@tdsoft-tech/aikit 0.1.31 → 0.1.33

package/dist/index.js

@@ -144,6 +144,34 @@ var init_paths = __esm({
        */
       claudeAgents(project) {
         return join(this.claudeConfig(project ? "project" : "user"), "agents");
+      },
+      /**
+       * Get Cursor configuration directory
+       */
+      cursorConfig(scope) {
+        if (scope === "project") {
+          return join(process.cwd(), ".cursor");
+        }
+        const base = process.platform === "win32" ? join(homedir(), "AppData", "Local", "Cursor") : join(homedir(), ".cursor");
+        return base;
+      },
+      /**
+       * Get Cursor commands directory
+       */
+      cursorCommands(project) {
+        return join(this.cursorConfig(project ? "project" : "user"), "commands");
+      },
+      /**
+       * Get Cursor skills directory
+       */
+      cursorSkills(project) {
+        return join(this.cursorConfig(project ? "project" : "user"), "skills");
+      },
+      /**
+       * Get Cursor agents directory
+       */
+      cursorAgents(project) {
+        return join(this.cursorConfig(project ? "project" : "user"), "agents");
       }
     };
   }
@@ -176,6 +204,756 @@ var init_version = __esm({
   }
 });
 
+// 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/database/schema.ts
+function initializeSchema(db) {
+  try {
+    logger.info("Initializing Figma database schema...");
+    db.pragma("foreign_keys = ON");
+    db.pragma("journal_mode = WAL");
+    Object.entries(SCHEMA_SQL).forEach(([tableName, sql]) => {
+      logger.debug(`Creating table: ${tableName}`);
+      db.exec(sql);
+    });
+    Object.entries(INDEX_SQL).forEach(([indexName, sql]) => {
+      logger.debug(`Creating index: ${indexName}`);
+      db.exec(sql);
+    });
+    Object.entries(TRIGGER_SQL).forEach(([triggerName, sql]) => {
+      logger.debug(`Creating trigger: ${triggerName}`);
+      db.exec(sql);
+    });
+    const currentVersion = getCurrentSchemaVersion(db);
+    if (currentVersion < DATABASE_VERSION) {
+      db.prepare("INSERT OR REPLACE INTO schema_version (version) VALUES (?)").run(DATABASE_VERSION);
+      logger.info(`Schema updated to version ${DATABASE_VERSION}`);
+    }
+    logger.info("Database schema initialized successfully");
+  } catch (error) {
+    logger.error(`Failed to initialize database schema: ${error instanceof Error ? error.message : String(error)}`);
+    throw error;
+  }
+}
+function getCurrentSchemaVersion(db) {
+  try {
+    const result = db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get();
+    return result?.version || 0;
+  } catch {
+    return 0;
+  }
+}
+var DATABASE_VERSION, SCHEMA_SQL, INDEX_SQL, TRIGGER_SQL;
+var init_schema = __esm({
+  "src/core/database/schema.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    DATABASE_VERSION = 1;
+    SCHEMA_SQL = {
+      // Files table - stores Figma file metadata
+      figma_files: `
+    CREATE TABLE IF NOT EXISTS figma_files (
+      id TEXT PRIMARY KEY,
+      url TEXT NOT NULL UNIQUE,
+      name TEXT,
+      file_key TEXT NOT NULL,
+      last_analyzed DATETIME,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `,
+      // Screens table - stores screen/frame information
+      figma_screens: `
+    CREATE TABLE IF NOT EXISTS figma_screens (
+      id TEXT PRIMARY KEY,
+      file_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      width INTEGER,
+      height INTEGER,
+      type TEXT,
+      description TEXT,
+      children_count INTEGER,
+      FOREIGN KEY (file_id) REFERENCES figma_files(id) ON DELETE CASCADE
+    )
+  `,
+      // Nodes table - stores hierarchical component structure
+      figma_nodes: `
+    CREATE TABLE IF NOT EXISTS figma_nodes (
+      id TEXT PRIMARY KEY,
+      file_id TEXT NOT NULL,
+      screen_id TEXT,
+      parent_id TEXT,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL,
+      content TEXT,
+      position_x REAL,
+      position_y REAL,
+      width REAL,
+      height REAL,
+      styles TEXT, -- JSON string
+      children_ids TEXT, -- JSON string array
+      FOREIGN KEY (file_id) REFERENCES figma_files(id) ON DELETE CASCADE,
+      FOREIGN KEY (screen_id) REFERENCES figma_screens(id) ON DELETE CASCADE,
+      FOREIGN KEY (parent_id) REFERENCES figma_nodes(id) ON DELETE CASCADE
+    )
+  `,
+      // Design tokens table - stores extracted design tokens
+      design_tokens: `
+    CREATE TABLE IF NOT EXISTS design_tokens (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_id TEXT NOT NULL,
+      type TEXT NOT NULL, -- 'color', 'typography', 'spacing', 'component'
+      name TEXT NOT NULL,
+      value TEXT NOT NULL,
+      category TEXT,
+      FOREIGN KEY (file_id) REFERENCES figma_files(id) ON DELETE CASCADE
+    )
+  `,
+      // Assets table - stores downloadable assets
+      figma_assets: `
+    CREATE TABLE IF NOT EXISTS figma_assets (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_id TEXT NOT NULL,
+      node_id TEXT NOT NULL,
+      node_name TEXT,
+      node_type TEXT,
+      format TEXT, -- 'png', 'svg', 'jpg'
+      file_path TEXT,
+      url TEXT,
+      width INTEGER,
+      height INTEGER,
+      FOREIGN KEY (file_id) REFERENCES figma_files(id) ON DELETE CASCADE
+    )
+  `,
+      // Schema version tracking
+      schema_version: `
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version INTEGER PRIMARY KEY,
+      applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `
+    };
+    INDEX_SQL = {
+      // Files indexes
+      idx_files_url: "CREATE INDEX IF NOT EXISTS idx_files_url ON figma_files(url)",
+      idx_files_file_key: "CREATE INDEX IF NOT EXISTS idx_files_file_key ON figma_files(file_key)",
+      idx_files_last_analyzed: "CREATE INDEX IF NOT EXISTS idx_files_last_analyzed ON figma_files(last_analyzed)",
+      // Screens indexes
+      idx_screens_file_id: "CREATE INDEX IF NOT EXISTS idx_screens_file_id ON figma_screens(file_id)",
+      idx_screens_type: "CREATE INDEX IF NOT EXISTS idx_screens_type ON figma_screens(type)",
+      // Nodes indexes
+      idx_nodes_file_id: "CREATE INDEX IF NOT EXISTS idx_nodes_file_id ON figma_nodes(file_id)",
+      idx_nodes_screen_id: "CREATE INDEX IF NOT EXISTS idx_nodes_screen_id ON figma_nodes(screen_id)",
+      idx_nodes_parent_id: "CREATE INDEX IF NOT EXISTS idx_nodes_parent_id ON figma_nodes(parent_id)",
+      idx_nodes_type: "CREATE INDEX IF NOT EXISTS idx_nodes_type ON figma_nodes(type)",
+      // Design tokens indexes
+      idx_tokens_file_id: "CREATE INDEX IF NOT EXISTS idx_tokens_file_id ON design_tokens(file_id)",
+      idx_tokens_type: "CREATE INDEX IF NOT EXISTS idx_tokens_type ON design_tokens(type)",
+      idx_tokens_file_type: "CREATE INDEX IF NOT EXISTS idx_tokens_file_type ON design_tokens(file_id, type)",
+      // Assets indexes
+      idx_assets_file_id: "CREATE INDEX IF NOT EXISTS idx_assets_file_id ON figma_assets(file_id)",
+      idx_assets_node_id: "CREATE INDEX IF NOT EXISTS idx_assets_node_id ON figma_assets(node_id)",
+      idx_assets_format: "CREATE INDEX IF NOT EXISTS idx_assets_format ON figma_assets(format)"
+    };
+    TRIGGER_SQL = {
+      // Update timestamp trigger for files table
+      trigger_files_updated_at: `
+    CREATE TRIGGER IF NOT EXISTS trigger_files_updated_at
+    AFTER UPDATE ON figma_files
+    FOR EACH ROW
+    BEGIN
+      UPDATE figma_files SET updated_at = CURRENT_TIMESTAMP WHERE id = NEW.id;
+    END
+  `
+    };
+  }
+});
+
+// src/core/database/figma-db.ts
+import Database from "better-sqlite3";
+var FigmaDatabase;
+var init_figma_db = __esm({
+  "src/core/database/figma-db.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_schema();
+    FigmaDatabase = class {
+      db;
+      constructor(dbPath = ":memory:") {
+        try {
+          this.db = new Database(dbPath);
+          initializeSchema(this.db);
+          logger.info(`Figma database initialized at: ${dbPath}`);
+        } catch (error) {
+          logger.error(`Failed to initialize database: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      /**
+       * Export database data to JSON
+       */
+      async exportData(fileId) {
+        try {
+          const files = fileId ? [await this.getFile(fileId)].filter(Boolean) : await this.listFiles();
+          const fileIds = files.map((f) => f.id);
+          let screens = [];
+          let nodes = [];
+          let tokens = [];
+          let assets = [];
+          for (const fId of fileIds) {
+            screens.push(...await this.getScreensByFile(fId));
+            nodes.push(...await this.getNodesByFile(fId));
+            tokens.push(...await this.getDesignTokensByFile(fId));
+            assets.push(...await this.getAssetsByFile(fId));
+          }
+          return {
+            files,
+            screens,
+            nodes,
+            tokens,
+            assets,
+            exported_at: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        } catch (error) {
+          logger.error(`Failed to export data: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      /**
+       * Import database data from JSON
+       */
+      async importData(data) {
+        try {
+          const stats = { files: 0, screens: 0, nodes: 0, tokens: 0, assets: 0 };
+          for (const file of data.files) {
+            await this.upsertFile(file);
+            stats.files++;
+          }
+          for (const screen of data.screens) {
+            await this.upsertScreen(screen);
+            stats.screens++;
+          }
+          for (const node of data.nodes) {
+            await this.upsertNode(node);
+            stats.nodes++;
+          }
+          for (const token of data.tokens) {
+            await this.upsertDesignToken(token);
+            stats.tokens++;
+          }
+          for (const asset of data.assets) {
+            await this.upsertAsset(asset);
+            stats.assets++;
+          }
+          logger.info(`Imported ${stats.files} files, ${stats.screens} screens, ${stats.nodes} nodes, ${stats.tokens} tokens, ${stats.assets} assets`);
+          return stats;
+        } catch (error) {
+          logger.error(`Failed to import data: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      /**
+       * Utility Operations
+       */
+      async upsertFile(file) {
+        try {
+          const lastAnalyzed = file.last_analyzed instanceof Date ? file.last_analyzed.toISOString() : file.last_analyzed || null;
+          const existing = this.db.prepare("SELECT id FROM figma_files WHERE id = ?").get(file.id);
+          if (existing) {
+            this.db.prepare(`
+          UPDATE figma_files 
+          SET url = ?, name = ?, file_key = ?, last_analyzed = ?, updated_at = CURRENT_TIMESTAMP
+          WHERE id = ?
+        `).run(file.url, file.name || null, file.file_key, lastAnalyzed, file.id);
+            return { id: file.id, created: false, updated: true };
+          } else {
+            this.db.prepare(`
+          INSERT INTO figma_files (id, url, name, file_key, last_analyzed)
+          VALUES (?, ?, ?, ?, ?)
+        `).run(file.id, file.url, file.name || null, file.file_key, lastAnalyzed);
+            return { id: file.id, created: true, updated: false };
+          }
+        } catch (error) {
+          logger.error(`Failed to upsert file: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      async getFile(id) {
+        try {
+          const row = this.db.prepare("SELECT * FROM figma_files WHERE id = ?").get(id);
+          if (!row) return null;
+          return {
+            ...row,
+            created_at: new Date(row.created_at),
+            updated_at: new Date(row.updated_at),
+            last_analyzed: row.last_analyzed ? new Date(row.last_analyzed) : void 0
+          };
+        } catch (error) {
+          logger.error(`Failed to get file: ${error instanceof Error ? error.message : String(error)}`);
+          return null;
+        }
+      }
+      async getFileByUrl(url) {
+        try {
+          const row = this.db.prepare("SELECT * FROM figma_files WHERE url = ?").get(url);
+          if (!row) return null;
+          return {
+            ...row,
+            created_at: new Date(row.created_at),
+            updated_at: new Date(row.updated_at),
+            last_analyzed: row.last_analyzed ? new Date(row.last_analyzed) : void 0
+          };
+        } catch (error) {
+          logger.error(`Failed to get file by URL: ${error instanceof Error ? error.message : String(error)}`);
+          return null;
+        }
+      }
+      async deleteFile(id) {
+        try {
+          const result = this.db.prepare("DELETE FROM figma_files WHERE id = ?").run(id);
+          return result.changes > 0;
+        } catch (error) {
+          logger.error(`Failed to delete file: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      async listFiles(options) {
+        try {
+          const limit = options?.limit || 50;
+          const offset = options?.offset || 0;
+          const orderBy = options?.orderBy || "updated_at";
+          const orderDirection = options?.orderDirection || "DESC";
+          const query = `
+        SELECT * FROM figma_files 
+        ORDER BY ${orderBy} ${orderDirection}
+        LIMIT ? OFFSET ?
+      `;
+          const rows = this.db.prepare(query).all(limit, offset);
+          return rows.map((row) => ({
+            ...row,
+            created_at: new Date(row.created_at),
+            updated_at: new Date(row.updated_at),
+            last_analyzed: row.last_analyzed ? new Date(row.last_analyzed) : void 0
+          }));
+        } catch (error) {
+          logger.error(`Failed to list files: ${error instanceof Error ? error.message : String(error)}`);
+          return [];
+        }
+      }
+      /**
+       * Screen Operations
+       */
+      async upsertScreen(screen) {
+        try {
+          const existing = this.db.prepare("SELECT id FROM figma_screens WHERE id = ?").get(screen.id);
+          if (existing) {
+            this.db.prepare(`
+          UPDATE figma_screens 
+          SET file_id = ?, name = ?, width = ?, height = ?, type = ?, description = ?, children_count = ?
+          WHERE id = ?
+        `).run(
+              screen.file_id,
+              screen.name,
+              screen.width || null,
+              screen.height || null,
+              screen.type || null,
+              screen.description || null,
+              screen.children_count || null,
+              screen.id
+            );
+            return { id: screen.id, created: false, updated: true };
+          } else {
+            this.db.prepare(`
+          INSERT INTO figma_screens (id, file_id, name, width, height, type, description, children_count)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(
+              screen.id,
+              screen.file_id,
+              screen.name,
+              screen.width || null,
+              screen.height || null,
+              screen.type || null,
+              screen.description || null,
+              screen.children_count || null
+            );
+            return { id: screen.id, created: true, updated: false };
+          }
+        } catch (error) {
+          logger.error(`Failed to upsert screen: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      async getScreen(id) {
+        try {
+          const row = this.db.prepare("SELECT * FROM figma_screens WHERE id = ?").get(id);
+          return row || null;
+        } catch (error) {
+          logger.error(`Failed to get screen: ${error instanceof Error ? error.message : String(error)}`);
+          return null;
+        }
+      }
+      async getScreensByFile(fileId) {
+        try {
+          const rows = this.db.prepare("SELECT * FROM figma_screens WHERE file_id = ? ORDER BY name").all(fileId);
+          return rows;
+        } catch (error) {
+          logger.error(`Failed to get screens by file: ${error instanceof Error ? error.message : String(error)}`);
+          return [];
+        }
+      }
+      async deleteScreen(id) {
+        try {
+          const result = this.db.prepare("DELETE FROM figma_screens WHERE id = ?").run(id);
+          return result.changes > 0;
+        } catch (error) {
+          logger.error(`Failed to delete screen: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      /**
+       * Node Operations
+       */
+      async upsertNode(node) {
+        try {
+          const existing = this.db.prepare("SELECT id FROM figma_nodes WHERE id = ?").get(node.id);
+          if (existing) {
+            this.db.prepare(`
+          UPDATE figma_nodes 
+          SET file_id = ?, screen_id = ?, parent_id = ?, name = ?, type = ?, content = ?,
+              position_x = ?, position_y = ?, width = ?, height = ?, styles = ?, children_ids = ?
+          WHERE id = ?
+        `).run(
+              node.file_id,
+              node.screen_id || null,
+              node.parent_id || null,
+              node.name,
+              node.type,
+              node.content || null,
+              node.position_x || null,
+              node.position_y || null,
+              node.width || null,
+              node.height || null,
+              node.styles || null,
+              node.children_ids || null,
+              node.id
+            );
+            return { id: node.id, created: false, updated: true };
+          } else {
+            this.db.prepare(`
+          INSERT INTO figma_nodes (id, file_id, screen_id, parent_id, name, type, content, 
+                                   position_x, position_y, width, height, styles, children_ids)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(
+              node.id,
+              node.file_id,
+              node.screen_id || null,
+              node.parent_id || null,
+              node.name,
+              node.type,
+              node.content || null,
+              node.position_x || null,
+              node.position_y || null,
+              node.width || null,
+              node.height || null,
+              node.styles || null,
+              node.children_ids || null
+            );
+            return { id: node.id, created: true, updated: false };
+          }
+        } catch (error) {
+          logger.error(`Failed to upsert node: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      async getNode(id) {
+        try {
+          const row = this.db.prepare("SELECT * FROM figma_nodes WHERE id = ?").get(id);
+          return row || null;
+        } catch (error) {
+          logger.error(`Failed to get node: ${error instanceof Error ? error.message : String(error)}`);
+          return null;
+        }
+      }
+      async getNodesByScreen(screenId) {
+        try {
+          const rows = this.db.prepare("SELECT * FROM figma_nodes WHERE screen_id = ? ORDER BY name").all(screenId);
+          return rows;
+        } catch (error) {
+          logger.error(`Failed to get nodes by screen: ${error instanceof Error ? error.message : String(error)}`);
+          return [];
+        }
+      }
+      async getNodesByFile(fileId) {
+        try {
+          const rows = this.db.prepare("SELECT * FROM figma_nodes WHERE file_id = ? ORDER BY name").all(fileId);
+          return rows;
+        } catch (error) {
+          logger.error(`Failed to get nodes by file: ${error instanceof Error ? error.message : String(error)}`);
+          return [];
+        }
+      }
+      async deleteNode(id) {
+        try {
+          const result = this.db.prepare("DELETE FROM figma_nodes WHERE id = ?").run(id);
+          return result.changes > 0;
+        } catch (error) {
+          logger.error(`Failed to delete node: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      /**
+       * Design Token Operations
+       */
+      async upsertDesignToken(token) {
+        try {
+          const existing = this.db.prepare(`
+        SELECT id FROM design_tokens 
+        WHERE file_id = ? AND type = ? AND name = ?
+      `).get(token.file_id, token.type, token.name);
+          if (existing) {
+            this.db.prepare(`
+          UPDATE design_tokens 
+          SET value = ?, category = ?
+          WHERE id = ?
+        `).run(token.value, token.category || null, existing.id);
+            return { id: existing.id.toString(), created: false, updated: true };
+          } else {
+            const result = this.db.prepare(`
+          INSERT INTO design_tokens (file_id, type, name, value, category)
+          VALUES (?, ?, ?, ?, ?)
+        `).run(token.file_id, token.type, token.name, token.value, token.category || null);
+            return { id: result.lastInsertRowid.toString(), created: true, updated: false };
+          }
+        } catch (error) {
+          logger.error(`Failed to upsert design token: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      async getDesignTokensByFile(fileId, type) {
+        try {
+          const query = type ? "SELECT * FROM design_tokens WHERE file_id = ? AND type = ? ORDER BY name" : "SELECT * FROM design_tokens WHERE file_id = ? ORDER BY type, name";
+          const rows = type ? this.db.prepare(query).all(fileId, type) : this.db.prepare(query).all(fileId);
+          return rows;
+        } catch (error) {
+          logger.error(`Failed to get design tokens: ${error instanceof Error ? error.message : String(error)}`);
+          return [];
+        }
+      }
+      async deleteDesignTokensByFile(fileId) {
+        try {
+          const result = this.db.prepare("DELETE FROM design_tokens WHERE file_id = ?").run(fileId);
+          return result.changes > 0;
+        } catch (error) {
+          logger.error(`Failed to delete design tokens: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      /**
+       * Asset Operations
+       */
+      async upsertAsset(asset) {
+        try {
+          const existing = this.db.prepare(`
+        SELECT id FROM figma_assets 
+        WHERE file_id = ? AND node_id = ?
+      `).get(asset.file_id, asset.node_id);
+          if (existing) {
+            this.db.prepare(`
+          UPDATE figma_assets 
+          SET node_name = ?, node_type = ?, format = ?, file_path = ?, url = ?, width = ?, height = ?
+          WHERE id = ?
+        `).run(
+              asset.node_name || null,
+              asset.node_type || null,
+              asset.format || null,
+              asset.file_path || null,
+              asset.url || null,
+              asset.width || null,
+              asset.height || null,
+              existing.id
+            );
+            return { id: existing.id.toString(), created: false, updated: true };
+          } else {
+            const result = this.db.prepare(`
+          INSERT INTO figma_assets (file_id, node_id, node_name, node_type, format, file_path, url, width, height)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(
+              asset.file_id,
+              asset.node_id,
+              asset.node_name || null,
+              asset.node_type || null,
+              asset.format || null,
+              asset.file_path || null,
+              asset.url || null,
+              asset.width || null,
+              asset.height || null
+            );
+            return { id: result.lastInsertRowid.toString(), created: true, updated: false };
+          }
+        } catch (error) {
+          logger.error(`Failed to upsert asset: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+      }
+      async getAssetsByFile(fileId) {
+        try {
+          const rows = this.db.prepare("SELECT * FROM figma_assets WHERE file_id = ? ORDER BY node_name").all(fileId);
+          return rows;
+        } catch (error) {
+          logger.error(`Failed to get assets by file: ${error instanceof Error ? error.message : String(error)}`);
+          return [];
+        }
+      }
+      async deleteAssetsByFile(fileId) {
+        try {
+          const result = this.db.prepare("DELETE FROM figma_assets WHERE file_id = ?").run(fileId);
+          return result.changes > 0;
+        } catch (error) {
+          logger.error(`Failed to delete assets by file: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      /**
+       * Cache invalidation logic
+       */
+      async isCacheValid(url, maxAgeHours = 24) {
+        try {
+          const file = await this.getFileByUrl(url);
+          if (!file || !file.last_analyzed) return false;
+          const now = /* @__PURE__ */ new Date();
+          const ageHours = (now.getTime() - file.last_analyzed.getTime()) / (1e3 * 60 * 60);
+          return ageHours < maxAgeHours;
+        } catch (error) {
+          logger.error(`Failed to check cache validity: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      /**
+       * Clear cache for a specific file
+       */
+      async clearFileCache(url) {
+        try {
+          const file = await this.getFileByUrl(url);
+          if (!file) return false;
+          await this.deleteDesignTokensByFile(file.id);
+          await this.deleteAssetsByFile(file.id);
+          const nodes = await this.getNodesByFile(file.id);
+          for (const node of nodes) {
+            await this.deleteNode(node.id);
+          }
+          const screens = await this.getScreensByFile(file.id);
+          for (const screen of screens) {
+            await this.deleteScreen(screen.id);
+          }
+          return await this.deleteFile(file.id);
+        } catch (error) {
+          logger.error(`Failed to clear file cache: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      }
+      /**
+       * Clear all expired cache entries
+       */
+      async clearExpiredCache(maxAgeHours = 24 * 7) {
+        try {
+          const cutoffDate = new Date(Date.now() - maxAgeHours * 60 * 60 * 1e3);
+          const expiredFiles = this.db.prepare(`
+        SELECT * FROM figma_files 
+        WHERE last_analyzed < ? OR last_analyzed IS NULL
+      `).all(cutoffDate.toISOString());
+          let clearedCount = 0;
+          for (const file of expiredFiles) {
+            if (await this.clearFileCache(file.url)) {
+              clearedCount++;
+            }
+          }
+          return clearedCount;
+        } catch (error) {
+          logger.error(`Failed to clear expired cache: ${error instanceof Error ? error.message : String(error)}`);
+          return 0;
+        }
+      }
+      async close() {
+        try {
+          this.db.close();
+          logger.info("Database connection closed");
+        } catch (error) {
+          logger.error(`Failed to close database: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      async vacuum() {
+        try {
+          this.db.exec("VACUUM");
+          logger.info("Database vacuumed");
+        } catch (error) {
+          logger.error(`Failed to vacuum database: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      async getStats() {
+        try {
+          const files = this.db.prepare("SELECT COUNT(*) as count FROM figma_files").get();
+          const screens = this.db.prepare("SELECT COUNT(*) as count FROM figma_screens").get();
+          const nodes = this.db.prepare("SELECT COUNT(*) as count FROM figma_nodes").get();
+          const tokens = this.db.prepare("SELECT COUNT(*) as count FROM design_tokens").get();
+          const assets = this.db.prepare("SELECT COUNT(*) as count FROM figma_assets").get();
+          return {
+            files: files.count,
+            screens: screens.count,
+            nodes: nodes.count,
+            tokens: tokens.count,
+            assets: assets.count
+          };
+        } catch (error) {
+          logger.error(`Failed to get stats: ${error instanceof Error ? error.message : String(error)}`);
+          return { files: 0, screens: 0, nodes: 0, tokens: 0, assets: 0 };
+        }
+      }
+    };
+  }
+});
+
 // src/core/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -233,15 +1011,41 @@ function deepMerge(base, override) {
   }
   return result;
 }
-var ConfigSchema, Config;
+var PlatformConfigSchema, ConfigSchema, Config;
 var init_config = __esm({
   "src/core/config.ts"() {
     "use strict";
     init_esm_shims();
     init_paths();
     init_version();
+    init_figma_db();
+    PlatformConfigSchema = z.object({
+      /**
+       * Primary platform to use (affects default behavior)
+       */
+      primary: z.enum(["opencode", "claude", "cursor"]).default("opencode"),
+      /**
+       * Enable OpenCode platform support
+       * Default: true (OpenCode is the primary focus)
+       */
+      opencode: z.boolean().default(true),
+      /**
+       * Enable Claude Code platform support
+       * Default: false (archived, can be re-enabled later)
+       */
+      claude: z.boolean().default(false),
+      /**
+       * Enable Cursor platform support
+       * Default: false (opt-in)
+       */
+      cursor: z.boolean().default(false)
+    }).default({});
     ConfigSchema = z.object({
       version: z.string(),
+      /**
+       * Platform configuration - controls which platforms are active
+       */
+      platform: PlatformConfigSchema,
       skills: z.object({
         enabled: z.boolean().default(true),
         directory: z.string().optional()
@@ -273,6 +1077,11 @@ var init_config = __esm({
         specFile: z.string().default("spec.md"),
         reviewFile: z.string().default("review.md")
       }).default({}),
+      database: z.object({
+        enabled: z.boolean().default(true),
+        path: z.string().optional()
+        // If not provided, will use default path
+      }).default({}),
       mcp: z.object({
         context7: z.boolean().default(false),
         githubGrep: z.boolean().default(false),
@@ -312,12 +1121,46 @@ var init_config = __esm({
       get antiHallucination() {
         return this.config.antiHallucination;
       }
+      get database() {
+        return this.config.database;
+      }
       get mode() {
         return this.config.mode;
       }
+      get platform() {
+        return this.config.platform;
+      }
       get configPath() {
         return this.config.configPath;
       }
+      /**
+       * Check if a specific platform is enabled
+       */
+      isPlatformEnabled(platform) {
+        return this.config.platform[platform] ?? false;
+      }
+      /**
+       * Get the primary platform
+       */
+      getPrimaryPlatform() {
+        return this.config.platform.primary;
+      }
+      /**
+       * Get list of all enabled platforms
+       */
+      getEnabledPlatforms() {
+        const platforms = [];
+        if (this.config.platform.opencode) {
+          platforms.push("opencode");
+        }
+        if (this.config.platform.claude) {
+          platforms.push("claude");
+        }
+        if (this.config.platform.cursor) {
+          platforms.push("cursor");
+        }
+        return platforms;
+      }
       get projectPath() {
         return this.config.projectPath;
       }
@@ -325,49 +1168,20 @@ var init_config = __esm({
        * Get path to a specific resource
        */
       getPath(resource) {
+        if (resource === "database") {
+          return this.config.database.path || join3(this.configPath, "figma.db");
+        }
         return paths[resource](this.configPath);
       }
-    };
-  }
-});
-
-// 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}`);
+      /**
+       * Get database instance
+       */
+      getDatabase() {
+        if (this.config.database?.enabled === false) {
+          throw new Error("Database is disabled in configuration");
         }
+        const dbPath = this.getPath("database");
+        return new FigmaDatabase(dbPath);
       }
     };
   }
@@ -605,8 +1419,10 @@ var init_figma_mcp = __esm({
     init_logger();
     FigmaMcpClient = class {
       apiKey;
-      constructor(apiKey, _configManager) {
+      database;
+      constructor(apiKey, _configManager, database) {
         this.apiKey = apiKey;
+        this.database = database;
       }
       /**
        * Fetch helper with simple retry/backoff for 429/5xx
@@ -689,14 +1505,22 @@ ${text}`);
         return data;
       }
       /**
-       * Extract design tokens from Figma file
+       * Extract design tokens from Figma file and optionally persist to database
        */
       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}`);
         }
+        if (this.database) {
+          const cachedData = await this.getFromDatabase(fileKey);
+          if (cachedData) {
+            logger.info(`\u26A1 Using cached data from database (analyzed ${this.getTimeAgo(cachedData.last_analyzed)})`);
+            return cachedData.tokens;
+          }
+        }
+        logger.info("\u23F3 Fetching fresh data from Figma API...");
+        const fileData = await this.getFileData(url);
         const tokens = {
           colors: [],
           typography: [],
@@ -741,8 +1565,227 @@ ${text}`);
             logger.warn(`Failed to download assets: ${error instanceof Error ? error.message : String(error)}`);
           }
         }
+        if (this.database) {
+          await this.persistToDatabase(url, fileKey, tokens);
+        }
         return tokens;
       }
+      /**
+       * Persist extracted tokens to database
+       */
+      async persistToDatabase(url, fileKey, tokens) {
+        if (!this.database) return;
+        try {
+          logger.info("Persisting Figma data to database...");
+          const fileId = fileKey;
+          await this.database.upsertFile({
+            id: fileId,
+            url,
+            name: url.split("/").pop() || "Figma Design",
+            file_key: fileKey,
+            last_analyzed: /* @__PURE__ */ new Date()
+          });
+          for (const screen of tokens.screens) {
+            await this.database.upsertScreen({
+              id: screen.id,
+              file_id: fileId,
+              name: screen.name,
+              width: screen.width,
+              height: screen.height,
+              type: screen.type,
+              children_count: screen.childrenCount
+            });
+          }
+          if (tokens.structure?.nodes) {
+            for (const node of tokens.structure.nodes) {
+              await this.database.upsertNode({
+                id: node.id,
+                file_id: fileId,
+                screen_id: this.findScreenIdForNode(node.id, tokens.screens),
+                parent_id: this.findParentId(node.id, tokens.structure.nodes),
+                name: node.name,
+                type: node.type,
+                content: node.content,
+                position_x: node.position?.x,
+                position_y: node.position?.y,
+                width: node.position?.width,
+                height: node.position?.height,
+                styles: node.styles ? JSON.stringify(node.styles) : void 0,
+                children_ids: node.children ? JSON.stringify(node.children) : void 0
+              });
+            }
+          }
+          for (const color of tokens.colors) {
+            await this.database.upsertDesignToken({
+              file_id: fileId,
+              type: "color",
+              name: color.name,
+              value: color.hex,
+              category: "color"
+            });
+          }
+          for (const typo of tokens.typography) {
+            await this.database.upsertDesignToken({
+              file_id: fileId,
+              type: "typography",
+              name: typo.name,
+              value: JSON.stringify({
+                fontFamily: typo.fontFamily,
+                fontSize: typo.fontSize,
+                fontWeight: typo.fontWeight,
+                lineHeight: typo.lineHeight
+              }),
+              category: "typography"
+            });
+          }
+          for (const component of tokens.components) {
+            await this.database.upsertDesignToken({
+              file_id: fileId,
+              type: "component",
+              name: component.name,
+              value: component.type,
+              category: component.description
+            });
+          }
+          if (tokens.assets) {
+            for (const asset of tokens.assets) {
+              await this.database.upsertAsset({
+                file_id: fileId,
+                node_id: asset.nodeId,
+                node_name: asset.nodeName,
+                node_type: asset.nodeType,
+                format: asset.format,
+                file_path: asset.path,
+                url: asset.url,
+                width: asset.width,
+                height: asset.height
+              });
+            }
+          }
+          logger.info("Successfully persisted Figma data to database");
+        } catch (error) {
+          logger.error(`Failed to persist to database: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      /**
+       * Get cached data from database
+       */
+      async getFromDatabase(fileKey) {
+        if (!this.database) return null;
+        try {
+          const file = await this.database.getFile(fileKey);
+          if (!file || !file.last_analyzed) return null;
+          const cacheAge = Date.now() - file.last_analyzed.getTime();
+          const maxAge = 24 * 60 * 60 * 1e3;
+          if (cacheAge > maxAge) {
+            logger.info("Cache expired, fetching fresh data...");
+            return null;
+          }
+          const screens = await this.database.getScreensByFile(fileKey);
+          const nodes = await this.database.getNodesByFile(fileKey);
+          const tokenRecords = await this.database.getDesignTokensByFile(fileKey);
+          const assets = await this.database.getAssetsByFile(fileKey);
+          const tokens = {
+            colors: tokenRecords.filter((t) => t.type === "color").map((t) => ({ name: t.name, hex: t.value, rgba: t.value })),
+            typography: tokenRecords.filter((t) => t.type === "typography").map((t) => {
+              const parsed = JSON.parse(t.value);
+              return {
+                name: t.name,
+                fontFamily: parsed.fontFamily,
+                fontSize: parsed.fontSize,
+                fontWeight: parsed.fontWeight,
+                lineHeight: parsed.lineHeight,
+                letterSpacing: parsed.letterSpacing
+              };
+            }),
+            spacing: {
+              unit: 8,
+              scale: [4, 8, 12, 16, 24, 32, 48, 64]
+            },
+            components: tokenRecords.filter((t) => t.type === "component").map((t) => ({ name: t.name, type: t.value, description: t.category })),
+            screens: screens.map((s) => ({
+              id: s.id,
+              name: s.name,
+              width: s.width || 0,
+              height: s.height || 0,
+              type: s.type || "FRAME",
+              description: s.description,
+              childrenCount: s.children_count
+            })),
+            breakpoints: [375, 768, 1024, 1280, 1920],
+            structure: {
+              nodes: nodes.map((n) => ({
+                id: n.id,
+                name: n.name,
+                type: n.type,
+                content: n.content,
+                position: n.position_x !== void 0 ? {
+                  x: n.position_x,
+                  y: n.position_y || 0,
+                  width: n.width || 0,
+                  height: n.height || 0
+                } : void 0,
+                styles: n.styles ? JSON.parse(n.styles) : void 0,
+                children: n.children_ids ? JSON.parse(n.children_ids) : void 0
+              })),
+              hierarchy: this.buildHierarchy(nodes)
+            },
+            assets: assets.map((a) => ({
+              nodeId: a.node_id,
+              nodeName: a.node_name || "",
+              nodeType: a.node_type || "",
+              format: a.format || "png",
+              path: a.file_path || "",
+              url: a.url || "",
+              width: a.width,
+              height: a.height
+            }))
+          };
+          return { tokens, last_analyzed: file.last_analyzed };
+        } catch (error) {
+          logger.warn(`Failed to retrieve from database: ${error instanceof Error ? error.message : String(error)}`);
+          return null;
+        }
+      }
+      /**
+       * Build hierarchy string from nodes
+       */
+      buildHierarchy(nodes) {
+        return nodes.map((n) => `${n.type} "${n.name}" [${n.id}]`).join("\n");
+      }
+      /**
+       * Get human-readable time ago
+       */
+      getTimeAgo(date) {
+        const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
+        if (seconds < 60) return `${seconds} seconds ago`;
+        const minutes = Math.floor(seconds / 60);
+        if (minutes < 60) return `${minutes} minutes ago`;
+        const hours = Math.floor(minutes / 60);
+        if (hours < 24) return `${hours} hours ago`;
+        const days = Math.floor(hours / 24);
+        return `${days} days ago`;
+      }
+      /**
+       * Helper to find which screen a node belongs to
+       */
+      findScreenIdForNode(nodeId, screens) {
+        if (screens.find((s) => s.id === nodeId)) {
+          return nodeId;
+        }
+        return void 0;
+      }
+      /**
+       * Helper to find parent node ID
+       */
+      findParentId(nodeId, nodes) {
+        for (const node of nodes) {
+          if (node.children?.includes(nodeId)) {
+            return node.id;
+          }
+        }
+        return void 0;
+      }
       /**
        * Recursively extract colors from nodes
        */
@@ -1013,11 +2056,66 @@ ${text}`);
 var figma_screen_developer_exports = {};
 __export(figma_screen_developer_exports, {
   checkCurrentCodeStatus: () => checkCurrentCodeStatus,
-  compareCodeWithFigma: () => compareCodeWithFigma
+  compareCodeWithFigma: () => compareCodeWithFigma,
+  getCachedFigmaData: () => getCachedFigmaData
 });
 import { readFile as readFile5, readdir as readdir3 } from "fs/promises";
 import { join as join8 } from "path";
 import { existsSync as existsSync3 } from "fs";
+async function getCachedFigmaData(url, database) {
+  if (!database) return null;
+  try {
+    const file = await database.getFileByUrl(url);
+    if (!file) return null;
+    const screens = await database.getScreensByFile(file.id);
+    const nodes = await database.getNodesByFile(file.id);
+    const tokens = await database.getDesignTokensByFile(file.id);
+    const assets = await database.getAssetsByFile(file.id);
+    return {
+      screens: screens.map((s) => ({
+        id: s.id,
+        name: s.name,
+        width: s.width,
+        height: s.height,
+        type: s.type,
+        childrenCount: s.children_count
+      })),
+      nodes: nodes.map((n) => ({
+        id: n.id,
+        name: n.name,
+        type: n.type,
+        content: n.content,
+        position: n.position_x ? {
+          x: n.position_x,
+          y: n.position_y,
+          width: n.width,
+          height: n.height
+        } : void 0,
+        styles: n.styles ? JSON.parse(n.styles) : void 0,
+        children: n.children_ids ? JSON.parse(n.children_ids) : void 0
+      })),
+      tokens: tokens.map((t) => ({
+        type: t.type,
+        name: t.name,
+        value: t.value,
+        category: t.category
+      })),
+      assets: assets.map((a) => ({
+        nodeId: a.node_id,
+        nodeName: a.node_name,
+        nodeType: a.node_type,
+        format: a.format,
+        path: a.file_path,
+        url: a.url,
+        width: a.width,
+        height: a.height
+      }))
+    };
+  } catch (error) {
+    logger.warn(`Failed to get cached Figma data: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
 async function checkCurrentCodeStatus(projectPath = process.cwd()) {
   const status = {
     hasHTML: false,
@@ -1077,7 +2175,12 @@ async function checkCurrentCodeStatus(projectPath = process.cwd()) {
   }
   return status;
 }
-async function compareCodeWithFigma(figmaTokens, selectedScreenId, projectPath = process.cwd()) {
+async function compareCodeWithFigma(figmaTokens, selectedScreenId, projectPath = process.cwd(), database, figmaUrl) {
+  let cachedData;
+  if (database && figmaUrl) {
+    cachedData = await getCachedFigmaData(figmaUrl, database);
+  }
+  const dataToUse = cachedData || figmaTokens;
   const codeStatus = await checkCurrentCodeStatus(projectPath);
   const result = {
     missingSections: [],
@@ -1085,17 +2188,18 @@ async function compareCodeWithFigma(figmaTokens, selectedScreenId, projectPath =
     needsUpdate: false,
     recommendations: []
   };
-  const selectedScreen = figmaTokens.screens?.find((s) => s.id === selectedScreenId);
+  const selectedScreen = dataToUse.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 (dataToUse.structure?.nodes || dataToUse.nodes) {
+    const nodes = dataToUse.structure?.nodes || dataToUse.nodes;
+    const screenNode = nodes.find((n) => n.id === selectedScreenId);
     if (screenNode?.children) {
       screenNode.children.forEach((childId) => {
-        const childNode = figmaTokens.structure.nodes.find((n) => n.id === childId);
+        const childNode = 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);
@@ -4794,7 +5898,15 @@ This will guide you through setting up your Figma Personal Access Token.`;
       }
       try {
         const { FigmaMcpClient: FigmaMcpClient2 } = await Promise.resolve().then(() => (init_figma_mcp(), figma_mcp_exports));
-        const client = new FigmaMcpClient2(apiKey, configManager);
+        let database;
+        try {
+          if (context?.config) {
+            database = context.config.getDatabase();
+          }
+        } catch (error) {
+          logger.info("Database not available for Figma persistence");
+        }
+        const client = new FigmaMcpClient2(apiKey, configManager, database);
         const assetsDir = "./assets/images";
         const tokens = await client.extractDesignTokens(url, false, assetsDir);
         let result = `# Figma Design Analysis
@@ -5025,25 +6137,6 @@ Please check:
       }
     }
   },
-  {
-    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.",
@@ -5075,7 +6168,15 @@ Next steps:
       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);
+        let database;
+        try {
+          if (context?.config) {
+            database = context.config.getDatabase();
+          }
+        } catch (error) {
+          logger.info("Database not available for Figma persistence");
+        }
+        const client = new FigmaMcpClient2(apiKey, configManager, database);
         const tokens = await client.extractDesignTokens(figmaUrl, false, "./assets/images");
         const screenIdStr = String(screenId);
         const selectedScreen = tokens.screens?.find(
@@ -5636,12 +6737,226 @@ ${argsDesc}
   }
 };
 
+// src/core/tool-config.ts
+init_esm_shims();
+init_logger();
+import { readFile as readFile7, writeFile as writeFile7, mkdir as mkdir7, access as access4, constants as constants4 } from "fs/promises";
+import { join as join11 } from "path";
+import { homedir as homedir2 } from "os";
+import { z as z3 } from "zod";
+var ToolConfigSchema = z3.object({
+  name: z3.string(),
+  status: z3.enum(["ready", "needs_config", "error"]),
+  description: z3.string(),
+  configMethod: z3.enum(["oauth", "manual", "none"]),
+  config: z3.record(z3.unknown()).optional(),
+  errorMessage: z3.string().optional()
+});
+var REGISTERED_TOOLS = [
+  {
+    name: "figma-analysis",
+    description: "Analyze Figma designs and extract design tokens using Figma API",
+    configMethod: "oauth"
+  }
+  // Add more tools here as needed
+];
+var ToolConfigManager = class {
+  config;
+  toolsConfigPath;
+  constructor(config) {
+    this.config = config;
+    this.toolsConfigPath = 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);
+    const isReady = toolConfig?.status === "ready";
+    logger.info(`\u{1F50D} Tool ready check for ${toolName}:`, {
+      hasConfig: !!toolConfig,
+      status: toolConfig?.status,
+      isReady
+    });
+    return isReady;
+  }
+  /**
+   * Get API key for a tool (if configured)
+   */
+  async getApiKey(toolName) {
+    const toolConfig = await this.getToolConfig(toolName);
+    logger.info(`\u{1F50D} Getting API key for ${toolName}:`, {
+      hasConfig: !!toolConfig,
+      hasApiKey: !!toolConfig?.config?.apiKey,
+      status: toolConfig?.status,
+      apiKeyLength: typeof toolConfig?.config?.apiKey === "string" ? toolConfig.config.apiKey.length : 0
+    });
+    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") {
+      logger.info(`\u{1F50D} Tool ${tool.name} uses 'none' config method - marking as ready`);
+      return "ready";
+    }
+    if (saved?.errorMessage) {
+      logger.warn(`\u{1F50D} Tool ${tool.name} has error: ${saved.errorMessage}`);
+      return "error";
+    }
+    if (tool.configMethod === "oauth" || tool.configMethod === "manual") {
+      const hasApiKey = saved?.config?.apiKey && typeof saved.config.apiKey === "string" && saved.config.apiKey.length > 0;
+      logger.info(`\u{1F50D} Tool ${tool.name} status check:`, {
+        configMethod: tool.configMethod,
+        hasSaved: !!saved,
+        hasConfig: !!saved?.config,
+        hasApiKey,
+        apiKeyLength: typeof saved?.config?.apiKey === "string" ? saved.config.apiKey.length : 0
+      });
+      if (hasApiKey) {
+        return "ready";
+      }
+      return "needs_config";
+    }
+    logger.warn(`\u{1F50D} Tool ${tool.name} fell through to default 'needs_config'`);
+    return "needs_config";
+  }
+  /**
+   * Load saved configurations
+   * Checks both global and project configs, project takes precedence
+   */
+  async loadConfigs() {
+    const globalConfigPath = join11(homedir2(), ".config", "aikit", "config", "tools.json");
+    let configs = {};
+    try {
+      await access4(globalConfigPath, constants4.R_OK);
+      const content = await readFile7(globalConfigPath, "utf-8");
+      configs = JSON.parse(content);
+      logger.info("Loaded global tool configs");
+    } catch {
+    }
+    try {
+      await access4(this.toolsConfigPath, constants4.R_OK);
+      const content = await readFile7(this.toolsConfigPath, "utf-8");
+      const projectConfigs = JSON.parse(content);
+      configs = { ...configs, ...projectConfigs };
+      logger.info("Loaded project tool configs");
+    } catch {
+    }
+    return configs;
+  }
+  /**
+   * Save configurations
+   */
+  async saveConfigs(configs) {
+    const configDir = join11(this.config.configPath, "config");
+    await mkdir7(configDir, { recursive: true });
+    await writeFile7(this.toolsConfigPath, JSON.stringify(configs, null, 2));
+  }
+  /**
+   * Configure Claude Desktop MCP server for a tool
+   * This adds the MCP server configuration to Claude Desktop's config file
+   */
+  async configureMcpServer(toolName, apiKey) {
+    if (toolName !== "figma-analysis") {
+      logger.info(`MCP server configuration not implemented for tool: ${toolName}`);
+      return;
+    }
+    const isWindows = process.platform === "win32";
+    const claudeConfigBase = isWindows ? process.env.APPDATA || join11(homedir2(), "AppData", "Roaming") : join11(homedir2(), ".config");
+    const claudeConfigPath = join11(claudeConfigBase, "claude", "claude_desktop_config.json");
+    try {
+      let claudeConfig = {};
+      try {
+        const content = await readFile7(claudeConfigPath, "utf-8");
+        claudeConfig = JSON.parse(content);
+      } catch {
+        claudeConfig = {};
+      }
+      if (!claudeConfig.mcpServers) {
+        claudeConfig.mcpServers = {};
+      }
+      claudeConfig.mcpServers.figma = {
+        command: "npx",
+        args: ["-y", "figma-developer-mcp", `--figma-oauth-token=${apiKey}`, "--stdio"]
+      };
+      const claudeConfigDir = join11(claudeConfigBase, "claude");
+      await mkdir7(claudeConfigDir, { recursive: true });
+      await writeFile7(claudeConfigPath, JSON.stringify(claudeConfig, null, 2));
+      logger.success("\u2705 Claude Desktop MCP server configured");
+      logger.info(`   Config file: ${claudeConfigPath}`);
+      logger.info("");
+      logger.info("\u26A0\uFE0F  IMPORTANT: Restart Claude Desktop for changes to take effect");
+    } catch (error) {
+      logger.warn(`Could not configure MCP server automatically: ${error instanceof Error ? error.message : String(error)}`);
+      logger.info("");
+      logger.info("Please configure manually:");
+      logger.info(`1. Edit: ${claudeConfigPath}`);
+      logger.info('2. Add the following to "mcpServers":');
+      logger.info(JSON.stringify({
+        figma: {
+          command: "npx",
+          args: ["-y", "figma-developer-mcp"],
+          env: {
+            FIGMA_OAUTH_TOKEN: apiKey
+          }
+        }
+      }, null, 2));
+    }
+  }
+};
+
 // src/core/plugins.ts
 init_esm_shims();
 init_paths();
 init_logger();
-import { readdir as readdir6, writeFile as writeFile7, mkdir as mkdir7 } from "fs/promises";
-import { join as join11, basename as basename3, extname as extname4 } from "path";
+import { readdir as readdir6, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
+import { join as join12, basename as basename3, extname as extname4 } from "path";
 var PluginSystem = class {
   config;
   plugins = /* @__PURE__ */ new Map();
@@ -5739,9 +7054,9 @@ var PluginSystem = class {
   async createPlugin(name, options) {
     const configPath = options.global ? paths.globalConfig() : this.config.configPath;
     const pluginsDir = paths.plugins(configPath);
-    await mkdir7(pluginsDir, { recursive: true });
+    await mkdir8(pluginsDir, { recursive: true });
     const fileName = `${name}.ts`;
-    const filePath = join11(pluginsDir, fileName);
+    const filePath = join12(pluginsDir, fileName);
     const content = `import { Plugin } from 'aikit';
 
 /**
@@ -5757,7 +7072,7 @@ ${options.code}
 
 export default ${toPascalCase(name)}Plugin;
 `;
-    await writeFile7(filePath, content);
+    await writeFile8(filePath, content);
   }
   /**
    * Process event queue
@@ -5831,7 +7146,7 @@ export default ${toPascalCase(name)}Plugin;
     }
     for (const file of files) {
       if (extname4(file) !== ".ts" && extname4(file) !== ".js") continue;
-      const filePath = join11(dir, file);
+      const filePath = join12(dir, file);
       const name = basename3(file, extname4(file));
       this.plugins.set(name, {
         name,
@@ -5937,8 +7252,8 @@ init_beads();
 // src/core/anti-hallucination.ts
 init_esm_shims();
 init_logger();
-import { readFile as readFile7, writeFile as writeFile8, readdir as readdir7, access as access4, constants as constants4 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile8, writeFile as writeFile9, readdir as readdir7, access as access5, constants as constants5 } from "fs/promises";
+import { join as join13 } from "path";
 var AntiHallucination = class {
   config;
   constructor(config) {
@@ -5948,9 +7263,9 @@ var AntiHallucination = class {
    * Layer 1: Validate task exists before work begins
    */
   async validateTask(taskId) {
-    const beadsDir = join12(this.config.projectPath, ".beads");
+    const beadsDir = join13(this.config.projectPath, ".beads");
     try {
-      await access4(beadsDir, constants4.R_OK);
+      await access5(beadsDir, constants5.R_OK);
     } catch {
       return {
         valid: false,
@@ -5967,7 +7282,7 @@ var AntiHallucination = class {
         };
       }
       for (const file of beadFiles) {
-        const content = await readFile7(join12(beadsDir, file), "utf-8");
+        const content = await readFile8(join13(beadsDir, file), "utf-8");
         if (content.includes("status: in-progress") || content.includes("Status: In Progress")) {
           const id = file.replace(".md", "");
           const descMatch = content.match(/description:\s*(.+)/i) || content.match(/# (.+)/);
@@ -5986,9 +7301,9 @@ var AntiHallucination = class {
         error: "No active task found. Start a task with /create or /implement."
       };
     }
-    const taskFile = join12(beadsDir, `${taskId}.md`);
+    const taskFile = join13(beadsDir, `${taskId}.md`);
     try {
-      const content = await readFile7(taskFile, "utf-8");
+      const content = await readFile8(taskFile, "utf-8");
       const statusMatch = content.match(/status:\s*(\w+)/i);
       const descMatch = content.match(/description:\s*(.+)/i) || content.match(/# (.+)/);
       return {
@@ -6011,9 +7326,9 @@ var AntiHallucination = class {
    */
   async checkSpec() {
     const specFile = this.config.antiHallucination.specFile;
-    const specPath = join12(this.config.projectPath, specFile);
+    const specPath = join13(this.config.projectPath, specFile);
     try {
-      const content = await readFile7(specPath, "utf-8");
+      const content = await readFile8(specPath, "utf-8");
       const constraints = {
         naming: this.extractConstraints(content, "Naming"),
         forbidden: this.extractConstraints(content, "Forbidden"),
@@ -6051,7 +7366,7 @@ var AntiHallucination = class {
    */
   async createReview(changes) {
     const reviewFile = this.config.antiHallucination.reviewFile;
-    const reviewPath = join12(this.config.projectPath, reviewFile);
+    const reviewPath = join13(this.config.projectPath, reviewFile);
     const content = `# Code Review
 
 _Generated: ${(/* @__PURE__ */ new Date()).toISOString()}_
@@ -6080,7 +7395,7 @@ ${changes.inconsistencies?.map((i) => `- \u26A0\uFE0F ${i}`).join("\n") || "- No
 - [ ] Build succeeds
 - [ ] Manual testing completed
 `;
-    await writeFile8(reviewPath, content);
+    await writeFile9(reviewPath, content);
     return reviewPath;
   }
   /**
@@ -6118,7 +7433,7 @@ ${changes.inconsistencies?.map((i) => `- \u26A0\uFE0F ${i}`).join("\n") || "- No
    * Recovery: Check for context loss
    */
   async checkContextLoss() {
-    const handoffsDir = join12(this.config.configPath, "memory", "handoffs");
+    const handoffsDir = join13(this.config.configPath, "memory", "handoffs");
     try {
       const files = await readdir7(handoffsDir);
       const handoffs = files.filter((f) => f.endsWith(".md")).sort().reverse();
@@ -6136,9 +7451,9 @@ ${changes.inconsistencies?.map((i) => `- \u26A0\uFE0F ${i}`).join("\n") || "- No
    * Initialize spec.md template
    */
   async initSpec() {
-    const specPath = join12(this.config.projectPath, this.config.antiHallucination.specFile);
+    const specPath = join13(this.config.projectPath, this.config.antiHallucination.specFile);
     try {
-      await access4(specPath, constants4.R_OK);
+      await access5(specPath, constants5.R_OK);
       logger.info("spec.md already exists");
       return;
     } catch {
@@ -6174,7 +7489,7 @@ Describe your project architecture here.
 
 List approved dependencies here.
 `;
-    await writeFile8(specPath, template);
+    await writeFile9(specPath, template);
     logger.success("Created spec.md template");
   }
   /**
@@ -6243,9 +7558,9 @@ async function getLatestVersion(packageName) {
 // src/utils/update-cache.ts
 init_esm_shims();
 init_paths();
-import { readFile as readFile8, writeFile as writeFile9, mkdir as mkdir8 } from "fs/promises";
+import { readFile as readFile9, writeFile as writeFile10, mkdir as mkdir9 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 var CACHE_FILE = ".update-cache.json";
 var DEFAULT_CACHE = {
   lastCheckTime: 0,
@@ -6254,7 +7569,7 @@ var DEFAULT_CACHE = {
 };
 function getCachePath() {
   const configDir = paths.globalConfig();
-  return join13(configDir, CACHE_FILE);
+  return join14(configDir, CACHE_FILE);
 }
 async function readCache() {
   try {
@@ -6262,7 +7577,7 @@ async function readCache() {
     if (!existsSync5(cachePath)) {
       return DEFAULT_CACHE;
     }
-    const content = await readFile8(cachePath, "utf-8");
+    const content = await readFile9(cachePath, "utf-8");
     const data = JSON.parse(content);
     return { ...DEFAULT_CACHE, ...data };
   } catch {
@@ -6274,9 +7589,9 @@ async function writeCache(data) {
     const cachePath = getCachePath();
     const configDir = paths.globalConfig();
     if (!existsSync5(configDir)) {
-      await mkdir8(configDir, { recursive: true });
+      await mkdir9(configDir, { recursive: true });
     }
-    await writeFile9(cachePath, JSON.stringify(data, null, 2), "utf-8");
+    await writeFile10(cachePath, JSON.stringify(data, null, 2), "utf-8");
   } catch {
   }
 }
@@ -6315,16 +7630,16 @@ async function incrementError(error) {
 init_esm_shims();
 init_paths();
 import { spawn } from "child_process";
-import { writeFile as writeFile10, mkdir as mkdir9 } from "fs/promises";
-import { join as join14 } from "path";
+import { writeFile as writeFile11, mkdir as mkdir10 } from "fs/promises";
+import { join as join15 } from "path";
 async function spawnUpdateProcess(targetVersion) {
   try {
     const configDir = paths.globalConfig();
-    const logsDir = join14(configDir, "logs");
-    await mkdir9(logsDir, { recursive: true });
+    const logsDir = join15(configDir, "logs");
+    await mkdir10(logsDir, { recursive: true });
     const scriptContent = generateUpdateScript(targetVersion, logsDir);
-    const scriptPath = join14(configDir, "update-script.js");
-    await writeFile10(scriptPath, scriptContent, "utf-8");
+    const scriptPath = join15(configDir, "update-script.js");
+    await writeFile11(scriptPath, scriptContent, "utf-8");
     const child = spawn(process.execPath, [scriptPath], {
       detached: true,
       stdio: "ignore",
@@ -6492,6 +7807,7 @@ export {
   MemoryManager,
   PluginSystem,
   SkillEngine,
+  ToolConfigManager,
   ToolRegistry,
   getVersion as VERSION,
   checkForUpdatesAsync,