HTTP API: intents

Proč byla vazba odmítnuta, jako slovo, které čtenář greppuje. Prvních sedm jsou vlastní příčiny preflightu, převzaté beze změny; zbytek je to, co dokáže najít jen vazba.

use majordomus_cli::intent::IntentPreflightCause;
use majordomus_cli::intent_binding::BindingCause;
// a preflight cause keeps its word
assert_eq!(
    serde_json::to_string(&BindingCause::from(IntentPreflightCause::IntentNotCritiqued)).unwrap(),
    serde_json::to_string(&IntentPreflightCause::IntentNotCritiqued).unwrap(),
);

Výjimka, kterou vazba přijala: třída, jak ji politika deklaruje, a důvod, který worker uvedl.

use majordomus_cli::intent_binding::BindingExemption;
let e = BindingExemption {
    class: "emergency".into(),
    description: "Restoring a broken trunk".into(),
    because: "master is red on case 500".into(),
};
assert_eq!(e.class, "emergency");

Jeden důvod, proč byla vazba zamítnuta.

use majordomus_cli::intent_binding::{BindingCause, BindingRefusal};
let r = BindingRefusal::new(None, BindingCause::NothingNamed, "name the work".into());
assert!(r.issue.is_none());
assert_eq!(r.cause, BindingCause::NothingNamed);

Co worker jmenoval, když se ptal, čemu jeho práce slouží. Každé pole je volitelné a kombinace se posuzují, nepředpokládají: samotný úkol, samotný záměr, úkol vedle záměru, kterému má sloužit, samotné cesty nebo výjimka s důvodem.

use majordomus_cli::intent_binding::BindingRequest;
let by_issue = BindingRequest { issue: Some("I0001".into()), ..Default::default() };
assert!(!by_issue.names_nothing());
// blanks are what a query string or a shell variable leaves behind, and name nothing
let blank = BindingRequest { issue: Some("  ".into()), ..Default::default() }.trimmed();
assert!(blank.names_nothing());

Kde stojí kus práce vůči záměrům: jediné slovo, podle kterého se rozhoduje o startu.

use majordomus_cli::intent_binding::BindingStanding;
assert_eq!(serde_json::to_string(&BindingStanding::Bound).unwrap(), "\"bound\"");
assert!(BindingStanding::Refused.refuses());
assert!(!BindingStanding::Maintenance.refuses());

Stav jednoho kritéria, jak ho mezera pozorovala. Čtyři hodnoty, protože „neurčeno“ musí jít zapsat: vynechané kritérium se odmítne a Unknown není nikdy úspěch.

use majordomus_cli::intent_review::ConditionState;
assert_eq!(serde_json::to_string(&ConditionState::Conflicting).unwrap(), "\"conflicting\"");
assert_ne!(ConditionState::Unknown, ConditionState::Satisfied);

Třída zjištění kritiky: otázka, kterou položil adversariální průchod. Uzavřená, aby bylo možné zjištění review počítat podle otázky, místo aby se četla jako próza.

use majordomus_cli::intent_review::CritiqueClass;
assert_eq!(
    serde_json::to_string(&CritiqueClass::DeliveryVerification).unwrap(),
    "\"delivery_verification\""
);

Jeden nález kritiky: co revize našla, čeho se týká, zda blokuje provedení a jak byl vyřešen. class a resolution jsou None, když záznam píše hodnotu, kterou tento modul nezná, a pole _text si ponechávají, co bylo napsáno.

use majordomus_cli::intent_review::{CritiqueFinding, CritiqueRecord, ResolutionState};
let c = CritiqueRecord::from_metadata("c.yaml", &serde_json::json!({
    "intent": "x",
    "findings": [{"id": "f1", "class": "regression_risk", "subject": "x#a",
                  "blocking": true, "resolution": {"state": "planned", "issue": "I1"}}],
}));
let finding: &CritiqueFinding = &c.findings[0];
assert!(finding.blocking);
assert_eq!(finding.resolution, Some(ResolutionState::Planned));
assert_eq!(finding.issue, "I1");

Stav jednoho kritéria proti pozorováním, jak ho píše záznam. state je None, když soubor jmenuje stav, který tento modul nezná, a state_text uchová, co bylo napsáno, aby ho zjištění mohlo citovat.

use majordomus_cli::intent_review::{ConditionState, GapCondition};
let c = GapCondition {
    criterion: "criteria-are-covered".into(),
    state: Some(ConditionState::Missing),
    state_text: "missing".into(),
    because: "nothing relates a criterion to an issue".into(),
    observations: vec!["no-serves-field".into()],
};
assert_eq!(c.state, Some(ConditionState::Missing));
assert!(!c.observations.is_empty());

K čemu je kus práce vázán: jeho postavení, co bylo jmenováno, úkoly a záměry, na které se rozřešil, s tím, co každý záměr po pracovníkovi chce, dva piny a každé odmítnutí.

use majordomus_cli::intent::Intents;
use majordomus_cli::intent_binding::{
    bind, BindingCause, BindingRequest, BindingStanding, IntentBinding,
};
use majordomus_cli::plan::Plan;
use majordomus_cli::policy::IntentPolicy;
#### let plan: Plan = serde_json::from_value(serde_json::json!({
####     "project": {"name": "p", "repository": "o/p", "default_branch": "master",
####                 "active_milestone": ""},
####     "statuses": {"issue": [], "milestone": []},
####     "milestones": [], "issues": [], "waves": [], "edges": [],
####     "milestone_edges": [], "findings": []})).unwrap();
let intents = Intents { intents: vec![], findings: vec![] };
let nothing: IntentBinding =
    bind(&intents, &plan, &[], &[], &IntentPolicy::default(), BindingRequest::default());
assert_eq!(nothing.standing, BindingStanding::Refused);
assert_eq!(nothing.refusals[0].cause, BindingCause::NothingNamed);
// nothing was reached, so there is nothing to pin
assert!(nothing.plan_revision.is_empty() && nothing.evidence_standing.is_empty());

Celé odvozené pokrytí: každé kritérium každého živého záměru, každý úkol s důvodem, proč existuje, a každý nález, který z obojího vzešel. Nic z toho se neukládá; odvozuje se při každém čtení ze záměrů a plánu.

use majordomus_cli::intent_plan::{IntentCoverage, IssueOrigin, IssuePurpose};
let coverage = IntentCoverage {
    criteria: vec![],
    issues: vec![IssuePurpose {
        issue: "I0007".into(),
        milestone: "ops".into(),
        origin: IssueOrigin::Maintenance,
        serves: vec![],
        intents: vec![],
    }],
    findings: vec![],
};
assert_eq!(coverage.failures(), 0);
assert_eq!(coverage.purpose("I0007").unwrap().origin, IssueOrigin::Maintenance);

Každý záměr s jeho odvozenou fází a verdiktem a kolik jich je v každé: čím odpovídají majordomus intent list, GET /api/v1/intents i nástroj majordomus_intents, z jednoho odvození.

use majordomus_cli::capability::builtin::intents::IntentList;
let empty = IntentList {
    count: 0,
    stages: std::collections::BTreeMap::new(),
    verdicts: std::collections::BTreeMap::new(),
    intents: vec![],
};
// a repository that declares no intent answers the route, with nothing in it
assert_eq!(empty.count, 0);

Kterému záměru kus práce slouží, zda jde o údržbu, nebo proč nesmí pokračovat: úkoly, na které se převedla, s verdiktem u každého, každý dosažený záměr s odkazem, co ty záměry od pracovníka vyžadují a každé odmítnutí s příčinou.

use majordomus_cli::intent::{
    IntentPreflight, IntentPreflightCause, IntentPreflightRefusal, IntentPreflightVerdict,
};
let refused = IntentPreflight {
    verdict: IntentPreflightVerdict::Refused,
    issues: vec![],
    matches: vec![],
    intents: vec![],
    governance: vec![],
    refusals: vec![IntentPreflightRefusal::new(
        None,
        IntentPreflightCause::NoIssueCoversPaths,
        "no open issue's scope covers README.md".into(),
    )],
    refusal: Some("no open issue's scope covers README.md".into()),
};
assert_eq!(refused.verdict, IntentPreflightVerdict::Refused);
assert_eq!(refused.refusals[0].cause, IntentPreflightCause::NoIssueCoversPaths);

Proč preflight odmítl, jako slovo, které čtenář vyhledá grepem.

use majordomus_cli::intent::IntentPreflightCause;
assert_eq!(
    serde_json::to_string(&IntentPreflightCause::OpenBlockingFinding).unwrap(),
    "\"open_blocking_finding\""
);
assert_ne!(
    IntentPreflightCause::IntentNotCritiqued,
    IntentPreflightCause::IssueServesNothing
);

Kritika záměru tak, jak ji čte preflight: kde je, kdy a kým byl plán posouzen a blokující zjištění, která jsou stále otevřená.

use majordomus_cli::intent::IntentPreflightCritique;
let c = IntentPreflightCritique {
    source: ".ai/repo/project/critiques/x.yaml".into(),
    reviewed_at: "c3f20da".into(),
    reviewed_by: "another session".into(),
    open_blocking: vec![],
};
assert!(c.open_blocking.is_empty());

Zaznamenaná mezera záměru tak, jak ji čte preflight, omezená na kritéria, kterým práce slouží: co o každém bylo pozorováno, na kterém commitu, a rizika.

use majordomus_cli::intent::IntentPreflightGap;
let g = IntentPreflightGap {
    source: ".ai/repo/project/gaps/x.yaml".into(),
    observed_at: "c3f20da".into(),
    conditions: vec![],
    risks: vec!["the schema may refuse old records".into()],
};
assert_eq!(g.risks.len(), 1);

Jeden intent, jemuž je práce podřízena, s tím, co worker potřebuje před dotykem: tvrzení, kritéria, kterým práce slouží, se živým stavem jejich důkazů, invarianty a non-goals, governance, kritika a mezera. Nesou se jen intenty, kterých se práce dotýká, nikdy každý intent.

use majordomus_cli::intent::{IntentPreflightIntent, IntentStage};
let i = IntentPreflightIntent {
    id: "x".into(),
    title: "X".into(),
    stage: IntentStage::Planned,
    statement: "It becomes true.".into(),
    criteria: vec![],
    invariants: vec![],
    non_goals: vec![],
    governance: vec![],
    critique: None,
    gap: None,
};
// no critique recorded is carried as an absence, never as an empty review
assert!(i.critique.is_none());

Jeden úkol, na který se práce vyřešila, a co o něm preflight uzavřel.

use majordomus_cli::intent::{IntentPreflightIssue, IntentPreflightVerdict};
let i = IntentPreflightIssue {
    issue: "I0007".into(),
    milestone: "ops".into(),
    verdict: IntentPreflightVerdict::Maintenance,
    serves: vec![],
    intents: vec![],
};
// a milestone no intent names carries maintenance, which is not a refusal
assert_eq!(i.verdict, IntentPreflightVerdict::Maintenance);

Jeden záměr, kterému práce slouží, a odkaz, který to říká: úkol ke kritériím, která deklaruje v serves, záměr každého kritéria jmenující milník úkolu.

use majordomus_cli::intent::{IntentPreflightMatch, IntentStage};
let m = IntentPreflightMatch {
    intent: "intent-lifecycle".into(),
    title: "Work is traceable to the intent it serves".into(),
    stage: IntentStage::Executing,
    milestone: "intent-lifecycle".into(),
    issue: "I1900".into(),
    criteria: vec!["stage-is-derived".into()],
};
assert_eq!(m.issue, "I1900");

Jeden důvod, proč předběžná kontrola odmítla: který úkol, příčina a jedna věta o tom, co je špatně.

use majordomus_cli::intent::{IntentPreflightCause, IntentPreflightRefusal};
let r = IntentPreflightRefusal::new(
    Some("I1900"),
    IntentPreflightCause::IntentNotCritiqued,
    "intent x has no critique".into(),
);
assert_eq!(r.cause, IntentPreflightCause::IntentNotCritiqued);
assert_eq!(r.issue.as_deref(), Some("I1900"));

K čemu preflight dospěl, o jednom úkolu nebo o celém kusu práce.

use majordomus_cli::intent::IntentPreflightVerdict;
// the words every surface answers with
assert_eq!(
    serde_json::to_string(&IntentPreflightVerdict::Maintenance).unwrap(),
    "\"maintenance\""
);
assert_ne!(IntentPreflightVerdict::Serves, IntentPreflightVerdict::Refused);

Vstup intents.propose: co se musí stát pravdou a volitelně jeho název a id.

Žádný milník, kritérium ani invariant: návrh říká, co se chce, a jeho plánování je samostatný akt (ADR 0144). Žádné časové razítko také ne: záznam se datuje, když se zapisuje.

use majordomus_cli::capability::builtin::intents::IntentProposeInput;
let i: IntentProposeInput =
    serde_json::from_str(r#"{"statement": "The UI answers within 100 ms warm"}"#).unwrap();
assert_eq!(i.title, None);
// a field the input does not have is refused, never ignored
assert!(serde_json::from_str::<IntentProposeInput>(r#"{"statement": "s", "stage": "x"}"#).is_err());

Co model záměrů odmítá: zda je platný, kolik záměrů bylo prozkoumáno a každé zjištění s jeho úrovní. Varování se hlásí a model neznehodnocují.

use majordomus_cli::capability::builtin::intents::IntentValidation;
let v = IntentValidation {
    valid: true,
    intents: 2,
    failures: 0,
    warnings: 20,
    findings: vec![],
};
// twenty warnings and no failure is a valid model
assert!(v.valid);

Proč úkol existuje: protože slouží kritériu, protože je to údržba pod milníkem, který nepojmenovává žádný záměr, nebo protože to nikdo neřekl — což je selhání pod záměrem.

use majordomus_cli::intent_plan::IssueOrigin;
assert_eq!(serde_json::to_string(&IssueOrigin::Maintenance).unwrap(), "\"maintenance\"");
// work under no intent is legitimate and says so; it is never given an invented intent
assert_ne!(IssueOrigin::Maintenance, IssueOrigin::Unexplained);

Odpověď na „proč tento úkol existuje?“: kritéria, kterým deklaruje, že slouží, záměry, jejichž milníky ho obsahují, a který ze tří původů z toho vychází.

use majordomus_cli::intent_plan::{IssueOrigin, IssuePurpose};
let purpose = IssuePurpose {
    issue: "I1901".into(),
    milestone: "intent-planning".into(),
    origin: IssueOrigin::Intent,
    serves: vec!["intent-planning#criteria-are-covered".into()],
    intents: vec!["intent-planning".into()],
};
assert_eq!(purpose.origin, IssueOrigin::Intent);
assert_eq!(purpose.serves.len(), 1);

Co zapsal propose: identita, soubor a záznam tak, jak se nyní čte.

use majordomus_cli::intent::Proposed;
let p: Proposed = serde_json::from_str(
    r#"{"id": "fast-ui", "path": ".ai/repo/project/intents/fast-ui.yaml",
        "title": "Fast UI", "statement": "The UI answers at once"}"#,
)
.unwrap();
// the path is the identity under the intents directory: one answer to where it lives
assert_eq!(p.path, format!(".ai/repo/project/intents/{}.yaml", p.id));

Jak byl vyřešen nález kritiky: zatím ne, plánováním práce, která záměru slouží, nebo jeho odmítnutím s důvodem. Blokující nález ponechaný Open provedení odmítne.

use majordomus_cli::intent_review::ResolutionState;
assert_eq!(serde_json::to_string(&ResolutionState::Planned).unwrap(), "\"planned\"");
assert_ne!(ResolutionState::Open, ResolutionState::Rejected);