@olwiba/dx 0.0.23 → 0.0.27

package/dist/cli.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import { mkdirSync, writeFileSync, readFileSync } from 'fs';
-import path, { join, resolve } from 'path';
-import { createRequire } from 'module';
+import { spawnSync } from 'child_process';
+import { mkdirSync, writeFileSync, existsSync, realpathSync, readFileSync, lstatSync, readdirSync } from 'fs';
+import path, { join, resolve, relative, sep, isAbsolute, basename } from 'path';
 import { createInterface } from 'readline/promises';
 import { stdout, stdin } from 'process';
+import { createRequire } from 'module';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -15,6 +16,414 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/worktree-cleanup.ts
+var worktree_cleanup_exports = {};
+__export(worktree_cleanup_exports, {
+  classifyWorktree: () => classifyWorktree,
+  parseWorktreeList: () => parseWorktreeList,
+  runWorktreeCleanup: () => runWorktreeCleanup
+});
+function parseWorktreeList(output3) {
+  return output3.trim().split(/\r?\n\r?\n/).filter(Boolean).map((record) => {
+    const fields = /* @__PURE__ */ new Map();
+    for (const line of record.split(/\r?\n/)) {
+      const separator = line.indexOf(" ");
+      if (separator === -1) {
+        fields.set(line, "");
+      } else {
+        fields.set(line.slice(0, separator), line.slice(separator + 1));
+      }
+    }
+    const path2 = fields.get("worktree");
+    const head = fields.get("HEAD");
+    if (!path2 || !head) throw new Error("Unexpected output from git worktree list");
+    const branchRef = fields.get("branch");
+    return {
+      path: path2,
+      head,
+      ...branchRef ? { branch: branchRef.replace(/^refs\/heads\//, "") } : {}
+    };
+  });
+}
+function classifyWorktree(state) {
+  const reasons = [];
+  let removalReason;
+  if (state.isCurrent) reasons.push("current working directory");
+  if (!state.branch) {
+    if (state.headMerged) {
+      removalReason = `detached HEAD merged into ${state.defaultBranch}`;
+    } else {
+      reasons.push(`detached HEAD is not merged into ${state.defaultBranch}`);
+    }
+  } else if (state.remoteBranchExists) {
+    if (state.remoteBranchMerged) {
+      removalReason = `branch merged into ${state.defaultBranch}`;
+    } else {
+      reasons.push(`remote branch exists; merge into ${state.defaultBranch} not confirmed`);
+    }
+  } else if (!state.headMerged) {
+    reasons.push(`remote branch deleted; merge into ${state.defaultBranch} not confirmed`);
+  } else if (state.head === state.defaultSha) {
+    reasons.push(`branch points at current ${state.defaultBranch}; automatic removal skipped`);
+  } else {
+    removalReason = `branch merged into ${state.defaultBranch} (remote branch deleted)`;
+  }
+  if (!state.pathExists) reasons.push("worktree path missing");
+  if (state.dirty) reasons.push("uncommitted changes");
+  if (state.aheadCount > 0) {
+    reasons.push(
+      `${state.aheadCount} commit(s) ahead of ${state.remote}/${state.defaultBranch}`
+    );
+  }
+  return reasons.length > 0 ? { removable: false, reasons } : { removable: true, reason: removalReason ?? "safe to remove" };
+}
+async function runWorktreeCleanup(args, hooks = {}) {
+  let options;
+  try {
+    options = parseCleanupArgs(args);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    writeUsage(process.stderr);
+    return 1;
+  }
+  if (args.includes("--help") || args.includes("-h")) {
+    writeUsage(process.stdout);
+    return 0;
+  }
+  let repoPath;
+  try {
+    repoPath = resolveRepo(options.repo, options.reposRoot);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+  const repoName = basename(repoPath);
+  process.stdout.write(`Repo: ${repoName}
+Path: ${repoPath}
+`);
+  if (options.fetch) {
+    process.stdout.write(`Fetching latest from ${options.remote}...
+`);
+    const fetched = runGit(repoPath, ["fetch", options.remote, "--prune"], true);
+    if (!fetched.ok) {
+      process.stderr.write(fetched.stderr || `git fetch failed for ${repoName}
+`);
+      return 1;
+    }
+  }
+  const defaultBranch = resolveDefaultBranch(repoPath, options.remote);
+  const defaultRef = `${options.remote}/${defaultBranch}`;
+  const defaultSha = gitOutput(repoPath, ["rev-parse", defaultRef]);
+  if (!defaultSha) {
+    process.stderr.write(`Could not find ${defaultRef} for ${repoName}.
+`);
+    return 1;
+  }
+  const worktrees = parseWorktreeList(requiredGitOutput(repoPath, ["worktree", "list", "--porcelain"]));
+  const additionalWorktrees = worktrees.slice(1);
+  if (additionalWorktrees.length === 0) {
+    process.stdout.write("No additional worktrees found. Nothing to clean up.\n");
+    return 0;
+  }
+  const callerWorktree = canonicalPath(gitOutput(process.cwd(), ["rev-parse", "--show-toplevel"]));
+  const removable = [];
+  const preserved = [];
+  for (const worktree of additionalWorktrees) {
+    const pathExists = existsSync(worktree.path);
+    const trackedBranch = worktree.branch ? gitOutput(repoPath, [
+      "for-each-ref",
+      "--format=%(upstream:short)",
+      `refs/heads/${worktree.branch}`
+    ]) : "";
+    const remoteBranch = worktree.branch ? trackedBranch.startsWith(`${options.remote}/`) ? trackedBranch : `${options.remote}/${worktree.branch}` : "";
+    const remoteBranchExists = Boolean(remoteBranch) && gitSucceeds(repoPath, ["rev-parse", "--verify", remoteBranch]);
+    const headMerged = gitIsAncestor(repoPath, worktree.head, defaultRef);
+    const classification = classifyWorktree({
+      branch: worktree.branch,
+      head: worktree.head,
+      defaultSha,
+      defaultBranch,
+      remote: options.remote,
+      isCurrent: canonicalPath(worktree.path) === callerWorktree,
+      pathExists,
+      dirty: pathExists && Boolean(gitOutput(worktree.path, ["status", "--porcelain"])),
+      aheadCount: worktree.branch && pathExists ? Number(gitOutput(worktree.path, ["rev-list", "--count", `${defaultRef}..HEAD`]) || 0) : 0,
+      remoteBranchExists,
+      remoteBranchMerged: remoteBranchExists && gitIsAncestor(repoPath, remoteBranch, defaultRef),
+      headMerged
+    });
+    if (classification.removable) {
+      removable.push({
+        ...worktree,
+        reason: classification.reason,
+        sizeMB: directorySizeMB(worktree.path)
+      });
+    } else {
+      preserved.push({ ...worktree, reasons: classification.reasons });
+    }
+  }
+  if (preserved.length > 0) {
+    process.stdout.write("\nWorktrees needing attention (not automatically removed):\n");
+    for (const item of preserved) {
+      process.stdout.write(`  ${item.branch ?? "(detached)"}
+    ${item.reasons.join("; ")}
+    ${item.path}
+`);
+    }
+  }
+  if (removable.length === 0) {
+    process.stdout.write(`
+No worktrees are safely removable.
+Summary: 0 safely removable; ${preserved.length} needing attention.
+`);
+    return 0;
+  }
+  const totalMB = removable.reduce((total, item) => total + item.sizeMB, 0);
+  process.stdout.write("\nWorktrees to remove:\n");
+  for (const item of removable) {
+    process.stdout.write(`  ${item.branch ?? "(detached)"} - ${item.reason} - ~${item.sizeMB} MB
+    ${item.path}
+`);
+  }
+  process.stdout.write(`Total space to reclaim: ~${totalMB} MB
+`);
+  if (options.dryRun) {
+    process.stdout.write(`
+[DRY RUN] No changes made.
+Summary: ${removable.length} safely removable; ${preserved.length} needing attention.
+`);
+    return 0;
+  }
+  if (!options.force && !await confirmRemoval()) {
+    process.stdout.write(`Aborted.
+Summary: 0 removed; ${preserved.length} needing attention.
+`);
+    return 0;
+  }
+  let removedCount = 0;
+  let reclaimedMB = 0;
+  const skipped = [];
+  for (const item of removable) {
+    hooks.beforeRemoval?.(item);
+    const current = inspectWorktree(repoPath, item.path, options.remote, defaultBranch);
+    if (!current.classification.removable) {
+      skipped.push({
+        item,
+        error: `changed since planning: ${current.classification.reasons.join("; ")}`
+      });
+      continue;
+    }
+    process.stdout.write(`Removing worktree: ${item.branch ?? "(detached)"} ...
+`);
+    const removal = runGit(repoPath, ["worktree", "remove", item.path, "--force"]);
+    if (!removal.ok) {
+      skipped.push({ item, error: removal.stderr.trim() || "git worktree remove failed" });
+      continue;
+    }
+    removedCount++;
+    reclaimedMB += item.sizeMB;
+    hooks.afterWorktreeRemoval?.(item);
+    if (current.worktree.branch) {
+      const branchRemoval = runGit(repoPath, ["branch", "-D", current.worktree.branch]);
+      if (!branchRemoval.ok) {
+        skipped.push({
+          item,
+          error: `worktree removed, but local branch deletion failed: ${branchRemoval.stderr.trim() || "git branch -D failed"}`
+        });
+        continue;
+      }
+    }
+  }
+  if (skipped.length > 0) {
+    process.stdout.write("\nWorktree cleanup issues:\n");
+    for (const { item, error } of skipped) {
+      process.stdout.write(`  ${item.branch ?? "(detached)"}: ${error}
+    ${item.path}
+`);
+    }
+  }
+  process.stdout.write(`
+Done. Removed ${removedCount} worktree(s), reclaimed ~${reclaimedMB} MB; skipped ${skipped.length}.
+`);
+  process.stdout.write(`Summary: ${preserved.length} worktree(s) still need attention (see report above).
+`);
+  return skipped.length > 0 ? 1 : 0;
+}
+function inspectWorktree(repoPath, worktreePath, remote, defaultBranch) {
+  const listed = parseWorktreeList(requiredGitOutput(repoPath, ["worktree", "list", "--porcelain"]));
+  const expectedPath = pathIdentity(worktreePath);
+  const worktree = listed.find((candidate) => pathIdentity(candidate.path) === expectedPath) ?? { path: worktreePath, head: "", branch: void 0 };
+  const pathExists = existsSync(worktree.path);
+  const defaultRef = `${remote}/${defaultBranch}`;
+  const defaultSha = gitOutput(repoPath, ["rev-parse", defaultRef]);
+  const trackedBranch = worktree.branch ? gitOutput(repoPath, ["for-each-ref", "--format=%(upstream:short)", `refs/heads/${worktree.branch}`]) : "";
+  const remoteBranch = worktree.branch ? trackedBranch.startsWith(`${remote}/`) ? trackedBranch : `${remote}/${worktree.branch}` : "";
+  const remoteBranchExists = Boolean(remoteBranch) && gitSucceeds(repoPath, ["rev-parse", "--verify", remoteBranch]);
+  const currentWorktree = canonicalPath(gitOutput(process.cwd(), ["rev-parse", "--show-toplevel"]));
+  return {
+    worktree,
+    classification: classifyWorktree({
+      branch: worktree.branch,
+      head: worktree.head,
+      defaultSha,
+      defaultBranch,
+      remote,
+      isCurrent: expectedPath !== "" && expectedPath === currentWorktree,
+      pathExists,
+      dirty: pathExists && Boolean(gitOutput(worktree.path, ["status", "--porcelain"])),
+      aheadCount: worktree.branch && pathExists ? Number(gitOutput(worktree.path, ["rev-list", "--count", `${defaultRef}..HEAD`]) || 0) : 0,
+      remoteBranchExists,
+      remoteBranchMerged: remoteBranchExists && gitIsAncestor(repoPath, remoteBranch, defaultRef),
+      headMerged: Boolean(worktree.head) && gitIsAncestor(repoPath, worktree.head, defaultRef)
+    })
+  };
+}
+function parseCleanupArgs(args) {
+  const options = {
+    remote: "origin",
+    dryRun: false,
+    force: false,
+    fetch: true
+  };
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--dry-run" || arg.toLowerCase() === "-dryrun") options.dryRun = true;
+    else if (arg === "--force" || arg.toLowerCase() === "-force") options.force = true;
+    else if (arg === "--no-fetch") options.fetch = false;
+    else if (arg === "--help" || arg === "-h") continue;
+    else if (arg === "--repos-root" || arg === "--remote") {
+      const value = args[++index];
+      if (!value) throw new Error(`${arg} requires a value`);
+      if (arg === "--repos-root") options.reposRoot = value;
+      else options.remote = value;
+    } else if (arg.startsWith("--repos-root=")) options.reposRoot = arg.slice(13);
+    else if (arg.startsWith("--remote=")) options.remote = arg.slice(9);
+    else if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);
+    else if (!options.repo) options.repo = arg;
+    else throw new Error(`Unexpected argument: ${arg}`);
+  }
+  return options;
+}
+function resolveRepo(repoInput, reposRootInput) {
+  if (!repoInput) {
+    const root = gitOutput(process.cwd(), ["rev-parse", "--show-toplevel"]);
+    if (!root) throw new Error("Current directory is not inside a git repository. Provide a repo path or name.");
+    return realpathSync(root);
+  }
+  const directPath = isAbsolute(repoInput) ? repoInput : resolve(process.cwd(), repoInput);
+  if (existsSync(directPath)) return resolveGitRoot(directPath);
+  const reposRoot = resolve(process.cwd(), reposRootInput ?? "repos");
+  if (!existsSync(reposRoot)) {
+    throw new Error(`Repo '${repoInput}' was not found. Provide its path or use --repos-root.`);
+  }
+  const matches = findRepos(reposRoot).filter((path2) => basename(path2).toLowerCase() === repoInput.toLowerCase());
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) throw new Error(`Repo name '${repoInput}' is ambiguous. Provide a repo path instead.`);
+  throw new Error(`Unknown repo '${repoInput}' under ${reposRoot}.`);
+}
+function resolveGitRoot(path2) {
+  const root = gitOutput(path2, ["rev-parse", "--show-toplevel"]);
+  if (!root) throw new Error(`Path is not inside a git repository: ${path2}`);
+  return realpathSync(root);
+}
+function findRepos(root) {
+  const repos = [];
+  const visit = (directory) => {
+    if (existsSync(join(directory, ".git"))) {
+      repos.push(realpathSync(directory));
+      return;
+    }
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+      visit(join(directory, entry.name));
+    }
+  };
+  visit(root);
+  return repos;
+}
+function resolveDefaultBranch(repoPath, remote) {
+  const symbolic = gitOutput(repoPath, ["symbolic-ref", "--short", `refs/remotes/${remote}/HEAD`]);
+  if (symbolic) return symbolic.replace(`${remote}/`, "");
+  if (gitSucceeds(repoPath, ["rev-parse", "--verify", `${remote}/main`])) return "main";
+  if (gitSucceeds(repoPath, ["rev-parse", "--verify", `${remote}/master`])) return "master";
+  throw new Error(`Could not resolve the default branch for remote '${remote}'.`);
+}
+function canonicalPath(path2) {
+  if (!path2 || !existsSync(path2)) return "";
+  const canonical = realpathSync(path2);
+  return process.platform === "win32" ? canonical.toLowerCase() : canonical;
+}
+function pathIdentity(path2) {
+  const identity = existsSync(path2) ? realpathSync(path2) : resolve(path2);
+  return process.platform === "win32" ? identity.toLowerCase() : identity;
+}
+function gitIsAncestor(repoPath, ancestor, descendant) {
+  return gitSucceeds(repoPath, ["merge-base", "--is-ancestor", ancestor, descendant]);
+}
+function gitSucceeds(repoPath, args) {
+  return runGit(repoPath, args).ok;
+}
+function requiredGitOutput(repoPath, args) {
+  const result = runGit(repoPath, args);
+  if (!result.ok) throw new Error(result.stderr.trim() || `git ${args.join(" ")} failed`);
+  return result.stdout.trim();
+}
+function gitOutput(repoPath, args) {
+  const result = runGit(repoPath, args);
+  return result.ok ? result.stdout.trim() : "";
+}
+function runGit(repoPath, args, showOutput = false) {
+  const result = spawnSync("git", ["-C", repoPath, ...args], {
+    encoding: "utf8",
+    stdio: showOutput ? ["inherit", "pipe", "pipe"] : "pipe"
+  });
+  return {
+    ok: !result.error && result.status === 0,
+    stdout: result.stdout ?? "",
+    stderr: result.error?.message ?? result.stderr ?? ""
+  };
+}
+function directorySizeMB(path2) {
+  if (!existsSync(path2)) return 0;
+  let bytes = 0;
+  const visit = (entryPath) => {
+    try {
+      const stat = lstatSync(entryPath);
+      if (stat.isSymbolicLink()) return;
+      if (stat.isFile()) {
+        bytes += stat.size;
+        return;
+      }
+      if (stat.isDirectory()) {
+        for (const entry of readdirSync(entryPath)) visit(join(entryPath, entry));
+      }
+    } catch {
+    }
+  };
+  visit(path2);
+  return Math.round(bytes / 1024 / 1024);
+}
+async function confirmRemoval() {
+  const readline = createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = await readline.question("\nRemove these worktrees? (y/N) ");
+    return ["y", "yes"].includes(answer.trim().toLowerCase());
+  } finally {
+    readline.close();
+  }
+}
+function writeUsage(stream) {
+  stream.write(
+    "Usage: dx worktree cleanup [repo-name-or-path] [--repos-root <path>] [--remote <name>] [--dry-run] [--force] [--no-fetch]\n\nWith no repo, the current git repository is used. A repo name is searched for under ./repos by default.\n"
+  );
+}
+var init_worktree_cleanup = __esm({
+  "src/worktree-cleanup.ts"() {
+  }
+});
+
 // src/ascii/compose.ts
 function composeAsciiText(font, text) {
   const charBlocks = [];
@@ -1517,6 +1926,7 @@ function getGlitterIntensity(cell, loop) {
   return Math.max(0.55, Math.min(1, 0.68 + flow + sparkBoost));
 }
 function createRowColorPalette(options) {
+  assertGifPaletteSize("row-color", 1 + options.rowColors.length * options.levels);
   const bg = parseColor(options.backgroundColor);
   const blend = parseColor(options.blendColor);
   const table = [bg.r, bg.g, bg.b];
@@ -1557,6 +1967,7 @@ function resolveFont(font) {
   return readFileSync(font, "utf-8");
 }
 function createMultiAccentPalette(options) {
+  assertGifPaletteSize("accent", 1 + (1 + options.accentColors.length) * options.levels);
   const bg = parseColor(options.backgroundColor);
   const blend = parseColor(options.blendColor);
   const base = parseColor(options.color);
@@ -1577,8 +1988,13 @@ function createMultiAccentPalette(options) {
   while (table.length < 256 * 3) table.push(0, 0, 0);
   return { table: Uint8Array.from(table.slice(0, 256 * 3)) };
 }
-function parseColor(input2) {
-  const color = input2.trim();
+function assertGifPaletteSize(mode, entries) {
+  if (entries > 256) {
+    throw new Error(`GIF palette supports at most 256 entries; ${mode} mode requires ${entries}`);
+  }
+}
+function parseColor(input3) {
+  const color = input3.trim();
   const shortHex = /^#([0-9a-f]{3})$/i.exec(color);
   if (shortHex) {
     const [r, g, b] = shortHex[1].split("").map((part) => Number.parseInt(part + part, 16));
@@ -1601,7 +2017,7 @@ function parseColor(input2) {
       b: clampByte(Number.parseInt(rgb[3], 10))
     };
   }
-  throw new Error(`Unsupported color "${input2}". Use #rgb, #rrggbb, or rgb(r,g,b).`);
+  throw new Error(`Unsupported color "${input3}". Use #rgb, #rrggbb, or rgb(r,g,b).`);
 }
 function mix(a, b, amount) {
   return {
@@ -1645,8 +2061,8 @@ function lzwEncode(indices, minCodeSize) {
   const clearCode = 1 << minCodeSize;
   const endCode = clearCode + 1;
   let codeSize = minCodeSize + 1;
-  const output2 = [];
-  const writeCode = createBitWriter(output2);
+  const output3 = [];
+  const writeCode = createBitWriter(output3);
   writeCode(clearCode, codeSize);
   let codesSinceClear = 0;
   for (const index of indices) {
@@ -1660,14 +2076,14 @@ function lzwEncode(indices, minCodeSize) {
   }
   writeCode(endCode, codeSize);
   writeCode(-1, 0);
-  return Uint8Array.from(output2);
+  return Uint8Array.from(output3);
 }
-function createBitWriter(output2) {
+function createBitWriter(output3) {
   let buffer = 0;
   let bitCount = 0;
   return (code, size) => {
     if (code < 0) {
-      if (bitCount > 0) output2.push(buffer & 255);
+      if (bitCount > 0) output3.push(buffer & 255);
       buffer = 0;
       bitCount = 0;
       return;
@@ -1675,7 +2091,7 @@ function createBitWriter(output2) {
     buffer |= code << bitCount;
     bitCount += size;
     while (bitCount >= 8) {
-      output2.push(buffer & 255);
+      output3.push(buffer & 255);
       buffer >>= 8;
       bitCount -= 8;
     }
@@ -1936,17 +2352,169 @@ var init_generate_assets = __esm({
     ];
   }
 });
+
+// src/env-check.ts
+var env_check_exports = {};
+__export(env_check_exports, {
+  checkEnv: () => checkEnv,
+  formatEnvReport: () => formatEnvReport,
+  parseEnv: () => parseEnv
+});
+function parseEnv(source) {
+  const keys = /* @__PURE__ */ new Map();
+  const duplicates = [];
+  const malformed = [];
+  source.split(/\r?\n/).forEach((raw, index) => {
+    const line = raw.trim();
+    if (line === "" || line.startsWith("#")) return;
+    const withoutExport = line.replace(/^export\s+/, "");
+    const eq = withoutExport.indexOf("=");
+    if (eq <= 0) {
+      malformed.push({ line: index + 1, text: withoutExport.slice(0, 24) });
+      return;
+    }
+    const key = withoutExport.slice(0, eq).trim();
+    const value = withoutExport.slice(eq + 1).trim();
+    if (keys.has(key)) duplicates.push(key);
+    keys.set(key, value !== "" && value !== '""' && value !== "''");
+  });
+  return { keys, duplicates, malformed };
+}
+function findRenameCandidate(unknownKey, knownKeys) {
+  const normalise = (key) => key.replace(/[^A-Z0-9]/gi, "").toUpperCase();
+  const target = normalise(unknownKey);
+  return knownKeys.find((known) => {
+    const candidate = normalise(known);
+    if (candidate === target) return true;
+    return candidate.length >= 6 && (target.endsWith(candidate) || target.startsWith(candidate));
+  });
+}
+function checkEnv({
+  example,
+  actual,
+  /** Keys allowed to be absent, e.g. optional credentials. */
+  optional = []
+}) {
+  const exampleEnv = parseEnv(example);
+  const actualEnv = parseEnv(actual);
+  const optionalSet = new Set(optional);
+  const exampleKeys = [...exampleEnv.keys.keys()];
+  const findings = [];
+  let okCount = 0;
+  for (const key of exampleKeys) {
+    if (!actualEnv.keys.has(key)) {
+      if (!optionalSet.has(key)) findings.push({ kind: "missing", key });
+      continue;
+    }
+    const hasValue = actualEnv.keys.get(key) === true;
+    const exampleHasValue = exampleEnv.keys.get(key) === true;
+    if (!hasValue && exampleHasValue && !optionalSet.has(key)) {
+      findings.push({ kind: "empty", key });
+      continue;
+    }
+    okCount += 1;
+  }
+  for (const key of actualEnv.keys.keys()) {
+    if (exampleEnv.keys.has(key)) continue;
+    const looksLike = findRenameCandidate(key, exampleKeys);
+    findings.push(looksLike ? { kind: "renamed", key, looksLike } : { kind: "unknown", key });
+  }
+  for (const key of actualEnv.duplicates) findings.push({ kind: "duplicate", key });
+  for (const line of actualEnv.malformed) findings.push({ kind: "malformed", ...line });
+  return {
+    findings,
+    okCount,
+    exampleCount: exampleEnv.keys.size,
+    actualCount: actualEnv.keys.size
+  };
+}
+function formatEnvReport(result) {
+  const lines = [];
+  lines.push(
+    `  ${result.actualCount} keys checked against ${result.exampleCount} in the example, ${result.okCount} correct`
+  );
+  if (result.findings.length === 0) {
+    lines.push("\nPASS \u2014 environment matches the example.");
+    return lines.join("\n");
+  }
+  for (const kind of ORDER) {
+    const group = result.findings.filter((finding) => finding.kind === kind);
+    if (group.length === 0) continue;
+    lines.push(`
+${LABELS[kind]}:`);
+    for (const finding of group) {
+      if (finding.kind === "renamed") {
+        lines.push(`  \u2717 ${finding.key}  \u2192  did you mean ${finding.looksLike}?`);
+      } else if (finding.kind === "malformed") {
+        lines.push(`  \u2717 line ${finding.line}: ${finding.text}\u2026`);
+      } else {
+        lines.push(`  \u2717 ${finding.key}`);
+      }
+    }
+  }
+  const renamed = result.findings.filter((finding) => finding.kind === "renamed").length;
+  if (renamed > 0) {
+    lines.push(
+      `
+${renamed} key(s) look renamed. The setting they were meant to carry is unset,
+which usually means a default is in force that nobody chose.`
+    );
+  }
+  lines.push(`
+FAIL \u2014 ${result.findings.length} finding(s).`);
+  return lines.join("\n");
+}
+var ORDER, LABELS;
+var init_env_check = __esm({
+  "src/env-check.ts"() {
+    ORDER = [
+      "renamed",
+      "missing",
+      "empty",
+      "malformed",
+      "duplicate",
+      "unknown"
+    ];
+    LABELS = {
+      renamed: "Renamed \u2014 set under a name nothing reads",
+      missing: "Missing",
+      empty: "Present but empty",
+      malformed: "Malformed line",
+      duplicate: "Set more than once",
+      unknown: "Unknown \u2014 not in the example"
+    };
+  }
+});
+
+// src/skills.ts
+function isSafeSkillSlug(slug) {
+  return slug !== "." && slug !== ".." && /^[A-Za-z0-9._-]+$/.test(slug);
+}
+
+// src/cli.ts
+var BREAK = "\n";
 var DEFAULT_SOURCE = "https://olwiba.com/skills/manifest.json";
 var [command, subcommand] = process.argv.slice(2);
 if (command === "skills" && subcommand === "install") {
   await runSkillsInstall();
+} else if ((command === "worktree" || command === "wt") && subcommand === "cleanup") {
+  const { runWorktreeCleanup: runWorktreeCleanup2 } = await Promise.resolve().then(() => (init_worktree_cleanup(), worktree_cleanup_exports));
+  try {
+    process.exitCode = await runWorktreeCleanup2(process.argv.slice(4));
+  } catch (error) {
+    process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 1;
+  }
 } else if (command === "ascii-gif") {
   await runAsciiGif();
 } else if (command === "generate-assets") {
   await runGenerateAssets();
+} else if (command === "env-check" || command === "env") {
+  process.exitCode = await runEnvCheck();
 } else {
   process.stdout.write(
-    "Usage:\n  dx skills install [--source <url>] [--target claude|amp] [--all] [--name a,b,c]\n  dx ascii-gif --text <text> --out <file.gif>\n  dx generate-assets --name <app> --icon <lucide-icon> --color <#hex> [--out <dir>] [--og-component <svg-or-image-path>]\n"
+    "Usage:\n  dx skills install [--source <url>] [--target claude|amp] [--all] [--name a,b,c]\n  dx worktree cleanup [repo-name-or-path] [--repos-root <path>] [--remote <name>] [--dry-run] [--force] [--no-fetch]\n  dx ascii-gif --text <text> --out <file.gif>\n  dx generate-assets --name <app> --icon <lucide-icon> --color <#hex> [--out <dir>] [--og-component <svg-or-image-path>]\n"
   );
 }
 async function runSkillsInstall() {
@@ -1960,7 +2528,7 @@ async function runSkillsInstall() {
     return;
   }
   const targetDir = target === "amp" ? join(".amp", "skills") : join(".claude", "skills");
-  process.stdout.write(`Fetching manifest from ${source}
+  process.stdout.write(`Fetching manifest from ${safeUrlForDisplay(source)}
 `);
   let manifest;
   try {
@@ -1968,8 +2536,7 @@ async function runSkillsInstall() {
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
     manifest = await res.json();
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`Failed to fetch manifest: ${message}
+    process.stderr.write(`Failed to fetch manifest: ${safeRequestError(err)}
 `);
     process.exitCode = 1;
     return;
@@ -1988,10 +2555,22 @@ async function runSkillsInstall() {
   let installed = 0;
   let failed = 0;
   for (const skill of selected) {
-    const skillDir = join(installDir, skill.slug);
+    if (!isSafeSkillSlug(skill.slug)) {
+      process.stderr.write("  \u2717 invalid skill slug\n");
+      failed++;
+      continue;
+    }
+    const skillDir = resolve(installDir, skill.slug);
+    const relativeDestination = relative(installDir, skillDir);
+    if (!relativeDestination || relativeDestination === ".." || relativeDestination.startsWith(`..${sep}`) || isAbsolute(relativeDestination)) {
+      process.stderr.write(`  \u2717 ${skill.slug}: invalid install destination
+`);
+      failed++;
+      continue;
+    }
     const skillPath = join(skillDir, "SKILL.md");
-    const url = new URL(skill.contentUrl, source).toString();
     try {
+      const url = new URL(skill.contentUrl, source).toString();
       const res = await fetch(url);
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const content = await res.text();
@@ -2001,8 +2580,7 @@ async function runSkillsInstall() {
 `);
       installed++;
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`  \u2717 ${skill.slug}: ${message}
+      process.stderr.write(`  \u2717 ${skill.slug}: ${safeRequestError(err)}
 `);
       failed++;
     }
@@ -2012,6 +2590,23 @@ ${installed} installed, ${failed} failed
 `);
   process.stdout.write(`Location: ${targetDir}/
 `);
+  if (failed > 0) process.exitCode = 1;
+}
+function safeUrlForDisplay(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return "custom source";
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return "custom source";
+  }
+}
+function safeRequestError(error) {
+  return error instanceof Error && /^HTTP \d{3}$/.test(error.message) ? error.message : "request failed";
 }
 async function selectSkills(skills, flags) {
   if (flags.all === "true") return skills;
@@ -2138,3 +2733,47 @@ function parseNumberFlag(value) {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : void 0;
 }
+async function runEnvCheck() {
+  const { readFileSync: readFileSync3, existsSync: existsSync2 } = await import('fs');
+  const { checkEnv: checkEnv2, formatEnvReport: formatEnvReport2 } = await Promise.resolve().then(() => (init_env_check(), env_check_exports));
+  const flags = parseFlags(process.argv.slice(3));
+  const examplePath = flags.example ?? ".env.example";
+  if (!existsSync2(examplePath)) {
+    process.stderr.write(
+      `No example file at ${examplePath}.${BREAK}It is the schema this compares against; pass --example to point elsewhere.` + BREAK
+    );
+    return 1;
+  }
+  const example = readFileSync3(examplePath, "utf8");
+  let actual;
+  if (flags.file) {
+    if (!existsSync2(flags.file)) {
+      process.stderr.write(`No environment file at ${flags.file}.${BREAK}`);
+      return 1;
+    }
+    actual = readFileSync3(flags.file, "utf8");
+  } else {
+    if (stdin.isTTY) {
+      process.stdout.write(
+        `Paste the environment below, then press ${process.platform === "win32" ? "Ctrl+Z and Enter" : "Ctrl+D"}.${BREAK}Nothing is stored or transmitted.` + BREAK + BREAK
+      );
+    }
+    actual = await readAllStdin();
+    if (actual.trim() === "") {
+      process.stderr.write("Nothing to check. Pass --file <path> or paste an environment." + BREAK);
+      return 1;
+    }
+  }
+  const result = checkEnv2({
+    example,
+    actual,
+    optional: flags.optional ? flags.optional.split(",").map((key) => key.trim()).filter(Boolean) : []
+  });
+  process.stdout.write(`${formatEnvReport2(result)}${BREAK}`);
+  return result.findings.length > 0 ? 1 : 0;
+}
+async function readAllStdin() {
+  const chunks = [];
+  for await (const chunk of stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}