skill-tree 0.0.1 → 0.1.1

package/dist/cli/index.mjs

@@ -0,0 +1,3569 @@
+#!/usr/bin/env node
+import {
+  FilesystemStorageAdapter,
+  GitSyncAdapter,
+  SkillBank,
+  SkillGraphServer,
+  SkillTreeMcpServer,
+  VERSION,
+  createDefaultSyncConfig
+} from "../chunk-Q6SFFUDU.mjs";
+
+// src/cli/index.ts
+import { Command as Command24 } from "commander";
+
+// src/config/types.ts
+var DEFAULT_CONFIG = {
+  storage: {
+    type: "sqlite",
+    path: "~/.skill-tree/skills.db"
+  },
+  indexer: {
+    sources: [],
+    batch_size: 10,
+    min_confidence: 0.7
+  },
+  matching: {
+    embedding_model: "text-embedding-3-small",
+    similarity_threshold: 0.8
+  },
+  sync: {
+    auto_check: false,
+    check_interval_hours: 24,
+    conflict_resolution: "prompt"
+  },
+  cli: {
+    output_format: "table",
+    color: true,
+    quiet: false
+  }
+};
+
+// src/config/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var ENV_MAPPINGS = {
+  GITHUB_TOKEN: "indexer.github_token",
+  ANTHROPIC_API_KEY: "indexer.anthropic_key",
+  SKILL_TREE_STORAGE_TYPE: "storage.type",
+  SKILL_TREE_STORAGE_PATH: "storage.path",
+  SKILL_TREE_OUTPUT_FORMAT: "cli.output_format",
+  SKILL_TREE_QUIET: "cli.quiet",
+  SKILL_TREE_NO_COLOR: "cli.color"
+};
+function getConfigDir() {
+  return path.join(os.homedir(), ".skill-tree");
+}
+function getConfigPath() {
+  return path.join(getConfigDir(), "config.yaml");
+}
+function expandPath(filePath) {
+  if (filePath.startsWith("~/")) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  if (filePath.startsWith("~")) {
+    return path.join(os.homedir(), filePath.slice(1));
+  }
+  return filePath;
+}
+function substituteEnvVars(value) {
+  let result = value.replace(/\$\{([^}]+)\}/g, (_, varName) => {
+    return process.env[varName] || "";
+  });
+  result = result.replace(/\$([A-Z_][A-Z0-9_]*)/gi, (_, varName) => {
+    return process.env[varName] || "";
+  });
+  return result;
+}
+function substituteEnvVarsInObject(obj) {
+  if (typeof obj === "string") {
+    return substituteEnvVars(obj);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => substituteEnvVarsInObject(item));
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = substituteEnvVarsInObject(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function setNestedProperty(obj, path6, value) {
+  const parts = path6.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current)) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue !== void 0 && typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else if (sourceValue !== void 0) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function parseSimpleYaml(content) {
+  const result = {};
+  const lines = content.split("\n");
+  const stack = [{ indent: -1, obj: result }];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const indent = line.search(/\S/);
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
+    }
+    const parent = stack[stack.length - 1].obj;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    if (value === "") {
+      const newObj = {};
+      parent[key] = newObj;
+      stack.push({ indent, obj: newObj });
+    } else if (value.startsWith("[") && value.endsWith("]")) {
+      const items = value.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
+      parent[key] = items.map((item) => {
+        if (item.startsWith('"') && item.endsWith('"') || item.startsWith("'") && item.endsWith("'")) {
+          return item.slice(1, -1);
+        }
+        if (item === "true") return true;
+        if (item === "false") return false;
+        const num = Number(item);
+        if (!isNaN(num)) return num;
+        return item;
+      });
+    } else {
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (value === "true") {
+        parent[key] = true;
+      } else if (value === "false") {
+        parent[key] = false;
+      } else {
+        const num = Number(value);
+        if (!isNaN(num) && value !== "") {
+          parent[key] = num;
+        } else {
+          parent[key] = value;
+        }
+      }
+    }
+  }
+  return result;
+}
+function loadConfigFromFile(configPath) {
+  const expandedPath = expandPath(configPath);
+  if (!fs.existsSync(expandedPath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(expandedPath, "utf-8");
+    const parsed = parseSimpleYaml(content);
+    return substituteEnvVarsInObject(parsed);
+  } catch (error) {
+    console.error(`Warning: Failed to parse config file ${configPath}:`, error);
+    return null;
+  }
+}
+function loadConfigFromEnv() {
+  const config2 = {};
+  for (const [envVar, configPath] of Object.entries(ENV_MAPPINGS)) {
+    const value = process.env[envVar];
+    if (value !== void 0) {
+      if (envVar === "SKILL_TREE_NO_COLOR") {
+        setNestedProperty(config2, configPath, value !== "true" && value !== "1");
+      } else if (envVar === "SKILL_TREE_QUIET") {
+        setNestedProperty(config2, configPath, value === "true" || value === "1");
+      } else {
+        setNestedProperty(config2, configPath, value);
+      }
+    }
+  }
+  return config2;
+}
+var ConfigLoader = class {
+  constructor(configPath) {
+    this.loaded = false;
+    this.configPath = configPath || getConfigPath();
+    this.config = { ...DEFAULT_CONFIG };
+  }
+  /**
+   * Load configuration from all sources
+   * Priority (highest to lowest):
+   * 1. Environment variables
+   * 2. Config file
+   * 3. Default values
+   */
+  load() {
+    if (this.loaded) {
+      return this.config;
+    }
+    let config2 = deepMerge({}, DEFAULT_CONFIG);
+    const fileConfig = loadConfigFromFile(this.configPath);
+    if (fileConfig) {
+      config2 = deepMerge(config2, fileConfig);
+    }
+    const envConfig = loadConfigFromEnv();
+    config2 = deepMerge(config2, envConfig);
+    config2.storage.path = expandPath(config2.storage.path);
+    this.config = config2;
+    this.loaded = true;
+    return this.config;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    if (!this.loaded) {
+      return this.load();
+    }
+    return this.config;
+  }
+  /**
+   * Override configuration with partial values
+   */
+  override(overrides) {
+    this.config = deepMerge(this.getConfig(), overrides);
+    return this.config;
+  }
+  /**
+   * Get a specific config value by path
+   */
+  get(path6) {
+    const parts = path6.split(".");
+    let current = this.getConfig();
+    for (const part of parts) {
+      if (current === null || typeof current !== "object") {
+        return void 0;
+      }
+      current = current[part];
+    }
+    return current;
+  }
+  /**
+   * Check if config file exists
+   */
+  configFileExists() {
+    return fs.existsSync(expandPath(this.configPath));
+  }
+  /**
+   * Create default config file
+   */
+  createDefaultConfigFile() {
+    const configDir = path.dirname(expandPath(this.configPath));
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+    const configContent = `# Skill Tree Configuration
+# Generated by skill-tree
+
+storage:
+  type: sqlite
+  path: ~/.skill-tree/skills.db
+
+indexer:
+  # GitHub token for API access (or use GITHUB_TOKEN env var)
+  github_token: \${GITHUB_TOKEN}
+  # Anthropic API key for classification (or use ANTHROPIC_API_KEY env var)
+  anthropic_key: \${ANTHROPIC_API_KEY}
+  sources: []
+  batch_size: 10
+  min_confidence: 0.7
+
+matching:
+  embedding_model: text-embedding-3-small
+  similarity_threshold: 0.8
+
+sync:
+  auto_check: false
+  check_interval_hours: 24
+  conflict_resolution: prompt
+
+cli:
+  output_format: table
+  color: true
+  quiet: false
+`;
+    fs.writeFileSync(expandPath(this.configPath), configContent);
+  }
+};
+var globalConfig = null;
+function getConfigLoader(configPath) {
+  if (!globalConfig) {
+    globalConfig = new ConfigLoader(configPath);
+  }
+  return globalConfig;
+}
+function loadConfig(configPath) {
+  return getConfigLoader(configPath).load();
+}
+
+// src/cli/commands/list.ts
+import { Command } from "commander";
+
+// src/cli/utils/paths.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+var DEFAULT_PATHS = [
+  ".claude/skills",
+  // Project local (Claude)
+  ".agent/skills",
+  // Project local (universal)
+  "~/.claude/skills",
+  // User global (Claude)
+  "~/.agent/skills"
+  // User global (universal)
+];
+function expandHome(p) {
+  if (p.startsWith("~/")) {
+    return path2.join(os2.homedir(), p.slice(2));
+  }
+  return p;
+}
+function dirExists(p) {
+  try {
+    return fs2.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function resolveSkillPath(explicitPath) {
+  if (explicitPath) {
+    const resolved = expandHome(explicitPath);
+    return path2.resolve(resolved);
+  }
+  const envPath = process.env.SKILL_TREE_PATH;
+  if (envPath) {
+    return path2.resolve(expandHome(envPath));
+  }
+  for (const defaultPath of DEFAULT_PATHS) {
+    const resolved = path2.resolve(expandHome(defaultPath));
+    if (dirExists(resolved)) {
+      return resolved;
+    }
+  }
+  return path2.resolve(".claude/skills");
+}
+function ensureDir(dir) {
+  if (!dirExists(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// src/cli/utils/skillbank.ts
+async function createSkillBankFromOptions(options) {
+  const skillPath = resolveSkillPath(options.path);
+  ensureDir(skillPath);
+  const skillBank = new SkillBank({
+    storage: {
+      type: "filesystem",
+      basePath: skillPath,
+      openSkillsCompatible: true
+    }
+  });
+  await skillBank.initialize();
+  return skillBank;
+}
+function getSkillPath(options) {
+  return resolveSkillPath(options.path);
+}
+var getSkillBank = createSkillBankFromOptions;
+
+// src/cli/utils/output.ts
+import chalk from "chalk";
+function formatSkillLine(skill) {
+  const status = formatStatus(skill.status);
+  const version = chalk.dim(`v${skill.version}`);
+  const id = chalk.bold(skill.id);
+  const name = skill.name !== skill.id ? chalk.dim(` (${skill.name})`) : "";
+  const tags = skill.tags.length > 0 ? chalk.dim(` [${skill.tags.join(", ")}]`) : "";
+  return `${status} ${id}${name} ${version}${tags}`;
+}
+function formatStatus(status) {
+  switch (status) {
+    case "active":
+      return chalk.green("\u25CF");
+    case "draft":
+      return chalk.yellow("\u25CB");
+    case "deprecated":
+      return chalk.red("\u2717");
+    case "experimental":
+      return chalk.blue("\u25D0");
+    default:
+      return chalk.gray("?");
+  }
+}
+function formatSkillDetail(skill) {
+  const lines = [];
+  lines.push(chalk.bold(`${skill.name} v${skill.version}`));
+  lines.push(chalk.dim("\u2500".repeat(50)));
+  lines.push(`${chalk.dim("Status:")}    ${formatStatusLabel(skill.status)}`);
+  lines.push(`${chalk.dim("Author:")}    ${skill.author}`);
+  if (skill.tags.length > 0) {
+    lines.push(`${chalk.dim("Tags:")}      ${skill.tags.join(", ")}`);
+  }
+  if (skill.parentVersion) {
+    lines.push(`${chalk.dim("Parent:")}    v${skill.parentVersion}`);
+  }
+  if (skill.derivedFrom && skill.derivedFrom.length > 0) {
+    lines.push(`${chalk.dim("Derived:")}   ${skill.derivedFrom.join(", ")}`);
+  }
+  const { usageCount, successRate } = skill.metrics;
+  if (usageCount > 0) {
+    lines.push(`${chalk.dim("Usage:")}     ${usageCount} times, ${Math.round(successRate * 100)}% success`);
+  }
+  lines.push("");
+  lines.push(chalk.dim("Description"));
+  lines.push(chalk.dim("\u2500".repeat(50)));
+  lines.push(skill.description);
+  lines.push("");
+  lines.push(chalk.dim("Problem"));
+  lines.push(chalk.dim("\u2500".repeat(50)));
+  lines.push(skill.problem);
+  lines.push("");
+  if (skill.triggerConditions.length > 0) {
+    lines.push(chalk.dim("Trigger Conditions"));
+    lines.push(chalk.dim("\u2500".repeat(50)));
+    for (const trigger of skill.triggerConditions) {
+      const desc = trigger.description ? ` - ${trigger.description}` : "";
+      lines.push(`  ${chalk.cyan(trigger.type)}: ${trigger.value}${chalk.dim(desc)}`);
+    }
+    lines.push("");
+  }
+  lines.push(chalk.dim("Solution"));
+  lines.push(chalk.dim("\u2500".repeat(50)));
+  lines.push(skill.solution);
+  lines.push("");
+  if (skill.verification) {
+    lines.push(chalk.dim("Verification"));
+    lines.push(chalk.dim("\u2500".repeat(50)));
+    lines.push(skill.verification);
+    lines.push("");
+  }
+  if (skill.notes) {
+    lines.push(chalk.dim("Notes"));
+    lines.push(chalk.dim("\u2500".repeat(50)));
+    lines.push(skill.notes);
+  }
+  return lines.join("\n");
+}
+function formatStatusLabel(status) {
+  switch (status) {
+    case "active":
+      return chalk.green("active");
+    case "draft":
+      return chalk.yellow("draft");
+    case "deprecated":
+      return chalk.red("deprecated");
+    case "experimental":
+      return chalk.blue("experimental");
+    default:
+      return chalk.gray(status);
+  }
+}
+function formatVersionHistory(versions) {
+  const lines = [];
+  lines.push(chalk.bold("Version History"));
+  lines.push(chalk.dim("\u2500".repeat(50)));
+  for (const v of versions.reverse()) {
+    const date = v.createdAt.toISOString().split("T")[0];
+    const hash = chalk.dim(`#${v.contentHash.slice(0, 7)}`);
+    const changelog = v.changelog ? ` - ${v.changelog}` : "";
+    lines.push(`  ${chalk.cyan(`v${v.version}`)} ${chalk.dim(date)} ${hash}${changelog}`);
+  }
+  return lines.join("\n");
+}
+function formatDiff(versionA, versionB, changes) {
+  const lines = [];
+  lines.push(chalk.bold(`Diff: v${versionA} \u2192 v${versionB}`));
+  lines.push(chalk.dim("\u2500".repeat(50)));
+  if (changes.modified.length === 0 && changes.added.length === 0 && changes.removed.length === 0) {
+    lines.push(chalk.dim("No changes"));
+    return lines.join("\n");
+  }
+  for (const mod of changes.modified) {
+    lines.push(chalk.yellow(`~ ${mod.field}`));
+    lines.push(chalk.red(`  - ${truncate(mod.oldValue, 60)}`));
+    lines.push(chalk.green(`  + ${truncate(mod.newValue, 60)}`));
+  }
+  for (const add of changes.added) {
+    lines.push(chalk.green(`+ ${add.type}: ${add.value}`));
+  }
+  for (const rem of changes.removed) {
+    lines.push(chalk.red(`- ${rem.type}: ${rem.value}`));
+  }
+  return lines.join("\n");
+}
+function formatStats(stats) {
+  const lines = [];
+  lines.push(chalk.bold("Skill Bank Statistics"));
+  lines.push(chalk.dim("\u2500".repeat(50)));
+  lines.push(`${chalk.dim("Total skills:")}  ${stats.totalSkills}`);
+  lines.push("");
+  lines.push(chalk.dim("By Status:"));
+  lines.push(`  ${chalk.green("\u25CF")} Active:       ${stats.byStatus.active}`);
+  lines.push(`  ${chalk.yellow("\u25CB")} Draft:        ${stats.byStatus.draft}`);
+  lines.push(`  ${chalk.blue("\u25D0")} Experimental: ${stats.byStatus.experimental}`);
+  lines.push(`  ${chalk.red("\u2717")} Deprecated:   ${stats.byStatus.deprecated}`);
+  lines.push("");
+  if (Object.keys(stats.byTag).length > 0) {
+    lines.push(chalk.dim("By Tag:"));
+    const sortedTags = Object.entries(stats.byTag).sort((a, b) => b[1] - a[1]);
+    for (const [tag, count] of sortedTags.slice(0, 10)) {
+      lines.push(`  ${tag}: ${count}`);
+    }
+    lines.push("");
+  }
+  if (stats.totalUsage > 0) {
+    lines.push(chalk.dim("Usage:"));
+    lines.push(`  Total uses:      ${stats.totalUsage}`);
+    lines.push(`  Avg success:     ${Math.round(stats.avgSuccessRate * 100)}%`);
+  }
+  return lines.join("\n");
+}
+function printError(message) {
+  console.error(chalk.red(`Error: ${message}`));
+}
+function printSuccess(message) {
+  console.log(chalk.green(`\u2713 ${message}`));
+}
+function printWarning(message) {
+  console.log(chalk.yellow(`\u26A0 ${message}`));
+}
+function printInfo(message) {
+  console.log(chalk.dim(message));
+}
+function truncate(text, maxLength) {
+  const oneLine = text.replace(/\n/g, " ");
+  if (oneLine.length <= maxLength) return oneLine;
+  return oneLine.slice(0, maxLength - 3) + "...";
+}
+
+// src/cli/commands/list.ts
+var listCommand = new Command("list").description("List all skills").option("-s, --status <status>", "Filter by status (active, draft, deprecated, experimental)").option("-t, --tag <tag>", "Filter by tag").option("-a, --author <author>", "Filter by author").action(async (options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const filter = {};
+    if (options.status) {
+      filter.status = [options.status];
+    }
+    if (options.tag) {
+      filter.tags = [options.tag];
+    }
+    if (options.author) {
+      filter.author = options.author;
+    }
+    const skills = await skillBank.listSkills(
+      Object.keys(filter).length > 0 ? filter : void 0
+    );
+    if (globalOpts.json) {
+      console.log(JSON.stringify(skills, null, 2));
+      return;
+    }
+    if (skills.length === 0) {
+      printInfo(`No skills found in ${getSkillPath(globalOpts)}`);
+      return;
+    }
+    if (!globalOpts.quiet) {
+      printInfo(`Skills in ${getSkillPath(globalOpts)}:
+`);
+    }
+    for (const skill of skills) {
+      console.log(formatSkillLine(skill));
+    }
+    if (!globalOpts.quiet) {
+      console.log();
+      printInfo(`${skills.length} skill(s)`);
+    }
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/show.ts
+import { Command as Command2 } from "commander";
+var showCommand = new Command2("show").description("Show skill details").argument("<id>", "Skill ID").option("-v, --version <version>", "Show specific version").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skill = await skillBank.getSkill(id, options.version);
+    if (!skill) {
+      printError(`Skill not found: ${id}${options.version ? `@${options.version}` : ""}`);
+      process.exit(1);
+    }
+    if (globalOpts.json) {
+      console.log(JSON.stringify(skill, null, 2));
+      return;
+    }
+    console.log(formatSkillDetail(skill));
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/search.ts
+import { Command as Command3 } from "commander";
+var searchCommand = new Command3("search").description("Search skills by text").argument("<query>", "Search query").action(async (query, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skills = await skillBank.searchSkills(query);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(skills, null, 2));
+      return;
+    }
+    if (skills.length === 0) {
+      printInfo(`No skills found matching "${query}"`);
+      return;
+    }
+    if (!globalOpts.quiet) {
+      printInfo(`Results for "${query}":
+`);
+    }
+    for (const skill of skills) {
+      console.log(formatSkillLine(skill));
+    }
+    if (!globalOpts.quiet) {
+      console.log();
+      printInfo(`${skills.length} result(s)`);
+    }
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/stats.ts
+import { Command as Command4 } from "commander";
+var statsCommand = new Command4("stats").description("Show skill bank statistics").action(async (options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const stats = await skillBank.getStats();
+    if (globalOpts.json) {
+      console.log(JSON.stringify(stats, null, 2));
+      return;
+    }
+    console.log(formatStats(stats));
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/versions.ts
+import { Command as Command5 } from "commander";
+var versionsCommand = new Command5("versions").description("Show version history for a skill").argument("<id>", "Skill ID").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const versions = await skillBank.getVersionHistory(id);
+    if (versions.length === 0) {
+      printInfo(`No version history found for: ${id}`);
+      return;
+    }
+    if (globalOpts.json) {
+      console.log(JSON.stringify(versions, null, 2));
+      return;
+    }
+    console.log(formatVersionHistory(versions));
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/diff.ts
+import { Command as Command6 } from "commander";
+var diffCommand = new Command6("diff").description("Compare two versions of a skill").argument("<id>", "Skill ID").argument("<version-a>", "First version").argument("<version-b>", "Second version").action(async (id, versionA, versionB, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const diff = await skillBank.compareVersions(id, versionA, versionB);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(diff, null, 2));
+      return;
+    }
+    console.log(formatDiff(diff.versionA, diff.versionB, diff.changes));
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/rollback.ts
+import { Command as Command7 } from "commander";
+var rollbackCommand = new Command7("rollback").description("Rollback a skill to a previous version").argument("<id>", "Skill ID").requiredOption("--to <version>", "Version to rollback to").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skill = await skillBank.rollbackSkill(id, options.to);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(skill, null, 2));
+      return;
+    }
+    printSuccess(`Rolled back ${id} to v${options.to} (new version: v${skill.version})`);
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/fork.ts
+import { Command as Command8 } from "commander";
+var forkCommand = new Command8("fork").description("Fork a skill to create a variant").argument("<id>", "Skill ID to fork from").requiredOption("--new-id <id>", "ID for the new forked skill").requiredOption("--reason <reason>", "Reason for forking").option("--name <name>", "Name for the forked skill").option("--from-version <version>", "Version to fork from (defaults to latest)").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const forked = await skillBank.forkSkill(id, {
+      newId: options.newId,
+      newName: options.name,
+      reason: options.reason,
+      fromVersion: options.fromVersion
+    });
+    if (globalOpts.json) {
+      console.log(JSON.stringify(forked, null, 2));
+      return;
+    }
+    printSuccess(`Forked ${id} \u2192 ${forked.id} (v${forked.version})`);
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/deprecate.ts
+import { Command as Command9 } from "commander";
+var deprecateCommand = new Command9("deprecate").description("Mark a skill as deprecated").argument("<id>", "Skill ID").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skill = await skillBank.deprecateSkill(id);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(skill, null, 2));
+      return;
+    }
+    printSuccess(`Deprecated: ${id} (v${skill.version})`);
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/activate.ts
+import { Command as Command10 } from "commander";
+var activateCommand = new Command10("activate").description("Mark a skill as active").argument("<id>", "Skill ID").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skill = await skillBank.getSkill(id);
+    if (!skill) {
+      printError(`Skill not found: ${id}`);
+      process.exit(1);
+    }
+    skill.status = "active";
+    skill.updatedAt = /* @__PURE__ */ new Date();
+    await skillBank.saveSkill(skill);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(skill, null, 2));
+      return;
+    }
+    printSuccess(`Activated: ${id} (v${skill.version})`);
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/delete.ts
+import { Command as Command11 } from "commander";
+var deleteCommand = new Command11("delete").description("Delete a skill").argument("<id>", "Skill ID").option("-f, --force", "Skip confirmation").option("-v, --version <version>", "Delete specific version only").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skill = await skillBank.getSkill(id, options.version);
+    if (!skill) {
+      printError(`Skill not found: ${id}${options.version ? `@${options.version}` : ""}`);
+      process.exit(1);
+    }
+    if (!options.force) {
+      printWarning(`This will permanently delete ${id}${options.version ? `@${options.version}` : " and all versions"}`);
+      printWarning("Use --force to confirm");
+      process.exit(1);
+    }
+    const deleted = await skillBank.deleteSkill(id, options.version);
+    if (!deleted) {
+      printError(`Failed to delete: ${id}`);
+      process.exit(1);
+    }
+    if (globalOpts.json) {
+      console.log(JSON.stringify({ deleted: true, id, version: options.version }));
+      return;
+    }
+    printSuccess(`Deleted: ${id}${options.version ? `@${options.version}` : ""}`);
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/export.ts
+import { Command as Command12 } from "commander";
+import * as fs3 from "fs";
+var exportCommand = new Command12("export").description("Export all skills to JSON").option("-o, --output <file>", "Output file path (defaults to stdout)").action(async (options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skills = await skillBank.exportAll();
+    const json = JSON.stringify(skills, null, 2);
+    if (options.output) {
+      fs3.writeFileSync(options.output, json, "utf-8");
+      if (!globalOpts.quiet) {
+        printSuccess(`Exported ${skills.length} skill(s) to ${options.output}`);
+      }
+    } else {
+      console.log(json);
+    }
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/import.ts
+import { Command as Command13 } from "commander";
+import * as fs4 from "fs";
+
+// src/import/converter.ts
+var DEFAULT_SECTION_PATTERNS = {
+  problem: [
+    /^#+\s*(?:problem|issue|what\s+problem|the\s+problem)/i,
+    /^#+\s*(?:why|motivation|background)/i
+  ],
+  solution: [
+    /^#+\s*(?:solution|how\s+to|implementation|approach)/i,
+    /^#+\s*(?:usage|instructions|steps)/i
+  ],
+  verification: [
+    /^#+\s*(?:verification|verify|testing|test|validate)/i,
+    /^#+\s*(?:how\s+to\s+verify|checking)/i
+  ],
+  examples: [
+    /^#+\s*(?:examples?|sample|demo)/i,
+    /^#+\s*(?:use\s+cases?|scenarios?)/i
+  ],
+  notes: [
+    /^#+\s*(?:notes?|caveats?|warnings?|tips?)/i,
+    /^#+\s*(?:additional|edge\s+cases?|considerations?)/i
+  ],
+  triggers: [
+    /^#+\s*(?:triggers?|when\s+to\s+use|conditions?)/i,
+    /^#+\s*(?:activation|applies\s+when)/i
+  ]
+};
+function parseMarkdownSections(content) {
+  const lines = content.split("\n");
+  const sections = {
+    remainingContent: ""
+  };
+  let currentSection = "remaining";
+  let currentContent = [];
+  const flushSection = () => {
+    const text = currentContent.join("\n").trim();
+    if (!text) return;
+    switch (currentSection) {
+      case "problem":
+        sections.problem = text;
+        break;
+      case "solution":
+        sections.solution = text;
+        break;
+      case "verification":
+        sections.verification = text;
+        break;
+      case "examples":
+        sections.examples = parseExamples(text);
+        break;
+      case "notes":
+        sections.notes = text;
+        break;
+      case "triggers":
+        sections.triggers = parseTriggerList(text);
+        break;
+      case "remaining":
+        sections.remainingContent += (sections.remainingContent ? "\n\n" : "") + text;
+        break;
+    }
+    currentContent = [];
+  };
+  for (const line of lines) {
+    let matchedSection = null;
+    for (const [section, sectionPatterns] of Object.entries(DEFAULT_SECTION_PATTERNS)) {
+      for (const pattern of sectionPatterns) {
+        if (pattern.test(line)) {
+          matchedSection = section;
+          break;
+        }
+      }
+      if (matchedSection) break;
+    }
+    if (matchedSection) {
+      flushSection();
+      currentSection = matchedSection;
+    } else {
+      currentContent.push(line);
+    }
+  }
+  flushSection();
+  return sections;
+}
+function parseExamples(text) {
+  const examples = [];
+  const exampleBlocks = text.split(/^###\s+/m).filter(Boolean);
+  for (const block of exampleBlocks) {
+    const lines = block.split("\n");
+    const scenario = lines[0]?.trim() || "Example";
+    const content = lines.slice(1).join("\n");
+    const beforeMatch = content.match(/(?:before|input|given)[:\s]*\n?([\s\S]*?)(?=(?:after|output|then|result)|$)/i);
+    const afterMatch = content.match(/(?:after|output|then|result)[:\s]*\n?([\s\S]*?)$/i);
+    if (beforeMatch || afterMatch) {
+      examples.push({
+        scenario,
+        before: beforeMatch?.[1]?.trim() || "",
+        after: afterMatch?.[1]?.trim() || content.trim()
+      });
+    } else {
+      examples.push({
+        scenario,
+        before: "",
+        after: content.trim()
+      });
+    }
+  }
+  if (examples.length === 0 && text.trim()) {
+    examples.push({
+      scenario: "Example usage",
+      before: "",
+      after: text.trim()
+    });
+  }
+  return examples;
+}
+function parseTriggerList(text) {
+  const triggers = [];
+  const listItems = text.match(/^[\s]*[-*•]\s*(.+)$/gm) || text.match(/^[\s]*\d+\.\s*(.+)$/gm);
+  if (listItems) {
+    for (const item of listItems) {
+      const cleaned = item.replace(/^[\s]*[-*•\d.]+\s*/, "").trim();
+      if (cleaned) triggers.push(cleaned);
+    }
+  } else {
+    triggers.push(...text.split("\n").map((t) => t.trim()).filter(Boolean));
+  }
+  return triggers;
+}
+function inferTriggerType(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("error") || lower.includes("exception") || lower.includes("fail")) {
+    return { type: "error", value: text, description: "Triggered by error conditions" };
+  }
+  if (lower.includes("pattern") || lower.includes("regex") || lower.includes("match")) {
+    return { type: "pattern", value: text };
+  }
+  if (lower.includes("when") || lower.includes("context") || lower.includes("if ")) {
+    return { type: "context", value: text };
+  }
+  return { type: "keyword", value: text };
+}
+function extractKeywordsFromDescription(description) {
+  const keywords = [];
+  const techPatterns = [
+    /\b(react|vue|angular|svelte|next\.?js|nuxt)\b/gi,
+    /\b(node\.?js|deno|bun|python|rust|go|java|typescript|javascript)\b/gi,
+    /\b(docker|kubernetes|k8s|aws|gcp|azure)\b/gi,
+    /\b(git|github|gitlab|npm|yarn|pnpm)\b/gi,
+    /\b(sql|postgres|mysql|mongodb|redis)\b/gi,
+    /\b(api|rest|graphql|grpc)\b/gi,
+    /\b(test|testing|jest|vitest|pytest)\b/gi
+  ];
+  for (const pattern of techPatterns) {
+    const matches = description.match(pattern);
+    if (matches) {
+      keywords.push(...matches.map((m) => m.toLowerCase()));
+    }
+  }
+  return [...new Set(keywords)];
+}
+function extractTriggerConditions(skill, sections) {
+  const conditions = [];
+  if (sections?.triggers) {
+    for (const trigger of sections.triggers) {
+      conditions.push(inferTriggerType(trigger));
+    }
+  }
+  const keywords = extractKeywordsFromDescription(skill.description);
+  for (const keyword of keywords) {
+    if (!conditions.some((c) => c.value.toLowerCase() === keyword.toLowerCase())) {
+      conditions.push({
+        type: "keyword",
+        value: keyword,
+        description: "Keyword from description"
+      });
+    }
+  }
+  if (skill.tags) {
+    for (const tag of skill.tags.slice(0, 5)) {
+      if (!conditions.some((c) => c.value.toLowerCase() === tag.toLowerCase())) {
+        conditions.push({
+          type: "keyword",
+          value: tag,
+          description: "Tag from classification"
+        });
+      }
+    }
+  }
+  if (conditions.length === 0) {
+    conditions.push({
+      type: "context",
+      value: skill.description.substring(0, 100),
+      description: "Generated from skill description"
+    });
+  }
+  return conditions;
+}
+function convertIndexerSkill(indexerSkill) {
+  const warnings = [];
+  const sections = parseMarkdownSections(indexerSkill.content);
+  const hasStructuredContent = !!(sections.problem || sections.solution || sections.verification || sections.examples?.length);
+  if (!hasStructuredContent) {
+    warnings.push("No structured content sections found, using raw content");
+  }
+  const triggerConditions = extractTriggerConditions(indexerSkill, sections);
+  let examples = sections.examples || [];
+  if (examples.length === 0) {
+    examples = [{
+      scenario: "Usage example",
+      before: "",
+      after: indexerSkill.content.substring(0, 500)
+    }];
+    warnings.push("No examples found, created placeholder");
+  }
+  const problem = sections.problem || indexerSkill.description;
+  const solution = sections.solution || indexerSkill.content;
+  const verification = sections.verification || "Verify the skill output meets expectations";
+  if (!sections.problem) warnings.push("No problem section found, using description");
+  if (!sections.solution) warnings.push("No solution section found, using full content");
+  if (!sections.verification) warnings.push("No verification section found, using default");
+  const tags = [...indexerSkill.tags || []];
+  if (indexerSkill.sourceRepo) {
+    const repoName = indexerSkill.sourceRepo.split("/").pop();
+    if (repoName && !tags.includes(repoName)) {
+      tags.push(repoName);
+    }
+  }
+  const status = indexerSkill.status === "indexed" ? "active" : indexerSkill.status === "raw" ? "draft" : "draft";
+  let notes = sections.notes || void 0;
+  if (indexerSkill.classificationReasoning) {
+    const classificationNote = `
+
+---
+Classification: ${indexerSkill.primaryPath?.join(" > ") || "uncategorized"}
+Reasoning: ${indexerSkill.classificationReasoning}`;
+    notes = (notes || "") + classificationNote;
+  }
+  const skill = {
+    id: indexerSkill.slug,
+    name: indexerSkill.displayName || indexerSkill.name,
+    version: indexerSkill.version,
+    description: indexerSkill.description,
+    problem,
+    triggerConditions,
+    solution,
+    verification,
+    examples,
+    notes,
+    author: indexerSkill.author,
+    tags,
+    createdAt: new Date(indexerSkill.scrapedAt),
+    updatedAt: new Date(indexerSkill.updatedAt),
+    status,
+    metrics: {
+      usageCount: 0,
+      successRate: 0,
+      feedbackScores: []
+    },
+    source: {
+      type: "imported",
+      location: indexerSkill.sourceUrl,
+      importedAt: /* @__PURE__ */ new Date()
+    },
+    // Extended fields for indexed skills
+    taxonomy: indexerSkill.primaryPath ? {
+      primaryPath: indexerSkill.primaryPath,
+      secondaryPaths: indexerSkill.secondaryPaths,
+      confidence: indexerSkill.confidence
+    } : void 0,
+    externalSource: {
+      url: indexerSkill.sourceUrl,
+      repo: indexerSkill.sourceRepo,
+      scrapedAt: new Date(indexerSkill.scrapedAt)
+    }
+  };
+  return { skill, warnings, hasStructuredContent };
+}
+function convertIndexerSkills(skills) {
+  const results = [];
+  const converted = [];
+  for (const skill of skills) {
+    const result = convertIndexerSkill(skill);
+    results.push(result);
+    converted.push(result.skill);
+  }
+  return {
+    skills: converted,
+    results,
+    stats: {
+      total: results.length,
+      withStructuredContent: results.filter((r) => r.hasStructuredContent).length,
+      withWarnings: results.filter((r) => r.warnings.length > 0).length
+    }
+  };
+}
+function parseIndexerExport(content) {
+  const data = JSON.parse(content);
+  let indexerSkills;
+  let exportMetadata;
+  if (Array.isArray(data)) {
+    indexerSkills = data;
+  } else if (data.skills && Array.isArray(data.skills)) {
+    indexerSkills = data.skills;
+    exportMetadata = {
+      exportedAt: data.exportedAt,
+      originalStats: data.stats
+    };
+  } else {
+    throw new Error("Invalid indexer export format: expected array or object with skills array");
+  }
+  const { skills, stats } = convertIndexerSkills(indexerSkills);
+  return { skills, stats, exportMetadata };
+}
+
+// src/import/detect.ts
+function isSkillTreeSkill(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const skill = obj;
+  return typeof skill.id === "string" && typeof skill.name === "string" && typeof skill.version === "string" && typeof skill.problem === "string" && typeof skill.solution === "string" && Array.isArray(skill.triggerConditions) && typeof skill.metrics === "object";
+}
+function isIndexerSkill(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const skill = obj;
+  return typeof skill.slug === "string" && typeof skill.sourceRepo === "string" && typeof skill.sourcePath === "string" && typeof skill.sourceUrl === "string" && typeof skill.content === "string" && typeof skill.scrapedAt === "string" && (skill.status === "raw" || skill.status === "indexed" || skill.status === "failed");
+}
+function isIndexerExport(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const exp = obj;
+  return typeof exp.exportedAt === "string" && Array.isArray(exp.skills);
+}
+function detectFormat(data) {
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      return { format: "unknown", confidence: 0, details: "Empty array" };
+    }
+    const first = data[0];
+    if (isIndexerSkill(first)) {
+      return { format: "indexer", confidence: 0.95, details: "Array of indexer skills" };
+    }
+    if (isSkillTreeSkill(first)) {
+      return { format: "skill-tree", confidence: 0.95, details: "Array of skill-tree skills" };
+    }
+    return { format: "unknown", confidence: 0.3, details: "Array of unknown objects" };
+  }
+  if (typeof data === "object" && data !== null) {
+    if (isIndexerExport(data)) {
+      return { format: "indexer-export", confidence: 0.98, details: "Indexer export with metadata" };
+    }
+    if (isIndexerSkill(data)) {
+      return { format: "indexer", confidence: 0.9, details: "Single indexer skill" };
+    }
+    if (isSkillTreeSkill(data)) {
+      return { format: "skill-tree", confidence: 0.9, details: "Single skill-tree skill" };
+    }
+  }
+  return { format: "unknown", confidence: 0, details: "Unrecognized format" };
+}
+function detectFormatFromString(content) {
+  try {
+    const data = JSON.parse(content);
+    return detectFormat(data);
+  } catch {
+    return { format: "unknown", confidence: 0, details: "Invalid JSON" };
+  }
+}
+function isLikelyIndexerFormat(content) {
+  const result = detectFormatFromString(content);
+  return result.format === "indexer" || result.format === "indexer-export";
+}
+
+// src/cli/commands/import.ts
+var importCommand = new Command13("import").description("Import skills from JSON file").argument("<file>", "JSON file to import").option("--from-indexer", "Import from skill-indexer export format").option("--auto-detect", "Auto-detect format (default: true)", true).action(async (file, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    if (!fs4.existsSync(file)) {
+      printError(`File not found: ${file}`);
+      process.exit(1);
+    }
+    const content = fs4.readFileSync(file, "utf-8");
+    let skills;
+    const isIndexerFormat = options.fromIndexer || options.autoDetect !== false && isLikelyIndexerFormat(content);
+    if (isIndexerFormat) {
+      if (!globalOpts.quiet) {
+        printInfo("Detected skill-indexer format, converting...");
+      }
+      try {
+        const { skills: converted, stats, exportMetadata } = parseIndexerExport(content);
+        skills = converted;
+        if (!globalOpts.quiet) {
+          printInfo(`Converted ${stats.total} skills (${stats.withStructuredContent} with structured content)`);
+          if (exportMetadata) {
+            printInfo(`Original export from: ${exportMetadata.exportedAt}`);
+          }
+        }
+      } catch (err) {
+        printError(`Failed to parse indexer export: ${err.message}`);
+        process.exit(1);
+      }
+    } else {
+      try {
+        const parsed = JSON.parse(content);
+        skills = Array.isArray(parsed) ? parsed : [parsed];
+      } catch {
+        printError("Invalid JSON file");
+        process.exit(1);
+      }
+      for (const skill of skills) {
+        skill.createdAt = new Date(skill.createdAt);
+        skill.updatedAt = new Date(skill.updatedAt);
+        if (skill.metrics.lastUsed) {
+          skill.metrics.lastUsed = new Date(skill.metrics.lastUsed);
+        }
+        if (skill.source?.importedAt) {
+          skill.source.importedAt = new Date(skill.source.importedAt);
+        }
+        if (skill.externalSource?.scrapedAt) {
+          skill.externalSource.scrapedAt = new Date(skill.externalSource.scrapedAt);
+        }
+      }
+    }
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const result = await skillBank.importSkills(skills);
+    if (globalOpts.json) {
+      console.log(JSON.stringify({
+        ...result,
+        format: isIndexerFormat ? "indexer" : "skill-tree"
+      }, null, 2));
+      return;
+    }
+    printSuccess(`Imported ${result.imported} skill(s)`);
+    if (result.failed > 0) {
+      printWarning(`Failed to import ${result.failed} skill(s)`);
+    }
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/indexer/index.ts
+import { Command as Command20 } from "commander";
+
+// src/cli/commands/indexer/scrape.ts
+import { Command as Command14 } from "commander";
+import { spawn } from "child_process";
+
+// src/services/indexer.ts
+import * as path3 from "path";
+import * as fs5 from "fs";
+function hasIndexerSupport(storage) {
+  const s = storage;
+  return typeof s.addRelationship === "function" && typeof s.getTaxonomyTree === "function";
+}
+var IndexerService = class {
+  constructor(config2 = {}, skillBank) {
+    this.initialized = false;
+    this.globalConfig = loadConfig();
+    this.serviceConfig = {
+      githubToken: config2.githubToken || this.globalConfig.indexer.github_token,
+      anthropicApiKey: config2.anthropicApiKey || this.globalConfig.indexer.anthropic_key,
+      batchSize: config2.batchSize || this.globalConfig.indexer.batch_size,
+      minConfidence: config2.minConfidence || this.globalConfig.indexer.min_confidence,
+      concurrency: config2.concurrency || 3,
+      cacheTtlSeconds: config2.cacheTtlSeconds || 3600,
+      databasePath: config2.databasePath,
+      cacheDir: config2.cacheDir,
+      claudeModel: config2.claudeModel
+    };
+    this.skillBank = skillBank;
+  }
+  /**
+   * Get effective configuration
+   */
+  getConfig() {
+    return { ...this.serviceConfig };
+  }
+  /**
+   * Initialize the service (lazy load scraper modules)
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      const possiblePaths = [
+        // Relative to this file in dist
+        path3.resolve(__dirname, "../../scraper/dist"),
+        // Relative to project root
+        path3.resolve(process.cwd(), "scraper/dist"),
+        // Absolute paths from config
+        this.serviceConfig.cacheDir ? path3.resolve(this.serviceConfig.cacheDir, "../scraper/dist") : null
+      ].filter(Boolean);
+      let scraperBasePath = null;
+      for (const basePath of possiblePaths) {
+        const scraperIndex = path3.join(basePath, "scraper/index.js");
+        if (fs5.existsSync(scraperIndex)) {
+          scraperBasePath = basePath;
+          break;
+        }
+      }
+      if (!scraperBasePath) {
+        throw new Error("Scraper modules not found. Run `cd scraper && npm run build` first.");
+      }
+      const scraperPath = path3.join(scraperBasePath, "scraper/index.js");
+      const indexerPath = path3.join(scraperBasePath, "indexer/index.js");
+      const databasePath = path3.join(scraperBasePath, "database/index.js");
+      this.scraperModule = await import(
+        /* webpackIgnore: true */
+        scraperPath
+      );
+      this.indexerModule = await import(
+        /* webpackIgnore: true */
+        indexerPath
+      );
+      this.databaseModule = await import(
+        /* webpackIgnore: true */
+        databasePath
+      );
+      if (this.databaseModule.createDatabase) {
+        const dbPath = this.serviceConfig.databasePath || path3.join(process.cwd(), "scraper/data/skills.db");
+        this.db = this.databaseModule.createDatabase(dbPath);
+      }
+      this.initialized = true;
+    } catch (err) {
+      console.warn(`Scraper modules not available: ${err.message}`);
+      console.warn("Some indexer features will be limited.");
+      this.initialized = true;
+    }
+  }
+  /**
+   * Check if the indexer is available
+   */
+  isAvailable() {
+    return this.initialized && !!this.scraperModule;
+  }
+  /**
+   * Check if running in degraded mode (no scraper modules)
+   */
+  isDegradedMode() {
+    return this.initialized && !this.scraperModule;
+  }
+  /**
+   * Scrape skills from GitHub sources
+   */
+  async scrape(sources, options) {
+    await this.initialize();
+    if (!this.scraperModule || !this.db) {
+      throw new Error(
+        "Scraper not available. Build the scraper module first: cd scraper && npm run build"
+      );
+    }
+    const result = {
+      discovered: 0,
+      scraped: 0,
+      skipped: 0,
+      failed: 0,
+      unchanged: 0,
+      errors: []
+    };
+    try {
+      const scraper = this.scraperModule.createScraper({
+        githubToken: this.serviceConfig.githubToken,
+        cacheDir: this.serviceConfig.cacheDir,
+        cacheTtlSeconds: this.serviceConfig.cacheTtlSeconds
+      });
+      for (const source of sources) {
+        try {
+          let skills;
+          if (source.type === "awesome-list") {
+            skills = await scraper.scrapeAwesomeList(source.url, {
+              force: options?.force
+            });
+          } else {
+            skills = await scraper.scrapeRepository(source.url, {
+              force: options?.force
+            });
+          }
+          result.discovered += skills.length;
+          for (const skill of skills) {
+            try {
+              const existing = this.db.getSkillBySlug?.(skill.slug);
+              if (existing && !options?.force) {
+                result.unchanged++;
+              } else {
+                this.db.saveSkill?.(skill);
+                result.scraped++;
+              }
+            } catch (err) {
+              result.failed++;
+              result.errors.push(`Failed to save skill ${skill.slug}: ${err.message}`);
+            }
+          }
+        } catch (err) {
+          result.failed++;
+          result.errors.push(`Failed to scrape ${source.url}: ${err.message}`);
+        }
+      }
+    } catch (err) {
+      result.errors.push(`Scrape failed: ${err.message}`);
+    }
+    return result;
+  }
+  /**
+   * Classify unindexed skills using AI
+   */
+  async classify(options) {
+    await this.initialize();
+    if (!this.indexerModule || !this.db) {
+      throw new Error(
+        "Indexer not available. Build the scraper module first: cd scraper && npm run build"
+      );
+    }
+    const result = {
+      indexed: 0,
+      skipped: 0,
+      failed: 0,
+      errors: []
+    };
+    try {
+      const indexer = this.indexerModule.createIndexer({
+        anthropicApiKey: this.serviceConfig.anthropicApiKey,
+        model: this.serviceConfig.claudeModel || "claude-sonnet-4-20250514",
+        minConfidence: this.serviceConfig.minConfidence
+      });
+      let skills;
+      if (options?.skillId) {
+        const skill = this.db.getSkillBySlug?.(options.skillId);
+        skills = skill ? [skill] : [];
+      } else if (options?.all) {
+        skills = this.db.getAllSkills?.() || [];
+      } else {
+        skills = this.db.getSkillsByStatus?.("raw") || [];
+      }
+      const batchSize = this.serviceConfig.batchSize || 10;
+      for (let i = 0; i < skills.length; i += batchSize) {
+        const batch = skills.slice(i, i + batchSize);
+        for (const skill of batch) {
+          if (skill.status === "indexed" && !options?.all) {
+            result.skipped++;
+            continue;
+          }
+          try {
+            const classification = await indexer.classifySkill(skill);
+            skill.status = "indexed";
+            skill.primaryPath = classification.primaryPath;
+            skill.secondaryPaths = classification.secondaryPaths;
+            skill.confidence = classification.confidence;
+            skill.classificationReasoning = classification.reasoning;
+            skill.indexedAt = (/* @__PURE__ */ new Date()).toISOString();
+            this.db.saveSkill?.(skill);
+            result.indexed++;
+          } catch (err) {
+            result.failed++;
+            result.errors.push(`Failed to classify ${skill.slug}: ${err.message}`);
+          }
+        }
+      }
+    } catch (err) {
+      result.errors.push(`Classification failed: ${err.message}`);
+    }
+    return result;
+  }
+  /**
+   * Detect relationships between skills
+   */
+  async detectRelationships(options) {
+    await this.initialize();
+    const result = {
+      detected: 0,
+      skipped: 0,
+      errors: []
+    };
+    if (this.skillBank) {
+      try {
+        const storage = this.skillBank.getStorage();
+        if (hasIndexerSupport(storage)) {
+          const skills = await this.skillBank.listSkills();
+          const targetSkills = options?.skillId ? skills.filter((s) => s.id === options.skillId) : skills;
+          for (const skill of targetSkills) {
+            const relationships = this.detectSkillRelationships(skill, skills);
+            for (const rel of relationships) {
+              try {
+                await storage.addRelationship(
+                  skill.id,
+                  rel.targetSkillId,
+                  rel.type,
+                  rel.confidence,
+                  rel.reasoning
+                );
+                result.detected++;
+              } catch (err) {
+                result.skipped++;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        result.errors.push(`Relationship detection failed: ${err.message}`);
+      }
+      return result;
+    }
+    if (!this.db) {
+      throw new Error(
+        "Neither SkillBank nor scraper database available."
+      );
+    }
+    try {
+      const skills = this.db.getAllSkills?.() || [];
+      const targetSkills = options?.skillId ? skills.filter((s) => s.slug === options.skillId) : skills.filter((s) => s.status === "indexed");
+      for (const skill of targetSkills) {
+        const relationships = this.detectSkillRelationships(skill, skills);
+        for (const rel of relationships) {
+          try {
+            this.db.saveRelationship?.({
+              sourceSkillId: skill.id,
+              ...rel
+            });
+            result.detected++;
+          } catch (err) {
+            result.skipped++;
+          }
+        }
+      }
+    } catch (err) {
+      result.errors.push(`Relationship detection failed: ${err.message}`);
+    }
+    return result;
+  }
+  /**
+   * Detect relationships for a single skill
+   */
+  detectSkillRelationships(skill, allSkills) {
+    const relationships = [];
+    const skillId = skill.id || skill.slug;
+    const skillContent = `${skill.name} ${skill.description} ${skill.problem || ""} ${skill.solution || ""} ${skill.content || ""}`.toLowerCase();
+    for (const other of allSkills) {
+      const otherId = other.id || other.slug;
+      if (otherId === skillId) continue;
+      const otherName = (other.name || "").toLowerCase();
+      const dependencyPatterns = ["requires", "depends on", "uses", "needs", "builds on"];
+      for (const pattern of dependencyPatterns) {
+        if (skillContent.includes(`${pattern} ${otherName}`)) {
+          relationships.push({
+            targetSkillId: otherId,
+            type: "depends_on",
+            confidence: 0.7,
+            reasoning: `Content mentions "${pattern} ${other.name}"`
+          });
+          break;
+        }
+      }
+      const extensionPatterns = ["extends", "improves", "enhances", "builds upon"];
+      for (const pattern of extensionPatterns) {
+        if (skillContent.includes(`${pattern} ${otherName}`)) {
+          relationships.push({
+            targetSkillId: otherId,
+            type: "extends",
+            confidence: 0.7,
+            reasoning: `Content mentions "${pattern} ${other.name}"`
+          });
+          break;
+        }
+      }
+      const alternativePatterns = ["alternative to", "instead of", "replacement for"];
+      for (const pattern of alternativePatterns) {
+        if (skillContent.includes(`${pattern} ${otherName}`)) {
+          relationships.push({
+            targetSkillId: otherId,
+            type: "alternative",
+            confidence: 0.6,
+            reasoning: `Content mentions "${pattern} ${other.name}"`
+          });
+          break;
+        }
+      }
+      const skillPath = skill.taxonomy?.primaryPath || skill.primaryPath || [];
+      const otherPath = other.taxonomy?.primaryPath || other.primaryPath || [];
+      if (skillPath.length >= 2 && otherPath.length >= 2) {
+        if (skillPath[0] === otherPath[0] && skillPath[1] === otherPath[1]) {
+          relationships.push({
+            targetSkillId: otherId,
+            type: "related",
+            confidence: 0.5,
+            reasoning: `Same taxonomy category: ${skillPath.slice(0, 2).join(" > ")}`
+          });
+        }
+      }
+    }
+    return relationships;
+  }
+  /**
+   * Get taxonomy tree
+   */
+  async getTaxonomyTree(rootPath) {
+    await this.initialize();
+    if (this.skillBank) {
+      const storage = this.skillBank.getStorage();
+      if (hasIndexerSupport(storage)) {
+        const nodes = await storage.getTaxonomyTree(rootPath);
+        return this.wrapTreeNodes(nodes, rootPath);
+      }
+    }
+    const skills = this.skillBank ? await this.skillBank.listSkills() : this.db?.getAllSkills?.() || [];
+    return this.buildTaxonomyTreeFromSkills(skills, rootPath);
+  }
+  /**
+   * Wrap tree nodes returned from SQLite storage into a root node
+   */
+  wrapTreeNodes(nodes, rootPath) {
+    const root = {
+      id: "root",
+      name: rootPath?.join(" > ") || "All Skills",
+      path: rootPath || [],
+      skillCount: 0,
+      children: []
+    };
+    for (const node of nodes) {
+      root.children.push(this.convertToTaxonomyNode(node));
+      root.skillCount += this.countNodeSkills(node);
+    }
+    return root;
+  }
+  /**
+   * Convert storage tree node to TaxonomyNode format
+   */
+  convertToTaxonomyNode(node) {
+    return {
+      id: node.id,
+      name: node.name,
+      path: Array.isArray(node.path) ? node.path : (node.path || "").split("/"),
+      skillCount: node.skillCount || 0,
+      children: (node.children || []).map((child) => this.convertToTaxonomyNode(child))
+    };
+  }
+  /**
+   * Count total skills in a node tree
+   */
+  countNodeSkills(node) {
+    let count = node.skillCount || 0;
+    for (const child of node.children || []) {
+      count += this.countNodeSkills(child);
+    }
+    return count;
+  }
+  /**
+   * Build taxonomy tree from flat nodes
+   */
+  buildTaxonomyTree(nodes, rootPath) {
+    const root = {
+      id: "root",
+      name: rootPath?.join(" > ") || "All Skills",
+      path: rootPath || [],
+      skillCount: 0,
+      children: []
+    };
+    const nodeMap = /* @__PURE__ */ new Map();
+    nodeMap.set("root", root);
+    for (const node of nodes) {
+      const taxNode = {
+        id: node.id,
+        name: node.name,
+        path: node.path,
+        skillCount: node.skillCount || 0,
+        children: []
+      };
+      nodeMap.set(node.id, taxNode);
+    }
+    for (const node of nodes) {
+      const taxNode = nodeMap.get(node.id);
+      const parentId = node.parentId || "root";
+      const parent = nodeMap.get(parentId);
+      if (parent) {
+        parent.children.push(taxNode);
+        parent.skillCount += taxNode.skillCount;
+      }
+    }
+    return root;
+  }
+  /**
+   * Build taxonomy tree from skills
+   */
+  buildTaxonomyTreeFromSkills(skills, rootPath) {
+    const root = {
+      id: "root",
+      name: rootPath?.join(" > ") || "All Skills",
+      path: rootPath || [],
+      skillCount: 0,
+      children: []
+    };
+    const nodeMap = /* @__PURE__ */ new Map();
+    for (const skill of skills) {
+      const taxonomy = skill.taxonomy || (skill.primaryPath ? { primaryPath: skill.primaryPath } : null);
+      if (!taxonomy?.primaryPath) continue;
+      const skillPath = taxonomy.primaryPath;
+      if (rootPath && rootPath.length > 0) {
+        let matches = true;
+        for (let i = 0; i < rootPath.length; i++) {
+          if (skillPath[i] !== rootPath[i]) {
+            matches = false;
+            break;
+          }
+        }
+        if (!matches) continue;
+      }
+      let currentPath = [];
+      let parent = root;
+      for (const segment of skillPath) {
+        currentPath = [...currentPath, segment];
+        const pathKey = currentPath.join("/");
+        let node = nodeMap.get(pathKey);
+        if (!node) {
+          node = {
+            id: pathKey,
+            name: segment,
+            path: [...currentPath],
+            skillCount: 0,
+            children: []
+          };
+          nodeMap.set(pathKey, node);
+          parent.children.push(node);
+        }
+        parent = node;
+      }
+      parent.skillCount++;
+      root.skillCount++;
+    }
+    return root;
+  }
+  /**
+   * Get indexer statistics
+   */
+  async getStats() {
+    await this.initialize();
+    if (this.skillBank) {
+      const skills = await this.skillBank.listSkills();
+      const storage = this.skillBank.getStorage();
+      let taxonomyNodes = 0;
+      let relationships = 0;
+      let sources = 0;
+      if (storage) {
+        if (hasIndexerSupport(storage)) {
+          const tree = await storage.getTaxonomyTree();
+          taxonomyNodes = this.countTaxonomyNodes(tree);
+          if (storage.getRelationships) {
+            for (const skill of skills) {
+              const rels = await storage.getRelationships(skill.id);
+              relationships += rels.length;
+            }
+          }
+        }
+        const sourceSet = /* @__PURE__ */ new Set();
+        for (const skill of skills) {
+          if (skill.externalSource?.repo) {
+            sourceSet.add(skill.externalSource.repo);
+          }
+          if (skill.source?.type === "imported" && skill.externalSource?.url) {
+            sourceSet.add(skill.externalSource.url);
+          }
+        }
+        sources = sourceSet.size;
+      }
+      const indexed = skills.filter(
+        (s) => s.status === "active" && (s.taxonomy || s.source?.type === "imported")
+      ).length;
+      return {
+        totalSkills: skills.length,
+        indexedSkills: indexed,
+        rawSkills: skills.filter((s) => s.status === "draft").length,
+        failedSkills: skills.filter((s) => s.status === "deprecated").length,
+        taxonomyNodes,
+        relationships,
+        sources
+      };
+    }
+    if (this.db) {
+      const stats = this.db.getStats?.() || {};
+      return {
+        totalSkills: stats.totalSkills || 0,
+        indexedSkills: stats.indexedSkills || 0,
+        rawSkills: stats.rawSkills || 0,
+        failedSkills: stats.failedSkills || 0,
+        taxonomyNodes: stats.taxonomyNodes || 0,
+        relationships: stats.relationships || 0,
+        sources: stats.sources || 0
+      };
+    }
+    return {
+      totalSkills: 0,
+      indexedSkills: 0,
+      rawSkills: 0,
+      failedSkills: 0,
+      taxonomyNodes: 0,
+      relationships: 0,
+      sources: 0
+    };
+  }
+  /**
+   * Count nodes in taxonomy tree
+   */
+  countTaxonomyNodes(nodes) {
+    let count = 0;
+    for (const node of nodes) {
+      count++;
+      if (node.children) {
+        count += this.countTaxonomyNodes(node.children);
+      }
+    }
+    return count;
+  }
+  /**
+   * Scrape and index skills directly into SkillBank
+   * This is the streamlined workflow for integrated mode
+   */
+  async scrapeAndIndex(sources, options) {
+    if (!this.skillBank) {
+      throw new Error("SkillBank required for scrapeAndIndex. Use integrated mode.");
+    }
+    await this.initialize();
+    const skillsAdded = [];
+    const scraped = await this.scrape(sources, { force: options?.force });
+    let indexed = { indexed: 0, skipped: 0, failed: 0, errors: [] };
+    if (options?.autoClassify !== false) {
+      indexed = await this.classify({ all: options?.force });
+    }
+    if (this.db) {
+      const skills = this.db.getAllSkills?.() || [];
+      for (const skill of skills) {
+        if (skill.status !== "indexed" && !options?.force) continue;
+        try {
+          const converted = convertIndexerSkill(skill);
+          await this.skillBank.addSkill(converted.skill);
+          skillsAdded.push(converted.skill.id);
+        } catch (err) {
+          indexed.errors.push(`Failed to import ${skill.slug}: ${err.message}`);
+        }
+      }
+    }
+    let relationships = { detected: 0, skipped: 0, errors: [] };
+    if (options?.detectRelationships !== false) {
+      relationships = await this.detectRelationships();
+    }
+    return {
+      scraped,
+      indexed,
+      relationships,
+      skillsAdded
+    };
+  }
+  /**
+   * Import skills from indexer database into SkillBank
+   */
+  async importFromIndexerDb(options) {
+    if (!this.skillBank) {
+      throw new Error("SkillBank not configured. Use integrated mode.");
+    }
+    await this.initialize();
+    if (!this.db) {
+      throw new Error(
+        "Scraper database not available. Build the scraper module first."
+      );
+    }
+    const result = { imported: 0, failed: 0, skills: [] };
+    try {
+      let skills;
+      if (options?.status) {
+        skills = this.db.getSkillsByStatus?.(options.status) || [];
+      } else {
+        skills = this.db.getAllSkills?.() || [];
+      }
+      if (options?.limit) {
+        skills = skills.slice(0, options.limit);
+      }
+      for (const skill of skills) {
+        try {
+          const converted = convertIndexerSkill(skill);
+          await this.skillBank.addSkill(converted.skill);
+          result.imported++;
+          result.skills.push(converted.skill);
+        } catch (err) {
+          result.failed++;
+        }
+      }
+    } catch (err) {
+      throw new Error(`Import failed: ${err.message}`);
+    }
+    return result;
+  }
+  /**
+   * Get default skill sources from config
+   */
+  getDefaultSources() {
+    const configSources = this.globalConfig.indexer.sources;
+    if (configSources.length > 0) {
+      return configSources.map((url) => ({
+        type: "awesome-list",
+        url
+      }));
+    }
+    return [
+      { type: "awesome-list", url: "https://github.com/VoltAgent/awesome-agent-skills" }
+    ];
+  }
+  /**
+   * Close database connections
+   */
+  async close() {
+    if (this.db && typeof this.db.close === "function") {
+      this.db.close();
+    }
+    this.db = void 0;
+    this.initialized = false;
+  }
+};
+function createIntegratedIndexer(skillBank, config2 = {}) {
+  return new IndexerService(config2, skillBank);
+}
+
+// src/cli/commands/indexer/scrape.ts
+var scrapeCommand = new Command14("scrape").description("Scrape skills from GitHub sources").argument("[url]", "Repository or awesome-list URL").option("-d, --discover", "Discover from default sources").option("-f, --force", "Force scrape even if no changes detected").option("--standalone", "Use standalone skillindexer CLI (fallback)").option("--import", "Auto-import scraped skills into skill-tree", true).action(async (url, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  if (options.standalone) {
+    await runStandaloneMode(url, options, globalOpts);
+    return;
+  }
+  try {
+    const skillBank = await getSkillBank(globalOpts);
+    const indexer = createIntegratedIndexer(skillBank, {
+      githubToken: process.env.GITHUB_TOKEN,
+      anthropicApiKey: process.env.ANTHROPIC_API_KEY
+    });
+    let sources;
+    if (url) {
+      sources = [{
+        type: url.includes("awesome") ? "awesome-list" : "repository",
+        url
+      }];
+    } else if (options.discover) {
+      sources = indexer.getDefaultSources();
+    } else {
+      printError("Please provide a URL or use --discover to scrape from default sources");
+      process.exit(1);
+    }
+    if (!globalOpts.quiet) {
+      printInfo(`Scraping ${sources.length} source(s)...`);
+      for (const source of sources) {
+        printInfo(`  - ${source.url} (${source.type})`);
+      }
+      printInfo("");
+    }
+    const result = await indexer.scrape(sources, { force: options.force });
+    if (globalOpts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else if (!globalOpts.quiet) {
+      printSuccess("Scrape completed");
+      console.log(`  Discovered: ${result.discovered}`);
+      console.log(`  Scraped: ${result.scraped}`);
+      console.log(`  Unchanged: ${result.unchanged}`);
+      console.log(`  Skipped: ${result.skipped}`);
+      console.log(`  Failed: ${result.failed}`);
+      if (result.errors.length > 0) {
+        printWarning("\nErrors:");
+        for (const error of result.errors) {
+          console.log(`  - ${error}`);
+        }
+      }
+    }
+    if (options.import && result.scraped > 0) {
+      if (!globalOpts.quiet) {
+        printInfo("\nImporting scraped skills into skill-tree...");
+      }
+      try {
+        const importResult = await indexer.importFromIndexerDb({ status: "indexed" });
+        if (!globalOpts.quiet) {
+          printSuccess(`Imported ${importResult.imported} skills`);
+          if (importResult.failed > 0) {
+            printWarning(`Failed to import ${importResult.failed} skills`);
+          }
+        }
+      } catch (err) {
+        printWarning(`Auto-import failed: ${err.message}`);
+        printInfo("You can manually import with: skill-tree import");
+      }
+    }
+    await indexer.close();
+  } catch (err) {
+    const errorMessage = err.message;
+    if (errorMessage.includes("Scraper not available") || errorMessage.includes("not found")) {
+      printWarning("IndexerService not available, falling back to standalone CLI...");
+      await runStandaloneMode(url, options, globalOpts);
+      return;
+    }
+    printError(errorMessage);
+    process.exit(1);
+  }
+});
+async function runStandaloneMode(url, options, globalOpts) {
+  if (!globalOpts.quiet) {
+    printInfo("Using standalone skillindexer CLI...");
+    printInfo("");
+  }
+  const args = ["scrape"];
+  if (url) args.push(url);
+  if (options.discover) args.push("--discover");
+  if (options.force) args.push("--force");
+  try {
+    await runSkillIndexer(args, globalOpts.quiet ?? false);
+  } catch (err) {
+    printError(err.message);
+    printWarning("");
+    printWarning("If skillindexer is not installed, you can:");
+    printWarning("  1. cd scraper && npm install && npm run build");
+    printWarning("  2. npm link (in scraper directory)");
+    printWarning("");
+    printWarning("Or use the export/import workflow:");
+    printWarning("  skillindexer scrape --discover");
+    printWarning("  skillindexer export-skilltree -o skills.json");
+    printWarning("  skill-tree import skills.json");
+    process.exit(1);
+  }
+}
+async function runSkillIndexer(args, quiet) {
+  return new Promise((resolve3, reject) => {
+    const proc = spawn("skillindexer", args, {
+      stdio: quiet ? "pipe" : "inherit",
+      shell: true
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to run skillindexer: ${err.message}`));
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(new Error(`skillindexer exited with code ${code}`));
+      }
+    });
+  });
+}
+
+// src/cli/commands/indexer/classify.ts
+import { Command as Command15 } from "commander";
+import { spawn as spawn2 } from "child_process";
+var classifyCommand = new Command15("classify").description("Classify unindexed skills using AI").option("-s, --skill <id>", "Classify specific skill by ID").option("--all", "Re-classify all skills (including already indexed)").option("--standalone", "Use standalone skillindexer CLI (fallback)").action(async (options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  if (!process.env.ANTHROPIC_API_KEY) {
+    printError("ANTHROPIC_API_KEY environment variable is required");
+    process.exit(1);
+  }
+  if (options.standalone) {
+    await runStandaloneMode2(options, globalOpts);
+    return;
+  }
+  try {
+    const skillBank = await getSkillBank(globalOpts);
+    const indexer = createIntegratedIndexer(skillBank, {
+      anthropicApiKey: process.env.ANTHROPIC_API_KEY
+    });
+    if (!globalOpts.quiet) {
+      if (options.skill) {
+        printInfo(`Classifying skill: ${options.skill}`);
+      } else if (options.all) {
+        printInfo("Re-classifying all skills...");
+      } else {
+        printInfo("Classifying unindexed skills...");
+      }
+      printInfo("");
+    }
+    const result = await indexer.classify({
+      skillId: options.skill,
+      all: options.all
+    });
+    if (globalOpts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else if (!globalOpts.quiet) {
+      printSuccess("Classification completed");
+      console.log(`  Indexed: ${result.indexed}`);
+      console.log(`  Skipped: ${result.skipped}`);
+      console.log(`  Failed: ${result.failed}`);
+      if (result.errors.length > 0) {
+        printWarning("\nErrors:");
+        for (const error of result.errors) {
+          console.log(`  - ${error}`);
+        }
+      }
+    }
+    await indexer.close();
+  } catch (err) {
+    const errorMessage = err.message;
+    if (errorMessage.includes("not available") || errorMessage.includes("not found")) {
+      printWarning("IndexerService not available, falling back to standalone CLI...");
+      await runStandaloneMode2(options, globalOpts);
+      return;
+    }
+    printError(errorMessage);
+    process.exit(1);
+  }
+});
+async function runStandaloneMode2(options, globalOpts) {
+  if (!globalOpts.quiet) {
+    printInfo("Using standalone skillindexer CLI...");
+    printInfo("");
+  }
+  const args = ["index"];
+  if (options.skill) args.push("--skill", options.skill);
+  if (options.all) args.push("--all");
+  try {
+    await runSkillIndexer2(args, globalOpts.quiet ?? false);
+  } catch (err) {
+    printError(err.message);
+    printWarning("");
+    printWarning("Make sure skillindexer is installed and ANTHROPIC_API_KEY is set.");
+    process.exit(1);
+  }
+}
+async function runSkillIndexer2(args, quiet) {
+  return new Promise((resolve3, reject) => {
+    const proc = spawn2("skillindexer", args, {
+      stdio: quiet ? "pipe" : "inherit",
+      shell: true
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to run skillindexer: ${err.message}`));
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(new Error(`skillindexer exited with code ${code}`));
+      }
+    });
+  });
+}
+
+// src/cli/commands/indexer/taxonomy.ts
+import { Command as Command16 } from "commander";
+import { spawn as spawn3 } from "child_process";
+var taxonomyCommand = new Command16("taxonomy").description("Browse the taxonomy tree").argument("[path]", 'Subtree path (e.g., "Development/Python")').option("-i, --interactive", "Interactive browsing mode").option("--standalone", "Use standalone skillindexer CLI (fallback)").action(async (pathArg, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  if (options.interactive || options.standalone) {
+    await runStandaloneMode3(pathArg, options, globalOpts);
+    return;
+  }
+  try {
+    const skillBank = await getSkillBank(globalOpts);
+    const indexer = createIntegratedIndexer(skillBank);
+    const rootPath = pathArg ? pathArg.split("/").filter(Boolean) : void 0;
+    const tree = await indexer.getTaxonomyTree(rootPath);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(tree, null, 2));
+    } else {
+      printTaxonomyTree(tree, 0);
+    }
+    await indexer.close();
+  } catch (err) {
+    const errorMessage = err.message;
+    if (errorMessage.includes("not available") || errorMessage.includes("not found")) {
+      printWarning("IndexerService not available, falling back to standalone CLI...");
+      await runStandaloneMode3(pathArg, options, globalOpts);
+      return;
+    }
+    printError(errorMessage);
+    process.exit(1);
+  }
+});
+function printTaxonomyTree(node, indent) {
+  const prefix = "  ".repeat(indent);
+  const countStr = node.skillCount > 0 ? ` (${node.skillCount})` : "";
+  if (indent === 0) {
+    console.log(`${node.name}${countStr}`);
+  } else {
+    console.log(`${prefix}\u251C\u2500 ${node.name}${countStr}`);
+  }
+  for (const child of node.children) {
+    printTaxonomyTree(child, indent + 1);
+  }
+}
+async function runStandaloneMode3(pathArg, options, globalOpts) {
+  if (!globalOpts.quiet) {
+    printInfo("Using standalone skillindexer CLI...");
+    printInfo("");
+  }
+  const args = ["tree"];
+  if (pathArg) args.push(pathArg);
+  if (options.interactive) args.push("--interactive");
+  try {
+    await runSkillIndexer3(args, globalOpts.quiet ?? false);
+  } catch (err) {
+    printError(err.message);
+    printWarning("");
+    printWarning("Make sure skillindexer is installed and has indexed skills.");
+    printWarning("Run: skill-tree index scrape --discover && skill-tree index classify");
+    process.exit(1);
+  }
+}
+async function runSkillIndexer3(args, quiet) {
+  return new Promise((resolve3, reject) => {
+    const proc = spawn3("skillindexer", args, {
+      stdio: quiet ? "pipe" : "inherit",
+      shell: true
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to run skillindexer: ${err.message}`));
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(new Error(`skillindexer exited with code ${code}`));
+      }
+    });
+  });
+}
+
+// src/cli/commands/indexer/relationships.ts
+import { Command as Command17 } from "commander";
+import { spawn as spawn4 } from "child_process";
+var relationshipsCommand = new Command17("relationships").description("Detect relationships between indexed skills").option("-s, --skill <id>", "Detect relationships for specific skill").option("--use-ai", "Use AI for relationship reasoning (slower, more accurate)").option("--clear", "Clear existing relationships before detection").option("--standalone", "Use standalone skillindexer CLI (fallback)").action(async (options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  if (options.standalone || options.useAi) {
+    await runStandaloneMode4(options, globalOpts);
+    return;
+  }
+  try {
+    const skillBank = await getSkillBank(globalOpts);
+    const indexer = createIntegratedIndexer(skillBank);
+    if (!globalOpts.quiet) {
+      if (options.skill) {
+        printInfo(`Detecting relationships for skill: ${options.skill}`);
+      } else {
+        printInfo("Detecting relationships between all skills...");
+      }
+      printInfo("");
+    }
+    const result = await indexer.detectRelationships({
+      skillId: options.skill,
+      useAi: options.useAi
+    });
+    if (globalOpts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else if (!globalOpts.quiet) {
+      printSuccess("Relationship detection completed");
+      console.log(`  Detected: ${result.detected}`);
+      console.log(`  Skipped: ${result.skipped}`);
+      if (result.errors.length > 0) {
+        printWarning("\nErrors:");
+        for (const error of result.errors) {
+          console.log(`  - ${error}`);
+        }
+      }
+    }
+    await indexer.close();
+  } catch (err) {
+    const errorMessage = err.message;
+    if (errorMessage.includes("not available") || errorMessage.includes("not found")) {
+      printWarning("IndexerService not available, falling back to standalone CLI...");
+      await runStandaloneMode4(options, globalOpts);
+      return;
+    }
+    printError(errorMessage);
+    process.exit(1);
+  }
+});
+async function runStandaloneMode4(options, globalOpts) {
+  if (!globalOpts.quiet) {
+    printInfo("Using standalone skillindexer CLI...");
+    printInfo("");
+  }
+  const args = ["detect-relationships"];
+  if (options.skill) args.push("--skill", options.skill);
+  if (options.useAi) args.push("--use-ai");
+  if (options.clear) args.push("--clear");
+  try {
+    await runSkillIndexer4(args, globalOpts.quiet ?? false);
+  } catch (err) {
+    printError(err.message);
+    printWarning("");
+    printWarning("Make sure skillindexer is installed and has indexed skills.");
+    process.exit(1);
+  }
+}
+async function runSkillIndexer4(args, quiet) {
+  return new Promise((resolve3, reject) => {
+    const proc = spawn4("skillindexer", args, {
+      stdio: quiet ? "pipe" : "inherit",
+      shell: true
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to run skillindexer: ${err.message}`));
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(new Error(`skillindexer exited with code ${code}`));
+      }
+    });
+  });
+}
+
+// src/cli/commands/indexer/stats.ts
+import { Command as Command18 } from "commander";
+import { spawn as spawn5 } from "child_process";
+var indexerStatsCommand = new Command18("stats").description("Show indexer database statistics").option("--standalone", "Use standalone skillindexer CLI (fallback)").action(async (options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  if (options.standalone) {
+    await runStandaloneMode5(globalOpts);
+    return;
+  }
+  try {
+    const skillBank = await getSkillBank(globalOpts);
+    const indexer = createIntegratedIndexer(skillBank);
+    const stats = await indexer.getStats();
+    if (globalOpts.json) {
+      console.log(JSON.stringify(stats, null, 2));
+    } else {
+      console.log("Skill-Tree Statistics");
+      console.log("=".repeat(40));
+      console.log("");
+      console.log("Skills:");
+      console.log(`  Total:      ${stats.totalSkills}`);
+      console.log(`  Indexed:    ${stats.indexedSkills}`);
+      console.log(`  Draft:      ${stats.rawSkills}`);
+      console.log(`  Deprecated: ${stats.failedSkills}`);
+      console.log("");
+      console.log("Taxonomy:");
+      console.log(`  Nodes:      ${stats.taxonomyNodes}`);
+      console.log("");
+      console.log("Relationships:");
+      console.log(`  Total:      ${stats.relationships}`);
+      console.log("");
+      console.log("Sources:");
+      console.log(`  Unique:     ${stats.sources}`);
+    }
+    await indexer.close();
+  } catch (err) {
+    const errorMessage = err.message;
+    if (errorMessage.includes("not available") || errorMessage.includes("not found")) {
+      printWarning("IndexerService not available, falling back to standalone CLI...");
+      await runStandaloneMode5(globalOpts);
+      return;
+    }
+    printError(errorMessage);
+    process.exit(1);
+  }
+});
+async function runStandaloneMode5(globalOpts) {
+  if (!globalOpts.quiet) {
+    printInfo("Using standalone skillindexer CLI...");
+    printInfo("");
+  }
+  try {
+    await runSkillIndexer5(["stats"], globalOpts.quiet ?? false);
+  } catch (err) {
+    printError(err.message);
+    printWarning("");
+    printWarning("Make sure skillindexer is installed.");
+    process.exit(1);
+  }
+}
+async function runSkillIndexer5(args, quiet) {
+  return new Promise((resolve3, reject) => {
+    const proc = spawn5("skillindexer", args, {
+      stdio: quiet ? "pipe" : "inherit",
+      shell: true
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to run skillindexer: ${err.message}`));
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(new Error(`skillindexer exited with code ${code}`));
+      }
+    });
+  });
+}
+
+// src/cli/commands/indexer/sync.ts
+import { Command as Command19 } from "commander";
+import * as fs6 from "fs";
+import * as path4 from "path";
+import * as os3 from "os";
+import { spawn as spawn6 } from "child_process";
+
+// src/services/sync.ts
+var SyncService = class {
+  constructor(skillBank, config2 = {}) {
+    this.syncStates = /* @__PURE__ */ new Map();
+    this.skillBank = skillBank;
+    this.globalConfig = loadConfig();
+    this.config = {
+      githubToken: config2.githubToken || this.globalConfig.indexer.github_token,
+      autoSyncInterval: config2.autoSyncInterval || 0,
+      conflictResolution: config2.conflictResolution || this.globalConfig.sync.conflict_resolution
+    };
+  }
+  /**
+   * Initialize sync service
+   * Loads sync state from storage if available
+   */
+  async initialize() {
+    const storage = this.skillBank.getStorage();
+    if (storage?.getSyncStates) {
+      try {
+        const states = await storage.getSyncStates();
+        for (const state of states) {
+          const record = state;
+          if (record.skillId && record.lastSynced) {
+            const skillId = record.skillId;
+            this.syncStates.set(skillId, {
+              skillId,
+              sourceUrl: record.sourceUrl || "",
+              sourceEtag: record.sourceEtag,
+              lastSynced: new Date(record.lastSynced),
+              localVersion: record.localVersion || "0.0.0",
+              remoteVersion: record.remoteVersion,
+              status: record.status || "synced"
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Get sync state for a skill
+   */
+  getSyncState(skillId) {
+    return this.syncStates.get(skillId);
+  }
+  /**
+   * Set sync state for a skill
+   */
+  async setSyncState(skillId, state) {
+    this.syncStates.set(skillId, state);
+    const storage = this.skillBank.getStorage();
+    if (storage?.saveSyncState) {
+      try {
+        await storage.saveSyncState({
+          remote: state.sourceUrl,
+          syncedAt: state.lastSynced,
+          commitHash: state.sourceEtag
+        });
+      } catch {
+      }
+    }
+  }
+  /**
+   * Check for updates on all imported skills
+   */
+  async checkForUpdates() {
+    const results = [];
+    const skills = await this.skillBank.listSkills();
+    for (const skill of skills) {
+      if (!skill.externalSource?.url) continue;
+      const result = await this.checkSkillForUpdates(skill);
+      results.push(result);
+    }
+    this.lastCheck = /* @__PURE__ */ new Date();
+    return results;
+  }
+  /**
+   * Check a single skill for updates
+   */
+  async checkSkillForUpdates(skill) {
+    const syncState = this.syncStates.get(skill.id);
+    if (!skill.externalSource?.url) {
+      return {
+        skillId: skill.id,
+        skillName: skill.name,
+        status: "synced",
+        localVersion: skill.version,
+        hasRemoteChanges: false,
+        hasLocalChanges: false
+      };
+    }
+    const hasLocalChanges = syncState ? skill.version !== syncState.localVersion : false;
+    let hasRemoteChanges = false;
+    let remoteVersion;
+    if (skill.externalSource.url.includes("github.com")) {
+      try {
+        const remoteInfo = await this.fetchRemoteInfo(skill.externalSource.url);
+        hasRemoteChanges = remoteInfo.etag !== syncState?.sourceEtag;
+        remoteVersion = remoteInfo.version;
+      } catch {
+      }
+    }
+    let status;
+    if (hasLocalChanges && hasRemoteChanges) {
+      status = "conflict";
+    } else if (hasLocalChanges) {
+      status = "local-modified";
+    } else if (hasRemoteChanges) {
+      status = "remote-modified";
+    } else {
+      status = "synced";
+    }
+    return {
+      skillId: skill.id,
+      skillName: skill.name,
+      status,
+      localVersion: skill.version,
+      remoteVersion,
+      lastSynced: syncState?.lastSynced,
+      hasRemoteChanges,
+      hasLocalChanges
+    };
+  }
+  /**
+   * Fetch remote info from GitHub
+   */
+  async fetchRemoteInfo(url) {
+    const match = url.match(/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)/);
+    if (!match) {
+      throw new Error("Invalid GitHub URL");
+    }
+    const [, owner, repo, branch, filePath] = match;
+    const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${filePath}?ref=${branch}`;
+    const headers = {
+      "Accept": "application/vnd.github.v3+json",
+      "User-Agent": "skill-tree-sync"
+    };
+    if (this.config.githubToken) {
+      headers["Authorization"] = `Bearer ${this.config.githubToken}`;
+    }
+    const response = await fetch(apiUrl, { headers });
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status}`);
+    }
+    const data = await response.json();
+    const etag = response.headers.get("etag") || data.sha;
+    let version;
+    if (data.content) {
+      const content = Buffer.from(data.content, "base64").toString("utf-8");
+      const versionMatch = content.match(/version:\s*['"]?(\d+\.\d+\.\d+)['"]?/i);
+      if (versionMatch) {
+        version = versionMatch[1];
+      }
+    }
+    return { etag, version, content: data.content };
+  }
+  /**
+   * Pull remote changes for all skills that need updates
+   */
+  async pullRemoteChanges(options) {
+    const result = {
+      pulled: 0,
+      skipped: 0,
+      conflicts: 0,
+      errors: [],
+      updates: []
+    };
+    let skills = await this.skillBank.listSkills();
+    if (options?.skillIds) {
+      skills = skills.filter((s) => options.skillIds.includes(s.id));
+    }
+    for (const skill of skills) {
+      if (!skill.externalSource?.url) {
+        result.skipped++;
+        continue;
+      }
+      try {
+        const checkResult = await this.checkSkillForUpdates(skill);
+        if (checkResult.status === "synced") {
+          result.skipped++;
+          continue;
+        }
+        if (checkResult.status === "conflict") {
+          const resolution = options?.conflictResolution || this.config.conflictResolution;
+          if (resolution === "manual") {
+            result.conflicts++;
+            continue;
+          } else if (resolution === "local") {
+            result.skipped++;
+            continue;
+          }
+        }
+        if (checkResult.status === "local-modified") {
+          result.skipped++;
+          continue;
+        }
+        if (!options?.dryRun) {
+          const updated = await this.pullSkillUpdate(skill);
+          if (updated) {
+            result.pulled++;
+            result.updates.push({
+              skillId: skill.id,
+              previousVersion: skill.version,
+              newVersion: updated.version
+            });
+          }
+        } else {
+          result.pulled++;
+        }
+      } catch (err) {
+        result.errors.push(`Failed to sync ${skill.id}: ${err.message}`);
+      }
+    }
+    return result;
+  }
+  /**
+   * Pull update for a single skill
+   */
+  async pullSkillUpdate(skill) {
+    if (!skill.externalSource?.url) return null;
+    try {
+      const remoteInfo = await this.fetchRemoteInfo(skill.externalSource.url);
+      if (!remoteInfo.content) return null;
+      const content = Buffer.from(remoteInfo.content, "base64").toString("utf-8");
+      const updatedSkill = {
+        ...skill,
+        version: remoteInfo.version || skill.version,
+        updatedAt: /* @__PURE__ */ new Date(),
+        externalSource: {
+          ...skill.externalSource,
+          etag: remoteInfo.etag
+        }
+      };
+      await this.skillBank.saveSkill(updatedSkill);
+      await this.setSyncState(skill.id, {
+        skillId: skill.id,
+        sourceUrl: skill.externalSource.url,
+        sourceEtag: remoteInfo.etag,
+        lastSynced: /* @__PURE__ */ new Date(),
+        localVersion: updatedSkill.version,
+        remoteVersion: remoteInfo.version,
+        status: "synced"
+      });
+      return updatedSkill;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Mark a skill as synced (after manual resolution)
+   */
+  async markAsSynced(skillId) {
+    const skill = await this.skillBank.getSkill(skillId);
+    if (!skill || !skill.externalSource?.url) return;
+    await this.setSyncState(skillId, {
+      skillId,
+      sourceUrl: skill.externalSource.url,
+      sourceEtag: skill.externalSource.etag,
+      lastSynced: /* @__PURE__ */ new Date(),
+      localVersion: skill.version,
+      status: "synced"
+    });
+  }
+  /**
+   * Get sync status summary
+   */
+  async getStatusSummary() {
+    const skills = await this.skillBank.listSkills();
+    const summary = {
+      total: 0,
+      synced: 0,
+      localModified: 0,
+      remoteModified: 0,
+      conflicts: 0,
+      neverSynced: 0,
+      lastCheck: this.lastCheck
+    };
+    for (const skill of skills) {
+      if (!skill.externalSource?.url) continue;
+      summary.total++;
+      const state = this.syncStates.get(skill.id);
+      if (!state) {
+        summary.neverSynced++;
+      } else {
+        switch (state.status) {
+          case "synced":
+            summary.synced++;
+            break;
+          case "local-modified":
+            summary.localModified++;
+            break;
+          case "remote-modified":
+            summary.remoteModified++;
+            break;
+          case "conflict":
+            summary.conflicts++;
+            break;
+        }
+      }
+    }
+    return summary;
+  }
+  /**
+   * Detect conflicts between local and remote versions
+   */
+  async detectConflicts() {
+    const conflicts = [];
+    const skills = await this.skillBank.listSkills();
+    for (const skill of skills) {
+      const state = this.syncStates.get(skill.id);
+      if (state?.status === "conflict" && skill.externalSource?.url) {
+        conflicts.push({
+          skill,
+          localChanges: [`Version changed: ${state.localVersion} -> ${skill.version}`],
+          remoteChanges: state.remoteVersion ? [`Remote version: ${state.remoteVersion}`] : ["Remote content changed"]
+        });
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * Register a skill as imported (sets initial sync state)
+   */
+  async registerImportedSkill(skill) {
+    if (!skill.externalSource?.url) return;
+    await this.setSyncState(skill.id, {
+      skillId: skill.id,
+      sourceUrl: skill.externalSource.url,
+      sourceEtag: skill.externalSource.etag,
+      lastSynced: /* @__PURE__ */ new Date(),
+      localVersion: skill.version,
+      status: "synced"
+    });
+  }
+};
+function createSyncService(skillBank, config2) {
+  return new SyncService(skillBank, config2);
+}
+
+// src/cli/commands/indexer/sync.ts
+var syncCommand = new Command19("sync").description("Sync imported skills with remote sources").option("--status", "Show sync status for all imported skills").option("--pull", "Pull remote changes for skills that need updates").option("--dry-run", "Preview changes without making them").option("--force", "Force sync even for conflicting skills").option("--resolve <strategy>", "Conflict resolution: local, remote, manual", "manual").option("--skill <id>", "Sync specific skill only").option("--import", "Import from indexer export (legacy mode)").option("--export-path <path>", "Path to indexer export file (for --import)").option("--indexed-only", "Only sync indexed skills (for --import)").action(async (options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    if (options.import) {
+      await runLegacyImport(options, globalOpts);
+      return;
+    }
+    const skillBank = await getSkillBank(globalOpts);
+    const syncService = createSyncService(skillBank, {
+      githubToken: process.env.GITHUB_TOKEN,
+      conflictResolution: options.resolve
+    });
+    await syncService.initialize();
+    if (options.status) {
+      if (!globalOpts.quiet) {
+        printInfo("Checking sync status...");
+      }
+      const results = await syncService.checkForUpdates();
+      const summary = await syncService.getStatusSummary();
+      if (globalOpts.json) {
+        console.log(JSON.stringify({ results, summary }, null, 2));
+        return;
+      }
+      console.log("");
+      console.log("Sync Status Summary");
+      console.log("=".repeat(40));
+      console.log(`  Total imported skills: ${summary.total}`);
+      console.log(`  Synced:                ${summary.synced}`);
+      console.log(`  Local modified:        ${summary.localModified}`);
+      console.log(`  Remote modified:       ${summary.remoteModified}`);
+      console.log(`  Conflicts:             ${summary.conflicts}`);
+      console.log(`  Never synced:          ${summary.neverSynced}`);
+      if (summary.lastCheck) {
+        console.log(`  Last check:            ${summary.lastCheck.toISOString()}`);
+      }
+      const needsAction = results.filter((r) => r.status !== "synced");
+      if (needsAction.length > 0) {
+        console.log("");
+        console.log("Skills needing attention:");
+        for (const result of needsAction) {
+          const icon = result.status === "conflict" ? "\u26A0\uFE0F" : result.status === "remote-modified" ? "\u2193" : result.status === "local-modified" ? "\u2191" : "?";
+          console.log(`  ${icon} ${result.skillName} (${result.skillId})`);
+          console.log(`      Status: ${result.status}`);
+          console.log(`      Local version: ${result.localVersion}`);
+          if (result.remoteVersion) {
+            console.log(`      Remote version: ${result.remoteVersion}`);
+          }
+        }
+      }
+      return;
+    }
+    if (options.pull) {
+      if (!globalOpts.quiet) {
+        if (options.dryRun) {
+          printInfo("Checking for remote changes (dry run)...");
+        } else {
+          printInfo("Pulling remote changes...");
+        }
+      }
+      const pullResult = await syncService.pullRemoteChanges({
+        skillIds: options.skill ? [options.skill] : void 0,
+        conflictResolution: options.force ? "remote" : options.resolve,
+        dryRun: options.dryRun
+      });
+      if (globalOpts.json) {
+        console.log(JSON.stringify(pullResult, null, 2));
+        return;
+      }
+      if (options.dryRun) {
+        console.log("");
+        console.log("Would pull the following updates:");
+        console.log(`  Skills to update: ${pullResult.pulled}`);
+        console.log(`  Skipped: ${pullResult.skipped}`);
+        console.log(`  Conflicts: ${pullResult.conflicts}`);
+      } else {
+        printSuccess("Sync completed");
+        console.log(`  Pulled: ${pullResult.pulled}`);
+        console.log(`  Skipped: ${pullResult.skipped}`);
+        console.log(`  Conflicts: ${pullResult.conflicts}`);
+        if (pullResult.updates.length > 0) {
+          console.log("");
+          console.log("Updated skills:");
+          for (const update of pullResult.updates) {
+            console.log(`  - ${update.skillId}: ${update.previousVersion} -> ${update.newVersion}`);
+          }
+        }
+      }
+      if (pullResult.errors.length > 0) {
+        printWarning("\nErrors:");
+        for (const error of pullResult.errors) {
+          console.log(`  - ${error}`);
+        }
+      }
+      return;
+    }
+    printInfo("Usage:");
+    console.log("  skill-tree index sync --status    Show sync status");
+    console.log("  skill-tree index sync --pull      Pull remote changes");
+    console.log("  skill-tree index sync --import    Import from indexer export");
+    console.log("");
+    console.log("Options:");
+    console.log("  --dry-run              Preview changes");
+    console.log("  --force                Force sync for conflicts");
+    console.log("  --resolve <strategy>   Conflict resolution: local, remote, manual");
+    console.log("  --skill <id>           Sync specific skill");
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+});
+async function runLegacyImport(options, globalOpts) {
+  let exportPath = options.exportPath;
+  if (!exportPath) {
+    if (!globalOpts.quiet) {
+      printInfo("Exporting skills from indexer...");
+    }
+    exportPath = path4.join(os3.tmpdir(), `skill-tree-sync-${Date.now()}.json`);
+    const args = ["export-skilltree", "-o", exportPath, "-f", "json"];
+    if (options.indexedOnly) args.push("--indexed-only");
+    await runSkillIndexer6(args, true);
+    if (!fs6.existsSync(exportPath)) {
+      printError("Failed to export skills from indexer");
+      process.exit(1);
+    }
+  }
+  if (!globalOpts.quiet) {
+    printInfo(`Reading export from ${exportPath}...`);
+  }
+  const content = fs6.readFileSync(exportPath, "utf-8");
+  const { skills, stats } = parseIndexerExport(content);
+  if (!globalOpts.quiet) {
+    printInfo(`Found ${stats.total} skills (${stats.withStructuredContent} with structured content)`);
+  }
+  if (options.dryRun) {
+    console.log("");
+    console.log("Would import the following skills:");
+    for (const skill of skills.slice(0, 20)) {
+      console.log(`  - ${skill.id} (${skill.name})`);
+    }
+    if (skills.length > 20) {
+      console.log(`  ... and ${skills.length - 20} more`);
+    }
+    return;
+  }
+  const skillBank = await getSkillBank(globalOpts);
+  const result = await skillBank.importSkills(skills);
+  if (!options.exportPath && exportPath) {
+    try {
+      fs6.unlinkSync(exportPath);
+    } catch {
+    }
+  }
+  if (globalOpts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  printSuccess(`Synced ${result.imported} skills into SkillBank`);
+  if (result.failed > 0) {
+    printWarning(`Failed to sync ${result.failed} skills`);
+  }
+}
+async function runSkillIndexer6(args, quiet) {
+  return new Promise((resolve3, reject) => {
+    const proc = spawn6("skillindexer", args, {
+      stdio: quiet ? "pipe" : "inherit",
+      shell: true
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to run skillindexer: ${err.message}`));
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(new Error(`skillindexer exited with code ${code}`));
+      }
+    });
+  });
+}
+
+// src/cli/commands/indexer/index.ts
+var indexerCommand = new Command20("index").description("Skill indexer - discover and classify skills from GitHub").addCommand(scrapeCommand).addCommand(classifyCommand).addCommand(taxonomyCommand).addCommand(relationshipsCommand).addCommand(indexerStatsCommand).addCommand(syncCommand);
+
+// src/cli/commands/config.ts
+import { Command as Command21 } from "commander";
+import * as fs7 from "fs";
+var configCommand = new Command21("config").description("View and manage configuration");
+configCommand.command("show").description("Show current configuration").option("--path <path>", "Path to specific config value (e.g., storage.type)").action((options) => {
+  const globalOpts = configCommand.parent?.opts() || {};
+  const configPath = globalOpts.config;
+  const loader = new ConfigLoader(configPath);
+  const config2 = loader.load();
+  if (options.path) {
+    const value = loader.get(options.path);
+    if (value === void 0) {
+      console.error(`Config path not found: ${options.path}`);
+      process.exit(1);
+    }
+    if (globalOpts.json) {
+      console.log(JSON.stringify(value, null, 2));
+    } else {
+      console.log(value);
+    }
+  } else {
+    if (globalOpts.json) {
+      console.log(JSON.stringify(config2, null, 2));
+    } else {
+      console.log("Current Configuration:");
+      console.log("=".repeat(40));
+      console.log(`Config file: ${expandPath(configPath || getConfigPath())}`);
+      console.log("");
+      printConfig(config2, 0);
+    }
+  }
+});
+configCommand.command("init").description("Create default configuration file").option("-f, --force", "Overwrite existing config file").action((options) => {
+  const globalOpts = configCommand.parent?.opts() || {};
+  const configPath = expandPath(globalOpts.config || getConfigPath());
+  if (fs7.existsSync(configPath) && !options.force) {
+    console.error(`Config file already exists: ${configPath}`);
+    console.error("Use --force to overwrite");
+    process.exit(1);
+  }
+  const loader = new ConfigLoader(configPath);
+  loader.createDefaultConfigFile();
+  if (!(globalOpts.quiet ?? false)) {
+    console.log(`Created config file: ${configPath}`);
+  }
+});
+configCommand.command("path").description("Show configuration file path").action(() => {
+  const globalOpts = configCommand.parent?.opts() || {};
+  const configPath = globalOpts.config || getConfigPath();
+  console.log(expandPath(configPath));
+});
+configCommand.command("edit").description("Open configuration file in editor").action(() => {
+  const globalOpts = configCommand.parent?.opts() || {};
+  const configPath = expandPath(globalOpts.config || getConfigPath());
+  if (!fs7.existsSync(configPath)) {
+    const loader = new ConfigLoader(configPath);
+    loader.createDefaultConfigFile();
+  }
+  const editor = process.env.EDITOR || process.env.VISUAL || "nano";
+  import("child_process").then(({ spawn: spawn7 }) => {
+    const child = spawn7(editor, [configPath], {
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("exit", (code) => {
+      process.exit(code || 0);
+    });
+  }).catch((error) => {
+    console.error("Failed to open editor:", error.message);
+    process.exit(1);
+  });
+});
+configCommand.command("defaults").description("Show default configuration values").action(() => {
+  const globalOpts = configCommand.parent?.opts() || {};
+  if (globalOpts.json) {
+    console.log(JSON.stringify(DEFAULT_CONFIG, null, 2));
+  } else {
+    console.log("Default Configuration:");
+    console.log("=".repeat(40));
+    printConfig(DEFAULT_CONFIG, 0);
+  }
+});
+configCommand.command("validate").description("Validate configuration file").action(() => {
+  const globalOpts = configCommand.parent?.opts() || {};
+  const configPath = expandPath(globalOpts.config || getConfigPath());
+  if (!fs7.existsSync(configPath)) {
+    console.error(`Config file not found: ${configPath}`);
+    process.exit(1);
+  }
+  try {
+    const loader = new ConfigLoader(configPath);
+    const config2 = loader.load();
+    const errors = [];
+    if (!config2.storage.type) {
+      errors.push("storage.type is required");
+    }
+    if (!config2.storage.path) {
+      errors.push("storage.path is required");
+    }
+    if (!["sqlite", "filesystem", "memory"].includes(config2.storage.type)) {
+      errors.push(`storage.type must be one of: sqlite, filesystem, memory`);
+    }
+    if (config2.indexer.min_confidence < 0 || config2.indexer.min_confidence > 1) {
+      errors.push("indexer.min_confidence must be between 0 and 1");
+    }
+    if (config2.indexer.batch_size < 1) {
+      errors.push("indexer.batch_size must be at least 1");
+    }
+    if (config2.matching.similarity_threshold < 0 || config2.matching.similarity_threshold > 1) {
+      errors.push("matching.similarity_threshold must be between 0 and 1");
+    }
+    if (errors.length > 0) {
+      console.error("Configuration errors:");
+      for (const error of errors) {
+        console.error(`  - ${error}`);
+      }
+      process.exit(1);
+    }
+    if (!(globalOpts.quiet ?? false)) {
+      console.log("Configuration is valid");
+    }
+  } catch (error) {
+    console.error("Failed to parse config file:", error.message);
+    process.exit(1);
+  }
+});
+function printConfig(obj, indent) {
+  const prefix = "  ".repeat(indent);
+  if (typeof obj !== "object" || obj === null) {
+    console.log(`${prefix}${obj}`);
+    return;
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      console.log(`${prefix}[]`);
+    } else {
+      for (const item of obj) {
+        console.log(`${prefix}- ${item}`);
+      }
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      console.log(`${prefix}${key}:`);
+      printConfig(value, indent + 1);
+    } else if (Array.isArray(value)) {
+      console.log(`${prefix}${key}:`);
+      printConfig(value, indent + 1);
+    } else {
+      const displayValue = value === void 0 ? "(not set)" : value;
+      console.log(`${prefix}${key}: ${displayValue}`);
+    }
+  }
+}
+
+// src/cli/commands/sync.ts
+import { Command as Command22 } from "commander";
+import * as path5 from "path";
+import * as fs8 from "fs";
+function getSyncConfigPath(basePath) {
+  return path5.join(basePath, ".skillbank", "sync-config.json");
+}
+async function loadSyncConfig(basePath) {
+  const configPath = getSyncConfigPath(basePath);
+  try {
+    const content = await fs8.promises.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveSyncConfig(basePath, config2) {
+  const configPath = getSyncConfigPath(basePath);
+  await fs8.promises.mkdir(path5.dirname(configPath), { recursive: true });
+  await fs8.promises.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+}
+async function createSyncAdapter(basePath, globalOpts) {
+  const config2 = await loadSyncConfig(basePath);
+  if (!config2) {
+    printError('Sync not configured. Run "skill-tree sync init" first.');
+    return null;
+  }
+  const adapter = new GitSyncAdapter({
+    repoPath: basePath,
+    config: config2
+  });
+  await adapter.initialize();
+  return adapter;
+}
+var syncCommand2 = new Command22("sync").description("Multi-agent skill synchronization").addCommand(initCommand()).addCommand(statusCommand()).addCommand(pullCommand()).addCommand(pushCommand()).addCommand(conflictsCommand()).addCommand(resolveCommand());
+function initCommand() {
+  return new Command22("init").description("Initialize sync configuration").requiredOption("-r, --remote <url>", "Remote repository URL").requiredOption("-a, --agent <id>", "Agent ID (slug format)").option("-b, --branch <branch>", "Branch to sync with", "main").option("-n, --name <name>", "Agent name (human-readable)").option("-e, --env <environment>", "Environment (production, staging, etc.)").action(async (options, command) => {
+    const globalOpts = command.optsWithGlobals();
+    const basePath = getSkillPath(globalOpts);
+    try {
+      const existing = await loadSyncConfig(basePath);
+      if (existing) {
+        printWarning("Sync already configured. Overwriting...");
+      }
+      const config2 = createDefaultSyncConfig(options.remote, options.agent, {
+        branch: options.branch,
+        agentName: options.name,
+        environment: options.env
+      });
+      const gitDir = path5.join(basePath, ".git");
+      if (!fs8.existsSync(gitDir)) {
+        printError(`Not a git repository: ${basePath}`);
+        printInfo("Initialize a git repository first with: git init");
+        process.exit(1);
+      }
+      await saveSyncConfig(basePath, config2);
+      printSuccess("Sync configured successfully!");
+      console.log();
+      printInfo(`Remote: ${options.remote}`);
+      printInfo(`Branch: ${options.branch}`);
+      printInfo(`Agent ID: ${options.agent}`);
+      if (options.name) {
+        printInfo(`Agent Name: ${options.name}`);
+      }
+      if (options.env) {
+        printInfo(`Environment: ${options.env}`);
+      }
+      console.log();
+      printInfo('Run "skill-tree sync pull" to fetch skills from remote.');
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+}
+function statusCommand() {
+  return new Command22("status").description("Show sync status").action(async (_options, command) => {
+    const globalOpts = command.optsWithGlobals();
+    const basePath = getSkillPath(globalOpts);
+    try {
+      const adapter = await createSyncAdapter(basePath, globalOpts);
+      if (!adapter) return;
+      const status = await adapter.status();
+      if (globalOpts.json) {
+        console.log(JSON.stringify(status, null, 2));
+        return;
+      }
+      console.log();
+      printInfo(`Branch: ${status.branch}`);
+      printInfo(`Remote: ${status.remoteUrl}`);
+      console.log();
+      if (!status.connected) {
+        printWarning("Not connected to remote");
+      } else {
+        if (status.localAhead > 0) {
+          printWarning(`Your branch is ahead by ${status.localAhead} commit(s)`);
+        }
+        if (status.remoteBehind > 0) {
+          printWarning(`Your branch is behind by ${status.remoteBehind} commit(s)`);
+        }
+        if (status.localAhead === 0 && status.remoteBehind === 0) {
+          printSuccess("Up to date with remote");
+        }
+      }
+      if (status.modifiedSkills.length > 0) {
+        console.log();
+        printInfo(`Modified skills (${status.modifiedSkills.length}):`);
+        for (const skillId of status.modifiedSkills) {
+          console.log(`  - ${skillId}`);
+        }
+      }
+      if (status.pendingConflicts > 0) {
+        console.log();
+        printWarning(`Pending conflicts: ${status.pendingConflicts}`);
+        printInfo('Run "skill-tree sync conflicts" to see details');
+      }
+      if (status.lastSync) {
+        console.log();
+        printInfo(`Last sync: ${status.lastSync.toLocaleString()}`);
+      }
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+}
+function pullCommand() {
+  return new Command22("pull").description("Pull skills from remote").option("-s, --skills <ids>", "Specific skill IDs (comma-separated)").option("-f, --force", "Force overwrite local changes").option("-d, --dry-run", "Preview changes without applying").action(async (options, command) => {
+    const globalOpts = command.optsWithGlobals();
+    const basePath = getSkillPath(globalOpts);
+    try {
+      const adapter = await createSyncAdapter(basePath, globalOpts);
+      if (!adapter) return;
+      const skillIds = options.skills?.split(",").map((s) => s.trim());
+      if (options.dryRun) {
+        printInfo("Dry run - no changes will be applied");
+        console.log();
+      }
+      const result = await adapter.pull({
+        skillIds,
+        force: options.force,
+        dryRun: options.dryRun
+      });
+      if (globalOpts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      if (result.pulled.length === 0 && result.conflicts.length === 0) {
+        printSuccess("Already up to date");
+        return;
+      }
+      if (result.pulled.length > 0) {
+        console.log();
+        printSuccess(`Pulled ${result.pulled.length} skill(s):`);
+        for (const change of result.pulled) {
+          const icon = change.changeType === "added" ? "+" : change.changeType === "deleted" ? "-" : "~";
+          console.log(`  ${icon} ${change.skillId}`);
+        }
+      }
+      if (result.autoMerged.length > 0) {
+        console.log();
+        printInfo(`Auto-merged ${result.autoMerged.length} skill(s):`);
+        for (const merge of result.autoMerged) {
+          console.log(`  ~ ${merge.skillId}`);
+        }
+      }
+      if (result.conflicts.length > 0) {
+        console.log();
+        printWarning(`Conflicts (${result.conflicts.length}):`);
+        for (const conflict of result.conflicts) {
+          console.log(`  ! ${conflict.skillId}`);
+          for (const field of conflict.conflictingFields) {
+            console.log(`    - ${field}`);
+          }
+        }
+        console.log();
+        printInfo('Run "skill-tree sync conflicts" to resolve');
+      }
+      if (result.errors.length > 0) {
+        console.log();
+        printError(`Errors (${result.errors.length}):`);
+        for (const err of result.errors) {
+          console.log(`  - ${err.skillId || "general"}: ${err.message}`);
+        }
+      }
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+}
+function pushCommand() {
+  return new Command22("push").description("Push skills to remote").option("-s, --skills <ids>", "Specific skill IDs (comma-separated)").option("-m, --message <msg>", "Custom commit message").option("-f, --force", "Force push (overwrites remote)").action(async (options, command) => {
+    const globalOpts = command.optsWithGlobals();
+    const basePath = getSkillPath(globalOpts);
+    try {
+      const adapter = await createSyncAdapter(basePath, globalOpts);
+      if (!adapter) return;
+      const skillIds = options.skills?.split(",").map((s) => s.trim());
+      if (options.force) {
+        printWarning("Force push enabled - this may overwrite remote changes!");
+      }
+      const result = await adapter.push({
+        skillIds,
+        message: options.message,
+        force: options.force
+      });
+      if (globalOpts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      if (result.pushed.length === 0 && result.errors.length === 0) {
+        printInfo("Nothing to push");
+        return;
+      }
+      if (result.pushed.length > 0) {
+        console.log();
+        printSuccess(`Pushed ${result.pushed.length} skill(s):`);
+        for (const change of result.pushed) {
+          const icon = change.changeType === "added" ? "+" : "~";
+          console.log(`  ${icon} ${change.skillId}`);
+        }
+      }
+      if (result.errors.length > 0) {
+        console.log();
+        if (result.errors.some((e) => e.type === "conflict")) {
+          printWarning("Push rejected - remote has changes");
+          printInfo('Run "skill-tree sync pull" first, then try again');
+        } else {
+          printError(`Errors (${result.errors.length}):`);
+          for (const err of result.errors) {
+            console.log(`  - ${err.skillId || "general"}: ${err.message}`);
+          }
+        }
+      }
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+}
+function conflictsCommand() {
+  return new Command22("conflicts").description("List pending conflicts").option("-v, --verbose", "Show detailed conflict information").action(async (options, command) => {
+    const globalOpts = command.optsWithGlobals();
+    const basePath = getSkillPath(globalOpts);
+    try {
+      const adapter = await createSyncAdapter(basePath, globalOpts);
+      if (!adapter) return;
+      const conflicts = await adapter.listConflicts();
+      if (globalOpts.json) {
+        console.log(JSON.stringify(conflicts, null, 2));
+        return;
+      }
+      if (conflicts.length === 0) {
+        printSuccess("No pending conflicts");
+        return;
+      }
+      console.log();
+      printWarning(`${conflicts.length} conflict(s) pending resolution:`);
+      console.log();
+      for (const conflict of conflicts) {
+        console.log(`  ${conflict.skillId}`);
+        console.log(`    Detected: ${conflict.detectedAt.toLocaleString()}`);
+        console.log(`    Local version: ${conflict.localVersion.version}`);
+        console.log(`    Remote version: ${conflict.remoteVersion.version}`);
+        console.log(`    Conflicting fields:`);
+        for (const field of conflict.conflictingFields) {
+          console.log(`      - ${field}`);
+        }
+        if (options.verbose && conflict.fieldConflicts.length > 0) {
+          console.log(`    Details:`);
+          for (const fc of conflict.fieldConflicts) {
+            console.log(`      ${fc.field}: ${fc.reason}`);
+          }
+        }
+        if (conflict.suggestedResolution) {
+          console.log(
+            `    Suggested resolution available (confidence: ${Math.round(conflict.confidence * 100)}%)`
+          );
+        }
+        console.log();
+      }
+      printInfo("To resolve a conflict:");
+      console.log("  skill-tree sync resolve <skill-id> --accept-local");
+      console.log("  skill-tree sync resolve <skill-id> --accept-remote");
+      console.log("  skill-tree sync resolve <skill-id> --accept-merged");
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+}
+function resolveCommand() {
+  return new Command22("resolve").description("Resolve a conflict").argument("<skill-id>", "Skill ID to resolve").option("-l, --accept-local", "Accept local version").option("-r, --accept-remote", "Accept remote version").option("-m, --accept-merged", "Accept auto-merged suggestion").action(async (skillId, options, command) => {
+    const globalOpts = command.optsWithGlobals();
+    const basePath = getSkillPath(globalOpts);
+    try {
+      const adapter = await createSyncAdapter(basePath, globalOpts);
+      if (!adapter) return;
+      let strategy;
+      if (options.acceptLocal) {
+        strategy = "accept-local";
+      } else if (options.acceptRemote) {
+        strategy = "accept-remote";
+      } else if (options.acceptMerged) {
+        strategy = "accept-merged";
+      } else {
+        printError("Specify a resolution strategy:");
+        console.log("  --accept-local   Keep your local version");
+        console.log("  --accept-remote  Accept the remote version");
+        console.log("  --accept-merged  Accept the auto-merged suggestion");
+        process.exit(1);
+        return;
+      }
+      await adapter.resolveConflict(skillId, { strategy });
+      printSuccess(`Resolved conflict for ${skillId} using ${strategy}`);
+      printInfo('The resolved version has been staged. Run "skill-tree sync push" when ready.');
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/mcp.ts
+import { Command as Command23 } from "commander";
+import * as readline from "readline";
+var mcpCommand = new Command23("mcp").description("Start MCP server over stdio (JSON-RPC 2.0)").option("--agent-can-set-loadout", "Allow agent to set loadout via criteria", false).option("--max-expanded <n>", "Maximum number of expanded skills", "5").action(async (options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  const skillPath = resolveSkillPath(globalOpts.path);
+  ensureDir(skillPath);
+  const storage = new FilesystemStorageAdapter({ basePath: skillPath });
+  await storage.initialize();
+  const graphServer = new SkillGraphServer(storage, {
+    agentCanModify: true,
+    agentCanSetLoadout: globalOpts.agentCanSetLoadout ?? false,
+    agentCanSwitchProfile: true,
+    requireApproval: false,
+    autoExpandOnUse: true,
+    autoExpandRelated: false,
+    maxExpanded: parseInt(globalOpts.maxExpanded || "5", 10)
+  });
+  await graphServer.initialize();
+  const mcpServer = new SkillTreeMcpServer(graphServer, {
+    dynamicTools: false
+  });
+  const rl = readline.createInterface({ input: process.stdin, terminal: false });
+  let buffer = "";
+  rl.on("line", async (line) => {
+    buffer += line;
+    let msg;
+    try {
+      msg = JSON.parse(buffer);
+      buffer = "";
+    } catch {
+      return;
+    }
+    const { id, method, params } = msg;
+    try {
+      let result;
+      switch (method) {
+        case "initialize":
+          result = {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: mcpServer.getServerInfo()
+          };
+          break;
+        case "notifications/initialized":
+          return;
+        case "tools/list":
+          result = {
+            tools: mcpServer.getTools().map((t) => ({
+              name: t.name,
+              description: t.description,
+              inputSchema: t.inputSchema
+            }))
+          };
+          break;
+        case "tools/call": {
+          const { name, arguments: args } = params;
+          const toolResult = await mcpServer.executeTool(name, args || {});
+          result = {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(toolResult, null, 2)
+              }
+            ],
+            isError: !toolResult.success
+          };
+          break;
+        }
+        case "ping":
+          result = {};
+          break;
+        default:
+          respond(id, null, { code: -32601, message: `Method not found: ${method}` });
+          return;
+      }
+      respond(id, result);
+    } catch (err) {
+      respond(id, null, { code: -32603, message: String(err) });
+    }
+  });
+  function respond(id, result, error) {
+    if (id === void 0) return;
+    const response = { jsonrpc: "2.0", id };
+    if (error) {
+      response.error = error;
+    } else {
+      response.result = result;
+    }
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+  process.on("SIGTERM", () => {
+    mcpServer.dispose();
+    process.exit(0);
+  });
+});
+
+// src/cli/index.ts
+var program = new Command24();
+var config = loadConfig();
+program.name("skill-tree").description("Management CLI for agent skills").version(VERSION).option("-p, --path <dir>", "Skills directory path", config.storage.path).option("-c, --config <file>", "Config file path", getConfigPath()).option("--json", "Output as JSON", config.cli.output_format === "json").option("-q, --quiet", "Suppress non-essential output", config.cli.quiet).option("--no-color", "Disable colored output", !config.cli.color);
+program.addCommand(listCommand);
+program.addCommand(showCommand);
+program.addCommand(searchCommand);
+program.addCommand(statsCommand);
+program.addCommand(versionsCommand);
+program.addCommand(diffCommand);
+program.addCommand(rollbackCommand);
+program.addCommand(forkCommand);
+program.addCommand(deprecateCommand);
+program.addCommand(activateCommand);
+program.addCommand(deleteCommand);
+program.addCommand(exportCommand);
+program.addCommand(importCommand);
+program.addCommand(indexerCommand);
+program.addCommand(configCommand);
+program.addCommand(syncCommand2);
+program.addCommand(mcpCommand);
+program.parse();