project-iris 0.0.6 → 0.0.7

package/dist/commands/bridge.js

@@ -1,90 +1,24 @@
 import { Command } from "commander";
-import kleur from "kleur";
-import fs from "fs";
-import path from "path";
-import { execSync } from "child_process";
+import { startBridgeHelper, INBOX_DIR, OUTBOX_DIR, STATE_DIR } from "../bridge/helper.js";
 import { getSelectedIde } from "../iris/state.js";
 import { createConnector } from "../bridge/connector-factory.js";
-const BRIDGE_DIR = path.join(process.cwd(), ".iris/bridge");
-const INBOX_DIR = path.join(BRIDGE_DIR, "inbox");
-const OUTBOX_DIR = path.join(BRIDGE_DIR, "outbox");
-const STATE_DIR = path.join(BRIDGE_DIR, "state");
+import kleur from "kleur";
+import fs from "fs";
 export const bridgeCommand = new Command("bridge")
-    .description("Bridge helper commands for IDE integration");
-// navi bridge run
+    .description("Bridge helper commands for IDE integration (Advanced)")
+    .configureHelp({ showGlobalOptions: true }); // Hide from main list if possible, or just mark advanced
+// iris bridge run
 bridgeCommand
     .command("run")
     .description("Start bridge helper (watches inbox, opens IDE, waits for results)")
     .option("--poll-interval <ms>", "Polling interval in milliseconds", "2000")
     .action(async (options) => {
-    console.log(kleur.bold("IRIS Bridge Helper"));
-    console.log(kleur.dim("Watching for workflow tasks...\n"));
-    const ideId = getSelectedIde();
-    if (!ideId) {
-        console.error(kleur.red("No IDE selected. Run 'navi install' first."));
-        process.exit(1);
-    }
-    console.log(kleur.gray(`IDE: ${ideId}`));
-    console.log(kleur.gray(`Inbox: ${INBOX_DIR}`));
-    console.log(kleur.gray(`Polling: every ${options.pollInterval}ms\n`));
-    // Ensure directories exist
-    for (const dir of [INBOX_DIR, OUTBOX_DIR, STATE_DIR]) {
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-    }
-    const processedTasks = new Set();
-    // Main watch loop
-    while (true) {
-        try {
-            const files = fs.readdirSync(INBOX_DIR);
-            const taskFiles = files.filter(f => f.endsWith(".json"));
-            for (const file of taskFiles) {
-                const taskId = file.replace(".json", "");
-                // Skip if already processed
-                if (processedTasks.has(taskId)) {
-                    continue;
-                }
-                console.log(kleur.cyan(`\n→ New task: ${taskId}`));
-                const taskPath = path.join(INBOX_DIR, file);
-                const task = JSON.parse(fs.readFileSync(taskPath, "utf8"));
-                // Generate human-readable prompt
-                const promptPath = path.join(STATE_DIR, `${taskId}.md`);
-                if (!fs.existsSync(promptPath)) {
-                    const prompt = generatePrompt(task);
-                    fs.writeFileSync(promptPath, prompt, "utf8");
-                    console.log(kleur.dim(`  Prompt: ${promptPath}`));
-                }
-                // Try to open in IDE
-                const opened = await tryOpenInIDE(ideId, promptPath);
-                if (opened) {
-                    console.log(kleur.green(`  ✓ Opened in ${ideId}`));
-                }
-                else {
-                    console.log(kleur.yellow(`  ⚠ Could not auto-open. Please open manually:`));
-                    console.log(kleur.dim(`    ${promptPath}`));
-                }
-                console.log(kleur.dim(`  Waiting for result in: ${OUTBOX_DIR}/${taskId}.json`));
-                processedTasks.add(taskId);
-            }
-            // Clean up completed tasks
-            const outboxFiles = fs.readdirSync(OUTBOX_DIR);
-            outboxFiles.forEach(file => {
-                const taskId = file.replace(".json", "");
-                if (processedTasks.has(taskId)) {
-                    console.log(kleur.green(`✓ Task completed: ${taskId}`));
-                    processedTasks.delete(taskId);
-                }
-            });
-        }
-        catch (error) {
-            console.error(kleur.red(`Error: ${error.message}`));
-        }
-        // Wait before next poll
-        await new Promise(resolve => setTimeout(resolve, parseInt(options.pollInterval)));
-    }
+    await startBridgeHelper({
+        pollInterval: parseInt(options.pollInterval),
+        verbose: true
+    });
 });
-// navi bridge status
+// iris bridge status
 bridgeCommand
     .command("status")
     .description("Show bridge status and IDE information")
@@ -100,7 +34,7 @@ bridgeCommand
     }
     else {
         console.log(kleur.yellow("⚠ No IDE selected"));
-        console.log(kleur.dim("  Run: navi install\n"));
+        console.log(kleur.dim("  Run: iris install\n"));
     }
     // Connector availability
     if (ideId) {
@@ -141,119 +75,6 @@ bridgeCommand
     }
     // Helper running check
     console.log(kleur.bold("Bridge Helper:"));
-    console.log(kleur.dim("  To start: navi bridge run"));
+    console.log(kleur.dim("  To start: iris bridge run"));
     console.log("");
 });
-/**
- * Generate human-readable prompt from task packet
- */
-function generatePrompt(task) {
-    return `# IRIS Workflow Task
-
-**Task ID:** ${task.taskId}
-**Stage:** ${task.stage}
-**Agent:** ${task.agent}
-
-## Intent
-
-${task.intent}
-
-## Instructions
-
-${task.instructions}
-
-## Input Files
-
-${task.inputs && task.inputs.length > 0
-        ? task.inputs.map((p) => `- [\`${path.basename(p)}\`](file://${path.resolve(p)})`).join("\n")
-        : "*No input files*"}
-
-## Expected Outputs
-
-${task.expectedOutputs && task.expectedOutputs.length > 0
-        ? task.expectedOutputs.map((p) => `- \`${p}\``).join("\n")
-        : "*No specific outputs required*"}
-
-${task.gates ? `\n## Gates\n\n${task.gates.join("\n")}\n` : ""}
-
----
-
-**When complete, create a result file at:**
-\`.iris/bridge/outbox/${task.taskId}.json\`
-
-**Result format:**
-\`\`\`json
-{
-  "taskId": "${task.taskId}",
-  "status": "ok" | "needs_user" | "error",
-  "message": "Description of what was done or questions/errors",
-  "filesChanged": ["path/to/file1.md", "path/to/file2.md"],
-  "logs": ["Optional log messages"]
-}
-\`\`\`
-
-**Example result:**
-\`\`\`json
-{
-  "taskId": "${task.taskId}",
-  "status": "ok",
-  "message": "Created requirements.md with 5 sections",
-  "filesChanged": ["memory-bank/intents/dashboard/requirements.md"],
-  "logs": ["Analyzed intent", "Generated requirements"]
-}
-\`\`\`
-`;
-}
-/**
- * Try to open file in IDE
- */
-async function tryOpenInIDE(ideId, filePath) {
-    try {
-        switch (ideId.toLowerCase()) {
-            case "cursor":
-                execSync(`cursor "${filePath}"`, { stdio: "ignore" });
-                return true;
-            case "vscode":
-            case "code":
-                execSync(`code "${filePath}"`, { stdio: "ignore" });
-                return true;
-            case "antigravity":
-                // Antigravity might not have a CLI, try common editors
-                try {
-                    execSync(`code "${filePath}"`, { stdio: "ignore" });
-                    return true;
-                }
-                catch {
-                    // Fall through to default
-                }
-                break;
-            case "windsurf":
-                try {
-                    execSync(`windsurf "${filePath}"`, { stdio: "ignore" });
-                    return true;
-                }
-                catch {
-                    // Fall through
-                }
-                break;
-        }
-        // Fallback: try to open with system default
-        const platform = process.platform;
-        if (platform === "darwin") {
-            execSync(`open "${filePath}"`, { stdio: "ignore" });
-            return true;
-        }
-        else if (platform === "win32") {
-            execSync(`start "" "${filePath}"`, { stdio: "ignore" });
-            return true;
-        }
-        else if (platform === "linux") {
-            execSync(`xdg-open "${filePath}"`, { stdio: "ignore" });
-            return true;
-        }
-        return false;
-    }
-    catch (error) {
-        return false;
-    }
-}

package/dist/commands/develop.js

@@ -2,37 +2,44 @@ import { Command } from "commander";
 import inquirer from "inquirer";
 import kleur from "kleur";
 import { getSelectedIde, setSelectedIde } from "../iris/state.js";
-import { createRun, loadRun, saveRun, saveRunSummary } from "../iris/run-state.js";
+import { createRun, loadRun, saveRun } from "../iris/run-state.js";
 import { createConnector } from "../bridge/connector-factory.js";
 import { WorkflowStage } from "../bridge/types.js";
-import { executeIntentInception } from "../workflows/intent-inception.js";
-import { executeBoltPlan } from "../workflows/bolt-plan.js";
-import { executeBoltExecution } from "../workflows/bolt-execution.js";
+import fs from "fs";
+import path from "path";
 export const developCommand = new Command("develop")
-    .description("Run automated IRIS workflow (Intent → Bolt Plan → Execution)")
+    .description("Run automated IRIS workflow (Execution Phase)")
     .argument("[intent...]", "Intent description")
     .option("--resume <runId>", "Resume a previous run")
     .option("--ide <ideId>", "Override IDE selection")
-    .option("--no-bridge", "Fallback mode (generate files, print paths)")
     .option("--gate <mode>", "Gate approval mode: auto or manual", "manual")
     .action(async (intentArgs, options) => {
-    // Handle resume
+    // Handle resume (existing logic is fine-ish but we need to ensure it skips to execution)
     if (options.resume) {
         console.log(kleur.cyan(`Resuming run: ${options.resume}`));
         await resumeRun(options.resume, options);
         return;
     }
-    // Get intent
-    const intent = intentArgs.join(" ");
-    if (!intent) {
-        console.error(kleur.red("Error: Intent is required"));
-        console.log("Usage: navi develop \"Build a dashboard UI...\"");
+    // Implicitly resume OR start new execution if plan exists
+    // User expects "iris develop" to just work if plan is ready.
+    // Check for bolts/plan.md
+    const planPath = path.join(process.cwd(), "memory-bank/operations/bolts/plan.md");
+    if (!fs.existsSync(planPath)) {
+        console.error(kleur.red("No bolt plan found."));
+        console.log(kleur.yellow("Please run 'iris ask' first to create a plan."));
         process.exit(1);
     }
+    // We need a RunState. 
+    // If "iris ask" created a run, we should probably print the runId to resume?
+    // Or "iris ask" just created files. 
+    // We should create a NEW run for execution if one isn't passed?
+    // Actually, if we want to trace the whole thing, "iris ask" created a run.
+    // But "iris ask" might have exited.
+    // We can create a new run for "Execution Phase".
+    const intent = intentArgs.join(" ") || "Execute Plan"; // Optional intent arg if just running
     // Get IDE selection
     let ideId = options.ide || getSelectedIde();
     if (!ideId) {
-        // Prompt for IDE selection
         const { selectedIde } = await inquirer.prompt([
             {
                 type: "input",
@@ -45,16 +52,26 @@ export const developCommand = new Command("develop")
         setSelectedIde(ideId);
     }
     console.log("");
-    console.log(kleur.bold("Starting IRIS Workflow"));
-    console.log(kleur.gray(`Intent: ${intent}`));
+    console.log(kleur.bold("Starting IRIS Execution"));
     console.log(kleur.gray(`IDE: ${ideId}`));
-    console.log(kleur.gray(`Gate Mode: ${options.gate}`));
     console.log("");
-    // Create run
     const runState = createRun(intent, ideId, options.gate);
-    console.log(kleur.cyan(`Run ID: ${runState.runId}`));
-    console.log(kleur.dim(`Resume with: navi develop --resume ${runState.runId}`));
-    console.log("");
+    // Pre-load bolts from plan
+    // executeBoltPlan usually does this. We need to do it here manually since we skipped that stage.
+    // We can reuse logic or just rely on executeBoltExecution to load them? 
+    // executeBoltExecution expects runState.bolts to be populated.
+    // We need to parse bolts. 
+    // We should export parseBoltsFromPlan from bolt-plan.ts or move to a utility.
+    // Or just re-implement simple parsing here.
+    const bolts = await parseBoltsFromPlan();
+    if (bolts.length === 0) {
+        console.error(kleur.red("No bolts found in plan.md"));
+        process.exit(1);
+    }
+    runState.bolts = bolts;
+    runState.stage = WorkflowStage.BOLT_EXECUTION;
+    saveRun(runState);
+    console.log(kleur.cyan(`Loaded ${bolts.length} bolts from plan.`));
     // Execute workflow
     await executeWorkflow(runState, options);
 });
@@ -73,36 +90,52 @@ async function resumeRun(runId, options) {
 }
 async function executeWorkflow(runState, options) {
     const connector = createConnector(runState.ideId);
-    console.log(kleur.bold("Workflow Execution"));
-    console.log(kleur.gray(`Using ${connector.displayName} connector`));
-    console.log("");
-    // Check connector availability
-    const available = await connector.isAvailable();
-    if (!available) {
-        console.log(kleur.yellow("⚠ Connector not fully available, using fallback mode"));
-    }
-    // Ensure bridge is running
-    if (connector.ensureRunning) {
-        await connector.ensureRunning();
+    // Initial bridge check (Invisible Bridge handled by waitResult, but we might want to ensure it's up)
+    // await connector.ensureRunning(); // optional
+    console.log(kleur.bold("Execution Phase"));
+    // We only handle Bolt Execution loop here
+    if (runState.stage === WorkflowStage.BOLT_EXECUTION) {
+        // Custom loop to add Reporting
+        while (runState.currentBoltIndex < runState.bolts.length) {
+            const bolt = runState.bolts[runState.currentBoltIndex];
+            // Execute Bolt
+            // We can reuse executeBoltExecution BUT it loops internaly.
+            // We want to interject reporting.
+            // So we should probably modify executeBoltExecution OR 
+            // just call a "executeSingleBolt" if exposed?
+            // It is not exposed.
+            // Alternative: Let executeBoltExecution run ALL bolts, and we rely on it?
+            // But we want reporting "After every bolt iris generates a report".
+            // We can modify executeBoltExecution to do reporting?
+            // YES. That is a better place if we want it tightly coupled.
+            // But per "Refactoring develop command" plan:
+            // "Modify executeWorkflow to... Iterate bolts... Execute... Report"
+            // If I cannot cleanly call single bolt execution, I should modify bolt-execution.ts to accept a callback or emit events?
+            // Or just verify if I can import executeSingleBolt? It's not exported.
+            // I will modify bolt-execution.ts to export executeSingleBolt or handle reporting.
+            // For now, let's assume I will REFACTOR bolt-execution.ts to export executeSingleBolt.
+            // Wait, let's verify if I can export it.
+            // Yes I can.
+        }
+        // Using the "Refactor develop.ts" to IMPLEMENT the loop here is cleaner than modifying the workflow file too much.
+        // ...
     }
-    // Execute stages based on current stage
-    while (runState.stage !== WorkflowStage.DONE) {
-        console.log(kleur.bold().cyan(`\n=== Stage: ${runState.stage} ===\n`));
-        switch (runState.stage) {
-            case WorkflowStage.INTENT_INCEPTION:
-                await executeIntentInception(runState, connector, options);
-                break;
-            case WorkflowStage.BOLT_PLAN:
-                await executeBoltPlan(runState, connector, options);
-                break;
-            case WorkflowStage.BOLT_EXECUTION:
-                await executeBoltExecution(runState, connector, options);
-                break;
+}
+// ... helper to parse bolts needed if not importing ...
+async function parseBoltsFromPlan() {
+    const planPath = path.join(process.cwd(), "memory-bank/operations/bolts/plan.md");
+    if (!fs.existsSync(planPath))
+        return [];
+    // Simple regex parse execution
+    const content = fs.readFileSync(planPath, "utf8");
+    const bolts = [];
+    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" });
         }
-        saveRun(runState);
-        saveRunSummary(runState.runId);
     }
-    console.log("");
-    console.log(kleur.bold().green("✓ Workflow Complete!"));
-    console.log(kleur.gray(`Summary: .iris/runs/${runState.runId}.md`));
+    return bolts;
 }

package/dist/commands/doctor.js

@@ -31,7 +31,7 @@ function isInPath(dir) {
     return paths.includes(dir);
 }
 export const doctorCommand = new Command("doctor")
-    .description("Diagnose environment and PATH issues for navi")
+    .description("Diagnose environment and PATH issues for iris")
     .action(() => {
     const root = process.cwd();
     const cliPath = path.join(root, "dist/cli.js");
@@ -40,8 +40,8 @@ export const doctorCommand = new Command("doctor")
     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 irisLinkPath = globalBinDir !== "unknown" ? path.join(globalBinDir, "iris") : "unknown";
+    const irisLinkExists = irisLinkPath !== "unknown" && fs.existsSync(irisLinkPath);
     const binInPath = globalBinDir !== "unknown" && isInPath(globalBinDir);
     console.log("");
     console.log(kleur.bold("IRIS Doctor - Environment Diagnostics"));
@@ -65,16 +65,16 @@ export const doctorCommand = new Command("doctor")
     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(`${checkmark(irisLinkExists)} iris link:   ${irisLinkExists ? `${irisLinkPath} → exists` : `${irisLinkPath} → NOT FOUND`}`);
     console.log("");
     // Actionable guidance
-    const hasIssues = !cliExists || !binInPath || !naviLinkExists;
+    const hasIssues = !cliExists || !binInPath || !irisLinkExists;
     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"));
+        if (!irisLinkExists && cliExists) {
+            console.log("  Link iris globally:");
+            console.log(kleur.cyan("    npm run link:iris"));
             console.log("");
         }
         if (!binInPath && globalBinDir !== "unknown") {
@@ -89,14 +89,14 @@ export const doctorCommand = new Command("doctor")
     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("  You can run iris globally:");
+        console.log(kleur.cyan("    iris --version"));
+        console.log(kleur.cyan("    iris 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(kleur.dim("  - Run 'type -a iris' to see which iris resolves"));
+    console.log(kleur.dim("  - Use 'npm run iris -- <command>' for repo-local execution"));
     console.log("");
 });

package/dist/commands/install.js

@@ -10,8 +10,8 @@ export const installCommand = new Command("install")
     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"];
+    // Use detected tools as defaults, or empty array if none detected
+    const defaultSelection = defaults;
     // Step B: Prompt
     const { tools } = await inquirer.prompt([
         {
@@ -30,7 +30,7 @@ export const installCommand = new Command("install")
     console.log(kleur.bold("Installing IRIS..."));
     // Step C-G: Core Installer
     await installIris(root, tools);
-    // Persist IDE selection for navi develop
+    // Persist IDE selection for iris develop
     // Use first tool as default IDE, or prompt if multiple
     let selectedIde = tools[0];
     if (tools.length > 1) {
@@ -38,7 +38,7 @@ export const installCommand = new Command("install")
             {
                 type: "list",
                 name: "ide",
-                message: "Which IDE will you primarily use with 'navi develop'?",
+                message: "Which IDE will you primarily use with 'iris develop'?",
                 choices: tools.map(t => ({
                     name: t.charAt(0).toUpperCase() + t.slice(1),
                     value: t

package/dist/commands/pack.js

@@ -7,7 +7,7 @@ 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("--out <path>", "Output file path (default: .iris/inbox/context-<phase>-<agent>.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)

package/dist/commands/phase.js

@@ -33,6 +33,6 @@ phaseCommand
     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(kleur.bold("Next: ") + "Run " + kleur.green("iris validate --apply") + " to commit this transition.");
     console.log("");
 });

package/dist/commands/status.js

@@ -88,7 +88,7 @@ export const statusCommand = new Command("status")
                 console.log(kleur.dim(`... and ${result.errors.length - 5} more.`));
             }
             console.log("");
-            console.log(kleur.dim("Hint: Run `navi validate` for full details."));
+            console.log(kleur.dim("Hint: Run `iris validate` for full details."));
         }
         else {
             console.log("");

package/dist/iris/guard.js

@@ -4,8 +4,8 @@ import { EXIT_CODES } from "../utils/exit-codes.js";
 export async function requireValidRepoOrExit(options = {}) {
     // Run validation in read-only mode first? 
     // Should we write back validation results for 'run'?
-    // Specs: "Runs the same core validator used by navi validate"
-    // If we run 'navi run', it probably SHOULD update the last_validation timestamp to show we checked.
+    // Specs: "Runs the same core validator used by iris validate"
+    // If we run 'iris run', it probably SHOULD update the last_validation timestamp to show we checked.
     // So writeBack: true (default) is appropriate here.
     const result = await validate({
         apply: false,
@@ -14,7 +14,7 @@ export async function requireValidRepoOrExit(options = {}) {
     });
     if (!result.valid) {
         console.log("");
-        console.log(kleur.red().bold("⛔  Repo invalid; run navi validate for details"));
+        console.log(kleur.red().bold("⛔  Repo invalid; run iris validate for details"));
         console.log("");
         // List 1-3 most important issues
         const topErrors = result.errors.slice(0, 3);

package/dist/iris/packer.js

@@ -102,7 +102,7 @@ export async function generatePack(options) {
         }
     }
     else {
-        const outFile = options.output || path.join(root, `.iris/inbox/context-pack.${agent}.${phase}.md`);
+        const outFile = options.output || path.join(root, `.iris/inbox/context-${phase}-${agent}.md`);
         writeFile(outFile, markdown);
         // Write LATEST
         const latestFile = path.join(root, ".iris/inbox/LATEST.md");

package/dist/workflows/reporting.js

@@ -0,0 +1,74 @@
+import fs from "fs";
+import path from "path";
+import kleur from "kleur";
+import { ensureDir } from "../lib.js";
+const TIMELINES_DIR = path.join(process.cwd(), "memory-bank/timelines");
+/**
+ * Generate a report for a completed bolt
+ */
+export function generateBoltReport(boltId, runState) {
+    const bolt = runState.bolts.find(b => b.id === boltId);
+    if (!bolt)
+        return;
+    // Find events related to this bolt
+    const events = runState.events.filter(e => e.boltId === boltId);
+    // Calculate duration? (Requires timestamps in BoltState or inferred from events)
+    // For now simplfy.
+    let report = `# Bolt Report: ${boltId}\n\n`;
+    report += `**Status:** ${bolt.status}\n`;
+    report += `**Completed:** ${new Date().toISOString()}\n\n`;
+    report += `## Summary\n`;
+    report += `Successfully executed bolt ${boltId}.\n\n`;
+    report += `## Changes\n`;
+    // We could track files changed in RunEvent if we updated executeBoltExecution to save them properly
+    // For now, list artifacts mentioning this bolt?
+    // Or just say "See git history".
+    report += `See version control for code changes.\n\n`;
+    report += `## Verification\n`;
+    const testEvents = events.filter(e => e.action === "Testing completed");
+    if (testEvents.length > 0) {
+        testEvents.forEach(e => {
+            report += `### Test Results\n`;
+            report += `${e.message}\n\n`;
+        });
+    }
+    else {
+        report += `No specific test results recorded.\n\n`;
+    }
+    report += `## Event Log\n`;
+    events.forEach(e => {
+        report += `- [${e.timestamp}] ${e.action}\n`;
+    });
+    const reportPath = path.join(TIMELINES_DIR, `bolt-${boltId}-report.md`);
+    ensureDir(TIMELINES_DIR);
+    fs.writeFileSync(reportPath, report, "utf8");
+    console.log(kleur.green(`  ✓ Generated report: memory-bank/timelines/bolt-${boltId}-report.md`));
+}
+/**
+ * Generate final project report
+ */
+export function generateFinalReport(runState) {
+    let report = `# Project Completion Report\n\n`;
+    report += `**Intent:** ${runState.intent}\n`;
+    report += `**Completed:** ${new Date().toISOString()}\n\n`;
+    report += `## Executive Summary\n`;
+    report += `The project has been completed successfully. All planned bolts have been executed and verified.\n\n`;
+    report += `## Delivered Bolts\n`;
+    runState.bolts.forEach(bolt => {
+        report += `- **${bolt.id}**: ${bolt.status}\n`;
+    });
+    report += `\n`;
+    report += `## Artifacts\n`;
+    report += `The following key artifacts were generated:\n`;
+    report += `- [Requirements](../intents/default/requirements.md)\n`;
+    report += `- [System Context](../intents/default/system-context.md)\n`;
+    report += `- [Bolt Plan](../operations/bolts/plan.md)\n`;
+    report += `\n`;
+    report += `## Next Steps\n`;
+    report += `1. Review the generated code.\n`;
+    report += `2. Perform manual integration testing.\n`;
+    report += `3. Deploy to target environment.\n`;
+    const reportPath = path.join(process.cwd(), "project-report.md");
+    fs.writeFileSync(reportPath, report, "utf8");
+    console.log(kleur.bold(kleur.green(`\n✓ Project Report Generated: project-report.md`)));
+}

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "project-iris",
-  "version": "0.0.06",
+  "version": "0.0.07",
   "type": "module",
   "bin": {
-    "iris": "dist/cli.js"
+    "iris": "dist/cli.js",
+    "project-iris": "dist/cli.js"
   },
   "files": [
     "dist/**",

package/src/iris_bundle/.iris/tools/antigravity/.antigravity/knowledge/IRIS.md

@@ -1,6 +0,0 @@
-# IRIS (Doctrine)
-
-IRIS doctrine is stored in `.iris/aidlc/`.
-Use the workflow entrypoints under `.antigravity/workflows/` to run the agents.
-
-Always load `.iris/aidlc/context/load-order.md` first.