pi-agent-toolkit 0.1.0

package/dist/index.js

@@ -0,0 +1,1344 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { defineCommand, runMain } from "citty";
+
+// src/commands/install.ts
+import * as p3 from "@clack/prompts";
+import pc from "picocolors";
+
+// src/lib/registry.ts
+var extensions = [
+  // Safety
+  {
+    name: "damage-control",
+    category: "extensions",
+    group: "safety",
+    description: "Safety guardrail engine: blocks destructive commands, enforces path access rules",
+    method: "copy",
+    source: "extensions/damage-control",
+    isDirectory: true,
+    recommends: ["damage-control-rules.yaml"]
+  },
+  {
+    name: "commit-approval",
+    category: "extensions",
+    group: "safety",
+    description: "Intercepts git commits for interactive review before execution",
+    method: "copy",
+    source: "extensions/commit-approval.ts"
+  },
+  {
+    name: "pr-approval",
+    category: "extensions",
+    group: "safety",
+    description: "Intercepts PR creation for interactive review",
+    method: "copy",
+    source: "extensions/pr-approval.ts"
+  },
+  {
+    name: "dirty-repo-guard",
+    category: "extensions",
+    group: "safety",
+    description: "Warns when working in a repo with uncommitted changes",
+    method: "copy",
+    source: "extensions/dirty-repo-guard.ts"
+  },
+  // Search
+  {
+    name: "exa-search-tool",
+    category: "extensions",
+    group: "search",
+    description: "Registers Exa as a semantic web search tool",
+    method: "copy",
+    source: "extensions/exa-search-tool.ts"
+  },
+  {
+    name: "exa-enforce",
+    category: "extensions",
+    group: "search",
+    description: "Enforces Exa over ad-hoc web search methods",
+    method: "copy",
+    source: "extensions/exa-enforce.ts",
+    recommends: ["exa-search-tool"]
+  },
+  // Tasks
+  {
+    name: "tilldone",
+    category: "extensions",
+    group: "tasks",
+    description: "Task list management with progress tracking",
+    method: "copy",
+    source: "extensions/tilldone.ts"
+  },
+  {
+    name: "todos",
+    category: "extensions",
+    group: "tasks",
+    description: "File-based todo management",
+    method: "copy",
+    source: "extensions/todos.ts"
+  },
+  {
+    name: "loop",
+    category: "extensions",
+    group: "tasks",
+    description: "Loop execution with breakout conditions",
+    method: "copy",
+    source: "extensions/loop.ts"
+  },
+  // UI
+  {
+    name: "btw",
+    category: "extensions",
+    group: "ui",
+    description: "Overlay chat panel with scroll support",
+    method: "copy",
+    source: "extensions/btw.ts"
+  },
+  {
+    name: "control",
+    category: "extensions",
+    group: "ui",
+    description: "Session control and summarization",
+    method: "copy",
+    source: "extensions/control.ts"
+  },
+  {
+    name: "context",
+    category: "extensions",
+    group: "ui",
+    description: "TUI showing loaded extensions, skills, and token usage",
+    method: "copy",
+    source: "extensions/context.ts"
+  },
+  {
+    name: "files",
+    category: "extensions",
+    group: "ui",
+    description: "File picker with quick actions (reveal, open, edit, diff)",
+    method: "copy",
+    source: "extensions/files.ts"
+  },
+  {
+    name: "session-breakdown",
+    category: "extensions",
+    group: "ui",
+    description: "Session cost and usage analytics with calendar heatmap",
+    method: "copy",
+    source: "extensions/session-breakdown.ts"
+  },
+  {
+    name: "term-notify",
+    category: "extensions",
+    group: "ui",
+    description: "Desktop notifications on agent completion (cmux + OSC 777)",
+    method: "copy",
+    source: "extensions/term-notify.ts"
+  },
+  // Review
+  {
+    name: "review",
+    category: "extensions",
+    group: "review",
+    description: "Code review: PR review, branch diffs, uncommitted changes",
+    method: "copy",
+    source: "extensions/review.ts"
+  },
+  // Workflow
+  {
+    name: "question-mode",
+    category: "extensions",
+    group: "workflow",
+    description: "Read-only question mode (no file changes)",
+    method: "copy",
+    source: "extensions/question-mode.ts"
+  },
+  {
+    name: "qna-interactive",
+    category: "extensions",
+    group: "workflow",
+    description: "Structured Q&A mode",
+    method: "copy",
+    source: "extensions/qna-interactive.ts"
+  },
+  {
+    name: "require-session-name-on-exit",
+    category: "extensions",
+    group: "workflow",
+    description: "Prompts for session name before exit",
+    method: "copy",
+    source: "extensions/require-session-name-on-exit.ts"
+  },
+  // Tools
+  {
+    name: "tools",
+    category: "extensions",
+    group: "tools",
+    description: "Custom tool registrations",
+    method: "copy",
+    source: "extensions/tools.ts"
+  },
+  {
+    name: "uv",
+    category: "extensions",
+    group: "tools",
+    description: "Intercepts pip/python calls and redirects to uv",
+    method: "copy",
+    source: "extensions/uv.ts",
+    recommends: ["intercepted-commands"]
+  },
+  {
+    name: "execute-command",
+    category: "extensions",
+    group: "tools",
+    description: "Slash command execution",
+    method: "copy",
+    source: "extensions/execute-command",
+    isDirectory: true
+  }
+];
+var bundledSkills = [
+  {
+    name: "brainstorm",
+    category: "skills-bundled",
+    description: "Interview-driven plan stress-testing",
+    method: "copy",
+    source: "global-skills/brainstorm",
+    target: "global-skills",
+    isDirectory: true
+  },
+  {
+    name: "cli-detector",
+    category: "skills-bundled",
+    description: "Scan repos for service integrations and their CLIs",
+    method: "copy",
+    source: "global-skills/cli-detector",
+    target: "global-skills",
+    isDirectory: true
+  },
+  {
+    name: "exa-search",
+    category: "skills-bundled",
+    description: "Semantic web search via Exa API",
+    method: "copy",
+    source: "agent-skills/exa-search",
+    target: "agent-skills",
+    isDirectory: true
+  },
+  {
+    name: "gh-issue-creator",
+    category: "skills-bundled",
+    description: "Create GitHub issues via gh CLI with consistent formatting",
+    method: "copy",
+    source: "global-skills/gh-issue-creator",
+    target: "global-skills",
+    isDirectory: true
+  },
+  {
+    name: "google-chat-cards-v2",
+    category: "skills-bundled",
+    description: "Google Chat Cards v2 format for rich alert notifications",
+    method: "copy",
+    source: "global-skills/google-chat-cards-v2",
+    target: "global-skills",
+    isDirectory: true
+  },
+  {
+    name: "technical-docs",
+    category: "skills-bundled",
+    description: "Technical documentation standards and best practices",
+    method: "copy",
+    source: "global-skills/technical-docs",
+    target: "global-skills",
+    isDirectory: true
+  },
+  {
+    name: "whats-new",
+    category: "skills-bundled",
+    description: "Git changelog generation between branches",
+    method: "copy",
+    source: "global-skills/whats-new",
+    target: "global-skills",
+    isDirectory: true
+  }
+];
+var externalSkills = [
+  {
+    name: "docx",
+    category: "skills-external",
+    description: "Create, read, edit, and manipulate Word documents",
+    method: "skills-cli",
+    remote: "anthropics/skills",
+    remoteSkills: ["docx"]
+  },
+  {
+    name: "pdf",
+    category: "skills-external",
+    description: "Read, merge, split, create, and manipulate PDF files",
+    method: "skills-cli",
+    remote: "anthropics/skills",
+    remoteSkills: ["pdf"]
+  },
+  {
+    name: "pptx",
+    category: "skills-external",
+    description: "Create and edit PowerPoint presentations",
+    method: "skills-cli",
+    remote: "anthropics/skills",
+    remoteSkills: ["pptx"]
+  },
+  {
+    name: "xlsx",
+    category: "skills-external",
+    description: "Create, read, and edit spreadsheet files",
+    method: "skills-cli",
+    remote: "anthropics/skills",
+    remoteSkills: ["xlsx"]
+  },
+  {
+    name: "frontend-design",
+    category: "skills-external",
+    description: "Production-grade frontend interfaces with high design quality",
+    method: "skills-cli",
+    remote: "anthropics/skills",
+    remoteSkills: ["frontend-design"]
+  },
+  {
+    name: "skill-creator",
+    category: "skills-external",
+    description: "Create, modify, and measure skill performance",
+    method: "skills-cli",
+    remote: "anthropics/skills",
+    remoteSkills: ["skill-creator"]
+  },
+  {
+    name: "agent-browser",
+    category: "skills-external",
+    description: "Browser automation for agents",
+    method: "skills-cli",
+    remote: "anthropics/skills",
+    remoteSkills: ["agent-browser"]
+  },
+  {
+    name: "vercel-react-best-practices",
+    category: "skills-external",
+    description: "React best practices from Vercel",
+    method: "skills-cli",
+    remote: "vercel-labs/skills",
+    remoteSkills: ["vercel-react-best-practices"]
+  },
+  {
+    name: "web-design-guidelines",
+    category: "skills-external",
+    description: "Web design guidelines and patterns",
+    method: "skills-cli",
+    remote: "vercel-labs/skills",
+    remoteSkills: ["web-design-guidelines"]
+  },
+  {
+    name: "find-skills",
+    category: "skills-external",
+    description: "Discover and install agent skills",
+    method: "skills-cli",
+    remote: "vercel-labs/skills",
+    remoteSkills: ["find-skills"]
+  },
+  {
+    name: "learn-codebase",
+    category: "skills-external",
+    description: "Discover project conventions and surface security concerns",
+    method: "skills-cli",
+    remote: "HazAT/pi-config",
+    remoteSkills: ["learn-codebase"]
+  },
+  {
+    name: "self-improve",
+    category: "skills-external",
+    description: "Self-improvement and reflection for agents",
+    method: "skills-cli",
+    remote: "HazAT/pi-config",
+    remoteSkills: ["self-improve"]
+  },
+  {
+    name: "cmux",
+    category: "skills-external",
+    description: "Control cmux topology: windows, workspaces, panes, focus",
+    method: "skills-cli",
+    remote: "manaflow-ai/cmux",
+    remoteSkills: ["cmux"]
+  },
+  {
+    name: "cmux-and-worktrees",
+    category: "skills-external",
+    description: "Parallel development with cmux-style git worktrees",
+    method: "skills-cli",
+    remote: "manaflow-ai/cmux",
+    remoteSkills: ["cmux-and-worktrees"]
+  },
+  {
+    name: "cmux-browser",
+    category: "skills-external",
+    description: "Browser automation with cmux surfaces",
+    method: "skills-cli",
+    remote: "manaflow-ai/cmux",
+    remoteSkills: ["cmux-browser"]
+  },
+  {
+    name: "vue-best-practices",
+    category: "skills-external",
+    description: "Vue 3 Composition API with TypeScript best practices",
+    method: "skills-cli",
+    remote: "hyf0/vue-skills",
+    remoteSkills: ["vue-best-practices"]
+  },
+  {
+    name: "systematic-debugging",
+    category: "skills-external",
+    description: "Systematic approach to debugging and test failures",
+    method: "skills-cli",
+    remote: "obra/superpowers",
+    remoteSkills: ["systematic-debugging"]
+  },
+  {
+    name: "writing-skills",
+    category: "skills-external",
+    description: "Create and verify skills before deployment",
+    method: "skills-cli",
+    remote: "obra/superpowers",
+    remoteSkills: ["writing-skills"]
+  },
+  {
+    name: "code-simplifier",
+    category: "skills-external",
+    description: "Simplify and refine code for clarity and maintainability",
+    method: "skills-cli",
+    remote: "getsentry/skills",
+    remoteSkills: ["code-simplifier"]
+  },
+  {
+    name: "iterate-pr",
+    category: "skills-external",
+    description: "Iterate on a PR until CI passes",
+    method: "skills-cli",
+    remote: "getsentry/skills",
+    remoteSkills: ["iterate-pr"]
+  },
+  {
+    name: "playwright-cli",
+    category: "skills-external",
+    description: "Automate browser interactions and Playwright tests",
+    method: "skills-cli",
+    remote: "microsoft/playwright-cli"
+  },
+  {
+    name: "firecrawl",
+    category: "skills-external",
+    description: "Web scraping, search, crawling, and page interaction",
+    method: "skills-cli",
+    remote: "firecrawl/cli",
+    remoteSkills: ["firecrawl"]
+  },
+  {
+    name: "excalidraw-diagram",
+    category: "skills-external",
+    description: "Create Excalidraw diagram JSON files for visual workflows",
+    method: "skills-cli",
+    remote: "coleam00/excalidraw-diagram-skill"
+  }
+];
+var packages = [
+  {
+    name: "agent-modes",
+    category: "packages",
+    description: "Switch between code, architect, debug, ask, and review modes",
+    method: "pi-install",
+    remote: "npm:@danchamorro/pi-agent-modes"
+  },
+  {
+    name: "prompt-enhancer",
+    category: "packages",
+    description: "Rewrite prompts to be clearer and more actionable before sending",
+    method: "pi-install",
+    remote: "npm:@danchamorro/pi-prompt-enhancer"
+  }
+];
+var configs = [
+  {
+    name: "AGENTS.md",
+    category: "configs",
+    description: "Global agent rules: git safety, commit style, code style",
+    method: "copy",
+    source: "AGENTS.md",
+    isTemplate: true
+  },
+  {
+    name: "APPEND_SYSTEM.md",
+    category: "configs",
+    description: "System prompt: reasoning quality, jCodeMunch policy, writing style",
+    method: "copy",
+    source: "APPEND_SYSTEM.md",
+    isTemplate: true
+  },
+  {
+    name: "settings.json",
+    category: "configs",
+    description: "Pi settings: default provider, model, compaction",
+    method: "copy",
+    source: "settings.json",
+    isTemplate: true
+  },
+  {
+    name: "models.json",
+    category: "configs",
+    description: "Custom provider definitions (e.g., local MLX models)",
+    method: "copy",
+    source: "models.json",
+    isTemplate: true
+  },
+  {
+    name: "agent-modes.json",
+    category: "configs",
+    description: "Per-mode model and thinking overrides",
+    method: "copy",
+    source: "agent-modes.json",
+    isTemplate: true
+  },
+  {
+    name: "damage-control-rules.yaml",
+    category: "configs",
+    description: "Safety rules: bash patterns, path access, delete protection",
+    method: "copy",
+    source: "damage-control-rules.yaml",
+    isTemplate: true,
+    recommends: ["damage-control"]
+  },
+  {
+    name: "auth.json",
+    category: "configs",
+    description: "API key configuration (created from template)",
+    method: "copy",
+    source: "auth.json.template",
+    isTemplate: true
+  },
+  {
+    name: "mcp.json",
+    category: "configs",
+    description: "MCP server configuration (created from template)",
+    method: "copy",
+    source: "mcp.json.template",
+    isTemplate: true
+  }
+];
+var registry = [
+  ...extensions,
+  ...bundledSkills,
+  ...externalSkills,
+  ...packages,
+  ...configs
+];
+function getByCategory(category) {
+  return registry.filter((c) => c.category === category);
+}
+function getExtensionGroups() {
+  const groups = {};
+  for (const ext of getByCategory("extensions")) {
+    const group = ext.group ?? "tools";
+    if (!groups[group]) groups[group] = [];
+    groups[group].push(ext);
+  }
+  return groups;
+}
+var GROUP_LABELS = {
+  safety: "Safety",
+  search: "Search",
+  tasks: "Tasks",
+  ui: "UI & Session",
+  review: "Review",
+  workflow: "Workflow",
+  tools: "Tools"
+};
+
+// src/lib/warnings.ts
+import * as p from "@clack/prompts";
+async function checkRecommendations(selected) {
+  const selectedNames = new Set(selected.map((c) => c.name));
+  const warnings = [];
+  for (const component of selected) {
+    if (!component.recommends) continue;
+    for (const rec of component.recommends) {
+      if (!selectedNames.has(rec)) {
+        warnings.push(
+          `${component.name} works best with ${rec}, which you didn't select.`
+        );
+      }
+    }
+  }
+  if (warnings.length === 0) return true;
+  p.log.warn("Some selected components have recommendations:");
+  for (const warning of warnings) {
+    p.log.message(`  - ${warning}`);
+  }
+  const proceed = await p.confirm({
+    message: "Continue anyway?",
+    initialValue: true
+  });
+  if (p.isCancel(proceed)) {
+    p.cancel("Installation cancelled.");
+    process.exit(0);
+  }
+  return proceed;
+}
+
+// src/lib/installer.ts
+import {
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  symlinkSync,
+  lstatSync,
+  readlinkSync,
+  readdirSync,
+  statSync,
+  unlinkSync
+} from "fs";
+import { resolve as resolve2, basename } from "path";
+import { execSync } from "child_process";
+import * as p2 from "@clack/prompts";
+
+// src/lib/paths.ts
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var BUNDLED_DOTFILES = resolve(__dirname, "dotfiles");
+var PI_AGENT_DIR = resolve(homedir(), ".pi", "agent");
+var AGENTS_SKILLS_DIR = resolve(homedir(), ".agents", "skills");
+var MANIFEST_PATH = resolve(PI_AGENT_DIR, ".pi-toolkit.json");
+var PI_EXTENSIONS_DIR = resolve(PI_AGENT_DIR, "extensions");
+var PI_SKILLS_DIR = resolve(PI_AGENT_DIR, "skills");
+
+// src/lib/manifest.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname as dirname2 } from "path";
+function emptyManifest() {
+  return {
+    version: "",
+    installed: {
+      extensions: [],
+      skills: { bundled: [], external: [] },
+      packages: [],
+      configs: []
+    },
+    installedAt: "",
+    updatedAt: ""
+  };
+}
+function readManifest() {
+  if (!existsSync(MANIFEST_PATH)) return emptyManifest();
+  try {
+    const raw = readFileSync(MANIFEST_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return emptyManifest();
+  }
+}
+function writeManifest(manifest) {
+  const dir = dirname2(MANIFEST_PATH);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(MANIFEST_PATH, JSON.stringify(manifest, null, 2) + "\n");
+}
+function recordInstall(names, category, cliVersion) {
+  const manifest = readManifest();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (!manifest.installedAt) manifest.installedAt = now;
+  manifest.updatedAt = now;
+  manifest.version = cliVersion;
+  for (const name of names) {
+    switch (category) {
+      case "extensions":
+        if (!manifest.installed.extensions.includes(name))
+          manifest.installed.extensions.push(name);
+        break;
+      case "skills-bundled":
+        if (!manifest.installed.skills.bundled.includes(name))
+          manifest.installed.skills.bundled.push(name);
+        break;
+      case "skills-external":
+        if (!manifest.installed.skills.external.includes(name))
+          manifest.installed.skills.external.push(name);
+        break;
+      case "packages":
+        if (!manifest.installed.packages.includes(name))
+          manifest.installed.packages.push(name);
+        break;
+      case "configs":
+        if (!manifest.installed.configs.includes(name))
+          manifest.installed.configs.push(name);
+        break;
+    }
+  }
+  writeManifest(manifest);
+}
+
+// src/lib/installer.ts
+function resolveSource(component, options) {
+  if (!component.source) {
+    throw new Error(`Component ${component.name} has no source path`);
+  }
+  if (options.link && options.repoPath) {
+    return resolve2(options.repoPath, "dotfiles", component.source);
+  }
+  return resolve2(BUNDLED_DOTFILES, component.source);
+}
+function resolveTarget(component) {
+  switch (component.category) {
+    case "extensions": {
+      const name = component.isDirectory ? component.name : basename(component.source ?? component.name);
+      return resolve2(PI_EXTENSIONS_DIR, name);
+    }
+    case "skills-bundled": {
+      if (component.target === "global-skills") {
+        return resolve2(AGENTS_SKILLS_DIR, component.name);
+      }
+      return resolve2(PI_SKILLS_DIR, component.name);
+    }
+    case "configs": {
+      const name = (component.source ?? component.name).replace(".template", "");
+      return resolve2(PI_AGENT_DIR, name);
+    }
+    default:
+      return resolve2(PI_AGENT_DIR, component.name);
+  }
+}
+function copyComponent(source, target, isDirectory) {
+  const targetDir = isDirectory ? resolve2(target, "..") : resolve2(target, "..");
+  mkdirSync2(targetDir, { recursive: true });
+  if (isDirectory) {
+    cpSync(source, target, { recursive: true });
+  } else {
+    cpSync(source, target);
+  }
+}
+function linkComponent(source, target) {
+  const targetDir = resolve2(target, "..");
+  mkdirSync2(targetDir, { recursive: true });
+  if (existsSync2(target) || isSymlink(target)) {
+    unlinkSync(target);
+  }
+  symlinkSync(source, target);
+}
+function isSymlink(path) {
+  try {
+    lstatSync(path);
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function targetExists(target) {
+  if (isSymlink(target)) {
+    try {
+      readlinkSync(target);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return existsSync2(target);
+}
+function installLocal(component, options) {
+  const source = resolveSource(component, options);
+  const target = resolveTarget(component);
+  if (!existsSync2(source)) {
+    return { success: false, message: `Source not found: ${source}` };
+  }
+  if (component.isTemplate && targetExists(target) && !options.overrideConfigs) {
+    return { success: true, message: "already exists (skipped)" };
+  }
+  try {
+    if (options.link) {
+      linkComponent(source, target);
+      return { success: true, message: "linked" };
+    } else {
+      copyComponent(source, target, component.isDirectory ?? false);
+      return { success: true, message: "copied" };
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { success: false, message: msg };
+  }
+}
+function installViaSkillsCli(component) {
+  if (!component.remote) {
+    return { success: false, message: "No remote source defined" };
+  }
+  try {
+    let cmd = `npx skills add ${component.remote}`;
+    if (component.remoteSkills?.length) {
+      for (const skill of component.remoteSkills) {
+        cmd += ` -s ${skill}`;
+      }
+    }
+    cmd += " -g -y";
+    execSync(cmd, { stdio: "pipe", timeout: 6e4 });
+    return { success: true, message: "installed via skills CLI" };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { success: false, message: msg };
+  }
+}
+function installViaPi(component) {
+  if (!component.remote) {
+    return { success: false, message: "No remote source defined" };
+  }
+  try {
+    execSync(`pi install ${component.remote}`, {
+      stdio: "pipe",
+      timeout: 6e4
+    });
+    return { success: true, message: "installed via pi" };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { success: false, message: msg };
+  }
+}
+async function installComponents(components, options) {
+  if (components.length === 0) return;
+  mkdirSync2(PI_AGENT_DIR, { recursive: true });
+  mkdirSync2(PI_EXTENSIONS_DIR, { recursive: true });
+  mkdirSync2(PI_SKILLS_DIR, { recursive: true });
+  mkdirSync2(AGENTS_SKILLS_DIR, { recursive: true });
+  const spinner2 = p2.spinner();
+  const results = [];
+  for (const component of components) {
+    spinner2.start(`Installing ${component.name}...`);
+    let result;
+    switch (component.method) {
+      case "copy":
+      case "symlink":
+        result = installLocal(component, options);
+        break;
+      case "skills-cli":
+        result = installViaSkillsCli(component);
+        break;
+      case "pi-install":
+        result = installViaPi(component);
+        break;
+      default:
+        result = { success: false, message: `Unknown method: ${component.method}` };
+    }
+    results.push({ name: component.name, ...result });
+    if (result.success) {
+      spinner2.stop(`${component.name}: ${result.message}`);
+    } else {
+      spinner2.stop(`${component.name}: FAILED - ${result.message}`);
+    }
+  }
+  const successByCategory = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    if (!r.success) continue;
+    const component = components.find((c) => c.name === r.name);
+    if (!component) continue;
+    const cat = component.category;
+    if (!successByCategory.has(cat)) successByCategory.set(cat, []);
+    successByCategory.get(cat).push(r.name);
+  }
+  for (const [category, names] of successByCategory) {
+    recordInstall(names, category, options.cliVersion);
+  }
+  const succeeded = results.filter((r) => r.success).length;
+  const failed = results.filter((r) => !r.success).length;
+  if (failed > 0) {
+    p2.log.warn(
+      `Installed ${succeeded}/${results.length} components. ${failed} failed:`
+    );
+    for (const r of results.filter((r2) => !r2.success)) {
+      p2.log.error(`  ${r.name}: ${r.message}`);
+    }
+  } else {
+    p2.log.success(`All ${succeeded} components installed successfully.`);
+  }
+}
+function installExtensionDeps() {
+  const extDir = PI_EXTENSIONS_DIR;
+  if (!existsSync2(extDir)) return;
+  const entries = readdirSync(extDir);
+  for (const entry of entries) {
+    const fullPath = resolve2(extDir, entry);
+    try {
+      if (statSync(fullPath).isDirectory() && existsSync2(resolve2(fullPath, "package.json"))) {
+        p2.log.info(`Installing dependencies for ${entry}...`);
+        execSync("npm install --silent", { cwd: fullPath, stdio: "pipe" });
+      }
+    } catch {
+    }
+  }
+}
+
+// src/commands/install.ts
+function componentOptions(components) {
+  return components.map((c) => ({
+    value: c.name,
+    label: c.name,
+    hint: c.description
+  }));
+}
+async function interactivePicker() {
+  const selected = [];
+  const groups = getExtensionGroups();
+  const extensionOptions = [];
+  for (const group of Object.keys(GROUP_LABELS)) {
+    const components = groups[group];
+    if (!components?.length) continue;
+    extensionOptions.push({
+      value: `__separator_${group}`,
+      label: pc.dim(`--- ${GROUP_LABELS[group]} ---`),
+      hint: ""
+    });
+    extensionOptions.push(...componentOptions(components));
+  }
+  const extResult = await p3.multiselect({
+    message: "Select extensions to install:",
+    options: extensionOptions.filter((o) => !o.value.startsWith("__separator")),
+    required: false
+  });
+  if (p3.isCancel(extResult)) {
+    p3.cancel("Installation cancelled.");
+    process.exit(0);
+  }
+  selected.push(...extResult);
+  const bundledSkills2 = getByCategory("skills-bundled");
+  if (bundledSkills2.length > 0) {
+    const skillResult = await p3.multiselect({
+      message: "Select bundled skills to install:",
+      options: componentOptions(bundledSkills2),
+      required: false
+    });
+    if (p3.isCancel(skillResult)) {
+      p3.cancel("Installation cancelled.");
+      process.exit(0);
+    }
+    selected.push(...skillResult);
+  }
+  const externalSkills2 = getByCategory("skills-external");
+  if (externalSkills2.length > 0) {
+    const extSkillResult = await p3.multiselect({
+      message: "Select external skills to install (fetched from source repos):",
+      options: componentOptions(externalSkills2),
+      required: false
+    });
+    if (p3.isCancel(extSkillResult)) {
+      p3.cancel("Installation cancelled.");
+      process.exit(0);
+    }
+    selected.push(...extSkillResult);
+  }
+  const pkgs = getByCategory("packages");
+  if (pkgs.length > 0) {
+    const pkgResult = await p3.multiselect({
+      message: "Select pi packages to install:",
+      options: componentOptions(pkgs),
+      required: false
+    });
+    if (p3.isCancel(pkgResult)) {
+      p3.cancel("Installation cancelled.");
+      process.exit(0);
+    }
+    selected.push(...pkgResult);
+  }
+  const configs2 = getByCategory("configs");
+  if (configs2.length > 0) {
+    const configResult = await p3.multiselect({
+      message: "Select starter configs to install (copied as templates, won't overwrite existing):",
+      options: componentOptions(configs2),
+      required: false
+    });
+    if (p3.isCancel(configResult)) {
+      p3.cancel("Installation cancelled.");
+      process.exit(0);
+    }
+    selected.push(...configResult);
+  }
+  return registry.filter((c) => selected.includes(c.name));
+}
+function resolveFromFlags(args) {
+  const names = /* @__PURE__ */ new Set();
+  if (args.extensions) {
+    for (const name of args.extensions) names.add(name);
+  }
+  if (args.skills) {
+    for (const name of args.skills) names.add(name);
+  }
+  if (args.packages) {
+    for (const name of args.packages) names.add(name);
+  }
+  const resolved = [];
+  const notFound = [];
+  for (const name of names) {
+    const component = registry.find((c) => c.name === name);
+    if (component) {
+      resolved.push(component);
+    } else {
+      notFound.push(name);
+    }
+  }
+  if (notFound.length > 0) {
+    p3.log.warn(`Unknown components: ${notFound.join(", ")}`);
+    p3.log.info('Run "pi-toolkit list" to see available components.');
+  }
+  return resolved;
+}
+async function runInstall(args) {
+  p3.intro(pc.bold("pi-toolkit install"));
+  if (args.link && !args.repoPath) {
+    p3.log.error("--link requires --repo-path to be set.");
+    p3.log.info("Example: pi-toolkit install --link --repo-path ~/Code/pi-toolkit");
+    process.exit(1);
+  }
+  let components;
+  if (args.all) {
+    components = [...registry];
+    p3.log.info(`Installing all ${components.length} components...`);
+  } else if (args.extensions || args.skills || args.packages) {
+    components = resolveFromFlags(args);
+  } else {
+    components = await interactivePicker();
+  }
+  if (components.length === 0) {
+    p3.log.warn("Nothing selected to install.");
+    p3.outro("Done.");
+    return;
+  }
+  const extCount = components.filter((c) => c.category === "extensions").length;
+  const skillCount = components.filter(
+    (c) => c.category === "skills-bundled" || c.category === "skills-external"
+  ).length;
+  const pkgCount = components.filter((c) => c.category === "packages").length;
+  const cfgCount = components.filter((c) => c.category === "configs").length;
+  const parts = [];
+  if (extCount) parts.push(`${extCount} extension${extCount > 1 ? "s" : ""}`);
+  if (skillCount) parts.push(`${skillCount} skill${skillCount > 1 ? "s" : ""}`);
+  if (pkgCount) parts.push(`${pkgCount} package${pkgCount > 1 ? "s" : ""}`);
+  if (cfgCount) parts.push(`${cfgCount} config${cfgCount > 1 ? "s" : ""}`);
+  p3.log.info(`Will install: ${parts.join(", ")}`);
+  if (args.link) {
+    p3.log.info(`Mode: symlink (repo: ${args.repoPath})`);
+  }
+  if (args.overrideConfigs) {
+    p3.log.warn("Config override enabled: existing configs will be overwritten.");
+  }
+  const proceed = await checkRecommendations(components);
+  if (!proceed) {
+    p3.log.info("Go back and adjust your selections, then re-run.");
+    p3.outro("Cancelled.");
+    return;
+  }
+  await installComponents(components, {
+    link: args.link ?? false,
+    repoPath: args.repoPath,
+    overrideConfigs: args.overrideConfigs ?? false,
+    cliVersion: args.version
+  });
+  const hasDirectoryExtensions = components.some(
+    (c) => c.category === "extensions" && c.isDirectory
+  );
+  if (hasDirectoryExtensions) {
+    installExtensionDeps();
+  }
+  p3.outro(pc.green("Installation complete!"));
+}
+
+// src/commands/list.ts
+import pc2 from "picocolors";
+function runList() {
+  console.log();
+  console.log(pc2.bold("pi-toolkit: available components"));
+  console.log();
+  console.log(pc2.bold(pc2.cyan("Extensions")));
+  const groups = getExtensionGroups();
+  for (const group of Object.keys(GROUP_LABELS)) {
+    const components = groups[group];
+    if (!components?.length) continue;
+    console.log(`  ${pc2.dim(GROUP_LABELS[group])}`);
+    for (const c of components) {
+      console.log(`    ${pc2.green(c.name.padEnd(36))} ${pc2.dim(c.description)}`);
+    }
+  }
+  console.log();
+  const bundled = getByCategory("skills-bundled");
+  if (bundled.length > 0) {
+    console.log(pc2.bold(pc2.cyan("Bundled Skills")));
+    for (const c of bundled) {
+      console.log(`  ${pc2.green(c.name.padEnd(38))} ${pc2.dim(c.description)}`);
+    }
+    console.log();
+  }
+  const external = getByCategory("skills-external");
+  if (external.length > 0) {
+    console.log(pc2.bold(pc2.cyan("External Skills")) + pc2.dim(" (installed from source repos)"));
+    for (const c of external) {
+      const source = c.remote ? pc2.dim(` [${c.remote}]`) : "";
+      console.log(`  ${pc2.green(c.name.padEnd(38))} ${pc2.dim(c.description)}${source}`);
+    }
+    console.log();
+  }
+  const pkgs = getByCategory("packages");
+  if (pkgs.length > 0) {
+    console.log(pc2.bold(pc2.cyan("Packages")) + pc2.dim(" (installed via pi install)"));
+    for (const c of pkgs) {
+      console.log(`  ${pc2.green(c.name.padEnd(38))} ${pc2.dim(c.description)}`);
+    }
+    console.log();
+  }
+  const configs2 = getByCategory("configs");
+  if (configs2.length > 0) {
+    console.log(pc2.bold(pc2.cyan("Starter Configs")) + pc2.dim(" (copied as templates)"));
+    for (const c of configs2) {
+      console.log(`  ${pc2.green(c.name.padEnd(38))} ${pc2.dim(c.description)}`);
+    }
+    console.log();
+  }
+}
+
+// src/commands/status.ts
+import { existsSync as existsSync3, lstatSync as lstatSync2, readlinkSync as readlinkSync2 } from "fs";
+import { resolve as resolve3, basename as basename2 } from "path";
+import pc3 from "picocolors";
+function expectedPath(component) {
+  switch (component.category) {
+    case "extensions": {
+      const name = component.isDirectory ? component.name : basename2(component.source ?? component.name);
+      return resolve3(PI_EXTENSIONS_DIR, name);
+    }
+    case "skills-bundled": {
+      if (component.target === "global-skills") {
+        return resolve3(AGENTS_SKILLS_DIR, component.name);
+      }
+      return resolve3(PI_SKILLS_DIR, component.name);
+    }
+    case "skills-external": {
+      const piPath = resolve3(PI_SKILLS_DIR, component.name);
+      const agentsPath = resolve3(AGENTS_SKILLS_DIR, component.name);
+      if (existsSync3(piPath) || isSymlink2(piPath)) return piPath;
+      if (existsSync3(agentsPath) || isSymlink2(agentsPath)) return agentsPath;
+      return agentsPath;
+    }
+    case "packages":
+      return null;
+    // Can't easily check pi packages on disk
+    case "configs": {
+      const name = (component.source ?? component.name).replace(".template", "");
+      return resolve3(PI_AGENT_DIR, name);
+    }
+    default:
+      return null;
+  }
+}
+function isSymlink2(path) {
+  try {
+    return lstatSync2(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function checkFile(path) {
+  if (isSymlink2(path)) {
+    const target = readlinkSync2(path);
+    const dangling = !existsSync3(path);
+    return {
+      exists: !dangling,
+      detail: dangling ? `dangling symlink -> ${target}` : `symlink -> ${target}`
+    };
+  }
+  return { exists: existsSync3(path) };
+}
+function runStatus() {
+  const manifest = readManifest();
+  console.log();
+  console.log(pc3.bold("pi-toolkit status"));
+  console.log();
+  if (!manifest.installedAt) {
+    console.log(pc3.dim("No pi-toolkit manifest found. Nothing has been installed yet."));
+    console.log(pc3.dim('Run "pi-toolkit install" to get started.'));
+    console.log();
+    return;
+  }
+  console.log(
+    `${pc3.dim("CLI version:")}  ${manifest.version || "unknown"}`
+  );
+  console.log(
+    `${pc3.dim("Installed at:")} ${manifest.installedAt}`
+  );
+  console.log(
+    `${pc3.dim("Updated at:")}   ${manifest.updatedAt}`
+  );
+  console.log();
+  const installedNames = /* @__PURE__ */ new Set([
+    ...manifest.installed.extensions,
+    ...manifest.installed.skills.bundled,
+    ...manifest.installed.skills.external,
+    ...manifest.installed.packages,
+    ...manifest.installed.configs
+  ]);
+  const entries = [];
+  for (const component of registry) {
+    const isInstalled = installedNames.has(component.name);
+    if (!isInstalled) {
+      entries.push({
+        name: component.name,
+        category: component.category,
+        status: "not-installed"
+      });
+      continue;
+    }
+    const path = expectedPath(component);
+    if (!path) {
+      entries.push({
+        name: component.name,
+        category: component.category,
+        status: "ok",
+        detail: "installed (cannot verify on disk)"
+      });
+      continue;
+    }
+    const check = checkFile(path);
+    entries.push({
+      name: component.name,
+      category: component.category,
+      status: check.exists ? "ok" : "missing",
+      detail: check.detail
+    });
+  }
+  const categories = [
+    { key: "extensions", label: "Extensions" },
+    { key: "skills-bundled", label: "Bundled Skills" },
+    { key: "skills-external", label: "External Skills" },
+    { key: "packages", label: "Packages" },
+    { key: "configs", label: "Configs" }
+  ];
+  for (const cat of categories) {
+    const catEntries = entries.filter((e) => e.category === cat.key);
+    if (catEntries.length === 0) continue;
+    const installed = catEntries.filter((e) => e.status !== "not-installed");
+    const available = catEntries.filter((e) => e.status === "not-installed");
+    console.log(
+      pc3.bold(pc3.cyan(cat.label)) + pc3.dim(` (${installed.length}/${catEntries.length} installed)`)
+    );
+    for (const entry of installed) {
+      const icon = entry.status === "ok" ? pc3.green("*") : pc3.red("!");
+      const detail = entry.detail ? pc3.dim(` (${entry.detail})`) : "";
+      const statusLabel = entry.status === "missing" ? pc3.red(" MISSING") : "";
+      console.log(`  ${icon} ${entry.name}${statusLabel}${detail}`);
+    }
+    if (available.length > 0) {
+      console.log(
+        pc3.dim(`  ${available.length} more available: ${available.map((e) => e.name).join(", ")}`)
+      );
+    }
+    console.log();
+  }
+  const missing = entries.filter((e) => e.status === "missing");
+  if (missing.length > 0) {
+    console.log(
+      pc3.yellow(
+        `${missing.length} component(s) in manifest but missing from disk:`
+      )
+    );
+    for (const m of missing) {
+      console.log(pc3.yellow(`  - ${m.name}`));
+    }
+    console.log(pc3.dim('Re-run "pi-toolkit install" to restore them.'));
+    console.log();
+  }
+}
+
+// src/index.ts
+var CLI_VERSION = "0.1.0";
+var install = defineCommand({
+  meta: {
+    name: "install",
+    description: "Install extensions, skills, packages, and configs"
+  },
+  args: {
+    all: {
+      type: "boolean",
+      description: "Install all available components",
+      default: false
+    },
+    "override-configs": {
+      type: "boolean",
+      description: "Overwrite existing config files",
+      default: false
+    },
+    link: {
+      type: "boolean",
+      description: "Symlink to local repo clone instead of copying",
+      default: false
+    },
+    "repo-path": {
+      type: "string",
+      description: "Path to local pi-toolkit repo clone (required with --link)"
+    },
+    extensions: {
+      type: "string",
+      description: "Extensions to install (space-separated names)"
+    },
+    skills: {
+      type: "string",
+      description: "Skills to install (space-separated names)"
+    },
+    packages: {
+      type: "string",
+      description: "Packages to install (space-separated names)"
+    }
+  },
+  run({ args }) {
+    const splitArg = (val) => {
+      if (!val) return void 0;
+      return val.split(/[\s,]+/).map((s) => s.trim()).filter(Boolean);
+    };
+    return runInstall({
+      all: args.all,
+      overrideConfigs: args["override-configs"],
+      link: args.link,
+      repoPath: args["repo-path"],
+      extensions: splitArg(args.extensions),
+      skills: splitArg(args.skills),
+      packages: splitArg(args.packages),
+      version: CLI_VERSION
+    });
+  }
+});
+var list = defineCommand({
+  meta: {
+    name: "list",
+    description: "Browse all available components"
+  },
+  run() {
+    runList();
+  }
+});
+var status = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show installed components and detect drift"
+  },
+  run() {
+    runStatus();
+  }
+});
+var main = defineCommand({
+  meta: {
+    name: "pi-toolkit",
+    version: CLI_VERSION,
+    description: "Selectively install curated extensions, skills, and configs for the pi coding agent"
+  },
+  subCommands: {
+    install,
+    list,
+    status
+  }
+});
+runMain(main);