@lamentis/naome 1.1.2 → 1.2.0

package/crates/naome-core/src/intent/classifier.rs

@@ -0,0 +1,171 @@
+use std::collections::HashSet;
+
+use super::envelope::parse_routing_envelope;
+use super::model::{CanonicalIntent, IntentCandidate, IntentKind, PromptSegment, SegmentKind};
+use super::patterns;
+use super::risk::detect_risk;
+use super::segment::{actionable_text, segment_prompt};
+
+const DIRECT_WORKFLOW_CONFIDENCE: u8 = 90;
+const NEW_TASK_CONFIDENCE: u8 = 80;
+const REVISION_CONFIDENCE: u8 = 78;
+const GENERIC_WORK_CONFIDENCE: u8 = 50;
+
+pub(crate) fn canonical_intent(prompt: &str) -> CanonicalIntent {
+    let segments = segment_prompt(prompt);
+    let actionable = actionable_text(&segments);
+    let mut candidates = classify_candidates(&segments);
+    let mut risk = detect_risk(&segments);
+
+    if let Some(envelope) = parse_routing_envelope(prompt) {
+        candidates.clear();
+        candidates.extend(envelope.candidates);
+        risk.risk_codes.extend(envelope.risk.risk_codes);
+        risk.risk_codes.sort();
+        risk.risk_codes.dedup();
+        risk.has_risky_terms = !risk.risk_codes.is_empty();
+    }
+
+    candidates = dedupe_candidates(candidates);
+    let references_current_task = has_candidate_kind(&candidates, IntentKind::TaskRevision);
+    if risk.has_risky_terms {
+        candidates.push(IntentCandidate {
+            kind: IntentKind::Unsafe,
+            confidence: 100,
+            evidence: risk.risk_codes.join(","),
+        });
+    }
+
+    CanonicalIntent {
+        is_empty: actionable.trim().is_empty(),
+        references_current_task,
+        has_workflow_conflict: has_workflow_conflict(&candidates),
+        candidates,
+        risk,
+    }
+}
+
+pub(crate) fn winning_intent(canonical: &CanonicalIntent) -> IntentKind {
+    if canonical.is_empty || canonical.has_workflow_conflict {
+        return IntentKind::Ambiguous;
+    }
+    for kind in [
+        IntentKind::Unsafe,
+        IntentKind::StatusQuestion,
+        IntentKind::RepairRequest,
+        IntentKind::CancelRequest,
+        IntentKind::ReviewRequest,
+        IntentKind::NoCommitRequest,
+        IntentKind::CommitRequest,
+        IntentKind::NewTask,
+        IntentKind::TaskRevision,
+        IntentKind::TaskCompletion,
+    ] {
+        if has_candidate(canonical, kind) {
+            return kind;
+        }
+    }
+    IntentKind::Ambiguous
+}
+
+pub(crate) fn has_candidate(canonical: &CanonicalIntent, kind: IntentKind) -> bool {
+    canonical
+        .candidates
+        .iter()
+        .any(|candidate| candidate.kind == kind)
+}
+
+fn classify_candidates(segments: &[PromptSegment]) -> Vec<IntentCandidate> {
+    let mut candidates = Vec::new();
+    for segment in action_segments(segments) {
+        classify_direct_workflow(&mut candidates, segment);
+        classify_task_work(&mut candidates, &segment.text);
+    }
+
+    if candidates.is_empty() {
+        let actionable = actionable_text(segments);
+        if patterns::is_generic_work_request(&actionable) {
+            push(
+                &mut candidates,
+                IntentKind::NewTask,
+                GENERIC_WORK_CONFIDENCE,
+                "generic_work_request",
+            );
+        }
+    }
+
+    dedupe_candidates(candidates)
+}
+
+fn classify_direct_workflow(candidates: &mut Vec<IntentCandidate>, segment: &PromptSegment) {
+    let intents = if segment.kind == SegmentKind::CommandLike {
+        patterns::command_workflow_intents(&segment.text)
+    } else {
+        patterns::structured_workflow_intents(&segment.text)
+    };
+    for intent in intents {
+        push(
+            candidates,
+            intent,
+            DIRECT_WORKFLOW_CONFIDENCE,
+            &patterns::normalized(&segment.text),
+        );
+    }
+}
+
+fn classify_task_work(candidates: &mut Vec<IntentCandidate>, text: &str) {
+    if let Some(intent) = patterns::explicit_task_intent(text) {
+        let confidence = if intent == IntentKind::NewTask {
+            NEW_TASK_CONFIDENCE
+        } else {
+            REVISION_CONFIDENCE
+        };
+        push(candidates, intent, confidence, &patterns::normalized(text));
+    }
+}
+
+fn has_candidate_kind(candidates: &[IntentCandidate], kind: IntentKind) -> bool {
+    candidates.iter().any(|candidate| candidate.kind == kind)
+}
+
+fn has_workflow_conflict(candidates: &[IntentCandidate]) -> bool {
+    let workflow = candidates
+        .iter()
+        .filter(|candidate| candidate.confidence >= DIRECT_WORKFLOW_CONFIDENCE)
+        .filter(|candidate| {
+            !matches!(
+                candidate.kind,
+                IntentKind::NewTask | IntentKind::TaskRevision | IntentKind::Unsafe
+            )
+        })
+        .map(|candidate| candidate.kind)
+        .collect::<HashSet<_>>();
+    workflow.len() > 1
+}
+
+fn action_segments(segments: &[PromptSegment]) -> impl Iterator<Item = &PromptSegment> {
+    segments.iter().filter(|segment| {
+        matches!(
+            segment.kind,
+            super::model::SegmentKind::Prose
+                | super::model::SegmentKind::ListItem
+                | super::model::SegmentKind::CommandLike
+        )
+    })
+}
+
+fn push(candidates: &mut Vec<IntentCandidate>, kind: IntentKind, confidence: u8, text: &str) {
+    candidates.push(IntentCandidate {
+        kind,
+        confidence,
+        evidence: text.to_string(),
+    });
+}
+
+fn dedupe_candidates(candidates: Vec<IntentCandidate>) -> Vec<IntentCandidate> {
+    let mut seen = HashSet::new();
+    candidates
+        .into_iter()
+        .filter(|candidate| seen.insert((candidate.kind, candidate.evidence.clone())))
+        .collect()
+}

package/crates/naome-core/src/intent/envelope.rs

@@ -0,0 +1,108 @@
+use serde::Deserialize;
+
+use super::model::{IntentCandidate, IntentKind, RiskContext};
+
+const ENVELOPE_FENCE: &str = "```naome-intent-v2";
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RoutingEnvelope {
+    pub candidates: Vec<IntentCandidate>,
+    pub risk: RiskContext,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct EnvelopeInput {
+    schema: Option<String>,
+    workflow_action: Option<String>,
+    task_intent: Option<String>,
+    risk: Option<String>,
+    risk_codes: Option<Vec<String>>,
+}
+
+pub(crate) fn parse_routing_envelope(prompt: &str) -> Option<RoutingEnvelope> {
+    let json = envelope_json(prompt)?;
+    let input = serde_json::from_str::<EnvelopeInput>(json).ok()?;
+    if !matches!(input.schema.as_deref(), Some("naome.intent.v2")) {
+        return None;
+    }
+
+    let mut candidates = Vec::new();
+    if let Some(kind) = workflow_action(input.workflow_action.as_deref()) {
+        candidates.push(candidate(kind, "envelope.workflowAction"));
+    }
+    if let Some(kind) = task_intent(input.task_intent.as_deref()) {
+        candidates.push(candidate(kind, "envelope.taskIntent"));
+    }
+
+    let risk_codes = envelope_risk_codes(input.risk.as_deref(), input.risk_codes);
+    let risk = RiskContext {
+        has_risky_terms: !risk_codes.is_empty(),
+        risk_codes,
+    };
+
+    Some(RoutingEnvelope { candidates, risk })
+}
+
+fn envelope_json(prompt: &str) -> Option<&str> {
+    let start = prompt.find(ENVELOPE_FENCE)?;
+    let after_open = &prompt[start + ENVELOPE_FENCE.len()..];
+    let after_line = after_open
+        .strip_prefix('\n')
+        .or_else(|| after_open.strip_prefix("\r\n"))?;
+    let end = after_line.find("\n```")?;
+    Some(after_line[..end].trim())
+}
+
+fn workflow_action(value: Option<&str>) -> Option<IntentKind> {
+    match normalized_value(value)?.as_str() {
+        "none" | "unknown" => None,
+        "commit_request" => Some(IntentKind::CommitRequest),
+        "review_request" => Some(IntentKind::ReviewRequest),
+        "repair_request" => Some(IntentKind::RepairRequest),
+        "cancel_request" => Some(IntentKind::CancelRequest),
+        "task_completion" => Some(IntentKind::TaskCompletion),
+        "status_question" => Some(IntentKind::StatusQuestion),
+        "no_commit_request" => Some(IntentKind::NoCommitRequest),
+        _ => None,
+    }
+}
+
+fn task_intent(value: Option<&str>) -> Option<IntentKind> {
+    match normalized_value(value)?.as_str() {
+        "none" | "unknown" => None,
+        "new_task" => Some(IntentKind::NewTask),
+        "task_revision" => Some(IntentKind::TaskRevision),
+        _ => None,
+    }
+}
+
+fn envelope_risk_codes(risk: Option<&str>, risk_codes: Option<Vec<String>>) -> Vec<String> {
+    let mut codes = risk_codes.unwrap_or_default();
+    match normalized_value(risk).as_deref() {
+        Some("none") | Some("unknown") | None => {}
+        Some("unsafe") | Some("unsafe_context") => codes.push("envelope_risk:unsafe".to_string()),
+        Some("credential_context") => {
+            codes.push("envelope_risk:credential_context".to_string());
+        }
+        Some("bypass_context") => codes.push("envelope_risk:bypass_context".to_string()),
+        Some(other) => codes.push(format!("envelope_risk:{other}")),
+    }
+    codes.sort();
+    codes.dedup();
+    codes
+}
+
+fn normalized_value(value: Option<&str>) -> Option<String> {
+    value
+        .map(|value| value.trim().to_ascii_lowercase())
+        .filter(|value| !value.is_empty())
+}
+
+fn candidate(kind: IntentKind, evidence: &str) -> IntentCandidate {
+    IntentCandidate {
+        kind,
+        confidence: 100,
+        evidence: evidence.to_string(),
+    }
+}

package/crates/naome-core/src/intent/legacy.rs

@@ -0,0 +1,138 @@
+use serde::Serialize;
+
+use crate::models::Decision;
+
+use super::classifier::{has_candidate, winning_intent};
+use super::legacy_response::response_policy;
+use super::model::{CanonicalIntent, IntentKind};
+use super::resolver::ResolvedIntent;
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct IntentDecision {
+    pub schema: String,
+    pub repo_state: String,
+    pub blocked: bool,
+    pub prompt_intent: String,
+    pub certainty: String,
+    pub policy_action: String,
+    pub allowed: bool,
+    pub summary: String,
+    pub next_action: String,
+    pub user_message: String,
+    pub human_options: Vec<String>,
+    pub internal_notes: Vec<String>,
+    pub reason_codes: Vec<String>,
+    pub risk_codes: Vec<String>,
+    pub changed_paths: Vec<String>,
+    pub required_context: Vec<String>,
+    pub evidence: PromptEvidence,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct PromptEvidence {
+    pub references_current_task: bool,
+    pub requests_new_goal: bool,
+    pub requests_correction: bool,
+    pub requests_status: bool,
+    pub requests_review: bool,
+    pub requests_repair: bool,
+    pub requests_commit: bool,
+    pub requests_no_commit: bool,
+    pub requests_cancel: bool,
+    pub requests_completion: bool,
+    pub has_risky_terms: bool,
+    pub is_empty: bool,
+}
+
+pub(crate) fn legacy_decision(
+    decision: Decision,
+    canonical: CanonicalIntent,
+    resolved: ResolvedIntent,
+) -> IntentDecision {
+    let evidence = PromptEvidence::from_canonical(&canonical);
+    let (user_message, human_options, mut internal_notes) = response_policy(
+        &decision,
+        resolved.prompt_intent.as_str(),
+        &resolved.policy_action,
+        &resolved.summary,
+    );
+    for code in &resolved.reason_codes {
+        if !internal_notes.contains(code) {
+            internal_notes.push(code.clone());
+        }
+    }
+
+    IntentDecision {
+        schema: "naome.intent.v1".to_string(),
+        repo_state: decision.state,
+        blocked: decision.blocked,
+        prompt_intent: resolved.prompt_intent.as_str().to_string(),
+        certainty: resolved.certainty,
+        policy_action: resolved.policy_action,
+        allowed: resolved.allowed,
+        summary: resolved.summary,
+        next_action: resolved.next_action,
+        user_message,
+        human_options,
+        internal_notes,
+        reason_codes: resolved.reason_codes,
+        risk_codes: resolved.risk_codes,
+        changed_paths: decision.changed_paths,
+        required_context: decision.required_context,
+        evidence,
+    }
+}
+
+pub fn format_intent(intent: &IntentDecision) -> String {
+    let mut lines = vec![
+        format!("NAOME intent: {}", intent.prompt_intent),
+        format!("Repo state: {}", intent.repo_state),
+        format!("Allowed: {}", intent.allowed),
+        format!("Policy action: {}", intent.policy_action),
+        format!("Summary: {}", intent.user_message),
+        format!("Next action: {}", intent.next_action),
+    ];
+
+    if !intent.human_options.is_empty() {
+        lines.push(format!(
+            "Human options: {}",
+            intent.human_options.join(", ")
+        ));
+    }
+    if !intent.reason_codes.is_empty() {
+        lines.push(format!("Reason codes: {}", intent.reason_codes.join(", ")));
+    }
+    if !intent.risk_codes.is_empty() {
+        lines.push(format!("Risk codes: {}", intent.risk_codes.join(", ")));
+    }
+    if !intent.changed_paths.is_empty() {
+        lines.push(format!(
+            "Changed paths: {}",
+            intent.changed_paths.join(", ")
+        ));
+    }
+
+    lines.push(String::new());
+    lines.join("\n")
+}
+
+impl PromptEvidence {
+    fn from_canonical(canonical: &CanonicalIntent) -> Self {
+        Self {
+            references_current_task: canonical.references_current_task,
+            requests_new_goal: has_candidate(canonical, IntentKind::NewTask),
+            requests_correction: has_candidate(canonical, IntentKind::TaskRevision),
+            requests_status: winning_intent(canonical) == IntentKind::StatusQuestion,
+            requests_review: has_candidate(canonical, IntentKind::ReviewRequest),
+            requests_repair: has_candidate(canonical, IntentKind::RepairRequest),
+            requests_commit: has_candidate(canonical, IntentKind::CommitRequest),
+            requests_no_commit: has_candidate(canonical, IntentKind::NoCommitRequest),
+            requests_cancel: has_candidate(canonical, IntentKind::CancelRequest),
+            requests_completion: has_candidate(canonical, IntentKind::TaskCompletion),
+            has_risky_terms: canonical.risk.has_risky_terms,
+            is_empty: canonical.is_empty,
+        }
+    }
+}

package/crates/naome-core/src/intent/legacy_response.rs

@@ -0,0 +1,76 @@
+use crate::models::Decision;
+
+pub(crate) fn response_policy(
+    decision: &Decision,
+    prompt_intent: &str,
+    policy_action: &str,
+    summary: &str,
+) -> (String, Vec<String>, Vec<String>) {
+    let internal_notes = response_notes(decision, prompt_intent, policy_action);
+    let human_options = response_human_options(decision, policy_action);
+    let user_message = match policy_action {
+        "auto_commit_completed_task_then_create_new_task" => "The completed task is valid. NAOME can baseline it automatically before starting the next separate task.",
+        "auto_commit_completed_task_then_create_isolated_task_worktree" => "The completed task is valid. NAOME can baseline only that task, preserve unrelated user edits, and create an isolated worktree for the next task.",
+        "auto_commit_harness_refresh_then_create_new_task" => "NAOME can baseline deterministic harness refresh changes first, then create the next task in the same worktree.",
+        "auto_commit_harness_refresh_then_create_isolated_task_worktree" => "NAOME can baseline deterministic harness refresh changes first, then create an isolated task worktree and leave user edits untouched.",
+        "auto_commit_harness_refresh_baseline" => "NAOME can baseline deterministic harness refresh changes and leave unrelated user edits untouched.",
+        "create_isolated_task_worktree" => "NAOME can create an isolated task worktree and leave existing user edits untouched.",
+        "commit_user_diff_with_quality_gate" => "NAOME can commit the current user-owned diff only after the configured quality gate passes. It will stage only the changed paths present before the gate runs.",
+        "auto_commit_harness_refresh_then_completed_task_then_create_new_task" => "The completed task is valid after separating deterministic harness refresh changes. NAOME can baseline the refresh first, then baseline the task before starting the next separate task.",
+        "auto_commit_upgrade_baseline_then_create_new_task" => "The setup or repair diff is ready. NAOME can baseline it automatically before starting the next task.",
+        "create_new_task" | "create_new_task_without_auto_baseline" => "NAOME is ready to create the next task.",
+        "answer_status_only" => summary,
+        "block_auto_baseline_due_to_no_commit" => "I will not baseline or commit because the prompt explicitly blocks committing. Review, revise, cancel, or clear the current diff first.",
+        "review_task_diff" | "review_diff_first" | "review_current_task_diff" => "The prompt asks for review, so NAOME will not mutate the repository automatically.",
+        "cancel_task_changes" | "cancel_upgrade_baseline" | "cancel_current_task" => "The prompt asks to cancel changes, so NAOME will not start new work until that decision is handled.",
+        "block_unsafe_intent" => "NAOME blocked this request because it contains unsafe or guardrail-bypass wording.",
+        "block_unowned_diff" => "NAOME will not commit or clear unowned changes automatically. Review the existing diff, or ask for a separate new task so NAOME can use an isolated worktree and leave those edits untouched.",
+        "repair_harness_only" => "NAOME harness health failed, so normal task work is blocked until repair or review.",
+        _ => summary,
+    };
+
+    (user_message.to_string(), human_options, internal_notes)
+}
+
+fn response_notes(decision: &Decision, prompt_intent: &str, policy_action: &str) -> Vec<String> {
+    let mut notes = vec![
+        format!("repo_state:{}", decision.state),
+        format!("prompt_intent:{prompt_intent}"),
+        format!("policy_action:{policy_action}"),
+    ];
+    if !decision.allowed_actions.is_empty() {
+        notes.push(format!(
+            "internal_allowed_actions:{}",
+            decision.allowed_actions.join(",")
+        ));
+    }
+    notes
+}
+
+fn response_human_options(decision: &Decision, policy_action: &str) -> Vec<String> {
+    match policy_action {
+        "review_task_diff" => decision.allowed_actions.clone(),
+        "cancel_task_changes" => vec![
+            "review_task_diff".to_string(),
+            "cancel_task_changes".to_string(),
+        ],
+        "block_auto_baseline_due_to_no_commit" => decision
+            .allowed_actions
+            .iter()
+            .filter(|action| !action.starts_with("commit_"))
+            .cloned()
+            .collect(),
+        "block_unsafe_intent" => vec!["narrow_request".to_string(), "review_status".to_string()],
+        "block_ambiguous_intent" => decision.allowed_actions.clone(),
+        "block_unowned_diff" => decision
+            .allowed_actions
+            .iter()
+            .filter(|action| action.as_str() == "review_unowned_diff")
+            .cloned()
+            .collect(),
+        "repair_harness_only" => decision.allowed_actions.clone(),
+        "review_diff_first" | "cancel_upgrade_baseline" => decision.allowed_actions.clone(),
+        "review_current_task_diff" | "cancel_current_task" => decision.allowed_actions.clone(),
+        _ => Vec::new(),
+    }
+}

package/crates/naome-core/src/intent/model.rs

@@ -0,0 +1,71 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum SegmentKind {
+    Prose,
+    InlineCode,
+    CodeFence,
+    QuotedText,
+    ListItem,
+    FilePath,
+    CommandLike,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct PromptSegment {
+    pub kind: SegmentKind,
+    pub text: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(crate) enum IntentKind {
+    Ambiguous,
+    NewTask,
+    TaskRevision,
+    StatusQuestion,
+    ReviewRequest,
+    RepairRequest,
+    CommitRequest,
+    NoCommitRequest,
+    CancelRequest,
+    TaskCompletion,
+    Unsafe,
+}
+
+impl IntentKind {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Ambiguous => "ambiguous",
+            Self::NewTask => "new_task",
+            Self::TaskRevision => "task_revision",
+            Self::StatusQuestion => "status_question",
+            Self::ReviewRequest => "review_request",
+            Self::RepairRequest => "repair_request",
+            Self::CommitRequest => "commit_request",
+            Self::NoCommitRequest => "no_commit_request",
+            Self::CancelRequest => "cancel_request",
+            Self::TaskCompletion => "task_completion",
+            Self::Unsafe => "unsafe",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct IntentCandidate {
+    pub kind: IntentKind,
+    pub confidence: u8,
+    pub evidence: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RiskContext {
+    pub has_risky_terms: bool,
+    pub risk_codes: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct CanonicalIntent {
+    pub is_empty: bool,
+    pub references_current_task: bool,
+    pub candidates: Vec<IntentCandidate>,
+    pub risk: RiskContext,
+    pub has_workflow_conflict: bool,
+}