project-iris 0.0.6

package/dist/commands/doctor.js

@@ -0,0 +1,102 @@
+import { Command } from "commander";
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import kleur from "kleur";
+function checkmark(condition) {
+    return condition ? kleur.green("✓") : kleur.red("✗");
+}
+function getNodeVersion() {
+    return process.version;
+}
+function getNpmVersion() {
+    try {
+        return execSync("npm --version", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return "unknown";
+    }
+}
+function getNpmPrefix() {
+    try {
+        return execSync("npm prefix -g", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return "unknown";
+    }
+}
+function isInPath(dir) {
+    const pathEnv = process.env.PATH || "";
+    const paths = pathEnv.split(":");
+    return paths.includes(dir);
+}
+export const doctorCommand = new Command("doctor")
+    .description("Diagnose environment and PATH issues for navi")
+    .action(() => {
+    const root = process.cwd();
+    const cliPath = path.join(root, "dist/cli.js");
+    const cliExists = fs.existsSync(cliPath);
+    const nodeVersion = getNodeVersion();
+    const npmVersion = getNpmVersion();
+    const npmPrefix = getNpmPrefix();
+    const globalBinDir = npmPrefix !== "unknown" ? path.join(npmPrefix, "bin") : "unknown";
+    const naviLinkPath = globalBinDir !== "unknown" ? path.join(globalBinDir, "navi") : "unknown";
+    const naviLinkExists = naviLinkPath !== "unknown" && fs.existsSync(naviLinkPath);
+    const binInPath = globalBinDir !== "unknown" && isInPath(globalBinDir);
+    console.log("");
+    console.log(kleur.bold("IRIS Doctor - Environment Diagnostics"));
+    console.log("=====================================");
+    console.log("");
+    // System info
+    console.log(kleur.bold("System:"));
+    console.log(`${checkmark(true)} Node.js:     ${nodeVersion}`);
+    console.log(`${checkmark(npmVersion !== "unknown")} npm:         ${npmVersion}`);
+    console.log(`${checkmark(true)} Repo root:   ${root}`);
+    console.log(`${checkmark(cliExists)} CLI built:   ${cliExists ? "dist/cli.js exists" : "dist/cli.js MISSING"}`);
+    console.log("");
+    if (!cliExists) {
+        console.log(kleur.yellow("⚠ Action Required:"));
+        console.log("  Build the CLI first:");
+        console.log(kleur.cyan("    npm run build"));
+        console.log("");
+    }
+    // Global installation
+    console.log(kleur.bold("Global Installation:"));
+    console.log(`${checkmark(npmPrefix !== "unknown")} npm prefix:  ${npmPrefix}`);
+    console.log(`${checkmark(globalBinDir !== "unknown")} bin dir:     ${globalBinDir}`);
+    console.log(`${checkmark(binInPath)} In PATH:     ${binInPath ? "YES" : "NO"}`);
+    console.log(`${checkmark(naviLinkExists)} navi link:   ${naviLinkExists ? `${naviLinkPath} → exists` : `${naviLinkPath} → NOT FOUND`}`);
+    console.log("");
+    // Actionable guidance
+    const hasIssues = !cliExists || !binInPath || !naviLinkExists;
+    if (hasIssues) {
+        console.log(kleur.yellow("⚠ Action Required:"));
+        console.log("");
+        if (!naviLinkExists && cliExists) {
+            console.log("  Link navi globally:");
+            console.log(kleur.cyan("    npm run link:navi"));
+            console.log("");
+        }
+        if (!binInPath && globalBinDir !== "unknown") {
+            console.log("  Add global bin to PATH:");
+            console.log(kleur.cyan(`    export PATH="${globalBinDir}:$PATH"`));
+            console.log("");
+            console.log("  Then reload shell:");
+            console.log(kleur.cyan("    source ~/.zshrc && hash -r"));
+            console.log("");
+        }
+    }
+    else {
+        console.log(kleur.green("✓ Everything looks good!"));
+        console.log("");
+        console.log("  You can run navi globally:");
+        console.log(kleur.cyan("    navi --version"));
+        console.log(kleur.cyan("    navi validate"));
+        console.log("");
+    }
+    // Additional tips
+    console.log(kleur.dim("Tips:"));
+    console.log(kleur.dim("  - Run 'type -a navi' to see which navi resolves"));
+    console.log(kleur.dim("  - Use 'npm run navi -- <command>' for repo-local execution"));
+    console.log("");
+});

package/dist/commands/install.js

@@ -0,0 +1,57 @@
+import { Command } from "commander";
+import inquirer from "inquirer";
+import kleur from "kleur";
+import { repoRoot } from "../lib.js";
+import { detectTools, installIris, TOOLS } from "../iris/installer.js";
+import { setSelectedIde } from "../iris/state.js";
+export const installCommand = new Command("install")
+    .description("Install IRIS doctrine under .iris and install tool commands into this repo (interactive).")
+    .action(async () => {
+    const root = repoRoot();
+    // Step A: Detect
+    const defaults = detectTools(root);
+    // If defaults empty, fallback to Claude + Cursor
+    const defaultSelection = defaults.length > 0 ? defaults : ["claude", "cursor"];
+    // Step B: Prompt
+    const { tools } = await inquirer.prompt([
+        {
+            type: "checkbox",
+            name: "tools",
+            message: "Select the tool(s) you will use with IRIS in this repository:",
+            choices: TOOLS.map(t => ({
+                name: t.charAt(0).toUpperCase() + t.slice(1), // Capitalize
+                value: t,
+                checked: defaultSelection.includes(t)
+            })),
+            validate: (arr) => (arr.length ? true : "Select at least one tool."),
+        },
+    ]);
+    console.log("");
+    console.log(kleur.bold("Installing IRIS..."));
+    // Step C-G: Core Installer
+    await installIris(root, tools);
+    // Persist IDE selection for navi develop
+    // Use first tool as default IDE, or prompt if multiple
+    let selectedIde = tools[0];
+    if (tools.length > 1) {
+        const { ide } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "ide",
+                message: "Which IDE will you primarily use with 'navi develop'?",
+                choices: tools.map(t => ({
+                    name: t.charAt(0).toUpperCase() + t.slice(1),
+                    value: t
+                }))
+            }
+        ]);
+        selectedIde = ide;
+    }
+    setSelectedIde(selectedIde);
+    console.log("");
+    console.log(kleur.bold().green("IRIS install complete."));
+    console.log(kleur.gray("Doctrine: .iris/aidlc"));
+    console.log(kleur.gray("Policy:  .iris/policy.yaml"));
+    console.log(kleur.gray(`Tools:   ${tools.join(", ")}`));
+    console.log(kleur.gray(`Primary IDE: ${selectedIde}`));
+});

package/dist/commands/pack.js

@@ -0,0 +1,27 @@
+import { Command } from "commander";
+import { generatePack } from "../iris/packer.js";
+function collect(value, previous) {
+    return previous.concat([value]);
+}
+export const packCommand = new Command("pack")
+    .description("Generate a deterministic context bundle (markdown) for an agent.")
+    .option("--agent <agent>", "Target agent (inception|construction|operations|master)")
+    .option("--phase <phase>", "Target phase (overrides state.phase.current)")
+    .option("--out <path>", "Output file path (default: .iris/inbox/context-pack.<agent>.<phase>.md)")
+    .option("--stdout", "Print bundle to stdout instead of writing file", false)
+    .option("--strict", "Fail on validation warnings", false)
+    .option("--max-bytes <n>", "Maximum size in bytes", (val) => parseInt(val, 10), 1_500_000)
+    .option("--include <glob>", "Glob pattern to include files (repeatable)", collect, [])
+    .option("--exclude <glob>", "Glob pattern to exclude files (repeatable)", collect, [])
+    .action(async (opts) => {
+    await generatePack({
+        agent: opts.agent,
+        phase: opts.phase,
+        output: opts.out,
+        stdout: opts.stdout,
+        strict: opts.strict,
+        maxBytes: opts.maxBytes,
+        includes: opts.include,
+        excludes: opts.exclude
+    });
+});

package/dist/commands/phase.js

@@ -0,0 +1,38 @@
+import { Command } from "commander";
+import kleur from "kleur";
+import { loadState, saveState } from "../iris/state.js";
+import { loadPolicy } from "../iris/policy.js";
+import { EXIT_CODES } from "../utils/exit-codes.js";
+export const phaseCommand = new Command("phase")
+    .description("Manage IRIS lifecycle phases");
+phaseCommand
+    .command("set")
+    .description("Request a transition to a new phase")
+    .argument("<phase>", "The target phase to transition to")
+    .action((phaseName) => {
+    // 1. Validate phase exists in policy
+    const policy = loadPolicy();
+    if (!policy.phases[phaseName]) {
+        console.error(kleur.red(`Error: Phase '${phaseName}' is not defined in policy.`));
+        console.log("Available phases: " + Object.keys(policy.phases).join(", "));
+        process.exit(EXIT_CODES.POLICY_ERROR);
+    }
+    // 2. Load state
+    const state = loadState();
+    // 3. Write request
+    state.phase.requested = phaseName;
+    try {
+        saveState(state);
+    }
+    catch (e) {
+        console.error(kleur.red("Failed to save state."));
+        process.exit(EXIT_CODES.STATE_ERROR);
+    }
+    // 4. Print output
+    console.log("");
+    console.log(`Current Phase:   ${kleur.cyan(state.phase.current)}`);
+    console.log(`Requested Phase: ${kleur.yellow(state.phase.requested || "")}`);
+    console.log("");
+    console.log(kleur.bold("Next: ") + "Run " + kleur.green("navi validate --apply") + " to commit this transition.");
+    console.log("");
+});

package/dist/commands/run.js

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import kleur from "kleur";
+import { requireValidRepoOrExit } from "../iris/guard.js";
+import { EXIT_CODES } from "../utils/exit-codes.js";
+export const runCommand = new Command("run")
+    .description("Execute a named workflow or agent (Placeholder)")
+    .argument("<name>", "Name of the workflow/agent to run")
+    .option("--strict", "Enforce strict validation (warnings become errors)", false)
+    .action(async (name, options) => {
+    // GUARDRAIL
+    await requireValidRepoOrExit({ strict: options.strict });
+    // If we are here, repo is valid (or warnings ignored)
+    console.log("");
+    console.log(kleur.green(`✅  Guards passed. Would run: ${name}`));
+    console.log("");
+    process.exit(EXIT_CODES.SUCCESS);
+});

package/dist/commands/status.js

@@ -0,0 +1,105 @@
+import { Command } from "commander";
+import fs from "fs";
+import path from "path";
+import kleur from "kleur";
+import { validate } from "../iris/validator.js";
+import { loadState, DEFAULT_STATE } from "../iris/state.js";
+import { EXIT_CODES } from "../utils/exit-codes.js";
+function getIrisStatus() {
+    const root = process.cwd();
+    const policyPath = path.join(root, ".iris/policy.yaml");
+    const doctrinePath = path.join(root, ".iris/aidlc");
+    return {
+        policy: fs.existsSync(policyPath),
+        doctrine: fs.existsSync(doctrinePath)
+    };
+}
+export const statusCommand = new Command("status")
+    .description("Show IRIS validation status (informational)")
+    .option("--json", "Output result as JSON", false)
+    .action(async (options) => {
+    // 1. Check basic presence
+    const presence = getIrisStatus();
+    // 2. Run validator in read-only mode
+    // We catch errors here because status command should be safe and always exit 0
+    let result = null;
+    let error = null;
+    try {
+        result = await validate({
+            apply: false,
+            strict: false,
+            writeBack: false // Do not mutate state
+        });
+    }
+    catch (e) {
+        error = e;
+    }
+    // 3. Load state manually just for reporting if validate failed completely
+    let state = DEFAULT_STATE;
+    try {
+        state = loadState();
+    }
+    catch (e) {
+        // failed to load state, use defaults
+    }
+    if (options.json) {
+        const jsonOutput = {
+            policy: { ok: presence.policy },
+            doctrine: { ok: presence.doctrine },
+            phase: {
+                current: result ? result.phase.current : state.phase.current,
+                requested: result ? result.phase.requested : state.phase.requested
+            },
+            last_validation: result ? state.last_validation : null,
+            summary: result ? {
+                result: result.valid ? "valid" : "invalid",
+                errors_count: result.errors.length,
+                warnings_count: result.warnings ? 1 : 0, // simplistic
+                top_errors: result.errors
+            } : { error: "Validation failed to run" }
+        };
+        console.log(JSON.stringify(jsonOutput, null, 2));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    // Human Output
+    console.log("");
+    console.log(kleur.bold("IRIS Status"));
+    console.log(`- Policy:   ${presence.policy ? kleur.green("OK") : kleur.red("MISSING")} (.iris/policy.yaml)`);
+    console.log(`- Doctrine: ${presence.doctrine ? kleur.green("OK") : kleur.red("MISSING")} (.iris/aidlc)`);
+    if (result) {
+        console.log(`- Phase:    ${kleur.cyan(result.phase.current)}`);
+        if (result.phase.requested) {
+            console.log(`- Requested:${kleur.yellow(result.phase.requested)}`);
+        }
+        // Show validation result
+        const validity = result.valid
+            ? kleur.green("VALID")
+            : kleur.red("INVALID");
+        console.log(`- Last val.:  ${validity} (dry-run just now)`);
+        if (!result.valid && result.errors.length > 0) {
+            console.log("");
+            console.log(kleur.bold(`Issues (showing top ${Math.min(5, result.errors.length)}/${result.errors.length})`));
+            result.errors.slice(0, 5).forEach((err, idx) => {
+                console.log(kleur.yellow(`${idx + 1}) [${err.code}] ${err.path || ""}`));
+                if (err.remediation)
+                    console.log(`   Fix: ${kleur.dim(err.remediation)}`);
+            });
+            if (result.errors.length > 5) {
+                console.log(kleur.dim(`... and ${result.errors.length - 5} more.`));
+            }
+            console.log("");
+            console.log(kleur.dim("Hint: Run `navi validate` for full details."));
+        }
+        else {
+            console.log("");
+            console.log(kleur.green("System is healthy."));
+        }
+    }
+    else {
+        console.log(kleur.red("Validation engine failed to run."));
+        if (error)
+            console.log(error);
+    }
+    console.log("");
+    process.exit(EXIT_CODES.SUCCESS);
+});

package/dist/commands/uninstall.js

@@ -0,0 +1,12 @@
+import { Command } from "commander";
+import { uninstallIris } from "../iris/uninstaller.js";
+export const uninstallCommand = new Command("uninstall")
+    .description("Remove .iris and tool command files installed by IRIS (manifest-driven).")
+    .option("--keep-memory", "Keep memory-bank folder if present", false)
+    .option("--force", "Skip confirmations where possible", false)
+    .action(async (opts) => {
+    await uninstallIris({
+        keepMemory: opts.keepMemory,
+        force: opts.force
+    });
+});

package/dist/commands/validate.js

@@ -0,0 +1,87 @@
+import { Command } from "commander";
+import kleur from "kleur";
+import { validate } from "../iris/validator.js";
+import { printReport } from "../iris/report.js";
+import { collectFixPlan, applyFixPlan } from "../iris/fixer.js";
+import { EXIT_CODES } from "../utils/exit-codes.js";
+export const validateCommand = new Command("validate")
+    .description("Validate the current repository state against the IRIS policy.")
+    .option("--apply", "Automatically apply requested phase changes if valid.")
+    .option("--phase <phase>", "Override the target phase to validate against.")
+    .option("--strict", "Fail on warnings as well as errors.")
+    .option("--json", "Output results as JSON.")
+    .option("--fix", "Attempt to fix missing artifacts automatically.")
+    .option("--fix-dry-run", "Show what would be fixed without making changes.")
+    .option("--yes", "Automatically confirm overwrites (if any).")
+    .action(async (options) => {
+    // 1. First Validation Pass
+    if (!options.fix && !options.fixDryRun) {
+        const result = await validate({
+            apply: options.apply || false,
+            phase: options.phase,
+            strict: options.strict || false,
+        });
+        printReport(result, options.json, undefined, options.strict);
+        let exitCode = EXIT_CODES.SUCCESS;
+        if (!result.valid) {
+            exitCode = EXIT_CODES.INVALID;
+        }
+        else if (options.strict && result.warnings) {
+            exitCode = EXIT_CODES.VALID_WITH_WARNINGS;
+        }
+        process.exit(exitCode);
+    }
+    // 2. Fix Mode
+    // Pass 1: Discovery
+    const result1 = await validate({
+        apply: false,
+        phase: options.phase,
+        strict: options.strict || false,
+        writeBack: false
+    });
+    if (result1.valid && !result1.warnings) {
+        if (options.json) {
+            printReport(result1, true);
+        }
+        else {
+            console.log(kleur.green("✓ Repository is valid. No fixes needed."));
+        }
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    // Collect Plan
+    const plan = collectFixPlan(result1);
+    if (plan.actions.length === 0) {
+        if (options.json) {
+            printReport(result1, true);
+        }
+        else {
+            console.log(kleur.yellow("No fixable missing artifacts found."));
+            printReport(result1, false, undefined, options.strict);
+        }
+        process.exit(EXIT_CODES.INVALID); // Changed from POLICY_ERROR
+    }
+    // Apply Fixes
+    const fixResult = await applyFixPlan(plan, {
+        dryRun: options.fixDryRun,
+        yes: options.yes
+    });
+    if (options.fixDryRun) {
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    // 3. Re-validate (Final Pass)
+    const result2 = await validate({
+        apply: options.apply || false,
+        phase: options.phase,
+        strict: options.strict || false,
+        writeBack: true
+    });
+    printReport(result2, options.json, fixResult, options.strict);
+    let exitCode = EXIT_CODES.SUCCESS;
+    if (!result2.valid) {
+        exitCode = EXIT_CODES.INVALID; // Changed from POLICY_ERROR
+    }
+    else if (options.strict && result2.warnings) {
+        exitCode = EXIT_CODES.VALID_WITH_WARNINGS;
+    }
+    process.exit(exitCode);
+});

package/dist/iris/artifact-checker.js

@@ -0,0 +1,78 @@
+import fs from "fs";
+import path from "path";
+/**
+ * Normalizes an artifact path by:
+ * - Removing CRLF (\r) characters
+ * - Trimming whitespace
+ * - Converting backslashes to forward slashes
+ * - Removing trailing slashes (except for root)
+ */
+export function normalizeArtifactPath(rawPath) {
+    let normalized = rawPath;
+    // Remove \r characters (CRLF normalization)
+    normalized = normalized.replace(/\r/g, "");
+    // Trim whitespace
+    normalized = normalized.trim();
+    // Convert backslashes to forward slashes
+    normalized = normalized.replace(/\\/g, "/");
+    // Remove trailing slashes (but keep single "/" for root)
+    if (normalized.length > 1) {
+        normalized = normalized.replace(/\/+$/, "");
+    }
+    return normalized;
+}
+/**
+ * Infers whether a path represents a file or directory based on:
+ * - Trailing slash → directory
+ * - Has file extension → file
+ * - No extension → directory
+ */
+export function inferArtifactKind(normalizedPath) {
+    // If original had trailing slash (before normalization), it's a directory
+    // But we've already normalized, so check for extension
+    const basename = path.basename(normalizedPath);
+    const hasExtension = basename.includes(".") && !basename.startsWith(".");
+    return hasExtension ? "file" : "directory";
+}
+/**
+ * Checks if a raw path contains control characters
+ */
+export function hasControlCharacters(rawPath) {
+    // Check for common control characters: \r, \n, \t, etc.
+    return /[\r\n\t\x00-\x1F]/.test(rawPath);
+}
+/**
+ * Main artifact validation function.
+ * Validates an artifact path and returns detailed information.
+ */
+export function checkArtifact(repoRoot, rawPath, expectedType) {
+    const normalized = normalizeArtifactPath(rawPath);
+    const absolutePath = path.resolve(repoRoot, normalized);
+    const hasControlChars = hasControlCharacters(rawPath);
+    const inferredKind = expectedType || inferArtifactKind(normalized);
+    let exists = false;
+    let isDirectory = false;
+    let isFile = false;
+    try {
+        exists = fs.existsSync(absolutePath);
+        if (exists) {
+            const stats = fs.statSync(absolutePath);
+            isDirectory = stats.isDirectory();
+            isFile = stats.isFile();
+        }
+    }
+    catch (e) {
+        // If stat fails, treat as non-existent
+        exists = false;
+    }
+    return {
+        exists,
+        isDirectory,
+        isFile,
+        absolutePath,
+        normalized,
+        raw: rawPath,
+        hasControlChars,
+        inferredKind
+    };
+}

package/dist/iris/fixer.js

@@ -0,0 +1,143 @@
+import fs from "fs";
+import path from "path";
+import kleur from "kleur";
+import { repoRoot, ensureDir } from "../lib.js";
+export function collectFixPlan(result) {
+    const plan = {
+        actions: [],
+        skipped: []
+    };
+    const root = repoRoot();
+    for (const error of result.errors) {
+        if (error.code !== "MISSING_ARTIFACT") {
+            continue;
+        }
+        if (!error.path)
+            continue;
+        // Fix: Create Directory
+        if (error.artifactType === "dir") {
+            // Check if already in plan
+            const exists = plan.actions.find(a => a.path === error.path && a.kind === "mkdir");
+            if (!exists) {
+                plan.actions.push({
+                    kind: "mkdir",
+                    path: error.path
+                });
+            }
+            continue;
+        }
+        // Fix: Create File from Template
+        if (error.artifactType === "file") {
+            if (error.template) {
+                // Verify template exists in repo
+                const templatePath = path.join(root, error.template);
+                if (fs.existsSync(templatePath)) {
+                    plan.actions.push({
+                        kind: "createFileFromTemplate",
+                        path: error.path,
+                        template: error.template
+                    });
+                }
+                else {
+                    plan.skipped.push({
+                        reason: `Template missing: ${error.template}`,
+                        path: error.path
+                    });
+                }
+            }
+            else {
+                plan.skipped.push({
+                    reason: "No template defined",
+                    path: error.path
+                });
+            }
+            continue;
+        }
+    }
+    // Sort actions: mkdir first, then files
+    plan.actions.sort((a, b) => {
+        if (a.kind === "mkdir" && b.kind !== "mkdir")
+            return -1;
+        if (a.kind !== "mkdir" && b.kind === "mkdir")
+            return 1;
+        return a.path.localeCompare(b.path);
+    });
+    return plan;
+}
+export async function applyFixPlan(plan, options) {
+    const result = {
+        createdDirs: 0,
+        createdFiles: 0,
+        paths: []
+    };
+    const root = repoRoot();
+    if (options.dryRun) {
+        console.log(kleur.bold().blue("Dry Run Fix Plan:"));
+    }
+    for (const action of plan.actions) {
+        const fullPath = path.join(root, action.path);
+        if (action.kind === "mkdir") {
+            if (options.dryRun) {
+                console.log(`  [MKDIR] ${action.path}`);
+                continue;
+            }
+            try {
+                if (!fs.existsSync(fullPath)) {
+                    ensureDir(fullPath);
+                    result.createdDirs++;
+                    result.paths.push(action.path);
+                }
+            }
+            catch (e) {
+                console.error(kleur.red(`Failed to create dir ${action.path}: ${e}`));
+            }
+            continue;
+        }
+        if (action.kind === "createFileFromTemplate" && action.template) {
+            const templatePath = path.join(root, action.template);
+            if (options.dryRun) {
+                console.log(`  [COPY]  ${action.path} (from ${action.template})`);
+                continue;
+            }
+            // Check existence logic (safe overwrite)
+            // MISSING_ARTIFACT error implies it didn't exist during validate.
+            // But checking again just in case (race condition or manual change).
+            if (fs.existsSync(fullPath)) {
+                // It exists now? 
+                if (options.yes) {
+                    // Overwrite? Spec says "Missing artifacts (safe fixes)". 
+                    // If it now exists, we probably shouldn't touch it unless it's empty?
+                    // Validator said it was missing.
+                    // If it exists now, we skip it to be safe, or prompt.
+                    // Prompt says "File exists and differs. Overwrite?".
+                    // Let's compare logs? No, simplistic check.
+                    // Actually, if it exists, it wasn't missing. Maybe the validator ran, then user created it.
+                    // Only overwrite if explicit confirmation.
+                    // But usually applyFixPlan follows validate immediately.
+                    console.log(kleur.yellow(`Skipping ${action.path}: File exists.`));
+                    continue;
+                }
+                else {
+                    // Interactive prompt?
+                    // "Default behavior: non-interactive safe fixes where no overwrite is needed"
+                    // "If a fix would require overwriting... Prompt"
+                    // Since we only fix MISSING artifacts, we assume we don't overwrite.
+                    // If it exists, we skip.
+                    continue;
+                }
+            }
+            try {
+                // Read template
+                const content = fs.readFileSync(templatePath, "utf-8");
+                ensureDir(path.dirname(fullPath));
+                fs.writeFileSync(fullPath, content);
+                result.createdFiles++;
+                result.paths.push(action.path);
+            }
+            catch (e) {
+                console.error(kleur.red(`Failed to create file ${action.path}: ${e}`));
+            }
+        }
+    }
+    return result;
+}