@olwiba/dx 0.0.22 → 0.0.24

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;
     }
@@ -1740,6 +2156,14 @@ function getSvgInner(svgPath) {
   const inner = svg.replace(/<svg[^>]*>/, "").replace(/<\/svg>/, "").trim();
   return { inner, viewBox };
 }
+function resolveIcon(icon) {
+  const mode = detectIconMode(icon);
+  if (mode === "svg") {
+    const { inner, viewBox } = getSvgInner(icon);
+    return { mode, inner, viewBox };
+  }
+  return { mode, inner: getLucideInner(icon), viewBox: 24 };
+}
 function buildIconSvgLucide(inner, color, size) {
   const pad = Math.round(size * 0.18);
   const area = size - pad * 2;
@@ -1798,8 +2222,44 @@ function buildOgSvgCustom(inner, viewBox, color) {
   </g>
 </svg>`;
 }
+function buildOgGlowSvg(box) {
+  const spread = 40;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${OG_WIDTH}" height="${OG_HEIGHT}">
+  <defs>
+    <filter id="glow" x="-40%" y="-40%" width="180%" height="180%">
+      <feGaussianBlur stdDeviation="46"/>
+    </filter>
+  </defs>
+  <rect x="${box.left - spread}" y="${box.top - spread}" width="${box.width + spread * 2}" height="${box.height + spread * 2}" rx="48" fill="#ffffff" opacity="0.22" filter="url(#glow)"/>
+</svg>`;
+}
+function buildOgSvgWithSmallLogo(mode, inner, viewBox, color, name) {
+  const markSize = OG_HEADER.markSize;
+  const gap = 28;
+  const fontSize = 56;
+  const groupY = OG_HEADER.top;
+  const scale = markSize / viewBox;
+  const textWidth = Math.round(name.length * fontSize * 0.58);
+  const totalWidth = markSize + gap + textWidth;
+  const groupX = Math.round((1200 - totalWidth) / 2);
+  const logoMarkup = mode === "lucide" ? (() => {
+    const sw = (2.5 / scale).toFixed(4);
+    return `<g transform="translate(${groupX} ${groupY}) scale(${scale})" stroke="white" fill="none" stroke-width="${sw}" stroke-linecap="round" stroke-linejoin="round">
+    ${inner}
+  </g>`;
+  })() : `<g transform="translate(${groupX} ${groupY}) scale(${scale})">
+    ${inner}
+  </g>`;
+  const textX = groupX + markSize + gap;
+  const textY = groupY + markSize / 2;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${OG_WIDTH}" height="${OG_HEIGHT}">
+  <rect width="${OG_WIDTH}" height="${OG_HEIGHT}" fill="${color}"/>
+  ${logoMarkup}
+  <text x="${textX}" y="${textY}" font-family="-apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif" font-size="${fontSize}" font-weight="700" fill="white" dominant-baseline="middle" letter-spacing="-1">${escapeXml(name)}</text>
+</svg>`;
+}
 async function generateAssets(config) {
-  const { name, icon, color, outputDir } = config;
+  const { name, icon, color, outputDir, ogComponent } = config;
   let sharpFn;
   try {
     sharpFn = (await import('sharp')).default;
@@ -1811,17 +2271,8 @@ async function generateAssets(config) {
   mkdirSync(outputDir, { recursive: true });
   const faviconDir = join(outputDir, "favicon");
   mkdirSync(faviconDir, { recursive: true });
-  const mode = detectIconMode(icon);
   const written = [];
-  let inner;
-  let viewBox = 24;
-  if (mode === "svg") {
-    const parsed = getSvgInner(icon);
-    inner = parsed.inner;
-    viewBox = parsed.viewBox;
-  } else {
-    inner = getLucideInner(icon);
-  }
+  const { mode, inner, viewBox } = resolveIcon(icon);
   const buildIcon = (size) => mode === "svg" ? buildIconSvgCustom(inner, viewBox, color, size) : buildIconSvgLucide(inner, color, size);
   for (const size of FAVICON_SIZES) {
     const png = await sharpFn(Buffer.from(buildIcon(size))).png().toBuffer();
@@ -1835,8 +2286,31 @@ async function generateAssets(config) {
     writeFileSync(dest, png);
     written.push(dest);
   }
-  const ogSvg = mode === "svg" ? buildOgSvgCustom(inner, viewBox, color) : buildOgSvgLucide(inner, name, color);
-  const ogPng = await sharpFn(Buffer.from(ogSvg)).png().toBuffer();
+  const ogSvg = ogComponent ? buildOgSvgWithSmallLogo(mode, inner, viewBox, color, name) : mode === "svg" ? buildOgSvgCustom(inner, viewBox, color) : buildOgSvgLucide(inner, name, color);
+  let ogPng = await sharpFn(Buffer.from(ogSvg)).png().toBuffer();
+  if (ogComponent) {
+    const sideMargin = 72;
+    const maxWidth = OG_WIDTH - sideMargin * 2;
+    const headerBottom = OG_HEADER.top + OG_HEADER.markSize + OG_HEADER.gapBelow;
+    const componentBuf = readFileSync(resolve(process.cwd(), ogComponent));
+    const resized = await sharpFn(componentBuf, { density: 300 }).resize({ width: maxWidth, withoutEnlargement: true }).png().toBuffer();
+    const { width: compWidth = maxWidth, height: compHeight = 0 } = await sharpFn(resized).metadata();
+    const left = Math.round((OG_WIDTH - compWidth) / 2);
+    const fits = headerBottom + compHeight <= OG_HEIGHT;
+    const top = fits ? Math.round(headerBottom + (OG_HEIGHT - headerBottom - compHeight) / 2) : headerBottom;
+    ogPng = await sharpFn(ogPng).composite([
+      // Glow first: it has to sit under the component, and sharp applies
+      // composites in array order.
+      {
+        input: Buffer.from(
+          buildOgGlowSvg({ left, top, width: compWidth, height: compHeight })
+        ),
+        left: 0,
+        top: 0
+      },
+      { input: resized, left, top }
+    ]).png().toBuffer();
+  }
   const ogDest = join(outputDir, "og-image.png");
   writeFileSync(ogDest, ogPng);
   written.push(ogDest);
@@ -1859,9 +2333,17 @@ async function generateAssets(config) {
   written.push(robotsDest);
   return { files: written };
 }
-var FAVICON_SIZES, NAMED_ICONS;
+var OG_WIDTH, OG_HEIGHT, OG_HEADER, FAVICON_SIZES, NAMED_ICONS;
 var init_generate_assets = __esm({
   "src/generate-assets.ts"() {
+    OG_WIDTH = 1200;
+    OG_HEIGHT = 630;
+    OG_HEADER = {
+      top: 54,
+      markSize: 96,
+      /** Clear space between the wordmark's baseline and the component. */
+      gapBelow: 30
+    };
     FAVICON_SIZES = [16, 32, 48, 64, 192, 512];
     NAMED_ICONS = [
       ["apple-touch-icon.png", 180],
@@ -1870,17 +2352,33 @@ var init_generate_assets = __esm({
     ];
   }
 });
+
+// src/skills.ts
+function isSafeSkillSlug(slug) {
+  return slug !== "." && slug !== ".." && /^[A-Za-z0-9._-]+$/.test(slug);
+}
+
+// src/cli.ts
 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 {
   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>]\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() {
@@ -1894,7 +2392,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 {
@@ -1902,8 +2400,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;
@@ -1922,10 +2419,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();
@@ -1935,8 +2444,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++;
     }
@@ -1946,6 +2454,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;
@@ -2044,9 +2569,10 @@ async function runGenerateAssets() {
   const icon = flags.icon;
   const color = flags.color;
   const outputDir = flags.out ?? flags.output ?? "public";
+  const ogComponent = flags["og-component"];
   if (!name || !icon || !color) {
     process.stderr.write(
-      "Usage: dx generate-assets --name <app> --icon <lucide-icon> --color <#hex> [--out <dir>]\n"
+      "Usage: dx generate-assets --name <app> --icon <lucide-icon> --color <#hex> [--out <dir>] [--og-component <svg-or-image-path>]\n"
     );
     process.exitCode = 1;
     return;
@@ -2054,7 +2580,7 @@ async function runGenerateAssets() {
   process.stdout.write(`Generating assets for "${name}"\u2026
 `);
   try {
-    const result = await generateAssets2({ name, icon, color, outputDir });
+    const result = await generateAssets2({ name, icon, color, outputDir, ogComponent });
     process.stdout.write(`Generated ${result.files.length} files in ${outputDir}/
 `);
     for (const f of result.files) process.stdout.write(`  ${f}