dlw-machine-setup 0.6.2 → 0.8.0

package/bin/installer.js

@@ -3850,7 +3850,7 @@ var import_fs6 = require("fs");
 var import_path6 = require("path");
 
 // src/bundles/types.ts
-var SCHEMA_VERSION = 1;
+var SUPPORTED_SCHEMA_VERSIONS = [1, 2];
 
 // src/utils/marker-block.ts
 var import_fs5 = require("fs");
@@ -3881,11 +3881,99 @@ ${endMarker}`;
   }
 }
 
+// src/profiles/claude-code.ts
+var claudeCodeProfile = {
+  agent: "claude-code",
+  instructionsFile: "CLAUDE.md",
+  handlers: {
+    agent: {
+      supported: true,
+      destination: (name) => `.claude/agents/${name}.md`
+    },
+    skill: {
+      supported: true,
+      // Claude reads skills from a folder per skill: `.claude/skills/<name>/SKILL.md`.
+      destination: (name) => `.claude/skills/${name}/SKILL.md`
+    },
+    hook: {
+      supported: true,
+      configFile: ".claude/settings.json",
+      configKey: "hooks",
+      scriptDir: ".claude/hooks"
+    },
+    "instructions-snippet": {
+      supported: true
+    }
+  }
+};
+
+// src/profiles/github-copilot.ts
+var githubCopilotProfile = {
+  agent: "github-copilot",
+  instructionsFile: ".github/copilot-instructions.md",
+  handlers: {
+    agent: {
+      supported: true,
+      destination: (name) => `.github/agents/${name}.agent.md`
+    },
+    skill: {
+      supported: true,
+      destination: (name) => `.github/skills/${name}/SKILL.md`
+    },
+    hook: {
+      // See header docblock for the three HookHandler extensions needed
+      // to flip this on. Until then, hook assets are skipped on Copilot.
+      supported: false
+    },
+    "instructions-snippet": {
+      supported: true
+    }
+  }
+};
+
+// src/profiles/cursor.ts
+var cursorProfile = {
+  agent: "cursor",
+  instructionsFile: ".cursor/rules/instructions.mdc",
+  handlers: {
+    agent: { supported: false },
+    skill: { supported: false },
+    hook: { supported: false },
+    "instructions-snippet": { supported: true }
+  }
+};
+
+// src/profiles/index.ts
+var PROFILES = {
+  "claude-code": claudeCodeProfile,
+  "github-copilot": githubCopilotProfile,
+  "cursor": cursorProfile
+};
+function getProfile(agent) {
+  const profile = PROFILES[agent];
+  if (!profile) {
+    const known = Object.keys(PROFILES).map((k) => `"${k}"`).join(", ");
+    throw new Error(
+      `No profile registered for agent "${agent}". Known agents: ${known}. Add src/profiles/${agent}.ts and register it in src/profiles/index.ts.`
+    );
+  }
+  return profile;
+}
+
 // src/bundles/run-bundle.ts
 var OWNER_KEY = "_bundleOwner";
 async function runBundle(manifest, ctx) {
   assertSchemaCompatible(manifest);
+  assertNameValid(manifest);
   assertBundleRootExists(ctx);
+  switch (manifest.schemaVersion) {
+    case 1:
+      return runBundleV1(manifest, ctx);
+    case 2:
+      return runBundleV2(manifest, ctx);
+  }
+}
+function runBundleV1(manifest, ctx) {
   const result = {
     name: manifest.name,
     opsExecuted: 0,
@@ -3896,30 +3984,120 @@ async function runBundle(manifest, ctx) {
     executeOp(op, manifest.name, ctx, result);
     result.opsExecuted++;
   }
-  if (manifest.gitignore?.length) {
-    upsertMarkerBlock(
-      (0, import_path6.join)(ctx.projectPath, ".gitignore"),
-      `# ${manifest.name}:start`,
-      `# ${manifest.name}:end`,
-      manifest.gitignore.join("\n")
-    );
-    result.filesTouched.push(".gitignore");
-  }
+  writeGitignoreBlock(manifest, ctx, result);
   const snippet = manifest.instructions?.[ctx.agent];
   if (snippet) {
     result.instructionsSnippet = snippet;
-    if (!ctx.skipInstructions) {
-      upsertMarkerBlock(
-        (0, import_path6.join)(ctx.projectPath, ctx.instructionsFile),
-        `<!-- ${manifest.name}:start -->`,
-        `<!-- ${manifest.name}:end -->`,
-        snippet
-      );
-      result.filesTouched.push(ctx.instructionsFile);
-    }
+    writeInstructionsBlock(manifest.name, snippet, ctx.instructionsFile, ctx, result);
+  }
+  return result;
+}
+function runBundleV2(manifest, ctx) {
+  const profile = getProfile(ctx.agent);
+  const result = {
+    name: manifest.name,
+    opsExecuted: 0,
+    filesTouched: []
+  };
+  const hookPatches = /* @__PURE__ */ new Map();
+  for (const asset of manifest.assets ?? []) {
+    runAsset(asset, profile, hookPatches, ctx, result);
+    result.opsExecuted++;
+  }
+  for (const [file, patch] of hookPatches) {
+    runMergeJson({ op: "merge-json", file, patch }, manifest.name, ctx, result);
+  }
+  for (const op of manifest.ops ?? []) {
+    executeOp(op, manifest.name, ctx, result);
+    result.opsExecuted++;
+  }
+  writeGitignoreBlock(manifest, ctx, result);
+  const snippet = result.instructionsSnippet;
+  if (snippet) {
+    const instructionsFile = profile.instructionsFile || ctx.instructionsFile;
+    writeInstructionsBlock(manifest.name, snippet, instructionsFile, ctx, result);
   }
   return result;
 }
+function runAsset(asset, profile, hookPatches, ctx, result) {
+  switch (asset.type) {
+    case "agent":
+      runAssetCopy(asset, profile.handlers.agent, ctx, result);
+      return;
+    case "skill":
+      runAssetCopy(asset, profile.handlers.skill, ctx, result);
+      return;
+    case "hook":
+      accumulateHook(asset, profile.handlers.hook, hookPatches, ctx, result);
+      return;
+    case "instructions-snippet":
+      if (profile.handlers["instructions-snippet"].supported) {
+        result.instructionsSnippet = asset.content;
+      }
+      return;
+  }
+}
+function runAssetCopy(asset, handler, ctx, result) {
+  if (!handler.supported || !handler.destination) return;
+  const source = resolveBundlePath(asset.source, ctx);
+  if (!(0, import_fs6.existsSync)(source)) return;
+  const target = resolveProjectPath(handler.destination(asset.name), ctx);
+  if ((0, import_fs6.statSync)(source).isDirectory()) {
+    copyDirectory(source, target);
+  } else {
+    (0, import_fs6.mkdirSync)((0, import_path6.dirname)(target), { recursive: true });
+    (0, import_fs6.copyFileSync)(source, target);
+  }
+  result.filesTouched.push(handler.destination(asset.name));
+}
+function accumulateHook(asset, handler, hookPatches, ctx, result) {
+  if (!handler.supported) return;
+  if (!handler.configFile || !handler.configKey) return;
+  if (asset.script && handler.scriptDir) {
+    const scriptSource = resolveBundlePath(asset.script, ctx);
+    if ((0, import_fs6.existsSync)(scriptSource)) {
+      const scriptName = (0, import_path6.basename)(asset.script);
+      const scriptRelDest = `${handler.scriptDir}/${scriptName}`;
+      const scriptDest = resolveProjectPath(scriptRelDest, ctx);
+      (0, import_fs6.mkdirSync)((0, import_path6.dirname)(scriptDest), { recursive: true });
+      (0, import_fs6.copyFileSync)(scriptSource, scriptDest);
+      result.filesTouched.push(scriptRelDest);
+    }
+  }
+  const command = handler.scriptDir ? asset.command.replace(/\{hookDir\}/g, handler.scriptDir) : asset.command;
+  const entry = {
+    hooks: [{ type: "command", command }]
+  };
+  if (asset.matcher) entry.matcher = asset.matcher;
+  let patch = hookPatches.get(handler.configFile);
+  if (!patch) {
+    patch = {};
+    hookPatches.set(handler.configFile, patch);
+  }
+  const root = patch[handler.configKey] ??= {};
+  const events = root[asset.event] ??= [];
+  events.push(entry);
+}
+function writeGitignoreBlock(manifest, ctx, result) {
+  if (!manifest.gitignore?.length) return;
+  upsertMarkerBlock(
+    (0, import_path6.join)(ctx.projectPath, ".gitignore"),
+    `# ${manifest.name}:start`,
+    `# ${manifest.name}:end`,
+    manifest.gitignore.join("\n")
+  );
+  result.filesTouched.push(".gitignore");
+}
+function writeInstructionsBlock(bundleName, snippet, instructionsFile, ctx, result) {
+  if (ctx.skipInstructions) return;
+  upsertMarkerBlock(
+    (0, import_path6.join)(ctx.projectPath, instructionsFile),
+    `<!-- ${bundleName}:start -->`,
+    `<!-- ${bundleName}:end -->`,
+    snippet
+  );
+  result.filesTouched.push(instructionsFile);
+}
 function executeOp(op, owner, ctx, result) {
   switch (op.op) {
     case "copy":
@@ -4021,11 +4199,14 @@ function resolveProjectPath(rel, ctx) {
   return full;
 }
 function assertSchemaCompatible(manifest) {
-  if (manifest.schemaVersion !== SCHEMA_VERSION) {
+  if (!SUPPORTED_SCHEMA_VERSIONS.includes(manifest.schemaVersion)) {
+    const supported = SUPPORTED_SCHEMA_VERSIONS.join(", ");
     throw new Error(
-      `Bundle "${manifest.name}" declares schemaVersion ${manifest.schemaVersion}, installer supports ${SCHEMA_VERSION}. Upgrade the installer or re-pin the bundle.`
+      `Bundle "${manifest.name}" declares schemaVersion ${manifest.schemaVersion}, installer supports ${supported}. Upgrade the installer or re-pin the bundle.`
     );
   }
+}
+function assertNameValid(manifest) {
   if (!manifest.name || !/^[a-z][a-z0-9-]*$/.test(manifest.name)) {
     throw new Error(
       `Bundle name must match /^[a-z][a-z0-9-]*$/: got "${manifest.name}"`
@@ -4039,14 +4220,8 @@ function assertBundleRootExists(ctx) {
 }
 
 // src/steps/resources/fetch-factory.ts
-function getFactoryAsset(agent) {
-  switch (agent) {
-    case "github-copilot":
-      return { assetName: "factory-copilot.tar.gz", rootFolder: "factory-copilot" };
-    default:
-      return { assetName: "factory.tar.gz", rootFolder: "factory" };
-  }
-}
+var FACTORY_ASSET_NAME = "factory.tar.gz";
+var FACTORY_ROOT_FOLDER = "factory";
 var fetch_factory_default = defineStep({
   name: "fetch-factory",
   label: "Installing Factory framework",
@@ -4065,7 +4240,6 @@ var fetch_factory_default = defineStep({
 });
 async function fetchFactory(token, repo, targetDir, agent) {
   const result = { success: false, filesInstalled: [] };
-  const { assetName, rootFolder } = getFactoryAsset(agent);
   let release;
   try {
     release = await fetchLatestRelease(token, repo);
@@ -4073,18 +4247,18 @@ async function fetchFactory(token, repo, targetDir, agent) {
     result.failureReason = err instanceof Error ? err.message : String(err);
     return result;
   }
-  const asset = release.assets.find((a) => a.name === assetName);
+  const asset = release.assets.find((a) => a.name === FACTORY_ASSET_NAME);
   if (!asset) {
-    result.failureReason = `${assetName} not found in release`;
+    result.failureReason = `${FACTORY_ASSET_NAME} not found in release`;
     return result;
   }
   let archive = null;
   try {
     archive = await downloadAndExtractAsset(token, asset, targetDir, ".temp-factory-download");
     const extractedEntries = (0, import_fs7.readdirSync)(archive.extractedRoot);
-    const extractedFolder = extractedEntries.find((e) => e.toLowerCase() === rootFolder.toLowerCase());
+    const extractedFolder = extractedEntries.find((e) => e.toLowerCase() === FACTORY_ROOT_FOLDER.toLowerCase());
     if (!extractedFolder) {
-      result.failureReason = `No ${rootFolder}/ folder in archive`;
+      result.failureReason = `No ${FACTORY_ROOT_FOLDER}/ folder in archive`;
       return result;
     }
     const extractedPath = (0, import_path7.join)(archive.extractedRoot, extractedFolder);
@@ -4219,8 +4393,8 @@ function extractFirstHeading(filePath) {
     }
   } catch {
   }
-  const basename = filePath.split(/[/\\]/).pop() ?? "";
-  return basename.replace(/\.md$/i, "").replace(/[-_]+/g, " ");
+  const basename2 = filePath.split(/[/\\]/).pop() ?? "";
+  return basename2.replace(/\.md$/i, "").replace(/[-_]+/g, " ");
 }
 function formatPathRef(contextPath, description, agent) {
   if (agent === "github-copilot") {
@@ -4471,6 +4645,7 @@ var package_default = {
   scripts: {
     dev: "tsx src/index.ts",
     build: 'esbuild src/index.ts --bundle --platform=node --banner:js="#!/usr/bin/env node" --outfile=wrapper/bin/installer.js',
+    "build:all": "npm run build",
     "publish:wrapper": "cd wrapper && npm publish"
   },
   dependencies: {

package/package.json

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