@lamentis/naome 1.1.2 → 1.2.0

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

@@ -0,0 +1,55 @@
+pub(crate) type Policy = (&'static str, bool, &'static str, &'static str);
+
+pub(crate) fn policy(
+    action: &'static str,
+    allowed: bool,
+    summary: &'static str,
+    next_action: &'static str,
+) -> Policy {
+    (action, allowed, summary, next_action)
+}
+
+pub(crate) fn harness_refresh_policy() -> Policy {
+    policy(
+        "auto_commit_harness_refresh_baseline",
+        true,
+        "The repository has only deterministic harness refresh changes.",
+        "Baseline the harness refresh before feature work.",
+    )
+}
+
+pub(crate) fn ambiguous_empty() -> Policy {
+    policy(
+        "block_ambiguous_intent",
+        false,
+        "The prompt is empty, so NAOME cannot infer a safe task transition.",
+        "Ask for a concrete request before mutating the repository.",
+    )
+}
+
+pub(crate) fn ambiguous_conflict() -> Policy {
+    policy(
+        "block_ambiguous_intent",
+        false,
+        "The prompt contains conflicting workflow actions.",
+        "Ask which workflow action should run before mutating the repository.",
+    )
+}
+
+pub(crate) fn ambiguous_policy() -> Policy {
+    policy(
+        "block_ambiguous_intent",
+        false,
+        "The prompt does not clearly map to a safe NAOME task transition.",
+        "Ask for a narrower request or inspect status.",
+    )
+}
+
+pub(crate) fn unsafe_policy() -> Policy {
+    policy(
+        "block_unsafe_intent",
+        false,
+        "The prompt contains risky terms or asks to bypass guardrails.",
+        "Ask for a narrower request that does not expose secrets or bypass guardrails.",
+    )
+}

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

@@ -0,0 +1,40 @@
+use super::model::{PromptSegment, RiskContext, SegmentKind};
+use super::patterns::lexical_tokens;
+
+pub(crate) fn detect_risk(segments: &[PromptSegment]) -> RiskContext {
+    let mut codes = Vec::new();
+    for segment in segments
+        .iter()
+        .filter(|segment| segment.kind == SegmentKind::CommandLike)
+    {
+        let tokens = lexical_tokens(&segment.text);
+        if is_bypass_command(&tokens) {
+            codes.push("structured_risk:bypass_command".to_string());
+        }
+        if is_publish_command(&tokens) {
+            codes.push("structured_risk:publish_command".to_string());
+        }
+    }
+
+    codes.sort();
+    codes.dedup();
+    RiskContext {
+        has_risky_terms: !codes.is_empty(),
+        risk_codes: codes,
+    }
+}
+
+fn is_bypass_command(tokens: &[String]) -> bool {
+    tokens
+        .iter()
+        .any(|token| matches!(token.as_str(), "--no-verify" | "no-verify"))
+        || tokens
+            .windows(2)
+            .any(|window| window[0] == "git" && window[1] == "push")
+}
+
+fn is_publish_command(tokens: &[String]) -> bool {
+    tokens
+        .windows(2)
+        .any(|window| window[0] == "npm" && window[1] == "publish")
+}

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

@@ -0,0 +1,170 @@
+use super::model::{PromptSegment, SegmentKind};
+
+pub(crate) fn segment_prompt(prompt: &str) -> Vec<PromptSegment> {
+    let mut segments = Vec::new();
+    let mut rest = prompt;
+
+    loop {
+        let Some(start) = rest.find("```") else {
+            segment_plain_block(&mut segments, rest);
+            break;
+        };
+
+        segment_plain_block(&mut segments, &rest[..start]);
+        let after_open = &rest[start + 3..];
+        let Some(end) = after_open.find("```") else {
+            push_segment(&mut segments, SegmentKind::CodeFence, after_open);
+            break;
+        };
+
+        push_segment(
+            &mut segments,
+            SegmentKind::CodeFence,
+            code_fence_body(&after_open[..end]),
+        );
+        rest = &after_open[end + 3..];
+    }
+
+    segments
+}
+
+fn segment_plain_block(segments: &mut Vec<PromptSegment>, text: &str) {
+    for line in text.lines() {
+        let trimmed = line.trim();
+        if !trimmed.is_empty() {
+            segment_line(segments, line);
+        }
+    }
+}
+
+fn code_fence_body(text: &str) -> &str {
+    if let Some((language, body)) = text.split_once('\n') {
+        if language.trim().chars().all(|ch| ch.is_ascii_alphanumeric()) {
+            return body;
+        }
+    }
+    text
+}
+
+pub(crate) fn actionable_text(segments: &[PromptSegment]) -> String {
+    segments
+        .iter()
+        .filter(|segment| {
+            matches!(
+                segment.kind,
+                SegmentKind::Prose | SegmentKind::ListItem | SegmentKind::CommandLike
+            )
+        })
+        .map(|segment| segment.text.as_str())
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+fn segment_line(segments: &mut Vec<PromptSegment>, line: &str) {
+    let trimmed = line.trim();
+    if trimmed.is_empty() {
+        return;
+    }
+
+    let (kind, text) = if let Some(item) = list_item_text(trimmed) {
+        (SegmentKind::ListItem, item)
+    } else if is_command_like(trimmed) {
+        (SegmentKind::CommandLike, trimmed)
+    } else if is_path_like(trimmed) {
+        (SegmentKind::FilePath, trimmed)
+    } else {
+        (SegmentKind::Prose, trimmed)
+    };
+
+    segment_inline(segments, kind, text);
+}
+
+fn segment_inline(segments: &mut Vec<PromptSegment>, default_kind: SegmentKind, text: &str) {
+    let mut rest = text;
+    loop {
+        let Some(start) = rest.find('`') else {
+            segment_quotes(segments, default_kind, rest);
+            break;
+        };
+        segment_quotes(segments, default_kind, &rest[..start]);
+        let after_tick = &rest[start + 1..];
+        let Some(end) = after_tick.find('`') else {
+            segment_quotes(segments, default_kind, rest);
+            break;
+        };
+        push_segment(segments, SegmentKind::InlineCode, &after_tick[..end]);
+        rest = &after_tick[end + 1..];
+    }
+}
+
+fn segment_quotes(segments: &mut Vec<PromptSegment>, default_kind: SegmentKind, text: &str) {
+    let mut current = String::new();
+    let mut quoted = String::new();
+    let mut in_quote = false;
+    for ch in text.chars() {
+        if matches!(ch, '"' | '\'' | '“' | '”' | '‘' | '’') {
+            if in_quote {
+                push_segment(segments, SegmentKind::QuotedText, &quoted);
+                quoted.clear();
+            } else {
+                push_segment(segments, default_kind, &current);
+                current.clear();
+            }
+            in_quote = !in_quote;
+        } else if in_quote {
+            quoted.push(ch);
+        } else {
+            current.push(ch);
+        }
+    }
+
+    let kind = if in_quote {
+        default_kind
+    } else {
+        SegmentKind::QuotedText
+    };
+    push_segment(segments, kind, &quoted);
+    push_segment(segments, default_kind, &current);
+}
+
+fn push_segment(segments: &mut Vec<PromptSegment>, kind: SegmentKind, text: &str) {
+    let trimmed = text.trim();
+    if !trimmed.is_empty() {
+        segments.push(PromptSegment {
+            kind,
+            text: trimmed.to_string(),
+        });
+    }
+}
+
+fn list_item_text(trimmed: &str) -> Option<&str> {
+    if let Some(rest) = trimmed
+        .strip_prefix("- ")
+        .or_else(|| trimmed.strip_prefix("* "))
+    {
+        return Some(rest.trim());
+    }
+
+    let (number, rest) = trimmed.split_once(". ")?;
+    number
+        .chars()
+        .all(|ch| ch.is_ascii_digit())
+        .then_some(rest.trim())
+}
+
+fn is_command_like(trimmed: &str) -> bool {
+    let first = trimmed.split_whitespace().next().unwrap_or_default();
+    matches!(
+        first,
+        "git" | "npm" | "node" | "cargo" | "naome" | "rg" | "python" | "python3"
+    )
+}
+
+fn is_path_like(trimmed: &str) -> bool {
+    !trimmed.contains(' ')
+        && (trimmed.contains('/')
+            || trimmed.ends_with(".rs")
+            || trimmed.ends_with(".js")
+            || trimmed.ends_with(".json")
+            || trimmed.ends_with(".md"))
+}