project-iris 0.0.1

package/dist/iris/packer.js

@@ -0,0 +1,325 @@
+import fs from "fs";
+import path from "path";
+import kleur from "kleur";
+import { repoRoot, writeFile, ensureDir } from "../lib.js";
+import { loadState } from "./state.js";
+import { loadEffectivePolicy } from "./policy.js";
+import { validate } from "./validator.js";
+import { resolveIncludes, getFileContent } from "./include.js";
+import { checkArtifact } from "./artifact-checker.js";
+import { collectDoctrineFiles } from "./doctrine/collector.js";
+export async function generatePack(options) {
+    const root = repoRoot();
+    // 1. Validate Repo (Guardrail)
+    try {
+        const result = await validate({
+            apply: false,
+            strict: false,
+            writeBack: false,
+            frameworkResolution: options.frameworkResolution
+        });
+        if (!result.valid) {
+            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) {
+            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) {
+        // 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();
+    const phase = options.phase || state.phase.current;
+    const agent = options.agent || inferAgent(phase);
+    // 3. Collect Candidates
+    // Doctrine
+    const doctrineFiles = collectDoctrine(root, state.active.flow);
+    // Required Artifacts
+    const requiredArtifacts = collectRequiredArtifacts(phase, state, options.frameworkResolution);
+    // Optional Artifacts
+    const optionalArtifacts = collectOptionalArtifacts(phase);
+    // Included Artifacts
+    const includedFiles = options.includes && options.includes.length > 0
+        ? await resolveIncludes(options.includes, options.excludes)
+        : [];
+    // 4. Read & Assemble
+    // Core (Doctrine + Required) - Must be included
+    const coreContent = [];
+    for (const p of [...doctrineFiles, ...requiredArtifacts]) {
+        // Required files generally SHOULD exist, but if missing, we record them
+        // Doctrine: "If a file is missing, skip it but record in the bundle '(missing)' list."
+        // Required Artifacts: "If required file missing -> pack must fail (exit 2)"
+        const res = getFileContent(p);
+        // Check requirement for artifacts (not doctrine)
+        if (requiredArtifacts.includes(p)) {
+            // Use artifact checker for proper validation
+            const check = checkArtifact(root, p);
+            if (!check.exists) {
+                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") {
+                const msg = `Cannot read required artifact: ${check.normalized}`;
+                if (!options.quiet)
+                    console.error(kleur.red(msg));
+                throw new Error(msg);
+            }
+        }
+        coreContent.push(res);
+    }
+    // Optional - Can be dropped
+    const optionalContent = [];
+    for (const p of optionalArtifacts) {
+        // Optional artifacts usually are logs/bolts which are repo-local. 
+        // getFileContent resolves them. If they don't exist, we skip.
+        const res = getFileContent(p);
+        if (res.skipped === "read_error" || res.size === 0)
+            continue;
+        optionalContent.push(res);
+    }
+    // Includes - Can be dropped
+    const extraContent = [];
+    for (const p of includedFiles) {
+        extraContent.push(getFileContent(p));
+    }
+    // 5. Enforce Limits
+    const maxBytes = options.maxBytes || 1_500_000;
+    const finalSelection = enforceLimits(coreContent, optionalContent, extraContent, maxBytes, options.quiet);
+    // 6. Format
+    const markdown = formatBundle(finalSelection, {
+        repo: path.basename(root),
+        phase,
+        agent,
+        generatedAt: new Date().toISOString()
+    });
+    // 7. Output
+    if (options.stdout && !options.json) {
+        console.log(markdown);
+        if (options.output) {
+            writeFile(options.output, markdown);
+        }
+    }
+    else {
+        const outFile = options.output || path.join(root, `.iris/inbox/context-${phase}-${agent}.md`);
+        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) {
+        case "inception": return "inception";
+        case "construction": return "construction";
+        case "operations": return "operations";
+        default: return "master";
+    }
+}
+function collectDoctrine(root, activeFlowId) {
+    // Replaced legacy hardcoded list with flow-aware collector
+    return collectDoctrineFiles(root, activeFlowId);
+}
+function collectRequiredArtifacts(phase, state, framework) {
+    const list = [
+        ".iris/state.yaml",
+        ".iris/policy.yaml"
+    ];
+    if (fs.existsSync(path.join(repoRoot(), ".iris/routes.yaml")))
+        list.push(".iris/routes.yaml");
+    if (fs.existsSync(path.join(repoRoot(), ".iris/manifest.yaml")))
+        list.push(".iris/manifest.yaml");
+    // Use Policy Source of Truth
+    try {
+        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);
+            }
+        }
+    }
+    catch (e) {
+        // Fallback or ignore if policy broken (validator should have caught it)
+    }
+    return list;
+}
+function collectOptionalArtifacts(phase) {
+    const list = [];
+    const root = repoRoot();
+    if (phase === "inception") {
+        if (fs.existsSync(path.join(root, "memory-bank/intents/intent.md"))) {
+            list.push("memory-bank/intents/intent.md");
+        }
+        list.push(...getLatestFiles(path.join(root, "memory-bank/logs"), 5));
+    }
+    else if (phase === "construction") {
+        list.push(...getLatestFiles(path.join(root, "memory-bank/bolts"), 5));
+        list.push(...getLatestFiles(path.join(root, "memory-bank/logs"), 5));
+    }
+    else if (phase === "operations") {
+        list.push(...getLatestFiles(path.join(root, "memory-bank/logs"), 10));
+        list.push(...getLatestFiles(path.join(root, "memory-bank/standards"), 5));
+    }
+    return list;
+}
+function getLatestFiles(dir, count) {
+    const root = repoRoot();
+    if (!fs.existsSync(dir))
+        return [];
+    const files = fs.readdirSync(dir)
+        .map(f => path.join(dir, f))
+        .filter(f => fs.statSync(f).isFile())
+        .map(f => ({ path: path.relative(root, f), mtime: fs.statSync(f).mtime.getTime() }))
+        .sort((a, b) => {
+        if (b.mtime !== a.mtime)
+            return b.mtime - a.mtime; // Descending time
+        return a.path.localeCompare(b.path); // Tie-break name
+    });
+    return files.slice(0, count).map(f => f.path);
+}
+function enforceLimits(core, optional, extra, maxBytes, quiet) {
+    let currentSize = sumSize(core) + sumSize(optional) + sumSize(extra);
+    const errors = [];
+    const skipped = [];
+    // 1. Reduce Optional
+    while (currentSize > maxBytes && optional.length > 0) {
+        const removed = optional.pop(); // Remove from end (which are older logs/bolts usually!)
+        // Wait, collectOptionalArtifacts sorted by latest first.
+        // So pop() removes the OLDEST (least relevant). Correct.
+        if (removed) {
+            currentSize -= (removed.size || 0);
+            skipped.push(removed.path);
+        }
+    }
+    // 2. Reduce Extra
+    while (currentSize > maxBytes && extra.length > 0) {
+        const removed = extra.pop(); // Remove from end of glob list (arbitrary?)
+        if (removed) {
+            currentSize -= (removed.size || 0);
+            skipped.push(removed.path);
+        }
+    }
+    if (currentSize > maxBytes) {
+        // Hard fail if Core is too big?
+        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,
+        optional,
+        extra,
+        skipped
+    };
+}
+function sumSize(files) {
+    return files.reduce((acc, f) => acc + (f.content ? f.content.length : 0), 0);
+}
+function formatBundle(selection, meta) {
+    const { core, optional, extra, skipped } = selection;
+    let out = `# IRIS Context Pack\n\n`;
+    out += `## Metadata\n`;
+    out += `- Generated: ${meta.generatedAt}\n`;
+    out += `- Repo: ${meta.repo}\n`;
+    out += `- Phase: ${meta.phase}\n`;
+    out += `- Agent: ${meta.agent}\n`;
+    out += `- Navi: 0.0.07\n\n`; // Hardcoded version for now or read pkg
+    out += `## How to use\n`;
+    out += `- Run: /iris-${meta.agent}-agent\n`;
+    out += `- This bundle contains doctrine + required artifacts.\n\n`;
+    // Groups
+    const all = [...core, ...optional, ...extra];
+    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/"));
+    const others = all.filter(f => !f.path.startsWith(".iris/") && !f.path.startsWith("memory-bank/"));
+    const printer = (title, files) => {
+        if (files.length === 0)
+            return;
+        out += `## ${title}\n\n`;
+        files.forEach((f, idx) => {
+            if (f.skipped) {
+                // Should list in skipped section?
+                return;
+            }
+            if (!f.content && !f.skipped) {
+                // Missing file (e.g. Doctrine missing)
+                out += `### [${idx + 1}] ${f.path} (MISSING)\n\n`;
+                return;
+            }
+            out += `### [${idx + 1}] ${f.path}\n`;
+            out += "```" + detectLang(f.path) + "\n";
+            out += f.content + "\n";
+            out += "```\n\n";
+        });
+    };
+    printer("Doctrine (Load Order)", doctrine);
+    printer("Repo State", stateFiles);
+    printer("Memory Bank", memory);
+    printer("Included Context", others);
+    // Missing / Skipped
+    const missing = all.filter(f => !f.content && !f.skipped).map(f => f.path);
+    const skippedReasons = all.filter(f => f.skipped).map(f => `${f.path} (${f.skipped})`);
+    const droppedLimits = skipped;
+    if (missing.length > 0 || skippedReasons.length > 0 || droppedLimits.length > 0) {
+        out += `## Missing / Skipped Files\n\n`;
+        missing.forEach(p => out += `* ${p} (missing)\n`);
+        skippedReasons.forEach(p => out += `* ${p}\n`);
+        droppedLimits.forEach(p => out += `* ${p} (dropped for size)\n`);
+    }
+    return out;
+}
+function detectLang(p) {
+    const ext = path.extname(p);
+    if (ext === ".md")
+        return "markdown";
+    if (ext === ".yaml")
+        return "yaml";
+    if (ext === ".json")
+        return "json";
+    if (ext === ".ts")
+        return "typescript";
+    if (ext === ".js")
+        return "javascript";
+    return "";
+}

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

@@ -0,0 +1,133 @@
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+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";
+// --- Loaders ---
+/**
+ * Loads the base policy from the active framework OR fallback to legacy .iris/policy.yaml.
+ */
+export function loadBasePolicy(framework, root) {
+    try {
+        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);
+        }
+        // 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 base if no overlay
+        return base;
+    }
+    catch (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/report.js

@@ -0,0 +1,53 @@
+import kleur from "kleur";
+export function printReport(result, json = false, fixResult, strict = false) {
+    if (json) {
+        console.log(JSON.stringify({
+            valid: result.valid,
+            warnings: result.warnings,
+            errors: result.errors,
+            fix_result: fixResult // Optional
+        }, null, 2));
+        return;
+    }
+    if (fixResult) {
+        console.log("");
+        console.log(kleur.bold().green("Applied fixes:"));
+        if (fixResult.paths.length === 0) {
+            console.log(kleur.gray("  (None needed)"));
+        }
+        else {
+            for (const p of fixResult.paths) {
+                console.log(kleur.green(`  + Created: ${p}`));
+            }
+        }
+        console.log("");
+        console.log(kleur.bold(`Remaining issues (${result.errors.length}):`));
+    }
+    else {
+        if (result.valid && !result.warnings) {
+            console.log(kleur.green("✓ Repository is valid."));
+            return;
+        }
+        if (!result.valid) {
+            console.log(kleur.red(`✗ Validation failed with ${result.errors.length} error(s):`));
+        }
+        else {
+            if (strict) {
+                console.log(kleur.red("✗ Validation FAILED (strict) due to warnings:"));
+            }
+            else {
+                console.log(kleur.yellow("! Validation PASSED with warnings:"));
+            }
+        }
+    }
+    // Print errors
+    for (const err of result.errors) {
+        const icon = err.severity === "warning" ? kleur.yellow("!") : kleur.red("x");
+        const code = kleur.dim(`[${err.code}]`);
+        // If fixed, skip? No, this function prints current result. 
+        // If called after fix, these are remaining errors.
+        console.log(`  ${icon} ${code} ${err.message}`);
+        if (err.path)
+            console.log(kleur.dim(`     Path: ${err.path}`));
+    }
+}