project-iris 0.0.1

package/dist/commands/flow.js

@@ -0,0 +1,301 @@
+import { Command } from "commander";
+import kleur from "kleur";
+import { repoRoot, ensureDir } from "../lib.js";
+import { loadState, saveState } from "../iris/state.js";
+import { listInstalledFlows, loadFlowManifest } from "../iris/flows/manifest.js";
+import { loadEffectivePolicy } from "../iris/policy.js";
+import { loadEffectiveRoutes } from "../iris/routes.js";
+import { validate } from "../iris/validator.js";
+import { printReport } from "../iris/report.js";
+import { EXIT_CODES } from "../utils/exit-codes.js";
+import { getBundledFlowsDir, listBundledFlows } from "../iris/bundle.js";
+import fs from "fs";
+import path from "path";
+import { getImporter } from "../iris/importers/index.js";
+import { ensureDoctrineOnlyFlowInstalled } from "../iris/importers/writer.js";
+import { makeTempDir, removeTempDir } from "../iris/tmp.js";
+import { ImporterError } from "../iris/importers/types.js";
+const importFlowCommand = new Command("import")
+    .description("Import an external methodology as a doctrine-only flow (DEPRECATED)")
+    .argument("<provider>", "Provider ID")
+    .option("-f, --force", "Overwrite existing files", false)
+    .option("-d, --dry-run", "Simulate import without writing files", false)
+    .option("-v, --verbose", "Show detailed output", false)
+    .action(async (providerId, options) => {
+    const root = repoRoot();
+    const importer = getImporter(providerId);
+    if (!importer) {
+        console.error(kleur.red(`No import providers available.`));
+        console.log(kleur.yellow("IRIS ships only iris-core. External imports are not supported for now."));
+        process.exit(1);
+    }
+    console.log(kleur.bold(`Importing '${importer.displayName}'...`));
+    if (options.dryRun)
+        console.log(kleur.yellow("[Dry Run Mode]"));
+    console.warn(kleur.yellow("IRIS_WARNING IRIS_FLOW_IMPORT_DEPRECATED: use \"iris framework install <id>\" instead."));
+    let tempDir = "";
+    try {
+        tempDir = makeTempDir(providerId);
+        if (options.verbose)
+            console.log(kleur.dim(`Temporary workspace: ${tempDir}`));
+        // 1. Run Installer
+        try {
+            await importer.runInstaller({
+                repoRoot: root,
+                tempDir,
+                provider: providerId,
+                force: options.force,
+                dryRun: options.dryRun,
+                verbose: options.verbose
+            });
+        }
+        catch (e) {
+            if (e instanceof ImporterError && e.exitCode === 4) {
+                // Policy/Not Supported error (e.g. Speckit)
+                // Print friendly message and exit cleanly without stack trace
+                console.error(kleur.yellow(e.message));
+                process.exit(4);
+            }
+            throw e;
+        }
+        // 2. Detect Templates
+        const { templateDirs } = await importer.detectDoctrineRoots({
+            repoRoot: root,
+            tempDir,
+            provider: providerId,
+            force: options.force,
+            dryRun: options.dryRun,
+            verbose: options.verbose
+        });
+        if (options.verbose) {
+            console.log(kleur.dim(`Detected template roots: ${templateDirs.length > 0 ? templateDirs.join(", ") : "None"}`));
+        }
+        // 3. Install
+        const result = ensureDoctrineOnlyFlowInstalled({
+            repoRoot: root,
+            flowId: providerId,
+            displayName: importer.displayName,
+            sourceTemplateDirs: templateDirs,
+            force: options.force,
+            dryRun: options.dryRun,
+            verbose: options.verbose
+        });
+        if (result.installedDir && !options.dryRun) {
+            // 4. Validate
+            try {
+                loadFlowManifest(root, providerId);
+            }
+            catch (e) {
+                console.warn(kleur.yellow("\nWarning: Imported flow structure seems invalid:"));
+                console.warn(kleur.red(e.message));
+            }
+        }
+        // Summary
+        console.log(kleur.green(`\n✓ Imported ${importer.displayName} as flow '${providerId}'`));
+        if (options.dryRun) {
+            console.log(kleur.dim(`  [Dry Run] Would copy: ${result.copiedFiles}, Skip: ${result.skippedFiles}, Overwrite: ${result.overwrittenFiles}`));
+        }
+        else {
+            console.log(kleur.dim(`  Files: ${result.copiedFiles} created, ${result.skippedFiles} skipped, ${result.overwrittenFiles} overwritten.`));
+            console.log(kleur.dim(`  Templates: .iris/flows/${providerId}/doctrine/templates/${providerId}/...`));
+            console.log(`\nTo activate, run: ${kleur.cyan(`iris flow use ${providerId}`)}`);
+            console.log(kleur.gray(`This will make the '${importer.displayName}' templates available to doctrine.`));
+        }
+    }
+    catch (e) {
+        console.error(kleur.red(`\nImport failed: ${e.message}`));
+        if (options.verbose && e.stack)
+            console.error(kleur.dim(e.stack));
+        // Rollback: If we created a directory but failed, remove it
+        // We need to know the target dir. It's safe to assume .iris/flows/<providerId>
+        const flowDir = path.join(root, ".iris/flows", providerId);
+        if (!options.dryRun && fs.existsSync(flowDir)) {
+            // Only rollback if we created it in this run? 
+            // It's hard to track perfectly without more state, but for safety in "import"
+            // if it failed, leaving a partial flow is bad. 
+            // Limitation: If we were updating (--force) and failed, we might lose the original flow.
+            // Risk acceptance: --force implies destructive.
+            // For new installs, this is safe. 
+            try {
+                // Check if it looks like a partial install? or just nuke it.
+                console.log(kleur.yellow(`Rolling back partial installation at ${flowDir}...`));
+                fs.rmSync(flowDir, { recursive: true, force: true });
+            }
+            catch (cleanupErr) {
+                console.error(kleur.red(`Failed to rollback: ${cleanupErr}`));
+            }
+        }
+        // Ensure we don't return 0
+        process.exit(1);
+    }
+    finally {
+        if (tempDir) {
+            removeTempDir(tempDir);
+            if (options.verbose)
+                console.log(kleur.dim("Cleaned up temp workspace."));
+        }
+    }
+});
+const installCommand = new Command("install")
+    .description("Install a flow from the bundle")
+    .argument("<flowId>", "ID of the flow to install")
+    .option("-f, --force", "Overwrite existing files", false)
+    .action((flowId, options) => {
+    const root = repoRoot();
+    const bundledFlowsDir = getBundledFlowsDir();
+    const sourceDir = path.join(bundledFlowsDir, flowId);
+    // 1. Check Source
+    if (!fs.existsSync(sourceDir)) {
+        console.error(kleur.red(`Bundled flow '${flowId}' not found.`));
+        const available = listBundledFlows();
+        if (available.length > 0) {
+            console.log(kleur.cyan("Available flows:"));
+            available.forEach(id => console.log(`  - ${id}`));
+        }
+        process.exit(1);
+    }
+    const targetDir = path.join(root, ".iris/flows", flowId);
+    console.log(kleur.bold(`Installing flow '${flowId}' to .iris/flows/${flowId}...`));
+    // 2. Install (Recursive Copy with stats)
+    const stats = { installed: 0, skipped: 0, overwritten: 0 };
+    function copyRec(src, dest) {
+        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()) {
+                copyRec(srcPath, destPath);
+            }
+            else if (entry.isFile()) {
+                if (fs.existsSync(destPath)) {
+                    if (options.force) {
+                        fs.copyFileSync(srcPath, destPath);
+                        stats.overwritten++;
+                        // console.log(kleur.gray(`  Overwrote ${entry.name}`));
+                    }
+                    else {
+                        stats.skipped++;
+                        // console.log(kleur.gray(`  Skipped ${entry.name} (exists)`));
+                    }
+                }
+                else {
+                    fs.copyFileSync(srcPath, destPath);
+                    stats.installed++;
+                    // console.log(kleur.green(`  Created ${entry.name}`));
+                }
+            }
+        }
+    }
+    try {
+        copyRec(sourceDir, targetDir);
+    }
+    catch (e) {
+        console.error(kleur.red(`Installation failed: ${e.message}`));
+        process.exit(1);
+    }
+    // 3. Post-Install Validation
+    try {
+        loadFlowManifest(root, flowId);
+        // Optional: Check existence of overlays explicitly if manifest says so?
+        // loadFlowManifest checks structure. 
+        // We can trust it for now or do improved checks later.
+    }
+    catch (e) {
+        console.error(kleur.yellow(`\nWarning: Installed flow '${flowId}' seems invalid:`));
+        console.error(kleur.red(e.message));
+        console.log("Installation completed but flow may not work.");
+        process.exit(1);
+    }
+    console.log(kleur.green(`\n✓ Flow '${flowId}' installed successfully.`));
+    console.log(kleur.dim(`  Files: ${stats.installed} created, ${stats.overwritten} overwritten, ${stats.skipped} skipped.`));
+    console.log(`\nTo activate, run: ${kleur.cyan(`iris flow use ${flowId}`)}`);
+});
+const listCommand = new Command("list")
+    .description("List installed flows")
+    .action(() => {
+    const root = repoRoot();
+    const state = loadState();
+    const flows = listInstalledFlows(root);
+    if (flows.length === 0) {
+        console.log(kleur.gray("No flows installed."));
+        return;
+    }
+    console.log(kleur.bold("\nInstalled Flows:"));
+    for (const flow of flows) {
+        const isActive = state.active.flow === flow.id;
+        const status = isActive ? kleur.green("(active)") : "";
+        const line = `${kleur.cyan(flow.id.padEnd(20))} ${flow.name} ${kleur.dim(flow.version)} ${status}`;
+        console.log(line);
+    }
+    console.log("");
+});
+const useCommand = new Command("use")
+    .description("Switch the active flow")
+    .argument("<flowId>", "ID of the flow to switch to")
+    .action(async (flowId) => {
+    const root = repoRoot();
+    const state = loadState();
+    if (state.active.flow === flowId) {
+        console.log(kleur.yellow(`Flow '${flowId}' is already active.`));
+        return;
+    }
+    // 1. Safety Check (Dry Run)
+    // Verify we can load policy and routes BEFORE switching
+    try {
+        console.log(kleur.dim(`Verifying flow '${flowId}' integrity...`));
+        // Check manifest existence implicit in these loaders (via loadFlowManifest)
+        // Resolve framework to ensure compatibility (best effort check)
+        // We import resolveActiveFramework dynamically or add import? 
+        // Better to rely on null if we don't want to async resolve here?
+        // Actually useCommand IS async action.
+        // But we need to import resolveActiveFramework.
+        // Let's pass null for framework for now to just check OVERLAY existence, 
+        // unless we want strict framework compatibility check.
+        // Step 1 logic implies overlays are valid if files exist.
+        // NOTE: Changing signature to (null, root, flowId) due to refactor
+        loadEffectivePolicy(null, root, flowId);
+        console.log(kleur.dim("  Policy overlay: OK"));
+        loadEffectiveRoutes(null, root, flowId);
+        console.log(kleur.dim("  Routes overlay: OK"));
+    }
+    catch (e) {
+        console.error(kleur.red(`\nCannot switch to flow '${flowId}':`));
+        if (e.name === "PolicyOverlayMissingError" || e.name === "RoutesOverlayMissingError") {
+            console.error(kleur.red(`  ${e.message}`));
+            console.error(kleur.yellow("  This flow is broken (missing required overlay). Fix it or reinstall."));
+        }
+        else if (e.name === "FlowNotFoundError") {
+            console.error(kleur.red(`  Flow '${flowId}' is not installed.`));
+        }
+        else {
+            console.error(kleur.red(`  ${e.message}`));
+            if (e.cause)
+                console.error(kleur.gray(`  Cause: ${e.cause}`));
+        }
+        process.exit(EXIT_CODES.POLICY_ERROR);
+    }
+    // 2. Update State
+    state.active.flow = flowId;
+    saveState(state);
+    console.log(kleur.green(`Switched to flow: ${flowId}`));
+    // 3. Run Validation (Info only)
+    console.log(kleur.dim("Validating new requirements..."));
+    const result = await validate({
+        apply: false,
+        strict: false,
+        writeBack: false // Don't verify/update validation timestamp just for this check? Or yes?
+        // "validates manifest exists and sets state... then runs validate (non-fix) to show new requirements"
+        // Usually we want to show the report.
+    });
+    printReport(result, false);
+    if (!result.valid) {
+        console.log(kleur.yellow("\nNote: You may need to satisfy new requirements. Run 'iris fix' or 'iris validate'."));
+    }
+});
+export const flowCommand = new Command("flow")
+    .description("Manage active flows")
+    .addCommand(listCommand)
+    .addCommand(installCommand)
+    .addCommand(importFlowCommand)
+    .addCommand(useCommand);

package/dist/commands/framework.js

@@ -0,0 +1,273 @@
+import { Command } from "commander";
+import kleur from "kleur";
+import { loadState, getActiveFramework, setActiveFramework } from "../iris/state.js";
+import { loadFramework } from "../framework/framework-loader.js";
+import { repoRoot } from "../lib.js";
+import { listInstalledFrameworks, listBundledFrameworks, installFrameworkFromPath, installBundledFramework, removeFramework, validateFrameworkParams } from "../iris/framework-manager.js";
+export const frameworkCommand = new Command("framework")
+    .description("Manage IRIS frameworks");
+frameworkCommand
+    .command("current")
+    .description("Show the currently active framework")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const state = loadState();
+    const active = getActiveFramework(state);
+    const root = repoRoot();
+    let resolution = null;
+    let error = null;
+    try {
+        resolution = await loadFramework(active.current, { repoRoot: root });
+    }
+    catch (e) {
+        error = e;
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            schemaVersion: 1,
+            active: {
+                id: active.current,
+                version: active.version
+            },
+            resolved: !!resolution,
+            rootDir: resolution?.rootDir || null,
+            source: resolution ? {
+                kind: resolution.source.kind,
+                path: resolution.source.path,
+                ...(resolution.source.id ? { id: resolution.source.id } : {})
+            } : null,
+            error: error ? {
+                code: error.code || 'UNKNOWN',
+                path: error.path || null,
+                hint: error.hint || null
+            } : null
+        }, null, 2));
+        return;
+    }
+    // Human output
+    console.log("");
+    if (resolution) {
+        console.log(kleur.bold(`Active Framework: ${kleur.green(active.current)}`));
+        if (active.version) {
+            console.log(`Version Pin: ${kleur.cyan(active.version)}`);
+        }
+        console.log(kleur.gray(`Location: ${resolution.rootDir}`));
+        if (resolution.manifest.version) {
+            console.log(`Manifest Version: ${resolution.manifest.version}`);
+        }
+    }
+    else {
+        console.log(kleur.bold(`Active Framework: ${kleur.yellow(active.current)} (Not Found)`));
+        if (active.version) {
+            console.log(`Version Pin: ${kleur.cyan(active.version)}`);
+        }
+        console.log(kleur.red(`Error: ${error?.message || "Could not resolve framework"}`));
+        if (error?.hint) {
+            console.log(kleur.gray(`Hint: ${error.hint}`));
+        }
+    }
+});
+frameworkCommand
+    .command("use")
+    .description("Switch the active framework")
+    .argument("<id>", "Framework ID (can include @version)")
+    .option("--strict", "Fail if framework cannot be resolved")
+    .action(async (idStr, options) => {
+    // Parse ID and Version
+    const lastAt = idStr.lastIndexOf('@');
+    let id = idStr;
+    let version = null;
+    if (lastAt > 0) {
+        id = idStr.substring(0, lastAt);
+        version = idStr.substring(lastAt + 1);
+    }
+    const root = repoRoot();
+    const state = loadState();
+    // Check if resolvable
+    try {
+        await loadFramework(id, { repoRoot: root });
+    }
+    catch (error) {
+        if (options.strict) {
+            console.error(kleur.red(`Error: Framework '${id}' not found.`));
+            console.error(kleur.gray(error.message));
+            process.exit(1);
+        }
+        else {
+            console.warn(kleur.yellow(`Warning: Framework '${id}' could not be resolved. Setting anyway.`));
+        }
+    }
+    setActiveFramework(state, id, version);
+    console.log(kleur.green(`✓ Set active framework to: ${kleur.bold(id)}`));
+    if (version) {
+        console.log(kleur.cyan(`  Pinned version: ${version}`));
+    }
+});
+frameworkCommand
+    .command("list")
+    .description("List installed and available frameworks")
+    .action(async () => {
+    const root = repoRoot();
+    const installed = await listInstalledFrameworks(root);
+    const bundled = await listBundledFrameworks();
+    // Merge strategy: map by ID
+    const map = new Map();
+    for (const i of installed) {
+        if (!map.has(i.id))
+            map.set(i.id, {});
+        map.get(i.id).installed = i;
+    }
+    for (const b of bundled) {
+        if (!map.has(b.id))
+            map.set(b.id, {});
+        map.get(b.id).bundled = b;
+    }
+    console.log(kleur.bold("\nFrameworks:\n"));
+    // Output format
+    // ID  Version  Status
+    const sortedIds = Array.from(map.keys()).sort();
+    for (const id of sortedIds) {
+        const entry = map.get(id);
+        const inst = entry.installed;
+        const bund = entry.bundled;
+        let status = "";
+        let version = "";
+        let meta = "";
+        if (inst) {
+            version = inst.version || "???";
+            if (inst.active)
+                status = kleur.green("Active");
+            else if (inst.valid)
+                status = "Installed";
+            else
+                status = kleur.red("Broken");
+            if (bund)
+                meta = kleur.gray("(Bundled available)");
+        }
+        else if (bund) {
+            version = bund.version || "bundled";
+            status = kleur.dim("Bundled");
+            meta = kleur.gray("(Use 'iris framework install' to install)");
+        }
+        console.log(`  ${kleur.bold(id.padEnd(20))} ${version.padEnd(10)} ${status.padEnd(15)} ${meta}`);
+        if (inst?.error) {
+            console.log(kleur.red(`    Error: ${inst.error.message}`));
+        }
+    }
+    console.log("");
+});
+frameworkCommand
+    .command("add")
+    .description("Install a framework from a local directory")
+    .argument("<path>", "Path to framework folder")
+    .option("-f, --force", "Overwrite existing framework if present")
+    .action(async (srcPath, options) => {
+    const root = repoRoot();
+    try {
+        const result = await installFrameworkFromPath(root, srcPath, { force: options.force });
+        console.log(kleur.green(`✓ Added framework '${result.id}' (v${result.version})`));
+        console.log(kleur.gray(`  Installed to: ${result.path}`));
+    }
+    catch (error) {
+        console.error(kleur.red(`Error: ${error.message}`));
+        if (error.hint)
+            console.error(kleur.gray(`Hint: ${error.hint}`));
+        process.exit(1);
+    }
+});
+frameworkCommand
+    .command("install")
+    .description("Install a bundled framework")
+    .argument("<id>", "Framework ID")
+    .option("-f, --force", "Overwrite existing framework if present")
+    .action(async (id, options) => {
+    const root = repoRoot();
+    try {
+        const result = await installBundledFramework(root, id, { force: options.force });
+        console.log(kleur.green(`✓ Installed framework '${result.id}' (v${result.version})`));
+    }
+    catch (error) {
+        console.error(kleur.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});
+frameworkCommand
+    .command("remove")
+    .description("Remove an installed framework")
+    .argument("<id>", "Framework ID")
+    .action((id) => {
+    const root = repoRoot();
+    try {
+        removeFramework(root, id);
+        console.log(kleur.green(`✓ Removed framework '${id}'`));
+    }
+    catch (error) {
+        console.error(kleur.red(`Error: ${error.message}`));
+        if (error.hint)
+            console.error(kleur.gray(`Hint: ${error.hint}`));
+        process.exit(1);
+    }
+});
+frameworkCommand
+    .command("validate")
+    .description("Validate a framework")
+    .argument("<input>", "Framework ID or Path")
+    .option("--json", "Output as JSON")
+    .action(async (input, options) => {
+    const root = repoRoot();
+    let result = null;
+    let error = null;
+    try {
+        result = await validateFrameworkParams(input, root);
+    }
+    catch (e) {
+        error = e;
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            schemaVersion: 1,
+            ok: !error,
+            id: result?.manifest?.id || null,
+            rootDir: result?.rootDir || null,
+            files: result?.files ? {
+                policy: !!result.files.policy,
+                routes: !!result.files.routes,
+                interview: !!result.files.interview,
+                pack: !!result.files.pack,
+                templates: !!result.files.templates
+            } : null,
+            warnings: [], // Todo: collecting warnings?
+            error: error ? {
+                code: error.code || 'UNKNOWN',
+                message: error.message,
+                path: error.path
+            } : null
+        }, null, 2));
+        return;
+    }
+    if (error) {
+        console.error(kleur.red(`Validation Failed:`));
+        console.error(kleur.red(`  ${error.message}`));
+        if (error.path)
+            console.error(`  Path: ${error.path}`);
+        if (error.hint)
+            console.error(kleur.gray(`  Hint: ${error.hint}`));
+        process.exit(1);
+    }
+    else {
+        console.log(kleur.green(`✓ Framework '${result.manifest.id}' is valid.`));
+        console.log(kleur.gray(`  Location: ${result.rootDir}`));
+        console.log(`  Version: ${result.manifest.version}`);
+        // List found files?
+        const files = [];
+        if (result.files.policy)
+            files.push("Policy");
+        if (result.files.routes)
+            files.push("Routes");
+        if (result.files.interview)
+            files.push("Interview");
+        if (result.files.templates)
+            files.push("Templates");
+        console.log(`  Components: ${files.join(", ")}`);
+    }
+});

package/dist/commands/generate.js

@@ -0,0 +1,59 @@
+import { Command } from "commander";
+import path from "path";
+import fs from "fs";
+import kleur from "kleur";
+import { resolveActiveFramework } from "../iris/framework-context.js";
+import { loadEffectiveArtifactsConfig } from "../iris/artifacts/config.js";
+import { generateArtifacts } from "../iris/artifacts/generator.js";
+export const generateCommand = new Command("generate")
+    .alias("gen")
+    .description("Synthesize artifacts from an intent draft")
+    .option("-i, --in <path>", "Input draft file (default: .iris/inbox/intent-draft.latest.json)")
+    .option("-o, --out <path>", "Output artifacts file")
+    .option("--json", "Output JSON to stdout")
+    .action(async (opts) => {
+    try {
+        // 1. Resolve Framework
+        const root = process.cwd();
+        const projectRoot = root; // Assume CWD is root for now
+        const { resolution } = await resolveActiveFramework(projectRoot);
+        // resolveActiveFramework returns { resolution, activeFlowId? }
+        const artifactsConfig = loadEffectiveArtifactsConfig(resolution);
+        // 2. Load Draft
+        let draftPath = opts.in;
+        if (!draftPath) {
+            draftPath = path.join(projectRoot, ".iris", "inbox", "intent-draft.latest.json");
+        }
+        else {
+            draftPath = path.resolve(process.cwd(), draftPath); // Resolve relative to CWD
+        }
+        if (!fs.existsSync(draftPath)) {
+            console.error(kleur.red(`Error: Draft file not found at ${draftPath}`));
+            process.exit(1);
+        }
+        const draftContent = fs.readFileSync(draftPath, "utf8");
+        const draft = JSON.parse(draftContent);
+        // 3. Generate
+        const output = generateArtifacts(draft, artifactsConfig, resolution);
+        // 4. Output
+        const jsonStr = JSON.stringify(output, null, 2);
+        if (opts.out) {
+            const outPath = path.resolve(process.cwd(), opts.out);
+            fs.mkdirSync(path.dirname(outPath), { recursive: true });
+            fs.writeFileSync(outPath, jsonStr);
+            if (!opts.json) {
+                console.log(kleur.green(`Artifacts generated at ${outPath}`));
+            }
+        }
+        else if (!opts.json) {
+            console.log(jsonStr);
+        }
+        if (opts.json) {
+            console.log(jsonStr);
+        }
+    }
+    catch (error) {
+        console.error(kleur.red(`Generation Failed: ${error.message}`));
+        process.exit(1);
+    }
+});