@lamentis/naome 1.3.0 → 1.3.2

package/crates/naome-core/src/repository_model.rs

@@ -0,0 +1,164 @@
+mod detect;
+mod explain;
+mod path_scan;
+mod path_support;
+mod types;
+mod world;
+mod world_adapters;
+mod world_path_facts;
+mod world_paths;
+
+use std::fs;
+use std::path::Path;
+
+use crate::models::NaomeError;
+
+use detect::detect_repository_model;
+use explain::explain_path;
+pub use types::{
+    RepositoryEntity, RepositoryFact, RepositoryModel, RepositoryModelDrift,
+    RepositoryModelRefresh, RepositoryPathExplanation, RepositoryPathFact, RepositoryRoot,
+    RepositoryVerificationCheck, RepositoryWorldSignal,
+};
+
+const MODEL_PATH: &str = ".naome/repository-model.json";
+
+pub fn refresh_repository_model(
+    root: &Path,
+    write: bool,
+) -> Result<RepositoryModelRefresh, NaomeError> {
+    let model = detect_repository_model(root)?;
+    let existing = read_existing_model(root)?;
+    let stale = existing.as_ref() != Some(&model);
+    let canonical_drift = write && !model_file_matches(root, &model)?;
+    let mut updated_paths = Vec::new();
+
+    if write && (stale || canonical_drift) {
+        write_model(root, &model)?;
+        updated_paths.push(MODEL_PATH.to_string());
+    }
+
+    let stale_after_write = stale && !write;
+    Ok(RepositoryModelRefresh {
+        schema: "naome.repository-model-refresh.v1".to_string(),
+        ok: !stale_after_write,
+        stale: stale_after_write,
+        write,
+        model_path: MODEL_PATH.to_string(),
+        updated_paths,
+        reason_codes: if stale {
+            vec!["repository_model_stale".to_string()]
+        } else {
+            Vec::new()
+        },
+        model,
+    })
+}
+
+pub fn explain_repository_model_path(
+    root: &Path,
+    path: impl AsRef<str>,
+) -> Result<RepositoryPathExplanation, NaomeError> {
+    let model = read_existing_model(root)?.unwrap_or(detect_repository_model(root)?);
+    Ok(explain_path(&model, path.as_ref()))
+}
+
+pub fn repository_model_drift(root: &Path) -> Result<RepositoryModelDrift, NaomeError> {
+    let path = root.join(MODEL_PATH);
+    let model_present = path.is_file();
+    if !model_present {
+        return Ok(RepositoryModelDrift {
+            schema: "naome.repository-model-drift.v1".to_string(),
+            ok: true,
+            model_present,
+            stale: false,
+            model_path: MODEL_PATH.to_string(),
+            reason_codes: Vec::new(),
+            related_paths: Vec::new(),
+            messages: Vec::new(),
+        });
+    }
+
+    let existing = read_existing_model(root)?.unwrap_or_default();
+    let current = detect_repository_model(root)?;
+    let stale = existing != current;
+    let related_paths = if stale {
+        model_evidence_paths(&current)
+    } else {
+        Vec::new()
+    };
+    let messages = if stale {
+        vec![format!(
+            "NAOME repository model is stale; run naome repo model --write to refresh deterministic repository facts in {MODEL_PATH}."
+        )]
+    } else {
+        Vec::new()
+    };
+
+    Ok(RepositoryModelDrift {
+        schema: "naome.repository-model-drift.v1".to_string(),
+        ok: !stale,
+        model_present,
+        stale,
+        model_path: MODEL_PATH.to_string(),
+        reason_codes: if stale {
+            vec!["repository_model_stale".to_string()]
+        } else {
+            Vec::new()
+        },
+        related_paths,
+        messages,
+    })
+}
+
+fn read_existing_model(root: &Path) -> Result<Option<RepositoryModel>, NaomeError> {
+    let path = root.join(MODEL_PATH);
+    if !path.is_file() {
+        return Ok(None);
+    }
+    Ok(Some(serde_json::from_str(&fs::read_to_string(path)?)?))
+}
+
+fn model_evidence_paths(model: &RepositoryModel) -> Vec<String> {
+    let mut paths = model
+        .facts
+        .iter()
+        .flat_map(|fact| fact.evidence.iter())
+        .chain(model.roots.iter().flat_map(|root| root.evidence.iter()))
+        .chain(model.entities.iter().flat_map(|entity| entity.evidence.iter()))
+        .chain(model.path_facts.iter().map(|fact| &fact.path))
+        .chain(
+            model
+                .verification_checks
+                .iter()
+                .flat_map(|check| check.evidence.iter()),
+        )
+        .filter(|path| path.as_str() != ".naome/verification.json")
+        .cloned()
+        .collect::<std::collections::BTreeSet<_>>()
+        .into_iter()
+        .collect::<Vec<_>>();
+    paths.sort();
+    paths
+}
+
+fn write_model(root: &Path, model: &RepositoryModel) -> Result<(), NaomeError> {
+    let path = root.join(MODEL_PATH);
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    fs::write(path, model_content(model)?)?;
+    Ok(())
+}
+
+fn model_file_matches(root: &Path, model: &RepositoryModel) -> Result<bool, NaomeError> {
+    let path = root.join(MODEL_PATH);
+    if !path.is_file() {
+        return Ok(false);
+    }
+    Ok(fs::read_to_string(path)? == model_content(model)?)
+}
+
+fn model_content(model: &RepositoryModel) -> Result<String, NaomeError> {
+    Ok(format!("{}\n", serde_json::to_string(model)?))
+}

package/crates/naome-core/src/route/builtin_checks.rs

@@ -2,7 +2,7 @@ use std::path::Path;
 
 use crate::harness_health::{validate_harness_health, HarnessHealthOptions};
 use crate::models::NaomeError;
-use crate::quality::{check_repository_quality, QualityMode};
+use crate::quality::{check_repository_quality, check_semantic_legacy, QualityMode};
 use crate::route::git_ops::{command_output, git_output};
 use crate::route::quality_gate::QualityCheck;
 use crate::task_state::{validate_task_state, TaskStateMode, TaskStateOptions};
@@ -64,12 +64,51 @@ pub(super) fn run_quality_check(
             )?;
             run_repository_quality_check(root)
         }
+        "repository-semantic-check" => {
+            require_builtin_quality_check_any(
+                check_id,
+                check,
+                &[
+                    "naome semantic check --changed",
+                    "node .naome/bin/naome.js semantic check --changed",
+                    "npm run check:repository-semantic",
+                ],
+            )?;
+            run_repository_semantic_check(root)
+        }
         _ => Err(NaomeError::new(format!(
             "Quality check {check_id} is not a built-in safe check; NAOME will not execute repository-controlled verification commands."
         ))),
     }
 }
 
+fn run_repository_semantic_check(root: &Path) -> Result<(), NaomeError> {
+    let report = check_semantic_legacy(root, QualityMode::ChangedFast)?;
+    if report.ok {
+        return Ok(());
+    }
+
+    let details = report
+        .findings
+        .iter()
+        .take(20)
+        .flat_map(|finding| {
+            finding.occurrences.iter().take(1).map(move |occurrence| {
+                format!(
+                    "{}:{} semantic-{}: {}",
+                    occurrence.path, occurrence.start_line, finding.kind, finding.summary
+                )
+            })
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    Err(NaomeError::new(format!(
+        "repository-semantic-check failed with {} finding(s).\n{}",
+        report.findings.len(),
+        details
+    )))
+}
+
 fn run_repository_quality_check(root: &Path) -> Result<(), NaomeError> {
     let report = check_repository_quality(root, QualityMode::ChangedFast)?;
     if report.ok {

package/crates/naome-core/src/task_ledger/import.rs

@@ -0,0 +1,142 @@
+use std::fs;
+use std::path::Path;
+
+use serde_json::{json, Value};
+
+use crate::models::NaomeError;
+
+use super::read::{active_path, task_dir};
+use super::write::json_text;
+
+pub(super) fn migrate_task_state_to_ledger(
+    root: &Path,
+    write_ledger: bool,
+) -> Result<Option<Value>, NaomeError> {
+    if active_path(root).is_file() {
+        return Ok(Some(json!({
+            "schema": "naome.task-ledger-migration.v1",
+            "source": "ledger",
+            "updated": false,
+            "reason": "ledger already exists"
+        })));
+    }
+
+    let Some(task_state) = super::read::read_legacy_task_state(root)? else {
+        return Ok(None);
+    };
+    let Some(active_task) = task_state
+        .get("activeTask")
+        .filter(|value| !value.is_null())
+    else {
+        return Ok(None);
+    };
+    let Some(task_id) = active_task.get("id").and_then(Value::as_str) else {
+        return Err(NaomeError::new(
+            "Cannot migrate task-state to ledger: activeTask.id is missing.",
+        ));
+    };
+
+    let task_dir = task_dir(root, task_id);
+    let proof_dir = task_dir.join("proofs");
+    let proofs = super::proof_record::expanded_proofs(active_task, root)?;
+    let status = task_state
+        .get("status")
+        .and_then(Value::as_str)
+        .unwrap_or("implementing");
+    let updated_at = task_state
+        .get("updatedAt")
+        .and_then(Value::as_str)
+        .unwrap_or("1970-01-01T00:00:00.000Z");
+
+    let active = json!({
+        "schema": "naome.task-ledger-active.v1",
+        "version": 1,
+        "primaryTaskId": task_id,
+        "worklanes": [
+            { "id": "default", "taskId": task_id, "status": "active" }
+        ]
+    });
+    let spec = task_spec(active_task);
+    let events = task_events(status, updated_at, task_state.get("blocker"));
+
+    if write_ledger {
+        fs::create_dir_all(&proof_dir)?;
+        fs::write(active_path(root), json_text(&active)?)?;
+        fs::write(task_dir.join("task.json"), json_text(&spec)?)?;
+        fs::write(task_dir.join("events.jsonl"), events)?;
+        for proof in &proofs {
+            let file_name = super::proof_record::proof_file_name(
+                proof
+                    .get("checkId")
+                    .and_then(Value::as_str)
+                    .unwrap_or("proof"),
+            );
+            fs::write(proof_dir.join(file_name), json_text(proof)?)?;
+        }
+        if let Some(projection) = super::render::render_from_ledger(root)? {
+            super::write::write_task_state_projection(root, &projection.state)?;
+        }
+    }
+
+    Ok(Some(json!({
+        "schema": "naome.task-ledger-migration.v1",
+        "source": "task-state",
+        "updated": write_ledger,
+        "taskId": task_id,
+        "proofCount": proofs.len()
+    })))
+}
+
+fn task_spec(active_task: &Value) -> Value {
+    json!({
+        "schema": "naome.task-ledger-task.v1",
+        "version": 1,
+        "id": active_task.get("id").cloned().unwrap_or(Value::Null),
+        "request": active_task.get("request").cloned().unwrap_or(Value::Null),
+        "userPrompt": active_task.get("userPrompt").cloned().unwrap_or(Value::Null),
+        "admission": active_task.get("admission").cloned().unwrap_or(Value::Null),
+        "allowedPaths": active_task.get("allowedPaths").cloned().unwrap_or_else(|| json!([])),
+        "declaredChangeTypes": active_task
+            .get("declaredChangeTypes")
+            .cloned()
+            .unwrap_or_else(|| json!([])),
+        "requiredCheckIds": active_task
+            .get("requiredCheckIds")
+            .cloned()
+            .unwrap_or_else(|| json!([])),
+        "revisions": active_task.get("revisions").cloned().unwrap_or_else(|| json!([])),
+        "humanReview": active_task.get("humanReview").cloned().unwrap_or_else(|| {
+            json!({
+                "required": false,
+                "approved": false,
+                "reason": null
+            })
+        })
+    })
+}
+
+fn task_events(status: &str, updated_at: &str, blocker: Option<&Value>) -> String {
+    let mut events = Vec::new();
+    events.push(json!({
+        "schema": "naome.task-ledger-event.v1",
+        "type": "status",
+        "status": status,
+        "recordedAt": updated_at
+    }));
+    if let Some(blocker) = blocker.filter(|value| !value.is_null()) {
+        events.push(json!({
+            "schema": "naome.task-ledger-event.v1",
+            "type": "blocker",
+            "blocker": blocker,
+            "recordedAt": updated_at
+        }));
+    }
+
+    let mut text = events
+        .into_iter()
+        .map(|event| serde_json::to_string(&event).unwrap_or_else(|_| "{}".to_string()))
+        .collect::<Vec<_>>()
+        .join("\n");
+    text.push('\n');
+    text
+}

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

@@ -0,0 +1,13 @@
+use serde_json::Value;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TaskLedgerProjection {
+    pub state: Value,
+    pub status: TaskLedgerStatus,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TaskLedgerStatus {
+    Active,
+    LegacyFallback,
+}

package/crates/naome-core/src/task_ledger/proof_record.rs

@@ -0,0 +1,52 @@
+use std::path::Path;
+
+use serde_json::{json, Value};
+
+use crate::models::NaomeError;
+use crate::task_state::canonical_proofs;
+
+pub(super) fn expanded_proofs(active_task: &Value, root: &Path) -> Result<Vec<Value>, NaomeError> {
+    let mut errors = Vec::new();
+    let proofs = canonical_proofs(active_task, root, &mut errors)?;
+    if !errors.is_empty() {
+        return Err(NaomeError::new(format!(
+            "Cannot migrate invalid task proof into ledger: {}",
+            errors.join("; ")
+        )));
+    }
+
+    Ok(proofs
+        .into_iter()
+        .map(|proof| {
+            json!({
+                "schema": "naome.task-ledger-proof.v1",
+                "version": 1,
+                "taskId": active_task.get("id").cloned().unwrap_or(Value::Null),
+                "checkId": proof.check_id,
+                "command": proof.command,
+                "cwd": proof.cwd,
+                "exitCode": proof.exit_code,
+                "checkedAt": proof.checked_at,
+                "evidence": proof.evidence
+            })
+        })
+        .collect())
+}
+
+pub(super) fn proof_file_name(check_id: &str) -> String {
+    let mut name = check_id
+        .chars()
+        .map(|ch| {
+            if ch.is_ascii_alphanumeric() || matches!(ch, '-' | '_' | '.') {
+                ch
+            } else {
+                '_'
+            }
+        })
+        .collect::<String>();
+    if name.is_empty() {
+        name = "proof".to_string();
+    }
+    name.push_str(".json");
+    name
+}

package/crates/naome-core/src/task_ledger/read.rs

@@ -0,0 +1,118 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use serde_json::{json, Value};
+
+use crate::models::NaomeError;
+
+pub(super) fn read_legacy_task_state(root: &Path) -> Result<Option<Value>, NaomeError> {
+    let path = root.join(".naome/task-state.json");
+    if !path.is_file() {
+        return Ok(None);
+    }
+    let content = fs::read_to_string(path)?;
+    Ok(Some(serde_json::from_str(&content)?))
+}
+
+pub(super) fn read_active_task_id(root: &Path) -> Result<Option<String>, NaomeError> {
+    let path = active_path(root);
+    if !path.is_file() {
+        return Ok(None);
+    }
+    let active = read_json(&path)?;
+    Ok(active
+        .get("primaryTaskId")
+        .and_then(Value::as_str)
+        .map(ToString::to_string))
+}
+
+pub(super) fn read_task_spec(root: &Path, task_id: &str) -> Result<Value, NaomeError> {
+    read_json(&task_dir(root, task_id).join("task.json"))
+}
+
+pub(super) fn read_status(
+    root: &Path,
+    task_id: &str,
+) -> Result<(String, Option<Value>, String), NaomeError> {
+    let events_path = task_dir(root, task_id).join("events.jsonl");
+    let mut status = "implementing".to_string();
+    let mut blocker = None;
+    let mut updated_at = None;
+
+    if events_path.is_file() {
+        for line in fs::read_to_string(events_path)?.lines() {
+            if line.trim().is_empty() {
+                continue;
+            }
+            let event: Value = serde_json::from_str(line)?;
+            if let Some(recorded_at) = event.get("recordedAt").and_then(Value::as_str) {
+                updated_at = Some(recorded_at.to_string());
+            }
+            match event.get("type").and_then(Value::as_str) {
+                Some("status") => {
+                    if let Some(next_status) = event.get("status").and_then(Value::as_str) {
+                        status = next_status.to_string();
+                    }
+                }
+                Some("blocker") => blocker = event.get("blocker").cloned(),
+                _ => {}
+            }
+        }
+    }
+
+    Ok((
+        status,
+        blocker,
+        updated_at.unwrap_or_else(|| "1970-01-01T00:00:00.000Z".to_string()),
+    ))
+}
+
+pub(super) fn read_proofs(root: &Path, task_id: &str) -> Result<Vec<Value>, NaomeError> {
+    let proofs_dir = task_dir(root, task_id).join("proofs");
+    if !proofs_dir.is_dir() {
+        return Ok(Vec::new());
+    }
+
+    let mut entries: Vec<PathBuf> = fs::read_dir(proofs_dir)?
+        .filter_map(Result::ok)
+        .map(|entry| entry.path())
+        .filter(|path| path.extension().and_then(|ext| ext.to_str()) == Some("json"))
+        .collect();
+    entries.sort();
+
+    let mut proofs = Vec::new();
+    for path in entries {
+        let proof = read_json(&path)?;
+        proofs.push(json!({
+            "checkId": proof.get("checkId").cloned().unwrap_or(Value::Null),
+            "command": proof.get("command").cloned().unwrap_or(Value::Null),
+            "cwd": proof.get("cwd").cloned().unwrap_or(Value::Null),
+            "exitCode": proof.get("exitCode").cloned().unwrap_or(Value::Null),
+            "checkedAt": proof.get("checkedAt").cloned().unwrap_or(Value::Null),
+            "evidence": proof.get("evidence").cloned().unwrap_or_else(|| json!([])),
+            "outputSummary": proof.get("outputSummary").cloned().unwrap_or(Value::Null)
+        }));
+    }
+    Ok(proofs
+        .into_iter()
+        .map(|mut proof| {
+            if proof.get("outputSummary").is_some_and(Value::is_null) {
+                proof.as_object_mut().unwrap().remove("outputSummary");
+            }
+            proof
+        })
+        .collect())
+}
+
+fn read_json(path: &Path) -> Result<Value, NaomeError> {
+    let content = fs::read_to_string(path)?;
+    Ok(serde_json::from_str(&content)?)
+}
+
+pub(super) fn active_path(root: &Path) -> PathBuf {
+    root.join(".naome/tasks/active.json")
+}
+
+pub(super) fn task_dir(root: &Path, task_id: &str) -> PathBuf {
+    root.join(".naome/tasks").join(task_id)
+}

package/crates/naome-core/src/task_ledger/render.rs

@@ -0,0 +1,55 @@
+use std::path::Path;
+
+use serde_json::{json, Value};
+
+use crate::models::NaomeError;
+
+use super::model::{TaskLedgerProjection, TaskLedgerStatus};
+use super::read::{read_active_task_id, read_proofs, read_status, read_task_spec};
+
+pub(super) fn render_from_ledger(root: &Path) -> Result<Option<TaskLedgerProjection>, NaomeError> {
+    let Some(task_id) = read_active_task_id(root)? else {
+        return Ok(None);
+    };
+    let spec = read_task_spec(root, &task_id)?;
+    let (status, blocker, updated_at) = read_status(root, &task_id)?;
+    let active_task = render_active_task(spec, read_proofs(root, &task_id)?);
+    Ok(Some(TaskLedgerProjection {
+        state: json!({
+            "schema": "naome.task-state.v2",
+            "version": 2,
+            "status": status,
+            "activeTask": active_task,
+            "blocker": blocker,
+            "updatedAt": updated_at
+        }),
+        status: TaskLedgerStatus::Active,
+    }))
+}
+
+fn render_active_task(spec: Value, proof_results: Vec<Value>) -> Value {
+    json!({
+        "id": spec.get("id").cloned().unwrap_or(Value::Null),
+        "request": spec.get("request").cloned().unwrap_or(Value::Null),
+        "userPrompt": spec.get("userPrompt").cloned().unwrap_or(Value::Null),
+        "admission": spec.get("admission").cloned().unwrap_or(Value::Null),
+        "allowedPaths": spec.get("allowedPaths").cloned().unwrap_or_else(|| json!([])),
+        "declaredChangeTypes": spec
+            .get("declaredChangeTypes")
+            .cloned()
+            .unwrap_or_else(|| json!([])),
+        "requiredCheckIds": spec
+            .get("requiredCheckIds")
+            .cloned()
+            .unwrap_or_else(|| json!([])),
+        "proofResults": proof_results,
+        "revisions": spec.get("revisions").cloned().unwrap_or_else(|| json!([])),
+        "humanReview": spec.get("humanReview").cloned().unwrap_or_else(|| {
+            json!({
+                "required": false,
+                "approved": false,
+                "reason": null
+            })
+        })
+    })
+}

package/crates/naome-core/src/task_ledger/write.rs

@@ -0,0 +1,38 @@
+use std::fs;
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+use super::read;
+use super::render;
+
+pub(super) fn write_task_state_projection(root: &Path, state: &Value) -> Result<(), NaomeError> {
+    let path = root.join(".naome/task-state.json");
+    fs::write(path, json_text(state)?)?;
+    Ok(())
+}
+
+pub(super) fn validate_task_state_projection_is_current(
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    if !read::active_path(root).is_file() {
+        return Ok(());
+    }
+    let Some(legacy) = read::read_legacy_task_state(root)? else {
+        return Ok(());
+    };
+    let Some(rendered) = render::render_from_ledger(root)? else {
+        return Ok(());
+    };
+    if legacy != rendered.state {
+        errors.push(".naome/task-state.json is stale relative to .naome/tasks/. Run node .naome/bin/naome.js task render-state --write --json before completion or commit.".to_string());
+    }
+    Ok(())
+}
+
+pub(super) fn json_text(value: &Value) -> Result<String, NaomeError> {
+    Ok(format!("{}\n", serde_json::to_string_pretty(value)?))
+}

package/crates/naome-core/src/task_ledger.rs

@@ -0,0 +1,48 @@
+mod import;
+mod model;
+mod proof_record;
+mod read;
+mod render;
+mod write;
+
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::models::NaomeError;
+
+pub use model::{TaskLedgerProjection, TaskLedgerStatus};
+
+pub fn migrate_task_state_to_ledger(
+    root: &Path,
+    write_ledger: bool,
+) -> Result<Option<Value>, NaomeError> {
+    import::migrate_task_state_to_ledger(root, write_ledger)
+}
+
+pub fn read_task_state_projection(root: &Path) -> Result<Option<Value>, NaomeError> {
+    if let Some(projection) = render::render_from_ledger(root)? {
+        return Ok(Some(projection.state));
+    }
+    read::read_legacy_task_state(root)
+}
+
+pub fn render_task_state_from_ledger(
+    root: &Path,
+    write_projection: bool,
+) -> Result<Option<Value>, NaomeError> {
+    let Some(projection) = render::render_from_ledger(root)? else {
+        return Ok(None);
+    };
+    if write_projection {
+        write::write_task_state_projection(root, &projection.state)?;
+    }
+    Ok(Some(projection.state))
+}
+
+pub(crate) fn validate_task_state_projection_is_current(
+    root: &Path,
+    errors: &mut Vec<String>,
+) -> Result<(), NaomeError> {
+    write::validate_task_state_projection_is_current(root, errors)
+}