project-iris 0.0.1

package/dist/lib.js

@@ -0,0 +1,96 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+export function repoRoot() {
+    return process.cwd();
+}
+export function ensureDir(p) {
+    fs.mkdirSync(p, { recursive: true });
+}
+export function copyDir(src, dst) {
+    ensureDir(dst);
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const s = path.join(src, entry.name);
+        const d = path.join(dst, entry.name);
+        if (entry.isDirectory())
+            copyDir(s, d);
+        else if (entry.isSymbolicLink()) {
+            const link = fs.readlinkSync(s);
+            try {
+                fs.symlinkSync(link, d);
+            }
+            catch { /* ignore */ }
+        }
+        else {
+            ensureDir(path.dirname(d));
+            fs.copyFileSync(s, d);
+        }
+    }
+}
+export function removeDir(p) {
+    if (!fs.existsSync(p))
+        return;
+    fs.rmSync(p, { recursive: true, force: true });
+}
+export function writeFile(p, content) {
+    ensureDir(path.dirname(p));
+    fs.writeFileSync(p, content, "utf8");
+}
+/**
+ * Sanitize a folder name to be a valid npm package name
+ */
+export function sanitizeFolderName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9-_]/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-+/g, "-")
+        || "my-project";
+}
+/**
+ * Check if npm is available in PATH
+ */
+export function hasNpm() {
+    try {
+        const result = spawn("npm", ["--version"], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Spawn a command asynchronously and return the result
+ */
+export function spawnAsync(command, args, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn(command, args, {
+            cwd,
+            stdio: ["inherit", "pipe", "pipe"],
+            shell: true
+        });
+        let stdout = "";
+        let stderr = "";
+        if (proc.stdout) {
+            proc.stdout.on("data", (data) => {
+                const text = data.toString();
+                stdout += text;
+                process.stdout.write(text);
+            });
+        }
+        if (proc.stderr) {
+            proc.stderr.on("data", (data) => {
+                const text = data.toString();
+                stderr += text;
+                process.stderr.write(text);
+            });
+        }
+        proc.on("close", (code) => {
+            resolve({ code: code ?? 0, stdout, stderr });
+        });
+        proc.on("error", (err) => {
+            stderr += err.message;
+            resolve({ code: 1, stdout, stderr });
+        });
+    });
+}

package/dist/utils/exit-codes.js

@@ -0,0 +1,7 @@
+export const EXIT_CODES = {
+    SUCCESS: 0,
+    INVALID: 2, // Missing artifacts, failed gates, invalid transition
+    VALID_WITH_WARNINGS: 3,
+    POLICY_ERROR: 4, // Policy invalid
+    STATE_ERROR: 5, // State invalid/unwritable
+};

package/dist/workflows/bolt-execution.js

@@ -0,0 +1,238 @@
+import { randomUUID } from "crypto";
+import inquirer from "inquirer";
+import kleur from "kleur";
+import { WorkflowStage } from "../bridge/types.js";
+import { appendEvent, saveRun } from "../iris/run-state.js";
+/**
+ * Execute Bolt Execution stage
+ * For each bolt:
+ * 1. Design notes (optional gate)
+ * 2. Implementation
+ * 3. Testing
+ * 4. Gate after implementation
+ */
+export async function executeBoltExecution(runState, connector, options) {
+    console.log(kleur.bold("Bolt Execution Stage"));
+    console.log(kleur.dim(`Executing ${runState.bolts.length} bolt(s)\n`));
+    // Execute each bolt in order
+    while (runState.currentBoltIndex < runState.bolts.length) {
+        const bolt = runState.bolts[runState.currentBoltIndex];
+        console.log(kleur.bold(kleur.cyan(`\n=== Bolt ${runState.currentBoltIndex + 1}/${runState.bolts.length}: ${bolt.id} ===\n`)));
+        bolt.status = "in_progress";
+        saveRun(runState);
+        try {
+            await executeSingleBolt(runState, bolt, connector, options);
+            bolt.status = "completed";
+            runState.currentBoltIndex++;
+            saveRun(runState);
+            console.log(kleur.green(`✓ Bolt "${bolt.id}" completed\n`));
+        }
+        catch (error) {
+            console.error(kleur.red(`✗ Bolt "${bolt.id}" failed: ${error.message}\n`));
+            bolt.status = "failed";
+            saveRun(runState);
+            throw error;
+        }
+    }
+    // All bolts complete
+    console.log(kleur.bold(kleur.green("\n✓ All bolts executed successfully!")));
+    runState.stage = WorkflowStage.DONE;
+    saveRun(runState);
+}
+async function executeSingleBolt(runState, bolt, connector, options) {
+    // Step 1: Design (optional)
+    console.log(kleur.cyan("→ Design phase..."));
+    const designTaskId = randomUUID();
+    const designPacket = {
+        taskId: designTaskId,
+        intent: runState.intent,
+        stage: WorkflowStage.BOLT_EXECUTION,
+        agent: "iris-construction-agent",
+        instructions: `Design phase for bolt: ${bolt.id}
+
+Review the bolt file: memory-bank/operations/bolts/${bolt.id}.md
+
+Create design notes covering:
+- Domain model (if applicable)
+- Technical approach
+- Key decisions (ADRs if needed)
+- File structure
+
+You may create design notes inline in the bolt file or in separate files.
+This is optional but recommended for complex bolts.`,
+        inputs: [
+            `memory-bank/operations/bolts/${bolt.id}.md`,
+            ...runState.artifacts
+        ],
+        expectedOutputs: [],
+        metadata: { step: "design", boltId: bolt.id }
+    };
+    appendEvent(runState.runId, {
+        stage: WorkflowStage.BOLT_EXECUTION,
+        boltId: bolt.id,
+        action: "Design phase started",
+        taskId: designTaskId
+    });
+    if (!options.noBridge) {
+        await connector.sendTask(designPacket);
+        console.log(kleur.dim(`  Task sent: ${designTaskId}`));
+        console.log(kleur.dim("  Waiting for design notes...\n"));
+        const designResult = await connector.waitResult(designTaskId, {
+            timeoutMs: 600000 // 10 minutes
+        });
+        if (designResult.status === "ok") {
+            console.log(kleur.green("✓ Design complete"));
+            if (designResult.filesChanged) {
+                designResult.filesChanged.forEach(file => console.log(kleur.dim(`  - ${file}`)));
+            }
+            console.log("");
+            bolt.designCompleted = true;
+            appendEvent(runState.runId, {
+                stage: WorkflowStage.BOLT_EXECUTION,
+                boltId: bolt.id,
+                action: "Design completed",
+                outputs: designResult.filesChanged,
+                resultStatus: "ok"
+            });
+        }
+    }
+    else {
+        console.log(kleur.yellow("  Bridge disabled. Skipping design phase.\n"));
+    }
+    // Step 2: Implementation
+    console.log(kleur.cyan("→ Implementation phase..."));
+    const implTaskId = randomUUID();
+    const implPacket = {
+        taskId: implTaskId,
+        intent: runState.intent,
+        stage: WorkflowStage.BOLT_EXECUTION,
+        agent: "iris-construction-agent",
+        instructions: `Implementation phase for bolt: ${bolt.id}
+
+Review:
+- Bolt file: memory-bank/operations/bolts/${bolt.id}.md
+- Intent artifacts in memory-bank/intents/
+- Any design notes created
+
+Implement all tasks listed in the bolt file.
+Create/modify code files as needed.
+Follow the project's coding standards.
+
+Mark tasks as complete in the bolt file as you finish them.`,
+        inputs: [
+            `memory-bank/operations/bolts/${bolt.id}.md`,
+            ...runState.artifacts
+        ],
+        expectedOutputs: [],
+        gates: ["Implementation complete - ready for testing"],
+        metadata: { step: "implementation", boltId: bolt.id }
+    };
+    appendEvent(runState.runId, {
+        stage: WorkflowStage.BOLT_EXECUTION,
+        boltId: bolt.id,
+        action: "Implementation started",
+        taskId: implTaskId
+    });
+    if (!options.noBridge) {
+        await connector.sendTask(implPacket);
+        console.log(kleur.dim(`  Task sent: ${implTaskId}`));
+        console.log(kleur.dim("  Waiting for implementation...\n"));
+        const implResult = await connector.waitResult(implTaskId, {
+            timeoutMs: 1200000 // 20 minutes
+        });
+        if (implResult.status === "error") {
+            throw new Error(implResult.error || "Implementation failed");
+        }
+        console.log(kleur.green("✓ Implementation complete"));
+        if (implResult.filesChanged) {
+            implResult.filesChanged.forEach(file => console.log(kleur.dim(`  - ${file}`)));
+        }
+        console.log("");
+        bolt.implementationCompleted = true;
+        appendEvent(runState.runId, {
+            stage: WorkflowStage.BOLT_EXECUTION,
+            boltId: bolt.id,
+            action: "Implementation completed",
+            outputs: implResult.filesChanged,
+            resultStatus: "ok"
+        });
+    }
+    else {
+        console.log(kleur.yellow("  Bridge disabled. Skipping implementation.\n"));
+    }
+    // Step 3: Testing
+    console.log(kleur.cyan("→ Testing phase..."));
+    const testTaskId = randomUUID();
+    const testPacket = {
+        taskId: testTaskId,
+        intent: runState.intent,
+        stage: WorkflowStage.BOLT_EXECUTION,
+        agent: "iris-construction-agent",
+        instructions: `Testing phase for bolt: ${bolt.id}
+
+Run tests or propose test commands for the implemented changes.
+
+If tests exist, run them and report results.
+If no tests exist, propose what should be tested and expected outcomes.
+
+Include:
+- Test commands run
+- Test results
+- Any issues found`,
+        inputs: [
+            `memory-bank/operations/bolts/${bolt.id}.md`
+        ],
+        expectedOutputs: [],
+        metadata: { step: "testing", boltId: bolt.id }
+    };
+    appendEvent(runState.runId, {
+        stage: WorkflowStage.BOLT_EXECUTION,
+        boltId: bolt.id,
+        action: "Testing started",
+        taskId: testTaskId
+    });
+    if (!options.noBridge) {
+        await connector.sendTask(testPacket);
+        console.log(kleur.dim(`  Task sent: ${testTaskId}`));
+        console.log(kleur.dim("  Waiting for test results...\n"));
+        const testResult = await connector.waitResult(testTaskId, {
+            timeoutMs: 600000 // 10 minutes
+        });
+        console.log(kleur.green("✓ Testing complete"));
+        console.log(kleur.dim(`  ${testResult.message}`));
+        console.log("");
+        bolt.testingCompleted = true;
+        appendEvent(runState.runId, {
+            stage: WorkflowStage.BOLT_EXECUTION,
+            boltId: bolt.id,
+            action: "Testing completed",
+            message: testResult.message,
+            resultStatus: testResult.status
+        });
+    }
+    else {
+        console.log(kleur.yellow("  Bridge disabled. Skipping testing.\n"));
+    }
+    // Step 4: Gate - Approve bolt?
+    if (options.gate === "manual") {
+        console.log(kleur.bold(kleur.yellow("Gate: Bolt Completion")));
+        const { approved } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "approved",
+                message: `Approve bolt "${bolt.id}" and continue?`,
+                default: true
+            }
+        ]);
+        appendEvent(runState.runId, {
+            stage: WorkflowStage.BOLT_EXECUTION,
+            boltId: bolt.id,
+            action: "Gate decision",
+            userGateDecision: approved ? "approved" : "rejected"
+        });
+        if (!approved) {
+            throw new Error("Bolt rejected by user");
+        }
+        console.log(kleur.green("✓ Bolt approved\n"));
+    }
+}

package/dist/workflows/bolt-plan.js

@@ -0,0 +1,192 @@
+import { randomUUID } from "crypto";
+import inquirer from "inquirer";
+import kleur from "kleur";
+import fs from "fs";
+import path from "path";
+import { WorkflowStage } from "../bridge/types.js";
+import { appendEvent, saveRun } from "../iris/run-state.js";
+/**
+ * Execute Bolt Plan stage
+ * Steps:
+ * 1. Generate bolt plan and individual bolt files
+ * 2. Parse bolt list from plan
+ * 3. Gate: Approve bolt plan? (y/N)
+ */
+export async function executeBoltPlan(runState, connector, options) {
+    console.log(kleur.bold("Bolt Plan Stage"));
+    console.log(kleur.dim("Generating implementation plan and bolts\n"));
+    // Step 1: Generate bolt plan
+    console.log(kleur.cyan("→ Generating bolt plan..."));
+    const planTaskId = randomUUID();
+    const planPacket = {
+        taskId: planTaskId,
+        intent: runState.intent,
+        stage: WorkflowStage.BOLT_PLAN,
+        agent: "iris-master-agent",
+        instructions: `Based on the intent artifacts, create a bolt plan and individual bolt files.
+
+Intent: ${runState.intent}
+
+Review the intent artifacts in memory-bank/intents/ to understand requirements.
+
+Create:
+1. memory-bank/operations/bolts/plan.md - Overall implementation plan listing all bolts
+2. memory-bank/operations/bolts/<bolt-id>.md - One file per bolt
+
+Each bolt should be a focused, testable unit of work (e.g., "setup-database", "create-api-endpoint", "build-ui-component").
+
+Bolt file format:
+# Bolt: <Name>
+
+## Purpose
+Brief description of what this bolt accomplishes
+
+## Dependencies
+List any other bolts this depends on
+
+## Tasks
+- [ ] Task 1
+- [ ] Task 2
+
+## Acceptance Criteria
+- Criterion 1
+- Criterion 2
+
+In plan.md, list all bolts in dependency order.`,
+        inputs: runState.artifacts,
+        expectedOutputs: [
+            "memory-bank/operations/bolts/plan.md"
+        ],
+        metadata: { step: "generate_bolt_plan" }
+    };
+    appendEvent(runState.runId, {
+        stage: WorkflowStage.BOLT_PLAN,
+        action: "Requesting bolt plan generation",
+        taskId: planTaskId
+    });
+    if (options.noBridge) {
+        console.log(kleur.yellow("  Bridge disabled. Task packet written to:"));
+        console.log(kleur.dim(`  .iris/bridge/inbox/${planTaskId}.json`));
+        console.log(kleur.dim("  Manually create result in .iris/bridge/outbox/\n"));
+        return;
+    }
+    try {
+        await connector.sendTask(planPacket);
+        console.log(kleur.dim(`  Task sent: ${planTaskId}`));
+        console.log(kleur.dim("  Waiting for IDE agent to create bolt plan...\n"));
+        const planResult = await connector.waitResult(planTaskId, {
+            timeoutMs: 600000 // 10 minutes
+        });
+        if (planResult.status === "error") {
+            throw new Error(planResult.error || "Failed to generate bolt plan");
+        }
+        console.log(kleur.green("✓ Bolt plan created"));
+        if (planResult.filesChanged) {
+            planResult.filesChanged.forEach(file => {
+                console.log(kleur.dim(`  - ${file}`));
+                runState.artifacts.push(file);
+            });
+        }
+        console.log("");
+        appendEvent(runState.runId, {
+            stage: WorkflowStage.BOLT_PLAN,
+            action: "Bolt plan generated",
+            outputs: planResult.filesChanged,
+            resultStatus: "ok"
+        });
+        // Step 2: Parse bolt list from plan
+        const bolts = await parseBoltsFromPlan();
+        if (bolts.length === 0) {
+            console.log(kleur.yellow("⚠ No bolts found in plan. Creating default bolt.\n"));
+            bolts.push({
+                id: "implementation",
+                status: "pending"
+            });
+        }
+        runState.bolts = bolts;
+        console.log(kleur.cyan(`Found ${bolts.length} bolt(s):`));
+        bolts.forEach((bolt, i) => {
+            console.log(kleur.dim(`  ${i + 1}. ${bolt.id}`));
+        });
+        console.log("");
+        // Step 3: Gate - Approve bolt plan?
+        if (options.gate === "manual") {
+            console.log(kleur.bold(kleur.yellow("Gate: Bolt Plan Approval")));
+            const { approved } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "approved",
+                    message: "Approve bolt plan and proceed to execution?",
+                    default: true
+                }
+            ]);
+            appendEvent(runState.runId, {
+                stage: WorkflowStage.BOLT_PLAN,
+                action: "Gate decision",
+                userGateDecision: approved ? "approved" : "rejected"
+            });
+            if (!approved) {
+                console.log(kleur.yellow("\n⚠ Bolt plan rejected. Revision loop not yet implemented."));
+                console.log(kleur.dim("For now, manually edit bolt files and re-run.\n"));
+                runState.stage = WorkflowStage.DONE;
+                return;
+            }
+            console.log(kleur.green("✓ Bolt plan approved\n"));
+        }
+        // Move to next stage
+        runState.stage = WorkflowStage.BOLT_EXECUTION;
+        runState.currentBoltIndex = 0;
+        saveRun(runState);
+    }
+    catch (error) {
+        console.error(kleur.red(`\n✗ Error: ${error.message}`));
+        appendEvent(runState.runId, {
+            stage: WorkflowStage.BOLT_PLAN,
+            action: "Stage failed",
+            message: error.message,
+            resultStatus: "error"
+        });
+        throw error;
+    }
+}
+/**
+ * Parse bolts from plan.md
+ * Looks for bolt file references or creates default list
+ */
+async function parseBoltsFromPlan() {
+    const planPath = path.join(process.cwd(), "memory-bank/operations/bolts/plan.md");
+    if (!fs.existsSync(planPath)) {
+        return [];
+    }
+    const content = fs.readFileSync(planPath, "utf8");
+    const bolts = [];
+    // Look for bolt file references (e.g., "- bolt-name.md" or "1. bolt-name")
+    const boltPattern = /(?:^|\n)(?:\d+\.|[-*])\s+([a-z0-9-]+)(?:\.md)?/gi;
+    let match;
+    while ((match = boltPattern.exec(content)) !== null) {
+        const boltId = match[1].replace(/\.md$/, "");
+        if (!bolts.find(b => b.id === boltId)) {
+            bolts.push({
+                id: boltId,
+                status: "pending"
+            });
+        }
+    }
+    // Also check for actual bolt files in the directory
+    const boltsDir = path.join(process.cwd(), "memory-bank/operations/bolts");
+    if (fs.existsSync(boltsDir)) {
+        const files = fs.readdirSync(boltsDir);
+        files.forEach(file => {
+            if (file.endsWith(".md") && file !== "plan.md") {
+                const boltId = file.replace(/\.md$/, "");
+                if (!bolts.find(b => b.id === boltId)) {
+                    bolts.push({
+                        id: boltId,
+                        status: "pending"
+                    });
+                }
+            }
+        });
+    }
+    return bolts;
+}