@tdsoft-tech/aikit 0.1.2

package/dist/cli.js

@@ -0,0 +1,4901 @@
+#!/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: readdir7 } = await import("fs/promises");
+            const files = await readdir7(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/core/tool-config.ts
+var tool_config_exports = {};
+__export(tool_config_exports, {
+  ToolConfigManager: () => ToolConfigManager
+});
+import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir8, access as access4, constants as constants4 } from "fs/promises";
+import { join as join11 } from "path";
+import { z as z3 } from "zod";
+var ToolConfigSchema, REGISTERED_TOOLS, ToolConfigManager;
+var init_tool_config = __esm({
+  "src/core/tool-config.ts"() {
+    "use strict";
+    init_esm_shims();
+    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()
+    });
+    REGISTERED_TOOLS = [
+      {
+        name: "figma-analysis",
+        description: "Analyze Figma designs and extract design tokens using Figma API",
+        configMethod: "oauth"
+      }
+      // Add more tools here as needed
+    ];
+    ToolConfigManager = class {
+      config;
+      toolsConfigPath;
+      constructor(config) {
+        this.config = config;
+        this.toolsConfigPath = join11(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 access4(this.toolsConfigPath, constants4.R_OK);
+          const content = await readFile7(this.toolsConfigPath, "utf-8");
+          return JSON.parse(content);
+        } catch {
+          return {};
+        }
+      }
+      /**
+       * Save configurations
+       */
+      async saveConfigs(configs) {
+        const configDir = join11(this.config.configPath, "config");
+        await mkdir8(configDir, { recursive: true });
+        await writeFile8(this.toolsConfigPath, JSON.stringify(configs, null, 2));
+      }
+    };
+  }
+});
+
+// src/core/auth/figma-oauth.ts
+var figma_oauth_exports = {};
+__export(figma_oauth_exports, {
+  FigmaOAuth: () => FigmaOAuth
+});
+import open from "open";
+var FigmaOAuth;
+var init_figma_oauth = __esm({
+  "src/core/auth/figma-oauth.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    FigmaOAuth = class {
+      configManager;
+      constructor(configManager) {
+        this.configManager = configManager;
+      }
+      /**
+       * Start OAuth flow for Figma
+       * 
+       * Since Figma uses Personal Access Tokens (not OAuth 2.0),
+       * we'll open browser to token creation page and guide user
+       */
+      async authenticate() {
+        console.log("\n\u{1F510} Figma Authentication\n");
+        console.log("Figma uses Personal Access Tokens for API access.");
+        console.log("We will open your browser to create a token.\n");
+        const tokenUrl = "https://www.figma.com/developers/api#access-tokens";
+        console.log(`Opening: ${tokenUrl}`);
+        try {
+          await open(tokenUrl);
+        } catch (error) {
+          console.log("\n\u26A0\uFE0F  Could not open browser automatically.");
+          console.log(`Please visit: ${tokenUrl}`);
+        }
+        console.log("\n\u{1F4CB} Instructions:");
+        console.log('1. In the browser, scroll to "Personal access tokens" section');
+        console.log('2. Click "Create new token"');
+        console.log('3. Give it a name (e.g., "AIKit")');
+        console.log("4. Copy the token (you won't see it again!)");
+        console.log("5. Paste it here when prompted\n");
+        const { default: inquirer } = await import("inquirer");
+        const { token } = await inquirer.prompt([
+          {
+            type: "password",
+            name: "token",
+            message: "Paste your Figma Personal Access Token:",
+            validate: (input) => {
+              if (!input || input.trim().length === 0) {
+                return "Token cannot be empty";
+              }
+              if (input.length < 20) {
+                return "Token seems too short. Please check and try again.";
+              }
+              return true;
+            }
+          }
+        ]);
+        const trimmedToken = token.trim();
+        await this.configManager.updateToolConfig("figma-analysis", {
+          config: {
+            apiKey: trimmedToken
+          },
+          status: "ready"
+        });
+        logger.success("Figma token saved successfully!");
+        return trimmedToken;
+      }
+      /**
+       * Alternative: Manual token input
+       */
+      async authenticateManual() {
+        const { default: inquirer } = await import("inquirer");
+        console.log("\n\u{1F510} Figma Authentication (Manual)\n");
+        console.log("To get your Figma Personal Access Token:");
+        console.log("1. Visit: https://www.figma.com/developers/api#access-tokens");
+        console.log('2. Scroll to "Personal access tokens"');
+        console.log('3. Click "Create new token"');
+        console.log("4. Copy the token and paste it below\n");
+        const { token } = await inquirer.prompt([
+          {
+            type: "password",
+            name: "token",
+            message: "Enter your Figma Personal Access Token:",
+            validate: (input) => {
+              if (!input || input.trim().length === 0) {
+                return "Token cannot be empty";
+              }
+              return true;
+            }
+          }
+        ]);
+        const trimmedToken = token.trim();
+        await this.configManager.updateToolConfig("figma-analysis", {
+          config: {
+            apiKey: trimmedToken
+          },
+          status: "ready"
+        });
+        logger.success("Figma token saved successfully!");
+        return trimmedToken;
+      }
+      /**
+       * Test if token is valid by making a simple API call
+       */
+      async validateToken(token) {
+        try {
+          const response = await fetch("https://api.figma.com/v1/me", {
+            headers: {
+              "X-Figma-Token": token
+            }
+          });
+          if (response.ok) {
+            const data = await response.json();
+            logger.success(`Token validated! Logged in as: ${data.email || "Unknown"}`);
+            return true;
+          } else {
+            logger.error(`Token validation failed: ${response.status} ${response.statusText}`);
+            return false;
+          }
+        } catch (error) {
+          logger.error(`Token validation error: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// src/cli.ts
+init_esm_shims();
+import { Command } from "commander";
+import chalk2 from "chalk";
+
+// src/index.ts
+init_esm_shims();
+
+// 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/plugins.ts
+init_esm_shims();
+init_paths();
+init_logger();
+import { readdir as readdir5, writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
+import { join as join9, basename as basename3, extname as extname4 } from "path";
+var PluginSystem = class {
+  config;
+  plugins = /* @__PURE__ */ new Map();
+  loadedPlugins = /* @__PURE__ */ new Map();
+  eventQueue = [];
+  processing = false;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Initialize and load all plugins
+   */
+  async initialize() {
+    await this.loadPlugins();
+    for (const [name, info] of this.plugins) {
+      if (info.enabled) {
+        try {
+          const handlers = await this.initializePlugin(info);
+          this.loadedPlugins.set(name, handlers);
+          info.handlers = handlers;
+        } catch (error) {
+          logger.warn(`Failed to initialize plugin ${name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    }
+  }
+  /**
+   * List all available plugins
+   */
+  async listPlugins() {
+    await this.loadPlugins();
+    return Array.from(this.plugins.values());
+  }
+  /**
+   * Enable a plugin
+   */
+  async enablePlugin(name) {
+    const plugin = this.plugins.get(name);
+    if (plugin) {
+      plugin.enabled = true;
+      if (!this.loadedPlugins.has(name)) {
+        const handlers = await this.initializePlugin(plugin);
+        this.loadedPlugins.set(name, handlers);
+        plugin.handlers = handlers;
+      }
+    }
+  }
+  /**
+   * Disable a plugin
+   */
+  disablePlugin(name) {
+    const plugin = this.plugins.get(name);
+    if (plugin) {
+      plugin.enabled = false;
+      this.loadedPlugins.delete(name);
+      plugin.handlers = void 0;
+    }
+  }
+  /**
+   * Emit an event to all plugins
+   */
+  async emit(event) {
+    this.eventQueue.push(event);
+    if (!this.processing) {
+      await this.processEventQueue();
+    }
+  }
+  /**
+   * Execute before hooks for tool execution
+   */
+  async executeBeforeHooks(_toolName, input) {
+    let result = input;
+    for (const handlers of this.loadedPlugins.values()) {
+      if (handlers["tool.execute.before"]) {
+        result = await handlers["tool.execute.before"](result);
+      }
+    }
+    return result;
+  }
+  /**
+   * Execute after hooks for tool execution
+   */
+  async executeAfterHooks(_toolName, input, output) {
+    let result = output;
+    for (const handlers of this.loadedPlugins.values()) {
+      if (handlers["tool.execute.after"]) {
+        result = await handlers["tool.execute.after"](input, result);
+      }
+    }
+    return result;
+  }
+  /**
+   * Create a new plugin
+   */
+  async createPlugin(name, options) {
+    const configPath = options.global ? paths.globalConfig() : this.config.configPath;
+    const pluginsDir = paths.plugins(configPath);
+    await mkdir6(pluginsDir, { recursive: true });
+    const fileName = `${name}.ts`;
+    const filePath = join9(pluginsDir, fileName);
+    const content = `import { Plugin } from 'aikit';
+
+/**
+ * ${options.description || `Custom plugin: ${name}`}
+ */
+export const ${toPascalCase(name)}Plugin: Plugin = async ({ project, config, emit }) => {
+  return {
+    event: async ({ event }) => {
+${options.code}
+    }
+  };
+};
+
+export default ${toPascalCase(name)}Plugin;
+`;
+    await writeFile6(filePath, content);
+  }
+  /**
+   * Process event queue
+   */
+  async processEventQueue() {
+    this.processing = true;
+    while (this.eventQueue.length > 0) {
+      const event = this.eventQueue.shift();
+      for (const handlers of this.loadedPlugins.values()) {
+        if (handlers.event) {
+          try {
+            await handlers.event(event);
+          } catch (error) {
+            logger.warn(`Plugin error handling event ${event.type}: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+      }
+    }
+    this.processing = false;
+  }
+  /**
+   * Load plugins from disk
+   */
+  async loadPlugins() {
+    this.registerBuiltInPlugins();
+    const globalPluginsPath = paths.plugins(paths.globalConfig());
+    await this.loadPluginsFromDir(globalPluginsPath);
+    const projectPluginsPath = paths.plugins(this.config.configPath);
+    if (projectPluginsPath !== globalPluginsPath) {
+      await this.loadPluginsFromDir(projectPluginsPath);
+    }
+  }
+  registerBuiltInPlugins() {
+    this.plugins.set("enforcer", {
+      name: "enforcer",
+      description: "Warns when session idles with TODO items remaining",
+      enabled: true,
+      filePath: "built-in"
+    });
+    this.plugins.set("compactor", {
+      name: "compactor",
+      description: "Warns when context usage reaches 70%, 85%, 95%",
+      enabled: true,
+      filePath: "built-in"
+    });
+    this.plugins.set("truncator", {
+      name: "truncator",
+      description: "Auto-truncates tool output to preserve context space",
+      enabled: true,
+      filePath: "built-in"
+    });
+    this.plugins.set("notification", {
+      name: "notification",
+      description: "OS notifications when OpenCode completes a session",
+      enabled: true,
+      filePath: "built-in"
+    });
+    this.plugins.set("session-management", {
+      name: "session-management",
+      description: "Cross-session context transfer based on handoffs",
+      enabled: true,
+      filePath: "built-in"
+    });
+  }
+  async loadPluginsFromDir(dir) {
+    let files;
+    try {
+      files = await readdir5(dir);
+    } catch {
+      return;
+    }
+    for (const file of files) {
+      if (extname4(file) !== ".ts" && extname4(file) !== ".js") continue;
+      const filePath = join9(dir, file);
+      const name = basename3(file, extname4(file));
+      this.plugins.set(name, {
+        name,
+        description: `Custom plugin: ${name}`,
+        enabled: true,
+        filePath
+      });
+    }
+  }
+  async initializePlugin(info) {
+    if (info.filePath === "built-in") {
+      return this.getBuiltInPluginHandlers(info.name);
+    }
+    try {
+      const pluginModule = await import(`file://${info.filePath}`);
+      const factory = pluginModule.default;
+      const context = {
+        project: {
+          path: this.config.projectPath,
+          name: basename3(this.config.projectPath)
+        },
+        config: this.config,
+        emit: this.emit.bind(this)
+      };
+      return await factory(context);
+    } catch (error) {
+      logger.warn(`Failed to load plugin ${info.name}: ${error instanceof Error ? error.message : String(error)}`);
+      return {};
+    }
+  }
+  getBuiltInPluginHandlers(name) {
+    switch (name) {
+      case "enforcer":
+        return {
+          event: async (event) => {
+            if (event.type === "session.idle") {
+              logger.info("[Enforcer] Session idle - check for remaining work");
+            }
+          }
+        };
+      case "compactor":
+        return {
+          event: async (event) => {
+            const usage = event.properties?.contextUsage;
+            if (usage && usage > 70) {
+              logger.info(`[Compactor] Context usage at ${usage}%`);
+            }
+          }
+        };
+      case "truncator":
+        return {
+          "tool.execute.after": async (_input, output) => {
+            if (typeof output === "string" && output.length > 5e4) {
+              return output.slice(0, 5e4) + "\n\n[Output truncated - exceeded 50KB limit]";
+            }
+            return output;
+          }
+        };
+      case "notification":
+        return {
+          event: async (event) => {
+            if (event.type === "session.idle") {
+              try {
+                const { exec: exec2 } = await import("child_process");
+                const { promisify: promisify2 } = await import("util");
+                const execAsync2 = promisify2(exec2);
+                const platform = process.platform;
+                const summary = event.properties?.summary || "Session completed";
+                if (platform === "darwin") {
+                  await execAsync2(`osascript -e 'display notification "${summary}" with title "OpenCode Session Complete"'`);
+                } else if (platform === "linux") {
+                  await execAsync2(`notify-send "OpenCode Session Complete" "${summary}"`);
+                } else if (platform === "win32") {
+                  await execAsync2(`powershell -Command "New-BurntToastNotification -Text 'OpenCode Session Complete', '${summary}'"`);
+                }
+              } catch (error) {
+                logger.warn(`[Notification] Failed to send notification: ${error instanceof Error ? error.message : String(error)}`);
+              }
+            }
+          }
+        };
+      case "session-management":
+        return {
+          event: async (event) => {
+            if (event.type === "session.idle") {
+              logger.info("[Session Management] Session idle - context saved for next session");
+            }
+          }
+        };
+      default:
+        return {};
+    }
+  }
+};
+function toPascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+
+// src/index.ts
+init_memory();
+
+// src/core/beads.ts
+init_esm_shims();
+init_paths();
+init_logger();
+import { readFile as readFile6, writeFile as writeFile7, readdir as readdir6, access as access3, constants as constants3, mkdir as mkdir7 } from "fs/promises";
+import { join as join10 } from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var BeadsIntegration = class {
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath || process.cwd();
+  }
+  /**
+   * Check if Beads CLI is installed
+   */
+  async isInstalled() {
+    try {
+      await execAsync("bd --version");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get Beads version
+   */
+  async getVersion() {
+    try {
+      const { stdout } = await execAsync("bd --version");
+      const match = stdout.match(/bd version (\S+)/);
+      return match?.[1] || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if Beads is initialized in project
+   */
+  async isInitialized() {
+    const beadsDir = paths.beadsDir(this.projectPath);
+    try {
+      await access3(beadsDir, constants3.R_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Initialize Beads in project
+   */
+  async init() {
+    try {
+      await execAsync("bd init", { cwd: this.projectPath });
+      logger.success("Beads initialized");
+      return true;
+    } catch (error) {
+      logger.error("Failed to initialize Beads:", error);
+      return false;
+    }
+  }
+  /**
+   * Get current status
+   */
+  async getStatus() {
+    const installed = await this.isInstalled();
+    const version = await this.getVersion();
+    const initialized = await this.isInitialized();
+    let activeTasks = 0;
+    let completedTasks = 0;
+    let currentTask;
+    if (initialized) {
+      const beads = await this.listBeads();
+      activeTasks = beads.filter((b) => b.status === "in-progress" || b.status === "todo").length;
+      completedTasks = beads.filter((b) => b.status === "completed").length;
+      const active = beads.find((b) => b.status === "in-progress");
+      currentTask = active?.title;
+    }
+    return {
+      installed,
+      version: version || void 0,
+      initialized,
+      activeTasks,
+      completedTasks,
+      currentTask
+    };
+  }
+  /**
+   * List all beads in the project
+   */
+  async listBeads() {
+    const beadsDir = paths.beadsDir(this.projectPath);
+    const beads = [];
+    try {
+      const files = await readdir6(beadsDir);
+      for (const file of files) {
+        if (!file.match(/^bead-\d+\.md$/)) continue;
+        const content = await readFile6(join10(beadsDir, file), "utf-8");
+        const bead = this.parseBeadFile(file, content);
+        if (bead) beads.push(bead);
+      }
+    } catch {
+    }
+    return beads.sort((a, b) => a.id.localeCompare(b.id));
+  }
+  /**
+   * Get a specific bead
+   */
+  async getBead(id) {
+    const beadsDir = paths.beadsDir(this.projectPath);
+    const fileName = id.endsWith(".md") ? id : `${id}.md`;
+    try {
+      const content = await readFile6(join10(beadsDir, fileName), "utf-8");
+      return this.parseBeadFile(fileName, content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Create a new bead
+   */
+  async createBead(title, description) {
+    const beadsDir = paths.beadsDir(this.projectPath);
+    await mkdir7(beadsDir, { recursive: true });
+    const beads = await this.listBeads();
+    const maxId = beads.reduce((max, b) => {
+      const num = parseInt(b.id.replace("bead-", ""), 10);
+      return num > max ? num : max;
+    }, 0);
+    const id = `bead-${String(maxId + 1).padStart(3, "0")}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const content = `---
+id: ${id}
+title: ${title}
+status: in-progress
+created: ${now}
+updated: ${now}
+---
+
+# ${title}
+
+## Description
+${description}
+
+## Notes
+
+
+## Checklist
+- [ ] Requirements understood
+- [ ] Implementation complete
+- [ ] Tests passing
+- [ ] Code reviewed
+
+## Progress
+
+`;
+    await writeFile7(join10(beadsDir, `${id}.md`), content);
+    return {
+      id,
+      title,
+      description,
+      status: "in-progress",
+      createdAt: new Date(now),
+      updatedAt: new Date(now),
+      notes: []
+    };
+  }
+  /**
+   * Update bead status
+   */
+  async updateBeadStatus(id, status) {
+    const beadsDir = paths.beadsDir(this.projectPath);
+    const fileName = id.endsWith(".md") ? id : `${id}.md`;
+    const filePath = join10(beadsDir, fileName);
+    try {
+      let content = await readFile6(filePath, "utf-8");
+      content = content.replace(
+        /status:\s*\w+/,
+        `status: ${status}`
+      );
+      content = content.replace(
+        /updated:\s*.+/,
+        `updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
+      );
+      await writeFile7(filePath, content);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Add note to bead
+   */
+  async addNote(id, note) {
+    const beadsDir = paths.beadsDir(this.projectPath);
+    const fileName = id.endsWith(".md") ? id : `${id}.md`;
+    const filePath = join10(beadsDir, fileName);
+    try {
+      let content = await readFile6(filePath, "utf-8");
+      const notesMatch = content.match(/## Notes\n([\s\S]*?)(?=\n##|$)/);
+      if (notesMatch) {
+        const timestamp = (/* @__PURE__ */ new Date()).toLocaleString();
+        const newNote = `- [${timestamp}] ${note}`;
+        content = content.replace(
+          notesMatch[0],
+          `## Notes
+${notesMatch[1]}${newNote}
+`
+        );
+      }
+      content = content.replace(
+        /updated:\s*.+/,
+        `updated: ${(/* @__PURE__ */ new Date()).toISOString()}`
+      );
+      await writeFile7(filePath, content);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Complete a bead with quality gates
+   */
+  async completeBead(id) {
+    const gates = [
+      { name: "Type Check", command: "npm run typecheck" },
+      { name: "Tests", command: "npm run test" },
+      { name: "Lint", command: "npm run lint" },
+      { name: "Build", command: "npm run build" }
+    ];
+    const results = [];
+    for (const gate of gates) {
+      try {
+        await execAsync(gate.command, { cwd: this.projectPath });
+        results.push({ name: gate.name, passed: true });
+        logger.success(`${gate.name}: passed`);
+      } catch (error) {
+        results.push({
+          name: gate.name,
+          passed: false,
+          error: error instanceof Error ? error.message.slice(0, 200) : "Failed"
+        });
+        logger.error(`${gate.name}: failed`);
+      }
+    }
+    const allPassed = results.every((r) => r.passed);
+    if (allPassed) {
+      await this.updateBeadStatus(id, "completed");
+      await this.addNote(id, "Task completed - all quality gates passed");
+    } else {
+      await this.addNote(id, "Completion attempted but quality gates failed");
+    }
+    return {
+      success: allPassed,
+      gates: results
+    };
+  }
+  /**
+   * Get current active bead
+   */
+  async getCurrentBead() {
+    const beads = await this.listBeads();
+    return beads.find((b) => b.status === "in-progress") || null;
+  }
+  /**
+   * Parse a bead file
+   */
+  parseBeadFile(fileName, content) {
+    try {
+      const id = fileName.replace(".md", "");
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      const frontmatter = frontmatterMatch?.[1] || "";
+      const getValue = (key) => {
+        const match = frontmatter.match(new RegExp(`${key}:\\s*(.+)`));
+        return match?.[1]?.trim() || "";
+      };
+      const titleMatch = content.match(/^# (.+)/m);
+      const title = getValue("title") || titleMatch?.[1] || id;
+      const descMatch = content.match(/## Description\n([\s\S]*?)(?=\n##|$)/);
+      const description = descMatch?.[1]?.trim() || "";
+      const notesMatch = content.match(/## Notes\n([\s\S]*?)(?=\n##|$)/);
+      const notesContent = notesMatch?.[1] || "";
+      const notes = notesContent.split("\n").filter((line) => line.trim().startsWith("-")).map((line) => line.replace(/^-\s*/, "").trim());
+      return {
+        id,
+        title,
+        description,
+        status: getValue("status") || "todo",
+        createdAt: new Date(getValue("created") || Date.now()),
+        updatedAt: new Date(getValue("updated") || Date.now()),
+        notes
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/core/anti-hallucination.ts
+init_esm_shims();
+init_logger();
+
+// src/index.ts
+init_logger();
+init_paths();
+var VERSION = "0.1.0";
+
+// src/cli.ts
+init_memory();
+init_logger();
+init_paths();
+var program = new Command();
+program.name("aikit").description("Open-source AI coding agent toolkit for OpenCode").version(VERSION);
+program.command("init").description("Initialize AIKit configuration").option("-g, --global", "Initialize global configuration").option("-p, --project", "Initialize project-level configuration").action(async (options) => {
+  const configDir = options.global ? paths.globalConfig() : paths.projectConfig();
+  console.log(chalk2.bold("\n\u{1F680} AIKit Setup\n"));
+  logger.info(`Initializing AIKit in ${configDir}...`);
+  try {
+    await initializeConfig(configDir, options.global);
+    logger.success("\u2713 Configuration created");
+    if (!options.global) {
+      const config = await loadConfig();
+      const engine = new SkillEngine(config);
+      const result = await engine.syncSkillsToProject();
+      if (result.count > 0) {
+        logger.success(`\u2713 Synced ${result.count} skills`);
+      }
+      const opencodePath = paths.opencodeConfig();
+      await installToOpenCode(opencodePath);
+      console.log(chalk2.bold("\n\u2728 AIKit is ready!\n"));
+      console.log("Usage in OpenCode:");
+      console.log(chalk2.cyan("  /skills") + "  - List all available skills");
+      console.log(chalk2.cyan("  /plan") + "    - Create implementation plan");
+      console.log(chalk2.cyan("  /tdd") + "     - Test-driven development");
+      console.log(chalk2.cyan("  /debug") + "   - Systematic debugging");
+      console.log(chalk2.cyan("  /review") + "  - Code review checklist");
+      console.log(chalk2.cyan("  /git") + "     - Git workflow");
+      console.log(chalk2.cyan("  /frontend-aesthetics") + " - UI/UX guidelines");
+      console.log("\nPress " + chalk2.bold("Ctrl+K") + " in OpenCode to see all commands.\n");
+    }
+  } catch (error) {
+    logger.error("Failed to initialize AIKit:", error);
+    process.exit(1);
+  }
+});
+program.command("install").description("Install AIKit to OpenCode configuration").action(async () => {
+  logger.info("Installing AIKit to OpenCode...");
+  try {
+    const opencodePath = paths.opencodeConfig();
+    await installToOpenCode(opencodePath);
+    logger.success("AIKit installed to OpenCode!");
+  } catch (error) {
+    logger.error("Failed to install:", error);
+    process.exit(1);
+  }
+});
+var skillsCmd = program.command("skills").description("Manage skills");
+skillsCmd.command("list").description("List available skills and tools with their configuration status").action(async () => {
+  const config = await loadConfig();
+  const engine = new SkillEngine(config);
+  const skills = await engine.listSkills();
+  const { ToolConfigManager: ToolConfigManager2 } = await Promise.resolve().then(() => (init_tool_config(), tool_config_exports));
+  const toolConfigManager = new ToolConfigManager2(config);
+  const tools = await toolConfigManager.listTools();
+  console.log(chalk2.bold("\n\u{1F4DA} Available Skills:\n"));
+  for (const skill of skills) {
+    console.log(`  ${chalk2.cyan(skill.name)} - ${skill.description}`);
+  }
+  console.log(chalk2.bold("\n\u{1F527} Available Tools:\n"));
+  for (const tool of tools) {
+    let statusIcon = "  ";
+    let statusText = "";
+    if (tool.status === "ready") {
+      statusIcon = chalk2.green("\u2713");
+      statusText = chalk2.gray("(ready)");
+    } else if (tool.status === "needs_config") {
+      statusIcon = chalk2.yellow("\u26A0");
+      statusText = chalk2.yellow("(needs config)");
+    } else if (tool.status === "error") {
+      statusIcon = chalk2.red("\u2717");
+      statusText = chalk2.red("(error)");
+    }
+    console.log(`  ${statusIcon} ${chalk2.cyan(tool.name)} - ${tool.description} ${statusText}`);
+    if (tool.errorMessage) {
+      console.log(`    ${chalk2.red("Error:")} ${tool.errorMessage}`);
+    }
+  }
+  console.log();
+  console.log(chalk2.gray('Tip: Use "aikit skills <tool-name> config" to configure a tool\n'));
+});
+skillsCmd.command("show <name>").description("Show skill details").action(async (name) => {
+  const config = await loadConfig();
+  const engine = new SkillEngine(config);
+  const skill = await engine.getSkill(name);
+  if (!skill) {
+    logger.error(`Skill not found: ${name}`);
+    process.exit(1);
+  }
+  console.log(chalk2.bold(`
+\u{1F4D6} Skill: ${skill.name}
+`));
+  console.log(chalk2.gray(skill.description));
+  console.log(chalk2.bold("\nWorkflow:"));
+  console.log(skill.content);
+});
+skillsCmd.command("create <name>").description("Create a new skill").action(async (name) => {
+  const config = await loadConfig();
+  const engine = new SkillEngine(config);
+  await engine.createSkill(name);
+  logger.success(`Skill created: ${name}`);
+});
+skillsCmd.command("sync").description("Sync global skills to project").action(async () => {
+  const config = await loadConfig();
+  const engine = new SkillEngine(config);
+  const result = await engine.syncSkillsToProject();
+  if (result.count === 0) {
+    logger.info("Skills already in sync or no global skills to sync");
+  } else {
+    console.log(chalk2.bold(`
+\u2713 Synced ${result.count} skills to project:
+`));
+    for (const skill of result.synced) {
+      console.log(`  ${chalk2.cyan("\u2022")} ${skill}`);
+    }
+    console.log();
+  }
+});
+skillsCmd.command("config <tool-name>").description("Configure a tool (e.g., config figma-analysis)").action(async (toolName) => {
+  const config = await loadConfig();
+  const { ToolConfigManager: ToolConfigManager2 } = await Promise.resolve().then(() => (init_tool_config(), tool_config_exports));
+  const toolConfigManager = new ToolConfigManager2(config);
+  const tool = await toolConfigManager.getToolConfig(toolName);
+  if (!tool) {
+    logger.error(`Tool not found: ${toolName}`);
+    console.log(chalk2.gray("\nAvailable tools:"));
+    const tools = await toolConfigManager.listTools();
+    for (const t of tools) {
+      console.log(`  - ${chalk2.cyan(t.name)}`);
+    }
+    console.log();
+    process.exit(1);
+  }
+  console.log(chalk2.bold(`
+\u{1F527} Configuring: ${tool.name}
+`));
+  console.log(chalk2.gray(tool.description));
+  console.log();
+  if (tool.configMethod === "oauth") {
+    if (toolName === "figma-analysis") {
+      const { FigmaOAuth: FigmaOAuth2 } = await Promise.resolve().then(() => (init_figma_oauth(), figma_oauth_exports));
+      const oauth = new FigmaOAuth2(toolConfigManager);
+      try {
+        const token = await oauth.authenticate();
+        console.log(chalk2.gray("\nValidating token..."));
+        const isValid = await oauth.validateToken(token);
+        if (isValid) {
+          logger.success(`
+\u2705 ${tool.name} configured successfully!`);
+          console.log(chalk2.gray("\nYou can now use the /analyze-figma command in OpenCode.\n"));
+        } else {
+          await toolConfigManager.updateToolConfig(toolName, {
+            status: "error",
+            errorMessage: "Token validation failed"
+          });
+          logger.error("Token validation failed. Please try again.");
+          process.exit(1);
+        }
+      } catch (error) {
+        await toolConfigManager.updateToolConfig(toolName, {
+          status: "error",
+          errorMessage: error instanceof Error ? error.message : String(error)
+        });
+        logger.error(`Configuration failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+    } else {
+      logger.error(`OAuth flow not implemented for tool: ${toolName}`);
+      process.exit(1);
+    }
+  } else if (tool.configMethod === "manual") {
+    logger.info("Manual configuration not yet implemented");
+    process.exit(1);
+  } else {
+    logger.info(`Tool ${tool.name} does not require configuration`);
+  }
+});
+skillsCmd.command("*").description("Configure a tool (e.g., figma-analysis config)").allowUnknownOption().action(async () => {
+  const args = process.argv.slice(process.argv.indexOf("skills") + 1);
+  const toolName = args[0];
+  const action = args[1];
+  if (action === "config" && toolName) {
+    const config = await loadConfig();
+    const { ToolConfigManager: ToolConfigManager2 } = await Promise.resolve().then(() => (init_tool_config(), tool_config_exports));
+    const toolConfigManager = new ToolConfigManager2(config);
+    const tool = await toolConfigManager.getToolConfig(toolName);
+    if (!tool) {
+      logger.error(`Tool not found: ${toolName}`);
+      console.log(chalk2.gray("\nAvailable tools:"));
+      const tools = await toolConfigManager.listTools();
+      for (const t of tools) {
+        console.log(`  - ${chalk2.cyan(t.name)}`);
+      }
+      console.log();
+      console.log(chalk2.gray("Tip: If you meant to show a skill, use: aikit skills show <name>"));
+      console.log();
+      process.exit(1);
+    }
+    console.log(chalk2.bold(`
+\u{1F527} Configuring: ${tool.name}
+`));
+    console.log(chalk2.gray(tool.description));
+    console.log();
+    if (tool.configMethod === "oauth") {
+      if (toolName === "figma-analysis") {
+        const { FigmaOAuth: FigmaOAuth2 } = await Promise.resolve().then(() => (init_figma_oauth(), figma_oauth_exports));
+        const oauth = new FigmaOAuth2(toolConfigManager);
+        try {
+          const token = await oauth.authenticate();
+          console.log(chalk2.gray("\nValidating token..."));
+          const isValid = await oauth.validateToken(token);
+          if (isValid) {
+            logger.success(`
+\u2705 ${tool.name} configured successfully!`);
+            console.log(chalk2.gray("\nYou can now use the /analyze-figma command in OpenCode.\n"));
+          } else {
+            await toolConfigManager.updateToolConfig(toolName, {
+              status: "error",
+              errorMessage: "Token validation failed"
+            });
+            logger.error("Token validation failed. Please try again.");
+            process.exit(1);
+          }
+        } catch (error) {
+          await toolConfigManager.updateToolConfig(toolName, {
+            status: "error",
+            errorMessage: error instanceof Error ? error.message : String(error)
+          });
+          logger.error(`Configuration failed: ${error instanceof Error ? error.message : String(error)}`);
+          process.exit(1);
+        }
+      } else {
+        logger.error(`OAuth flow not implemented for tool: ${toolName}`);
+        process.exit(1);
+      }
+    } else if (tool.configMethod === "manual") {
+      logger.info("Manual configuration not yet implemented");
+      process.exit(1);
+    } else {
+      logger.info(`Tool ${tool.name} does not require configuration`);
+    }
+  } else {
+    logger.error(`Unknown command: ${toolName || "unknown"} ${action || ""}`);
+    console.log(chalk2.gray("\nAvailable commands:"));
+    console.log("  aikit skills list                    - List all skills and tools");
+    console.log("  aikit skills show <name>              - Show skill details");
+    console.log("  aikit skills config <tool-name>       - Configure a tool");
+    console.log("  aikit skills <tool-name> config       - Configure a tool (alternative syntax)");
+    console.log();
+    process.exit(1);
+  }
+});
+var agentsCmd = program.command("agents").description("Manage agents");
+agentsCmd.command("list").description("List available agents").action(async () => {
+  const config = await loadConfig();
+  const manager = new AgentManager(config);
+  const agents = manager.listAgents();
+  console.log(chalk2.bold("\n\u{1F916} Available Agents:\n"));
+  for (const agent of agents) {
+    console.log(`  ${chalk2.cyan(`@${agent.name}`)} - ${agent.description}`);
+    console.log(chalk2.gray(`    Use when: ${agent.useWhen}`));
+  }
+  console.log();
+});
+var commandsCmd = program.command("commands").description("Manage commands");
+commandsCmd.command("list").description("List available commands").action(async () => {
+  const config = await loadConfig();
+  const runner = new CommandRunner(config);
+  const commands = await runner.listCommands();
+  console.log(chalk2.bold("\n\u26A1 Available Commands:\n"));
+  const groups = groupBy(commands, (c) => c.category);
+  for (const [category, cmds] of Object.entries(groups)) {
+    console.log(chalk2.bold.yellow(`
+  ${category}:`));
+    for (const cmd of cmds) {
+      console.log(`    ${chalk2.cyan(`/${cmd.name}`)} - ${cmd.description}`);
+    }
+  }
+  console.log();
+});
+var toolsCmd = program.command("tools").description("Manage custom tools");
+toolsCmd.command("list").description("List available tools").action(async () => {
+  const config = await loadConfig();
+  const registry = new ToolRegistry(config);
+  const tools = await registry.listTools();
+  console.log(chalk2.bold("\n\u{1F527} Available Tools:\n"));
+  for (const tool of tools) {
+    console.log(`  ${chalk2.cyan(tool.name)} - ${tool.description}`);
+  }
+  console.log();
+});
+var pluginsCmd = program.command("plugins").description("Manage plugins");
+pluginsCmd.command("list").description("List available plugins").action(async () => {
+  const config = await loadConfig();
+  const system = new PluginSystem(config);
+  const plugins = await system.listPlugins();
+  console.log(chalk2.bold("\n\u{1F50C} Available Plugins:\n"));
+  for (const plugin of plugins) {
+    const status = plugin.enabled ? chalk2.green("\u2713") : chalk2.gray("\u25CB");
+    console.log(`  ${status} ${chalk2.cyan(plugin.name)} - ${plugin.description}`);
+  }
+  console.log();
+});
+var memoryCmd = program.command("memory").description("Manage persistent memory");
+memoryCmd.command("list").description("List memory entries").action(async () => {
+  const config = await loadConfig();
+  const memory = new MemoryManager(config);
+  const entries = await memory.list();
+  console.log(chalk2.bold("\n\u{1F9E0} Memory Entries:\n"));
+  for (const entry of entries) {
+    console.log(`  ${chalk2.cyan(entry.key)} - ${entry.summary}`);
+    console.log(chalk2.gray(`    Updated: ${entry.updatedAt}`));
+  }
+  console.log();
+});
+memoryCmd.command("read <key>").description("Read a memory entry").action(async (key) => {
+  const config = await loadConfig();
+  const memory = new MemoryManager(config);
+  const content = await memory.read(key);
+  if (!content) {
+    logger.error(`Memory entry not found: ${key}`);
+    process.exit(1);
+  }
+  console.log(content);
+});
+var beadsCmd = program.command("beads").description("Beads task management integration");
+beadsCmd.command("status").description("Show current Beads status").action(async () => {
+  const beads = new BeadsIntegration();
+  const status = await beads.getStatus();
+  console.log(chalk2.bold("\n\u{1F4FF} Beads Status:\n"));
+  console.log(`  Active tasks: ${status.activeTasks}`);
+  console.log(`  Completed: ${status.completedTasks}`);
+  console.log(`  Current: ${status.currentTask || "None"}`);
+  console.log();
+});
+program.command("status").description("Show AIKit status").action(async () => {
+  console.log(chalk2.bold(`
+\u{1F680} AIKit v${VERSION}
+`));
+  try {
+    const config = await loadConfig();
+    console.log(chalk2.green("\u2713 Configuration loaded"));
+    const skillEngine = new SkillEngine(config);
+    const skills = await skillEngine.listSkills();
+    console.log(`  Skills: ${skills.length}`);
+    const agentManager = new AgentManager(config);
+    const agents = agentManager.listAgents();
+    console.log(`  Agents: ${agents.length}`);
+    const commandRunner = new CommandRunner(config);
+    const commands = await commandRunner.listCommands();
+    console.log(`  Commands: ${commands.length}`);
+    const toolRegistry = new ToolRegistry(config);
+    const tools = await toolRegistry.listTools();
+    console.log(`  Tools: ${tools.length}`);
+    const beads = new BeadsIntegration();
+    const beadsStatus = await beads.isInstalled();
+    console.log(`  Beads: ${beadsStatus ? chalk2.green("Installed") : chalk2.yellow("Not installed")}`);
+  } catch (error) {
+    console.log(chalk2.yellow('\u26A0 AIKit not initialized. Run "aikit init" to get started.'));
+  }
+  console.log();
+});
+async function initializeConfig(configDir, _isGlobal) {
+  const { mkdir: mkdir9, writeFile: writeFile9 } = await import("fs/promises");
+  const { join: join12 } = await import("path");
+  const dirs = [
+    "",
+    "skills",
+    "agents",
+    "commands",
+    "commands/build",
+    "commands/git",
+    "commands/plan",
+    "commands/research",
+    "tools",
+    "plugins",
+    "memory",
+    "memory/_templates",
+    "memory/handoffs",
+    "memory/observations",
+    "memory/research"
+  ];
+  for (const dir of dirs) {
+    await mkdir9(join12(configDir, dir), { recursive: true });
+  }
+  const defaultConfig = {
+    version: VERSION,
+    skills: { enabled: true },
+    agents: { enabled: true, default: "build" },
+    commands: { enabled: true },
+    tools: { enabled: true },
+    plugins: { enabled: true },
+    memory: { enabled: true },
+    beads: { enabled: true },
+    antiHallucination: { enabled: true }
+  };
+  await writeFile9(
+    join12(configDir, "aikit.json"),
+    JSON.stringify(defaultConfig, null, 2)
+  );
+  const agentsMd = `# AIKit Agent Rules
+
+## Build Commands
+- \`npm run build\` - Build the project
+- \`npm run test\` - Run tests
+- \`npm run lint\` - Run linting
+
+## Code Style
+- Use 2 spaces for indentation
+- Use single quotes for strings
+- Add trailing commas
+
+## Naming Conventions
+- Variables: camelCase
+- Components: PascalCase
+- Files: kebab-case
+
+## Project-Specific Rules
+Add your project-specific rules here.
+`;
+  await writeFile9(join12(configDir, "AGENTS.md"), agentsMd);
+}
+async function configureMcpServer(projectPath) {
+  const { mkdir: mkdir9, writeFile: writeFile9, readFile: readFile8 } = await import("fs/promises");
+  const { join: join12 } = await import("path");
+  const { existsSync: existsSync4 } = await import("fs");
+  const { homedir: homedir2 } = await import("os");
+  const { fileURLToPath: fileURLToPath2 } = await import("url");
+  const { dirname: dirname2 } = await import("path");
+  const currentFile = fileURLToPath2(import.meta.url);
+  const currentDir = dirname2(currentFile);
+  const aikitPath = join12(currentDir, "..");
+  const mcpServerPath = join12(aikitPath, "dist", "mcp-server.js");
+  const configLocations = [
+    // Global config (most common)
+    join12(homedir2(), ".config", "opencode", "opencode.json"),
+    // Project-level config
+    join12(projectPath, ".opencode", "opencode.json"),
+    // Alternative global location
+    join12(homedir2(), ".opencode", "opencode.json")
+  ];
+  const mcpServerConfig = {
+    type: "local",
+    command: ["node", mcpServerPath],
+    environment: {}
+  };
+  for (const configPath of configLocations) {
+    try {
+      const configDir = join12(configPath, "..");
+      await mkdir9(configDir, { recursive: true });
+      let config = {};
+      if (existsSync4(configPath)) {
+        try {
+          const existing = await readFile8(configPath, "utf-8");
+          config = JSON.parse(existing);
+        } catch {
+          config = {};
+        }
+      }
+      if (!config.mcp) {
+        config.mcp = {};
+      }
+      config.mcp.aikit = mcpServerConfig;
+      await writeFile9(configPath, JSON.stringify(config, null, 2));
+      logger.success(`
+\u2705 MCP server configured: ${configPath}`);
+      logger.info(`   Server: node ${mcpServerPath}`);
+      return;
+    } catch (error) {
+      continue;
+    }
+  }
+  const instructionsPath = join12(projectPath, ".opencode", "MCP_SETUP.md");
+  await mkdir9(join12(projectPath, ".opencode"), { recursive: true });
+  await writeFile9(instructionsPath, `# AIKit MCP Server Configuration
+
+## Automatic Setup Failed
+
+Please manually configure the MCP server in OpenCode.
+
+## Configuration
+
+Add this to your OpenCode configuration file (\`~/.config/opencode/opencode.json\`):
+
+\`\`\`json
+{
+  "mcpServers": {
+    "aikit": {
+      "command": "node",
+      "args": ["${mcpServerPath}"],
+      "env": {}
+    }
+  }
+}
+\`\`\`
+
+## After Configuration
+
+1. Restart OpenCode completely
+2. OpenCode will automatically start the MCP server
+3. Tools will be available via MCP protocol
+4. You can use tools like \`tool_read_figma_design\` directly
+
+## Verify
+
+After restarting OpenCode, check:
+- MCP server is running (check OpenCode settings)
+- Tools are discoverable (OpenCode should list them)
+- You can call tools via MCP protocol
+`);
+  logger.warn(`
+\u26A0\uFE0F  Could not auto-configure MCP server. See: ${instructionsPath}`);
+}
+async function installToOpenCode(_opencodePath) {
+  const { mkdir: mkdir9, writeFile: writeFile9, access: access5 } = await import("fs/promises");
+  const { join: join12 } = await import("path");
+  const projectPath = process.cwd();
+  const opencodeCommandDir = join12(projectPath, ".opencode", "command");
+  const aikitDir = join12(projectPath, ".aikit");
+  const opencodeAgentDir = join12(paths.opencodeConfig(), "agent");
+  await mkdir9(opencodeCommandDir, { recursive: true });
+  await mkdir9(join12(aikitDir, "skills"), { recursive: true });
+  await mkdir9(opencodeAgentDir, { recursive: true });
+  const agentFiles = {
+    agent: `---
+description: General-purpose default agent (OpenCode compatibility).
+mode: subagent
+tools:
+  "*": true
+---
+
+Use for quick tasks when no specialized agent is needed.`,
+    planner: `---
+description: Strategic planner; breaks down work and coordinates specialist agents.
+mode: subagent
+tools:
+  "*": true
+---
+
+Use when the task is complex or multi-step. Delegates to @build for implementation,
+@scout for research, @review for code review/security, @explore for codebase navigation,
+and @vision for visual analysis.`,
+    build: `---
+description: Primary builder; writes code, tests, and implements features.
+mode: subagent
+tools:
+  "*": true
+---
+
+Use for feature implementation, refactors, and bug fixes. Prefer TDD, small steps,
+and run checks after changes. Delegates to @review for audits and @explore for context.`,
+    rush: `---
+description: Fast execution for small/urgent changes with minimal planning.
+mode: subagent
+tools:
+  "*": true
+---
+
+Use for quick fixes, hotfixes, or tiny edits. Keep scope minimal and verify quickly.`,
+    review: `---
+description: Code review and quality/security auditing agent.
+mode: subagent
+tools:
+  "*": true
+---
+
+Use to review correctness, security, performance, maintainability, and tests. Be specific
+about issues and suggest concrete fixes.`,
+    scout: `---
+description: Research agent for external docs, patterns, and references.
+mode: subagent
+tools:
+  "*": true
+---
+
+Use to look up docs, examples, best practices. Summarize findings concisely and cite sources.`,
+    explore: `---
+description: Codebase navigation agent (search, grep, structure understanding).
+mode: subagent
+tools:
+  "*": true
+---
+
+Use to locate files, patterns, dependencies, and gather quick context in the repo.`,
+    vision: `---
+description: Visual analysis agent for mockups, screenshots, PDFs, diagrams.
+mode: subagent
+tools:
+  "*": true
+---
+
+Use to interpret visual assets (components, layout, colors, typography) and translate to tasks.`
+  };
+  for (const [name, content] of Object.entries(agentFiles)) {
+    const filePath = join12(opencodeAgentDir, `${name}.md`);
+    try {
+      await access5(filePath);
+    } catch {
+      await writeFile9(filePath, content, "utf8");
+    }
+  }
+  const config = await loadConfig();
+  const skillEngine = new SkillEngine(config);
+  const commandRunner = new CommandRunner(config);
+  const skills = await skillEngine.listSkills();
+  const commands = await commandRunner.listCommands();
+  const opencodeCommands = {};
+  const skillsList = skills.map((s) => `| \`/${s.name.replace(/\s+/g, "-")}\` | ${s.description} |`).join("\n");
+  opencodeCommands["skills"] = `List all available AIKit skills and how to use them.
+
+READ .aikit/AGENTS.md
+
+## Available Skills
+
+| Command | Description |
+|---------|-------------|
+${skillsList}
+
+Type any command to use that skill. For example: \`/test-driven-development\` or \`/tdd\`.`;
+  for (const skill of skills) {
+    const commandName = skill.name.replace(/\s+/g, "-").toLowerCase();
+    const skillPath = skill.filePath;
+    const relativePath = skillPath.startsWith(projectPath) ? skillPath.replace(projectPath, "").replace(/\\/g, "/").replace(/^\//, "") : `.aikit/skills/${skill.name.replace(/\s+/g, "-").toLowerCase()}.md`;
+    const useWhen = skill.useWhen || `The user asks you to ${skill.name}`;
+    opencodeCommands[commandName] = `Use the **${skill.name} skill** ${useWhen.toLowerCase()}.
+
+READ ${relativePath}
+
+## Description
+${skill.description}
+
+## When to Use
+${useWhen}
+
+## Workflow
+${skill.content.split("\n").slice(0, 20).join("\n")}${skill.content.split("\n").length > 20 ? "\n\n... (see full skill file for complete workflow)" : ""}
+
+**IMPORTANT**: Follow this skill's workflow step by step. Do not skip steps.
+Complete the checklist at the end of the skill.`;
+  }
+  for (const cmd of commands) {
+    if (opencodeCommands[cmd.name]) continue;
+    const commandName = cmd.name.replace(/\//g, "").replace(/\s+/g, "-");
+    const examples = cmd.examples.map((e) => `- \`${e}\``).join("\n");
+    if (cmd.name === "analyze-figma") {
+      opencodeCommands[commandName] = `# Command: /analyze-figma
+
+## Description
+${cmd.description}
+
+## Usage
+\`${cmd.usage}\`
+
+## Examples
+${examples}
+
+## \u26A0\uFE0F CRITICAL: Extract URL FIRST!
+
+**BEFORE ANYTHING ELSE**: Look at the user's FULL input message (all lines) and find the Figma URL. It's ALWAYS there - never ask for it!
+
+**The URL pattern**: Look for text containing \`figma.com/design/\` anywhere in the user's message.
+
+**Example of what user input looks like**:
+\`\`\`
+/analyze-figma https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/
+Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0
+\`\`\`
+
+**Extract the complete URL** (combine if split):
+\`https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0\`
+
+## Workflow
+
+**IMPORTANT**: When user provides a Figma URL, you MUST immediately:
+
+**Step 1: Extract URL from User Input**
+
+**CRITICAL**: The URL is ALWAYS in the user's input message! DO NOT ask for it - just extract it!
+
+**MANDATORY**: You MUST extract the URL before proceeding. This is not optional!
+
+**How to Extract**:
+1. **Read the ENTIRE user input message** - look at ALL lines, not just the first line
+2. **Search for ANY text containing** \`figma.com/design/\` - this is the URL
+3. **URL may appear in different formats**:
+   - On same line: \`/analyze-figma https://www.figma.com/design/...\`
+   - Split across lines:
+     \`\`\`
+     /analyze-figma https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/
+     Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0
+     \`\`\`
+   - Just the URL: \`https://www.figma.com/design/...\`
+4. **Extract the COMPLETE URL**:
+   - Start from \`https://\` or \`http://\`
+   - Include everything until the end of the line or next whitespace
+   - If URL is split, combine ALL parts into one complete URL
+5. **Include ALL query parameters**: \`?node-id=...\`, \`&t=...\`, etc.
+
+**REAL EXAMPLE**:
+\`\`\`
+User input:
+/analyze-figma https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/
+Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0
+\`\`\`
+
+**Extract as**:
+\`https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?t=7G5yzTiEtJlIZBtY-0\`
+
+**CRITICAL RULES**:
+- \u2705 DO: Read the ENTIRE user message (all lines)
+- \u2705 DO: Look for \`figma.com/design/\` anywhere in the message
+- \u2705 DO: Combine split lines into one URL
+- \u274C DO NOT: Ask user for URL - it's ALWAYS in the input
+- \u274C DO NOT: Skip this step - URL extraction is MANDATORY
+- \u274C DO NOT: Proceed without extracting URL first
+
+**If you think URL is not found**:
+1. Re-read the user's message line by line
+2. Look for ANY mention of "figma.com"
+3. Check if URL is split across multiple lines
+4. The URL is definitely there - find it!
+- If URL not found in current message, check previous messages
+
+**Step 2: Check Tool Configuration**
+
+Before calling the tool, verify that Figma tool is configured:
+- If not configured, inform user to run: \`aikit skills figma-analysis config\`
+- The tool requires a Figma Personal Access Token
+
+**Step 3: Call MCP Tool read_figma_design**
+
+Use the MCP tool \`read_figma_design\` (or \`tool_read_figma_design\` via MCP) with the extracted URL:
+\`\`\`
+Use tool: read_figma_design
+Arguments: { "url": "[extracted URL]" }
+\`\`\`
+
+**This tool will automatically**:
+1. Validate the Figma URL format
+2. Check if Figma tool is configured
+3. Call Figma API to fetch design data
+4. Extract design tokens:
+   - Colors (from fills and strokes, converted to hex)
+   - Typography (font families, sizes, weights, line heights)
+   - Spacing system (8px grid detection)
+   - Components (from Figma components)
+   - Screens/Frames (dimensions and names)
+   - Breakpoints (common responsive breakpoints)
+5. Return formatted markdown with all extracted tokens
+
+**Step 4: Format and Save**
+
+Format extracted tokens as structured markdown and save using memory-update tool:
+\`\`\`
+Use tool: memory-update
+Arguments: {
+  "key": "research/figma-analysis",
+  "content": "[formatted markdown with all tokens]"
+}
+\`\`\`
+
+**Step 5: Report Results**
+
+Report what was extracted:
+- Number of screens found
+- Number of colors in palette
+- Typography styles found
+- Components identified
+- Confirm save location: \`memory/research/figma-analysis.md\`
+
+## Critical Instructions
+
+- **DO NOT** ask user to "share the Figma URL" - they already provided it in the command
+- **DO NOT** wait for confirmation - just start analyzing immediately
+- **DO** extract URL from full user input message
+- **DO** call MCP tool \`read_figma_design\` immediately
+- **DO** use browser MCP to navigate and snapshot
+- **DO** extract everything automatically without asking
+- **DO** save to memory automatically
+
+## Error Handling
+
+If the tool returns an error:
+1. **If "needs config"**: Guide user to run \`aikit skills figma-analysis config\`
+2. **If API error**: 
+   - Verify the Figma URL is correct and accessible
+   - Ensure your API token has access to the file
+   - Check if the file is public or you have permission to access it
+3. **If URL invalid**: Re-check the extracted URL format
+
+## How to Parse URL from Command
+
+**CRITICAL**: The Figma URL is provided in the SAME message as the command!
+
+Example:
+- User input: \`/analyze-figma https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?node-id=0-1&t=70yZa7w5wSyjDhYj-1\`
+- The URL is: \`https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?node-id=0-1&t=70yZa7w5wSyjDhYj-1\`
+
+**Extract the URL** from the command input:
+- Everything after \`/analyze-figma \` (note the space) is the URL
+- The URL starts with \`https://\` or \`http://\`
+- Extract the ENTIRE URL including all query parameters
+- Check the FULL user message, not just command name
+
+## Example Usage
+
+User input: \`/analyze-figma https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?node-id=0-1&t=70yZa7w5wSyjDhYj-1\`
+
+**Step 1: Extract URL**
+- Check full user input message
+- Extract: \`https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?node-id=0-1&t=70yZa7w5wSyjDhYj-1\`
+
+**Step 2: Call MCP Tool**
+\`\`\`
+Use tool: read_figma_design
+Arguments: { "url": "https://www.figma.com/design/lC34qpTSy2MYalTIOsj8S2/Online-Education-Website-Free-Template--Community-?node-id=0-1&t=70yZa7w5wSyjDhYj-1" }
+\`\`\`
+
+**Step 3: Tool automatically extracts tokens via Figma API**
+
+**Step 4: Save to memory using memory-update tool**
+
+**Step 5: Report results to user**
+
+## Important Reminders
+
+- The URL is ALREADY in the command input - extract it from full message!
+- URL may be split across multiple lines - combine them into one complete URL
+- Do NOT ask for URL again - it's always in the input
+- Do NOT wait - start immediately
+- Use MCP tool \`read_figma_design\` which uses Figma API directly`;
+    } else {
+      opencodeCommands[commandName] = `# Command: /${cmd.name}
+
+## Description
+${cmd.description}
+
+## Usage
+\`${cmd.usage}\`
+
+## Examples
+${examples}
+
+## Workflow
+${cmd.content}
+
+**Category**: ${cmd.category}`;
+    }
+  }
+  let count = 0;
+  for (const [name, content] of Object.entries(opencodeCommands)) {
+    const filePath = join12(opencodeCommandDir, `${name}.md`);
+    await writeFile9(filePath, content.trim());
+    logger.info(`  \u2713 Created /${name} command`);
+    count++;
+  }
+  logger.success(`
+Created ${count} OpenCode commands in .opencode/command/`);
+  await configureMcpServer(projectPath);
+  logger.info("\nUsage in OpenCode:");
+  logger.info("  Press Ctrl+K to open command picker");
+  logger.info("  Or type /skills to see all available skills");
+  logger.info(`  Available: ${skills.length} skills, ${commands.length} commands`);
+  logger.info("  MCP server configured - tools available via MCP protocol");
+}
+function groupBy(array, keyFn) {
+  return array.reduce((acc, item) => {
+    const key = keyFn(item);
+    if (!acc[key]) acc[key] = [];
+    acc[key].push(item);
+    return acc;
+  }, {});
+}
+program.parse();
+//# sourceMappingURL=cli.js.map