project-iris 0.0.1

package/dist/iris/importers/speckit.js

@@ -0,0 +1,15 @@
+import { ImporterError } from './types.js';
+export const SpeckitImporter = {
+    id: 'speckit',
+    displayName: 'Speckit',
+    async runInstaller(_ctx) {
+        // Per requirements, we explicitly define this as unsupported for now
+        // to avoid guessing the installer command.
+        throw new ImporterError("Speckit import isn’t supported yet because its install command isn’t standardized. Use --from (future) or contribute an adapter.", 4 // Use a distinct exit code for "Not Supported" / Policy Error
+        );
+    },
+    async detectDoctrineRoots(_ctx) {
+        // Unreachable due to runInstaller throwing
+        return { templateDirs: [] };
+    }
+};

package/dist/iris/importers/specsmd.js

@@ -0,0 +1,78 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { ImporterError } from './types.js';
+import { runCmd } from '../proc.js';
+const SIGNAL_FILES = ['requirements.md', 'system-context.md', 'spec.md'];
+export const SpecsMdImporter = {
+    id: 'specsmd',
+    displayName: 'specs.md',
+    async runInstaller(ctx) {
+        if (process.env.IRIS_TEST_FAKE_INSTALLER === '1') {
+            if (ctx.verbose)
+                console.log('Simulating specsmd install...');
+            // Create a simulated installed structure
+            const templatesDir = path.join(ctx.tempDir, 'templates');
+            fs.mkdirSync(templatesDir, { recursive: true });
+            fs.writeFileSync(path.join(templatesDir, 'requirements.md'), '# Requirements\n');
+            fs.writeFileSync(path.join(templatesDir, 'system-context.md'), '# System Context\n');
+            return;
+        }
+        // Offline Guard
+        if (process.env.IRIS_OFFLINE === '1') {
+            throw new ImporterError('Cannot install specsmd in IRIS_OFFLINE mode.', 1);
+        }
+        try {
+            // Use --yes to avoid interactive prompts (install confirmation)
+            await runCmd('npx', ['--yes', 'specsmd@latest', 'install'], {
+                cwd: ctx.tempDir,
+                verbose: ctx.verbose
+            });
+        }
+        catch (err) {
+            throw new ImporterError(`Failed to install specsmd: ${err.message}`, 1);
+        }
+    },
+    async detectDoctrineRoots(ctx) {
+        const candidates = ['templates', '.specs', 'docs/templates', '.'];
+        // Scan candidates and score them
+        const scored = candidates.map(relPath => {
+            const fullPath = path.join(ctx.tempDir, relPath);
+            if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isDirectory()) {
+                return { path: fullPath, score: 0 };
+            }
+            let score = 0;
+            let mdCount = 0;
+            try {
+                const files = fs.readdirSync(fullPath);
+                for (const file of files) {
+                    if (file.endsWith('.md')) {
+                        mdCount++;
+                        score += 1;
+                    }
+                    if (SIGNAL_FILES.includes(file)) {
+                        score += 10;
+                    }
+                }
+            }
+            catch (e) {
+                // ignore read errors
+            }
+            // Bonus sanity check: require at least 2 md files OR 1 signal file to count at all
+            if (mdCount < 2 && score < 10) {
+                score = 0;
+            }
+            return { path: fullPath, score, mdCount, signal: score >= 10 };
+        });
+        if (ctx.verbose) {
+            console.log('Template detection candidates:');
+            scored.forEach(s => console.log(`  - ${path.relative(ctx.tempDir, s.path) || '.'}: score=${s.score} (md=${s.mdCount}, signal=${s.signal})`));
+        }
+        // Sort by score descending
+        scored.sort((a, b) => b.score - a.score);
+        const best = scored[0];
+        if (best.score >= 2) { // Minimum threshold
+            return { templateDirs: [best.path] };
+        }
+        throw new ImporterError(`Could not detect a valid template directory for specsmd. Scanned: ${candidates.join(', ')}`, 1);
+    }
+};

package/dist/iris/importers/types.js

@@ -0,0 +1,8 @@
+export class ImporterError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = 'ImporterError';
+    }
+}

package/dist/iris/importers/writer.js

@@ -0,0 +1,139 @@
+import * as fs from 'fs';
+import * as path from 'path';
+// Safe extensions to import
+const SAFE_EXTENSIONS = ['.md', '.txt', '.yml', '.yaml', '.json'];
+const IGNORED_DIRS = ['node_modules', '.git', 'dist', 'build', 'coverage'];
+export function ensureDoctrineOnlyFlowInstalled(opts) {
+    const result = {
+        flowId: opts.flowId,
+        installedDir: '', // set below
+        copiedFiles: 0,
+        skippedFiles: 0,
+        overwrittenFiles: 0,
+    };
+    const flowDir = path.join(opts.repoRoot, '.iris', 'flows', opts.flowId);
+    result.installedDir = flowDir;
+    if (opts.verbose) {
+        console.log(`Preparing to install flow '${opts.flowId}' into ${flowDir}`);
+    }
+    // 1. Check if flow already exists
+    if (fs.existsSync(flowDir) && !opts.force) {
+        // If not creating/updating, we might still want to report what happened, 
+        // but typically we'd expect the caller to handle "already exists" checks if they wanted to abort early.
+        // However, the requirement is "overwrite if force", which implies "skip/merge if not force".
+        // For simplicity, if it exists and !force, we might just return early if we consider the flow "installed".
+        // But let's proceed to copy templates with "skip existing" semantics.
+    }
+    if (opts.dryRun) {
+        console.log(`[Dry Run] Would create/update flow directory: ${flowDir}`);
+    }
+    else {
+        fs.mkdirSync(flowDir, { recursive: true });
+    }
+    // 2. Ensure flow.yaml exists
+    const flowYamlPath = path.join(flowDir, 'flow.yaml');
+    if (opts.dryRun) {
+        if (!fs.existsSync(flowYamlPath) || opts.force) {
+            console.log(`[Dry Run] Would write flow.yaml for ${opts.flowId}`);
+        }
+    }
+    else {
+        if (!fs.existsSync(flowYamlPath) || opts.force) {
+            const flowYamlContent = `# Generated by iris flow import
+id: ${opts.flowId}
+name: ${opts.flowId}
+description: Imported from ${opts.displayName}
+version: imported
+`;
+            fs.writeFileSync(flowYamlPath, flowYamlContent);
+        }
+    }
+    // 3. Ensure overlays exist (empty)
+    const overlays = ['policy.overlay.yaml', 'routes.overlay.yaml'];
+    for (const file of overlays) {
+        const filePath = path.join(flowDir, file);
+        if (opts.dryRun) {
+            if (!fs.existsSync(filePath) || opts.force) {
+                console.log(`[Dry Run] Would ensure empty ${file}`);
+            }
+        }
+        else {
+            if (!fs.existsSync(filePath) || opts.force) {
+                fs.writeFileSync(filePath, '{}\n');
+            }
+        }
+    }
+    // 4. Copy templates
+    // Destination: .iris/flows/<id>/doctrine/templates/<id>/...
+    // We nest under <id> again inside templates/ to avoid collision if multiple flows share generic names,
+    // and to keep it namespaced.
+    const destTemplateRoot = path.join(flowDir, 'doctrine', 'templates', opts.flowId);
+    if (opts.dryRun) {
+        console.log(`[Dry Run] Would copy templates to ${destTemplateRoot}`);
+    }
+    else {
+        fs.mkdirSync(destTemplateRoot, { recursive: true });
+    }
+    for (const srcDir of opts.sourceTemplateDirs) {
+        copyRecursive(srcDir, destTemplateRoot, opts, result);
+    }
+    return result;
+}
+function copyRecursive(src, dest, opts, result, relPath = '') {
+    if (!fs.existsSync(src))
+        return;
+    const stats = fs.statSync(src);
+    if (stats.isDirectory()) {
+        // Check ignore list
+        const dirName = path.basename(src);
+        if (IGNORED_DIRS.includes(dirName))
+            return;
+        if (!opts.dryRun) {
+            fs.mkdirSync(dest, { recursive: true });
+        }
+        const children = fs.readdirSync(src);
+        for (const child of children) {
+            copyRecursive(path.join(src, child), path.join(dest, child), opts, result, path.join(relPath, child));
+        }
+    }
+    else if (stats.isFile()) {
+        // Filter extensions
+        const ext = path.extname(src).toLowerCase();
+        if (!SAFE_EXTENSIONS.includes(ext)) {
+            if (opts.verbose)
+                console.log(`Skipping unsafe/irrelevant file type: ${src}`);
+            return;
+        }
+        if (opts.dryRun) {
+            // Just log what would happen
+            if (fs.existsSync(dest)) {
+                if (opts.force) {
+                    console.log(`[Dry Run] Would overwrite ${relPath}`);
+                    result.overwrittenFiles++;
+                }
+                else {
+                    console.log(`[Dry Run] Would skip existing ${relPath}`);
+                    result.skippedFiles++;
+                }
+            }
+            else {
+                console.log(`[Dry Run] Would copy ${relPath}`);
+                result.copiedFiles++;
+            }
+            return;
+        }
+        if (fs.existsSync(dest)) {
+            if (opts.force) {
+                fs.copyFileSync(src, dest);
+                result.overwrittenFiles++;
+            }
+            else {
+                result.skippedFiles++;
+            }
+        }
+        else {
+            fs.copyFileSync(src, dest);
+            result.copiedFiles++;
+        }
+    }
+}

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,334 @@
+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";
+import { getBundleRoot, getBundledFrameworksDir } from "./bundle.js";
+export const TOOLS = ["claude", "cursor", "gemini", "antigravity", "codex", "auto"];
+const BUNDLE_ROOT = getBundleRoot();
+/**
+ * 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")),
+        auto: false,
+    };
+    return TOOLS.filter(t => checks[t]);
+}
+export async function installIris(root, tools, options = {}) {
+    // 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: Framework & Core Configuration
+    // New (Step 3): Install iris-core framework as the Single Source of Truth
+    // Then populate legacy mirrors (.iris/aidlc, policy.yaml, etc) from it.
+    const bundledFrameworksDir = getBundledFrameworksDir();
+    const sourceIrisCore = path.join(bundledFrameworksDir, "iris-core");
+    const frameworksDir = path.join(targetIris, "frameworks");
+    const targetIrisCore = path.join(frameworksDir, "iris-core");
+    ensureDir(frameworksDir);
+    // 1. Install Framework (Idempotent: Skip if exists unless --force)
+    let installedFramework = false;
+    if (fs.existsSync(sourceIrisCore)) {
+        if (fs.existsSync(targetIrisCore) && !options.force) {
+            // Skip
+            // console.log(kleur.gray("Skipped iris-core (exists)"));
+            // Check for version mismatch (UX enhancement)
+            try {
+                const targetManifestPath = path.join(targetIrisCore, "framework.yaml");
+                const sourceManifestPath = path.join(sourceIrisCore, "framework.yaml");
+                if (fs.existsSync(targetManifestPath) && fs.existsSync(sourceManifestPath)) {
+                    const targetManifest = JSON.parse(fs.readFileSync(targetManifestPath, 'utf8')); // Yaml is subset of json? No, need yaml parser or simple regex for version.
+                    // We don't have yaml parser imported here easily (maybe?) inquirer or kleur doesn't help.
+                    // Let's use simple regex since we control the manifest format mostly.
+                    const getVer = (content) => {
+                        const m = content.match(/version:\s*["']?([\w.-]+)["']?/);
+                        return m ? m[1] : null;
+                    };
+                    const targetVer = getVer(fs.readFileSync(targetManifestPath, 'utf8'));
+                    const sourceVer = getVer(fs.readFileSync(sourceManifestPath, 'utf8'));
+                    if (targetVer && sourceVer && targetVer !== sourceVer) {
+                        console.log(kleur.yellow(`Warning: Installed iris-core is v${targetVer}, but bundled is v${sourceVer}.`));
+                        console.log(kleur.yellow(`Run 'iris install --force' to update (will overwrite changes).`));
+                    }
+                }
+            }
+            catch (e) {
+                // ignore 
+            }
+        }
+        else {
+            // Install / Overwrite
+            if (fs.existsSync(targetIrisCore)) {
+                // Force overwrite implies we can clobber. 
+                // Simple recursive copy over top works for updating files.
+            }
+            ensureDir(targetIrisCore);
+            copyDirRec(sourceIrisCore, targetIrisCore, [], root, true);
+            installedFramework = true;
+            installedPaths.push({
+                path: ".iris/frameworks/iris-core",
+                type: "directory",
+                status: "installed"
+            });
+        }
+    }
+    // 2. Compatibility Mirror: .iris/aidlc
+    // Populated FROM the valid target iris-core framework
+    // This ensures legacy tools see the same templates as the framework.
+    const targetAidlc = path.join(targetIris, "aidlc");
+    ensureDir(targetAidlc);
+    // Mirror Templates
+    const frameworkTemplates = path.join(targetIrisCore, "templates");
+    const aidlcTemplates = path.join(targetAidlc, "templates");
+    // Only mirror if framework templates exist
+    if (fs.existsSync(frameworkTemplates)) {
+        // If aidlc/templates exists, only overwrite if force? 
+        // Or always align mirror to framework? 
+        // "Keep it read-only in spirit". Aligning is safer.
+        // But if user modified aidlc, we clobber? 
+        // Let's protect user edits in aidlc too unless force.
+        if (!fs.existsSync(aidlcTemplates) || options.force) {
+            ensureDir(aidlcTemplates);
+            copyDirRec(frameworkTemplates, aidlcTemplates, [], root, true);
+        }
+    }
+    // Legacy Config Mirrors (policy.yaml, routes.yaml)
+    // Copy from framework -> .iris/ root IF MISSING (don't overwrite config by default)
+    // We do NOT use --force to overwrite these configs usually, as they are user-owned once installed.
+    // Spec: "Default: Skip if exists (preserve user edits). If --force: Overwrite."
+    // So we respect that for these files too if we consider them part of "install".
+    const frameworkPolicy = path.join(targetIrisCore, "policy.yaml");
+    const targetPolicy = path.join(targetIris, "policy.yaml");
+    if (fs.existsSync(frameworkPolicy) && (!fs.existsSync(targetPolicy) || options.force)) {
+        fs.copyFileSync(frameworkPolicy, targetPolicy);
+        installedPaths.push({ path: ".iris/policy.yaml", type: "file", status: "installed" });
+    }
+    const frameworkRoutes = path.join(targetIrisCore, "routes.yaml");
+    const targetRoutes = path.join(targetIris, "routes.yaml");
+    if (fs.existsSync(frameworkRoutes) && (!fs.existsSync(targetRoutes) || options.force)) {
+        fs.copyFileSync(frameworkRoutes, targetRoutes);
+        installedPaths.push({ path: ".iris/routes.yaml", type: "file", status: "installed" });
+    }
+    // Add README to aidlc
+    const mirrorReadme = path.join(targetAidlc, "README.md");
+    if (!fs.existsSync(mirrorReadme)) {
+        fs.writeFileSync(mirrorReadme, "# Legacy Mirror\n\nThis directory is a compatibility mirror of `.iris/frameworks/iris-core`.\nDo not edit files here; they may be overwritten by system updates.\nEdit the framework files instead.\n");
+    }
+    // 3. State (only if missing)
+    if (!fs.existsSync(path.join(targetIris, "state.yaml"))) {
+        if (fs.existsSync(path.join(bundleIris, "state.yaml"))) {
+            fs.copyFileSync(path.join(bundleIris, "state.yaml"), path.join(targetIris, "state.yaml"));
+            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/interactive/env.js

@@ -0,0 +1,21 @@
+export function checkInteractiveMode(options) {
+    // 1. Force Interactive overrides all
+    if (options.forceInteractive) {
+        return { isInteractive: true, reason: "Forced by user flag" };
+    }
+    // 2. Explicit Non-Interactive
+    if (options.nonInteractive) {
+        return { isInteractive: false, reason: "User requested non-interactive mode" };
+    }
+    // 3. CI Detection
+    // Common CI env vars: CI, GITHUB_ACTIONS, GITLAB_CI, CIRCLECI, TRAVIS
+    if (process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI) {
+        return { isInteractive: false, reason: "CI environment detected" };
+    }
+    // 4. TTY Detection
+    // process.stdin.isTTY is undefined or false if piped/redirected
+    if (!process.stdin.isTTY) {
+        return { isInteractive: false, reason: "No TTY detected (piped input)" };
+    }
+    return { isInteractive: true };
+}