Struct CompileInput 

pub struct CompileInput {
    pub issue: Option<String>,
    pub milestone: Option<String>,
    pub intent: Option<String>,
    pub paths: Vec<String>,
    pub uris: Vec<String>,
    pub budget_tokens: Option<u64>,
    pub max_depth: Option<usize>,
    pub floor: Option<f64>,
    pub all_blocking_rules: Option<bool>,
}

What to compile a context about.

Every field is optional. A request that names nothing still gets an answer: the governance the layer applies to everything, and what the last session left — which is the smallest true context there is.

The seeds are additive, not alternative: issue, milestone, uris, paths and intent all contribute, and naming several is the normal case rather than a conflict. intent is the only one the compiler infers from, which is why every entry it produces carries Selector::IntentMatch and a confidence below one.

deny_unknown_fields is deliberate. This is the input of a served capability, so a misspelled field is a request that does not mean what its author thought; refusing it is the difference between a typo and a silently smaller answer.

use majordomus_cli::devcontext::CompileInput;
use serde_json::json;

// the smallest legitimate request, which is not the same as no request
let nothing: CompileInput = serde_json::from_value(json!({})).unwrap();
assert_eq!(nothing, CompileInput::default());
assert!(nothing.issue.is_none() && nothing.paths.is_empty());

// the seeds combine rather than compete
let both: CompileInput = serde_json::from_value(json!({
    "issue": "I0301",
    "paths": ["apps/majordomus-cli/src"],
    "intent": "explain the budget",
    "budget_tokens": 4_000,
})).unwrap();
assert_eq!(both.issue.as_deref(), Some("I0301"));
assert_eq!(both.paths, ["apps/majordomus-cli/src"]);
assert_eq!(both.budget_tokens, Some(4_000));

// and a misspelled field is refused rather than quietly ignored
let typo = serde_json::from_value::<CompileInput>(json!({"max_dept": 2}));
assert!(typo.is_err(), "a typo must not become a smaller answer");

Fields

issue: Option<String>

An issue id (I0301) or its canonical identifier. Its milestone, its dependencies, its declared scope and the decisions over that scope follow from it.

milestone: Option<String>

A milestone id or slug, or its canonical identifier.

intent: Option<String>

What the session is trying to do, in words. The only input the compiler infers from, and every entry it produces says so and carries a confidence below one.

paths: Vec<String>

Repository-relative paths the work touches, added to whatever the seeds declare.

uris: Vec<String>

Canonical identifiers to seed with directly, for a request about something that is neither an issue nor a milestone.

budget_tokens: Option<u64>

The ceiling in estimated tokens; DEFAULT_BUDGET_TOKENS when absent.

max_depth: Option<usize>

How far from a seed the walk goes; DEFAULT_MAX_DEPTH when absent.

floor: Option<f64>

Relevance below which an entry is reported rather than given; DEFAULT_FLOOR when absent.

all_blocking_rules: Option<bool>

Every blocking rule of the layer, not only the ones the work reaches. Honest and usually over budget: the answer then says over_budget rather than dropping what it may not drop.

Trait Implementations

impl BenchmarkCases for CompileInput

fn benchmark_cases(ctx: &CaseContext<'_>) -> Vec<NamedCase<Self>>

The cases, in a stable order. An empty list means “nothing to benchmark in this repository”, which the coverage check reports as missing.

fn benchmark_cases_json(ctx: &CaseContext<'_>) -> Vec<NamedCase<Value>>

The cases as JSON, the shape every runner serialises from.

impl Clone for CompileInput

fn clone(&self) -> CompileInput

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompileInput

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

Formats the value using the given formatter.

impl Default for CompileInput

fn default() -> CompileInput

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CompileInput

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for CompileInput

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 CompileInput

fn eq(&self, other: &CompileInput) -> 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 CompileInput

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 CompileInput