project-iris 0.0.8 → 0.0.12

package/dist/iris/routes.js

@@ -1,20 +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 { EXIT_CODES } from "../utils/exit-codes.js";
-export function loadRoutes() {
-    const root = repoRoot();
-    const routesPath = resolveArtifactPath(root, ".iris/routes.yaml");
-    if (!fs.existsSync(routesPath)) {
-        return null;
+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 content = fs.readFileSync(routesPath, "utf8");
-        return yaml.load(content);
+        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.`);
     }
-    catch (e) {
-        console.error("Failed to parse .iris/routes.yaml:", e);
-        process.exit(EXIT_CODES.POLICY_ERROR);
+    // Normalize Phase
+    if (r.phase) {
+        r.phase = r.phase.toLowerCase();
     }
 }

package/dist/iris/run-state.js

@@ -3,15 +3,18 @@ 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,

package/dist/iris/state.js

@@ -5,6 +5,10 @@ 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,
@@ -13,6 +17,7 @@ export const DEFAULT_STATE = {
         intent_id: null,
         unit_id: null,
         bolt_id: null,
+        flow: null,
     },
     last_validation: {
         at: null,
@@ -32,7 +37,19 @@ export function loadState() {
         }
         const content = fs.readFileSync(STATE_FILE_PATH, "utf8");
         const doc = yaml.load(content);
-        const merged = { ...DEFAULT_STATE, ...doc };
+        // 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 = {
@@ -40,14 +57,9 @@ export function loadState() {
                 requested: null
             };
         }
-        // Ensure nested objects exist
-        if (!merged.phase)
-            merged.phase = { ...DEFAULT_STATE.phase };
-        if (!merged.active)
-            merged.active = { ...DEFAULT_STATE.active };
-        if (!merged.last_validation || typeof merged.last_validation !== 'object') {
-            merged.last_validation = { ...DEFAULT_STATE.last_validation };
-        }
+        // Ensure flow exists (backward compatibility)
+        if (merged.active.flow === undefined)
+            merged.active.flow = null;
         return merged;
     }
     catch (error) {
@@ -83,3 +95,19 @@ export function setSelectedIde(ideId) {
     };
     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}}
+\`\`\`
+`;

package/dist/iris/tmp.js

@@ -0,0 +1,24 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+export function makeTempDir(prefix) {
+    // Ensure the prefix is safe and doesn't contain path separators
+    const safePrefix = prefix.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return fs.mkdtempSync(path.join(os.tmpdir(), `iris-${safePrefix}-`));
+}
+export function removeTempDir(dir) {
+    try {
+        if (fs.existsSync(dir)) {
+            // Use rmSync with force and recursive options for robust deletion
+            // This is available in Node.js 14.14.0+
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }
+    catch (err) {
+        // Log but don't throw, cleanup failure shouldn't crash the main process
+        // unless strictly required. For CLI tools, silence is usually gold for cleanup.
+        // However, if verbose logging was available here we'd use it. 
+        // For now, we swallow the error to prevent crashing.
+        // console.warn(`Failed to remove temp dir ${dir}:`, err);
+    }
+}

package/dist/iris/uninstaller.js

@@ -70,9 +70,15 @@ export async function uninstallIris(options) {
     // Actually if we remove .iris entire folder, we don't need to do C.
     // Step D: Remove doctrine prompt
     let removeDoctrine = false;
+    const isNonInteractive = options.force || options.yes || !!process.env.CI;
     if (options.force) {
         removeDoctrine = true;
     }
+    else if (isNonInteractive) {
+        // Safe default: Preserve doctrine in non-interactive/CI unless --force is used
+        removeDoctrine = false;
+        console.log(kleur.gray("Non-interactive mode (CI/--yes): Preserving .iris/ directory by default."));
+    }
     else {
         const { confirm } = await inquirer.prompt([
             {
@@ -92,15 +98,24 @@ export async function uninstallIris(options) {
         console.log(kleur.gray("Kept .iris/ directory."));
     }
     // Step E: Memory Bank
-    if (!options.keepMemory) {
-        const { confirmMemory } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "confirmMemory",
-                message: "Keep memory-bank/ folder? (default: Yes, keep)",
-                default: true
-            }
-        ]);
+    if (!options.keepMemory && !options.force) {
+        let confirmMemory = true; // Default Keep
+        if (isNonInteractive) {
+            // Safe default: Preserve memory bank
+            confirmMemory = true;
+            console.log(kleur.gray("Non-interactive mode: Preserving memory-bank/ by default."));
+        }
+        else {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: "Keep memory-bank/ folder? (default: Yes, keep)",
+                    default: true
+                }
+            ]);
+            confirmMemory = confirm;
+        }
         if (!confirmMemory) { // User said "No" to keeping -> Delete
             // Check if empty or created by us
             // Created dirs = manifest.created_dirs

package/dist/iris/utils/interpolate.js

@@ -0,0 +1,42 @@
+/**
+ * Interpolates tokens in a string.
+ * Currently supports: {intentId}
+ * Throws on unknown tokens.
+ */
+export function interpolateTokens(str, tokens) {
+    return str.replace(/\{(\w+)\}/g, (match, key) => {
+        if (key === 'intentId') {
+            if (!tokens.intentId) {
+                throw new Error(`Token {intentId} requires intentId value but none provided`);
+            }
+            return tokens.intentId;
+        }
+        throw new Error(`Unknown token {${key}} in path: ${str}`);
+    });
+}
+/**
+ * Generates a unique intentId from draft fields.
+ * Format: YYYYMMDD-HHMMSS-<slug>
+ * Slug priority: goal > problem > valueProp > fallback
+ */
+export function generateIntentId(draft) {
+    const now = new Date();
+    const date = [
+        now.getFullYear(),
+        String(now.getMonth() + 1).padStart(2, '0'),
+        String(now.getDate()).padStart(2, '0')
+    ].join('');
+    const time = [
+        String(now.getHours()).padStart(2, '0'),
+        String(now.getMinutes()).padStart(2, '0'),
+        String(now.getSeconds()).padStart(2, '0')
+    ].join('');
+    const source = draft?.goal || draft?.problem || draft?.valueProp || 'intent';
+    const slug = source
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 40);
+    return `${date}-${time}-${slug || 'intent'}`;
+}

package/dist/iris/validator.js

@@ -1,16 +1,17 @@
 import fs from "fs";
 import path from "path";
 import matter from "gray-matter";
-import { loadPolicy } from "./policy.js";
+import { loadEffectivePolicy } from "./policy.js";
 import { loadState, saveState } from "./state.js";
 import { checkArtifact } from "./artifact-checker.js";
-// Force specific phases to be valid per context? Or just trust policy? context says "Valid Phases: inception, construction, operations"
-// We will rely on policy.yaml for configuration but code logic handles general cases.
+import glob from "fast-glob";
+import { interpolateTokens } from "./utils/interpolate.js";
 export async function validate(options) {
     const shouldWrite = options.writeBack !== false;
     // Step A: Load & validate config
-    const policy = loadPolicy();
+    // May throw PolicyLoadError or PolicyOverlayMissingError - caller must handle
     const state = loadState();
+    const policy = loadEffectivePolicy(options.frameworkResolution, undefined, state.active.flow);
     const errors = [];
     // Step B: Resolve target phase
     let targetPhase = state.phase.current;
@@ -30,7 +31,45 @@ export async function validate(options) {
     // Gather requirements for the phase
     const requirements = policy.phases[targetPhase].requires || [];
     for (const req of requirements) {
-        const check = checkArtifact(process.cwd(), req.path, req.type);
+        let reqPath = req.path;
+        try {
+            // Interpolate path with intentId if available
+            reqPath = interpolateTokens(req.path, { intentId: state.active.intent_id || undefined });
+        }
+        catch (e) {
+            // If interpolation fails (e.g. missing intentId), we treat it as an error
+            errors.push({
+                code: "CONFIG_ERROR",
+                message: `Policy requirement path interpolation failed: ${e.message}`,
+                severity: "error"
+            });
+            continue;
+        }
+        if (glob.isDynamicPattern(reqPath)) {
+            const matches = glob.sync(reqPath, { cwd: process.cwd(), onlyFiles: req.type === 'file', onlyDirectories: req.type === 'directory' });
+            if (matches.length === 0) {
+                errors.push({
+                    code: "MISSING_ARTIFACT",
+                    path: reqPath,
+                    message: `No artifacts found matching required pattern: ${reqPath}`,
+                    remediation: req.template
+                        ? `Create artifact matching pattern`
+                        : `Create ${req.type} matching ${reqPath}`,
+                    severity: "error"
+                });
+            }
+            else {
+                // Check quality for all matches?
+                for (const match of matches) {
+                    const check = checkArtifact(process.cwd(), match, req.type);
+                    if (req.type === "file") {
+                        errors.push(...checkContentQuality(check.absolutePath));
+                    }
+                }
+            }
+            continue;
+        }
+        const check = checkArtifact(process.cwd(), reqPath, req.type);
         if (!check.exists) {
             errors.push({
                 code: "MISSING_ARTIFACT",
@@ -89,9 +128,21 @@ export async function validate(options) {
     const gates = policy.phases[targetPhase].gates || [];
     for (const gate of gates) {
         if (gate.kind === "frontmatter") {
-            const gateError = checkFrontmatterGate(gate);
-            if (gateError) {
-                errors.push(gateError);
+            try {
+                // Create a copy with interpolated file path
+                const interpolatedGate = { ...gate };
+                interpolatedGate.file = interpolateTokens(gate.file, { intentId: state.active.intent_id || undefined });
+                const gateError = checkFrontmatterGate(interpolatedGate);
+                if (gateError) {
+                    errors.push(gateError);
+                }
+            }
+            catch (e) {
+                errors.push({
+                    code: "CONFIG_ERROR",
+                    message: `Gate file path interpolation failed: ${e.message}`,
+                    severity: "error"
+                });
             }
         }
         else {
@@ -207,7 +258,18 @@ function checkFrontmatterGate(gate) {
             };
         }
         if (gate.field) {
-            const val = parsed.data[gate.field];
+            // Support dot-notation for nested fields
+            const fields = gate.field.split('.');
+            let val = parsed.data;
+            for (const f of fields) {
+                if (val && typeof val === 'object') {
+                    val = val[f];
+                }
+                else {
+                    val = undefined;
+                    break;
+                }
+            }
             if (val === undefined) {
                 return {
                     code: "GATE_FIELD_MISSING",
@@ -217,7 +279,7 @@ function checkFrontmatterGate(gate) {
                     severity: "error"
                 };
             }
-            if (gate.equals !== undefined && val !== gate.equals) {
+            if (gate.equals !== undefined && String(val) !== String(gate.equals)) {
                 return {
                     code: "GATE_VALUE_MISMATCH",
                     path: gate.file,

package/dist/iris/workflow/config.js

@@ -0,0 +1,51 @@
+import yaml from "js-yaml";
+import fs from "fs";
+import { FrameworkError } from "../../framework/framework-types.js";
+// Default workflow for frameworks that don't specify one
+export const DEFAULT_WORKFLOW_CONFIG = {
+    schemaVersion: 1,
+    steps: [
+        { id: "interview", kind: "interview" },
+        { id: "artifacts", kind: "artifacts" },
+        { id: "plan", kind: "planning" },
+        { id: "build", kind: "construction" },
+        { id: "execute", kind: "execution" },
+        { id: "validate", kind: "validate" },
+        { id: "pack", kind: "pack" },
+        { id: "handoff", kind: "handoff" }
+    ]
+};
+export function loadEffectiveWorkflowConfig(framework) {
+    if (!framework || !framework.files.workflow) {
+        return DEFAULT_WORKFLOW_CONFIG;
+    }
+    try {
+        const content = fs.readFileSync(framework.files.workflow, "utf-8");
+        const doc = yaml.load(content);
+        if (!doc)
+            throw new Error("Empty workflow file");
+        // Basic schema validation
+        if (doc.schemaVersion !== 1) {
+            throw new FrameworkError("INVALID_SCHEMA", framework.files.workflow, `Unsupported workflow schema version: ${doc.schemaVersion}. Only version 1 is supported.`);
+        }
+        if (!Array.isArray(doc.steps)) {
+            throw new FrameworkError("INVALID_SCHEMA", framework.files.workflow, "Workflow must have a 'steps' array.");
+        }
+        // Validate steps
+        for (const step of doc.steps) {
+            if (!step.id || !step.kind) {
+                throw new FrameworkError("INVALID_SCHEMA", framework.files.workflow, "Workflow steps must have 'id' and 'kind'.");
+            }
+            if (!['interview', 'artifacts', 'planning', 'construction', 'validate', 'pack', 'handoff', 'execution'].includes(step.kind)) {
+                throw new FrameworkError("INVALID_SCHEMA", framework.files.workflow, `Unknown step kind: '${step.kind}'.`);
+            }
+        }
+        return doc;
+    }
+    catch (e) {
+        // Wrap generic errors
+        if (e instanceof FrameworkError)
+            throw e;
+        throw new FrameworkError("INVALID_YAML", framework.files.workflow, `Failed to parse workflow configuration: ${e.message}`);
+    }
+}