delegation-layer 0.1.28 → 0.1.29

package/scripts/install-cli.mjs

@@ -1,77 +1,37 @@
 #!/usr/bin/env node
 
 import { spawn } from "node:child_process";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const installerPath = join(packageRoot, "install.sh");
-
-function usage(message) {
-  if (message) {
-    console.error(`Error: ${message}`);
-  }
-  console.error(
-    "Usage: delegation-layer install-cli [--version VERSION] [--install-dir ABSOLUTE_DIR]",
-  );
-}
-
-function parseArguments(argumentsList) {
-  let version;
-  let installDir;
-
-  for (let index = 0; index < argumentsList.length; index += 1) {
-    const argument = argumentsList[index];
-    if (argument === "--version") {
-      version = argumentsList[index + 1];
-      index += 1;
-      if (!version) {
-        throw new Error("--version requires a value");
-      }
-      continue;
-    }
-    if (argument === "--install-dir") {
-      installDir = argumentsList[index + 1];
-      index += 1;
-      if (!installDir) {
-        throw new Error("--install-dir requires a value");
-      }
-      if (!isAbsolute(installDir)) {
-        throw new Error("--install-dir must be an absolute path");
-      }
-      continue;
-    }
-    if (argument === "--help" || argument === "-h") {
-      usage();
-      return null;
-    }
-    throw new Error(`unknown argument ${argument}`);
-  }
-
-  if (process.platform === "win32") {
-    throw new Error("the release installer supports Linux and macOS only");
-  }
-
-  return { installDir: installDir ? resolve(installDir) : undefined, version };
-}
-
-export function main(argumentsList) {
-  const options = parseArguments(argumentsList);
-  if (!options) {
-    return Promise.resolve();
+import { join } from "node:path";
+import { parseInstallCliArguments } from "./installer/arguments.mjs";
+
+const usageText = "Usage: delegation-layer install-cli [--version VERSION] [--install-dir ABSOLUTE_DIR]";
+
+export async function main(argumentsList, {
+  packageRoot,
+  environment = process.env,
+  platform = process.platform,
+  spawnProcess = spawn,
+  errorOutput = process.stderr,
+} = {}) {
+  const parsed = parseInstallCliArguments(argumentsList, { platform });
+  if (parsed.kind === "error") throw new Error(parsed.message);
+  if (parsed.kind === "help") {
+    errorOutput.write(`${usageText}\n`);
+    return;
   }
+  if (!packageRoot) throw new Error("install-cli requires a package root");
 
-  const environment = { ...process.env };
-  if (options.version) {
-    environment.DELEGATION_LAYER_VERSION = options.version;
+  const childEnvironment = { ...environment };
+  if (parsed.options.version) {
+    childEnvironment.DELEGATION_LAYER_VERSION = parsed.options.version;
   }
-  if (options.installDir) {
-    environment.DELEGATION_LAYER_INSTALL_DIR = options.installDir;
+  if (parsed.options.installDir) {
+    childEnvironment.DELEGATION_LAYER_INSTALL_DIR = parsed.options.installDir;
   }
 
-  return new Promise((resolvePromise, reject) => {
-    const child = spawn("sh", [installerPath], {
-      env: environment,
+  await new Promise((resolvePromise, reject) => {
+    const child = spawnProcess("sh", [join(packageRoot, "install.sh")], {
+      env: childEnvironment,
       stdio: "inherit",
     });
     child.on("error", reject);

package/scripts/installer/application.mjs

@@ -0,0 +1,250 @@
+import { join } from "node:path";
+import { harnesses } from "./catalog.mjs";
+import { parseInstallArguments, parseLegacyArguments } from "./arguments.mjs";
+import { detectHarnesses } from "./detection.mjs";
+import { validateSkillSource } from "./filesystem.mjs";
+import { installSkill } from "./skill-store.mjs";
+import { defaultHarnessNames, formatDetected, resolveInstallSelection, targetFor } from "./selection.mjs";
+import { pickOptions } from "./terminal.mjs";
+import { applyRouting, prepareRouting, printRouting } from "./routing-store.mjs";
+
+const usageText = "Usage:\n  delegation-layer install [--scope project|global] [--harness NAME[,NAME...]] [--yes] [--force] [--routing default|skill-only]\n  delegation-layer routing status|disable [--scope project|global] [--harness NAME[,NAME...]]\n  delegation-layer --target ABSOLUTE_SKILL_DIR [--force]\n  delegation-layer install-cli [--version VERSION] [--install-dir ABSOLUTE_DIR]";
+const helpText = `${usageText}\n\nThe install command detects supported agent harnesses and installs the skill for a project or user.\nGlobal scope is the default; use --scope project for a project-local install.\nUse --harness universal when no specific harness is detected.`;
+
+function isFailure(value) {
+  return value.kind === "error";
+}
+
+function printUsage(errorOutput, message) {
+  if (message) errorOutput.write(`Error: ${message}\n`);
+  errorOutput.write(`${usageText}\n`);
+}
+
+function printDetections(detections, report) {
+  report("Detected harnesses:");
+  detections.forEach(({ harness, reasons }, index) => {
+    report(`  ${index + 1}. ${harness.label}${formatDetected(reasons)}`);
+  });
+}
+
+async function chooseInstallOptions({
+  force,
+  harnessNames,
+  scope,
+  yes,
+  routing,
+  cwd,
+  home,
+  environment,
+  platform,
+  input,
+  output,
+  report,
+}) {
+  const detections = await detectHarnesses({ cwd, home, path: environment.PATH ?? "", platform });
+  const defaults = defaultHarnessNames(detections);
+  const canPrompt = Boolean(input.isTTY && output.isTTY);
+  const needsPrompt = !yes && !harnessNames && !scope && canPrompt;
+
+  if (!harnessNames && !needsPrompt) printDetections(detections, report);
+  if (!canPrompt && !yes && !harnessNames && !scope) {
+    report("No interactive terminal detected; using global scope and detected harnesses.");
+  }
+
+  if (needsPrompt) {
+    scope = await pickOptions({
+      initialValues: ["global"],
+      options: [
+        { value: "global", label: "Global", description: `available to your agents from ${home}` },
+        { value: "project", label: "Project", description: `available to this project from ${cwd}` },
+      ],
+      title: "Where should the agent skill be installed?",
+      input,
+      output,
+    });
+    if (!scope) return null;
+    harnessNames = await pickOptions({
+      initialValues: defaults,
+      multiple: true,
+      options: detections.map(({ harness, reasons }) => ({
+        value: harness.name,
+        label: `${harness.label}${formatDetected(reasons)}`,
+        description: targetFor(harness, scope, cwd, home, environment),
+      })),
+      title: "Which harnesses should use the skill?",
+      input,
+      output,
+    });
+    if (!harnessNames) return null;
+  }
+
+  if (needsPrompt && !routing) {
+    routing = await pickOptions({
+      initialValues: ["default"],
+      options: [
+        {
+          value: "default",
+          label: "Prefer Delegate",
+          description: "Install collaboration context hooks for Claude and Codex; native hook trust still applies",
+        },
+        {
+          value: "skill-only",
+          label: "Skill only",
+          description: "Install guidance without adding hooks; keep existing routing settings",
+        },
+      ],
+      title: "How should external collaboration be routed?",
+      input,
+      output,
+    });
+    if (!routing) return null;
+  }
+
+  return resolveInstallSelection({ force, harnessNames, scope, routing, cwd, home, detections });
+}
+
+function parseResult(parsed, errorOutput, output) {
+  if (parsed.kind === "help") {
+    output.write(`${helpText}\n`);
+    return 0;
+  }
+  if (isFailure(parsed)) {
+    printUsage(errorOutput, parsed.message);
+    return 2;
+  }
+  return null;
+}
+
+export async function runInstaller({
+  argumentsList,
+  packageRoot,
+  cwd,
+  home,
+  resolveHome,
+  environment,
+  platform,
+  input,
+  output,
+  errorOutput,
+  installCliMain,
+}) {
+  const report = (message) => output.write(`${message}\n`);
+  const reportError = (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    errorOutput.write(`Error: ${message}\n`);
+  };
+  const sourceDirectory = join(packageRoot, "skills", "agent-integration");
+
+  try {
+    await validateSkillSource(sourceDirectory);
+  } catch (error) {
+    reportError(error);
+    return 1;
+  }
+
+  if (argumentsList[0] === "install-cli") {
+    try {
+      await installCliMain(argumentsList.slice(1), { packageRoot, environment, platform });
+      return 0;
+    } catch (error) {
+      reportError(error);
+      return 1;
+    }
+  }
+
+  if (argumentsList[0] === "routing") {
+    const action = argumentsList[1];
+    const parsed = parseInstallArguments(argumentsList.slice(2));
+    const parseExit = parseResult(parsed, errorOutput, output);
+    if (parseExit !== null) return parseExit;
+    if (!["status", "disable"].includes(action)) {
+      printUsage(errorOutput, "routing requires status or disable");
+      return 2;
+    }
+    const options = parsed.options;
+    try {
+      if (options.routing || options.force) {
+        throw new Error("routing status/disable do not accept --routing or --force");
+      }
+      const selected = await chooseInstallOptions({
+        ...options,
+        yes: true,
+        harnessNames: options.harnessNames ?? ["claude", "codex"],
+        cwd,
+        home: home ?? resolveHome(),
+        environment,
+        platform,
+        input,
+        output,
+        report,
+      });
+      const plans = await prepareRouting(selected, action, { environment, platform, sourceDirectory });
+      if (action === "disable") await applyRouting(plans);
+      for (const plan of plans) printRouting(plan, action, report);
+      return 0;
+    } catch (error) {
+      reportError(error);
+      return 1;
+    }
+  }
+
+  if (argumentsList[0] === "install") {
+    const parsed = parseInstallArguments(argumentsList.slice(1));
+    const parseExit = parseResult(parsed, errorOutput, output);
+    if (parseExit !== null) return parseExit;
+    try {
+      const selected = await chooseInstallOptions({
+        ...parsed.options,
+        cwd,
+        home: home ?? resolveHome(),
+        environment,
+        platform,
+        input,
+        output,
+        report,
+      });
+      if (!selected) {
+        report("Installation cancelled.");
+        return 0;
+      }
+      const routingPlans = selected.routing === "default"
+        ? await prepareRouting(selected, "enable", { environment, platform, sourceDirectory })
+        : [];
+      const targets = selected.harnessNames.map((name) => {
+        const harness = harnesses.find((candidate) => candidate.name === name);
+        if (!harness) throw new Error(`cannot install for unknown harness: ${name}`);
+        return targetFor(harness, selected.scope, selected.cwd, selected.home, environment);
+      });
+      const uniqueTargets = [...new Set(targets)];
+      report(`Installing for ${selected.scope}: ${uniqueTargets.join(", ")}`);
+      for (const target of uniqueTargets) {
+        await installSkill({ force: selected.force, sourceDirectory, target, report });
+      }
+      await applyRouting(routingPlans);
+      for (const plan of routingPlans) printRouting(plan, "enable", report);
+      if (selected.routing === "skill-only") {
+        report("Skill-only installation; existing routing settings were not changed.");
+      }
+      return 0;
+    } catch (error) {
+      reportError(error);
+      return 1;
+    }
+  }
+
+  const parsed = parseLegacyArguments(argumentsList);
+  const parseExit = parseResult(parsed, errorOutput, output);
+  if (parseExit !== null) return parseExit;
+  try {
+    await installSkill({
+      force: parsed.options.force,
+      sourceDirectory,
+      target: parsed.options.target,
+      report,
+    });
+    return 0;
+  } catch (error) {
+    reportError(error);
+    return 1;
+  }
+}

package/scripts/installer/arguments.mjs

@@ -0,0 +1,123 @@
+import { isAbsolute } from "node:path";
+import { harnesses, isHarnessName } from "./catalog.mjs";
+import { normalizeAbsolute } from "./paths.mjs";
+
+function error(message) {
+  return { kind: "error", message };
+}
+
+function requiredValue(argumentsList, index) {
+  const value = argumentsList[index + 1];
+  return value && !value.startsWith("--") ? value : null;
+}
+
+export function parseLegacyArguments(argumentsList) {
+  let target;
+  let force = false;
+
+  for (let index = 0; index < argumentsList.length; index += 1) {
+    const argument = argumentsList[index];
+    if (argument === "--force") {
+      force = true;
+      continue;
+    }
+    if (argument === "--target") {
+      target = requiredValue(argumentsList, index);
+      if (!target) return error("--target requires a value");
+      index += 1;
+      continue;
+    }
+    if (argument === "--help" || argument === "-h") {
+      return { kind: "help" };
+    }
+    return error(`unknown argument ${argument}`);
+  }
+
+  if (!target) return error("--target is required");
+  if (!isAbsolute(target)) return error("--target must be an absolute path");
+  return { kind: "options", options: { force, target: normalizeAbsolute(target) } };
+}
+
+export function parseInstallArguments(argumentsList) {
+  let force = false;
+  let harnessNames;
+  let scope;
+  let yes = false;
+  let routing;
+
+  for (let index = 0; index < argumentsList.length; index += 1) {
+    const argument = argumentsList[index];
+    if (argument === "--force") {
+      force = true;
+      continue;
+    }
+    if (argument === "--yes" || argument === "-y") {
+      yes = true;
+      continue;
+    }
+    if (["--routing", "--scope", "--harness"].includes(argument)) {
+      const value = requiredValue(argumentsList, index);
+      if (!value) return error(`${argument} requires a value`);
+      if (argument === "--routing") routing = value;
+      if (argument === "--scope") scope = value;
+      if (argument === "--harness") {
+        harnessNames = value.split(",").map((name) => name.trim().toLowerCase());
+      }
+      index += 1;
+      continue;
+    }
+    if (argument === "--help" || argument === "-h") {
+      return { kind: "help" };
+    }
+    return error(`unknown argument ${argument}`);
+  }
+
+  if (scope && scope !== "project" && scope !== "global") {
+    return error("--scope must be project or global");
+  }
+  if (harnessNames?.length === 0 || harnessNames?.some((name) => !name)) {
+    return error("--harness requires at least one harness name");
+  }
+  const unknownHarness = harnessNames?.find((name) => !isHarnessName(name));
+  if (unknownHarness) {
+    return error(`unknown harness ${unknownHarness}; choose from ${harnesses.map((harness) => harness.name).join(", ")}`);
+  }
+  if (routing && !["default", "skill-only"].includes(routing)) {
+    return error("--routing must be default or skill-only");
+  }
+  return { kind: "options", options: { force, harnessNames, scope, yes, routing } };
+}
+
+export function parseInstallCliArguments(argumentsList, { platform }) {
+  let version;
+  let installDir;
+
+  for (let index = 0; index < argumentsList.length; index += 1) {
+    const argument = argumentsList[index];
+    if (argument === "--version") {
+      version = argumentsList[index + 1];
+      index += 1;
+      if (!version) return error("--version requires a value");
+      continue;
+    }
+    if (argument === "--install-dir") {
+      installDir = argumentsList[index + 1];
+      index += 1;
+      if (!installDir) return error("--install-dir requires a value");
+      if (!isAbsolute(installDir)) return error("--install-dir must be an absolute path");
+      continue;
+    }
+    if (argument === "--help" || argument === "-h") {
+      return { kind: "help" };
+    }
+    return error(`unknown argument ${argument}`);
+  }
+
+  if (platform === "win32") {
+    return error("the release installer supports Linux and macOS only");
+  }
+  return {
+    kind: "options",
+    options: { installDir: installDir ? normalizeAbsolute(installDir) : undefined, version },
+  };
+}

package/scripts/installer/catalog.mjs

@@ -0,0 +1,95 @@
+function freezeHarness(harness) {
+  return Object.freeze({
+    ...harness,
+    projectPath: Object.freeze(harness.projectPath),
+    globalPath: Object.freeze(harness.globalPath),
+    projectMarkers: Object.freeze(harness.projectMarkers.map((marker) => Object.freeze(marker))),
+    globalMarkers: Object.freeze(harness.globalMarkers.map((marker) => Object.freeze(marker))),
+    commands: Object.freeze(harness.commands),
+  });
+}
+
+export const harnesses = Object.freeze([
+  freezeHarness({
+    name: "universal",
+    label: "Universal Agent Skills",
+    projectPath: [".agents", "skills"],
+    globalPath: [".agents", "skills"],
+    projectMarkers: [[".agents"]],
+    globalMarkers: [[".agents"]],
+    commands: [],
+  }),
+  freezeHarness({
+    name: "codex",
+    label: "Codex",
+    projectPath: [".agents", "skills"],
+    globalPath: [".agents", "skills"],
+    projectMarkers: [[".agents"], [".codex"]],
+    globalMarkers: [[".agents"], [".codex"]],
+    commands: ["codex"],
+  }),
+  freezeHarness({
+    name: "claude",
+    label: "Claude Code",
+    projectPath: [".claude", "skills"],
+    globalPath: [".claude", "skills"],
+    projectMarkers: [[".claude"]],
+    globalMarkers: [[".claude"]],
+    commands: ["claude"],
+  }),
+  freezeHarness({
+    name: "cursor",
+    label: "Cursor",
+    projectPath: [".cursor", "skills"],
+    globalPath: [".cursor", "skills"],
+    projectMarkers: [[".cursor"]],
+    globalMarkers: [[".cursor"]],
+    commands: ["cursor"],
+  }),
+  freezeHarness({
+    name: "gemini",
+    label: "Gemini CLI",
+    projectPath: [".gemini", "skills"],
+    globalPath: [".gemini", "skills"],
+    projectMarkers: [[".gemini"]],
+    globalMarkers: [[".gemini"]],
+    commands: ["gemini"],
+  }),
+  freezeHarness({
+    name: "opencode",
+    label: "OpenCode",
+    projectPath: [".opencode", "skills"],
+    globalPath: [".config", "opencode", "skills"],
+    projectMarkers: [[".opencode"]],
+    globalMarkers: [[".config", "opencode"]],
+    commands: ["opencode"],
+  }),
+  freezeHarness({
+    name: "pi",
+    label: "Pi",
+    projectPath: [".pi", "skills"],
+    globalPath: [".pi", "agent", "skills"],
+    projectMarkers: [[".pi"]],
+    globalMarkers: [[".pi", "agent"]],
+    commands: ["pi"],
+  }),
+  freezeHarness({
+    name: "hermes",
+    label: "Hermes",
+    projectPath: [".hermes", "skills"],
+    globalPath: [".hermes", "skills"],
+    projectMarkers: [[".hermes"]],
+    globalMarkers: [[".hermes"]],
+    commands: ["hermes"],
+  }),
+]);
+
+const harnessesByName = new Map(harnesses.map((harness) => [harness.name, harness]));
+
+export function getHarness(name) {
+  return harnessesByName.get(name) ?? null;
+}
+
+export function isHarnessName(name) {
+  return harnessesByName.has(name);
+}

package/scripts/installer/detection.mjs

@@ -0,0 +1,41 @@
+import { accessSync, constants } from "node:fs";
+import { delimiter, join } from "node:path";
+import { harnesses } from "./catalog.mjs";
+import { existingPath } from "./filesystem.mjs";
+
+function executableOnPath(command, path, platform) {
+  const candidates = platform === "win32" ? [command, `${command}.exe`, `${command}.cmd`] : [command];
+  return path.split(delimiter).filter(Boolean).some((pathEntry) => candidates.some((candidate) => {
+    try {
+      accessSync(join(pathEntry, candidate), constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }));
+}
+
+export async function detectHarnesses({ cwd, home, path = "", platform = process.platform }) {
+  return Promise.all(harnesses.map(async (harness) => {
+    const reasons = [];
+    for (const marker of harness.projectMarkers) {
+      if ((await existingPath(join(cwd, ...marker)))?.isDirectory()) {
+        reasons.push(`project ${join(...marker)}`);
+        break;
+      }
+    }
+    for (const marker of harness.globalMarkers) {
+      if ((await existingPath(join(home, ...marker)))?.isDirectory()) {
+        reasons.push(`global ${join(...marker)}`);
+        break;
+      }
+    }
+    for (const command of harness.commands) {
+      if (executableOnPath(command, path, platform)) {
+        reasons.push(`${command} on PATH`);
+        break;
+      }
+    }
+    return { harness, reasons };
+  }));
+}