project-iris 0.0.8 → 0.0.12

package/dist/commands/install.js

@@ -4,42 +4,80 @@ import kleur from "kleur";
 import { repoRoot } from "../lib.js";
 import { detectTools, installIris, TOOLS } from "../iris/installer.js";
 import { setSelectedIde } from "../iris/state.js";
+import { displayLogo } from "../utils/logo.js";
 export const installCommand = new Command("install")
     .description("Install IRIS doctrine under .iris and install tool commands into this repo (interactive).")
-    .action(async () => {
+    .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) => {
+    // Display OSiris logo banner
+    displayLogo("0.0.11");
     const root = repoRoot();
-    // Step A: Detect
+    // Step 1: Detect agentic coding tools
+    console.log(kleur.bold(`(1/4) Detecting agentic coding tools...`));
     const defaults = detectTools(root);
-    // Use detected tools as defaults, or empty array if none detected
-    const defaultSelection = defaults;
-    // 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."),
-        },
-    ]);
+    if (defaults.length > 0) {
+        console.log(kleur.gray(`      Found: ${defaults.join(", ")}`));
+    }
+    else {
+        console.log(kleur.gray("      No agentic coding tools detected"));
+    }
     console.log("");
-    console.log(kleur.bold("Installing IRIS..."));
-    // Step C-G: Core Installer
-    await installIris(root, tools);
+    // Step 2: Select target tools
+    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
+        }
+        console.log(kleur.bold(`(2/4) Select target tools`));
+        console.log(kleur.gray(`      [Space] = toggle  [Enter] confirm  [a] toggle all`));
+        console.log(kleur.green(`      [x] = selected    [ ] = not selected`));
+        console.log("");
+        selectedTools.forEach(t => {
+            console.log(kleur.green(`  ◉   ${t.charAt(0).toUpperCase() + t.slice(1)}`));
+        });
+        console.log("");
+    }
+    else {
+        // Step B: Prompt
+        console.log(kleur.bold(`(2/4) Select target tools`));
+        const { tools } = await inquirer.prompt([
+            {
+                type: "checkbox",
+                name: "tools",
+                message: "Choose tools:",
+                prefix: "?",
+                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("(3/4) Installing iris-core framework..."));
+    // Step 3: Core Installer - Install framework and tools
+    await installIris(root, selectedTools, options);
+    console.log("");
+    console.log(kleur.bold("(4/4) Finalizing setup..."));
     // Persist IDE selection for iris develop
-    // Use first tool as default IDE, or prompt if multiple
-    let selectedIde = tools[0];
-    if (tools.length > 1) {
+    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: tools.map(t => ({
+                choices: selectedTools.map(t => ({
                     name: t.charAt(0).toUpperCase() + t.slice(1),
                     value: t
                 }))
@@ -47,11 +85,16 @@ export const installCommand = new Command("install")
         ]);
         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:   ${tools.join(", ")}`));
+    console.log(kleur.bold().green("✓ IRIS install complete."));
+    console.log("");
+    console.log(kleur.gray("Installation Summary"));
+    console.log(kleur.gray("───────────────────────"));
+    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}`));
+    console.log("");
 });

package/dist/commands/pack.js

@@ -1,5 +1,6 @@
 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]);
 }
@@ -9,19 +10,24 @@ export const packCommand = new Command("pack")
     .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
+        excludes: opts.exclude,
+        frameworkResolution: resolution
     });
 });

package/dist/commands/run.js

@@ -1,17 +1,199 @@
 import { Command } from "commander";
 import kleur from "kleur";
-import { requireValidRepoOrExit } from "../iris/guard.js";
-import { EXIT_CODES } from "../utils/exit-codes.js";
+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 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);
+    .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

@@ -51,6 +51,9 @@ export const statusCommand = new Command("status")
                 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,
@@ -71,6 +74,12 @@ export const statusCommand = new Command("status")
         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")

package/dist/commands/uninstall.js

@@ -3,10 +3,12 @@ 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
+        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

@@ -4,84 +4,99 @@ 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")
-    .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({
+    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(result, options.json, undefined, options.strict);
+        printReport(result2, options.json, fixResult, options.strict);
         let exitCode = EXIT_CODES.SUCCESS;
-        if (!result.valid) {
-            exitCode = EXIT_CODES.INVALID;
+        if (!result2.valid) {
+            exitCode = EXIT_CODES.INVALID; // Changed from POLICY_ERROR
         }
-        else if (options.strict && result.warnings) {
+        else if (options.strict && result2.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);
+    catch (e) {
+        if (e.name === "PolicyOverlayMissingError") {
+            console.error(kleur.red(`\n[Policy Error] ${e.message}`));
+            process.exit(EXIT_CODES.POLICY_ERROR);
         }
-        else {
-            console.log(kleur.yellow("No fixable missing artifacts found."));
-            printReport(result1, false, undefined, options.strict);
+        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);
         }
-        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;
+        // Unexpected
+        console.error(kleur.red(`\n[Unexpected Error] ${e.message}`));
+        process.exit(EXIT_CODES.INVALID);
     }
-    process.exit(exitCode);
 });