agent-loadout 0.1.0

package/dist/index.js

@@ -0,0 +1,1577 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk6 from "chalk";
+
+// src/catalog.ts
+var PRESETS = [
+  {
+    id: "core",
+    name: "Core",
+    description: "Fundamentals every terminal should have",
+    defaultOn: true
+  },
+  {
+    id: "agent",
+    name: "Agent",
+    description: "Tools that specifically improve LLM workflows",
+    defaultOn: true
+  },
+  {
+    id: "media",
+    name: "Media",
+    description: "Image, audio, and video pipeline tools",
+    defaultOn: false
+  },
+  {
+    id: "dx",
+    name: "DX",
+    description: "Developer experience and quality of life",
+    defaultOn: false
+  },
+  {
+    id: "security",
+    name: "Security",
+    description: "Scanning and CI hygiene",
+    defaultOn: false
+  }
+];
+var TOOLS = [
+  // ── Core ──────────────────────────────────────────────
+  {
+    id: "rg",
+    name: "ripgrep",
+    package: "ripgrep",
+    installMethod: "brew",
+    verify: "rg --version",
+    description: "Fast code search",
+    preset: "core"
+  },
+  {
+    id: "fd",
+    name: "fd",
+    package: "fd",
+    installMethod: "brew",
+    verify: "fd --version",
+    description: "Fast file finder",
+    preset: "core"
+  },
+  {
+    id: "jq",
+    name: "jq",
+    package: "jq",
+    installMethod: "brew",
+    verify: "jq --version",
+    description: "JSON processor",
+    preset: "core"
+  },
+  {
+    id: "yq",
+    name: "yq",
+    package: "yq",
+    installMethod: "brew",
+    verify: "yq --version",
+    description: "YAML processor",
+    preset: "core"
+  },
+  {
+    id: "bat",
+    name: "bat",
+    package: "bat",
+    installMethod: "brew",
+    verify: "bat --version",
+    description: "Cat with syntax highlighting",
+    preset: "core"
+  },
+  {
+    id: "tree",
+    name: "tree",
+    package: "tree",
+    installMethod: "brew",
+    verify: "tree --version",
+    description: "Directory structure viewer",
+    preset: "core"
+  },
+  {
+    id: "gh",
+    name: "GitHub CLI",
+    package: "gh",
+    installMethod: "brew",
+    verify: "gh --version",
+    description: "GitHub CLI for PRs, issues, releases",
+    preset: "core"
+  },
+  {
+    id: "fzf",
+    name: "fzf",
+    package: "fzf",
+    installMethod: "brew",
+    verify: "fzf --version",
+    description: "Fuzzy finder",
+    preset: "core"
+  },
+  {
+    id: "xh",
+    name: "xh",
+    package: "xh",
+    installMethod: "brew",
+    verify: "xh --version",
+    description: "Friendly HTTP client",
+    preset: "core"
+  },
+  // ── Agent ─────────────────────────────────────────────
+  {
+    id: "shellcheck",
+    name: "shellcheck",
+    package: "shellcheck",
+    installMethod: "brew",
+    verify: "shellcheck --version",
+    description: "Static analysis for shell scripts",
+    preset: "agent"
+  },
+  {
+    id: "ast-grep",
+    name: "ast-grep",
+    package: "ast-grep",
+    installMethod: "brew",
+    verify: "sg --version",
+    description: "Structural code search/replace",
+    preset: "agent"
+  },
+  {
+    id: "just",
+    name: "just",
+    package: "just",
+    installMethod: "brew",
+    verify: "just --version",
+    description: "Command runner (agent-readable task menu)",
+    preset: "agent"
+  },
+  {
+    id: "grex",
+    name: "grex",
+    package: "grex",
+    installMethod: "brew",
+    verify: "grex --version",
+    description: "Generate regex from examples",
+    preset: "agent"
+  },
+  {
+    id: "knip",
+    name: "knip",
+    package: "knip",
+    installMethod: "npm",
+    verify: "knip --version",
+    description: "Find unused code/deps in TS/JS",
+    preset: "agent"
+  },
+  {
+    id: "sd",
+    name: "sd",
+    package: "sd",
+    installMethod: "brew",
+    verify: "sd --version",
+    description: "Simpler sed replacement",
+    preset: "agent"
+  },
+  {
+    id: "hyperfine",
+    name: "hyperfine",
+    package: "hyperfine",
+    installMethod: "brew",
+    verify: "hyperfine --version",
+    description: "CLI benchmarking",
+    preset: "agent"
+  },
+  {
+    id: "tokei",
+    name: "tokei",
+    package: "tokei",
+    installMethod: "brew",
+    verify: "tokei --version",
+    description: "Code statistics",
+    preset: "agent"
+  },
+  {
+    id: "tldr",
+    name: "tldr",
+    package: "tldr",
+    installMethod: "brew",
+    verify: "tldr --version",
+    description: "Quick man page summaries",
+    preset: "agent"
+  },
+  {
+    id: "biome",
+    name: "biome",
+    package: "biome",
+    installMethod: "brew",
+    verify: "biome --version",
+    description: "Lint + format JS/TS",
+    preset: "agent"
+  },
+  {
+    id: "difftastic",
+    name: "difftastic",
+    package: "difftastic",
+    installMethod: "brew",
+    verify: "difft --version",
+    description: "Structural/AST diff",
+    preset: "agent"
+  },
+  // ── Media ─────────────────────────────────────────────
+  {
+    id: "ffmpeg",
+    name: "ffmpeg",
+    package: "ffmpeg",
+    installMethod: "brew",
+    verify: "ffmpeg -version",
+    description: "Audio/video Swiss army knife",
+    preset: "media"
+  },
+  {
+    id: "exiftool",
+    name: "exiftool",
+    package: "exiftool",
+    installMethod: "brew",
+    verify: "exiftool -ver",
+    description: "Image/media metadata",
+    preset: "media"
+  },
+  {
+    id: "imagemagick",
+    name: "ImageMagick",
+    package: "imagemagick",
+    installMethod: "brew",
+    verify: "magick -version",
+    description: "Image transforms",
+    preset: "media"
+  },
+  {
+    id: "svgo",
+    name: "svgo",
+    package: "svgo",
+    installMethod: "npm",
+    verify: "svgo --version",
+    description: "SVG optimiser",
+    preset: "media"
+  },
+  // ── DX ────────────────────────────────────────────────
+  {
+    id: "eza",
+    name: "eza",
+    package: "eza",
+    installMethod: "brew",
+    verify: "eza --version",
+    description: "Modern ls replacement",
+    preset: "dx"
+  },
+  {
+    id: "zoxide",
+    name: "zoxide",
+    package: "zoxide",
+    installMethod: "brew",
+    verify: "zoxide --version",
+    description: "Smarter cd",
+    preset: "dx"
+  },
+  {
+    id: "delta",
+    name: "delta",
+    package: "git-delta",
+    installMethod: "brew",
+    verify: "delta --version",
+    description: "Better git diffs",
+    preset: "dx"
+  },
+  {
+    id: "glow",
+    name: "glow",
+    package: "glow",
+    installMethod: "brew",
+    verify: "glow --version",
+    description: "Terminal markdown renderer",
+    preset: "dx"
+  },
+  {
+    id: "mise",
+    name: "mise",
+    package: "mise",
+    installMethod: "brew",
+    verify: "mise --version",
+    description: "Runtime version manager",
+    preset: "dx"
+  },
+  {
+    id: "watchexec",
+    name: "watchexec",
+    package: "watchexec",
+    installMethod: "brew",
+    verify: "watchexec --version",
+    description: "Run commands on file change",
+    preset: "dx"
+  },
+  {
+    id: "mkcert",
+    name: "mkcert",
+    package: "mkcert",
+    installMethod: "brew",
+    verify: "mkcert --version",
+    description: "Local HTTPS certs",
+    preset: "dx"
+  },
+  {
+    id: "lazygit",
+    name: "lazygit",
+    package: "lazygit",
+    installMethod: "brew",
+    verify: "lazygit --version",
+    description: "TUI git client",
+    preset: "dx"
+  },
+  {
+    id: "dust",
+    name: "dust",
+    package: "dust",
+    installMethod: "brew",
+    verify: "dust --version",
+    description: "Disk usage tree",
+    preset: "dx"
+  },
+  {
+    id: "btm",
+    name: "bottom",
+    package: "bottom",
+    installMethod: "brew",
+    verify: "btm --version",
+    description: "System monitor TUI",
+    preset: "dx"
+  },
+  // ── Security ──────────────────────────────────────────
+  {
+    id: "trivy",
+    name: "trivy",
+    package: "trivy",
+    installMethod: "brew",
+    verify: "trivy --version",
+    description: "Vulnerability scanner",
+    preset: "security"
+  },
+  {
+    id: "act",
+    name: "act",
+    package: "act",
+    installMethod: "brew",
+    verify: "act --version",
+    description: "Run GitHub Actions locally",
+    preset: "security"
+  },
+  {
+    id: "gitleaks",
+    name: "gitleaks",
+    package: "gitleaks",
+    installMethod: "brew",
+    verify: "gitleaks version",
+    description: "Secrets scanner",
+    preset: "security"
+  }
+];
+function getToolsByPreset(presetId) {
+  return TOOLS.filter((t) => t.preset === presetId);
+}
+function getToolsByIds(ids) {
+  return TOOLS.filter((t) => ids.includes(t.id));
+}
+
+// src/brew.ts
+import { writeFile } from "fs/promises";
+import { execa } from "execa";
+import chalk from "chalk";
+
+// src/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdir } from "fs/promises";
+var BASE_DIR = join(homedir(), ".agent-loadout");
+var SKILLS_DIR = join(homedir(), ".claude", "skills");
+var paths = {
+  base: BASE_DIR,
+  receipt: join(BASE_DIR, "receipt.json"),
+  brewfile: join(BASE_DIR, "Brewfile"),
+  skills: SKILLS_DIR
+};
+async function ensureDir() {
+  await mkdir(paths.base, { recursive: true });
+}
+async function ensureSkillsDir() {
+  await mkdir(paths.skills, { recursive: true });
+}
+
+// src/brew.ts
+async function checkBrewInstalled() {
+  try {
+    await execa("brew", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function generateBrewfile(tools) {
+  const brewTools = tools.filter((t) => t.installMethod === "brew");
+  if (brewTools.length === 0) return "";
+  const lines = brewTools.map((t) => `brew "${t.package}"`);
+  return lines.join("\n") + "\n";
+}
+async function writeBrewfile(content) {
+  await ensureDir();
+  await writeFile(paths.brewfile, content);
+}
+async function runBrewBundle() {
+  try {
+    await execa("brew", ["bundle", "--file", paths.brewfile], {
+      stdio: "inherit"
+    });
+  } catch {
+    console.log(
+      chalk.yellow(
+        "\n  Some brew packages may have failed to install. Run 'brew bundle --file ~/.agent-loadout/Brewfile' to retry."
+      )
+    );
+  }
+}
+
+// src/npm.ts
+import { execa as execa2 } from "execa";
+import chalk2 from "chalk";
+async function checkNpmInstalled() {
+  try {
+    await execa2("npm", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getNpmTools(tools) {
+  return tools.filter((t) => t.installMethod === "npm");
+}
+function getNpmInstallCommand(tools) {
+  const npmTools = getNpmTools(tools);
+  if (npmTools.length === 0) return [];
+  return npmTools.map((t) => t.package);
+}
+async function runNpmInstall(packages) {
+  if (packages.length === 0) return true;
+  try {
+    await execa2("npm", ["install", "-g", ...packages], { stdio: "inherit" });
+    return true;
+  } catch {
+    console.log(
+      chalk2.yellow(
+        `
+  npm install failed. Try manually: npm install -g ${packages.join(" ")}`
+      )
+    );
+    return false;
+  }
+}
+
+// src/verify.ts
+import { execa as execa3 } from "execa";
+import chalk3 from "chalk";
+async function checkTool(tool) {
+  try {
+    const [cmd, ...args] = tool.verify.split(" ");
+    const result = await execa3(cmd, args, { timeout: 5e3 });
+    const version = result.stdout.split("\n")[0].trim();
+    return { id: tool.id, name: tool.name, installed: true, version };
+  } catch {
+    return { id: tool.id, name: tool.name, installed: false, version: "" };
+  }
+}
+async function verifyTools(tools) {
+  return Promise.all(tools.map(checkTool));
+}
+function printVerifyResults(results) {
+  const maxName = Math.max(...results.map((r) => r.name.length));
+  for (const r of results) {
+    const name = r.name.padEnd(maxName);
+    if (r.installed) {
+      console.log(`  ${chalk3.green("\u2713")} ${name}  ${chalk3.dim(r.version)}`);
+    } else {
+      console.log(`  ${chalk3.red("\u2717")} ${name}  ${chalk3.red("not found")}`);
+    }
+  }
+  const installed = results.filter((r) => r.installed).length;
+  const total = results.length;
+  console.log();
+  console.log(
+    installed === total ? chalk3.green(`  All ${total} tools installed.`) : chalk3.yellow(`  ${installed}/${total} tools installed.`)
+  );
+}
+function verifyResultsToJson(results) {
+  const out = {};
+  for (const r of results) {
+    if (r.installed) out[r.id] = r.version;
+  }
+  return out;
+}
+
+// src/receipt.ts
+import { readFile, writeFile as writeFile2 } from "fs/promises";
+import chalk4 from "chalk";
+async function readReceipt() {
+  try {
+    const raw = await readFile(paths.receipt, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      console.log(
+        chalk4.yellow(
+          "  Warning: ~/.agent-loadout/receipt.json is corrupted. Ignoring."
+        )
+      );
+    }
+    return null;
+  }
+}
+async function writeReceipt(receipt) {
+  await ensureDir();
+  await writeFile2(paths.receipt, JSON.stringify(receipt, null, 2) + "\n");
+}
+
+// src/ui.ts
+import { checkbox, confirm } from "@inquirer/prompts";
+import chalk5 from "chalk";
+async function selectPresets() {
+  return checkbox({
+    message: "Which presets do you want to install?",
+    choices: PRESETS.map((p) => ({
+      name: `${p.name} \u2014 ${p.description}`,
+      value: p.id,
+      checked: p.defaultOn
+    }))
+  });
+}
+async function selectTools(presetIds) {
+  const available = presetIds.flatMap(getToolsByPreset);
+  const status = await verifyTools(available);
+  const installedIds = new Set(
+    status.filter((r) => r.installed).map((r) => r.id)
+  );
+  const selectedIds = await checkbox({
+    message: "Toggle individual tools (all selected by default)",
+    choices: available.map((t) => {
+      const badge = installedIds.has(t.id) ? chalk5.green(" (installed)") : "";
+      return {
+        name: `${t.name}${badge} \u2014 ${chalk5.dim(t.description)}`,
+        value: t.id,
+        checked: true
+      };
+    })
+  });
+  return TOOLS.filter((t) => selectedIds.includes(t.id));
+}
+function printPreview(tools) {
+  const brewfile = generateBrewfile(tools);
+  const npmPackages = getNpmInstallCommand(tools);
+  console.log();
+  if (brewfile) {
+    console.log(chalk5.bold("Brewfile:"));
+    console.log(chalk5.dim(brewfile));
+    console.log(
+      chalk5.dim("  \u2192 brew bundle --file ~/.agent-loadout/Brewfile")
+    );
+    console.log();
+  }
+  if (npmPackages.length > 0) {
+    console.log(chalk5.bold("npm globals:"));
+    console.log(chalk5.dim(`  \u2192 npm install -g ${npmPackages.join(" ")}`));
+    console.log();
+  }
+}
+async function confirmInstall() {
+  return confirm({ message: "Install now?", default: true });
+}
+
+// src/skills.ts
+import { writeFile as writeFile3 } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/skills/rg.ts
+var rg_default = `
+# ripgrep (rg) \u2014 Fast code search
+
+## When to use
+Search file contents across a codebase. Faster than grep, respects .gitignore by default.
+
+## Trusted commands
+- Search for a pattern: \`rg "pattern" path/\`
+- Fixed string (no regex): \`rg -F "exact string"\`
+- File type filter: \`rg "pattern" -t ts\` (ts, js, py, rust, go, etc.)
+- Glob filter: \`rg "pattern" -g '*.tsx'\`
+- Show context lines: \`rg "pattern" -C 3\`
+- Files only (no content): \`rg -l "pattern"\`
+- Count matches: \`rg -c "pattern"\`
+- Case insensitive: \`rg -i "pattern"\`
+
+## Output format
+\`file:line:column:matched_text\` \u2014 one match per line, stable and parseable.
+
+## Gotchas
+- Skips hidden files and .gitignore'd paths by default. Use \`--hidden\` or \`--no-ignore\` to include them.
+- For literal dots, brackets etc. in patterns, use \`-F\` (fixed string) to avoid regex escaping issues.
+`.trim();
+
+// src/skills/fd.ts
+var fd_default = `
+# fd \u2014 Fast file finder
+
+## When to use
+Find files by name pattern. Faster than \`find\`, respects .gitignore, sane defaults.
+
+## Trusted commands
+- Find by name: \`fd "pattern"\`
+- Find by extension: \`fd -e ts\`
+- Find exact filename: \`fd -g "package.json"\`
+- Include hidden files: \`fd --hidden "pattern"\`
+- Exec on each result: \`fd -e tmp -x rm {}\`
+- Type filter (file/dir/symlink): \`fd -t f "pattern"\`
+
+## Output format
+One path per line, relative to search root.
+
+## Gotchas
+- Regex by default. Use \`-g\` for glob patterns.
+- Ignores .gitignore'd files by default. Use \`--no-ignore\` to include.
+`.trim();
+
+// src/skills/jq.ts
+var jq_default = `
+# jq \u2014 JSON processor
+
+## When to use
+Filter, transform, and extract data from JSON. Essential for working with API responses and config files.
+
+## Trusted commands
+- Pretty print: \`cat file.json | jq .\`
+- Extract field: \`jq '.fieldName'\`
+- Pick multiple fields: \`jq '{id, name, status}'\`
+- Map over array: \`jq '[.items[] | {id, name}]'\`
+- Count array: \`jq '.items | length'\`
+- Filter: \`jq '.items[] | select(.status == "active")'\`
+- Default for missing: \`jq '.name // "unknown"'\`
+- Validate JSON (fail on error): \`jq -e .\`
+
+## Gotchas
+- Use \`-e\` flag to get non-zero exit code on null/false results.
+- Use \`-r\` for raw string output (no quotes).
+- Missing fields return null, not an error. Use \`//\` for defaults.
+`.trim();
+
+// src/skills/yq.ts
+var yq_default = `
+# yq \u2014 YAML processor
+
+## When to use
+Same as jq but for YAML files. Query, filter, and transform YAML.
+
+## Trusted commands
+- Read field: \`yq '.spec.replicas' file.yaml\`
+- Convert YAML to JSON: \`yq -o json file.yaml\`
+- Convert JSON to YAML: \`yq -P file.json\`
+- Update in place: \`yq -i '.version = "2.0"' file.yaml\`
+- Merge files: \`yq eval-all 'select(fi == 0) * select(fi == 1)' a.yaml b.yaml\`
+
+## Gotchas
+- There are multiple tools called yq. This refers to the Go version (mikefarah/yq), installed via brew.
+- Use \`-i\` carefully \u2014 it modifies files in place.
+`.trim();
+
+// src/skills/bat.ts
+var bat_default = `
+# bat \u2014 Cat with syntax highlighting
+
+## When to use
+View file contents with syntax highlighting, line numbers, and git diff indicators.
+
+## Trusted commands
+- View file: \`bat file.ts\`
+- Plain output (no decorations): \`bat --plain file.ts\`
+- Show line range: \`bat -r 10:20 file.ts\`
+- Force language: \`bat -l json file.txt\`
+- Use as pager for other commands: \`command | bat -l json\`
+`.trim();
+
+// src/skills/tree.ts
+var tree_default = `
+# tree \u2014 Directory structure viewer
+
+## When to use
+Visualise directory structure as a tree. Useful for understanding project layout.
+
+## Trusted commands
+- Current directory: \`tree\`
+- With depth limit: \`tree -L 2\`
+- Show only directories: \`tree -d\`
+- Ignore patterns: \`tree -I 'node_modules|dist'\`
+- With file sizes: \`tree -sh\`
+`.trim();
+
+// src/skills/gh.ts
+var gh_default = `
+# GitHub CLI (gh) \u2014 GitHub from the terminal
+
+## When to use
+Create PRs, manage issues, check CI status, manage releases \u2014 all without leaving the terminal.
+
+## Trusted commands
+- Create PR: \`gh pr create --title "title" --body "body"\`
+- View PR: \`gh pr view 123\`
+- List PRs: \`gh pr list\`
+- Check CI status: \`gh pr checks 123\`
+- Create issue: \`gh issue create --title "title" --body "body"\`
+- List issues: \`gh issue list\`
+- View repo: \`gh repo view\`
+- API calls: \`gh api repos/owner/repo/pulls/123/comments\`
+- Clone: \`gh repo clone owner/repo\`
+
+## Output format
+Supports \`--json\` on most commands for structured output. E.g. \`gh pr list --json number,title,state\`.
+
+## Gotchas
+- Requires authentication: \`gh auth login\`
+- \`gh api\` is very powerful for anything not covered by built-in commands.
+`.trim();
+
+// src/skills/fzf.ts
+var fzf_default = `
+# fzf \u2014 Fuzzy finder
+
+## When to use
+Interactive fuzzy search for files, command history, git branches \u2014 anything with a list.
+
+## Trusted commands
+- Find files: \`fzf\`
+- Pipe any list: \`git branch | fzf\`
+- Preview files: \`fzf --preview 'bat --color=always {}'\`
+- With fd: \`fd -t f | fzf\`
+
+## Gotchas
+- Primarily interactive \u2014 less useful for non-interactive agent workflows, but great when you're driving.
+`.trim();
+
+// src/skills/shellcheck.ts
+var shellcheck_default = `
+# shellcheck \u2014 Static analysis for shell scripts
+
+## When to use
+Lint shell scripts (bash, sh, dash) for common mistakes: quoting issues, unset variables, deprecated syntax, portability problems. Agents frequently generate shell scripts \u2014 shellcheck catches errors before they run.
+
+## Trusted commands
+- Check a script: \`shellcheck script.sh\`
+- Check with specific shell: \`shellcheck --shell=bash script.sh\`
+- JSON output: \`shellcheck --format=json script.sh\`
+- GCC-style output: \`shellcheck --format=gcc script.sh\`
+- Exclude specific rules: \`shellcheck --exclude=SC2034 script.sh\`
+- Check from stdin: \`echo '#!/bin/bash' | shellcheck -\`
+
+## Output format
+Default output is human-readable with line numbers and fix suggestions. Use \`--format=json\` for structured output.
+
+## Gotchas
+- Scripts need a shebang (\`#!/bin/bash\`) or use \`--shell=\` flag.
+- SC codes (e.g. SC2086) link to detailed wiki explanations.
+`.trim();
+
+// src/skills/ast-grep.ts
+var ast_grep_default = `
+# ast-grep (sg) \u2014 Structural code search/replace
+
+## When to use
+Search and replace code using syntax tree patterns instead of regex. Far safer for refactors because it understands code structure.
+
+## Trusted commands
+- Search for pattern: \`sg --pattern 'console.log($ARG)' --lang ts\`
+- Search in directory: \`sg --pattern 'useEffect($FN, [])' --lang tsx src/\`
+- Replace: \`sg --pattern 'console.log($ARG)' --rewrite 'logger.info($ARG)' --lang ts\`
+- Interactive replace: \`sg --pattern '$X' --rewrite '$Y' --lang ts --interactive\`
+
+## When to prefer over regex
+- Renaming function calls or method calls
+- Finding patterns that span multiple lines
+- Replacing with structural awareness (e.g. moving arguments)
+- Any refactor where brackets/nesting matters
+
+## Gotchas
+- The binary is called \`sg\`, not \`ast-grep\`.
+- \`$ARG\` is a metavariable that matches any single node. \`$$$ARGS\` matches multiple.
+- Always specify \`--lang\` for predictable results.
+`.trim();
+
+// src/skills/just.ts
+var just_default = `
+# just \u2014 Command runner
+
+## When to use
+Define and run project commands via a \`justfile\`. Like \`make\` but modern, with better syntax and no tab issues.
+
+## Trusted commands
+- List available recipes: \`just --list\`
+- Run a recipe: \`just recipe-name\`
+- Run with args: \`just deploy staging\`
+- Dry run (show commands): \`just --dry-run recipe-name\`
+- Choose recipe interactively: \`just --choose\` (requires fzf)
+
+## Why it matters for agents
+A justfile is an agent-readable task menu. \`just --list\` gives the agent a complete map of available project commands.
+
+## Gotchas
+- Uses spaces for indentation (not tabs like Makefile).
+- Recipes are independent by default (no implicit dependencies like make).
+`.trim();
+
+// src/skills/grex.ts
+var grex_default = `
+# grex \u2014 Generate regex from examples
+
+## When to use
+Generate a regular expression from a set of example strings. Useful when you know what you want to match but not the pattern.
+
+## Trusted commands
+- Generate regex: \`grex "foo-123" "bar-456" "baz-789"\`
+- With anchors: \`grex --with-anchors "foo-123" "bar-456"\`
+- Case insensitive: \`grex --ignore-case "Foo" "FOO" "foo"\`
+- Verbose regex: \`grex --verbose "foo-123" "bar-456"\`
+
+## Gotchas
+- Output is a regex string, not a replacement. Useful as input for rg, sd, or code.
+`.trim();
+
+// src/skills/knip.ts
+var knip_default = `
+# knip \u2014 Find unused code/deps in TS/JS
+
+## When to use
+Detect unused files, exports, dependencies, and types in TypeScript/JavaScript projects. Run at project root.
+
+## Trusted commands
+- Full scan: \`knip\`
+- Unused files only: \`knip --include files\`
+- Unused exports only: \`knip --include exports\`
+- Unused deps only: \`knip --include dependencies\`
+- JSON output: \`knip --reporter json\`
+
+## Gotchas
+- Must be run at project root (where package.json lives).
+- May need a knip.json config for monorepos or non-standard project structures.
+- Some frameworks have plugins (Next.js, Remix, etc.) \u2014 check docs if results seem wrong.
+`.trim();
+
+// src/skills/sd.ts
+var sd_default = `
+# sd \u2014 Simpler sed
+
+## When to use
+Find and replace in files. Like sed but with intuitive syntax \u2014 no escaping nightmares.
+
+## Trusted commands
+- Replace in file: \`sd 'old' 'new' file.ts\`
+- Preview changes: \`sd -p 'old' 'new' file.ts\`
+- Regex replace: \`sd 'v(\\d+)' 'version-$1' file.txt\`
+- Replace across files (with fd): \`fd -e ts -x sd 'old' 'new' {}\`
+
+## Gotchas
+- Uses regex by default. Use \`-F\` for fixed/literal strings.
+- Modifies files in place when given a filename. Use \`-p\` to preview first.
+`.trim();
+
+// src/skills/hyperfine.ts
+var hyperfine_default = `
+# hyperfine \u2014 CLI benchmarking
+
+## When to use
+Benchmark commands to compare performance. Runs commands multiple times and reports stats.
+
+## Trusted commands
+- Benchmark single command: \`hyperfine 'command'\`
+- Compare two commands: \`hyperfine 'command-a' 'command-b'\`
+- With warmup: \`hyperfine --warmup 3 'command'\`
+- Export results: \`hyperfine --export-json results.json 'command'\`
+- Min runs: \`hyperfine --min-runs 20 'command'\`
+
+## Gotchas
+- Wrap commands in quotes.
+- Use \`--warmup\` for commands that benefit from caching.
+`.trim();
+
+// src/skills/tokei.ts
+var tokei_default = `
+# tokei \u2014 Code statistics
+
+## When to use
+Get a quick overview of a codebase: languages, lines of code, comments, blanks.
+
+## Trusted commands
+- Current directory: \`tokei\`
+- Specific path: \`tokei src/\`
+- JSON output: \`tokei --output json\`
+- Sort by lines: \`tokei --sort lines\`
+
+## Output format
+Table with language, files, lines, code, comments, blanks.
+Use \`--output json\` for structured output.
+`.trim();
+
+// src/skills/ffmpeg.ts
+var ffmpeg_default = `
+# ffmpeg \u2014 Audio/video Swiss army knife
+
+## When to use
+Transcode, trim, concatenate, normalise audio, extract streams, generate waveforms \u2014 anything media.
+
+## Trusted commands
+- Inspect media: \`ffprobe -hide_banner -of json -show_format -show_streams file.mp4\`
+- Convert format: \`ffmpeg -i input.wav output.mp3\`
+- Trim: \`ffmpeg -i input.mp4 -ss 00:01:00 -t 00:00:30 -c copy output.mp4\`
+- Extract audio: \`ffmpeg -i video.mp4 -vn -acodec copy audio.aac\`
+- Normalise loudness: \`ffmpeg -i input.wav -af loudnorm=I=-16 output.wav\`
+- Resize video: \`ffmpeg -i input.mp4 -vf scale=1280:720 output.mp4\`
+- Generate waveform: \`ffmpeg -i audio.wav -filter_complex showwavespic=s=1920x200 waveform.png\`
+
+## Safety rules
+- Never overwrite input files. Always write to a different output path.
+- Use \`-n\` flag to skip if output exists (never overwrite silently).
+- Always inspect with \`ffprobe\` before transcoding to understand the source.
+
+## Gotchas
+- Argument order matters: input flags before \`-i\`, output flags after.
+- \`-c copy\` copies streams without re-encoding (fast, lossless).
+- ffprobe is installed alongside ffmpeg.
+`.trim();
+
+// src/skills/exiftool.ts
+var exiftool_default = `
+# exiftool \u2014 Image/media metadata
+
+## When to use
+Read, write, and strip metadata (EXIF, IPTC, XMP) from images and media files.
+
+## Trusted commands
+- Read all metadata: \`exiftool file.jpg\`
+- Read as JSON: \`exiftool -json file.jpg\`
+- Read specific fields: \`exiftool -Make -Model -DateTimeOriginal file.jpg\`
+- Strip GPS data: \`exiftool -gps:all= file.jpg\`
+- Strip all metadata: \`exiftool -all= file.jpg\`
+- Rename by date: \`exiftool '-FileName<DateTimeOriginal' -d '%Y%m%d_%H%M%S.%%e' dir/\`
+- Batch read: \`exiftool -json dir/\`
+
+## Safety rules
+- exiftool creates backup files (.jpg_original) by default when modifying. Use \`-overwrite_original\` only when sure.
+
+## Gotchas
+- Field names are case-insensitive.
+- Use \`-json\` for structured output.
+`.trim();
+
+// src/skills/imagemagick.ts
+var imagemagick_default = `
+# ImageMagick (magick) \u2014 Image transforms
+
+## When to use
+Resize, crop, convert, and manipulate images from the command line.
+
+## Trusted commands
+- Convert format: \`magick input.png output.jpg\`
+- Resize: \`magick input.jpg -resize 800x600 output.jpg\`
+- Resize to width (maintain aspect): \`magick input.jpg -resize 800x output.jpg\`
+- Generate thumbnail: \`magick input.jpg -thumbnail 200x200^ -gravity center -extent 200x200 thumb.jpg\`
+- Get dimensions: \`magick identify -format '%wx%h' input.jpg\`
+- Batch convert: \`magick mogrify -format webp *.png\`
+
+## Safety rules
+- \`magick mogrify\` modifies files in place. Use \`magick convert\` (or just \`magick in out\`) for safe transforms.
+
+## Gotchas
+- The binary is \`magick\` (ImageMagick 7). Older versions used \`convert\`.
+`.trim();
+
+// src/skills/svgo.ts
+var svgo_default = `
+# svgo \u2014 SVG optimiser
+
+## When to use
+Optimise SVG files by removing unnecessary metadata, comments, and reducing precision.
+
+## Trusted commands
+- Optimise file: \`svgo input.svg -o output.svg\`
+- Optimise in place: \`svgo input.svg\`
+- Folder: \`svgo -f ./icons/ -o ./icons-optimised/\`
+- Show savings: \`svgo input.svg --pretty\`
+
+## Gotchas
+- Default plugins are usually fine. Override with \`--config svgo.config.js\` if needed.
+- In-place by default when no \`-o\` specified. Pipe or use \`-o\` for safety.
+`.trim();
+
+// src/skills/eza.ts
+var eza_default = `
+# eza \u2014 Modern ls replacement
+
+## When to use
+List files with better defaults: colours, git status, icons, tree view built in.
+
+## Trusted commands
+- List: \`eza\`
+- Long format: \`eza -l\`
+- With git status: \`eza -l --git\`
+- Tree view: \`eza --tree\`
+- Tree with depth limit: \`eza --tree --level 2\`
+- All files (including hidden): \`eza -la\`
+`.trim();
+
+// src/skills/zoxide.ts
+var zoxide_default = `
+# zoxide \u2014 Smarter cd
+
+## When to use
+Jump to frequently used directories without typing full paths. Learns from your usage.
+
+## Setup
+Add to ~/.zshrc: \`eval "$(zoxide init zsh)"\`
+Then use \`z\` instead of \`cd\`: \`z projects\` jumps to your most-used match.
+
+## Trusted commands
+- Jump: \`z partial-dirname\`
+- Interactive: \`zi\` (requires fzf)
+- Add path manually: \`zoxide add /path/to/dir\`
+- List known paths: \`zoxide query --list\`
+`.trim();
+
+// src/skills/delta.ts
+var delta_default = `
+# delta \u2014 Better git diffs
+
+## When to use
+Syntax-highlighted, side-by-side diffs. Configure as your git pager for automatic use.
+
+## Setup
+Add to ~/.gitconfig:
+\`\`\`
+[core]
+  pager = delta
+[interactive]
+  diffFilter = delta --color-only
+\`\`\`
+
+## Trusted commands
+- View diff: \`git diff\` (uses delta automatically once configured)
+- Side by side: set \`delta --side-by-side\` in config
+
+## Gotchas
+- The brew package is called \`git-delta\`, but the binary is \`delta\`.
+`.trim();
+
+// src/skills/glow.ts
+var glow_default = `
+# glow \u2014 Terminal markdown renderer
+
+## When to use
+Render markdown files beautifully in the terminal. Great for reading READMEs, docs, changelogs.
+
+## Trusted commands
+- Render file: \`glow README.md\`
+- Render with pager: \`glow -p README.md\`
+- Render from stdin: \`cat CHANGELOG.md | glow\`
+`.trim();
+
+// src/skills/mise.ts
+var mise_default = `
+# mise \u2014 Runtime version manager
+
+## When to use
+Manage Node, Python, Ruby, Go (etc.) versions per project. Replaces nvm, pyenv, rbenv, asdf.
+
+## Trusted commands
+- List available tools: \`mise ls-remote node\`
+- Install a version: \`mise install node@20\`
+- Use in current dir: \`mise use node@20\`
+- Check current: \`mise current\`
+- Install all from config: \`mise install\`
+- Trust a config file: \`mise trust\`
+
+## Config
+Uses \`.mise.toml\` or \`.tool-versions\` in project root. This ensures deterministic versions for all contributors.
+
+## Gotchas
+- Run \`mise activate zsh\` (or bash/fish) in your shell profile for automatic version switching.
+`.trim();
+
+// src/skills/watchexec.ts
+var watchexec_default = `
+# watchexec \u2014 Run commands on file change
+
+## When to use
+Watch files for changes and re-run a command. Language-agnostic alternative to nodemon.
+
+## Trusted commands
+- Watch and run: \`watchexec -e ts,tsx "pnpm typecheck"\`
+- Watch specific path: \`watchexec -w src/ "pnpm test"\`
+- Clear screen on change: \`watchexec --clear -e ts "pnpm typecheck"\`
+- Restart long-running process: \`watchexec --restart -e ts "node server.js"\`
+
+## Gotchas
+- Use \`-e\` to filter by extension, \`-w\` to filter by directory.
+- Use \`--restart\` for long-running processes (servers), otherwise it waits for completion.
+`.trim();
+
+// src/skills/mkcert.ts
+var mkcert_default = `
+# mkcert \u2014 Local HTTPS certificates
+
+## When to use
+Generate locally-trusted HTTPS certificates for development. No more "insecure" warnings.
+
+## Trusted commands
+- First-time setup: \`mkcert -install\` (installs local CA)
+- Generate cert: \`mkcert localhost 127.0.0.1 ::1\`
+- Generate for custom domain: \`mkcert "myapp.local" "*.myapp.local"\`
+
+## Gotchas
+- \`mkcert -install\` only needs to run once per machine.
+- Output is two files: cert.pem and key.pem. Point your dev server at them.
+`.trim();
+
+// src/skills/trivy.ts
+var trivy_default = `
+# trivy \u2014 Vulnerability scanner
+
+## When to use
+Scan filesystems, container images, and code repos for known vulnerabilities.
+
+## Trusted commands
+- Scan current directory: \`trivy fs .\`
+- Scan with JSON output: \`trivy fs --format json .\`
+- Scan a container image: \`trivy image myapp:latest\`
+- Only critical/high: \`trivy fs --severity CRITICAL,HIGH .\`
+- Scan for secrets: \`trivy fs --scanners secret .\`
+
+## Gotchas
+- First run downloads a vulnerability database (can be slow).
+- Use \`--format json\` for structured output.
+`.trim();
+
+// src/skills/act.ts
+var act_default = `
+# act \u2014 Run GitHub Actions locally
+
+## When to use
+Test GitHub Actions workflows without pushing. Runs workflows in Docker containers locally.
+
+## Trusted commands
+- List available workflows: \`act -l\`
+- Run default workflow: \`act\`
+- Run specific event: \`act push\`
+- Run specific job: \`act -j build\`
+- Dry run: \`act -n\`
+
+## Gotchas
+- Requires Docker to be running.
+- Not all GitHub Actions features are supported locally (secrets, some contexts).
+- Use \`-n\` (dry run) first to see what would happen.
+`.trim();
+
+// src/skills/xh.ts
+var xh_default = `
+# xh \u2014 Friendly HTTP client
+
+## When to use
+Send HTTP requests from the terminal. Cleaner syntax than curl, JSON-first, coloured output.
+
+## Trusted commands
+- GET request: \`xh get httpbin.org/json\`
+- POST JSON body: \`xh post httpbin.org/post name=Alice age:=30\`
+- Set headers: \`xh get api.example.com Authorization:"Bearer $TOKEN"\`
+- Force JSON output: \`xh --json get api.example.com\`
+- Follow redirects: \`xh --follow get example.com\`
+- Save response to file: \`xh get example.com/file.zip > file.zip\`
+- Show request/response headers: \`xh --print=hHbB get httpbin.org/get\`
+
+## Gotchas
+- \`key=value\` sends as JSON string; \`key:=value\` sends raw JSON (numbers, bools, arrays).
+- Defaults to HTTPS if scheme is omitted.
+- Use \`--check-status\` to exit non-zero on 4xx/5xx responses.
+`.trim();
+
+// src/skills/tldr.ts
+var tldr_default = `
+# tldr \u2014 Quick man page summaries
+
+## When to use
+Get practical, example-driven command summaries without reading full man pages.
+
+## Trusted commands
+- Look up a command: \`tldr rg\`
+- Look up a subcommand: \`tldr git commit\`
+- Update the local cache: \`tldr --update\`
+- List all available pages: \`tldr --list\`
+- Search for a topic: \`tldr --search "compress files"\`
+
+## Gotchas
+- First run requires internet to fetch the page cache. Run \`tldr --update\` after install.
+- Not every obscure tool has a page \u2014 fall back to \`man\` or \`--help\` when missing.
+- Pages are community-written; they cover common usage, not edge cases.
+`.trim();
+
+// src/skills/biome.ts
+var biome_default = `
+# biome \u2014 Lint and format JS/TS
+
+## When to use
+Fast, zero-config linter and formatter for JavaScript/TypeScript projects. Replaces ESLint + Prettier in one binary.
+
+## Trusted commands
+- Check (lint + format): \`biome check .\`
+- Format only (write): \`biome format --write .\`
+- Lint only: \`biome lint .\`
+- CI mode (no writes, exits 1 on issues): \`biome ci .\`
+- Init config: \`biome init\`
+- Check single file: \`biome check src/index.ts\`
+
+## Gotchas
+- Requires a \`biome.json\` config or \`--config-path\` flag; \`biome init\` generates a sensible default.
+- Not 100% compatible with all ESLint rules \u2014 check the migration guide when switching existing projects.
+- \`biome check\` is read-only by default; pass \`--write\` to apply fixes.
+`.trim();
+
+// src/skills/difftastic.ts
+var difftastic_default = `
+# difftastic (difft) \u2014 Structural/AST diff
+
+## When to use
+Compare files by syntax tree, not line-by-line. Understands code structure so renaming a variable shows intent, not noise.
+
+## Trusted commands
+- Diff two files: \`difft old.ts new.ts\`
+- Use as git diff driver: \`GIT_EXTERNAL_DIFF=difft git diff\`
+- Set as permanent git difftool: \`git config --global diff.external difft\`
+- Diff staged changes: \`GIT_EXTERNAL_DIFF=difft git diff --cached\`
+- Plain text mode (no syntax): \`difft --display side-by-side-show-both old.txt new.txt\`
+
+## Gotchas
+- Supports most languages automatically via file extension detection.
+- Output is always side-by-side; pipe width matters \u2014 use a wide terminal.
+- Falls back to line-diff for unsupported file types.
+`.trim();
+
+// src/skills/lazygit.ts
+var lazygit_default = `
+# lazygit \u2014 TUI git client
+
+## When to use
+Interactive terminal UI for git \u2014 stage hunks, commit, branch, rebase, and push without typing git commands.
+
+## Trusted commands
+- Open in current repo: \`lazygit\`
+- Open for a specific path: \`lazygit -p /path/to/repo\`
+
+## Key bindings (inside lazygit)
+- \`?\` \u2014 show full keybinding help
+- \`space\` \u2014 stage/unstage file or hunk
+- \`c\` \u2014 commit staged changes
+- \`P\` \u2014 push
+- \`p\` \u2014 pull
+- \`b\` \u2014 branch panel; \`n\` to create, \`space\` to checkout
+- \`R\` \u2014 interactive rebase
+- \`q\` \u2014 quit
+
+## Gotchas
+- Requires git to be installed (it's a UI wrapper, not a replacement).
+- Config lives at \`~/.config/lazygit/config.yml\`.
+- Mouse support is on by default \u2014 click panels to navigate.
+`.trim();
+
+// src/skills/dust.ts
+var dust_default = `
+# dust \u2014 Disk usage tree
+
+## When to use
+Visualise what's eating disk space in a directory tree. Faster and more readable than \`du\`.
+
+## Trusted commands
+- Current directory overview: \`dust\`
+- Limit tree depth: \`dust -d 2\`
+- Show top N entries: \`dust -n 20\`
+- Reverse order (smallest first): \`dust -r\`
+- Specific path: \`dust /var/log\`
+- Ignore a directory: \`dust --ignore-directory node_modules\`
+
+## Gotchas
+- Output is proportional bars + sizes; percentages are relative to the scanned root, not total disk.
+- Use \`-d 1\` for a quick top-level summary before drilling down.
+- Symlinks are not followed by default \u2014 add \`-L\` to follow them.
+`.trim();
+
+// src/skills/btm.ts
+var btm_default = `
+# bottom (btm) \u2014 System monitor
+
+## When to use
+Real-time TUI system monitor \u2014 CPU, memory, network, disk, and process list in one view.
+
+## Trusted commands
+- Open monitor: \`btm\`
+- Basic mode (simpler layout): \`btm --basic\`
+- Show all processes (no grouping): \`btm --process_command\`
+
+## Key bindings (inside btm)
+- \`?\` \u2014 show help overlay
+- \`q\` / \`Ctrl+C\` \u2014 quit
+- \`dd\` \u2014 kill selected process
+- \`s\` \u2014 sort column selector
+- \`/\` \u2014 filter processes by name
+- \`Tab\` \u2014 switch between widgets
+- \`e\` \u2014 expand focused widget to full screen
+
+## Gotchas
+- Config lives at \`~/.config/bottom/bottom.toml\` \u2014 customise colours and layout there.
+- \`--basic\` mode is useful in constrained terminals or for quick checks.
+`.trim();
+
+// src/skills/gitleaks.ts
+var gitleaks_default = `
+# gitleaks \u2014 Secrets scanner
+
+## When to use
+Detect hardcoded secrets (API keys, tokens, passwords) in git repos before they reach remote.
+
+## Trusted commands
+- Scan entire repo history: \`gitleaks detect\`
+- Scan only staged changes (pre-commit): \`gitleaks protect --staged\`
+- Scan a specific path: \`gitleaks detect --source /path/to/repo\`
+- Output as JSON: \`gitleaks detect --report-format json --report-path leaks.json\`
+- Verbose (show findings inline): \`gitleaks detect -v\`
+
+## CI usage
+Add to a pre-commit hook or CI step:
+\`\`\`sh
+gitleaks protect --staged   # pre-commit hook
+gitleaks detect             # CI full scan
+\`\`\`
+
+## Gotchas
+- Findings include file, line, rule, and matched secret fragment \u2014 review before dismissing.
+- Use a \`.gitleaksignore\` file to whitelist known false positives.
+- Does not redact secrets from history \u2014 use \`git filter-repo\` to remove them.
+`.trim();
+
+// src/skills.ts
+var PREFIX = "agent-loadout";
+var SKILL_CONTENT = {
+  rg: rg_default,
+  fd: fd_default,
+  jq: jq_default,
+  yq: yq_default,
+  bat: bat_default,
+  tree: tree_default,
+  gh: gh_default,
+  fzf: fzf_default,
+  shellcheck: shellcheck_default,
+  "ast-grep": ast_grep_default,
+  just: just_default,
+  grex: grex_default,
+  knip: knip_default,
+  sd: sd_default,
+  hyperfine: hyperfine_default,
+  tokei: tokei_default,
+  ffmpeg: ffmpeg_default,
+  exiftool: exiftool_default,
+  imagemagick: imagemagick_default,
+  svgo: svgo_default,
+  eza: eza_default,
+  zoxide: zoxide_default,
+  delta: delta_default,
+  glow: glow_default,
+  mise: mise_default,
+  watchexec: watchexec_default,
+  mkcert: mkcert_default,
+  trivy: trivy_default,
+  act: act_default,
+  xh: xh_default,
+  tldr: tldr_default,
+  biome: biome_default,
+  difftastic: difftastic_default,
+  lazygit: lazygit_default,
+  dust: dust_default,
+  btm: btm_default,
+  gitleaks: gitleaks_default
+};
+function skillPath(toolId) {
+  return join2(paths.skills, `${PREFIX}-${toolId}.md`);
+}
+async function writeSkills(tools) {
+  await ensureSkillsDir();
+  let written = 0;
+  for (const tool of tools) {
+    const content = SKILL_CONTENT[tool.id];
+    if (!content) continue;
+    await writeFile3(skillPath(tool.id), content + "\n");
+    written++;
+  }
+  return written;
+}
+
+// src/index.ts
+var program = new Command();
+program.name("agent-loadout").description("One command to load out your terminal for agentic coding").version("0.1.0");
+process.on("SIGINT", () => {
+  console.log(chalk6.dim("\n  Cancelled."));
+  process.exit(0);
+});
+program.command("install", { isDefault: true }).description("Install tools (interactive by default)").option("--preset <presets...>", "Install specific presets without prompts").option("--all", "Install everything").option("--apply", "Actually run the install (default is preview only)").action(async (opts) => {
+  const hasBrew = await checkBrewInstalled();
+  if (!hasBrew) {
+    console.log(chalk6.red("Homebrew is required but not installed."));
+    console.log(
+      chalk6.dim(
+        'Install it: https://brew.sh  \u2192  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"'
+      )
+    );
+    process.exit(1);
+  }
+  let tools;
+  if (opts.all) {
+    tools = TOOLS;
+  } else if (opts.preset) {
+    const rawIds = opts.preset;
+    const validIds = PRESETS.map((p) => p.id);
+    const invalid = rawIds.filter((p) => !validIds.includes(p));
+    if (invalid.length > 0) {
+      console.log(
+        chalk6.red(
+          `Unknown preset${invalid.length > 1 ? "s" : ""}: ${invalid.map((p) => `'${p}'`).join(", ")}. Available: ${validIds.join(", ")}`
+        )
+      );
+      process.exit(1);
+    }
+    const presetIds = rawIds;
+    tools = TOOLS.filter((t) => presetIds.includes(t.preset));
+  } else {
+    const presetIds = await selectPresets();
+    if (presetIds.length === 0) {
+      console.log(chalk6.dim("No presets selected. Nothing to install."));
+      return;
+    }
+    tools = await selectTools(presetIds);
+    if (tools.length === 0) {
+      console.log(chalk6.dim("No tools selected. Nothing to install."));
+      return;
+    }
+  }
+  printPreview(tools);
+  if (!opts.apply && (opts.all || opts.preset)) {
+    console.log(
+      chalk6.yellow("Dry run \u2014 add --apply to install. Example:")
+    );
+    console.log(
+      chalk6.dim(
+        `  npx agent-loadout install ${opts.all ? "--all" : `--preset ${opts.preset.join(" ")}`} --apply`
+      )
+    );
+    return;
+  }
+  if (!opts.all && !opts.preset) {
+    const proceed = await confirmInstall();
+    if (!proceed) {
+      console.log(chalk6.dim("Cancelled."));
+      return;
+    }
+  }
+  const npmPackages = getNpmInstallCommand(tools);
+  if (npmPackages.length > 0) {
+    const hasNpm = await checkNpmInstalled();
+    if (!hasNpm) {
+      console.log(
+        chalk6.yellow(
+          `npm is required for: ${npmPackages.join(", ")}. Skipping npm packages (install Node.js to include them).`
+        )
+      );
+    }
+  }
+  console.log();
+  const brewfile = generateBrewfile(tools);
+  if (brewfile) {
+    console.log(chalk6.bold("Installing brew packages..."));
+    await writeBrewfile(brewfile);
+    await runBrewBundle();
+  }
+  if (npmPackages.length > 0 && await checkNpmInstalled()) {
+    console.log(chalk6.bold("Installing npm globals..."));
+    await runNpmInstall(npmPackages);
+  }
+  console.log();
+  console.log(chalk6.bold("Verifying..."));
+  const results = await verifyTools(tools);
+  printVerifyResults(results);
+  const skillCount = await writeSkills(tools);
+  if (skillCount > 0) {
+    console.log(
+      chalk6.dim(`
+  ${skillCount} skill files written to ~/.claude/skills/`)
+    );
+  }
+  await writeReceipt({
+    selections: tools.map((t) => t.id),
+    installed: verifyResultsToJson(results),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  console.log(chalk6.dim("  Receipt saved to ~/.agent-loadout/receipt.json"));
+});
+program.command("verify").alias("doctor").description("Check which tools are installed").option("--json", "Output as JSON").action(async (opts) => {
+  const receipt = await readReceipt();
+  const toolIds = receipt?.selections ?? TOOLS.map((t) => t.id);
+  const tools = getToolsByIds(toolIds);
+  const results = await verifyTools(tools);
+  const installed = results.filter((r) => r.installed).length;
+  const allInstalled = installed === results.length;
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          ok: allInstalled,
+          installed,
+          total: results.length,
+          tools: results
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    printVerifyResults(results);
+  }
+  process.exit(allInstalled ? 0 : 1);
+});
+program.command("list").description("Print the tool catalog").option("--json", "Output as JSON").action((opts) => {
+  if (opts.json) {
+    console.log(JSON.stringify({ presets: PRESETS, tools: TOOLS }, null, 2));
+    return;
+  }
+  for (const preset of PRESETS) {
+    const marker = preset.defaultOn ? chalk6.green("\u25CF") : chalk6.dim("\u25CB");
+    console.log(
+      `
+${marker} ${chalk6.bold(preset.name)} \u2014 ${preset.description}`
+    );
+    const presetTools = TOOLS.filter((t) => t.preset === preset.id);
+    const maxName = Math.max(...presetTools.map((t) => t.name.length));
+    for (const t of presetTools) {
+      const method = t.installMethod === "npm" ? chalk6.cyan("npm") : chalk6.yellow("brew");
+      console.log(
+        `    ${t.name.padEnd(maxName)}  ${method}  ${chalk6.dim(t.description)}`
+      );
+    }
+  }
+  console.log();
+});
+program.parse();