@lamentis/naome 1.2.1 → 1.3.1

package/crates/naome-cli/src/quality_commands.rs

@@ -1,30 +1,41 @@
 use std::path::Path;
 
 use naome_core::{
-    check_repository_quality, explain_repository_structure, init_repository_quality,
-    plan_quality_cleanup, route_quality_cleanup, QualityMode,
+    check_repository_quality, check_repository_quality_paths, check_semantic_legacy, check_semantic_legacy_paths,
+    clear_quality_cache, explain_repository_structure, init_repository_quality_with_mode,
+    plan_quality_cleanup, quality_cache_status, route_quality_cleanup, semantic_route_for_finding,
+    QualityInitMode, QualityMode,
 };
 
 use crate::cli_args::option_value;
+use crate::quality_output::{is_structure_check, print_quality_violation, report_json};
+use crate::quality_reconcile_command::run_quality_reconcile;
 
 pub fn run_quality_command(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
     let Some(subcommand) = args.get(1).map(String::as_str) else {
-        return Err("naome quality requires init, check, or report.".into());
+        return Err("naome quality requires init, reconcile, check, report, or cache.".into());
     };
     let json = args.iter().any(|arg| arg == "--json");
 
     match subcommand {
         "init" => {
-            let result = init_repository_quality(root)?;
+            let result = init_repository_quality_with_mode(root, quality_init_mode(args)?)?;
             if json {
                 println!("{}", serde_json::to_string_pretty(&result)?);
             } else {
                 println!("NAOME repository quality initialized.");
-                println!("Baseline violations: {}", result.baseline_violations);
+                if result.baseline_pending {
+                    println!("repository quality policy initialized");
+                    println!("baseline pending: run naome quality init --baseline");
+                } else {
+                    println!("Baseline violations: {}", result.baseline_violations);
+                }
             }
         }
+        "reconcile" => run_quality_reconcile(root, args, json)?,
         "check" => run_quality_check(root, args, json)?,
-        "report" => run_quality_report(root, json)?,
+        "report" => run_quality_report(root, args, json)?,
+        "cache" => run_quality_cache(root, args, json)?,
         _ => return Err(format!("unknown naome quality command: {subcommand}").into()),
     }
     Ok(())
@@ -61,17 +72,41 @@ pub fn run_structure_command(
     Ok(())
 }
 
+pub fn run_semantic_command(
+    root: &Path,
+    args: &[String],
+) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(subcommand) = args.get(1).map(String::as_str) else {
+        return Err("naome semantic requires report, check, route, or loop.".into());
+    };
+    let json = args.iter().any(|arg| arg == "--json");
+
+    match subcommand {
+        "report" => run_semantic_report(root, args, json)?,
+        "check" => run_semantic_check(root, args, json)?,
+        "route" => run_semantic_route(root, args, json)?,
+        "loop" => run_semantic_loop(root, json)?,
+        _ => return Err(format!("unknown naome semantic command: {subcommand}").into()),
+    }
+    Ok(())
+}
+
 fn run_quality_check(
     root: &Path,
     args: &[String],
     json: bool,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    if !args.iter().any(|arg| arg == "--changed") {
-        return Err("naome quality check requires --changed.".into());
-    }
-    let report = check_repository_quality(root, QualityMode::Changed)?;
+    let paths = option_values(args, "--path");
+    let report = if paths.is_empty() {
+        if !args.iter().any(|arg| arg == "--changed") {
+            return Err("naome quality check requires --changed or --path <path>.".into());
+        }
+        check_repository_quality(root, QualityMode::ChangedFast)?
+    } else {
+        check_repository_quality_paths(root, &paths)?
+    };
     if json {
-        println!("{}", serde_json::to_string_pretty(&report)?);
+        println!("{}", report_json(&report, args)?);
     } else if report.ok {
         println!("NAOME repository quality OK.");
     } else {
@@ -89,10 +124,19 @@ fn run_quality_check(
     Ok(())
 }
 
-fn run_quality_report(root: &Path, json: bool) -> Result<(), Box<dyn std::error::Error>> {
-    let report = check_repository_quality(root, QualityMode::Report)?;
+fn run_quality_report(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let mode = if args.iter().any(|arg| arg == "--deep") {
+        QualityMode::DeepReport
+    } else {
+        QualityMode::Report
+    };
+    let report = check_repository_quality(root, mode)?;
     if json {
-        println!("{}", serde_json::to_string_pretty(&report)?);
+        println!("{}", report_json(&report, args)?);
     } else if report.violations.is_empty() {
         println!("NAOME repository quality report: no debt found.");
     } else {
@@ -108,6 +152,32 @@ fn run_quality_report(root: &Path, json: bool) -> Result<(), Box<dyn std::error:
     Ok(())
 }
 
+fn run_quality_cache(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(action) = args.get(2).map(String::as_str) else {
+        return Err("naome quality cache requires status or clear.".into());
+    };
+    let status = match action {
+        "status" => quality_cache_status(root)?,
+        "clear" => clear_quality_cache(root)?,
+        _ => return Err(format!("unknown naome quality cache command: {action}").into()),
+    };
+    if json {
+        println!("{}", serde_json::to_string_pretty(&status)?);
+    } else if action == "clear" {
+        println!("NAOME quality cache cleared.");
+    } else {
+        println!(
+            "NAOME quality cache: {} entrie(s), {} byte(s).",
+            status.entry_count, status.bytes
+        );
+    }
+    Ok(())
+}
+
 fn run_cleanup_plan(root: &Path, json: bool) -> Result<(), Box<dyn std::error::Error>> {
     let plan = plan_quality_cleanup(root)?;
     if json {
@@ -206,24 +276,158 @@ fn run_structure_explain(
     Ok(())
 }
 
-fn is_structure_check(check_id: &str) -> bool {
-    matches!(
-        check_id,
-        "directory-role-mixing"
-            | "misplaced-file-role"
-            | "root-file-sprawl"
-            | "dumping-ground-directory"
-            | "directory-size"
-            | "path-depth"
-            | "case-collision"
-            | "test-source-pairing"
-    )
-}
-
-fn print_quality_violation(violation: &naome_core::QualityViolation) {
-    let location = violation
-        .line
-        .map(|line| format!("{}:{line}", violation.path))
-        .unwrap_or_else(|| violation.path.clone());
-    eprintln!("- {location} {}: {}", violation.check_id, violation.message);
+fn run_semantic_report(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let mode = if args.iter().any(|arg| arg == "--deep") {
+        QualityMode::DeepReport
+    } else {
+        QualityMode::Report
+    };
+    let report = check_semantic_legacy(root, mode)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else if report.findings.is_empty() {
+        println!("NAOME semantic legacy report: no cleanup candidates found.");
+    } else {
+        println!(
+            "NAOME semantic legacy report: {} finding(s).",
+            report.findings.len()
+        );
+        for finding in report.findings.iter().take(20) {
+            println!(
+                "- {} {}: {}",
+                finding.kind, finding.occurrences[0].path, finding.summary
+            );
+        }
+    }
+    Ok(())
+}
+
+fn run_semantic_check(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let paths = option_values(args, "--path");
+    let report = if paths.is_empty() {
+        if !args.iter().any(|arg| arg == "--changed") {
+            return Err("naome semantic check requires --changed or --path <path>.".into());
+        }
+        check_semantic_legacy(root, QualityMode::ChangedFast)?
+    } else {
+        check_semantic_legacy_paths(root, &paths)?
+    };
+    if json {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else if report.ok {
+        println!("NAOME semantic legacy check OK.");
+    } else {
+        eprintln!(
+            "NAOME semantic legacy check failed with {} finding(s).",
+            report.findings.len()
+        );
+        for finding in report.findings.iter().take(20) {
+            eprintln!(
+                "- {} {}: {}",
+                finding.kind, finding.occurrences[0].path, finding.summary
+            );
+        }
+    }
+    if !report.ok {
+        std::process::exit(1);
+    }
+    Ok(())
+}
+
+fn run_semantic_route(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(finding_id) = option_value(args, "--finding") else {
+        return Err("naome semantic route requires --finding <id>.".into());
+    };
+    let report = check_semantic_legacy(root, QualityMode::DeepReport)?;
+    let Some(finding) = semantic_route_for_finding(&report, &finding_id) else {
+        return Err(format!("semantic finding not found: {finding_id}").into());
+    };
+    if json {
+        println!("{}", serde_json::to_string_pretty(&finding)?);
+    } else {
+        println!("NAOME semantic cleanup route for {}", finding.id);
+        println!("{}", finding.cleanup_route.intent);
+        for instruction in &finding.cleanup_route.agent_instructions {
+            println!("- {instruction}");
+        }
+        let paths = finding
+            .occurrences
+            .iter()
+            .map(|occurrence| occurrence.path.as_str())
+            .collect::<Vec<_>>()
+            .join(", ");
+        println!("Affected paths: {paths}");
+    }
+    Ok(())
+}
+
+fn run_semantic_loop(root: &Path, json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let changed = check_semantic_legacy(root, QualityMode::ChangedFast)?;
+    let (action, finding) = if let Some(finding) = changed.findings.first().cloned() {
+        ("cleanup_changed_finding", Some(finding))
+    } else {
+        let report = check_semantic_legacy(root, QualityMode::Report)?;
+        if let Some(finding) = report.findings.first().cloned() {
+            ("report_legacy_debt", Some(finding))
+        } else {
+            ("complete", None)
+        }
+    };
+
+    if json {
+        println!(
+            "{}",
+            serde_json::to_string_pretty(&serde_json::json!({
+                "schema": "naome.semantic-loop.v1",
+                "ok": action != "cleanup_changed_finding",
+                "action": action,
+                "finding": finding
+            }))?
+        );
+    } else {
+        match finding {
+            Some(finding) => {
+                println!("NAOME semantic loop action: {action}");
+                println!("{} {}", finding.kind, finding.id);
+                println!("{}", finding.summary);
+                println!("Run: naome semantic route --finding {} --json", finding.id);
+            }
+            None => println!("NAOME semantic loop complete: no semantic cleanup candidates found."),
+        }
+    }
+    Ok(())
+}
+
+fn quality_init_mode(args: &[String]) -> Result<QualityInitMode, Box<dyn std::error::Error>> {
+    let baseline = args.iter().any(|arg| arg == "--baseline");
+    let deep_baseline = args.iter().any(|arg| arg == "--deep-baseline");
+    if baseline && deep_baseline {
+        return Err("naome quality init accepts only one baseline mode.".into());
+    }
+    Ok(if deep_baseline {
+        QualityInitMode::DeepBaseline
+    } else if baseline {
+        QualityInitMode::Baseline
+    } else {
+        QualityInitMode::SeedOnly
+    })
+}
+
+fn option_values(args: &[String], name: &str) -> Vec<String> {
+    args.windows(2)
+        .filter(|window| window[0] == name)
+        .map(|window| window[1].clone())
+        .collect()
 }

package/crates/naome-cli/src/quality_output.rs

@@ -0,0 +1,34 @@
+pub fn report_json(
+    report: &naome_core::QualityReport,
+    args: &[String],
+) -> Result<String, Box<dyn std::error::Error>> {
+    let mut value = serde_json::to_value(report)?;
+    if !args.iter().any(|arg| arg == "--include-scanned-paths") {
+        if let Some(object) = value.as_object_mut() {
+            object.remove("scannedPaths");
+        }
+    }
+    Ok(serde_json::to_string_pretty(&value)?)
+}
+
+pub fn print_quality_violation(violation: &naome_core::QualityViolation) {
+    let location = violation
+        .line
+        .map(|line| format!("{}:{line}", violation.path))
+        .unwrap_or_else(|| violation.path.clone());
+    eprintln!("- {location} {}: {}", violation.check_id, violation.message);
+}
+
+pub fn is_structure_check(check_id: &str) -> bool {
+    matches!(
+        check_id,
+        "directory-role-mixing"
+            | "misplaced-file-role"
+            | "root-file-sprawl"
+            | "dumping-ground-directory"
+            | "directory-size"
+            | "path-depth"
+            | "case-collision"
+            | "test-source-pairing"
+    )
+}

package/crates/naome-cli/src/quality_reconcile_command.rs

@@ -0,0 +1,45 @@
+use std::collections::BTreeSet;
+use std::path::Path;
+
+use naome_core::reconcile_repository_quality;
+
+pub fn run_quality_reconcile(
+    root: &Path,
+    args: &[String],
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let write = args.iter().any(|arg| arg == "--write");
+    let report = reconcile_repository_quality(root, write)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else if report.ok && report.updated_paths.is_empty() {
+        println!("NAOME repository quality adapter policy is current.");
+    } else if report.ok {
+        println!(
+            "NAOME repository quality adapter policy updated: {}",
+            report.updated_paths.join(", ")
+        );
+    } else {
+        eprintln!(
+            "NAOME repository quality adapter policy is stale. Missing adapter(s): {}",
+            missing_adapters(&report)
+        );
+        eprintln!("Run: naome quality reconcile --write");
+    }
+    if !report.ok {
+        std::process::exit(1);
+    }
+    Ok(())
+}
+
+fn missing_adapters(report: &naome_core::QualityReconcileReport) -> String {
+    report
+        .missing_quality_adapters
+        .iter()
+        .chain(report.missing_structure_adapters.iter())
+        .cloned()
+        .collect::<BTreeSet<_>>()
+        .into_iter()
+        .collect::<Vec<_>>()
+        .join(", ")
+}

package/crates/naome-cli/src/repository_model_commands.rs

@@ -0,0 +1,84 @@
+use std::path::Path;
+
+use naome_core::{explain_repository_model_path, refresh_repository_model, RepositoryModelRefresh};
+
+use crate::cli_args::option_value;
+
+pub fn run_repo_command(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(subcommand) = args.get(1).map(String::as_str) else {
+        return Err("naome repo requires model, check, or explain.".into());
+    };
+    let json = args.iter().any(|arg| arg == "--json");
+
+    match subcommand {
+        "model" => run_model(root, args, json)?,
+        "check" => run_check(root, json)?,
+        "explain" => run_explain(root, args, json)?,
+        _ => return Err(format!("unknown naome repo command: {subcommand}").into()),
+    }
+    Ok(())
+}
+
+fn run_model(root: &Path, args: &[String], json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let report = refresh_repository_model(root, args.iter().any(|arg| arg == "--write"))?;
+    print_refresh_report(&report, json)
+}
+
+fn run_check(root: &Path, json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let report = refresh_repository_model(root, false)?;
+    print_refresh_report(&report, json)
+}
+
+fn print_refresh_report(
+    report: &RepositoryModelRefresh,
+    json: bool,
+) -> Result<(), Box<dyn std::error::Error>> {
+    if json {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else if !report.updated_paths.is_empty() {
+        println!(
+            "NAOME repository model updated: {}.",
+            report.updated_paths.join(", ")
+        );
+    } else if report.ok {
+        println!("NAOME repository model is current.");
+    } else {
+        println!("NAOME repository model is stale.");
+        println!("Run naome repo model --write to refresh deterministic repository facts.");
+    }
+    if !report.ok {
+        std::process::exit(1);
+    }
+    Ok(())
+}
+
+fn run_explain(root: &Path, args: &[String], json: bool) -> Result<(), Box<dyn std::error::Error>> {
+    let Some(path) = option_value(args, "--path") else {
+        return Err("naome repo explain requires --path <path>.".into());
+    };
+    let explanation = explain_repository_model_path(root, path)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&explanation)?);
+    } else {
+        println!(
+            "{} role={} language={} module={} entity={}",
+            explanation.path,
+            explanation.role.as_deref().unwrap_or("unknown"),
+            explanation.language.as_deref().unwrap_or("unknown"),
+            explanation.module.as_deref().unwrap_or("unknown"),
+            explanation.entity.as_deref().unwrap_or("unknown")
+        );
+        if !explanation.facts.is_empty() {
+            println!(
+                "Facts: {}",
+                explanation
+                    .facts
+                    .iter()
+                    .map(|fact| fact.id.as_str())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            );
+        }
+    }
+    Ok(())
+}

package/crates/naome-cli/src/task_commands.rs

@@ -0,0 +1,62 @@
+use std::path::Path;
+
+use naome_core::{migrate_task_state_to_ledger, render_task_state_from_ledger};
+
+pub fn run_task_command(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    match args.get(1).map(String::as_str) {
+        Some("render-state") => render_state(root, args),
+        Some("migrate-ledger") => migrate_ledger(root, args),
+        _ => Err("unknown task command".into()),
+    }
+}
+
+fn render_state(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let write = args.iter().any(|arg| arg == "--write");
+    let json = args.iter().any(|arg| arg == "--json");
+    let rendered = render_task_state_from_ledger(root, write)?;
+
+    if json {
+        println!(
+            "{}",
+            serde_json::to_string_pretty(&serde_json::json!({
+                "schema": "naome.task-render-state.v1",
+                "updated": write && rendered.is_some(),
+                "source": if rendered.is_some() { "ledger" } else { "task-state" },
+                "taskState": rendered
+            }))?
+        );
+    } else if rendered.is_some() {
+        println!("NAOME task-state projection rendered from task ledger.");
+    } else {
+        println!(
+            "NAOME task ledger not found; existing task-state compatibility mode remains active."
+        );
+    }
+
+    Ok(())
+}
+
+fn migrate_ledger(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let write = args.iter().any(|arg| arg == "--write");
+    let json = args.iter().any(|arg| arg == "--json");
+    let migrated = migrate_task_state_to_ledger(root, write)?;
+
+    if json {
+        println!(
+            "{}",
+            serde_json::to_string_pretty(&serde_json::json!({
+                "schema": "naome.task-migrate-ledger.v1",
+                "updated": write && migrated.is_some(),
+                "migration": migrated
+            }))?
+        );
+    } else if migrated.is_some() && write {
+        println!("NAOME task ledger migrated from task-state.");
+    } else if migrated.is_some() {
+        println!("NAOME task ledger migration is available; rerun with --write to apply it.");
+    } else {
+        println!("NAOME task ledger migration skipped; no active task-state task exists.");
+    }
+
+    Ok(())
+}