project-iris 0.0.1

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

@@ -0,0 +1,181 @@
+import fs from "fs";
+import path from "path";
+import inquirer from "inquirer";
+import kleur from "kleur";
+import { removeDir, repoRoot } from "../lib.js";
+import { loadManifest } from "./manifest.js";
+export async function uninstallIris(options) {
+    const root = repoRoot();
+    const manifest = loadManifest();
+    if (!manifest) {
+        console.log("No IRIS manifest found; nothing to uninstall.");
+        return;
+    }
+    // Step B: Remove installed tool wrapper files
+    const manifestTools = manifest.paths_installed || [];
+    let removedCount = 0;
+    let skippedCount = 0;
+    for (const entry of manifestTools) {
+        // Only remove stuff outside .iris (we delete .iris wholesale later)
+        if (entry.path.startsWith(".iris/"))
+            continue;
+        // Only remove if status was installed or overwritten
+        if (entry.status !== "installed" && entry.status !== "overwritten")
+            continue;
+        const targetPath = path.join(root, entry.path);
+        if (!fs.existsSync(targetPath))
+            continue;
+        // Check if modified by user?
+        // Method 1: Compare with mirror in .iris/tools/
+        // entry.path is like .claude/commands/foo.md
+        // We know which tool it belongs to? Not directly from installedPath.
+        // But we have tools_selected.
+        // Let's rely on finding it in one of the mirrors? 
+        // Or cleaner: we know the 'source' from manifest? I didn't save 'source' in installedPath in installer.ts (oops).
+        // I saved: path, type, status.
+        // Recover source bundle path from mirror?
+        // We mirrored relevant tools to .iris/tools/<tool>.
+        // Check if file exists in ANY mirror that matches content?
+        // Or simpler: Check against ALL mirrors.
+        let matchFound = false;
+        for (const tool of manifest.tools_selected) {
+            const mirrorFile = path.join(root, ".iris/tools", tool, entry.path); // Mirror structure mimics repo root?
+            // Wrapper in installer.ts: copyDirRec(toolBundlePath, mirrorPath) -> mirrorPath = .iris/tools/<tool>
+            // And installToolWrapper copied from toolBundlePath to root.
+            // So yes, relative path inside .iris/tools/<tool> should match relative path from root? 
+            // Wait. toolBundlePath might be .../tools/claude. Content is .claude/... 
+            // So in mirror: .iris/tools/claude/.claude/...
+            // relative path of entry: .claude/...
+            // So yes: join(.iris/tools/<tool>, entry.path) should point to the backup.
+            if (fs.existsSync(mirrorFile)) {
+                if (areFilesEqual(targetPath, mirrorFile)) {
+                    matchFound = true;
+                    break;
+                }
+            }
+        }
+        if (matchFound) {
+            fs.unlinkSync(targetPath);
+            // Cleanup parent dirs if empty?
+            tryRemoveEmptyParents(targetPath, root);
+            removedCount++;
+            console.log(kleur.gray(`Removed ${entry.path}`));
+        }
+        else {
+            console.log(kleur.yellow(`Modified by user; skipping: ${entry.path}`));
+            skippedCount++;
+        }
+    }
+    // Step C: Remove .iris/tools mirrors (Implicitly done by removing .iris later, but specs say remove mirrors)
+    // 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([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: "Remove IRIS doctrine (.iris/aidlc) and policy files?",
+                default: true
+            }
+        ]);
+        removeDoctrine = confirm;
+    }
+    if (removeDoctrine) {
+        removeDir(path.join(root, ".iris"));
+        console.log(kleur.green("Removed .iris/ directory."));
+    }
+    else {
+        console.log(kleur.gray("Kept .iris/ directory."));
+    }
+    // Step E: Memory Bank
+    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
+            // Safety check: contains anything we didn't create?
+            // Actually difficult to track every file in memory bank.
+            // Safe approach: Only delete if empty? 
+            // Or prompt: "memory-bank contains files. Type DELETE to confirm."
+            const mbPath = path.join(root, "memory-bank");
+            if (fs.existsSync(mbPath)) {
+                const isEmpty = fs.readdirSync(mbPath).length === 0;
+                if (!isEmpty) {
+                    const { typeDelete } = await inquirer.prompt([
+                        {
+                            type: "input",
+                            name: "typeDelete",
+                            message: "memory-bank contains files. Type DELETE to confirm removal:",
+                        }
+                    ]);
+                    if (typeDelete === "DELETE") {
+                        removeDir(mbPath);
+                        console.log(kleur.green("Removed memory-bank/."));
+                    }
+                    else {
+                        console.log(kleur.yellow("Skipped memory-bank removal (safety)."));
+                    }
+                }
+                else {
+                    removeDir(mbPath);
+                    console.log(kleur.green("Removed empty memory-bank/."));
+                }
+            }
+        }
+    }
+    // Step F: Summary
+    console.log("");
+    console.log(kleur.bold("Uninstall Summary:"));
+    console.log(`- Removed files: ${removedCount}`);
+    console.log(`- Skipped files (modified): ${skippedCount}`);
+    console.log("");
+}
+function areFilesEqual(a, b) {
+    try {
+        const bufA = fs.readFileSync(a);
+        const bufB = fs.readFileSync(b);
+        return bufA.equals(bufB);
+    }
+    catch {
+        return false;
+    }
+}
+function tryRemoveEmptyParents(filePath, root) {
+    let dir = path.dirname(filePath);
+    while (dir && path.relative(root, dir) !== "" && !path.isAbsolute(path.relative(root, dir)) && fs.existsSync(dir)) {
+        const files = fs.readdirSync(dir);
+        if (files.length === 0) {
+            fs.rmdirSync(dir);
+            dir = path.dirname(dir);
+        }
+        else {
+            break;
+        }
+    }
+}

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

@@ -0,0 +1,391 @@
+import fs from "fs";
+import path from "path";
+import matter from "gray-matter";
+import { loadEffectivePolicy } from "./policy.js";
+import { loadState, saveState } from "./state.js";
+import { checkArtifact } from "./artifact-checker.js";
+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
+    // 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;
+    if (options.phase) {
+        targetPhase = options.phase;
+    }
+    // Check if phase exists in policy
+    if (!policy.phases[targetPhase]) {
+        errors.push({
+            code: "UNKNOWN_PHASE",
+            message: `Target phase '${targetPhase}' does not exist in policy.`,
+            severity: "error"
+        });
+        return finalizeResult(errors, state, false, shouldWrite);
+    }
+    // Step C: Required artifacts (FAIL FAST)
+    // Gather requirements for the phase
+    const requirements = policy.phases[targetPhase].requires || [];
+    for (const req of requirements) {
+        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",
+                path: check.normalized,
+                message: `Required ${req.type} missing: ${check.normalized}`,
+                remediation: req.template
+                    ? `Create from template: ${req.template}`
+                    : `Create ${req.type} at ${check.normalized}`,
+                template: req.template,
+                artifactType: req.type,
+                severity: "error"
+            });
+        }
+        else {
+            // Validate type matches
+            if (req.type === "directory" && !check.isDirectory) {
+                errors.push({
+                    code: "INVALID_TYPE",
+                    path: check.normalized,
+                    message: `Expected directory but found file: ${check.normalized}`,
+                    remediation: "Remove file and create directory",
+                    severity: "error"
+                });
+            }
+            else if (req.type === "file" && !check.isFile) {
+                errors.push({
+                    code: "INVALID_TYPE",
+                    path: check.normalized,
+                    message: `Expected file but found directory: ${check.normalized}`,
+                    remediation: "Remove directory and create file",
+                    severity: "error"
+                });
+            }
+            else if (req.type === "file") {
+                // Content Quality Check (Warnings)
+                const qualityWarnings = checkContentQuality(check.absolutePath);
+                errors.push(...qualityWarnings);
+            }
+        }
+    }
+    // Fail fast if strict artifact check fails?
+    // Specs say "Missing artifacts -> fail fast errors". 
+    // Usually means return immediately or don't proceed to gates?
+    // Let's collect all missing artifacts first, but if ANY are missing, we probably shouldn't check gates that rely on them.
+    if (errors.length > 0) {
+        return finalizeResult(errors, state, false, shouldWrite);
+    }
+    // Optional Structure Check: Units
+    // IF units/ exists under any intent, IT MUST contain unit-brief.md
+    checkOptionalUnits(errors);
+    if (errors.length > 0) {
+        return finalizeResult(errors, state, false, shouldWrite);
+    }
+    // Step D: Gate checks (HARD ERRORS)
+    // "Support frontmatter gates"
+    const gates = policy.phases[targetPhase].gates || [];
+    for (const gate of gates) {
+        if (gate.kind === "frontmatter") {
+            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 {
+            console.warn(`Unknown gate kind: ${gate.kind}`);
+        }
+    }
+    if (errors.length > 0) {
+        return finalizeResult(errors, state, false, shouldWrite);
+    }
+    // Step E: Phase transition enforcement
+    let applying = false;
+    // Only check transition if we have a requested phase and we are NOT just probing a specific phase with --phase
+    if (state.phase.requested && !options.phase) {
+        // Validate transition
+        const from = state.phase.current;
+        const to = state.phase.requested;
+        const transition = policy.transitions.find(t => t.from === from && t.to === to);
+        if (!transition) {
+            errors.push({
+                code: "INVALID_TRANSITION",
+                message: `Transition from '${from}' to '${to}' is not defined in policy.`,
+                remediation: "Reset requested phase or update policy.",
+                severity: "error"
+            });
+        }
+        else {
+            // Validate requires_gates[] for transition
+            // These reference gates defined in the phase? OR are they ids?
+            // "Validate requires_gates[] for transition" implies the transition object has a list of gate IDs that must pass.
+            // But where are these gates defined? Usually gates are on the phase.
+            // Interpretation: Check if the gates identified by ID in the CURRENT phase (or destination?) are passed?
+            // "If transition not allowed -> ERROR"
+            // "Validate requires_gates[] for transition" -> "If any gate fails -> ERROR"
+            // Let's assume gates are identified by 'id' in policy.phases[...].gates
+            // AND the transition rules apply to the CURRENT state config or the TARGET?
+            // Usually transition gates check if you are ready to LEAVE 'from' or ENTER 'to'.
+            // Given "inception.intent.approved", it likely checks the state of the *current* phase artifacts to allow moving forward.
+            if (transition.requires_gates) {
+                // Find these gates. They could be in the 'from' phase or 'to' phase. 
+                // A safe bet is to search all defined gates in 'from' phase, or global?
+                // The snippet shows: id: "inception.intent.approved" -> implies inception phase.
+                // We need to look up these gates.
+                // NOTE: We only ran checks for 'targetPhase' above. 
+                // If targetPhase == current, we checked current.
+                // If targetPhase == requested (via --phase), we checked requested.
+                // Transition logic is: checking if we can move FROM current TO requested.
+                // So we should validate gates required by the transition.
+                for (const gateId of transition.requires_gates) {
+                    // Find the gate definition. 
+                    // We search in 'from' phase first, then 'to' phase?
+                    // Or just iterate all phases?
+                    let foundGate;
+                    // Optimization: check 'from' first
+                    if (policy.phases[from]?.gates) {
+                        foundGate = policy.phases[from].gates?.find(g => g.id === gateId);
+                    }
+                    // check 'to' next
+                    if (!foundGate && policy.phases[to]?.gates) {
+                        foundGate = policy.phases[to].gates?.find(g => g.id === gateId);
+                    }
+                    if (!foundGate) {
+                        errors.push({
+                            code: "MISSING_GATE_DEF",
+                            message: `Transition requires gate '${gateId}' but it is not found in '${from}' or '${to}' phases.`,
+                            severity: "error"
+                        });
+                        continue;
+                    }
+                    // Run the gate check
+                    if (foundGate.kind === "frontmatter") {
+                        const gateError = checkFrontmatterGate(foundGate);
+                        if (gateError) {
+                            errors.push(gateError);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Step F: Apply transition (--apply)
+    // Only apply if we are allowed to write back
+    if (shouldWrite && errors.length === 0 && options.apply && state.phase.requested && !options.phase) {
+        // Valid and apply requested
+        // Safety: ensure transition valid again? (already done in Step E if we had errors, it would fail)
+        // If we are here, Step E passed.
+        state.phase.current = state.phase.requested;
+        state.phase.requested = null; // Clear request
+        applying = true;
+    }
+    return finalizeResult(errors, state, applying, shouldWrite);
+}
+function checkFrontmatterGate(gate) {
+    const filePath = path.join(process.cwd(), gate.file);
+    if (!fs.existsSync(filePath)) {
+        return {
+            code: "GATE_FILE_MISSING",
+            path: gate.file,
+            message: `Gate '${gate.id}' failed: File missing`,
+            remediation: `Create ${gate.file}`,
+            severity: "error"
+        };
+    }
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const parsed = matter(content);
+        if (!parsed.data) {
+            return {
+                code: "GATE_NO_FRONTMATTER",
+                path: gate.file,
+                message: `Gate '${gate.id}' failed: No frontmatter found`,
+                remediation: "Add frontmatter variables",
+                severity: "error"
+            };
+        }
+        if (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",
+                    path: gate.file,
+                    message: `Gate '${gate.id}' failed: Field '${gate.field}' missing`,
+                    remediation: `Add '${gate.field}' to frontmatter`,
+                    severity: "error"
+                };
+            }
+            if (gate.equals !== undefined && String(val) !== String(gate.equals)) {
+                return {
+                    code: "GATE_VALUE_MISMATCH",
+                    path: gate.file,
+                    message: `Gate '${gate.id}' failed: Field '${gate.field}' is '${val}', expected '${gate.equals}'`,
+                    remediation: `Set '${gate.field}: ${gate.equals}' in ${gate.file}`,
+                    severity: "error"
+                };
+            }
+        }
+        return null;
+    }
+    catch (e) {
+        return {
+            code: "GATE_PARSE_ERROR",
+            path: gate.file,
+            message: `Gate '${gate.id}' failed: Error parsing file: ${e}`,
+            severity: "error"
+        };
+    }
+}
+function checkOptionalUnits(errors) {
+    const intentsDir = path.join(process.cwd(), "memory-bank", "intents");
+    if (!fs.existsSync(intentsDir))
+        return;
+    try {
+        const intents = fs.readdirSync(intentsDir).filter(f => fs.statSync(path.join(intentsDir, f)).isDirectory());
+        for (const intent of intents) {
+            const unitsDir = path.join(intentsDir, intent, "units");
+            if (fs.existsSync(unitsDir) && fs.statSync(unitsDir).isDirectory()) {
+                // Units folder exists, check contents
+                const units = fs.readdirSync(unitsDir).filter(f => fs.statSync(path.join(unitsDir, f)).isDirectory());
+                for (const unit of units) {
+                    const briefPath = path.join(unitsDir, unit, "unit-brief.md");
+                    if (!fs.existsSync(briefPath)) {
+                        const relPath = path.relative(process.cwd(), briefPath);
+                        errors.push({
+                            code: "MISSING_ARTIFACT",
+                            path: relPath,
+                            message: `Unit '${unit}' requires unit-brief.md`,
+                            remediation: "Create from template",
+                            template: ".iris/aidlc/templates/unit-brief.md",
+                            artifactType: "file",
+                            severity: "error"
+                        });
+                    }
+                    else {
+                        // Check quality of unit brief too
+                        errors.push(...checkContentQuality(briefPath));
+                    }
+                }
+            }
+        }
+    }
+    catch (e) {
+        // Ignore read errors
+    }
+}
+function checkContentQuality(filePath) {
+    const warnings = [];
+    try {
+        const content = fs.readFileSync(filePath, "utf8");
+        const relativePath = path.relative(process.cwd(), filePath);
+        // 1. Effective emptiness
+        if (content.trim().length < 20) {
+            warnings.push({
+                code: "QUALITY_EMPTY",
+                path: relativePath,
+                message: `File is effectively empty (<20 chars): ${relativePath}`,
+                severity: "warning",
+                remediation: "Add meaningful content"
+            });
+        }
+        // 2. Placeholders
+        const placeholderRegex = /\b(TODO|FIXME|TBD)\b|<[^>]+>/;
+        if (placeholderRegex.test(content)) {
+            warnings.push({
+                code: "QUALITY_PLACEHOLDER",
+                path: relativePath,
+                message: `File contains placeholders (TODO/FIXME/TBD/<...>): ${relativePath}`,
+                severity: "warning",
+                remediation: "Replace placeholders with actual content"
+            });
+        }
+    }
+    catch (e) {
+        // Ignore read errors
+    }
+    return warnings;
+}
+function finalizeResult(errors, state, applied, writeBack) {
+    const hasErrors = errors.some(e => e.severity === "error");
+    const hasWarnings = errors.some(e => e.severity === "warning");
+    const isValid = !hasErrors;
+    if (writeBack) {
+        state.last_validation.at = new Date().toISOString();
+        state.last_validation.result = isValid ? "valid" : "invalid";
+        saveState(state);
+    }
+    return {
+        valid: isValid,
+        warnings: hasWarnings,
+        phase: {
+            current: state.phase.current,
+            requested: state.phase.requested,
+            applied: applied
+        },
+        errors: errors
+    };
+}