project-iris 0.0.8 → 0.0.11

package/dist/iris/interview/types.js

@@ -0,0 +1,16 @@
+export const KNOWN_INTENT_FIELDS = new Set([
+    'successCriteria',
+    'user',
+    'problem',
+    'constraints',
+    'nonGoals',
+    'risks',
+    'acceptanceTests',
+    'context',
+    'context.user',
+    'context.phase',
+    'visuals',
+    'name', // Sometimes inferred, but valid
+    'description', // Basic
+    'features', // High level
+]);

package/dist/iris/interview/utils.js

@@ -0,0 +1,38 @@
+/**
+ * Access a value in an object via dot-notation.
+ * Safe traversal: returns undefined if path breaks.
+ */
+export function getByPath(obj, path) {
+    if (!obj)
+        return undefined;
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Checks if a value is "missing" according to strict interview rules.
+ * Missing = null, undefined, empty string "", whitespace-only string, or empty array [].
+ */
+export function isMissing(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (typeof value === 'string')
+        return value.trim().length === 0;
+    if (Array.isArray(value))
+        return value.length === 0;
+    // Objects? We typically check leaf nodes, but an empty object {} usually counts as present for 'context'
+    // UNLESS the requirement is specifically context.user.
+    // So for generic objects, existence is enough.
+    return false;
+}
+/**
+ * Returns a list of required fields that are missing in the draft.
+ */
+export function getMissingFields(draft, requiredFields) {
+    return requiredFields.filter(field => isMissing(getByPath(draft, field)));
+}

package/dist/iris/packer.js

@@ -3,11 +3,11 @@ import path from "path";
 import kleur from "kleur";
 import { repoRoot, writeFile, ensureDir } from "../lib.js";
 import { loadState } from "./state.js";
-import { loadPolicy } from "./policy.js";
+import { loadEffectivePolicy } from "./policy.js";
 import { validate } from "./validator.js";
 import { resolveIncludes, getFileContent } from "./include.js";
 import { checkArtifact } from "./artifact-checker.js";
-import { EXIT_CODES } from "../utils/exit-codes.js";
+import { collectDoctrineFiles } from "./doctrine/collector.js";
 export async function generatePack(options) {
     const root = repoRoot();
     // 1. Validate Repo (Guardrail)
@@ -15,20 +15,27 @@ export async function generatePack(options) {
         const result = await validate({
             apply: false,
             strict: false,
-            writeBack: false
+            writeBack: false,
+            frameworkResolution: options.frameworkResolution
         });
         if (!result.valid) {
-            console.error(kleur.red("Repo is INVALID. Fix issues before packing."));
-            process.exit(EXIT_CODES.INVALID); // Exit 2
+            const msg = !options.quiet ? kleur.red("Repo is INVALID. Fix issues before packing.") : "Repo is INVALID";
+            if (!options.quiet)
+                console.error(msg);
+            throw new Error(typeof msg === 'string' ? msg : "Repo is INVALID");
         }
         if (options.strict && result.warnings) {
-            console.error(kleur.red("Repo has warnings and strict mode is on."));
-            process.exit(EXIT_CODES.INVALID);
+            const msg = !options.quiet ? kleur.red("Repo has warnings and strict mode is on.") : "Repo has warnings";
+            if (!options.quiet)
+                console.error(msg);
+            throw new Error(typeof msg === 'string' ? msg : "Repo has warnings");
         }
     }
     catch (e) {
-        console.error("Validation failed:", e);
-        process.exit(EXIT_CODES.INVALID);
+        // If policy loading fails, we should catch it here
+        if (!options.quiet)
+            console.error("Validation failed:", e);
+        throw new Error(`Validation failed: ${e.message}`);
     }
     // 2. Load State & Determine Context
     const state = loadState();
@@ -36,9 +43,9 @@ export async function generatePack(options) {
     const agent = options.agent || inferAgent(phase);
     // 3. Collect Candidates
     // Doctrine
-    const doctrineFiles = collectDoctrine(agent);
+    const doctrineFiles = collectDoctrine(root, state.active.flow);
     // Required Artifacts
-    const requiredArtifacts = collectRequiredArtifacts(phase, state);
+    const requiredArtifacts = collectRequiredArtifacts(phase, state, options.frameworkResolution);
     // Optional Artifacts
     const optionalArtifacts = collectOptionalArtifacts(phase);
     // Included Artifacts
@@ -58,13 +65,18 @@ export async function generatePack(options) {
             // Use artifact checker for proper validation
             const check = checkArtifact(root, p);
             if (!check.exists) {
-                console.error(kleur.red(`Missing required artifact: ${check.normalized}`));
-                process.exit(EXIT_CODES.INVALID);
+                const msg = `Missing required artifact: ${check.normalized}`;
+                if (!options.quiet)
+                    console.error(kleur.red(msg));
+                throw new Error(msg);
             }
             // For files, also check if content was readable
+            // Absolute path fix in resolver.ts implies this works now
             if (check.isFile && res.skipped === "read_error") {
-                console.error(kleur.red(`Cannot read required artifact: ${check.normalized}`));
-                process.exit(EXIT_CODES.INVALID);
+                const msg = `Cannot read required artifact: ${check.normalized}`;
+                if (!options.quiet)
+                    console.error(kleur.red(msg));
+                throw new Error(msg);
             }
         }
         coreContent.push(res);
@@ -86,7 +98,7 @@ export async function generatePack(options) {
     }
     // 5. Enforce Limits
     const maxBytes = options.maxBytes || 1_500_000;
-    const finalSelection = enforceLimits(coreContent, optionalContent, extraContent, maxBytes);
+    const finalSelection = enforceLimits(coreContent, optionalContent, extraContent, maxBytes, options.quiet);
     // 6. Format
     const markdown = formatBundle(finalSelection, {
         repo: path.basename(root),
@@ -95,7 +107,7 @@ export async function generatePack(options) {
         generatedAt: new Date().toISOString()
     });
     // 7. Output
-    if (options.stdout) {
+    if (options.stdout && !options.json) {
         console.log(markdown);
         if (options.output) {
             writeFile(options.output, markdown);
@@ -103,15 +115,36 @@ export async function generatePack(options) {
     }
     else {
         const outFile = options.output || path.join(root, `.iris/inbox/context-${phase}-${agent}.md`);
-        writeFile(outFile, markdown);
-        // Write LATEST
-        const latestFile = path.join(root, ".iris/inbox/LATEST.md");
-        ensureDir(path.dirname(latestFile)); // Ensure dir exists for LATEST too
-        const relPath = path.relative(path.dirname(latestFile), outFile);
-        writeFile(latestFile, relPath);
-        console.log(kleur.green(`Packed context bundle to: ${outFile}`));
-        console.log(kleur.gray(`Size: ${(markdown.length / 1024).toFixed(1)} KB`));
+        let fileWritten = false;
+        if (!options.stdout) {
+            writeFile(outFile, markdown);
+            // Write LATEST
+            const latestFile = path.join(root, ".iris/inbox/LATEST.md");
+            ensureDir(path.dirname(latestFile));
+            const relPath = path.relative(path.dirname(latestFile), outFile);
+            writeFile(latestFile, relPath);
+            fileWritten = true;
+        }
+        const allCount = finalSelection.core.length + finalSelection.optional.length + finalSelection.extra.length;
+        const result = {
+            path: fileWritten ? outFile : "stdout",
+            size: markdown.length,
+            fileCount: allCount
+        };
+        if (options.json && !options.quiet) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (!options.stdout && !options.quiet) {
+            console.log(kleur.green(`Packed context bundle to: ${outFile}`));
+            console.log(kleur.gray(`Size: ${(markdown.length / 1024).toFixed(1)} KB`));
+        }
+        return result;
     }
+    return {
+        path: options.output || "stdout",
+        size: markdown.length,
+        fileCount: finalSelection.core.length + finalSelection.optional.length + finalSelection.extra.length
+    };
 }
 function inferAgent(phase) {
     switch (phase) {
@@ -121,21 +154,11 @@ function inferAgent(phase) {
         default: return "master";
     }
 }
-function collectDoctrine(agent) {
-    const list = [
-        ".iris/aidlc/quick-start.md",
-        ".iris/aidlc/context/load-order.md",
-        ".iris/aidlc/standards/doctrine-structure.md",
-        ".iris/aidlc/standards/phases-and-gates.md",
-        ".iris/aidlc/validation/phase-preconditions.md",
-        ".iris/aidlc/standards/artifacts-registry.md",
-        ".iris/aidlc/standards/tool-wrappers.md",
-        `.iris/aidlc/agents/iris-${agent}-agent.md`,
-        `.iris/aidlc/commands/iris-${agent}-agent.md`
-    ];
-    return list;
+function collectDoctrine(root, activeFlowId) {
+    // Replaced legacy hardcoded list with flow-aware collector
+    return collectDoctrineFiles(root, activeFlowId);
 }
-function collectRequiredArtifacts(phase, state) {
+function collectRequiredArtifacts(phase, state, framework) {
     const list = [
         ".iris/state.yaml",
         ".iris/policy.yaml"
@@ -146,7 +169,7 @@ function collectRequiredArtifacts(phase, state) {
         list.push(".iris/manifest.yaml");
     // Use Policy Source of Truth
     try {
-        const policy = loadPolicy();
+        const policy = loadEffectivePolicy(framework, undefined, state.active.flow);
         if (policy.phases[phase] && policy.phases[phase].requires) {
             for (const req of policy.phases[phase].requires) {
                 list.push(req.path);
@@ -192,7 +215,7 @@ function getLatestFiles(dir, count) {
     });
     return files.slice(0, count).map(f => f.path);
 }
-function enforceLimits(core, optional, extra, maxBytes) {
+function enforceLimits(core, optional, extra, maxBytes, quiet) {
     let currentSize = sumSize(core) + sumSize(optional) + sumSize(extra);
     const errors = [];
     const skipped = [];
@@ -216,9 +239,11 @@ function enforceLimits(core, optional, extra, maxBytes) {
     }
     if (currentSize > maxBytes) {
         // Hard fail if Core is too big?
-        console.error(kleur.red(`Bundle size (${currentSize}) exceeds --max-bytes limit (${maxBytes}) even after trimming optional content.`));
-        console.error("Required content is too large. Increase limit or clean up artifacts.");
-        process.exit(EXIT_CODES.INVALID);
+        if (!quiet)
+            console.error(kleur.red(`Bundle size (${currentSize}) exceeds --max-bytes limit (${maxBytes}) even after trimming optional content.`));
+        if (!quiet)
+            console.error("Required content is too large. Increase limit or clean up artifacts.");
+        throw new Error(`Bundle size exceeds limit ${maxBytes}`);
     }
     return {
         core,
@@ -244,9 +269,6 @@ function formatBundle(selection, meta) {
     out += `- This bundle contains doctrine + required artifacts.\n\n`;
     // Groups
     const all = [...core, ...optional, ...extra];
-    // Separate Doctrine from others?
-    // Core has doctrine + state + required.
-    // Let's group by type roughly using path analysis
     const doctrine = all.filter(f => f.path.startsWith(".iris/aidlc"));
     const stateFiles = all.filter(f => f.path.startsWith(".iris/") && !f.path.startsWith(".iris/aidlc"));
     const memory = all.filter(f => f.path.startsWith("memory-bank/"));

package/dist/iris/parsers/unit-parser.js

@@ -0,0 +1,43 @@
+export function parseUnitList(content) {
+    const lines = content.split('\n');
+    const units = [];
+    let currentUnit = null;
+    for (const line of lines) {
+        // 1. Check for Unit Header: - [ ] U001: Title
+        const headerMatch = line.match(/^- \[([ x])\] (U\d+): (.+)$/);
+        if (headerMatch) {
+            if (currentUnit) {
+                units.push(currentUnit);
+            }
+            const isChecked = headerMatch[1] === 'x';
+            currentUnit = {
+                id: headerMatch[2],
+                title: headerMatch[3].trim(),
+                summary: '',
+                status: isChecked ? 'done' : 'todo'
+            };
+            continue;
+        }
+        // 2. Check for Summary: summary: ... (must be indented)
+        // We only accept lines starting with whitespace + "summary:"
+        if (currentUnit) {
+            const summaryMatch = line.match(/^\s+summary:\s*(.+)$/);
+            if (summaryMatch) {
+                currentUnit.summary = summaryMatch[1].trim();
+            }
+        }
+        // Ignore other lines
+    }
+    if (currentUnit) {
+        units.push(currentUnit);
+    }
+    // Validate unique IDs
+    const ids = new Set();
+    for (const u of units) {
+        if (ids.has(u.id)) {
+            throw new Error(`Duplicate Unit ID found: ${u.id}`);
+        }
+        ids.add(u.id);
+    }
+    return units;
+}

package/dist/iris/paths.js

@@ -0,0 +1,18 @@
+import path from "path";
+export const IRIS_DOT_DIR = ".iris";
+export const IRIS_INBOX_DIR = path.join(IRIS_DOT_DIR, "inbox");
+export const INTENT_DRAFT_LATEST_FILE = "intent-draft.latest.json";
+export const INTENT_DRAFT_LEGACY_FILE = "intent-draft.json";
+export function getInboxPath(root) {
+    return path.join(root, IRIS_INBOX_DIR);
+}
+export function getLatestDraftPath(root) {
+    return path.join(getInboxPath(root), INTENT_DRAFT_LATEST_FILE);
+}
+export function getLegacyDraftPath(root) {
+    return path.join(getInboxPath(root), INTENT_DRAFT_LEGACY_FILE);
+}
+export function getHistoryDraftPath(root, timestamp) {
+    const ts = timestamp.toISOString().replace(/[-:T]/g, "").split(".")[0];
+    return path.join(getInboxPath(root), `intent-draft-${ts}.json`);
+}

package/dist/iris/policy.js

@@ -1,28 +1,133 @@
 import fs from "fs";
+import path from "path";
 import yaml from "js-yaml";
-import { EXIT_CODES } from "../utils/exit-codes.js";
+import kleur from "kleur";
+export class PolicyError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PolicyError";
+    }
+}
+export class PolicyLoadError extends PolicyError {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "PolicyLoadError";
+    }
+}
 import { resolveArtifactPath } from "./resolver.js";
 import { repoRoot } from "../lib.js";
-export function loadPolicy() {
+// --- Loaders ---
+/**
+ * Loads the base policy from the active framework OR fallback to legacy .iris/policy.yaml.
+ */
+export function loadBasePolicy(framework, root) {
     try {
-        const root = repoRoot();
-        const policyPath = resolveArtifactPath(root, ".iris/policy.yaml");
-        if (!fs.existsSync(policyPath)) {
-            // Policy is REQUIRED.
-            console.error(`Missing required policy file: ${policyPath}`);
-            process.exit(EXIT_CODES.POLICY_ERROR);
+        const r = root || repoRoot();
+        // 1. Framework Priority
+        if (framework && framework.files.policy && fs.existsSync(framework.files.policy)) {
+            const content = fs.readFileSync(framework.files.policy, "utf8");
+            return parsePolicy(content);
+        }
+        // 2. Legacy Fallback
+        const legacyPath = resolveArtifactPath(r, ".iris/policy.yaml");
+        if (fs.existsSync(legacyPath)) {
+            if (framework) {
+                console.error(kleur.yellow(`IRIS_WARNING IRIS_DEPRECATED_LEGACY_POLICY: framework=${framework.manifest.id} missing policy.yaml; using .iris/policy.yaml`));
+            }
+            const content = fs.readFileSync(legacyPath, "utf8");
+            return parsePolicy(content);
         }
-        const content = fs.readFileSync(policyPath, "utf8");
-        const doc = yaml.load(content);
-        // Basic structural check
-        if (!doc || !doc.phases || !doc.transitions) {
-            console.error("Invalid policy file format: 'phases' and 'transitions' are required.");
-            process.exit(EXIT_CODES.POLICY_ERROR);
+        // 3. Hard Failure
+        throw new PolicyLoadError(`Missing required policy file. No active framework policy and no .iris/policy.yaml found at ${legacyPath}`);
+    }
+    catch (error) {
+        if (error instanceof PolicyError)
+            throw error;
+        throw new PolicyLoadError("Failed to load base policy", error);
+    }
+}
+function parsePolicy(content) {
+    const doc = yaml.load(content);
+    // Basic structural check
+    if (!doc || !doc.phases || !doc.transitions) {
+        throw new PolicyLoadError("Invalid base policy format: 'phases' and 'transitions' are required.");
+    }
+    return doc;
+}
+/**
+ * Legacy alias for backward compatibility or simple usage.
+ */
+export const loadPolicy = (root) => loadBasePolicy(null, root);
+/**
+ * Loads the Effective Policy: Base + User Repo Overlay.
+ */
+export function loadEffectivePolicy(framework, root, activeFlowId) {
+    const r = root || repoRoot();
+    const base = loadBasePolicy(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>/policy.yaml
+        const overlayPath = path.join(r, ".iris/overlays", overlayNamespace, "policy.yaml");
+        if (fs.existsSync(overlayPath)) {
+            const content = fs.readFileSync(overlayPath, "utf8");
+            const overlay = (yaml.load(content) || {});
+            return mergePolicies(base, overlay);
         }
-        return doc;
+        // Return base if no overlay
+        return base;
     }
     catch (error) {
-        console.error("Failed to load .iris/policy.yaml:", error);
-        process.exit(EXIT_CODES.POLICY_ERROR);
+        if (error instanceof PolicyError)
+            throw error;
+        throw new PolicyLoadError(`Failed to load effective policy for namespace '${overlayNamespace}'`, error);
+    }
+}
+/**
+ * Merges a base policy with an overlay policy purely.
+ */
+export function mergePolicies(base, overlay) {
+    // Deep clone base using JSON serialization
+    const result = JSON.parse(JSON.stringify(base));
+    if (!overlay.phases)
+        return result;
+    for (const [phaseName, overlayPhase] of Object.entries(overlay.phases)) {
+        if (!overlayPhase)
+            continue;
+        // If base doesn't have this phase, initialize it
+        if (!result.phases[phaseName]) {
+            result.phases[phaseName] = { requires: [], gates: [] };
+        }
+        const basePhase = result.phases[phaseName];
+        // 1. Merge Requirements (Union by path)
+        if (overlayPhase.requires && Array.isArray(overlayPhase.requires)) {
+            const baseMap = new Map();
+            (basePhase.requires || []).forEach((r, idx) => baseMap.set(r.path, idx));
+            if (!basePhase.requires)
+                basePhase.requires = [];
+            for (const req of overlayPhase.requires) {
+                if (baseMap.has(req.path)) {
+                    // OVERRIDE in place
+                    const idx = baseMap.get(req.path);
+                    basePhase.requires[idx] = { ...basePhase.requires[idx], ...req };
+                }
+                else {
+                    // APPEND
+                    basePhase.requires.push(req);
+                }
+            }
+        }
+        // 2. Merge Gates (Concatenate)
+        if (overlayPhase.gates && Array.isArray(overlayPhase.gates)) {
+            if (!basePhase.gates)
+                basePhase.gates = [];
+            basePhase.gates.push(...overlayPhase.gates);
+        }
     }
+    return result;
 }

package/dist/iris/proc.js

@@ -0,0 +1,56 @@
+import { spawn } from 'child_process';
+export class ExecError extends Error {
+    command;
+    args;
+    result;
+    constructor(command, args, result) {
+        super(`Command failed with code ${result.code}: ${command} ${args.join(' ')}\nStderr: ${result.stderr}`);
+        this.command = command;
+        this.args = args;
+        this.result = result;
+        this.name = 'ExecError';
+    }
+}
+export async function runCmd(cmd, args, opts = { cwd: process.cwd() }) {
+    return new Promise((resolve, reject) => {
+        if (opts.verbose) {
+            console.log(`> ${cmd} ${args.join(' ')} (in ${opts.cwd})`);
+        }
+        const child = spawn(cmd, args, {
+            cwd: opts.cwd,
+            env: { ...process.env, ...opts.env },
+            shell: false, // Safer to not use shell
+            stdio: 'pipe',
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data) => {
+            const chunk = data.toString();
+            stdout += chunk;
+            if (opts.verbose)
+                process.stdout.write(chunk);
+        });
+        child.stderr.on('data', (data) => {
+            const chunk = data.toString();
+            stderr += chunk;
+            if (opts.verbose)
+                process.stderr.write(chunk);
+        });
+        child.on('error', (err) => {
+            reject(err);
+        });
+        child.on('close', (code) => {
+            const result = {
+                code: code ?? 1, // Treat signal termination as error code 1
+                stdout,
+                stderr,
+            };
+            if (code === 0) {
+                resolve(result);
+            }
+            else {
+                reject(new ExecError(cmd, args, result));
+            }
+        });
+    });
+}

package/dist/iris/resolver.js

@@ -38,6 +38,9 @@ export function resolveIrisRoot(repoRoot) {
  * 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")