project-iris 0.0.6

package/dist/commands/ask.js

@@ -0,0 +1,232 @@
+import { Command } from "commander";
+import inquirer from "inquirer";
+import kleur from "kleur";
+import path from "path";
+import fs from "fs";
+import { repoRoot, writeFile, ensureDir } from "../lib.js";
+import { getIrisDebugInfo } from "../iris/resolver.js";
+import { loadRoutes } from "../iris/routes.js";
+import { routeIntent } from "../iris/router.js";
+import { generatePack } from "../iris/packer.js";
+import { checkArtifact } from "../iris/artifact-checker.js";
+import { loadPolicy } from "../iris/policy.js";
+import { loadState } from "../iris/state.js";
+import { EXIT_CODES } from "../utils/exit-codes.js";
+export const askCommand = new Command("ask")
+    .description("Route intent to an agent and generate context pack")
+    .argument("[intent...]", "Natural language request intent")
+    .option("--agent <agent>", "Override target agent")
+    .option("--phase <phase>", "Override target phase")
+    .option("--out <path>", "Explicit output path for pack")
+    .option("--stdout", "Print pack to stdout", false)
+    .option("--json", "Output structured JSON result", false)
+    .option("--dry-run", "Simulate routing without writing files", false)
+    .option("--debug", "Show IRIS authority and artifact resolution info", false)
+    .action(async (intentParts, opts) => {
+    const root = repoRoot();
+    if (opts.debug) {
+        const debug = getIrisDebugInfo(root);
+        console.log(kleur.bold("IRIS Authority Debug"));
+        console.log(`- Repo Root:   ${debug.repoRoot}`);
+        console.log(`- IRIS Root:   ${debug.irisRoot}`);
+        console.log(`- Source:      ${kleur.magenta(debug.source.toUpperCase())}`);
+        console.log(`- Bundled Path:${debug.bundledPath}`);
+        console.log("");
+        // Show artifact validation details
+        const policy = loadPolicy();
+        const state = loadState();
+        const phase = state.phase.current;
+        const requirements = policy.phases[phase]?.requires || [];
+        if (requirements.length > 0) {
+            console.log(kleur.bold("Required Artifacts Debug"));
+            for (const req of requirements) {
+                const check = checkArtifact(root, req.path, req.type);
+                console.log(`\n- Artifact: ${req.type}`);
+                console.log(`  Raw:        ${JSON.stringify(req.path)}`);
+                console.log(`  Normalized: ${check.normalized}`);
+                console.log(`  Absolute:   ${check.absolutePath}`);
+                console.log(`  Inferred:   ${check.inferredKind}`);
+                console.log(`  Exists:     ${check.exists ? kleur.green("YES") : kleur.red("NO")}`);
+                if (check.exists) {
+                    console.log(`  Type:       ${check.isDirectory ? "directory" : check.isFile ? "file" : "unknown"}`);
+                }
+                if (check.hasControlChars) {
+                    console.log(`  ${kleur.yellow("⚠ WARNING: Raw path contains control characters (\\r, \\n, etc.)")}`);
+                }
+            }
+            console.log("");
+        }
+    }
+    // 1. Get Intent
+    let intent = intentParts.join(" ");
+    if (!intent) {
+        if (process.stdin.isTTY) {
+            const { input } = await inquirer.prompt([
+                { type: "input", name: "input", message: "What do you want to do?" }
+            ]);
+            intent = input;
+        }
+        else {
+            intent = fs.readFileSync(0, "utf-8").trim();
+        }
+    }
+    if (!intent) {
+        console.error(kleur.red("No intent provided."));
+        process.exit(EXIT_CODES.INVALID);
+    }
+    // 2. Load Routes
+    const routesConfig = loadRoutes();
+    if (!routesConfig) {
+        console.error(kleur.red("Routes not found. Run `navi install` or create .iris/routes.yaml"));
+        process.exit(EXIT_CODES.POLICY_ERROR);
+    }
+    // 3. Route
+    const routing = routeIntent(intent, routesConfig);
+    const routeId = routing.route === "default" ? "default" : routing.route.route_id;
+    // 4. Decide Context
+    let agent = opts.agent;
+    let phase = opts.phase;
+    let command = "";
+    if (routing.route === "default") {
+        if (!agent)
+            agent = routesConfig.default.agent;
+        if (!phase)
+            phase = routesConfig.default.phase;
+        command = routesConfig.default.command;
+    }
+    else {
+        const selectedRoute = routing.route;
+        // If agent missing in route, try to infer or fallback
+        if (!agent)
+            agent = selectedRoute.agent || inferAgentFromPhase(selectedRoute.phase);
+        if (!phase)
+            phase = selectedRoute.phase ? selectedRoute.phase.toLowerCase() : "";
+        command = selectedRoute.command;
+    }
+    // Fallback inference if agent is still missing (e.g. default route missing fields)
+    if (!agent && command) {
+        if (command.includes("inception"))
+            agent = "inception";
+        else if (command.includes("construction"))
+            agent = "construction";
+        else if (command.includes("operations"))
+            agent = "operations";
+        else if (command.includes("master"))
+            agent = "master";
+    }
+    // Override command logic if agent/phase changed via flags
+    if (opts.agent) {
+        switch (opts.agent) {
+            case "master":
+                command = "/iris-master-agent";
+                break;
+            case "inception":
+                command = "/iris-inception-agent";
+                break;
+            case "construction":
+                command = "/iris-construction-agent";
+                break;
+            case "operations":
+                command = "/iris-operations-agent";
+                break;
+        }
+    }
+    // 5. Pack
+    let packPath = "";
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    if (opts.out) {
+        packPath = opts.out;
+    }
+    else {
+        packPath = path.join(root, `.iris/inbox/context-pack.${agent}.${phase}.${timestamp}.md`);
+    }
+    if (!opts.dryRun) {
+        try {
+            await generatePack({
+                agent,
+                phase,
+                output: opts.stdout ? undefined : packPath,
+                stdout: opts.stdout,
+                strict: false
+            });
+        }
+        catch (e) {
+            console.error("Packing failed:", e);
+            process.exit(EXIT_CODES.INVALID);
+        }
+    }
+    // 6. Write Next Action
+    const nextPath = path.join(root, ".iris/inbox/next.md");
+    const nextHistoryPath = path.join(root, `.iris/inbox/next.${timestamp}.md`);
+    const nextContent = `# IRIS Next Action
+
+## Intent
+${intent}
+
+## Routing Decision
+- Route: ${routeId}
+- Agent: ${agent}
+- Phase: ${phase}
+- Command: ${command}
+- Score: ${routing.score}
+- Matched: ${routing.matches.join(", ")}
+${routing.excludedBy ? `- Excluded By: ${routing.excludedBy}` : ""}
+
+## Context Pack
+- Path: ${opts.stdout ? "(stdout)" : path.relative(root, packPath)}
+- Generated: ${new Date().toISOString()}
+
+## Do this now
+1) Open your IDE agent tool
+2) Run: \`${command}\`
+3) Provide the context pack at: \`${opts.stdout ? "(stdout)" : path.relative(root, packPath)}\`
+
+## Notes
+- If validation fails, run: \`navi validate\`
+`;
+    if (!opts.dryRun) {
+        ensureDir(path.dirname(nextPath));
+        writeFile(nextPath, nextContent);
+        writeFile(nextHistoryPath, nextContent);
+    }
+    // 7. Output
+    if (opts.json) {
+        console.log(JSON.stringify({
+            intent,
+            route: routeId,
+            agent,
+            phase,
+            command,
+            score: routing.score,
+            matches: routing.matches,
+            pack_path: opts.stdout ? null : packPath,
+            next_path: nextPath
+        }, null, 2));
+    }
+    else if (!opts.stdout) {
+        console.log("");
+        console.log(kleur.bold("Routing: ") + kleur.cyan(routeId) + kleur.dim(` (conf: ${routing.score})`));
+        console.log(kleur.bold("Command: ") + kleur.green(command));
+        if (opts.dryRun) {
+            console.log(kleur.yellow("[DRY RUN] No files written."));
+            console.log(`Would satisfy intent '${intent}' with agent ${agent}.`);
+        }
+        else {
+            console.log(kleur.bold("Context: ") + kleur.gray(path.relative(root, packPath)));
+            console.log(kleur.bold("Next:    ") + kleur.gray(path.relative(root, nextPath)));
+        }
+        console.log("");
+    }
+});
+function inferAgentFromPhase(phase) {
+    if (!phase)
+        return "master";
+    const p = phase.toLowerCase();
+    if (p === "inception")
+        return "inception";
+    if (p === "construction")
+        return "construction";
+    if (p === "operations")
+        return "operations";
+    return "master";
+}

package/dist/commands/bridge.js

@@ -0,0 +1,259 @@
+import { Command } from "commander";
+import kleur from "kleur";
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+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");
+export const bridgeCommand = new Command("bridge")
+    .description("Bridge helper commands for IDE integration");
+// navi 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)));
+    }
+});
+// navi bridge status
+bridgeCommand
+    .command("status")
+    .description("Show bridge status and IDE information")
+    .action(() => {
+    console.log("");
+    console.log(kleur.bold("IRIS Bridge Status"));
+    console.log("===================\n");
+    // IDE selection
+    const ideId = getSelectedIde();
+    if (ideId) {
+        console.log(kleur.bold("Selected IDE:"));
+        console.log(`  ${kleur.cyan(ideId)}\n`);
+    }
+    else {
+        console.log(kleur.yellow("⚠ No IDE selected"));
+        console.log(kleur.dim("  Run: navi install\n"));
+    }
+    // Connector availability
+    if (ideId) {
+        const connector = createConnector(ideId);
+        console.log(kleur.bold("Connector:"));
+        console.log(`  Type: ${connector.displayName}`);
+        console.log(`  ID: ${connector.id}\n`);
+    }
+    // Bridge directories
+    console.log(kleur.bold("Bridge Directories:"));
+    const dirs = [
+        { name: "Inbox", path: INBOX_DIR },
+        { name: "Outbox", path: OUTBOX_DIR },
+        { name: "State", path: STATE_DIR }
+    ];
+    dirs.forEach(({ name, path: dirPath }) => {
+        const exists = fs.existsSync(dirPath);
+        const status = exists ? kleur.green("✓") : kleur.red("✗");
+        console.log(`  ${status} ${name}: ${dirPath}`);
+        if (exists) {
+            const files = fs.readdirSync(dirPath);
+            if (files.length > 0) {
+                console.log(kleur.dim(`    ${files.length} file(s)`));
+            }
+        }
+    });
+    console.log("");
+    // Pending tasks
+    if (fs.existsSync(INBOX_DIR)) {
+        const tasks = fs.readdirSync(INBOX_DIR).filter(f => f.endsWith(".json"));
+        if (tasks.length > 0) {
+            console.log(kleur.bold("Pending Tasks:"));
+            tasks.forEach(task => {
+                console.log(kleur.yellow(`  - ${task.replace(".json", "")}`));
+            });
+            console.log("");
+        }
+    }
+    // Helper running check
+    console.log(kleur.bold("Bridge Helper:"));
+    console.log(kleur.dim("  To start: navi 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

@@ -0,0 +1,108 @@
+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 { 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";
+export const developCommand = new Command("develop")
+    .description("Run automated IRIS workflow (Intent → Bolt Plan → Execution)")
+    .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
+    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...\"");
+        process.exit(1);
+    }
+    // Get IDE selection
+    let ideId = options.ide || getSelectedIde();
+    if (!ideId) {
+        // Prompt for IDE selection
+        const { selectedIde } = await inquirer.prompt([
+            {
+                type: "input",
+                name: "selectedIde",
+                message: "Which IDE will you use? (e.g., cursor, vscode, antigravity)",
+                default: "antigravity"
+            }
+        ]);
+        ideId = selectedIde;
+        setSelectedIde(ideId);
+    }
+    console.log("");
+    console.log(kleur.bold("Starting IRIS Workflow"));
+    console.log(kleur.gray(`Intent: ${intent}`));
+    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("");
+    // Execute workflow
+    await executeWorkflow(runState, options);
+});
+async function resumeRun(runId, options) {
+    try {
+        const runState = loadRun(runId);
+        console.log(kleur.gray(`Intent: ${runState.intent}`));
+        console.log(kleur.gray(`Current Stage: ${runState.stage}`));
+        console.log("");
+        await executeWorkflow(runState, options);
+    }
+    catch (error) {
+        console.error(kleur.red(`Failed to resume run: ${error.message}`));
+        process.exit(1);
+    }
+}
+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();
+    }
+    // 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;
+        }
+        saveRun(runState);
+        saveRunSummary(runState.runId);
+    }
+    console.log("");
+    console.log(kleur.bold().green("✓ Workflow Complete!"));
+    console.log(kleur.gray(`Summary: .iris/runs/${runState.runId}.md`));
+}