project-iris 0.0.1

package/dist/iris/resolver.js

@@ -0,0 +1,66 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+// Get __dirname equivalent in ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Resolves the root directory of the active IRIS configuration (.iris folder).
+ * Strategy:
+ * 1. Check <repoRoot>/.iris
+ * 2. Fallback to bundled <package>/.iris (e.g. ../iris_bundle/.iris)
+ */
+export function resolveIrisRoot(repoRoot) {
+    const repoIris = path.join(repoRoot, ".iris");
+    // Check for policy.yaml to confirm this is a valid IRIS configuration authority
+    if (fs.existsSync(path.join(repoIris, "policy.yaml"))) {
+        return { path: repoIris, source: "repo" };
+    }
+    // Fallback to bundled
+    // We assume this file is in .../iris/resolver.js|ts
+    // And bundle is in .../iris_bundle/.iris
+    let bundledIris = path.resolve(__dirname, "../iris_bundle/.iris");
+    // Safety check (bundled should always exist, but in dev vs prod checks...)
+    if (!fs.existsSync(bundledIris)) {
+        // Try finding it in src if we are in dist (dev environment fallback)
+        const srcBundle = path.resolve(__dirname, "../../src/iris_bundle/.iris");
+        if (fs.existsSync(srcBundle)) {
+            bundledIris = srcBundle;
+        }
+        else {
+            console.warn(`[IRIS] Warning: Bundled IRIS not found at ${bundledIris}`);
+        }
+    }
+    return { path: bundledIris, source: "bundled" };
+}
+/**
+ * Resolves a relative path (like ".iris/policy.yaml" or "memory-bank/foo.md")
+ * to its absolute physical location on disk, respecting the IRIS source authority.
+ */
+export function resolveArtifactPath(repoRoot, relativePath) {
+    if (path.isAbsolute(relativePath)) {
+        return relativePath;
+    }
+    if (relativePath.startsWith(".iris/") || relativePath === ".iris") {
+        const root = resolveIrisRoot(repoRoot);
+        if (relativePath === ".iris")
+            return root.path;
+        // internal path inside .iris
+        const subPath = relativePath.substring(6); // remove ".iris/"
+        return path.join(root.path, subPath);
+    }
+    // Standard repo file
+    return path.join(repoRoot, relativePath);
+}
+/**
+ * Debug helper to show resolution status
+ */
+export function getIrisDebugInfo(repoRoot) {
+    const root = resolveIrisRoot(repoRoot);
+    return {
+        repoRoot,
+        irisRoot: root.path,
+        source: root.source,
+        bundledPath: path.resolve(__dirname, "../iris_bundle/.iris")
+    };
+}

package/dist/iris/router.js

@@ -0,0 +1,114 @@
+export function routeIntent(intent, routesConfig) {
+    const candidates = [];
+    for (const route of routesConfig.routes) {
+        // 1. Check exclusions
+        if (checkExclusion(intent, route.exclude)) {
+            continue;
+        }
+        // 2. Score Match
+        const { score, matches } = scoreRoute(intent, route);
+        // Qualification:
+        if (score > 0) {
+            candidates.push({ route, score, matches });
+        }
+    }
+    // Sort: 1. Score desc, 2. Longest match count desc, 3. Route order (stable sort)
+    candidates.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        if (b.matches.length !== a.matches.length)
+            return b.matches.length - a.matches.length;
+        return 0;
+    });
+    if (candidates.length > 0) {
+        return {
+            route: candidates[0].route,
+            score: candidates[0].score,
+            matches: candidates[0].matches
+        };
+    }
+    // Default
+    return {
+        route: "default",
+        score: 0,
+        matches: []
+    };
+}
+function checkExclusion(intent, exclude) {
+    if (!exclude)
+        return false;
+    const lower = intent.toLowerCase();
+    // Any / Any Keywords
+    const anyList = [...(exclude.any || []), ...(exclude.any_keywords || [])];
+    if (anyList.length > 0) {
+        for (const kw of anyList) {
+            if (lower.includes(kw.toLowerCase()))
+                return true;
+        }
+    }
+    // Regex
+    if (exclude.regex) {
+        for (const pattern of exclude.regex) {
+            try {
+                if (new RegExp(pattern, "i").test(intent))
+                    return true;
+            }
+            catch (e) {
+                console.warn(`Invalid exclude regex: ${pattern}`);
+            }
+        }
+    }
+    return false;
+}
+function scoreRoute(intent, route) {
+    let score = 0;
+    const matches = [];
+    const lower = intent.toLowerCase();
+    const rules = route.match;
+    // 1. Check ALL
+    const allList = [...(rules.all || []), ...(rules.all_keywords || [])];
+    if (allList.length > 0) {
+        for (const kw of allList) {
+            if (lower.includes(kw.toLowerCase())) {
+                score += 1;
+                matches.push(`all:${kw}`);
+            }
+            else {
+                return { score: 0, matches: [] }; // Failed ALL condition
+            }
+        }
+    }
+    // 2. Check ANY + Phrases
+    const anyList = [
+        ...(rules.any || []),
+        ...(rules.any_keywords || []),
+        ...(rules.phrases || [])
+    ];
+    if (anyList.length > 0) {
+        for (const kw of anyList) {
+            if (lower.includes(kw.toLowerCase())) {
+                score += 1;
+                matches.push(`any:${kw}`);
+            }
+        }
+    }
+    // 3. Check Regex
+    if (rules.regex) {
+        for (const pattern of rules.regex) {
+            try {
+                if (new RegExp(pattern, "i").test(intent)) {
+                    score += 2;
+                    matches.push(`regex:${pattern}`);
+                }
+            }
+            catch (e) {
+                console.warn(`Invalid match regex in route ${route.route_id}: ${pattern}`);
+            }
+        }
+    }
+    // Boost
+    if (score > 0 && route.boost) {
+        score += route.boost;
+    }
+    return { score, matches };
+}

package/dist/iris/routes.js

@@ -0,0 +1,189 @@
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import { repoRoot } from "../lib.js";
+import { resolveArtifactPath } from "./resolver.js";
+import kleur from "kleur";
+// --- Errors ---
+export class RoutesError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RoutesError";
+    }
+}
+export class RoutesLoadError extends RoutesError {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "RoutesLoadError";
+    }
+}
+export class RoutesOverlayMissingError extends RoutesError {
+    constructor(message) {
+        super(message);
+        this.name = "RoutesOverlayMissingError";
+    }
+}
+// --- Loaders ---
+export function loadBaseRoutes(framework, root) {
+    try {
+        const r = root || repoRoot();
+        // 1. Framework Priority
+        if (framework && framework.files.routes && fs.existsSync(framework.files.routes)) {
+            const content = fs.readFileSync(framework.files.routes, "utf8");
+            const doc = yaml.load(content);
+            validateRoutes(doc, "framework-base");
+            validateRoutes(doc, "framework-base");
+            doc.routes.forEach(r => r._source = "base");
+            Object.defineProperty(doc, '_meta', {
+                value: { sourceKind: "framework", sourcePath: framework.files.routes },
+                enumerable: false,
+                writable: true
+            });
+            return doc;
+        }
+        // 2. Legacy Fallback
+        const legacyPath = resolveArtifactPath(r, ".iris/routes.yaml");
+        if (fs.existsSync(legacyPath)) {
+            if (framework) {
+                console.error(kleur.yellow(`IRIS_WARNING IRIS_DEPRECATED_LEGACY_ROUTES: framework=${framework.manifest.id} missing routes.yaml; using .iris/routes.yaml`));
+            }
+            const content = fs.readFileSync(legacyPath, "utf8");
+            const doc = yaml.load(content);
+            validateRoutes(doc, "legacy-base");
+            doc.routes.forEach(r => r._source = "base");
+            Object.defineProperty(doc, '_meta', {
+                value: { sourceKind: "legacy", sourcePath: legacyPath },
+                enumerable: false,
+                writable: true
+            });
+            return doc;
+        }
+        throw new RoutesLoadError(`Missing required routes.yaml (Checked framework '${framework?.manifest.id || 'none'}' and legacy .iris/routes.yaml)`);
+    }
+    catch (error) {
+        if (error instanceof RoutesError)
+            throw error;
+        throw new RoutesLoadError("Failed to load base routes", error);
+    }
+}
+export const loadRoutes = (root) => loadBaseRoutes(null, root);
+/**
+ * Loads Effective Routes: Base + User Repo Overlay.
+ */
+export function loadEffectiveRoutes(framework, root, activeFlowId) {
+    // 1. Load Base (Framework or Legacy)
+    // Note: base is required. loadBaseRoutes throws if missing.
+    const r = root || repoRoot();
+    const base = loadBaseRoutes(framework, r);
+    // Determine Overlay Namespace: Flow ID (if active) OR Framework ID (if loaded)
+    const overlayNamespace = activeFlowId || framework?.manifest.id;
+    if (!overlayNamespace)
+        return base;
+    try {
+        // User Repo Overlay: .iris/overlays/<namespace>/routes.yaml
+        // This allows the user to override routing via flow OR framework namespace.
+        const overlayPath = path.join(r, ".iris/overlays", overlayNamespace, "routes.yaml");
+        if (fs.existsSync(overlayPath)) {
+            const content = fs.readFileSync(overlayPath, "utf8");
+            const overlay = (yaml.load(content) || {});
+            const merged = mergeRoutes(base, overlay);
+            Object.defineProperty(merged, '_meta', {
+                value: {
+                    sourceKind: "mixed",
+                    sourcePath: overlayPath
+                },
+                enumerable: false,
+                writable: true
+            });
+            return merged;
+        }
+        // Return base if no overlay found (Optional)
+        // Ensure we throw if explicit namespace was requested but not found?
+        // The test expects RoutesOverlayMissingError if "missing" flow is passed.
+        // Assuming if overlayNamespace is provided, we EXPECT an overlay.
+        if (overlayNamespace) {
+            // Only throw if this was an EXPLICIT flow request (activeFlowId is set)
+            // If it fell back to framework ID, treat overlay as optional.
+            if (activeFlowId) {
+                throw new RoutesOverlayMissingError(`Routes overlay not found for namespace '${overlayNamespace}' at ${overlayPath}`);
+            }
+            // else: explicit overlay not found for base framework -> return base (safe)
+        }
+        return base;
+    }
+    catch (error) {
+        if (error instanceof RoutesError)
+            throw error;
+        throw new RoutesLoadError(`Failed to load effective routes for namespace '${overlayNamespace}'`, error);
+    }
+}
+/**
+ * Merges routes purely.
+ */
+export function mergeRoutes(base, overlay) {
+    // Deep clone base
+    const result = JSON.parse(JSON.stringify(base));
+    // 1. Merge Default
+    if (overlay.default) {
+        result.default = { ...result.default, ...overlay.default };
+    }
+    if (!overlay.routes || !Array.isArray(overlay.routes)) {
+        return result;
+    }
+    // Validate Overlay Routes first
+    overlay.routes.forEach(r => validateRoute(r, "overlay"));
+    // 2. Merge Routes
+    const baseMap = new Map();
+    result.routes.forEach((r, idx) => baseMap.set(r.route_id, idx));
+    const newRoutes = [];
+    for (const oRoute of overlay.routes) {
+        if (baseMap.has(oRoute.route_id)) {
+            // Override
+            const idx = baseMap.get(oRoute.route_id);
+            result.routes[idx] = {
+                ...result.routes[idx],
+                ...oRoute,
+                _source: "merged"
+            };
+        }
+        else {
+            // New
+            newRoutes.push({
+                ...oRoute,
+                _source: "overlay"
+            });
+        }
+    }
+    // Prepend new routes
+    if (newRoutes.length > 0) {
+        result.routes.unshift(...newRoutes);
+    }
+    // Validate Final Result (Uniqueness check)
+    validateRoutes(result, "effective");
+    return result;
+}
+// --- Validation Helpers ---
+function validateRoutes(routes, context) {
+    if (!routes || !routes.routes) {
+        throw new RoutesLoadError(`Invalid routes format (${context}): 'routes' array missing.`);
+    }
+    const seenIds = new Set();
+    routes.routes.forEach(r => {
+        validateRoute(r, context);
+        if (seenIds.has(r.route_id)) {
+            throw new RoutesLoadError(`Duplicate route_id found (${context}): '${r.route_id}'`);
+        }
+        seenIds.add(r.route_id);
+    });
+}
+function validateRoute(r, context) {
+    if (!r.route_id || typeof r.route_id !== "string" || !r.route_id.trim()) {
+        throw new RoutesLoadError(`Invalid route in ${context}: route_id must be a non-empty string.`);
+    }
+    // Normalize Phase
+    if (r.phase) {
+        r.phase = r.phase.toLowerCase();
+    }
+}

package/dist/iris/run-state.js

@@ -0,0 +1,146 @@
+import fs from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+import { WorkflowStage } from "../bridge/types.js";
+const RUNS_DIR = path.join(process.cwd(), ".iris/runs");
+import { generateIntentId } from "./utils/interpolate.js";
+/**
+ * Create a new workflow run
+ */
+export function createRun(intent, ideId, gateMode = "manual") {
+    const runId = randomUUID();
+    const now = new Date().toISOString();
+    const intentId = generateIntentId({ goal: intent }); // Fallback to intent processing if draft is missing
+    const runState = {
+        runId,
+        intent,
+        intentId,
+        ideId,
+        stage: WorkflowStage.INTENT_INCEPTION,
+        gateMode,
+        artifacts: [],
+        bolts: [],
+        currentBoltIndex: 0,
+        pendingTasks: [],
+        events: [],
+        createdAt: now,
+        updatedAt: now
+    };
+    saveRun(runState);
+    return runState;
+}
+/**
+ * Load a run by ID
+ */
+export function loadRun(runId) {
+    const runPath = path.join(RUNS_DIR, `${runId}.json`);
+    if (!fs.existsSync(runPath)) {
+        throw new Error(`Run not found: ${runId}`);
+    }
+    const content = fs.readFileSync(runPath, "utf8");
+    return JSON.parse(content);
+}
+/**
+ * Save run state
+ */
+export function saveRun(state) {
+    if (!fs.existsSync(RUNS_DIR)) {
+        fs.mkdirSync(RUNS_DIR, { recursive: true });
+    }
+    state.updatedAt = new Date().toISOString();
+    const runPath = path.join(RUNS_DIR, `${state.runId}.json`);
+    fs.writeFileSync(runPath, JSON.stringify(state, null, 2), "utf8");
+    // Also save a small state snapshot for quick resume
+    const statePath = path.join(RUNS_DIR, `${state.runId}.state.json`);
+    const snapshot = {
+        runId: state.runId,
+        stage: state.stage,
+        currentBoltIndex: state.currentBoltIndex,
+        updatedAt: state.updatedAt
+    };
+    fs.writeFileSync(statePath, JSON.stringify(snapshot, null, 2), "utf8");
+}
+/**
+ * Append an event to the run
+ */
+export function appendEvent(runId, event) {
+    const state = loadRun(runId);
+    const fullEvent = {
+        ...event,
+        timestamp: new Date().toISOString()
+    };
+    state.events.push(fullEvent);
+    saveRun(state);
+}
+/**
+ * Generate a human-readable summary of the run
+ */
+export function generateRunSummary(runId) {
+    const state = loadRun(runId);
+    let summary = `# IRIS Workflow Run: ${runId}\n\n`;
+    summary += `**Intent:** ${state.intent}\n`;
+    summary += `**IDE:** ${state.ideId}\n`;
+    summary += `**Stage:** ${state.stage}\n`;
+    summary += `**Created:** ${state.createdAt}\n`;
+    summary += `**Updated:** ${state.updatedAt}\n\n`;
+    summary += `## Artifacts Created\n\n`;
+    if (state.artifacts.length > 0) {
+        summary += state.artifacts.map(a => `- \`${a}\``).join("\n") + "\n\n";
+    }
+    else {
+        summary += "*No artifacts yet*\n\n";
+    }
+    summary += `## Bolts\n\n`;
+    if (state.bolts.length > 0) {
+        state.bolts.forEach(bolt => {
+            summary += `### ${bolt.id} (${bolt.status})\n`;
+            if (bolt.designCompleted)
+                summary += "- ✓ Design\n";
+            if (bolt.implementationCompleted)
+                summary += "- ✓ Implementation\n";
+            if (bolt.testingCompleted)
+                summary += "- ✓ Testing\n";
+            summary += "\n";
+        });
+    }
+    else {
+        summary += "*No bolts yet*\n\n";
+    }
+    summary += `## Event Log\n\n`;
+    state.events.forEach(event => {
+        summary += `**${event.timestamp}** [${event.stage}] ${event.action}\n`;
+        if (event.message)
+            summary += `  ${event.message}\n`;
+        if (event.userGateDecision)
+            summary += `  Gate: ${event.userGateDecision}\n`;
+        summary += "\n";
+    });
+    return summary;
+}
+/**
+ * Save run summary to markdown file
+ */
+export function saveRunSummary(runId) {
+    const summary = generateRunSummary(runId);
+    const summaryPath = path.join(RUNS_DIR, `${runId}.md`);
+    fs.writeFileSync(summaryPath, summary, "utf8");
+}
+/**
+ * List all runs
+ */
+export function listRuns() {
+    if (!fs.existsSync(RUNS_DIR)) {
+        return [];
+    }
+    const files = fs.readdirSync(RUNS_DIR);
+    const stateFiles = files.filter(f => f.endsWith(".state.json"));
+    return stateFiles.map(file => {
+        const content = fs.readFileSync(path.join(RUNS_DIR, file), "utf8");
+        const snapshot = JSON.parse(content);
+        return {
+            runId: snapshot.runId,
+            stage: snapshot.stage,
+            updatedAt: snapshot.updatedAt
+        };
+    }).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}

package/dist/iris/state.js

@@ -0,0 +1,113 @@
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import { EXIT_CODES } from "../utils/exit-codes.js";
+const STATE_FILE_PATH = path.join(process.cwd(), ".iris/state.yaml");
+export const DEFAULT_STATE = {
+    version: 1,
+    framework: {
+        current: "iris-core",
+        version: null,
+    },
+    phase: {
+        current: "inception",
+        requested: null,
+    },
+    active: {
+        intent_id: null,
+        unit_id: null,
+        bolt_id: null,
+        flow: null,
+    },
+    last_validation: {
+        at: null,
+        result: null,
+    },
+};
+export function loadState() {
+    try {
+        if (!fs.existsSync(STATE_FILE_PATH)) {
+            // Auto-create directory if it doesn't exist
+            const dir = path.dirname(STATE_FILE_PATH);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            saveState(DEFAULT_STATE);
+            return DEFAULT_STATE;
+        }
+        const content = fs.readFileSync(STATE_FILE_PATH, "utf8");
+        const doc = yaml.load(content);
+        // Start with defaults to ensure all fields exist (deep merge strategy)
+        // We manually merge top-level objects to avoid losing nested defaults
+        const merged = {
+            ...DEFAULT_STATE,
+            ...doc,
+            framework: { ...DEFAULT_STATE.framework, ...doc.framework },
+            phase: { ...DEFAULT_STATE.phase, ...doc.phase },
+            active: { ...DEFAULT_STATE.active, ...doc.active },
+            last_validation: { ...DEFAULT_STATE.last_validation, ...doc.last_validation },
+            // Optional fields
+            ide: doc.ide ? { ...doc.ide } : undefined,
+            bridge: doc.bridge ? { ...doc.bridge } : undefined,
+        };
+        // Migration/Fixup for legacy/bundled schema
+        if (doc.current_phase && !doc.phase) {
+            merged.phase = {
+                current: doc.current_phase.toLowerCase(), // Normalize to lowercase
+                requested: null
+            };
+        }
+        // Ensure flow exists (backward compatibility)
+        if (merged.active.flow === undefined)
+            merged.active.flow = null;
+        return merged;
+    }
+    catch (error) {
+        console.error("Failed to load or create .iris/state.yaml:", error);
+        process.exit(EXIT_CODES.STATE_ERROR);
+    }
+}
+export function saveState(state) {
+    try {
+        const content = yaml.dump(state);
+        fs.writeFileSync(STATE_FILE_PATH, content, "utf8");
+    }
+    catch (error) {
+        console.error("Failed to write .iris/state.yaml:", error);
+        process.exit(EXIT_CODES.STATE_ERROR);
+    }
+}
+/**
+ * Get the selected IDE from state, or null if not set
+ */
+export function getSelectedIde() {
+    const state = loadState();
+    return state.ide?.id || null;
+}
+/**
+ * Set the selected IDE in state
+ */
+export function setSelectedIde(ideId) {
+    const state = loadState();
+    state.ide = {
+        id: ideId,
+        selected_at: new Date().toISOString()
+    };
+    saveState(state);
+}
+/**
+ * Get the active framework info
+ */
+export function getActiveFramework(state = loadState()) {
+    return state.framework;
+}
+/**
+ * Set the active framework
+ */
+export function setActiveFramework(state, id, version = null) {
+    state.framework = {
+        current: id,
+        version: version
+    };
+    saveState(state);
+}

package/dist/iris/templates.js

@@ -0,0 +1,70 @@
+export const UNIT_BRIEF_TEMPLATE = `---
+id: {{unitId}}
+status: draft
+---
+
+# Unit Brief: {{title}}
+
+## Objective
+{{summary}}
+
+## Scope
+### In Scope
+- [ ] Implementation item 1
+- [ ] Implementation item 2
+
+### Out of Scope
+- Non-goals for this unit
+
+## Acceptance Criteria
+- [ ] Criteria 1
+- [ ] Criteria 2
+
+## Risks
+- Risk 1
+`;
+export const BOLT_TEMPLATE = `---
+id: {{boltId}}
+unit: {{unitId}}
+status: draft
+type: feature
+files:
+  - src/index.ts
+cwd: .
+commands:
+  test: npm test
+---
+
+# Bolt: {{title}}
+
+## Implementation Plan
+- [ ] Step 1
+- [ ] Step 2
+
+## Files to Touch
+- src/index.ts
+
+## Verification Plan
+### Automated Tests
+- \`npm test\`
+
+### Manual Verification
+- Check output
+`;
+export const TEST_REPORT_TEMPLATE = `---
+bolt: {{boltId}}
+status: {{status}}
+timestamp: {{timestamp}}
+---
+
+# Test Report: {{title}}
+
+## Summary
+Status: {{status}}
+Time: {{timestamp}}
+
+## Output
+\`\`\`
+{{output}}
+\`\`\`
+`;