project-iris 0.0.8 → 0.0.11

package/dist/bridge/agent-runner.js

@@ -0,0 +1,190 @@
+import fs from "fs";
+import path from "path";
+import kleur from "kleur";
+import { INBOX_DIR, OUTBOX_DIR } from "./helper.js";
+export async function startAgentRunner(options = {}) {
+    const pollInterval = options.pollInterval || 2000;
+    const verbose = options.verbose !== false;
+    console.log(kleur.bold("🤖 IRIS Automated Agent Started"));
+    console.log(kleur.dim(`   Watching: ${INBOX_DIR}`));
+    console.log(kleur.dim(`   Answering to: ${OUTBOX_DIR}\n`));
+    // Ensure directories
+    fs.mkdirSync(INBOX_DIR, { recursive: true });
+    fs.mkdirSync(OUTBOX_DIR, { recursive: true });
+    const processed = new Set();
+    // Polling Loop
+    setInterval(async () => {
+        try {
+            const files = fs.readdirSync(INBOX_DIR).filter(f => f.endsWith(".json"));
+            for (const file of files) {
+                if (processed.has(file))
+                    continue;
+                const filePath = path.join(INBOX_DIR, file);
+                try {
+                    const content = fs.readFileSync(filePath, "utf8");
+                    const task = JSON.parse(content);
+                    processed.add(file);
+                    const outPath = path.join(OUTBOX_DIR, file);
+                    if (fs.existsSync(outPath)) {
+                        processed.add(file);
+                        continue;
+                    }
+                    if (verbose) {
+                        console.log(kleur.cyan(`\n[Active] Processing task: ${task.taskId}`));
+                        console.log(kleur.dim(`  Stage: ${task.stage}`));
+                        console.log(kleur.dim(`  Intent: ${task.intent}`));
+                    }
+                    // Think...
+                    await new Promise(r => setTimeout(r, 1000)); // Simulate latency
+                    // Handle
+                    const result = await handleTask(task);
+                    // Respond
+                    fs.writeFileSync(outPath, JSON.stringify(result, null, 2));
+                    console.log(kleur.green(`  ✓ Responded to ${task.taskId}`));
+                }
+                catch (err) {
+                    console.error(kleur.red(`  ✗ Failed to process ${file}: ${err.message}`));
+                }
+            }
+        }
+        catch (e) {
+            // Ignore read errors
+        }
+    }, pollInterval);
+}
+// Heuristic Intelligence
+export async function handleTask(task) {
+    // 1. Intent Inception (Ping-Pong)
+    if (task.stage === "INTENT_INCEPTION" && task.metadata?.step === "clarify_turn") {
+        return handleClarification(task);
+    }
+    // 2. Artifact Generation
+    if (task.stage === "INTENT_INCEPTION" && task.metadata?.step === "generate_artifacts") {
+        return handleArtifactGeneration(task);
+    }
+    // 3. Bolt Plan
+    if (task.stage === "BOLT_PLAN" && task.metadata?.step === "generate_bolt_plan") {
+        return handleBoltPlan(task);
+    }
+    // Default fallback
+    return {
+        taskId: task.taskId,
+        status: "ok",
+        message: "DONE",
+        filesChanged: []
+    };
+}
+function handleClarification(task) {
+    const instructions = task.instructions || "";
+    const historyLines = instructions.split("\n").filter(l => l.trim().startsWith("Q:"));
+    const turnCount = historyLines.length;
+    let message = "DONE";
+    // Simple Script
+    if (turnCount === 0) {
+        message = "\"Who is the primary user for this application?\"";
+    }
+    else if (turnCount === 1) {
+        message = "\"What are the key technical constraints (Language, DB)?\"";
+    }
+    else if (turnCount === 2) {
+        message = "\"What are the success criteria for this project?\"";
+    }
+    else if (turnCount === 3) {
+        message = "\"What are the non-goals (what should we NOT build)?\"";
+    }
+    else {
+        message = "\"DONE\"";
+    }
+    return {
+        taskId: task.taskId,
+        status: "ok",
+        message,
+        filesChanged: []
+    };
+}
+function handleArtifactGeneration(task) {
+    const intentSlug = task.metadata?.intentSlug || "default";
+    const prompt = task.instructions || "";
+    // 1. Parse Inputs (Poor man's extraction from "User Answers" section of prompt)
+    let targetUser = "Unknown User";
+    let techStack = "Node.js (Default)";
+    let successCriteria = "- Standard success criteria";
+    let nonGoals = "- None specified";
+    // Extract Answers
+    const qaRegex = /Q: (.*?)\nA: (.*?)(?=\nQ:|\n$)/gs;
+    const matches = [...prompt.matchAll(qaRegex)];
+    matches.forEach(([, q, a]) => {
+        const qLower = q.toLowerCase();
+        if (qLower.includes("primary user"))
+            targetUser = a.trim();
+        else if (qLower.includes("technical constraints"))
+            techStack = a.trim();
+        else if (qLower.includes("success criteria"))
+            successCriteria = a.trim().split('.').map(s => s.trim()).filter(Boolean).map(s => `- ${s}`).join("\n");
+        else if (qLower.includes("non-goals"))
+            nonGoals = a.trim().split('.').map(s => s.trim()).filter(Boolean).map(s => `- ${s}`).join("\n");
+    });
+    // 2. Generate Requirements
+    const reqContent = `# Requirements: ${task.intent}
+
+## Goal
+${task.intent}
+
+## Target User
+${targetUser}
+
+## Success Criteria
+${successCriteria}
+
+## Non-Goals
+${nonGoals}
+
+## Functional Requirements (Inferred)
+- User should be able to complete the core workflows described in criteria.
+- System should be performant and reliable.
+`;
+    // 3. Generate System Context
+    const sysContent = `# System Context
+
+## Tech Stack
+${techStack}
+
+## Architecture Decisions
+- **Frontend / Backend Split**: as implied by tech stack.
+- **Data Persistence**: ${techStack.includes("firebase") ? "Firebase" : "Local/File-based (Default)"}.
+
+## Constraints
+- ${techStack}
+`;
+    const root = process.cwd();
+    const reqPath = `memory-bank/intents/${intentSlug}/requirements.md`;
+    const sysPath = `memory-bank/intents/${intentSlug}/system-context.md`;
+    ensureFile(path.join(root, reqPath), reqContent);
+    ensureFile(path.join(root, sysPath), sysContent);
+    return {
+        taskId: task.taskId,
+        status: "ok",
+        message: "Artifacts generated.",
+        filesChanged: [reqPath, sysPath]
+    };
+}
+function handleBoltPlan(task) {
+    const root = process.cwd();
+    const planPath = "memory-bank/operations/bolts/plan.md";
+    const boltPath = "memory-bank/operations/bolts/b001-bootstrap.md";
+    const planContent = `# Bolt Plan\n\n- [ ] [B001] [Bootstrap Project](./b001-bootstrap.md)\n`;
+    const boltContent = `# Bolt: Bootstrap\n\n## Tasks\n- [ ] Init project\n\n## Acceptance\n- runs\n`;
+    ensureFile(path.join(root, planPath), planContent);
+    ensureFile(path.join(root, boltPath), boltContent);
+    return {
+        taskId: task.taskId,
+        status: "ok",
+        message: "Plan generated.",
+        filesChanged: [planPath, boltPath]
+    };
+}
+function ensureFile(p, content) {
+    const dir = path.dirname(p);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(p, content);
+}

package/dist/bridge/connector-factory.js

@@ -3,6 +3,7 @@ import { CursorConnector } from "./connectors/cursor-connector.js";
 import { VSCodeConnector } from "./connectors/vscode-connector.js";
 import { AntigravityConnector } from "./connectors/antigravity-connector.js";
 import { WindsurfConnector } from "./connectors/windsurf-connector.js";
+import { InProcessBridgeConnector } from "./connectors/in-process-connector.js";
 /**
  * Create a bridge connector based on IDE id
  */
@@ -18,6 +19,9 @@ export function createConnector(ideId) {
             return new AntigravityConnector();
         case "windsurf":
             return new WindsurfConnector();
+        case "auto":
+        case "internal":
+            return new InProcessBridgeConnector();
         case "claude":
         case "codex":
         default:

package/dist/bridge/connectors/in-process-connector.js

@@ -0,0 +1,29 @@
+import { handleTask } from "../agent-runner.js";
+export class InProcessBridgeConnector {
+    id = "in-process";
+    displayName = "Internal Agent";
+    pendingTasks = new Map();
+    async isAvailable() {
+        return true;
+    }
+    async ensureRunning() {
+        // No-op
+    }
+    async sendTask(packet) {
+        this.pendingTasks.set(packet.taskId, packet);
+        return { taskId: packet.taskId };
+    }
+    async waitResult(taskId, opts) {
+        const packet = this.pendingTasks.get(taskId);
+        if (!packet) {
+            throw new Error(`Task ${taskId} not found in process memory`);
+        }
+        // Simulate async processing (think time)
+        await new Promise(resolve => setTimeout(resolve, 500));
+        // Execute logic directly
+        const result = await handleTask(packet);
+        // Cleanup
+        this.pendingTasks.delete(taskId);
+        return result;
+    }
+}

package/dist/bridge/filesystem-connector.js

@@ -2,6 +2,7 @@ import fs from "fs";
 import path from "path";
 import { processInboxTasks } from "./helper.js";
 import { getSelectedIde } from "../iris/state.js";
+import kleur from "kleur";
 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");
@@ -40,6 +41,7 @@ export class FilesystemBridgeConnector {
         while (Date.now() - startTime < timeoutMs) {
             // Check for result logic...
             if (fs.existsSync(outboxPath)) {
+                console.log(kleur.dim(`    [Debug] Found result at: ${outboxPath}`));
                 const content = fs.readFileSync(outboxPath, "utf8");
                 const result = JSON.parse(content);
                 // Clean up
@@ -50,6 +52,9 @@ export class FilesystemBridgeConnector {
                 }
                 return result;
             }
+            else {
+                // console.log(kleur.dim(`    [Debug] Waiting... Checked: ${outboxPath}`));
+            }
             // AUTO-BRIDGE: Act as the bridge while waiting
             const ideId = getSelectedIde();
             if (ideId) {

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import { installCommand } from "./commands/install.js";
+import { flowCommand } from "./commands/flow.js";
 import { uninstallCommand } from "./commands/uninstall.js";
 import { phaseCommand } from "./commands/phase.js";
 import { validateCommand } from "./commands/validate.js";
@@ -11,13 +12,19 @@ import { askCommand } from "./commands/ask.js";
 import { doctorCommand } from "./commands/doctor.js";
 import { developCommand } from "./commands/develop.js";
 import { bridgeCommand } from "./commands/bridge.js";
+import { frameworkCommand } from "./commands/framework.js";
+import { generateCommand } from "./commands/generate.js";
+import { useCommand } from "./commands/use.js";
 const program = new Command();
 program
     .name("iris")
     .description("IRIS CLI - Intelligent Repository for Intent-driven Systems")
-    .version("0.0.08")
+    .version("0.0.11")
     .addCommand(installCommand)
     .addCommand(uninstallCommand)
+    .addCommand(frameworkCommand)
+    .addCommand(generateCommand)
+    .addCommand(flowCommand)
     .addCommand(phaseCommand)
     .addCommand(validateCommand)
     .addCommand(statusCommand)
@@ -26,5 +33,6 @@ program
     .addCommand(askCommand)
     .addCommand(doctorCommand)
     .addCommand(developCommand)
-    .addCommand(bridgeCommand);
+    .addCommand(bridgeCommand)
+    .addCommand(useCommand);
 program.parseAsync(process.argv);

package/dist/commands/ask.js

@@ -1,20 +1,24 @@
 import { Command } from "commander";
 import inquirer from "inquirer";
 import kleur from "kleur";
+import path from "path";
 import fs from "fs";
 import { repoRoot } from "../lib.js";
-import { getIrisDebugInfo } from "../iris/resolver.js";
-import { loadRoutes } from "../iris/routes.js";
+import { resolveArtifactPath, getIrisDebugInfo } from "../iris/resolver.js";
+import { loadEffectiveRoutes } from "../iris/routes.js";
 import { routeIntent } from "../iris/router.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";
+import { migrateLegacyDraft } from "../iris/interactive/intent-interview.js";
+import { checkInteractiveMode } from "../iris/interactive/env.js";
+import { resolveActiveFramework } from "../iris/framework-context.js";
+import { loadEffectiveInterviewConfig } from "../iris/interview/config.js";
 export const askCommand = new Command("ask")
     .description("Route intent to an agent and generate context pack")
     .argument("[intent...]", "Natural language request intent")
@@ -25,8 +29,12 @@ export const askCommand = new Command("ask")
     .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)
+    .option("--non-interactive", "Skip interactive interview", false)
+    .option("--force-interactive", "Force interactive mode even in CI/Pipe", false)
+    .option("--save-draft-only", "Run interview and save draft, but do not execute workflow", false)
     .action(async (intentParts, opts) => {
     const root = repoRoot();
+    const { resolution } = await resolveActiveFramework(root);
     if (opts.debug) {
         const debug = getIrisDebugInfo(root);
         console.log(kleur.bold("IRIS Authority Debug"));
@@ -36,7 +44,7 @@ export const askCommand = new Command("ask")
         console.log(`- Bundled Path:${debug.bundledPath}`);
         console.log("");
         // Show artifact validation details
-        const policy = loadPolicy();
+        const policy = loadPolicy(root);
         const state = loadState();
         const phase = state.phase.current;
         const requirements = policy.phases[phase]?.requires || [];
@@ -60,39 +68,143 @@ export const askCommand = new Command("ask")
             console.log("");
         }
     }
+    // Migration Check
+    const migrated = migrateLegacyDraft(root);
+    if (migrated) {
+        console.log(kleur.dim("Migrated old intent-draft.json to intent-draft.latest.json"));
+    }
     // 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?" }
+    // Environment Check
+    const envCheck = checkInteractiveMode({
+        nonInteractive: opts.nonInteractive,
+        forceInteractive: opts.forceInteractive
+    });
+    if (envCheck.isInteractive) {
+        // 1.5 Load Interview Config
+        // Skipped Legacy Interview - proceeding directly to Ping-Pong Flow
+        // If no intent provided yet, ask for just the one-liner intent
+        if (!intent) {
+            const { initialIntent } = await inquirer.prompt([
+                {
+                    type: "input",
+                    name: "initialIntent",
+                    message: "What are you trying to build?",
+                    validate: (val) => val.trim().length > 0 || "Please provide a goal."
+                }
             ]);
-            intent = input;
+            intent = initialIntent;
         }
-        else {
-            intent = fs.readFileSync(0, "utf-8").trim();
+    }
+    else {
+        // NON-INTERACTIVE MODE
+        if (!opts.nonInteractive && !opts.forceInteractive) {
+            // Warn if we fell back automatically (reason exists)
+            if (envCheck.reason) {
+                console.warn(kleur.yellow(`⚠ Interactive mode disabled: ${envCheck.reason}`));
+                console.warn(kleur.dim("  Use --force-interactive to override if safe."));
+            }
+        }
+        // Fallback input reading
+        if (!intent) {
+            if (process.stdin.isTTY) {
+                console.error(kleur.red("Error: Intent argument required in non-interactive mode."));
+                process.exit(EXIT_CODES.INVALID);
+                return;
+            }
+            else {
+                try {
+                    intent = fs.readFileSync(0, "utf-8").trim();
+                }
+                catch (e) {
+                    // Ignore read error
+                }
+            }
         }
     }
     if (!intent) {
         console.error(kleur.red("No intent provided."));
         process.exit(EXIT_CODES.INVALID);
+        return; // TS Guard
     }
     // 2. Load Routes
-    const routesConfig = loadRoutes();
-    if (!routesConfig) {
-        console.error(kleur.red("Routes not found. Run `iris install` or create .iris/routes.yaml"));
+    let routesConfig;
+    try {
+        const state = loadState();
+        // Load Base or Effective
+        routesConfig = loadEffectiveRoutes(resolution, root, state.active.flow);
+    }
+    catch (e) {
+        if (e.name === "RoutesOverlayMissingError") {
+            console.error(kleur.red(`\n[Policy Error] ${e.message}`));
+            process.exit(EXIT_CODES.POLICY_ERROR);
+        }
+        if (e.name === "RoutesLoadError") {
+            console.error(kleur.red(`\n[Routes Error] ${e.message}`));
+            if (e.cause)
+                console.error(kleur.gray(e.cause));
+            process.exit(EXIT_CODES.POLICY_ERROR);
+        }
+        // Fallback for unexpected
+        console.error(kleur.red(`Failed to load routes: ${e.message}`));
         process.exit(EXIT_CODES.POLICY_ERROR);
     }
     // 3. Route
     const routing = routeIntent(intent, routesConfig);
     const routeId = routing.route === "default" ? "default" : routing.route.route_id;
+    const source = routing.route !== "default" ? routing.route._source : "default";
+    if (opts.debug) {
+        console.log(kleur.bold(`Matched route_id: ${routeId} ${source ? `(source: ${source})` : ""}`));
+    }
     // 4. Execution Workflow (Inception + Planning)
+    if (opts.dryRun) {
+        // DRY RUN: Simulate pack generation
+        // We know intent, route, agent.
+        // We can create a Plan object.
+        const plan = {
+            schemaVersion: 1,
+            intent: intent,
+            framework: resolution ? resolution.manifest.id : "legacy-fallback",
+            route: {
+                id: routeId,
+                target: routing.route === "default" ? "default" : routing.route.agent,
+                score: routing.route === "default" ? 0 : routing.route.score
+            },
+            routesSource: {
+                kind: routesConfig?._meta?.sourceKind || (resolution ? 'framework' : 'legacy'),
+                path: routesConfig?._meta?.sourcePath || (resolution ? resolution.files.routes : resolveArtifactPath(root, ".iris/routes.yaml"))
+            },
+            interviewSource: (() => {
+                // We need to load it here for dry run to show source
+                const interviewConfig = loadEffectiveInterviewConfig(resolution);
+                const isFramework = !!(resolution?.files.interview);
+                return {
+                    kind: isFramework ? 'framework' : 'default',
+                    path: isFramework ? resolution?.files.interview : null,
+                    activeFrameworkId: resolution?.manifest.id || null
+                };
+            })(),
+            pack: {
+                planned: true,
+            }
+        };
+        if (opts.json) {
+            console.log(JSON.stringify(plan, null, 2));
+        }
+        else {
+            console.log(kleur.yellow("[Dry Run] Routing Result:"));
+            console.log(JSON.stringify(plan, null, 2));
+        }
+        process.exit(0);
+        return;
+    }
     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.
+    // Default to 'auto' (In-Process Agent) for seamless UX, ignoring detected IDE unless explicitly bridged?
+    // For now, satisfy user request: "Check user intent first".
+    // We will use "auto" as the default connector.
+    const ideId = "auto";
     // Create new run
     const runState = createRun(intent, ideId, "manual");
     const connector = createConnector(ideId);
@@ -107,14 +219,29 @@ export const askCommand = new Command("ask")
             gate: "manual",
             noBridge: false
         });
-        console.log("");
-        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("");
+        const result = {
+            runId: runState.runId,
+            status: "plan_created",
+            planPath: path.join(root, ".iris/runs", runState.runId, "implementation_plan.md")
+        };
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log("");
+            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}`));
+        if (opts.json) {
+            console.log(JSON.stringify({ error: error.message }, null, 2));
+        }
+        else {
+            console.error(kleur.red(`\n✗ Planning Failed: ${error.message}`));
+        }
         process.exit(1);
     }
 });

package/dist/commands/bridge.js

@@ -18,6 +18,14 @@ bridgeCommand
         verbose: true
     });
 });
+// iris bridge serve
+bridgeCommand
+    .command("serve")
+    .description("Start automated agent (Simulates AI response)")
+    .action(async () => {
+    const { startAgentRunner } = await import("../bridge/agent-runner.js");
+    await startAgentRunner({ verbose: true });
+});
 // iris bridge status
 bridgeCommand
     .command("status")