project-iris 0.0.6

package/dist/iris/packer.js

@@ -0,0 +1,303 @@
+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 { loadPolicy } 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";
+export async function generatePack(options) {
+    const root = repoRoot();
+    // 1. Validate Repo (Guardrail)
+    try {
+        const result = await validate({
+            apply: false,
+            strict: false,
+            writeBack: false
+        });
+        if (!result.valid) {
+            console.error(kleur.red("Repo is INVALID. Fix issues before packing."));
+            process.exit(EXIT_CODES.INVALID); // Exit 2
+        }
+        if (options.strict && result.warnings) {
+            console.error(kleur.red("Repo has warnings and strict mode is on."));
+            process.exit(EXIT_CODES.INVALID);
+        }
+    }
+    catch (e) {
+        console.error("Validation failed:", e);
+        process.exit(EXIT_CODES.INVALID);
+    }
+    // 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(agent);
+    // Required Artifacts
+    const requiredArtifacts = collectRequiredArtifacts(phase, state);
+    // 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) {
+                console.error(kleur.red(`Missing required artifact: ${check.normalized}`));
+                process.exit(EXIT_CODES.INVALID);
+            }
+            // For files, also check if content was readable
+            if (check.isFile && res.skipped === "read_error") {
+                console.error(kleur.red(`Cannot read required artifact: ${check.normalized}`));
+                process.exit(EXIT_CODES.INVALID);
+            }
+        }
+        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);
+    // 6. Format
+    const markdown = formatBundle(finalSelection, {
+        repo: path.basename(root),
+        phase,
+        agent,
+        generatedAt: new Date().toISOString()
+    });
+    // 7. Output
+    if (options.stdout) {
+        console.log(markdown);
+        if (options.output) {
+            writeFile(options.output, markdown);
+        }
+    }
+    else {
+        const outFile = options.output || path.join(root, `.iris/inbox/context-pack.${agent}.${phase}.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`));
+    }
+}
+function inferAgent(phase) {
+    switch (phase) {
+        case "inception": return "inception";
+        case "construction": return "construction";
+        case "operations": return "operations";
+        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 collectRequiredArtifacts(phase, state) {
+    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 = loadPolicy();
+        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) {
+    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?
+        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);
+    }
+    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];
+    // 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/"));
+    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/policy.js

@@ -0,0 +1,28 @@
+import fs from "fs";
+import yaml from "js-yaml";
+import { EXIT_CODES } from "../utils/exit-codes.js";
+import { resolveArtifactPath } from "./resolver.js";
+import { repoRoot } from "../lib.js";
+export function loadPolicy() {
+    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 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);
+        }
+        return doc;
+    }
+    catch (error) {
+        console.error("Failed to load .iris/policy.yaml:", error);
+        process.exit(EXIT_CODES.POLICY_ERROR);
+    }
+}

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}`));
+    }
+}

package/dist/iris/resolver.js

@@ -0,0 +1,63 @@
+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 (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,20 @@
+import fs from "fs";
+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;
+    }
+    try {
+        const content = fs.readFileSync(routesPath, "utf8");
+        return yaml.load(content);
+    }
+    catch (e) {
+        console.error("Failed to parse .iris/routes.yaml:", e);
+        process.exit(EXIT_CODES.POLICY_ERROR);
+    }
+}