dlw-machine-setup 0.8.1 → 0.8.2

package/bin/installer.js

@@ -3244,9 +3244,9 @@ ${page}${helpTipBottom}${choiceDescription}${import_ansi_escapes3.default.cursor
 });
 
 // src/index.ts
-var import_fs11 = require("fs");
+var import_fs12 = require("fs");
 var import_readline = require("readline");
-var import_path12 = require("path");
+var import_path13 = require("path");
 
 // src/utils/fetch.ts
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -3324,6 +3324,25 @@ async function fetchLatestRelease(token, repo) {
   const data = await res.json();
   return { tagName: data.tag_name ?? "unknown", assets: data.assets ?? [] };
 }
+async function fetchLatestReleaseByTagPrefix(token, repo, tagPrefix) {
+  const headers = {
+    "Accept": "application/vnd.github+json",
+    "Authorization": `Bearer ${token}`
+  };
+  const res = await fetchWithRetry(
+    `https://api.github.com/repos/${repo}/releases?per_page=100`,
+    { headers }
+  );
+  if (!res.ok) {
+    throw new Error(`GitHub API error (${res.status}): ${getReadableError(res.status)}`);
+  }
+  const releases = await res.json();
+  const match = releases.find((r) => typeof r.tag_name === "string" && r.tag_name.startsWith(tagPrefix));
+  if (!match) {
+    throw new Error(`No release with tag prefix "${tagPrefix}" found in ${repo}`);
+  }
+  return { tagName: match.tag_name ?? "unknown", assets: match.assets ?? [] };
+}
 async function downloadAndExtractAsset(token, asset, projectPath, tempDirName) {
   const tarCheck = (0, import_child_process.spawnSync)("tar", ["--version"], { stdio: "ignore" });
   if (tarCheck.status !== 0) {
@@ -3738,6 +3757,7 @@ async function runPipeline(steps, ctx) {
 // src/steps/index.ts
 var steps_exports = {};
 __export(steps_exports, {
+  fetchAbapHooks: () => fetch_abap_hooks_default,
   fetchContexts: () => fetch_contexts_default,
   fetchFactory: () => fetch_factory_default,
   runMcpInstallCommands: () => run_mcp_install_commands_default,
@@ -4330,9 +4350,140 @@ async function installViaBundle(manifestPath, extractedPath, targetDir, agent, r
   result.filesInstalled = runResult.filesTouched;
 }
 
-// src/steps/setup/write-instructions.ts
+// src/steps/resources/fetch-abap-hooks.ts
 var import_fs8 = require("fs");
 var import_path8 = require("path");
+var HOOKS_ASSET_NAME = "sap-hooks.tar.gz";
+var HOOKS_TAG_PREFIX = "hooks-v";
+var HOOKS_ROOT_FOLDER = "hooks";
+var BUNDLE_NAME = "abap-mcp-hooks";
+var HOOK_DEFINITIONS = [
+  { event: "PreToolUse", script: "sap-safety-gate.mjs" },
+  { event: "PostToolUse", script: "telemetry-post-tool.mjs" },
+  { event: "PostToolUseFailure", script: "telemetry-post-tool-failure.mjs" },
+  { event: "SessionStart", script: "telemetry-session-start.mjs" },
+  { event: "SessionEnd", script: "telemetry-session-end.mjs" }
+];
+var INSTRUCTIONS_SNIPPET = [
+  `## SAP ABAP MCP Hooks`,
+  ``,
+  `Installed by One-Shot Installer. Hook scripts live in \`.claude/hooks/\` and are wired into \`.claude/settings.json\`.`,
+  ``,
+  `**What they do:**`,
+  `- \`sap-safety-gate.mjs\` (PreToolUse) \u2014 blocks \`delete\` (any tool) and transport \`release\`.`,
+  `- \`telemetry-*.mjs\` (PostToolUse, PostToolUseFailure, SessionStart, SessionEnd) \u2014 emit usage events.`,
+  ``,
+  `**Optional environment variables:**`,
+  `- \`SAP_MCP_TELEMETRY_URL\` \u2014 base URL of the MCP telemetry endpoint (e.g. \`https://mcp.<cluster>.kyma.ondemand.com\`). When unset, telemetry is silently skipped; the safety gate still blocks.`,
+  `- \`SAP_MCP_TELEMETRY_TOKEN\` \u2014 Bearer token for the telemetry endpoint.`,
+  ``,
+  `On network/HTTP failure, telemetry events fall back to \`~/.claude/telemetry/events.jsonl\`.`,
+  ``
+].join("\n");
+var fetch_abap_hooks_default = defineStep({
+  name: "fetch-abap-hooks",
+  label: "Installing ABAP MCP hooks",
+  /* All eligibility (Claude-only + ABAP selected + repo discovered) is
+   * resolved upfront in collectInputs() and frozen on InstallConfig.
+   * Reading the single flag keeps the guard, the preview, and the
+   * step in sync with no scattered conditionals. */
+  when: (ctx) => ctx.config.installAbapHooks,
+  execute: async (ctx) => {
+    const result = await fetchAbapHooks(
+      ctx.token,
+      ctx.abapHooksRepo,
+      ctx.config.projectPath,
+      ctx.config.agent
+    );
+    ctx.installed.abapHooksInstalled = result.success;
+    if (result.instructionsSnippet) {
+      ctx.installed.abapHooksInstructionsSnippet = result.instructionsSnippet;
+    }
+    if (!result.success) {
+      return { status: "failed", detail: result.failureReason };
+    }
+    return { status: "success", message: result.filesInstalled.join(", ") };
+  }
+});
+async function fetchAbapHooks(token, repo, targetDir, agent) {
+  const result = { success: false, filesInstalled: [] };
+  let release;
+  try {
+    release = await fetchLatestReleaseByTagPrefix(token, repo, HOOKS_TAG_PREFIX);
+  } catch (err) {
+    result.failureReason = err instanceof Error ? err.message : String(err);
+    return result;
+  }
+  const asset = release.assets.find((a) => a.name === HOOKS_ASSET_NAME);
+  if (!asset) {
+    result.failureReason = `${HOOKS_ASSET_NAME} not found in release ${release.tagName}`;
+    return result;
+  }
+  let archive = null;
+  try {
+    archive = await downloadAndExtractAsset(token, asset, targetDir, ".temp-abap-hooks-download");
+    const extractedEntries = (0, import_fs8.readdirSync)(archive.extractedRoot);
+    const innerFolder = extractedEntries.find(
+      (e) => e.toLowerCase() === HOOKS_ROOT_FOLDER.toLowerCase()
+    );
+    if (!innerFolder) {
+      result.failureReason = `No ${HOOKS_ROOT_FOLDER}/ folder in archive`;
+      return result;
+    }
+    const bundleRoot = (0, import_path8.join)(archive.extractedRoot, innerFolder);
+    if (!(0, import_fs8.statSync)(bundleRoot).isDirectory()) {
+      result.failureReason = `${HOOKS_ROOT_FOLDER}/ entry is not a directory`;
+      return result;
+    }
+    const presentDefs = HOOK_DEFINITIONS.filter((d) => (0, import_fs8.existsSync)((0, import_path8.join)(bundleRoot, d.script)));
+    if (presentDefs.length === 0) {
+      result.failureReason = "Archive contains no recognized hook scripts";
+      return result;
+    }
+    const assets = [
+      ...presentDefs.map((d) => ({
+        type: "hook",
+        event: d.event,
+        /* {hookDir} is substituted by run-bundle.ts with the agent
+         * profile's scriptDir (.claude/hooks for Claude Code), so the
+         * resulting command is exactly `node .claude/hooks/<script>`,
+         * matching the form Claude Code already uses for Factory hooks. */
+        command: `node {hookDir}/${d.script}`,
+        script: d.script
+      })),
+      { type: "instructions-snippet", content: INSTRUCTIONS_SNIPPET }
+    ];
+    const manifest = {
+      schemaVersion: 2,
+      name: BUNDLE_NAME,
+      assets
+    };
+    const target = getAgentTarget(agent);
+    const runResult = await runBundle(manifest, {
+      bundleRoot,
+      projectPath: targetDir,
+      agent,
+      instructionsFile: target.instructions,
+      /* write-instructions.ts owns the ordering of marker blocks in
+       * CLAUDE.md (one-shot-installer:start/end first, bundle blocks
+       * after). Skipping here means we hand the snippet back; it gets
+       * committed when write-instructions.ts runs in the setup phase. */
+      skipInstructions: true
+    });
+    result.filesInstalled = runResult.filesTouched;
+    result.instructionsSnippet = runResult.instructionsSnippet;
+    result.success = true;
+  } catch (error) {
+    result.failureReason = error instanceof Error ? error.message : String(error);
+  } finally {
+    archive?.cleanup();
+  }
+  return result;
+}
+
+// src/steps/setup/write-instructions.ts
+var import_fs9 = require("fs");
+var import_path9 = require("path");
 
 // src/steps/shared.ts
 var cached = null;
@@ -4359,7 +4510,7 @@ 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 || Object.keys(ctx.config.mcpConfig).length > 0 || !!ctx.installed.factoryInstructionsSnippet,
+  when: (ctx) => (ctx.installed.domainsInstalled?.length ?? 0) > 0 || Object.keys(ctx.config.mcpConfig).length > 0 || !!ctx.installed.factoryInstructionsSnippet || !!ctx.installed.abapHooksInstructionsSnippet,
   execute: async (ctx) => {
     const filteredMcpConfig = getFilteredMcpConfig(ctx);
     const domains = ctx.installed.domainsInstalled ?? [];
@@ -4367,11 +4518,11 @@ var write_instructions_default = defineStep({
     const projectPath = ctx.config.projectPath;
     const content = buildCombinedInstructions(domains, filteredMcpConfig, agent, projectPath);
     const target = getAgentTarget(agent);
-    const filePath = (0, import_path8.join)(projectPath, target.instructions);
-    const fileDir = (0, import_path8.dirname)(filePath);
-    if (!(0, import_fs8.existsSync)(fileDir)) (0, import_fs8.mkdirSync)(fileDir, { recursive: true });
-    if (agent === "cursor" && !(0, import_fs8.existsSync)(filePath)) {
-      (0, import_fs8.writeFileSync)(filePath, `---
+    const filePath = (0, import_path9.join)(projectPath, target.instructions);
+    const fileDir = (0, import_path9.dirname)(filePath);
+    if (!(0, import_fs9.existsSync)(fileDir)) (0, import_fs9.mkdirSync)(fileDir, { recursive: true });
+    if (agent === "cursor" && !(0, import_fs9.existsSync)(filePath)) {
+      (0, import_fs9.writeFileSync)(filePath, `---
 description: AI development instructions from One-Shot Installer
 alwaysApply: true
 ---
@@ -4406,20 +4557,28 @@ alwaysApply: true
         ctx.installed.factoryInstructionsSnippet
       );
     }
+    if (ctx.installed.abapHooksInstructionsSnippet) {
+      upsertMarkerBlock(
+        filePath,
+        "<!-- abap-mcp-hooks:start -->",
+        "<!-- abap-mcp-hooks:end -->",
+        ctx.installed.abapHooksInstructionsSnippet
+      );
+    }
     return { status: "success", message: target.instructions };
   }
 });
 function collectMdFiles(dir) {
-  if (!(0, import_fs8.existsSync)(dir)) return [];
-  const entries = (0, import_fs8.readdirSync)(dir, { recursive: true });
+  if (!(0, import_fs9.existsSync)(dir)) return [];
+  const entries = (0, import_fs9.readdirSync)(dir, { recursive: true });
   return entries.filter((entry) => {
-    const fullPath = (0, import_path8.join)(dir, entry);
-    return entry.endsWith(".md") && (0, import_fs8.statSync)(fullPath).isFile();
+    const fullPath = (0, import_path9.join)(dir, entry);
+    return entry.endsWith(".md") && (0, import_fs9.statSync)(fullPath).isFile();
   }).map((entry) => entry.replace(/\\/g, "/")).sort();
 }
 function extractFirstHeading(filePath) {
   try {
-    const content = (0, import_fs8.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs9.readFileSync)(filePath, "utf-8");
     const withoutFrontmatter = content.replace(/^---[\s\S]*?---\s*/, "");
     const match = withoutFrontmatter.match(/^#\s+(.+)/m);
     if (match) {
@@ -4437,16 +4596,16 @@ function formatPathRef(contextPath, description, agent) {
   return `- \`${contextPath}\` \u2014 ${description}`;
 }
 function resolveDomainFolder(domain, contextsDir) {
-  if ((0, import_fs8.existsSync)(contextsDir)) {
+  if ((0, import_fs9.existsSync)(contextsDir)) {
     try {
-      const entries = (0, import_fs8.readdirSync)(contextsDir);
+      const entries = (0, import_fs9.readdirSync)(contextsDir);
       const match = entries.find((e) => e.toLowerCase() === domain.toLowerCase());
-      if (match) return { folderName: match, folderPath: (0, import_path8.join)(contextsDir, match) };
+      if (match) return { folderName: match, folderPath: (0, import_path9.join)(contextsDir, match) };
     } catch {
     }
   }
   const fallback = domain.toUpperCase();
-  return { folderName: fallback, folderPath: (0, import_path8.join)(contextsDir, fallback) };
+  return { folderName: fallback, folderPath: (0, import_path9.join)(contextsDir, fallback) };
 }
 function buildContextRefsSection(domains, agent, contextsDir) {
   const lines2 = [
@@ -4458,34 +4617,34 @@ function buildContextRefsSection(domains, agent, contextsDir) {
   let hasAnyFiles = false;
   for (const domain of domains) {
     const { folderName, folderPath: domainPath } = resolveDomainFolder(domain, contextsDir);
-    if (!(0, import_fs8.existsSync)(domainPath)) continue;
+    if (!(0, import_fs9.existsSync)(domainPath)) continue;
     const domainFiles = [];
-    const ctxInstructions = (0, import_path8.join)(domainPath, "context-instructions.md");
-    if ((0, import_fs8.existsSync)(ctxInstructions)) {
+    const ctxInstructions = (0, import_path9.join)(domainPath, "context-instructions.md");
+    if ((0, import_fs9.existsSync)(ctxInstructions)) {
       const desc = extractFirstHeading(ctxInstructions);
       domainFiles.push(formatPathRef(`_ai-context/${folderName}/context-instructions.md`, desc, agent));
     }
-    const instructionsMd = (0, import_path8.join)(domainPath, "core", "instructions.md");
-    if ((0, import_fs8.existsSync)(instructionsMd)) {
+    const instructionsMd = (0, import_path9.join)(domainPath, "core", "instructions.md");
+    if ((0, import_fs9.existsSync)(instructionsMd)) {
       const desc = extractFirstHeading(instructionsMd);
       domainFiles.push(formatPathRef(`_ai-context/${folderName}/core/instructions.md`, `${desc} (start here)`, agent));
     }
-    const coreDir = (0, import_path8.join)(domainPath, "core");
-    if ((0, import_fs8.existsSync)(coreDir)) {
+    const coreDir = (0, import_path9.join)(domainPath, "core");
+    if ((0, import_fs9.existsSync)(coreDir)) {
       const coreFiles = collectMdFiles(coreDir).filter((f) => f !== "instructions.md" && !f.startsWith("instructions/"));
       for (const file of coreFiles) {
-        const desc = extractFirstHeading((0, import_path8.join)(coreDir, file));
+        const desc = extractFirstHeading((0, import_path9.join)(coreDir, file));
         domainFiles.push(formatPathRef(`_ai-context/${folderName}/core/${file}`, desc, agent));
       }
     }
-    const refDir = (0, import_path8.join)(domainPath, "reference");
-    if ((0, import_fs8.existsSync)(refDir)) {
+    const refDir = (0, import_path9.join)(domainPath, "reference");
+    if ((0, import_fs9.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_path8.join)(refDir, file));
+          const desc = extractFirstHeading((0, import_path9.join)(refDir, file));
           domainFiles.push(formatPathRef(`_ai-context/${folderName}/reference/${file}`, desc, agent));
         }
       }
@@ -4516,7 +4675,7 @@ function buildMCPSection(mcpConfig) {
   return lines2.join("\n");
 }
 function buildCombinedInstructions(domains, mcpConfig, agent, projectPath) {
-  const contextsDir = (0, import_path8.join)(projectPath, "_ai-context");
+  const contextsDir = (0, import_path9.join)(projectPath, "_ai-context");
   const lines2 = [`# AI Development Instructions`, ``, `> Generated by One-Shot Installer`, ``];
   lines2.push(buildContextRefsSection(domains, agent, contextsDir));
   if (Object.keys(mcpConfig).length > 0) lines2.push(buildMCPSection(mcpConfig));
@@ -4524,8 +4683,8 @@ function buildCombinedInstructions(domains, mcpConfig, agent, projectPath) {
 }
 
 // src/steps/setup/write-mcp-config.ts
-var import_fs9 = require("fs");
-var import_path9 = require("path");
+var import_fs10 = require("fs");
+var import_path10 = require("path");
 var red2 = (text) => `\x1B[31m${text}\x1B[0m`;
 var write_mcp_config_default = defineStep({
   name: "write-mcp-config",
@@ -4534,15 +4693,15 @@ var write_mcp_config_default = defineStep({
   execute: async (ctx) => {
     const filteredMcpConfig = getFilteredMcpConfig(ctx);
     const target = getAgentTarget(ctx.config.agent);
-    const mcpJsonPath = (0, import_path9.join)(ctx.config.projectPath, target.mcpConfig);
+    const mcpJsonPath = (0, import_path10.join)(ctx.config.projectPath, target.mcpConfig);
     if (target.mcpDir) {
-      const dir = (0, import_path9.join)(ctx.config.projectPath, target.mcpDir);
-      if (!(0, import_fs9.existsSync)(dir)) (0, import_fs9.mkdirSync)(dir, { recursive: true });
+      const dir = (0, import_path10.join)(ctx.config.projectPath, target.mcpDir);
+      if (!(0, import_fs10.existsSync)(dir)) (0, import_fs10.mkdirSync)(dir, { recursive: true });
     }
     let existingFile = {};
-    if ((0, import_fs9.existsSync)(mcpJsonPath)) {
+    if ((0, import_fs10.existsSync)(mcpJsonPath)) {
       try {
-        existingFile = JSON.parse((0, import_fs9.readFileSync)(mcpJsonPath, "utf-8"));
+        existingFile = JSON.parse((0, import_fs10.readFileSync)(mcpJsonPath, "utf-8"));
       } catch {
         const box = [
           "",
@@ -4568,7 +4727,7 @@ var write_mcp_config_default = defineStep({
     }
     const mergedServers = { ...existingServers, ...newServers };
     const outputFile = { ...existingFile, [target.mcpRootKey]: mergedServers };
-    (0, import_fs9.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
+    (0, import_fs10.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
     ctx.installed.mcpServersAdded = addedServers;
     return {
       status: "success",
@@ -4637,7 +4796,7 @@ function isClaudeCliAvailable() {
 }
 
 // src/steps/setup/update-gitignore.ts
-var import_path10 = require("path");
+var import_path11 = require("path");
 var MARKER_START2 = "# one-shot-installer:start";
 var MARKER_END2 = "# one-shot-installer:end";
 var CORE_GITIGNORE_ENTRIES = [
@@ -4658,15 +4817,15 @@ var update_gitignore_default = defineStep({
   name: "update-gitignore",
   label: "Updating .gitignore",
   execute: async (ctx) => {
-    const gitignorePath = (0, import_path10.join)(ctx.config.projectPath, ".gitignore");
+    const gitignorePath = (0, import_path11.join)(ctx.config.projectPath, ".gitignore");
     upsertMarkerBlock(gitignorePath, MARKER_START2, MARKER_END2, CORE_GITIGNORE_ENTRIES.join("\n"));
     return { status: "success" };
   }
 });
 
 // src/steps/setup/write-state.ts
-var import_fs10 = require("fs");
-var import_path11 = require("path");
+var import_fs11 = require("fs");
+var import_path12 = require("path");
 var import_os2 = require("os");
 
 // package.json
@@ -4700,7 +4859,7 @@ var write_state_default = defineStep({
   name: "write-state",
   label: "Saving installation state",
   execute: async (ctx) => {
-    const statePath = (0, import_path11.join)(ctx.config.projectPath, ".one-shot-state.json");
+    const statePath = (0, import_path12.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))
@@ -4718,15 +4877,17 @@ var write_state_default = defineStep({
       mcpServers: mcpServersAdded,
       mcpConfigs: filteredMcpConfig,
       factoryInstalled: ctx.installed.factoryInstalled ?? false,
+      abapHooksInstalled: ctx.installed.abapHooksInstalled ?? false,
       files: {
         instructions: target.instructions,
         mcpConfig: target.mcpConfig,
         contexts: "_ai-context/",
         factory: ctx.installed.factoryInstalled ? "factory/" : null,
-        globalConfig: (0, import_path11.join)((0, import_os2.homedir)(), ".one-shot-installer")
+        abapHooks: ctx.installed.abapHooksInstalled ? ".claude/hooks/" : null,
+        globalConfig: (0, import_path12.join)((0, import_os2.homedir)(), ".one-shot-installer")
       }
     };
-    (0, import_fs10.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
+    (0, import_fs11.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
     return { status: "success" };
   }
 });
@@ -4741,19 +4902,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_fs11.existsSync)(filePath)) return green("create");
-  const content = (0, import_fs11.readFileSync)(filePath, "utf-8");
+  if (!(0, import_fs12.existsSync)(filePath)) return green("create");
+  const content = (0, import_fs12.readFileSync)(filePath, "utf-8");
   if (content.includes(markerStart)) return yellow("update");
   return yellow("append");
 }
 function detectMCPFileMode(filePath) {
-  if (!(0, import_fs11.existsSync)(filePath)) return green("create");
+  if (!(0, import_fs12.existsSync)(filePath)) return green("create");
   return yellow("merge");
 }
 function detectContextMode(projectPath, domain) {
-  const contextDir = (0, import_path12.join)(projectPath, "_ai-context", domain.toUpperCase());
-  const contextDirLower = (0, import_path12.join)(projectPath, "_ai-context", domain);
-  if ((0, import_fs11.existsSync)(contextDir) || (0, import_fs11.existsSync)(contextDirLower)) return yellow("overwrite");
+  const contextDir = (0, import_path13.join)(projectPath, "_ai-context", domain.toUpperCase());
+  const contextDirLower = (0, import_path13.join)(projectPath, "_ai-context", domain);
+  if ((0, import_fs12.existsSync)(contextDir) || (0, import_fs12.existsSync)(contextDirLower)) return yellow("overwrite");
   return green("create");
 }
 function waitForEnter() {
@@ -4771,10 +4932,11 @@ async function main() {
   try {
     const token = await getGitHubToken();
     console.log("  Locating repositories...");
-    const [repo, contextRepo, factoryRepo] = await Promise.all([
+    const [repo, contextRepo, factoryRepo, abapHooksRepo] = await Promise.all([
       discoverRepo(token),
       discoverRepo(token, "context-data").catch(() => null),
-      discoverRepo(token, "factory-data").catch(() => null)
+      discoverRepo(token, "factory-data").catch(() => null),
+      discoverRepo(token, "abap-mcp-hooks").catch(() => null)
     ]);
     if (!contextRepo) {
       console.log("  \u26A0  Context repo not found \u2014 AI contexts will not be installed.");
@@ -4782,9 +4944,12 @@ async function main() {
     if (!factoryRepo) {
       console.log("  \u26A0  Factory repo not found \u2014 Factory will not be installed.");
     }
+    if (!abapHooksRepo) {
+      console.log("  \u26A0  ABAP MCP hooks repo not found \u2014 hooks will not be installed.");
+    }
     console.log("  Loading configuration...");
     const options = await loadWizardOptions(token, repo);
-    const config = await collectInputs(options, options.releaseVersion, !!factoryRepo);
+    const config = await collectInputs(options, options.releaseVersion, !!factoryRepo, !!abapHooksRepo);
     if (!config) {
       await waitForEnter();
       return;
@@ -4801,6 +4966,7 @@ async function main() {
       repo,
       contextRepo,
       factoryRepo,
+      abapHooksRepo,
       installed: {}
     };
     const stepList = Object.values(steps_exports);
@@ -4813,7 +4979,7 @@ async function main() {
     await waitForEnter();
   }
 }
-async function collectInputs(options, releaseVersion, factoryAvailable = false) {
+async function collectInputs(options, releaseVersion, factoryAvailable = false, abapHooksAvailable = false) {
   const selectedIds = await esm_default2({
     message: "Technology:",
     instructions: "  Space to select  \xB7  Enter to confirm",
@@ -4851,17 +5017,20 @@ async function collectInputs(options, releaseVersion, factoryAvailable = false)
   }
   const projectInput = await esm_default4({
     message: "Project directory:",
-    default: (0, import_path12.resolve)(process.cwd())
+    default: (0, import_path13.resolve)(process.cwd())
   });
+  const isAbapSelected = selectedTechnologies.some((t) => t.domains.includes("ABAP"));
+  const installAbapHooks = abapHooksAvailable && agent === "claude-code" && isAbapSelected;
   return {
     technologies: selectedTechnologies,
     agent,
     azureDevOpsOrg,
-    projectPath: (0, import_path12.resolve)(projectInput),
+    projectPath: (0, import_path13.resolve)(projectInput),
     baseMcpServers: options.baseMcpServers,
     mcpConfig,
     releaseVersion,
-    installFactory: factoryAvailable
+    installFactory: factoryAvailable,
+    installAbapHooks
   };
 }
 async function previewAndConfirm(config, options) {
@@ -4871,9 +5040,9 @@ async function previewAndConfirm(config, options) {
   const instructionFile = target.instructions;
   const mcpConfigFile = target.mcpConfig;
   const serverEntries = Object.entries(config.mcpConfig);
-  const instructionFilePath = (0, import_path12.join)(config.projectPath, instructionFile);
-  const mcpConfigFilePath = (0, import_path12.join)(config.projectPath, mcpConfigFile);
-  const gitignorePath = (0, import_path12.join)(config.projectPath, ".gitignore");
+  const instructionFilePath = (0, import_path13.join)(config.projectPath, instructionFile);
+  const mcpConfigFilePath = (0, import_path13.join)(config.projectPath, mcpConfigFile);
+  const gitignorePath = (0, import_path13.join)(config.projectPath, ".gitignore");
   const instructionMode = detectMarkerFileMode(instructionFilePath, "<!-- one-shot-installer:start -->");
   const mcpMode = detectMCPFileMode(mcpConfigFilePath);
   const gitignoreMode = detectMarkerFileMode(gitignorePath, "# one-shot-installer:start");
@@ -4888,6 +5057,7 @@ async function previewAndConfirm(config, options) {
   console.log(`  Technology   ${technologyNames}`);
   console.log(`  Tool         ${agentDisplay}`);
   console.log(`  Factory      ${config.installFactory ? "yes" : "no"}`);
+  console.log(`  ABAP hooks   ${config.installAbapHooks ? "yes" : "no"}`);
   console.log(`  Directory    ${config.projectPath}`);
   console.log("");
   console.log(`  ${dim("File actions:")}`);
@@ -4899,10 +5069,15 @@ 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_fs11.existsSync)((0, import_path12.join)(config.projectPath, "factory"));
+    const factoryExists = (0, import_fs12.existsSync)((0, import_path13.join)(config.projectPath, "factory"));
     const factoryMode = factoryExists ? yellow("overwrite") : green("create");
     console.log(`    ${"factory/".padEnd(domainColWidth + 14)}${factoryMode}`);
   }
+  if (config.installAbapHooks) {
+    const hooksDir = (0, import_path13.join)(config.projectPath, ".claude", "hooks");
+    const hooksMode = (0, import_fs12.existsSync)(hooksDir) ? yellow("merge") : green("create");
+    console.log(`    ${".claude/hooks/".padEnd(domainColWidth + 14)}${hooksMode}`);
+  }
   if (serverEntries.length > 0) {
     console.log("");
     console.log(`  ${dim("MCP servers:")}`);

package/package.json

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