@outerlayer/cli 0.2.0 → 0.4.0

package/dist/{emit-cmd-TWSYYEZI.js → chunk-H5NCNVDA.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-KFYJV2ZG.js';
-import './chunk-Z5GEFMRW.js';
+import { maintainedFilesForExistingSkills, loadMaintainedFiles, writeMaintainedFiles } from './chunk-WO2BXCTQ.js';
+import { emitTree, parseOuterlayerConfig, classifyTree, generatedHeaderSource, CONTEXT_PIN_FILENAME, normalizePath } from './chunk-EMY4I27X.js';
 import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, readdirSync } from 'fs';
 import { join, dirname, relative, sep } from 'path';
 
@@ -53,19 +53,21 @@ function walk(dir, repoRoot, insideOuterlayer, out) {
     }
   }
 }
-function buildEmitInput(repoRoot, targets) {
-  const discovered = discoverOuterlayerPaths(repoRoot);
+function buildEmitInput(repoRoot, targets, maintained) {
+  const bundled = new Map(maintained.map((f) => [f.path, f.content]));
+  const discovered = [.../* @__PURE__ */ new Set([...discoverOuterlayerPaths(repoRoot), ...bundled.keys()])].sort();
   const { entries } = classifyTree(discovered);
   const classified = new Set(entries.map((e) => e.path));
   const contents = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (!CONTENT_KINDS.has(entry.kind)) continue;
-    contents.set(entry.path, readFileSync(join(repoRoot, entry.path), "utf8"));
+    contents.set(entry.path, bundled.get(entry.path) ?? readFileSync(join(repoRoot, entry.path), "utf8"));
   }
   const assetPaths = discovered.filter((p) => !classified.has(p));
   return { input: { entries, contents, assetPaths, targets }, sourcePaths: classified };
 }
-function writeOutputs(repoRoot, result) {
+function writeOutputs(repoRoot, result, maintained) {
+  const changedMaintained = writeMaintainedFiles(repoRoot, maintained);
   const files = [];
   for (const file of result.files) {
     const abs = join(repoRoot, file.path);
@@ -80,11 +82,15 @@ function writeOutputs(repoRoot, result) {
     copyFileSync(join(repoRoot, copy.fromSourcePath), abs);
     copies.push(copy.toPath);
   }
-  return { files, copies };
+  return { files, copies, maintained: [...changedMaintained.created, ...changedMaintained.rewritten] };
 }
-function renderSuccess(targets, files, copies) {
+function renderSuccess(targets, files, copies, maintained) {
   const copySuffix = copies.length > 0 ? `, ${copies.length} ${copies.length === 1 ? "copy" : "copies"}` : "";
-  return `${GREEN}\u2713${RESET} emitted ${files.length} file${files.length === 1 ? "" : "s"}${copySuffix} for ${DIM}${targets.join(", ")}${RESET}`;
+  const lines = [
+    `${GREEN}\u2713${RESET} emitted ${files.length} file${files.length === 1 ? "" : "s"}${copySuffix} for ${DIM}${targets.join(", ")}${RESET}`
+  ];
+  for (const path of maintained) lines.push(`  ${DIM}updated ${path} to this CLI's version${RESET}`);
+  return lines.join("\n");
 }
 function renderFailure(errors) {
   const lines = [`${RED}\u2717${RESET} emit failed \u2014 nothing written`];
@@ -150,17 +156,48 @@ function findOrphans(repoRoot, computedFiles, sourcePaths) {
   }
   return orphans;
 }
+function withholdKept(repoRoot, result, keep) {
+  if (keep === void 0) return { result, kept: [] };
+  const kept = [];
+  const files = result.files.filter((file) => {
+    const abs = join(repoRoot, file.path);
+    if (!existsSync(abs)) return true;
+    const existing = readFileSync(abs, "utf8");
+    if (existing === file.content || !keep({ kind: "file", path: file.path, existing, content: file.content })) return true;
+    kept.push(file.path);
+    return false;
+  });
+  const copies = result.copies.filter((copy) => {
+    const abs = join(repoRoot, copy.toPath);
+    if (!existsSync(abs)) return true;
+    const src = join(repoRoot, copy.fromSourcePath);
+    if (existsSync(src) && readFileSync(abs).equals(readFileSync(src))) return true;
+    if (!keep({ kind: "copy", path: copy.toPath, source: copy.fromSourcePath })) return true;
+    kept.push(copy.toPath);
+    return false;
+  });
+  return { result: { ...result, files, copies }, kept: kept.sort() };
+}
 function runEmit(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   if (!existsSync(cwd)) throw new EmitError(`no such directory: ${cwd}`);
   const targets = resolveTargetsFromConfig(cwd);
-  const built = buildEmitInput(cwd, targets);
-  const result = emitTree(built.input);
+  const maintained = maintainedFilesForExistingSkills(cwd, loadMaintainedFiles());
+  const built = buildEmitInput(cwd, targets, maintained);
+  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);
-  const written = hasErrors ? { files: [], copies: [] } : writeOutputs(cwd, result);
+  if (opts.check) return runCheck(cwd, opts, targets, result, hasErrors, built.sourcePaths, maintained, kept);
+  const written = hasErrors ? { files: [], copies: [], maintained: [] } : writeOutputs(cwd, result, maintained);
   const exitCode = hasErrors ? 1 : 0;
-  const output = opts.json ? JSON.stringify({ targets, files: written.files, copies: written.copies, warnings: result.warnings, errors: result.errors }) : hasErrors ? renderFailure(result.errors) : renderSuccess(targets, written.files, written.copies);
+  const output = opts.json ? JSON.stringify({
+    targets,
+    files: written.files,
+    copies: written.copies,
+    maintained: written.maintained,
+    warnings: result.warnings,
+    errors: result.errors
+  }) : hasErrors ? renderFailure(result.errors) : renderSuccess(targets, written.files, written.copies, written.maintained);
   if (!opts.quiet) {
     if (opts.json) {
       process.stdout.write(output + "\n");
@@ -172,11 +209,25 @@ function runEmit(opts = {}) {
 `);
     }
   }
-  return { targets, files: written.files, copies: written.copies, warnings: result.warnings, errors: result.errors, output, exitCode };
+  return {
+    targets,
+    files: written.files,
+    copies: written.copies,
+    maintained: written.maintained,
+    kept,
+    warnings: result.warnings,
+    errors: result.errors,
+    output,
+    exitCode
+  };
 }
-function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths) {
+function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths, maintained, kept) {
   const drift = [];
   if (!hasErrors) {
+    for (const file of 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);
@@ -202,7 +253,7 @@ function runCheck(cwd, opts, targets, result, hasErrors, sourcePaths) {
 `);
     }
   }
-  return { targets, files: [], copies: [], warnings: result.warnings, errors: result.errors, drift, output, exitCode };
+  return { targets, files: [], copies: [], maintained: [], kept, warnings: result.warnings, errors: result.errors, drift, output, exitCode };
 }
 
 export { EmitError, runEmit };

package/dist/chunk-HE2D4EY5.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { setCustomScrubbers, setLocalIdentity, setRepoRoot, resolveRepoIdentity, scrubDeep, downconvertSession, isHumanUserTurn, turnCountBound } from './chunk-G7FSV7JX.js';
+import { execFileSync } from 'child_process';
+import { hostname, userInfo } from 'os';
+
+createRequire(import.meta.url);
+function detectCi(env = process.env) {
+  return env.CI === "true" || env.CI === "1" || !!env.JENKINS_URL;
+}
+function gitGlobalConfig(key) {
+  try {
+    return execFileSync("git", ["config", "--global", key], { encoding: "utf8", timeout: 2e3 }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function installScrubContext(home, scrub) {
+  setCustomScrubbers(scrub);
+  setLocalIdentity({
+    name: gitGlobalConfig("user.name"),
+    email: gitGlobalConfig("user.email"),
+    username: (() => {
+      try {
+        return userInfo().username;
+      } catch {
+        return void 0;
+      }
+    })(),
+    hostname: (() => {
+      try {
+        return hostname();
+      } catch {
+        return void 0;
+      }
+    })(),
+    home
+  });
+}
+function applyContextProvenance(session, record) {
+  if (!record) return;
+  if (record.repository !== void 0) session.env.contextSourceRepo = record.repository;
+  if (record.ref !== void 0) session.env.contextSourceRef = record.ref;
+  if (record.sha !== null) session.env.contextSourceSha = record.sha;
+  session.env.contextSourceVerification = record.verification;
+}
+function prepareSessionForUpload(session, tier, envVars = process.env) {
+  setRepoRoot(resolveRepoIdentity(session.env.cwd).repoRoot);
+  scrubDeep(session);
+  session.workerKind ??= detectCi(envVars) ? "ci" : "seat";
+  return downconvertSession(session, tier);
+}
+var MAX_TOOL_IO_CHARS = 64e3;
+function sliceToolIo(value) {
+  const text = typeof value === "string" ? value : JSON.stringify(value);
+  if (typeof text !== "string" || text.length <= MAX_TOOL_IO_CHARS) return value;
+  return `${text.slice(0, MAX_TOOL_IO_CHARS)}\u2026[sliced: ${text.length} chars exceeded the sync per-call cap]`;
+}
+function sliceTurnIo(turn) {
+  return {
+    ...turn,
+    toolCalls: (turn.toolCalls ?? []).map((call) => ({
+      ...call,
+      ...call.input !== void 0 ? { input: sliceToolIo(call.input) } : {},
+      ...call.output !== void 0 ? { output: sliceToolIo(call.output) } : {}
+    }))
+  };
+}
+function wholeSessionCounts(turns) {
+  const allCalls = turns.flatMap((t) => t.toolCalls ?? []);
+  return {
+    // An index BOUND (`1 + max(turn.index)`), not the shipped turn count —
+    // turn indexes are not guaranteed dense from zero, and a late artifact
+    // anchored at its real turn index must still validate against the
+    // summary row this produces (see turnCountBound).
+    turns: turnCountBound(turns),
+    toolCalls: allCalls.length,
+    errors: allCalls.filter((c) => c.status === "error").length,
+    userTurns: turns.filter(isHumanUserTurn).length
+  };
+}
+
+export { applyContextProvenance, detectCi, installScrubContext, prepareSessionForUpload, sliceTurnIo, wholeSessionCounts };

package/dist/chunk-L2DBRKRA.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { MIN_ENGINE_MAJOR } from './chunk-7A6RVXPZ.js';
+import { firecrackerArch, MICROVM_ARCHES, guestAssetsPinned } from './chunk-ZNA27WEV.js';
+import { spawnSync } from 'child_process';
+import { existsSync, accessSync, constants, statSync, readFileSync } from 'fs';
+
+createRequire(import.meta.url);
+function groupName(gid) {
+  try {
+    for (const line of readFileSync("/etc/group", "utf8").split("\n")) {
+      const [name, , id] = line.split(":");
+      if (name !== void 0 && Number(id) === gid) return name;
+    }
+  } catch {
+  }
+  return String(gid);
+}
+function detectKvm(device) {
+  if (!existsSync(device)) return { state: "absent" };
+  try {
+    accessSync(device, constants.R_OK | constants.W_OK);
+    return { state: "usable" };
+  } catch {
+    return { state: "no-permission", group: groupName(statSync(device).gid) };
+  }
+}
+function readProcVersion() {
+  try {
+    return readFileSync("/proc/version", "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function docker(args) {
+  const result = spawnSync("docker", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 15e3 });
+  const out = result.status === 0 ? result.stdout.trim() : "";
+  return out === "" ? void 0 : out;
+}
+function dockerFailure() {
+  const result = spawnSync("docker", ["version", "--format", "{{.Server.Version}}"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 15e3 });
+  if (result.error?.code === "ENOENT") return void 0;
+  return /permission denied/i.test(result.stderr ?? "") ? "permission" : "daemon";
+}
+function platformOf(probes) {
+  const platform = probes.platform ?? process.platform;
+  if (platform === "win32") return "windows";
+  if (platform === "darwin") return "darwin";
+  if (platform !== "linux") return "other";
+  return /microsoft/i.test((probes.procVersion ?? readProcVersion)() ?? "") ? "wsl2" : "linux";
+}
+function detectMachine(probes = {}) {
+  const platform = platformOf(probes);
+  const kvm = (probes.kvm ?? (() => detectKvm(probes.kvmDevice ?? "/dev/kvm")))();
+  const arch = firecrackerArch(probes.nodeArch ?? process.arch);
+  const version = (probes.dockerVersion ?? (() => docker(["version", "--format", "{{.Server.Version}}"])))();
+  if (version === void 0) {
+    const failure = (probes.dockerFailure ?? (probes.dockerVersion === void 0 ? dockerFailure : () => void 0))();
+    return { platform, docker: failure === void 0 ? { kind: "none" } : { kind: "unreachable", reason: failure }, kvm, arch };
+  }
+  const system = (probes.dockerOperatingSystem ?? (() => docker(["info", "--format", "{{.OperatingSystem}}"])))() ?? "";
+  return { platform, docker: { kind: /docker desktop/i.test(system) ? "desktop" : "engine", version }, kvm, arch };
+}
+function supportsContainerBuilds(machine) {
+  if (machine.platform !== "linux" && machine.platform !== "wsl2") return false;
+  return machine.docker.kind === "engine" && Number.parseInt(machine.docker.version ?? "", 10) >= MIN_ENGINE_MAJOR;
+}
+function supportsMicroVmBuilds(machine) {
+  return machine.platform === "linux" && machine.kvm?.state === "usable" && supportsContainerBuilds(machine) && microVmAssetsPinned(machine);
+}
+function microVmArchSupported(machine) {
+  return MICROVM_ARCHES.includes(machine.arch ?? "");
+}
+function microVmAssetsPinned(machine) {
+  return microVmArchSupported(machine) && guestAssetsPinned(machine.arch);
+}
+function reachDockerStep(machine) {
+  if (machine.docker.kind !== "unreachable") return void 0;
+  return machine.docker.reason === "permission" ? "give this user access to Docker Engine's socket (add it to the docker group, then log in again)" : "start Docker Engine's daemon (for example, sudo systemctl start docker)";
+}
+function describeMachineDocker(machine) {
+  const { kind, version, reason } = machine.docker;
+  const where = machine.platform === "windows" ? "Windows" : machine.platform === "darwin" ? "macOS" : machine.platform === "wsl2" ? "WSL2" : "Linux";
+  if (kind === "desktop") return `Docker Desktop ${version ?? ""} on ${where}, which cannot pass a Unix socket into a container`.replace("  ", " ");
+  if (kind === "none") return `no Docker on ${where}`;
+  if (kind === "unreachable") {
+    const problem = reason === "permission" ? "this user has no permission on its socket" : "its daemon is not running";
+    return `a docker command on ${where} that cannot reach Docker Engine (${problem})`;
+  }
+  if (machine.platform !== "linux" && machine.platform !== "wsl2") return `Docker Engine ${version ?? ""} on ${where}, which cannot isolate a build`.replace("  ", " ");
+  return `Docker Engine ${version ?? "of no known version"}, older than the ${MIN_ENGINE_MAJOR} that container builds need`;
+}
+
+export { describeMachineDocker, detectMachine, microVmArchSupported, microVmAssetsPinned, reachDockerStep, supportsContainerBuilds, supportsMicroVmBuilds };

package/dist/chunk-LF6MLJCY.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+createRequire(import.meta.url);
+var LAUNCH_AGENT_LABEL = "ai.outerlayer.runner-vm";
+function launchAgentPath(home) {
+  return join(home, "Library", "LaunchAgents", `${LAUNCH_AGENT_LABEL}.plist`);
+}
+var escapeXml = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function launchAgentPlist(limactl, instance) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCH_AGENT_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(limactl)}</string>
+    <string>start</string>
+    <string>${escapeXml(instance)}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+</dict>
+</plist>
+`;
+}
+function writeLaunchAgent(home, limactl, instance) {
+  const path = launchAgentPath(home);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, launchAgentPlist(limactl, instance));
+  return path;
+}
+
+export { launchAgentPath, writeLaunchAgent };