project-iris 0.0.13 → 0.0.14

package/dist/iris/tmp.js

@@ -1,24 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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

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

package/dist/iris/validator.js

@@ -1,391 +0,0 @@
-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
-    };
-}