@lamentis/naome 1.3.8 → 1.3.10

package/Cargo.lock

@@ -76,7 +76,7 @@ checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "naome-cli"
-version = "1.3.8"
+version = "1.3.10"
 dependencies = [
  "naome-core",
  "serde_json",
@@ -84,7 +84,7 @@ dependencies = [
 
 [[package]]
 name = "naome-core"
-version = "1.3.8"
+version = "1.3.10"
 dependencies = [
  "serde",
  "serde_json",

package/README.md

@@ -83,6 +83,7 @@ naome quality report
 naome quality report --deep
 naome quality check --changed
 naome semantic check --changed
+naome arch validate --changed-only
 naome task render-state --write --json
 naome commit -m "type(scope): summary"
 ```
@@ -103,6 +104,8 @@ After sync, NAOME writes the agent-facing workflow into `docs/naome/`:
 - `docs/naome/testing.md` maps change types to required checks.
 - `docs/naome/repository-quality.md` explains quality, structure, and cleanup
   policy.
+- `docs/naome/architecture-fitness.md` explains architecture graph validation
+  and agent feedback.
 
 Agents should follow the repository's NAOME docs instead of guessing workflow
 rules from generic project files.
@@ -117,6 +120,7 @@ The main local policy files are:
   quality policy.
 - `.naome/repository-structure.json` for path role, module, and directory
   structure policy.
+- `naome.arch.yaml` for language-agnostic architecture fitness rules.
 - `.naome/task-state.json` for the compact committed active task projection.
 
 Product defaults stay generic. Repository-specific policy belongs in the local
@@ -133,6 +137,7 @@ npm run test:naome-installer
 npm run pack:dry-run
 node .naome/bin/naome.js quality check --changed --json
 node .naome/bin/naome.js semantic check --changed --json
+node .naome/bin/naome.js arch validate --changed-only --json
 git diff --check
 ```
 

package/bin/naome.js

@@ -12,7 +12,7 @@ const packageVersion = packageMetadata.version;
 const nativeBinaryName = process.platform === "win32" ? "naome.exe" : "naome";
 const args = process.argv.slice(2);
 const [command] = args;
-const helpCommands = "status [--json]|next [--json]|intent --prompt-file <path> [--json]|intent --prompt <text> [--json]|route --prompt-file <path> [--execute] [--json]|route --prompt <text> [--execute] [--json]|explain --prompt-file <path> [--json]|explain --prompt <text> [--json]|context select --changed [--json]|context select --prompt-file <path> [--json]|context select --prompt <text> [--json]|doctor [--json]|install|sync [--check-update]|update [--json] [--execute]|task render-state [--write] [--json]|task migrate-ledger [--write] [--json]|quality init [--baseline|--deep-baseline] [--json]|quality reconcile [--write] [--json]|quality check --changed [--include-scanned-paths] [--json]|quality check --path <path> [--path <path>...] [--include-scanned-paths] [--json]|quality report [--deep] [--include-scanned-paths] [--json]|quality cache status [--json]|quality cache clear|semantic report [--deep] [--json]|semantic check --changed [--json]|semantic check --path <path> [--path <path>...] [--json]|semantic route --finding <id> [--json]|semantic loop [--json]|repo model [--write] [--json]|repo check [--json]|repo explain --path <path> [--json]|structure report [--json]|structure explain --path <path> [--json]|cleanup plan [--json]|cleanup route --path <path> [--json]|refresh-integrity [--json]|workflow agent-plan|context-delta|proof-plan|capabilities|edit-watchdog|decision-gate|digest [--json]|workflow search-profile|check-search|phases|processes|mutations [--json]|commit -m \"type(scope): message\"".split("|");
+const helpCommands = "status [--json]|next [--json]|intent --prompt-file <path> [--json]|intent --prompt <text> [--json]|route --prompt-file <path> [--execute] [--json]|route --prompt <text> [--execute] [--json]|explain --prompt-file <path> [--json]|explain --prompt <text> [--json]|context select --changed [--json]|context select --prompt-file <path> [--json]|context select --prompt <text> [--json]|doctor [--json]|install|sync [--check-update]|update [--json] [--execute]|task render-state [--write] [--json]|task migrate-ledger [--write] [--json]|quality init [--baseline|--deep-baseline] [--json]|quality reconcile [--write] [--json]|quality check --changed [--include-scanned-paths] [--json]|quality check --path <path> [--path <path>...] [--include-scanned-paths] [--json]|quality report [--deep] [--include-scanned-paths] [--json]|quality cache status [--json]|quality cache clear|semantic report [--deep] [--json]|semantic check --changed [--json]|semantic check --path <path> [--path <path>...] [--json]|semantic route --finding <id> [--json]|semantic loop [--json]|arch init [--config <path>] [--json]|arch explain [--config <path>] [--json]|arch scan [--config <path>] [--changed-only] [--write] [--output <path>] [--json]|arch validate [--config <path>] [--changed-only] [--json|--agent-feedback]|repo model [--write] [--json]|repo check [--json]|repo explain --path <path> [--json]|structure report [--json]|structure explain --path <path> [--json]|cleanup plan [--json]|cleanup route --path <path> [--json]|refresh-integrity [--json]|workflow agent-plan|context-delta|proof-plan|capabilities|edit-watchdog|decision-gate|digest [--json]|workflow search-profile|check-search|phases|processes|mutations [--json]|commit -m \"type(scope): message\"".split("|");
 
 if (isHelpRequest(args)) {
   printHelp();

package/crates/naome-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-cli"
-version = "1.3.8"
+version = "1.3.10"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

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

@@ -0,0 +1,123 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use naome_core::{
+    default_architecture_config_text, format_architecture_explain, format_architecture_scan,
+    format_architecture_validation, scan_architecture, validate_architecture,
+    ArchitectureScanOptions,
+};
+
+use crate::cli_args::{has_flag, option_value};
+
+pub fn run_arch_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 arch requires init, explain, scan, or validate".into());
+    };
+    match subcommand {
+        "init" => run_arch_init(root, args)?,
+        "explain" => run_arch_explain(root, args)?,
+        "scan" => run_arch_scan(root, args)?,
+        "validate" => run_arch_validate(root, args)?,
+        other => return Err(format!("unknown arch subcommand: {other}").into()),
+    }
+    Ok(())
+}
+
+fn run_arch_init(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let path = config_path(root, args);
+    if path.exists() {
+        return Err(format!("{} already exists", display_path(root, &path)).into());
+    }
+    fs::write(&path, default_architecture_config_text())?;
+    if has_flag(args, "--json") {
+        println!(
+            "{}",
+            serde_json::json!({
+                "schema": "naome.arch.init.v1",
+                "created": display_path(root, &path)
+            })
+        );
+    } else {
+        println!("Created {}", display_path(root, &path));
+    }
+    Ok(())
+}
+
+fn run_arch_explain(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let scan = scan_architecture(root, scan_options(root, args, false))?;
+    if has_flag(args, "--json") {
+        println!(
+            "{}",
+            serde_json::to_string_pretty(&serde_json::json!({
+                "schema": "naome.arch.explain.v1",
+                "layers": scan.config.layers.keys().collect::<Vec<_>>(),
+                "contexts": scan.config.contexts.keys().collect::<Vec<_>>(),
+                "rules": ["arch.max_file_lines", "arch.generated_manual_boundary"],
+                "extractors": ["path"]
+            }))?
+        );
+    } else {
+        print!("{}", format_architecture_explain(&scan));
+    }
+    Ok(())
+}
+
+fn run_arch_scan(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let scan = scan_architecture(
+        root,
+        scan_options(root, args, has_flag(args, "--changed-only")),
+    )?;
+    if has_flag(args, "--write") {
+        let output = option_value(args, "--output")
+            .map(PathBuf::from)
+            .unwrap_or_else(|| root.join(".naome/architecture-graph.json"));
+        fs::write(&output, serde_json::to_string_pretty(&scan.graph)?)?;
+    }
+    if has_flag(args, "--json") {
+        println!("{}", serde_json::to_string_pretty(&scan)?);
+    } else {
+        print!("{}", format_architecture_scan(&scan));
+    }
+    Ok(())
+}
+
+fn run_arch_validate(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let report = validate_architecture(
+        root,
+        scan_options(root, args, has_flag(args, "--changed-only")),
+    )?;
+    let json = has_flag(args, "--json") || has_flag(args, "--agent-feedback");
+    if json {
+        if has_flag(args, "--agent-feedback") {
+            println!("{}", serde_json::to_string_pretty(&report.agent_feedback)?);
+        } else {
+            println!("{}", serde_json::to_string_pretty(&report)?);
+        }
+    } else {
+        print!("{}", format_architecture_validation(&report));
+    }
+    if report.status == "fail" {
+        std::process::exit(1);
+    }
+    Ok(())
+}
+
+fn scan_options(root: &Path, args: &[String], changed_only: bool) -> ArchitectureScanOptions {
+    ArchitectureScanOptions {
+        config_path: option_value(args, "--config").map(|path| root.join(path)),
+        changed_only,
+    }
+}
+
+fn config_path(root: &Path, args: &[String]) -> PathBuf {
+    option_value(args, "--config")
+        .map(|path| root.join(path))
+        .unwrap_or_else(|| root.join("naome.arch.yaml"))
+}
+
+fn display_path(root: &Path, path: &Path) -> String {
+    path.strip_prefix(root)
+        .unwrap_or(path)
+        .to_string_lossy()
+        .replace('\\', "/")
+}

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

@@ -3,3 +3,7 @@ pub fn option_value(args: &[String], option: &str) -> Option<String> {
         .find(|window| window[0] == option)
         .map(|window| window[1].clone())
 }
+
+pub fn has_flag(args: &[String], flag: &str) -> bool {
+    args.iter().any(|arg| arg == flag)
+}

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

@@ -1,5 +1,6 @@
 use std::path::Path;
 
+use crate::architecture_commands::run_arch_command;
 use crate::check_commands::{run_harness_health, run_task_state, run_verification_contract};
 use crate::context_commands::run_context_command;
 use crate::install_bridge::run_install_bridge;
@@ -32,6 +33,7 @@ pub fn dispatch_command(
         "repo" => run_repo_command(root, args)?,
         "structure" => run_structure_command(root, args)?,
         "cleanup" => run_cleanup_command(root, args)?,
+        "arch" => run_arch_command(root, args)?,
         "workflow" => run_workflow_command(root, args)?,
         "check-harness-health" => run_harness_health(root, args)?,
         "check-task-state" => run_task_state(root, args)?,

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

@@ -10,8 +10,7 @@ pub fn run_install_bridge(
     let package_root = option_value(args, "--package-root")
         .map(PathBuf::from)
         .or_else(|| std::env::var("NAOME_PACKAGE_ROOT").ok().map(PathBuf::from))
-        .or_else(resolve_package_root_from_exe)
-        .or_else(resolve_package_root_from_cwd);
+        .or_else(resolve_package_root_from_exe);
     let installer_js = option_value(args, "--installer-js")
         .map(PathBuf::from)
         .or_else(|| std::env::var("NAOME_INSTALLER_JS").ok().map(PathBuf::from))
@@ -72,12 +71,61 @@ fn resolve_package_root_from_exe() -> Option<PathBuf> {
     None
 }
 
-fn resolve_package_root_from_cwd() -> Option<PathBuf> {
-    let current = std::env::current_dir().ok()?;
-    for candidate in [current.join("packages").join("naome"), current] {
-        if candidate.join("bin").join("naome-node.js").is_file() {
-            return Some(candidate);
+#[cfg(test)]
+mod tests {
+    use std::fs;
+    use std::sync::{Mutex, OnceLock};
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    use super::run_install_bridge;
+
+    fn env_lock() -> &'static Mutex<()> {
+        static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+        LOCK.get_or_init(|| Mutex::new(()))
+    }
+
+    #[test]
+    fn install_bridge_does_not_discover_installer_from_cwd() {
+        let _guard = env_lock().lock().unwrap();
+        let original_dir = std::env::current_dir().unwrap();
+        let original_package_root = std::env::var_os("NAOME_PACKAGE_ROOT");
+        let original_installer_js = std::env::var_os("NAOME_INSTALLER_JS");
+        let temp_root = std::env::temp_dir().join(format!(
+            "naome-cwd-installer-test-{}",
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        let installer_path = temp_root
+            .join("packages")
+            .join("naome")
+            .join("bin")
+            .join("naome-node.js");
+        fs::create_dir_all(installer_path.parent().unwrap()).unwrap();
+        fs::write(&installer_path, "console.log('untrusted cwd installer');\n").unwrap();
+
+        std::env::remove_var("NAOME_PACKAGE_ROOT");
+        std::env::remove_var("NAOME_INSTALLER_JS");
+        std::env::set_current_dir(&temp_root).unwrap();
+
+        let args = vec!["install".to_string()];
+        let error = run_install_bridge("install", &args)
+            .expect_err("cwd-local installer must not be treated as trusted");
+        assert!(
+            error.to_string().contains("needs naome-node.js"),
+            "unexpected error: {error}"
+        );
+
+        std::env::set_current_dir(original_dir).unwrap();
+        match original_package_root {
+            Some(value) => std::env::set_var("NAOME_PACKAGE_ROOT", value),
+            None => std::env::remove_var("NAOME_PACKAGE_ROOT"),
         }
+        match original_installer_js {
+            Some(value) => std::env::set_var("NAOME_INSTALLER_JS", value),
+            None => std::env::remove_var("NAOME_INSTALLER_JS"),
+        }
+        let _ = fs::remove_dir_all(temp_root);
     }
-    None
 }

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

@@ -1,3 +1,4 @@
+mod architecture_commands;
 mod check_commands;
 mod cli_args;
 mod context_commands;
@@ -57,6 +58,10 @@ const HELP: &str = r#"Usage:
   naome structure explain --path <path> [--json]
   naome cleanup plan [--json]
   naome cleanup route --path <path> [--json]
+  naome arch init [--config <path>] [--json]
+  naome arch explain [--config <path>] [--json]
+  naome arch scan [--config <path>] [--changed-only] [--write] [--output <path>] [--json]
+  naome arch validate [--config <path>] [--changed-only] [--agent-feedback] [--json]
   naome workflow search-profile [--json]
   naome workflow agent-plan [--json]
   naome workflow context-delta [--read-path <path>...] [--json]
@@ -93,6 +98,7 @@ const PUBLIC_COMMANDS: &[&str] = &[
     "repo",
     "structure",
     "cleanup",
+    "arch",
     "install-plan",
     "install",
     "sync",

package/crates/naome-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "naome-core"
-version = "1.3.8"
+version = "1.3.10"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true

package/crates/naome-core/src/architecture/config/parser/scalar.rs

@@ -0,0 +1,26 @@
+pub(super) fn indent(line: &str) -> usize {
+    line.chars().take_while(|ch| *ch == ' ').count()
+}
+
+pub(super) fn section_name(line: &str, expected_indent: usize) -> Option<&str> {
+    (indent(line) == expected_indent)
+        .then_some(line.trim())?
+        .strip_suffix(':')
+        .filter(|value| !value.is_empty())
+}
+
+pub(super) fn clean(value: &str) -> String {
+    value
+        .trim()
+        .trim_matches('"')
+        .trim_matches('\'')
+        .to_string()
+}
+
+pub(super) fn parse_bool(value: &str) -> Option<bool> {
+    match value {
+        "true" => Some(true),
+        "false" => Some(false),
+        _ => None,
+    }
+}

package/crates/naome-core/src/architecture/config/parser/sections.rs

@@ -0,0 +1,137 @@
+use crate::models::NaomeError;
+
+use super::scalar::{clean, indent, parse_bool, section_name};
+use super::ConfigParser;
+use crate::architecture::config::{ContextConfig, IgnoreRule, LayerConfig, RuleConfig};
+use crate::architecture::output::Severity;
+
+pub(super) fn parse_layers(parser: &mut ConfigParser<'_>) -> Result<(), NaomeError> {
+    while let Some((_, line)) = parser.peek_line() {
+        if indent(line) == 0 {
+            break;
+        }
+        let (line_number, line) = parser.next_line().unwrap();
+        let name = section_name(line, 2)
+            .ok_or_else(|| parser.error(line_number, "expected layer name".to_string()))?;
+        let paths = parser.parse_paths_block(4)?;
+        parser
+            .config
+            .layers
+            .insert(name.to_string(), LayerConfig { paths });
+    }
+    Ok(())
+}
+
+pub(super) fn parse_contexts(parser: &mut ConfigParser<'_>) -> Result<(), NaomeError> {
+    while let Some((_, line)) = parser.peek_line() {
+        if indent(line) == 0 {
+            break;
+        }
+        let (line_number, line) = parser.next_line().unwrap();
+        let name = section_name(line, 2)
+            .ok_or_else(|| parser.error(line_number, "expected context name".to_string()))?;
+        let context = parse_context(parser)?;
+        parser.config.contexts.insert(name.to_string(), context);
+    }
+    Ok(())
+}
+
+fn parse_context(parser: &mut ConfigParser<'_>) -> Result<ContextConfig, NaomeError> {
+    let mut context = ContextConfig::default();
+    while let Some((_, child)) = parser.peek_line() {
+        if indent(child) <= 2 {
+            break;
+        }
+        let (child_line, child) = parser.next_line().unwrap();
+        match child.trim() {
+            "paths:" => context.paths = parser.parse_list(6)?,
+            "public_api:" => context.public_api = parser.parse_list(6)?,
+            other => {
+                return Err(parser.error(child_line, format!("unsupported context key: {other}")))
+            }
+        }
+    }
+    Ok(context)
+}
+
+pub(super) fn parse_rules(parser: &mut ConfigParser<'_>) -> Result<(), NaomeError> {
+    while let Some((_, line)) = parser.peek_line() {
+        if indent(line) == 0 {
+            break;
+        }
+        let (line_number, line) = parser.next_line().unwrap();
+        let name = section_name(line, 2)
+            .ok_or_else(|| parser.error(line_number, "expected rule name".to_string()))?;
+        let rule = parse_rule(parser)?;
+        parser.config.rules.insert(name.to_string(), rule);
+    }
+    Ok(())
+}
+
+fn parse_rule(parser: &mut ConfigParser<'_>) -> Result<RuleConfig, NaomeError> {
+    let mut rule = RuleConfig::default();
+    while let Some((_, child)) = parser.peek_line() {
+        if indent(child) <= 2 {
+            break;
+        }
+        apply_rule_property(parser, &mut rule)?;
+    }
+    Ok(rule)
+}
+
+fn apply_rule_property(
+    parser: &mut ConfigParser<'_>,
+    rule: &mut RuleConfig,
+) -> Result<(), NaomeError> {
+    let (child_line, child) = parser.next_line().unwrap();
+    let trimmed = child.trim();
+    if let Some(value) = trimmed.strip_prefix("enabled:") {
+        rule.enabled = parse_bool(value.trim())
+            .ok_or_else(|| parser.error(child_line, "enabled must be true or false".to_string()))?;
+    } else if let Some(value) = trimmed.strip_prefix("severity:") {
+        rule.severity = Severity::parse(value.trim()).ok_or_else(|| {
+            parser.error(
+                child_line,
+                "severity must be error, warning, or info".to_string(),
+            )
+        })?;
+    } else if let Some(value) = trimmed.strip_prefix("value:") {
+        rule.value = Some(value.trim().parse::<usize>().map_err(|_| {
+            parser.error(child_line, "value must be an unsigned integer".to_string())
+        })?);
+    } else {
+        return Err(parser.error(child_line, format!("unsupported rule key: {trimmed}")));
+    }
+    Ok(())
+}
+
+pub(super) fn parse_ignore(parser: &mut ConfigParser<'_>) -> Result<(), NaomeError> {
+    while let Some((_, line)) = parser.peek_line() {
+        if indent(line) == 0 {
+            break;
+        }
+        let (line_number, line) = parser.next_line().unwrap();
+        let Some(path) = line.trim().strip_prefix("- path:").map(clean) else {
+            return Err(parser.error(
+                line_number,
+                "ignore entries must start with path".to_string(),
+            ));
+        };
+        let reason = parse_ignore_reason(parser);
+        if reason.trim().is_empty() {
+            return Err(parser.error(line_number, "ignore entries require a reason".to_string()));
+        }
+        parser.config.ignore.push(IgnoreRule { path, reason });
+    }
+    Ok(())
+}
+
+fn parse_ignore_reason(parser: &mut ConfigParser<'_>) -> String {
+    if let Some((_, next)) = parser.peek_line() {
+        if indent(next) > 2 && next.trim().starts_with("reason:") {
+            let (_, reason_line) = parser.next_line().unwrap();
+            return clean(reason_line.trim().trim_start_matches("reason:"));
+        }
+    }
+    String::new()
+}

package/crates/naome-core/src/architecture/config/parser.rs

@@ -0,0 +1,96 @@
+use crate::models::NaomeError;
+
+use super::ArchitectureConfig;
+
+mod scalar;
+mod sections;
+
+pub(super) fn parse_config(content: &str, source: &str) -> Result<ArchitectureConfig, NaomeError> {
+    let mut parser = ConfigParser::new(content, source);
+    parser.parse()
+}
+
+pub(super) struct ConfigParser<'a> {
+    pub(super) lines: Vec<(usize, &'a str)>,
+    pub(super) source: &'a str,
+    pub(super) index: usize,
+    pub(super) config: ArchitectureConfig,
+}
+
+impl<'a> ConfigParser<'a> {
+    fn new(content: &'a str, source: &'a str) -> Self {
+        let lines = content
+            .lines()
+            .enumerate()
+            .filter_map(|(index, line)| {
+                let trimmed = line.trim();
+                (!trimmed.is_empty() && !trimmed.starts_with('#')).then_some((index + 1, line))
+            })
+            .collect();
+        Self {
+            lines,
+            source,
+            index: 0,
+            config: ArchitectureConfig::default(),
+        }
+    }
+
+    fn parse(&mut self) -> Result<ArchitectureConfig, NaomeError> {
+        while let Some((line_number, line)) = self.next_line() {
+            match line.trim() {
+                "layers:" => sections::parse_layers(self)?,
+                "contexts:" => sections::parse_contexts(self)?,
+                "rules:" => sections::parse_rules(self)?,
+                "ignore:" => sections::parse_ignore(self)?,
+                other => {
+                    return Err(
+                        self.error(line_number, format!("unsupported top-level key: {other}"))
+                    )
+                }
+            }
+        }
+        Ok(std::mem::take(&mut self.config))
+    }
+
+    pub(super) fn parse_paths_block(
+        &mut self,
+        key_indent: usize,
+    ) -> Result<Vec<String>, NaomeError> {
+        let Some((line_number, line)) = self.next_line() else {
+            return Ok(Vec::new());
+        };
+        if scalar::indent(line) != key_indent || line.trim() != "paths:" {
+            return Err(self.error(line_number, "expected paths block".to_string()));
+        }
+        self.parse_list(key_indent + 2)
+    }
+
+    pub(super) fn parse_list(&mut self, item_indent: usize) -> Result<Vec<String>, NaomeError> {
+        let mut values = Vec::new();
+        while let Some((_, line)) = self.peek_line() {
+            if scalar::indent(line) < item_indent || !line.trim().starts_with("- ") {
+                break;
+            }
+            let (line_number, line) = self.next_line().unwrap();
+            if scalar::indent(line) != item_indent {
+                return Err(self.error(line_number, "invalid list indentation".to_string()));
+            }
+            values.push(scalar::clean(line.trim().trim_start_matches("- ")));
+        }
+        Ok(values)
+    }
+
+    pub(super) fn next_line(&mut self) -> Option<(usize, &'a str)> {
+        let line = self.lines.get(self.index).copied();
+        self.index += usize::from(line.is_some());
+        line
+    }
+
+    pub(super) fn peek_line(&self) -> Option<(usize, &'a str)> {
+        self.lines.get(self.index).copied()
+    }
+
+    pub(super) fn error(&self, line: usize, message: String) -> NaomeError {
+        NaomeError::new(format!("{}:{line}: {message}", self.source))
+    }
+}