@lamentis/naome 1.2.1 → 1.3.0

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

@@ -1,7 +1,7 @@
 use std::path::Path;
 
 use naome_core::{
-    classify_mutations, refresh_integrity, safe_rg_args, tracked_process_report,
+    classify_mutations, doctor_report, refresh_integrity, safe_rg_args, tracked_process_report,
     validate_search_command, verification_phase_plan,
 };
 
@@ -83,6 +83,26 @@ pub fn run_workflow_command(
     Ok(())
 }
 
+pub fn run_doctor(root: &Path, args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
+    let report = doctor_report(root)?;
+    if args.iter().any(|arg| arg == "--json") {
+        println!("{}", serde_json::to_string_pretty(&report)?);
+    } else {
+        println!(
+            "NAOME doctor: {}",
+            if report.ok { "ok" } else { "attention needed" }
+        );
+        println!("{}", report.next_action);
+        if !report.recommended_check_ids.is_empty() {
+            println!(
+                "Recommended checks: {}",
+                report.recommended_check_ids.join(", ")
+            );
+        }
+    }
+    Ok(())
+}
+
 fn run_check_search(
     root: &Path,
     args: &[String],

package/crates/naome-core/Cargo.toml

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

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

@@ -63,12 +63,14 @@ fn read_naomeignore_patterns(root: &Path) -> Vec<String> {
         return Vec::new();
     };
 
-    content
+    let mut patterns = content
         .lines()
         .map(str::trim)
         .filter(|line| !line.is_empty() && !line.starts_with('#') && !line.starts_with('!'))
         .map(normalize_ignore_pattern)
-        .collect()
+        .collect::<Vec<_>>();
+    patterns.push(".naome/cache/**".to_string());
+    patterns
 }
 
 fn normalize_ignore_pattern(pattern: &str) -> String {

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

@@ -50,6 +50,7 @@ pub const LOCAL_NATIVE_BINARY_PATHS: &[&str] = &[
     ".naome/bin/naome-rust",
     ".naome/bin/naome-rust.exe",
     ".naome/archive",
+    ".naome/cache",
     ".naome/task-journal.jsonl",
 ];
 
@@ -72,6 +73,7 @@ pub fn install_plan(harness_version: impl Into<String>) -> InstallPlan {
         "# NAOME local machine-owned harness files.",
         ".naome/archive/",
         ".naome/bin/naome-rust*",
+        ".naome/cache/",
         ".naome/task-journal.jsonl",
     ];
     git_exclude_entries.extend_from_slice(LOCAL_ONLY_MACHINE_OWNED_PATHS);

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

@@ -21,10 +21,13 @@ pub use intent::{evaluate_intent, format_intent, IntentDecision, PromptEvidence}
 pub use journal::{append_task_journal, TaskJournalEntry};
 pub use models::{Decision, NaomeError};
 pub use quality::{
-    check_repository_quality, explain_repository_structure, init_repository_quality,
-    plan_quality_cleanup, route_quality_cleanup, QualityCleanupPlan, QualityCleanupRoute,
-    QualityCleanupTask, QualityInitResult, QualityMode, QualityReport, QualitySummary,
-    QualityViolation, RepositoryQualityConfig, RepositoryStructureConfig, StructurePathExplanation,
+    check_repository_quality, check_semantic_legacy, explain_repository_structure,
+    clear_quality_cache, init_repository_quality, init_repository_quality_with_mode,
+    plan_quality_cleanup, quality_cache_status, route_quality_cleanup,
+    semantic_route_for_finding, QualityCacheStatus, QualityCleanupPlan, QualityCleanupRoute,
+    QualityCleanupTask, QualityInitMode, QualityInitResult, QualityMode, QualityReport,
+    QualitySummary, QualityViolation, RepositoryQualityConfig, RepositoryStructureConfig,
+    SemanticFinding, SemanticReport, StructurePathExplanation,
 };
 pub use route::{evaluate_route, explain_route, ExplainDecision, RouteDecision, RouteOptions};
 pub use task_state::{
@@ -34,8 +37,9 @@ pub use task_state::{
 pub use verification::seed_builtin_verification_checks;
 pub use verification_contract::validate_verification_contract;
 pub use workflow::{
-    classify_mutations, refresh_integrity, safe_rg_args, summarize_command_output,
+    classify_mutations, doctor_report, refresh_integrity, safe_rg_args, summarize_command_output,
     tracked_process_report, validate_read_boundaries, validate_search_command,
-    verification_phase_plan, CommandCheckResult, CommandOutputSummary, IntegrityRefreshReport,
-    MutationClassification, ProcessReport, ReadActivity, VerificationPhasePlan, WorkflowFinding,
+    verification_phase_plan, CommandCheckResult, CommandOutputSummary, DoctorReport, DoctorSection,
+    IntegrityRefreshReport, MutationClassification, ProcessReport, ReadActivity,
+    RepositoryPolicySection, VerificationPhasePlan, WorkflowFinding,
 };

package/crates/naome-core/src/quality/baseline.rs

@@ -73,3 +73,11 @@ pub fn write_baseline(root: &Path, violations: &[QualityViolation]) -> Result<bo
     }
     Ok(changed)
 }
+
+pub fn write_empty_baseline_if_missing(root: &Path) -> Result<bool, NaomeError> {
+    let path = root.join(BASELINE_RELATIVE_PATH);
+    if path.is_file() {
+        return Ok(false);
+    }
+    write_baseline(root, &[])
+}

package/crates/naome-core/src/quality/cache.rs

@@ -0,0 +1,153 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+
+use crate::models::NaomeError;
+
+use super::scanner::FileAnalysis;
+use super::types::RepositoryQualityConfig;
+
+const CACHE_RELATIVE_PATH: &str = ".naome/cache/quality";
+const CACHE_SCHEMA: &str = "naome.quality-cache-entry.v1";
+const ADAPTER_VERSION: &str = "quality-core-v1";
+
+#[derive(Debug, Clone)]
+pub(crate) struct QualityCache {
+    root: PathBuf,
+    config_hash: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct CacheEntry {
+    schema: String,
+    naome_version: String,
+    config_hash: String,
+    adapter_version: String,
+    path: String,
+    content_hash: String,
+    analysis: FileAnalysis,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QualityCacheStatus {
+    pub schema: String,
+    pub path: String,
+    pub entry_count: usize,
+    pub bytes: u64,
+}
+
+impl QualityCache {
+    pub(crate) fn new(root: &Path, config: &RepositoryQualityConfig) -> Self {
+        Self {
+            root: root.to_path_buf(),
+            config_hash: config_hash(config),
+        }
+    }
+
+    pub(crate) fn read(&self, path: &str, content_hash: &str) -> Option<FileAnalysis> {
+        let entry = fs::read_to_string(self.entry_path(path, content_hash)).ok()?;
+        let entry: CacheEntry = serde_json::from_str(&entry).ok()?;
+        if entry.schema == CACHE_SCHEMA
+            && entry.naome_version == env!("CARGO_PKG_VERSION")
+            && entry.config_hash == self.config_hash
+            && entry.adapter_version == ADAPTER_VERSION
+            && entry.path == path
+            && entry.content_hash == content_hash
+        {
+            Some(entry.analysis)
+        } else {
+            None
+        }
+    }
+
+    pub(crate) fn write(
+        &self,
+        path: &str,
+        content_hash: &str,
+        analysis: &FileAnalysis,
+    ) -> Result<(), NaomeError> {
+        let cache_path = self.entry_path(path, content_hash);
+        if let Some(parent) = cache_path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        let entry = CacheEntry {
+            schema: CACHE_SCHEMA.to_string(),
+            naome_version: env!("CARGO_PKG_VERSION").to_string(),
+            config_hash: self.config_hash.clone(),
+            adapter_version: ADAPTER_VERSION.to_string(),
+            path: path.to_string(),
+            content_hash: content_hash.to_string(),
+            analysis: analysis.clone(),
+        };
+        let content = format!("{}\n", serde_json::to_string(&entry)?);
+        if fs::read_to_string(&cache_path).map_or(true, |current| current != content) {
+            fs::write(cache_path, content)?;
+        }
+        Ok(())
+    }
+
+    fn entry_path(&self, path: &str, content_hash: &str) -> PathBuf {
+        self.root
+            .join(CACHE_RELATIVE_PATH)
+            .join(stable_key(&[
+                env!("CARGO_PKG_VERSION"),
+                &self.config_hash,
+                ADAPTER_VERSION,
+                path,
+                content_hash,
+            ]))
+    }
+}
+
+pub fn quality_cache_status(root: &Path) -> Result<QualityCacheStatus, NaomeError> {
+    let path = root.join(CACHE_RELATIVE_PATH);
+    let mut entry_count = 0;
+    let mut bytes = 0;
+    if path.is_dir() {
+        for entry in fs::read_dir(&path)? {
+            let entry = entry?;
+            let metadata = entry.metadata()?;
+            if metadata.is_file() {
+                entry_count += 1;
+                bytes += metadata.len();
+            }
+        }
+    }
+    Ok(QualityCacheStatus {
+        schema: "naome.quality-cache-status.v1".to_string(),
+        path: CACHE_RELATIVE_PATH.to_string(),
+        entry_count,
+        bytes,
+    })
+}
+
+pub fn clear_quality_cache(root: &Path) -> Result<QualityCacheStatus, NaomeError> {
+    let path = root.join(CACHE_RELATIVE_PATH);
+    if path.exists() {
+        fs::remove_dir_all(&path)?;
+    }
+    quality_cache_status(root)
+}
+
+pub(crate) fn content_hash(content: &str) -> String {
+    stable_key(&[content])
+}
+
+fn config_hash(config: &RepositoryQualityConfig) -> String {
+    serde_json::to_string(config)
+        .map(|content| stable_key(&[&content]))
+        .unwrap_or_else(|_| stable_key(&["invalid-config"]))
+}
+
+fn stable_key(parts: &[&str]) -> String {
+    let mut hasher = Sha256::new();
+    for part in parts {
+        hasher.update(part.as_bytes());
+        hasher.update(b"\0");
+    }
+    format!("{:x}.json", hasher.finalize())
+}

package/crates/naome-core/src/quality/checks/duplicate_blocks.rs

@@ -1,6 +1,8 @@
 use std::collections::{HashMap, HashSet};
 
-use super::super::scanner::{stable_fingerprint, QualityContext};
+use sha2::{Digest, Sha256};
+
+use super::super::scanner::{stable_fingerprint, NormalizedLine, QualityContext};
 use super::super::types::QualityViolation;
 use super::{is_code_like_path, QualityCheck};
 
@@ -12,22 +14,23 @@ impl QualityCheck for DuplicateBlockCheck {
     }
 
     fn evaluate(&self, context: &QualityContext, violations: &mut Vec<QualityViolation>) {
+        if context.mode == super::super::types::QualityMode::Report {
+            return;
+        }
         let mut occurrences: HashMap<String, Vec<DuplicateOccurrence>> = HashMap::new();
-        for file in context.files.iter().filter(|file| {
-            is_code_like_path(&file.path)
-                && context.config.check_enabled_for_path(self.id(), &file.path)
-        }) {
+        for file in context
+            .comparison_candidate_files()
+            .filter(|file| {
+                is_code_like_path(&file.path)
+                    && context.config.check_enabled_for_path(self.id(), &file.path)
+            })
+        {
             let window = context.limits_for(&file.path).duplicate_block_lines;
             if file.normalized_lines.len() < window {
                 continue;
             }
             for lines in file.normalized_lines.windows(window) {
-                let joined = lines
-                    .iter()
-                    .map(|line| line.value.as_str())
-                    .collect::<Vec<_>>()
-                    .join("\n");
-                let fingerprint = stable_fingerprint(&[self.id(), &joined]);
+                let fingerprint = window_fingerprint(self.id(), lines);
                 occurrences
                     .entry(fingerprint.clone())
                     .or_default()
@@ -72,6 +75,17 @@ impl QualityCheck for DuplicateBlockCheck {
     }
 }
 
+fn window_fingerprint(check_id: &str, lines: &[NormalizedLine]) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(check_id.as_bytes());
+    hasher.update(b"\0");
+    for line in lines {
+        hasher.update(line.value.as_bytes());
+        hasher.update(b"\n");
+    }
+    format!("sha256:{:x}", hasher.finalize())
+}
+
 #[derive(Debug, Clone)]
 struct DuplicateOccurrence {
     path: String,

package/crates/naome-core/src/quality/checks/near_duplicates.rs

@@ -12,6 +12,9 @@ impl QualityCheck for NearDuplicateFunctionCheck {
     }
 
     fn evaluate(&self, context: &QualityContext, violations: &mut Vec<QualityViolation>) {
+        if context.mode == super::super::types::QualityMode::Report {
+            return;
+        }
         let symbols = collect_function_occurrences(context, self.id());
         let mut emitted = HashSet::new();
 
@@ -59,8 +62,7 @@ fn collect_function_occurrences<'a>(
     check_id: &str,
 ) -> Vec<FunctionOccurrence<'a>> {
     context
-        .files
-        .iter()
+        .comparison_candidate_files()
         .filter(|file| {
             is_code_like_path(&file.path)
                 && context.config.check_enabled_for_path(check_id, &file.path)

package/crates/naome-core/src/quality/checks.rs

@@ -4,7 +4,7 @@ mod near_duplicates;
 use std::collections::HashSet;
 
 use super::scanner::{stable_fingerprint, QualityContext};
-use super::types::{QualityMode, QualityViolation};
+use super::types::QualityViolation;
 use duplicate_blocks::DuplicateBlockCheck;
 use near_duplicates::NearDuplicateFunctionCheck;
 
@@ -64,12 +64,11 @@ impl QualityCheck for FileLengthCheck {
             .filter(|file| context.check_applies_to(self.id(), &file.path))
         {
             let limits = context.limits_for(&file.path);
-            let limit =
-                if context.mode == QualityMode::Changed && file.added_lines == file.line_count {
-                    limits.max_new_file_lines
-                } else {
-                    limits.max_file_lines
-                };
+            let limit = if context.mode.is_changed() && file.added_lines == file.line_count {
+                limits.max_new_file_lines
+            } else {
+                limits.max_file_lines
+            };
             if file.line_count > limit {
                 violations.push(violation(
                     self.id(),
@@ -96,7 +95,7 @@ impl QualityCheck for DiffGrowthCheck {
     }
 
     fn evaluate(&self, context: &QualityContext, violations: &mut Vec<QualityViolation>) {
-        if context.mode != QualityMode::Changed {
+        if !context.mode.is_changed() {
             return;
         }
         for file in context

package/crates/naome-core/src/quality/cleanup.rs

@@ -68,17 +68,50 @@ pub fn cleanup_route_for_path(
     } else {
         "repository quality"
     };
+    let agent_instructions = cleanup_instructions(path, topic, &violations);
     QualityCleanupRoute {
         schema: "naome.quality-cleanup-route.v1".to_string(),
         path: path.to_string(),
         violations,
         related_paths,
-        agent_instructions: format!(
-            "Reduce or split {path} until every {topic} violation is gone. Prefer named modules and reusable helpers/components over dumping logic into generic directories. Keep behavior unchanged, add or preserve focused tests, then run naome quality check --changed before task completion."
-        ),
+        agent_instructions,
         required_checks: vec![
             "naome quality check --changed".to_string(),
             "git diff --check".to_string(),
         ],
     }
 }
+
+fn cleanup_instructions(path: &str, topic: &str, violations: &[QualityViolation]) -> String {
+    let mut instructions = Vec::new();
+    instructions.push(format!(
+        "Clean up {path} until every {topic} violation is gone while preserving behavior."
+    ));
+    for check_id in violations
+        .iter()
+        .map(|violation| violation.check_id.as_str())
+        .collect::<BTreeSet<_>>()
+    {
+        instructions.push(match check_id {
+            "test-source-pairing" => "Create or update a nearby or module-matched test that exercises the changed source behavior.".to_string(),
+            "dumping-ground-directory" => "Move feature logic out of generic utils/helpers/common/shared directories into a named module, or extract a reusable helper with a clear owner.".to_string(),
+            "directory-role-mixing" => "Separate source, generated, artifact, and dependency/vendor roles into directories that match repository policy.".to_string(),
+            "misplaced-file-role" => "Move the file to a configured root for its role, such as source, test, docs, config, or script.".to_string(),
+            "root-file-sprawl" => "Move new root-level work into an existing module, docs, config, or script directory unless it is a recognized root manifest.".to_string(),
+            "directory-size" => "Split the directory by module or responsibility until direct file count is below the configured limit.".to_string(),
+            "path-depth" => "Shorten the path by moving the file closer to its owning module boundary.".to_string(),
+            "case-collision" => "Rename colliding paths so they are distinct on case-insensitive filesystems.".to_string(),
+            "file-length" => "Reduce or split the file into focused modules with stable public behavior.".to_string(),
+            "function-length" => "Extract cohesive helper functions or components until each function fits the configured limit.".to_string(),
+            "top-level-symbols" => "Group related symbols into smaller modules and export only the intended public surface.".to_string(),
+            "duplicate-block" | "near-duplicate-function" => "Extract shared behavior into a reusable helper, fixture, builder, or component used by all duplicate call sites.".to_string(),
+            "diff-growth" => "Reduce the diff by narrowing scope, splitting generated changes, or moving unrelated cleanup to a separate task.".to_string(),
+            _ => format!("Resolve the {check_id} finding without weakening generic policy."),
+        });
+    }
+    instructions.push(
+        "Run naome quality check --changed and git diff --check before task completion."
+            .to_string(),
+    );
+    instructions.join(" ")
+}

package/crates/naome-core/src/quality/mod.rs

@@ -1,11 +1,13 @@
 mod adapter_support;
 mod adapters;
 mod baseline;
+mod cache;
 mod checks;
 mod cleanup;
 mod config;
 mod config_support;
 mod scanner;
+mod semantic;
 mod structure;
 mod types;
 
@@ -14,18 +16,26 @@ use std::path::Path;
 use crate::models::NaomeError;
 
 pub use cleanup::{cleanup_plan_from_violations, cleanup_route_for_path};
+pub use cache::{clear_quality_cache, quality_cache_status, QualityCacheStatus};
+pub use semantic::{semantic_route_for_finding, SemanticFinding, SemanticReport};
 pub use structure::{
     explain_repository_structure, RepositoryStructureConfig, StructurePathExplanation,
 };
 pub use types::{
-    QualityCleanupPlan, QualityCleanupRoute, QualityCleanupTask, QualityInitResult, QualityMode,
-    QualityReport, QualitySummary, QualityViolation, RepositoryQualityConfig,
+    QualityCleanupPlan, QualityCleanupRoute, QualityCleanupTask, QualityInitMode,
+    QualityInitResult, QualityMode, QualityReport, QualitySummary, QualityViolation,
+    RepositoryQualityConfig,
 };
 
-use self::baseline::{baseline_relative_path, read_baseline_fingerprints, write_baseline};
+use self::baseline::{
+    baseline_relative_path, read_baseline_fingerprints, write_baseline,
+    write_empty_baseline_if_missing,
+};
 use self::checks::run_quality_checks;
 use self::config::{config_relative_path, read_config, write_default_config_if_missing};
+use self::scanner::collect_repo_paths;
 use self::scanner::scan_repository;
+use self::semantic::run_semantic_checks;
 use self::structure::{
     run_repository_structure_checks, structure_config_relative_path,
     write_default_structure_config_if_missing,
@@ -49,6 +59,10 @@ pub fn check_repository_quality(
         .filter(|violation| violation.baseline)
         .count();
     let ok = blocking_violation_count == 0;
+    let mut reason_codes = context.reason_codes.clone();
+    if mode == QualityMode::Report {
+        reason_codes.push("deep_checks_skipped".to_string());
+    }
 
     Ok(QualityReport {
         schema: "naome.repository-quality-report.v1".to_string(),
@@ -58,30 +72,58 @@ pub fn check_repository_quality(
         scanned_paths: context.scanned_paths(),
         summary: QualitySummary {
             scanned_files: context.files.len(),
+            scanned_path_count: context.scanned_paths().len(),
             violation_count: violations.len(),
             baseline_violation_count,
             blocking_violation_count,
+            truncated: context.truncated,
+            reason_codes,
+            cache_hits: context.cache_hits,
+            cache_misses: context.cache_misses,
         },
         violations,
     })
 }
 
 pub fn init_repository_quality(root: &Path) -> Result<QualityInitResult, NaomeError> {
+    init_repository_quality_with_mode(root, QualityInitMode::SeedOnly)
+}
+
+pub fn init_repository_quality_with_mode(
+    root: &Path,
+    mode: QualityInitMode,
+) -> Result<QualityInitResult, NaomeError> {
     let config_written = write_default_config_if_missing(root)?;
     let structure_config_written = {
-        let config = read_config(root)?;
-        let context = scan_repository(root, QualityMode::Report, config)?;
-        write_default_structure_config_if_missing(root, &context.repo_paths)?
+        let repo_paths = collect_repo_paths(root)?;
+        write_default_structure_config_if_missing(root, &repo_paths)?
+    };
+    let (baseline_written, baseline_violations, baseline_pending) = match mode {
+        QualityInitMode::SeedOnly => {
+            write_empty_baseline_if_missing(root)?;
+            (false, 0, true)
+        }
+        QualityInitMode::Baseline | QualityInitMode::DeepBaseline => {
+            let report = check_repository_quality(
+                root,
+                if mode == QualityInitMode::DeepBaseline {
+                    QualityMode::DeepReport
+                } else {
+                    QualityMode::Report
+                },
+            )?;
+            (write_baseline(root, &report.violations)?, report.violations.len(), false)
+        }
     };
-    let report = check_repository_quality(root, QualityMode::Report)?;
-    let baseline_written = write_baseline(root, &report.violations)?;
 
     Ok(QualityInitResult {
         schema: "naome.repository-quality-init.v1".to_string(),
+        mode: mode.as_str().to_string(),
         config_written,
         structure_config_written,
         baseline_written,
-        baseline_violations: report.violations.len(),
+        baseline_pending,
+        baseline_violations,
         config_path: config_relative_path().to_string(),
         structure_config_path: structure_config_relative_path().to_string(),
         baseline_path: baseline_relative_path().to_string(),
@@ -106,3 +148,9 @@ pub fn route_quality_cleanup(
         .collect::<Vec<_>>();
     Ok(cleanup_route_for_path(&path, violations))
 }
+
+pub fn check_semantic_legacy(root: &Path, mode: QualityMode) -> Result<SemanticReport, NaomeError> {
+    let config = read_config(root)?;
+    let context = scan_repository(root, mode, config)?;
+    Ok(run_semantic_checks(&context))
+}

package/crates/naome-core/src/quality/scanner/analysis/normalize.rs

@@ -0,0 +1,78 @@
+pub(super) fn normalize_line(line: &str) -> Option<String> {
+    let trimmed = line.trim();
+    if trimmed.is_empty()
+        || is_comment_only(trimmed)
+        || is_string_list_item(trimmed)
+        || is_generated_hash_mapping(trimmed)
+    {
+        return None;
+    }
+
+    let mut normalized = String::new();
+    let mut in_string = false;
+    let mut quote = '\0';
+    let mut previous_space = false;
+    for character in trimmed.chars() {
+        if in_string {
+            if character == quote {
+                in_string = false;
+                normalized.push('S');
+                previous_space = false;
+            }
+            continue;
+        }
+        if character == '"' || character == '\'' || character == '`' {
+            in_string = true;
+            quote = character;
+            continue;
+        }
+        let next = if character.is_ascii_digit() {
+            '0'
+        } else if character.is_whitespace() {
+            ' '
+        } else {
+            character.to_ascii_lowercase()
+        };
+        if next == ' ' {
+            if !previous_space {
+                normalized.push(next);
+            }
+            previous_space = true;
+        } else {
+            normalized.push(next);
+            previous_space = false;
+        }
+    }
+    let value = normalized.trim().to_string();
+    (!value.is_empty()).then_some(value)
+}
+
+pub(super) fn token_set(line: &str) -> Vec<String> {
+    line.split(|character: char| !character.is_ascii_alphanumeric() && character != '_')
+        .filter(|token| token.len() > 1)
+        .map(ToString::to_string)
+        .collect()
+}
+
+fn is_comment_only(trimmed: &str) -> bool {
+    trimmed.starts_with("//")
+        || trimmed.starts_with('#')
+        || trimmed.starts_with("/*")
+        || trimmed.starts_with('*')
+        || trimmed.starts_with("--")
+}
+
+fn is_generated_hash_mapping(trimmed: &str) -> bool {
+    let Some((key, value)) = trimmed.split_once(':') else {
+        return false;
+    };
+    key.trim_start().starts_with('"')
+        && value.trim_start().starts_with("\"sha256:")
+        && value.chars().filter(|character| *character == '"').count() >= 2
+}
+
+fn is_string_list_item(trimmed: &str) -> bool {
+    let value = trimmed.trim_end_matches(',');
+    (value.starts_with('"') && value.ends_with('"'))
+        || (value.starts_with('\'') && value.ends_with('\''))
+}