@skillkit/cli 1.4.0 → 1.6.0

package/dist/index.js

@@ -2356,7 +2356,9 @@ import {
   loadWorkflowByName,
   loadWorkflow,
   validateWorkflow,
-  createWorkflowOrchestrator
+  createWorkflowOrchestrator,
+  createSkillExecutor,
+  createSimulatedSkillExecutor
 } from "@skillkit/core";
 var WorkflowRunCommand = class extends Command18 {
   static paths = [["workflow", "run"], ["wf", "run"]];
@@ -2400,6 +2402,14 @@ var WorkflowRunCommand = class extends Command18 {
   projectPath = Option17.String("--path,-p", {
     description: "Project path (default: current directory)"
   });
+  // Agent to use for execution
+  agent = Option17.String("--agent,-a", {
+    description: "Agent to use for skill execution (e.g., claude-code, codex)"
+  });
+  // Simulate execution (for testing)
+  simulate = Option17.Boolean("--simulate", false, {
+    description: "Simulate execution without running skills (for testing)"
+  });
   async execute() {
     const targetPath = resolve6(this.projectPath || process.cwd());
     let workflow;
@@ -2440,11 +2450,40 @@ var WorkflowRunCommand = class extends Command18 {
     console.log();
     const spinner = ora4();
     let currentWave = -1;
+    const skillExecutor = this.simulate ? createSimulatedSkillExecutor({
+      delay: 500,
+      onExecute: (skillName) => {
+        if (this.verbose && !this.json) {
+          console.log(chalk17.dim(`  [Simulated] ${skillName}`));
+        }
+      }
+    }) : createSkillExecutor({
+      projectPath: targetPath,
+      preferredAgent: this.agent,
+      fallbackToAvailable: true,
+      onExecutionEvent: (event) => {
+        if (this.verbose && !this.json) {
+          switch (event.type) {
+            case "skill_found":
+              console.log(chalk17.dim(`  Found: ${event.message}`));
+              break;
+            case "skill_not_found":
+              console.log(chalk17.red(`  Not found: ${event.skillName}`));
+              break;
+            case "agent_selected":
+              console.log(chalk17.dim(`  Agent: ${event.agent}`));
+              break;
+            case "execution_complete":
+              if (!event.success) {
+                console.log(chalk17.red(`  Error: ${event.error}`));
+              }
+              break;
+          }
+        }
+      }
+    });
     const orchestrator = createWorkflowOrchestrator(
-      async (_skillName, _config) => {
-        await new Promise((resolve11) => setTimeout(resolve11, 500));
-        return { success: true };
-      },
+      skillExecutor,
       (event) => {
         if (this.json) return;
         switch (event.type) {
@@ -3763,13 +3802,13 @@ ${learning.title}
       return 0;
     }
     const outputPath = this.output || `.skillkit/exports/${skillName}/SKILL.md`;
-    const { dirname: dirname3 } = await import("path");
-    const { existsSync: existsSync11, mkdirSync: mkdirSync5, writeFileSync: writeFileSync5 } = await import("fs");
-    const outputDir = dirname3(outputPath);
-    if (!existsSync11(outputDir)) {
-      mkdirSync5(outputDir, { recursive: true });
+    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 });
     }
-    writeFileSync5(outputPath, skillContent, "utf-8");
+    writeFileSync6(outputPath, skillContent, "utf-8");
     console.log(chalk23.green(`\u2713 Exported learning as skill: ${skillName}`));
     console.log(chalk23.gray(`  Path: ${outputPath}`));
     return 0;
@@ -3784,10 +3823,10 @@ ${learning.title}
       console.log(chalk23.gray("Usage: skillkit memory import --input <path>"));
       return 1;
     }
-    const { existsSync: existsSync11, readFileSync: readFileSync6 } = await import("fs");
-    const { resolve: resolve11 } = await import("path");
-    const fullPath = resolve11(inputPath);
-    if (!existsSync11(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;
     }
@@ -3797,7 +3836,7 @@ ${learning.title}
       this.global ? void 0 : projectPath
     );
     try {
-      const content = readFileSync6(fullPath, "utf-8");
+      const content = readFileSync7(fullPath, "utf-8");
       const { parse: parseYaml2 } = await import("yaml");
       const data = parseYaml2(content);
       if (!data.learnings || !Array.isArray(data.learnings)) {
@@ -4040,24 +4079,3151 @@ ${learning.title}
     return lines.join("\n");
   }
 };
+
+// src/commands/settings.ts
+import { Command as Command25, Option as Option24 } from "clipanion";
+import chalk24 from "chalk";
+import { loadConfig as loadConfig3, saveConfig } from "@skillkit/core";
+var VALID_AGENTS = [
+  "claude-code",
+  "cursor",
+  "codex",
+  "gemini-cli",
+  "opencode",
+  "antigravity",
+  "amp",
+  "clawdbot",
+  "droid",
+  "github-copilot",
+  "goose",
+  "kilo",
+  "kiro-cli",
+  "roo",
+  "trae",
+  "windsurf",
+  "universal"
+];
+var SettingsCommand = class extends Command25 {
+  static paths = [["settings"], ["config"]];
+  static usage = Command25.Usage({
+    description: "View and modify SkillKit settings",
+    details: `
+      View or modify SkillKit configuration. Settings are stored in skillkit.yaml.
+
+      Without arguments, shows all current settings.
+      With --set, modifies a specific setting.
+    `,
+    examples: [
+      ["Show all settings", "$0 settings"],
+      ["Set default agent", "$0 settings --set agent=claude-code"],
+      ["Enable auto-sync", "$0 settings --set autoSync=true"],
+      ["Set cache directory", "$0 settings --set cacheDir=~/.cache/skillkit"],
+      ["Show settings as JSON", "$0 settings --json"],
+      ["Save to global config", "$0 settings --set agent=cursor --global"]
+    ]
+  });
+  // Set a setting
+  set = Option24.String("--set,-s", {
+    description: "Set a config value (key=value)"
+  });
+  // Get a specific setting
+  get = Option24.String("--get,-g", {
+    description: "Get a specific setting value"
+  });
+  // JSON output
+  json = Option24.Boolean("--json,-j", false, {
+    description: "Output as JSON"
+  });
+  // Global config
+  global = Option24.Boolean("--global", false, {
+    description: "Use global config (~/.config/skillkit/)"
+  });
+  // Reset to defaults
+  reset = Option24.Boolean("--reset", false, {
+    description: "Reset all settings to defaults"
+  });
+  async execute() {
+    const config = loadConfig3(this.global);
+    if (this.reset) {
+      const defaultConfig = {
+        version: 1,
+        agent: "universal",
+        autoSync: true
+      };
+      saveConfig(defaultConfig, this.global);
+      console.log(chalk24.green("Settings reset to defaults"));
+      return 0;
+    }
+    if (this.get) {
+      const knownKeys = [
+        "agent",
+        "autoSync",
+        "cacheDir",
+        "skillsDir",
+        "enabledSkills",
+        "disabledSkills",
+        "marketplaceSources",
+        "defaultTimeout"
+      ];
+      if (!knownKeys.includes(this.get)) {
+        console.error(chalk24.red(`Unknown setting: ${this.get}`));
+        return 1;
+      }
+      const value = this.getConfigValue(config, this.get);
+      if (this.json) {
+        console.log(JSON.stringify({ [this.get]: value ?? null }));
+      } else {
+        console.log(value ?? "(not set)");
+      }
+      return 0;
+    }
+    if (this.set) {
+      const [key, ...valueParts] = this.set.split("=");
+      const value = valueParts.join("=");
+      if (!key || !this.set.includes("=")) {
+        console.error(chalk24.red("Invalid format. Use: --set key=value"));
+        return 1;
+      }
+      const result = this.setConfigValue(config, key, value);
+      if (!result.success) {
+        console.error(chalk24.red(result.error));
+        return 1;
+      }
+      saveConfig(config, this.global);
+      console.log(chalk24.green(`${key} = ${value}`));
+      return 0;
+    }
+    if (this.json) {
+      console.log(JSON.stringify(config, null, 2));
+    } else {
+      console.log(chalk24.cyan("SkillKit Settings"));
+      console.log(chalk24.dim("\u2500".repeat(40)));
+      console.log();
+      const settings = [
+        { key: "agent", label: "Default Agent", value: config.agent },
+        { key: "autoSync", label: "Auto Sync", value: config.autoSync ? "enabled" : "disabled" },
+        { key: "cacheDir", label: "Cache Dir", value: config.cacheDir || "~/.skillkit/cache" },
+        { key: "skillsDir", label: "Skills Dir", value: config.skillsDir || "(default)" },
+        { key: "defaultTimeout", label: "Timeout", value: config.defaultTimeout ? `${config.defaultTimeout}ms` : "(default)" }
+      ];
+      for (const setting of settings) {
+        console.log(`  ${chalk24.white(setting.label.padEnd(14))} ${chalk24.dim(setting.value)}`);
+      }
+      if (config.enabledSkills?.length) {
+        console.log();
+        console.log(`  ${chalk24.white("Enabled Skills".padEnd(14))} ${chalk24.dim(config.enabledSkills.join(", "))}`);
+      }
+      if (config.disabledSkills?.length) {
+        console.log(`  ${chalk24.white("Disabled Skills".padEnd(14))} ${chalk24.dim(config.disabledSkills.join(", "))}`);
+      }
+      if (config.marketplaceSources?.length) {
+        console.log(`  ${chalk24.white("Marketplaces".padEnd(14))} ${chalk24.dim(config.marketplaceSources.join(", "))}`);
+      }
+      console.log();
+      console.log(chalk24.dim("Use --set key=value to modify settings"));
+      console.log(chalk24.dim("Available keys: agent, autoSync, cacheDir, skillsDir, defaultTimeout"));
+    }
+    return 0;
+  }
+  getConfigValue(config, key) {
+    switch (key) {
+      case "agent":
+        return config.agent;
+      case "autoSync":
+        return config.autoSync;
+      case "cacheDir":
+        return config.cacheDir;
+      case "skillsDir":
+        return config.skillsDir;
+      case "enabledSkills":
+        return config.enabledSkills;
+      case "disabledSkills":
+        return config.disabledSkills;
+      case "marketplaceSources":
+        return config.marketplaceSources;
+      case "defaultTimeout":
+        return config.defaultTimeout;
+      default:
+        return void 0;
+    }
+  }
+  setConfigValue(config, key, value) {
+    switch (key) {
+      case "agent":
+        if (!VALID_AGENTS.includes(value)) {
+          return {
+            success: false,
+            error: `Invalid agent. Valid options: ${VALID_AGENTS.join(", ")}`
+          };
+        }
+        config.agent = value;
+        break;
+      case "autoSync":
+        if (!["true", "false", "enabled", "disabled"].includes(value.toLowerCase())) {
+          return { success: false, error: "autoSync must be true/false or enabled/disabled" };
+        }
+        config.autoSync = value.toLowerCase() === "true" || value.toLowerCase() === "enabled";
+        break;
+      case "cacheDir":
+        config.cacheDir = value || void 0;
+        break;
+      case "skillsDir":
+        config.skillsDir = value || void 0;
+        break;
+      case "defaultTimeout": {
+        const timeout = parseInt(value, 10);
+        if (isNaN(timeout) || timeout <= 0) {
+          return { success: false, error: "defaultTimeout must be a positive number (milliseconds)" };
+        }
+        config.defaultTimeout = timeout;
+        break;
+      }
+      default:
+        return { success: false, error: `Unknown setting: ${key}` };
+    }
+    return { success: true };
+  }
+};
+
+// src/commands/cicd.ts
+import { Command as Command26, Option as Option25 } from "clipanion";
+import chalk25 from "chalk";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readFileSync as readFileSync6 } from "fs";
+import { join as join8 } from "path";
+var GITHUB_ACTIONS_WORKFLOW = `name: SkillKit CI
+
+on:
+  push:
+    branches: [main, master]
+    paths:
+      - '.skillkit/**'
+      - 'skills/**'
+      - '.claude/skills/**'
+      - '.cursor/skills/**'
+  pull_request:
+    branches: [main, master]
+    paths:
+      - '.skillkit/**'
+      - 'skills/**'
+      - '.claude/skills/**'
+      - '.cursor/skills/**'
+
+jobs:
+  validate:
+    name: Validate Skills
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install SkillKit
+        run: npm install -g skillkit
+
+      - name: Validate Skills
+        run: skillkit validate --all
+
+      - name: List Skills
+        run: skillkit list
+
+  test:
+    name: Test Skills
+    runs-on: ubuntu-latest
+    needs: validate
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install SkillKit
+        run: npm install -g skillkit
+
+      - name: Run Skill Tests
+        run: skillkit test --all
+        continue-on-error: true
+
+  sync:
+    name: Sync Skills
+    runs-on: ubuntu-latest
+    needs: validate
+    if: github.event_name == 'push'
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install SkillKit
+        run: npm install -g skillkit
+
+      - name: Sync Skills to All Agents
+        run: skillkit sync --yes
+`;
+var GITLAB_CI = `stages:
+  - validate
+  - test
+  - sync
+
+variables:
+  NODE_VERSION: "20"
+
+.skillkit-base:
+  image: node:\${NODE_VERSION}
+  before_script:
+    - npm install -g skillkit
+  rules:
+    - changes:
+        - .skillkit/**/*
+        - skills/**/*
+        - .claude/skills/**/*
+        - .cursor/skills/**/*
+
+validate:
+  extends: .skillkit-base
+  stage: validate
+  script:
+    - skillkit validate --all
+    - skillkit list
+
+test:
+  extends: .skillkit-base
+  stage: test
+  script:
+    - skillkit test --all
+  allow_failure: true
+  needs:
+    - validate
+
+sync:
+  extends: .skillkit-base
+  stage: sync
+  script:
+    - skillkit sync --yes
+  needs:
+    - validate
+  rules:
+    - if: $CI_COMMIT_BRANCH == "main" || $CI_COMMIT_BRANCH == "master"
+      changes:
+        - .skillkit/**/*
+        - skills/**/*
+        - .claude/skills/**/*
+        - .cursor/skills/**/*
+`;
+var CIRCLECI_CONFIG = `version: 2.1
+
+executors:
+  node:
+    docker:
+      - image: cimg/node:20.0
+
+jobs:
+  validate:
+    executor: node
+    steps:
+      - checkout
+      - run:
+          name: Install SkillKit
+          command: npm install -g skillkit
+      - run:
+          name: Validate Skills
+          command: skillkit validate --all
+      - run:
+          name: List Skills
+          command: skillkit list
+
+  test:
+    executor: node
+    steps:
+      - checkout
+      - run:
+          name: Install SkillKit
+          command: npm install -g skillkit
+      - run:
+          name: Run Skill Tests
+          command: skillkit test --all || true
+
+  sync:
+    executor: node
+    steps:
+      - checkout
+      - run:
+          name: Install SkillKit
+          command: npm install -g skillkit
+      - run:
+          name: Sync Skills
+          command: skillkit sync --yes
+
+workflows:
+  skillkit:
+    jobs:
+      - validate:
+          filters:
+            branches:
+              only:
+                - main
+                - master
+      - test:
+          requires:
+            - validate
+      - sync:
+          requires:
+            - validate
+          filters:
+            branches:
+              only:
+                - main
+                - master
+`;
+var CICDCommand = class extends Command26 {
+  static paths = [["cicd", "init"]];
+  static usage = Command26.Usage({
+    description: "Initialize CI/CD workflows for skill validation",
+    details: `
+      The cicd command sets up continuous integration workflows to automatically
+      validate and test skills on every push or pull request.
+
+      Supported providers: github, gitlab, circleci
+    `,
+    examples: [
+      ["Initialize GitHub Actions workflow", "$0 cicd init"],
+      ["Initialize GitLab CI", "$0 cicd init --provider gitlab"],
+      ["Initialize CircleCI", "$0 cicd init --provider circleci"],
+      ["Initialize all providers", "$0 cicd init --all"],
+      ["Force overwrite existing files", "$0 cicd init --force"]
+    ]
+  });
+  // Provider selection
+  provider = Option25.String("--provider,-p", "github", {
+    description: "CI/CD provider (github, gitlab, circleci)"
+  });
+  // Generate for all providers
+  all = Option25.Boolean("--all,-a", false, {
+    description: "Generate workflows for all supported providers"
+  });
+  // Force overwrite
+  force = Option25.Boolean("--force,-f", false, {
+    description: "Overwrite existing workflow files"
+  });
+  // Project path
+  targetPath = Option25.String("--path", {
+    description: "Project path (default: current directory)"
+  });
+  async execute() {
+    const projectPath = this.targetPath || process.cwd();
+    const providers = this.all ? ["github", "gitlab", "circleci"] : [this.provider];
+    console.log(chalk25.cyan("Initializing CI/CD workflows..."));
+    console.log();
+    let success = true;
+    let created = false;
+    for (const provider of providers) {
+      const result = this.createWorkflow(projectPath, provider);
+      if (result.skipped) {
+        console.log(chalk25.yellow(`  ${result.message}`));
+        continue;
+      }
+      if (!result.success) {
+        success = false;
+        console.error(chalk25.red(`  ${result.message}`));
+        continue;
+      }
+      created = true;
+      console.log(chalk25.green(`  \u2713 ${result.message}`));
+    }
+    if (success) {
+      console.log();
+      console.log(
+        created ? chalk25.green("CI/CD workflows initialized successfully!") : chalk25.yellow("CI/CD workflows already exist; nothing to do.")
+      );
+      console.log();
+      if (created) {
+        console.log(chalk25.dim("The workflows will run on push/PR to validate your skills."));
+        console.log(chalk25.dim("Commit the generated files to enable CI/CD."));
+      }
+    }
+    return success ? 0 : 1;
+  }
+  createWorkflow(projectPath, provider) {
+    switch (provider) {
+      case "github":
+        return this.createGitHubActions(projectPath);
+      case "gitlab":
+        return this.createGitLabCI(projectPath);
+      case "circleci":
+        return this.createCircleCI(projectPath);
+      default:
+        return { success: false, message: `Unknown provider: ${provider}` };
+    }
+  }
+  createGitHubActions(projectPath) {
+    const workflowDir = join8(projectPath, ".github", "workflows");
+    const workflowFile = join8(workflowDir, "skillkit.yml");
+    if (existsSync11(workflowFile) && !this.force) {
+      return {
+        success: true,
+        message: `GitHub Actions workflow already exists (use --force to overwrite)`,
+        skipped: true
+      };
+    }
+    try {
+      mkdirSync5(workflowDir, { recursive: true });
+      writeFileSync5(workflowFile, GITHUB_ACTIONS_WORKFLOW);
+      return { success: true, message: `Created ${workflowFile}` };
+    } catch (error) {
+      return { success: false, message: `Failed to create GitHub workflow: ${error}` };
+    }
+  }
+  createGitLabCI(projectPath) {
+    const ciFile = join8(projectPath, ".gitlab-ci.yml");
+    if (existsSync11(ciFile) && !this.force) {
+      try {
+        const content = readFileSync6(ciFile, "utf-8");
+        if (content.includes("skillkit")) {
+          return {
+            success: true,
+            message: `.gitlab-ci.yml already contains SkillKit config (use --force to overwrite)`,
+            skipped: true
+          };
+        }
+        return {
+          success: true,
+          message: `.gitlab-ci.yml already exists (use --force to overwrite)`,
+          skipped: true
+        };
+      } catch (error) {
+        return {
+          success: false,
+          message: `Failed to read .gitlab-ci.yml: ${error}`
+        };
+      }
+    }
+    try {
+      writeFileSync5(ciFile, GITLAB_CI);
+      return { success: true, message: `Created ${ciFile}` };
+    } catch (error) {
+      return { success: false, message: `Failed to create GitLab CI config: ${error}` };
+    }
+  }
+  createCircleCI(projectPath) {
+    const circleDir = join8(projectPath, ".circleci");
+    const configFile = join8(circleDir, "config.yml");
+    if (existsSync11(configFile) && !this.force) {
+      return {
+        success: true,
+        message: `CircleCI config already exists (use --force to overwrite)`,
+        skipped: true
+      };
+    }
+    try {
+      mkdirSync5(circleDir, { recursive: true });
+      writeFileSync5(configFile, CIRCLECI_CONFIG);
+      return { success: true, message: `Created ${configFile}` };
+    } catch (error) {
+      return { success: false, message: `Failed to create CircleCI config: ${error}` };
+    }
+  }
+};
+
+// src/commands/team.ts
+import { Command as Command27, Option as Option26 } from "clipanion";
+import chalk26 from "chalk";
+import { createTeamManager, createSkillBundle, exportBundle, importBundle } from "@skillkit/core";
+import { join as join9 } from "path";
+var TeamCommand = class extends Command27 {
+  static paths = [["team"]];
+  static usage = Command27.Usage({
+    description: "Manage team skill sharing and collaboration",
+    examples: [
+      ["Initialize team", '$0 team init --name "My Team" --registry https://github.com/myteam/skills'],
+      ["Share a skill", "$0 team share --name my-skill"],
+      ["Import a skill", "$0 team import --name shared-skill"],
+      ["List shared skills", "$0 team list"],
+      ["Sync with remote", "$0 team sync"],
+      ["Create a bundle", "$0 team bundle-create --name my-bundle --skills skill1,skill2"],
+      ["Export a bundle", "$0 team bundle-export --name my-bundle --output ./bundle.json"],
+      ["Import a bundle", "$0 team bundle-import --source ./bundle.json"]
+    ]
+  });
+  action = Option26.String({ required: true });
+  name = Option26.String("--name", { description: "Team name (for init), skill name, or bundle name" });
+  registry = Option26.String("--registry", { description: "Registry URL (for init)" });
+  description = Option26.String("--description,-d", { description: "Description (for share/bundle)" });
+  tags = Option26.String("--tags,-t", { description: "Comma-separated tags (for share)" });
+  skills = Option26.String("--skills", { description: "Comma-separated skill names (for bundle)" });
+  output = Option26.String("--output,-o", { description: "Output path (for bundle-export)" });
+  source = Option26.String("--source,-s", { description: "Source path (for bundle-import)" });
+  overwrite = Option26.Boolean("--overwrite", { description: "Overwrite existing (for import)" });
+  dryRun = Option26.Boolean("--dry-run", { description: "Preview without changes" });
+  async execute() {
+    const projectPath = process.cwd();
+    const teamManager = createTeamManager(projectPath);
+    try {
+      switch (this.action) {
+        case "init":
+          return await this.initTeam(teamManager);
+        case "share":
+          return await this.shareSkill(teamManager);
+        case "import":
+          return await this.importSkill(teamManager);
+        case "list":
+          return await this.listSkills(teamManager);
+        case "sync":
+          return await this.syncTeam(teamManager);
+        case "remove":
+          return await this.removeSkill(teamManager);
+        case "bundle-create":
+          return await this.createBundle(teamManager);
+        case "bundle-export":
+          return await this.exportSkillBundle(teamManager);
+        case "bundle-import":
+          return await this.importSkillBundle();
+        default:
+          this.context.stderr.write(chalk26.red(`Unknown action: ${this.action}
+`));
+          this.context.stderr.write("Available actions: init, share, import, list, sync, remove, bundle-create, bundle-export, bundle-import\n");
+          return 1;
+      }
+    } catch (err) {
+      this.context.stderr.write(chalk26.red(`\u2717 ${err instanceof Error ? err.message : "Unknown error"}
+`));
+      return 1;
+    }
+  }
+  async initTeam(teamManager) {
+    if (!this.name) {
+      this.context.stderr.write(chalk26.red("--name is required for init\n"));
+      return 1;
+    }
+    if (!this.registry) {
+      this.context.stderr.write(chalk26.red("--registry is required for init\n"));
+      return 1;
+    }
+    const config = await teamManager.init({
+      teamName: this.name,
+      registryUrl: this.registry
+    });
+    this.context.stdout.write(chalk26.green("\u2713 Team initialized!\n"));
+    this.context.stdout.write(`  Team ID: ${config.teamId}
+`);
+    this.context.stdout.write(`  Registry: ${config.registryUrl}
+`);
+    return 0;
+  }
+  async shareSkill(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    if (!this.name) {
+      this.context.stderr.write(chalk26.red("--name <skill-name> is required for share\n"));
+      return 1;
+    }
+    const shared = await teamManager.shareSkill({
+      skillName: this.name,
+      description: this.description,
+      tags: this.tags?.split(",").map((t) => t.trim())
+    });
+    this.context.stdout.write(chalk26.green("\u2713 Skill shared!\n"));
+    this.context.stdout.write(`  Name: ${shared.name}
+`);
+    this.context.stdout.write(`  Version: ${shared.version}
+`);
+    this.context.stdout.write(`  Source: ${shared.source}
+`);
+    return 0;
+  }
+  async importSkill(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    if (!this.name) {
+      this.context.stderr.write(chalk26.red("--name <skill-name> is required for import\n"));
+      return 1;
+    }
+    const result = await teamManager.importSkill(this.name, {
+      overwrite: this.overwrite,
+      dryRun: this.dryRun
+    });
+    if (!result.success) {
+      this.context.stderr.write(chalk26.red(`\u2717 ${result.error}
+`));
+      return 1;
+    }
+    if (this.dryRun) {
+      this.context.stdout.write(chalk26.cyan(`[dry-run] Would import to: ${result.path}
+`));
+    } else {
+      this.context.stdout.write(chalk26.green(`\u2713 Skill imported to: ${result.path}
+`));
+    }
+    return 0;
+  }
+  async listSkills(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    const skills = teamManager.listSharedSkills();
+    this.context.stdout.write(chalk26.cyan(`Team: ${config.teamName}
+`));
+    this.context.stdout.write(chalk26.gray(`Registry: ${config.registryUrl}
+
+`));
+    if (skills.length === 0) {
+      this.context.stdout.write("No shared skills yet. Use `skillkit team share` to share a skill.\n");
+      return 0;
+    }
+    this.context.stdout.write(`Shared Skills (${skills.length}):
+`);
+    for (const skill of skills) {
+      this.context.stdout.write(chalk26.cyan(`  ${skill.name}`) + ` v${skill.version}
+`);
+      if (skill.description) {
+        this.context.stdout.write(chalk26.gray(`    ${skill.description}
+`));
+      }
+      this.context.stdout.write(`    by ${skill.author} | ${skill.downloads || 0} downloads
+`);
+    }
+    return 0;
+  }
+  async syncTeam(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    this.context.stdout.write(`Syncing with ${config.registryUrl}...
+`);
+    const result = await teamManager.sync();
+    this.context.stdout.write(chalk26.green("\u2713 Sync complete!\n"));
+    if (result.added.length > 0) {
+      this.context.stdout.write(`  Added: ${result.added.join(", ")}
+`);
+    }
+    if (result.updated.length > 0) {
+      this.context.stdout.write(`  Updated: ${result.updated.join(", ")}
+`);
+    }
+    if (result.added.length === 0 && result.updated.length === 0) {
+      this.context.stdout.write("  Already up to date.\n");
+    }
+    return 0;
+  }
+  async removeSkill(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    if (!this.name) {
+      this.context.stderr.write(chalk26.red("--name <skill-name> is required for remove\n"));
+      return 1;
+    }
+    const removed = teamManager.removeSkill(this.name);
+    if (!removed) {
+      this.context.stderr.write(chalk26.red(`Skill "${this.name}" not found in team registry.
+`));
+      return 1;
+    }
+    this.context.stdout.write(chalk26.green(`\u2713 Skill "${this.name}" removed from team registry.
+`));
+    return 0;
+  }
+  async createBundle(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    if (!this.name) {
+      this.context.stderr.write(chalk26.red("--name <bundle-name> is required for bundle-create\n"));
+      return 1;
+    }
+    if (!this.skills) {
+      this.context.stderr.write(chalk26.red("--skills <skill1,skill2,...> is required for bundle-create\n"));
+      return 1;
+    }
+    const skillNames = this.skills.split(",").map((s) => s.trim());
+    const projectPath = process.cwd();
+    const skillsDir = join9(projectPath, "skills");
+    const bundle = createSkillBundle(this.name, config.teamName, this.description);
+    let addedCount = 0;
+    for (const skillName of skillNames) {
+      const skillPath = join9(skillsDir, skillName);
+      try {
+        bundle.addSkill(skillPath);
+        addedCount++;
+        this.context.stdout.write(chalk26.gray(`  + ${skillName}
+`));
+      } catch (err) {
+        this.context.stderr.write(chalk26.yellow(`  \u26A0 Skipping ${skillName}: ${err instanceof Error ? err.message : "Unknown error"}
+`));
+      }
+    }
+    if (addedCount === 0) {
+      this.context.stderr.write(chalk26.red("No skills were added to the bundle.\n"));
+      return 1;
+    }
+    const outputPath = this.output || join9(projectPath, ".skillkit", "bundles", `${this.name}.json`);
+    const result = exportBundle(bundle, outputPath);
+    if (!result.success) {
+      this.context.stderr.write(chalk26.red(`\u2717 ${result.error}
+`));
+      return 1;
+    }
+    this.context.stdout.write(chalk26.green(`
+\u2713 Bundle "${this.name}" created with ${addedCount} skills!
+`));
+    this.context.stdout.write(`  Checksum: ${bundle.getChecksum()}
+`);
+    this.context.stdout.write(`  Output: ${result.path}
+`);
+    return 0;
+  }
+  async exportSkillBundle(teamManager) {
+    const config = teamManager.load();
+    if (!config) {
+      this.context.stderr.write(chalk26.red("Team not initialized. Run `skillkit team init` first.\n"));
+      return 1;
+    }
+    if (!this.name) {
+      this.context.stderr.write(chalk26.red("--name <bundle-name> is required for bundle-export\n"));
+      return 1;
+    }
+    if (!this.output) {
+      this.context.stderr.write(chalk26.red("--output <path> is required for bundle-export\n"));
+      return 1;
+    }
+    const projectPath = process.cwd();
+    const bundlePath = join9(projectPath, ".skillkit", "bundles", `${this.name}.json`);
+    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;
+    }
+    const content = readFileSync7(bundlePath, "utf-8");
+    writeFileSync6(this.output, content, "utf-8");
+    this.context.stdout.write(chalk26.green(`\u2713 Bundle exported to: ${this.output}
+`));
+    return 0;
+  }
+  async importSkillBundle() {
+    if (!this.source) {
+      this.context.stderr.write(chalk26.red("--source <path> is required for bundle-import\n"));
+      return 1;
+    }
+    const { existsSync: existsSync14 } = await import("fs");
+    if (!existsSync14(this.source)) {
+      this.context.stderr.write(chalk26.red(`Bundle file not found: ${this.source}
+`));
+      return 1;
+    }
+    const projectPath = process.cwd();
+    const skillsDir = join9(projectPath, "skills");
+    if (this.dryRun) {
+      this.context.stdout.write(chalk26.cyan("[dry-run] Would import bundle to: " + skillsDir + "\n"));
+      return 0;
+    }
+    const result = importBundle(this.source, skillsDir, { overwrite: this.overwrite });
+    if (!result.success && result.imported.length === 0) {
+      this.context.stderr.write(chalk26.red("\u2717 Failed to import bundle:\n"));
+      for (const error of result.errors) {
+        this.context.stderr.write(chalk26.red(`  - ${error}
+`));
+      }
+      return 1;
+    }
+    this.context.stdout.write(chalk26.green(`\u2713 Imported ${result.imported.length} skills from bundle!
+`));
+    for (const name of result.imported) {
+      this.context.stdout.write(chalk26.gray(`  + ${name}
+`));
+    }
+    if (result.errors.length > 0) {
+      this.context.stdout.write(chalk26.yellow("\nWarnings:\n"));
+      for (const error of result.errors) {
+        this.context.stdout.write(chalk26.yellow(`  - ${error}
+`));
+      }
+    }
+    return 0;
+  }
+};
+
+// src/commands/plugin.ts
+import { Command as Command28, Option as Option27 } from "clipanion";
+import { join as join10, isAbsolute, resolve as resolve11, sep } from "path";
+import { homedir } from "os";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, copyFileSync, cpSync as cpSync3, rmSync as rmSync4 } from "fs";
+import chalk27 from "chalk";
+import { createPluginManager, loadPlugin, loadPluginsFromDirectory } from "@skillkit/core";
+var PluginCommand = class extends Command28 {
+  static paths = [["plugin"]];
+  static usage = Command28.Usage({
+    description: "Manage SkillKit plugins",
+    examples: [
+      ["List installed plugins", "$0 plugin list"],
+      ["Install a plugin", "$0 plugin install --source ./my-plugin"],
+      ["Install from npm", "$0 plugin install --source skillkit-plugin-gitlab"],
+      ["Uninstall a plugin", "$0 plugin uninstall --name my-plugin"],
+      ["Enable a plugin", "$0 plugin enable --name my-plugin"],
+      ["Disable a plugin", "$0 plugin disable --name my-plugin"]
+    ]
+  });
+  action = Option27.String({ required: true });
+  source = Option27.String("--source,-s", { description: "Plugin source (file path or npm package)" });
+  name = Option27.String("--name,-n", { description: "Plugin name" });
+  global = Option27.Boolean("--global,-g", { description: "Use global plugin directory" });
+  async execute() {
+    const projectPath = this.global ? join10(homedir(), ".skillkit") : process.cwd();
+    const pluginManager = createPluginManager(projectPath);
+    const pluginsDir = this.global ? join10(projectPath, "plugins") : join10(projectPath, ".skillkit", "plugins");
+    try {
+      const plugins = await loadPluginsFromDirectory(pluginsDir);
+      for (const plugin of plugins) {
+        if (pluginManager.isPluginEnabled(plugin.metadata.name)) {
+          await pluginManager.register(plugin);
+        }
+      }
+    } catch {
+    }
+    try {
+      switch (this.action) {
+        case "list":
+          return this.listPlugins(pluginManager);
+        case "install":
+          return await this.installPlugin(pluginManager);
+        case "uninstall":
+          return await this.uninstallPlugin(pluginManager);
+        case "enable":
+          return this.enablePlugin(pluginManager);
+        case "disable":
+          return this.disablePlugin(pluginManager);
+        case "info":
+          return this.pluginInfo(pluginManager);
+        default:
+          this.context.stderr.write(chalk27.red(`Unknown action: ${this.action}
+`));
+          this.context.stderr.write("Available actions: list, install, uninstall, enable, disable, info\n");
+          return 1;
+      }
+    } catch (err) {
+      this.context.stderr.write(chalk27.red(`\u2717 ${err instanceof Error ? err.message : "Unknown error"}
+`));
+      return 1;
+    }
+  }
+  listPlugins(pluginManager) {
+    const plugins = pluginManager.listPlugins();
+    if (plugins.length === 0) {
+      this.context.stdout.write("No plugins installed.\n");
+      this.context.stdout.write("Use `skillkit plugin install --source <source>` to install a plugin.\n");
+      return 0;
+    }
+    this.context.stdout.write(chalk27.cyan(`Installed Plugins (${plugins.length}):
+
+`));
+    for (const plugin of plugins) {
+      const enabled = pluginManager.isPluginEnabled(plugin.name);
+      const status = enabled ? chalk27.green("enabled") : chalk27.gray("disabled");
+      this.context.stdout.write(chalk27.cyan(`  ${plugin.name}`) + ` v${plugin.version} [${status}]
+`);
+      if (plugin.description) {
+        this.context.stdout.write(chalk27.gray(`    ${plugin.description}
+`));
+      }
+    }
+    const translators = pluginManager.getAllTranslators();
+    const providers = pluginManager.getAllProviders();
+    const commands = pluginManager.getAllCommands();
+    if (translators.size > 0 || providers.size > 0 || commands.length > 0) {
+      this.context.stdout.write(chalk27.cyan("\nRegistered Extensions:\n"));
+      if (translators.size > 0) {
+        this.context.stdout.write(`  Translators: ${Array.from(translators.keys()).join(", ")}
+`);
+      }
+      if (providers.size > 0) {
+        this.context.stdout.write(`  Providers: ${Array.from(providers.keys()).join(", ")}
+`);
+      }
+      if (commands.length > 0) {
+        this.context.stdout.write(`  Commands: ${commands.map((c) => c.name).join(", ")}
+`);
+      }
+    }
+    return 0;
+  }
+  /**
+   * Validate plugin name to prevent path traversal attacks
+   * Allows scoped npm names like @scope/name (mirrors loader.ts validation)
+   */
+  isValidPluginName(name) {
+    if (!name) return false;
+    if (name.includes("\\") || name.includes("..") || name === "." || name.startsWith(".")) {
+      return false;
+    }
+    return /^(?:@[a-z0-9-]+\/)?[a-z0-9-]+$/.test(name);
+  }
+  async installPlugin(pluginManager) {
+    if (!this.source) {
+      this.context.stderr.write(chalk27.red("--source is required for install\n"));
+      return 1;
+    }
+    const resolvedSource = this.source.startsWith("~") ? join10(homedir(), this.source.slice(1)) : this.source;
+    this.context.stdout.write(`Installing plugin from ${this.source}...
+`);
+    const plugin = await loadPlugin(resolvedSource);
+    const pluginName = plugin.metadata.name;
+    if (!this.isValidPluginName(pluginName)) {
+      this.context.stderr.write(chalk27.red(`Invalid plugin name: ${pluginName}
+`));
+      return 1;
+    }
+    const projectPath = this.global ? join10(homedir(), ".skillkit") : process.cwd();
+    const pluginsDir = this.global ? join10(projectPath, "plugins") : join10(projectPath, ".skillkit", "plugins");
+    const isLocalPath3 = this.source.startsWith("./") || this.source.startsWith("../") || this.source.startsWith("/") || this.source.startsWith("~") || this.source.includes("\\") || isAbsolute(this.source);
+    if (isLocalPath3 && existsSync12(resolvedSource)) {
+      const targetDir = join10(pluginsDir, pluginName);
+      const resolvedTarget = resolve11(targetDir);
+      const resolvedPluginsDir = resolve11(pluginsDir);
+      if (!resolvedTarget.startsWith(resolvedPluginsDir + sep)) {
+        this.context.stderr.write(chalk27.red("Invalid plugin name\n"));
+        return 1;
+      }
+      if (!existsSync12(pluginsDir)) {
+        mkdirSync6(pluginsDir, { recursive: true });
+      }
+      const { statSync: statSync2 } = await import("fs");
+      const sourceStat = statSync2(resolvedSource);
+      if (sourceStat.isDirectory()) {
+        cpSync3(resolvedSource, targetDir, { recursive: true });
+      } else {
+        if (!existsSync12(targetDir)) {
+          mkdirSync6(targetDir, { recursive: true });
+        }
+        let destFileName;
+        if (resolvedSource.endsWith(".json")) {
+          destFileName = "plugin.json";
+        } else if (resolvedSource.endsWith(".mjs")) {
+          destFileName = "index.mjs";
+        } else {
+          destFileName = "index.js";
+        }
+        copyFileSync(resolvedSource, join10(targetDir, destFileName));
+      }
+      this.context.stdout.write(chalk27.dim(`  Copied to ${targetDir}
+`));
+    }
+    await pluginManager.register(plugin);
+    this.context.stdout.write(chalk27.green(`\u2713 Plugin "${plugin.metadata.name}" installed!
+`));
+    this.context.stdout.write(`  Version: ${plugin.metadata.version}
+`);
+    if (plugin.metadata.description) {
+      this.context.stdout.write(`  ${plugin.metadata.description}
+`);
+    }
+    if (plugin.translators?.length) {
+      this.context.stdout.write(`  Translators: ${plugin.translators.map((t) => t.agentType).join(", ")}
+`);
+    }
+    if (plugin.providers?.length) {
+      this.context.stdout.write(`  Providers: ${plugin.providers.map((p) => p.providerName).join(", ")}
+`);
+    }
+    if (plugin.commands?.length) {
+      this.context.stdout.write(`  Commands: ${plugin.commands.map((c) => c.name).join(", ")}
+`);
+    }
+    return 0;
+  }
+  async uninstallPlugin(pluginManager) {
+    if (!this.name) {
+      this.context.stderr.write(chalk27.red("--name is required for uninstall\n"));
+      return 1;
+    }
+    if (!this.isValidPluginName(this.name)) {
+      this.context.stderr.write(chalk27.red("Invalid plugin name\n"));
+      return 1;
+    }
+    await pluginManager.unregister(this.name);
+    const projectPath = this.global ? join10(homedir(), ".skillkit") : process.cwd();
+    const pluginsDir = this.global ? join10(projectPath, "plugins") : join10(projectPath, ".skillkit", "plugins");
+    const pluginDir = join10(pluginsDir, this.name);
+    const resolvedPluginDir = resolve11(pluginDir);
+    const resolvedPluginsDir = resolve11(pluginsDir);
+    if (!resolvedPluginDir.startsWith(resolvedPluginsDir + sep)) {
+      this.context.stderr.write(chalk27.red("Invalid plugin name\n"));
+      return 1;
+    }
+    if (existsSync12(pluginDir)) {
+      rmSync4(pluginDir, { recursive: true, force: true });
+      this.context.stdout.write(chalk27.dim(`  Removed ${pluginDir}
+`));
+    }
+    this.context.stdout.write(chalk27.green(`\u2713 Plugin "${this.name}" uninstalled.
+`));
+    return 0;
+  }
+  enablePlugin(pluginManager) {
+    if (!this.name) {
+      this.context.stderr.write(chalk27.red("--name is required for enable\n"));
+      return 1;
+    }
+    pluginManager.enablePlugin(this.name);
+    this.context.stdout.write(chalk27.green(`\u2713 Plugin "${this.name}" enabled.
+`));
+    return 0;
+  }
+  disablePlugin(pluginManager) {
+    if (!this.name) {
+      this.context.stderr.write(chalk27.red("--name is required for disable\n"));
+      return 1;
+    }
+    pluginManager.disablePlugin(this.name);
+    this.context.stdout.write(chalk27.green(`\u2713 Plugin "${this.name}" disabled.
+`));
+    return 0;
+  }
+  pluginInfo(pluginManager) {
+    if (!this.name) {
+      this.context.stderr.write(chalk27.red("--name is required for info\n"));
+      return 1;
+    }
+    const plugin = pluginManager.getPlugin(this.name);
+    if (!plugin) {
+      this.context.stderr.write(chalk27.red(`Plugin "${this.name}" not found.
+`));
+      return 1;
+    }
+    const { metadata } = plugin;
+    const enabled = pluginManager.isPluginEnabled(this.name);
+    this.context.stdout.write(chalk27.cyan(`${metadata.name}`) + ` v${metadata.version}
+`);
+    this.context.stdout.write(`Status: ${enabled ? "enabled" : "disabled"}
+`);
+    if (metadata.description) {
+      this.context.stdout.write(`Description: ${metadata.description}
+`);
+    }
+    if (metadata.author) {
+      this.context.stdout.write(`Author: ${metadata.author}
+`);
+    }
+    if (metadata.homepage) {
+      this.context.stdout.write(`Homepage: ${metadata.homepage}
+`);
+    }
+    if (metadata.keywords?.length) {
+      this.context.stdout.write(`Keywords: ${metadata.keywords.join(", ")}
+`);
+    }
+    if (metadata.dependencies?.length) {
+      this.context.stdout.write(`Dependencies: ${metadata.dependencies.join(", ")}
+`);
+    }
+    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,
   RemoveCommand,
   ResumeCommand,
   RunCommand,
+  SettingsCommand,
   StatusCommand,
   SyncCommand,
+  TeamCommand,
   TestCommand,
   TranslateCommand,
   UICommand,