Struct CompiledContext 

pub struct CompiledContext {
    pub schema: u64,
    pub fingerprint: String,
    pub git: GitContext,
    pub seeds: Vec<Seed>,
    pub selected: Vec<ContextEntry>,
    pub excluded: Vec<Excluded>,
    pub deduplicated: Vec<Deduplicated>,
    pub conflicts: Vec<Conflict>,
    pub budget: Budget,
    pub diagnostics: Vec<Diagnostic>,
}

A compiled development context: what to give a session, what was left out, what collapsed into what, and the budget it was all decided under.

This is the canonical form. Rendering it as a prompt is a downstream projection of this value and is not performed here — the structure is what lets a caller re-budget, re-order or explain the selection without recompiling it.

Two invariants hold over every answer, and they are what make it safe to cache and to compare. fingerprint is over the index this was compiled from, so the same request against the same fingerprint is the same answer and a different fingerprint is a different tree — a caller can tell two trees apart without asking. And budget.used_tokens is exactly the sum of selected’s costs, so the arithmetic in the budget describes the list beside it rather than a walk that has since been filtered.

use majordomus_cli::devcontext::{compile, CompileInput, CompiledContext};
use majordomus_cli::devcontext::{Tier, DEFAULT_BUDGET_TOKENS};
use majordomus_cli::synthetic::SyntheticRepository;

let repo = SyntheticRepository::small().unwrap();
let ctx = repo.context().unwrap();

let c: CompiledContext = compile(&ctx, CompileInput::default()).unwrap();

// the answer says which tree it is true of, and nothing else has to be asked
assert_eq!(c.schema, 1);
assert!(!c.fingerprint.is_empty(), "an answer that names no tree is not one");

// the budget describes the list beside it
let spent: u64 = c.selected.iter().map(|e| e.cost_tokens).sum();
assert_eq!(c.budget.used_tokens, spent);
assert_eq!(c.budget.limit_tokens, DEFAULT_BUDGET_TOKENS);

// every tier is reported, so an empty tier is visibly empty rather than missing
assert_eq!(c.budget.tiers.len(), Tier::ORDER.len());

// a request that named nothing has no seeds and is still an answer
assert!(c.seeds.is_empty());

// and recompiling the same request over the same tree gives the same answer
let again: CompiledContext = compile(&ctx, CompileInput::default()).unwrap();
assert_eq!(again.fingerprint, c.fingerprint);
assert_eq!(again.selected.len(), c.selected.len());

Fields

schema: u64

The format of this answer.

fingerprint: String

The index this was compiled from, over every object’s path and content. Two answers with the same fingerprint and the same request are the same answer; a different fingerprint is a different tree.

git: GitContext

The head the answer is true of.

seeds: Vec<Seed>

What was asked for.

selected: Vec<ContextEntry>

What to give the session, in the order the budget spent: tier, then relevance, then canonical identifier.

excluded: Vec<Excluded>

What was reached and not given, with the reason for each.

deduplicated: Vec<Deduplicated>

What collapsed into what.

conflicts: Vec<Conflict>

What does not agree with what.

budget: Budget

The budget and its per-tier spend.

diagnostics: Vec<Diagnostic>

What the compiler could not read: a knowledge source the layer names and does not hold, a session record that no longer describes this checkout. Never an error: an absent source is an answer.

Trait Implementations

impl Clone for CompiledContext

fn clone(&self) -> CompiledContext

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompiledContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CompiledContext

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for CompiledContext

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for CompiledContext

fn eq(&self, other: &CompiledContext) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CompiledContext

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CompiledContext