project-iris 0.0.6 → 0.0.8

package/README.md

@@ -14,7 +14,7 @@ mkdir my-project
 cd my-project
 
 # Install IRIS
-npx iris@latest install
+npx project-iris@latest install
 ```
 
 The installer will:
@@ -28,19 +28,29 @@ The installer will:
 
 ```bash
 # Check IRIS is working
-npx iris --help
-npx iris validate
+npx project-iris --help
+npx project-iris validate
 
 # Start using IRIS
-npx iris ask "scaffold a new login system"
+npx project-iris ask "scaffold a new login system"
 ```
 
+> [!IMPORTANT]
+> **Package Name vs Command Name**
+> 
+> The npm package is named `project-iris`, but when installed globally, the command is `iris`.
+> 
+> - **With npx** (no global install): Use `npx project-iris <command>`
+> - **After global install**: Use `iris <command>`
+> 
+> This is why `npx iris` won't work - there's no package named `iris` on npm.
+
 ### For Existing Projects
 
 If you already have a `package.json`, just run:
 
 ```bash
-npx iris@latest install
+npx project-iris@latest install
 ```
 
 IRIS will integrate with your existing project without breaking anything.
@@ -52,12 +62,12 @@ IRIS will integrate with your existing project without breaking anything.
 For convenience, you can install IRIS globally:
 
 ```bash
-npm install -g iris@latest
+npm install -g project-iris@latest
 
-# Now use 'iris' directly
-iris --version
-iris install
-iris ask "create a new feature"
+# Now use 'project-iris' directly
+project-iris --version
+project-iris install
+project-iris ask "create a new feature"
 ```
 
 ---
@@ -82,7 +92,7 @@ A standardized documentation structure enforced by Navi. The following minimal b
 *   **`memory-bank/standards/`**: Coding and documentation standards (`README.md` required).
 *   **`memory-bank/operations/`**: Runbooks and maintenance guides (`README.md` required).
 
-Navi ensures these files always exist. If missing, `navi validate` fails. Use `navi validate --fix` to restore them.
+IRIS ensures these files always exist. If missing, `project-iris validate` fails. Use `project-iris validate --fix` to restore them.
 
 ---
 
@@ -92,7 +102,7 @@ Navi ensures these files always exist. If missing, `navi validate` fails. Use `n
 Don't guess which agent or prompt to use. Just ask IRIS.
 
 ```bash
-iris ask "I need to fix the auth bug in login"
+project-iris ask "I need to fix the auth bug in login"
 ```
 *   **Result**: IRIS analyzes `.iris/routes.yaml`, picks the right agent (e.g., `inception` vs `construction`), generates a context pack, and tells you exactly what command to run.
 *   **Artifact**: Creates `.iris/inbox/next.md` with instructions.
@@ -101,7 +111,7 @@ iris ask "I need to fix the auth bug in login"
 If you just need the context for an agent manually:
 
 ```bash
-iris pack --agent inception
+project-iris pack --agent inception
 ```
 *   **Result**: Generates a single Markdown file containing all relevant project context, rules, and active tasks.
 
@@ -109,29 +119,29 @@ iris pack --agent inception
 Ensure your project complies with the defined policies (e.g., "Designs must be approved before coding").
 
 ```bash
-iris validate
+project-iris validate
 ```
 
 **Auto-Fix**: IRIS can repair missing directories and file structures automatically.
 ```bash
-iris validate --fix
+project-iris validate --fix
 ```
 
 **Strict Mode (CI)**:
 Use strict mode to fail (exit non-zero) on quality warnings (e.g. placeholders, empty files).
 ```bash
-iris validate --strict
+project-iris validate --strict
 ```
 
 ---
 
-## 🤖 Automated Workflows with `iris develop`
+## 🤖 Automated Workflows with `project-iris develop`
 
 **NEW**: Automate the complete IRIS workflow from Intent → Bolt Plan → Execution with IDE agent integration.
 
 ### Overview
 
-`iris develop` orchestrates the entire IRIS workflow automatically:
+`project-iris develop` orchestrates the entire IRIS workflow automatically:
 1. **Intent Inception** - Clarifies requirements through questions, generates intent artifacts
 2. **Bolt Plan** - Creates implementation plan and individual bolt files
 3. **Bolt Execution** - Executes each bolt (design → implement → test)
@@ -142,10 +152,10 @@ All stages interact with your IDE agent via a bridge protocol, with approval gat
 
 ```bash
 # Terminal 1: Start bridge helper (recommended)
-iris bridge run
+project-iris bridge run
 
 # Terminal 2: Run workflow
-iris develop "Build a dashboard UI to track IRIS progress"
+project-iris develop "Build a dashboard UI to track IRIS progress"
 ```
 
 The workflow will:
@@ -160,27 +170,27 @@ The workflow will:
 
 **Basic workflow:**
 ```bash
-iris develop "Your intent description"
+project-iris develop "Your intent description"
 ```
 
 **Resume interrupted workflow:**
 ```bash
-iris develop --resume <runId>
+project-iris develop --resume <runId>
 ```
 
 **Auto-approve gates (no prompts):**
 ```bash
-iris develop --gate auto "Your intent"
+project-iris develop --gate auto "Your intent"
 ```
 
 **Override IDE selection:**
 ```bash
-iris develop --ide cursor "Your intent"
+project-iris develop --ide cursor "Your intent"
 ```
 
 **No-bridge mode (manual result creation):**
 ```bash
-iris develop --no-bridge "Your intent"
+project-iris develop --no-bridge "Your intent"
 ```
 
 ### Bridge Helper
@@ -189,12 +199,12 @@ The bridge helper watches for workflow tasks and opens them in your IDE:
 
 **Start the helper:**
 ```bash
-iris bridge run
+project-iris bridge run
 ```
 
 **Check bridge status:**
 ```bash
-iris bridge status
+project-iris bridge status
 ```
 
 The helper will:
@@ -281,12 +291,12 @@ cat .iris/runs/<runId>.md
 
 **Bridge helper not finding tasks:**
 - Check `.iris/bridge/inbox/` for task files
-- Ensure bridge helper is running (`navi bridge run`)
+- Ensure bridge helper is running (`iris bridge run`)
 
 **IDE not opening automatically:**
 - Verify IDE CLI is available (`which cursor`, `which code`)
 - Use `--no-bridge` mode and open files manually
-- Check `navi bridge status` for connector info
+- Check `iris bridge status` for connector info
 
 **Workflow stuck waiting:**
 - Create result file manually in `.iris/bridge/outbox/<taskId>.json`
@@ -308,7 +318,7 @@ cat .iris/runs/<runId>.md
 *   **`pack`**: focused context bundle generator.
     *   `--agent <name>`: Target specific agent context.
     *   `--auth`: Include sensitive rules (optional).
-*   **`run <workflow>`**: Execute a named workflow (e.g., `npm run navi run deploy`).
+*   **`run <workflow>`**: Execute a named workflow (e.g., `iris run deploy`).
 *   **`develop [intent]`**: **NEW** - Automated workflow orchestration (Intent → Bolt Plan → Execution).
     *   `--resume <runId>`: Resume interrupted workflow.
     *   `--ide <ideId>`: Override IDE selection.
@@ -339,7 +349,7 @@ This section is for developers who want to contribute to IRIS itself (not for us
 ```bash
 # Clone the repository
 git clone <repo-url>
-cd iris-beta
+cd project-iris
 
 # Install dependencies
 npm ci

package/dist/bridge/filesystem-connector.js

@@ -1,5 +1,7 @@
 import fs from "fs";
 import path from "path";
+import { processInboxTasks } from "./helper.js";
+import { getSelectedIde } from "../iris/state.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");
@@ -27,10 +29,6 @@ export class FilesystemBridgeConnector {
         await this.ensureRunning();
         const inboxPath = path.join(INBOX_DIR, `${packet.taskId}.json`);
         fs.writeFileSync(inboxPath, JSON.stringify(packet, null, 2), "utf8");
-        // Also create a human-readable prompt file
-        const promptPath = path.join(STATE_DIR, `${packet.taskId}.md`);
-        const promptContent = this.generatePrompt(packet);
-        fs.writeFileSync(promptPath, promptContent, "utf8");
         return { taskId: packet.taskId };
     }
     async waitResult(taskId, opts) {
@@ -38,7 +36,9 @@ export class FilesystemBridgeConnector {
         const pollIntervalMs = opts?.pollIntervalMs || 1000; // 1 second
         const outboxPath = path.join(OUTBOX_DIR, `${taskId}.json`);
         const startTime = Date.now();
+        const processedTasks = new Set(); // Track state for this wait cycle
         while (Date.now() - startTime < timeoutMs) {
+            // Check for result logic...
             if (fs.existsSync(outboxPath)) {
                 const content = fs.readFileSync(outboxPath, "utf8");
                 const result = JSON.parse(content);
@@ -50,6 +50,11 @@ export class FilesystemBridgeConnector {
                 }
                 return result;
             }
+            // AUTO-BRIDGE: Act as the bridge while waiting
+            const ideId = getSelectedIde();
+            if (ideId) {
+                await processInboxTasks(ideId, processedTasks, false);
+            }
             // Wait before next poll
             await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
         }

package/dist/bridge/helper.js

@@ -0,0 +1,203 @@
+import fs from "fs";
+import path from "path";
+import kleur from "kleur";
+import { execSync } from "child_process";
+import { getSelectedIde } from "../iris/state.js";
+const BRIDGE_DIR = path.join(process.cwd(), ".iris/bridge");
+export const INBOX_DIR = path.join(BRIDGE_DIR, "inbox");
+export const OUTBOX_DIR = path.join(BRIDGE_DIR, "outbox");
+export const STATE_DIR = path.join(BRIDGE_DIR, "state");
+/**
+ * Start the bridge helper loop
+ */
+/**
+ * Start the bridge helper loop
+ */
+export async function startBridgeHelper(options = {}) {
+    const { pollInterval = 2000, verbose = false, stopSignal } = options;
+    if (verbose) {
+        console.log(kleur.bold("IRIS Bridge Helper"));
+        console.log(kleur.dim("Watching for workflow tasks...\n"));
+    }
+    const ideId = getSelectedIde();
+    if (!ideId) {
+        if (verbose)
+            console.error(kleur.red("No IDE selected. Run 'iris install' first."));
+        return;
+    }
+    if (verbose) {
+        console.log(kleur.gray(`IDE: ${ideId}`));
+        console.log(kleur.gray(`Inbox: ${INBOX_DIR}`));
+        console.log(kleur.gray(`Polling: every ${pollInterval}ms\n`));
+    }
+    ensureBridgeDirs();
+    const processedTasks = new Set();
+    let running = true;
+    while (running) {
+        if (stopSignal && stopSignal()) {
+            running = false;
+            break;
+        }
+        await processInboxTasks(ideId, processedTasks, verbose);
+        if (options.runOnce) {
+            running = false;
+        }
+        else {
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+        }
+    }
+}
+/**
+ * Process all tasks in the inbox once
+ */
+export async function processInboxTasks(ideId, processedTasks, verbose = false) {
+    try {
+        // Ensure dirs exist (safe to call repeatedly)
+        if (!fs.existsSync(INBOX_DIR))
+            return;
+        const files = fs.readdirSync(INBOX_DIR);
+        const taskFiles = files.filter(f => f.endsWith(".json"));
+        for (const file of taskFiles) {
+            const taskId = file.replace(".json", "");
+            if (processedTasks.has(taskId))
+                continue;
+            // Allow check against outbox to skip already completed tasks
+            if (fs.existsSync(path.join(OUTBOX_DIR, `${taskId}.json`))) {
+                processedTasks.add(taskId);
+                continue;
+            }
+            if (verbose)
+                console.log(kleur.cyan(`\n→ New task: ${taskId}`));
+            const taskPath = path.join(INBOX_DIR, file);
+            let task;
+            try {
+                task = JSON.parse(fs.readFileSync(taskPath, "utf8"));
+            }
+            catch (e) {
+                if (verbose)
+                    console.error(`Failed to parse task ${taskId}`, e);
+                continue;
+            }
+            const promptPath = path.join(STATE_DIR, `${taskId}.md`);
+            if (!fs.existsSync(promptPath)) {
+                const prompt = generatePrompt(task);
+                fs.writeFileSync(promptPath, prompt, "utf8");
+                if (verbose)
+                    console.log(kleur.dim(`  Prompt: ${promptPath}`));
+            }
+            const opened = await tryOpenInIDE(ideId, promptPath);
+            if (verbose) {
+                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);
+        }
+    }
+    catch (error) {
+        if (verbose)
+            console.error(kleur.red(`Error: ${error.message}`));
+    }
+}
+export function ensureBridgeDirs() {
+    for (const dir of [INBOX_DIR, OUTBOX_DIR, STATE_DIR]) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+}
+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"]
+}
+\`\`\`
+`;
+}
+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":
+            case "gemini":
+                try {
+                    execSync(`code "${filePath}"`, { stdio: "ignore" });
+                    return true;
+                }
+                catch { }
+                break;
+            case "windsurf":
+                try {
+                    execSync(`windsurf "${filePath}"`, { stdio: "ignore" });
+                    return true;
+                }
+                catch { }
+                break;
+        }
+        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/bridge/types.js

@@ -1,5 +1,5 @@
 /**
- * Bridge types for navi develop workflow
+ * Bridge types for iris develop workflow
  */
 export var WorkflowStage;
 (function (WorkflowStage) {

package/dist/cli.js

@@ -15,7 +15,7 @@ const program = new Command();
 program
     .name("iris")
     .description("IRIS CLI - Intelligent Repository for Intent-driven Systems")
-    .version("0.0.06")
+    .version("0.0.08")
     .addCommand(installCommand)
     .addCommand(uninstallCommand)
     .addCommand(phaseCommand)

package/dist/commands/ask.js

@@ -1,17 +1,20 @@
 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 { repoRoot } 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";
+import { createConnector } from "../bridge/connector-factory.js";
+import { getSelectedIde } from "../iris/state.js";
+import { executeIntentInception } from "../workflows/intent-inception.js";
+import { executeBoltPlan } from "../workflows/bolt-plan.js";
+import { createRun } from "../iris/run-state.js";
 export const askCommand = new Command("ask")
     .description("Route intent to an agent and generate context pack")
     .argument("[intent...]", "Natural language request intent")
@@ -77,146 +80,43 @@ export const askCommand = new Command("ask")
     // 2. Load Routes
     const routesConfig = loadRoutes();
     if (!routesConfig) {
-        console.error(kleur.red("Routes not found. Run `navi install` or create .iris/routes.yaml"));
+        console.error(kleur.red("Routes not found. Run `iris 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) {
+    // 4. Execution Workflow (Inception + Planning)
+    console.log(kleur.bold("Starting IRIS Inception & Planning"));
+    console.log(kleur.dim("This process will clarify your intent and generate an implementation plan.\n"));
+    // Initialize Bridge/IDE
+    const ideId = getSelectedIde() || "antigravity"; // Default or prompt?
+    // If not selected, we might want to prompt, but for now fallback to antigravity or error?
+    // The bridge helper handles "run 'iris install'" error.
+    // Create new run
+    const runState = createRun(intent, ideId, "manual");
+    const connector = createConnector(ideId);
+    try {
+        // Phase 1: Inception (Clarify + Artifacts)
+        await executeIntentInception(runState, connector, {
+            gate: "manual",
+            noBridge: false
+        });
+        // Phase 2: Bolt Plan (Stories -> Bolts)
+        await executeBoltPlan(runState, connector, {
+            gate: "manual",
+            noBridge: false
+        });
         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(kleur.bold(kleur.green("✓ Plan Created Successfully!")));
+        console.log("To start execution, run:");
+        console.log(kleur.cyan(`  iris develop --resume ${runState.runId}`));
         console.log("");
     }
+    catch (error) {
+        console.error(kleur.red(`\n✗ Planning Failed: ${error.message}`));
+        process.exit(1);
+    }
 });
 function inferAgentFromPhase(phase) {
     if (!phase)