@devrev-computer/skills 1.0.0 → 2.0.0

package/bin/install.mjs

@@ -1,158 +1,500 @@
 #!/usr/bin/env node
 
-import { readdir, cp, mkdir, stat, readFile } from "node:fs/promises";
+import { readdir, cp, mkdir, stat, readFile, rm } from "node:fs/promises";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
 import { parseArgs } from "node:util";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const skillsSource = join(__dirname, "..", "skills");
 
+// ── Skill catalog ──────────────────────────────────────────────
+
 const SKILLS = [
-  "account-evaluation",
-  "account-research",
-  "create-workflow-template",
-  "customer-brief",
-  "deal-review-meddpicc",
-  "next-step-for-opportunity",
-  "opportunity-feature-prioritizer",
-  "sales-call-plan-coach",
-  "sales-context",
-  "sales-search-and-lookup",
-  "skill-creator",
-  "trace-diagnosis",
+  { name: "account-evaluation",           category: "sales",    desc: "Account health report — pipeline, engagement, and external data" },
+  { name: "account-research",             category: "sales",    desc: "Company/person research — web, DevRev, and enrichment layers" },
+  { name: "create-workflow-template",     category: "platform", desc: "Generate DevRev workflow template JSON from natural language" },
+  { name: "customer-brief",              category: "sales",    desc: "Pre-meeting briefing with internal and external context" },
+  { name: "deal-review-meddpicc",        category: "sales",    desc: "Full MEDDPICC deal assessment with evidence-tagged scoring" },
+  { name: "next-step-for-opportunity",   category: "sales",    desc: "Extract planned actions from meetings, emails, discussions" },
+  { name: "opportunity-feature-prioritizer", category: "product", desc: "Prioritize features based on open opportunity pipeline" },
+  { name: "sales-call-plan-coach",       category: "sales",    desc: "Interactive call plan coaching — Franklin Covey methodology" },
+  { name: "sales-context",              category: "sales",    desc: "Always-active skill for consistent sales terminology" },
+  { name: "sales-search-and-lookup",    category: "sales",    desc: "Query pipeline, forecast, accounts via natural language" },
+  { name: "skill-creator",             category: "meta",     desc: "Create, modify, evaluate, and benchmark skills" },
+  { name: "trace-diagnosis",           category: "eng",      desc: "Debug Computer agent traces and auto-create tickets" },
+];
+
+const SKILL_NAMES = SKILLS.map((s) => s.name);
+
+// ── Logo ───────────────────────────────────────────────────────
+
+const GRAYS = [
+  "\x1b[38;5;251m",
+  "\x1b[38;5;248m",
+  "\x1b[38;5;245m",
+  "\x1b[38;5;242m",
+  "\x1b[38;5;239m",
+];
+const RESET = "\x1b[0m";
+
+const LOGO = [
+  " ██████╗ ██████╗ ███╗   ███╗██████╗ ██╗   ██╗████████╗███████╗██████╗ ",
+  "██╔════╝██╔═══██╗████╗ ████║██╔══██╗██║   ██║╚══██╔══╝██╔════╝██╔══██╗",
+  "██║     ██║   ██║██╔████╔██║██████╔╝██║   ██║   ██║   █████╗  ██████╔╝",
+  "██║     ██║   ██║██║╚██╔╝██║██╔═══╝ ██║   ██║   ██║   ██╔══╝  ██╔══██╗",
+  "╚██████╗╚██████╔╝██║ ╚═╝ ██║██║     ╚██████╔╝   ██║   ███████╗██║  ██║",
 ];
 
+function showLogo() {
+  console.log();
+  LOGO.forEach((line, i) => {
+    console.log(`  ${GRAYS[i]}${line}${RESET}`);
+  });
+  console.log();
+  console.log(
+    `  ${pc.dim("DevRev Computer Skills")}  ${pc.dim("v")}${pc.dim(getVersion())}`
+  );
+  console.log();
+}
+
+function getVersion() {
+  try {
+    const pkg = JSON.parse(
+      require("node:fs").readFileSync(join(__dirname, "..", "package.json"), "utf-8")
+    );
+    return pkg.version;
+  } catch {
+    return "1.0.0";
+  }
+}
+
+// ── Helpers ────────────────────────────────────────────────────
+
+function shortenPath(fullPath) {
+  const home = homedir();
+  if (fullPath.startsWith(home)) {
+    return "~" + fullPath.slice(home.length);
+  }
+  return fullPath;
+}
+
+function getGlobalSkillsDir() {
+  return join(homedir(), ".claude", "skills");
+}
+
+function getProjectSkillsDir(cwd) {
+  return join(cwd, ".claude", "skills");
+}
+
+function hasProjectClaude(cwd) {
+  return existsSync(join(cwd, ".claude")) || existsSync(join(cwd, "CLAUDE.md"));
+}
+
+async function getInstalledSkills(dir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries
+      .filter((e) => e.isDirectory() && SKILL_NAMES.includes(e.name))
+      .map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+
+// ── Non-interactive (flags) ────────────────────────────────────
+
 function usage() {
   console.log(`
-Usage: computer-skills [options]
+${pc.bold("Usage:")} computer-skills ${pc.dim("[command] [options]")}
 
-Install DevRev Computer Skills into your project's .claude/skills/ directory.
+${pc.bold("Commands:")}
+  ${pc.cyan("add")}          Install skills ${pc.dim("(default, interactive)")}
+  ${pc.cyan("remove")}       Uninstall skills
+  ${pc.cyan("list")}         List installed and available skills
 
-Options:
-  --list, -l          List available skills
-  --skill, -s <name>  Install specific skill(s) (repeatable)
-  --dir, -d <path>    Target project directory (default: cwd)
-  --uninstall, -u     Remove installed skills
-  --help, -h          Show this help
+${pc.bold("Options:")}
+  ${pc.dim("-s, --skill <name>")}   Specific skill(s) ${pc.dim("(repeatable)")}
+  ${pc.dim("-g, --global")}         Install to ~/.claude/skills/
+  ${pc.dim("-d, --dir <path>")}     Target project directory
+  ${pc.dim("-y, --yes")}            Skip prompts, install all
+  ${pc.dim("-h, --help")}           Show this help
+  ${pc.dim("-v, --version")}        Show version
+
+${pc.bold("Examples:")}
+  ${pc.dim("$")} npx @devrev-computer/skills
+  ${pc.dim("$")} npx @devrev-computer/skills add -g
+  ${pc.dim("$")} npx @devrev-computer/skills add -s skill-creator -s trace-diagnosis
+  ${pc.dim("$")} npx @devrev-computer/skills remove
+  ${pc.dim("$")} npx @devrev-computer/skills list
 `);
 }
 
-async function getSkillDescription(skillDir) {
-  const candidates = [
-    "SKILL.md",
-    ...SKILLS.map((s) => `${s}.md`),
-  ];
-  for (const file of await readdir(skillDir)) {
-    if (file.endsWith(".md") && (file === "SKILL.md" || file === join(skillDir).split("/").pop() + ".md")) {
-      try {
-        const content = await readFile(join(skillDir, file), "utf-8");
-        const match = content.match(/description:\s*>?\s*\n?\s*(.+)/);
-        if (match) return match[1].trim().slice(0, 80);
-      } catch {}
+// ── List command ───────────────────────────────────────────────
+
+async function runList(cwd) {
+  const globalDir = getGlobalSkillsDir();
+  const projectDir = getProjectSkillsDir(cwd);
+  const globalInstalled = await getInstalledSkills(globalDir);
+  const projectInstalled = await getInstalledSkills(projectDir);
+
+  console.log();
+  console.log(pc.bold("  Available skills:\n"));
+
+  const categories = { sales: "Sales", platform: "Platform", product: "Product", meta: "Meta", eng: "Engineering" };
+
+  for (const [cat, label] of Object.entries(categories)) {
+    const skills = SKILLS.filter((s) => s.category === cat);
+    if (skills.length === 0) continue;
+
+    console.log(`  ${pc.dim("──")} ${pc.bold(label)} ${pc.dim("─".repeat(50))}`);
+    for (const skill of skills) {
+      const inGlobal = globalInstalled.includes(skill.name);
+      const inProject = projectInstalled.includes(skill.name);
+      let badge = "";
+      if (inGlobal && inProject) badge = pc.green(" [global + project]");
+      else if (inGlobal) badge = pc.cyan(" [global]");
+      else if (inProject) badge = pc.blue(" [project]");
+
+      console.log(`  ${pc.cyan(skill.name)}${badge}`);
+      console.log(`  ${pc.dim(skill.desc)}`);
     }
+    console.log();
   }
-  return "";
+
+  console.log(
+    `  ${pc.dim(`${SKILLS.length} available`)}${globalInstalled.length ? pc.dim(` · ${globalInstalled.length} global`) : ""}${projectInstalled.length ? pc.dim(` · ${projectInstalled.length} project`) : ""}`
+  );
+  console.log();
 }
 
-async function listSkills() {
-  console.log("\nAvailable skills:\n");
-  for (const skill of SKILLS) {
-    const desc = await getSkillDescription(join(skillsSource, skill)).catch(() => "");
-    console.log(`  ${skill}${desc ? ` — ${desc}` : ""}`);
+// ── Interactive add ────────────────────────────────────────────
+
+async function runAdd(cwd, flags) {
+  showLogo();
+  p.intro(pc.inverse(" Install Skills "));
+
+  // ── Step 1: Scope ──
+
+  let targetDir;
+  const isInProject = hasProjectClaude(cwd);
+
+  if (flags.global) {
+    targetDir = homedir();
+  } else if (flags.dir) {
+    targetDir = flags.dir;
+  } else if (flags.yes) {
+    targetDir = isInProject ? cwd : homedir();
+  } else {
+    const scopeOptions = [];
+    if (isInProject) {
+      scopeOptions.push({
+        value: "project",
+        label: "Project",
+        hint: shortenPath(getProjectSkillsDir(cwd)),
+      });
+    }
+    scopeOptions.push({
+      value: "global",
+      label: "Global",
+      hint: shortenPath(getGlobalSkillsDir()),
+    });
+    if (isInProject) {
+      scopeOptions.push({
+        value: "both",
+        label: "Both",
+        hint: "Project + Global",
+      });
+    }
+
+    const scope = await p.select({
+      message: "Where do you want to install skills?",
+      options: scopeOptions,
+    });
+
+    if (p.isCancel(scope)) {
+      p.cancel("Installation cancelled.");
+      process.exit(0);
+    }
+
+    if (scope === "global") {
+      targetDir = homedir();
+    } else if (scope === "both") {
+      // Install to both — we'll handle this after skill selection
+      targetDir = "__both__";
+    } else {
+      targetDir = cwd;
+    }
   }
-  console.log(`\n  ${SKILLS.length} skills total\n`);
-}
 
-async function installSkills(targetDir, selectedSkills) {
-  const skillsDir = join(targetDir, ".claude", "skills");
-  await mkdir(skillsDir, { recursive: true });
+  // ── Step 2: Skill selection ──
 
-  const toInstall = selectedSkills.length > 0 ? selectedSkills : SKILLS;
-  const invalid = toInstall.filter((s) => !SKILLS.includes(s));
-  if (invalid.length > 0) {
-    console.error(`Unknown skill(s): ${invalid.join(", ")}`);
-    console.error(`Run 'computer-skills --list' to see available skills.`);
-    process.exit(1);
+  let selectedSkills;
+
+  if (flags.skill && flags.skill.length > 0) {
+    const invalid = flags.skill.filter((s) => !SKILL_NAMES.includes(s));
+    if (invalid.length > 0) {
+      p.cancel(`Unknown skill(s): ${invalid.join(", ")}`);
+      process.exit(1);
+    }
+    selectedSkills = flags.skill;
+  } else if (flags.yes) {
+    selectedSkills = SKILL_NAMES;
+  } else {
+    const alreadyInstalled = targetDir === "__both__"
+      ? await getInstalledSkills(getProjectSkillsDir(cwd))
+      : await getInstalledSkills(
+          targetDir === homedir()
+            ? getGlobalSkillsDir()
+            : getProjectSkillsDir(targetDir)
+        );
+
+    const selected = await p.multiselect({
+      message: "Which skills do you want to install?",
+      options: SKILLS.map((s) => ({
+        value: s.name,
+        label: s.name,
+        hint: alreadyInstalled.includes(s.name)
+          ? `${s.desc} ${pc.yellow("(installed, will update)")}`
+          : s.desc,
+      })),
+      required: true,
+    });
+
+    if (p.isCancel(selected)) {
+      p.cancel("Installation cancelled.");
+      process.exit(0);
+    }
+
+    selectedSkills = selected;
+  }
+
+  // ── Step 3: Confirmation ──
+
+  const targets =
+    targetDir === "__both__"
+      ? [getProjectSkillsDir(cwd), getGlobalSkillsDir()]
+      : [
+          targetDir === homedir()
+            ? getGlobalSkillsDir()
+            : getProjectSkillsDir(targetDir),
+        ];
+
+  if (!flags.yes) {
+    const summaryLines = [
+      `${pc.bold("Skills:")}  ${selectedSkills.length === SKILL_NAMES.length ? "All (" + SKILL_NAMES.length + ")" : selectedSkills.join(", ")}`,
+      `${pc.bold("Target:")}  ${targets.map(shortenPath).join(" + ")}`,
+    ];
+
+    p.note(summaryLines.join("\n"), "Installation Summary");
+
+    const confirmed = await p.confirm({
+      message: "Proceed with installation?",
+    });
+
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.cancel("Installation cancelled.");
+      process.exit(0);
+    }
   }
 
-  let installed = 0;
-  let skipped = 0;
+  // ── Step 4: Install ──
 
-  for (const skill of toInstall) {
-    const src = join(skillsSource, skill);
-    const dest = join(skillsDir, skill);
+  const s = p.spinner();
+  s.start(`Installing ${selectedSkills.length} skill(s)`);
 
-    try {
-      await stat(src);
-    } catch {
-      console.error(`  skip  ${skill} (not found in package)`);
-      skipped++;
-      continue;
+  let totalInstalled = 0;
+  for (const dest of targets) {
+    await mkdir(dest, { recursive: true });
+    for (const skill of selectedSkills) {
+      const src = join(skillsSource, skill);
+      try {
+        await stat(src);
+        await cp(src, join(dest, skill), { recursive: true, force: true });
+        totalInstalled++;
+      } catch {
+        // skip missing
+      }
     }
+  }
 
-    await cp(src, dest, { recursive: true, force: true });
-    console.log(`  +  ${skill}`);
-    installed++;
+  s.stop(`Installed ${selectedSkills.length} skill(s)`);
+
+  // ── Step 5: Summary ──
+
+  const installed = selectedSkills;
+  console.log();
+  for (const skill of installed) {
+    const info = SKILLS.find((s) => s.name === skill);
+    console.log(`  ${pc.green("+")} ${pc.bold(skill)} ${pc.dim("—")} ${pc.dim(info?.desc || "")}`);
   }
+  console.log();
 
-  console.log(
-    `\nInstalled ${installed} skill(s) into ${skillsDir}${skipped > 0 ? ` (${skipped} skipped)` : ""}`
+  for (const dest of targets) {
+    console.log(`  ${pc.dim("Installed to")} ${pc.cyan(shortenPath(dest))}`);
+  }
+  console.log();
+
+  p.outro(
+    `${pc.green("Done!")} Skills are ready to use in Claude Code.`
   );
 }
 
-async function uninstallSkills(targetDir, selectedSkills) {
-  const { rm } = await import("node:fs/promises");
-  const skillsDir = join(targetDir, ".claude", "skills");
-  const toRemove = selectedSkills.length > 0 ? selectedSkills : SKILLS;
+// ── Interactive remove ─────────────────────────────────────────
+
+async function runRemove(cwd, flags) {
+  showLogo();
+  p.intro(pc.inverse(" Remove Skills "));
+
+  // Find installed skills
+  const globalDir = getGlobalSkillsDir();
+  const projectDir = getProjectSkillsDir(cwd);
+  const globalInstalled = await getInstalledSkills(globalDir);
+  const projectInstalled = await getInstalledSkills(projectDir);
+
+  if (globalInstalled.length === 0 && projectInstalled.length === 0) {
+    p.log.warn("No skills are currently installed.");
+    p.outro("Nothing to remove.");
+    return;
+  }
+
+  // Build options with location badges
+  const allInstalled = new Map();
+  for (const s of projectInstalled) {
+    allInstalled.set(s, { project: true, global: globalInstalled.includes(s) });
+  }
+  for (const s of globalInstalled) {
+    if (!allInstalled.has(s)) {
+      allInstalled.set(s, { project: false, global: true });
+    }
+  }
+
+  let toRemove;
+  if (flags.skill && flags.skill.length > 0) {
+    toRemove = flags.skill;
+  } else if (flags.yes) {
+    toRemove = [...allInstalled.keys()];
+  } else {
+    const selected = await p.multiselect({
+      message: "Which skills do you want to remove?",
+      options: [...allInstalled.entries()].map(([name, loc]) => {
+        const where = [loc.project && "project", loc.global && "global"]
+          .filter(Boolean)
+          .join(" + ");
+        return {
+          value: name,
+          label: name,
+          hint: where,
+        };
+      }),
+      required: true,
+    });
+
+    if (p.isCancel(selected)) {
+      p.cancel("Removal cancelled.");
+      process.exit(0);
+    }
+    toRemove = selected;
+  }
+
+  const confirmed = flags.yes || await (async () => {
+    const c = await p.confirm({
+      message: `Remove ${toRemove.length} skill(s)?`,
+    });
+    return !p.isCancel(c) && c;
+  })();
+
+  if (!confirmed) {
+    p.cancel("Removal cancelled.");
+    process.exit(0);
+  }
+
+  const s = p.spinner();
+  s.start(`Removing ${toRemove.length} skill(s)`);
 
   let removed = 0;
   for (const skill of toRemove) {
-    const dest = join(skillsDir, skill);
-    try {
-      await stat(dest);
-      await rm(dest, { recursive: true, force: true });
-      console.log(`  -  ${skill}`);
-      removed++;
-    } catch {
-      // not installed, skip
+    for (const dir of [projectDir, globalDir]) {
+      const dest = join(dir, skill);
+      try {
+        await stat(dest);
+        await rm(dest, { recursive: true, force: true });
+        removed++;
+      } catch {
+        // not there
+      }
     }
   }
-  console.log(`\nRemoved ${removed} skill(s) from ${skillsDir}`);
+
+  s.stop(`Removed ${toRemove.length} skill(s)`);
+
+  console.log();
+  for (const skill of toRemove) {
+    console.log(`  ${pc.red("-")} ${skill}`);
+  }
+  console.log();
+
+  p.outro(pc.green("Done!"));
 }
 
+// ── Main ───────────────────────────────────────────────────────
+
 async function main() {
-  const { values } = parseArgs({
+  const { values, positionals } = parseArgs({
     options: {
-      list: { type: "boolean", short: "l", default: false },
       skill: { type: "string", short: "s", multiple: true, default: [] },
-      dir: { type: "string", short: "d", default: process.cwd() },
-      uninstall: { type: "boolean", short: "u", default: false },
+      dir: { type: "string", short: "d" },
+      global: { type: "boolean", short: "g", default: false },
+      yes: { type: "boolean", short: "y", default: false },
       help: { type: "boolean", short: "h", default: false },
+      version: { type: "boolean", short: "v", default: false },
     },
+    allowPositionals: true,
     strict: true,
   });
 
-  if (values.help) {
-    usage();
+  if (values.version) {
+    console.log(getVersion());
     process.exit(0);
   }
 
-  if (values.list) {
-    await listSkills();
+  if (values.help) {
+    showLogo();
+    usage();
     process.exit(0);
   }
 
-  console.log("\n@devrev/computer-skills\n");
+  const command = positionals[0] || "add";
+  const cwd = values.dir || process.cwd();
 
-  if (values.uninstall) {
-    await uninstallSkills(values.dir, values.skill);
-  } else {
-    await installSkills(values.dir, values.skill);
+  switch (command) {
+    case "add":
+    case "install":
+    case "i":
+      await runAdd(cwd, values);
+      break;
+    case "remove":
+    case "rm":
+    case "uninstall":
+      await runRemove(cwd, values);
+      break;
+    case "list":
+    case "ls":
+      showLogo();
+      await runList(cwd);
+      break;
+    default:
+      // No command = interactive add
+      await runAdd(cwd, values);
+      break;
   }
 }
 
 main().catch((err) => {
-  console.error(err.message);
+  p.cancel(err.message);
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev-computer/skills",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "AI-powered skills for Claude Code — sales intelligence, deal management, workflow automation, and agent debugging, built on DevRev.",
   "type": "module",
   "bin": {
@@ -29,5 +29,9 @@
   "author": "DevRev",
   "engines": {
     "node": ">=18"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.2.0",
+    "picocolors": "^1.1.1"
   }
 }