@tdsoft-tech/aikit 0.1.2

package/dist/mcp-server.js

@@ -0,0 +1,3496 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/utils/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync } from "fs";
+var paths;
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    "use strict";
+    init_esm_shims();
+    paths = {
+      /**
+       * Get the global AIKit configuration directory
+       * ~/.config/aikit/ on Unix, %APPDATA%/aikit/ on Windows
+       */
+      globalConfig() {
+        const base = process.platform === "win32" ? process.env.APPDATA || join(homedir(), "AppData", "Roaming") : join(homedir(), ".config");
+        return join(base, "aikit");
+      },
+      /**
+       * Get the project-level AIKit configuration directory
+       */
+      projectConfig(projectPath) {
+        const base = projectPath || process.cwd();
+        return join(base, ".aikit");
+      },
+      /**
+       * Get the OpenCode configuration directory
+       */
+      opencodeConfig() {
+        const base = process.platform === "win32" ? process.env.APPDATA || join(homedir(), "AppData", "Roaming") : join(homedir(), ".config");
+        return join(base, "opencode");
+      },
+      /**
+       * Get the Beads directory for the current project
+       */
+      beadsDir(projectPath) {
+        const base = projectPath || process.cwd();
+        return join(base, ".beads");
+      },
+      /**
+       * Check if a project has AIKit initialized
+       */
+      hasProjectConfig(projectPath) {
+        return existsSync(this.projectConfig(projectPath));
+      },
+      /**
+       * Check if global AIKit is initialized
+       */
+      hasGlobalConfig() {
+        return existsSync(this.globalConfig());
+      },
+      /**
+       * Get effective config path (project takes precedence over global)
+       */
+      effectiveConfig(projectPath) {
+        if (this.hasProjectConfig(projectPath)) {
+          return this.projectConfig(projectPath);
+        }
+        if (this.hasGlobalConfig()) {
+          return this.globalConfig();
+        }
+        return null;
+      },
+      /**
+       * Get skills directory
+       */
+      skills(configPath) {
+        return join(configPath, "skills");
+      },
+      /**
+       * Get agents directory
+       */
+      agents(configPath) {
+        return join(configPath, "agents");
+      },
+      /**
+       * Get commands directory
+       */
+      commands(configPath) {
+        return join(configPath, "commands");
+      },
+      /**
+       * Get tools directory
+       */
+      tools(configPath) {
+        return join(configPath, "tools");
+      },
+      /**
+       * Get plugins directory
+       */
+      plugins(configPath) {
+        return join(configPath, "plugins");
+      },
+      /**
+       * Get memory directory
+       */
+      memory(configPath) {
+        return join(configPath, "memory");
+      }
+    };
+  }
+});
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    logger = {
+      info(...args) {
+        console.log(chalk.blue("\u2139"), ...args);
+      },
+      success(...args) {
+        console.log(chalk.green("\u2713"), ...args);
+      },
+      warn(...args) {
+        console.log(chalk.yellow("\u26A0"), ...args);
+      },
+      error(...args) {
+        console.error(chalk.red("\u2716"), ...args);
+      },
+      debug(...args) {
+        if (process.env.DEBUG || process.env.AIKIT_DEBUG) {
+          console.log(chalk.gray("\u22EF"), ...args);
+        }
+      },
+      step(step, total, message) {
+        console.log(chalk.cyan(`[${step}/${total}]`), message);
+      },
+      header(message) {
+        console.log(chalk.bold.underline(`
+${message}
+`));
+      },
+      list(items, prefix = "\u2022") {
+        for (const item of items) {
+          console.log(`  ${prefix} ${item}`);
+        }
+      }
+    };
+  }
+});
+
+// src/core/tools/figma-mcp.ts
+var figma_mcp_exports = {};
+__export(figma_mcp_exports, {
+  FigmaMcpClient: () => FigmaMcpClient
+});
+import { writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { join as join5 } from "path";
+import { existsSync as existsSync2 } from "fs";
+var FigmaMcpClient;
+var init_figma_mcp = __esm({
+  "src/core/tools/figma-mcp.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    FigmaMcpClient = class {
+      apiKey;
+      configManager;
+      constructor(apiKey, configManager) {
+        this.apiKey = apiKey;
+        this.configManager = configManager;
+      }
+      /**
+       * Fetch helper with simple retry/backoff for 429/5xx
+       */
+      async fetchWithRetry(url, options, label, retries = 3, backoffMs = 1500) {
+        let attempt = 0;
+        let lastError;
+        while (attempt <= retries) {
+          try {
+            const res = await fetch(url, options);
+            if (res.ok) return res;
+            if (res.status === 429 || res.status >= 500) {
+              const retryAfter = Number(res.headers.get("retry-after")) || 0;
+              const delay = retryAfter > 0 ? retryAfter * 1e3 : backoffMs * (attempt + 1);
+              logger.warn(`${label} failed (status ${res.status}), retrying in ${Math.round(delay / 1e3)}s...`);
+              await new Promise((r) => setTimeout(r, delay));
+              attempt += 1;
+              continue;
+            }
+            const text = await res.text();
+            throw new Error(`${label} error: ${res.status} ${res.statusText}
+${text}`);
+          } catch (err) {
+            lastError = err;
+            logger.warn(`${label} network error, attempt ${attempt + 1}/${retries + 1}: ${err instanceof Error ? err.message : String(err)}`);
+            if (attempt >= retries) break;
+            await new Promise((r) => setTimeout(r, backoffMs * (attempt + 1)));
+            attempt += 1;
+          }
+        }
+        throw lastError instanceof Error ? lastError : new Error(`${label} failed after retries`);
+      }
+      /**
+       * Extract file key from Figma URL
+       */
+      extractFileKey(url) {
+        const match = url.match(/figma\.com\/design\/([a-zA-Z0-9]+)/);
+        return match ? match[1] : null;
+      }
+      /**
+       * Extract node ID from Figma URL
+       */
+      extractNodeId(url) {
+        const match = url.match(/[?&]node-id=([^&]+)/);
+        if (!match) return null;
+        let nodeId = decodeURIComponent(match[1]);
+        if (nodeId.includes("-") && !nodeId.includes(":")) {
+          nodeId = nodeId.replace(/-/g, ":");
+        }
+        return nodeId;
+      }
+      /**
+       * Get Figma file data using API
+       */
+      async getFileData(url) {
+        const fileKey = this.extractFileKey(url);
+        if (!fileKey) {
+          throw new Error(`Invalid Figma URL: ${url}`);
+        }
+        const nodeId = this.extractNodeId(url);
+        const apiUrl = nodeId ? `https://api.figma.com/v1/files/${fileKey}/nodes?ids=${encodeURIComponent(nodeId)}` : `https://api.figma.com/v1/files/${fileKey}`;
+        const response = await this.fetchWithRetry(apiUrl, {
+          headers: {
+            "X-Figma-Token": this.apiKey
+          }
+        }, "Figma file fetch");
+        const data = await response.json();
+        if (nodeId) {
+          const nodes = data.nodes;
+          const nodeData = Object.values(nodes)[0];
+          if (!nodeData) {
+            throw new Error(`Node not found: ${nodeId}`);
+          }
+          return {
+            document: nodeData.document,
+            components: {},
+            styles: {}
+          };
+        }
+        return data;
+      }
+      /**
+       * Extract design tokens from Figma file
+       */
+      async extractDesignTokens(url, downloadAssets = true, assetsDir) {
+        const fileData = await this.getFileData(url);
+        const fileKey = this.extractFileKey(url);
+        if (!fileKey) {
+          throw new Error(`Invalid Figma URL: ${url}`);
+        }
+        const tokens = {
+          colors: [],
+          typography: [],
+          spacing: {
+            unit: 8,
+            // Default 8px grid
+            scale: []
+          },
+          components: [],
+          screens: [],
+          breakpoints: [375, 768, 1024, 1280, 1920]
+          // Common breakpoints
+        };
+        const colorMap = /* @__PURE__ */ new Map();
+        this.extractColors(fileData.document, colorMap);
+        tokens.colors = Array.from(colorMap.entries()).map(([name, hex]) => ({
+          name,
+          hex,
+          rgba: hex
+          // Simplified
+        }));
+        const typographyMap = /* @__PURE__ */ new Map();
+        this.extractTypography(fileData.document, typographyMap);
+        tokens.typography = Array.from(typographyMap.values());
+        Object.values(fileData.components).forEach((component) => {
+          tokens.components.push({
+            name: component.name,
+            type: "component",
+            description: component.description
+          });
+        });
+        this.extractScreens(fileData.document, tokens.screens);
+        tokens.structure = this.extractStructure(fileData.document);
+        if (downloadAssets && tokens.structure) {
+          try {
+            tokens.assets = await this.downloadAssets(
+              fileKey,
+              fileData.document,
+              assetsDir || "./assets/images"
+            );
+          } catch (error) {
+            logger.warn(`Failed to download assets: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+        return tokens;
+      }
+      /**
+       * Recursively extract colors from nodes
+       */
+      extractColors(node, colorMap) {
+        if (node.fills && Array.isArray(node.fills)) {
+          node.fills.forEach((fill) => {
+            if (fill.type === "SOLID" && fill.color) {
+              const { r, g, b, a } = fill.color;
+              const hex = this.rgbaToHex(r, g, b, a);
+              const name = node.name || "Color";
+              if (!colorMap.has(hex)) {
+                colorMap.set(hex, hex);
+              }
+            }
+          });
+        }
+        if (node.strokes && Array.isArray(node.strokes)) {
+          node.strokes.forEach((stroke) => {
+            if (stroke.type === "SOLID" && stroke.color) {
+              const { r, g, b, a } = stroke.color;
+              const hex = this.rgbaToHex(r, g, b, a);
+              if (!colorMap.has(hex)) {
+                colorMap.set(hex, hex);
+              }
+            }
+          });
+        }
+        if (node.children) {
+          node.children.forEach((child) => this.extractColors(child, colorMap));
+        }
+      }
+      /**
+       * Recursively extract typography from nodes
+       */
+      extractTypography(node, typographyMap) {
+        if (node.type === "TEXT" && node.style) {
+          const key = `${node.style.fontFamily}-${node.style.fontSize}-${node.style.fontWeight}`;
+          if (!typographyMap.has(key)) {
+            typographyMap.set(key, {
+              name: `${node.style.fontSize}px ${node.style.fontFamily}`,
+              fontFamily: node.style.fontFamily || "Inter",
+              fontSize: node.style.fontSize || 16,
+              fontWeight: node.style.fontWeight || 400,
+              lineHeight: node.style.lineHeightPx || node.style.fontSize || 16,
+              letterSpacing: node.style.letterSpacing
+            });
+          }
+        }
+        if (node.children) {
+          node.children.forEach((child) => this.extractTypography(child, typographyMap));
+        }
+      }
+      /**
+       * Extract screens/frames with detailed information
+       */
+      extractScreens(node, screens) {
+        if (node.type === "FRAME" || node.type === "COMPONENT") {
+          if (node.absoluteBoundingBox) {
+            const isMainScreen = node.absoluteBoundingBox.width >= 800 && node.absoluteBoundingBox.height >= 400;
+            if (isMainScreen) {
+              screens.push({
+                id: node.id,
+                name: node.name,
+                width: node.absoluteBoundingBox.width,
+                height: node.absoluteBoundingBox.height,
+                type: node.type,
+                childrenCount: node.children?.length || 0
+              });
+            }
+          }
+        }
+        if (node.children) {
+          node.children.forEach((child) => this.extractScreens(child, screens));
+        }
+      }
+      /**
+       * Extract structure, content, and layout from nodes
+       */
+      extractStructure(node, depth = 0) {
+        const nodes = [];
+        const hierarchyLines = [];
+        const processNode = (n, level = 0) => {
+          const indent = "  ".repeat(level);
+          const childIds = [];
+          const nodeData = {
+            id: n.id,
+            name: n.name || "Unnamed",
+            type: n.type
+          };
+          if (n.absoluteBoundingBox) {
+            nodeData.position = {
+              x: n.absoluteBoundingBox.x,
+              y: n.absoluteBoundingBox.y,
+              width: n.absoluteBoundingBox.width,
+              height: n.absoluteBoundingBox.height
+            };
+          }
+          if (n.type === "TEXT" && n.characters) {
+            nodeData.content = n.characters;
+          }
+          const styles = {};
+          if (n.fills && Array.isArray(n.fills)) {
+            const solidFill = n.fills.find((f) => f.type === "SOLID" && f.color);
+            if (solidFill && solidFill.color) {
+              const { r, g, b, a } = solidFill.color;
+              styles.backgroundColor = this.rgbaToHex(r, g, b, a);
+            }
+          }
+          if (n.style) {
+            if (n.style.fontFamily) styles.fontFamily = n.style.fontFamily;
+            if (n.style.fontSize) styles.fontSize = n.style.fontSize;
+            if (n.style.fontWeight) styles.fontWeight = n.style.fontWeight;
+            if (n.style.lineHeightPx) styles.lineHeight = n.style.lineHeightPx;
+            if (n.fills && Array.isArray(n.fills)) {
+              const textFill = n.fills.find((f) => f.type === "SOLID" && f.color);
+              if (textFill && textFill.color) {
+                const { r, g, b, a } = textFill.color;
+                styles.color = this.rgbaToHex(r, g, b, a);
+              }
+            }
+          }
+          if (n.layoutMode) {
+            styles.layout = n.layoutMode;
+          }
+          if (n.itemSpacing !== void 0) {
+            styles.gap = n.itemSpacing;
+          }
+          if (n.paddingLeft || n.paddingRight || n.paddingTop || n.paddingBottom) {
+            styles.padding = {
+              top: n.paddingTop || 0,
+              right: n.paddingRight || 0,
+              bottom: n.paddingBottom || 0,
+              left: n.paddingLeft || 0
+            };
+          }
+          if (Object.keys(styles).length > 0) {
+            nodeData.styles = styles;
+          }
+          if (n.children && n.children.length > 0) {
+            n.children.forEach((child) => {
+              const childNodeIds = processNode(child, level + 1);
+              childIds.push(child.id);
+              childIds.push(...childNodeIds);
+            });
+            nodeData.children = n.children.map((c) => c.id);
+          }
+          nodes.push(nodeData);
+          const typeLabel = n.type.toLowerCase();
+          const nameLabel = n.name || "Unnamed";
+          const contentPreview = n.type === "TEXT" && n.characters ? `: "${n.characters.substring(0, 50)}${n.characters.length > 50 ? "..." : ""}"` : "";
+          const sizeLabel = n.absoluteBoundingBox ? ` [${Math.round(n.absoluteBoundingBox.width)}\xD7${Math.round(n.absoluteBoundingBox.height)}]` : "";
+          hierarchyLines.push(`${indent}${typeLabel} "${nameLabel}"${contentPreview}${sizeLabel}`);
+          return [n.id, ...childIds];
+        };
+        processNode(node, depth);
+        return {
+          nodes,
+          hierarchy: hierarchyLines.join("\n")
+        };
+      }
+      /**
+       * Find all nodes that can be exported as images (optionally filtered by screen)
+       */
+      findImageNodes(node, imageNodes = [], screenId, isWithinScreen = false) {
+        const currentIsScreen = node.id === screenId;
+        const nowWithinScreen = isWithinScreen || currentIsScreen;
+        if (screenId && !nowWithinScreen && node.type !== "PAGE") {
+          if (node.children) {
+            node.children.forEach((child) => this.findImageNodes(child, imageNodes, screenId, false));
+          }
+          return;
+        }
+        const exportableTypes = ["VECTOR", "COMPONENT", "INSTANCE", "FRAME", "GROUP", "RECTANGLE", "ELLIPSE"];
+        const hasImageFill = node.fills?.some((fill) => fill.type === "IMAGE" || fill.imageRef);
+        const isExportable = exportableTypes.includes(node.type) || hasImageFill;
+        if (isExportable && node.absoluteBoundingBox) {
+          const minSize = 16;
+          if (node.absoluteBoundingBox.width >= minSize && node.absoluteBoundingBox.height >= minSize) {
+            imageNodes.push({
+              id: node.id,
+              name: node.name || "Unnamed",
+              type: node.type,
+              width: node.absoluteBoundingBox.width,
+              height: node.absoluteBoundingBox.height
+            });
+          }
+        }
+        if (node.children) {
+          node.children.forEach((child) => this.findImageNodes(child, imageNodes, screenId, nowWithinScreen));
+        }
+      }
+      /**
+       * Download images/assets from Figma (optionally filtered by screen)
+       */
+      async downloadAssets(fileKey, rootNode, assetsDir, screenId) {
+        const imageNodes = [];
+        this.findImageNodes(rootNode, imageNodes, screenId);
+        if (imageNodes.length === 0) {
+          logger.info("No image nodes found to download");
+          return [];
+        }
+        logger.info(`Found ${imageNodes.length} image nodes to download`);
+        const nodesToDownload = imageNodes.slice(0, 50);
+        const nodeIds = nodesToDownload.map((n) => n.id).join(",");
+        const imageUrl = `https://api.figma.com/v1/images/${fileKey}?ids=${encodeURIComponent(nodeIds)}&format=png&scale=2`;
+        const response = await this.fetchWithRetry(imageUrl, {
+          headers: {
+            "X-Figma-Token": this.apiKey
+          }
+        }, "Figma images listing");
+        const imageData = await response.json();
+        const images = imageData.images;
+        const fullAssetsDir = assetsDir.startsWith("/") ? assetsDir : join5(process.cwd(), assetsDir);
+        if (!existsSync2(fullAssetsDir)) {
+          await mkdir3(fullAssetsDir, { recursive: true });
+        }
+        const downloadedAssets = [];
+        for (const node of nodesToDownload) {
+          const imageUrl2 = images[node.id];
+          if (!imageUrl2) {
+            logger.warn(`No image URL returned for node ${node.id} (${node.name})`);
+            continue;
+          }
+          try {
+            const imageResponse = await this.fetchWithRetry(
+              imageUrl2,
+              {},
+              `Download image ${node.id}`
+            );
+            const imageBuffer = await imageResponse.arrayBuffer();
+            const safeName = node.name.replace(/[^a-z0-9]/gi, "_").toLowerCase().substring(0, 50);
+            const extension = "png";
+            const filename = `${safeName}_${node.id.substring(0, 8)}.${extension}`;
+            const filePath = join5(fullAssetsDir, filename);
+            await writeFile3(filePath, Buffer.from(imageBuffer));
+            downloadedAssets.push({
+              nodeId: node.id,
+              nodeName: node.name,
+              nodeType: node.type,
+              format: extension,
+              path: filePath,
+              url: imageUrl2,
+              width: node.width,
+              height: node.height
+            });
+            logger.info(`Downloaded: ${filename} (${node.name})`);
+          } catch (error) {
+            logger.warn(`Error downloading image for node ${node.id}: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+        logger.info(`Downloaded ${downloadedAssets.length} assets to ${fullAssetsDir}`);
+        return downloadedAssets;
+      }
+      /**
+       * Convert RGBA to hex
+       */
+      rgbaToHex(r, g, b, a = 1) {
+        const toHex = (n) => {
+          const hex = Math.round(n * 255).toString(16);
+          return hex.length === 1 ? "0" + hex : hex;
+        };
+        return `#${toHex(r)}${toHex(g)}${toHex(b)}${a < 1 ? toHex(a) : ""}`;
+      }
+    };
+  }
+});
+
+// src/core/tools/figma-screen-developer.ts
+var figma_screen_developer_exports = {};
+__export(figma_screen_developer_exports, {
+  checkCurrentCodeStatus: () => checkCurrentCodeStatus,
+  compareCodeWithFigma: () => compareCodeWithFigma
+});
+import { readFile as readFile4, readdir as readdir3 } from "fs/promises";
+import { join as join6 } from "path";
+import { existsSync as existsSync3 } from "fs";
+async function checkCurrentCodeStatus(projectPath = process.cwd()) {
+  const status = {
+    hasHTML: false,
+    htmlFile: void 0,
+    hasCSS: false,
+    cssFiles: [],
+    hasAssets: false,
+    assetCount: 0,
+    sections: []
+  };
+  try {
+    const htmlFiles = ["index.html", "index.htm", "main.html"].filter(
+      (file) => existsSync3(join6(projectPath, file))
+    );
+    if (htmlFiles.length > 0) {
+      status.hasHTML = true;
+      status.htmlFile = htmlFiles[0];
+      try {
+        const htmlContent = await readFile4(join6(projectPath, htmlFiles[0]), "utf-8");
+        const sectionMatches = htmlContent.match(/<(section|div|header|footer|main|article|aside)[^>]*(?:id|class)=["']([^"']+)["']/gi);
+        if (sectionMatches) {
+          status.sections = sectionMatches.map((match) => {
+            const idMatch = match.match(/id=["']([^"']+)["']/i);
+            const classMatch = match.match(/class=["']([^"']+)["']/i);
+            return idMatch ? idMatch[1] : classMatch ? classMatch[1].split(" ")[0] : "";
+          }).filter(Boolean);
+        }
+      } catch (e) {
+      }
+    }
+    const stylesDir = join6(projectPath, "styles");
+    if (existsSync3(stylesDir)) {
+      try {
+        const files = await readdir3(stylesDir);
+        const cssFiles = files.filter((f) => f.endsWith(".css"));
+        if (cssFiles.length > 0) {
+          status.hasCSS = true;
+          status.cssFiles = cssFiles.map((f) => join6(stylesDir, f));
+        }
+      } catch (e) {
+      }
+    }
+    const assetsDir = join6(projectPath, "assets", "images");
+    if (existsSync3(assetsDir)) {
+      try {
+        const files = await readdir3(assetsDir);
+        const imageFiles = files.filter((f) => /\.(png|jpg|jpeg|svg|webp)$/i.test(f));
+        if (imageFiles.length > 0) {
+          status.hasAssets = true;
+          status.assetCount = imageFiles.length;
+        }
+      } catch (e) {
+      }
+    }
+  } catch (error) {
+    logger.warn(`Error checking code status: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return status;
+}
+async function compareCodeWithFigma(figmaTokens, selectedScreenId, projectPath = process.cwd()) {
+  const codeStatus = await checkCurrentCodeStatus(projectPath);
+  const result = {
+    missingSections: [],
+    missingAssets: [],
+    needsUpdate: false,
+    recommendations: []
+  };
+  const selectedScreen = figmaTokens.screens?.find((s) => s.id === selectedScreenId);
+  if (!selectedScreen) {
+    result.recommendations.push("Selected screen not found in Figma design");
+    return result;
+  }
+  const figmaSections = [];
+  if (figmaTokens.structure?.nodes) {
+    const screenNode = figmaTokens.structure.nodes.find((n) => n.id === selectedScreenId);
+    if (screenNode?.children) {
+      screenNode.children.forEach((childId) => {
+        const childNode = figmaTokens.structure.nodes.find((n) => n.id === childId);
+        if (childNode && (childNode.type === "FRAME" || childNode.type === "COMPONENT")) {
+          const sectionName = childNode.name.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-");
+          figmaSections.push(sectionName);
+        }
+      });
+    }
+  }
+  const existingSections = codeStatus.sections.map((s) => s.toLowerCase());
+  result.missingSections = figmaSections.filter(
+    (s) => !existingSections.some((existing) => existing.includes(s) || s.includes(existing))
+  );
+  if (codeStatus.assetCount === 0) {
+    result.missingAssets.push("All assets need to be downloaded");
+    result.needsUpdate = true;
+  }
+  if (!codeStatus.hasHTML) {
+    result.recommendations.push("Create index.html with HTML5 structure");
+  }
+  if (!codeStatus.hasCSS) {
+    result.recommendations.push("Create CSS files (variables.css, base.css, components.css)");
+  }
+  if (result.missingSections.length > 0) {
+    result.recommendations.push(`Implement missing sections: ${result.missingSections.join(", ")}`);
+  }
+  if (result.missingAssets.length > 0) {
+    result.recommendations.push("Download required assets from Figma");
+  }
+  return result;
+}
+var init_figma_screen_developer = __esm({
+  "src/core/tools/figma-screen-developer.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+  }
+});
+
+// src/core/memory.ts
+var memory_exports = {};
+__export(memory_exports, {
+  MemoryManager: () => MemoryManager
+});
+import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir4, access as access2, constants as constants2 } from "fs/promises";
+import { join as join7 } from "path";
+var MemoryManager;
+var init_memory = __esm({
+  "src/core/memory.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+    MemoryManager = class {
+      config;
+      constructor(config) {
+        this.config = config;
+      }
+      /**
+       * List all memory entries
+       */
+      async list() {
+        const memories = [];
+        const memoryPath = paths.memory(this.config.configPath);
+        const subDirs = ["observations", "handoffs", "research"];
+        for (const subDir of subDirs) {
+          const dirPath = join7(memoryPath, subDir);
+          try {
+            const { readdir: readdir5 } = await import("fs/promises");
+            const files = await readdir5(dirPath);
+            for (const file of files) {
+              if (!file.endsWith(".md")) continue;
+              const content = await readFile5(join7(dirPath, file), "utf-8");
+              const summary = this.extractSummary(content);
+              memories.push({
+                key: `${subDir}/${file.replace(".md", "")}`,
+                content,
+                summary,
+                createdAt: /* @__PURE__ */ new Date(),
+                // Would get from file stats
+                updatedAt: /* @__PURE__ */ new Date(),
+                type: subDir
+              });
+            }
+          } catch {
+          }
+        }
+        return memories;
+      }
+      /**
+       * Read a memory entry
+       */
+      async read(key) {
+        const memoryPath = paths.memory(this.config.configPath);
+        let filePath;
+        if (key.includes("/")) {
+          filePath = join7(memoryPath, `${key}.md`);
+        } else {
+          const subDirs = ["observations", "handoffs", "research", "_templates"];
+          for (const subDir of subDirs) {
+            const testPath = join7(memoryPath, subDir, `${key}.md`);
+            try {
+              await access2(testPath, constants2.R_OK);
+              filePath = testPath;
+              break;
+            } catch {
+              continue;
+            }
+          }
+          filePath = filePath || join7(memoryPath, `${key}.md`);
+        }
+        try {
+          return await readFile5(filePath, "utf-8");
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Update a memory entry
+       */
+      async update(key, content, options) {
+        const memoryPath = paths.memory(this.config.configPath);
+        const type = options?.type || "custom";
+        let filePath;
+        if (key.includes("/")) {
+          filePath = join7(memoryPath, `${key}.md`);
+        } else {
+          const subDir = type === "observation" ? "observations" : type === "handoff" ? "handoffs" : type === "research" ? "research" : "";
+          filePath = join7(memoryPath, subDir, `${key}.md`);
+        }
+        const { dirname: dirname2 } = await import("path");
+        await mkdir4(dirname2(filePath), { recursive: true });
+        if (options?.append) {
+          try {
+            const existing = await readFile5(filePath, "utf-8");
+            const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+            content = `${existing}
+
+---
+_Updated: ${timestamp}_
+
+${content}`;
+          } catch {
+          }
+        }
+        await writeFile4(filePath, content);
+      }
+      /**
+       * Create a handoff bundle
+       */
+      async createHandoff(summary) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        const key = `handoffs/${timestamp}`;
+        const content = `# Handoff: ${(/* @__PURE__ */ new Date()).toLocaleString()}
+
+## Completed
+${summary.completed.map((item) => `- [x] ${item}`).join("\n") || "- None"}
+
+## In Progress
+${summary.inProgress.map((item) => `- [ ] ${item}`).join("\n") || "- None"}
+
+## Remaining
+${summary.remaining.map((item) => `- [ ] ${item}`).join("\n") || "- None"}
+
+## Context
+${summary.context || "No additional context."}
+
+## Next Steps
+${summary.nextSteps.map((step, i) => `${i + 1}. ${step}`).join("\n") || "- Continue from where left off"}
+`;
+        await this.update(key, content, { type: "handoff" });
+        return key;
+      }
+      /**
+       * Get the latest handoff
+       */
+      async getLatestHandoff() {
+        const memories = await this.list();
+        const handoffs = memories.filter((m) => m.type === "handoff");
+        if (handoffs.length === 0) return null;
+        handoffs.sort((a, b) => b.key.localeCompare(a.key));
+        return handoffs[0];
+      }
+      /**
+       * Create an observation
+       */
+      async createObservation(title, observation) {
+        const slug = title.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+        const key = `observations/${slug}`;
+        const content = `# ${title}
+
+## What
+${observation.what}
+
+## Why
+${observation.why}
+
+## Impact
+${observation.impact}
+
+${observation.tags?.length ? `## Tags
+${observation.tags.map((t) => `- ${t}`).join("\n")}` : ""}
+
+---
+_Created: ${(/* @__PURE__ */ new Date()).toISOString()}_
+`;
+        await this.update(key, content, { type: "observation" });
+        return key;
+      }
+      /**
+       * Save research findings
+       */
+      async saveResearch(topic, findings) {
+        const slug = topic.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+        const key = `research/${slug}`;
+        const content = `# Research: ${topic}
+
+## Summary
+${findings.summary}
+
+## Sources
+${findings.sources.map((s) => `- ${s}`).join("\n")}
+
+## Recommendations
+${findings.recommendations.map((r, i) => `${i + 1}. ${r}`).join("\n")}
+
+${findings.codeExamples ? `## Code Examples
+\`\`\`
+${findings.codeExamples}
+\`\`\`` : ""}
+
+---
+_Researched: ${(/* @__PURE__ */ new Date()).toISOString()}_
+`;
+        await this.update(key, content, { type: "research" });
+        return key;
+      }
+      /**
+       * Extract a summary from content (first paragraph or heading)
+       */
+      extractSummary(content) {
+        const lines = content.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          if (!line.startsWith("#") && line.trim().length > 0) {
+            return line.slice(0, 100) + (line.length > 100 ? "..." : "");
+          }
+        }
+        if (lines[0]?.startsWith("#")) {
+          return lines[0].replace(/^#+\s*/, "");
+        }
+        return "No summary available";
+      }
+    };
+  }
+});
+
+// src/mcp-server.ts
+init_esm_shims();
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/core/config.ts
+init_esm_shims();
+init_paths();
+import { readFile, access, constants } from "fs/promises";
+import { join as join2 } from "path";
+import { z } from "zod";
+var ConfigSchema = z.object({
+  version: z.string(),
+  skills: z.object({
+    enabled: z.boolean().default(true),
+    directory: z.string().optional()
+  }).default({}),
+  agents: z.object({
+    enabled: z.boolean().default(true),
+    default: z.string().default("build")
+  }).default({}),
+  commands: z.object({
+    enabled: z.boolean().default(true)
+  }).default({}),
+  tools: z.object({
+    enabled: z.boolean().default(true)
+  }).default({}),
+  plugins: z.object({
+    enabled: z.boolean().default(true),
+    autoload: z.array(z.string()).optional()
+  }).default({}),
+  memory: z.object({
+    enabled: z.boolean().default(true),
+    maxSize: z.number().optional()
+  }).default({}),
+  beads: z.object({
+    enabled: z.boolean().default(true),
+    autoInit: z.boolean().default(false)
+  }).default({}),
+  antiHallucination: z.object({
+    enabled: z.boolean().default(true),
+    specFile: z.string().default("spec.md"),
+    reviewFile: z.string().default("review.md")
+  }).default({}),
+  mcp: z.object({
+    context7: z.boolean().default(false),
+    githubGrep: z.boolean().default(false),
+    gkg: z.boolean().default(false)
+  }).optional()
+});
+var Config = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  get() {
+    return this.config;
+  }
+  get skills() {
+    return this.config.skills;
+  }
+  get agents() {
+    return this.config.agents;
+  }
+  get commands() {
+    return this.config.commands;
+  }
+  get tools() {
+    return this.config.tools;
+  }
+  get plugins() {
+    return this.config.plugins;
+  }
+  get memory() {
+    return this.config.memory;
+  }
+  get beads() {
+    return this.config.beads;
+  }
+  get antiHallucination() {
+    return this.config.antiHallucination;
+  }
+  get configPath() {
+    return this.config.configPath;
+  }
+  get projectPath() {
+    return this.config.projectPath;
+  }
+  /**
+   * Get path to a specific resource
+   */
+  getPath(resource) {
+    return paths[resource](this.configPath);
+  }
+};
+async function loadConfig(projectPath) {
+  const project = projectPath || process.cwd();
+  const projectConfigPath = paths.projectConfig(project);
+  const globalConfigPath = paths.globalConfig();
+  let configPath;
+  let configData = {};
+  try {
+    await access(join2(globalConfigPath, "aikit.json"), constants.R_OK);
+    const globalContent = await readFile(join2(globalConfigPath, "aikit.json"), "utf-8");
+    configData = JSON.parse(globalContent);
+    configPath = globalConfigPath;
+  } catch {
+    configPath = projectConfigPath;
+  }
+  try {
+    await access(join2(projectConfigPath, "aikit.json"), constants.R_OK);
+    const projectContent = await readFile(join2(projectConfigPath, "aikit.json"), "utf-8");
+    const projectData = JSON.parse(projectContent);
+    configData = deepMerge(configData, projectData);
+    configPath = projectConfigPath;
+  } catch {
+  }
+  if (!configData.version) {
+    configData.version = "0.1.0";
+  }
+  const parsed = ConfigSchema.parse(configData);
+  return new Config({
+    ...parsed,
+    configPath,
+    projectPath: project
+  });
+}
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const key in override) {
+    const baseValue = base[key];
+    const overrideValue = override[key];
+    if (typeof baseValue === "object" && baseValue !== null && typeof overrideValue === "object" && overrideValue !== null && !Array.isArray(baseValue) && !Array.isArray(overrideValue)) {
+      result[key] = deepMerge(
+        baseValue,
+        overrideValue
+      );
+    } else if (overrideValue !== void 0) {
+      result[key] = overrideValue;
+    }
+  }
+  return result;
+}
+
+// src/core/skills.ts
+init_esm_shims();
+init_paths();
+import { readFile as readFile2, readdir, writeFile, mkdir } from "fs/promises";
+import { join as join3, basename, extname } from "path";
+import matter from "gray-matter";
+var SkillEngine = class {
+  config;
+  skillsCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * List all available skills
+   */
+  async listSkills() {
+    const skills = [];
+    const globalSkillsPath = paths.skills(paths.globalConfig());
+    try {
+      const globalSkills = await this.loadSkillsFromDir(globalSkillsPath);
+      skills.push(...globalSkills);
+    } catch {
+    }
+    const projectSkillsPath = paths.skills(this.config.configPath);
+    if (projectSkillsPath !== globalSkillsPath) {
+      try {
+        const projectSkills = await this.loadSkillsFromDir(projectSkillsPath);
+        for (const skill of projectSkills) {
+          const existingIndex = skills.findIndex((s) => s.name === skill.name);
+          if (existingIndex >= 0) {
+            skills[existingIndex] = skill;
+          } else {
+            skills.push(skill);
+          }
+        }
+      } catch {
+      }
+    }
+    return skills.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  /**
+   * Get a specific skill by name
+   */
+  async getSkill(name) {
+    if (this.skillsCache.has(name)) {
+      return this.skillsCache.get(name);
+    }
+    const skills = await this.listSkills();
+    const skill = skills.find((s) => s.name === name);
+    if (skill) {
+      this.skillsCache.set(name, skill);
+    }
+    return skill || null;
+  }
+  /**
+   * Find skills matching a query
+   */
+  async findSkills(query) {
+    const skills = await this.listSkills();
+    if (!query) {
+      return skills;
+    }
+    const lowerQuery = query.toLowerCase();
+    return skills.filter(
+      (skill) => skill.name.toLowerCase().includes(lowerQuery) || skill.description.toLowerCase().includes(lowerQuery) || skill.tags.some((tag) => tag.toLowerCase().includes(lowerQuery)) || skill.category.toLowerCase().includes(lowerQuery)
+    );
+  }
+  /**
+   * Create a new skill
+   */
+  async createSkill(name, options) {
+    const configPath = options?.global ? paths.globalConfig() : this.config.configPath;
+    const skillsDir = paths.skills(configPath);
+    await mkdir(skillsDir, { recursive: true });
+    const fileName = `${name.replace(/\s+/g, "-").toLowerCase()}.md`;
+    const filePath = join3(skillsDir, fileName);
+    const frontmatter = {
+      name,
+      description: options?.description || `Use when you need to ${name}`,
+      useWhen: options?.useWhen || `The user asks you to ${name}`,
+      category: options?.category || "custom",
+      tags: options?.tags || ["custom"]
+    };
+    const content = options?.content || `## ${name}
+
+### Overview
+Describe what this skill does.
+
+### Workflow
+
+#### Step 1: Understand the Task
+- Gather context
+- Clarify requirements
+
+#### Step 2: Plan the Approach
+- Break down into sub-tasks
+- Identify dependencies
+
+#### Step 3: Execute
+- Follow TDD principles
+- Write tests first
+
+#### Step 4: Verify
+- Run all tests
+- Check for regressions
+
+### Checklist
+- [ ] Requirements understood
+- [ ] Tests written
+- [ ] Implementation complete
+- [ ] All tests passing
+- [ ] Code reviewed
+`;
+    const fileContent = matter.stringify(content, frontmatter);
+    await writeFile(filePath, fileContent);
+    const skill = {
+      name,
+      description: frontmatter.description,
+      useWhen: frontmatter.useWhen,
+      category: frontmatter.category,
+      tags: frontmatter.tags,
+      content,
+      filePath
+    };
+    this.skillsCache.set(name, skill);
+    return skill;
+  }
+  /**
+   * Sync global skills to project directory
+   */
+  async syncSkillsToProject() {
+    const globalSkillsPath = paths.skills(paths.globalConfig());
+    const projectSkillsPath = paths.skills(this.config.configPath);
+    if (globalSkillsPath === projectSkillsPath) {
+      return { count: 0, synced: [] };
+    }
+    const globalSkills = await this.loadSkillsFromDir(globalSkillsPath);
+    await mkdir(projectSkillsPath, { recursive: true });
+    const synced = [];
+    for (const skill of globalSkills) {
+      const fileName = `${skill.name.replace(/\s+/g, "-").toLowerCase()}.md`;
+      const destPath = join3(projectSkillsPath, fileName);
+      const srcContent = await readFile2(skill.filePath, "utf-8");
+      await writeFile(destPath, srcContent);
+      synced.push(skill.name);
+    }
+    return { count: synced.length, synced };
+  }
+  /**
+   * Format skill for agent consumption
+   */
+  formatForAgent(skill) {
+    return `# Skill: ${skill.name}
+
+## When to Use
+${skill.useWhen}
+
+## Description
+${skill.description}
+
+## Workflow
+${skill.content}
+
+---
+**IMPORTANT**: Follow this workflow step by step. Do not skip steps.
+`;
+  }
+  /**
+   * Load skills from a directory
+   */
+  async loadSkillsFromDir(dir) {
+    const files = await readdir(dir);
+    const skills = [];
+    for (const file of files) {
+      if (extname(file) !== ".md") continue;
+      const filePath = join3(dir, file);
+      const content = await readFile2(filePath, "utf-8");
+      const { data, content: body } = matter(content);
+      const frontmatter = data;
+      const name = frontmatter.name || basename(file, ".md");
+      skills.push({
+        name,
+        description: frontmatter.description || "",
+        useWhen: frontmatter.useWhen || "",
+        category: frontmatter.category || "general",
+        tags: frontmatter.tags || [],
+        content: body.trim(),
+        filePath
+      });
+    }
+    return skills;
+  }
+};
+
+// src/core/agents.ts
+init_esm_shims();
+var DEFAULT_AGENTS = [
+  {
+    name: "planner",
+    displayName: "@planner",
+    description: "Strategic planning and multi-agent coordination",
+    useWhen: "Complex tasks requiring architecture decisions, multi-step planning, or coordination between specialists",
+    capabilities: [
+      "Break down complex tasks into sub-tasks",
+      "Coordinate between specialist agents",
+      "Make architecture decisions",
+      "Create implementation plans"
+    ],
+    systemPrompt: `You are a strategic planner agent. Your role is to:
+
+1. ANALYZE the task and understand the full scope
+2. BREAK DOWN complex tasks into smaller, manageable sub-tasks
+3. DELEGATE to appropriate specialist agents
+4. COORDINATE the overall workflow
+5. VERIFY completion of the overall goal
+
+When delegating:
+- Use @build for implementation tasks
+- Use @scout for external research
+- Use @review for code review and security audits
+- Use @explore for codebase navigation
+- Use @vision for visual analysis
+
+Always create a clear plan before delegating. Track progress and ensure all sub-tasks complete successfully.`,
+    delegatesTo: ["build", "scout", "review", "explore", "vision"]
+  },
+  {
+    name: "build",
+    displayName: "@build",
+    description: "Primary execution agent for implementing features",
+    useWhen: "Implementing features, writing code, making changes to the codebase",
+    capabilities: [
+      "Write production code",
+      "Write tests",
+      "Refactor code",
+      "Fix bugs",
+      "Implement features"
+    ],
+    systemPrompt: `You are the build agent. Your role is to implement code changes.
+
+Follow these principles:
+1. TEST-DRIVEN DEVELOPMENT: Write tests before implementation
+2. INCREMENTAL CHANGES: Make small, focused commits
+3. VERIFY: Run tests and type checks after each change
+4. DOCUMENT: Add comments for complex logic
+
+Before starting:
+- Understand the requirements fully
+- Check existing patterns in the codebase
+- Plan the implementation approach
+
+After completing:
+- Ensure all tests pass
+- Run linting and type checks
+- Create a clear commit message`,
+    delegatesTo: ["review", "explore"]
+  },
+  {
+    name: "rush",
+    displayName: "@rush",
+    description: "Fast execution with minimal planning",
+    useWhen: "Quick fixes, hotfixes, simple edits that need minimal planning",
+    capabilities: [
+      "Quick bug fixes",
+      "Simple refactoring",
+      "Minor changes",
+      "Hotfixes"
+    ],
+    systemPrompt: `You are the rush agent. Your role is to make quick, focused changes.
+
+Guidelines:
+1. ACT FAST: Minimal planning, direct execution
+2. FOCUS: One change at a time
+3. VERIFY: Quick sanity check after change
+4. MINIMAL SCOPE: Don't expand beyond the immediate task
+
+Use for:
+- Typo fixes
+- Simple bug fixes
+- Minor adjustments
+- Urgent hotfixes`,
+    delegatesTo: []
+  },
+  {
+    name: "review",
+    displayName: "@review",
+    description: "Code review, debugging, and security audits",
+    useWhen: "Reviewing code quality, finding bugs, security review, debugging issues",
+    capabilities: [
+      "Code review",
+      "Security audit",
+      "Performance analysis",
+      "Bug finding",
+      "Best practices enforcement"
+    ],
+    systemPrompt: `You are the review agent. Your role is to review and improve code quality.
+
+Review checklist:
+1. CORRECTNESS: Does the code do what it's supposed to?
+2. SECURITY: Are there any security vulnerabilities?
+3. PERFORMANCE: Are there performance issues?
+4. MAINTAINABILITY: Is the code clean and readable?
+5. TESTS: Are there adequate tests?
+6. PATTERNS: Does it follow project conventions?
+
+When reviewing:
+- Be specific about issues
+- Suggest fixes, not just problems
+- Prioritize by severity
+- Check for edge cases`,
+    delegatesTo: []
+  },
+  {
+    name: "scout",
+    displayName: "@scout",
+    description: "External research - library docs, GitHub patterns, frameworks",
+    useWhen: "Researching external libraries, finding code patterns on GitHub, learning about frameworks",
+    capabilities: [
+      "Web research",
+      "GitHub code search",
+      "Documentation lookup",
+      "Framework exploration",
+      "Best practices research"
+    ],
+    systemPrompt: `You are the scout agent. Your role is to research external resources.
+
+Research strategy:
+1. UNDERSTAND what information is needed
+2. SEARCH appropriate sources (docs, GitHub, web)
+3. EVALUATE quality and relevance of findings
+4. SUMMARIZE key findings concisely
+5. PROVIDE actionable recommendations
+
+Sources to use:
+- Official documentation
+- GitHub code examples
+- Stack Overflow (verified answers)
+- Framework guides
+- Community best practices
+
+Always cite your sources and verify information accuracy.`,
+    delegatesTo: []
+  },
+  {
+    name: "explore",
+    displayName: "@explore",
+    description: "Fast codebase navigation and pattern search",
+    useWhen: "Finding files, understanding codebase structure, searching for patterns in code",
+    capabilities: [
+      "File discovery",
+      "Pattern search",
+      "Codebase navigation",
+      "Structure analysis",
+      "Dependency mapping"
+    ],
+    systemPrompt: `You are the explore agent. Your role is to navigate and understand the codebase.
+
+Exploration techniques:
+1. FILE STRUCTURE: Understand project organization
+2. GREP SEARCH: Find specific patterns or usages
+3. DEPENDENCY ANALYSIS: Map relationships between modules
+4. PATTERN DISCOVERY: Find existing patterns to follow
+5. QUICK CONTEXT: Gather just enough context for the task
+
+Focus on speed and accuracy. Provide concise summaries of findings.`,
+    delegatesTo: []
+  },
+  {
+    name: "vision",
+    displayName: "@vision",
+    description: "Multimodal analysis - mockups, PDFs, diagrams",
+    useWhen: "Analyzing images, mockups, screenshots, PDFs, or diagrams",
+    capabilities: [
+      "Image analysis",
+      "Mockup interpretation",
+      "PDF extraction",
+      "Diagram understanding",
+      "UI/UX analysis"
+    ],
+    systemPrompt: `You are the vision agent. Your role is to analyze visual content.
+
+Analysis approach:
+1. OBSERVE: Carefully examine the visual content
+2. EXTRACT: Identify key information, text, structure
+3. INTERPRET: Understand the intent and requirements
+4. TRANSLATE: Convert visual specs to actionable tasks
+5. VALIDATE: Ensure accurate interpretation
+
+For mockups:
+- Identify components and layout
+- Note colors, spacing, typography
+- Extract interaction patterns
+
+For diagrams:
+- Understand relationships
+- Map to code structure
+- Note data flow`,
+    delegatesTo: []
+  }
+];
+var AgentManager = class {
+  config;
+  agents;
+  constructor(config) {
+    this.config = config;
+    this.agents = /* @__PURE__ */ new Map();
+    for (const agent of DEFAULT_AGENTS) {
+      this.agents.set(agent.name, agent);
+    }
+  }
+  /**
+   * List all available agents
+   */
+  listAgents() {
+    return Array.from(this.agents.values());
+  }
+  /**
+   * Get a specific agent
+   */
+  getAgent(name) {
+    return this.agents.get(name);
+  }
+  /**
+   * Get the default agent
+   */
+  getDefaultAgent() {
+    const defaultName = this.config.agents.default;
+    return this.agents.get(defaultName) || this.agents.get("build");
+  }
+  /**
+   * Decide which agent should handle a task
+   */
+  decideAgent(task, _context) {
+    const lowerTask = task.toLowerCase();
+    for (const [name, agent] of this.agents) {
+      if (lowerTask.includes(`@${name}`)) {
+        return {
+          agent,
+          reason: `Explicitly requested @${name}`,
+          shouldDelegate: false
+        };
+      }
+    }
+    if (this.matchesKeywords(lowerTask, ["plan", "architect", "design", "coordinate", "complex"])) {
+      return {
+        agent: this.agents.get("planner"),
+        reason: "Task requires planning and coordination",
+        shouldDelegate: true
+      };
+    }
+    if (this.matchesKeywords(lowerTask, ["research", "docs", "documentation", "library", "framework", "how to"])) {
+      return {
+        agent: this.agents.get("scout"),
+        reason: "Task requires external research",
+        shouldDelegate: false
+      };
+    }
+    if (this.matchesKeywords(lowerTask, ["review", "audit", "security", "check", "debug"])) {
+      return {
+        agent: this.agents.get("review"),
+        reason: "Task requires code review or debugging",
+        shouldDelegate: false
+      };
+    }
+    if (this.matchesKeywords(lowerTask, ["find", "search", "where", "locate", "explore"])) {
+      return {
+        agent: this.agents.get("explore"),
+        reason: "Task requires codebase exploration",
+        shouldDelegate: false
+      };
+    }
+    if (this.matchesKeywords(lowerTask, ["image", "mockup", "screenshot", "pdf", "diagram", "visual"])) {
+      return {
+        agent: this.agents.get("vision"),
+        reason: "Task requires visual analysis",
+        shouldDelegate: false
+      };
+    }
+    if (this.matchesKeywords(lowerTask, ["fix quickly", "hotfix", "urgent", "quick fix", "typo"])) {
+      return {
+        agent: this.agents.get("rush"),
+        reason: "Task is a quick fix",
+        shouldDelegate: false
+      };
+    }
+    return {
+      agent: this.agents.get("build"),
+      reason: "Default to build agent for implementation",
+      shouldDelegate: false
+    };
+  }
+  /**
+   * Format agent instructions for prompt
+   */
+  formatAgentPrompt(agent) {
+    return `# Agent: ${agent.displayName}
+
+${agent.systemPrompt}
+
+## Capabilities
+${agent.capabilities.map((c) => `- ${c}`).join("\n")}
+
+${agent.delegatesTo.length > 0 ? `## Can Delegate To
+${agent.delegatesTo.map((a) => `- @${a}`).join("\n")}` : ""}
+`;
+  }
+  matchesKeywords(text, keywords) {
+    return keywords.some((kw) => text.includes(kw));
+  }
+};
+
+// src/core/commands.ts
+init_esm_shims();
+init_paths();
+import { readFile as readFile3, readdir as readdir2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join4, basename as basename2, extname as extname2 } from "path";
+import matter2 from "gray-matter";
+var DEFAULT_COMMANDS = [
+  // Core Workflow Commands (Beads integration)
+  {
+    name: "create",
+    description: "Create a new Beads task for tracking",
+    category: "core",
+    usage: "/create <task description>",
+    examples: ["/create Add user authentication", "/create Fix navigation bug"],
+    content: `Create a new task in the Beads system (.beads/ directory).
+
+## Workflow
+1. Create a new bead file with unique ID
+2. Add task description, status, and notes
+3. Set status to "in-progress"
+4. Initialize working notes section
+
+## Required Output
+- Task ID for reference
+- Confirmation of task creation
+- Next steps`
+  },
+  {
+    name: "plan",
+    description: "Create a detailed implementation plan",
+    category: "core",
+    usage: "/plan <feature or task>",
+    examples: ["/plan user authentication system", "/plan refactor database layer"],
+    content: `Create a comprehensive plan before implementation.
+
+## Workflow
+1. UNDERSTAND: Clarify requirements through Socratic questioning
+2. RESEARCH: Check existing patterns and dependencies
+3. BREAK DOWN: Create 2-5 minute sub-tasks with:
+   - Exact file paths
+   - Expected changes
+   - Verification steps
+4. DOCUMENT: Write plan to memory/plans/
+
+## Output Format
+\`\`\`markdown
+# Plan: [Feature Name]
+
+## Overview
+Brief description of the goal.
+
+## Tasks
+1. [ ] Task 1 - file.ts
+2. [ ] Task 2 - component.tsx
+...
+
+## Dependencies
+- List dependencies
+
+## Risks
+- Potential issues
+
+## Verification
+- How to verify completion
+\`\`\``
+  },
+  {
+    name: "implement",
+    description: "Implement a planned task with TDD",
+    category: "core",
+    usage: "/implement <task reference>",
+    examples: ["/implement task-001", '/implement "add login form"'],
+    content: `Implement a task following TDD principles.
+
+## Workflow
+1. LOAD: Get task details from .beads/ or plan
+2. TEST: Write failing tests first (RED)
+3. IMPLEMENT: Write minimal code to pass (GREEN)
+4. REFACTOR: Clean up while keeping tests green
+5. VERIFY: Run full test suite
+
+## Hard Gates
+Before marking complete:
+- [ ] All new tests pass
+- [ ] No regressions
+- [ ] Type check passes
+- [ ] Linting passes`
+  },
+  {
+    name: "finish",
+    description: "Complete a task with quality gates",
+    category: "core",
+    usage: "/finish [task-id]",
+    examples: ["/finish", "/finish task-001"],
+    content: `Complete the current task with mandatory quality checks.
+
+## Hard Gates (Must ALL Pass)
+1. \`npm run typecheck\` - No type errors
+2. \`npm run test\` - All tests pass
+3. \`npm run lint\` - No linting errors
+4. \`npm run build\` - Build succeeds
+
+## Workflow
+1. Run all quality gates
+2. If any fail, report issues and stop
+3. If all pass, update task status to "completed"
+4. Create summary of changes
+5. Suggest commit message`
+  },
+  {
+    name: "handoff",
+    description: "Create handoff bundle for session continuity",
+    category: "core",
+    usage: "/handoff",
+    examples: ["/handoff"],
+    content: `Create a handoff bundle for context transfer to next session.
+
+## Workflow
+1. Summarize current progress
+2. Document:
+   - What was completed
+   - What remains
+   - Current blockers
+   - Key decisions made
+3. Save to memory/handoffs/[timestamp].md
+
+## Output Format
+\`\`\`markdown
+# Handoff: [Date/Time]
+
+## Completed
+- List of completed items
+
+## In Progress
+- Current work state
+
+## Remaining
+- What still needs to be done
+
+## Context
+- Important context for next session
+
+## Next Steps
+- Recommended actions
+\`\`\``
+  },
+  {
+    name: "resume",
+    description: "Resume from last handoff",
+    category: "core",
+    usage: "/resume",
+    examples: ["/resume"],
+    content: `Resume work from the most recent handoff.
+
+## Workflow
+1. Load latest handoff from memory/handoffs/
+2. Display summary to user
+3. Propose next actions
+4. Continue from where left off`
+  },
+  // Quick Actions
+  {
+    name: "fix",
+    description: "Quick fix for an issue",
+    category: "quick",
+    usage: "/fix <issue description>",
+    examples: ["/fix button not clickable", "/fix type error in auth.ts"],
+    content: `Quick fix with minimal ceremony.
+
+## Workflow
+1. Identify the issue
+2. Make minimal change to fix
+3. Verify fix works
+4. Run affected tests`
+  },
+  {
+    name: "fix-types",
+    description: "Fix TypeScript type errors",
+    category: "quick",
+    usage: "/fix-types [file]",
+    examples: ["/fix-types", "/fix-types src/auth.ts"],
+    content: `Fix TypeScript type errors systematically.
+
+## Workflow
+1. Run \`npm run typecheck\`
+2. Parse error output
+3. Fix each error in dependency order
+4. Verify all types pass`
+  },
+  {
+    name: "fix-ci",
+    description: "Fix CI/CD pipeline failures",
+    category: "quick",
+    usage: "/fix-ci",
+    examples: ["/fix-ci"],
+    content: `Diagnose and fix CI failures.
+
+## Workflow
+1. Check CI logs for errors
+2. Reproduce locally if possible
+3. Fix issues in order:
+   - Type errors
+   - Test failures
+   - Lint errors
+   - Build errors
+4. Verify full CI pipeline locally`
+  },
+  {
+    name: "commit",
+    description: "Create a well-formatted commit",
+    category: "quick",
+    usage: "/commit [message]",
+    examples: ["/commit", '/commit "feat: add login"'],
+    content: `Create a conventional commit.
+
+## Workflow
+1. Stage changes: \`git add -A\`
+2. Generate commit message following conventional commits:
+   - feat: New feature
+   - fix: Bug fix
+   - docs: Documentation
+   - refactor: Code refactoring
+   - test: Adding tests
+   - chore: Maintenance
+3. Commit with message`
+  },
+  {
+    name: "pr",
+    description: "Create a pull request",
+    category: "quick",
+    usage: "/pr [title]",
+    examples: ["/pr", '/pr "Add user authentication"'],
+    content: `Create a pull request with proper description.
+
+## Workflow
+1. Push current branch
+2. Generate PR description:
+   - Summary of changes
+   - Related issues
+   - Testing done
+   - Screenshots if UI changes
+3. Create PR via GitHub CLI or provide URL`
+  },
+  // Research & Analysis
+  {
+    name: "research",
+    description: "Deep research on a topic",
+    category: "research",
+    usage: "/research <topic>",
+    examples: ["/research React Server Components", "/research OAuth 2.0 best practices"],
+    content: `Conduct thorough research and document findings.
+
+## Workflow
+1. Search documentation and resources
+2. Find code examples and patterns
+3. Evaluate options and trade-offs
+4. Document findings in memory/research/
+
+## Output
+- Summary of findings
+- Recommended approach
+- Code examples
+- Links to resources`
+  },
+  {
+    name: "analyze-project",
+    description: "Analyze project structure and patterns",
+    category: "research",
+    usage: "/analyze-project",
+    examples: ["/analyze-project"],
+    content: `Comprehensive project analysis.
+
+## Workflow
+1. Scan directory structure
+2. Identify:
+   - Tech stack
+   - Architecture patterns
+   - Key dependencies
+   - Coding conventions
+3. Document findings in AGENTS.md`
+  },
+  {
+    name: "review-codebase",
+    description: "Review codebase quality",
+    category: "research",
+    usage: "/review-codebase [path]",
+    examples: ["/review-codebase", "/review-codebase src/"],
+    content: `Review codebase for quality issues.
+
+## Workflow
+1. Check code quality metrics
+2. Identify:
+   - Code smells
+   - Security issues
+   - Performance concerns
+   - Test coverage gaps
+3. Prioritize findings
+4. Suggest improvements`
+  },
+  // Design & Planning
+  {
+    name: "design",
+    description: "Design a feature or system",
+    category: "design",
+    usage: "/design <feature>",
+    examples: ["/design notification system", "/design API gateway"],
+    content: `Design a feature with thorough planning.
+
+## Workflow
+1. Requirements gathering (Socratic questioning)
+2. Research existing solutions
+3. Design options with trade-offs
+4. Choose approach
+5. Document design in memory/
+
+## Output
+- Design document
+- Architecture diagrams (described)
+- API contracts
+- Data models`
+  },
+  {
+    name: "brainstorm",
+    description: "Brainstorm ideas for a problem",
+    category: "design",
+    usage: "/brainstorm <problem>",
+    examples: ["/brainstorm user retention", "/brainstorm performance optimization"],
+    content: `Collaborative brainstorming session.
+
+## Workflow
+1. Define the problem clearly
+2. Generate diverse ideas (no judgement)
+3. Group related ideas
+4. Evaluate feasibility
+5. Select top candidates`
+  },
+  // Git & Version Control
+  {
+    name: "branch",
+    description: "Create a new feature branch",
+    category: "git",
+    usage: "/branch <name>",
+    examples: ["/branch feat/auth", "/branch fix/navigation-bug"],
+    content: `Create and switch to a new branch.
+
+## Workflow
+1. Ensure clean working directory
+2. Pull latest main/master
+3. Create branch with naming convention:
+   - feat/* for features
+   - fix/* for bug fixes
+   - refactor/* for refactoring
+   - docs/* for documentation
+4. Switch to new branch`
+  },
+  {
+    name: "merge",
+    description: "Merge current branch to target",
+    category: "git",
+    usage: "/merge [target]",
+    examples: ["/merge", "/merge main"],
+    content: `Merge current branch to target.
+
+## Workflow
+1. Run quality gates first
+2. Commit any pending changes
+3. Switch to target branch
+4. Pull latest
+5. Merge feature branch
+6. Resolve conflicts if any
+7. Push`
+  },
+  // Utilities
+  {
+    name: "status",
+    description: "Show current status overview",
+    category: "utility",
+    usage: "/status",
+    examples: ["/status"],
+    content: `Display comprehensive status.
+
+## Shows
+- Current task (from Beads)
+- Git status
+- Active branch
+- Pending changes
+- Test status
+- Recent activity`
+  },
+  {
+    name: "help",
+    description: "Show available commands",
+    category: "utility",
+    usage: "/help [command]",
+    examples: ["/help", "/help plan"],
+    content: `Display help information.
+
+If no command specified, list all available commands.
+If command specified, show detailed help for that command.`
+  },
+  {
+    name: "analyze-figma",
+    description: "Analyze Figma design and extract design tokens using Figma API",
+    category: "design",
+    usage: "/analyze-figma <figma-url>",
+    examples: [
+      "/analyze-figma https://www.figma.com/design/...",
+      "/analyze-figma [figma-url]"
+    ],
+    content: `Analyze a Figma design and extract all design tokens automatically using Figma API.
+
+## Workflow
+
+**Step 1: Extract URL from User Input**
+
+The Figma URL is provided in the SAME message as the command. Extract it:
+- Check the full user input message
+- Look for URL pattern: \`https://www.figma.com/design/...\` or \`http://www.figma.com/design/...\`
+- Extract the ENTIRE URL including all query parameters
+- 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**
+
+**CRITICAL**: You MUST use the MCP tool \`tool_read_figma_design\`, NOT web fetch!
+
+**The correct tool name is**: \`tool_read_figma_design\` (exposed via MCP)
+
+**DO NOT use**:
+- \u274C \`read_figma_design\` (wrong - missing "tool_" prefix)
+- \u274C \`figma-analysis/read_figma_design\` (wrong format)
+- \u274C Web fetch (file requires authentication)
+
+**DO use**:
+- \u2705 \`tool_read_figma_design\` (correct MCP tool name)
+
+Use the MCP tool:
+\`\`\`
+Use MCP tool: tool_read_figma_design
+Arguments: { "url": "[extracted URL]" }
+\`\`\`
+
+The tool has the Figma API token configured and will authenticate automatically.
+
+This tool will:
+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)
+   - 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:
+\`\`\`markdown
+# Figma Design Analysis
+
+**Source**: [Figma URL]
+**Analyzed**: [Date]
+
+## Screens/Pages
+- [List all screens]
+
+## Color Palette
+### Primary Colors
+- Color Name: #hexcode
+[Continue for all colors]
+
+## Typography
+### Font Families
+- Primary: Font Name
+[Continue]
+
+### Font Sizes
+- Heading 1: 48px
+[Continue for all sizes]
+
+## Spacing System
+- Base unit: 8px
+- Values used: [list]
+
+## Component Structure
+- Header: [description]
+[Continue for all components]
+
+## Layout Grid
+- Container max-width: [value]
+- Columns: [value]
+
+## Responsive Breakpoints
+- Mobile: [range]
+- Tablet: [range]
+- Desktop: [range]
+
+## Assets Needed
+### Images
+- [List]
+
+### Icons
+- [List]
+
+### Fonts
+- [List]
+\`\`\`
+
+Save to memory using memory-update tool:
+\`\`\`
+Use tool: memory-update
+Arguments: {
+  "key": "research/figma-analysis",
+  "content": "[formatted markdown]"
+}
+\`\`\`
+
+**Step 5: Report Results**
+
+Summarize what was extracted:
+- Number of colors found
+- Number of typography styles
+- Number of components
+- Number of screens/frames
+- Confirm save location: \`memory/research/figma-analysis.md\`
+
+## Important Notes
+
+- **DO NOT** ask user to provide URL again - extract it from input
+- **DO NOT** wait - start immediately after extracting URL
+- The URL is in the SAME message as the command
+- The tool uses Figma API, so the file must be accessible with your API token
+- If the tool returns an error about configuration, guide user to run: \`aikit skills figma-analysis config\`
+- If the tool returns an error about access, verify the file is accessible with your token
+
+The analysis will be saved automatically for later reference.`
+  },
+  {
+    name: "refactor",
+    description: "Refactor code to improve structure without changing behavior",
+    category: "quick",
+    usage: "/refactor [file or pattern]",
+    examples: ["/refactor src/utils.ts", "/refactor duplicate code"],
+    content: `Refactor code following best practices.
+
+## Workflow
+1. Ensure tests are in place
+2. Identify refactoring opportunities
+3. Apply refactoring incrementally
+4. Run tests after each change
+5. Verify no behavior changes`
+  },
+  {
+    name: "test",
+    description: "Run tests and show results",
+    category: "utility",
+    usage: "/test [pattern]",
+    examples: ["/test", "/test auth", "/test --watch"],
+    content: `Run test suite and display results.
+
+## Workflow
+1. Run test command: \`npm run test\`
+2. Parse and display results
+3. Show coverage if available
+4. Highlight failures
+5. Suggest fixes for failures`
+  },
+  {
+    name: "lint",
+    description: "Run linter and fix issues",
+    category: "quick",
+    usage: "/lint [--fix]",
+    examples: ["/lint", "/lint --fix"],
+    content: `Run linter and optionally fix issues.
+
+## Workflow
+1. Run linter: \`npm run lint\`
+2. Parse errors and warnings
+3. If --fix flag, run auto-fix
+4. Report remaining issues
+5. Suggest manual fixes if needed`
+  },
+  {
+    name: "deploy",
+    description: "Deploy application to production",
+    category: "utility",
+    usage: "/deploy [environment]",
+    examples: ["/deploy", "/deploy staging", "/deploy production"],
+    content: `Deploy application with quality checks.
+
+## Workflow
+1. Run quality gates (test, lint, build)
+2. Check for uncommitted changes
+3. Build production bundle
+4. Deploy to target environment
+5. Verify deployment success`
+  },
+  {
+    name: "rollback",
+    description: "Rollback to previous deployment",
+    category: "utility",
+    usage: "/rollback [version]",
+    examples: ["/rollback", "/rollback v1.2.3"],
+    content: `Rollback to previous version.
+
+## Workflow
+1. Identify current version
+2. List available versions
+3. Confirm rollback target
+4. Execute rollback
+5. Verify rollback success`
+  },
+  {
+    name: "logs",
+    description: "View application logs",
+    category: "utility",
+    usage: "/logs [--tail] [--follow]",
+    examples: ["/logs", "/logs --tail 100", "/logs --follow"],
+    content: `View and filter application logs.
+
+## Workflow
+1. Determine log location
+2. Apply filters if specified
+3. Display logs
+4. If --follow, stream updates
+5. Format for readability`
+  }
+];
+var CommandRunner = class {
+  config;
+  commandsCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * List all available commands
+   */
+  async listCommands() {
+    const commands = [];
+    for (const cmd of DEFAULT_COMMANDS) {
+      commands.push({
+        ...cmd,
+        filePath: "built-in"
+      });
+    }
+    const globalCommandsPath = paths.commands(paths.globalConfig());
+    try {
+      const globalCommands = await this.loadCommandsFromDir(globalCommandsPath);
+      commands.push(...globalCommands);
+    } catch {
+    }
+    const projectCommandsPath = paths.commands(this.config.configPath);
+    if (projectCommandsPath !== globalCommandsPath) {
+      try {
+        const projectCommands = await this.loadCommandsFromDir(projectCommandsPath);
+        for (const cmd of projectCommands) {
+          const existingIndex = commands.findIndex((c) => c.name === cmd.name);
+          if (existingIndex >= 0) {
+            commands[existingIndex] = cmd;
+          } else {
+            commands.push(cmd);
+          }
+        }
+      } catch {
+      }
+    }
+    return commands.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  /**
+   * Get a specific command
+   */
+  async getCommand(name) {
+    if (this.commandsCache.has(name)) {
+      return this.commandsCache.get(name);
+    }
+    const commands = await this.listCommands();
+    const command = commands.find((c) => c.name === name);
+    if (command) {
+      this.commandsCache.set(name, command);
+    }
+    return command || null;
+  }
+  /**
+   * Create a custom command
+   */
+  async createCommand(name, options) {
+    const configPath = options?.global ? paths.globalConfig() : this.config.configPath;
+    const category = options?.category || "utility";
+    const commandsDir = join4(paths.commands(configPath), category);
+    await mkdir2(commandsDir, { recursive: true });
+    const fileName = `${name}.md`;
+    const filePath = join4(commandsDir, fileName);
+    const frontmatter = {
+      name,
+      description: options?.description || `Custom command: ${name}`,
+      category,
+      usage: options?.usage || `/${name}`,
+      examples: options?.examples || [`/${name}`]
+    };
+    const content = options?.content || `## /${name}
+
+Describe what this command does.
+
+## Workflow
+1. Step 1
+2. Step 2
+3. Step 3
+`;
+    const fileContent = matter2.stringify(content, frontmatter);
+    await writeFile2(filePath, fileContent);
+    const command = {
+      name,
+      description: frontmatter.description,
+      category,
+      usage: frontmatter.usage,
+      examples: frontmatter.examples,
+      content,
+      filePath
+    };
+    this.commandsCache.set(name, command);
+    return command;
+  }
+  /**
+   * Format command for agent consumption
+   */
+  formatForAgent(command) {
+    return `# Command: /${command.name}
+
+## Usage
+\`${command.usage}\`
+
+## Description
+${command.description}
+
+## Examples
+${command.examples.map((e) => `- \`${e}\``).join("\n")}
+
+## Workflow
+${command.content}
+`;
+  }
+  /**
+   * Load commands from directory (recursively)
+   */
+  async loadCommandsFromDir(dir) {
+    const commands = [];
+    const processDir = async (currentDir, category) => {
+      try {
+        const entries = await readdir2(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = join4(currentDir, entry.name);
+          if (entry.isDirectory()) {
+            await processDir(fullPath, entry.name);
+          } else if (extname2(entry.name) === ".md") {
+            const content = await readFile3(fullPath, "utf-8");
+            const { data, content: body } = matter2(content);
+            const frontmatter = data;
+            const name = frontmatter.name || basename2(entry.name, ".md");
+            commands.push({
+              name,
+              description: frontmatter.description || "",
+              category: frontmatter.category || category,
+              usage: frontmatter.usage || `/${name}`,
+              examples: frontmatter.examples || [],
+              content: body.trim(),
+              filePath: fullPath
+            });
+          }
+        }
+      } catch {
+        return;
+      }
+    };
+    await processDir(dir, "custom");
+    return commands;
+  }
+};
+
+// src/core/tools.ts
+init_esm_shims();
+init_paths();
+init_logger();
+import { readdir as readdir4, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
+import { join as join8, extname as extname3 } from "path";
+import { z as z2 } from "zod";
+var ToolArgSchema = z2.object({
+  type: z2.enum(["string", "number", "boolean", "array", "object"]),
+  description: z2.string(),
+  required: z2.boolean().optional().default(true),
+  default: z2.any().optional()
+});
+var BUILT_IN_TOOLS = [
+  {
+    name: "websearch",
+    description: "Search the web for documentation, articles, and current information",
+    args: {
+      query: {
+        type: "string",
+        description: "The search query",
+        required: true
+      },
+      numResults: {
+        type: "number",
+        description: "Number of results to return (default: 5)",
+        required: false,
+        default: 5
+      }
+    },
+    async execute({ query }) {
+      return `Web search results for: "${query}"
+
+Note: Configure a search provider in AIKit settings for actual results.`;
+    }
+  },
+  {
+    name: "codesearch",
+    description: "Search GitHub for code patterns and examples across millions of repositories",
+    args: {
+      query: {
+        type: "string",
+        description: "The code pattern or search query",
+        required: true
+      },
+      language: {
+        type: "string",
+        description: "Programming language to filter by",
+        required: false
+      }
+    },
+    async execute({ query, language }) {
+      const langFilter = language ? ` in ${language}` : "";
+      return `GitHub code search for: "${query}"${langFilter}
+
+Note: Configure GitHub integration in AIKit settings for actual results.`;
+    }
+  },
+  {
+    name: "memory-read",
+    description: "Read from persistent memory (project or global)",
+    args: {
+      key: {
+        type: "string",
+        description: "The memory key to read",
+        required: true
+      }
+    },
+    async execute({ key }) {
+      return `Memory read: ${key}`;
+    }
+  },
+  {
+    name: "memory-update",
+    description: "Update persistent memory with new information",
+    args: {
+      key: {
+        type: "string",
+        description: "The memory key to update",
+        required: true
+      },
+      content: {
+        type: "string",
+        description: "The content to write",
+        required: true
+      },
+      append: {
+        type: "boolean",
+        description: "Whether to append to existing content (default: true)",
+        required: false,
+        default: true
+      }
+    },
+    async execute({ key, append = true }) {
+      return `Memory updated: ${key} (append: ${append})`;
+    }
+  },
+  {
+    name: "find_skills",
+    description: "Find available workflow skills",
+    args: {
+      query: {
+        type: "string",
+        description: "Optional search query to filter skills",
+        required: false
+      }
+    },
+    async execute({ query }) {
+      return `Skills matching: ${query || "all"}`;
+    }
+  },
+  {
+    name: "use_skill",
+    description: "Load and use a specific skill workflow",
+    args: {
+      name: {
+        type: "string",
+        description: "Name of the skill to use",
+        required: true
+      }
+    },
+    async execute({ name }) {
+      return `Loading skill: ${name}`;
+    }
+  },
+  {
+    name: "read_figma_design",
+    description: "Read and analyze a Figma design using Figma API. Extracts design tokens including colors, typography, spacing, components, and layout.",
+    args: {
+      url: {
+        type: "string",
+        description: "Figma design URL to analyze (must start with https://www.figma.com/design/)",
+        required: true
+      }
+    },
+    async execute({ url }, context) {
+      if (!url || typeof url !== "string") {
+        return "Error: Invalid URL provided";
+      }
+      if (!url.startsWith("https://www.figma.com/design/") && !url.startsWith("http://www.figma.com/design/")) {
+        return `Error: Invalid Figma URL format. URL must start with https://www.figma.com/design/
+
+Provided URL: ${url}`;
+      }
+      const configManager = context?.toolConfigManager;
+      if (!configManager) {
+        return `Error: Tool configuration manager not available. This usually means the MCP server isn't properly initialized. Please restart OpenCode.
+
+If the issue persists, configure Figma tool manually: aikit skills figma-analysis config`;
+      }
+      const isReady = await configManager.isToolReady("figma-analysis");
+      if (!isReady) {
+        const toolConfig = await configManager.getToolConfig("figma-analysis");
+        if (toolConfig?.status === "error") {
+          return `Error: Figma tool configuration error: ${toolConfig.errorMessage || "Unknown error"}
+
+Please reconfigure: aikit skills figma-analysis config`;
+        }
+        return `Error: Figma tool is not configured. Please run: aikit skills figma-analysis config
+
+This will guide you through setting up your Figma Personal Access Token.`;
+      }
+      const apiKey = await configManager.getApiKey("figma-analysis");
+      if (!apiKey) {
+        return `Error: Figma API key not found. Please run: aikit skills figma-analysis config`;
+      }
+      try {
+        const { FigmaMcpClient: FigmaMcpClient2 } = await Promise.resolve().then(() => (init_figma_mcp(), figma_mcp_exports));
+        const client = new FigmaMcpClient2(apiKey, configManager);
+        const assetsDir = "./assets/images";
+        const tokens = await client.extractDesignTokens(url, false, assetsDir);
+        let result = `# Figma Design Analysis
+
+`;
+        result += `**URL**: ${url}
+
+`;
+        result += `## Design Structure & Content
+
+`;
+        if (tokens.structure) {
+          result += `### Node Hierarchy (${tokens.structure.nodes.length} nodes)
+
+`;
+          result += `\`\`\`
+${tokens.structure.hierarchy}
+\`\`\`
+
+`;
+          const textNodes = tokens.structure.nodes.filter((n) => n.type === "TEXT" && n.content);
+          if (textNodes.length > 0) {
+            result += `### Text Content (${textNodes.length} text elements)
+
+`;
+            textNodes.slice(0, 20).forEach((node) => {
+              const preview = node.content && node.content.length > 100 ? node.content.substring(0, 100) + "..." : node.content;
+              result += `- **${node.name}**: "${preview}"
+`;
+              if (node.styles) {
+                result += `  - Style: ${node.styles.fontFamily || "N/A"} ${node.styles.fontSize || "N/A"}px, weight ${node.styles.fontWeight || "N/A"}
+`;
+              }
+            });
+            if (textNodes.length > 20) {
+              result += `
+... and ${textNodes.length - 20} more text elements
+`;
+            }
+            result += `
+`;
+          }
+          const frameNodes = tokens.structure.nodes.filter((n) => n.type === "FRAME" || n.type === "COMPONENT");
+          if (frameNodes.length > 0) {
+            result += `### Layout Structure (${frameNodes.length} frames/components)
+
+`;
+            frameNodes.slice(0, 15).forEach((node) => {
+              result += `- **${node.name}** (${node.type})
+`;
+              if (node.position) {
+                result += `  - Position: x=${Math.round(node.position.x)}, y=${Math.round(node.position.y)}
+`;
+                result += `  - Size: ${Math.round(node.position.width)}\xD7${Math.round(node.position.height)}px
+`;
+              }
+              if (node.styles?.layout) {
+                result += `  - Layout: ${node.styles.layout}${node.styles.gap ? `, gap: ${node.styles.gap}px` : ""}
+`;
+              }
+              if (node.children && node.children.length > 0) {
+                result += `  - Children: ${node.children.length}
+`;
+              }
+            });
+            if (frameNodes.length > 15) {
+              result += `
+... and ${frameNodes.length - 15} more frames/components
+`;
+            }
+            result += `
+`;
+          }
+        }
+        result += `## Design Tokens
+
+`;
+        if (tokens.colors.length > 0) {
+          result += `### Colors (${tokens.colors.length} found)
+
+`;
+          tokens.colors.slice(0, 30).forEach((color) => {
+            result += `- \`${color.hex}\`
+`;
+          });
+          if (tokens.colors.length > 30) {
+            result += `
+... and ${tokens.colors.length - 30} more colors
+`;
+          }
+          result += `
+`;
+        }
+        if (tokens.typography.length > 0) {
+          result += `### Typography (${tokens.typography.length} styles)
+
+`;
+          tokens.typography.forEach((typography) => {
+            result += `- **${typography.name}**: ${typography.fontFamily}, ${typography.fontSize}px, weight ${typography.fontWeight}, line-height ${typography.lineHeight}px
+`;
+          });
+          result += `
+`;
+        }
+        result += `### Spacing System
+
+`;
+        result += `- Base unit: ${tokens.spacing.unit}px
+`;
+        result += `- Scale: ${tokens.spacing.scale.length > 0 ? tokens.spacing.scale.join(", ") : "Not detected"}
+
+`;
+        if (tokens.components.length > 0) {
+          result += `### Components (${tokens.components.length} found)
+
+`;
+          tokens.components.forEach((component) => {
+            result += `- **${component.name}**: ${component.type}${component.description ? ` - ${component.description}` : ""}
+`;
+          });
+          result += `
+`;
+        }
+        if (tokens.screens.length > 0) {
+          result += `## Available Screens/Frames (${tokens.screens.length} found)
+
+`;
+          result += `**Please confirm which screen(s) you want to develop:**
+
+`;
+          tokens.screens.forEach((screen, index) => {
+            result += `${index + 1}. **${screen.name}**
+`;
+            result += `   - Size: ${screen.width}\xD7${screen.height}px
+`;
+            result += `   - Type: ${screen.type}
+`;
+            if (screen.childrenCount) {
+              result += `   - Components: ${screen.childrenCount}
+`;
+            }
+            result += `   - ID: \`${screen.id}\`
+
+`;
+          });
+          result += `
+**To proceed, simply reply with the screen number(s) or name(s) you want to develop.**
+`;
+          result += `Example: "1" or "Main Page" or "1, 2, 3"
+
+`;
+        }
+        result += `### Responsive Breakpoints
+
+`;
+        result += `- ${tokens.breakpoints.join("px, ")}px
+
+`;
+        if (tokens.assets && tokens.assets.length > 0) {
+          result += `## Downloaded Assets (${tokens.assets.length} files)
+
+`;
+          result += `All assets have been downloaded to: \`${tokens.assets[0].path.split("/").slice(0, -1).join("/")}\`
+
+`;
+          result += `### Image Files
+
+`;
+          tokens.assets.forEach((asset) => {
+            const relativePath = asset.path.replace(process.cwd() + "/", "");
+            result += `- **${asset.nodeName}** (${asset.nodeType})
+`;
+            result += `  - File: \`${relativePath}\`
+`;
+            if (asset.width && asset.height) {
+              result += `  - Size: ${Math.round(asset.width)}\xD7${Math.round(asset.height)}px
+`;
+            }
+            result += `  - Format: ${asset.format.toUpperCase()}
+`;
+            result += `  - Usage: \`<img src="${relativePath}" alt="${asset.nodeName}" />\`
+
+`;
+          });
+        }
+        result += `## Implementation Guide
+
+`;
+        result += `### Structure Analysis
+`;
+        result += `The design contains ${tokens.structure?.nodes.length || 0} nodes organized in a hierarchical structure.
+`;
+        result += `Use the node hierarchy above to understand:
+`;
+        result += `1. **Component structure** - How elements are organized
+`;
+        result += `2. **Text content** - All text content from TEXT nodes
+`;
+        result += `3. **Layout properties** - Flex direction, gaps, padding
+`;
+        result += `4. **Positioning** - Exact x, y, width, height values
+
+`;
+        result += `### Next Steps
+
+`;
+        result += `1. Review the structure hierarchy to understand component organization
+`;
+        result += `2. Extract text content from TEXT nodes for HTML content
+`;
+        result += `3. Use position and size data for pixel-perfect CSS
+`;
+        result += `4. Use layout properties (HORIZONTAL/VERTICAL) for flexbox/grid
+`;
+        result += `5. Use extracted design tokens (colors, typography) for styling
+`;
+        result += `6. Save this analysis: \`memory-update("research/figma-analysis", "[this analysis]")\`
+`;
+        return result;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return `Error analyzing Figma design: ${errorMessage}
+
+Please check:
+1. The Figma URL is correct and accessible
+2. Your Figma API token has proper permissions
+3. The design file is shared with your account`;
+      }
+    }
+  },
+  {
+    name: "analyze_figma",
+    description: "Analyze a Figma design URL and extract all design tokens automatically. The URL should be provided in the user input after the command.",
+    args: {
+      url: {
+        type: "string",
+        description: "Figma design URL to analyze",
+        required: true
+      }
+    },
+    async execute({ url }) {
+      return `Figma analysis tool called for: ${url}
+
+Next steps:
+1. Use @vision agent to analyze the design
+2. Extract all design tokens
+3. Save to memory/research/figma-analysis.md`;
+    }
+  },
+  {
+    name: "develop_figma_screen",
+    description: "Smart workflow to develop a specific Figma screen: check current code, pull needed assets, plan, and develop. User just needs to confirm the screen number/name.",
+    args: {
+      figmaUrl: {
+        type: "string",
+        description: "Figma design URL",
+        required: true
+      },
+      screenId: {
+        type: "string",
+        description: "Screen ID or name to develop (from read_figma_design output)",
+        required: true
+      }
+    },
+    async execute({ figmaUrl, screenId }, context) {
+      const configManager = context?.toolConfigManager;
+      if (!configManager) {
+        return "Error: Tool configuration manager not available.";
+      }
+      const isReady = await configManager.isToolReady("figma-analysis");
+      if (!isReady) {
+        return "Error: Figma tool is not configured. Please run: aikit skills figma-analysis config";
+      }
+      const apiKey = await configManager.getApiKey("figma-analysis");
+      if (!apiKey) {
+        return "Error: Figma API key not found.";
+      }
+      try {
+        const { FigmaMcpClient: FigmaMcpClient2 } = await Promise.resolve().then(() => (init_figma_mcp(), figma_mcp_exports));
+        const { checkCurrentCodeStatus: checkCurrentCodeStatus2, compareCodeWithFigma: compareCodeWithFigma2 } = await Promise.resolve().then(() => (init_figma_screen_developer(), figma_screen_developer_exports));
+        const client = new FigmaMcpClient2(apiKey, configManager);
+        const tokens = await client.extractDesignTokens(figmaUrl, false, "./assets/images");
+        const screenIdStr = String(screenId);
+        const selectedScreen = tokens.screens?.find(
+          (s) => s.id === screenIdStr || s.name.toLowerCase() === screenIdStr.toLowerCase()
+        );
+        if (!selectedScreen) {
+          return `Error: Screen "${screenId}" not found. Available screens:
+${tokens.screens?.map((s, i) => `${i + 1}. ${s.name} (ID: ${s.id})`).join("\n") || "None"}`;
+        }
+        const codeStatus = await checkCurrentCodeStatus2();
+        const comparison = await compareCodeWithFigma2(tokens, selectedScreen.id);
+        let downloadedAssets = [];
+        const fileKey = client.extractFileKey(figmaUrl);
+        if (fileKey) {
+          try {
+            const fileData = await client.getFileData(figmaUrl);
+            const projectPath = process.cwd();
+            const assetsDir = join8(projectPath, "assets", "images");
+            const assets = await client.downloadAssets(fileKey, fileData.document, assetsDir, selectedScreen.id);
+            downloadedAssets = assets || [];
+            logger.info(`Downloaded ${downloadedAssets.length} assets for screen ${selectedScreen.name}`);
+          } catch (error) {
+            logger.warn(`Failed to download assets: ${error instanceof Error ? error.message : String(error)}`);
+            downloadedAssets = [];
+          }
+        }
+        let result = `# Development Plan for Screen: ${selectedScreen.name}
+
+`;
+        result += `## Current Code Status
+
+`;
+        result += `- HTML: ${codeStatus.hasHTML ? `\u2705 ${codeStatus.htmlFile}` : "\u274C Not found"}
+`;
+        result += `- CSS: ${codeStatus.hasCSS ? `\u2705 ${codeStatus.cssFiles.length} files` : "\u274C Not found"}
+`;
+        result += `- Assets: ${codeStatus.hasAssets ? `\u2705 ${codeStatus.assetCount} files` : "\u274C Not found"}
+`;
+        result += `- Existing Sections: ${codeStatus.sections.length > 0 ? codeStatus.sections.join(", ") : "None"}
+
+`;
+        result += `## Comparison with Figma Design
+
+`;
+        result += `- Missing Sections: ${comparison.missingSections.length > 0 ? comparison.missingSections.join(", ") : "None"}
+`;
+        result += `- Missing Assets: ${comparison.missingAssets.length > 0 ? comparison.missingAssets.join(", ") : "None"}
+`;
+        result += `- Needs Update: ${comparison.needsUpdate ? "Yes" : "No"}
+
+`;
+        result += `## Recommendations
+
+`;
+        comparison.recommendations.forEach((rec, i) => {
+          result += `${i + 1}. ${rec}
+`;
+        });
+        result += `
+`;
+        result += `## Downloaded Assets (${downloadedAssets.length})
+
+`;
+        if (downloadedAssets.length > 0) {
+          downloadedAssets.forEach((asset) => {
+            const relativePath = asset.path.replace(process.cwd() + "/", "");
+            result += `- **${asset.nodeName}** (${asset.nodeType})
+`;
+            result += `  - File: \`${relativePath}\`
+`;
+            if (asset.width && asset.height) {
+              result += `  - Size: ${Math.round(asset.width)}\xD7${Math.round(asset.height)}px
+`;
+            }
+            result += `  - Usage: \`<img src="${relativePath}" alt="${asset.nodeName}" />\`
+
+`;
+          });
+          result += `
+**\u26A0\uFE0F IMPORTANT: Use downloaded assets above instead of placeholder images!**
+`;
+          result += `Replace all Unsplash/placeholder image URLs with the downloaded asset paths.
+
+`;
+        } else {
+          result += `**No assets downloaded.** This may indicate:
+`;
+          result += `1. The screen doesn't contain exportable image nodes
+`;
+          result += `2. Assets download failed (check logs)
+`;
+          result += `3. Figma API permissions issue
+
+`;
+        }
+        result += `
+## Next Steps
+
+`;
+        result += `1. Review the plan above
+`;
+        result += `2. Use @build agent to implement missing sections
+`;
+        result += `3. Use extracted design tokens for CSS variables
+`;
+        result += `4. Use downloaded assets in HTML
+`;
+        result += `5. Verify pixel-perfect match with Figma design
+`;
+        return result;
+      } catch (error) {
+        return `Error: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+  },
+  {
+    name: "list_session",
+    description: "List previous sessions to discover what happened and when. Use this before read_session to find the right context.",
+    args: {
+      limit: {
+        type: "number",
+        description: "Maximum number of sessions to return (default: 10)",
+        required: false,
+        default: 10
+      }
+    },
+    async execute({ limit = 10 }, context) {
+      const config = context?.config;
+      if (!config) {
+        return "Error: Configuration not available";
+      }
+      const limitNum = typeof limit === "number" ? limit : 10;
+      try {
+        const { MemoryManager: MemoryManager2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
+        const memory = new MemoryManager2(config);
+        const memories = await memory.list();
+        const handoffs = memories.filter((m) => m.type === "handoff").sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()).slice(0, limitNum);
+        if (handoffs.length === 0) {
+          return "No previous sessions found. Use /handoff to create a session handoff.";
+        }
+        let result = `# Previous Sessions (${handoffs.length})
+
+`;
+        handoffs.forEach((handoff, index) => {
+          const sessionId = handoff.key.replace("handoffs/", "");
+          result += `${index + 1}. **${sessionId}**
+`;
+          result += `   - Updated: ${handoff.updatedAt.toLocaleString()}
+`;
+          result += `   - Summary: ${handoff.summary}
+
+`;
+        });
+        result += `
+Use \`read_session\` with a session ID to load full context.`;
+        return result;
+      } catch (error) {
+        return `Error listing sessions: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+  },
+  {
+    name: "read_session",
+    description: "Load context from a previous session. Returns session summary, user tasks, and file changes.",
+    args: {
+      sessionId: {
+        type: "string",
+        description: 'Session ID from list_session (e.g., "2024-01-15T10-30-00")',
+        required: true
+      }
+    },
+    async execute({ sessionId }, context) {
+      const config = context?.config;
+      if (!config) {
+        return "Error: Configuration not available";
+      }
+      try {
+        const { MemoryManager: MemoryManager2 } = await Promise.resolve().then(() => (init_memory(), memory_exports));
+        const memory = new MemoryManager2(config);
+        const content = await memory.read(`handoffs/${sessionId}`);
+        if (!content) {
+          return `Session not found: ${sessionId}
+
+Use \`list_session\` to see available sessions.`;
+        }
+        return `# Session Context: ${sessionId}
+
+${content}
+
+---
+
+This context has been loaded. Use /resume to continue from this point.`;
+      } catch (error) {
+        return `Error reading session: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+  }
+];
+var ToolRegistry = class {
+  config;
+  tools = /* @__PURE__ */ new Map();
+  toolConfigManager;
+  constructor(config) {
+    this.config = config;
+    for (const tool of BUILT_IN_TOOLS) {
+      this.tools.set(tool.name, tool);
+    }
+  }
+  /**
+   * Set tool config manager (for tools that need configuration)
+   */
+  setToolConfigManager(manager) {
+    this.toolConfigManager = manager;
+  }
+  /**
+   * List all available tools
+   */
+  async listTools() {
+    await this.loadCustomTools();
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Get a specific tool
+   */
+  getTool(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * Register a new tool
+   */
+  registerTool(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  /**
+   * Execute a tool
+   */
+  async executeTool(name, args, context) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new Error(`Tool not found: ${name}`);
+    }
+    for (const [argName, argDef] of Object.entries(tool.args)) {
+      if (argDef.required && args[argName] === void 0) {
+        throw new Error(`Missing required argument: ${argName}`);
+      }
+    }
+    const mergedContext = {
+      ...context,
+      toolConfigManager: context?.toolConfigManager || this.toolConfigManager
+    };
+    if (tool.execute.length === 2) {
+      return await tool.execute(args, mergedContext);
+    }
+    return await tool.execute(args);
+  }
+  /**
+   * Create a custom tool
+   */
+  async createTool(name, options) {
+    const configPath = options.global ? paths.globalConfig() : this.config.configPath;
+    const toolsDir = paths.tools(configPath);
+    await mkdir5(toolsDir, { recursive: true });
+    const fileName = `${name}.ts`;
+    const filePath = join8(toolsDir, fileName);
+    const argsSchema = Object.entries(options.args).map(([argName, arg]) => `    ${argName}: {
+      type: '${arg.type}',
+      description: '${arg.description}',
+      required: ${arg.required ?? true},
+    }`).join(",\n");
+    const content = `import { defineTool } from 'aikit';
+
+export default defineTool({
+  name: '${name}',
+  description: '${options.description}',
+  args: {
+${argsSchema}
+  },
+  async execute(args) {
+${options.code}
+  }
+});
+`;
+    await writeFile5(filePath, content);
+  }
+  /**
+   * Format tool for agent consumption
+   */
+  formatForAgent(tool) {
+    const argsDesc = Object.entries(tool.args).map(([name, arg]) => `  - ${name} (${arg.type}${arg.required ? ", required" : ""}): ${arg.description}`).join("\n");
+    return `## Tool: ${tool.name}
+
+${tool.description}
+
+### Arguments
+${argsDesc}
+`;
+  }
+  /**
+   * Load custom tools from disk
+   */
+  async loadCustomTools() {
+    const globalToolsPath = paths.tools(paths.globalConfig());
+    await this.loadToolsFromDir(globalToolsPath);
+    const projectToolsPath = paths.tools(this.config.configPath);
+    if (projectToolsPath !== globalToolsPath) {
+      await this.loadToolsFromDir(projectToolsPath);
+    }
+  }
+  async loadToolsFromDir(dir) {
+    let files;
+    try {
+      files = await readdir4(dir);
+    } catch {
+      return;
+    }
+    for (const file of files) {
+      if (extname3(file) !== ".ts" && extname3(file) !== ".js") continue;
+      const filePath = join8(dir, file);
+      try {
+        const toolModule = await import(`file://${filePath}`);
+        const tool = toolModule.default;
+        if (tool?.name && typeof tool.execute === "function") {
+          tool.filePath = filePath;
+          this.tools.set(tool.name, tool);
+        }
+      } catch (error) {
+        logger.warn(`Failed to load tool from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+};
+
+// src/core/tool-config.ts
+init_esm_shims();
+import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir6, access as access3, constants as constants3 } from "fs/promises";
+import { join as join9 } from "path";
+import { z as z3 } from "zod";
+var ToolConfigSchema = z3.object({
+  name: z3.string(),
+  status: z3.enum(["ready", "needs_config", "error"]),
+  description: z3.string(),
+  configMethod: z3.enum(["oauth", "manual", "none"]),
+  config: z3.record(z3.unknown()).optional(),
+  errorMessage: z3.string().optional()
+});
+var REGISTERED_TOOLS = [
+  {
+    name: "figma-analysis",
+    description: "Analyze Figma designs and extract design tokens using Figma API",
+    configMethod: "oauth"
+  }
+  // Add more tools here as needed
+];
+var ToolConfigManager = class {
+  config;
+  toolsConfigPath;
+  constructor(config) {
+    this.config = config;
+    this.toolsConfigPath = join9(this.config.configPath, "config", "tools.json");
+  }
+  /**
+   * Get all registered tools with their current status
+   */
+  async listTools() {
+    const savedConfigs = await this.loadConfigs();
+    const tools = [];
+    for (const tool of REGISTERED_TOOLS) {
+      const saved = savedConfigs[tool.name];
+      const toolConfig = {
+        ...tool,
+        status: this.determineStatus(tool, saved),
+        config: saved?.config,
+        errorMessage: saved?.errorMessage
+      };
+      tools.push(toolConfig);
+    }
+    return tools;
+  }
+  /**
+   * Get configuration for a specific tool
+   */
+  async getToolConfig(toolName) {
+    const tools = await this.listTools();
+    return tools.find((t) => t.name === toolName) || null;
+  }
+  /**
+   * Update tool configuration
+   */
+  async updateToolConfig(toolName, updates) {
+    const savedConfigs = await this.loadConfigs();
+    const tool = REGISTERED_TOOLS.find((t) => t.name === toolName);
+    if (!tool) {
+      throw new Error(`Tool not found: ${toolName}`);
+    }
+    const existing = savedConfigs[toolName] || {};
+    savedConfigs[toolName] = {
+      ...existing,
+      ...updates
+    };
+    await this.saveConfigs(savedConfigs);
+  }
+  /**
+   * Check if a tool is ready to use
+   */
+  async isToolReady(toolName) {
+    const toolConfig = await this.getToolConfig(toolName);
+    return toolConfig?.status === "ready";
+  }
+  /**
+   * Get API key for a tool (if configured)
+   */
+  async getApiKey(toolName) {
+    const toolConfig = await this.getToolConfig(toolName);
+    if (toolConfig?.config?.apiKey && typeof toolConfig.config.apiKey === "string") {
+      return toolConfig.config.apiKey;
+    }
+    return null;
+  }
+  /**
+   * Determine tool status based on configuration
+   */
+  determineStatus(tool, saved) {
+    if (tool.configMethod === "none") {
+      return "ready";
+    }
+    if (saved?.errorMessage) {
+      return "error";
+    }
+    if (tool.configMethod === "oauth" || tool.configMethod === "manual") {
+      if (saved?.config?.apiKey && typeof saved.config.apiKey === "string" && saved.config.apiKey.length > 0) {
+        return "ready";
+      }
+      return "needs_config";
+    }
+    return "needs_config";
+  }
+  /**
+   * Load saved configurations
+   */
+  async loadConfigs() {
+    try {
+      await access3(this.toolsConfigPath, constants3.R_OK);
+      const content = await readFile6(this.toolsConfigPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Save configurations
+   */
+  async saveConfigs(configs) {
+    const configDir = join9(this.config.configPath, "config");
+    await mkdir6(configDir, { recursive: true });
+    await writeFile6(this.toolsConfigPath, JSON.stringify(configs, null, 2));
+  }
+};
+
+// src/mcp-server.ts
+init_logger();
+var AiKitMcpServer = class {
+  server;
+  skillEngine;
+  agentManager;
+  commandRunner;
+  toolRegistry;
+  toolConfigManager;
+  constructor() {
+    const capabilities = {
+      tools: {}
+    };
+    this.server = new Server(
+      {
+        name: "aikit",
+        version: "0.1.0"
+      },
+      {
+        capabilities
+      }
+    );
+    this.setupHandlers();
+  }
+  setupHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: await this.getAvailableTools()
+      };
+    });
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      return await this.handleToolCall(request);
+    });
+  }
+  async getAvailableTools() {
+    const tools = [];
+    try {
+      const skills = await this.skillEngine.listSkills();
+      for (const skill of skills) {
+        tools.push({
+          name: `skill_${skill.name.replace(/\s+/g, "_")}`,
+          description: `Execute the "${skill.name}" skill: ${skill.description}`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              context: {
+                type: "string",
+                description: "Additional context for the skill"
+              }
+            },
+            required: []
+          }
+        });
+      }
+      const agents = this.agentManager.listAgents();
+      for (const agent of agents) {
+        tools.push({
+          name: `agent_${agent.name}`,
+          description: `Delegate to the ${agent.name} agent: ${agent.description}`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              task: {
+                type: "string",
+                description: "Task for the agent to handle"
+              },
+              context: {
+                type: "string",
+                description: "Optional context"
+              }
+            },
+            required: ["task"]
+          }
+        });
+      }
+      const commands = await this.commandRunner.listCommands();
+      for (const cmd of commands) {
+        tools.push({
+          name: `cmd_${cmd.name.replace(/\//g, "_").slice(1)}`,
+          description: `Run command: ${cmd.description}`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              args: {
+                type: "string",
+                description: "Arguments for the command"
+              }
+            },
+            required: []
+          }
+        });
+      }
+      const aikitTools = await this.toolRegistry.listTools();
+      for (const tool of aikitTools) {
+        const properties = {};
+        const required = [];
+        for (const [argName, argDef] of Object.entries(tool.args)) {
+          properties[argName] = {
+            type: argDef.type,
+            description: argDef.description
+          };
+          if (argDef.required) {
+            required.push(argName);
+          }
+        }
+        tools.push({
+          name: `tool_${tool.name.replace(/\s+/g, "_")}`,
+          description: tool.description,
+          inputSchema: {
+            type: "object",
+            properties,
+            required
+          }
+        });
+      }
+    } catch (error) {
+      logger.error(`Failed to list tools: ${error}`);
+    }
+    return tools;
+  }
+  async handleToolCall(request) {
+    const { name, arguments: args } = request.params;
+    try {
+      let result = "";
+      if (name.startsWith("skill_")) {
+        const skillName = name.replace("skill_", "").replace(/_/g, "-");
+        const skill = await this.skillEngine.getSkill(skillName);
+        if (skill) {
+          const formatted = this.skillEngine.formatForAgent(skill);
+          result = formatted;
+        } else {
+          result = `Skill not found: ${skillName}`;
+        }
+      } else if (name.startsWith("agent_")) {
+        const task = args?.task || "Execute task";
+        const context = args?.context || "";
+        const decision = this.agentManager.decideAgent(task, context);
+        result = `Delegated to agent: ${decision.agent}
+
+Reasoning: ${decision.reason}`;
+      } else if (name.startsWith("cmd_")) {
+        const cmdName = "/" + name.replace("cmd_", "").replace(/_/g, "/");
+        const cmdArgs = args?.args || "";
+        result = `Execute: ${cmdName} ${cmdArgs}`;
+      } else if (name.startsWith("tool_")) {
+        const toolName = name.replace("tool_", "");
+        try {
+          if (!this.toolConfigManager) {
+            result = `Error: Tool configuration manager not initialized. MCP server may not be properly started.`;
+          } else {
+            const context = { toolConfigManager: this.toolConfigManager };
+            result = await this.toolRegistry.executeTool(toolName, args || {}, context);
+          }
+        } catch (error) {
+          result = `Error executing tool ${toolName}: ${error instanceof Error ? error.message : String(error)}`;
+        }
+      } else {
+        result = `Unknown tool: ${name}`;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: result
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error executing tool: ${errorMsg}`
+          }
+        ]
+      };
+    }
+  }
+  async initialize() {
+    try {
+      const config = await loadConfig();
+      this.skillEngine = new SkillEngine(config);
+      this.agentManager = new AgentManager(config);
+      this.commandRunner = new CommandRunner(config);
+      this.toolRegistry = new ToolRegistry(config);
+      this.toolConfigManager = new ToolConfigManager(config);
+      this.toolRegistry.setToolConfigManager(this.toolConfigManager);
+      const figmaReady = await this.toolConfigManager.isToolReady("figma-analysis");
+      if (figmaReady) {
+        logger.info("Figma tool configured and ready");
+      } else {
+        logger.warn("Figma tool not configured - tools requiring config may not work");
+      }
+    } catch (error) {
+      logger.error(`Failed to initialize: ${error}`);
+      process.exit(1);
+    }
+  }
+  async start() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    logger.info("AIKit MCP Server started");
+  }
+};
+async function main() {
+  const server = new AiKitMcpServer();
+  await server.initialize();
+  await server.start();
+}
+main().catch((error) => {
+  logger.error(`Fatal error: ${error}`);
+  process.exit(1);
+});
+//# sourceMappingURL=mcp-server.js.map