@callmeradical/augy 0.1.0

package/dist/chunk-ZW6ZKHTF.js

@@ -0,0 +1,136 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/registry.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+function augyHome() {
+  const env = process.env["AUGY_HOME"];
+  return env ?? join(homedir(), ".augy");
+}
+function registryPath() {
+  return join(augyHome(), "registry.json");
+}
+function versionsDir() {
+  return join(augyHome(), "versions");
+}
+function versionArchivePath(skillName, sha) {
+  return join(versionsDir(), skillName, sha);
+}
+var EMPTY_REGISTRY = { version: 1, taps: {}, skills: {} };
+async function readRegistry() {
+  const p = registryPath();
+  if (!existsSync(p)) return structuredClone(EMPTY_REGISTRY);
+  try {
+    const raw = await readFile(p, "utf8");
+    const parsed = JSON.parse(raw);
+    return { ...structuredClone(EMPTY_REGISTRY), ...parsed };
+  } catch {
+    return structuredClone(EMPTY_REGISTRY);
+  }
+}
+async function writeRegistry(registry) {
+  const p = registryPath();
+  const tmp = `${p}.tmp`;
+  await mkdir(join(p, ".."), { recursive: true });
+  await writeFile(tmp, JSON.stringify(registry, null, 2) + "\n", "utf8");
+  await rename(tmp, p);
+}
+function shortSha(sha) {
+  return sha.slice(0, 7);
+}
+function getSkill(registry, name) {
+  return registry.skills[name];
+}
+function listSkills(registry) {
+  return Object.values(registry.skills);
+}
+function upsertSkill(registry, skill) {
+  registry.skills[skill.name] = skill;
+}
+function removeSkill(registry, name) {
+  delete registry.skills[name];
+}
+function createSkillRecord(opts) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    name: opts.name,
+    source: opts.source,
+    gigetSource: opts.gigetSource,
+    sha: opts.sha,
+    shortSha: shortSha(opts.sha),
+    installedAt: now,
+    updatedAt: now,
+    pinned: false,
+    tap: opts.tap,
+    agents: Object.fromEntries(
+      opts.agentIds.map((id) => [
+        id,
+        { path: opts.agentPaths[id] ?? "", active: true }
+      ])
+    ),
+    history: []
+  };
+}
+function tapKey(owner, repo) {
+  return `${owner}/${repo}`;
+}
+function getTap(registry, key) {
+  return registry.taps[key];
+}
+function listTaps(registry) {
+  return Object.entries(registry.taps).map(([key, tap]) => ({ key, ...tap }));
+}
+function addTap(registry, tap) {
+  registry.taps[tapKey(tap.owner, tap.repo)] = tap;
+}
+function removeTap(registry, key) {
+  delete registry.taps[key];
+}
+
+export {
+  __commonJS,
+  __toESM,
+  augyHome,
+  registryPath,
+  versionsDir,
+  versionArchivePath,
+  readRegistry,
+  writeRegistry,
+  shortSha,
+  getSkill,
+  listSkills,
+  upsertSkill,
+  removeSkill,
+  createSkillRecord,
+  tapKey,
+  getTap,
+  listTaps,
+  addTap,
+  removeTap
+};

package/dist/diff-KYSWUXMH.js

@@ -0,0 +1,303 @@
+import {
+  archiveExists
+} from "./chunk-PX2LVUHV.js";
+import {
+  discoverSkills,
+  parseGitHubUrl
+} from "./chunk-EU54UQ4C.js";
+import {
+  getSkill,
+  readRegistry,
+  shortSha,
+  versionArchivePath
+} from "./chunk-ZW6ZKHTF.js";
+
+// src/commands/diff.ts
+import { cancel, intro, isCancel, outro, select, spinner } from "@clack/prompts";
+import chalk2 from "chalk";
+import { existsSync } from "fs";
+
+// src/fileDiff.ts
+import { readdir, readFile } from "fs/promises";
+import { join, relative } from "path";
+import { createPatch } from "diff";
+import chalk from "chalk";
+async function readLocalFiles(dir) {
+  const result = /* @__PURE__ */ new Map();
+  await walk(dir, dir, result);
+  return result;
+}
+async function walk(root, current, out) {
+  const entries = await readdir(current, { withFileTypes: true });
+  await Promise.all(
+    entries.map(async (entry) => {
+      const full = join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(root, full, out);
+      } else if (entry.isFile()) {
+        const rel = relative(root, full);
+        const content = await readFile(full, "utf8").catch(() => "");
+        out.set(rel, content);
+      }
+    })
+  );
+}
+function apiHeaders() {
+  const token = process.env["GITHUB_TOKEN"];
+  return {
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    ...token ? { Authorization: `Bearer ${token}` } : {}
+  };
+}
+async function ghFetch(url) {
+  const res = await fetch(url, { headers: apiHeaders() });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`GitHub API ${res.status}: ${url}
+${body}`);
+  }
+  return res.json();
+}
+async function fetchGitHubFiles(coords, commitSha) {
+  const { owner, repo, path: skillRepoPath } = coords;
+  const commit = await ghFetch(
+    `https://api.github.com/repos/${owner}/${repo}/git/commits/${commitSha}`
+  );
+  const rootTreeSha = commit.tree.sha;
+  const tree = await ghFetch(
+    `https://api.github.com/repos/${owner}/${repo}/git/trees/${rootTreeSha}?recursive=1`
+  );
+  const prefix = skillRepoPath ? `${skillRepoPath}/` : "";
+  const blobs = tree.tree.filter(
+    (item) => item.type === "blob" && item.path.startsWith(prefix)
+  );
+  const result = /* @__PURE__ */ new Map();
+  await Promise.all(
+    blobs.map(async (blob) => {
+      const data = await ghFetch(
+        `https://api.github.com/repos/${owner}/${repo}/git/blobs/${blob.sha}`
+      );
+      const content = data.encoding === "base64" ? Buffer.from(data.content.replace(/\n/g, ""), "base64").toString("utf8") : data.content;
+      const relPath = prefix ? blob.path.slice(prefix.length) : blob.path;
+      result.set(relPath, content);
+    })
+  );
+  return result;
+}
+function computeFileDiffs(oldFiles, newFiles) {
+  const allPaths = /* @__PURE__ */ new Set([...oldFiles.keys(), ...newFiles.keys()]);
+  const diffs = [];
+  for (const path of allPaths) {
+    const oldContent = oldFiles.get(path) ?? "";
+    const newContent = newFiles.get(path) ?? "";
+    const status = !oldFiles.has(path) ? "added" : !newFiles.has(path) ? "deleted" : oldContent === newContent ? "unchanged" : "modified";
+    if (status === "unchanged") continue;
+    const patch = createPatch(path, oldContent, newContent, void 0, void 0, {
+      context: 3
+    });
+    const { additions, deletions } = countChanges(patch);
+    diffs.push({ path, status, additions, deletions, patch, oldContent, newContent });
+  }
+  const order = {
+    modified: 0,
+    added: 1,
+    deleted: 2,
+    unchanged: 3
+  };
+  return diffs.sort((a, b) => order[a.status] - order[b.status]);
+}
+function countChanges(patch) {
+  let additions = 0;
+  let deletions = 0;
+  for (const line of patch.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++")) additions++;
+    else if (line.startsWith("-") && !line.startsWith("---")) deletions++;
+  }
+  return { additions, deletions };
+}
+function renderPatch(diff, oldLabel, newLabel) {
+  if (!diff.patch) return chalk.dim("(no changes)");
+  const lines = diff.patch.split("\n");
+  const rendered = [];
+  for (const line of lines) {
+    if (line.startsWith("---")) {
+      rendered.push(chalk.dim(`--- ${oldLabel}/${diff.path}`));
+    } else if (line.startsWith("+++")) {
+      rendered.push(chalk.dim(`+++ ${newLabel}/${diff.path}`));
+    } else if (line.startsWith("@@")) {
+      rendered.push(chalk.cyan(line));
+    } else if (line.startsWith("+")) {
+      rendered.push(chalk.green(line));
+    } else if (line.startsWith("-")) {
+      rendered.push(chalk.red(line));
+    } else if (line.startsWith("\\")) {
+      rendered.push(chalk.dim(line));
+    } else {
+      rendered.push(line);
+    }
+  }
+  return rendered.join("\n");
+}
+function diffBadge(diff) {
+  const parts = [];
+  if (diff.additions > 0) parts.push(chalk.green(`+${diff.additions}`));
+  if (diff.deletions > 0) parts.push(chalk.red(`-${diff.deletions}`));
+  return parts.join(" ") || chalk.dim("no changes");
+}
+function statusSigil(status) {
+  switch (status) {
+    case "modified":
+      return chalk.yellow("M");
+    case "added":
+      return chalk.green("A");
+    case "deleted":
+      return chalk.red("D");
+    default:
+      return " ";
+  }
+}
+
+// src/commands/diff.ts
+async function diffCommand(skillName, sha1Arg, sha2Arg) {
+  intro(chalk2.bold("augy") + chalk2.dim(" \u2014 diff browser"));
+  const registry = await readRegistry();
+  const skill = getSkill(registry, skillName);
+  if (!skill) {
+    cancel(`Skill "${skillName}" not found. Run \`augy list\` to see installed skills.`);
+    process.exit(1);
+  }
+  let oldFiles;
+  let newFiles;
+  let oldLabel;
+  let newLabel;
+  if (sha1Arg && sha2Arg) {
+    ({ files: oldFiles, label: oldLabel } = await resolveLocalArchive(skillName, sha1Arg, skill.history));
+    ({ files: newFiles, label: newLabel } = await resolveLocalArchive(skillName, sha2Arg, skill.history));
+  } else if (sha1Arg) {
+    ({ files: oldFiles, label: oldLabel } = await resolveInstalledFiles(skill));
+    ({ files: newFiles, label: newLabel } = await resolveArbitraryRef(skill, sha1Arg));
+  } else {
+    ({ files: oldFiles, label: oldLabel } = await resolveInstalledFiles(skill));
+    ({ files: newFiles, label: newLabel } = await resolveUpstream(skill));
+  }
+  const diffs = computeFileDiffs(oldFiles, newFiles);
+  const changed = diffs.filter((d) => d.status !== "unchanged");
+  if (!changed.length) {
+    outro(chalk2.green(`No differences found between ${oldLabel} and ${newLabel}.`));
+    return;
+  }
+  printSummary(skillName, oldLabel, newLabel, changed);
+  await browseFiles(changed, oldLabel, newLabel);
+  outro(chalk2.dim("Done."));
+}
+async function resolveInstalledFiles(skill) {
+  const activeEntry = Object.entries(skill.agents).find(([, a]) => a.active);
+  if (!activeEntry) throw new Error("No active agent installation found.");
+  const [, install] = activeEntry;
+  if (!existsSync(install.path)) {
+    throw new Error(`Installed path does not exist: ${install.path}`);
+  }
+  const s = spinner();
+  s.start("Reading installed files\u2026");
+  const files = await readLocalFiles(install.path);
+  s.stop(`Read ${files.size} local file(s)`);
+  return { files, label: shortSha(skill.sha) + " (installed)" };
+}
+async function resolveUpstream(skill) {
+  const s = spinner();
+  s.start("Fetching upstream from GitHub\u2026");
+  const coords = parseGitHubUrl(skill.source);
+  const remote = await discoverSkills(coords);
+  const match = remote.find((r) => r.name === skill.name) ?? remote[0];
+  if (!match) throw new Error("Could not find skill on GitHub.");
+  const files = await fetchGitHubFiles(
+    { ...coords, path: match.repoPath },
+    match.sha
+  );
+  s.stop(`Fetched ${files.size} remote file(s)  ${chalk2.dim("@" + shortSha(match.sha))}`);
+  const label = match.sha === skill.sha ? shortSha(match.sha) + " (upstream = installed)" : shortSha(match.sha) + " (upstream)";
+  return { files, label };
+}
+async function resolveArbitraryRef(skill, shaPrefix) {
+  const histEntry = skill.history.find((v) => v.sha.startsWith(shaPrefix));
+  const fullSha = histEntry?.sha ?? shaPrefix;
+  if (archiveExists(skill.name, fullSha)) {
+    const archivePath = versionArchivePath(skill.name, fullSha);
+    const s2 = spinner();
+    s2.start(`Reading local archive ${shortSha(fullSha)}\u2026`);
+    const files2 = await readLocalFiles(archivePath);
+    s2.stop(`Read ${files2.size} archived file(s)`);
+    return { files: files2, label: shortSha(fullSha) + " (archive)" };
+  }
+  const s = spinner();
+  s.start(`Fetching GitHub @ ${shortSha(fullSha)}\u2026`);
+  const coords = parseGitHubUrl(skill.source);
+  const remote = await discoverSkills(coords);
+  const match = remote.find((r) => r.name === skill.name) ?? remote[0];
+  if (!match) throw new Error("Could not resolve skill path on GitHub.");
+  const files = await fetchGitHubFiles(
+    { ...coords, path: match.repoPath },
+    fullSha
+  );
+  s.stop(`Fetched ${files.size} file(s)  ${chalk2.dim("@" + shortSha(fullSha))}`);
+  return { files, label: shortSha(fullSha) };
+}
+async function resolveLocalArchive(skillName, shaPrefix, history) {
+  const histEntry = history.find((v) => v.sha.startsWith(shaPrefix));
+  const fullSha = histEntry?.sha ?? shaPrefix;
+  if (!archiveExists(skillName, fullSha)) {
+    throw new Error(
+      `No local archive for "${skillName}" @ ${shortSha(fullSha)}.
+Available: ${history.map((v) => shortSha(v.sha)).join(", ")}`
+    );
+  }
+  const archivePath = versionArchivePath(skillName, fullSha);
+  const s = spinner();
+  s.start(`Reading archive ${shortSha(fullSha)}\u2026`);
+  const files = await readLocalFiles(archivePath);
+  s.stop(`Read ${files.size} archived file(s)`);
+  return { files, label: shortSha(fullSha) };
+}
+function printSummary(skillName, oldLabel, newLabel, diffs) {
+  const totalAdd = diffs.reduce((n, d) => n + d.additions, 0);
+  const totalDel = diffs.reduce((n, d) => n + d.deletions, 0);
+  console.log();
+  console.log(
+    `  ${chalk2.bold(skillName)}  ` + chalk2.dim(oldLabel) + chalk2.dim("  \u2192  ") + chalk2.green(newLabel)
+  );
+  console.log(
+    `  ${chalk2.bold(String(diffs.length))} file(s) changed  ` + chalk2.green(`+${totalAdd}`) + "  " + chalk2.red(`-${totalDel}`)
+  );
+  console.log();
+  for (const d of diffs) {
+    const sigil = statusSigil(d.status);
+    const badge = diffBadge(d);
+    console.log(`    ${sigil}  ${chalk2.bold(d.path)}  ${badge}`);
+  }
+  console.log();
+}
+var EXIT_SENTINEL = "__EXIT__";
+async function browseFiles(diffs, oldLabel, newLabel) {
+  while (true) {
+    const chosen = await select({
+      message: "Select a file to inspect",
+      options: [
+        ...diffs.map((d) => ({
+          value: d.path,
+          label: `${statusSigil(d.status)}  ${chalk2.bold(d.path)}`,
+          hint: diffBadge(d)
+        })),
+        { value: EXIT_SENTINEL, label: chalk2.dim("\u2500\u2500 done \u2500\u2500"), hint: "" }
+      ]
+    });
+    if (isCancel(chosen) || chosen === EXIT_SENTINEL) break;
+    const diff = diffs.find((d) => d.path === chosen);
+    console.log();
+    console.log(renderPatch(diff, oldLabel, newLabel));
+    console.log();
+  }
+}
+export {
+  diffCommand
+};

package/dist/index.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { fileURLToPath } from "url";
+import { join, dirname } from "path";
+import { readFileSync } from "fs";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf8"));
+var program = new Command();
+program.name("augy").description("Homebrew for AI agent skills \u2014 install, version, update, rollback").version(pkg.version);
+program.command("install [url]").description("Install skills from a GitHub URL or owner/repo[/path]").option("-a, --agent <agents...>", "Target agent(s): opencode, claude, codex").action(async (url, opts) => {
+  const { installCommand } = await import("./install-FPAGHWX2.js");
+  await installCommand(url, opts ?? {});
+});
+program.command("update [skill]").description("Check for upstream changes and upgrade installed skills").action(async (skill) => {
+  const { updateCommand } = await import("./update-A3PSROUK.js");
+  await updateCommand(skill);
+});
+program.command("list").description("Show all installed skills with version + agent info").option("--json", "Output raw JSON registry").action(async (opts) => {
+  const { listCommand } = await import("./list-UJX2MYXK.js");
+  await listCommand(opts ?? {});
+});
+program.command("diff <skill> [sha1] [sha2]").description(
+  "Browse file-level diffs for a skill\n  augy diff <skill>              installed \u2194 upstream HEAD\n  augy diff <skill> <sha>        installed \u2194 specific SHA (archive or GitHub)\n  augy diff <skill> <sha1> <sha2> two local archives side-by-side"
+).action(async (skill, sha1, sha2) => {
+  const { diffCommand } = await import("./diff-KYSWUXMH.js");
+  await diffCommand(skill, sha1, sha2);
+});
+program.command("scan").description("Find skills installed outside augy and optionally import them into the registry").action(async () => {
+  const { scanCommand } = await import("./scan-DKN7YBT5.js");
+  await scanCommand();
+});
+program.command("info <skill>").description("Show full metadata, version history, and description for an installed skill").action(async (skill) => {
+  const { infoCommand } = await import("./info-7BO4LXXS.js");
+  await infoCommand(skill);
+});
+program.command("search [query]").description("Search all taps for available skills (optionally filter by name)").action(async (query) => {
+  const { searchCommand } = await import("./search-2V2U23KC.js");
+  await searchCommand(query);
+});
+var tap = program.command("tap").description("Manage trusted repos (taps) for skill name resolution");
+tap.command("add <repo>").description("Register a tap  e.g. augy tap add owner/repo").option("--path <skills-dir>", "Subdirectory where skills live (default: skills)").option("--description <text>", "Optional description").action(async (repo, opts) => {
+  const { tapAddCommand } = await import("./tap-3RD3XZ56.js");
+  await tapAddCommand(repo, opts);
+});
+tap.command("remove <repo>").description("Unregister a tap").action(async (repo) => {
+  const { tapRemoveCommand } = await import("./tap-3RD3XZ56.js");
+  await tapRemoveCommand(repo);
+});
+tap.command("list").description("List all registered taps").action(async () => {
+  const { tapListCommand } = await import("./tap-3RD3XZ56.js");
+  await tapListCommand();
+});
+program.command("set-source <skill> <url>").description("Attach a GitHub source URL to a skill imported without one").action(async (skill, url) => {
+  const { setSourceCommand } = await import("./set-source-TITL27N3.js");
+  await setSourceCommand(skill, url);
+});
+program.command("uninstall <skill>").description("Remove a skill from all agent paths and the registry").action(async (skill) => {
+  const { uninstallCommand } = await import("./uninstall-3C3XZZEC.js");
+  await uninstallCommand(skill);
+});
+program.command("rollback <skill> [sha]").description("Restore a skill to a previous archived version").action(async (skill, sha) => {
+  const { rollbackCommand } = await import("./rollback-WAZV5HNG.js");
+  await rollbackCommand(skill, sha);
+});
+program.command("pin <skill>").description("Pin a skill so it is skipped during `augy update`").action(async (skill) => {
+  await setPinned(skill, true);
+});
+program.command("unpin <skill>").description("Allow a pinned skill to receive updates again").action(async (skill) => {
+  await setPinned(skill, false);
+});
+program.action(async () => {
+  const { installCommand } = await import("./install-FPAGHWX2.js");
+  await installCommand();
+});
+program.parse();
+async function setPinned(skillName, pinned) {
+  const chalk = (await import("chalk")).default;
+  const { readRegistry, writeRegistry, getSkill } = await import("./registry-QVCNZXBZ.js");
+  const registry = await readRegistry();
+  const skill = getSkill(registry, skillName);
+  if (!skill) {
+    console.error(chalk.red(`Skill "${skillName}" not found in registry.`));
+    process.exit(1);
+  }
+  skill.pinned = pinned;
+  registry.skills[skillName] = skill;
+  await writeRegistry(registry);
+  const action = pinned ? chalk.yellow("pinned") : chalk.green("unpinned");
+  console.log(`${chalk.cyan(skillName)} is now ${action}.`);
+}

package/dist/info-7BO4LXXS.js

@@ -0,0 +1,119 @@
+import {
+  archiveExists
+} from "./chunk-PX2LVUHV.js";
+import {
+  AGENTS
+} from "./chunk-R2TJ3UDO.js";
+import {
+  getSkill,
+  readRegistry,
+  shortSha
+} from "./chunk-ZW6ZKHTF.js";
+
+// src/commands/info.ts
+import chalk from "chalk";
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+async function infoCommand(nameArg) {
+  const registry = await readRegistry();
+  const skill = getSkill(registry, nameArg);
+  if (!skill) {
+    console.error(
+      chalk.red(`Skill "${nameArg}" not found.`) + chalk.dim(" Run `augy list` to see installed skills.")
+    );
+    process.exit(1);
+  }
+  const hr = chalk.dim("\u2500".repeat(50));
+  console.log();
+  console.log(`  ${chalk.cyan.bold(skill.name)}` + (skill.label ? `  ${chalk.dim(skill.label)}` : ""));
+  console.log(`  ${hr}`);
+  console.log(`  ${label("source")}  ${skill.source}`);
+  if (skill.tap) {
+    const tap = registry.taps[skill.tap];
+    const tapDesc = tap?.description ? `  ${chalk.dim("\u2014")}  ${tap.description}` : "";
+    console.log(`  ${label("tap")}     ${chalk.cyan(skill.tap)}${tapDesc}`);
+  }
+  console.log(
+    `  ${label("sha")}     ${chalk.green(skill.shortSha)}` + chalk.dim(`  (full: ${skill.sha})`)
+  );
+  console.log(`  ${label("installed")} ${fmtDate(skill.installedAt)}`);
+  if (skill.updatedAt !== skill.installedAt) {
+    console.log(`  ${label("updated")}   ${fmtDate(skill.updatedAt)}`);
+  }
+  console.log(
+    `  ${label("pinned")}    ${skill.pinned ? chalk.yellow("yes  (skipped during `augy update`)") : chalk.dim("no")}`
+  );
+  console.log();
+  console.log(`  ${chalk.bold("Agents")}`);
+  const agentEntries = Object.entries(skill.agents);
+  if (!agentEntries.length) {
+    console.log(`  ${chalk.dim("  (none)")}`);
+  } else {
+    for (const [agentId, install] of agentEntries) {
+      const agentDef = AGENTS.find((a) => a.id === agentId);
+      const agentName = agentDef?.name ?? agentId;
+      const exists = existsSync(install.path);
+      const pathStatus = exists ? chalk.dim(install.path) : chalk.red(install.path) + chalk.red("  (missing!)");
+      const active = install.active ? "" : chalk.dim("  [inactive]");
+      console.log(`    ${chalk.bold(agentName.padEnd(10))}  ${pathStatus}${active}`);
+    }
+  }
+  console.log();
+  console.log(`  ${chalk.bold("Version history")}`);
+  if (!skill.history.length) {
+    console.log(`  ${chalk.dim("  No previous versions")}`);
+  } else {
+    const entries = [...skill.history].reverse();
+    for (const v of entries) {
+      const archived = archiveExists(skill.name, v.sha);
+      const archiveTag = archived ? chalk.dim("  [archived]") : chalk.red("  [archive missing]");
+      console.log(
+        `    ${chalk.dim(shortSha(v.sha))}  ${fmtDate(v.installedAt)}${archiveTag}`
+      );
+    }
+  }
+  const description = await readSkillDescription(skill);
+  if (description) {
+    console.log();
+    console.log(`  ${chalk.bold("Description")}`);
+    for (const line of description) {
+      console.log(`  ${chalk.dim("\u2502")}  ${line}`);
+    }
+  }
+  console.log();
+}
+function label(text) {
+  return chalk.dim(text.padEnd(9));
+}
+function fmtDate(iso) {
+  return new Date(iso).toLocaleString();
+}
+async function readSkillDescription(skill) {
+  const activeEntry = Object.entries(skill.agents).find(([, a]) => a.active);
+  if (!activeEntry) return null;
+  const skillMdPath = join(activeEntry[1].path, "SKILL.md");
+  if (!existsSync(skillMdPath)) return null;
+  try {
+    const raw = await readFile(skillMdPath, "utf8");
+    const lines = raw.split("\n");
+    const content = [];
+    let skippedH1 = false;
+    for (const line of lines) {
+      if (!skippedH1 && line.startsWith("# ")) {
+        skippedH1 = true;
+        continue;
+      }
+      if (!content.length && !line.trim()) continue;
+      if (content.length > 0 && line.startsWith("#")) break;
+      if (line.trim()) content.push(line);
+      if (content.length >= 5) break;
+    }
+    return content.length ? content : null;
+  } catch {
+    return null;
+  }
+}
+export {
+  infoCommand
+};