project-iris 0.0.6

package/dist/iris/guard.js

@@ -0,0 +1,38 @@
+import kleur from "kleur";
+import { validate } from "./validator.js";
+import { EXIT_CODES } from "../utils/exit-codes.js";
+export async function requireValidRepoOrExit(options = {}) {
+    // Run validation in read-only mode first? 
+    // Should we write back validation results for 'run'?
+    // Specs: "Runs the same core validator used by navi validate"
+    // If we run 'navi run', it probably SHOULD update the last_validation timestamp to show we checked.
+    // So writeBack: true (default) is appropriate here.
+    const result = await validate({
+        apply: false,
+        strict: options.strict || false,
+        writeBack: true
+    });
+    if (!result.valid) {
+        console.log("");
+        console.log(kleur.red().bold("⛔  Repo invalid; run navi validate for details"));
+        console.log("");
+        // List 1-3 most important issues
+        const topErrors = result.errors.slice(0, 3);
+        topErrors.forEach((err) => {
+            console.log(kleur.red(`   [${err.code}] ${err.path || ""}`));
+        });
+        if (result.errors.length > 3) {
+            console.log(kleur.dim(`   ... and ${result.errors.length - 3} more.`));
+        }
+        console.log("");
+        process.exit(EXIT_CODES.INVALID);
+    }
+    // If validated with warnings, we usually proceed unless strict is on.
+    // Validator handles strict check internally? 
+    // No, validate() returns warnings=true. command/validate.ts handled exit.
+    if (result.warnings && options.strict) {
+        console.log("");
+        console.log(kleur.red().bold("⛔  Repo has warnings (strict mode enabled)"));
+        process.exit(EXIT_CODES.INVALID);
+    }
+}

package/dist/iris/include.js

@@ -0,0 +1,49 @@
+import fs from "fs";
+import fg from "fast-glob";
+import { repoRoot } from "../lib.js";
+import { resolveArtifactPath } from "./resolver.js";
+export const DEFAULT_EXCLUDES = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.iris/cache/**",
+    "**/.DS_Store"
+];
+export async function resolveIncludes(includeGlobs, excludeGlobs = []) {
+    const root = repoRoot();
+    if (includeGlobs.length === 0)
+        return [];
+    const entries = await fg(includeGlobs, {
+        cwd: root,
+        ignore: [...DEFAULT_EXCLUDES, ...excludeGlobs],
+        dot: true,
+        absolute: false,
+        onlyFiles: true
+    });
+    // Sort for determinism
+    return entries.sort();
+}
+export function isBinary(buffer) {
+    const chunk = buffer.subarray(0, Math.min(buffer.length, 8000));
+    return chunk.includes(0);
+}
+const MAX_INDIVIDUAL_FILE_SIZE = 1_000_000;
+export function getFileContent(relPath) {
+    const root = repoRoot();
+    const absPath = resolveArtifactPath(root, relPath);
+    try {
+        const stats = fs.statSync(absPath);
+        if (stats.size > MAX_INDIVIDUAL_FILE_SIZE) {
+            return { path: relPath, size: stats.size, skipped: "too_large" };
+        }
+        const buffer = fs.readFileSync(absPath);
+        if (isBinary(buffer)) {
+            return { path: relPath, size: stats.size, skipped: "binary" };
+        }
+        return { path: relPath, size: stats.size, content: buffer.toString("utf8") };
+    }
+    catch (e) {
+        return { path: relPath, size: 0, skipped: "read_error" };
+    }
+}

package/dist/iris/installer.js

@@ -0,0 +1,269 @@
+import fs from "fs";
+import path from "path";
+import kleur from "kleur";
+import inquirer from "inquirer";
+import { ensureDir, sanitizeFolderName, spawnAsync } from "../lib.js";
+import { updateManifest } from "./manifest.js";
+export const TOOLS = ["claude", "cursor", "gemini", "antigravity", "codex"];
+const BUNDLE_ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../../src/iris_bundle");
+/**
+ * Ensure package.json exists in the target directory.
+ * If missing, create a minimal one.
+ */
+function ensurePackageJson(root) {
+    const pkgPath = path.join(root, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        console.log(kleur.gray("✓ package.json already exists"));
+        return;
+    }
+    const folderName = path.basename(root);
+    const sanitizedName = sanitizeFolderName(folderName);
+    const minimalPackage = {
+        name: sanitizedName,
+        version: "0.0.0",
+        private: true,
+        description: "Project using IRIS framework",
+        scripts: {}
+    };
+    fs.writeFileSync(pkgPath, JSON.stringify(minimalPackage, null, 2) + "\n", "utf8");
+    console.log(kleur.green(`✓ Created package.json (name: ${sanitizedName})`));
+}
+/**
+ * Run npm install to generate package-lock.json and install any dependencies
+ */
+async function runNpmInstall(root) {
+    console.log("");
+    console.log(kleur.bold("Running npm install to generate lockfile..."));
+    try {
+        const result = await spawnAsync("npm", ["install"], root);
+        if (result.code === 0) {
+            console.log(kleur.green("✓ npm install completed successfully"));
+            // Verify lockfile was created
+            const lockPath = path.join(root, "package-lock.json");
+            if (fs.existsSync(lockPath)) {
+                console.log(kleur.green("✓ package-lock.json generated"));
+            }
+            return true;
+        }
+        else {
+            console.error(kleur.red(`✗ npm install failed with code ${result.code}`));
+            return false;
+        }
+    }
+    catch (err) {
+        console.error(kleur.red("✗ Failed to run npm install"));
+        console.error(kleur.gray(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+        return false;
+    }
+}
+export function detectTools(root) {
+    const checks = {
+        claude: fs.existsSync(path.join(root, ".claude")),
+        cursor: fs.existsSync(path.join(root, ".cursor")),
+        gemini: fs.existsSync(path.join(root, ".gemini")),
+        antigravity: fs.existsSync(path.join(root, ".antigravity")),
+        codex: fs.existsSync(path.join(root, "AGENTS.md")),
+    };
+    return TOOLS.filter(t => checks[t]);
+}
+export async function installIris(root, tools) {
+    // Step 0: Ensure package.json exists (for empty folder support)
+    ensurePackageJson(root);
+    const installedPaths = [];
+    const createdDirs = [];
+    // Bundle locations
+    const bundleIris = path.join(BUNDLE_ROOT, ".iris");
+    const bundleDoctrine = path.join(bundleIris, "aidlc");
+    const bundleTools = path.join(bundleIris, "tools");
+    // Target locations
+    const targetIris = path.join(root, ".iris");
+    const targetDoctrine = path.join(targetIris, "aidlc");
+    const targetTools = path.join(targetIris, "tools");
+    // Step C: Install IRIS core
+    ensureDir(targetIris);
+    // 1. Doctrine
+    let backupPath = "";
+    if (fs.existsSync(targetDoctrine)) {
+        const { overwrite } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "overwrite",
+                message: "IRIS doctrine (.iris/aidlc) already exists. Overwrite with fresh bundle?",
+                default: false
+            }
+        ]);
+        if (overwrite) {
+            backupPath = `${targetDoctrine}.backup.${Date.now()}`;
+            fs.renameSync(targetDoctrine, backupPath);
+            console.log(kleur.yellow(`Backed up existing doctrine to ${path.relative(root, backupPath)}`));
+            copyDirRec(bundleDoctrine, targetDoctrine, installedPaths, root); // copy new
+        }
+        // else keep existing
+    }
+    else {
+        copyDirRec(bundleDoctrine, targetDoctrine, installedPaths, root);
+    }
+    // 2. Policy & Routes (Overwrite or keep? Usually overwrite core config if missing, but maybe prompt if exists?)
+    // Spec says: "Install .iris/policy.yaml... .iris/routes.yaml"
+    // Let's safe install: only if missing? Or overwrite? 
+    // Spec doesn't explicitly say prompt for policy. 
+    // "Install IRIS core... .iris/policy.yaml"
+    // Let's assume non-destructive for config if it exists, to preserve user edits.
+    safeCopy(path.join(bundleIris, "policy.yaml"), path.join(targetIris, "policy.yaml"), installedPaths, root);
+    safeCopy(path.join(bundleIris, "routes.yaml"), path.join(targetIris, "routes.yaml"), installedPaths, root);
+    // 3. State (only if missing)
+    if (!fs.existsSync(path.join(targetIris, "state.yaml"))) {
+        fs.copyFileSync(path.join(bundleIris, "state.yaml"), path.join(targetIris, "state.yaml"));
+        // Don't track state in manifest as "installed" usually, as it changes? 
+        // Or do track it so we know we created it? "remove only paths that were installed"
+        // If we track it, uninstall might delete it. Good.
+        installedPaths.push({
+            path: ".iris/state.yaml",
+            type: "file",
+            status: "installed"
+        });
+    }
+    // Step D: Memory Bank Skeleton
+    const memoryDirs = ["intents", "units", "bolts", "standards", "logs"];
+    for (const d of memoryDirs) {
+        const p = path.join(root, "memory-bank", d);
+        if (!fs.existsSync(p)) {
+            ensureDir(p);
+            createdDirs.push(path.relative(root, p));
+        }
+    }
+    // Step E: Install Tool Wrappers & F: Mirror
+    for (const t of tools) {
+        const toolBundlePath = path.join(bundleTools, t);
+        if (!fs.existsSync(toolBundlePath)) {
+            console.warn(kleur.yellow(`Warning: No bundle found for tool '${t}' at ${toolBundlePath}`));
+            continue;
+        }
+        // Mirror first (always safe/overwrite in .iris/tools)
+        const mirrorPath = path.join(targetTools, t);
+        ensureDir(mirrorPath);
+        // We copy the WHOLE bundles content for that tool into mirror.
+        // Actually, we should mirror what we *attempt* to install.
+        // Spec: "mirror exactly what was installed (and skipped) into .iris/tools/<tool>"
+        // "still mirror the bundle version ... and record skipped_existing"
+        // So: copy bundle -> mirror.
+        copyDirRec(toolBundlePath, mirrorPath, [], root, true); // Don't track mirror files in manifest individually? Or do we?
+        // "mirror installed tool payloads... create but only filled for selected tools"
+        // Uninstall: "Remove .iris/tools/<tool> mirrors ... Always safe"
+        // So we don't strictly need to track every file inside mirror in manifest, just the tool selection implies it.
+        // Install to Repo Root
+        await installToolWrapper(t, toolBundlePath, root, installedPaths);
+    }
+    // Step G: Update Manifest
+    updateManifest({
+        tools_selected: tools,
+        paths_installed: installedPaths,
+        created_dirs: createdDirs,
+        doctrine_path: ".iris/aidlc",
+        policy_path: ".iris/policy.yaml"
+    });
+    // Step H: Run npm install to generate lockfile
+    await runNpmInstall(root);
+}
+async function installToolWrapper(tool, srcDir, root, installedPaths) {
+    // We need to walk the srcDir and copy to root, respecting collisions.
+    // For Claude: srcDir is .../tools/claude. contains .claude/...
+    // So we just copy * recursively from srcDir to root.
+    // Check for collisions first?
+    // Recursive walker needed.
+    const entries = getAllFiles(srcDir);
+    for (const entry of entries) {
+        const relPath = path.relative(srcDir, entry);
+        const targetPath = path.join(root, relPath);
+        if (fs.existsSync(targetPath)) {
+            // Prompt? "Prompt per tool: File exists... Overwrite?"
+            // Actually prompting check-per-file might be spammy. 
+            // "Prompt per tool: File exists... Overwrite?" -> implies one prompt per file clash? 
+            // "If a target file exists... Prompt per tool (maybe once?)... No, spec says: 'Prompt per tool: "File exists: <path>. Overwrite? (y/N)"'"
+            // This looks like per-file.
+            // Let's implement per-file prompt for safety.
+            // Check content difference!
+            if (areFilesEqual(entry, targetPath)) {
+                // Identical, skip prompt, mark installed (or skipped? effectively same)
+                installedPaths.push({ path: relPath, type: "file", status: "installed" });
+                continue;
+            }
+            const { overwrite } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "overwrite",
+                    message: `File exists: ${relPath}. Overwrite?`,
+                    default: false
+                }
+            ]);
+            if (overwrite) {
+                ensureDir(path.dirname(targetPath));
+                fs.copyFileSync(entry, targetPath);
+                installedPaths.push({ path: relPath, type: "file", status: "overwritten" });
+                console.log(kleur.green(`Overwrote ${relPath}`));
+            }
+            else {
+                console.log(kleur.gray(`Skipped ${relPath}`));
+                installedPaths.push({ path: relPath, type: "file", status: "skipped_existing" });
+            }
+        }
+        else {
+            ensureDir(path.dirname(targetPath));
+            fs.copyFileSync(entry, targetPath);
+            installedPaths.push({ path: relPath, type: "file", status: "installed" });
+        }
+    }
+}
+// Helpers
+function getAllFiles(dir, fileList = []) {
+    const files = fs.readdirSync(dir);
+    files.forEach(file => {
+        const filePath = path.join(dir, file);
+        if (fs.statSync(filePath).isDirectory()) {
+            getAllFiles(filePath, fileList);
+        }
+        else {
+            fileList.push(filePath);
+        }
+    });
+    return fileList;
+}
+function copyDirRec(src, dest, trackList, root, silentTrack = false) {
+    ensureDir(dest);
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRec(srcPath, destPath, trackList, root, silentTrack);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+            if (!silentTrack) {
+                trackList.push({
+                    path: path.relative(root, destPath),
+                    type: "file",
+                    status: "installed"
+                });
+            }
+        }
+    }
+}
+function safeCopy(src, dest, trackList, root) {
+    if (fs.existsSync(dest))
+        return; // Skip if exists
+    if (!fs.existsSync(src))
+        return; // Skip if source missing
+    ensureDir(path.dirname(dest));
+    fs.copyFileSync(src, dest);
+    trackList.push({
+        path: path.relative(root, dest),
+        type: "file",
+        status: "installed"
+    });
+}
+function areFilesEqual(a, b) {
+    const bufA = fs.readFileSync(a);
+    const bufB = fs.readFileSync(b);
+    return bufA.equals(bufB);
+}

package/dist/iris/manifest.js

@@ -0,0 +1,54 @@
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import { writeFile } from "../lib.js";
+const MANIFEST_PATH = path.join(process.cwd(), ".iris/manifest.yaml");
+export function loadManifest() {
+    if (!fs.existsSync(MANIFEST_PATH))
+        return null;
+    try {
+        const doc = yaml.load(fs.readFileSync(MANIFEST_PATH, "utf8"));
+        // Basic migration/defaulting if needed
+        return {
+            version: 1,
+            installed_at: new Date().toISOString(),
+            tools_selected: [],
+            paths_installed: [],
+            created_dirs: [],
+            ...doc
+        };
+    }
+    catch (e) {
+        console.error("Failed to parse manifest:", e);
+        return null;
+    }
+}
+export function saveManifest(manifest) {
+    writeFile(MANIFEST_PATH, yaml.dump(manifest));
+}
+export function updateManifest(updates) {
+    const current = loadManifest() || {
+        version: 1,
+        installed_at: new Date().toISOString(),
+        tools_selected: [],
+        paths_installed: [],
+        created_dirs: [],
+    };
+    const updated = {
+        ...current,
+        ...updates,
+        installed_at: new Date().toISOString(), // Always update timestamp
+        tools_selected: Array.from(new Set([...current.tools_selected, ...(updates.tools_selected || [])])),
+        paths_installed: mergePaths(current.paths_installed, updates.paths_installed || []),
+        created_dirs: Array.from(new Set([...current.created_dirs, ...(updates.created_dirs || [])])),
+    };
+    saveManifest(updated);
+}
+function mergePaths(current, updates) {
+    // Map current paths by path string for easy update
+    const map = new Map();
+    current.forEach(p => map.set(p.path, p));
+    // Apply updates
+    updates.forEach(p => map.set(p.path, p));
+    return Array.from(map.values());
+}