@skillkit/cli 1.5.0 → 1.6.0

package/dist/index.js

@@ -3802,10 +3802,10 @@ ${learning.title}
       return 0;
     }
     const outputPath = this.output || `.skillkit/exports/${skillName}/SKILL.md`;
-    const { dirname: dirname3 } = await import("path");
-    const { existsSync: existsSync13, mkdirSync: mkdirSync7, writeFileSync: writeFileSync6 } = await import("fs");
-    const outputDir = dirname3(outputPath);
-    if (!existsSync13(outputDir)) {
+    const { dirname: dirname5 } = await import("path");
+    const { existsSync: existsSync14, mkdirSync: mkdirSync7, writeFileSync: writeFileSync6 } = await import("fs");
+    const outputDir = dirname5(outputPath);
+    if (!existsSync14(outputDir)) {
       mkdirSync7(outputDir, { recursive: true });
     }
     writeFileSync6(outputPath, skillContent, "utf-8");
@@ -3823,10 +3823,10 @@ ${learning.title}
       console.log(chalk23.gray("Usage: skillkit memory import --input <path>"));
       return 1;
     }
-    const { existsSync: existsSync13, readFileSync: readFileSync7 } = await import("fs");
-    const { resolve: resolve12 } = await import("path");
-    const fullPath = resolve12(inputPath);
-    if (!existsSync13(fullPath)) {
+    const { existsSync: existsSync14, readFileSync: readFileSync7 } = await import("fs");
+    const { resolve: resolve16 } = await import("path");
+    const fullPath = resolve16(inputPath);
+    if (!existsSync14(fullPath)) {
       console.error(chalk23.red(`File not found: ${fullPath}`));
       return 1;
     }
@@ -4905,8 +4905,8 @@ var TeamCommand = class extends Command27 {
     }
     const projectPath = process.cwd();
     const bundlePath = join9(projectPath, ".skillkit", "bundles", `${this.name}.json`);
-    const { existsSync: existsSync13, readFileSync: readFileSync7, writeFileSync: writeFileSync6 } = await import("fs");
-    if (!existsSync13(bundlePath)) {
+    const { existsSync: existsSync14, readFileSync: readFileSync7, writeFileSync: writeFileSync6 } = await import("fs");
+    if (!existsSync14(bundlePath)) {
       this.context.stderr.write(chalk26.red(`Bundle "${this.name}" not found. Create it first with bundle-create.
 `));
       return 1;
@@ -4922,8 +4922,8 @@ var TeamCommand = class extends Command27 {
       this.context.stderr.write(chalk26.red("--source <path> is required for bundle-import\n"));
       return 1;
     }
-    const { existsSync: existsSync13 } = await import("fs");
-    if (!existsSync13(this.source)) {
+    const { existsSync: existsSync14 } = await import("fs");
+    if (!existsSync14(this.source)) {
       this.context.stderr.write(chalk26.red(`Bundle file not found: ${this.source}
 `));
       return 1;
@@ -5235,18 +5235,1985 @@ var PluginCommand = class extends Command28 {
     return 0;
   }
 };
+
+// src/commands/methodology.ts
+import { Command as Command29, Option as Option28 } from "clipanion";
+import chalk28 from "chalk";
+import { createMethodologyManager, createMethodologyLoader } from "@skillkit/core";
+var MethodologyCommand = class extends Command29 {
+  static paths = [["methodology"]];
+  static usage = Command29.Usage({
+    description: "Manage methodology packs for AI coding agents",
+    examples: [
+      ["List available packs", "$0 methodology list"],
+      ["Install all methodology packs", "$0 methodology install"],
+      ["Install specific pack", "$0 methodology install testing"],
+      ["Install specific skill", "$0 methodology install testing/red-green-refactor"],
+      ["Sync methodology skills to agents", "$0 methodology sync"],
+      ["Search methodology skills", "$0 methodology search tdd"],
+      ["Show pack details", "$0 methodology info testing"]
+    ]
+  });
+  action = Option28.String({ required: true });
+  target = Option28.String({ required: false });
+  agent = Option28.String("--agent,-a", { description: "Target agent for sync" });
+  dryRun = Option28.Boolean("--dry-run", { description: "Preview without making changes" });
+  verbose = Option28.Boolean("--verbose,-v", { description: "Show detailed output" });
+  async execute() {
+    const projectPath = process.cwd();
+    try {
+      switch (this.action) {
+        case "list":
+          return await this.listPacks();
+        case "install":
+          return await this.installPacks(projectPath);
+        case "uninstall":
+          return await this.uninstallPack(projectPath);
+        case "sync":
+          return await this.syncSkills(projectPath);
+        case "search":
+          return await this.searchSkills();
+        case "info":
+          return await this.showPackInfo();
+        case "installed":
+          return await this.listInstalled(projectPath);
+        default:
+          this.context.stderr.write(chalk28.red(`Unknown action: ${this.action}
+`));
+          this.context.stderr.write("Available actions: list, install, uninstall, sync, search, info, installed\n");
+          return 1;
+      }
+    } catch (err) {
+      this.context.stderr.write(chalk28.red(`\u2717 ${err instanceof Error ? err.message : "Unknown error"}
+`));
+      return 1;
+    }
+  }
+  async listPacks() {
+    const loader = createMethodologyLoader();
+    const packs = await loader.loadAllPacks();
+    if (packs.length === 0) {
+      this.context.stdout.write("No methodology packs available.\n");
+      return 0;
+    }
+    this.context.stdout.write(chalk28.cyan("Available Methodology Packs:\n\n"));
+    for (const pack of packs) {
+      this.context.stdout.write(chalk28.green(`  ${pack.name}`) + ` v${pack.version}
+`);
+      this.context.stdout.write(chalk28.gray(`    ${pack.description}
+`));
+      this.context.stdout.write(`    Skills: ${pack.skills.join(", ")}
+`);
+      this.context.stdout.write(`    Tags: ${pack.tags.join(", ")}
+`);
+      this.context.stdout.write("\n");
+    }
+    this.context.stdout.write(`Total: ${packs.length} packs
+`);
+    this.context.stdout.write(chalk28.gray("\nRun `skillkit methodology install` to install all packs.\n"));
+    return 0;
+  }
+  async installPacks(projectPath) {
+    const manager = createMethodologyManager({ projectPath });
+    const loader = manager.getLoader();
+    if (this.target) {
+      if (this.target.includes("/")) {
+        this.context.stdout.write(`Installing skill: ${chalk28.cyan(this.target)}...
+`);
+        if (this.dryRun) {
+          this.context.stdout.write(chalk28.yellow("[dry-run] Would install skill.\n"));
+          return 0;
+        }
+        const result = await manager.installSkill(this.target);
+        if (result.success) {
+          this.context.stdout.write(chalk28.green(`\u2713 Skill installed: ${this.target}
+`));
+        } else {
+          for (const failed of result.failed) {
+            this.context.stderr.write(chalk28.red(`\u2717 ${failed.name}: ${failed.error}
+`));
+          }
+          return 1;
+        }
+      } else {
+        this.context.stdout.write(`Installing pack: ${chalk28.cyan(this.target)}...
+`);
+        if (this.dryRun) {
+          const pack = await loader.loadPack(this.target);
+          if (pack) {
+            this.context.stdout.write(chalk28.yellow(`[dry-run] Would install ${pack.skills.length} skills.
+`));
+          }
+          return 0;
+        }
+        const result = await manager.installPack(this.target);
+        if (result.success) {
+          this.context.stdout.write(chalk28.green(`\u2713 Pack "${this.target}" installed!
+`));
+          this.context.stdout.write(`  Installed: ${result.installed.length} skills
+`);
+          if (result.skipped.length > 0) {
+            this.context.stdout.write(`  Skipped (already installed): ${result.skipped.length}
+`);
+          }
+        } else {
+          this.context.stderr.write(chalk28.red(`\u2717 Failed to install pack
+`));
+          for (const failed of result.failed) {
+            this.context.stderr.write(chalk28.red(`  - ${failed.name}: ${failed.error}
+`));
+          }
+          return 1;
+        }
+      }
+    } else {
+      this.context.stdout.write("Installing all methodology packs...\n\n");
+      if (this.dryRun) {
+        const packs = await loader.loadAllPacks();
+        let totalSkills = 0;
+        for (const pack of packs) {
+          this.context.stdout.write(chalk28.yellow(`[dry-run] Would install ${pack.name} (${pack.skills.length} skills)
+`));
+          totalSkills += pack.skills.length;
+        }
+        this.context.stdout.write(chalk28.yellow(`
+[dry-run] Would install ${totalSkills} skills total.
+`));
+        return 0;
+      }
+      const result = await manager.installAllPacks();
+      if (result.success) {
+        this.context.stdout.write(chalk28.green("\n\u2713 All methodology packs installed!\n"));
+        this.context.stdout.write(`  Installed: ${result.installed.length} skills
+`);
+        if (result.skipped.length > 0) {
+          this.context.stdout.write(`  Skipped (already installed): ${result.skipped.length}
+`);
+        }
+      } else {
+        this.context.stdout.write(chalk28.yellow("\n\u26A0 Some skills failed to install:\n"));
+        for (const failed of result.failed) {
+          this.context.stderr.write(chalk28.red(`  - ${failed.name}: ${failed.error}
+`));
+        }
+        this.context.stdout.write(`
+  Installed: ${result.installed.length} skills
+`);
+      }
+    }
+    this.context.stdout.write(chalk28.gray("\nRun `skillkit methodology sync` to sync to detected agents.\n"));
+    return 0;
+  }
+  async uninstallPack(projectPath) {
+    const manager = createMethodologyManager({ projectPath });
+    if (!this.target) {
+      this.context.stderr.write(chalk28.red("Pack name required for uninstall.\n"));
+      this.context.stderr.write("Usage: skillkit methodology uninstall <pack-name>\n");
+      return 1;
+    }
+    if (this.dryRun) {
+      this.context.stdout.write(chalk28.yellow(`[dry-run] Would uninstall pack: ${this.target}
+`));
+      return 0;
+    }
+    await manager.uninstallPack(this.target);
+    this.context.stdout.write(chalk28.green(`\u2713 Pack "${this.target}" uninstalled.
+`));
+    return 0;
+  }
+  async syncSkills(projectPath) {
+    const manager = createMethodologyManager({ projectPath, autoSync: false });
+    this.context.stdout.write("Syncing methodology skills to detected agents...\n\n");
+    if (this.dryRun) {
+      const installed = manager.listInstalledSkills();
+      this.context.stdout.write(chalk28.yellow(`[dry-run] Would sync ${installed.length} skills.
+`));
+      return 0;
+    }
+    const result = await manager.syncAll();
+    if (result.synced.length > 0) {
+      this.context.stdout.write(chalk28.green("\u2713 Sync complete!\n"));
+      for (const sync of result.synced) {
+        this.context.stdout.write(`  ${sync.skill} \u2192 ${sync.agents.join(", ")}
+`);
+      }
+    }
+    if (result.failed.length > 0) {
+      this.context.stdout.write(chalk28.yellow("\n\u26A0 Some syncs failed:\n"));
+      for (const fail of result.failed) {
+        this.context.stderr.write(chalk28.red(`  ${fail.skill} (${fail.agent}): ${fail.error}
+`));
+      }
+    }
+    if (result.synced.length === 0 && result.failed.length === 0) {
+      this.context.stdout.write("No installed skills to sync. Run `skillkit methodology install` first.\n");
+    }
+    return result.success ? 0 : 1;
+  }
+  async searchSkills() {
+    const loader = createMethodologyLoader();
+    if (!this.target) {
+      this.context.stderr.write(chalk28.red("Search query required.\n"));
+      this.context.stderr.write("Usage: skillkit methodology search <query>\n");
+      return 1;
+    }
+    const skills = await loader.searchSkills(this.target);
+    if (skills.length === 0) {
+      this.context.stdout.write(`No skills found matching "${this.target}".
+`);
+      return 0;
+    }
+    this.context.stdout.write(chalk28.cyan(`Found ${skills.length} skills matching "${this.target}":
+
+`));
+    for (const skill of skills) {
+      this.context.stdout.write(chalk28.green(`  ${skill.id}`) + ` v${skill.version}
+`);
+      this.context.stdout.write(chalk28.gray(`    ${skill.description || "No description"}
+`));
+      if (skill.tags.length > 0) {
+        this.context.stdout.write(`    Tags: ${skill.tags.join(", ")}
+`);
+      }
+      if (this.verbose && skill.metadata.triggers) {
+        this.context.stdout.write(`    Triggers: ${skill.metadata.triggers.join(", ")}
+`);
+      }
+      this.context.stdout.write("\n");
+    }
+    return 0;
+  }
+  async showPackInfo() {
+    const loader = createMethodologyLoader();
+    if (!this.target) {
+      this.context.stderr.write(chalk28.red("Pack name required.\n"));
+      this.context.stderr.write("Usage: skillkit methodology info <pack-name>\n");
+      return 1;
+    }
+    const pack = await loader.loadPack(this.target);
+    if (!pack) {
+      this.context.stderr.write(chalk28.red(`Pack not found: ${this.target}
+`));
+      return 1;
+    }
+    this.context.stdout.write(chalk28.cyan(`
+Pack: ${pack.name}
+`));
+    this.context.stdout.write(`Version: ${pack.version}
+`);
+    this.context.stdout.write(`Description: ${pack.description}
+`);
+    this.context.stdout.write(`Tags: ${pack.tags.join(", ")}
+`);
+    this.context.stdout.write(`Author: ${pack.author || "Unknown"}
+`);
+    this.context.stdout.write(`License: ${pack.license || "Unknown"}
+`);
+    this.context.stdout.write(`Compatibility: ${pack.compatibility.join(", ")}
+`);
+    this.context.stdout.write(chalk28.cyan(`
+Skills (${pack.skills.length}):
+`));
+    const skills = await loader.loadPackSkills(this.target);
+    for (const skill of skills) {
+      this.context.stdout.write(chalk28.green(`  ${skill.id.split("/")[1]}
+`));
+      this.context.stdout.write(chalk28.gray(`    ${skill.description || "No description"}
+`));
+      if (this.verbose) {
+        if (skill.metadata.triggers) {
+          this.context.stdout.write(`    Triggers: ${skill.metadata.triggers.join(", ")}
+`);
+        }
+        if (skill.metadata.difficulty) {
+          this.context.stdout.write(`    Difficulty: ${skill.metadata.difficulty}
+`);
+        }
+        if (skill.metadata.estimatedTime) {
+          this.context.stdout.write(`    Est. Time: ${skill.metadata.estimatedTime} min
+`);
+        }
+      }
+    }
+    this.context.stdout.write(chalk28.gray(`
+Run \`skillkit methodology install ${this.target}\` to install this pack.
+`));
+    return 0;
+  }
+  async listInstalled(projectPath) {
+    const manager = createMethodologyManager({ projectPath });
+    const installedPacks = manager.listInstalledPacks();
+    const installedSkills = manager.listInstalledSkills();
+    if (installedPacks.length === 0 && installedSkills.length === 0) {
+      this.context.stdout.write("No methodology skills installed.\n");
+      this.context.stdout.write(chalk28.gray("Run `skillkit methodology install` to install methodology packs.\n"));
+      return 0;
+    }
+    if (installedPacks.length > 0) {
+      this.context.stdout.write(chalk28.cyan("Installed Packs:\n"));
+      for (const pack of installedPacks) {
+        this.context.stdout.write(chalk28.green(`  ${pack.name}`) + ` v${pack.version}
+`);
+        this.context.stdout.write(`    Skills: ${pack.skills.length}
+`);
+      }
+      this.context.stdout.write("\n");
+    }
+    if (installedSkills.length > 0) {
+      this.context.stdout.write(chalk28.cyan("Installed Skills:\n"));
+      for (const skill of installedSkills) {
+        const syncStatus = skill.syncedAgents.length > 0 ? chalk28.green(`synced to ${skill.syncedAgents.length} agents`) : chalk28.yellow("not synced");
+        this.context.stdout.write(`  ${chalk28.green(skill.id)} v${skill.version} [${syncStatus}]
+`);
+      }
+    }
+    this.context.stdout.write(chalk28.gray(`
+Total: ${installedSkills.length} skills installed.
+`));
+    return 0;
+  }
+};
+
+// src/commands/hook.ts
+import { Command as Command30, Option as Option29 } from "clipanion";
+import chalk29 from "chalk";
+import { createHookManager } from "@skillkit/core";
+var HookCommand = class extends Command30 {
+  static paths = [["hook"]];
+  static usage = Command30.Usage({
+    description: "Manage skill hooks for automatic triggering",
+    examples: [
+      ["List all hooks", "$0 hook list"],
+      ["Add a session start hook", "$0 hook add session:start tdd-workflow"],
+      ["Add a file save hook with pattern", '$0 hook add file:save code-review --pattern "*.ts"'],
+      ["Remove a hook", "$0 hook remove <hook-id>"],
+      ["Enable a hook", "$0 hook enable <hook-id>"],
+      ["Disable a hook", "$0 hook disable <hook-id>"],
+      ["Generate agent hooks", "$0 hook generate --agent claude-code"]
+    ]
+  });
+  action = Option29.String({ required: true });
+  target = Option29.String({ required: false });
+  skill = Option29.String({ required: false });
+  pattern = Option29.String("--pattern,-p", { description: "File pattern matcher" });
+  agent = Option29.String("--agent,-a", { description: "Target agent for generation" });
+  inject = Option29.String("--inject,-i", { description: "Injection mode: content, reference, prompt" });
+  priority = Option29.String("--priority", { description: "Hook priority (higher = earlier)" });
+  verbose = Option29.Boolean("--verbose,-v", { description: "Show detailed output" });
+  async execute() {
+    const projectPath = process.cwd();
+    try {
+      switch (this.action) {
+        case "list":
+          return await this.listHooks(projectPath);
+        case "add":
+          return await this.addHook(projectPath);
+        case "remove":
+          return await this.removeHook(projectPath);
+        case "enable":
+          return await this.enableHook(projectPath);
+        case "disable":
+          return await this.disableHook(projectPath);
+        case "generate":
+          return await this.generateHooks(projectPath);
+        case "info":
+          return await this.showHookInfo(projectPath);
+        default:
+          this.context.stderr.write(chalk29.red(`Unknown action: ${this.action}
+`));
+          this.context.stderr.write("Available actions: list, add, remove, enable, disable, generate, info\n");
+          return 1;
+      }
+    } catch (err) {
+      this.context.stderr.write(chalk29.red(`\u2717 ${err instanceof Error ? err.message : "Unknown error"}
+`));
+      return 1;
+    }
+  }
+  async listHooks(projectPath) {
+    const manager = createHookManager({ projectPath });
+    const hooks = manager.getAllHooks();
+    if (hooks.length === 0) {
+      this.context.stdout.write("No hooks configured.\n");
+      this.context.stdout.write(chalk29.gray("Run `skillkit hook add <event> <skill>` to add a hook.\n"));
+      return 0;
+    }
+    this.context.stdout.write(chalk29.cyan("Configured Hooks:\n\n"));
+    const eventGroups = /* @__PURE__ */ new Map();
+    for (const hook of hooks) {
+      const group = eventGroups.get(hook.event) || [];
+      group.push(hook);
+      eventGroups.set(hook.event, group);
+    }
+    for (const [event, eventHooks] of eventGroups) {
+      this.context.stdout.write(chalk29.yellow(`${event}:
+`));
+      for (const hook of eventHooks) {
+        const status = hook.enabled ? chalk29.green("\u25CF") : chalk29.gray("\u25CB");
+        this.context.stdout.write(`  ${status} ${chalk29.white(hook.id.slice(0, 8))} \u2192 ${hook.skills.join(", ")}
+`);
+        if (hook.matcher) {
+          this.context.stdout.write(chalk29.gray(`    Pattern: ${hook.matcher}
+`));
+        }
+        if (this.verbose) {
+          this.context.stdout.write(chalk29.gray(`    Inject: ${hook.inject}, Priority: ${hook.priority || 0}
+`));
+        }
+      }
+    }
+    this.context.stdout.write(`
+Total: ${hooks.length} hooks
+`);
+    return 0;
+  }
+  async addHook(projectPath) {
+    if (!this.target) {
+      this.context.stderr.write(chalk29.red("Event type required.\n"));
+      this.context.stderr.write("Usage: skillkit hook add <event> <skill>\n");
+      this.context.stderr.write("Events: session:start, session:end, file:save, file:open, task:start, commit:pre, commit:post, error:occur, test:fail, build:fail\n");
+      return 1;
+    }
+    if (!this.skill) {
+      this.context.stderr.write(chalk29.red("Skill name required.\n"));
+      this.context.stderr.write("Usage: skillkit hook add <event> <skill>\n");
+      return 1;
+    }
+    const event = this.target;
+    const validEvents = [
+      "session:start",
+      "session:resume",
+      "session:end",
+      "file:open",
+      "file:save",
+      "file:create",
+      "file:delete",
+      "task:start",
+      "task:complete",
+      "commit:pre",
+      "commit:post",
+      "error:occur",
+      "test:fail",
+      "test:pass",
+      "build:start",
+      "build:fail",
+      "build:success"
+    ];
+    if (!validEvents.includes(event)) {
+      this.context.stderr.write(chalk29.red(`Invalid event: ${this.target}
+`));
+      this.context.stderr.write(`Valid events: ${validEvents.join(", ")}
+`);
+      return 1;
+    }
+    const manager = createHookManager({ projectPath });
+    const hook = manager.registerHook({
+      event,
+      skills: [this.skill],
+      inject: this.inject || "reference",
+      matcher: this.pattern,
+      priority: this.priority ? parseInt(this.priority, 10) : 0,
+      enabled: true
+    });
+    manager.save();
+    this.context.stdout.write(chalk29.green(`\u2713 Hook added: ${hook.id.slice(0, 8)}
+`));
+    this.context.stdout.write(`  Event: ${event}
+`);
+    this.context.stdout.write(`  Skill: ${this.skill}
+`);
+    if (this.pattern) {
+      this.context.stdout.write(`  Pattern: ${this.pattern}
+`);
+    }
+    return 0;
+  }
+  async removeHook(projectPath) {
+    if (!this.target) {
+      this.context.stderr.write(chalk29.red("Hook ID required.\n"));
+      this.context.stderr.write("Usage: skillkit hook remove <hook-id>\n");
+      return 1;
+    }
+    const manager = createHookManager({ projectPath });
+    const hooks = manager.getAllHooks();
+    const hook = hooks.find((h) => h.id.startsWith(this.target));
+    if (!hook) {
+      this.context.stderr.write(chalk29.red(`Hook not found: ${this.target}
+`));
+      return 1;
+    }
+    manager.unregisterHook(hook.id);
+    manager.save();
+    this.context.stdout.write(chalk29.green(`\u2713 Hook removed: ${hook.id.slice(0, 8)}
+`));
+    return 0;
+  }
+  async enableHook(projectPath) {
+    if (!this.target) {
+      this.context.stderr.write(chalk29.red("Hook ID required.\n"));
+      return 1;
+    }
+    const manager = createHookManager({ projectPath });
+    const hooks = manager.getAllHooks();
+    const hook = hooks.find((h) => h.id.startsWith(this.target));
+    if (!hook) {
+      this.context.stderr.write(chalk29.red(`Hook not found: ${this.target}
+`));
+      return 1;
+    }
+    manager.enableHook(hook.id);
+    manager.save();
+    this.context.stdout.write(chalk29.green(`\u2713 Hook enabled: ${hook.id.slice(0, 8)}
+`));
+    return 0;
+  }
+  async disableHook(projectPath) {
+    if (!this.target) {
+      this.context.stderr.write(chalk29.red("Hook ID required.\n"));
+      return 1;
+    }
+    const manager = createHookManager({ projectPath });
+    const hooks = manager.getAllHooks();
+    const hook = hooks.find((h) => h.id.startsWith(this.target));
+    if (!hook) {
+      this.context.stderr.write(chalk29.red(`Hook not found: ${this.target}
+`));
+      return 1;
+    }
+    manager.disableHook(hook.id);
+    manager.save();
+    this.context.stdout.write(chalk29.yellow(`\u25CB Hook disabled: ${hook.id.slice(0, 8)}
+`));
+    return 0;
+  }
+  async generateHooks(projectPath) {
+    const manager = createHookManager({ projectPath });
+    const hooks = manager.getAllHooks();
+    if (hooks.length === 0) {
+      this.context.stdout.write("No hooks configured to generate.\n");
+      return 0;
+    }
+    const agent = this.agent || "claude-code";
+    const generated = manager.generateAgentHooks(agent);
+    this.context.stdout.write(chalk29.cyan(`Generated hooks for ${agent}:
+
+`));
+    if (typeof generated === "string") {
+      this.context.stdout.write(generated);
+    } else {
+      this.context.stdout.write(JSON.stringify(generated, null, 2));
+    }
+    this.context.stdout.write("\n");
+    return 0;
+  }
+  async showHookInfo(projectPath) {
+    if (!this.target) {
+      this.context.stderr.write(chalk29.red("Hook ID required.\n"));
+      return 1;
+    }
+    const manager = createHookManager({ projectPath });
+    const hooks = manager.getAllHooks();
+    const hook = hooks.find((h) => h.id.startsWith(this.target));
+    if (!hook) {
+      this.context.stderr.write(chalk29.red(`Hook not found: ${this.target}
+`));
+      return 1;
+    }
+    this.context.stdout.write(chalk29.cyan(`
+Hook: ${hook.id}
+`));
+    this.context.stdout.write(`Event: ${hook.event}
+`);
+    this.context.stdout.write(`Skills: ${hook.skills.join(", ")}
+`);
+    this.context.stdout.write(`Enabled: ${hook.enabled ? "Yes" : "No"}
+`);
+    this.context.stdout.write(`Inject: ${hook.inject}
+`);
+    this.context.stdout.write(`Priority: ${hook.priority || 0}
+`);
+    if (hook.matcher) {
+      this.context.stdout.write(`Pattern: ${hook.matcher}
+`);
+    }
+    if (hook.condition) {
+      this.context.stdout.write(`Condition: ${hook.condition}
+`);
+    }
+    if (hook.agentOverrides) {
+      this.context.stdout.write(`Agent Overrides: ${Object.keys(hook.agentOverrides).join(", ")}
+`);
+    }
+    return 0;
+  }
+};
+
+// src/commands/plan.ts
+import { Command as Command31, Option as Option30 } from "clipanion";
+import { readFile, writeFile } from "fs/promises";
+import { resolve as resolve12 } from "path";
+import {
+  createPlanParser,
+  createPlanValidator,
+  createPlanGenerator,
+  createPlanExecutor,
+  dryRunExecutor,
+  shellExecutor,
+  TASK_TEMPLATES
+} from "@skillkit/core";
+var PlanCommand = class extends Command31 {
+  static paths = [["plan"]];
+  static usage = Command31.Usage({
+    category: "Development",
+    description: "Manage structured development plans",
+    details: `
+      This command provides tools for working with structured development plans.
+
+      Actions:
+      - parse:    Parse a markdown plan to structured format
+      - validate: Validate a plan for completeness
+      - execute:  Execute a plan (with optional dry-run)
+      - generate: Generate a plan from task list
+      - templates: List available task templates
+      - create:   Create a new empty plan
+
+      Examples:
+        $ skillkit plan parse ./plan.md
+        $ skillkit plan validate ./plan.md
+        $ skillkit plan execute ./plan.md --dry-run
+        $ skillkit plan generate "Add auth" --tasks "Setup,Login,Logout"
+        $ skillkit plan templates
+    `,
+    examples: [
+      ["Parse a markdown plan", "$0 plan parse ./development-plan.md"],
+      ["Validate a plan", "$0 plan validate ./plan.md --strict"],
+      ["Dry-run execute a plan", "$0 plan execute ./plan.md --dry-run"],
+      ["List task templates", "$0 plan templates"]
+    ]
+  });
+  action = Option30.String({ required: true });
+  file = Option30.String("--file,-f", {
+    description: "Plan file path"
+  });
+  output = Option30.String("--output,-o", {
+    description: "Output file path"
+  });
+  name = Option30.String("--name,-n", {
+    description: "Plan name"
+  });
+  goal = Option30.String("--goal,-g", {
+    description: "Plan goal"
+  });
+  tasks = Option30.String("--tasks,-t", {
+    description: "Comma-separated list of task names"
+  });
+  template = Option30.String("--template", {
+    description: "Task template to use"
+  });
+  techStack = Option30.String("--tech-stack", {
+    description: "Comma-separated tech stack"
+  });
+  dryRun = Option30.Boolean("--dry-run", false, {
+    description: "Dry run execution (no actual changes)"
+  });
+  strict = Option30.Boolean("--strict", false, {
+    description: "Strict validation (treat warnings as errors)"
+  });
+  stopOnError = Option30.Boolean("--stop-on-error", true, {
+    description: "Stop execution on first error"
+  });
+  verbose = Option30.Boolean("--verbose,-v", false, {
+    description: "Verbose output"
+  });
+  json = Option30.Boolean("--json", false, {
+    description: "Output as JSON"
+  });
+  async execute() {
+    try {
+      switch (this.action) {
+        case "parse":
+          return await this.parsePlan();
+        case "validate":
+          return await this.validatePlan();
+        case "execute":
+          return await this.executePlan();
+        case "generate":
+          return await this.generatePlan();
+        case "templates":
+          return await this.listTemplates();
+        case "create":
+          return await this.createPlan();
+        default:
+          this.context.stderr.write(
+            `Unknown action: ${this.action}
+Available actions: parse, validate, execute, generate, templates, create
+`
+          );
+          return 1;
+      }
+    } catch (error) {
+      this.context.stderr.write(`Error: ${error.message}
+`);
+      return 1;
+    }
+  }
+  async parsePlan() {
+    if (!this.file) {
+      this.context.stderr.write("Error: --file is required for parse action\n");
+      return 1;
+    }
+    const filePath = resolve12(this.file);
+    const content = await readFile(filePath, "utf-8");
+    const parser = createPlanParser();
+    const plan = parser.parse(content);
+    if (this.json) {
+      this.context.stdout.write(JSON.stringify(plan, null, 2) + "\n");
+    } else {
+      this.context.stdout.write(`Plan: ${plan.name}
+`);
+      this.context.stdout.write(`Goal: ${plan.goal}
+`);
+      this.context.stdout.write(`Status: ${plan.status}
+`);
+      this.context.stdout.write(`Tasks: ${plan.tasks.length}
+
+`);
+      for (const task of plan.tasks) {
+        this.context.stdout.write(`  Task ${task.id}: ${task.name}
+`);
+        this.context.stdout.write(`    Steps: ${task.steps.length}
+`);
+        if (task.estimatedMinutes) {
+          this.context.stdout.write(`    Estimated: ${task.estimatedMinutes} min
+`);
+        }
+      }
+    }
+    if (this.output) {
+      const outputPath = resolve12(this.output);
+      await writeFile(outputPath, JSON.stringify(plan, null, 2));
+      this.context.stdout.write(`
+Saved to: ${outputPath}
+`);
+    }
+    return 0;
+  }
+  async validatePlan() {
+    if (!this.file) {
+      this.context.stderr.write("Error: --file is required for validate action\n");
+      return 1;
+    }
+    const filePath = resolve12(this.file);
+    const content = await readFile(filePath, "utf-8");
+    const parser = createPlanParser();
+    const plan = parser.parse(content);
+    const validator = createPlanValidator({ strict: this.strict });
+    const result = validator.validate(plan);
+    if (this.json) {
+      this.context.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    } else {
+      this.context.stdout.write(`Validation: ${result.valid ? "PASSED" : "FAILED"}
+
+`);
+      this.context.stdout.write(`Statistics:
+`);
+      this.context.stdout.write(`  Total tasks: ${result.stats.totalTasks}
+`);
+      this.context.stdout.write(`  Total steps: ${result.stats.totalSteps}
+`);
+      this.context.stdout.write(`  Estimated time: ${result.stats.estimatedMinutes} minutes
+`);
+      this.context.stdout.write(`  Tasks with tests: ${result.stats.tasksWithTests}
+`);
+      this.context.stdout.write(`  Avg steps/task: ${result.stats.avgStepsPerTask}
+
+`);
+      if (result.issues.length > 0) {
+        this.context.stdout.write(`Issues:
+`);
+        for (const issue of result.issues) {
+          const icon = issue.type === "error" ? "\u274C" : issue.type === "warning" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
+          const location = issue.taskId ? `Task ${issue.taskId}` : "Plan";
+          this.context.stdout.write(`  ${icon} [${location}] ${issue.message}
+`);
+          if (issue.suggestion && this.verbose) {
+            this.context.stdout.write(`     Suggestion: ${issue.suggestion}
+`);
+          }
+        }
+      } else {
+        this.context.stdout.write("No issues found.\n");
+      }
+    }
+    return result.valid ? 0 : 1;
+  }
+  async executePlan() {
+    if (!this.file) {
+      this.context.stderr.write("Error: --file is required for execute action\n");
+      return 1;
+    }
+    const filePath = resolve12(this.file);
+    const content = await readFile(filePath, "utf-8");
+    const parser = createPlanParser();
+    const plan = parser.parse(content);
+    const validator = createPlanValidator({ strict: this.strict });
+    const validation = validator.validate(plan);
+    if (!validation.valid) {
+      this.context.stderr.write("Plan validation failed. Fix errors before executing.\n");
+      for (const issue of validation.issues.filter((i) => i.type === "error")) {
+        this.context.stderr.write(`  \u274C ${issue.message}
+`);
+      }
+      return 1;
+    }
+    const executor = createPlanExecutor({
+      stepExecutor: this.dryRun ? dryRunExecutor : shellExecutor
+    });
+    executor.addListener((event, _plan, task) => {
+      if (this.verbose) {
+        if (event === "plan:task_started" && task) {
+          this.context.stdout.write(`Starting task ${task.id}: ${task.name}
+`);
+        } else if (event === "plan:task_completed" && task) {
+          this.context.stdout.write(`Completed task ${task.id}: ${task.name}
+`);
+        } else if (event === "plan:task_failed" && task) {
+          this.context.stderr.write(`Failed task ${task.id}: ${task.name}
+`);
+        }
+      }
+    });
+    this.context.stdout.write(`Executing plan: ${plan.name}
+`);
+    if (this.dryRun) {
+      this.context.stdout.write("(Dry run mode - no actual changes)\n");
+    }
+    this.context.stdout.write("\n");
+    const result = await executor.execute(plan, {
+      dryRun: this.dryRun,
+      stopOnError: this.stopOnError,
+      onProgress: (taskId, step, status) => {
+        if (this.verbose) {
+          this.context.stdout.write(`  Task ${taskId}, Step ${step}: ${status}
+`);
+        }
+      }
+    });
+    this.context.stdout.write("\n");
+    if (this.json) {
+      this.context.stdout.write(
+        JSON.stringify(
+          {
+            ...result,
+            taskResults: Object.fromEntries(result.taskResults)
+          },
+          null,
+          2
+        ) + "\n"
+      );
+    } else {
+      this.context.stdout.write(`Execution: ${result.success ? "SUCCESS" : "FAILED"}
+`);
+      this.context.stdout.write(`Duration: ${result.durationMs}ms
+`);
+      this.context.stdout.write(`Completed: ${result.completedTasks.length} tasks
+`);
+      this.context.stdout.write(`Failed: ${result.failedTasks.length} tasks
+`);
+      this.context.stdout.write(`Skipped: ${result.skippedTasks.length} tasks
+`);
+      if (result.errors && result.errors.length > 0) {
+        this.context.stdout.write("\nErrors:\n");
+        for (const error of result.errors) {
+          this.context.stderr.write(`  - ${error}
+`);
+        }
+      }
+    }
+    return result.success ? 0 : 1;
+  }
+  async generatePlan() {
+    if (!this.name) {
+      this.context.stderr.write("Error: --name is required for generate action\n");
+      return 1;
+    }
+    const generator = createPlanGenerator({
+      includeTests: true,
+      includeCommits: true,
+      techStack: this.techStack?.split(",").map((s) => s.trim()).filter((s) => s !== "")
+    });
+    let plan;
+    if (this.tasks) {
+      const taskNames = this.tasks.split(",").map((s) => s.trim()).filter((s) => s !== "");
+      plan = generator.fromTaskList(this.name, this.goal || "Complete the tasks", taskNames, {
+        template: this.template,
+        techStack: this.techStack?.split(",").map((s) => s.trim()).filter((s) => s !== "")
+      });
+    } else {
+      plan = generator.createPlan(this.name, this.goal || "Complete the project");
+      if (this.techStack) {
+        plan.techStack = this.techStack.split(",").map((s) => s.trim()).filter((s) => s !== "");
+      }
+    }
+    const markdown = generator.toMarkdown(plan);
+    if (this.output) {
+      const outputPath = resolve12(this.output);
+      await writeFile(outputPath, markdown);
+      this.context.stdout.write(`Plan saved to: ${outputPath}
+`);
+    } else if (this.json) {
+      this.context.stdout.write(JSON.stringify(plan, null, 2) + "\n");
+    } else {
+      this.context.stdout.write(markdown);
+    }
+    return 0;
+  }
+  async listTemplates() {
+    if (this.json) {
+      this.context.stdout.write(JSON.stringify(TASK_TEMPLATES, null, 2) + "\n");
+    } else {
+      this.context.stdout.write("Available Task Templates:\n\n");
+      for (const [name, template] of Object.entries(TASK_TEMPLATES)) {
+        this.context.stdout.write(`  ${name}
+`);
+        this.context.stdout.write(`    ${template.description}
+`);
+        this.context.stdout.write(`    Steps: ${template.steps.length}
+`);
+        this.context.stdout.write(`    Estimated: ${template.estimatedMinutes} min
+
+`);
+      }
+    }
+    return 0;
+  }
+  async createPlan() {
+    if (!this.name) {
+      this.context.stderr.write("Error: --name is required for create action\n");
+      return 1;
+    }
+    const generator = createPlanGenerator({
+      includeTests: true,
+      includeCommits: true
+    });
+    const plan = generator.createPlan(this.name, this.goal || "Complete the project");
+    if (this.techStack) {
+      plan.techStack = this.techStack.split(",").map((s) => s.trim()).filter((s) => s !== "");
+    }
+    const markdown = generator.toMarkdown(plan);
+    const outputPath = this.output || resolve12(`${this.name.toLowerCase().replace(/\s+/g, "-")}-plan.md`);
+    await writeFile(outputPath, markdown);
+    this.context.stdout.write(`Plan created: ${outputPath}
+`);
+    return 0;
+  }
+};
+
+// src/commands/command.ts
+import { Command as Command32, Option as Option31 } from "clipanion";
+import { readFile as readFile2, writeFile as writeFile2, mkdir } from "fs/promises";
+import { resolve as resolve13, join as join11, dirname as dirname3, extname } from "path";
+import * as path from "path";
+import * as fs from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import {
+  createCommandRegistry,
+  createCommandGenerator,
+  getAgentFormat,
+  supportsSlashCommands
+} from "@skillkit/core";
+var CommandCmd = class extends Command32 {
+  static paths = [["command"]];
+  static usage = Command32.Usage({
+    category: "Commands",
+    description: "Manage slash commands and agent integration",
+    details: `
+      This command provides tools for working with slash commands.
+
+      Actions:
+      - list:     List registered commands
+      - create:   Create a new command from a skill
+      - generate: Generate agent-specific command files
+      - validate: Validate command definitions
+      - export:   Export commands to a bundle
+      - import:   Import commands from a bundle
+
+      Examples:
+        $ skillkit command list
+        $ skillkit command create my-skill --name my-command
+        $ skillkit command generate --agent claude-code
+        $ skillkit command validate ./commands.json
+    `,
+    examples: [
+      ["List all commands", "$0 command list"],
+      ["Create command from skill", "$0 command create tdd --name run-tdd"],
+      ["Generate for Claude Code", "$0 command generate --agent claude-code"],
+      ["Export commands", "$0 command export --output commands.json"]
+    ]
+  });
+  action = Option31.String({ required: true });
+  skill = Option31.String("--skill,-s", {
+    description: "Skill to create command from"
+  });
+  name = Option31.String("--name,-n", {
+    description: "Command name"
+  });
+  description = Option31.String("--description,-d", {
+    description: "Command description"
+  });
+  agent = Option31.String("--agent,-a", {
+    description: "Target agent for generation"
+  });
+  output = Option31.String("--output,-o", {
+    description: "Output file or directory"
+  });
+  input = Option31.String("--input,-i", {
+    description: "Input file"
+  });
+  category = Option31.String("--category,-c", {
+    description: "Command category"
+  });
+  all = Option31.Boolean("--all", false, {
+    description: "Include all commands (hidden and disabled)"
+  });
+  json = Option31.Boolean("--json", false, {
+    description: "Output as JSON"
+  });
+  dryRun = Option31.Boolean("--dry-run", false, {
+    description: "Show what would be generated without writing files"
+  });
+  async execute() {
+    try {
+      switch (this.action) {
+        case "list":
+          return await this.listCommands();
+        case "create":
+          return await this.createCommand();
+        case "generate":
+          return await this.generateCommands();
+        case "validate":
+          return await this.validateCommands();
+        case "export":
+          return await this.exportCommands();
+        case "import":
+          return await this.importCommands();
+        case "info":
+          return await this.showInfo();
+        default:
+          this.context.stderr.write(
+            `Unknown action: ${this.action}
+Available actions: list, create, generate, validate, export, import, info
+`
+          );
+          return 1;
+      }
+    } catch (error) {
+      this.context.stderr.write(`Error: ${error.message}
+`);
+      return 1;
+    }
+  }
+  async listCommands() {
+    const registry = createCommandRegistry();
+    await this.loadCommandsFromConfig(registry);
+    const commands = registry.search({
+      category: this.category,
+      includeHidden: this.all,
+      includeDisabled: this.all
+    });
+    if (this.json) {
+      this.context.stdout.write(JSON.stringify(commands, null, 2) + "\n");
+    } else {
+      if (commands.length === 0) {
+        this.context.stdout.write("No commands registered.\n");
+        this.context.stdout.write('Use "skillkit command create" to create commands from skills.\n');
+        return 0;
+      }
+      this.context.stdout.write(`Registered Commands (${commands.length}):
+
+`);
+      const categories = /* @__PURE__ */ new Map();
+      for (const cmd of commands) {
+        const cat = cmd.category || "uncategorized";
+        if (!categories.has(cat)) {
+          categories.set(cat, []);
+        }
+        categories.get(cat).push(cmd);
+      }
+      for (const [category, cmds] of categories) {
+        this.context.stdout.write(`  ${category.toUpperCase()}
+`);
+        for (const cmd of cmds) {
+          const status = cmd.enabled ? "" : " (disabled)";
+          const hidden = cmd.hidden ? " (hidden)" : "";
+          this.context.stdout.write(`    /${cmd.name}${status}${hidden}
+`);
+          this.context.stdout.write(`      ${cmd.description}
+`);
+          if (cmd.aliases && cmd.aliases.length > 0) {
+            this.context.stdout.write(`      Aliases: ${cmd.aliases.join(", ")}
+`);
+          }
+        }
+        this.context.stdout.write("\n");
+      }
+    }
+    return 0;
+  }
+  async createCommand() {
+    if (!this.skill) {
+      this.context.stderr.write("Error: --skill is required for create action\n");
+      return 1;
+    }
+    const commandName = this.name || this.skill.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    const command = {
+      name: commandName,
+      description: this.description || `Execute ${this.skill} skill`,
+      skill: this.skill,
+      category: this.category,
+      examples: [`/${commandName}`]
+    };
+    const configPath = resolve13(process.cwd(), ".skillkit", "commands.json");
+    let commands = [];
+    if (existsSync13(configPath)) {
+      const content = await readFile2(configPath, "utf-8");
+      const config = JSON.parse(content);
+      commands = config.commands || [];
+    }
+    const existing = commands.findIndex((c) => c.name === commandName);
+    if (existing >= 0) {
+      const previous = commands[existing];
+      commands[existing] = {
+        ...previous,
+        name: commandName,
+        skill: this.skill,
+        description: this.description ?? previous.description ?? command.description,
+        category: this.category ?? previous.category,
+        examples: command.examples?.length ? command.examples : previous.examples,
+        // Preserve existing metadata if not provided
+        aliases: previous.aliases,
+        args: previous.args,
+        tags: previous.tags,
+        hidden: previous.hidden,
+        metadata: previous.metadata
+      };
+      this.context.stdout.write(`Updated command: /${commandName}
+`);
+    } else {
+      commands.push(command);
+      this.context.stdout.write(`Created command: /${commandName}
+`);
+    }
+    await mkdir(dirname3(configPath), { recursive: true });
+    await writeFile2(
+      configPath,
+      JSON.stringify({ version: "1.0.0", commands }, null, 2)
+    );
+    this.context.stdout.write(`Saved to: ${configPath}
+`);
+    return 0;
+  }
+  async generateCommands() {
+    const agent = this.agent || "claude-code";
+    if (!supportsSlashCommands(agent)) {
+      this.context.stdout.write(`Note: ${agent} has limited slash command support.
+`);
+    }
+    const registry = createCommandRegistry();
+    await this.loadCommandsFromConfig(registry);
+    const commands = registry.getAll(this.all);
+    if (commands.length === 0) {
+      this.context.stderr.write("No commands to generate. Create commands first.\n");
+      return 1;
+    }
+    const generator = createCommandGenerator({
+      includeHidden: this.all,
+      includeDisabled: this.all
+    });
+    const format = getAgentFormat(agent);
+    const outputTarget = this.output ? resolve13(this.output) : resolve13(process.cwd(), format.directory);
+    const outputDir = extname(outputTarget) ? dirname3(outputTarget) : outputTarget;
+    const result = generator.generate(commands, agent);
+    if (typeof result === "string") {
+      const extension = format.extension ? format.extension.startsWith(".") ? format.extension : `.${format.extension}` : ".mdc";
+      const filePath = extname(outputTarget) ? outputTarget : join11(outputTarget, `commands${extension}`);
+      if (this.dryRun) {
+        this.context.stdout.write("Would write to: " + filePath + "\n\n");
+        this.context.stdout.write(result);
+      } else {
+        await mkdir(dirname3(filePath), { recursive: true });
+        await writeFile2(filePath, result);
+        this.context.stdout.write(`Generated: ${filePath}
+`);
+      }
+    } else {
+      if (extname(outputTarget)) {
+        this.context.stderr.write(
+          "Error: --output must be a directory for multi-file formats\n"
+        );
+        return 1;
+      }
+      if (this.dryRun) {
+        this.context.stdout.write("Would write to: " + outputDir + "\n\n");
+        for (const [filename, content] of result) {
+          this.context.stdout.write(`--- ${filename} ---
+`);
+          this.context.stdout.write(content.substring(0, 500));
+          if (content.length > 500) {
+            this.context.stdout.write("\n... (truncated)\n");
+          }
+          this.context.stdout.write("\n");
+        }
+      } else {
+        await mkdir(outputDir, { recursive: true });
+        for (const [filename, content] of result) {
+          const filePath = join11(outputDir, filename);
+          await writeFile2(filePath, content);
+          this.context.stdout.write(`Generated: ${filePath}
+`);
+        }
+      }
+    }
+    const manifestPath = join11(outputDir, "manifest.json");
+    const manifest = generator.generateManifest(commands);
+    if (!this.dryRun) {
+      await writeFile2(manifestPath, manifest);
+      this.context.stdout.write(`Generated: ${manifestPath}
+`);
+    }
+    this.context.stdout.write(`
+Generated ${commands.length} commands for ${agent}
+`);
+    return 0;
+  }
+  async validateCommands() {
+    const inputPath = this.input || resolve13(process.cwd(), ".skillkit", "commands.json");
+    if (!existsSync13(inputPath)) {
+      this.context.stderr.write(`File not found: ${inputPath}
+`);
+      return 1;
+    }
+    const content = await readFile2(inputPath, "utf-8");
+    const config = JSON.parse(content);
+    const commands = config.commands || [];
+    const registry = createCommandRegistry({ validateOnRegister: false });
+    let valid = 0;
+    let invalid = 0;
+    this.context.stdout.write(`Validating ${commands.length} commands...
+
+`);
+    for (const command of commands) {
+      const result = registry.validate(command);
+      if (result.valid) {
+        valid++;
+        if (!this.json) {
+          this.context.stdout.write(`\u2713 /${command.name}
+`);
+        }
+      } else {
+        invalid++;
+        if (!this.json) {
+          this.context.stdout.write(`\u2717 /${command.name}
+`);
+          for (const error of result.errors) {
+            this.context.stdout.write(`    Error: ${error}
+`);
+          }
+        }
+      }
+      if (!this.json && result.warnings.length > 0) {
+        for (const warning of result.warnings) {
+          this.context.stdout.write(`    Warning: ${warning}
+`);
+        }
+      }
+    }
+    if (this.json) {
+      this.context.stdout.write(
+        JSON.stringify({
+          total: commands.length,
+          valid,
+          invalid
+        }) + "\n"
+      );
+    } else {
+      this.context.stdout.write(`
+Validation complete: ${valid} valid, ${invalid} invalid
+`);
+    }
+    return invalid > 0 ? 1 : 0;
+  }
+  async exportCommands() {
+    const registry = createCommandRegistry();
+    await this.loadCommandsFromConfig(registry);
+    const bundle = registry.export(this.all);
+    if (this.output) {
+      let outputPath = resolve13(this.output);
+      const stat2 = await fs.stat(outputPath).catch(() => null);
+      if (stat2 && stat2.isDirectory() || this.output.endsWith(path.sep)) {
+        outputPath = path.join(outputPath, "commands.json");
+      }
+      await fs.mkdir(path.dirname(outputPath), { recursive: true });
+      await writeFile2(outputPath, JSON.stringify(bundle, null, 2));
+      this.context.stdout.write(`Exported ${bundle.commands.length} commands to: ${outputPath}
+`);
+    } else {
+      this.context.stdout.write(JSON.stringify(bundle, null, 2) + "\n");
+    }
+    return 0;
+  }
+  async importCommands() {
+    if (!this.input) {
+      this.context.stderr.write("Error: --input is required for import action\n");
+      return 1;
+    }
+    const inputPath = resolve13(this.input);
+    if (!existsSync13(inputPath)) {
+      this.context.stderr.write(`File not found: ${inputPath}
+`);
+      return 1;
+    }
+    const content = await readFile2(inputPath, "utf-8");
+    const bundle = JSON.parse(content);
+    const configPath = resolve13(process.cwd(), ".skillkit", "commands.json");
+    let existingCommands = [];
+    if (existsSync13(configPath)) {
+      const existingContent = await readFile2(configPath, "utf-8");
+      const config = JSON.parse(existingContent);
+      existingCommands = config.commands || [];
+    }
+    const commandMap = /* @__PURE__ */ new Map();
+    for (const cmd of existingCommands) {
+      commandMap.set(cmd.name, cmd);
+    }
+    for (const cmd of bundle.commands) {
+      commandMap.set(cmd.name, cmd);
+    }
+    const mergedCommands = Array.from(commandMap.values());
+    await mkdir(dirname3(configPath), { recursive: true });
+    await writeFile2(
+      configPath,
+      JSON.stringify({ version: "1.0.0", commands: mergedCommands }, null, 2)
+    );
+    const imported = bundle.commands.length;
+    this.context.stdout.write(`Imported ${imported} commands
+`);
+    this.context.stdout.write(`Total commands: ${mergedCommands.length}
+`);
+    this.context.stdout.write(`Saved to: ${configPath}
+`);
+    return 0;
+  }
+  async showInfo() {
+    const agent = this.agent || "claude-code";
+    const format = getAgentFormat(agent);
+    if (this.json) {
+      this.context.stdout.write(JSON.stringify(format, null, 2) + "\n");
+    } else {
+      this.context.stdout.write(`Agent: ${agent}
+`);
+      this.context.stdout.write(`Directory: ${format.directory}
+`);
+      this.context.stdout.write(`Extension: ${format.extension}
+`);
+      this.context.stdout.write(`Supports Slash Commands: ${format.supportsSlashCommands}
+`);
+      this.context.stdout.write(`Supports Command Files: ${format.supportsCommandFiles}
+`);
+    }
+    return 0;
+  }
+  async loadCommandsFromConfig(registry) {
+    const configPath = resolve13(process.cwd(), ".skillkit", "commands.json");
+    if (existsSync13(configPath)) {
+      const content = await readFile2(configPath, "utf-8");
+      const config = JSON.parse(content);
+      const commands = config.commands || [];
+      for (const command of commands) {
+        try {
+          registry.register(command);
+        } catch {
+        }
+      }
+    }
+  }
+};
+
+// src/commands/ai.ts
+import { Command as Command33, Option as Option32 } from "clipanion";
+import { resolve as resolve14 } from "path";
+import { promises as fs2 } from "fs";
+import chalk30 from "chalk";
+import ora7 from "ora";
+import {
+  AIManager,
+  loadIndex as loadIndexFromCache2
+} from "@skillkit/core";
+var AICommand = class extends Command33 {
+  static paths = [["ai"]];
+  static usage = Command33.Usage({
+    description: "AI-powered skill search and generation",
+    details: `
+      The ai command provides AI-powered features for skills:
+
+      - Natural language search: Find skills using conversational queries
+      - Skill generation: Automatically generate skills from examples
+      - Similar skills: Find skills similar to a given skill
+
+      Note: Without an API key, the command uses a basic mock AI provider.
+      Set ANTHROPIC_API_KEY or OPENAI_API_KEY to use real AI features.
+    `,
+    examples: [
+      ["Search skills naturally", '$0 ai search "help me write better tests"'],
+      ["Generate skill from description", '$0 ai generate --description "skill for code review"'],
+      ["Generate from code example", '$0 ai generate --from-code example.ts --description "..."'],
+      ["Find similar skills", "$0 ai similar my-skill-name"]
+    ]
+  });
+  // Subcommand
+  subcommand = Option32.String({ required: true });
+  // Search options
+  query = Option32.String("--query,-q", {
+    description: "Search query for natural language search"
+  });
+  // Generation options
+  description = Option32.String("--description,-d", {
+    description: "Description of the skill to generate"
+  });
+  fromCode = Option32.String("--from-code", {
+    description: "Generate skill from code example file"
+  });
+  additionalContext = Option32.String("--context", {
+    description: "Additional context for generation"
+  });
+  targetAgent = Option32.String("--agent,-a", {
+    description: "Target agent for generated skill"
+  });
+  // Similar skills option
+  skillName = Option32.String({ required: false });
+  // Common options
+  limit = Option32.String("--limit,-l", {
+    description: "Maximum number of results"
+  });
+  minRelevance = Option32.String("--min-relevance", {
+    description: "Minimum relevance score (0-1)"
+  });
+  json = Option32.Boolean("--json,-j", false, {
+    description: "Output in JSON format"
+  });
+  output = Option32.String("--output,-o", {
+    description: "Output file for generated skill"
+  });
+  async execute() {
+    const aiConfig = this.getAIConfig();
+    const manager = new AIManager(aiConfig);
+    if (!this.json) {
+      const providerName = manager.getProviderName();
+      if (providerName === "mock") {
+        console.log(
+          chalk30.yellow(
+            "\u26A0 Using mock AI provider (limited functionality)\n  Set ANTHROPIC_API_KEY or OPENAI_API_KEY for real AI features\n"
+          )
+        );
+      }
+    }
+    switch (this.subcommand) {
+      case "search":
+        return await this.handleSearch(manager);
+      case "generate":
+      case "gen":
+        return await this.handleGenerate(manager);
+      case "similar":
+        return await this.handleSimilar(manager);
+      default:
+        console.error(
+          chalk30.red(`Unknown subcommand: ${this.subcommand}
+`)
+        );
+        console.log("Valid subcommands: search, generate, similar");
+        return 1;
+    }
+  }
+  async handleSearch(manager) {
+    const query = this.query || this.skillName;
+    if (!query) {
+      console.error(chalk30.red("Search query required (--query or positional argument)"));
+      return 1;
+    }
+    const skills = await this.loadSkills();
+    if (skills.length === 0) {
+      console.log(
+        chalk30.yellow('No skills found. Run "skillkit recommend --update" first.')
+      );
+      return 0;
+    }
+    const spinner = ora7("Searching with AI...").start();
+    try {
+      const results = await manager.searchSkills(query, skills, {
+        limit: this.limit ? parseInt(this.limit, 10) : 10,
+        minRelevance: this.minRelevance ? parseFloat(this.minRelevance) : 0.5,
+        includeReasoning: !this.json
+      });
+      spinner.stop();
+      if (this.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return 0;
+      }
+      if (results.length === 0) {
+        console.log(chalk30.yellow(`No skills found matching "${query}"`));
+        return 0;
+      }
+      console.log(chalk30.cyan(`
+AI Search Results (${results.length} found):
+`));
+      for (const result of results) {
+        const score = Math.round(result.relevance * 100);
+        const scoreColor = score >= 70 ? chalk30.green : score >= 50 ? chalk30.yellow : chalk30.dim;
+        console.log(
+          `  ${scoreColor(`${score}%`)} ${chalk30.bold(result.skill.name)}`
+        );
+        if (result.skill.description) {
+          console.log(`      ${chalk30.dim(result.skill.description)}`);
+        }
+        if (result.reasoning) {
+          console.log(`      ${chalk30.dim("\u2192 " + result.reasoning)}`);
+        }
+        console.log();
+      }
+      return 0;
+    } catch (error) {
+      spinner.fail("Search failed");
+      console.error(
+        chalk30.red(error instanceof Error ? error.message : String(error))
+      );
+      return 1;
+    }
+  }
+  async handleGenerate(manager) {
+    const description = this.description;
+    if (!description) {
+      console.error(chalk30.red("Description required (--description)"));
+      return 1;
+    }
+    let codeExamples = [];
+    if (this.fromCode) {
+      const codePath = resolve14(this.fromCode);
+      try {
+        const code = await fs2.readFile(codePath, "utf-8");
+        codeExamples = [code];
+      } catch {
+        console.error(chalk30.red(`Failed to read code file: ${codePath}`));
+        return 1;
+      }
+    }
+    const example = {
+      description,
+      context: this.additionalContext,
+      codeExamples,
+      targetAgent: this.targetAgent
+    };
+    const spinner = ora7("Generating skill with AI...").start();
+    try {
+      const generated = await manager.generateSkill(example, {
+        targetAgent: this.targetAgent,
+        includeTests: true,
+        includeDocumentation: true
+      });
+      spinner.stop();
+      const validation = manager.validateGenerated(generated);
+      if (!validation.valid) {
+        console.log(chalk30.yellow("\n\u26A0 Generated skill has validation warnings:"));
+        for (const error of validation.errors) {
+          console.log(chalk30.dim(`  \u2022 ${error}`));
+        }
+        console.log();
+      }
+      if (this.json) {
+        console.log(JSON.stringify(generated, null, 2));
+        return 0;
+      }
+      console.log(chalk30.green("\n\u2713 Generated skill successfully\n"));
+      console.log(chalk30.cyan("Name:") + ` ${generated.name}`);
+      console.log(chalk30.cyan("Description:") + ` ${generated.description}`);
+      console.log(
+        chalk30.cyan("Tags:") + ` ${generated.tags.join(", ")}`
+      );
+      console.log(
+        chalk30.cyan("Confidence:") + ` ${Math.round(generated.confidence * 100)}%`
+      );
+      if (generated.reasoning) {
+        console.log(chalk30.cyan("Reasoning:") + ` ${generated.reasoning}`);
+      }
+      console.log("\n" + chalk30.dim("Content:"));
+      console.log(chalk30.dim("\u2500".repeat(60)));
+      console.log(generated.content);
+      console.log(chalk30.dim("\u2500".repeat(60)));
+      if (this.output) {
+        const outputPath = resolve14(this.output);
+        await fs2.writeFile(outputPath, generated.content, "utf-8");
+        console.log(chalk30.green(`
+\u2713 Saved to: ${outputPath}`));
+      } else {
+        console.log(
+          chalk30.dim("\nSave with: --output <filename>")
+        );
+      }
+      return 0;
+    } catch (error) {
+      spinner.fail("Generation failed");
+      console.error(
+        chalk30.red(error instanceof Error ? error.message : String(error))
+      );
+      return 1;
+    }
+  }
+  async handleSimilar(manager) {
+    const skillName = this.skillName;
+    if (!skillName) {
+      console.error(chalk30.red("Skill name required"));
+      return 1;
+    }
+    const skills = await this.loadSkills();
+    if (skills.length === 0) {
+      console.log(
+        chalk30.yellow('No skills found. Run "skillkit recommend --update" first.')
+      );
+      return 0;
+    }
+    const targetSkill = skills.find(
+      (s) => s.name.toLowerCase() === skillName.toLowerCase()
+    );
+    if (!targetSkill) {
+      console.error(chalk30.red(`Skill not found: ${skillName}`));
+      return 1;
+    }
+    const spinner = ora7("Finding similar skills...").start();
+    try {
+      const results = await manager.findSimilar(targetSkill, skills, {
+        limit: this.limit ? parseInt(this.limit, 10) : 10,
+        minRelevance: this.minRelevance ? parseFloat(this.minRelevance) : 0.5,
+        includeReasoning: !this.json
+      });
+      spinner.stop();
+      if (this.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return 0;
+      }
+      if (results.length === 0) {
+        console.log(
+          chalk30.yellow(`No similar skills found for "${skillName}"`)
+        );
+        return 0;
+      }
+      console.log(
+        chalk30.cyan(`
+Skills similar to "${skillName}" (${results.length} found):
+`)
+      );
+      for (const result of results) {
+        const score = Math.round(result.relevance * 100);
+        const scoreColor = score >= 70 ? chalk30.green : score >= 50 ? chalk30.yellow : chalk30.dim;
+        console.log(
+          `  ${scoreColor(`${score}%`)} ${chalk30.bold(result.skill.name)}`
+        );
+        if (result.skill.description) {
+          console.log(`      ${chalk30.dim(result.skill.description)}`);
+        }
+        if (result.reasoning) {
+          console.log(`      ${chalk30.dim("\u2192 " + result.reasoning)}`);
+        }
+        console.log();
+      }
+      return 0;
+    } catch (error) {
+      spinner.fail("Search failed");
+      console.error(
+        chalk30.red(error instanceof Error ? error.message : String(error))
+      );
+      return 1;
+    }
+  }
+  async loadSkills() {
+    const index = loadIndexFromCache2();
+    if (!index) {
+      return [];
+    }
+    return index.skills.map((s) => ({
+      name: s.name,
+      description: s.description,
+      content: "",
+      tags: s.tags,
+      source: s.source
+    }));
+  }
+  getAIConfig() {
+    const apiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+    return {
+      provider: process.env.ANTHROPIC_API_KEY ? "anthropic" : process.env.OPENAI_API_KEY ? "openai" : "none",
+      apiKey,
+      model: process.env.ANTHROPIC_API_KEY ? "claude-3-sonnet-20240229" : void 0,
+      maxTokens: 4096,
+      temperature: 0.7
+    };
+  }
+};
+
+// src/commands/audit.ts
+import { Command as Command34, Option as Option33 } from "clipanion";
+import { resolve as resolve15 } from "path";
+import { promises as fs3 } from "fs";
+import path2 from "path";
+import chalk31 from "chalk";
+import { AuditLogger } from "@skillkit/core";
+var AuditCommand = class extends Command34 {
+  static paths = [["audit"]];
+  static usage = Command34.Usage({
+    description: "View and manage audit logs",
+    details: `
+      The audit command provides access to the audit log system.
+      All skill operations, team activities, and plugin actions are logged.
+
+      Subcommands:
+        log      View recent audit log entries
+        export   Export audit logs to file
+        stats    Show audit statistics
+        clear    Clear old audit entries
+    `,
+    examples: [
+      ["View recent logs", "$0 audit log"],
+      ["View logs with filters", "$0 audit log --type skill.install --limit 20"],
+      ["Export logs to JSON", "$0 audit export --format json --output audit.json"],
+      ["Show statistics", "$0 audit stats"],
+      ["Clear logs older than 30 days", "$0 audit clear --days 30"]
+    ]
+  });
+  subcommand = Option33.String({ required: true });
+  // Query options
+  type = Option33.Array("--type,-t", {
+    description: "Filter by event type"
+  });
+  user = Option33.String("--user,-u", {
+    description: "Filter by user"
+  });
+  resource = Option33.String("--resource,-r", {
+    description: "Filter by resource"
+  });
+  success = Option33.Boolean("--success", {
+    description: "Show only successful operations"
+  });
+  failed = Option33.Boolean("--failed", {
+    description: "Show only failed operations"
+  });
+  since = Option33.String("--since", {
+    description: "Show events since date (ISO 8601)"
+  });
+  until = Option33.String("--until", {
+    description: "Show events until date (ISO 8601)"
+  });
+  limit = Option33.String("--limit,-l", {
+    description: "Maximum number of entries"
+  });
+  // Export options
+  format = Option33.String("--format,-f", {
+    description: "Export format (json, csv, text)"
+  });
+  output = Option33.String("--output,-o", {
+    description: "Output file path"
+  });
+  // Clear options
+  days = Option33.String("--days", {
+    description: "Clear entries older than N days"
+  });
+  // Common options
+  json = Option33.Boolean("--json,-j", false, {
+    description: "Output in JSON format"
+  });
+  projectPath = Option33.String("--path,-p", {
+    description: "Project path (default: current directory)"
+  });
+  async execute() {
+    const targetPath = resolve15(this.projectPath || process.cwd());
+    const logDir = path2.join(targetPath, ".skillkit");
+    const logger = new AuditLogger(logDir);
+    try {
+      switch (this.subcommand) {
+        case "log":
+        case "list":
+          return await this.handleLog(logger);
+        case "export":
+          return await this.handleExport(logger);
+        case "stats":
+          return await this.handleStats(logger);
+        case "clear":
+          return await this.handleClear(logger);
+        default:
+          console.error(chalk31.red(`Unknown subcommand: ${this.subcommand}
+`));
+          console.log("Valid subcommands: log, export, stats, clear");
+          return 1;
+      }
+    } finally {
+      await logger.destroy();
+    }
+  }
+  async handleLog(logger) {
+    const query = this.buildQuery();
+    const events = await logger.query(query);
+    if (this.json) {
+      console.log(JSON.stringify(events, null, 2));
+      return 0;
+    }
+    if (events.length === 0) {
+      console.log(chalk31.yellow("No audit events found"));
+      return 0;
+    }
+    console.log(chalk31.cyan(`
+Audit Log (${events.length} entries):
+`));
+    for (const event of events) {
+      const statusIcon = event.success ? chalk31.green("\u2713") : chalk31.red("\u2717");
+      const timestamp = event.timestamp.toLocaleString();
+      console.log(
+        `${statusIcon} ${chalk31.dim(timestamp)} ${chalk31.bold(event.type)}`
+      );
+      console.log(
+        `   ${event.action} on ${chalk31.cyan(event.resource)}`
+      );
+      if (event.user) {
+        console.log(`   ${chalk31.dim("User:")} ${event.user}`);
+      }
+      if (event.duration) {
+        console.log(`   ${chalk31.dim("Duration:")} ${event.duration}ms`);
+      }
+      if (event.error) {
+        console.log(`   ${chalk31.red("Error:")} ${event.error}`);
+      }
+      if (event.details && Object.keys(event.details).length > 0) {
+        console.log(`   ${chalk31.dim("Details:")} ${JSON.stringify(event.details)}`);
+      }
+      console.log();
+    }
+    return 0;
+  }
+  async handleExport(logger) {
+    const format = this.format || "json";
+    const query = this.buildQuery();
+    const content = await logger.export({ format, query });
+    if (this.output) {
+      const outputPath = resolve15(this.output);
+      await fs3.writeFile(outputPath, content, "utf-8");
+      console.log(chalk31.green(`\u2713 Exported audit log to: ${outputPath}`));
+    } else {
+      console.log(content);
+    }
+    return 0;
+  }
+  async handleStats(logger) {
+    const stats = await logger.stats();
+    if (this.json) {
+      console.log(JSON.stringify(stats, null, 2));
+      return 0;
+    }
+    console.log(chalk31.cyan("\nAudit Statistics:\n"));
+    console.log(`Total Events: ${chalk31.bold(stats.totalEvents.toString())}`);
+    console.log(
+      `Success Rate: ${chalk31.bold(`${(stats.successRate * 100).toFixed(1)}%`)}`
+    );
+    if (Object.keys(stats.eventsByType).length > 0) {
+      console.log(chalk31.cyan("\nEvents by Type:"));
+      const sorted = Object.entries(stats.eventsByType).sort(
+        ([, a], [, b]) => b - a
+      );
+      for (const [type, count] of sorted) {
+        console.log(`  ${type.padEnd(30)} ${count}`);
+      }
+    }
+    if (stats.topResources.length > 0) {
+      console.log(chalk31.cyan("\nTop Resources:"));
+      for (const { resource, count } of stats.topResources) {
+        console.log(`  ${resource.padEnd(40)} ${count}`);
+      }
+    }
+    if (stats.recentErrors.length > 0) {
+      console.log(chalk31.cyan(`
+Recent Errors (${stats.recentErrors.length}):`));
+      for (const error of stats.recentErrors.slice(0, 5)) {
+        const timestamp = error.timestamp.toLocaleString();
+        console.log(
+          `  ${chalk31.red("\u2717")} ${chalk31.dim(timestamp)} ${error.type}`
+        );
+        if (error.error) {
+          console.log(`     ${chalk31.dim(error.error)}`);
+        }
+      }
+    }
+    console.log();
+    return 0;
+  }
+  async handleClear(logger) {
+    if (!this.days) {
+      console.error(chalk31.red("--days option required"));
+      return 1;
+    }
+    const daysAgo = parseInt(this.days, 10);
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - daysAgo);
+    const cleared = await logger.clear(cutoffDate);
+    console.log(
+      chalk31.green(
+        `\u2713 Cleared ${cleared} audit entries older than ${daysAgo} days`
+      )
+    );
+    return 0;
+  }
+  buildQuery() {
+    const query = {};
+    if (this.type && this.type.length > 0) {
+      query.types = this.type;
+    }
+    if (this.user) {
+      query.user = this.user;
+    }
+    if (this.resource) {
+      query.resource = this.resource;
+    }
+    if (this.success) {
+      query.success = true;
+    } else if (this.failed) {
+      query.success = false;
+    }
+    if (this.since) {
+      query.startDate = new Date(this.since);
+    }
+    if (this.until) {
+      query.endDate = new Date(this.until);
+    }
+    if (this.limit) {
+      query.limit = parseInt(this.limit, 10);
+    } else {
+      query.limit = 50;
+    }
+    return query;
+  }
+};
 export {
+  AICommand,
+  AuditCommand,
   CICDCommand,
+  CommandCmd,
   ContextCommand,
   CreateCommand,
   DisableCommand,
   EnableCommand,
+  HookCommand,
   InitCommand,
   InstallCommand,
   ListCommand,
   MarketplaceCommand,
   MemoryCommand,
+  MethodologyCommand,
   PauseCommand,
+  PlanCommand,
   PluginCommand,
   ReadCommand,
   RecommendCommand,