project-iris 0.0.12 → 0.0.14

package/dist/bridge/agent-runner.js

@@ -1,190 +0,0 @@
-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

@@ -1,31 +0,0 @@
-import { FilesystemBridgeConnector } from "./filesystem-connector.js";
-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
- */
-export function createConnector(ideId) {
-    switch (ideId.toLowerCase()) {
-        case "cursor":
-            return new CursorConnector();
-        case "vscode":
-        case "code":
-            return new VSCodeConnector();
-        case "antigravity":
-        case "gemini":
-            return new AntigravityConnector();
-        case "windsurf":
-            return new WindsurfConnector();
-        case "auto":
-        case "internal":
-            return new InProcessBridgeConnector();
-        case "claude":
-        case "codex":
-        default:
-            // Fallback to filesystem bridge for unsupported IDEs
-            return new FilesystemBridgeConnector();
-    }
-}

package/dist/bridge/connectors/antigravity-connector.js

@@ -1,18 +0,0 @@
-import { FilesystemBridgeConnector } from "../filesystem-connector.js";
-/**
- * Antigravity connector
- * Uses filesystem bridge (Antigravity doesn't have a standalone CLI)
- */
-export class AntigravityConnector extends FilesystemBridgeConnector {
-    id = "antigravity";
-    displayName = "Antigravity (Google Gemini)";
-    async isAvailable() {
-        // Antigravity is always "available" via filesystem bridge
-        // The user interacts through the Gemini interface
-        return true;
-    }
-    async ensureRunning() {
-        await super.ensureRunning();
-        // No additional setup needed for Antigravity
-    }
-}

package/dist/bridge/connectors/cursor-connector.js

@@ -1,31 +0,0 @@
-import { execSync } from "child_process";
-import { FilesystemBridgeConnector } from "../filesystem-connector.js";
-/**
- * Cursor IDE connector
- * Extends filesystem bridge with Cursor CLI integration
- */
-export class CursorConnector extends FilesystemBridgeConnector {
-    id = "cursor";
-    displayName = "Cursor IDE";
-    async isAvailable() {
-        try {
-            execSync("which cursor", { stdio: "ignore" });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async ensureRunning() {
-        await super.ensureRunning();
-        // Try to open Cursor if available
-        if (await this.isAvailable()) {
-            try {
-                execSync("cursor --version", { stdio: "ignore" });
-            }
-            catch {
-                // Cursor not running or not available, continue anyway
-            }
-        }
-    }
-}

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

@@ -1,29 +0,0 @@
-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/connectors/vscode-connector.js

@@ -1,31 +0,0 @@
-import { execSync } from "child_process";
-import { FilesystemBridgeConnector } from "../filesystem-connector.js";
-/**
- * VS Code connector
- * Extends filesystem bridge with VS Code CLI integration
- */
-export class VSCodeConnector extends FilesystemBridgeConnector {
-    id = "vscode";
-    displayName = "Visual Studio Code";
-    async isAvailable() {
-        try {
-            execSync("which code", { stdio: "ignore" });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async ensureRunning() {
-        await super.ensureRunning();
-        // Try to verify VS Code is available
-        if (await this.isAvailable()) {
-            try {
-                execSync("code --version", { stdio: "ignore" });
-            }
-            catch {
-                // VS Code not running or not available, continue anyway
-            }
-        }
-    }
-}

package/dist/bridge/connectors/windsurf-connector.js

@@ -1,23 +0,0 @@
-import { execSync } from "child_process";
-import { FilesystemBridgeConnector } from "../filesystem-connector.js";
-/**
- * Windsurf connector
- * Extends filesystem bridge with Windsurf CLI integration (if available)
- */
-export class WindsurfConnector extends FilesystemBridgeConnector {
-    id = "windsurf";
-    displayName = "Windsurf";
-    async isAvailable() {
-        try {
-            execSync("which windsurf", { stdio: "ignore" });
-            return true;
-        }
-        catch {
-            // Fallback to filesystem bridge
-            return true;
-        }
-    }
-    async ensureRunning() {
-        await super.ensureRunning();
-    }
-}

package/dist/bridge/filesystem-connector.js

@@ -1,110 +0,0 @@
-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");
-const STATE_DIR = path.join(BRIDGE_DIR, "state");
-/**
- * Filesystem-based bridge connector (baseline implementation)
- * Works by writing/reading JSON files in .iris/bridge/
- */
-export class FilesystemBridgeConnector {
-    id = "filesystem";
-    displayName = "Filesystem Bridge";
-    async isAvailable() {
-        // Always available - just needs filesystem
-        return true;
-    }
-    async ensureRunning() {
-        // Ensure bridge directories exist
-        for (const dir of [INBOX_DIR, OUTBOX_DIR, STATE_DIR]) {
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-        }
-    }
-    async sendTask(packet) {
-        await this.ensureRunning();
-        const inboxPath = path.join(INBOX_DIR, `${packet.taskId}.json`);
-        fs.writeFileSync(inboxPath, JSON.stringify(packet, null, 2), "utf8");
-        return { taskId: packet.taskId };
-    }
-    async waitResult(taskId, opts) {
-        const timeoutMs = opts?.timeoutMs || 300000; // 5 minutes default
-        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)) {
-                console.log(kleur.dim(`    [Debug] Found result at: ${outboxPath}`));
-                const content = fs.readFileSync(outboxPath, "utf8");
-                const result = JSON.parse(content);
-                // Clean up
-                fs.unlinkSync(outboxPath);
-                const inboxPath = path.join(INBOX_DIR, `${taskId}.json`);
-                if (fs.existsSync(inboxPath)) {
-                    fs.unlinkSync(inboxPath);
-                }
-                return result;
-            }
-            else {
-                // console.log(kleur.dim(`    [Debug] Waiting... Checked: ${outboxPath}`));
-            }
-            // 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));
-        }
-        throw new Error(`Timeout waiting for result: ${taskId}`);
-    }
-    generatePrompt(packet) {
-        return `# IRIS Workflow Task
-
-**Task ID:** ${packet.taskId}
-**Stage:** ${packet.stage}
-**Agent:** ${packet.agent}
-
-## Intent
-
-${packet.intent}
-
-## Instructions
-
-${packet.instructions}
-
-## Input Files
-
-${packet.inputs.map(p => `- [\`${path.basename(p)}\`](file://${path.resolve(p)})`).join("\n")}
-
-## Expected Outputs
-
-${packet.expectedOutputs.map(p => `- \`${p}\``).join("\n")}
-
-${packet.gates ? `\n## Gates\n\n${packet.gates.join("\n")}\n` : ""}
-
----
-
-**When complete, create a result file at:**
-\`.iris/bridge/outbox/${packet.taskId}.json\`
-
-**Result format:**
-\`\`\`json
-{
-  "taskId": "${packet.taskId}",
-  "status": "ok" | "needs_user" | "error",
-  "message": "Description of what was done",
-  "filesChanged": ["path/to/file1.md", "path/to/file2.md"],
-  "logs": ["Optional log messages"]
-}
-\`\`\`
-`;
-    }
-}

package/dist/bridge/helper.js

@@ -1,203 +0,0 @@
-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,10 +0,0 @@
-/**
- * Bridge types for iris develop workflow
- */
-export var WorkflowStage;
-(function (WorkflowStage) {
-    WorkflowStage["INTENT_INCEPTION"] = "INTENT_INCEPTION";
-    WorkflowStage["BOLT_PLAN"] = "BOLT_PLAN";
-    WorkflowStage["BOLT_EXECUTION"] = "BOLT_EXECUTION";
-    WorkflowStage["DONE"] = "DONE";
-})(WorkflowStage || (WorkflowStage = {}));