@skillkit/cli 1.4.0 → 1.5.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) {
@@ -3764,12 +3803,12 @@ ${learning.title}
     }
     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 { existsSync: existsSync13, mkdirSync: mkdirSync7, writeFileSync: writeFileSync6 } = await import("fs");
     const outputDir = dirname3(outputPath);
-    if (!existsSync11(outputDir)) {
-      mkdirSync5(outputDir, { recursive: true });
+    if (!existsSync13(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: existsSync13, readFileSync: readFileSync7 } = await import("fs");
+    const { resolve: resolve12 } = await import("path");
+    const fullPath = resolve12(inputPath);
+    if (!existsSync13(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,7 +4079,1164 @@ ${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: existsSync13, readFileSync: readFileSync7, writeFileSync: writeFileSync6 } = await import("fs");
+    if (!existsSync13(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: existsSync13 } = await import("fs");
+    if (!existsSync13(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;
+  }
+};
 export {
+  CICDCommand,
   ContextCommand,
   CreateCommand,
   DisableCommand,
@@ -4051,13 +5247,16 @@ export {
   MarketplaceCommand,
   MemoryCommand,
   PauseCommand,
+  PluginCommand,
   ReadCommand,
   RecommendCommand,
   RemoveCommand,
   ResumeCommand,
   RunCommand,
+  SettingsCommand,
   StatusCommand,
   SyncCommand,
+  TeamCommand,
   TestCommand,
   TranslateCommand,
   UICommand,