skilldex 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,701 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import * as p2 from "@clack/prompts";
+import { Command } from "commander";
+import pc2 from "picocolors";
+
+// src/lib/config.ts
+import { writeFile } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/lib/constants.ts
+var START_TAG = "<!-- skilldex:start (auto-generated, do not edit) -->";
+var END_TAG = "<!-- skilldex:end -->";
+var TARGET_FILE = "AGENTS.md";
+var CONFIG_FILENAME = "skilldex.config.json";
+var SKILL_META_FILE = "SKILL.md";
+var INDEX_HEADER = "[Skills Index]";
+var INDEX_INSTRUCTION = "IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for any tasks covered by indexed skills.";
+var CONTEXT_BUDGET_WARN_KB = 20;
+var CONTEXT_BUDGET_DANGER_KB = 40;
+function compareByNameThenPath(a, b) {
+  return a.name.localeCompare(b.name) || a.path.localeCompare(b.path);
+}
+
+// src/lib/scanner.ts
+import { lstat, readdir, readFile } from "fs/promises";
+import { join, relative } from "path";
+
+// src/lib/agents.ts
+var AGENT_SOURCES = [
+  { name: "universal", displayName: "Universal", skillsDir: ".agents/skills" },
+  { name: "antigravity", displayName: "Antigravity", skillsDir: ".agent/skills" },
+  { name: "claude-code", displayName: "Claude Code", skillsDir: ".claude/skills" },
+  { name: "codex", displayName: "Codex", skillsDir: ".agents/skills" },
+  { name: "cursor", displayName: "Cursor", skillsDir: ".cursor/skills" },
+  { name: "github-copilot", displayName: "GitHub Copilot", skillsDir: ".agents/skills" },
+  { name: "opencode", displayName: "OpenCode", skillsDir: ".agents/skills" },
+  { name: "openclaw", displayName: "OpenClaw", skillsDir: "skills" },
+  { name: "windsurf", displayName: "Windsurf", skillsDir: ".windsurf/skills" }
+];
+function getUniqueSkillsDirs() {
+  return [...new Set(AGENT_SOURCES.map((a) => a.skillsDir))];
+}
+function getAgentDisplayName(relativePath) {
+  for (const agent of AGENT_SOURCES) {
+    if (relativePath.startsWith(`${agent.skillsDir}/`) || relativePath === agent.skillsDir) {
+      return agent.displayName;
+    }
+  }
+  return void 0;
+}
+
+// src/lib/scanner.ts
+function parseFrontmatter(content) {
+  const result = {};
+  if (!content.startsWith("---")) return result;
+  const endIndex = content.indexOf("\n---", 3);
+  if (endIndex === -1) return result;
+  const block = content.slice(4, endIndex);
+  for (const line of block.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    if (key) result[key] = value;
+  }
+  return result;
+}
+async function safeReaddir(dir) {
+  try {
+    return await readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+async function safeReadFile(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+async function collectMdFiles(dir, skillRoot) {
+  const entries = await safeReaddir(dir);
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectMdFiles(fullPath, skillRoot);
+      files.push(...nested);
+    } else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== SKILL_META_FILE) {
+      files.push({
+        relativePath: relative(skillRoot, fullPath),
+        name: entry.name.replace(/\.md$/, "")
+      });
+    }
+  }
+  return files;
+}
+async function isSymlink(path) {
+  try {
+    const stats = await lstat(path);
+    return stats.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function scanDirectory(dir, projectRoot) {
+  const entries = await safeReaddir(dir);
+  const skills = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillPath = join(dir, entry.name);
+    if (await isSymlink(skillPath)) continue;
+    let description = "";
+    const skillMd = await safeReadFile(join(skillPath, SKILL_META_FILE));
+    if (skillMd !== void 0) {
+      const frontmatter = parseFrontmatter(skillMd);
+      description = frontmatter.description ?? "";
+    }
+    const files = await collectMdFiles(skillPath, skillPath);
+    skills.push({
+      name: entry.name,
+      description,
+      path: skillPath,
+      relativePath: relative(projectRoot, skillPath),
+      files
+    });
+  }
+  return skills;
+}
+async function scanForSkills(projectRoot) {
+  const results = await Promise.all(
+    getUniqueSkillsDirs().map((d) => scanDirectory(join(projectRoot, d), projectRoot))
+  );
+  return results.flat().sort(compareByNameThenPath);
+}
+
+// src/lib/config.ts
+function getDefaultConfig() {
+  return {
+    version: 1,
+    targets: [TARGET_FILE],
+    skills: []
+  };
+}
+async function readConfig(projectRoot) {
+  const configPath = join2(projectRoot, CONFIG_FILENAME);
+  const content = await safeReadFile(configPath);
+  if (content === void 0) {
+    return getDefaultConfig();
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed.version !== "number" || !Array.isArray(parsed.targets) || !Array.isArray(parsed.skills)) {
+      return getDefaultConfig();
+    }
+    return parsed;
+  } catch {
+    return getDefaultConfig();
+  }
+}
+async function writeConfig(projectRoot, config) {
+  const configPath = join2(projectRoot, CONFIG_FILENAME);
+  const sorted = {
+    ...config,
+    skills: [...config.skills].sort(compareByNameThenPath)
+  };
+  const content = JSON.stringify(sorted, null, 2);
+  await writeFile(configPath, content, "utf-8");
+}
+
+// src/lib/writer.ts
+import { stat, writeFile as writeFile2 } from "fs/promises";
+import { basename, join as join3 } from "path";
+
+// src/lib/indexer.ts
+import { dirname } from "path";
+function groupFilesBySubdir(files) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const dir = dirname(file.relativePath);
+    const key = dir === "." ? "" : dir;
+    const existing = groups.get(key);
+    if (existing) {
+      existing.push(`${file.name}.md`);
+    } else {
+      groups.set(key, [`${file.name}.md`]);
+    }
+  }
+  return groups;
+}
+function generateIndex(skills) {
+  const segments = [INDEX_HEADER, INDEX_INSTRUCTION];
+  for (const skill of skills) {
+    segments.push(`[${skill.name}]`);
+    segments.push(`root:./${skill.relativePath}`);
+    if (skill.description) {
+      segments.push(`desc:${skill.description}`);
+    }
+    const groups = groupFilesBySubdir(skill.files);
+    for (const [subdir, fileNames] of groups) {
+      const fileList = `{${fileNames.join(",")}}`;
+      if (subdir) {
+        segments.push(`${subdir}:${fileList}`);
+      } else {
+        segments.push(fileList);
+      }
+    }
+  }
+  return segments.join("|");
+}
+
+// src/lib/writer.ts
+async function getTargetInfos(projectRoot, targets) {
+  return Promise.all(
+    targets.map(async (t) => {
+      const p3 = join3(projectRoot, t);
+      const s = await stat(p3);
+      return { file: basename(t), path: p3, totalSize: s.size };
+    })
+  );
+}
+function buildManagedSection(indexContent) {
+  return `${START_TAG}
+${indexContent}
+${END_TAG}`;
+}
+async function writeTargetFile(projectRoot, indexContent, targetFile = TARGET_FILE) {
+  const targetPath = join3(projectRoot, targetFile);
+  const section = buildManagedSection(indexContent);
+  const existing = await safeReadFile(targetPath);
+  let output;
+  if (existing === void 0) {
+    output = `${section}
+`;
+  } else if (existing.includes(START_TAG) && existing.includes(END_TAG)) {
+    const startIdx = existing.indexOf(START_TAG);
+    const endIdx = existing.indexOf(END_TAG) + END_TAG.length;
+    output = existing.slice(0, startIdx) + section + existing.slice(endIdx);
+  } else {
+    output = `${existing.trimEnd()}
+
+${section}
+`;
+  }
+  await writeFile2(targetPath, output, "utf-8");
+  return output;
+}
+async function regenerateFromConfig(projectRoot) {
+  const config = await readConfig(projectRoot);
+  const allSkills = await scanForSkills(projectRoot);
+  const skillMap = new Map(allSkills.map((s) => [s.relativePath, s]));
+  const skills = config.skills.map((entry) => skillMap.get(entry.path)).filter((s) => s !== void 0);
+  const index = generateIndex(skills);
+  const writtenContent = /* @__PURE__ */ new Map();
+  for (const target of config.targets) {
+    const content = await writeTargetFile(projectRoot, index, target);
+    writtenContent.set(join3(projectRoot, target), content);
+  }
+  const managedSize = Buffer.byteLength(buildManagedSection(index));
+  const targets = await getTargetInfos(projectRoot, config.targets);
+  return {
+    skillCount: skills.length,
+    managedSize,
+    targets,
+    writtenContent
+  };
+}
+
+// src/lib/add.ts
+async function addSkill(projectRoot, skillName) {
+  const config = await readConfig(projectRoot);
+  const allSkills = await scanForSkills(projectRoot);
+  const isPath = skillName.includes("/");
+  let targetSkill;
+  if (isPath) {
+    targetSkill = allSkills.find((s) => s.relativePath === skillName);
+    if (!targetSkill) {
+      throw new Error(`Skill "${skillName}" not found. Did you create the skill directory?`);
+    }
+  } else {
+    const matches = allSkills.filter((s) => s.name === skillName);
+    if (matches.length === 0) {
+      throw new Error(`Skill "${skillName}" not found. Did you create the skill directory?`);
+    }
+    if (matches.length > 1) {
+      const paths = matches.map((s) => `  ${s.relativePath}`).join("\n");
+      throw new Error(`Multiple skills named "${skillName}" found. Specify the path:
+${paths}`);
+    }
+    targetSkill = matches[0];
+  }
+  if (config.skills.some((s) => s.path === targetSkill.relativePath)) {
+    throw new Error(`Skill "${targetSkill.relativePath}" is already indexed`);
+  }
+  config.skills.push({
+    name: targetSkill.name,
+    path: targetSkill.relativePath
+  });
+  await writeConfig(projectRoot, config);
+  const result = await regenerateFromConfig(projectRoot);
+  return {
+    skillName: targetSkill.name,
+    managedSize: result.managedSize,
+    targets: result.targets
+  };
+}
+
+// src/lib/init.ts
+async function initWithSkills(projectRoot, skills, targets = [TARGET_FILE]) {
+  const config = {
+    version: 1,
+    targets,
+    skills: skills.map((skill) => ({
+      name: skill.name,
+      path: skill.relativePath
+    }))
+  };
+  await writeConfig(projectRoot, config);
+  return regenerateFromConfig(projectRoot);
+}
+
+// src/lib/list.ts
+async function listSkills(projectRoot) {
+  const config = await readConfig(projectRoot);
+  const allSkills = await scanForSkills(projectRoot);
+  const indexedPaths = new Set(config.skills.map((s) => s.path));
+  const skillMap = new Map(allSkills.map((s) => [s.relativePath, s]));
+  const indexed = config.skills.map((entry) => {
+    const discovered = skillMap.get(entry.path);
+    if (!discovered) return void 0;
+    return {
+      name: entry.name,
+      path: entry.path,
+      description: discovered.description
+    };
+  }).filter((s) => s !== void 0);
+  const available = allSkills.filter((s) => !indexedPaths.has(s.relativePath)).map((s) => ({
+    name: s.name,
+    description: s.description,
+    path: s.relativePath
+  }));
+  return { indexed, available };
+}
+
+// src/lib/remove.ts
+import { rm } from "fs/promises";
+import { join as join4 } from "path";
+async function removeSkill(projectRoot, skillName, deleteFiles = false) {
+  const config = await readConfig(projectRoot);
+  const isPath = skillName.includes("/");
+  let skillIndex;
+  if (isPath) {
+    skillIndex = config.skills.findIndex((s) => s.path === skillName);
+    if (skillIndex === -1) {
+      throw new Error(`Skill "${skillName}" is not indexed`);
+    }
+  } else {
+    const matches = config.skills.map((s, i) => ({ entry: s, index: i })).filter(({ entry: entry2 }) => entry2.name === skillName);
+    if (matches.length === 0) {
+      throw new Error(`Skill "${skillName}" is not indexed`);
+    }
+    if (matches.length > 1) {
+      const paths = matches.map(({ entry: entry2 }) => `  ${entry2.path}`).join("\n");
+      throw new Error(`Multiple skills named "${skillName}" indexed. Specify the path:
+${paths}`);
+    }
+    skillIndex = matches[0].index;
+  }
+  const entry = config.skills[skillIndex];
+  const skillPath = join4(projectRoot, entry.path);
+  config.skills.splice(skillIndex, 1);
+  await writeConfig(projectRoot, config);
+  if (deleteFiles) {
+    await rm(skillPath, { recursive: true, force: true });
+  }
+  const result = await regenerateFromConfig(projectRoot);
+  return {
+    skillName: entry.name,
+    wasDeleted: deleteFiles,
+    managedSize: result.managedSize,
+    targets: result.targets
+  };
+}
+
+// src/lib/sync.ts
+import { join as join5 } from "path";
+async function syncSkills(projectRoot) {
+  const config = await readConfig(projectRoot);
+  const onDisk = await scanForSkills(projectRoot);
+  const diskPaths = new Set(onDisk.map((s) => s.relativePath));
+  const stale = config.skills.filter((s) => !diskPaths.has(s.path));
+  const removed = stale.map((s) => s.name);
+  if (stale.length > 0) {
+    const stalePaths = new Set(stale.map((s) => s.path));
+    config.skills = config.skills.filter((s) => !stalePaths.has(s.path));
+    await writeConfig(projectRoot, config);
+  }
+  const targetPaths = config.targets.map((t) => join5(projectRoot, t));
+  const beforeMap = /* @__PURE__ */ new Map();
+  for (const targetPath of targetPaths) {
+    beforeMap.set(targetPath, await safeReadFile(targetPath));
+  }
+  if (config.skills.length === 0 && [...beforeMap.values()].every((v) => v === void 0)) {
+    return { removed, changed: false, managedSize: 0, targets: [] };
+  }
+  const result = await regenerateFromConfig(projectRoot);
+  let changed = false;
+  for (const targetPath of targetPaths) {
+    const after = result.writtenContent.get(targetPath);
+    if (beforeMap.get(targetPath) !== after) {
+      changed = true;
+      break;
+    }
+  }
+  return {
+    removed,
+    changed,
+    managedSize: result.managedSize,
+    targets: result.targets
+  };
+}
+
+// src/cli/format.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+function pluralize(count, singular, plural) {
+  return count === 1 ? singular : plural;
+}
+function formatKb(bytes) {
+  return `${(bytes / 1024).toFixed(1)} KB`;
+}
+function logContextSize(managedSize, targets) {
+  const sizeKb = managedSize / 1024;
+  const sizeFormatted = formatKb(managedSize);
+  let sizeLabel;
+  if (sizeKb < CONTEXT_BUDGET_WARN_KB) {
+    sizeLabel = pc.green(sizeFormatted);
+  } else if (sizeKb < CONTEXT_BUDGET_DANGER_KB) {
+    sizeLabel = pc.yellow(sizeFormatted);
+  } else {
+    sizeLabel = pc.red(`${sizeFormatted} \u2014 may degrade agent performance`);
+  }
+  const targetLines = targets.map(
+    (t) => `   ${t.file}  ${pc.dim(`${formatKb(t.totalSize)} total`)}`
+  );
+  p.log.info(`Context: ${sizeLabel} (managed section)
+${targetLines.join("\n")}`);
+}
+function formatSkillPath(relativePath) {
+  const agent = getAgentDisplayName(relativePath);
+  if (agent) return `${pc.cyan(agent)}  ${pc.dim(relativePath)}`;
+  return pc.dim(relativePath);
+}
+function handleCommandError(error, spinner2) {
+  if (spinner2) {
+    spinner2.stop("\u2717 Failed");
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  p.outro(pc.red(message));
+  process.exit(1);
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("skilldex").description("Index AI agent skills into passive context (AGENTS.md)").version("0.1.0");
+program.command("init").description("Initialize skilldex in the current project").option("-y, --yes", "Skip prompts and index all discovered skills").option("-t, --target <files...>", "Target file(s) to write index to").action(async (opts) => {
+  p2.intro(pc2.bgCyan(pc2.black(" skilldex init ")));
+  const projectRoot = process.cwd();
+  const skills = await scanForSkills(projectRoot);
+  if (skills.length === 0) {
+    p2.outro(pc2.yellow("No skills found in any agent skills directory."));
+    return;
+  }
+  let targets;
+  if (opts.target) {
+    targets = opts.target;
+  } else if (opts.yes) {
+    targets = [TARGET_FILE];
+  } else {
+    const selected = await p2.multiselect({
+      message: "Select target file(s)",
+      options: [
+        { value: "AGENTS.md", label: "AGENTS.md", hint: "default" },
+        { value: "CLAUDE.md", label: "CLAUDE.md" },
+        { value: "__custom__", label: "Custom..." }
+      ],
+      initialValues: ["AGENTS.md"],
+      required: true
+    });
+    if (p2.isCancel(selected)) {
+      p2.cancel("Init cancelled.");
+      process.exit(0);
+    }
+    targets = selected.filter((v) => v !== "__custom__");
+    if (selected.includes("__custom__")) {
+      const custom = await p2.text({
+        message: "Enter target filename",
+        placeholder: "AGENTS.md",
+        validate: (value) => {
+          if (!value?.trim()) return "Filename is required";
+        }
+      });
+      if (p2.isCancel(custom)) {
+        p2.cancel("Init cancelled.");
+        process.exit(0);
+      }
+      targets.push(custom);
+    }
+  }
+  const nameCount = /* @__PURE__ */ new Map();
+  for (const s of skills) {
+    nameCount.set(s.name, (nameCount.get(s.name) ?? 0) + 1);
+  }
+  let selectedSkillPaths;
+  if (opts.yes) {
+    p2.log.info(
+      `Found ${skills.length} ${pluralize(skills.length, "skill", "skills")}, indexing all (--yes)`
+    );
+    selectedSkillPaths = skills.map((s) => s.relativePath);
+  } else {
+    const selected = await p2.multiselect({
+      message: "Select skills to index",
+      options: skills.map((s) => {
+        const relPath = s.relativePath;
+        const hasCollision = (nameCount.get(s.name) ?? 0) > 1;
+        if (hasCollision) {
+          const agent = getAgentDisplayName(relPath);
+          const label = agent ? `${s.name} - ${agent}` : s.name;
+          return { value: relPath, label, hint: relPath };
+        }
+        return { value: relPath, label: s.name, hint: s.description || void 0 };
+      }),
+      initialValues: skills.map((s) => s.relativePath),
+      required: true
+    });
+    if (p2.isCancel(selected)) {
+      p2.cancel("Init cancelled.");
+      process.exit(0);
+    }
+    selectedSkillPaths = selected;
+  }
+  const selectedSkills = skills.filter((s) => selectedSkillPaths.includes(s.relativePath));
+  const result = await initWithSkills(projectRoot, selectedSkills, targets);
+  logContextSize(result.managedSize, result.targets);
+  p2.outro(
+    pc2.green(
+      `Indexed ${result.skillCount} ${pluralize(result.skillCount, "skill", "skills")} into ${result.targets.map((t) => t.file).join(", ")}`
+    )
+  );
+});
+program.command("add <skill>").description("Add a skill to the project").action(async (skillName) => {
+  p2.intro(pc2.bgCyan(pc2.black(" skilldex add ")));
+  const projectRoot = process.cwd();
+  const s = p2.spinner();
+  try {
+    let resolvedName = skillName;
+    if (!skillName.includes("/")) {
+      const allSkills = await scanForSkills(projectRoot);
+      const matches = allSkills.filter((sk) => sk.name === skillName);
+      if (matches.length > 1) {
+        const config = await readConfig(projectRoot);
+        const indexedPaths = new Set(config.skills.map((sk) => sk.path));
+        const available = matches.filter((sk) => !indexedPaths.has(sk.relativePath));
+        if (available.length === 0) {
+          p2.outro(pc2.yellow(`All skills named "${skillName}" are already indexed.`));
+          return;
+        }
+        const selected = await p2.select({
+          message: `Multiple skills named "${skillName}" found. Which one?`,
+          options: matches.map((sk) => {
+            const indexed = indexedPaths.has(sk.relativePath);
+            const agent = getAgentDisplayName(sk.relativePath);
+            return {
+              value: sk.relativePath,
+              label: agent ?? sk.relativePath,
+              hint: indexed ? "already indexed" : sk.relativePath,
+              disabled: indexed
+            };
+          }).sort((a, b) => {
+            if (a.disabled !== b.disabled) return a.disabled ? -1 : 1;
+            return a.label.localeCompare(b.label);
+          })
+        });
+        if (p2.isCancel(selected)) {
+          p2.cancel("Add cancelled.");
+          process.exit(0);
+        }
+        resolvedName = selected;
+      }
+    }
+    s.start("Adding skill...");
+    const result = await addSkill(projectRoot, resolvedName);
+    s.stop("\u2713 Skill added");
+    logContextSize(result.managedSize, result.targets);
+    p2.outro(
+      pc2.green(`Added "${result.skillName}" to ${result.targets.map((t) => t.file).join(", ")}`)
+    );
+  } catch (error) {
+    handleCommandError(error, s);
+  }
+});
+program.command("remove <skill>").description("Remove a skill from the project").option("--delete-files", "Delete skill files from disk").action(async (skillName, opts) => {
+  p2.intro(pc2.bgCyan(pc2.black(" skilldex remove ")));
+  const projectRoot = process.cwd();
+  const s = p2.spinner();
+  try {
+    let resolvedName = skillName;
+    if (!skillName.includes("/")) {
+      const config = await readConfig(projectRoot);
+      const matches = config.skills.filter((sk) => sk.name === skillName);
+      if (matches.length > 1) {
+        const selected = await p2.select({
+          message: `Multiple skills named "${skillName}" indexed. Which one?`,
+          options: matches.map((sk) => {
+            const agent = getAgentDisplayName(sk.path);
+            return { value: sk.path, label: agent ?? sk.path, hint: sk.path };
+          })
+        });
+        if (p2.isCancel(selected)) {
+          p2.cancel("Remove cancelled.");
+          process.exit(0);
+        }
+        resolvedName = selected;
+      }
+    }
+    let deleteFiles = opts.deleteFiles ?? false;
+    if (!opts.deleteFiles) {
+      const shouldDelete = await p2.confirm({
+        message: `Delete skill files from disk (${resolvedName})?`,
+        initialValue: false
+      });
+      if (p2.isCancel(shouldDelete)) {
+        p2.cancel("Remove cancelled.");
+        process.exit(0);
+      }
+      deleteFiles = shouldDelete;
+    }
+    s.start("Removing skill...");
+    const result = await removeSkill(projectRoot, resolvedName, deleteFiles);
+    s.stop("\u2713 Skill removed");
+    logContextSize(result.managedSize, result.targets);
+    const suffix = result.wasDeleted ? " (files deleted)" : " (files kept on disk)";
+    p2.outro(pc2.green(`Removed "${result.skillName}"${suffix}`));
+  } catch (error) {
+    handleCommandError(error, s);
+  }
+});
+program.command("list").description("List indexed and available skills").action(async () => {
+  p2.intro(pc2.bgCyan(pc2.black(" skilldex list ")));
+  const projectRoot = process.cwd();
+  try {
+    const result = await listSkills(projectRoot);
+    if (result.indexed.length > 0) {
+      p2.log.step(pc2.bold("Indexed skills"));
+      const indexedLines = result.indexed.map(
+        (skill) => `  ${pc2.green(skill.name)}  ${formatSkillPath(skill.path)}`
+      );
+      p2.log.info(indexedLines.join("\n"));
+    } else {
+      p2.log.info(pc2.dim("No indexed skills."));
+    }
+    if (result.available.length > 0) {
+      p2.log.step(pc2.bold("Available skills (not indexed)"));
+      const availableLines = result.available.map(
+        (skill) => `  ${pc2.yellow(skill.name)}  ${formatSkillPath(skill.path)}`
+      );
+      p2.log.info(availableLines.join("\n"));
+    }
+    p2.outro(pc2.green("Done"));
+  } catch (error) {
+    handleCommandError(error);
+  }
+});
+program.command("sync").description("Sync skills and regenerate target file").action(async () => {
+  p2.intro(pc2.bgCyan(pc2.black(" skilldex sync ")));
+  const projectRoot = process.cwd();
+  const s = p2.spinner();
+  try {
+    s.start("Syncing...");
+    const result = await syncSkills(projectRoot);
+    s.stop("\u2713 Sync complete");
+    if (result.removed.length > 0) {
+      for (const name of result.removed) {
+        p2.log.warn(pc2.red(`Removed stale skill "${name}" (missing from disk)`));
+      }
+    }
+    logContextSize(result.managedSize, result.targets);
+    if (result.changed) {
+      p2.outro(pc2.green("Index updated"));
+    } else {
+      p2.outro(pc2.green("Everything up to date"));
+    }
+  } catch (error) {
+    handleCommandError(error, s);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map