@outerlayer/cli 0.17.0 → 0.19.0

package/dist/{chunk-2MNPHL23.js → chunk-ZHAUSEEN.js}

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { C } from './chunk-YRYMNBGQ.js';
-import { retiredSkillPaths, removeRetiredSkills } from './chunk-C5Y5ZJJZ.js';
-import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-POJMEEJJ.js';
-import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-OHVJA253.js';
-import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, readdirSync } from 'fs';
+import { C } from './chunk-ANPNT6PM.js';
+import { retiredSkillPaths, removeRetiredSkills } from './chunk-IXYZUUYQ.js';
+import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-NNLA7LLQ.js';
+import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-WFSUUUAN.js';
+import { cliInvocation } from './chunk-CRB3POP4.js';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, unlinkSync, rmdirSync, readdirSync } from 'fs';
 import { join, dirname, relative, sep } from 'path';
 
 createRequire(import.meta.url);
@@ -31,6 +32,9 @@ function discoverOuterlayerPaths(repoRoot) {
   walk(repoRoot, repoRoot, false, out);
   return out.sort();
 }
+function isForeignTree(dir) {
+  return existsSync(join(dir, ".git")) || existsSync(join(dir, CONTEXT_PIN_FILENAME));
+}
 function walk(dir, repoRoot, insideOuterlayer, out) {
   let entries;
   try {
@@ -43,7 +47,7 @@ function walk(dir, repoRoot, insideOuterlayer, out) {
     const full = join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!insideOuterlayer && SKIP_DIRS.has(entry.name)) continue;
-      if (!insideOuterlayer && existsSync(join(full, CONTEXT_PIN_FILENAME))) continue;
+      if (!insideOuterlayer && isForeignTree(full)) continue;
       walk(full, repoRoot, insideOuterlayer || entry.name === ".outerlayer", out);
     } else if (entry.isFile() && insideOuterlayer) {
       out.push(toRepoRelative(repoRoot, full));
@@ -81,13 +85,14 @@ function writeOutputs(repoRoot, result, maintained) {
   }
   return { files, copies, maintained: [...changedMaintained.created, ...changedMaintained.rewritten] };
 }
-function renderSuccess(targets, files, copies, maintained, retired) {
+function renderSuccess(targets, files, copies, maintained, retired, orphaned) {
   const copySuffix = copies.length > 0 ? `, ${copies.length} ${copies.length === 1 ? "copy" : "copies"}` : "";
   const lines = [
     `${C.green}\u2713${C.reset} emitted ${files.length} file${files.length === 1 ? "" : "s"}${copySuffix} for ${C.dim}${targets.join(", ")}${C.reset}`
   ];
   for (const path of maintained) lines.push(`  ${C.dim}updated ${path} to this CLI's version${C.reset}`);
   for (const path of retired) lines.push(`  ${C.dim}removed ${path}: this skill has a new name${C.reset}`);
+  for (const path of orphaned) lines.push(`  ${C.dim}removed ${path}: its source is gone${C.reset}`);
   return lines.join("\n");
 }
 function renderFailure(errors) {
@@ -97,7 +102,7 @@ function renderFailure(errors) {
 }
 function renderCheck(targets, drift) {
   if (drift.length === 0) return `${C.green}\u2713${C.reset} up to date for ${C.dim}${targets.join(", ")}${C.reset}`;
-  const lines = [`${C.red}\u2717${C.reset} drift detected (${drift.length}) \u2014 run \`outerlayer emit\` to update`];
+  const lines = [`${C.red}\u2717${C.reset} drift detected (${drift.length}) \u2014 run \`${cliInvocation()} emit\` to update`];
   for (const d of drift) lines.push(`  ${C.red}\u2717${C.reset} ${d.kind.padEnd(8)} ${d.path}`);
   return lines.join("\n");
 }
@@ -131,7 +136,7 @@ function walkAll(dir, repoRoot, out) {
     if (entry.isSymbolicLink()) continue;
     const full = join(dir, entry.name);
     if (entry.isDirectory()) {
-      if (SKIP_DIRS.has(entry.name) || entry.name === ".outerlayer") continue;
+      if (SKIP_DIRS.has(entry.name) || entry.name === ".outerlayer" || isForeignTree(full)) continue;
       walkAll(full, repoRoot, out);
     } else if (entry.isFile()) {
       out.push(toRepoRelative(repoRoot, full));
@@ -154,6 +159,21 @@ function findOrphans(repoRoot, computedFiles, sourcePaths) {
   }
   return orphans;
 }
+function removeOrphans(repoRoot, orphans) {
+  const removed = [];
+  for (const { path } of orphans) {
+    unlinkSync(join(repoRoot, path));
+    removed.push(path);
+    for (let dir = dirname(path); dir !== "."; dir = dirname(dir)) {
+      try {
+        rmdirSync(join(repoRoot, dir));
+      } catch {
+        break;
+      }
+    }
+  }
+  return removed;
+}
 function withholdKept(repoRoot, result, keep) {
   if (keep === void 0) return { result, kept: [] };
   const kept = [];
@@ -186,9 +206,11 @@ function runEmit(opts = {}) {
   const emitted = emitTree(built.input);
   const { result, kept } = withholdKept(cwd, emitted, opts.keep);
   const hasErrors = result.errors.length > 0;
-  if (opts.check) return runCheck(cwd, opts, targets, result, hasErrors, built.sourcePaths, maintained, kept, retired);
+  const outputs = new Set(emitted.files.map((f) => f.path));
+  if (opts.check) return runCheck(cwd, opts, targets, result, hasErrors, outputs, built.sourcePaths, maintained, kept, retired);
   const written = hasErrors ? { files: [], copies: [], maintained: [] } : writeOutputs(cwd, result, maintained);
   const removed = hasErrors ? [] : removeRetiredSkills(cwd);
+  const orphaned = hasErrors ? [] : removeOrphans(cwd, findOrphans(cwd, outputs, built.sourcePaths));
   const exitCode = hasErrors ? 1 : 0;
   const output = opts.json ? JSON.stringify({
     targets,
@@ -196,9 +218,10 @@ function runEmit(opts = {}) {
     copies: written.copies,
     maintained: written.maintained,
     retired: removed,
+    orphaned,
     warnings: result.warnings,
     errors: result.errors
-  }) : hasErrors ? renderFailure(result.errors) : renderSuccess(targets, written.files, written.copies, written.maintained, removed);
+  }) : hasErrors ? renderFailure(result.errors) : renderSuccess(targets, written.files, written.copies, written.maintained, removed, orphaned);
   if (!opts.quiet) {
     if (opts.json) {
       process.stdout.write(output + "\n");
@@ -217,13 +240,14 @@ function runEmit(opts = {}) {
     maintained: written.maintained,
     kept,
     retired: removed,
+    orphaned,
     warnings: result.warnings,
     errors: result.errors,
     output,
     exitCode
   };
 }
-function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths, maintained, kept, retired) {
+function runCheck(cwd, opts, targets, result, hasErrors, outputs, sourcePaths, maintained, kept, retired) {
   const drift = [];
   if (!hasErrors) {
     for (const path of retired) drift.push({ kind: "retired", path });
@@ -231,7 +255,6 @@ function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths, maintained
       const d = compareFile(cwd, file.path, file.content);
       if (d) drift.push(d);
     }
-    const computedFiles = new Set(result.files.map((f) => f.path));
     for (const file of result.files) {
       const d = compareFile(cwd, file.path, file.content);
       if (d) drift.push(d);
@@ -241,7 +264,7 @@ function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths, maintained
       if (d) drift.push(d);
     }
     const retiredPaths = new Set(retired);
-    drift.push(...findOrphans(cwd, computedFiles, sourcePaths).filter((d) => !retiredPaths.has(d.path)));
+    drift.push(...findOrphans(cwd, outputs, sourcePaths).filter((d) => !retiredPaths.has(d.path)));
     drift.sort((a, b) => a.path.localeCompare(b.path) || a.kind.localeCompare(b.kind));
   }
   const exitCode = hasErrors || drift.length > 0 ? 1 : 0;
@@ -257,7 +280,7 @@ function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths, maintained
 `);
     }
   }
-  return { targets, files: [], copies: [], maintained: [], kept, retired: [], warnings: result.warnings, errors: result.errors, drift, output, exitCode };
+  return { targets, files: [], copies: [], maintained: [], kept, retired: [], orphaned: [], warnings: result.warnings, errors: result.errors, drift, output, exitCode };
 }
 
 export { EmitError, runEmit };

package/dist/claude-launcher-FPPHZPMR.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { versionAtLeast, MINIMUM_CLAUDE_VERSION, SHIM_SCRIPT, CONTROL_PLANE_DIR_VARIABLE } from './chunk-G2YNJIGF.js';
+export { MINIMUM_CLAUDE_VERSION } from './chunk-G2YNJIGF.js';
+import { homeFromEnv } from './chunk-VNVZDWO3.js';
+import './chunk-Z5GEFMRW.js';
+import { spawnSync, execFileSync, spawn } from 'child_process';
+import { existsSync, accessSync, constants, statSync, readFileSync } from 'fs';
+import { join, delimiter, isAbsolute, resolve } from 'path';
+
+createRequire(import.meta.url);
+function readDeliveryRecord(cwd) {
+  let common;
+  try {
+    common = execFileSync("git", ["rev-parse", "--git-common-dir"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }).trim();
+  } catch {
+    return { kind: "none" };
+  }
+  const path = join(isAbsolute(common) ? common : resolve(cwd, common), "outerlayer", "delivery.json");
+  if (!existsSync(path)) return { kind: "none" };
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed.dir === "string" && isAbsolute(parsed.dir) && typeof parsed.repository === "string" && typeof parsed.sha === "string") {
+      return { kind: "found", record: { repository: parsed.repository, sha: parsed.sha, dir: parsed.dir, launcher: parsed.launcher === true } };
+    }
+  } catch {
+  }
+  return { kind: "invalid", path };
+}
+function findClaude(path) {
+  for (const entry of (path ?? "").split(delimiter)) {
+    if (entry === "") continue;
+    const candidate = join(entry, "claude");
+    try {
+      accessSync(candidate, constants.X_OK);
+      if (statSync(candidate).size === Buffer.byteLength(SHIM_SCRIPT) && readFileSync(candidate, "utf8") === SHIM_SCRIPT) continue;
+    } catch {
+      continue;
+    }
+    return candidate;
+  }
+  return void 0;
+}
+var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+var SIGNAL_NUMBERS = { SIGHUP: 1, SIGINT: 2, SIGTERM: 15 };
+function run(program, argv, env, cwd, stderr) {
+  return new Promise((done) => {
+    const child = spawn(program, argv, { cwd, env, stdio: "inherit" });
+    const forward = (signal) => () => {
+      child.kill(signal);
+    };
+    const handlers = SIGNALS.map((signal) => [signal, forward(signal)]);
+    for (const [signal, handler] of handlers) process.on(signal, handler);
+    const finish = (code) => {
+      for (const [signal, handler] of handlers) process.off(signal, handler);
+      done(code);
+    };
+    child.on("error", (err) => {
+      stderr(`outerlayer claude: could not start ${program}: ${err.message}
+`);
+      finish(127);
+    });
+    child.on("exit", (code, signal) => finish(code ?? 128 + (signal === null ? 0 : SIGNAL_NUMBERS[signal] ?? 0)));
+  });
+}
+async function runClaudeLauncher(args, deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  const stderr = deps.stderr ?? ((text) => void process.stderr.write(text));
+  const claude = findClaude(env.PATH);
+  if (claude === void 0) {
+    stderr("outerlayer claude: no claude program found on PATH\n");
+    return 127;
+  }
+  const found = readDeliveryRecord(cwd);
+  const build = found.kind === "found" && found.record.launcher !== true ? found.record : void 0;
+  if (found.kind === "invalid" && env.OUTERLAYER_JOB_DIR !== void 0) {
+    stderr(`outerlayer claude: ${found.path} is not a readable delivery record, so the control plane cannot be attached
+`);
+    return 1;
+  }
+  let dir;
+  if (build !== void 0) {
+    dir = build.dir;
+    if (!existsSync(dir)) {
+      stderr(`outerlayer claude: the control plane of ${build.repository} is not at ${dir}, so it cannot be attached
+`);
+      return 1;
+    }
+  } else {
+    const { resolveLaunchPlane } = await import('./control-plane-launch-NYVDJESK.js');
+    const plane = await resolveLaunchPlane({ cwd, env, home: homeFromEnv(env), fetchImpl: deps.fetchImpl, stderr });
+    if (plane.kind === "none") return run(claude, args, env, cwd, stderr);
+    if (plane.kind === "refused") {
+      stderr(plane.message);
+      return 1;
+    }
+    dir = plane.dir;
+  }
+  const reported = spawnSync(claude, ["--version"], { env, encoding: "utf8", timeout: 15e3, stdio: ["ignore", "pipe", "ignore"] }).stdout ?? "";
+  if (/\d+\.\d+\.\d+/.test(reported) && !versionAtLeast(reported)) {
+    stderr(`outerlayer claude: Claude Code ${reported.trim().split(/\s+/)[0]} is older than ${MINIMUM_CLAUDE_VERSION}, the oldest version known to load a control plane's instructions for subagents; the minimum version is ${MINIMUM_CLAUDE_VERSION}
+`);
+    return 1;
+  }
+  return run(
+    claude,
+    ["--add-dir", dir, "--settings", join(dir, "settings.json"), ...args],
+    { ...env, CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD: "1", [CONTROL_PLANE_DIR_VARIABLE]: dir },
+    cwd,
+    stderr
+  );
+}
+
+export { runClaudeLauncher };