dlw-machine-setup 0.4.11 → 0.5.7

package/README.md

@@ -1,108 +1,51 @@
-# @DLW-INT-SAP-DEV/one-shot-installer
+# dlw-machine-setup
 
-NPM wrapper for the One-Shot Setup installer. This package downloads and executes the appropriate binary from GitHub Releases based on your platform.
+NPM wrapper for the One-Shot Setup installer. This package runs a CLI wizard that configures AI-enhanced development with SAP-specific context files and MCP servers.
 
-## Installation
-
-### Using npx (Recommended)
-
-No installation required - run directly:
+## Usage
 
 ```bash
-npx @DLW-INT-SAP-DEV/one-shot-installer
+npx dlw-machine-setup@latest
 ```
 
-### Global Installation
-
-```bash
-npm install -g @DLW-INT-SAP-DEV/one-shot-installer
-one-shot-installer
-```
+Requires Node.js >=18. No additional runtime or binaries needed.
 
-### Local Installation
+## What It Does
 
-```bash
-npm install @DLW-INT-SAP-DEV/one-shot-installer
-npx one-shot-installer
-```
+The wizard guides you through:
 
-## Authentication
+1. **GitHub authentication** — one-time OAuth Device Flow (token cached for future runs)
+2. **Persona selection** — choose your SAP development domains (SAPUI5, CAP, ABAP, BTP, SAP DM, Forms)
+3. **AI tool selection** — Claude Code, GitHub Copilot, or Cursor
+4. **Azure DevOps org** — optional, for Azure DevOps MCP integration
+5. **Project directory** — where to install (defaults to current directory)
 
-This package downloads binaries from a private GitHub repository. Authentication is handled automatically:
+After confirming a preview, it downloads context archives from GitHub Releases and writes the appropriate config files for your AI tool.
 
-1. **First run**: The binary will prompt you to authenticate via GitHub OAuth Device Flow
-2. **Subsequent runs**: Your token is cached at `~/.one-shot-installer/github-token.json`
+## Authentication
 
-### Alternative: Environment Variable
+On first run, the installer prompts you to authenticate via GitHub OAuth Device Flow (browser-based). Your token is cached at `~/.one-shot-installer/github-token.json` for all future runs.
 
-You can also provide a GitHub token via environment variable:
+Alternatively, set the `GITHUB_TOKEN` environment variable:
 
 ```bash
+# macOS/Linux
+GITHUB_TOKEN="your_token_here" npx dlw-machine-setup@latest
+
 # Windows (PowerShell)
 $env:GITHUB_TOKEN="your_token_here"
-npx @DLW-INT-SAP-DEV/one-shot-installer
-
-# macOS/Linux
-GITHUB_TOKEN="your_token_here" npx @DLW-INT-SAP-DEV/one-shot-installer
+npx dlw-machine-setup@latest
 ```
 
-## How It Works
-
-1. Detects your platform (Windows, macOS, Linux) and architecture
-2. Downloads the appropriate binary from GitHub Releases (or uses cached version)
-3. Executes the installer
-4. The installer guides you through:
-   - Selecting technology domains (SAPUI5, CAP, ABAP, etc.)
-   - Choosing your AI assistant
-   - Installing MCP server configuration
-
-## Supported Platforms
-
-- **Windows**: x64
-- **macOS**: x64 (Intel), arm64 (Apple Silicon)
-- **Linux**: x64
-
-## Cache Location
-
-Binaries are cached at:
-- **Windows**: `%USERPROFILE%\.one-shot-installer\bin\`
-- **macOS/Linux**: `~/.one-shot-installer/bin/`
-
 ## Troubleshooting
 
-### "Failed to download binary"
-
-If you see authentication errors:
-
-1. Make sure you have access to the repository
-2. Run the installer once to authenticate via OAuth
-3. Or set `GITHUB_TOKEN` environment variable with a valid GitHub token
-
-### "Unsupported platform"
-
-The installer currently supports:
-- Windows 10/11 (x64)
-- macOS 10.15+ (Intel and Apple Silicon)
-- Linux x64 (Ubuntu, Debian, RHEL, etc.)
-
-### Binary not executing
-
-On macOS/Linux, if you get permission errors:
-```bash
-chmod +x ~/.one-shot-installer/bin/machine-setup-*
-```
-
-## What Gets Installed
-
-The installer provides:
-- **Technology-specific context files** (documentation, patterns, best practices)
-- **MCP server configuration** for AI assistants (Claude, Copilot, Cursor)
-- **Setup instructions** for your development environment
+| Problem | Solution |
+|---|---|
+| Authentication fails | Delete `~/.one-shot-installer/github-token.json` and re-run |
+| Context downloads fail | Check network connectivity and GitHub access |
+| SSO error | Ask your org admin to approve the OAuth app in GitHub org settings |
+| Stale cached version | Always use `npx dlw-machine-setup@latest` to bypass npx cache |
 
 ## License
 
-Internal use only - DLW-INT-SAP-DEV organization
-
-## Support
-
-For issues or questions, open an issue on GitHub.
+Internal use only — DLW-INT-SAP-DEV organization

package/bin/installer.js

@@ -2749,13 +2749,13 @@ var PromisePolyfill = class extends Promise {
   // Available starting from Node 22
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
   static withResolver() {
-    let resolve3;
+    let resolve4;
     let reject;
     const promise = new Promise((res, rej) => {
-      resolve3 = res;
+      resolve4 = res;
       reject = rej;
     });
-    return { promise, resolve: resolve3, reject };
+    return { promise, resolve: resolve4, reject };
   }
 };
 
@@ -2772,7 +2772,7 @@ function createPrompt(view) {
       output
     });
     const screen = new ScreenManager(rl);
-    const { promise, resolve: resolve3, reject } = PromisePolyfill.withResolver();
+    const { promise, resolve: resolve4, reject } = PromisePolyfill.withResolver();
     const cancel = () => reject(new CancelPromptError());
     if (signal) {
       const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
@@ -2796,7 +2796,7 @@ function createPrompt(view) {
       cycle(() => {
         try {
           const nextView = view(config, (value) => {
-            setImmediate(() => resolve3(value));
+            setImmediate(() => resolve4(value));
           });
           const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
           screen.render(content, bottomContent);
@@ -3240,9 +3240,10 @@ ${page}${helpTipBottom}${choiceDescription}${import_ansi_escapes3.default.cursor
 });
 
 // src/index.ts
-var import_fs6 = require("fs");
+var import_fs7 = require("fs");
 var import_readline = require("readline");
-var import_path6 = require("path");
+var import_path7 = require("path");
+var import_os2 = require("os");
 
 // src/utils/fetch.ts
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -3279,7 +3280,7 @@ async function fetchWithRetry(url, options = {}, maxRetries = DEFAULT_MAX_RETRIE
     }
     if (attempt < maxRetries) {
       const delay = retryDelayMs * Math.pow(2, attempt - 1);
-      await new Promise((resolve3) => setTimeout(resolve3, delay));
+      await new Promise((resolve4) => setTimeout(resolve4, delay));
     }
   }
   throw lastError || new Error("Failed after maximum retries");
@@ -3316,31 +3317,31 @@ async function fetchWizardOptions(token, repo) {
 
 // src/utils/data/discover-repo.ts
 var GITHUB_ORG = "DLW-INT-SAP-DEV";
-var REPO_TOPIC = "one-shot-data";
-async function discoverRepo(token) {
+var DEFAULT_TOPIC = "one-shot-data";
+async function discoverRepo(token, topic = DEFAULT_TOPIC) {
   const headers = {
     "Accept": "application/vnd.github+json",
     "Authorization": `Bearer ${token}`
   };
-  const searchResult = await trySearchAPI(headers);
+  const searchResult = await trySearchAPI(headers, topic);
   if (searchResult) return searchResult;
-  const listResult = await tryOrgReposList(headers);
+  const listResult = await tryOrgReposList(headers, topic);
   if (listResult) return listResult;
   throw new Error(
-    "No data repository found. Verify your GitHub account has access to the organization and the repository topic is configured."
+    `No repository with topic "${topic}" found. Verify your GitHub account has access to the organization and the repository topic is configured.`
   );
 }
-async function trySearchAPI(headers) {
+async function trySearchAPI(headers, topic) {
   try {
     const response = await fetchWithRetry(
-      `https://api.github.com/search/repositories?q=topic:${REPO_TOPIC}+org:${GITHUB_ORG}`,
+      `https://api.github.com/search/repositories?q=topic:${topic}+org:${GITHUB_ORG}`,
       { headers }
     );
     if (!response.ok) return null;
     const data = await response.json();
     if (data.total_count === 1) return data.items[0].full_name;
     if (data.total_count > 1) {
-      throw new Error("Multiple data repositories found. Contact your administrator.");
+      throw new Error(`Multiple repositories with topic "${topic}" found. Contact your administrator.`);
     }
     return null;
   } catch (error) {
@@ -3348,7 +3349,7 @@ async function trySearchAPI(headers) {
     return null;
   }
 }
-async function tryOrgReposList(headers) {
+async function tryOrgReposList(headers, topic) {
   try {
     const matched = [];
     let page = 1;
@@ -3361,7 +3362,7 @@ async function tryOrgReposList(headers) {
       const repos = await response.json();
       if (repos.length === 0) break;
       for (const repo of repos) {
-        if (repo.topics?.includes(REPO_TOPIC)) {
+        if (repo.topics?.includes(topic)) {
           matched.push(repo.full_name);
         }
       }
@@ -3370,7 +3371,7 @@ async function tryOrgReposList(headers) {
     }
     if (matched.length === 1) return matched[0];
     if (matched.length > 1) {
-      throw new Error("Multiple data repositories found. Contact your administrator.");
+      throw new Error(`Multiple repositories with topic "${topic}" found. Contact your administrator.`);
     }
     return null;
   } catch (error) {
@@ -3450,7 +3451,7 @@ async function pollForToken(deviceCode, interval) {
   const maxAttempts = 60;
   let attempts = 0;
   while (attempts < maxAttempts) {
-    await new Promise((resolve3) => setTimeout(resolve3, interval * 1e3));
+    await new Promise((resolve4) => setTimeout(resolve4, interval * 1e3));
     const response = await fetchWithTimeout(GITHUB_TOKEN_URL, {
       method: "POST",
       headers: {
@@ -3715,9 +3716,210 @@ function copyDirectory(source, target) {
   return { added, overwritten };
 }
 
-// src/utils/setup/setup-mcp.ts
+// src/utils/data/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: []
+  };
+  const tarCheck = (0, import_child_process2.spawnSync)("tar", ["--version"], { stdio: "ignore" });
+  if (tarCheck.status !== 0) {
+    result.failureReason = "tar command not found";
+    return result;
+  }
+  const headers = {
+    "Accept": "application/vnd.github+json",
+    "Authorization": `Bearer ${token}`
+  };
+  const releaseUrl = `https://api.github.com/repos/${repo}/releases/latest`;
+  const releaseResponse = await fetchWithRetry(releaseUrl, { headers });
+  if (!releaseResponse.ok) {
+    result.failureReason = `GitHub API error (${releaseResponse.status})`;
+    return result;
+  }
+  const releaseData = await releaseResponse.json();
+  const asset = releaseData.assets?.find((a) => a.name === FACTORY_ASSET_NAME);
+  if (!asset) {
+    result.failureReason = `${FACTORY_ASSET_NAME} not found in release`;
+    return result;
+  }
+  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 });
+    }
+    (0, import_fs3.mkdirSync)(tempDir, { recursive: true });
+    const downloadHeaders = {
+      "Accept": "application/octet-stream",
+      "Authorization": `Bearer ${token}`
+    };
+    const response = await fetchWithRetry(asset.url, { headers: downloadHeaders });
+    if (!response.ok) {
+      result.failureReason = `Download failed (${response.status})`;
+      return result;
+    }
+    const archivePath = (0, import_path3.join)(tempDir, FACTORY_ASSET_NAME);
+    const arrayBuffer = await response.arrayBuffer();
+    (0, import_fs3.writeFileSync)(archivePath, Buffer.from(arrayBuffer));
+    const stats = (0, import_fs3.statSync)(archivePath);
+    if (stats.size < MIN_FILE_SIZE2) {
+      result.failureReason = "Downloaded file corrupted (too small)";
+      return result;
+    }
+    const listResult = (0, import_child_process2.spawnSync)("tar", ["-tzf", archivePath], { encoding: "utf8" });
+    if (listResult.status !== 0) {
+      result.failureReason = "Failed to read archive contents";
+      return result;
+    }
+    const resolvedTempDir = (0, import_path3.resolve)(tempDir);
+    for (const entry of listResult.stdout.split("\n").filter(Boolean)) {
+      const entryPath = (0, import_path3.resolve)((0, import_path3.join)(tempDir, entry.replace(/\/$/, "")));
+      if (!entryPath.startsWith(resolvedTempDir + import_path3.sep)) {
+        result.failureReason = `Archive contains unsafe path: ${entry}`;
+        return result;
+      }
+    }
+    const extractResult = (0, import_child_process2.spawnSync)("tar", ["-xzf", archivePath, "-C", tempDir], { stdio: "ignore" });
+    if (extractResult.status !== 0) {
+      result.failureReason = "Archive extraction failed";
+      return result;
+    }
+    const extractedEntries = (0, import_fs3.readdirSync)(tempDir);
+    const extractedFolder = extractedEntries.find((e) => e.toLowerCase() === "factory");
+    if (!extractedFolder) {
+      result.failureReason = "No factory/ folder in archive";
+      return result;
+    }
+    const extractedPath = (0, import_path3.join)(tempDir, extractedFolder);
+    const claudeDir = (0, import_path3.join)(targetDir, ".claude");
+    const factoryDir = (0, import_path3.join)(targetDir, "factory");
+    const agentsSrc = (0, import_path3.join)(extractedPath, "agents");
+    if ((0, import_fs3.existsSync)(agentsSrc)) {
+      copyDirectory2(agentsSrc, (0, import_path3.join)(factoryDir, "agents"));
+      copyAgentStubs(agentsSrc, (0, import_path3.join)(claudeDir, "agents"));
+      result.filesInstalled.push(".claude/agents/", "factory/agents/");
+    }
+    const hooksSrc = (0, import_path3.join)(extractedPath, "hooks");
+    if ((0, import_fs3.existsSync)(hooksSrc)) {
+      copyDirectory2(hooksSrc, (0, import_path3.join)(claudeDir, "hooks"));
+      result.filesInstalled.push(".claude/hooks/");
+    }
+    const skillsSrc = (0, import_path3.join)(extractedPath, "skills");
+    if ((0, import_fs3.existsSync)(skillsSrc)) {
+      copyDirectory2(skillsSrc, (0, import_path3.join)(claudeDir, "skills"));
+      result.filesInstalled.push(".claude/skills/");
+    }
+    const workflowSrc = (0, import_path3.join)(extractedPath, "workflow");
+    if ((0, import_fs3.existsSync)(workflowSrc)) {
+      copyDirectory2(workflowSrc, (0, import_path3.join)(factoryDir, "workflow"));
+      result.filesInstalled.push("factory/workflow/");
+    }
+    configureSettings(claudeDir);
+    result.filesInstalled.push(".claude/settings.json");
+    result.success = true;
+  } catch (error) {
+    result.failureReason = error instanceof Error ? error.message : String(error);
+  } finally {
+    if ((0, import_fs3.existsSync)(tempDir)) {
+      try {
+        (0, import_fs3.rmSync)(tempDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+function configureSettings(claudeDir) {
+  const settingsPath = (0, import_path3.join)(claudeDir, "settings.json");
+  let settings = {};
+  if ((0, import_fs3.existsSync)(settingsPath)) {
+    try {
+      settings = JSON.parse((0, import_fs3.readFileSync)(settingsPath, "utf8"));
+    } catch {
+    }
+  }
+  if (!settings.hooks) settings.hooks = {};
+  const stateAdvanceHook = {
+    matcher: "Write|Edit",
+    hooks: [{ type: "command", command: "node .claude/hooks/factory-state-advance.cjs" }]
+  };
+  const contextMonitorHook = {
+    hooks: [{ type: "command", command: "node .claude/hooks/factory-context-monitor.cjs" }]
+  };
+  const stateGuardHook = {
+    hooks: [{ type: "command", command: "node .claude/hooks/factory-state-guard.cjs" }]
+  };
+  for (const event of ["PostToolUse", "UserPromptSubmit"]) {
+    if (settings.hooks[event]) {
+      settings.hooks[event] = settings.hooks[event].filter(
+        (h) => !h.hooks?.some(
+          (hh) => hh.command?.includes("factory-state-advance") || hh.command?.includes("factory-context-monitor") || hh.command?.includes("factory-state-guard")
+        )
+      );
+      if (settings.hooks[event].length === 0) delete settings.hooks[event];
+    }
+  }
+  if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
+  settings.hooks.PostToolUse.unshift(stateAdvanceHook);
+  if (!settings.hooks.UserPromptSubmit) {
+    settings.hooks.UserPromptSubmit = [stateGuardHook, contextMonitorHook];
+  } else {
+    const hasGuard = settings.hooks.UserPromptSubmit.some(
+      (h) => h.hooks?.some((hh) => hh.command?.includes("factory-state-guard"))
+    );
+    if (!hasGuard) settings.hooks.UserPromptSubmit.unshift(stateGuardHook);
+    const hasMonitor = settings.hooks.UserPromptSubmit.some(
+      (h) => h.hooks?.some((hh) => hh.command?.includes("factory-context-monitor"))
+    );
+    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 });
+  }
+  (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 });
+  }
+  const entries = (0, import_fs3.readdirSync)(source, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) continue;
+    if (!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 });
+  }
+  const entries = (0, import_fs3.readdirSync)(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = (0, import_path3.join)(source, entry.name);
+    const targetPath = (0, import_path3.join)(target, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory2(sourcePath, targetPath);
+    } else {
+      (0, import_fs3.copyFileSync)(sourcePath, targetPath);
+    }
+  }
+}
+
+// src/utils/setup/setup-mcp.ts
+var import_fs4 = require("fs");
+var import_path4 = require("path");
 function getAgentMCPTarget(agent) {
   switch (agent) {
     case "claude-code":
@@ -3731,18 +3933,18 @@ function getAgentMCPTarget(agent) {
 }
 async function setupMCPConfiguration(projectPath, mcpConfig, agent) {
   const target = getAgentMCPTarget(agent);
-  const mcpJsonPath = (0, import_path3.join)(projectPath, target.filePath);
+  const mcpJsonPath = (0, import_path4.join)(projectPath, target.filePath);
   if (target.dir) {
-    const dir = (0, import_path3.join)(projectPath, target.dir);
-    if (!(0, import_fs3.existsSync)(dir)) {
-      (0, import_fs3.mkdirSync)(dir, { recursive: true });
+    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_fs3.existsSync)(mcpJsonPath)) {
+  if ((0, import_fs4.existsSync)(mcpJsonPath)) {
     try {
-      const content = (0, import_fs3.readFileSync)(mcpJsonPath, "utf-8");
+      const content = (0, import_fs4.readFileSync)(mcpJsonPath, "utf-8");
       existingFile = JSON.parse(content);
     } catch {
       const box = [
@@ -3770,7 +3972,7 @@ async function setupMCPConfiguration(projectPath, mcpConfig, agent) {
   }
   const mergedServers = { ...existingServers, ...newServers };
   const outputFile = { ...existingFile, [target.rootKey]: mergedServers };
-  (0, import_fs3.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
+  (0, import_fs4.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
   return { addedServers, skippedServers };
 }
 function buildMCPConfiguration(selectedItems, baseMcpServers, allMcpServers) {
@@ -3791,8 +3993,8 @@ function buildMCPConfiguration(selectedItems, baseMcpServers, allMcpServers) {
 }
 
 // src/utils/setup/setup-instructions.ts
-var import_fs4 = require("fs");
-var import_path4 = require("path");
+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`;
@@ -3800,11 +4002,11 @@ function upsertBlock(filePath, block) {
   const marked = `${MARKER_START}
 ${block}
 ${MARKER_END}`;
-  if (!(0, import_fs4.existsSync)(filePath)) {
-    (0, import_fs4.writeFileSync)(filePath, marked, "utf-8");
+  if (!(0, import_fs5.existsSync)(filePath)) {
+    (0, import_fs5.writeFileSync)(filePath, marked, "utf-8");
     return;
   }
-  const existing = (0, import_fs4.readFileSync)(filePath, "utf-8");
+  const existing = (0, import_fs5.readFileSync)(filePath, "utf-8");
   const start = existing.indexOf(MARKER_START);
   const end = existing.indexOf(MARKER_END);
   const hasStart = start !== -1;
@@ -3829,23 +4031,23 @@ ${MARKER_END}`;
   }
   if (hasStart && hasEnd) {
     const updated = existing.slice(0, start) + marked + existing.slice(end + MARKER_END.length);
-    (0, import_fs4.writeFileSync)(filePath, updated, "utf-8");
+    (0, import_fs5.writeFileSync)(filePath, updated, "utf-8");
   } else {
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    (0, import_fs4.writeFileSync)(filePath, existing + separator + marked, "utf-8");
+    (0, import_fs5.writeFileSync)(filePath, existing + separator + marked, "utf-8");
   }
 }
 function collectMdFiles(dir) {
-  if (!(0, import_fs4.existsSync)(dir)) return [];
-  const entries = (0, import_fs4.readdirSync)(dir, { recursive: true });
+  if (!(0, import_fs5.existsSync)(dir)) return [];
+  const entries = (0, import_fs5.readdirSync)(dir, { recursive: true });
   return entries.filter((entry) => {
-    const fullPath = (0, import_path4.join)(dir, entry);
-    return entry.endsWith(".md") && (0, import_fs4.statSync)(fullPath).isFile();
+    const fullPath = (0, import_path5.join)(dir, entry);
+    return entry.endsWith(".md") && (0, import_fs5.statSync)(fullPath).isFile();
   }).map((entry) => entry.replace(/\\/g, "/")).sort();
 }
 function extractFirstHeading(filePath) {
   try {
-    const content = (0, import_fs4.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs5.readFileSync)(filePath, "utf-8");
     const withoutFrontmatter = content.replace(/^---[\s\S]*?---\s*/, "");
     const match = withoutFrontmatter.match(/^#\s+(.+)/m);
     if (match) {
@@ -3879,18 +4081,18 @@ function buildMCPSection(mcpConfig) {
   return lines2.join("\n");
 }
 function resolveDomainFolder(domain, contextsDir) {
-  if ((0, import_fs4.existsSync)(contextsDir)) {
+  if ((0, import_fs5.existsSync)(contextsDir)) {
     try {
-      const entries = (0, import_fs4.readdirSync)(contextsDir);
+      const entries = (0, import_fs5.readdirSync)(contextsDir);
       const match = entries.find((e) => e.toLowerCase() === domain.toLowerCase());
       if (match) {
-        return { folderName: match, folderPath: (0, import_path4.join)(contextsDir, match) };
+        return { folderName: match, folderPath: (0, import_path5.join)(contextsDir, match) };
       }
     } catch {
     }
   }
   const fallback = domain.toUpperCase();
-  return { folderName: fallback, folderPath: (0, import_path4.join)(contextsDir, fallback) };
+  return { folderName: fallback, folderPath: (0, import_path5.join)(contextsDir, fallback) };
 }
 function formatPathRef(contextPath, description, agent) {
   if (agent === "github-copilot") {
@@ -3908,34 +4110,34 @@ function buildContextRefsSection(domains, agent, contextsDir) {
   let hasAnyFiles = false;
   for (const domain of domains) {
     const { folderName, folderPath: domainPath } = resolveDomainFolder(domain, contextsDir);
-    if (!(0, import_fs4.existsSync)(domainPath)) continue;
+    if (!(0, import_fs5.existsSync)(domainPath)) continue;
     const domainFiles = [];
-    const ctxInstructions = (0, import_path4.join)(domainPath, "context-instructions.md");
-    if ((0, import_fs4.existsSync)(ctxInstructions)) {
+    const ctxInstructions = (0, import_path5.join)(domainPath, "context-instructions.md");
+    if ((0, import_fs5.existsSync)(ctxInstructions)) {
       const desc = extractFirstHeading(ctxInstructions);
       domainFiles.push(formatPathRef(`_ai-context/${folderName}/context-instructions.md`, desc, agent));
     }
-    const instructionsMd = (0, import_path4.join)(domainPath, "core", "instructions.md");
-    if ((0, import_fs4.existsSync)(instructionsMd)) {
+    const instructionsMd = (0, import_path5.join)(domainPath, "core", "instructions.md");
+    if ((0, import_fs5.existsSync)(instructionsMd)) {
       const desc = extractFirstHeading(instructionsMd);
       domainFiles.push(formatPathRef(`_ai-context/${folderName}/core/instructions.md`, `${desc} (start here)`, agent));
     }
-    const coreDir = (0, import_path4.join)(domainPath, "core");
-    if ((0, import_fs4.existsSync)(coreDir)) {
+    const coreDir = (0, import_path5.join)(domainPath, "core");
+    if ((0, import_fs5.existsSync)(coreDir)) {
       const coreFiles = collectMdFiles(coreDir).filter((f) => f !== "instructions.md" && !f.startsWith("instructions/"));
       for (const file of coreFiles) {
-        const desc = extractFirstHeading((0, import_path4.join)(coreDir, file));
+        const desc = extractFirstHeading((0, import_path5.join)(coreDir, file));
         domainFiles.push(formatPathRef(`_ai-context/${folderName}/core/${file}`, desc, agent));
       }
     }
-    const refDir = (0, import_path4.join)(domainPath, "reference");
-    if ((0, import_fs4.existsSync)(refDir)) {
+    const refDir = (0, import_path5.join)(domainPath, "reference");
+    if ((0, import_fs5.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_path4.join)(refDir, file));
+          const desc = extractFirstHeading((0, import_path5.join)(refDir, file));
           domainFiles.push(formatPathRef(`_ai-context/${folderName}/reference/${file}`, desc, agent));
         }
       }
@@ -3952,8 +4154,26 @@ function buildContextRefsSection(domains, agent, contextsDir) {
   }
   return lines2.join("\n");
 }
-function buildCombinedInstructions(domains, mcpConfig, agent = "", projectPath = process.cwd()) {
-  const contextsDir = (0, import_path4.join)(projectPath, "_ai-context");
+function buildFactorySection() {
+  return [
+    `## Factory Dev Workflow`,
+    ``,
+    `Factory is installed. Use \`/factory:dev-plan\` to start or resume the workflow.`,
+    ``,
+    `Available commands:`,
+    `- \`/factory:dev-plan\` \u2014 start or resume the workflow`,
+    `- \`/factory:progress\` \u2014 check status`,
+    `- \`/factory:analyst\` \u2014 validate a story`,
+    `- \`/factory:architect\` \u2014 design architecture`,
+    `- \`/factory:planner\` \u2014 create story plan`,
+    `- \`/factory:verifier\` \u2014 code review`,
+    `- \`/factory:security\` \u2014 OWASP security review`,
+    `- \`/factory:test-analyst\` \u2014 test quality review`,
+    ``
+  ].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`,
     ``,
@@ -3964,44 +4184,47 @@ function buildCombinedInstructions(domains, mcpConfig, agent = "", projectPath =
   if (mcpConfig && 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() } = config;
+  const { domains, agent, mcpConfig, projectPath = process.cwd(), factoryInstalled = false } = config;
   switch (agent) {
     case "claude-code": {
-      const content = buildCombinedInstructions(domains, mcpConfig, agent, projectPath);
-      upsertBlock((0, import_path4.join)(projectPath, "CLAUDE.md"), content);
+      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_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, `---
+      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);
+      const body = buildCombinedInstructions(domains, mcpConfig, agent, projectPath, factoryInstalled);
       upsertBlock(filePath, body);
       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, `---
+      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");
       }
-      const body = buildCombinedInstructions(domains, mcpConfig, agent, projectPath);
+      const body = buildCombinedInstructions(domains, mcpConfig, agent, projectPath, factoryInstalled);
       upsertBlock(filePath, body);
       break;
     }
@@ -4011,8 +4234,8 @@ alwaysApply: true
 }
 
 // src/utils/setup/setup-gitignore.ts
-var import_fs5 = require("fs");
-var import_path5 = require("path");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
 var MARKER_START2 = "# one-shot-installer:start";
 var MARKER_END2 = "# one-shot-installer:end";
 var GITIGNORE_ENTRIES = [
@@ -4027,24 +4250,37 @@ var GITIGNORE_ENTRIES = [
   ".claude/agents/",
   ".claude/agent-memory/",
   ".claude/plans/",
-  ".claude/settings.local.json"
+  ".claude/settings.local.json",
+  "",
+  "# Factory runtime state (generated by workflow, not committed)",
+  "factory/STATE.md",
+  "factory/PROJECT.md",
+  "factory/REQUIREMENTS.md",
+  "factory/ARCHITECTURE.md",
+  "factory/ROADMAP.md",
+  "factory/PLAN.md",
+  "factory/GATE-REPORT.md",
+  "factory/VERIFY-REPORT.md",
+  "factory/COMPLETION.md",
+  "factory/summaries/",
+  "factory/ai-context/"
 ];
 function setupGitignore(projectPath) {
-  const gitignorePath = (0, import_path5.join)(projectPath, ".gitignore");
+  const gitignorePath = (0, import_path6.join)(projectPath, ".gitignore");
   const block = [MARKER_START2, ...GITIGNORE_ENTRIES, MARKER_END2].join("\n");
-  if (!(0, import_fs5.existsSync)(gitignorePath)) {
-    (0, import_fs5.writeFileSync)(gitignorePath, block + "\n", "utf-8");
+  if (!(0, import_fs6.existsSync)(gitignorePath)) {
+    (0, import_fs6.writeFileSync)(gitignorePath, block + "\n", "utf-8");
     return;
   }
-  const existing = (0, import_fs5.readFileSync)(gitignorePath, "utf-8");
+  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_fs5.writeFileSync)(gitignorePath, updated, "utf-8");
+    (0, import_fs6.writeFileSync)(gitignorePath, updated, "utf-8");
   } else {
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    (0, import_fs5.writeFileSync)(gitignorePath, existing + separator + block + "\n", "utf-8");
+    (0, import_fs6.writeFileSync)(gitignorePath, existing + separator + block + "\n", "utf-8");
   }
 }
 
@@ -4068,7 +4304,7 @@ async function loadWizardOptions(token, repo) {
 }
 
 // src/index.ts
-var INSTALLER_VERSION = "0.4.11";
+var INSTALLER_VERSION = "0.5.7";
 function getInstructionFilePath(agent) {
   switch (agent) {
     case "claude-code":
@@ -4097,12 +4333,31 @@ function formatMCPCommand(server) {
   if (server.command) return `${server.command} ${(server.args ?? []).join(" ")}`.trimEnd();
   return "";
 }
+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 (content.includes(markerStart)) return yellow("update");
+  return yellow("append");
+}
+function detectMCPFileMode(filePath) {
+  if (!(0, import_fs7.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");
+  return green("create");
+}
 function waitForEnter() {
   const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     rl.question("  Press Enter to close...", () => {
       rl.close();
-      resolve3();
+      resolve4();
     });
   });
 }
@@ -4111,11 +4366,17 @@ async function main() {
   console.log("One-Shot Setup Installer\n");
   try {
     const token = await getGitHubToken();
-    console.log("  Locating data repository...");
-    const repo = await discoverRepo(token);
+    console.log("  Locating repositories...");
+    const [repo, factoryRepo] = await Promise.all([
+      discoverRepo(token),
+      discoverRepo(token, "factory-data").catch(() => null)
+    ]);
+    if (!factoryRepo) {
+      console.log("  \u26A0  Factory repo not found \u2014 Factory will not be installed.");
+    }
     console.log("  Loading configuration...");
     const options = await loadWizardOptions(token, repo);
-    const config = await collectInputs(options, options.releaseVersion);
+    const config = await collectInputs(options, options.releaseVersion, !!factoryRepo);
     if (!config) {
       await waitForEnter();
       return;
@@ -4126,7 +4387,7 @@ async function main() {
       await waitForEnter();
       return;
     }
-    const result = await execute(config, token, repo);
+    const result = await execute(config, token, repo, factoryRepo);
     printSummary(result);
     return;
   } catch (error) {
@@ -4134,7 +4395,7 @@ async function main() {
     await waitForEnter();
   }
 }
-async function collectInputs(options, releaseVersion) {
+async function collectInputs(options, releaseVersion, factoryAvailable = false) {
   const selectedIds = await esm_default2({
     message: "Personas:",
     instructions: "  Space to select  \xB7  Enter to confirm",
@@ -4166,16 +4427,17 @@ async function collectInputs(options, releaseVersion) {
   }
   const projectInput = await esm_default4({
     message: "Project directory:",
-    default: (0, import_path6.resolve)(process.cwd())
+    default: (0, import_path7.resolve)(process.cwd())
   });
   return {
     personas: selectedPersonas,
     agent,
     azureDevOpsOrg,
-    projectPath: (0, import_path6.resolve)(projectInput),
+    projectPath: (0, import_path7.resolve)(projectInput),
     baseMcpServers: options.baseMcpServers,
     mcpConfig,
-    releaseVersion
+    releaseVersion,
+    installFactory: factoryAvailable
   };
 }
 async function previewAndConfirm(config, options) {
@@ -4184,21 +4446,41 @@ async function previewAndConfirm(config, options) {
   const instructionFile = getInstructionFilePath(config.agent);
   const mcpConfigFile = getMCPConfigPath(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 instructionMode = detectMarkerFileMode(instructionFilePath, "<!-- one-shot-installer:start -->");
+  const mcpMode = detectMCPFileMode(mcpConfigFilePath);
+  const gitignoreMode = detectMarkerFileMode(gitignorePath, "# one-shot-installer:start");
+  const uniqueDomains = [...new Set(config.personas.flatMap((p) => p.domains))];
+  const domainModes = uniqueDomains.map((d) => ({
+    domain: d,
+    mode: detectContextMode(config.projectPath, d)
+  }));
   console.log("\n" + "\u2500".repeat(48));
   console.log("  Ready to install");
   console.log("\u2500".repeat(48) + "\n");
   console.log(`  Personas     ${personaNames}`);
   console.log(`  Tool         ${agentDisplay}`);
+  console.log(`  Factory      ${config.installFactory ? "yes" : "no"}`);
   console.log(`  Directory    ${config.projectPath}`);
   console.log("");
-  console.log(`  Instruction file`);
-  console.log(`    ${instructionFile}`);
-  console.log("");
-  console.log(`  MCP config`);
-  console.log(`    ${mcpConfigFile}`);
+  console.log(`  ${dim("File actions:")}`);
+  const domainColWidth = Math.max(...domainModes.map((d) => d.domain.length), 6) + 2;
+  for (const { domain, mode } of domainModes) {
+    console.log(`    _ai-context/${domain.padEnd(domainColWidth)}${mode}`);
+  }
+  console.log(`    ${instructionFile.padEnd(domainColWidth + 14)}${instructionMode}`);
+  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 factoryMode = factoryExists ? yellow("overwrite") : green("create");
+    console.log(`    ${"factory/".padEnd(domainColWidth + 14)}${factoryMode}`);
+  }
   if (serverEntries.length > 0) {
     console.log("");
-    console.log("  MCP servers");
+    console.log(`  ${dim("MCP servers:")}`);
     const maxLen = Math.max(...serverEntries.map(([name]) => name.length));
     for (const [name, server] of serverEntries) {
       const cmd = formatMCPCommand(server);
@@ -4208,7 +4490,7 @@ async function previewAndConfirm(config, options) {
   console.log("\n" + "\u2500".repeat(48));
   return esm_default3({ message: "Proceed?", default: true });
 }
-async function execute(config, token, repo) {
+async function execute(config, token, repo, factoryRepo = null) {
   const instructionFilePath = getInstructionFilePath(config.agent);
   const mcpConfigPath = getMCPConfigPath(config.agent);
   const result = {
@@ -4221,7 +4503,8 @@ async function execute(config, token, repo) {
     mcpConfigured: false,
     mcpConfigPath,
     mcpServersAdded: [],
-    gitignoreUpdated: false
+    gitignoreUpdated: false,
+    factoryInstalled: false
   };
   console.log("");
   const uniqueDomains = [...new Set(config.personas.flatMap((p) => p.domains))];
@@ -4245,6 +4528,22 @@ async function execute(config, token, repo) {
     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;
@@ -4260,7 +4559,7 @@ async function execute(config, token, repo) {
   const filteredMcpConfig = Object.fromEntries(
     Object.entries(config.mcpConfig).filter(([name]) => successfulMcpServers.has(name))
   );
-  const statePath = (0, import_path6.join)(config.projectPath, ".one-shot-state.json");
+  const statePath = (0, import_path7.join)(config.projectPath, ".one-shot-state.json");
   const allDomains = result.domainsInstalled;
   process.stdout.write(`  Writing ${instructionFilePath}...    `);
   try {
@@ -4268,7 +4567,8 @@ async function execute(config, token, repo) {
       domains: allDomains,
       agent: config.agent,
       mcpConfig: filteredMcpConfig,
-      projectPath: config.projectPath
+      projectPath: config.projectPath,
+      factoryInstalled: result.factoryInstalled
     });
     result.instructionsCreated = true;
     console.log("\u2713");
@@ -4313,14 +4613,17 @@ async function execute(config, token, repo) {
     domains: allDomains,
     mcpServers: Object.keys(filteredMcpConfig),
     mcpConfigs: filteredMcpConfig,
+    factoryInstalled: result.factoryInstalled,
     files: {
       instructions: instructionFilePath,
       mcpConfig: mcpConfigPath,
-      contexts: "_ai-context/"
+      contexts: "_ai-context/",
+      factory: result.factoryInstalled ? "factory/" : null,
+      globalConfig: (0, import_path7.join)((0, import_os2.homedir)(), ".one-shot-installer")
     }
   };
   try {
-    (0, import_fs6.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
+    (0, import_fs7.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
   } catch {
   }
   return result;
@@ -4339,6 +4642,9 @@ function printSummary(result) {
     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`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dlw-machine-setup",
-  "version": "0.4.11",
+  "version": "0.5.7",
   "description": "One-shot installer for The Machine toolchain",
   "bin": {
     "dlw-machine-setup": "bin/installer.js"