@tdsoft-tech/aikit 0.1.12 → 0.1.13

package/dist/cli.js

@@ -803,8 +803,8 @@ var init_memory = __esm({
           const subDir = type === "observation" ? "observations" : type === "handoff" ? "handoffs" : type === "research" ? "research" : "";
           filePath = join8(memoryPath, subDir, `${key}.md`);
         }
-        const { dirname: dirname4 } = await import("path");
-        await mkdir4(dirname4(filePath), { recursive: true });
+        const { dirname: dirname5 } = await import("path");
+        await mkdir4(dirname5(filePath), { recursive: true });
         if (options?.append) {
           try {
             const existing = await readFile5(filePath, "utf-8");
@@ -934,8 +934,8 @@ var tool_config_exports = {};
 __export(tool_config_exports, {
   ToolConfigManager: () => ToolConfigManager
 });
-import { readFile as readFile11, writeFile as writeFile12, mkdir as mkdir10, access as access4, constants as constants4 } from "fs/promises";
-import { join as join17 } from "path";
+import { readFile as readFile12, writeFile as writeFile13, mkdir as mkdir11, access as access5, constants as constants4 } from "fs/promises";
+import { join as join18 } from "path";
 import { z as z3 } from "zod";
 var ToolConfigSchema, REGISTERED_TOOLS, ToolConfigManager;
 var init_tool_config = __esm({
@@ -963,7 +963,7 @@ var init_tool_config = __esm({
       toolsConfigPath;
       constructor(config) {
         this.config = config;
-        this.toolsConfigPath = join17(this.config.configPath, "config", "tools.json");
+        this.toolsConfigPath = join18(this.config.configPath, "config", "tools.json");
       }
       /**
        * Get all registered tools with their current status
@@ -1046,8 +1046,8 @@ var init_tool_config = __esm({
        */
       async loadConfigs() {
         try {
-          await access4(this.toolsConfigPath, constants4.R_OK);
-          const content = await readFile11(this.toolsConfigPath, "utf-8");
+          await access5(this.toolsConfigPath, constants4.R_OK);
+          const content = await readFile12(this.toolsConfigPath, "utf-8");
           return JSON.parse(content);
         } catch {
           return {};
@@ -1057,9 +1057,9 @@ var init_tool_config = __esm({
        * Save configurations
        */
       async saveConfigs(configs) {
-        const configDir = join17(this.config.configPath, "config");
-        await mkdir10(configDir, { recursive: true });
-        await writeFile12(this.toolsConfigPath, JSON.stringify(configs, null, 2));
+        const configDir = join18(this.config.configPath, "config");
+        await mkdir11(configDir, { recursive: true });
+        await writeFile13(this.toolsConfigPath, JSON.stringify(configs, null, 2));
       }
     };
   }
@@ -1196,9 +1196,10 @@ var init_figma_oauth = __esm({
 
 // src/cli.ts
 init_esm_shims();
+
+// src/cli/index.ts
+init_esm_shims();
 import { Command } from "commander";
-import chalk3 from "chalk";
-import inquirer2 from "inquirer";
 
 // src/index.ts
 init_esm_shims();
@@ -1266,7 +1267,8 @@ var ConfigSchema = z.object({
     context7: z.boolean().default(false),
     githubGrep: z.boolean().default(false),
     gkg: z.boolean().default(false)
-  }).optional()
+  }).optional(),
+  mode: z.string().default("build").optional()
 });
 var Config = class {
   config;
@@ -1300,6 +1302,9 @@ var Config = class {
   get antiHallucination() {
     return this.config.antiHallucination;
   }
+  get mode() {
+    return this.config.mode;
+  }
   get configPath() {
     return this.config.configPath;
   }
@@ -4240,8 +4245,13 @@ init_logger();
 init_logger();
 init_paths();
 
-// src/cli.ts
-init_memory();
+// src/cli/commands/index.ts
+init_esm_shims();
+
+// src/cli/commands/init.ts
+init_esm_shims();
+import chalk2 from "chalk";
+import inquirer from "inquirer";
 
 // src/utils/cli-detector.ts
 init_esm_shims();
@@ -4358,702 +4368,1318 @@ var CliDetector = class {
   }
 };
 
-// src/cli.ts
+// src/cli/commands/init.ts
 init_logger();
 init_paths();
 
-// src/core/sync-engine.ts
-init_esm_shims();
-import { readFile as readFile10, writeFile as writeFile11, copyFile, mkdir as mkdir9 } from "fs/promises";
-import { join as join16, dirname as dirname3 } from "path";
-import inquirer from "inquirer";
-import chalk2 from "chalk";
-
-// src/core/version-manager.ts
+// src/cli/helpers.ts
 init_esm_shims();
-init_paths();
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir8, writeFile as writeFile8, readFile as readFile7, access as access4 } from "fs/promises";
+import { join as join13, dirname as dirname2 } from "path";
+import { homedir as homedir3 } from "os";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { execSync as execSync2 } from "child_process";
 init_logger();
-import { readFile as readFile7, readdir as readdir7, writeFile as writeFile8, stat } from "fs/promises";
-import { join as join13 } from "path";
-import { createHash } from "crypto";
-var VersionManager = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Get current installed version
-   */
-  async getCurrentVersion() {
-    const versionPath = join13(paths.globalConfig(), ".version.json");
-    try {
-      const content = await readFile7(versionPath, "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Get package version from package.json
-   */
-  getPackageVersion() {
-    try {
-      const packageJson = __require(join13(process.cwd(), "package.json"));
-      return packageJson.version || "0.0.0";
-    } catch {
-      return "0.0.0";
-    }
-  }
-  /**
-   * Check for updates
-   */
-  async checkForUpdates() {
-    const installed = await this.getCurrentVersion();
-    const packageVersion = this.getPackageVersion();
-    if (!installed) {
-      return {
-        hasUpdate: true,
-        fromVersion: "none",
-        toVersion: packageVersion,
-        newSkills: [],
-        modifiedSkills: [],
-        removedSkills: [],
-        conflicts: [],
-        configChanges: ["Initial version tracking"]
-      };
-    }
-    const hasUpdate = installed.installedVersion !== packageVersion;
-    if (!hasUpdate) {
-      return {
-        hasUpdate: false,
-        fromVersion: installed.installedVersion,
-        toVersion: packageVersion,
-        newSkills: [],
-        modifiedSkills: [],
-        removedSkills: [],
-        conflicts: [],
-        configChanges: []
-      };
-    }
-    const changes = await this.detectChanges();
-    return {
-      hasUpdate: true,
-      fromVersion: installed.installedVersion,
-      toVersion: packageVersion,
-      ...changes
-    };
+init_paths();
+async function initializeConfig(configDir, _isGlobal) {
+  const dirs = [
+    "",
+    "skills",
+    "agents",
+    "commands",
+    "commands/build",
+    "commands/git",
+    "commands/plan",
+    "commands/research",
+    "tools",
+    "plugins",
+    "memory",
+    "memory/_templates",
+    "memory/handoffs",
+    "memory/observations",
+    "memory/research"
+  ];
+  for (const dir of dirs) {
+    await mkdir8(join13(configDir, dir), { recursive: true });
   }
-  /**
-   * Detect changes between versions
-   */
-  async detectChanges() {
-    const globalSkillsPath = paths.skills(paths.globalConfig());
-    const projectSkillsPath = paths.skills(this.config.configPath);
-    const sourceSkills = await this.loadSkillHashes(globalSkillsPath);
-    const userSkills = await this.loadSkillHashes(projectSkillsPath);
-    const newSkills = [];
-    const modifiedSkills = [];
-    const removedSkills = [];
-    const conflicts = [];
-    const installedSkills = /* @__PURE__ */ new Map();
-    const installedPath = join13(paths.globalConfig(), ".installed-skills.json");
+  const defaultConfig = {
+    version: getVersion(),
+    skills: { enabled: true },
+    agents: { enabled: true, default: "build" },
+    commands: { enabled: true },
+    tools: { enabled: true },
+    plugins: { enabled: true },
+    memory: { enabled: true },
+    beads: { enabled: true },
+    antiHallucination: { enabled: true }
+  };
+  await writeFile8(
+    join13(configDir, "aikit.json"),
+    JSON.stringify(defaultConfig, null, 2)
+  );
+  const agentsMd = `# AIKit Agent Rules
+
+## Build Commands
+- \`npm run build\` - Build the project
+- \`npm run test\` - Run tests
+- \`npm run lint\` - Run linting
+
+## Code Style
+- Use 2 spaces for indentation
+- Use single quotes for strings
+- Add trailing commas
+
+## Naming Conventions
+- Variables: camelCase
+- Components: PascalCase
+- Files: kebab-case
+
+## Project-Specific Rules
+Add your project-specific rules here.
+`;
+  await writeFile8(join13(configDir, "AGENTS.md"), agentsMd);
+}
+async function configureMcpServer(projectPath) {
+  const currentFile = fileURLToPath3(import.meta.url);
+  const currentDir = dirname2(currentFile);
+  const aikitPath = join13(currentDir, "..", "..");
+  const mcpServerPath = join13(aikitPath, "dist", "mcp-server.js");
+  const configLocations = [
+    // Global config (most common)
+    join13(homedir3(), ".config", "opencode", "opencode.json"),
+    // Project-level config
+    join13(projectPath, ".opencode", "opencode.json"),
+    // Alternative global location
+    join13(homedir3(), ".opencode", "opencode.json")
+  ];
+  const mcpServerConfig = {
+    type: "local",
+    command: ["node", mcpServerPath],
+    environment: {}
+  };
+  for (const configPath of configLocations) {
     try {
-      const installedData = await readFile7(installedPath, "utf-8");
-      const installedList = JSON.parse(installedData);
-      installedList.forEach((skill) => {
-        installedSkills.set(skill.name, skill);
-      });
-    } catch {
-    }
-    for (const sourceSkill of sourceSkills) {
-      const installed = installedSkills.get(sourceSkill.name);
-      const user = userSkills.find((s) => s.name === sourceSkill.name);
-      if (!installed) {
-        newSkills.push(sourceSkill);
-      } else if (installed.hash !== sourceSkill.hash) {
-        modifiedSkills.push(sourceSkill);
-        if (user && user.hash !== installed.hash) {
-          conflicts.push({
-            skillName: sourceSkill.name,
-            userHash: user.hash,
-            sourceHash: sourceSkill.hash,
-            installedHash: installed.hash,
-            userModified: user.hash !== installed.hash,
-            sourceModified: sourceSkill.hash !== installed.hash
-          });
+      const configDir = join13(configPath, "..");
+      await mkdir8(configDir, { recursive: true });
+      let config = {};
+      if (existsSync5(configPath)) {
+        try {
+          const existing = await readFile7(configPath, "utf-8");
+          config = JSON.parse(existing);
+        } catch {
+          config = {};
         }
       }
-    }
-    for (const [name, installedSkill] of installedSkills.entries()) {
-      const existsInSource = sourceSkills.find((s) => s.name === name);
-      if (!existsInSource) {
-        removedSkills.push(installedSkill);
+      if (!config.mcp) {
+        config.mcp = {};
       }
+      config.mcp.aikit = mcpServerConfig;
+      await writeFile8(configPath, JSON.stringify(config, null, 2));
+      logger.success(`
+\u2705 MCP server configured: ${configPath}`);
+      logger.info(`   Server: node ${mcpServerPath}`);
+      return;
+    } catch {
+      continue;
     }
-    return {
-      newSkills,
-      modifiedSkills,
-      removedSkills,
-      conflicts,
-      configChanges: []
-      // Will be detected separately
-    };
   }
-  /**
-   * Load skill hashes from directory
-   */
-  async loadSkillHashes(skillsPath) {
-    const hashes = [];
-    try {
-      const loadFromDir = async (dir) => {
-        const files = await readdir7(dir);
-        for (const file of files) {
-          const filePath = join13(dir, file);
-          const stats = await stat(filePath);
-          if (stats.isDirectory()) {
-            await loadFromDir(filePath);
-          } else if (file.endsWith(".md")) {
-            const hash = await this.calculateSkillHash(filePath);
-            hashes.push({
-              path: filePath,
-              name: file.replace(".md", ""),
-              hash,
-              category: this.extractCategory(dir, skillsPath)
-            });
-          }
-        }
-      };
-      await loadFromDir(skillsPath);
-    } catch (error) {
-      logger.debug(`Could not load skills from ${skillsPath}:`, error);
+  const instructionsPath = join13(projectPath, ".opencode", "MCP_SETUP.md");
+  await mkdir8(join13(projectPath, ".opencode"), { recursive: true });
+  await writeFile8(instructionsPath, `# AIKit MCP Server Configuration
+
+## Automatic Setup Failed
+
+Please manually configure the MCP server in OpenCode.
+
+## Configuration
+
+Add this to your OpenCode configuration file (\`~/.config/opencode/opencode.json\`):
+
+\`\`\`json
+{
+  "mcpServers": {
+    "aikit": {
+      "command": "node",
+      "args": ["${mcpServerPath}"],
+      "env": {}
     }
-    return hashes;
   }
-  /**
-   * Calculate hash for a skill file
-   */
-  async calculateSkillHash(filePath) {
-    try {
-      const content = await readFile7(filePath, "utf-8");
-      return createHash("sha256").update(content).digest("hex");
-    } catch {
-      return "";
-    }
-  }
-  /**
-   * Extract category from path
-   */
-  extractCategory(filePath, basePath) {
-    const relative = filePath.replace(basePath + "/", "");
-    const parts = relative.split("/");
-    if (parts.length > 1) {
-      return parts[0];
+}
+\`\`\`
+
+## After Configuration
+
+1. Restart OpenCode completely
+2. OpenCode will automatically start the MCP server
+3. Tools will be available via MCP protocol
+4. You can use tools like \`tool_read_figma_design\` directly
+
+## Verify
+
+After restarting OpenCode, check:
+- MCP server is running (check OpenCode settings)
+- Tools are discoverable (OpenCode should list them)
+- You can call tools via MCP protocol
+`);
+  logger.warn(`
+\u26A0\uFE0F  Could not auto-configure MCP server. See: ${instructionsPath}`);
+}
+async function installCliTool(tool) {
+  try {
+    logger.info(`Installing ${tool.displayName}...`);
+    switch (tool.name) {
+      case "opencode" /* OPENCODE */:
+        await installToOpenCode(paths.opencodeConfig());
+        break;
+      case "claude" /* CLAUDE */:
+        execSync2("npm install -g @anthropic-ai/claude-code", { stdio: "inherit" });
+        break;
+      case "github" /* GITHUB */:
+        execSync2("npm install -g gh", { stdio: "inherit" });
+        break;
     }
-    return "uncategorized";
+    logger.success(`\u2713 ${tool.displayName} installed`);
+    return true;
+  } catch (error) {
+    logger.error(`Failed to install ${tool.displayName}:`, error);
+    return false;
   }
-  /**
-   * Save installed skills info
-   */
-  async saveInstalledSkills(skills) {
-    const installedPath = join13(paths.globalConfig(), ".installed-skills.json");
+}
+var AGENT_FILES = {
+  rush: `---
+description: Fast execution for small/urgent changes with minimal planning.
+mode: subagent
+tools:
+  "*": true
+---
+
+Use for quick fixes, hotfixes, or tiny edits. Keep scope minimal and verify quickly.`,
+  review: `---
+description: Code review and quality/security auditing agent.
+mode: subagent
+tools:
+  "*": true
+---
+
+Use to review correctness, security, performance, maintainability, and tests. Be specific
+about issues and suggest concrete fixes.`,
+  scout: `---
+description: Research agent for external docs, patterns, and references.
+mode: subagent
+tools:
+  "*": true
+---
+
+Use to look up docs, examples, best practices. Summarize findings concisely and cite sources.`,
+  explore: `---
+description: Codebase navigation agent (search, grep, structure understanding).
+mode: subagent
+tools:
+  "*": true
+---
+
+Use to locate files, patterns, dependencies, and gather quick context in the repo.`,
+  vision: `---
+description: Visual analysis agent for mockups, screenshots, PDFs, diagrams.
+mode: subagent
+tools:
+  "*": true
+---
+
+Use to interpret visual assets (components, layout, colors, typography) and translate to tasks.`,
+  "one-shot": `---
+description: End-to-end autonomous task execution (beta). Complete tasks from start to finish.
+mode: subagent
+tools:
+  "*": true
+---
+
+\u26A0\uFE0F BETA: This mode is experimental. Use for straightforward tasks first.
+
+## One-Shot Mode - Autonomous Task Execution
+
+Execute tasks end-to-end with minimal intervention:
+
+### Workflow Phases
+1. **REQUIREMENTS** - Gather task type, scope, dependencies, success criteria
+2. **PLANNING** - Create detailed plan, recommend skills/tools, create tracking bead
+3. **COMPLEXITY** - Auto-split if: >30min, >10 files, >500 lines, >2 sub-systems
+4. **EXECUTION** - Parallel tasks (max 3), dynamic agent delegation
+5. **TESTING** - Run until pass: typecheck \u2192 test \u2192 lint \u2192 build (max 3 retries)
+6. **VERIFICATION** - Quality gates \u2713 \u2192 Manual verification \u2192 Deployment approval
+7. **COMPLETION** - Generate proof, update tracking, collect feedback
+
+### Quality Gates (ALL must pass)
+- \`npm run typecheck\` - No type errors
+- \`npm run test\` - All tests pass
+- \`npm run lint\` - No lint errors
+- \`npm run build\` - Build succeeds
+
+### Error Recovery (3 Levels)
+- **Level 1**: Auto-fix (type errors, lint --fix)
+- **Level 2**: Alternative approach via @review
+- **Level 3**: User intervention + follow-up task
+
+### Delegates To
+@planner for planning, @build for implementation, @review for code review,
+@scout for research, @explore for navigation, @vision for visual analysis.
+
+### Best Use Cases
+- Straightforward features with clear scope
+- Bug fixes with known reproduction steps
+- Refactoring with defined boundaries
+
+### Consider Alternatives For
+- Complex multi-system features \u2192 Use /plan + /implement
+- Exploratory research \u2192 Use /research first
+- Critical production changes \u2192 Manual with /review`
+};
+function generateAnalyzeFigmaCommand() {
+  return `# Command: /analyze-figma
+
+## Description
+Analyze a Figma design and extract design tokens
+
+## Usage
+\`/analyze-figma <figma-url>\`
+
+## Examples
+- \`/analyze-figma https://www.figma.com/design/...\`
+
+## \u26A0\uFE0F CRITICAL: Extract URL FIRST!
+
+**BEFORE ANYTHING ELSE**: Look at the user's FULL input message (all lines) and find the Figma URL. It's ALWAYS there - never ask for it!
+
+**The URL pattern**: Look for text containing \`figma.com/design/\` anywhere in the user's message.
+
+**Example of what user input looks like**:
+\`\`\`
+/analyze-figma https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/
+Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0
+\`\`\`
+
+**Extract the complete URL** (combine if split):
+\`https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0\`
+
+## Workflow
+
+**IMPORTANT**: When user provides a Figma URL, you MUST immediately:
+
+**Step 1: Extract URL from User Input**
+
+**CRITICAL**: The URL is ALWAYS in the user's input message! DO NOT ask for it - just extract it!
+
+**MANDATORY**: You MUST extract the URL before proceeding. This is not optional!
+
+**How to Extract**:
+1. **Read the ENTIRE user input message** - look at ALL lines, not just the first line
+2. **Search for ANY text containing** \`figma.com/design/\` - this is the URL
+3. **URL may appear in different formats**:
+   - On same line: \`/analyze-figma https://www.figma.com/design/...\`
+   - Split across lines
+4. **Extract the COMPLETE URL**:
+   - Start from \`https://\` or \`http://\`
+   - Include everything until the end of the line or next whitespace
+   - If URL is split, combine ALL parts into one complete URL
+5. **Include ALL query parameters**: \`?node-id=...\`, \`&t=...\`, etc.
+
+**CRITICAL RULES**:
+- \u2705 DO: Read the ENTIRE user message (all lines)
+- \u2705 DO: Look for \`figma.com/design/\` anywhere in the message
+- \u2705 DO: Combine split lines into one URL
+- \u274C DO NOT: Ask user for URL - it's ALWAYS in the input
+- \u274C DO NOT: Skip this step - URL extraction is MANDATORY
+- \u274C DO NOT: Proceed without extracting URL first
+
+**Step 2: Check Tool Configuration**
+
+Before calling the tool, verify that Figma tool is configured:
+- If not configured, inform user to run: \`aikit skills figma-analysis config\`
+- The tool requires a Figma Personal Access Token
+
+**Step 3: Call MCP Tool read_figma_design**
+
+Use the MCP tool \`read_figma_design\` with the extracted URL:
+\`\`\`
+Use tool: read_figma_design
+Arguments: { "url": "[extracted URL]" }
+\`\`\`
+
+**Step 4: Format and Save**
+
+Format extracted tokens as structured markdown and save using memory-update tool.
+
+**Step 5: Report Results**
+
+Report what was extracted:
+- Number of screens found
+- Number of colors in palette
+- Typography styles found
+- Components identified
+
+## Critical Instructions
+
+- **DO NOT** ask user to "share the Figma URL" - they already provided it in the command
+- **DO NOT** wait for confirmation - just start analyzing immediately
+- **DO** extract URL from full user input message
+- **DO** call MCP tool \`read_figma_design\` immediately
+- **DO** save to memory automatically`;
+}
+async function installToOpenCode(_opencodePath) {
+  const projectPath = process.cwd();
+  const opencodeCommandDir = join13(projectPath, ".opencode", "command");
+  const aikitDir = join13(projectPath, ".aikit");
+  const opencodeAgentDir = join13(paths.opencodeConfig(), "agent");
+  await mkdir8(opencodeCommandDir, { recursive: true });
+  await mkdir8(join13(aikitDir, "skills"), { recursive: true });
+  await mkdir8(opencodeAgentDir, { recursive: true });
+  for (const [name, content] of Object.entries(AGENT_FILES)) {
+    const filePath = join13(opencodeAgentDir, `${name}.md`);
     try {
-      await writeFile8(installedPath, JSON.stringify(skills, null, 2));
-    } catch (error) {
-      logger.error("Failed to save installed skills info:", error);
+      await access4(filePath);
+      const existingContent = await readFile7(filePath, "utf8");
+      if (!existingContent.includes("mode: subagent")) {
+        const matter3 = await import("gray-matter");
+        const { data: frontmatter, content: body } = matter3.default(existingContent);
+        frontmatter.mode = "subagent";
+        const updatedContent = matter3.default.stringify(body, frontmatter);
+        await writeFile8(filePath, updatedContent, "utf8");
+      }
+    } catch {
+      await writeFile8(filePath, content, "utf8");
     }
   }
-  /**
-   * Update version file
-   */
-  async updateVersion(version, migration) {
-    const current = await this.getCurrentVersion() || {
-      installedVersion: "0.0.0",
-      lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
-      packageVersion: "0.0.0",
-      migrationHistory: []
-    };
-    const updated = {
-      installedVersion: version,
-      lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
-      packageVersion: this.getPackageVersion(),
-      migrationHistory: migration ? [...current.migrationHistory, migration] : current.migrationHistory
-    };
-    const versionPath = join13(paths.globalConfig(), ".version.json");
-    await writeFile8(versionPath, JSON.stringify(updated, null, 2));
-  }
-  /**
-   * Check if migration is needed
-   */
-  async needsMigration() {
-    const current = await this.getCurrentVersion();
-    const packageVersion = this.getPackageVersion();
-    return current?.installedVersion !== packageVersion;
-  }
-};
+  const config = await loadConfig();
+  const skillEngine = new SkillEngine(config);
+  const commandRunner = new CommandRunner(config);
+  const skills = await skillEngine.listSkills();
+  const commands = await commandRunner.listCommands();
+  const opencodeCommands = {};
+  const skillsList = skills.map((s) => `| \`/${s.name.replace(/\s+/g, "-")}\` | ${s.description} |`).join("\n");
+  opencodeCommands["skills"] = `List all available AIKit skills and how to use them.
 
-// src/core/backup-manager.ts
-init_esm_shims();
-init_logger();
-import { readFile as readFile8, writeFile as writeFile9, readdir as readdir8, stat as stat2, unlink, mkdir as mkdir8 } from "fs/promises";
-import { join as join14, dirname as dirname2 } from "path";
-import { createHash as createHash2 } from "crypto";
-var BackupManager = class {
-  configPath;
-  backupsDir;
-  maxBackups;
-  constructor(configPath, maxBackups = 5) {
-    this.configPath = configPath;
-    this.backupsDir = join14(configPath, ".backups");
-    this.maxBackups = maxBackups;
+READ .aikit/AGENTS.md
+
+## Available Skills
+
+| Command | Description |
+|---------|-------------|
+${skillsList}
+
+Type any command to use that skill. For example: \`/test-driven-development\` or \`/tdd\`.`;
+  for (const skill of skills) {
+    const commandName = skill.name.replace(/\s+/g, "-").toLowerCase();
+    const skillPath = skill.filePath;
+    const relativePath = skillPath.startsWith(projectPath) ? skillPath.replace(projectPath, "").replace(/\\/g, "/").replace(/^\//, "") : `.aikit/skills/${skill.name.replace(/\s+/g, "-").toLowerCase()}.md`;
+    const useWhen = skill.useWhen || `The user asks you to ${skill.name}`;
+    opencodeCommands[commandName] = `Use the **${skill.name} skill** ${useWhen.toLowerCase()}.
+
+READ ${relativePath}
+
+## Description
+${skill.description}
+
+## When to Use
+${useWhen}
+
+## Workflow
+${skill.content.split("\n").slice(0, 20).join("\n")}${skill.content.split("\n").length > 20 ? "\n\n... (see full skill file for complete workflow)" : ""}
+
+**IMPORTANT**: Follow this skill's workflow step by step. Do not skip steps.
+Complete the checklist at the end of the skill.`;
   }
-  /**
-   * Create backup before update
-   */
-  async createBackup(fromVersion, toVersion) {
-    try {
-      await mkdir8(this.backupsDir, { recursive: true });
-      const backupId = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-      const backupPath = join14(this.backupsDir, `${backupId}-v${toVersion}`);
-      await mkdir8(backupPath, { recursive: true });
-      logger.info(`Creating backup: ${backupPath}`);
-      const files = [];
-      const backupItems = [
-        "skills/",
-        "aikit.json",
-        "AGENTS.md",
-        "config/"
-      ];
-      for (const item of backupItems) {
-        const files2 = await this.backupItem(this.configPath, item, backupPath);
-        files2.push(...files2);
-      }
-      const manifest = {
-        backupId,
-        fromVersion,
-        toVersion,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        files,
-        success: true
-      };
-      const manifestPath = join14(backupPath, "backup-manifest.json");
-      await writeFile9(manifestPath, JSON.stringify(manifest, null, 2));
-      await this.cleanupOldBackups();
-      logger.success(`\u2713 Backup created: ${backupId}`);
-      return backupId;
-    } catch (error) {
-      logger.error("Failed to create backup:", error);
-      return null;
+  for (const cmd of commands) {
+    if (opencodeCommands[cmd.name]) continue;
+    const commandName = cmd.name.replace(/\//g, "").replace(/\s+/g, "-");
+    const examples = cmd.examples.map((e) => `- \`${e}\``).join("\n");
+    if (cmd.name === "analyze-figma") {
+      opencodeCommands[commandName] = generateAnalyzeFigmaCommand();
+    } else {
+      opencodeCommands[commandName] = `# Command: /${cmd.name}
+
+## Description
+${cmd.description}
+
+## Usage
+\`${cmd.usage}\`
+
+## Examples
+${examples}
+
+## Workflow
+${cmd.content}
+
+**Category**: ${cmd.category}`;
     }
   }
-  /**
-   * Backup a file or directory
-   */
-  async backupItem(sourceDir, item, targetDir) {
-    const sourcePath = join14(sourceDir, item);
-    const targetPath = join14(targetDir, item);
-    const files = [];
+  let count = 0;
+  for (const [name, content] of Object.entries(opencodeCommands)) {
+    const filePath = join13(opencodeCommandDir, `${name}.md`);
+    await writeFile8(filePath, content.trim());
+    logger.info(`  \u2713 Created /${name} command`);
+    count++;
+  }
+  logger.success(`
+Created ${count} OpenCode commands in .opencode/command/`);
+  await configureMcpServer(projectPath);
+  logger.info("\nUsage in OpenCode:");
+  logger.info("  Press Ctrl+K to open command picker");
+  logger.info("  Or type /skills to see all available skills");
+  logger.info(`  Available: ${skills.length} skills, ${commands.length} commands`);
+  logger.info("  MCP server configured - tools available via MCP protocol");
+}
+function groupBy(array, keyFn) {
+  return array.reduce((acc, item) => {
+    const key = keyFn(item);
+    if (!acc[key]) acc[key] = [];
+    acc[key].push(item);
+    return acc;
+  }, {});
+}
+
+// src/cli/commands/init.ts
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize AIKit configuration").option("-g, --global", "Initialize global configuration").option("-p, --project", "Initialize project-level configuration").action(async (options) => {
+    const configDir = options.global ? paths.globalConfig() : paths.projectConfig();
+    console.log(chalk2.bold("\n\u{1F680} AIKit Setup\n"));
+    logger.info(`Initializing AIKit in ${configDir}...`);
     try {
-      const stats = await stat2(sourcePath);
-      if (stats.isDirectory()) {
-        await mkdir8(targetPath, { recursive: true });
-        const entries = await readdir8(sourcePath);
-        for (const entry of entries) {
-          const entryFiles = await this.backupItem(sourcePath, entry, targetPath);
-          files.push(...entryFiles);
+      await initializeConfig(configDir, options.global);
+      logger.success("\u2713 Configuration created");
+      if (!options.global) {
+        const config = await loadConfig();
+        const engine = new SkillEngine(config);
+        const result = await engine.syncSkillsToProject();
+        if (result.count > 0) {
+          logger.success(`\u2713 Synced ${result.count} skills`);
         }
-      } else if (stats.isFile()) {
-        await mkdir8(dirname2(targetPath), { recursive: true });
-        await this.copyFile(sourcePath, targetPath);
-        const hash = await this.calculateHash(targetPath);
-        files.push({
-          path: item,
-          hash,
-          size: stats.size
-        });
+        console.log(chalk2.bold("\n\u{1F50D} Checking CLI tools...\n"));
+        const cliTools = await CliDetector.checkAll();
+        const installableTools = CliDetector.filterInstallable(cliTools);
+        for (const tool of cliTools) {
+          const status = tool.installed ? chalk2.green("\u2713 Installed") : chalk2.yellow("\u2717 Not installed");
+          const version = tool.version ? chalk2.gray(` (${tool.version})`) : "";
+          console.log(`  ${status} ${chalk2.cyan(tool.displayName)}${version}`);
+        }
+        if (installableTools.length > 0) {
+          console.log();
+          const { action } = await inquirer.prompt([
+            {
+              type: "list",
+              name: "action",
+              message: "How would you like to proceed?",
+              choices: [
+                {
+                  name: "all",
+                  value: "all",
+                  short: "a",
+                  message: "Install all missing CLI tools"
+                },
+                {
+                  name: "select",
+                  value: "select",
+                  short: "s",
+                  message: "Select specific tools to install (use space to select, Enter to confirm)"
+                },
+                {
+                  name: "skip",
+                  value: "skip",
+                  short: "n",
+                  message: "Skip CLI tool installation"
+                }
+              ],
+              default: "all"
+            }
+          ]);
+          if (action === "skip") {
+            console.log();
+            logger.info("Skipping CLI tool installation");
+          } else if (action === "all") {
+            console.log();
+            logger.info(`Installing ${installableTools.length} CLI tool(s)...`);
+            for (const tool of installableTools) {
+              await installCliTool(tool);
+            }
+            console.log();
+            logger.success("\u2713 CLI tools installed");
+          } else {
+            const { installTools } = await inquirer.prompt([
+              {
+                type: "checkbox",
+                name: "installTools",
+                message: "Select CLI tools to install (press Enter to skip):",
+                choices: installableTools.map((tool) => ({
+                  name: tool.name,
+                  value: tool,
+                  checked: true
+                  // Default to install all
+                }))
+              }
+            ]);
+            if (installTools.length > 0) {
+              console.log();
+              logger.info(`Installing ${installTools.length} CLI tool(s)...`);
+              for (const tool of installTools) {
+                await installCliTool(tool);
+              }
+              console.log();
+              logger.success("\u2713 CLI tools installed");
+            } else {
+              console.log();
+              logger.info("Skipping CLI tool installation");
+            }
+          }
+        } else {
+          console.log();
+          logger.success("\u2713 All CLI tools already installed");
+        }
+        const beads = new BeadsIntegration();
+        const beadsStatus = await beads.getStatus();
+        if (!beadsStatus.initialized) {
+          logger.info("Initializing .beads directory...");
+          await beads.initLocal();
+          logger.success("\u2713 .beads directory created");
+          if (!beadsStatus.installed) {
+            logger.info("Tip: Install Beads CLI globally for full functionality: npm install -g beads");
+          }
+        } else {
+          logger.info("Beads already initialized");
+        }
+        const opencodePath = paths.opencodeConfig();
+        await installToOpenCode(opencodePath);
+        console.log(chalk2.bold("\n\u2728 AIKit is ready!\n"));
+        console.log("Usage in OpenCode:");
+        console.log(chalk2.cyan("  /skills") + "  - List all available skills");
+        console.log(chalk2.cyan("  /plan") + "    - Create implementation plan");
+        console.log(chalk2.cyan("  /tdd") + "     - Test-driven development");
+        console.log(chalk2.cyan("  /debug") + "   - Systematic debugging");
+        console.log(chalk2.cyan("  /review") + "  - Code review checklist");
+        console.log(chalk2.cyan("  /git") + "     - Git workflow");
+        console.log(chalk2.cyan("  /frontend-aesthetics") + " - UI/UX guidelines");
+        console.log("\nPress " + chalk2.bold("Ctrl+K") + " in OpenCode to see all commands.\n");
       }
     } catch (error) {
-      logger.debug(`Could not backup ${item}:`, error);
+      logger.error("Failed to initialize AIKit:", error);
+      process.exit(1);
     }
-    return files;
-  }
-  /**
-   * Copy file with hash calculation
-   */
-  async copyFile(source, target) {
-    const content = await readFile8(source);
-    await writeFile9(target, content);
+  });
+}
+
+// src/cli/commands/install.ts
+init_esm_shims();
+init_logger();
+init_paths();
+function registerInstallCommand(program2) {
+  program2.command("install").description("Install AIKit to OpenCode configuration").action(async () => {
+    logger.info("Installing AIKit to OpenCode...");
+    try {
+      const opencodePath = paths.opencodeConfig();
+      await installToOpenCode(opencodePath);
+      logger.success("AIKit installed to OpenCode!");
+    } catch (error) {
+      logger.error("Failed to install:", error);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/sync.ts
+init_esm_shims();
+import chalk4 from "chalk";
+
+// src/core/sync-engine.ts
+init_esm_shims();
+import { readFile as readFile11, writeFile as writeFile12, copyFile, mkdir as mkdir10 } from "fs/promises";
+import { join as join17, dirname as dirname4 } from "path";
+import inquirer2 from "inquirer";
+import chalk3 from "chalk";
+
+// src/core/version-manager.ts
+init_esm_shims();
+init_paths();
+init_logger();
+import { readFile as readFile8, readdir as readdir7, writeFile as writeFile9, stat } from "fs/promises";
+import { join as join14 } from "path";
+import { createHash } from "crypto";
+var VersionManager = class {
+  config;
+  constructor(config) {
+    this.config = config;
   }
   /**
-   * Calculate file hash
+   * Get current installed version
    */
-  async calculateHash(filePath) {
+  async getCurrentVersion() {
+    const versionPath = join14(paths.globalConfig(), ".version.json");
     try {
-      const content = await readFile8(filePath);
-      return createHash2("sha256").update(content).digest("hex");
+      const content = await readFile8(versionPath, "utf-8");
+      return JSON.parse(content);
     } catch {
-      return "";
+      return null;
     }
   }
   /**
-   * List available backups
+   * Get package version from package.json
    */
-  async listBackups() {
+  getPackageVersion() {
     try {
-      const entries = await readdir8(this.backupsDir);
-      const backups = [];
-      for (const entry of entries) {
-        const backupPath = join14(this.backupsDir, entry);
-        const manifestPath = join14(backupPath, "backup-manifest.json");
-        try {
-          const manifestContent = await readFile8(manifestPath, "utf-8");
-          const manifest = JSON.parse(manifestContent);
-          const size = await this.calculateBackupSize(backupPath);
-          backups.push({
-            manifest,
-            path: backupPath,
-            size
-          });
-        } catch {
-        }
-      }
-      backups.sort(
-        (a, b) => new Date(b.manifest.timestamp).getTime() - new Date(a.manifest.timestamp).getTime()
-      );
-      return backups;
+      const packageJson = __require(join14(process.cwd(), "package.json"));
+      return packageJson.version || "0.0.0";
     } catch {
-      return [];
+      return "0.0.0";
     }
   }
   /**
-   * Calculate backup directory size
+   * Check for updates
    */
-  async calculateBackupSize(backupPath) {
-    let totalSize = 0;
-    try {
-      const calculate = async (dir) => {
-        const entries = await readdir8(dir);
-        for (const entry of entries) {
-          const entryPath = join14(dir, entry);
-          const stats = await stat2(entryPath);
-          if (stats.isDirectory()) {
-            await calculate(entryPath);
-          } else {
-            totalSize += stats.size;
-          }
-        }
+  async checkForUpdates() {
+    const installed = await this.getCurrentVersion();
+    const packageVersion = this.getPackageVersion();
+    if (!installed) {
+      return {
+        hasUpdate: true,
+        fromVersion: "none",
+        toVersion: packageVersion,
+        newSkills: [],
+        modifiedSkills: [],
+        removedSkills: [],
+        conflicts: [],
+        configChanges: ["Initial version tracking"]
       };
-      await calculate(backupPath);
-    } catch {
     }
-    return totalSize;
+    const hasUpdate = installed.installedVersion !== packageVersion;
+    if (!hasUpdate) {
+      return {
+        hasUpdate: false,
+        fromVersion: installed.installedVersion,
+        toVersion: packageVersion,
+        newSkills: [],
+        modifiedSkills: [],
+        removedSkills: [],
+        conflicts: [],
+        configChanges: []
+      };
+    }
+    const changes = await this.detectChanges();
+    return {
+      hasUpdate: true,
+      fromVersion: installed.installedVersion,
+      toVersion: packageVersion,
+      ...changes
+    };
   }
   /**
-   * Restore from backup
+   * Detect changes between versions
    */
-  async restoreBackup(backupId) {
+  async detectChanges() {
+    const globalSkillsPath = paths.skills(paths.globalConfig());
+    const projectSkillsPath = paths.skills(this.config.configPath);
+    const sourceSkills = await this.loadSkillHashes(globalSkillsPath);
+    const userSkills = await this.loadSkillHashes(projectSkillsPath);
+    const newSkills = [];
+    const modifiedSkills = [];
+    const removedSkills = [];
+    const conflicts = [];
+    const installedSkills = /* @__PURE__ */ new Map();
+    const installedPath = join14(paths.globalConfig(), ".installed-skills.json");
     try {
-      const backups = await this.listBackups();
-      const backup = backups.find((b) => b.manifest.backupId === backupId);
-      if (!backup) {
-        logger.error(`Backup not found: ${backupId}`);
-        return false;
-      }
-      logger.info(`Restoring from backup: ${backupId}`);
-      const isValid = await this.validateBackup(backup);
-      if (!isValid) {
-        logger.error("Backup validation failed");
-        return false;
+      const installedData = await readFile8(installedPath, "utf-8");
+      const installedList = JSON.parse(installedData);
+      installedList.forEach((skill) => {
+        installedSkills.set(skill.name, skill);
+      });
+    } catch {
+    }
+    for (const sourceSkill of sourceSkills) {
+      const installed = installedSkills.get(sourceSkill.name);
+      const user = userSkills.find((s) => s.name === sourceSkill.name);
+      if (!installed) {
+        newSkills.push(sourceSkill);
+      } else if (installed.hash !== sourceSkill.hash) {
+        modifiedSkills.push(sourceSkill);
+        if (user && user.hash !== installed.hash) {
+          conflicts.push({
+            skillName: sourceSkill.name,
+            userHash: user.hash,
+            sourceHash: sourceSkill.hash,
+            installedHash: installed.hash,
+            userModified: user.hash !== installed.hash,
+            sourceModified: sourceSkill.hash !== installed.hash
+          });
+        }
       }
-      for (const file of backup.manifest.files) {
-        const sourcePath = join14(backup.path, file.path);
-        const targetPath = join14(this.configPath, file.path);
-        await mkdir8(dirname2(targetPath), { recursive: true });
-        await this.copyFile(sourcePath, targetPath);
+    }
+    for (const [name, installedSkill] of installedSkills.entries()) {
+      const existsInSource = sourceSkills.find((s) => s.name === name);
+      if (!existsInSource) {
+        removedSkills.push(installedSkill);
       }
-      logger.success(`\u2713 Backup restored: ${backupId}`);
-      return true;
-    } catch (error) {
-      logger.error("Failed to restore backup:", error);
-      return false;
     }
+    return {
+      newSkills,
+      modifiedSkills,
+      removedSkills,
+      conflicts,
+      configChanges: []
+      // Will be detected separately
+    };
   }
   /**
-   * Validate backup integrity
+   * Load skill hashes from directory
    */
-  async validateBackup(backup) {
+  async loadSkillHashes(skillsPath) {
+    const hashes = [];
     try {
-      const manifestPath = join14(backup.path, "backup-manifest.json");
-      await readFile8(manifestPath, "utf-8");
-      for (const file of backup.manifest.files) {
-        const filePath = join14(backup.path, file.path);
-        await stat2(filePath);
-        const currentHash = await this.calculateHash(filePath);
-        if (currentHash !== file.hash) {
-          logger.warn(`File hash mismatch: ${file.path}`);
-          return false;
+      const loadFromDir = async (dir) => {
+        const files = await readdir7(dir);
+        for (const file of files) {
+          const filePath = join14(dir, file);
+          const stats = await stat(filePath);
+          if (stats.isDirectory()) {
+            await loadFromDir(filePath);
+          } else if (file.endsWith(".md")) {
+            const hash = await this.calculateSkillHash(filePath);
+            hashes.push({
+              path: filePath,
+              name: file.replace(".md", ""),
+              hash,
+              category: this.extractCategory(dir, skillsPath)
+            });
+          }
         }
-      }
-      return true;
+      };
+      await loadFromDir(skillsPath);
     } catch (error) {
-      logger.debug("Backup validation failed:", error);
-      return false;
+      logger.debug(`Could not load skills from ${skillsPath}:`, error);
     }
+    return hashes;
   }
   /**
-   * Delete backup
+   * Calculate hash for a skill file
    */
-  async deleteBackup(backupId) {
+  async calculateSkillHash(filePath) {
     try {
-      const backups = await this.listBackups();
-      const backup = backups.find((b) => b.manifest.backupId === backupId);
-      if (!backup) {
-        return false;
-      }
-      const entries = await readdir8(backup.path);
-      for (const entry of entries) {
-        const entryPath = join14(backup.path, entry);
-        const stats = await stat2(entryPath);
-        if (stats.isDirectory()) {
-          await this.removeDirectory(entryPath);
-        } else {
-          await unlink(entryPath);
-        }
-      }
-      logger.success(`\u2713 Backup deleted: ${backupId}`);
-      return true;
-    } catch (error) {
-      logger.error("Failed to delete backup:", error);
-      return false;
+      const content = await readFile8(filePath, "utf-8");
+      return createHash("sha256").update(content).digest("hex");
+    } catch {
+      return "";
     }
   }
   /**
-   * Remove directory recursively
+   * Extract category from path
    */
-  async removeDirectory(dirPath) {
-    const entries = await readdir8(dirPath);
-    for (const entry of entries) {
-      const entryPath = join14(dirPath, entry);
-      const stats = await stat2(entryPath);
-      if (stats.isDirectory()) {
-        await this.removeDirectory(entryPath);
-      } else {
-        await unlink(entryPath);
-      }
+  extractCategory(filePath, basePath) {
+    const relative = filePath.replace(basePath + "/", "");
+    const parts = relative.split("/");
+    if (parts.length > 1) {
+      return parts[0];
     }
-    await unlink(dirPath);
+    return "uncategorized";
   }
   /**
-   * Cleanup old backups (keep only maxBackups)
+   * Save installed skills info
    */
-  async cleanupOldBackups() {
+  async saveInstalledSkills(skills) {
+    const installedPath = join14(paths.globalConfig(), ".installed-skills.json");
     try {
-      const backups = await this.listBackups();
-      if (backups.length <= this.maxBackups) {
-        return;
-      }
-      const toDelete = backups.slice(this.maxBackups);
-      for (const backup of toDelete) {
-        await this.deleteBackup(backup.manifest.backupId);
-      }
-      logger.info(`Cleaned up ${toDelete.length} old backup(s)`);
+      await writeFile9(installedPath, JSON.stringify(skills, null, 2));
     } catch (error) {
-      logger.error("Failed to cleanup old backups:", error);
+      logger.error("Failed to save installed skills info:", error);
     }
   }
   /**
-   * Format backup size for display
+   * Update version file
    */
-  formatSize(bytes) {
-    const units = ["B", "KB", "MB", "GB"];
-    let size = bytes;
-    let unitIndex = 0;
-    while (size >= 1024 && unitIndex < units.length - 1) {
-      size /= 1024;
-      unitIndex++;
-    }
-    return `${size.toFixed(2)} ${units[unitIndex]}`;
+  async updateVersion(version, migration) {
+    const current = await this.getCurrentVersion() || {
+      installedVersion: "0.0.0",
+      lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
+      packageVersion: "0.0.0",
+      migrationHistory: []
+    };
+    const updated = {
+      installedVersion: version,
+      lastSynced: (/* @__PURE__ */ new Date()).toISOString(),
+      packageVersion: this.getPackageVersion(),
+      migrationHistory: migration ? [...current.migrationHistory, migration] : current.migrationHistory
+    };
+    const versionPath = join14(paths.globalConfig(), ".version.json");
+    await writeFile9(versionPath, JSON.stringify(updated, null, 2));
+  }
+  /**
+   * Check if migration is needed
+   */
+  async needsMigration() {
+    const current = await this.getCurrentVersion();
+    const packageVersion = this.getPackageVersion();
+    return current?.installedVersion !== packageVersion;
   }
 };
 
-// src/core/migration-manager.ts
+// src/core/backup-manager.ts
 init_esm_shims();
 init_logger();
-import { readFile as readFile9, writeFile as writeFile10, readdir as readdir9 } from "fs/promises";
-import { join as join15 } from "path";
-var MigrationManager = class {
+import { readFile as readFile9, writeFile as writeFile10, readdir as readdir8, stat as stat2, unlink, mkdir as mkdir9 } from "fs/promises";
+import { join as join15, dirname as dirname3 } from "path";
+import { createHash as createHash2 } from "crypto";
+var BackupManager = class {
   configPath;
-  migrationsDir;
-  constructor(configPath) {
+  backupsDir;
+  maxBackups;
+  constructor(configPath, maxBackups = 5) {
     this.configPath = configPath;
-    this.migrationsDir = join15(process.cwd(), "src/core/migrations");
+    this.backupsDir = join15(configPath, ".backups");
+    this.maxBackups = maxBackups;
   }
   /**
-   * Load all available migrations
+   * Create backup before update
    */
-  async loadMigrations() {
-    const migrations = [];
+  async createBackup(fromVersion, toVersion) {
     try {
-      const files = await readdir9(this.migrationsDir);
-      for (const file of files) {
-        if (file.endsWith(".js") && file.startsWith("migrate-")) {
-          try {
-            const module = await import(join15(this.migrationsDir, file));
-            const migration = module.default || module.migration;
-            if (migration) {
-              migrations.push(migration);
-            }
-          } catch (error) {
-            logger.warn(`Failed to load migration ${file}:`, error);
-          }
-        }
+      await mkdir9(this.backupsDir, { recursive: true });
+      const backupId = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+      const backupPath = join15(this.backupsDir, `${backupId}-v${toVersion}`);
+      await mkdir9(backupPath, { recursive: true });
+      logger.info(`Creating backup: ${backupPath}`);
+      const files = [];
+      const backupItems = [
+        "skills/",
+        "aikit.json",
+        "AGENTS.md",
+        "config/"
+      ];
+      for (const item of backupItems) {
+        const files2 = await this.backupItem(this.configPath, item, backupPath);
+        files2.push(...files2);
       }
+      const manifest = {
+        backupId,
+        fromVersion,
+        toVersion,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        files,
+        success: true
+      };
+      const manifestPath = join15(backupPath, "backup-manifest.json");
+      await writeFile10(manifestPath, JSON.stringify(manifest, null, 2));
+      await this.cleanupOldBackups();
+      logger.success(`\u2713 Backup created: ${backupId}`);
+      return backupId;
     } catch (error) {
-      logger.debug("Could not load migrations:", error);
+      logger.error("Failed to create backup:", error);
+      return null;
     }
-    return migrations.sort((a, b) => a.version.localeCompare(b.version));
   }
   /**
-   * Get applied migrations
+   * Backup a file or directory
    */
-  async getAppliedMigrations() {
-    const migrationHistoryPath = join15(this.configPath, ".migration-history.json");
+  async backupItem(sourceDir, item, targetDir) {
+    const sourcePath = join15(sourceDir, item);
+    const targetPath = join15(targetDir, item);
+    const files = [];
     try {
-      const content = await readFile9(migrationHistoryPath, "utf-8");
-      const history = JSON.parse(content);
-      return history.filter((m) => m.status === "completed").map((m) => m.to);
-    } catch {
-      return [];
+      const stats = await stat2(sourcePath);
+      if (stats.isDirectory()) {
+        await mkdir9(targetPath, { recursive: true });
+        const entries = await readdir8(sourcePath);
+        for (const entry of entries) {
+          const entryFiles = await this.backupItem(sourcePath, entry, targetPath);
+          files.push(...entryFiles);
+        }
+      } else if (stats.isFile()) {
+        await mkdir9(dirname3(targetPath), { recursive: true });
+        await this.copyFile(sourcePath, targetPath);
+        const hash = await this.calculateHash(targetPath);
+        files.push({
+          path: item,
+          hash,
+          size: stats.size
+        });
+      }
+    } catch (error) {
+      logger.debug(`Could not backup ${item}:`, error);
     }
+    return files;
   }
   /**
-   * Run pending migrations
+   * Copy file with hash calculation
    */
-  async runPendingMigrations() {
-    const appliedMigrations = await this.getAppliedMigrations();
-    const allMigrations = await this.loadMigrations();
-    const pendingMigrations = allMigrations.filter(
-      (m) => !appliedMigrations.includes(m.version)
-    );
-    if (pendingMigrations.length === 0) {
-      logger.info("No pending migrations");
-      return { success: true, applied: [], failed: [] };
+  async copyFile(source, target) {
+    const content = await readFile9(source);
+    await writeFile10(target, content);
+  }
+  /**
+   * Calculate file hash
+   */
+  async calculateHash(filePath) {
+    try {
+      const content = await readFile9(filePath);
+      return createHash2("sha256").update(content).digest("hex");
+    } catch {
+      return "";
     }
-    logger.info(`Running ${pendingMigrations.length} pending migration(s)...`);
-    const applied = [];
-    const failed = [];
-    const migrationHistory = [];
-    for (const migration of pendingMigrations) {
-      try {
-        logger.info(`Running migration: ${migration.version}`);
-        logger.info(`  ${migration.description}`);
-        await migration.up();
-        applied.push(migration.version);
-        migrationHistory.push({
-          from: "previous",
-          to: migration.version,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          status: "completed"
-        });
-        logger.success(`\u2713 Migration completed: ${migration.version}`);
-      } catch (error) {
-        logger.error(`\u2717 Migration failed: ${migration.version}`, error);
-        failed.push(migration.version);
-        migrationHistory.push({
-          from: "previous",
-          to: migration.version,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          status: "failed"
-        });
-        break;
+  }
+  /**
+   * List available backups
+   */
+  async listBackups() {
+    try {
+      const entries = await readdir8(this.backupsDir);
+      const backups = [];
+      for (const entry of entries) {
+        const backupPath = join15(this.backupsDir, entry);
+        const manifestPath = join15(backupPath, "backup-manifest.json");
+        try {
+          const manifestContent = await readFile9(manifestPath, "utf-8");
+          const manifest = JSON.parse(manifestContent);
+          const size = await this.calculateBackupSize(backupPath);
+          backups.push({
+            manifest,
+            path: backupPath,
+            size
+          });
+        } catch {
+        }
       }
+      backups.sort(
+        (a, b) => new Date(b.manifest.timestamp).getTime() - new Date(a.manifest.timestamp).getTime()
+      );
+      return backups;
+    } catch {
+      return [];
     }
-    await this.updateMigrationHistory(migrationHistory);
-    return {
-      success: failed.length === 0,
-      applied,
-      failed
-    };
   }
   /**
-   * Rollback migration
+   * Calculate backup directory size
    */
-  async rollbackMigration(version) {
+  async calculateBackupSize(backupPath) {
+    let totalSize = 0;
     try {
-      const applied = await this.getAppliedMigrations();
-      if (!applied.includes(version)) {
-        logger.error(`Migration not found in applied list: ${version}`);
+      const calculate = async (dir) => {
+        const entries = await readdir8(dir);
+        for (const entry of entries) {
+          const entryPath = join15(dir, entry);
+          const stats = await stat2(entryPath);
+          if (stats.isDirectory()) {
+            await calculate(entryPath);
+          } else {
+            totalSize += stats.size;
+          }
+        }
+      };
+      await calculate(backupPath);
+    } catch {
+    }
+    return totalSize;
+  }
+  /**
+   * Restore from backup
+   */
+  async restoreBackup(backupId) {
+    try {
+      const backups = await this.listBackups();
+      const backup = backups.find((b) => b.manifest.backupId === backupId);
+      if (!backup) {
+        logger.error(`Backup not found: ${backupId}`);
         return false;
       }
-      const allMigrations = await this.loadMigrations();
-      const migration = allMigrations.find((m) => m.version === version);
-      if (!migration) {
-        logger.error(`Migration file not found: ${version}`);
+      logger.info(`Restoring from backup: ${backupId}`);
+      const isValid = await this.validateBackup(backup);
+      if (!isValid) {
+        logger.error("Backup validation failed");
         return false;
       }
-      logger.info(`Rolling back migration: ${version}`);
-      await migration.down();
-      await this.updateMigrationHistoryStatus(version, "rolled-back");
-      logger.success(`\u2713 Migration rolled back: ${version}`);
+      for (const file of backup.manifest.files) {
+        const sourcePath = join15(backup.path, file.path);
+        const targetPath = join15(this.configPath, file.path);
+        await mkdir9(dirname3(targetPath), { recursive: true });
+        await this.copyFile(sourcePath, targetPath);
+      }
+      logger.success(`\u2713 Backup restored: ${backupId}`);
       return true;
     } catch (error) {
-      logger.error("Failed to rollback migration:", error);
+      logger.error("Failed to restore backup:", error);
       return false;
     }
   }
   /**
-   * Update migration history
+   * Validate backup integrity
    */
-  async updateMigrationHistory(entries) {
-    const historyPath = join15(this.configPath, ".migration-history.json");
+  async validateBackup(backup) {
     try {
-      let history = [];
-      try {
-        const content = await readFile9(historyPath, "utf-8");
-        history = JSON.parse(content);
-      } catch {
+      const manifestPath = join15(backup.path, "backup-manifest.json");
+      await readFile9(manifestPath, "utf-8");
+      for (const file of backup.manifest.files) {
+        const filePath = join15(backup.path, file.path);
+        await stat2(filePath);
+        const currentHash = await this.calculateHash(filePath);
+        if (currentHash !== file.hash) {
+          logger.warn(`File hash mismatch: ${file.path}`);
+          return false;
+        }
       }
-      history.push(...entries);
-      await writeFile10(historyPath, JSON.stringify(history, null, 2));
+      return true;
     } catch (error) {
-      logger.error("Failed to update migration history:", error);
+      logger.debug("Backup validation failed:", error);
+      return false;
     }
   }
   /**
-   * Update migration history status
+   * Delete backup
    */
-  async updateMigrationHistoryStatus(version, status) {
-    const historyPath = join15(this.configPath, ".migration-history.json");
+  async deleteBackup(backupId) {
     try {
-      const content = await readFile9(historyPath, "utf-8");
-      const history = JSON.parse(content);
-      const updated = history.map(
-        (m) => m.to === version ? { ...m, status } : m
-      );
-      await writeFile10(historyPath, JSON.stringify(updated, null, 2));
+      const backups = await this.listBackups();
+      const backup = backups.find((b) => b.manifest.backupId === backupId);
+      if (!backup) {
+        return false;
+      }
+      const entries = await readdir8(backup.path);
+      for (const entry of entries) {
+        const entryPath = join15(backup.path, entry);
+        const stats = await stat2(entryPath);
+        if (stats.isDirectory()) {
+          await this.removeDirectory(entryPath);
+        } else {
+          await unlink(entryPath);
+        }
+      }
+      logger.success(`\u2713 Backup deleted: ${backupId}`);
+      return true;
     } catch (error) {
-      logger.error("Failed to update migration history status:", error);
+      logger.error("Failed to delete backup:", error);
+      return false;
     }
   }
   /**
-   * Get migration history
+   * Remove directory recursively
    */
-  async getMigrationHistory() {
-    const historyPath = join15(this.configPath, ".migration-history.json");
-    try {
-      const content = await readFile9(historyPath, "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return [];
+  async removeDirectory(dirPath) {
+    const entries = await readdir8(dirPath);
+    for (const entry of entries) {
+      const entryPath = join15(dirPath, entry);
+      const stats = await stat2(entryPath);
+      if (stats.isDirectory()) {
+        await this.removeDirectory(entryPath);
+      } else {
+        await unlink(entryPath);
+      }
     }
+    await unlink(dirPath);
   }
   /**
-   * Check if migration is needed for version
+   * Cleanup old backups (keep only maxBackups)
    */
-  async needsMigration(_fromVersion) {
-    const applied = await this.getAppliedMigrations();
-    const allMigrations = await this.loadMigrations();
-    const pendingMigrations = allMigrations.filter(
-      (m) => !applied.includes(m.version)
+  async cleanupOldBackups() {
+    try {
+      const backups = await this.listBackups();
+      if (backups.length <= this.maxBackups) {
+        return;
+      }
+      const toDelete = backups.slice(this.maxBackups);
+      for (const backup of toDelete) {
+        await this.deleteBackup(backup.manifest.backupId);
+      }
+      logger.info(`Cleaned up ${toDelete.length} old backup(s)`);
+    } catch (error) {
+      logger.error("Failed to cleanup old backups:", error);
+    }
+  }
+  /**
+   * Format backup size for display
+   */
+  formatSize(bytes) {
+    const units = ["B", "KB", "MB", "GB"];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024;
+      unitIndex++;
+    }
+    return `${size.toFixed(2)} ${units[unitIndex]}`;
+  }
+};
+
+// src/core/migration-manager.ts
+init_esm_shims();
+init_logger();
+import { readFile as readFile10, writeFile as writeFile11, readdir as readdir9 } from "fs/promises";
+import { join as join16 } from "path";
+var MigrationManager = class {
+  configPath;
+  migrationsDir;
+  constructor(configPath) {
+    this.configPath = configPath;
+    this.migrationsDir = join16(process.cwd(), "src/core/migrations");
+  }
+  /**
+   * Load all available migrations
+   */
+  async loadMigrations() {
+    const migrations = [];
+    try {
+      const files = await readdir9(this.migrationsDir);
+      for (const file of files) {
+        if (file.endsWith(".js") && file.startsWith("migrate-")) {
+          try {
+            const module = await import(join16(this.migrationsDir, file));
+            const migration = module.default || module.migration;
+            if (migration) {
+              migrations.push(migration);
+            }
+          } catch (error) {
+            logger.warn(`Failed to load migration ${file}:`, error);
+          }
+        }
+      }
+    } catch (error) {
+      logger.debug("Could not load migrations:", error);
+    }
+    return migrations.sort((a, b) => a.version.localeCompare(b.version));
+  }
+  /**
+   * Get applied migrations
+   */
+  async getAppliedMigrations() {
+    const migrationHistoryPath = join16(this.configPath, ".migration-history.json");
+    try {
+      const content = await readFile10(migrationHistoryPath, "utf-8");
+      const history = JSON.parse(content);
+      return history.filter((m) => m.status === "completed").map((m) => m.to);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Run pending migrations
+   */
+  async runPendingMigrations() {
+    const appliedMigrations = await this.getAppliedMigrations();
+    const allMigrations = await this.loadMigrations();
+    const pendingMigrations = allMigrations.filter(
+      (m) => !appliedMigrations.includes(m.version)
+    );
+    if (pendingMigrations.length === 0) {
+      logger.info("No pending migrations");
+      return { success: true, applied: [], failed: [] };
+    }
+    logger.info(`Running ${pendingMigrations.length} pending migration(s)...`);
+    const applied = [];
+    const failed = [];
+    const migrationHistory = [];
+    for (const migration of pendingMigrations) {
+      try {
+        logger.info(`Running migration: ${migration.version}`);
+        logger.info(`  ${migration.description}`);
+        await migration.up();
+        applied.push(migration.version);
+        migrationHistory.push({
+          from: "previous",
+          to: migration.version,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "completed"
+        });
+        logger.success(`\u2713 Migration completed: ${migration.version}`);
+      } catch (error) {
+        logger.error(`\u2717 Migration failed: ${migration.version}`, error);
+        failed.push(migration.version);
+        migrationHistory.push({
+          from: "previous",
+          to: migration.version,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "failed"
+        });
+        break;
+      }
+    }
+    await this.updateMigrationHistory(migrationHistory);
+    return {
+      success: failed.length === 0,
+      applied,
+      failed
+    };
+  }
+  /**
+   * Rollback migration
+   */
+  async rollbackMigration(version) {
+    try {
+      const applied = await this.getAppliedMigrations();
+      if (!applied.includes(version)) {
+        logger.error(`Migration not found in applied list: ${version}`);
+        return false;
+      }
+      const allMigrations = await this.loadMigrations();
+      const migration = allMigrations.find((m) => m.version === version);
+      if (!migration) {
+        logger.error(`Migration file not found: ${version}`);
+        return false;
+      }
+      logger.info(`Rolling back migration: ${version}`);
+      await migration.down();
+      await this.updateMigrationHistoryStatus(version, "rolled-back");
+      logger.success(`\u2713 Migration rolled back: ${version}`);
+      return true;
+    } catch (error) {
+      logger.error("Failed to rollback migration:", error);
+      return false;
+    }
+  }
+  /**
+   * Update migration history
+   */
+  async updateMigrationHistory(entries) {
+    const historyPath = join16(this.configPath, ".migration-history.json");
+    try {
+      let history = [];
+      try {
+        const content = await readFile10(historyPath, "utf-8");
+        history = JSON.parse(content);
+      } catch {
+      }
+      history.push(...entries);
+      await writeFile11(historyPath, JSON.stringify(history, null, 2));
+    } catch (error) {
+      logger.error("Failed to update migration history:", error);
+    }
+  }
+  /**
+   * Update migration history status
+   */
+  async updateMigrationHistoryStatus(version, status) {
+    const historyPath = join16(this.configPath, ".migration-history.json");
+    try {
+      const content = await readFile10(historyPath, "utf-8");
+      const history = JSON.parse(content);
+      const updated = history.map(
+        (m) => m.to === version ? { ...m, status } : m
+      );
+      await writeFile11(historyPath, JSON.stringify(updated, null, 2));
+    } catch (error) {
+      logger.error("Failed to update migration history status:", error);
+    }
+  }
+  /**
+   * Get migration history
+   */
+  async getMigrationHistory() {
+    const historyPath = join16(this.configPath, ".migration-history.json");
+    try {
+      const content = await readFile10(historyPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Check if migration is needed for version
+   */
+  async needsMigration(_fromVersion) {
+    const applied = await this.getAppliedMigrations();
+    const allMigrations = await this.loadMigrations();
+    const pendingMigrations = allMigrations.filter(
+      (m) => !applied.includes(m.version)
     );
     return pendingMigrations.length > 0;
   }
@@ -5080,7 +5706,7 @@ var SyncEngine = class {
       if (changes.hasUpdate) {
         this.displayUpdateInfo(changes);
       } else {
-        console.log(chalk2.green("\u2713 Your AIKit is up to date"));
+        console.log(chalk3.green("\u2713 Your AIKit is up to date"));
         console.log(`  Installed: ${changes.fromVersion}`);
         console.log(`  Latest:    ${changes.toVersion}`);
       }
@@ -5095,15 +5721,15 @@ var SyncEngine = class {
    */
   async previewUpdate() {
     try {
-      console.log(chalk2.bold("\n\u{1F50D} Previewing update...\n"));
+      console.log(chalk3.bold("\n\u{1F50D} Previewing update...\n"));
       const changes = await this.versionManager.checkForUpdates();
       if (!changes.hasUpdate) {
-        console.log(chalk2.green("\u2713 No updates available"));
+        console.log(chalk3.green("\u2713 No updates available"));
         return false;
       }
       await this.displayChanges(changes);
-      console.log(chalk2.yellow("\n\u26A0\uFE0F  This is a preview - no changes will be made."));
-      console.log(chalk2.gray("Use `aikit sync apply` to apply these changes."));
+      console.log(chalk3.yellow("\n\u26A0\uFE0F  This is a preview - no changes will be made."));
+      console.log(chalk3.gray("Use `aikit sync apply` to apply these changes."));
       return true;
     } catch (error) {
       logger.error("Failed to preview update:", error);
@@ -5117,7 +5743,7 @@ var SyncEngine = class {
     try {
       const changes = await this.versionManager.checkForUpdates();
       if (!changes.hasUpdate) {
-        console.log(chalk2.green("\u2713 Already up to date"));
+        console.log(chalk3.green("\u2713 Already up to date"));
         return {
           success: true,
           newSkills: [],
@@ -5128,14 +5754,14 @@ var SyncEngine = class {
       }
       await this.displayChanges(changes);
       if (!options.force) {
-        const { confirmed } = await inquirer.prompt([{
+        const { confirmed } = await inquirer2.prompt([{
           type: "confirm",
           name: "confirmed",
           message: "Continue with update?",
           default: false
         }]);
         if (!confirmed) {
-          console.log(chalk2.yellow("Update cancelled"));
+          console.log(chalk3.yellow("Update cancelled"));
           return {
             success: false,
             newSkills: [],
@@ -5147,7 +5773,7 @@ var SyncEngine = class {
       }
       let backupId = void 0;
       if (!options.dryRun && options.backup !== false) {
-        console.log(chalk2.bold("\n\u{1F4E6} Creating backup..."));
+        console.log(chalk3.bold("\n\u{1F4E6} Creating backup..."));
         const backupResult = await this.backupManager.createBackup(
           changes.fromVersion,
           changes.toVersion
@@ -5160,19 +5786,19 @@ var SyncEngine = class {
       for (const conflict of changes.conflicts) {
         await this.resolveConflict(conflict);
       }
-      console.log(chalk2.bold("\n\u{1F504} Running migrations..."));
+      console.log(chalk3.bold("\n\u{1F504} Running migrations..."));
       const migrationResult = await this.migrationManager.runPendingMigrations();
       if (!migrationResult.success) {
         throw new Error(`Migration failed: ${migrationResult.failed.join(", ")}`);
       }
-      console.log(chalk2.bold("\n\u{1F4DD} Updating skills..."));
+      console.log(chalk3.bold("\n\u{1F4DD} Updating skills..."));
       const updateResult = await this.updateSkills(changes, options);
       await this.versionManager.updateVersion(changes.toVersion);
       if (backupId) {
         const allSkills = await this.versionManager.loadSkillHashes(paths.skills(paths.globalConfig()));
         await this.versionManager.saveInstalledSkills(allSkills);
       }
-      console.log(chalk2.green("\n\u2705 Update complete!"));
+      console.log(chalk3.green("\n\u2705 Update complete!"));
       this.displaySummary({
         success: true,
         backupId,
@@ -5187,7 +5813,7 @@ var SyncEngine = class {
       };
     } catch (error) {
       logger.error("Update failed:", error);
-      console.log(chalk2.red("\n\u274C Update failed"));
+      console.log(chalk3.red("\n\u274C Update failed"));
       return {
         success: false,
         newSkills: [],
@@ -5202,14 +5828,14 @@ var SyncEngine = class {
    */
   async rollback(backupId) {
     try {
-      console.log(chalk2.bold("\n\u{1F504} Rollback...\n"));
+      console.log(chalk3.bold("\n\u{1F504} Rollback...\n"));
       if (!backupId) {
         const backups = await this.backupManager.listBackups();
         if (backups.length === 0) {
-          console.log(chalk2.yellow("No backups available"));
+          console.log(chalk3.yellow("No backups available"));
           return false;
         }
-        const { selectedBackup } = await inquirer.prompt([{
+        const { selectedBackup } = await inquirer2.prompt([{
           type: "list",
           name: "selectedBackup",
           message: "Select backup to restore:",
@@ -5221,12 +5847,12 @@ var SyncEngine = class {
         backupId = selectedBackup;
       }
       if (!backupId) {
-        console.log(chalk2.yellow("No backup ID provided"));
+        console.log(chalk3.yellow("No backup ID provided"));
         return false;
       }
       const success = await this.backupManager.restoreBackup(backupId);
       if (success) {
-        console.log(chalk2.green("\u2713 Rollback complete"));
+        console.log(chalk3.green("\u2713 Rollback complete"));
         return true;
       }
       return false;
@@ -5239,36 +5865,36 @@ var SyncEngine = class {
    * Display update information
    */
   displayUpdateInfo(changes) {
-    console.log(chalk2.bold("\n\u{1F4E2} New version available!\n"));
-    console.log(`  ${chalk2.cyan("Current:")} ${changes.fromVersion}`);
-    console.log(`  ${chalk2.cyan("Latest:")}  ${changes.toVersion}
+    console.log(chalk3.bold("\n\u{1F4E2} New version available!\n"));
+    console.log(`  ${chalk3.cyan("Current:")} ${changes.fromVersion}`);
+    console.log(`  ${chalk3.cyan("Latest:")}  ${changes.toVersion}
 `);
   }
   /**
    * Display changes summary
    */
   async displayChanges(changes) {
-    console.log(chalk2.bold("\u{1F4CA} Changes detected:\n"));
+    console.log(chalk3.bold("\u{1F4CA} Changes detected:\n"));
     if (changes.newSkills.length > 0) {
-      console.log(chalk2.green("  New Skills:"));
+      console.log(chalk3.green("  New Skills:"));
       changes.newSkills.forEach((skill) => {
         console.log(`    + ${skill.name} (${skill.category})`);
       });
     }
     if (changes.modifiedSkills.length > 0) {
-      console.log(chalk2.yellow("  Updated Skills:"));
+      console.log(chalk3.yellow("  Updated Skills:"));
       changes.modifiedSkills.forEach((skill) => {
         console.log(`    ~ ${skill.name}`);
       });
     }
     if (changes.removedSkills.length > 0) {
-      console.log(chalk2.red("  Removed Skills:"));
+      console.log(chalk3.red("  Removed Skills:"));
       changes.removedSkills.forEach((skill) => {
         console.log(`    - ${skill.name}`);
       });
     }
     if (changes.conflicts.length > 0) {
-      console.log(chalk2.bold.red("  \u26A0\uFE0F  Conflicts:"));
+      console.log(chalk3.bold.red("  \u26A0\uFE0F  Conflicts:"));
       changes.conflicts.forEach((conflict) => {
         console.log(`    ! ${conflict.skillName} (user modified)`);
       });
@@ -5278,11 +5904,11 @@ var SyncEngine = class {
    * Resolve a conflict
    */
   async resolveConflict(conflict) {
-    console.log(chalk2.bold.red(`
+    console.log(chalk3.bold.red(`
 \u26A0\uFE0F  Conflict detected: ${conflict.skillName}
 `));
-    console.log(chalk2.yellow("Your version differs from official version."));
-    const { action } = await inquirer.prompt([{
+    console.log(chalk3.yellow("Your version differs from official version."));
+    const { action } = await inquirer2.prompt([{
       type: "list",
       name: "action",
       message: "Choose action:",
@@ -5307,1164 +5933,484 @@ var SyncEngine = class {
     if (action === "overwrite") {
       return;
     }
-    console.log(chalk2.yellow("  Your version will be preserved as -custom.md"));
+    console.log(chalk3.yellow("  Your version will be preserved as -custom.md"));
   }
   /**
    * Update skills based on changes
    */
   async updateSkills(changes, options) {
     const globalSkillsPath = paths.skills(paths.globalConfig());
-    const projectSkillsPath = paths.skills(this.versionManager["config"].configPath);
-    const newSkills = [];
-    const updatedSkills = [];
-    const removedSkills = [];
-    for (const skill of changes.newSkills) {
-      if (!options.dryRun) {
-        await this.installSkill(globalSkillsPath, skill, projectSkillsPath);
-      }
-      newSkills.push(skill.name);
-      console.log(chalk2.green(`    + ${skill.name}`));
-    }
-    for (const skill of changes.modifiedSkills) {
-      if (!options.dryRun) {
-        await this.installSkill(globalSkillsPath, skill, projectSkillsPath);
-      }
-      updatedSkills.push(skill.name);
-      console.log(chalk2.yellow(`    ~ ${skill.name}`));
-    }
-    for (const skill of changes.removedSkills) {
-      if (!options.dryRun) {
-        await this.archiveSkill(projectSkillsPath, skill);
-      }
-      removedSkills.push(skill.name);
-      console.log(chalk2.red(`    - ${skill.name} (archived)`));
-    }
-    return {
-      newSkills,
-      updatedSkills,
-      removedSkills
-    };
-  }
-  /**
-   * Install a skill
-   */
-  async installSkill(sourceDir, skill, targetDir) {
-    const sourcePath = join16(sourceDir, skill.category, `${skill.name}.md`);
-    const targetPath = join16(targetDir, skill.category, `${skill.name}.md`);
-    await mkdir9(dirname3(targetPath), { recursive: true });
-    await copyFile(sourcePath, targetPath);
-  }
-  /**
-   * Archive a removed skill
-   */
-  async archiveSkill(targetDir, skill) {
-    const sourcePath = join16(targetDir, skill.category, `${skill.name}.md`);
-    const targetPath = join16(targetDir, skill.category, `${skill.name}-deprecated.md`);
-    try {
-      const content = await readFile10(sourcePath, "utf-8");
-      const deprecatedNotice = `---
-\u26A0\uFE0F  DEPRECATED: This skill has been removed
-
-Deprecation date: ${(/* @__PURE__ */ new Date()).toISOString()}
-Reason: Check release notes for replacement
----
-
-${content}`;
-      await mkdir9(dirname3(targetPath), { recursive: true });
-      await writeFile11(targetPath, deprecatedNotice);
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        console.log(chalk2.yellow(`    - ${skill.name} (not found, skipping)`));
-      } else {
-        throw error;
-      }
-    }
-  }
-  /**
-   * Display sync summary
-   */
-  displaySummary(result) {
-    console.log(chalk2.bold("\n\u{1F4CB} Summary:\n"));
-    console.log(`  Updated from: ${chalk2.cyan(result.backupId || "N/A")}`);
-    console.log(`  Updated to:   ${chalk2.cyan("current")}`);
-    console.log();
-    if (result.newSkills.length > 0) {
-      console.log(chalk2.green(`  ${result.newSkills.length} new skills installed`));
-    }
-    if (result.updatedSkills.length > 0) {
-      console.log(chalk2.yellow(`  ${result.updatedSkills.length} skills updated`));
-    }
-    if (result.removedSkills.length > 0) {
-      console.log(chalk2.red(`  ${result.removedSkills.length} skills archived`));
-    }
-    if (result.migrationsRun.length > 0) {
-      console.log(chalk2.blue(`  ${result.migrationsRun.length} migrations run`));
-    }
-    if (result.backupId) {
-      console.log(chalk2.gray(`
-  Rollback available: aikit sync rollback ${result.backupId}`));
-    }
-  }
-};
-
-// src/cli.ts
-var program = new Command();
-program.name("aikit").description("Open-source AI coding agent toolkit for OpenCode").version(getVersion());
-program.command("init").description("Initialize AIKit configuration").option("-g, --global", "Initialize global configuration").option("-p, --project", "Initialize project-level configuration").action(async (options) => {
-  const configDir = options.global ? paths.globalConfig() : paths.projectConfig();
-  console.log(chalk3.bold("\n\u{1F680} AIKit Setup\n"));
-  logger.info(`Initializing AIKit in ${configDir}...`);
-  try {
-    await initializeConfig(configDir, options.global);
-    logger.success("\u2713 Configuration created");
-    if (!options.global) {
-      const config = await loadConfig();
-      const engine = new SkillEngine(config);
-      const result = await engine.syncSkillsToProject();
-      if (result.count > 0) {
-        logger.success(`\u2713 Synced ${result.count} skills`);
-      }
-      console.log(chalk3.bold("\n\u{1F50D} Checking CLI tools...\n"));
-      const cliTools = await CliDetector.checkAll();
-      const installableTools = CliDetector.filterInstallable(cliTools);
-      for (const tool of cliTools) {
-        const status = tool.installed ? chalk3.green("\u2713 Installed") : chalk3.yellow("\u2717 Not installed");
-        const version = tool.version ? chalk3.gray(` (${tool.version})`) : "";
-        console.log(`  ${status} ${chalk3.cyan(tool.displayName)}${version}`);
-      }
-      if (installableTools.length > 0) {
-        console.log();
-        const { action } = await inquirer2.prompt([
-          {
-            type: "list",
-            name: "action",
-            message: "How would you like to proceed?",
-            choices: [
-              {
-                name: "all",
-                value: "all",
-                short: "a",
-                message: "Install all missing CLI tools"
-              },
-              {
-                name: "select",
-                value: "select",
-                short: "s",
-                message: "Select specific tools to install (use space to select, Enter to confirm)"
-              },
-              {
-                name: "skip",
-                value: "skip",
-                short: "n",
-                message: "Skip CLI tool installation"
-              }
-            ],
-            default: "all"
-          }
-        ]);
-        if (action === "skip") {
-          console.log();
-          logger.info("Skipping CLI tool installation");
-        } else if (action === "all") {
-          console.log();
-          logger.info(`Installing ${installableTools.length} CLI tool(s)...`);
-          for (const tool of installableTools) {
-            await installCliTool(tool);
-          }
-          console.log();
-          logger.success("\u2713 CLI tools installed");
-        } else {
-          const { installTools } = await inquirer2.prompt([
-            {
-              type: "checkbox",
-              name: "installTools",
-              message: "Select CLI tools to install (press Enter to skip):",
-              choices: installableTools.map((tool) => ({
-                name: tool.name,
-                value: tool,
-                checked: true
-                // Default to install all
-              }))
-            }
-          ]);
-          if (installTools.length > 0) {
-            console.log();
-            logger.info(`Installing ${installTools.length} CLI tool(s)...`);
-            for (const tool of installTools) {
-              await installCliTool(tool);
-            }
-            console.log();
-            logger.success("\u2713 CLI tools installed");
-          } else {
-            console.log();
-            logger.info("Skipping CLI tool installation");
-          }
-        }
-      } else {
-        console.log();
-        logger.success("\u2713 All CLI tools already installed");
-      }
-      const beads = new BeadsIntegration();
-      const beadsStatus = await beads.getStatus();
-      if (!beadsStatus.initialized) {
-        logger.info("Initializing .beads directory...");
-        await beads.initLocal();
-        logger.success("\u2713 .beads directory created");
-        if (!beadsStatus.installed) {
-          logger.info("Tip: Install Beads CLI globally for full functionality: npm install -g beads");
-        }
-      } else {
-        logger.info("Beads already initialized");
-      }
-      const opencodePath = paths.opencodeConfig();
-      await installToOpenCode(opencodePath);
-      console.log(chalk3.bold("\n\u2728 AIKit is ready!\n"));
-      console.log("Usage in OpenCode:");
-      console.log(chalk3.cyan("  /skills") + "  - List all available skills");
-      console.log(chalk3.cyan("  /plan") + "    - Create implementation plan");
-      console.log(chalk3.cyan("  /tdd") + "     - Test-driven development");
-      console.log(chalk3.cyan("  /debug") + "   - Systematic debugging");
-      console.log(chalk3.cyan("  /review") + "  - Code review checklist");
-      console.log(chalk3.cyan("  /git") + "     - Git workflow");
-      console.log(chalk3.cyan("  /frontend-aesthetics") + " - UI/UX guidelines");
-      console.log("\nPress " + chalk3.bold("Ctrl+K") + " in OpenCode to see all commands.\n");
-    }
-  } catch (error) {
-    logger.error("Failed to initialize AIKit:", error);
-    process.exit(1);
-  }
-});
-program.command("install").description("Install AIKit to OpenCode configuration").action(async () => {
-  logger.info("Installing AIKit to OpenCode...");
-  try {
-    const opencodePath = paths.opencodeConfig();
-    await installToOpenCode(opencodePath);
-    logger.success("AIKit installed to OpenCode!");
-  } catch (error) {
-    logger.error("Failed to install:", error);
-    process.exit(1);
-  }
-});
-program.command("sync [subcommand]").description("Update AIKit to latest version").option("--dry-run", "Preview changes without applying").option("-f, --force", "Skip confirmation prompts").option("--no-backup", "Skip creating backup").action(async (subcommand, options) => {
-  const config = await loadConfig();
-  const syncEngine = new SyncEngine(config);
-  if (!subcommand) {
-    await syncEngine.applyUpdate(options);
-  } else {
-    switch (subcommand) {
-      case "check":
-        await syncEngine.checkForUpdates();
-        break;
-      case "preview":
-        await syncEngine.previewUpdate();
-        break;
-      case "apply":
-        await syncEngine.applyUpdate(options);
-        break;
-      case "rollback":
-        await syncEngine.rollback();
-        break;
-      default:
-        logger.error(`Unknown subcommand: ${subcommand}`);
-        console.log(chalk3.gray("Available subcommands: check, preview, apply, rollback"));
-        process.exit(1);
-    }
-  }
-});
-var skillsCmd = program.command("skills").description("Manage skills");
-skillsCmd.command("list").description("List available skills and tools with their configuration status").action(async () => {
-  const config = await loadConfig();
-  const engine = new SkillEngine(config);
-  const skills = await engine.listSkills();
-  const { ToolConfigManager: ToolConfigManager2 } = await Promise.resolve().then(() => (init_tool_config(), tool_config_exports));
-  const toolConfigManager = new ToolConfigManager2(config);
-  const tools = await toolConfigManager.listTools();
-  console.log(chalk3.bold("\n\u{1F4DA} Available Skills:\n"));
-  for (const skill of skills) {
-    console.log(`  ${chalk3.cyan(skill.name)} - ${skill.description}`);
-  }
-  console.log(chalk3.bold("\n\u{1F527} Available Tools:\n"));
-  for (const tool of tools) {
-    let statusIcon = "  ";
-    let statusText = "";
-    if (tool.status === "ready") {
-      statusIcon = chalk3.green("\u2713");
-      statusText = chalk3.gray("(ready)");
-    } else if (tool.status === "needs_config") {
-      statusIcon = chalk3.yellow("\u26A0");
-      statusText = chalk3.yellow("(needs config)");
-    } else if (tool.status === "error") {
-      statusIcon = chalk3.red("\u2717");
-      statusText = chalk3.red("(error)");
-    }
-    console.log(`  ${statusIcon} ${chalk3.cyan(tool.name)} - ${tool.description} ${statusText}`);
-    if (tool.errorMessage) {
-      console.log(`    ${chalk3.red("Error:")} ${tool.errorMessage}`);
-    }
-  }
-  console.log();
-  console.log(chalk3.gray('Tip: Use "aikit skills <tool-name> config" to configure a tool\n'));
-});
-skillsCmd.command("show <name>").description("Show skill details").action(async (name) => {
-  const config = await loadConfig();
-  const engine = new SkillEngine(config);
-  const skill = await engine.getSkill(name);
-  if (!skill) {
-    logger.error(`Skill not found: ${name}`);
-    process.exit(1);
-  }
-  console.log(chalk3.bold(`
-\u{1F4D6} Skill: ${skill.name}
-`));
-  console.log(chalk3.gray(skill.description));
-  console.log(chalk3.bold("\nWorkflow:"));
-  console.log(skill.content);
-});
-skillsCmd.command("create <name>").description("Create a new skill").action(async (name) => {
-  const config = await loadConfig();
-  const engine = new SkillEngine(config);
-  await engine.createSkill(name);
-  logger.success(`Skill created: ${name}`);
-});
-skillsCmd.command("sync").description("Sync global skills to project").action(async () => {
-  const config = await loadConfig();
-  const engine = new SkillEngine(config);
-  const result = await engine.syncSkillsToProject();
-  if (result.count === 0) {
-    logger.info("Skills already in sync or no global skills to sync");
-  } else {
-    console.log(chalk3.bold(`
-\u2713 Synced ${result.count} skills to project:
-`));
-    for (const skill of result.synced) {
-      console.log(`  ${chalk3.cyan("\u2022")} ${skill}`);
-    }
-    console.log();
-  }
-});
-skillsCmd.command("config <tool-name>").description("Configure a tool (e.g., config figma-analysis)").action(async (toolName) => {
-  const config = await loadConfig();
-  const { ToolConfigManager: ToolConfigManager2 } = await Promise.resolve().then(() => (init_tool_config(), tool_config_exports));
-  const toolConfigManager = new ToolConfigManager2(config);
-  const tool = await toolConfigManager.getToolConfig(toolName);
-  if (!tool) {
-    logger.error(`Tool not found: ${toolName}`);
-    console.log(chalk3.gray("\nAvailable tools:"));
-    const tools = await toolConfigManager.listTools();
-    for (const t of tools) {
-      console.log(`  - ${chalk3.cyan(t.name)}`);
-    }
-    console.log();
-    process.exit(1);
-  }
-  console.log(chalk3.bold(`
-\u{1F527} Configuring: ${tool.name}
-`));
-  console.log(chalk3.gray(tool.description));
-  console.log();
-  if (tool.configMethod === "oauth") {
-    if (toolName === "figma-analysis") {
-      const { FigmaOAuth: FigmaOAuth2 } = await Promise.resolve().then(() => (init_figma_oauth(), figma_oauth_exports));
-      const oauth = new FigmaOAuth2(toolConfigManager);
-      try {
-        const token = await oauth.authenticate();
-        console.log(chalk3.gray("\nValidating token..."));
-        const isValid = await oauth.validateToken(token);
-        if (isValid) {
-          logger.success(`
-\u2705 ${tool.name} configured successfully!`);
-          console.log(chalk3.gray("\nYou can now use the /analyze-figma command in OpenCode.\n"));
-        } else {
-          await toolConfigManager.updateToolConfig(toolName, {
-            status: "error",
-            errorMessage: "Token validation failed"
-          });
-          logger.error("Token validation failed. Please try again.");
-          process.exit(1);
-        }
-      } catch (error) {
-        await toolConfigManager.updateToolConfig(toolName, {
-          status: "error",
-          errorMessage: error instanceof Error ? error.message : String(error)
-        });
-        logger.error(`Configuration failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exit(1);
-      }
-    } else {
-      logger.error(`OAuth flow not implemented for tool: ${toolName}`);
-      process.exit(1);
-    }
-  } else if (tool.configMethod === "manual") {
-    logger.info("Manual configuration not yet implemented");
-    process.exit(1);
-  } else {
-    logger.info(`Tool ${tool.name} does not require configuration`);
-  }
-});
-skillsCmd.command("*").description("Configure a tool (e.g., figma-analysis config)").allowUnknownOption().action(async () => {
-  const args = process.argv.slice(process.argv.indexOf("skills") + 1);
-  const toolName = args[0];
-  const action = args[1];
-  if (action === "config" && toolName) {
-    const config = await loadConfig();
-    const { ToolConfigManager: ToolConfigManager2 } = await Promise.resolve().then(() => (init_tool_config(), tool_config_exports));
-    const toolConfigManager = new ToolConfigManager2(config);
-    const tool = await toolConfigManager.getToolConfig(toolName);
-    if (!tool) {
-      logger.error(`Tool not found: ${toolName}`);
-      console.log(chalk3.gray("\nAvailable tools:"));
-      const tools = await toolConfigManager.listTools();
-      for (const t of tools) {
-        console.log(`  - ${chalk3.cyan(t.name)}`);
-      }
-      console.log();
-      console.log(chalk3.gray("Tip: If you meant to show a skill, use: aikit skills show <name>"));
-      console.log();
-      process.exit(1);
-    }
-    console.log(chalk3.bold(`
-\u{1F527} Configuring: ${tool.name}
-`));
-    console.log(chalk3.gray(tool.description));
-    console.log();
-    if (tool.configMethod === "oauth") {
-      if (toolName === "figma-analysis") {
-        const { FigmaOAuth: FigmaOAuth2 } = await Promise.resolve().then(() => (init_figma_oauth(), figma_oauth_exports));
-        const oauth = new FigmaOAuth2(toolConfigManager);
-        try {
-          const token = await oauth.authenticate();
-          console.log(chalk3.gray("\nValidating token..."));
-          const isValid = await oauth.validateToken(token);
-          if (isValid) {
-            logger.success(`
-\u2705 ${tool.name} configured successfully!`);
-            console.log(chalk3.gray("\nYou can now use the /analyze-figma command in OpenCode.\n"));
-          } else {
-            await toolConfigManager.updateToolConfig(toolName, {
-              status: "error",
-              errorMessage: "Token validation failed"
-            });
-            logger.error("Token validation failed. Please try again.");
-            process.exit(1);
-          }
-        } catch (error) {
-          await toolConfigManager.updateToolConfig(toolName, {
-            status: "error",
-            errorMessage: error instanceof Error ? error.message : String(error)
-          });
-          logger.error(`Configuration failed: ${error instanceof Error ? error.message : String(error)}`);
-          process.exit(1);
-        }
-      } else {
-        logger.error(`OAuth flow not implemented for tool: ${toolName}`);
-        process.exit(1);
-      }
-    } else if (tool.configMethod === "manual") {
-      logger.info("Manual configuration not yet implemented");
-      process.exit(1);
-    } else {
-      logger.info(`Tool ${tool.name} does not require configuration`);
-    }
-  } else {
-    logger.error(`Unknown command: ${toolName || "unknown"} ${action || ""}`);
-    console.log(chalk3.gray("\nAvailable commands:"));
-    console.log("  aikit skills list                    - List all skills and tools");
-    console.log("  aikit skills show <name>              - Show skill details");
-    console.log("  aikit skills config <tool-name>       - Configure a tool");
-    console.log("  aikit skills <tool-name> config       - Configure a tool (alternative syntax)");
-    console.log();
-    process.exit(1);
-  }
-});
-var agentsCmd = program.command("agents").description("Manage agents");
-agentsCmd.command("list").description("List available agents").action(async () => {
-  const config = await loadConfig();
-  const manager = new AgentManager(config);
-  const agents = manager.listAgents();
-  console.log(chalk3.bold("\n\u{1F916} Available Agents:\n"));
-  for (const agent of agents) {
-    console.log(`  ${chalk3.cyan(`@${agent.name}`)} - ${agent.description}`);
-    console.log(chalk3.gray(`    Use when: ${agent.useWhen}`));
-  }
-  console.log();
-});
-var commandsCmd = program.command("commands").description("Manage commands");
-commandsCmd.command("list").description("List available commands").action(async () => {
-  const config = await loadConfig();
-  const runner = new CommandRunner(config);
-  const commands = await runner.listCommands();
-  console.log(chalk3.bold("\n\u26A1 Available Commands:\n"));
-  const groups = groupBy(commands, (c) => c.category);
-  for (const [category, cmds] of Object.entries(groups)) {
-    console.log(chalk3.bold.yellow(`
-  ${category}:`));
-    for (const cmd of cmds) {
-      console.log(`    ${chalk3.cyan(`/${cmd.name}`)} - ${cmd.description}`);
-    }
-  }
-  console.log();
-});
-var toolsCmd = program.command("tools").description("Manage custom tools");
-toolsCmd.command("list").description("List available tools").action(async () => {
-  const config = await loadConfig();
-  const registry = new ToolRegistry(config);
-  const tools = await registry.listTools();
-  console.log(chalk3.bold("\n\u{1F527} Available Tools:\n"));
-  for (const tool of tools) {
-    console.log(`  ${chalk3.cyan(tool.name)} - ${tool.description}`);
-  }
-  console.log();
-});
-var pluginsCmd = program.command("plugins").description("Manage plugins");
-pluginsCmd.command("list").description("List available plugins").action(async () => {
-  const config = await loadConfig();
-  const system = new PluginSystem(config);
-  const plugins = await system.listPlugins();
-  console.log(chalk3.bold("\n\u{1F50C} Available Plugins:\n"));
-  for (const plugin of plugins) {
-    const status = plugin.enabled ? chalk3.green("\u2713") : chalk3.gray("\u25CB");
-    console.log(`  ${status} ${chalk3.cyan(plugin.name)} - ${plugin.description}`);
-  }
-  console.log();
-});
-var memoryCmd = program.command("memory").description("Manage persistent memory");
-memoryCmd.command("list").description("List memory entries").action(async () => {
-  const config = await loadConfig();
-  const memory = new MemoryManager(config);
-  const entries = await memory.list();
-  console.log(chalk3.bold("\n\u{1F9E0} Memory Entries:\n"));
-  for (const entry of entries) {
-    console.log(`  ${chalk3.cyan(entry.key)} - ${entry.summary}`);
-    console.log(chalk3.gray(`    Updated: ${entry.updatedAt}`));
-  }
-  console.log();
-});
-memoryCmd.command("read <key>").description("Read a memory entry").action(async (key) => {
-  const config = await loadConfig();
-  const memory = new MemoryManager(config);
-  const content = await memory.read(key);
-  if (!content) {
-    logger.error(`Memory entry not found: ${key}`);
-    process.exit(1);
-  }
-  console.log(content);
-});
-var beadsCmd = program.command("beads").description("Beads task management integration");
-beadsCmd.command("status").description("Show current Beads status").action(async () => {
-  const beads = new BeadsIntegration();
-  const status = await beads.getStatus();
-  console.log(chalk3.bold("\n\u{1F4FF} Beads Status:\n"));
-  console.log(`  Active tasks: ${status.activeTasks}`);
-  console.log(`  Completed: ${status.completedTasks}`);
-  console.log(`  Current: ${status.currentTask || "None"}`);
-  console.log();
-});
-program.command("status").description("Show AIKit status").action(async () => {
-  console.log(chalk3.bold(`
-\u{1F680} AIKit v${getVersion}
-`));
-  try {
-    const config = await loadConfig();
-    console.log(chalk3.green("\u2713 Configuration loaded"));
-    const skillEngine = new SkillEngine(config);
-    const skills = await skillEngine.listSkills();
-    console.log(`  Skills: ${skills.length}`);
-    const agentManager = new AgentManager(config);
-    const agents = agentManager.listAgents();
-    console.log(`  Agents: ${agents.length}`);
-    const commandRunner = new CommandRunner(config);
-    const commands = await commandRunner.listCommands();
-    console.log(`  Commands: ${commands.length}`);
-    const toolRegistry = new ToolRegistry(config);
-    const tools = await toolRegistry.listTools();
-    console.log(`  Tools: ${tools.length}`);
-    const beads = new BeadsIntegration();
-    const beadsStatus = await beads.isInstalled();
-    console.log(`  Beads: ${beadsStatus ? chalk3.green("Installed") : chalk3.yellow("Not installed")}`);
-  } catch (error) {
-    console.log(chalk3.yellow('\u26A0 AIKit not initialized. Run "aikit init" to get started.'));
-  }
-  console.log();
-});
-async function initializeConfig(configDir, _isGlobal) {
-  const { mkdir: mkdir11, writeFile: writeFile13 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
-  const dirs = [
-    "",
-    "skills",
-    "agents",
-    "commands",
-    "commands/build",
-    "commands/git",
-    "commands/plan",
-    "commands/research",
-    "tools",
-    "plugins",
-    "memory",
-    "memory/_templates",
-    "memory/handoffs",
-    "memory/observations",
-    "memory/research"
-  ];
-  for (const dir of dirs) {
-    await mkdir11(join18(configDir, dir), { recursive: true });
-  }
-  const defaultConfig = {
-    version: getVersion,
-    skills: { enabled: true },
-    agents: { enabled: true, default: "build" },
-    commands: { enabled: true },
-    tools: { enabled: true },
-    plugins: { enabled: true },
-    memory: { enabled: true },
-    beads: { enabled: true },
-    antiHallucination: { enabled: true }
-  };
-  await writeFile13(
-    join18(configDir, "aikit.json"),
-    JSON.stringify(defaultConfig, null, 2)
-  );
-  const agentsMd = `# AIKit Agent Rules
-
-## Build Commands
-- \`npm run build\` - Build the project
-- \`npm run test\` - Run tests
-- \`npm run lint\` - Run linting
-
-## Code Style
-- Use 2 spaces for indentation
-- Use single quotes for strings
-- Add trailing commas
-
-## Naming Conventions
-- Variables: camelCase
-- Components: PascalCase
-- Files: kebab-case
-
-## Project-Specific Rules
-Add your project-specific rules here.
-`;
-  await writeFile13(join18(configDir, "AGENTS.md"), agentsMd);
-}
-async function configureMcpServer(projectPath) {
-  const { mkdir: mkdir11, writeFile: writeFile13, readFile: readFile12 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
-  const { existsSync: existsSync5 } = await import("fs");
-  const { homedir: homedir3 } = await import("os");
-  const { fileURLToPath: fileURLToPath3 } = await import("url");
-  const { dirname: dirname4 } = await import("path");
-  const currentFile = fileURLToPath3(import.meta.url);
-  const currentDir = dirname4(currentFile);
-  const aikitPath = join18(currentDir, "..");
-  const mcpServerPath = join18(aikitPath, "dist", "mcp-server.js");
-  const configLocations = [
-    // Global config (most common)
-    join18(homedir3(), ".config", "opencode", "opencode.json"),
-    // Project-level config
-    join18(projectPath, ".opencode", "opencode.json"),
-    // Alternative global location
-    join18(homedir3(), ".opencode", "opencode.json")
-  ];
-  const mcpServerConfig = {
-    type: "local",
-    command: ["node", mcpServerPath],
-    environment: {}
-  };
-  for (const configPath of configLocations) {
-    try {
-      const configDir = join18(configPath, "..");
-      await mkdir11(configDir, { recursive: true });
-      let config = {};
-      if (existsSync5(configPath)) {
-        try {
-          const existing = await readFile12(configPath, "utf-8");
-          config = JSON.parse(existing);
-        } catch {
-          config = {};
-        }
-      }
-      if (!config.mcp) {
-        config.mcp = {};
-      }
-      config.mcp.aikit = mcpServerConfig;
-      await writeFile13(configPath, JSON.stringify(config, null, 2));
-      logger.success(`
-\u2705 MCP server configured: ${configPath}`);
-      logger.info(`   Server: node ${mcpServerPath}`);
-      return;
-    } catch (error) {
-      continue;
-    }
-  }
-  const instructionsPath = join18(projectPath, ".opencode", "MCP_SETUP.md");
-  await mkdir11(join18(projectPath, ".opencode"), { recursive: true });
-  await writeFile13(instructionsPath, `# AIKit MCP Server Configuration
-
-## Automatic Setup Failed
-
-Please manually configure the MCP server in OpenCode.
-
-## Configuration
-
-Add this to your OpenCode configuration file (\`~/.config/opencode/opencode.json\`):
-
-\`\`\`json
-{
-  "mcpServers": {
-    "aikit": {
-      "command": "node",
-      "args": ["${mcpServerPath}"],
-      "env": {}
-    }
-  }
-}
-\`\`\`
-
-## After Configuration
-
-1. Restart OpenCode completely
-2. OpenCode will automatically start the MCP server
-3. Tools will be available via MCP protocol
-4. You can use tools like \`tool_read_figma_design\` directly
-
-## Verify
-
-After restarting OpenCode, check:
-- MCP server is running (check OpenCode settings)
-- Tools are discoverable (OpenCode should list them)
-- You can call tools via MCP protocol
-`);
-  logger.warn(`
-\u26A0\uFE0F  Could not auto-configure MCP server. See: ${instructionsPath}`);
-}
-async function installCliTool(tool) {
-  try {
-    logger.info(`Installing ${tool.displayName}...`);
-    switch (tool.name) {
-      case "opencode" /* OPENCODE */:
-        await installToOpenCode(paths.opencodeConfig());
-        break;
-      case "claude" /* CLAUDE */:
-        const { execSync: execSync2 } = await import("child_process");
-        execSync2("npm install -g @anthropic-ai/claude-code", { stdio: "inherit" });
-        break;
-      case "github" /* GITHUB */:
-        const { execSync: execGh } = await import("child_process");
-        execGh("npm install -g gh", { stdio: "inherit" });
-        break;
-    }
-    logger.success(`\u2713 ${tool.displayName} installed`);
-    return true;
-  } catch (error) {
-    logger.error(`Failed to install ${tool.displayName}:`, error);
-    return false;
-  }
-}
-async function installToOpenCode(_opencodePath) {
-  const { mkdir: mkdir11, writeFile: writeFile13, access: access5 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
-  const projectPath = process.cwd();
-  const opencodeCommandDir = join18(projectPath, ".opencode", "command");
-  const aikitDir = join18(projectPath, ".aikit");
-  const opencodeAgentDir = join18(paths.opencodeConfig(), "agent");
-  await mkdir11(opencodeCommandDir, { recursive: true });
-  await mkdir11(join18(aikitDir, "skills"), { recursive: true });
-  await mkdir11(opencodeAgentDir, { recursive: true });
-  const agentFiles = {
-    agent: `---
-description: General-purpose default agent (OpenCode compatibility).
-mode: subagent
-tools:
-  "*": true
----
-
-Use for quick tasks when no specialized agent is needed.`,
-    planner: `---
-description: Strategic planner; breaks down work and coordinates specialist agents.
-mode: subagent
-tools:
-  "*": true
----
-
-Use when the task is complex or multi-step. Delegates to @build for implementation,
-@scout for research, @review for code review/security, @explore for codebase navigation,
-and @vision for visual analysis.`,
-    build: `---
-description: Primary builder; writes code, tests, and implements features.
-mode: subagent
-tools:
-  "*": true
----
-
-Use for feature implementation, refactors, and bug fixes. Prefer TDD, small steps,
-and run checks after changes. Delegates to @review for audits and @explore for context.`,
-    rush: `---
-description: Fast execution for small/urgent changes with minimal planning.
-mode: subagent
-tools:
-  "*": true
----
-
-Use for quick fixes, hotfixes, or tiny edits. Keep scope minimal and verify quickly.`,
-    review: `---
-description: Code review and quality/security auditing agent.
-mode: subagent
-tools:
-  "*": true
----
-
-Use to review correctness, security, performance, maintainability, and tests. Be specific
-about issues and suggest concrete fixes.`,
-    scout: `---
-description: Research agent for external docs, patterns, and references.
-mode: subagent
-tools:
-  "*": true
----
-
-Use to look up docs, examples, best practices. Summarize findings concisely and cite sources.`,
-    explore: `---
-description: Codebase navigation agent (search, grep, structure understanding).
-mode: subagent
-tools:
-  "*": true
----
-
-Use to locate files, patterns, dependencies, and gather quick context in the repo.`,
-    vision: `---
-description: Visual analysis agent for mockups, screenshots, PDFs, diagrams.
-mode: subagent
-tools:
-  "*": true
----
-
-Use to interpret visual assets (components, layout, colors, typography) and translate to tasks.`,
-    "one-shot": `---
-description: End-to-end autonomous task execution (beta). Complete tasks from start to finish.
-mode: subagent
-tools:
-  "*": true
----
-
-\u26A0\uFE0F BETA: This mode is experimental. Use for straightforward tasks first.
-
-## One-Shot Mode - Autonomous Task Execution
-
-Execute tasks end-to-end with minimal intervention:
-
-### Workflow Phases
-1. **REQUIREMENTS** - Gather task type, scope, dependencies, success criteria
-2. **PLANNING** - Create detailed plan, recommend skills/tools, create tracking bead
-3. **COMPLEXITY** - Auto-split if: >30min, >10 files, >500 lines, >2 sub-systems
-4. **EXECUTION** - Parallel tasks (max 3), dynamic agent delegation
-5. **TESTING** - Run until pass: typecheck \u2192 test \u2192 lint \u2192 build (max 3 retries)
-6. **VERIFICATION** - Quality gates \u2713 \u2192 Manual verification \u2192 Deployment approval
-7. **COMPLETION** - Generate proof, update tracking, collect feedback
-
-### Quality Gates (ALL must pass)
-- \`npm run typecheck\` - No type errors
-- \`npm run test\` - All tests pass
-- \`npm run lint\` - No lint errors
-- \`npm run build\` - Build succeeds
-
-### Error Recovery (3 Levels)
-- **Level 1**: Auto-fix (type errors, lint --fix)
-- **Level 2**: Alternative approach via @review
-- **Level 3**: User intervention + follow-up task
-
-### Delegates To
-@planner for planning, @build for implementation, @review for code review,
-@scout for research, @explore for navigation, @vision for visual analysis.
-
-### Best Use Cases
-- Straightforward features with clear scope
-- Bug fixes with known reproduction steps
-- Refactoring with defined boundaries
-
-### Consider Alternatives For
-- Complex multi-system features \u2192 Use /plan + /implement
-- Exploratory research \u2192 Use /research first
-- Critical production changes \u2192 Manual with /review`
-  };
-  for (const [name, content] of Object.entries(agentFiles)) {
-    const filePath = join18(opencodeAgentDir, `${name}.md`);
-    try {
-      await access5(filePath);
-    } catch {
-      await writeFile13(filePath, content, "utf8");
-    }
-  }
-  const config = await loadConfig();
-  const skillEngine = new SkillEngine(config);
-  const commandRunner = new CommandRunner(config);
-  const skills = await skillEngine.listSkills();
-  const commands = await commandRunner.listCommands();
-  const opencodeCommands = {};
-  const skillsList = skills.map((s) => `| \`/${s.name.replace(/\s+/g, "-")}\` | ${s.description} |`).join("\n");
-  opencodeCommands["skills"] = `List all available AIKit skills and how to use them.
-
-READ .aikit/AGENTS.md
-
-## Available Skills
-
-| Command | Description |
-|---------|-------------|
-${skillsList}
-
-Type any command to use that skill. For example: \`/test-driven-development\` or \`/tdd\`.`;
-  for (const skill of skills) {
-    const commandName = skill.name.replace(/\s+/g, "-").toLowerCase();
-    const skillPath = skill.filePath;
-    const relativePath = skillPath.startsWith(projectPath) ? skillPath.replace(projectPath, "").replace(/\\/g, "/").replace(/^\//, "") : `.aikit/skills/${skill.name.replace(/\s+/g, "-").toLowerCase()}.md`;
-    const useWhen = skill.useWhen || `The user asks you to ${skill.name}`;
-    opencodeCommands[commandName] = `Use the **${skill.name} skill** ${useWhen.toLowerCase()}.
-
-READ ${relativePath}
-
-## Description
-${skill.description}
-
-## When to Use
-${useWhen}
-
-## Workflow
-${skill.content.split("\n").slice(0, 20).join("\n")}${skill.content.split("\n").length > 20 ? "\n\n... (see full skill file for complete workflow)" : ""}
-
-**IMPORTANT**: Follow this skill's workflow step by step. Do not skip steps.
-Complete the checklist at the end of the skill.`;
-  }
-  for (const cmd of commands) {
-    if (opencodeCommands[cmd.name]) continue;
-    const commandName = cmd.name.replace(/\//g, "").replace(/\s+/g, "-");
-    const examples = cmd.examples.map((e) => `- \`${e}\``).join("\n");
-    if (cmd.name === "analyze-figma") {
-      opencodeCommands[commandName] = `# Command: /analyze-figma
-
-## Description
-${cmd.description}
-
-## Usage
-\`${cmd.usage}\`
-
-## Examples
-${examples}
-
-## \u26A0\uFE0F CRITICAL: Extract URL FIRST!
-
-**BEFORE ANYTHING ELSE**: Look at the user's FULL input message (all lines) and find the Figma URL. It's ALWAYS there - never ask for it!
-
-**The URL pattern**: Look for text containing \`figma.com/design/\` anywhere in the user's message.
-
-**Example of what user input looks like**:
-\`\`\`
-/analyze-figma https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/
-Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0
-\`\`\`
-
-**Extract the complete URL** (combine if split):
-\`https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0\`
-
-## Workflow
-
-**IMPORTANT**: When user provides a Figma URL, you MUST immediately:
-
-**Step 1: Extract URL from User Input**
-
-**CRITICAL**: The URL is ALWAYS in the user's input message! DO NOT ask for it - just extract it!
-
-**MANDATORY**: You MUST extract the URL before proceeding. This is not optional!
-
-**How to Extract**:
-1. **Read the ENTIRE user input message** - look at ALL lines, not just the first line
-2. **Search for ANY text containing** \`figma.com/design/\` - this is the URL
-3. **URL may appear in different formats**:
-   - On same line: \`/analyze-figma https://www.figma.com/design/...\`
-   - Split across lines:
-     \`\`\`
-     /analyze-figma https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/
-     Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0
-     \`\`\`
-   - Just the URL: \`https://www.figma.com/design/...\`
-4. **Extract the COMPLETE URL**:
-   - Start from \`https://\` or \`http://\`
-   - Include everything until the end of the line or next whitespace
-   - If URL is split, combine ALL parts into one complete URL
-5. **Include ALL query parameters**: \`?node-id=...\`, \`&t=...\`, etc.
-
-**REAL EXAMPLE**:
-\`\`\`
-User input:
-/analyze-figma https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/
-Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0
-\`\`\`
-
-**Extract as**:
-\`https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0\`
-
-**CRITICAL RULES**:
-- \u2705 DO: Read the ENTIRE user message (all lines)
-- \u2705 DO: Look for \`figma.com/design/\` anywhere in the message
-- \u2705 DO: Combine split lines into one URL
-- \u274C DO NOT: Ask user for URL - it's ALWAYS in the input
-- \u274C DO NOT: Skip this step - URL extraction is MANDATORY
-- \u274C DO NOT: Proceed without extracting URL first
-
-**If you think URL is not found**:
-1. Re-read the user's message line by line
-2. Look for ANY mention of "figma.com"
-3. Check if URL is split across multiple lines
-4. The URL is definitely there - find it!
-- If URL not found in current message, check previous messages
-
-**Step 2: Check Tool Configuration**
-
-Before calling the tool, verify that Figma tool is configured:
-- If not configured, inform user to run: \`aikit skills figma-analysis config\`
-- The tool requires a Figma Personal Access Token
-
-**Step 3: Call MCP Tool read_figma_design**
-
-Use the MCP tool \`read_figma_design\` (or \`tool_read_figma_design\` via MCP) with the extracted URL:
-\`\`\`
-Use tool: read_figma_design
-Arguments: { "url": "[extracted URL]" }
-\`\`\`
-
-**This tool will automatically**:
-1. Validate the Figma URL format
-2. Check if Figma tool is configured
-3. Call Figma API to fetch design data
-4. Extract design tokens:
-   - Colors (from fills and strokes, converted to hex)
-   - Typography (font families, sizes, weights, line heights)
-   - Spacing system (8px grid detection)
-   - Components (from Figma components)
-   - Screens/Frames (dimensions and names)
-   - Breakpoints (common responsive breakpoints)
-5. Return formatted markdown with all extracted tokens
-
-**Step 4: Format and Save**
-
-Format extracted tokens as structured markdown and save using memory-update tool:
-\`\`\`
-Use tool: memory-update
-Arguments: {
-  "key": "research/figma-analysis",
-  "content": "[formatted markdown with all tokens]"
-}
-\`\`\`
-
-**Step 5: Report Results**
-
-Report what was extracted:
-- Number of screens found
-- Number of colors in palette
-- Typography styles found
-- Components identified
-- Confirm save location: \`memory/research/figma-analysis.md\`
-
-## Critical Instructions
-
-- **DO NOT** ask user to "share the Figma URL" - they already provided it in the command
-- **DO NOT** wait for confirmation - just start analyzing immediately
-- **DO** extract URL from full user input message
-- **DO** call MCP tool \`read_figma_design\` immediately
-- **DO** use browser MCP to navigate and snapshot
-- **DO** extract everything automatically without asking
-- **DO** save to memory automatically
-
-## Error Handling
-
-If the tool returns an error:
-1. **If "needs config"**: Guide user to run \`aikit skills figma-analysis config\`
-2. **If API error**: 
-   - Verify the Figma URL is correct and accessible
-   - Ensure your API token has access to the file
-   - Check if the file is public or you have permission to access it
-3. **If URL invalid**: Re-check the extracted URL format
-
-## How to Parse URL from Command
-
-**CRITICAL**: The Figma URL is provided in the SAME message as the command!
-
-Example:
-- User input: \`/analyze-figma https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?node-id=0-1&t=70yZa7w5wSyjDhYj-1\`
-- The URL is: \`https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?node-id=0-1&t=70yZa7w5wSyjDhYj-1\`
-
-**Extract the URL** from the command input:
-- Everything after \`/analyze-figma \` (note the space) is the URL
-- The URL starts with \`https://\` or \`http://\`
-- Extract the ENTIRE URL including all query parameters
-- Check the FULL user message, not just command name
-
-## Example Usage
-
-User input: \`/analyze-figma https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?node-id=0-1&t=70yZa7w5wSyjDhYj-1\`
-
-**Step 1: Extract URL**
-- Check full user input message
-- Extract: \`https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?node-id=0-1&t=70yZa7w5wSyjDhYj-1\`
-
-**Step 2: Call MCP Tool**
-\`\`\`
-Use tool: read_figma_design
-Arguments: { "url": "https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?node-id=0-1&t=70yZa7w5wSyjDhYj-1" }
-\`\`\`
-
-**Step 3: Tool automatically extracts tokens via Figma API**
-
-**Step 4: Save to memory using memory-update tool**
+    const projectSkillsPath = paths.skills(this.versionManager["config"].configPath);
+    const newSkills = [];
+    const updatedSkills = [];
+    const removedSkills = [];
+    for (const skill of changes.newSkills) {
+      if (!options.dryRun) {
+        await this.installSkill(globalSkillsPath, skill, projectSkillsPath);
+      }
+      newSkills.push(skill.name);
+      console.log(chalk3.green(`    + ${skill.name}`));
+    }
+    for (const skill of changes.modifiedSkills) {
+      if (!options.dryRun) {
+        await this.installSkill(globalSkillsPath, skill, projectSkillsPath);
+      }
+      updatedSkills.push(skill.name);
+      console.log(chalk3.yellow(`    ~ ${skill.name}`));
+    }
+    for (const skill of changes.removedSkills) {
+      if (!options.dryRun) {
+        await this.archiveSkill(projectSkillsPath, skill);
+      }
+      removedSkills.push(skill.name);
+      console.log(chalk3.red(`    - ${skill.name} (archived)`));
+    }
+    return {
+      newSkills,
+      updatedSkills,
+      removedSkills
+    };
+  }
+  /**
+   * Install a skill
+   */
+  async installSkill(sourceDir, skill, targetDir) {
+    const sourcePath = join17(sourceDir, skill.category, `${skill.name}.md`);
+    const targetPath = join17(targetDir, skill.category, `${skill.name}.md`);
+    await mkdir10(dirname4(targetPath), { recursive: true });
+    await copyFile(sourcePath, targetPath);
+  }
+  /**
+   * Archive a removed skill
+   */
+  async archiveSkill(targetDir, skill) {
+    const sourcePath = join17(targetDir, skill.category, `${skill.name}.md`);
+    const targetPath = join17(targetDir, skill.category, `${skill.name}-deprecated.md`);
+    try {
+      const content = await readFile11(sourcePath, "utf-8");
+      const deprecatedNotice = `---
+\u26A0\uFE0F  DEPRECATED: This skill has been removed
 
-**Step 5: Report results to user**
+Deprecation date: ${(/* @__PURE__ */ new Date()).toISOString()}
+Reason: Check release notes for replacement
+---
 
-## Important Reminders
+${content}`;
+      await mkdir10(dirname4(targetPath), { recursive: true });
+      await writeFile12(targetPath, deprecatedNotice);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        console.log(chalk3.yellow(`    - ${skill.name} (not found, skipping)`));
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Display sync summary
+   */
+  displaySummary(result) {
+    console.log(chalk3.bold("\n\u{1F4CB} Summary:\n"));
+    console.log(`  Updated from: ${chalk3.cyan(result.backupId || "N/A")}`);
+    console.log(`  Updated to:   ${chalk3.cyan("current")}`);
+    console.log();
+    if (result.newSkills.length > 0) {
+      console.log(chalk3.green(`  ${result.newSkills.length} new skills installed`));
+    }
+    if (result.updatedSkills.length > 0) {
+      console.log(chalk3.yellow(`  ${result.updatedSkills.length} skills updated`));
+    }
+    if (result.removedSkills.length > 0) {
+      console.log(chalk3.red(`  ${result.removedSkills.length} skills archived`));
+    }
+    if (result.migrationsRun.length > 0) {
+      console.log(chalk3.blue(`  ${result.migrationsRun.length} migrations run`));
+    }
+    if (result.backupId) {
+      console.log(chalk3.gray(`
+  Rollback available: aikit sync rollback ${result.backupId}`));
+    }
+  }
+};
 
-- The URL is ALREADY in the command input - extract it from full message!
-- URL may be split across multiple lines - combine them into one complete URL
-- Do NOT ask for URL again - it's always in the input
-- Do NOT wait - start immediately
-- Use MCP tool \`read_figma_design\` which uses Figma API directly`;
+// src/cli/commands/sync.ts
+init_logger();
+function registerSyncCommand(program2) {
+  program2.command("sync [subcommand]").description("Update AIKit to latest version").option("--dry-run", "Preview changes without applying").option("-f, --force", "Skip confirmation prompts").option("--no-backup", "Skip creating backup").action(async (subcommand, options) => {
+    const config = await loadConfig();
+    const syncEngine = new SyncEngine(config);
+    if (!subcommand) {
+      await syncEngine.applyUpdate(options);
     } else {
-      opencodeCommands[commandName] = `# Command: /${cmd.name}
-
-## Description
-${cmd.description}
-
-## Usage
-\`${cmd.usage}\`
-
-## Examples
-${examples}
-
-## Workflow
-${cmd.content}
+      switch (subcommand) {
+        case "check":
+          await syncEngine.checkForUpdates();
+          break;
+        case "preview":
+          await syncEngine.previewUpdate();
+          break;
+        case "apply":
+          await syncEngine.applyUpdate(options);
+          break;
+        case "rollback":
+          await syncEngine.rollback();
+          break;
+        default:
+          logger.error(`Unknown subcommand: ${subcommand}`);
+          console.log(chalk4.gray("Available subcommands: check, preview, apply, rollback"));
+          process.exit(1);
+      }
+    }
+  });
+}
 
-**Category**: ${cmd.category}`;
+// src/cli/commands/skills.ts
+init_esm_shims();
+import chalk5 from "chalk";
+init_logger();
+function registerSkillsCommand(program2) {
+  const skillsCmd = program2.command("skills").description("Manage skills");
+  skillsCmd.command("list").description("List available skills and tools with their configuration status").action(async () => {
+    const config = await loadConfig();
+    const engine = new SkillEngine(config);
+    const skills = await engine.listSkills();
+    const { ToolConfigManager: ToolConfigManager2 } = await Promise.resolve().then(() => (init_tool_config(), tool_config_exports));
+    const toolConfigManager = new ToolConfigManager2(config);
+    const tools = await toolConfigManager.listTools();
+    console.log(chalk5.bold("\n\u{1F4DA} Available Skills:\n"));
+    for (const skill of skills) {
+      console.log(`  ${chalk5.cyan(skill.name)} - ${skill.description}`);
+    }
+    console.log(chalk5.bold("\n\u{1F527} Available Tools:\n"));
+    for (const tool of tools) {
+      let statusIcon = "  ";
+      let statusText = "";
+      if (tool.status === "ready") {
+        statusIcon = chalk5.green("\u2713");
+        statusText = chalk5.gray("(ready)");
+      } else if (tool.status === "needs_config") {
+        statusIcon = chalk5.yellow("\u26A0");
+        statusText = chalk5.yellow("(needs config)");
+      } else if (tool.status === "error") {
+        statusIcon = chalk5.red("\u2717");
+        statusText = chalk5.red("(error)");
+      }
+      console.log(`  ${statusIcon} ${chalk5.cyan(tool.name)} - ${tool.description} ${statusText}`);
+      if (tool.errorMessage) {
+        console.log(`    ${chalk5.red("Error:")} ${tool.errorMessage}`);
+      }
+    }
+    console.log();
+    console.log(chalk5.gray('Tip: Use "aikit skills <tool-name> config" to configure a tool\n'));
+  });
+  skillsCmd.command("show <name>").description("Show skill details").action(async (name) => {
+    const config = await loadConfig();
+    const engine = new SkillEngine(config);
+    const skill = await engine.getSkill(name);
+    if (!skill) {
+      logger.error(`Skill not found: ${name}`);
+      process.exit(1);
+    }
+    console.log(chalk5.bold(`
+\u{1F4D6} Skill: ${skill.name}
+`));
+    console.log(chalk5.gray(skill.description));
+    console.log(chalk5.bold("\nWorkflow:"));
+    console.log(skill.content);
+  });
+  skillsCmd.command("create <name>").description("Create a new skill").action(async (name) => {
+    const config = await loadConfig();
+    const engine = new SkillEngine(config);
+    await engine.createSkill(name);
+    logger.success(`Skill created: ${name}`);
+  });
+  skillsCmd.command("sync").description("Sync global skills to project").action(async () => {
+    const config = await loadConfig();
+    const engine = new SkillEngine(config);
+    const result = await engine.syncSkillsToProject();
+    if (result.count === 0) {
+      logger.info("Skills already in sync or no global skills to sync");
+    } else {
+      console.log(chalk5.bold(`
+\u2713 Synced ${result.count} skills to project:
+`));
+      for (const skill of result.synced) {
+        console.log(`  ${chalk5.cyan("\u2022")} ${skill}`);
+      }
+      console.log();
+    }
+  });
+  skillsCmd.command("config <tool-name>").description("Configure a tool (e.g., config figma-analysis)").action(async (toolName) => {
+    await configureToolAction(toolName);
+  });
+  skillsCmd.command("*").description("Configure a tool (e.g., figma-analysis config)").allowUnknownOption().action(async () => {
+    const args = process.argv.slice(process.argv.indexOf("skills") + 1);
+    const toolName = args[0];
+    const action = args[1];
+    if (action === "config" && toolName) {
+      await configureToolAction(toolName);
+    } else {
+      logger.error(`Unknown command: ${toolName || "unknown"} ${action || ""}`);
+      console.log(chalk5.gray("\nAvailable commands:"));
+      console.log("  aikit skills list                    - List all skills and tools");
+      console.log("  aikit skills show <name>              - Show skill details");
+      console.log("  aikit skills config <tool-name>       - Configure a tool");
+      console.log("  aikit skills <tool-name> config       - Configure a tool (alternative syntax)");
+      console.log();
+      process.exit(1);
+    }
+  });
+  return skillsCmd;
+}
+async function configureToolAction(toolName) {
+  const config = await loadConfig();
+  const { ToolConfigManager: ToolConfigManager2 } = await Promise.resolve().then(() => (init_tool_config(), tool_config_exports));
+  const toolConfigManager = new ToolConfigManager2(config);
+  const tool = await toolConfigManager.getToolConfig(toolName);
+  if (!tool) {
+    logger.error(`Tool not found: ${toolName}`);
+    console.log(chalk5.gray("\nAvailable tools:"));
+    const tools = await toolConfigManager.listTools();
+    for (const t of tools) {
+      console.log(`  - ${chalk5.cyan(t.name)}`);
     }
+    console.log();
+    console.log(chalk5.gray("Tip: If you meant to show a skill, use: aikit skills show <name>"));
+    console.log();
+    process.exit(1);
   }
-  let count = 0;
-  for (const [name, content] of Object.entries(opencodeCommands)) {
-    const filePath = join18(opencodeCommandDir, `${name}.md`);
-    await writeFile13(filePath, content.trim());
-    logger.info(`  \u2713 Created /${name} command`);
-    count++;
+  console.log(chalk5.bold(`
+\u{1F527} Configuring: ${tool.name}
+`));
+  console.log(chalk5.gray(tool.description));
+  console.log();
+  if (tool.configMethod === "oauth") {
+    if (toolName === "figma-analysis") {
+      const { FigmaOAuth: FigmaOAuth2 } = await Promise.resolve().then(() => (init_figma_oauth(), figma_oauth_exports));
+      const oauth = new FigmaOAuth2(toolConfigManager);
+      try {
+        const token = await oauth.authenticate();
+        console.log(chalk5.gray("\nValidating token..."));
+        const isValid = await oauth.validateToken(token);
+        if (isValid) {
+          logger.success(`
+\u2705 ${tool.name} configured successfully!`);
+          console.log(chalk5.gray("\nYou can now use the /analyze-figma command in OpenCode.\n"));
+        } else {
+          await toolConfigManager.updateToolConfig(toolName, {
+            status: "error",
+            errorMessage: "Token validation failed"
+          });
+          logger.error("Token validation failed. Please try again.");
+          process.exit(1);
+        }
+      } catch (error) {
+        await toolConfigManager.updateToolConfig(toolName, {
+          status: "error",
+          errorMessage: error instanceof Error ? error.message : String(error)
+        });
+        logger.error(`Configuration failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+    } else {
+      logger.error(`OAuth flow not implemented for tool: ${toolName}`);
+      process.exit(1);
+    }
+  } else if (tool.configMethod === "manual") {
+    logger.info("Manual configuration not yet implemented");
+    process.exit(1);
+  } else {
+    logger.info(`Tool ${tool.name} does not require configuration`);
   }
-  logger.success(`
-Created ${count} OpenCode commands in .opencode/command/`);
-  await configureMcpServer(projectPath);
-  logger.info("\nUsage in OpenCode:");
-  logger.info("  Press Ctrl+K to open command picker");
-  logger.info("  Or type /skills to see all available skills");
-  logger.info(`  Available: ${skills.length} skills, ${commands.length} commands`);
-  logger.info("  MCP server configured - tools available via MCP protocol");
 }
-function groupBy(array, keyFn) {
-  return array.reduce((acc, item) => {
-    const key = keyFn(item);
-    if (!acc[key]) acc[key] = [];
-    acc[key].push(item);
-    return acc;
-  }, {});
+
+// src/cli/commands/misc.ts
+init_esm_shims();
+import chalk6 from "chalk";
+import { readFile as readFile13, writeFile as writeFile14 } from "fs/promises";
+import { join as join19 } from "path";
+init_memory();
+init_logger();
+function registerAgentsCommand(program2) {
+  const agentsCmd = program2.command("agents").description("Manage agents");
+  agentsCmd.command("list").description("List available agents").action(async () => {
+    const config = await loadConfig();
+    const manager = new AgentManager(config);
+    const agents = manager.listAgents();
+    console.log(chalk6.bold("\n\u{1F916} Available Agents:\n"));
+    for (const agent of agents) {
+      console.log(`  ${chalk6.cyan(`@${agent.name}`)} - ${agent.description}`);
+      console.log(chalk6.gray(`    Use when: ${agent.useWhen}`));
+    }
+    console.log();
+  });
+  return agentsCmd;
+}
+function registerCommandsCommand(program2) {
+  const commandsCmd = program2.command("commands").description("Manage commands");
+  commandsCmd.command("list").description("List available commands").action(async () => {
+    const config = await loadConfig();
+    const runner = new CommandRunner(config);
+    const commands = await runner.listCommands();
+    console.log(chalk6.bold("\n\u26A1 Available Commands:\n"));
+    const groups = groupBy(commands, (c) => c.category);
+    for (const [category, cmds] of Object.entries(groups)) {
+      console.log(chalk6.bold.yellow(`
+  ${category}:`));
+      for (const cmd of cmds) {
+        console.log(`    ${chalk6.cyan(`/${cmd.name}`)} - ${cmd.description}`);
+      }
+    }
+    console.log();
+  });
+  return commandsCmd;
+}
+function registerModeCommand(program2) {
+  const modeCmd = program2.command("mode").description("Manage AIKit mode");
+  modeCmd.command("get").description("Get current AIKit mode").action(async () => {
+    const config = await loadConfig();
+    const { mode } = config;
+    console.log(chalk6.bold("\n\u{1F4CB} Current Mode:\n"));
+    console.log(`  ${chalk6.cyan(mode || "build")}`);
+    console.log();
+    console.log(chalk6.bold("Available Modes:\n"));
+    console.log(`  ${chalk6.cyan("plan")} - Create detailed implementation plans`);
+    console.log(`  ${chalk6.cyan("build")} - Direct execution mode`);
+    console.log(`  ${chalk6.cyan("one-shot")} - End-to-end autonomous execution`);
+    console.log();
+    console.log(chalk6.gray('Use "aikit mode set <mode>" to change mode.'));
+  });
+  modeCmd.command("set <mode>").description("Set AIKit mode (plan, build, one-shot)").action(async (mode) => {
+    const config = await loadConfig();
+    const configPath = config.configPath;
+    try {
+      const validModes = ["plan", "build", "one-shot"];
+      if (!validModes.includes(mode)) {
+        console.log(chalk6.red(`Invalid mode. Available modes: ${validModes.join(", ")}`));
+        return;
+      }
+      const configData = JSON.parse(await readFile13(join19(configPath, "aikit.json"), "utf-8"));
+      configData.mode = mode;
+      await writeFile14(join19(configPath, "aikit.json"), JSON.stringify(configData, null, 2));
+      console.log(chalk6.green(`\u2713 Mode set to: ${mode}`));
+      console.log(chalk6.gray(`Configuration updated at: ${configPath}/aikit.json`));
+    } catch (error) {
+      console.log(chalk6.red(`Failed to set mode: ${error instanceof Error ? error.message : String(error)}`));
+    }
+  });
+  return modeCmd;
+}
+function registerToolsCommand(program2) {
+  const toolsCmd = program2.command("tools").description("Manage custom tools");
+  toolsCmd.command("list").description("List available tools").action(async () => {
+    const config = await loadConfig();
+    const registry = new ToolRegistry(config);
+    const tools = await registry.listTools();
+    console.log(chalk6.bold("\n\u{1F527} Available Tools:\n"));
+    for (const tool of tools) {
+      console.log(`  ${chalk6.cyan(tool.name)} - ${tool.description}`);
+    }
+    console.log();
+  });
+  return toolsCmd;
+}
+function registerPluginsCommand(program2) {
+  const pluginsCmd = program2.command("plugins").description("Manage plugins");
+  pluginsCmd.command("list").description("List available plugins").action(async () => {
+    const config = await loadConfig();
+    const system = new PluginSystem(config);
+    const plugins = await system.listPlugins();
+    console.log(chalk6.bold("\n\u{1F50C} Available Plugins:\n"));
+    for (const plugin of plugins) {
+      const status = plugin.enabled ? chalk6.green("\u2713") : chalk6.gray("\u25CB");
+      console.log(`  ${status} ${chalk6.cyan(plugin.name)} - ${plugin.description}`);
+    }
+    console.log();
+  });
+  return pluginsCmd;
+}
+function registerMemoryCommand(program2) {
+  const memoryCmd = program2.command("memory").description("Manage persistent memory");
+  memoryCmd.command("list").description("List memory entries").action(async () => {
+    const config = await loadConfig();
+    const memory = new MemoryManager(config);
+    const entries = await memory.list();
+    console.log(chalk6.bold("\n\u{1F9E0} Memory Entries:\n"));
+    for (const entry of entries) {
+      console.log(`  ${chalk6.cyan(entry.key)} - ${entry.summary}`);
+      console.log(chalk6.gray(`    Updated: ${entry.updatedAt}`));
+    }
+    console.log();
+  });
+  memoryCmd.command("read <key>").description("Read a memory entry").action(async (key) => {
+    const config = await loadConfig();
+    const memory = new MemoryManager(config);
+    const content = await memory.read(key);
+    if (!content) {
+      logger.error(`Memory entry not found: ${key}`);
+      process.exit(1);
+    }
+    console.log(content);
+  });
+  return memoryCmd;
 }
+function registerBeadsCommand(program2) {
+  const beadsCmd = program2.command("beads").description("Beads task management integration");
+  beadsCmd.command("status").description("Show current Beads status").action(async () => {
+    const beads = new BeadsIntegration();
+    const status = await beads.getStatus();
+    console.log(chalk6.bold("\n\u{1F4FF} Beads Status:\n"));
+    console.log(`  Active tasks: ${status.activeTasks}`);
+    console.log(`  Completed: ${status.completedTasks}`);
+    console.log(`  Current: ${status.currentTask || "None"}`);
+    console.log();
+  });
+  return beadsCmd;
+}
+function registerStatusCommand(program2) {
+  program2.command("status").description("Show AIKit status").action(async () => {
+    console.log(chalk6.bold(`
+\u{1F680} AIKit v${getVersion()}
+`));
+    try {
+      const config = await loadConfig();
+      console.log(chalk6.green("\u2713 Configuration loaded"));
+      const skillEngine = new SkillEngine(config);
+      const skills = await skillEngine.listSkills();
+      console.log(`  Skills: ${skills.length}`);
+      const agentManager = new AgentManager(config);
+      const agents = agentManager.listAgents();
+      console.log(`  Agents: ${agents.length}`);
+      const commandRunner = new CommandRunner(config);
+      const commands = await commandRunner.listCommands();
+      console.log(`  Commands: ${commands.length}`);
+      const toolRegistry = new ToolRegistry(config);
+      const tools = await toolRegistry.listTools();
+      console.log(`  Tools: ${tools.length}`);
+      const beads = new BeadsIntegration();
+      const beadsStatus = await beads.isInstalled();
+      console.log(`  Beads: ${beadsStatus ? chalk6.green("Installed") : chalk6.yellow("Not installed")}`);
+    } catch (error) {
+      console.log(chalk6.yellow('\u26A0 AIKit not initialized. Run "aikit init" to get started.'));
+    }
+    console.log();
+  });
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("aikit").description("Open-source AI coding agent toolkit for OpenCode").version(getVersion());
+registerInitCommand(program);
+registerInstallCommand(program);
+registerSyncCommand(program);
+registerSkillsCommand(program);
+registerAgentsCommand(program);
+registerCommandsCommand(program);
+registerModeCommand(program);
+registerToolsCommand(program);
+registerPluginsCommand(program);
+registerMemoryCommand(program);
+registerBeadsCommand(program);
+registerStatusCommand(program);
 program.parse();
 //# sourceMappingURL=cli.js.map