dlw-machine-setup 0.5.8 → 0.5.9

package/bin/installer.js

@@ -9,6 +9,10 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -3240,10 +3244,9 @@ ${page}${helpTipBottom}${choiceDescription}${import_ansi_escapes3.default.cursor
 });
 
 // src/index.ts
-var import_fs7 = require("fs");
+var import_fs8 = require("fs");
 var import_readline = require("readline");
-var import_path7 = require("path");
-var import_os2 = require("os");
+var import_path8 = require("path");
 
 // src/utils/fetch.ts
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -3286,7 +3289,7 @@ async function fetchWithRetry(url, options = {}, maxRetries = DEFAULT_MAX_RETRIE
   throw lastError || new Error("Failed after maximum retries");
 }
 
-// src/utils/data/fetch-wizard-options.ts
+// src/utils/wizard-options.ts
 async function fetchWizardOptions(token, repo) {
   try {
     const headers = {
@@ -3315,7 +3318,7 @@ async function fetchWizardOptions(token, repo) {
   }
 }
 
-// src/utils/data/discover-repo.ts
+// src/utils/discover-repo.ts
 var GITHUB_ORG = "DLW-INT-SAP-DEV";
 var DEFAULT_TOPIC = "one-shot-data";
 async function discoverRepo(token, topic = DEFAULT_TOPIC) {
@@ -3380,12 +3383,7 @@ async function tryOrgReposList(headers, topic) {
   }
 }
 
-// src/utils/data/fetch-contexts.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
-var import_child_process = require("child_process");
-
-// src/utils/auth/github-auth.ts
+// src/utils/github-auth.ts
 var import_fs = require("fs");
 var import_path = require("path");
 var import_os = require("os");
@@ -3544,56 +3542,154 @@ async function getGitHubToken() {
   return await authenticateWithGitHub();
 }
 
-// src/utils/data/fetch-contexts.ts
-var MIN_FILE_SIZE = 1024;
-async function fetchContexts(options = {}) {
-  const { domains = [], targetDir = process.cwd(), force = false, token, repo } = options;
-  if (!repo) {
-    throw new Error("Repository not specified. Discovery may have failed.");
+// src/utils/mcp-config.ts
+function buildMCPConfiguration(selectedItems, baseMcpServers, allMcpServers) {
+  const config = {};
+  for (const serverName of baseMcpServers) {
+    if (allMcpServers[serverName]) {
+      config[serverName] = allMcpServers[serverName];
+    }
   }
-  const result = {
-    successful: [],
-    failed: [],
-    skipped: [],
-    failureReasons: {}
-  };
-  if (domains.length === 0) {
-    return result;
+  for (const item of selectedItems) {
+    for (const serverName of item.mcpServers) {
+      if (allMcpServers[serverName] && !config[serverName]) {
+        config[serverName] = allMcpServers[serverName];
+      }
+    }
   }
-  await checkPrerequisites();
-  const githubToken = token ?? await getGitHubToken();
-  try {
-    const releaseUrl = `https://api.github.com/repos/${repo}/releases/latest`;
-    const headers = {
-      "Accept": "application/vnd.github+json",
-      "Authorization": `Bearer ${githubToken}`
-    };
-    const releaseResponse = await fetchWithRetry(releaseUrl, { headers });
-    if (!releaseResponse.ok) {
-      throw new Error(
-        `GitHub API error (${releaseResponse.status}): ${getReadableError(releaseResponse.status)}`
-      );
+  return config;
+}
+
+// src/utils/mod.ts
+async function loadWizardOptions(token, repo) {
+  const remote = await fetchWizardOptions(token, repo);
+  if (!remote) {
+    throw new Error("Failed to load configuration from GitHub release. Check your network and token.");
+  }
+  const { options, releaseVersion } = remote;
+  const filteredMcpServers = Object.fromEntries(
+    Object.entries(options.mcpServers).filter(([, config]) => config.active !== false)
+  );
+  return {
+    personas: options.personas.personas.filter((p) => p.active !== false),
+    agents: options.agents.filter((a) => a.active !== false),
+    baseMcpServers: options.personas.baseMcpServers,
+    mcpServers: filteredMcpServers,
+    releaseVersion
+  };
+}
+
+// src/pipeline.ts
+function defineStep(def) {
+  return def;
+}
+async function runPipeline(steps, ctx) {
+  const entries = [];
+  for (const step of steps) {
+    if (step.when && !step.when(ctx)) {
+      entries.push({ name: step.name, label: step.label, result: { status: "skipped" } });
+      continue;
     }
-    const releaseData = await releaseResponse.json();
-    const contextsDir = (0, import_path2.join)(targetDir, "_ai-context");
-    const tempDir = (0, import_path2.join)(targetDir, ".temp-download");
+    process.stdout.write(`  ${step.label}...  `);
     try {
-      if (!(0, import_fs2.existsSync)(contextsDir)) {
-        (0, import_fs2.mkdirSync)(contextsDir, { recursive: true });
+      const result = await step.execute(ctx);
+      entries.push({ name: step.name, label: step.label, result });
+      if (result.status === "success") {
+        console.log("\u2713");
+      } else {
+        console.log("\u2717");
       }
-      if ((0, import_fs2.existsSync)(tempDir)) {
-        (0, import_fs2.rmSync)(tempDir, { recursive: true, force: true });
+      if (result.detail) {
+        console.log(`    ${result.detail}`);
       }
-      (0, import_fs2.mkdirSync)(tempDir, { recursive: true });
-    } catch (error) {
-      throw new Error(`Failed to create directories: ${error instanceof Error ? error.message : "Unknown error"}`);
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      entries.push({
+        name: step.name,
+        label: step.label,
+        result: { status: "failed", detail }
+      });
+      console.log("\u2717");
+      console.log(`    ${detail}`);
     }
+  }
+  return { entries };
+}
+
+// src/steps/index.ts
+var steps_exports = {};
+__export(steps_exports, {
+  fetchContexts: () => fetch_contexts_default,
+  fetchFactory: () => fetch_factory_default,
+  updateGitignore: () => update_gitignore_default,
+  writeInstructions: () => write_instructions_default,
+  writeMcpConfig: () => write_mcp_config_default,
+  writeState: () => write_state_default
+});
+
+// src/steps/resources/fetch-contexts.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_child_process = require("child_process");
+var MIN_FILE_SIZE = 1024;
+var fetch_contexts_default = defineStep({
+  name: "fetch-contexts",
+  label: "Downloading contexts",
+  execute: async (ctx) => {
+    const uniqueDomains = [...new Set(ctx.config.personas.flatMap((p) => p.domains))];
+    const domainValues = uniqueDomains.map((d) => d.toLowerCase());
+    const downloadResult = await fetchContexts(domainValues, ctx.token, ctx.repo, ctx.config.projectPath);
+    ctx.installed.domainsInstalled = downloadResult.successful;
+    ctx.installed.domainsFailed = downloadResult.failed;
+    ctx.installed.failureReasons = downloadResult.failureReasons;
+    const domainColWidth = Math.max(...domainValues.map((d) => d.length), 8) + 2;
+    console.log("");
+    for (const domain of domainValues) {
+      const ok = downloadResult.successful.includes(domain);
+      const reason = downloadResult.failureReasons[domain];
+      const status = ok ? "\u2713" : `\u2717  ${reason ?? "Unknown error"}`;
+      console.log(`    ${domain.padEnd(domainColWidth)}${status}`);
+    }
+    if (downloadResult.failed.length > 0) {
+      return {
+        status: "failed",
+        message: `${downloadResult.successful.join(", ")} succeeded; ${downloadResult.failed.join(", ")} failed`
+      };
+    }
+    return {
+      status: "success",
+      message: downloadResult.successful.join(", ")
+    };
+  }
+});
+async function fetchContexts(domains, token, repo, targetDir) {
+  const result = { successful: [], failed: [], failureReasons: {} };
+  if (domains.length === 0) return result;
+  const tarCheck = (0, import_child_process.spawnSync)("tar", ["--version"], { stdio: "ignore" });
+  if (tarCheck.status !== 0) {
+    throw new Error("tar command not found. Please ensure tar is installed and available in your PATH.");
+  }
+  const headers = {
+    "Accept": "application/vnd.github+json",
+    "Authorization": `Bearer ${token}`
+  };
+  const releaseResponse = await fetchWithRetry(
+    `https://api.github.com/repos/${repo}/releases/latest`,
+    { headers }
+  );
+  if (!releaseResponse.ok) {
+    throw new Error(`GitHub API error (${releaseResponse.status}): ${getReadableError(releaseResponse.status)}`);
+  }
+  const releaseData = await releaseResponse.json();
+  const contextsDir = (0, import_path2.join)(targetDir, "_ai-context");
+  const tempDir = (0, import_path2.join)(targetDir, ".temp-download");
+  try {
+    if (!(0, import_fs2.existsSync)(contextsDir)) (0, import_fs2.mkdirSync)(contextsDir, { recursive: true });
+    if ((0, import_fs2.existsSync)(tempDir)) (0, import_fs2.rmSync)(tempDir, { recursive: true, force: true });
+    (0, import_fs2.mkdirSync)(tempDir, { recursive: true });
     for (const domain of domains) {
       try {
         const domainPath = (0, import_path2.join)(contextsDir, domain);
-        if ((0, import_fs2.existsSync)(domainPath) && force) {
-          (0, import_fs2.rmSync)(domainPath, { recursive: true, force: true });
-        }
         const archiveName = `${domain.toLowerCase()}.tar.gz`;
         const asset = releaseData.assets?.find((a) => a.name === archiveName);
         if (!asset) {
@@ -3603,10 +3699,9 @@ async function fetchContexts(options = {}) {
         }
         const downloadHeaders = {
           "Accept": "application/octet-stream",
-          "Authorization": `Bearer ${githubToken}`
+          "Authorization": `Bearer ${token}`
         };
-        const downloadUrl = asset.url;
-        const response = await fetchWithRetry(downloadUrl, { headers: downloadHeaders });
+        const response = await fetchWithRetry(asset.url, { headers: downloadHeaders });
         if (!response.ok) {
           throw new Error(`Download failed: ${getReadableError(response.status)}`);
         }
@@ -3618,9 +3713,7 @@ async function fetchContexts(options = {}) {
           throw new Error("File corrupted");
         }
         const listResult = (0, import_child_process.spawnSync)("tar", ["-tzf", archivePath], { encoding: "utf8" });
-        if (listResult.status !== 0) {
-          throw new Error("Failed to read archive contents");
-        }
+        if (listResult.status !== 0) throw new Error("Failed to read archive contents");
         const resolvedTempDir = (0, import_path2.resolve)(tempDir);
         for (const entry of listResult.stdout.split("\n").filter(Boolean)) {
           const entryPath = (0, import_path2.resolve)((0, import_path2.join)(tempDir, entry.replace(/\/$/, "")));
@@ -3629,47 +3722,38 @@ async function fetchContexts(options = {}) {
           }
         }
         const extractResult = (0, import_child_process.spawnSync)("tar", ["-xzf", archivePath, "-C", tempDir], { stdio: "ignore" });
-        if (extractResult.status !== 0) {
-          throw new Error("Archive extraction failed");
-        }
+        if (extractResult.status !== 0) throw new Error("Archive extraction failed");
         const extractedEntries = (0, import_fs2.readdirSync)(tempDir);
         const extractedFolder = extractedEntries.find((e) => e.toLowerCase() === domain.toLowerCase());
-        if (!extractedFolder) {
-          throw new Error("Extraction failed");
-        }
-        const extractedPath = (0, import_path2.join)(tempDir, extractedFolder);
-        copyDirectory(extractedPath, domainPath);
+        if (!extractedFolder) throw new Error("Extraction failed");
+        copyDirectory((0, import_path2.join)(tempDir, extractedFolder), domainPath);
         result.successful.push(domain);
       } catch (error) {
-        const reason = error instanceof Error ? error.message : "Unknown error";
         result.failed.push(domain);
-        result.failureReasons[domain] = reason;
-      }
-    }
-    try {
-      if ((0, import_fs2.existsSync)(tempDir)) {
-        (0, import_fs2.rmSync)(tempDir, { recursive: true, force: true });
+        result.failureReasons[domain] = error instanceof Error ? error.message : "Unknown error";
       }
-    } catch (error) {
     }
-  } catch (error) {
-    const tempDir = (0, import_path2.join)(targetDir, ".temp-download");
+  } finally {
     if ((0, import_fs2.existsSync)(tempDir)) {
       try {
         (0, import_fs2.rmSync)(tempDir, { recursive: true, force: true });
       } catch {
       }
     }
-    throw error;
   }
   return result;
 }
-async function checkPrerequisites() {
-  const check2 = (0, import_child_process.spawnSync)("tar", ["--version"], { stdio: "ignore" });
-  if (check2.status !== 0) {
-    throw new Error(
-      "tar command not found. Please ensure tar is installed and available in your PATH."
-    );
+function copyDirectory(source, target) {
+  if (!(0, import_fs2.existsSync)(target)) (0, import_fs2.mkdirSync)(target, { recursive: true });
+  const entries = (0, import_fs2.readdirSync)(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = (0, import_path2.join)(source, entry.name);
+    const targetPath = (0, import_path2.join)(target, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory(sourcePath, targetPath);
+    } else {
+      (0, import_fs2.copyFileSync)(sourcePath, targetPath);
+    }
   }
 }
 function getReadableError(status) {
@@ -3690,44 +3774,28 @@ function getReadableError(status) {
       return `Unexpected error (${status})`;
   }
 }
-function copyDirectory(source, target) {
-  let added = 0;
-  let overwritten = 0;
-  if (!(0, import_fs2.existsSync)(target)) {
-    (0, import_fs2.mkdirSync)(target, { recursive: true });
-  }
-  const entries = (0, import_fs2.readdirSync)(source, { withFileTypes: true });
-  for (const entry of entries) {
-    const sourcePath = (0, import_path2.join)(source, entry.name);
-    const targetPath = (0, import_path2.join)(target, entry.name);
-    if (entry.isDirectory()) {
-      const result = copyDirectory(sourcePath, targetPath);
-      added += result.added;
-      overwritten += result.overwritten;
-    } else {
-      if ((0, import_fs2.existsSync)(targetPath)) {
-        overwritten++;
-      } else {
-        added++;
-      }
-      (0, import_fs2.copyFileSync)(sourcePath, targetPath);
-    }
-  }
-  return { added, overwritten };
-}
 
-// src/utils/data/fetch-factory.ts
+// src/steps/resources/fetch-factory.ts
 var import_fs3 = require("fs");
 var import_path3 = require("path");
 var import_child_process2 = require("child_process");
 var MIN_FILE_SIZE2 = 1024;
 var FACTORY_ASSET_NAME = "factory.tar.gz";
-async function fetchFactory(options) {
-  const { token, repo, targetDir } = options;
-  const result = {
-    success: false,
-    filesInstalled: []
-  };
+var fetch_factory_default = defineStep({
+  name: "fetch-factory",
+  label: "Installing Factory framework",
+  when: (ctx) => ctx.config.installFactory && !!ctx.factoryRepo,
+  execute: async (ctx) => {
+    const result = await fetchFactory(ctx.token, ctx.factoryRepo, ctx.config.projectPath);
+    ctx.installed.factoryInstalled = result.success;
+    if (!result.success) {
+      return { status: "failed", detail: result.failureReason };
+    }
+    return { status: "success", message: result.filesInstalled.join(", ") };
+  }
+});
+async function fetchFactory(token, repo, targetDir) {
+  const result = { success: false, filesInstalled: [] };
   const tarCheck = (0, import_child_process2.spawnSync)("tar", ["--version"], { stdio: "ignore" });
   if (tarCheck.status !== 0) {
     result.failureReason = "tar command not found";
@@ -3737,8 +3805,10 @@ async function fetchFactory(options) {
     "Accept": "application/vnd.github+json",
     "Authorization": `Bearer ${token}`
   };
-  const releaseUrl = `https://api.github.com/repos/${repo}/releases/latest`;
-  const releaseResponse = await fetchWithRetry(releaseUrl, { headers });
+  const releaseResponse = await fetchWithRetry(
+    `https://api.github.com/repos/${repo}/releases/latest`,
+    { headers }
+  );
   if (!releaseResponse.ok) {
     result.failureReason = `GitHub API error (${releaseResponse.status})`;
     return result;
@@ -3751,15 +3821,11 @@ async function fetchFactory(options) {
   }
   const tempDir = (0, import_path3.join)(targetDir, ".temp-factory-download");
   try {
-    if ((0, import_fs3.existsSync)(tempDir)) {
-      (0, import_fs3.rmSync)(tempDir, { recursive: true, force: true });
-    }
+    if ((0, import_fs3.existsSync)(tempDir)) (0, import_fs3.rmSync)(tempDir, { recursive: true, force: true });
     (0, import_fs3.mkdirSync)(tempDir, { recursive: true });
-    const downloadHeaders = {
-      "Accept": "application/octet-stream",
-      "Authorization": `Bearer ${token}`
-    };
-    const response = await fetchWithRetry(asset.url, { headers: downloadHeaders });
+    const response = await fetchWithRetry(asset.url, {
+      headers: { "Accept": "application/octet-stream", "Authorization": `Bearer ${token}` }
+    });
     if (!response.ok) {
       result.failureReason = `Download failed (${response.status})`;
       return result;
@@ -3891,31 +3957,23 @@ function configureSettings(claudeDir) {
     if (!hasMonitor) settings.hooks.UserPromptSubmit.push(contextMonitorHook);
   }
   settings.statusLine = { type: "command", command: "node .claude/hooks/factory-statusline.cjs" };
-  if (!(0, import_fs3.existsSync)(claudeDir)) {
-    (0, import_fs3.mkdirSync)(claudeDir, { recursive: true });
-  }
+  if (!(0, import_fs3.existsSync)(claudeDir)) (0, import_fs3.mkdirSync)(claudeDir, { recursive: true });
   (0, import_fs3.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function copyAgentStubs(source, target) {
-  if (!(0, import_fs3.existsSync)(target)) {
-    (0, import_fs3.mkdirSync)(target, { recursive: true });
-  }
+  if (!(0, import_fs3.existsSync)(target)) (0, import_fs3.mkdirSync)(target, { recursive: true });
   const entries = (0, import_fs3.readdirSync)(source, { withFileTypes: true });
   for (const entry of entries) {
-    if (entry.isDirectory()) continue;
-    if (!entry.name.endsWith(".md")) continue;
+    if (entry.isDirectory() || !entry.name.endsWith(".md")) continue;
     const content = (0, import_fs3.readFileSync)((0, import_path3.join)(source, entry.name), "utf8");
     const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?\r?\n)---/);
     if (frontmatterMatch) {
       (0, import_fs3.writeFileSync)((0, import_path3.join)(target, entry.name), frontmatterMatch[0] + "\n");
-    } else {
     }
   }
 }
 function copyDirectory2(source, target) {
-  if (!(0, import_fs3.existsSync)(target)) {
-    (0, import_fs3.mkdirSync)(target, { recursive: true });
-  }
+  if (!(0, import_fs3.existsSync)(target)) (0, import_fs3.mkdirSync)(target, { recursive: true });
   const entries = (0, import_fs3.readdirSync)(source, { withFileTypes: true });
   for (const entry of entries) {
     const sourcePath = (0, import_path3.join)(source, entry.name);
@@ -3928,96 +3986,99 @@ function copyDirectory2(source, target) {
   }
 }
 
-// src/utils/setup/setup-mcp.ts
+// src/steps/setup/write-instructions.ts
 var import_fs4 = require("fs");
 var import_path4 = require("path");
-function getAgentMCPTarget(agent) {
+
+// src/steps/shared.ts
+function getFilteredMcpConfig(ctx) {
+  const successfulDomains = new Set(ctx.installed.domainsInstalled ?? []);
+  const successfulPersonas = ctx.config.personas.filter(
+    (p) => p.domains.every((d) => successfulDomains.has(d.toLowerCase()))
+  );
+  const successfulMcpServers = /* @__PURE__ */ new Set([
+    ...ctx.config.baseMcpServers,
+    ...successfulPersonas.flatMap((p) => p.mcpServers)
+  ]);
+  return Object.fromEntries(
+    Object.entries(ctx.config.mcpConfig).filter(([name]) => successfulMcpServers.has(name))
+  );
+}
+
+// src/steps/setup/write-instructions.ts
+var MARKER_START = "<!-- one-shot-installer:start -->";
+var MARKER_END = "<!-- one-shot-installer:end -->";
+var red = (text) => `\x1B[31m${text}\x1B[0m`;
+var write_instructions_default = defineStep({
+  name: "write-instructions",
+  label: "Writing instruction file",
+  when: (ctx) => (ctx.installed.domainsInstalled?.length ?? 0) > 0,
+  execute: async (ctx) => {
+    const filteredMcpConfig = getFilteredMcpConfig(ctx);
+    const domains = ctx.installed.domainsInstalled;
+    const agent = ctx.config.agent;
+    const projectPath = ctx.config.projectPath;
+    const factoryInstalled = ctx.installed.factoryInstalled ?? false;
+    const content = buildCombinedInstructions(domains, filteredMcpConfig, agent, projectPath, factoryInstalled);
+    switch (agent) {
+      case "claude-code": {
+        upsertBlock((0, import_path4.join)(projectPath, "CLAUDE.md"), content);
+        break;
+      }
+      case "github-copilot": {
+        const agentsDir = (0, import_path4.join)(projectPath, ".github", "agents");
+        if (!(0, import_fs4.existsSync)(agentsDir)) (0, import_fs4.mkdirSync)(agentsDir, { recursive: true });
+        const filePath = (0, import_path4.join)(agentsDir, "instructions.md");
+        if (!(0, import_fs4.existsSync)(filePath)) {
+          (0, import_fs4.writeFileSync)(filePath, `---
+applyTo: "**"
+---
+
+`, "utf-8");
+        }
+        upsertBlock(filePath, content);
+        break;
+      }
+      case "cursor": {
+        const cursorDir = (0, import_path4.join)(projectPath, ".cursor", "rules");
+        if (!(0, import_fs4.existsSync)(cursorDir)) (0, import_fs4.mkdirSync)(cursorDir, { recursive: true });
+        const filePath = (0, import_path4.join)(cursorDir, "instructions.mdc");
+        if (!(0, import_fs4.existsSync)(filePath)) {
+          (0, import_fs4.writeFileSync)(filePath, `---
+description: AI development instructions from One-Shot Installer
+alwaysApply: true
+---
+
+`, "utf-8");
+        }
+        upsertBlock(filePath, content);
+        break;
+      }
+    }
+    return { status: "success", message: getInstructionFilePath(agent) };
+  }
+});
+function getInstructionFilePath(agent) {
   switch (agent) {
     case "claude-code":
-      return { filePath: ".mcp.json", rootKey: "mcpServers", dir: null };
-    case "cursor":
-      return { filePath: ".cursor/mcp.json", rootKey: "mcpServers", dir: ".cursor" };
+      return "CLAUDE.md";
     case "github-copilot":
+      return ".github/agents/instructions.md";
+    case "cursor":
+      return ".cursor/rules/instructions.mdc";
     default:
-      return { filePath: ".vscode/mcp.json", rootKey: "servers", dir: ".vscode" };
-  }
-}
-async function setupMCPConfiguration(projectPath, mcpConfig, agent) {
-  const target = getAgentMCPTarget(agent);
-  const mcpJsonPath = (0, import_path4.join)(projectPath, target.filePath);
-  if (target.dir) {
-    const dir = (0, import_path4.join)(projectPath, target.dir);
-    if (!(0, import_fs4.existsSync)(dir)) {
-      (0, import_fs4.mkdirSync)(dir, { recursive: true });
-    }
-  }
-  const red2 = (text) => `\x1B[31m${text}\x1B[0m`;
-  let existingFile = {};
-  if ((0, import_fs4.existsSync)(mcpJsonPath)) {
-    try {
-      const content = (0, import_fs4.readFileSync)(mcpJsonPath, "utf-8");
-      existingFile = JSON.parse(content);
-    } catch {
-      const box = [
-        "",
-        red2("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"),
-        red2("  \u2551  \u26A0  MCP CONFIG HAS INVALID JSON                 \u2551"),
-        red2("  \u2551                                                  \u2551"),
-        red2(`  \u2551  ${target.filePath} could not be parsed.`.padEnd(52) + "\u2551"),
-        red2("  \u2551  Existing MCP servers may be lost.               \u2551"),
-        red2("  \u2551  Check the file after installation completes.    \u2551"),
-        red2("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"),
-        ""
-      ].join("\n");
-      console.log(box);
-    }
-  }
-  const addedServers = [];
-  const skippedServers = [];
-  const existingServers = existingFile[target.rootKey] ?? {};
-  const newServers = {};
-  for (const [serverName, serverConfig] of Object.entries(mcpConfig)) {
-    const { description, useWhen, active, ...mcpFields } = serverConfig;
-    newServers[serverName] = mcpFields;
-    addedServers.push(serverName);
-  }
-  const mergedServers = { ...existingServers, ...newServers };
-  const outputFile = { ...existingFile, [target.rootKey]: mergedServers };
-  (0, import_fs4.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
-  return { addedServers, skippedServers };
-}
-function buildMCPConfiguration(selectedItems, baseMcpServers, allMcpServers) {
-  const config = {};
-  for (const serverName of baseMcpServers) {
-    if (allMcpServers[serverName]) {
-      config[serverName] = allMcpServers[serverName];
-    }
-  }
-  for (const item of selectedItems) {
-    for (const serverName of item.mcpServers) {
-      if (allMcpServers[serverName] && !config[serverName]) {
-        config[serverName] = allMcpServers[serverName];
-      }
-    }
+      return "CLAUDE.md";
   }
-  return config;
 }
-
-// src/utils/setup/setup-instructions.ts
-var import_fs5 = require("fs");
-var import_path5 = require("path");
-var MARKER_START = "<!-- one-shot-installer:start -->";
-var MARKER_END = "<!-- one-shot-installer:end -->";
-var red = (text) => `\x1B[31m${text}\x1B[0m`;
 function upsertBlock(filePath, block) {
   const marked = `${MARKER_START}
 ${block}
 ${MARKER_END}`;
-  if (!(0, import_fs5.existsSync)(filePath)) {
-    (0, import_fs5.writeFileSync)(filePath, marked, "utf-8");
+  if (!(0, import_fs4.existsSync)(filePath)) {
+    (0, import_fs4.writeFileSync)(filePath, marked, "utf-8");
     return;
   }
-  const existing = (0, import_fs5.readFileSync)(filePath, "utf-8");
+  const existing = (0, import_fs4.readFileSync)(filePath, "utf-8");
   const start = existing.indexOf(MARKER_START);
   const end = existing.indexOf(MARKER_END);
   const hasStart = start !== -1;
@@ -4042,23 +4103,23 @@ ${MARKER_END}`;
   }
   if (hasStart && hasEnd) {
     const updated = existing.slice(0, start) + marked + existing.slice(end + MARKER_END.length);
-    (0, import_fs5.writeFileSync)(filePath, updated, "utf-8");
+    (0, import_fs4.writeFileSync)(filePath, updated, "utf-8");
   } else {
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    (0, import_fs5.writeFileSync)(filePath, existing + separator + marked, "utf-8");
+    (0, import_fs4.writeFileSync)(filePath, existing + separator + marked, "utf-8");
   }
 }
 function collectMdFiles(dir) {
-  if (!(0, import_fs5.existsSync)(dir)) return [];
-  const entries = (0, import_fs5.readdirSync)(dir, { recursive: true });
+  if (!(0, import_fs4.existsSync)(dir)) return [];
+  const entries = (0, import_fs4.readdirSync)(dir, { recursive: true });
   return entries.filter((entry) => {
-    const fullPath = (0, import_path5.join)(dir, entry);
-    return entry.endsWith(".md") && (0, import_fs5.statSync)(fullPath).isFile();
+    const fullPath = (0, import_path4.join)(dir, entry);
+    return entry.endsWith(".md") && (0, import_fs4.statSync)(fullPath).isFile();
   }).map((entry) => entry.replace(/\\/g, "/")).sort();
 }
 function extractFirstHeading(filePath) {
   try {
-    const content = (0, import_fs5.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs4.readFileSync)(filePath, "utf-8");
     const withoutFrontmatter = content.replace(/^---[\s\S]*?---\s*/, "");
     const match = withoutFrontmatter.match(/^#\s+(.+)/m);
     if (match) {
@@ -4069,47 +4130,23 @@ function extractFirstHeading(filePath) {
   const basename = filePath.split(/[/\\]/).pop() ?? "";
   return basename.replace(/\.md$/i, "").replace(/[-_]+/g, " ");
 }
-function buildMCPSection(mcpConfig) {
-  const entries = Object.entries(mcpConfig);
-  if (entries.length === 0) return "";
-  const lines2 = [
-    `## MCP Servers`,
-    ``,
-    `The following MCP servers are available. Use them proactively when relevant:`,
-    ``
-  ];
-  for (const [name, config] of entries) {
-    const description = config.description;
-    const useWhen = config.useWhen;
-    if (!description) continue;
-    lines2.push(`### ${name}`);
-    lines2.push(description);
-    if (useWhen) {
-      lines2.push(`**Use when**: ${useWhen}`);
-    }
-    lines2.push(``);
+function formatPathRef(contextPath, description, agent) {
+  if (agent === "github-copilot") {
+    return `- [${contextPath}](../../${contextPath}) \u2014 ${description}`;
   }
-  return lines2.join("\n");
+  return `- \`${contextPath}\` \u2014 ${description}`;
 }
 function resolveDomainFolder(domain, contextsDir) {
-  if ((0, import_fs5.existsSync)(contextsDir)) {
+  if ((0, import_fs4.existsSync)(contextsDir)) {
     try {
-      const entries = (0, import_fs5.readdirSync)(contextsDir);
+      const entries = (0, import_fs4.readdirSync)(contextsDir);
       const match = entries.find((e) => e.toLowerCase() === domain.toLowerCase());
-      if (match) {
-        return { folderName: match, folderPath: (0, import_path5.join)(contextsDir, match) };
-      }
+      if (match) return { folderName: match, folderPath: (0, import_path4.join)(contextsDir, match) };
     } catch {
     }
   }
   const fallback = domain.toUpperCase();
-  return { folderName: fallback, folderPath: (0, import_path5.join)(contextsDir, fallback) };
-}
-function formatPathRef(contextPath, description, agent) {
-  if (agent === "github-copilot") {
-    return `- [${contextPath}](../../${contextPath}) \u2014 ${description}`;
-  }
-  return `- \`${contextPath}\` \u2014 ${description}`;
+  return { folderName: fallback, folderPath: (0, import_path4.join)(contextsDir, fallback) };
 }
 function buildContextRefsSection(domains, agent, contextsDir) {
   const lines2 = [
@@ -4121,34 +4158,34 @@ function buildContextRefsSection(domains, agent, contextsDir) {
   let hasAnyFiles = false;
   for (const domain of domains) {
     const { folderName, folderPath: domainPath } = resolveDomainFolder(domain, contextsDir);
-    if (!(0, import_fs5.existsSync)(domainPath)) continue;
+    if (!(0, import_fs4.existsSync)(domainPath)) continue;
     const domainFiles = [];
-    const ctxInstructions = (0, import_path5.join)(domainPath, "context-instructions.md");
-    if ((0, import_fs5.existsSync)(ctxInstructions)) {
+    const ctxInstructions = (0, import_path4.join)(domainPath, "context-instructions.md");
+    if ((0, import_fs4.existsSync)(ctxInstructions)) {
       const desc = extractFirstHeading(ctxInstructions);
       domainFiles.push(formatPathRef(`_ai-context/${folderName}/context-instructions.md`, desc, agent));
     }
-    const instructionsMd = (0, import_path5.join)(domainPath, "core", "instructions.md");
-    if ((0, import_fs5.existsSync)(instructionsMd)) {
+    const instructionsMd = (0, import_path4.join)(domainPath, "core", "instructions.md");
+    if ((0, import_fs4.existsSync)(instructionsMd)) {
       const desc = extractFirstHeading(instructionsMd);
       domainFiles.push(formatPathRef(`_ai-context/${folderName}/core/instructions.md`, `${desc} (start here)`, agent));
     }
-    const coreDir = (0, import_path5.join)(domainPath, "core");
-    if ((0, import_fs5.existsSync)(coreDir)) {
+    const coreDir = (0, import_path4.join)(domainPath, "core");
+    if ((0, import_fs4.existsSync)(coreDir)) {
       const coreFiles = collectMdFiles(coreDir).filter((f) => f !== "instructions.md" && !f.startsWith("instructions/"));
       for (const file of coreFiles) {
-        const desc = extractFirstHeading((0, import_path5.join)(coreDir, file));
+        const desc = extractFirstHeading((0, import_path4.join)(coreDir, file));
         domainFiles.push(formatPathRef(`_ai-context/${folderName}/core/${file}`, desc, agent));
       }
     }
-    const refDir = (0, import_path5.join)(domainPath, "reference");
-    if ((0, import_fs5.existsSync)(refDir)) {
+    const refDir = (0, import_path4.join)(domainPath, "reference");
+    if ((0, import_fs4.existsSync)(refDir)) {
       const refFiles = collectMdFiles(refDir);
       if (refFiles.length > 0) {
         domainFiles.push(``);
         domainFiles.push(`**Reference & cheat sheets:**`);
         for (const file of refFiles) {
-          const desc = extractFirstHeading((0, import_path5.join)(refDir, file));
+          const desc = extractFirstHeading((0, import_path4.join)(refDir, file));
           domainFiles.push(formatPathRef(`_ai-context/${folderName}/reference/${file}`, desc, agent));
         }
       }
@@ -4165,6 +4202,21 @@ function buildContextRefsSection(domains, agent, contextsDir) {
   }
   return lines2.join("\n");
 }
+function buildMCPSection(mcpConfig) {
+  const entries = Object.entries(mcpConfig);
+  if (entries.length === 0) return "";
+  const lines2 = [`## MCP Servers`, ``, `The following MCP servers are available. Use them proactively when relevant:`, ``];
+  for (const [name, config] of entries) {
+    const description = config.description;
+    const useWhen = config.useWhen;
+    if (!description) continue;
+    lines2.push(`### ${name}`);
+    lines2.push(description);
+    if (useWhen) lines2.push(`**Use when**: ${useWhen}`);
+    lines2.push(``);
+  }
+  return lines2.join("\n");
+}
 function buildFactorySection() {
   return [
     `## Factory Dev Workflow`,
@@ -4183,68 +4235,81 @@ function buildFactorySection() {
     ``
   ].join("\n");
 }
-function buildCombinedInstructions(domains, mcpConfig, agent = "", projectPath = process.cwd(), factoryInstalled = false) {
-  const contextsDir = (0, import_path5.join)(projectPath, "_ai-context");
-  const lines2 = [
-    `# AI Development Instructions`,
-    ``,
-    `> Generated by One-Shot Installer`,
-    ``
-  ];
+function buildCombinedInstructions(domains, mcpConfig, agent, projectPath, factoryInstalled) {
+  const contextsDir = (0, import_path4.join)(projectPath, "_ai-context");
+  const lines2 = [`# AI Development Instructions`, ``, `> Generated by One-Shot Installer`, ``];
   lines2.push(buildContextRefsSection(domains, agent, contextsDir));
-  if (mcpConfig && Object.keys(mcpConfig).length > 0) {
-    lines2.push(buildMCPSection(mcpConfig));
-  }
-  if (factoryInstalled) {
-    lines2.push(buildFactorySection());
-  }
+  if (Object.keys(mcpConfig).length > 0) lines2.push(buildMCPSection(mcpConfig));
+  if (factoryInstalled) lines2.push(buildFactorySection());
   return lines2.join("\n");
 }
-async function setupInstructions(config) {
-  const { domains, agent, mcpConfig, projectPath = process.cwd(), factoryInstalled = false } = config;
-  switch (agent) {
-    case "claude-code": {
-      const content = buildCombinedInstructions(domains, mcpConfig, agent, projectPath, factoryInstalled);
-      upsertBlock((0, import_path5.join)(projectPath, "CLAUDE.md"), content);
-      break;
-    }
-    case "github-copilot": {
-      const agentsDir = (0, import_path5.join)(projectPath, ".github", "agents");
-      if (!(0, import_fs5.existsSync)(agentsDir)) (0, import_fs5.mkdirSync)(agentsDir, { recursive: true });
-      const filePath = (0, import_path5.join)(agentsDir, "instructions.md");
-      if (!(0, import_fs5.existsSync)(filePath)) {
-        (0, import_fs5.writeFileSync)(filePath, `---
-applyTo: "**"
----
 
-`, "utf-8");
-      }
-      const body = buildCombinedInstructions(domains, mcpConfig, agent, projectPath, factoryInstalled);
-      upsertBlock(filePath, body);
-      break;
+// src/steps/setup/write-mcp-config.ts
+var import_fs5 = require("fs");
+var import_path5 = require("path");
+var red2 = (text) => `\x1B[31m${text}\x1B[0m`;
+var write_mcp_config_default = defineStep({
+  name: "write-mcp-config",
+  label: "Writing MCP configuration",
+  when: (ctx) => (ctx.installed.domainsInstalled?.length ?? 0) > 0,
+  execute: async (ctx) => {
+    const filteredMcpConfig = getFilteredMcpConfig(ctx);
+    const target = getAgentMCPTarget(ctx.config.agent);
+    const mcpJsonPath = (0, import_path5.join)(ctx.config.projectPath, target.filePath);
+    if (target.dir) {
+      const dir = (0, import_path5.join)(ctx.config.projectPath, target.dir);
+      if (!(0, import_fs5.existsSync)(dir)) (0, import_fs5.mkdirSync)(dir, { recursive: true });
     }
-    case "cursor": {
-      const cursorDir = (0, import_path5.join)(projectPath, ".cursor", "rules");
-      if (!(0, import_fs5.existsSync)(cursorDir)) (0, import_fs5.mkdirSync)(cursorDir, { recursive: true });
-      const filePath = (0, import_path5.join)(cursorDir, "instructions.mdc");
-      if (!(0, import_fs5.existsSync)(filePath)) {
-        (0, import_fs5.writeFileSync)(filePath, `---
-description: AI development instructions from One-Shot Installer
-alwaysApply: true
----
-
-`, "utf-8");
+    let existingFile = {};
+    if ((0, import_fs5.existsSync)(mcpJsonPath)) {
+      try {
+        existingFile = JSON.parse((0, import_fs5.readFileSync)(mcpJsonPath, "utf-8"));
+      } catch {
+        const box = [
+          "",
+          red2("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"),
+          red2("  \u2551  \u26A0  MCP CONFIG HAS INVALID JSON                 \u2551"),
+          red2("  \u2551                                                  \u2551"),
+          red2(`  \u2551  ${target.filePath} could not be parsed.`.padEnd(52) + "\u2551"),
+          red2("  \u2551  Existing MCP servers may be lost.               \u2551"),
+          red2("  \u2551  Check the file after installation completes.    \u2551"),
+          red2("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"),
+          ""
+        ].join("\n");
+        console.log(box);
       }
-      const body = buildCombinedInstructions(domains, mcpConfig, agent, projectPath, factoryInstalled);
-      upsertBlock(filePath, body);
-      break;
     }
+    const addedServers = [];
+    const existingServers = existingFile[target.rootKey] ?? {};
+    const newServers = {};
+    for (const [serverName, serverConfig] of Object.entries(filteredMcpConfig)) {
+      const { description, useWhen, active, ...mcpFields } = serverConfig;
+      newServers[serverName] = mcpFields;
+      addedServers.push(serverName);
+    }
+    const mergedServers = { ...existingServers, ...newServers };
+    const outputFile = { ...existingFile, [target.rootKey]: mergedServers };
+    (0, import_fs5.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
+    ctx.installed.mcpServersAdded = addedServers;
+    return {
+      status: "success",
+      message: addedServers.length > 0 ? addedServers.join(", ") : void 0
+    };
+  }
+});
+function getAgentMCPTarget(agent) {
+  switch (agent) {
+    case "claude-code":
+      return { filePath: ".mcp.json", rootKey: "mcpServers", dir: null };
+    case "cursor":
+      return { filePath: ".cursor/mcp.json", rootKey: "mcpServers", dir: ".cursor" };
+    case "github-copilot":
     default:
-      break;
+      return { filePath: ".vscode/mcp.json", rootKey: "servers", dir: ".vscode" };
   }
 }
 
-// src/utils/setup/setup-gitignore.ts
+// src/steps/setup/update-gitignore.ts
 var import_fs6 = require("fs");
 var import_path6 = require("path");
 var MARKER_START2 = "# one-shot-installer:start";
@@ -4276,47 +4341,93 @@ var GITIGNORE_ENTRIES = [
   "factory/summaries/",
   "factory/ai-context/"
 ];
-function setupGitignore(projectPath) {
-  const gitignorePath = (0, import_path6.join)(projectPath, ".gitignore");
-  const block = [MARKER_START2, ...GITIGNORE_ENTRIES, MARKER_END2].join("\n");
-  if (!(0, import_fs6.existsSync)(gitignorePath)) {
-    (0, import_fs6.writeFileSync)(gitignorePath, block + "\n", "utf-8");
-    return;
+var update_gitignore_default = defineStep({
+  name: "update-gitignore",
+  label: "Updating .gitignore",
+  execute: async (ctx) => {
+    const gitignorePath = (0, import_path6.join)(ctx.config.projectPath, ".gitignore");
+    const block = [MARKER_START2, ...GITIGNORE_ENTRIES, MARKER_END2].join("\n");
+    if (!(0, import_fs6.existsSync)(gitignorePath)) {
+      (0, import_fs6.writeFileSync)(gitignorePath, block + "\n", "utf-8");
+      return { status: "success" };
+    }
+    const existing = (0, import_fs6.readFileSync)(gitignorePath, "utf-8");
+    const start = existing.indexOf(MARKER_START2);
+    const end = existing.indexOf(MARKER_END2);
+    if (start !== -1 && end !== -1 && end > start) {
+      const updated = existing.slice(0, start) + block + existing.slice(end + MARKER_END2.length);
+      (0, import_fs6.writeFileSync)(gitignorePath, updated, "utf-8");
+    } else {
+      const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+      (0, import_fs6.writeFileSync)(gitignorePath, existing + separator + block + "\n", "utf-8");
+    }
+    return { status: "success" };
   }
-  const existing = (0, import_fs6.readFileSync)(gitignorePath, "utf-8");
-  const start = existing.indexOf(MARKER_START2);
-  const end = existing.indexOf(MARKER_END2);
-  if (start !== -1 && end !== -1 && end > start) {
-    const updated = existing.slice(0, start) + block + existing.slice(end + MARKER_END2.length);
-    (0, import_fs6.writeFileSync)(gitignorePath, updated, "utf-8");
-  } else {
-    const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    (0, import_fs6.writeFileSync)(gitignorePath, existing + separator + block + "\n", "utf-8");
+});
+
+// src/steps/setup/write-state.ts
+var import_fs7 = require("fs");
+var import_path7 = require("path");
+var import_os2 = require("os");
+var INSTALLER_VERSION = "0.5.9";
+var write_state_default = defineStep({
+  name: "write-state",
+  label: "Saving installation state",
+  execute: async (ctx) => {
+    const statePath = (0, import_path7.join)(ctx.config.projectPath, ".one-shot-state.json");
+    const mcpServersAdded = ctx.installed.mcpServersAdded ?? [];
+    const filteredMcpConfig = Object.fromEntries(
+      Object.entries(ctx.config.mcpConfig).filter(([name]) => mcpServersAdded.includes(name))
+    );
+    const state = {
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      installerVersion: INSTALLER_VERSION,
+      releaseVersion: ctx.config.releaseVersion,
+      projectPath: ctx.config.projectPath,
+      agent: ctx.config.agent,
+      personas: ctx.config.personas.map((p) => p.id),
+      domains: ctx.installed.domainsInstalled ?? [],
+      mcpServers: mcpServersAdded,
+      mcpConfigs: filteredMcpConfig,
+      factoryInstalled: ctx.installed.factoryInstalled ?? false,
+      files: {
+        instructions: getInstructionFilePath2(ctx.config.agent),
+        mcpConfig: getMCPConfigPath(ctx.config.agent),
+        contexts: "_ai-context/",
+        factory: ctx.installed.factoryInstalled ? "factory/" : null,
+        globalConfig: (0, import_path7.join)((0, import_os2.homedir)(), ".one-shot-installer")
+      }
+    };
+    (0, import_fs7.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
+    return { status: "success" };
+  }
+});
+function getInstructionFilePath2(agent) {
+  switch (agent) {
+    case "claude-code":
+      return "CLAUDE.md";
+    case "github-copilot":
+      return ".github/agents/instructions.md";
+    case "cursor":
+      return ".cursor/rules/instructions.mdc";
+    default:
+      return "CLAUDE.md";
   }
 }
-
-// src/utils/mod.ts
-async function loadWizardOptions(token, repo) {
-  const remote = await fetchWizardOptions(token, repo);
-  if (!remote) {
-    throw new Error("Failed to load configuration from GitHub release. Check your network and token.");
+function getMCPConfigPath(agent) {
+  switch (agent) {
+    case "claude-code":
+      return ".mcp.json";
+    case "cursor":
+      return ".cursor/mcp.json";
+    case "github-copilot":
+    default:
+      return ".vscode/mcp.json";
   }
-  const { options, releaseVersion } = remote;
-  const filteredMcpServers = Object.fromEntries(
-    Object.entries(options.mcpServers).filter(([, config]) => config.active !== false)
-  );
-  return {
-    personas: options.personas.personas.filter((p) => p.active !== false),
-    agents: options.agents.filter((a) => a.active !== false),
-    baseMcpServers: options.personas.baseMcpServers,
-    mcpServers: filteredMcpServers,
-    releaseVersion
-  };
 }
 
 // src/index.ts
-var INSTALLER_VERSION = "0.5.7";
-function getInstructionFilePath(agent) {
+function getInstructionFilePath3(agent) {
   switch (agent) {
     case "claude-code":
       return "CLAUDE.md";
@@ -4328,7 +4439,7 @@ function getInstructionFilePath(agent) {
       return "CLAUDE.md";
   }
 }
-function getMCPConfigPath(agent) {
+function getMCPConfigPath2(agent) {
   switch (agent) {
     case "claude-code":
       return ".mcp.json";
@@ -4348,19 +4459,19 @@ var dim = (text) => `\x1B[2m${text}\x1B[0m`;
 var yellow = (text) => `\x1B[33m${text}\x1B[0m`;
 var green = (text) => `\x1B[32m${text}\x1B[0m`;
 function detectMarkerFileMode(filePath, markerStart) {
-  if (!(0, import_fs7.existsSync)(filePath)) return green("create");
-  const content = (0, import_fs7.readFileSync)(filePath, "utf-8");
+  if (!(0, import_fs8.existsSync)(filePath)) return green("create");
+  const content = (0, import_fs8.readFileSync)(filePath, "utf-8");
   if (content.includes(markerStart)) return yellow("update");
   return yellow("append");
 }
 function detectMCPFileMode(filePath) {
-  if (!(0, import_fs7.existsSync)(filePath)) return green("create");
+  if (!(0, import_fs8.existsSync)(filePath)) return green("create");
   return yellow("merge");
 }
 function detectContextMode(projectPath, domain) {
-  const contextDir = (0, import_path7.join)(projectPath, "_ai-context", domain.toUpperCase());
-  const contextDirLower = (0, import_path7.join)(projectPath, "_ai-context", domain);
-  if ((0, import_fs7.existsSync)(contextDir) || (0, import_fs7.existsSync)(contextDirLower)) return yellow("overwrite");
+  const contextDir = (0, import_path8.join)(projectPath, "_ai-context", domain.toUpperCase());
+  const contextDirLower = (0, import_path8.join)(projectPath, "_ai-context", domain);
+  if ((0, import_fs8.existsSync)(contextDir) || (0, import_fs8.existsSync)(contextDirLower)) return yellow("overwrite");
   return green("create");
 }
 function waitForEnter() {
@@ -4398,8 +4509,17 @@ async function main() {
       await waitForEnter();
       return;
     }
-    const result = await execute(config, token, repo, factoryRepo);
-    printSummary(result);
+    const ctx = {
+      config,
+      token,
+      repo,
+      factoryRepo,
+      installed: {}
+    };
+    const stepList = Object.values(steps_exports);
+    console.log("");
+    const result = await runPipeline(stepList, ctx);
+    printSummary(result, config);
     return;
   } catch (error) {
     console.error("\n[ERROR]", error instanceof Error ? error.message : String(error));
@@ -4438,13 +4558,13 @@ async function collectInputs(options, releaseVersion, factoryAvailable = false)
   }
   const projectInput = await esm_default4({
     message: "Project directory:",
-    default: (0, import_path7.resolve)(process.cwd())
+    default: (0, import_path8.resolve)(process.cwd())
   });
   return {
     personas: selectedPersonas,
     agent,
     azureDevOpsOrg,
-    projectPath: (0, import_path7.resolve)(projectInput),
+    projectPath: (0, import_path8.resolve)(projectInput),
     baseMcpServers: options.baseMcpServers,
     mcpConfig,
     releaseVersion,
@@ -4454,12 +4574,12 @@ async function collectInputs(options, releaseVersion, factoryAvailable = false)
 async function previewAndConfirm(config, options) {
   const personaNames = config.personas.map((p) => p.name.replace(/ Developer$/, "")).join(", ");
   const agentDisplay = options.agents.find((a) => a.value === config.agent)?.name ?? config.agent;
-  const instructionFile = getInstructionFilePath(config.agent);
-  const mcpConfigFile = getMCPConfigPath(config.agent);
+  const instructionFile = getInstructionFilePath3(config.agent);
+  const mcpConfigFile = getMCPConfigPath2(config.agent);
   const serverEntries = Object.entries(config.mcpConfig);
-  const instructionFilePath = (0, import_path7.join)(config.projectPath, instructionFile);
-  const mcpConfigFilePath = (0, import_path7.join)(config.projectPath, mcpConfigFile);
-  const gitignorePath = (0, import_path7.join)(config.projectPath, ".gitignore");
+  const instructionFilePath = (0, import_path8.join)(config.projectPath, instructionFile);
+  const mcpConfigFilePath = (0, import_path8.join)(config.projectPath, mcpConfigFile);
+  const gitignorePath = (0, import_path8.join)(config.projectPath, ".gitignore");
   const instructionMode = detectMarkerFileMode(instructionFilePath, "<!-- one-shot-installer:start -->");
   const mcpMode = detectMCPFileMode(mcpConfigFilePath);
   const gitignoreMode = detectMarkerFileMode(gitignorePath, "# one-shot-installer:start");
@@ -4485,7 +4605,7 @@ async function previewAndConfirm(config, options) {
   console.log(`    ${mcpConfigFile.padEnd(domainColWidth + 14)}${mcpMode}`);
   console.log(`    ${".gitignore".padEnd(domainColWidth + 14)}${gitignoreMode}`);
   if (config.installFactory) {
-    const factoryExists = (0, import_fs7.existsSync)((0, import_path7.join)(config.projectPath, "factory"));
+    const factoryExists = (0, import_fs8.existsSync)((0, import_path8.join)(config.projectPath, "factory"));
     const factoryMode = factoryExists ? yellow("overwrite") : green("create");
     console.log(`    ${"factory/".padEnd(domainColWidth + 14)}${factoryMode}`);
   }
@@ -4501,192 +4621,26 @@ async function previewAndConfirm(config, options) {
   console.log("\n" + "\u2500".repeat(48));
   return esm_default3({ message: "Proceed?", default: true });
 }
-async function execute(config, token, repo, factoryRepo = null) {
-  const instructionFilePath = getInstructionFilePath(config.agent);
-  const mcpConfigPath = getMCPConfigPath(config.agent);
-  const result = {
-    success: false,
-    domainsInstalled: [],
-    domainsFailed: [],
-    failureReasons: {},
-    instructionsCreated: false,
-    instructionFilePath,
-    mcpConfigured: false,
-    mcpConfigPath,
-    mcpServersAdded: [],
-    gitignoreUpdated: false,
-    factoryInstalled: false
-  };
-  console.log("");
-  const uniqueDomains = [...new Set(config.personas.flatMap((p) => p.domains))];
-  const domainValues = uniqueDomains.map((d) => d.toLowerCase());
-  console.log(`  Downloading contexts...`);
-  try {
-    const downloadResult = await fetchContexts({ domains: domainValues, token, repo, targetDir: config.projectPath });
-    result.domainsInstalled = downloadResult.successful;
-    result.domainsFailed = downloadResult.failed;
-    result.failureReasons = downloadResult.failureReasons;
-  } catch (error) {
-    result.domainsFailed = domainValues;
-    const reason = error instanceof Error ? error.message : String(error);
-    for (const d of domainValues) result.failureReasons[d] = reason;
-  }
-  const domainColWidth = Math.max(...domainValues.map((d) => d.length), 8) + 2;
-  for (const domain of domainValues) {
-    const ok = result.domainsInstalled.includes(domain);
-    const reason = result.failureReasons[domain];
-    const status = ok ? "\u2713" : `\u2717  ${reason ?? "Unknown error"}`;
-    console.log(`    ${domain.padEnd(domainColWidth)}${status}`);
-  }
-  console.log("");
-  if (config.installFactory && factoryRepo) {
-    process.stdout.write(`  Installing Factory framework...    `);
-    try {
-      const factoryResult = await fetchFactory({ token, repo: factoryRepo, targetDir: config.projectPath });
-      if (factoryResult.success) {
-        result.factoryInstalled = true;
-        console.log("\u2713");
-      } else {
-        console.log("\u2717");
-        console.log(`    ${factoryResult.failureReason}`);
-      }
-    } catch (error) {
-      console.log("\u2717");
-      console.log(`    ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  if (result.domainsInstalled.length === 0) {
-    result.success = false;
-    return result;
-  }
-  const successfulDomains = new Set(result.domainsInstalled);
-  const successfulPersonas = config.personas.filter(
-    (p) => p.domains.every((d) => successfulDomains.has(d.toLowerCase()))
-  );
-  const successfulMcpServers = /* @__PURE__ */ new Set([
-    ...config.baseMcpServers,
-    ...successfulPersonas.flatMap((p) => p.mcpServers)
-  ]);
-  const filteredMcpConfig = Object.fromEntries(
-    Object.entries(config.mcpConfig).filter(([name]) => successfulMcpServers.has(name))
-  );
-  const statePath = (0, import_path7.join)(config.projectPath, ".one-shot-state.json");
-  const allDomains = result.domainsInstalled;
-  process.stdout.write(`  Writing ${instructionFilePath}...    `);
-  try {
-    await setupInstructions({
-      domains: allDomains,
-      agent: config.agent,
-      mcpConfig: filteredMcpConfig,
-      projectPath: config.projectPath,
-      factoryInstalled: result.factoryInstalled
-    });
-    result.instructionsCreated = true;
-    console.log("\u2713");
-  } catch (error) {
-    console.log("\u2717");
-    console.log(`    Error: ${error instanceof Error ? error.message : String(error)}`);
-    console.log(`    Path:  ${instructionFilePath}`);
-  }
-  process.stdout.write(`  Writing ${mcpConfigPath}...    `);
-  try {
-    const mcpResult = await setupMCPConfiguration(
-      config.projectPath,
-      filteredMcpConfig,
-      config.agent
-    );
-    result.mcpConfigured = true;
-    result.mcpServersAdded = mcpResult.addedServers;
-    console.log("\u2713");
-  } catch (error) {
-    console.log("\u2717");
-    console.log(`    Error: ${error instanceof Error ? error.message : String(error)}`);
-    console.log(`    Path:  ${mcpConfigPath}`);
-  }
-  process.stdout.write(`  Updating .gitignore...    `);
-  try {
-    setupGitignore(config.projectPath);
-    result.gitignoreUpdated = true;
-    console.log("\u2713");
-  } catch (error) {
-    console.log("\u2717");
-    console.log(`    Error: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  result.success = result.domainsFailed.length === 0 && result.instructionsCreated && result.mcpConfigured;
-  const allPersonas = config.personas.map((p) => p.id);
-  const state = {
-    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    installerVersion: INSTALLER_VERSION,
-    releaseVersion: config.releaseVersion,
-    projectPath: config.projectPath,
-    agent: config.agent,
-    personas: allPersonas,
-    domains: allDomains,
-    mcpServers: Object.keys(filteredMcpConfig),
-    mcpConfigs: filteredMcpConfig,
-    factoryInstalled: result.factoryInstalled,
-    files: {
-      instructions: instructionFilePath,
-      mcpConfig: mcpConfigPath,
-      contexts: "_ai-context/",
-      factory: result.factoryInstalled ? "factory/" : null,
-      globalConfig: (0, import_path7.join)((0, import_os2.homedir)(), ".one-shot-installer")
-    }
-  };
-  try {
-    (0, import_fs7.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
-  } catch {
-  }
-  return result;
-}
-function printSummary(result) {
-  const hasErrors = !result.success;
+function printSummary(result, config) {
+  const failed = result.entries.filter((e) => e.result.status === "failed");
+  const succeeded = result.entries.filter((e) => e.result.status === "success");
+  const hasErrors = failed.length > 0;
   console.log("\u2500".repeat(48));
   console.log(hasErrors ? "  Done (with errors).\n" : "  Done.\n");
-  if (result.domainsInstalled.length > 0) {
-    console.log(`  _ai-context/   ${result.domainsInstalled.join(", ")}`);
-  }
-  if (result.instructionsCreated) {
-    console.log(`  ${result.instructionFilePath}   written`);
-  }
-  if (result.mcpConfigured) {
-    const serverList = result.mcpServersAdded.length > 0 ? `  (${result.mcpServersAdded.join(", ")})` : "";
-    console.log(`  ${result.mcpConfigPath}   written${serverList}`);
-  }
-  if (result.factoryInstalled) {
-    console.log(`  Factory      installed (.claude/ + factory/)`);
-  }
-  if (result.gitignoreUpdated) {
-    console.log(`  .gitignore   updated`);
+  for (const entry of succeeded) {
+    const msg = entry.result.message ? `  ${entry.result.message}` : "";
+    console.log(`  ${entry.label}${msg}`);
   }
   if (hasErrors) {
     console.log("\n  What went wrong:");
-    if (result.domainsFailed.length > 0) {
-      console.log("");
-      console.log("    Context downloads failed:");
-      for (const domain of result.domainsFailed) {
-        const reason = result.failureReasons[domain];
-        console.log(`      ${domain}  \u2014 ${reason ?? "Unknown error"}`);
-      }
-    }
-    if (!result.instructionsCreated) {
-      console.log("");
-      console.log(`    Instruction file not written: ${result.instructionFilePath}`);
-    }
-    if (!result.mcpConfigured) {
-      console.log("");
-      console.log(`    MCP config not written: ${result.mcpConfigPath}`);
+    for (const entry of failed) {
+      console.log(`    ${entry.label}: ${entry.result.detail ?? "Unknown error"}`);
     }
     console.log("\n  Troubleshooting:");
-    if (result.domainsFailed.length > 0) {
-      console.log("    - Re-authenticate: delete ~/.one-shot-installer/github-token.json");
-      console.log("    - Check network connectivity");
-      console.log("    - Confirm your GitHub account has access to the repository");
-    }
-    if (!result.instructionsCreated || !result.mcpConfigured) {
-      console.log("    - Check write permissions for the project directory");
-      console.log(`    - Project directory: ${result.instructionFilePath.includes("/") ? "check parent folders exist" : "current directory"}`);
-    }
+    console.log("    - Re-authenticate: delete ~/.one-shot-installer/github-token.json");
+    console.log("    - Check network connectivity");
+    console.log("    - Confirm your GitHub account has access to the repository");
+    console.log("    - Check write permissions for the project directory");
   }
   console.log("\n" + "\u2500".repeat(48) + "\n");
 }