project-iris 0.0.1

package/dist/commands/install.js

@@ -0,0 +1,73 @@
+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).")
+    .option("-y, --yes", "Skip prompts and use default/detected values")
+    .option("-f, --force", "Overwrite existing files")
+    .option("--tools <items>", "Comma-separated list of tools to install (e.g. cursor,vscode)")
+    .action(async (options) => {
+    const root = repoRoot();
+    // Step A: Detect
+    const defaults = detectTools(root);
+    let selectedTools = [];
+    if (options.yes || options.tools) {
+        if (options.tools) {
+            selectedTools = options.tools.split(",").map((t) => t.trim().toLowerCase());
+            // Validate? (optional but good)
+        }
+        else {
+            selectedTools = defaults.length > 0 ? defaults : ["cursor"]; // Fallback default
+        }
+    }
+    else {
+        // 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: defaults.includes(t)
+                })),
+                validate: (arr) => (arr.length ? true : "Select at least one tool."),
+            },
+        ]);
+        selectedTools = tools;
+    }
+    console.log("");
+    console.log(kleur.bold("Installing IRIS..."));
+    // Step C-G: Core Installer
+    // Step C-G: Core Installer
+    await installIris(root, selectedTools, options);
+    // Persist IDE selection for iris develop
+    let selectedIde = selectedTools[0];
+    if (!options.yes && selectedTools.length > 1) {
+        // Only prompt if interactive
+        const { ide } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "ide",
+                message: "Which IDE will you primarily use with 'iris develop'?",
+                choices: selectedTools.map(t => ({
+                    name: t.charAt(0).toUpperCase() + t.slice(1),
+                    value: t
+                }))
+            }
+        ]);
+        selectedIde = ide;
+    }
+    // If non-interactive and multiple tools, first one is default 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:   ${selectedTools.join(", ")}`));
+    console.log(kleur.gray(`Primary IDE: ${selectedIde}`));
+});

package/dist/commands/pack.js

@@ -0,0 +1,33 @@
+import { Command } from "commander";
+import { generatePack } from "../iris/packer.js";
+import { resolveActiveFramework } from "../iris/framework-context.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-<phase>-<agent>.md)")
+    .option("--stdout", "Print bundle to stdout instead of writing file", false)
+    .option("--json", "Output result as JSON", 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) => {
+    // Wiring up framework resolution as per Step 4 plan (no functional change to packer yet)
+    const { resolution } = await resolveActiveFramework();
+    await generatePack({
+        agent: opts.agent,
+        phase: opts.phase,
+        output: opts.out,
+        stdout: opts.stdout,
+        json: opts.json,
+        strict: opts.strict,
+        maxBytes: opts.maxBytes,
+        includes: opts.include,
+        excludes: opts.exclude,
+        frameworkResolution: resolution
+    });
+});

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("iris validate --apply") + " to commit this transition.");
+    console.log("");
+});

package/dist/commands/run.js

@@ -0,0 +1,199 @@
+import { Command } from "commander";
+import kleur from "kleur";
+import path from "path";
+import fs from "fs";
+import { repoRoot } from "../lib.js";
+import { loadState, getActiveFramework, saveState } from "../iris/state.js";
+import { WorkflowEngine } from "../iris/workflow/engine.js";
+import { loadEffectiveWorkflowConfig } from "../iris/workflow/config.js";
+import { EXEC_REGISTRY } from "../iris/workflow/steps.js";
+import { loadFramework } from "../framework/framework-loader.js";
+export const runCommand = new Command("run")
+    .description("Execute the IRIS workflow loop")
+    .option("--new", "Start a new run (even if one exists)", false)
+    .option("--resume [runId]", "Resume a specific run ID")
+    .option("--seed <path>", "Seed run with an existing intent draft")
+    .option("--step <id>", "Execute only a specific step")
+    .option("--force", "Force re-execution of done steps", false)
+    .option("--json", "Output machine-readable status", false)
+    .option("--no-interactive", "Disable interactive prompts (Block if input needed)")
+    .action(async (options) => {
+    const root = repoRoot();
+    try {
+        // 1. Resolve Run Context
+        let engine;
+        let runId = options.resume === true ? undefined : options.resume; // --resume might be boolean true if no arg? No, [runId] means optional arg.
+        // If --resume passed without arg, commander sets it to true? Commander syntax [runId] sets it to true if flag present but no arg?
+        // Wait, argument [runId] means optional.
+        // If I run `iris run --resume`, `options.resume` is `true`? Or `runId`?
+        // Need to handle `true`.
+        if (typeof options.resume === 'boolean') {
+            runId = undefined; // Implies "resume latest" explicitly requested
+        }
+        const latestId = WorkflowEngine.getLatestRunId(root);
+        if (options.new || (!runId && !latestId)) {
+            // START NEW RUN
+            // Resolve Active Framework for configuration
+            const state = loadState();
+            const active = getActiveFramework(state);
+            // Load framework config
+            let framework = null;
+            try {
+                if (active.current) {
+                    framework = await loadFramework(active.current, { repoRoot: root });
+                }
+            }
+            catch (e) {
+                // Ignore framework load error? Default workflow will use default.
+                // But we should probably warn.
+                if (options.json) {
+                    // We are creating a run, hard to report json error before engine exists?
+                }
+                else {
+                    console.warn(kleur.yellow(`Warning: Could not load framework '${active.current}'. Using default workflow.`));
+                }
+            }
+            const workflowConfig = loadEffectiveWorkflowConfig(framework);
+            engine = WorkflowEngine.create(root, active.current, active.version || null, workflowConfig);
+            if (!options.json) {
+                console.log(kleur.bold(`Started new run: ${kleur.cyan(engine.getRunId())}`));
+                console.log(kleur.dim(`Framework: ${active.current}`));
+            }
+        }
+        else {
+            // RESUME
+            runId = runId || latestId;
+            if (!runId) {
+                // Should be unreachable due to !latestId check above
+                throw new Error("No run to resume.");
+            }
+            try {
+                engine = WorkflowEngine.load(root, runId);
+                if (!options.json) {
+                    console.log(kleur.bold(`Resuming run: ${kleur.cyan(runId)}`));
+                }
+                engine.appendEvent("RUN_RESUMED");
+                // Assuming workflow config is baked into state, so no need to reload framework
+            }
+            catch (e) {
+                console.error(kleur.red(`Failed to load run '${runId}': ${e.message}`));
+                process.exit(1);
+            }
+        }
+        // 2. Execution Loop
+        const engineState = engine.getState();
+        // Sync intentId to global state
+        const state = loadState();
+        state.active.intent_id = engineState.intentId;
+        // Also sync other active fields if needed
+        saveState(state);
+        const steps = engineState.workflow.steps;
+        // Filter steps?
+        const targetSteps = options.step
+            ? steps.filter(s => s.id === options.step)
+            : steps;
+        if (targetSteps.length === 0) {
+            console.error(kleur.red(`Step '${options.step}' not found in workflow.`));
+            process.exit(1);
+        }
+        let blocked = false;
+        let failed = false;
+        for (const stepConfig of targetSteps) {
+            if (stepConfig.enabled === false)
+                continue;
+            const status = engine.getStepStatus(stepConfig.id);
+            const isDone = status?.status === 'done';
+            fs.appendFileSync(path.join(root, 'debug.log'), `[DEBUG] Step ${stepConfig.id} status=${status?.status} isDone=${isDone}\n`);
+            if (isDone && !options.force) {
+                if (!options.json)
+                    console.log(kleur.dim(`✓ Step '${stepConfig.id}' already done.`));
+                continue;
+            }
+            // Execute
+            if (!options.json)
+                console.log(kleur.bold(`\nRunning step: ${stepConfig.id}...`));
+            engine.appendEvent("STEP_STARTED", { stepId: stepConfig.id });
+            const executor = EXEC_REGISTRY[stepConfig.kind];
+            if (!executor) {
+                const msg = `Unknown step kind '${stepConfig.kind}'`;
+                console.error(kleur.red(msg));
+                engine.updateStepstatus(stepConfig.id, { status: "failed", error: msg });
+                engine.appendEvent("STEP_FAILED", { stepId: stepConfig.id, error: msg });
+                failed = true;
+                break;
+            }
+            const result = await executor.execute(engineState, stepConfig, root, engine.getRunDir(), {
+                interactive: options.interactive ?? true,
+                seed: options.seed,
+                force: options.force,
+                quiet: options.json // Suppress stdout when --json is enabled
+            });
+            fs.appendFileSync(path.join(root, 'debug.log'), `[DEBUG] Step ${stepConfig.id} result result=${JSON.stringify(result)}\n`);
+            // Update Status
+            engine.updateStepstatus(stepConfig.id, {
+                status: result.status,
+                reason: result.reason,
+                error: result.error,
+                outputs: result.outputs
+            });
+            if (result.status === "failed") {
+                if (!options.json)
+                    console.error(kleur.red(`✗ Step '${stepConfig.id}' failed: ${result.error}`));
+                engine.appendEvent("STEP_FAILED", { stepId: stepConfig.id, error: result.error });
+                failed = true;
+                break;
+            }
+            else if (result.status === "blocked") {
+                if (!options.json) {
+                    console.warn(kleur.yellow(`⚠ Step '${stepConfig.id}' blocked: ${result.reason}`));
+                    console.warn(kleur.dim(`  To fix: ${result.error}`));
+                }
+                engine.appendEvent("STEP_BLOCKED", { stepId: stepConfig.id, msg: result.reason, error: result.error });
+                blocked = true;
+                break;
+            }
+            else {
+                if (!options.json)
+                    console.log(kleur.green(`✓ Step '${stepConfig.id}' done.`));
+                engine.appendEvent("STEP_DONE", { stepId: stepConfig.id, outputs: result.outputs });
+            }
+        }
+        // Finish
+        if (failed) {
+            engine.appendEvent("RUN_FINISHED", { error: "Run failed" });
+            if (options.json) {
+                console.log(JSON.stringify(engine.getState(), null, 2));
+                // console.error("DEBUG: Run failed. Exiting 1.");
+            }
+            process.exit(1);
+        }
+        else if (blocked) {
+            // Blocked is special exit code 2
+            engine.appendEvent("STEP_BLOCKED", { stepId: "run", msg: "Run blocked" }); // Ensure event log?
+            if (options.json) {
+                console.log(JSON.stringify(engine.getState(), null, 2));
+                // console.error("DEBUG: Run blocked. Exiting 2.");
+            }
+            process.exit(2);
+        }
+        else {
+            if (!options.step) {
+                // Only mark run finished if we ran the full loop? 
+                // Or if cursor reached end?
+                // For now, if no failure/block, we assume success.
+                engine.appendEvent("RUN_FINISHED");
+            }
+        }
+        if (options.json) {
+            // Reload state to get latest updates
+            console.log(JSON.stringify(engine.getState(), null, 2));
+        }
+    }
+    catch (e) {
+        console.error(kleur.red(`Run error: ${e.message}`));
+        if (options.json) {
+            console.log(JSON.stringify({ error: e.message }));
+        }
+        process.exit(1);
+    }
+});

package/dist/commands/status.js

@@ -0,0 +1,114 @@
+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,
+            active: {
+                flow: state.active.flow
+            },
+            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)}`);
+        }
+        if (state.active && state.active.flow) {
+            console.log(`- Active Flow: ${kleur.blue(state.active.flow)}`);
+        }
+        else {
+            console.log(`- Active Flow: (none)`);
+        }
+        // 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 `iris 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,14 @@
+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("--yes", "Run non-interactively (defaults to safe preservation)", false)
+    .option("--force", "Skip confirmations where possible", false)
+    .action(async (opts) => {
+    await uninstallIris({
+        keepMemory: opts.keepMemory,
+        force: opts.force,
+        yes: opts.yes
+    });
+});

package/dist/commands/use.js

@@ -0,0 +1,20 @@
+import { Command } from "commander";
+import kleur from "kleur";
+import { setSelectedIde } from "../iris/state.js";
+import { TOOLS } from "../iris/installer.js";
+export const useCommand = new Command("use")
+    .description("Set the active IDE/Tool for IRIS")
+    .argument("<ide>", "IDE ID (cursor, vscode, auto, etc.)")
+    .action((ide) => {
+    const normalized = ide.toLowerCase();
+    // Validation (Soft)
+    if (!TOOLS.includes(normalized)) {
+        console.log(kleur.yellow(`Warning: '${ide}' is not in the standard tools list.`));
+        console.log(kleur.dim(`Available: ${TOOLS.join(", ")}`));
+    }
+    setSelectedIde(normalized);
+    console.log(kleur.green(`✓ Active IDE set to: ${normalized}`));
+    if (normalized === "auto") {
+        console.log(kleur.cyan("  In-Process Agent enabled (background mode)."));
+    }
+});

package/dist/commands/validate.js

@@ -0,0 +1,102 @@
+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";
+import { resolveActiveFramework } from "../iris/framework-context.js";
+export const validateCommand = new Command("validate")
+    // ...
+    .action(async (options) => {
+    const { resolution } = await resolveActiveFramework();
+    try {
+        // 1. First Validation Pass
+        if (!options.fix && !options.fixDryRun) {
+            const result = await validate({
+                apply: options.apply || false,
+                phase: options.phase,
+                strict: options.strict || false,
+                frameworkResolution: resolution,
+            });
+            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,
+            frameworkResolution: resolution,
+        });
+        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,
+            frameworkResolution: resolution,
+        });
+        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);
+    }
+    catch (e) {
+        if (e.name === "PolicyOverlayMissingError") {
+            console.error(kleur.red(`\n[Policy Error] ${e.message}`));
+            process.exit(EXIT_CODES.POLICY_ERROR);
+        }
+        if (e.name === "PolicyLoadError") {
+            console.error(kleur.red(`\n[Policy Error] ${e.message}`));
+            if (e.cause)
+                console.error(kleur.gray(e.cause));
+            process.exit(EXIT_CODES.POLICY_ERROR);
+        }
+        // Unexpected
+        console.error(kleur.red(`\n[Unexpected Error] ${e.message}`));
+        process.exit(EXIT_CODES.INVALID);
+    }
+});