project-iris 0.0.6

package/dist/iris/run-state.js

@@ -0,0 +1,143 @@
+import fs from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+import { WorkflowStage } from "../bridge/types.js";
+const RUNS_DIR = path.join(process.cwd(), ".iris/runs");
+/**
+ * Create a new workflow run
+ */
+export function createRun(intent, ideId, gateMode = "manual") {
+    const runId = randomUUID();
+    const now = new Date().toISOString();
+    const runState = {
+        runId,
+        intent,
+        ideId,
+        stage: WorkflowStage.INTENT_INCEPTION,
+        gateMode,
+        artifacts: [],
+        bolts: [],
+        currentBoltIndex: 0,
+        pendingTasks: [],
+        events: [],
+        createdAt: now,
+        updatedAt: now
+    };
+    saveRun(runState);
+    return runState;
+}
+/**
+ * Load a run by ID
+ */
+export function loadRun(runId) {
+    const runPath = path.join(RUNS_DIR, `${runId}.json`);
+    if (!fs.existsSync(runPath)) {
+        throw new Error(`Run not found: ${runId}`);
+    }
+    const content = fs.readFileSync(runPath, "utf8");
+    return JSON.parse(content);
+}
+/**
+ * Save run state
+ */
+export function saveRun(state) {
+    if (!fs.existsSync(RUNS_DIR)) {
+        fs.mkdirSync(RUNS_DIR, { recursive: true });
+    }
+    state.updatedAt = new Date().toISOString();
+    const runPath = path.join(RUNS_DIR, `${state.runId}.json`);
+    fs.writeFileSync(runPath, JSON.stringify(state, null, 2), "utf8");
+    // Also save a small state snapshot for quick resume
+    const statePath = path.join(RUNS_DIR, `${state.runId}.state.json`);
+    const snapshot = {
+        runId: state.runId,
+        stage: state.stage,
+        currentBoltIndex: state.currentBoltIndex,
+        updatedAt: state.updatedAt
+    };
+    fs.writeFileSync(statePath, JSON.stringify(snapshot, null, 2), "utf8");
+}
+/**
+ * Append an event to the run
+ */
+export function appendEvent(runId, event) {
+    const state = loadRun(runId);
+    const fullEvent = {
+        ...event,
+        timestamp: new Date().toISOString()
+    };
+    state.events.push(fullEvent);
+    saveRun(state);
+}
+/**
+ * Generate a human-readable summary of the run
+ */
+export function generateRunSummary(runId) {
+    const state = loadRun(runId);
+    let summary = `# IRIS Workflow Run: ${runId}\n\n`;
+    summary += `**Intent:** ${state.intent}\n`;
+    summary += `**IDE:** ${state.ideId}\n`;
+    summary += `**Stage:** ${state.stage}\n`;
+    summary += `**Created:** ${state.createdAt}\n`;
+    summary += `**Updated:** ${state.updatedAt}\n\n`;
+    summary += `## Artifacts Created\n\n`;
+    if (state.artifacts.length > 0) {
+        summary += state.artifacts.map(a => `- \`${a}\``).join("\n") + "\n\n";
+    }
+    else {
+        summary += "*No artifacts yet*\n\n";
+    }
+    summary += `## Bolts\n\n`;
+    if (state.bolts.length > 0) {
+        state.bolts.forEach(bolt => {
+            summary += `### ${bolt.id} (${bolt.status})\n`;
+            if (bolt.designCompleted)
+                summary += "- ✓ Design\n";
+            if (bolt.implementationCompleted)
+                summary += "- ✓ Implementation\n";
+            if (bolt.testingCompleted)
+                summary += "- ✓ Testing\n";
+            summary += "\n";
+        });
+    }
+    else {
+        summary += "*No bolts yet*\n\n";
+    }
+    summary += `## Event Log\n\n`;
+    state.events.forEach(event => {
+        summary += `**${event.timestamp}** [${event.stage}] ${event.action}\n`;
+        if (event.message)
+            summary += `  ${event.message}\n`;
+        if (event.userGateDecision)
+            summary += `  Gate: ${event.userGateDecision}\n`;
+        summary += "\n";
+    });
+    return summary;
+}
+/**
+ * Save run summary to markdown file
+ */
+export function saveRunSummary(runId) {
+    const summary = generateRunSummary(runId);
+    const summaryPath = path.join(RUNS_DIR, `${runId}.md`);
+    fs.writeFileSync(summaryPath, summary, "utf8");
+}
+/**
+ * List all runs
+ */
+export function listRuns() {
+    if (!fs.existsSync(RUNS_DIR)) {
+        return [];
+    }
+    const files = fs.readdirSync(RUNS_DIR);
+    const stateFiles = files.filter(f => f.endsWith(".state.json"));
+    return stateFiles.map(file => {
+        const content = fs.readFileSync(path.join(RUNS_DIR, file), "utf8");
+        const snapshot = JSON.parse(content);
+        return {
+            runId: snapshot.runId,
+            stage: snapshot.stage,
+            updatedAt: snapshot.updatedAt
+        };
+    }).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}

package/dist/iris/state.js

@@ -0,0 +1,85 @@
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import { EXIT_CODES } from "../utils/exit-codes.js";
+const STATE_FILE_PATH = path.join(process.cwd(), ".iris/state.yaml");
+export const DEFAULT_STATE = {
+    version: 1,
+    phase: {
+        current: "inception",
+        requested: null,
+    },
+    active: {
+        intent_id: null,
+        unit_id: null,
+        bolt_id: null,
+    },
+    last_validation: {
+        at: null,
+        result: null,
+    },
+};
+export function loadState() {
+    try {
+        if (!fs.existsSync(STATE_FILE_PATH)) {
+            // Auto-create directory if it doesn't exist
+            const dir = path.dirname(STATE_FILE_PATH);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            saveState(DEFAULT_STATE);
+            return DEFAULT_STATE;
+        }
+        const content = fs.readFileSync(STATE_FILE_PATH, "utf8");
+        const doc = yaml.load(content);
+        const merged = { ...DEFAULT_STATE, ...doc };
+        // Migration/Fixup for legacy/bundled schema
+        if (doc.current_phase && !doc.phase) {
+            merged.phase = {
+                current: doc.current_phase.toLowerCase(), // Normalize to lowercase
+                requested: null
+            };
+        }
+        // Ensure nested objects exist
+        if (!merged.phase)
+            merged.phase = { ...DEFAULT_STATE.phase };
+        if (!merged.active)
+            merged.active = { ...DEFAULT_STATE.active };
+        if (!merged.last_validation || typeof merged.last_validation !== 'object') {
+            merged.last_validation = { ...DEFAULT_STATE.last_validation };
+        }
+        return merged;
+    }
+    catch (error) {
+        console.error("Failed to load or create .iris/state.yaml:", error);
+        process.exit(EXIT_CODES.STATE_ERROR);
+    }
+}
+export function saveState(state) {
+    try {
+        const content = yaml.dump(state);
+        fs.writeFileSync(STATE_FILE_PATH, content, "utf8");
+    }
+    catch (error) {
+        console.error("Failed to write .iris/state.yaml:", error);
+        process.exit(EXIT_CODES.STATE_ERROR);
+    }
+}
+/**
+ * Get the selected IDE from state, or null if not set
+ */
+export function getSelectedIde() {
+    const state = loadState();
+    return state.ide?.id || null;
+}
+/**
+ * Set the selected IDE in state
+ */
+export function setSelectedIde(ideId) {
+    const state = loadState();
+    state.ide = {
+        id: ideId,
+        selected_at: new Date().toISOString()
+    };
+    saveState(state);
+}

package/dist/iris/uninstaller.js

@@ -0,0 +1,166 @@
+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;
+    if (options.force) {
+        removeDoctrine = true;
+    }
+    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) {
+        const { confirmMemory } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirmMemory",
+                message: "Keep memory-bank/ folder? (default: Yes, keep)",
+                default: true
+            }
+        ]);
+        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;
+        }
+    }
+}