ccjk 9.6.1 → 9.8.0

package/dist/index.mjs

@@ -1,17 +1,10 @@
-import * as fs from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import * as path from 'node:path';
-import { gzipSync, gunzipSync } from 'node:zlib';
-import { EventEmitter } from 'node:events';
-import chokidar from 'chokidar';
-import process__default from 'node:process';
-import ansis from 'ansis';
-import inquirer from 'inquirer';
 import { exec, execSync, spawn } from 'node:child_process';
 import { promises, existsSync, readdirSync, readFileSync, statSync, createReadStream } from 'node:fs';
 import * as os from 'node:os';
 import { homedir } from 'node:os';
+import * as path from 'node:path';
 import { promisify } from 'node:util';
+import ansis from 'ansis';
 import { version } from './chunks/package.mjs';
 import { join as join$1 } from 'pathe';
 export { c as config } from './chunks/config.mjs';
@@ -21,2716 +14,18 @@ import { Transform } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import 'node:url';
 import 'dayjs';
+import 'inquirer';
 import './chunks/constants.mjs';
 import './chunks/index.mjs';
+import 'node:process';
 import 'i18next';
-import 'i18next-fs-backend';
-import './chunks/claude-config.mjs';
-import './chunks/json-config.mjs';
-import './chunks/fs-operations.mjs';
-import 'tinyexec';
-
-class MemoryCache {
-  cache;
-  head = null;
-  tail = null;
-  maxSize;
-  ttl;
-  hits = 0;
-  misses = 0;
-  constructor(maxSize = 1e3) {
-    this.cache = /* @__PURE__ */ new Map();
-    this.maxSize = maxSize;
-    this.ttl = 1e3 * 60 * 30;
-  }
-  /**
-   * Get entry from cache
-   */
-  get(key) {
-    const node = this.cache.get(key);
-    if (!node) {
-      this.misses++;
-      return void 0;
-    }
-    if (Date.now() - node.timestamp > this.ttl) {
-      this.delete(key);
-      this.misses++;
-      return void 0;
-    }
-    this.moveToFront(node);
-    this.hits++;
-    return node.value;
-  }
-  /**
-   * Set entry in cache
-   */
-  set(key, entry) {
-    const existing = this.cache.get(key);
-    if (existing) {
-      existing.value = entry;
-      existing.timestamp = Date.now();
-      this.moveToFront(existing);
-      return;
-    }
-    const node = {
-      key,
-      value: entry,
-      timestamp: Date.now(),
-      prev: null,
-      next: null
-    };
-    this.cache.set(key, node);
-    this.addToFront(node);
-    if (this.cache.size > this.maxSize) {
-      this.evictLRU();
-    }
-  }
-  /**
-   * Check if key exists
-   */
-  has(key) {
-    const node = this.cache.get(key);
-    if (!node) {
-      return false;
-    }
-    if (Date.now() - node.timestamp > this.ttl) {
-      this.delete(key);
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Delete entry from cache
-   */
-  delete(key) {
-    const node = this.cache.get(key);
-    if (!node) {
-      return false;
-    }
-    this.removeNode(node);
-    return this.cache.delete(key);
-  }
-  /**
-   * Clear all entries
-   */
-  clear() {
-    this.cache.clear();
-    this.head = null;
-    this.tail = null;
-    this.hits = 0;
-    this.misses = 0;
-  }
-  /**
-   * Get cache statistics
-   */
-  getStats() {
-    const total = this.hits + this.misses;
-    const hitRate = total > 0 ? this.hits / total : 0;
-    return {
-      hits: this.hits,
-      misses: this.misses,
-      size: this.cache.size,
-      hitRate
-    };
-  }
-  /**
-   * Get cache size
-   */
-  getSize() {
-    return this.cache.size;
-  }
-  /**
-   * Check if cache is empty
-   */
-  isEmpty() {
-    return this.cache.size === 0;
-  }
-  /**
-   * Get all keys
-   */
-  keys() {
-    return Array.from(this.cache.keys());
-  }
-  /**
-   * Get all values
-   */
-  values() {
-    return Array.from(this.cache.values()).map((node) => node.value);
-  }
-  /**
-   * Dump cache contents (for debugging)
-   */
-  dump() {
-    const map = /* @__PURE__ */ new Map();
-    const entries = Array.from(this.cache.entries());
-    for (const [key, node] of entries) {
-      map.set(key, node.value);
-    }
-    return map;
-  }
-  /**
-   * Load multiple entries into cache
-   */
-  loadMany(entries) {
-    for (const [key, entry] of entries) {
-      this.set(key, entry);
-    }
-  }
-  /**
-   * Delete multiple entries
-   */
-  deleteMany(keys) {
-    let deleted = 0;
-    for (const key of keys) {
-      if (this.cache.delete(key)) {
-        deleted++;
-      }
-    }
-    return deleted;
-  }
-  /**
-   * Reset statistics
-   */
-  resetStats() {
-    this.hits = 0;
-    this.misses = 0;
-  }
-  /**
-   * Get estimated memory usage
-   */
-  getEstimatedSize() {
-    let size = 0;
-    const entries = Array.from(this.cache.entries());
-    for (const [key, node] of entries) {
-      size += key.length * 2;
-      size += JSON.stringify(node.value).length * 2;
-    }
-    return size;
-  }
-  /**
-   * Prune cache (remove expired entries)
-   */
-  prune() {
-  }
-  /**
-   * Set cache size limit
-   */
-  setMaxSize(maxSize) {
-    this.maxSize = maxSize;
-    while (this.cache.size > this.maxSize) {
-      this.evictLRU();
-    }
-  }
-  /**
-   * Get cache configuration
-   */
-  getConfig() {
-    return {
-      maxSize: this.maxSize,
-      ttl: this.ttl
-    };
-  }
-  /**
-   * Move node to front of list
-   */
-  moveToFront(node) {
-    if (node === this.head) {
-      return;
-    }
-    this.removeNode(node);
-    this.addToFront(node);
-  }
-  /**
-   * Add node to front of list
-   */
-  addToFront(node) {
-    node.next = this.head;
-    node.prev = null;
-    if (this.head) {
-      this.head.prev = node;
-    }
-    this.head = node;
-    if (!this.tail) {
-      this.tail = node;
-    }
-  }
-  /**
-   * Remove node from list
-   */
-  removeNode(node) {
-    if (node.prev) {
-      node.prev.next = node.next;
-    } else {
-      this.head = node.next;
-    }
-    if (node.next) {
-      node.next.prev = node.prev;
-    } else {
-      this.tail = node.prev;
-    }
-  }
-  /**
-   * Evict least recently used entry
-   */
-  evictLRU() {
-    if (!this.tail) {
-      return;
-    }
-    this.cache.delete(this.tail.key);
-    this.removeNode(this.tail);
-  }
-}
-let globalCache = null;
-function getGlobalCache(maxSize = 1e3) {
-  if (!globalCache) {
-    globalCache = new MemoryCache(maxSize);
-  }
-  return globalCache;
-}
-
-class LevelDBStorage {
-  dbPath;
-  compressionEnabled;
-  cache;
-  initialized = false;
-  constructor(dbPath, compressionEnabled = true) {
-    this.dbPath = dbPath;
-    this.compressionEnabled = compressionEnabled;
-    this.cache = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Initialize storage
-   */
-  async initialize() {
-    if (this.initialized) {
-      return;
-    }
-    try {
-      await fs.mkdir(this.dbPath, { recursive: true });
-      await this.loadFromDisk();
-      this.initialized = true;
-    } catch (error) {
-      console.error("Failed to initialize storage:", error);
-    }
-  }
-  /**
-   * Load data from disk
-   */
-  async loadFromDisk() {
-    try {
-      const files = await fs.readdir(this.dbPath);
-      for (const file of files) {
-        if (file.endsWith(".json")) {
-          const filePath = path.join(this.dbPath, file);
-          const content = await fs.readFile(filePath, "utf-8");
-          const entry = JSON.parse(content);
-          this.cache.set(entry.key, entry);
-        }
-      }
-    } catch (_error) {
-    }
-  }
-  /**
-   * Get file path for a key
-   */
-  getFilePath(key) {
-    const hash = createHash("md5").update(key).digest("hex");
-    return path.join(this.dbPath, `${hash}.json`);
-  }
-  /**
-   * Store a cache entry
-   */
-  async put(entry) {
-    await this.initialize();
-    const dataToStore = { ...entry };
-    if (this.compressionEnabled && shouldCompress(entry.type)) {
-      dataToStore.data = compressData(entry.data);
-      dataToStore.compressed = true;
-    }
-    this.cache.set(entry.key, dataToStore);
-    const filePath = this.getFilePath(entry.key);
-    await fs.writeFile(filePath, JSON.stringify(dataToStore, null, 2), "utf-8");
-  }
-  /**
-   * Retrieve a cache entry
-   */
-  async get(key) {
-    await this.initialize();
-    const entry = this.cache.get(key);
-    if (!entry) {
-      return null;
-    }
-    if (entry.compressed) {
-      const decompressed = { ...entry };
-      decompressed.data = decompressData(entry.data);
-      decompressed.compressed = false;
-      return decompressed;
-    }
-    return entry;
-  }
-  /**
-   * Delete a cache entry
-   */
-  async del(key) {
-    await this.initialize();
-    this.cache.delete(key);
-    const filePath = this.getFilePath(key);
-    try {
-      await fs.unlink(filePath);
-    } catch (_error) {
-    }
-  }
-  /**
-   * Check if key exists
-   */
-  async has(key) {
-    await this.initialize();
-    return this.cache.has(key);
-  }
-  /**
-   * Get all entries matching a prefix
-   */
-  async getByPrefix(prefix) {
-    await this.initialize();
-    const entries = [];
-    const cacheEntries = Array.from(this.cache.entries());
-    for (const [key, entry] of cacheEntries) {
-      if (key.startsWith(prefix)) {
-        if (entry.compressed) {
-          const decompressed = { ...entry };
-          decompressed.data = decompressData(entry.data);
-          decompressed.compressed = false;
-          entries.push(decompressed);
-        } else {
-          entries.push(entry);
-        }
-      }
-    }
-    return entries;
-  }
-  /**
-   * Batch write multiple entries
-   */
-  async batch(entries) {
-    await this.initialize();
-    await Promise.all(entries.map((entry) => this.put(entry)));
-  }
-  /**
-   * Clear all entries
-   */
-  async clear() {
-    await this.initialize();
-    this.cache.clear();
-    try {
-      const files = await fs.readdir(this.dbPath);
-      await Promise.all(
-        files.filter((file) => file.endsWith(".json")).map((file) => fs.unlink(path.join(this.dbPath, file)))
-      );
-    } catch (_error) {
-    }
-  }
-  /**
-   * Close database connection
-   */
-  async close() {
-    this.initialized = false;
-  }
-  /**
-   * Get approximate database size
-   */
-  async getSize() {
-    await this.initialize();
-    return this.cache.size;
-  }
-  /**
-   * Compact database
-   */
-  async compact() {
-  }
-  /**
-   * Generate checksum for data
-   */
-  generateChecksum(data) {
-    const json = JSON.stringify(data);
-    return createHash("sha256").update(json).digest("hex");
-  }
-  /**
-   * Verify checksum
-   */
-  verifyChecksum(entry) {
-    const calculated = this.generateChecksum(entry.data);
-    return calculated === entry.checksum;
-  }
-}
-function shouldCompress(type) {
-  return type === "ast" || type === "call-graph";
-}
-function compressData(data) {
-  const json = JSON.stringify(data);
-  const compressed = gzipSync(Buffer.from(json, "utf-8"));
-  return compressed.toString("base64");
-}
-function decompressData(compressedData) {
-  const buffer = Buffer.from(compressedData, "base64");
-  const decompressed = gunzipSync(buffer);
-  return JSON.parse(decompressed.toString("utf-8"));
-}
-
-class MultiLevelIndex {
-  l1;
-  l2;
-  config;
-  constructor(dbPath, config) {
-    this.l1 = getGlobalCache(config?.l1?.maxSize || 1e3);
-    this.l2 = new LevelDBStorage(dbPath);
-    this.config = {
-      l1: {
-        name: "L1-Memory",
-        maxSize: config?.l1?.maxSize || 1e3,
-        ttl: config?.l1?.ttl || 1e3 * 60 * 30
-        // 30 minutes
-      },
-      l2: {
-        name: "L2-Disk",
-        maxSize: config?.l2?.maxSize || 1e5,
-        ttl: config?.l2?.ttl || 1e3 * 60 * 60 * 24 * 7
-        // 7 days
-      }
-    };
-  }
-  /**
-   * Get entry from cache (L1 first, then L2)
-   */
-  async get(key) {
-    const l1Entry = this.l1.get(key);
-    if (l1Entry) {
-      l1Entry.accessCount++;
-      l1Entry.lastAccess = Date.now();
-      l1Entry.level = 1;
-      return l1Entry;
-    }
-    const l2Entry = await this.l2.get(key);
-    if (l2Entry) {
-      if (l2Entry.accessCount > 5) {
-        await this.promoteToL1(key, l2Entry);
-      }
-      l2Entry.accessCount++;
-      l2Entry.lastAccess = Date.now();
-      l2Entry.level = 2;
-      return l2Entry;
-    }
-    return null;
-  }
-  /**
-   * Set entry in cache (writes to both levels)
-   */
-  async set(key, entry) {
-    const indexedEntry = {
-      ...entry,
-      accessCount: 0,
-      lastAccess: Date.now(),
-      level: 1
-    };
-    this.l1.set(key, indexedEntry);
-    await this.l2.put(indexedEntry);
-  }
-  /**
-   * Delete entry from both levels
-   */
-  async delete(key) {
-    this.l1.delete(key);
-    await this.l2.del(key);
-  }
-  /**
-   * Check if key exists
-   */
-  async has(key) {
-    if (this.l1.has(key)) {
-      return true;
-    }
-    return await this.l2.has(key);
-  }
-  /**
-   * Get all entries for a file path
-   */
-  async getByFilePath(filePath) {
-    const prefix = `${filePath}|`;
-    const l1Entries = [];
-    for (const key of this.l1.keys()) {
-      if (key.startsWith(prefix)) {
-        const entry = this.l1.get(key);
-        if (entry) {
-          l1Entries.push(entry);
-        }
-      }
-    }
-    const l2Entries = await this.l2.getByPrefix(prefix);
-    return [...l1Entries, ...l2Entries];
-  }
-  /**
-   * Promote entry to L1 cache
-   */
-  async promoteToL1(key, entry) {
-    entry.level = 1;
-    this.l1.set(key, entry);
-  }
-  /**
-   * Demote entry from L1 to L2
-   */
-  async demoteToL2(key) {
-    const entry = this.l1.get(key);
-    if (entry) {
-      entry.level = 2;
-      await this.l2.put(entry);
-      this.l1.delete(key);
-    }
-  }
-  /**
-   * Get combined statistics
-   */
-  async getStats() {
-    const l1Stats = this.l1.getStats();
-    const l2Size = await this.l2.getSize();
-    const totalHits = l1Stats.hits;
-    const totalMisses = l1Stats.misses;
-    const combinedHitRate = totalHits + totalMisses > 0 ? totalHits / (totalHits + totalMisses) : 0;
-    return {
-      l1: l1Stats,
-      l2: { size: l2Size },
-      combined: {
-        hitRate: combinedHitRate
-      }
-    };
-  }
-  /**
-   * Clear all caches
-   */
-  async clear() {
-    this.l1.clear();
-    await this.l2.clear();
-  }
-  /**
-   * Warm up L1 cache with frequently accessed entries
-   */
-  async warmup(filePath) {
-    const entries = await this.getByFilePath(filePath);
-    entries.sort((a, b) => b.accessCount - a.accessCount).slice(0, 100).forEach(async (entry) => {
-      await this.promoteToL1(`${filePath}|${entry.type}`, entry);
-    });
-  }
-  /**
-   * Evict stale entries from L1
-   */
-  async evictStale() {
-    const keys = this.l1.keys();
-    const now = Date.now();
-    for (const key of keys) {
-      const entry = this.l1.get(key);
-      if (entry && now - entry.lastAccess > this.config.l1.ttl) {
-        await this.demoteToL2(key);
-      }
-    }
-  }
-  /**
-   * Close cache system
-   */
-  async close() {
-    await this.l2.close();
-  }
-  /**
-   * Compact L2 storage
-   */
-  async compact() {
-    await this.l2.compact();
-  }
-  /**
-   * Get cache configuration
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  /**
-   * Update cache configuration
-   */
-  updateConfig(config) {
-    if (config.l1) {
-      this.config.l1 = { ...this.config.l1, ...config.l1 };
-      if (config.l1.maxSize) {
-        this.l1.setMaxSize(config.l1.maxSize);
-      }
-    }
-    if (config.l2) {
-      this.config.l2 = { ...this.config.l2, ...config.l2 };
-    }
-  }
-}
-let globalIndex = null;
-function getGlobalIndex(dbPath = "./actionbook-cache") {
-  if (!globalIndex) {
-    globalIndex = new MultiLevelIndex(dbPath);
-  }
-  return globalIndex;
-}
-async function closeGlobalIndex() {
-  if (globalIndex) {
-    await globalIndex.close();
-    globalIndex = null;
-  }
-}
-
-async function queryAST(filePath, offset) {
-  const index = getGlobalIndex();
-  const key = offset ? `${filePath}|ast|${offset}` : `${filePath}|ast`;
-  const entry = await index.get(key);
-  if (!entry) {
-    return null;
-  }
-  return entry.data;
-}
-async function queryASTAtPosition(filePath, line, column) {
-  const ast = await queryAST(filePath);
-  if (!ast) {
-    return null;
-  }
-  return findNodeAtPosition(ast, line, column);
-}
-function findNodeAtPosition(node, line, column) {
-  const isBefore = line < node.range.start.line || line === node.range.start.line && column < node.range.start.column;
-  const isAfter = line > node.range.end.line || line === node.range.end.line && column > node.range.end.column;
-  if (isBefore || isAfter) {
-    return null;
-  }
-  for (const child of node.children) {
-    const found = findNodeAtPosition(child, line, column);
-    if (found) {
-      return found;
-    }
-  }
-  return node;
-}
-async function queryASTByType(filePath, nodeType) {
-  const ast = await queryAST(filePath);
-  if (!ast) {
-    return [];
-  }
-  return findNodesByType(ast, nodeType);
-}
-function findNodesByType(node, nodeType) {
-  const results = [];
-  if (node.type === nodeType) {
-    results.push(node);
-  }
-  for (const child of node.children) {
-    results.push(...findNodesByType(child, nodeType));
-  }
-  return results;
-}
-async function queryASTByName(filePath, name) {
-  const ast = await queryAST(filePath);
-  if (!ast) {
-    return [];
-  }
-  return findNodesByName(ast, name);
-}
-function findNodesByName(node, name) {
-  const results = [];
-  if (node.name === name) {
-    results.push(node);
-  }
-  for (const child of node.children) {
-    results.push(...findNodesByName(child, name));
-  }
-  return results;
-}
-
-const astQueries = {
-  __proto__: null,
-  queryAST: queryAST,
-  queryASTAtPosition: queryASTAtPosition,
-  queryASTByName: queryASTByName,
-  queryASTByType: queryASTByType
-};
-
-async function queryCallGraph(filePath) {
-  const index = getGlobalIndex();
-  const key = `${filePath}|call-graph`;
-  const entry = await index.get(key);
-  if (!entry) {
-    return null;
-  }
-  return entry.data;
-}
-async function queryEntryPoints(filePath) {
-  const callGraph = await queryCallGraph(filePath);
-  if (!callGraph) {
-    return [];
-  }
-  const entryNodes = callGraph.nodes.filter(
-    (node) => callGraph.entryPoints.includes(node.id)
-  );
-  return entryNodes;
-}
-async function queryFunction(filePath, name) {
-  const callGraph = await queryCallGraph(filePath);
-  if (!callGraph) {
-    return null;
-  }
-  return callGraph.nodes.find((node) => node.name === name) || null;
-}
-async function queryCallers(filePath, functionName) {
-  const callGraph = await queryCallGraph(filePath);
-  if (!callGraph) {
-    return [];
-  }
-  const targetNode = callGraph.nodes.find((n) => n.name === functionName);
-  if (!targetNode) {
-    return [];
-  }
-  return callGraph.edges.filter((edge) => edge.to === targetNode.id);
-}
-async function queryCallees(filePath, functionName) {
-  const callGraph = await queryCallGraph(filePath);
-  if (!callGraph) {
-    return [];
-  }
-  const sourceNode = callGraph.nodes.find((n) => n.name === functionName);
-  if (!sourceNode) {
-    return [];
-  }
-  return callGraph.edges.filter((edge) => edge.from === sourceNode.id);
-}
-async function queryCallChain(filePath, from, to) {
-  const callGraph = await queryCallGraph(filePath);
-  if (!callGraph) {
-    return [];
-  }
-  const fromNode = callGraph.nodes.find((n) => n.name === from);
-  const toNode = callGraph.nodes.find((n) => n.name === to);
-  if (!fromNode || !toNode) {
-    return [];
-  }
-  const queue = [
-    { node: fromNode.id, path: [fromNode.id] }
-  ];
-  const visited = /* @__PURE__ */ new Set([fromNode.id]);
-  while (queue.length > 0) {
-    const { node, path } = queue.shift();
-    if (node === toNode.id) {
-      return path.map((id) => callGraph.nodes.find((n) => n.id === id).name);
-    }
-    const edges = callGraph.edges.filter((e) => e.from === node);
-    for (const edge of edges) {
-      if (!visited.has(edge.to)) {
-        visited.add(edge.to);
-        queue.push({ node: edge.to, path: [...path, edge.to] });
-      }
-    }
-  }
-  return [];
-}
-async function queryRecursiveFunctions(filePath) {
-  const callGraph = await queryCallGraph(filePath);
-  if (!callGraph) {
-    return [];
-  }
-  const recursiveNodes = [];
-  for (const node of callGraph.nodes) {
-    const edges = callGraph.edges.filter((e) => e.from === node.id);
-    if (edges.some((e) => e.to === node.id)) {
-      recursiveNodes.push(node);
-    }
-  }
-  return recursiveNodes;
-}
-async function queryCallFrequency(filePath) {
-  const callGraph = await queryCallGraph(filePath);
-  if (!callGraph) {
-    return /* @__PURE__ */ new Map();
-  }
-  const frequency = /* @__PURE__ */ new Map();
-  for (const edge of callGraph.edges) {
-    const toNode = callGraph.nodes.find((n) => n.id === edge.to);
-    if (toNode) {
-      const currentCount = frequency.get(toNode.name) || 0;
-      frequency.set(toNode.name, currentCount + edge.callCount);
-    }
-  }
-  return frequency;
-}
-async function queryMostCalledFunctions(filePath, limit = 10) {
-  const frequency = await queryCallFrequency(filePath);
-  return Array.from(frequency.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([name, count]) => ({ name, count }));
-}
-async function queryFunctionDepth(filePath, functionName) {
-  const callGraph = await queryCallGraph(filePath);
-  if (!callGraph) {
-    return 0;
-  }
-  const targetNode = callGraph.nodes.find((n) => n.name === functionName);
-  if (!targetNode) {
-    return 0;
-  }
-  const queue = callGraph.entryPoints.map((id) => ({
-    node: id,
-    depth: 0
-  }));
-  const visited = new Set(callGraph.entryPoints);
-  while (queue.length > 0) {
-    const { node, depth } = queue.shift();
-    if (node === targetNode.id) {
-      return depth;
-    }
-    const edges = callGraph.edges.filter((e) => e.from === node);
-    for (const edge of edges) {
-      if (!visited.has(edge.to)) {
-        visited.add(edge.to);
-        queue.push({ node: edge.to, depth: depth + 1 });
-      }
-    }
-  }
-  return 0;
-}
-async function queryDynamicCalls(filePath) {
-  const callGraph = await queryCallGraph(filePath);
-  if (!callGraph) {
-    return [];
-  }
-  return callGraph.edges.filter((edge) => edge.isDynamic);
-}
-async function queryAsyncFunctions(filePath) {
-  const callGraph = await queryCallGraph(filePath);
-  if (!callGraph) {
-    return [];
-  }
-  return callGraph.nodes.filter((node) => node.isAsync);
-}
-
-const callGraphQueries = {
-  __proto__: null,
-  queryAsyncFunctions: queryAsyncFunctions,
-  queryCallChain: queryCallChain,
-  queryCallFrequency: queryCallFrequency,
-  queryCallGraph: queryCallGraph,
-  queryCallees: queryCallees,
-  queryCallers: queryCallers,
-  queryDynamicCalls: queryDynamicCalls,
-  queryEntryPoints: queryEntryPoints,
-  queryFunction: queryFunction,
-  queryFunctionDepth: queryFunctionDepth,
-  queryMostCalledFunctions: queryMostCalledFunctions,
-  queryRecursiveFunctions: queryRecursiveFunctions
-};
-
-async function querySymbols(filePath) {
-  const index = getGlobalIndex();
-  const key = `${filePath}|symbol`;
-  const entry = await index.get(key);
-  if (!entry) {
-    return null;
-  }
-  return entry.data;
-}
-async function queryExports(filePath) {
-  const symbolTable = await querySymbols(filePath);
-  if (!symbolTable) {
-    return [];
-  }
-  return symbolTable.exports;
-}
-async function queryImports(filePath) {
-  const symbolTable = await querySymbols(filePath);
-  if (!symbolTable) {
-    return [];
-  }
-  return symbolTable.imports;
-}
-async function querySymbolByName(filePath, name) {
-  const symbolTable = await querySymbols(filePath);
-  if (!symbolTable) {
-    return null;
-  }
-  return symbolTable.symbols.find((s) => s.name === name) || null;
-}
-async function querySymbolsByKind(filePath, kind) {
-  const symbolTable = await querySymbols(filePath);
-  if (!symbolTable) {
-    return [];
-  }
-  return symbolTable.symbols.filter((s) => s.kind === kind);
-}
-async function querySymbolAtPosition(filePath, line, column) {
-  const symbolTable = await querySymbols(filePath);
-  if (!symbolTable) {
-    return null;
-  }
-  return symbolTable.symbols.find((symbol) => {
-    const isBefore = line < symbol.range.start.line || line === symbol.range.start.line && column < symbol.range.start.column;
-    const isAfter = line > symbol.range.end.line || line === symbol.range.end.line && column > symbol.range.end.column;
-    return !isBefore && !isAfter;
-  }) || null;
-}
-async function queryFunctions(filePath) {
-  return querySymbolsByKind(filePath, "function");
-}
-async function queryClasses(filePath) {
-  return querySymbolsByKind(filePath, "class");
-}
-async function queryInterfaces(filePath) {
-  return querySymbolsByKind(filePath, "interface");
-}
-async function queryTypes(filePath) {
-  return querySymbolsByKind(filePath, "type");
-}
-async function queryVariables(filePath) {
-  return querySymbolsByKind(filePath, "variable");
-}
-async function queryScopeAtPosition(filePath, line, column) {
-  const symbolTable = await querySymbols(filePath);
-  if (!symbolTable) {
-    return null;
-  }
-  for (const scope of symbolTable.scopes) {
-    const isBefore = line < scope.range.start.line || line === scope.range.start.line && column < scope.range.start.column;
-    const isAfter = line > scope.range.end.line || line === scope.range.end.line && column > scope.range.end.column;
-    if (!isBefore && !isAfter) {
-      return scope.id;
-    }
-  }
-  return null;
-}
-async function querySymbolsInScope(filePath, scopeId) {
-  const symbolTable = await querySymbols(filePath);
-  if (!symbolTable) {
-    return [];
-  }
-  const scope = symbolTable.scopes.find((s) => s.id === scopeId);
-  if (!scope) {
-    return [];
-  }
-  return symbolTable.symbols.filter((s) => scope.symbols.includes(s.id));
-}
-
-const symbolQueries = {
-  __proto__: null,
-  queryClasses: queryClasses,
-  queryExports: queryExports,
-  queryFunctions: queryFunctions,
-  queryImports: queryImports,
-  queryInterfaces: queryInterfaces,
-  queryScopeAtPosition: queryScopeAtPosition,
-  querySymbolAtPosition: querySymbolAtPosition,
-  querySymbolByName: querySymbolByName,
-  querySymbols: querySymbols,
-  querySymbolsByKind: querySymbolsByKind,
-  querySymbolsInScope: querySymbolsInScope,
-  queryTypes: queryTypes,
-  queryVariables: queryVariables
-};
-
-class QueryAPIRouter {
-  /**
-   * Query AST for a file
-   */
-  async queryAST(filePath, offset) {
-    return queryAST(filePath, offset);
-  }
-  /**
-   * Query symbol table for a file
-   */
-  async querySymbols(filePath) {
-    return querySymbols(filePath);
-  }
-  /**
-   * Query call graph for a file
-   */
-  async queryCallGraph(filePath) {
-    return queryCallGraph(filePath);
-  }
-  /**
-   * Query complexity metrics for a file
-   */
-  async queryComplexity(filePath) {
-    const index = getGlobalIndex();
-    const key = `${filePath}|complexity`;
-    const entry = await index.get(key);
-    if (!entry) {
-      return null;
-    }
-    return entry.data;
-  }
-  /**
-   * Query patterns for a file
-   */
-  async queryPatterns(filePath) {
-    const index = getGlobalIndex();
-    const key = `${filePath}|patterns`;
-    const entry = await index.get(key);
-    if (!entry) {
-      return null;
-    }
-    return entry.data;
-  }
-  /**
-   * Query all precomputed data for a file
-   */
-  async queryAll(filePath) {
-    const index = getGlobalIndex();
-    const entries = await index.getByFilePath(filePath);
-    const result = {
-      ast: null,
-      symbols: null,
-      callGraph: null,
-      complexity: null,
-      patterns: null
-    };
-    for (const entry of entries) {
-      switch (entry.type) {
-        case "ast":
-          result.ast = entry.data;
-          break;
-        case "symbol":
-          result.symbols = entry.data;
-          break;
-        case "call-graph":
-          result.callGraph = entry.data;
-          break;
-        case "complexity":
-          result.complexity = entry.data;
-          break;
-        case "patterns":
-          result.patterns = entry.data;
-          break;
-      }
-    }
-    return result;
-  }
-  /**
-   * Get cache statistics
-   */
-  async getStats() {
-    const index = getGlobalIndex();
-    return index.getStats();
-  }
-  /**
-   * Clear all caches
-   */
-  async clear() {
-    const index = getGlobalIndex();
-    await index.clear();
-  }
-  /**
-   * Warm up cache for a file
-   */
-  async warmup(filePath) {
-    const index = getGlobalIndex();
-    await index.warmup(filePath);
-  }
-}
-let globalQueryAPI = null;
-function getQueryAPI() {
-  if (!globalQueryAPI) {
-    globalQueryAPI = new QueryAPIRouter();
-  }
-  return globalQueryAPI;
-}
-const ast = astQueries;
-const symbols = symbolQueries;
-const callGraph = callGraphQueries;
-
-class DependencyTracker {
-  graph;
-  watchMode = false;
-  constructor() {
-    this.graph = {
-      nodes: /* @__PURE__ */ new Map(),
-      edges: /* @__PURE__ */ new Map()
-    };
-  }
-  /**
-   * Track dependencies from symbol table
-   */
-  trackDependencies(filePath, symbols) {
-    const node = this.getOrCreateNode(filePath);
-    node.dependencies.clear();
-    for (const importDecl of symbols.imports) {
-      const resolvedPath = this.resolveImportPath(filePath, importDecl.module);
-      if (resolvedPath) {
-        node.dependencies.add(resolvedPath);
-        if (!this.graph.edges.has(filePath)) {
-          this.graph.edges.set(filePath, /* @__PURE__ */ new Set());
-        }
-        this.graph.edges.get(filePath).add(resolvedPath);
-        const depNode = this.getOrCreateNode(resolvedPath);
-        depNode.dependents.add(filePath);
-      }
-    }
-    node.lastIndexed = Date.now();
-  }
-  /**
-   * Get dependents of a file (files that import this file)
-   */
-  getDependents(filePath) {
-    const node = this.graph.nodes.get(filePath);
-    return node ? new Set(node.dependents) : /* @__PURE__ */ new Set();
-  }
-  /**
-   * Get dependencies of a file (files this file imports)
-   */
-  getDependencies(filePath) {
-    const node = this.graph.nodes.get(filePath);
-    return node ? new Set(node.dependencies) : /* @__PURE__ */ new Set();
-  }
-  /**
-   * Get transitive dependents (all files that indirectly depend on this file)
-   */
-  getTransitiveDependents(filePath) {
-    const transitive = /* @__PURE__ */ new Set();
-    const queue = [filePath];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      const directDependents = this.getDependents(current);
-      const dependentsArray = Array.from(directDependents);
-      for (const dependent of dependentsArray) {
-        if (!transitive.has(dependent)) {
-          transitive.add(dependent);
-          queue.push(dependent);
-        }
-      }
-    }
-    return transitive;
-  }
-  /**
-   * Get transitive dependencies (all files this file indirectly depends on)
-   */
-  getTransitiveDependencies(filePath) {
-    const transitive = /* @__PURE__ */ new Set();
-    const queue = [filePath];
-    const visited = /* @__PURE__ */ new Set([filePath]);
-    while (queue.length > 0) {
-      const current = queue.shift();
-      const directDeps = this.getDependencies(current);
-      const depsArray = Array.from(directDeps);
-      for (const dep of depsArray) {
-        if (!visited.has(dep)) {
-          visited.add(dep);
-          transitive.add(dep);
-          queue.push(dep);
-        }
-      }
-    }
-    return transitive;
-  }
-  /**
-   * Detect circular dependencies
-   */
-  detectCircularDependencies() {
-    const cycles = [];
-    const visited = /* @__PURE__ */ new Set();
-    const recStack = /* @__PURE__ */ new Set();
-    const path2 = [];
-    const dfs = (node) => {
-      visited.add(node);
-      recStack.add(node);
-      path2.push(node);
-      const neighbors = this.graph.edges.get(node) || /* @__PURE__ */ new Set();
-      const neighborsArray = Array.from(neighbors);
-      for (const neighbor of neighborsArray) {
-        if (!visited.has(neighbor)) {
-          if (dfs(neighbor)) {
-            return true;
-          }
-        } else if (recStack.has(neighbor)) {
-          const cycleStart = path2.indexOf(neighbor);
-          cycles.push([...path2.slice(cycleStart), neighbor]);
-        }
-      }
-      path2.pop();
-      recStack.delete(node);
-      return false;
-    };
-    const nodesArray = Array.from(this.graph.nodes.keys());
-    for (const node of nodesArray) {
-      if (!visited.has(node)) {
-        dfs(node);
-      }
-    }
-    return cycles;
-  }
-  /**
-   * Get files affected by a change (need reindexing)
-   */
-  getAffectedFiles(filePath) {
-    const affected = /* @__PURE__ */ new Set();
-    const dependents = this.getTransitiveDependents(filePath);
-    const dependentsArray = Array.from(dependents);
-    for (const dependent of dependentsArray) {
-      affected.add(dependent);
-    }
-    affected.add(filePath);
-    return affected;
-  }
-  /**
-   * Remove file from graph
-   */
-  removeFile(filePath) {
-    const node = this.graph.nodes.get(filePath);
-    if (node) {
-      const depsArray = Array.from(node.dependencies);
-      for (const dep of depsArray) {
-        const depNode = this.graph.nodes.get(dep);
-        if (depNode) {
-          depNode.dependents.delete(filePath);
-        }
-      }
-      this.graph.nodes.delete(filePath);
-    }
-    this.graph.edges.delete(filePath);
-    const edgesArray = Array.from(this.graph.edges);
-    for (const [_source, targets] of edgesArray) {
-      targets.delete(filePath);
-    }
-  }
-  /**
-   * Clear entire graph
-   */
-  clear() {
-    this.graph.nodes.clear();
-    this.graph.edges.clear();
-  }
-  /**
-   * Get graph statistics
-   */
-  getStats() {
-    let totalDependencies = 0;
-    let totalDependents = 0;
-    const nodesArray = Array.from(this.graph.nodes.values());
-    for (const node of nodesArray) {
-      totalDependencies += node.dependencies.size;
-      totalDependents += node.dependents.size;
-    }
-    const nodeCount = this.graph.nodes.size;
-    const avgDependencies = nodeCount > 0 ? totalDependencies / nodeCount : 0;
-    const avgDependents = nodeCount > 0 ? totalDependents / nodeCount : 0;
-    let edgeCount = 0;
-    const edgesValuesArray = Array.from(this.graph.edges.values());
-    for (const targets of edgesValuesArray) {
-      edgeCount += targets.size;
-    }
-    return {
-      nodeCount,
-      edgeCount,
-      avgDependencies,
-      avgDependents
-    };
-  }
-  /**
-   * Serialize graph to JSON
-   */
-  toJSON() {
-    const serialized = {
-      nodes: Array.from(this.graph.nodes.entries()).map(([path2, node]) => ({
-        path: path2,
-        dependencies: Array.from(node.dependencies),
-        dependents: Array.from(node.dependents),
-        lastIndexed: node.lastIndexed
-      })),
-      edges: Array.from(this.graph.edges.entries()).map(([source, targets]) => ({
-        source,
-        targets: Array.from(targets)
-      }))
-    };
-    return serialized;
-  }
-  /**
-   * Load graph from JSON
-   */
-  fromJSON(json) {
-    this.clear();
-    for (const nodeData of json.nodes || []) {
-      const node = {
-        filePath: nodeData.path,
-        dependencies: new Set(nodeData.dependencies),
-        dependents: new Set(nodeData.dependents),
-        lastIndexed: nodeData.lastIndexed
-      };
-      this.graph.nodes.set(nodeData.path, node);
-    }
-    for (const edgeData of json.edges || []) {
-      this.graph.edges.set(edgeData.source, new Set(edgeData.targets));
-    }
-  }
-  /**
-   * Resolve import path to absolute file path
-   */
-  resolveImportPath(fromFile, importPath) {
-    if (importPath.startsWith(".")) {
-      const fromDir = path.dirname(fromFile);
-      const resolved = path.resolve(fromDir, importPath);
-      if (!path.extname(resolved)) {
-        return `${resolved}.ts`;
-      }
-      return resolved;
-    }
-    return null;
-  }
-  /**
-   * Get or create node in graph
-   */
-  getOrCreateNode(filePath) {
-    let node = this.graph.nodes.get(filePath);
-    if (!node) {
-      node = {
-        filePath,
-        dependencies: /* @__PURE__ */ new Set(),
-        dependents: /* @__PURE__ */ new Set(),
-        lastIndexed: 0
-      };
-      this.graph.nodes.set(filePath, node);
-    }
-    return node;
-  }
-  /**
-   * Enable watch mode
-   */
-  enableWatchMode() {
-    this.watchMode = true;
-  }
-  /**
-   * Disable watch mode
-   */
-  disableWatchMode() {
-    this.watchMode = false;
-  }
-  /**
-   * Check if watch mode is enabled
-   */
-  isWatchModeEnabled() {
-    return this.watchMode;
-  }
-}
-let globalTracker = null;
-function getGlobalTracker() {
-  if (!globalTracker) {
-    globalTracker = new DependencyTracker();
-  }
-  return globalTracker;
-}
-function resetGlobalTracker() {
-  globalTracker = null;
-}
-
-async function parseAST(filePath) {
-  try {
-    const source = await fs.readFile(filePath, "utf-8");
-    return parseSourceToAST(source, filePath);
-  } catch (error) {
-    console.error(`Failed to parse AST for ${filePath}:`, error);
-    return null;
-  }
-}
-function parseSourceToAST(source, filePath) {
-  try {
-    const parser = require("@typescript-eslint/parser");
-    const estree = parser.parse(source, {
-      sourceType: "module",
-      ecmaVersion: "latest",
-      project: "./tsconfig.json",
-      filePath
-    });
-    return convertESTreeToASTNode(estree);
-  } catch (error) {
-    console.error(`Failed to parse source for ${filePath}:`, error);
-    return null;
-  }
-}
-function convertESTreeToASTNode(node, _parent) {
-  const astNode = {
-    type: node.type,
-    name: getNodeName(node),
-    range: {
-      start: {
-        line: node.loc?.start.line || 0,
-        column: node.loc?.start.column || 0
-      },
-      end: {
-        line: node.loc?.end.line || 0,
-        column: node.loc?.end.column || 0
-      }
-    },
-    children: [],
-    metadata: extractNodeMetadata(node)
-  };
-  for (const key of Object.keys(node)) {
-    if (key === "parent" || key === "loc" || key === "range")
-      continue;
-    const child = node[key];
-    if (Array.isArray(child)) {
-      for (const item of child) {
-        if (item && typeof item === "object" && item.type) {
-          astNode.children.push(convertESTreeToASTNode(item));
-        }
-      }
-    } else if (child && typeof child === "object" && child.type) {
-      astNode.children.push(convertESTreeToASTNode(child));
-    }
-  }
-  return astNode;
-}
-function getNodeName(node) {
-  if (node.id?.name)
-    return node.id.name;
-  if (node.key?.name)
-    return node.key.name;
-  if (node.name)
-    return node.name;
-  if (node.type === "Identifier")
-    return node.name;
-  return void 0;
-}
-function extractNodeMetadata(node) {
-  const metadata = {};
-  if (node.declarations)
-    metadata.declarationCount = node.declarations.length;
-  if (node.params)
-    metadata.paramCount = node.params.length;
-  if (node.async)
-    metadata.isAsync = true;
-  if (node.generator)
-    metadata.isGenerator = true;
-  if (node.kind)
-    metadata.kind = node.kind;
-  if (node.method)
-    metadata.isMethod = true;
-  return metadata;
-}
-
-function generateCallGraph(filePath, ast) {
-  const callGraph = {
-    filePath,
-    nodes: [],
-    edges: [],
-    entryPoints: []
-  };
-  const functionStack = [];
-  const nodeIdCounter = 0;
-  extractFunctions(ast, callGraph, functionStack, nodeIdCounter);
-  functionStack.length = 0;
-  extractCallEdges(ast, callGraph, functionStack);
-  const calledFunctions = new Set(callGraph.edges.map((e) => e.to));
-  callGraph.entryPoints = callGraph.nodes.filter((node) => !calledFunctions.has(node.id)).map((node) => node.id);
-  return callGraph;
-}
-function extractFunctions(node, callGraph, functionStack, nodeIdCounter) {
-  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
-    const callNode = {
-      id: `func-${nodeIdCounter++}`,
-      name: node.name || "<anonymous>",
-      kind: node.type.includes("Arrow") ? "arrow" : node.type === "FunctionExpression" ? "function" : "function",
-      range: node.range,
-      isAsync: node.metadata.isAsync || false,
-      isGenerator: node.metadata.isGenerator || false
-    };
-    callGraph.nodes.push(callNode);
-    functionStack.push(callNode.id);
-  }
-  for (const child of node.children) {
-    nodeIdCounter = extractFunctions(child, callGraph, functionStack, nodeIdCounter);
-  }
-  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
-    functionStack.pop();
-  }
-  return nodeIdCounter;
-}
-function extractCallEdges(node, callGraph, functionStack) {
-  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
-    const funcNode = callGraph.nodes.find((n) => n.range === node.range);
-    if (funcNode) {
-      functionStack.push(funcNode.id);
-    }
-  }
-  if (node.type === "CallExpression" || node.type === "NewExpression") {
-    const callee = node.children.find((c) => c.type === "Identifier" || c.type === "MemberExpression");
-    if (callee && functionStack.length > 0) {
-      const callerId = functionStack[functionStack.length - 1];
-      const calleeName = callee.name || getMemberExpressionName(callee);
-      const calleeNode = callGraph.nodes.find((n) => n.name === calleeName);
-      if (calleeNode) {
-        const existingEdge = callGraph.edges.find(
-          (e) => e.from === callerId && e.to === calleeNode.id && e.range.start.line === node.range.start.line
-        );
-        if (existingEdge) {
-          existingEdge.callCount++;
-        } else {
-          const edge = {
-            from: callerId,
-            to: calleeNode.id,
-            range: node.range,
-            isDynamic: node.type === "NewExpression" || callee.type === "MemberExpression",
-            callCount: 1
-          };
-          callGraph.edges.push(edge);
-        }
-      }
-    }
-  }
-  for (const child of node.children) {
-    extractCallEdges(child, callGraph, functionStack);
-  }
-  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
-    functionStack.pop();
-  }
-}
-function getMemberExpressionName(node) {
-  const property = node.children.find((c) => c.type === "Identifier");
-  return property?.name;
-}
-
-function calculateComplexity(ast, source) {
-  const cyclomatic = calculateCyclomaticComplexity(ast);
-  const cognitive = calculateCognitiveComplexity(ast);
-  const halstead = calculateHalsteadMetrics(ast);
-  const maintainability = calculateMaintainabilityIndex(ast, source, cyclomatic, halstead);
-  const linesOfCode = countLinesOfCode(source);
-  const commentRatio = calculateCommentRatio(source);
-  return {
-    cyclomatic,
-    cognitive,
-    halstead,
-    maintainabilityIndex: maintainability,
-    linesOfCode,
-    commentRatio
-  };
-}
-function calculateCyclomaticComplexity(ast) {
-  let complexity = 1;
-  for (const child of ast.children) {
-    complexity += calculateCyclomaticComplexity(child);
-    if (child.type === "IfStatement" || child.type === "ConditionalExpression" || child.type === "ForStatement" || child.type === "ForInStatement" || child.type === "ForOfStatement" || child.type === "WhileStatement" || child.type === "DoWhileStatement" || child.type === "SwitchCase") {
-      complexity++;
-    }
-    if (child.type === "CatchClause") {
-      complexity++;
-    }
-  }
-  return complexity;
-}
-function calculateCognitiveComplexity(ast, nestingLevel = 0) {
-  let complexity = 0;
-  for (const child of ast.children) {
-    if (child.type === "IfStatement" || child.type === "ConditionalExpression" || child.type === "ForStatement" || child.type === "ForInStatement" || child.type === "ForOfStatement" || child.type === "WhileStatement" || child.type === "DoWhileStatement" || child.type === "CatchClause") {
-      complexity += 1 + nestingLevel;
-    }
-    if (child.type === "SwitchCase") {
-      complexity += 1 + nestingLevel;
-    }
-    complexity += calculateCognitiveComplexity(child, nestingLevel + 1);
-  }
-  return complexity;
-}
-function calculateHalsteadMetrics(ast) {
-  const operators = /* @__PURE__ */ new Set();
-  const operands = /* @__PURE__ */ new Set();
-  const totalOperators = 0;
-  const totalOperands = 0;
-  extractHalsteadTokens(ast, operators, operands);
-  const n1 = operators.size;
-  const n2 = operands.size;
-  const N1 = totalOperators;
-  const N2 = totalOperands;
-  const vocabulary = n1 + n2;
-  const length = N1 + N2;
-  const volume = length * Math.log2(vocabulary);
-  const difficulty = n1 / 2 * (N2 / n2);
-  const effort = difficulty * volume;
-  const time = effort / 18;
-  const bugs = effort / 3e3;
-  return {
-    n1,
-    n2,
-    N1,
-    N2,
-    vocabulary,
-    difficulty,
-    effort,
-    bugs,
-    time
-  };
-}
-function extractHalsteadTokens(node, operators, operands, totalOperators, totalOperands) {
-  const operatorTypes = [
-    "BinaryExpression",
-    "LogicalExpression",
-    "UnaryExpression",
-    "AssignmentExpression",
-    "UpdateExpression",
-    "IfStatement",
-    "ForStatement",
-    "WhileStatement",
-    "DoWhileStatement",
-    "SwitchStatement",
-    "ConditionalExpression"
-  ];
-  if (operatorTypes.includes(node.type)) {
-    operators.add(node.type);
-  }
-  if (node.type === "Identifier" && node.name) {
-    operands.add(node.name);
-  } else if (node.type === "Literal") {
-    operands.add("literal");
-  }
-  for (const child of node.children) {
-    extractHalsteadTokens(child, operators, operands);
-  }
-}
-function calculateMaintainabilityIndex(ast, source, cyclomatic, halstead) {
-  const loc = countLinesOfCode(source);
-  const volume = (halstead.N1 + halstead.N2) * Math.log2(halstead.vocabulary);
-  const mi = 171 - 5.2 * Math.log(volume) - 0.23 * cyclomatic - 16.2 * Math.log(loc);
-  return Math.max(0, Math.min(100, mi));
-}
-function countLinesOfCode(source) {
-  const lines = source.split("\n");
-  return lines.filter((line) => line.trim().length > 0).length;
-}
-function calculateCommentRatio(source) {
-  const lines = source.split("\n");
-  const totalLines = lines.filter((line) => line.trim().length > 0).length;
-  const commentLines = lines.filter((line) => /^\s*\/\//.test(line) || /^\s*\/\*/.test(line)).length;
-  return totalLines > 0 ? commentLines / totalLines : 0;
-}
-
-function detectPatterns(ast) {
-  const patterns = [];
-  patterns.push(...detectAntiPatterns(ast));
-  patterns.push(...detectCodeSmells(ast));
-  patterns.push(...detectSecurityRisks(ast));
-  patterns.push(...detectPerformanceIssues(ast));
-  return patterns;
-}
-function detectAntiPatterns(node, patterns = []) {
-  if (node.children.length > 50) {
-    patterns.push({
-      id: `pattern-god-object-${node.range.start.line}`,
-      type: "anti-pattern",
-      name: "God Object",
-      range: node.range,
-      description: "This element has too many children and may be doing too much",
-      suggestions: [
-        "Consider splitting into smaller, more focused components",
-        "Apply Single Responsibility Principle"
-      ],
-      severity: "warning"
-    });
-  }
-  if (node.type === "Literal" && typeof node.metadata.value === "number") {
-    const value = node.metadata.value;
-    if (value !== 0 && value !== 1 && Math.abs(value) > 10) {
-      patterns.push({
-        id: `pattern-magic-number-${node.range.start.line}`,
-        type: "anti-pattern",
-        name: "Magic Number",
-        range: node.range,
-        description: "Unnamed numeric literal",
-        suggestions: [
-          "Replace with named constant",
-          "Use configuration object for related values"
-        ],
-        severity: "info"
-      });
-    }
-  }
-  for (const child of node.children) {
-    detectAntiPatterns(child, patterns);
-  }
-  return patterns;
-}
-function detectCodeSmells(node, patterns = []) {
-  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression") {
-    const loc = node.range.end.line - node.range.start.line;
-    if (loc > 50) {
-      patterns.push({
-        id: `pattern-long-function-${node.range.start.line}`,
-        type: "code-smell",
-        name: "Long Function",
-        range: node.range,
-        description: `Function has ${loc} lines (consider < 20)`,
-        suggestions: [
-          "Break down into smaller functions",
-          "Extract logical blocks into helper functions"
-        ],
-        severity: "warning"
-      });
-    }
-    const paramCount = node.metadata.paramCount || 0;
-    if (paramCount > 5) {
-      patterns.push({
-        id: `pattern-too-many-params-${node.range.start.line}`,
-        type: "code-smell",
-        name: "Too Many Parameters",
-        range: node.range,
-        description: `Function has ${paramCount} parameters (consider < 5)`,
-        suggestions: [
-          "Use parameter object",
-          "Split function into smaller functions"
-        ],
-        severity: "info"
-      });
-    }
-  }
-  if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
-    const callbackDepth = countCallbackDepth(node);
-    if (callbackDepth > 3) {
-      patterns.push({
-        id: `pattern-callback-hell-${node.range.start.line}`,
-        type: "code-smell",
-        name: "Callback Hell",
-        range: node.range,
-        description: `Deep callback nesting (${callbackDepth} levels)`,
-        suggestions: [
-          "Use async/await instead of callbacks",
-          "Extract callbacks to named functions"
-        ],
-        severity: "warning"
-      });
-    }
-  }
-  for (const child of node.children) {
-    detectCodeSmells(child, patterns);
-  }
-  return patterns;
-}
-function detectSecurityRisks(node, patterns = []) {
-  if (node.type === "CallExpression" && node.name === "eval") {
-    patterns.push({
-      id: `pattern-eval-${node.range.start.line}`,
-      type: "security-risk",
-      name: "Use of eval()",
-      range: node.range,
-      description: "eval() can execute arbitrary code and is a security risk",
-      suggestions: [
-        "Avoid eval() completely",
-        "Use JSON.parse() for JSON data",
-        "Use object property access for dynamic properties"
-      ],
-      severity: "error"
-    });
-  }
-  if ((node.type === "AssignmentExpression" || node.type === "CallExpression") && node.name?.includes("innerHTML")) {
-    patterns.push({
-      id: `pattern-innerhtml-${node.range.start.line}`,
-      type: "security-risk",
-      name: "innerHTML Usage",
-      range: node.range,
-      description: "Setting innerHTML can lead to XSS vulnerabilities",
-      suggestions: [
-        "Use textContent instead",
-        "Sanitize HTML before insertion",
-        "Use DOM methods (createElement, appendChild)"
-      ],
-      severity: "warning"
-    });
-  }
-  if (node.type === "VariableDeclarator") {
-    const name = node.name?.toLowerCase() || "";
-    if (name.includes("password") || name.includes("secret") || name.includes("token") || name.includes("api_key")) {
-      patterns.push({
-        id: `pattern-hardcoded-secret-${node.range.start.line}`,
-        type: "security-risk",
-        name: "Hardcoded Secret",
-        range: node.range,
-        description: "Potential hardcoded credential or secret",
-        suggestions: [
-          "Use environment variables",
-          "Use secret management service",
-          "Never commit secrets to code"
-        ],
-        severity: "error"
-      });
-    }
-  }
-  for (const child of node.children) {
-    detectSecurityRisks(child, patterns);
-  }
-  return patterns;
-}
-function detectPerformanceIssues(node, patterns = []) {
-  if (node.type === "ForStatement" || node.type === "WhileStatement") {
-    const hasHeavyOps = node.children.some(
-      (child) => child.type === "CallExpression" && (child.name?.includes("querySelector") || child.name?.includes("innerHTML"))
-    );
-    if (hasHeavyOps) {
-      patterns.push({
-        id: `pattern-loop-heavy-ops-${node.range.start.line}`,
-        type: "performance-issue",
-        name: "Heavy Operation in Loop",
-        range: node.range,
-        description: "Loop contains DOM or heavy I/O operations",
-        suggestions: [
-          "Move heavy operations outside loop",
-          "Cache DOM queries before loop",
-          "Use batch processing"
-        ],
-        severity: "warning"
-      });
-    }
-  }
-  if (node.type === "ForStatement" || node.type === "WhileStatement") {
-    const loopNestingDepth = countLoopNesting(node);
-    if (loopNestingDepth > 2) {
-      patterns.push({
-        id: `pattern-nested-loops-${node.range.start.line}`,
-        type: "performance-issue",
-        name: "Nested Loops",
-        range: node.range,
-        description: `${loopNestingDepth} levels of loop nesting (O(n^${loopNestingDepth}) complexity)`,
-        suggestions: [
-          "Consider using data structures with better lookup (Map, Set)",
-          "Break into multiple loops",
-          "Use functional methods (map, filter, reduce)"
-        ],
-        severity: "info"
-      });
-    }
-  }
-  for (const child of node.children) {
-    detectPerformanceIssues(child, patterns);
-  }
-  return patterns;
-}
-function countCallbackDepth(node, depth = 0) {
-  let maxDepth = depth;
-  for (const child of node.children) {
-    if (child.type === "ArrowFunctionExpression" || child.type === "FunctionExpression") {
-      const childDepth = countCallbackDepth(child, depth + 1);
-      maxDepth = Math.max(maxDepth, childDepth);
-    } else {
-      const childDepth = countCallbackDepth(child, depth);
-      maxDepth = Math.max(maxDepth, childDepth);
-    }
-  }
-  return maxDepth;
-}
-function countLoopNesting(node, depth = 1) {
-  let maxDepth = depth;
-  for (const child of node.children) {
-    if (child.type === "ForStatement" || child.type === "WhileStatement" || child.type === "ForInStatement" || child.type === "ForOfStatement") {
-      const childDepth = countLoopNesting(child, depth + 1);
-      maxDepth = Math.max(maxDepth, childDepth);
-    } else {
-      const childDepth = countLoopNesting(child, depth);
-      maxDepth = Math.max(maxDepth, childDepth);
-    }
-  }
-  return maxDepth;
-}
-
-function extractSymbols(filePath, ast) {
-  const symbolTable = {
-    filePath,
-    symbols: [],
-    exports: [],
-    imports: [],
-    scopes: []
-  };
-  const scopeStack = [];
-  let scopeIdCounter = 0;
-  const moduleScope = {
-    id: `scope-${scopeIdCounter++}`,
-    kind: "module",
-    range: ast.range,
-    children: [],
-    symbols: []
-  };
-  symbolTable.scopes.push(moduleScope);
-  scopeStack.push(moduleScope);
-  extractSymbolsFromNode(ast, symbolTable, scopeStack, scopeIdCounter);
-  return symbolTable;
-}
-function extractSymbolsFromNode(node, symbolTable, scopeStack, scopeIdCounter) {
-  const currentScope = scopeStack[scopeStack.length - 1];
-  switch (node.type) {
-    case "FunctionDeclaration":
-    case "FunctionExpression":
-    case "ArrowFunctionExpression": {
-      const symbol = createFunctionSymbol(node, currentScope.id);
-      symbolTable.symbols.push(symbol);
-      currentScope.symbols.push(symbol.id);
-      const functionScope = {
-        id: `scope-${scopeIdCounter++}`,
-        kind: "function",
-        range: node.range,
-        parent: currentScope.id,
-        children: [],
-        symbols: []
-      };
-      symbolTable.scopes.push(functionScope);
-      currentScope.children.push(functionScope.id);
-      scopeStack.push(functionScope);
-      break;
-    }
-    case "ClassDeclaration":
-    case "ClassExpression": {
-      const symbol = createClassSymbol(node, currentScope.id);
-      symbolTable.symbols.push(symbol);
-      currentScope.symbols.push(symbol.id);
-      const classScope = {
-        id: `scope-${scopeIdCounter++}`,
-        kind: "class",
-        range: node.range,
-        parent: currentScope.id,
-        children: [],
-        symbols: []
-      };
-      symbolTable.scopes.push(classScope);
-      currentScope.children.push(classScope.id);
-      scopeStack.push(classScope);
-      break;
-    }
-    case "VariableDeclaration":
-    case "VariableDeclarator": {
-      const symbol = createVariableSymbol(node, currentScope.id);
-      symbolTable.symbols.push(symbol);
-      currentScope.symbols.push(symbol.id);
-      break;
-    }
-    case "TSInterfaceDeclaration":
-    case "TSTypeAliasDeclaration": {
-      const symbol = createTypeSymbol(node, currentScope.id);
-      symbolTable.symbols.push(symbol);
-      symbolTable.exports.push(symbol);
-      currentScope.symbols.push(symbol.id);
-      break;
-    }
-    case "ImportDeclaration": {
-      const importDecl = createImportDeclaration(node);
-      symbolTable.imports.push(importDecl);
-      break;
-    }
-    case "ExportNamedDeclaration":
-    case "ExportDefaultDeclaration": {
-      if (node.name) {
-        const symbol = symbolTable.symbols.find((s) => s.name === node.name);
-        if (symbol && !symbolTable.exports.includes(symbol)) {
-          symbolTable.exports.push(symbol);
-        }
-      }
-      break;
-    }
-    case "BlockStatement": {
-      const blockScope = {
-        id: `scope-${scopeIdCounter++}`,
-        kind: "block",
-        range: node.range,
-        parent: currentScope.id,
-        children: [],
-        symbols: []
-      };
-      symbolTable.scopes.push(blockScope);
-      currentScope.children.push(blockScope.id);
-      scopeStack.push(blockScope);
-      break;
-    }
-  }
-  for (const child of node.children) {
-    scopeIdCounter = extractSymbolsFromNode(child, symbolTable, scopeStack, scopeIdCounter);
-    if (child.type === "FunctionDeclaration" || child.type === "FunctionExpression" || child.type === "ClassDeclaration" || child.type === "ClassExpression" || child.type === "BlockStatement") {
-      const childScopeEnd = symbolTable.scopes.findIndex((s) => s.range === child.range);
-      if (childScopeEnd !== -1 && childScopeEnd < symbolTable.scopes.length - 1) {
-        scopeStack.pop();
-      }
-    }
-  }
-  return scopeIdCounter;
-}
-function createFunctionSymbol(node, parentId) {
-  return {
-    id: `symbol-${node.type}-${node.range.start.line}-${node.range.start.column}`,
-    name: node.name || "<anonymous>",
-    kind: node.type.includes("Method") ? "method" : "function",
-    range: node.range,
-    definingScope: parentId,
-    references: [],
-    metadata: {
-      isAsync: node.metadata.isAsync || false,
-      isGenerator: node.metadata.isGenerator || false,
-      paramCount: node.metadata.paramCount || 0
-    }
-  };
-}
-function createClassSymbol(node, parentId) {
-  return {
-    id: `symbol-class-${node.range.start.line}-${node.range.start.column}`,
-    name: node.name || "<anonymous>",
-    kind: "class",
-    range: node.range,
-    definingScope: parentId,
-    references: [],
-    metadata: {}
-  };
-}
-function createVariableSymbol(node, parentId) {
-  const isConst = node.metadata.kind === "const";
-  return {
-    id: `symbol-variable-${node.range.start.line}-${node.range.start.column}`,
-    name: node.name || "<unknown>",
-    kind: isConst ? "constant" : "variable",
-    range: node.range,
-    definingScope: parentId,
-    references: [],
-    metadata: {}
-  };
-}
-function createTypeSymbol(node, parentId) {
-  return {
-    id: `symbol-type-${node.range.start.line}-${node.range.start.column}`,
-    name: node.name || "<anonymous>",
-    kind: node.type.includes("Interface") ? "interface" : "type",
-    range: node.range,
-    definingScope: parentId,
-    references: [],
-    metadata: {}
-  };
-}
-function createImportDeclaration(node) {
-  const imports = [];
-  for (const child of node.children) {
-    if (child.type === "ImportSpecifier" || child.type === "ImportDefaultSpecifier") {
-      imports.push({
-        name: child.name,
-        alias: child.metadata.local,
-        kind: child.type.replace("Import", "").toLowerCase()
-      });
-    }
-  }
-  return {
-    module: node.metadata.source || "",
-    imports,
-    range: node.range,
-    isDynamic: node.type === "ImportExpression"
-  };
-}
-
-class IncrementalIndexer {
-  index;
-  storage;
-  dependencyGraph = /* @__PURE__ */ new Map();
-  reverseDependencyGraph = /* @__PURE__ */ new Map();
-  constructor() {
-    this.index = getGlobalIndex();
-    this.storage = new LevelDBStorage("./actionbook-cache");
-  }
-  /**
-   * Index a single file
-   */
-  async indexFile(filePath) {
-    try {
-      const stats = await fs.stat(filePath).catch(() => null);
-      if (!stats?.isFile()) {
-        return null;
-      }
-      const source = await fs.readFile(filePath, "utf-8");
-      const ast = await parseAST(filePath);
-      if (!ast) {
-        return null;
-      }
-      const symbols = extractSymbols(filePath, ast);
-      const callGraph = generateCallGraph(filePath, ast);
-      const complexity = calculateComplexity(ast, source);
-      const patterns = detectPatterns(ast);
-      const data = {
-        filePath,
-        ast,
-        symbols,
-        callGraph,
-        complexity,
-        patterns,
-        lastModified: stats.mtimeMs,
-        checksum: this.generateChecksum(source)
-      };
-      await this.storePrecomputedData(data);
-      await this.updateDependencies(filePath, symbols);
-      return data;
-    } catch (error) {
-      console.error(`Failed to index file ${filePath}:`, error);
-      return null;
-    }
-  }
-  /**
-   * Index multiple files
-   */
-  async indexFiles(filePaths) {
-    const startTime = Date.now();
-    const stats = {
-      filesIndexed: 0,
-      totalFiles: filePaths.length,
-      errors: [],
-      duration: 0
-    };
-    const batchSize = 10;
-    for (let i = 0; i < filePaths.length; i += batchSize) {
-      const batch = filePaths.slice(i, i + batchSize);
-      const results = await Promise.allSettled(
-        batch.map((path) => this.indexFile(path))
-      );
-      for (const result of results) {
-        if (result.status === "fulfilled" && result.value) {
-          stats.filesIndexed++;
-        } else if (result.status === "rejected") {
-          stats.errors.push(result.reason?.message || "Unknown error");
-        }
-      }
-    }
-    stats.duration = Date.now() - startTime;
-    return stats;
-  }
-  /**
-   * Remove file from index
-   */
-  async removeFile(filePath) {
-    await this.index.delete(`${filePath}|ast`);
-    await this.index.delete(`${filePath}|symbol`);
-    await this.index.delete(`${filePath}|call-graph`);
-    await this.index.delete(`${filePath}|complexity`);
-    await this.index.delete(`${filePath}|patterns`);
-    const dependencies = this.dependencyGraph.get(filePath);
-    if (dependencies) {
-      const depsArray = Array.from(dependencies);
-      for (const dep of depsArray) {
-        const dependents = this.reverseDependencyGraph.get(dep);
-        if (dependents) {
-          dependents.delete(filePath);
-        }
-      }
-      this.dependencyGraph.delete(filePath);
-    }
-  }
-  /**
-   * Remove multiple files
-   */
-  async removeFiles(filePaths) {
-    await Promise.all(filePaths.map((path) => this.removeFile(path)));
-  }
-  /**
-   * Reindex file and its dependents
-   */
-  async reindexFile(filePath) {
-    const dependents = this.reverseDependencyGraph.get(filePath) || /* @__PURE__ */ new Set();
-    const stats = await this.indexFiles([filePath]);
-    if (dependents.size > 0) {
-      const dependentStats = await this.indexFiles(Array.from(dependents));
-      stats.filesIndexed += dependentStats.filesIndexed;
-      stats.errors.push(...dependentStats.errors);
-    }
-    return stats;
-  }
-  /**
-   * Check if file needs reindexing
-   */
-  async needsReindex(filePath) {
-    try {
-      const stats = await fs.stat(filePath);
-      const key = `${filePath}|ast`;
-      const entry = await this.index.get(key);
-      if (!entry) {
-        return true;
-      }
-      return stats.mtimeMs > entry.timestamp;
-    } catch {
-      return true;
-    }
-  }
-  /**
-   * Store precomputed data in cache
-   */
-  async storePrecomputedData(data) {
-    const timestamp = Date.now();
-    await this.index.set(`${data.filePath}|ast`, {
-      key: `${data.filePath}|ast`,
-      type: "ast",
-      data: data.ast,
-      checksum: data.checksum,
-      timestamp,
-      compressed: false
-    });
-    await this.index.set(`${data.filePath}|symbol`, {
-      key: `${data.filePath}|symbol`,
-      type: "symbol",
-      data: data.symbols,
-      checksum: data.checksum,
-      timestamp,
-      compressed: false
-    });
-    await this.index.set(`${data.filePath}|call-graph`, {
-      key: `${data.filePath}|call-graph`,
-      type: "call-graph",
-      data: data.callGraph,
-      checksum: data.checksum,
-      timestamp,
-      compressed: false
-    });
-    await this.index.set(`${data.filePath}|complexity`, {
-      key: `${data.filePath}|complexity`,
-      type: "complexity",
-      data: data.complexity,
-      checksum: data.checksum,
-      timestamp,
-      compressed: false
-    });
-    await this.index.set(`${data.filePath}|patterns`, {
-      key: `${data.filePath}|patterns`,
-      type: "patterns",
-      data: data.patterns,
-      checksum: data.checksum,
-      timestamp,
-      compressed: false
-    });
-  }
-  /**
-   * Update dependency graph based on imports
-   */
-  async updateDependencies(filePath, symbols) {
-    const imports = /* @__PURE__ */ new Set();
-    for (const importDecl of symbols.imports) {
-      const resolvedPath = await this.resolveImportPath(filePath, importDecl.module);
-      if (resolvedPath) {
-        imports.add(resolvedPath);
-      }
-    }
-    this.dependencyGraph.set(filePath, imports);
-    const importsArray = Array.from(imports);
-    for (const dep of importsArray) {
-      if (!this.reverseDependencyGraph.has(dep)) {
-        this.reverseDependencyGraph.set(dep, /* @__PURE__ */ new Set());
-      }
-      this.reverseDependencyGraph.get(dep).add(filePath);
-    }
-  }
-  /**
-   * Resolve import path to absolute file path
-   */
-  async resolveImportPath(fromFile, importPath) {
-    if (importPath.startsWith(".")) {
-      const fromDir = fromFile.substring(0, fromFile.lastIndexOf("/"));
-      const resolved = `${fromDir}/${importPath}`;
-      const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
-      for (const ext of extensions) {
-        const path = resolved + ext;
-        try {
-          await fs.access(path);
-          return path;
-        } catch {
-          try {
-            const indexPath = `${resolved}/index${ext}`;
-            await fs.access(indexPath);
-            return indexPath;
-          } catch {
-            continue;
-          }
-        }
-      }
-    }
-    return null;
-  }
-  /**
-   * Generate checksum for source code
-   */
-  generateChecksum(source) {
-    const crypto = require("node:crypto");
-    return crypto.createHash("sha256").update(source).digest("hex");
-  }
-  /**
-   * Get dependency graph
-   */
-  getDependencyGraph() {
-    return new Map(this.dependencyGraph);
-  }
-  /**
-   * Get reverse dependency graph
-   */
-  getReverseDependencyGraph() {
-    return new Map(this.reverseDependencyGraph);
-  }
-  /**
-   * Clear all indexes
-   */
-  async clear() {
-    await this.index.clear();
-    this.dependencyGraph.clear();
-    this.reverseDependencyGraph.clear();
-  }
-}
-let globalIndexer = null;
-function getGlobalIndexer() {
-  if (!globalIndexer) {
-    globalIndexer = new IncrementalIndexer();
-  }
-  return globalIndexer;
-}
-function resetGlobalIndexer() {
-  globalIndexer = null;
-}
-
-class FileWatcher extends EventEmitter {
-  watcher = null;
-  indexer;
-  watchedPaths = /* @__PURE__ */ new Set();
-  changeQueue = /* @__PURE__ */ new Map();
-  flushTimer = null;
-  FLUSH_DELAY = 100;
-  // ms
-  constructor(indexer) {
-    super();
-    this.indexer = indexer;
-  }
-  /**
-   * Start watching a path
-   */
-  watch(path, options = {}) {
-    if (this.watchedPaths.has(path)) {
-      return;
-    }
-    const watcherOptions = {
-      ignored: [
-        /(^|[\\/])\../,
-        // dot files
-        "**/node_modules/**",
-        "**/.git/**",
-        "**/dist/**",
-        "**/build/**",
-        "**/.next/**",
-        "**/coverage/**"
-      ],
-      persistent: options.persistent ?? true,
-      ignoreInitial: options.ignoreInitial ?? true,
-      ignorePermissionErrors: options.ignorePermissionErrors ?? true,
-      awaitWriteFinish: options.awaitWriteFinish ?? {
-        stabilityThreshold: 300,
-        pollInterval: 100
-      }
-    };
-    this.watcher = chokidar.watch(path, watcherOptions);
-    this.watcher.on("add", (filePath) => this.handleFileChange("add", filePath)).on("change", (filePath) => this.handleFileChange("change", filePath)).on("unlink", (filePath) => this.handleFileChange("unlink", filePath)).on("addDir", (dirPath) => this.handleFileChange("addDir", dirPath)).on("unlinkDir", (dirPath) => this.handleFileChange("unlinkDir", dirPath)).on("error", (error) => this.emit("error", error)).on("ready", () => this.emit("ready"));
-    this.watchedPaths.add(path);
-  }
-  /**
-   * Stop watching a path
-   */
-  async unwatch(path) {
-    if (!this.watchedPaths.has(path)) {
-      return;
-    }
-    if (this.watcher) {
-      await this.watcher.unwatch(path);
-    }
-    this.watchedPaths.delete(path);
-  }
-  /**
-   * Stop all watching
-   */
-  async close() {
-    if (this.watcher) {
-      await this.watcher.close();
-      this.watcher = null;
-    }
-    this.watchedPaths.clear();
-    this.changeQueue.clear();
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-  }
-  /**
-   * Handle file change event
-   */
-  handleFileChange(type, path) {
-    const event = {
-      type,
-      path,
-      timestamp: Date.now()
-    };
-    this.changeQueue.set(path, event);
-    this.emit("change", event);
-    this.scheduleFlush();
-  }
-  /**
-   * Schedule flushing the change queue
-   */
-  scheduleFlush() {
-    if (this.flushTimer) {
-      return;
-    }
-    this.flushTimer = setTimeout(() => {
-      this.flushChanges().catch((error) => this.emit("error", error));
-      this.flushTimer = null;
-    }, this.FLUSH_DELAY);
-  }
-  /**
-   * Flush queued changes to indexer
-   */
-  async flushChanges() {
-    if (this.changeQueue.size === 0) {
-      return;
-    }
-    const changes = Array.from(this.changeQueue.values());
-    this.changeQueue.clear();
-    const toAdd = changes.filter((c) => c.type === "add" || c.type === "change").map((c) => c.path);
-    const toRemove = changes.filter((c) => c.type === "unlink").map((c) => c.path);
-    try {
-      if (toAdd.length > 0) {
-        await this.indexer.indexFiles(toAdd);
-      }
-      if (toRemove.length > 0) {
-        await this.indexer.removeFiles(toRemove);
-      }
-      this.emit("indexed", { added: toAdd.length, removed: toRemove.length });
-    } catch (error) {
-      this.emit("error", error);
-    }
-  }
-  /**
-   * Get list of watched paths
-   */
-  getWatchedPaths() {
-    return Array.from(this.watchedPaths);
-  }
-  /**
-   * Check if path is being watched
-   */
-  isWatching(path) {
-    return this.watchedPaths.has(path);
-  }
-  /**
-   * Get current change queue size
-   */
-  getQueueSize() {
-    return this.changeQueue.size;
-  }
-}
-let globalWatcher = null;
-function getGlobalWatcher() {
-  if (!globalWatcher) {
-    const indexer = new IncrementalIndexer();
-    globalWatcher = new FileWatcher(indexer);
-  }
-  return globalWatcher;
-}
-async function closeGlobalWatcher() {
-  if (globalWatcher) {
-    await globalWatcher.close();
-    globalWatcher = null;
-  }
-}
-
-class ActionbookEngine {
-  config;
-  queryAPI;
-  indexer;
-  watcher;
-  tracker;
-  isInitialized = false;
-  constructor(config = {}) {
-    this.config = {
-      cachePath: config.cachePath || "./.actionbook-cache",
-      watchMode: config.watchMode ?? true,
-      compressionEnabled: config.compressionEnabled ?? true,
-      maxMemoryCacheSize: config.maxMemoryCacheSize || 1e3,
-      logLevel: config.logLevel || "info"
-    };
-    this.queryAPI = getQueryAPI();
-    this.indexer = getGlobalIndexer();
-    this.watcher = getGlobalWatcher();
-    this.tracker = getGlobalTracker();
-  }
-  /**
-   * Initialize the engine
-   */
-  async initialize() {
-    if (this.isInitialized) {
-      return;
-    }
-    this.log("info", "Initializing Actionbook Engine...");
-    const index = getGlobalIndex(this.config.cachePath);
-    await index.compact();
-    if (this.config.watchMode) {
-      this.tracker.enableWatchMode();
-      this.setupWatcher();
-    }
-    this.isInitialized = true;
-    this.log("info", "Actionbook Engine initialized");
-  }
-  /**
-   * Index a single file
-   */
-  async indexFile(filePath) {
-    this.ensureInitialized();
-    this.log("debug", `Indexing file: ${filePath}`);
-    return this.indexer.indexFile(filePath);
-  }
-  /**
-   * Index multiple files
-   */
-  async indexFiles(filePaths) {
-    this.ensureInitialized();
-    this.log("info", `Indexing ${filePaths.length} files...`);
-    return this.indexer.indexFiles(filePaths);
-  }
-  /**
-   * Index a directory recursively
-   */
-  async indexDirectory(dirPath, extensions = [".ts", ".tsx", ".js", ".jsx"]) {
-    this.ensureInitialized();
-    this.log("info", `Indexing directory: ${dirPath}`);
-    const files = await this.getFilesRecursively(dirPath, extensions);
-    return this.indexFiles(files);
-  }
-  /**
-   * Watch a directory for changes
-   */
-  async watchDirectory(dirPath) {
-    this.ensureInitialized();
-    this.log("info", `Watching directory: ${dirPath}`);
-    if (!this.config.watchMode) {
-      this.log("warn", "Watch mode is disabled");
-      return;
-    }
-    this.watcher.watch(dirPath);
-  }
-  /**
-   * Query precomputed data
-   */
-  get query() {
-    return this.queryAPI;
-  }
-  /**
-   * Get cache statistics
-   */
-  async getCacheStats() {
-    const index = getGlobalIndex();
-    return index.getStats();
-  }
-  /**
-   * Get dependency graph
-   */
-  getDependencyGraph() {
-    return this.indexer.getDependencyGraph();
-  }
-  /**
-   * Get circular dependencies
-   */
-  getCircularDependencies() {
-    return this.tracker.detectCircularDependencies();
-  }
-  /**
-   * Warm up cache for specific files
-   */
-  async warmup(files) {
-    this.ensureInitialized();
-    this.log("info", `Warming up cache for ${files.length} files...`);
-    const index = getGlobalIndex();
-    await Promise.all(files.map((file) => index.warmup(file)));
-  }
-  /**
-   * Clear all caches
-   */
-  async clearCache() {
-    this.log("info", "Clearing all caches...");
-    const index = getGlobalIndex();
-    await index.clear();
-  }
-  /**
-   * Shutdown the engine
-   */
-  async shutdown() {
-    if (!this.isInitialized) {
-      return;
-    }
-    this.log("info", "Shutting down Actionbook Engine...");
-    if (this.config.watchMode) {
-      await closeGlobalWatcher();
-    }
-    await closeGlobalIndex();
-    resetGlobalIndexer();
-    resetGlobalTracker();
-    this.isInitialized = false;
-    this.log("info", "Actionbook Engine shutdown complete");
-  }
-  /**
-   * Setup file watcher
-   */
-  setupWatcher() {
-    this.watcher.on("change", (event) => {
-      this.log("debug", `File changed: ${event.path} (${event.type})`);
-    });
-    this.watcher.on("indexed", (stats) => {
-      this.log("info", `Indexed ${stats.added + stats.removed} files`);
-    });
-    this.watcher.on("error", (error) => {
-      this.log("error", "Watcher error:", error);
-    });
-  }
-  /**
-   * Get files recursively
-   */
-  async getFilesRecursively(dir, extensions) {
-    const files = [];
-    try {
-      const entries = await fs.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = `${dir}/${entry.name}`;
-        if (entry.isDirectory()) {
-          if (!this.shouldIgnoreDirectory(entry.name)) {
-            const subFiles = await this.getFilesRecursively(fullPath, extensions);
-            files.push(...subFiles);
-          }
-        } else if (entry.isFile()) {
-          if (extensions.some((ext) => entry.name.endsWith(ext))) {
-            files.push(fullPath);
-          }
-        }
-      }
-    } catch (error) {
-      this.log("warn", `Failed to read directory ${dir}:`, error);
-    }
-    return files;
-  }
-  /**
-   * Check if directory should be ignored
-   */
-  shouldIgnoreDirectory(name) {
-    const ignorePatterns = [
-      "node_modules",
-      ".git",
-      "dist",
-      "build",
-      ".next",
-      "coverage",
-      ".actionbook-cache"
-    ];
-    return ignorePatterns.some((pattern) => name.includes(pattern));
-  }
-  /**
-   * Ensure engine is initialized
-   */
-  ensureInitialized() {
-    if (!this.isInitialized) {
-      throw new Error("Actionbook Engine not initialized. Call initialize() first.");
-    }
-  }
-  /**
-   * Log message
-   */
-  log(level, message, ...args) {
-    const levels = ["debug", "info", "warn", "error"];
-    const currentLevel = levels.indexOf(this.config.logLevel);
-    const messageLevel = levels.indexOf(level);
-    if (messageLevel >= currentLevel) {
-      console.log(`[Actionbook:${level.toUpperCase()}] ${message}`, ...args);
-    }
-  }
-}
-function createEngine(config) {
-  return new ActionbookEngine(config);
-}
+import 'i18next-fs-backend';
+import './chunks/claude-config.mjs';
+import './chunks/json-config.mjs';
+import './chunks/fs-operations.mjs';
+import 'node:crypto';
+import 'node:fs/promises';
+import 'tinyexec';
 
 const execAsync$1 = promisify(exec);
 class BaseCodeTool {
@@ -3494,1480 +789,6 @@ function createTool(name, config) {
   return factory.createTool(name, config);
 }
 
-const VERSION = "1.0.0";
-function isCommandGroup(entry) {
-  return "subcommands" in entry;
-}
-function parseArgs(argv) {
-  const args = argv.slice(2);
-  const command = [];
-  const options = {};
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg.startsWith("--")) {
-      const key = arg.slice(2);
-      const nextArg = args[i + 1];
-      if (nextArg && !nextArg.startsWith("-")) {
-        options[key] = nextArg;
-        i++;
-      } else {
-        options[key] = true;
-      }
-    } else if (arg.startsWith("-")) {
-      const key = arg.slice(1);
-      const nextArg = args[i + 1];
-      if (nextArg && !nextArg.startsWith("-")) {
-        options[key] = nextArg;
-        i++;
-      } else {
-        options[key] = true;
-      }
-    } else {
-      command.push(arg);
-    }
-  }
-  return { command, options };
-}
-function showHelp() {
-  console.log(`
-${ansis.bold("CCJK")} - Claude Code JK \u589E\u5F3A\u7248\u914D\u7F6E\u5DE5\u5177
-
-${ansis.bold("\u7528\u6CD5:")}
-  ccjk [\u547D\u4EE4] [\u9009\u9879]
-
-${ansis.bold("\u547D\u4EE4:")}
-  ${ansis.cyan("menu")}              \u542F\u52A8\u4EA4\u4E92\u5F0F\u83DC\u5355
-  ${ansis.cyan("api setup")}        \u5FEB\u901F\u914D\u7F6E API
-  ${ansis.cyan("api status")}       \u67E5\u770B API \u914D\u7F6E\u72B6\u6001
-  ${ansis.cyan("api switch")}       \u5207\u6362 API \u914D\u7F6E
-  ${ansis.cyan("api providers")}    \u67E5\u770B\u53EF\u7528\u7684 API \u63D0\u4F9B\u5546
-  ${ansis.cyan("init")}             \u521D\u59CB\u5316 CCJK \u914D\u7F6E
-  ${ansis.cyan("mcp list")}         \u5217\u51FA\u5DF2\u5B89\u88C5\u7684 MCP \u670D\u52A1\u5668
-  ${ansis.cyan("mcp search")} <q>   \u641C\u7D22 MCP \u670D\u52A1\u5668
-  ${ansis.cyan("mcp install")} <n>  \u5B89\u88C5 MCP \u670D\u52A1\u5668
-  ${ansis.cyan("mcp uninstall")} <n> \u5378\u8F7D MCP \u670D\u52A1\u5668
-  ${ansis.cyan("doctor")}           \u8FD0\u884C\u8BCA\u65AD\u68C0\u67E5
-  ${ansis.cyan("update")}           \u68C0\u67E5\u5E76\u5B89\u88C5\u66F4\u65B0
-  ${ansis.cyan("config show")}      \u663E\u793A\u5F53\u524D\u914D\u7F6E
-  ${ansis.cyan("config reset")}     \u91CD\u7F6E\u914D\u7F6E
-
-${ansis.bold("\u9009\u9879:")}
-  ${ansis.cyan("-h, --help")}       \u663E\u793A\u5E2E\u52A9\u4FE1\u606F
-  ${ansis.cyan("-v, --version")}    \u663E\u793A\u7248\u672C\u53F7
-  ${ansis.cyan("-l, --locale")}     \u8BED\u8A00\u8BBE\u7F6E (\u9ED8\u8BA4: zh-CN)
-
-${ansis.bold("\u793A\u4F8B:")}
-  ccjk                 \u542F\u52A8\u4EA4\u4E92\u5F0F\u83DC\u5355
-  ccjk api setup       \u5FEB\u901F\u914D\u7F6E API
-  ccjk mcp install github  \u5B89\u88C5 GitHub MCP \u670D\u52A1\u5668
-`);
-}
-function getCommands() {
-  return {
-    menu: {
-      description: "\u542F\u52A8\u4EA4\u4E92\u5F0F\u83DC\u5355",
-      action: async (args) => {
-        const { startMenu } = await Promise.resolve().then(function () { return index$7; });
-        const locale = args[0] || "zh-CN";
-        await startMenu({ locale });
-      }
-    },
-    api: {
-      description: "API \u914D\u7F6E\u7BA1\u7406",
-      subcommands: {
-        setup: {
-          description: "\u5FEB\u901F\u914D\u7F6E API",
-          action: async (args) => {
-            const { quickApiSetup } = await import('./chunks/api-adapter.mjs');
-            const locale = args[0] || "zh-CN";
-            await quickApiSetup(locale);
-          }
-        },
-        status: {
-          description: "\u67E5\u770B API \u914D\u7F6E\u72B6\u6001",
-          action: async (args) => {
-            const { detectApiStatus, getApiStatusSummary } = await import('./chunks/api-adapter.mjs');
-            const status = await detectApiStatus();
-            const locale = args[0] || "zh-CN";
-            console.log(getApiStatusSummary(status, locale));
-          }
-        },
-        switch: {
-          description: "\u5207\u6362 API \u914D\u7F6E",
-          action: async () => {
-            const { configSwitchCommand } = await import('./chunks/config-switch.mjs');
-            await configSwitchCommand({ codeType: "claude-code" });
-          }
-        },
-        providers: {
-          description: "\u67E5\u770B\u53EF\u7528\u7684 API \u63D0\u4F9B\u5546",
-          action: async () => {
-            const { providerRegistry } = await import('./chunks/provider-registry.mjs');
-            const providers = providerRegistry.getAllMetadata();
-            console.log("\n\u53EF\u7528\u7684 API \u63D0\u4F9B\u5546:\n");
-            providers.forEach((p) => {
-              const popular = p.popular ? " \u2B50" : "";
-              console.log(`  ${p.icon || "\u2022"} ${p.name}${popular}`);
-              console.log(`    ${p.description}`);
-              console.log(`    \u8BBE\u7F6E\u65F6\u95F4: ${p.setupTime}
-`);
-            });
-          }
-        }
-      }
-    },
-    init: {
-      description: "\u521D\u59CB\u5316 CCJK \u914D\u7F6E",
-      action: async () => {
-        const { init } = await import('./chunks/init.mjs');
-        await init({});
-      }
-    },
-    mcp: {
-      description: "MCP \u670D\u52A1\u5668\u7BA1\u7406",
-      subcommands: {
-        list: {
-          description: "\u5217\u51FA\u5DF2\u5B89\u88C5\u7684 MCP \u670D\u52A1\u5668",
-          action: async () => {
-            const { mcpList } = await import('./chunks/mcp-market.mjs');
-            await mcpList();
-          }
-        },
-        search: {
-          description: "\u641C\u7D22 MCP \u670D\u52A1\u5668",
-          action: async (args) => {
-            const query = args[0];
-            if (!query) {
-              console.log(ansis.red("\u9519\u8BEF: \u8BF7\u63D0\u4F9B\u641C\u7D22\u5173\u952E\u8BCD"));
-              return;
-            }
-            const { mcpSearch } = await import('./chunks/mcp-market.mjs');
-            await mcpSearch(query);
-          }
-        },
-        install: {
-          description: "\u5B89\u88C5 MCP \u670D\u52A1\u5668",
-          action: async (args) => {
-            const name = args[0];
-            if (!name) {
-              console.log(ansis.red("\u9519\u8BEF: \u8BF7\u63D0\u4F9B MCP \u670D\u52A1\u5668\u540D\u79F0"));
-              return;
-            }
-            const { mcpInstall } = await import('./chunks/mcp-market.mjs');
-            await mcpInstall(name);
-          }
-        },
-        uninstall: {
-          description: "\u5378\u8F7D MCP \u670D\u52A1\u5668",
-          action: async (args) => {
-            const name = args[0];
-            if (!name) {
-              console.log(ansis.red("\u9519\u8BEF: \u8BF7\u63D0\u4F9B MCP \u670D\u52A1\u5668\u540D\u79F0"));
-              return;
-            }
-            const { mcpUninstall } = await import('./chunks/mcp-market.mjs');
-            await mcpUninstall(name);
-          }
-        }
-      }
-    },
-    doctor: {
-      description: "\u8FD0\u884C\u8BCA\u65AD\u68C0\u67E5",
-      action: async () => {
-        const { doctor } = await import('./chunks/doctor.mjs');
-        await doctor();
-      }
-    },
-    update: {
-      description: "\u68C0\u67E5\u5E76\u5B89\u88C5\u66F4\u65B0",
-      action: async () => {
-        const { update } = await import('./chunks/update.mjs');
-        await update({});
-      }
-    },
-    config: {
-      description: "\u914D\u7F6E\u7BA1\u7406",
-      subcommands: {
-        show: {
-          description: "\u663E\u793A\u5F53\u524D\u914D\u7F6E",
-          action: async () => {
-            const { readZcfConfig } = await import('./chunks/ccjk-config.mjs');
-            const config = readZcfConfig();
-            console.log(JSON.stringify(config, null, 2));
-          }
-        },
-        reset: {
-          description: "\u91CD\u7F6E\u914D\u7F6E",
-          action: async () => {
-            const { confirm } = await inquirer.prompt([
-              {
-                type: "confirm",
-                name: "confirm",
-                message: "\u786E\u5B9A\u8981\u91CD\u7F6E\u6240\u6709\u914D\u7F6E\u5417\uFF1F",
-                default: false
-              }
-            ]);
-            if (!confirm) {
-              console.log("\u5DF2\u53D6\u6D88");
-              return;
-            }
-            console.log("\u914D\u7F6E\u5DF2\u91CD\u7F6E");
-          }
-        }
-      }
-    }
-  };
-}
-async function defaultAction() {
-  const { needsApiSetup, quickApiSetup } = await import('./chunks/api-adapter.mjs');
-  if (await needsApiSetup()) {
-    console.log("");
-    console.log(ansis.yellow("\u26A0\uFE0F  \u68C0\u6D4B\u5230 API \u5C1A\u672A\u914D\u7F6E"));
-    console.log(ansis.dim("\u5EFA\u8BAE\u5148\u914D\u7F6E API \u4EE5\u4F7F\u7528 Claude Code"));
-    console.log("");
-    const { action } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "action",
-        message: "\u8BF7\u9009\u62E9:",
-        choices: [
-          { name: "\u26A1 \u5FEB\u901F\u914D\u7F6E API", value: "setup" },
-          { name: "\u{1F4CB} \u8FDB\u5165\u4E3B\u83DC\u5355", value: "menu" },
-          { name: "\u274C \u9000\u51FA", value: "exit" }
-        ]
-      }
-    ]);
-    if (action === "setup") {
-      await quickApiSetup("zh-CN");
-    } else if (action === "menu") {
-      const { startMenu } = await Promise.resolve().then(function () { return index$7; });
-      await startMenu();
-    }
-  } else {
-    const { startMenu } = await Promise.resolve().then(function () { return index$7; });
-    await startMenu();
-  }
-}
-async function runCli() {
-  const { command, options } = parseArgs(process__default.argv);
-  if (options.help || options.h) {
-    showHelp();
-    return;
-  }
-  if (options.version || options.v) {
-    console.log(`ccjk v${VERSION}`);
-    return;
-  }
-  const commands = getCommands();
-  if (command.length === 0) {
-    await defaultAction();
-    return;
-  }
-  const mainCmd = command[0];
-  const cmdEntry = commands[mainCmd];
-  if (!cmdEntry) {
-    console.log(ansis.red(`\u9519\u8BEF: \u672A\u77E5\u547D\u4EE4 '${mainCmd}'`));
-    console.log(ansis.dim("\u8FD0\u884C ccjk --help \u67E5\u770B\u53EF\u7528\u547D\u4EE4"));
-    process__default.exit(1);
-  }
-  if (isCommandGroup(cmdEntry)) {
-    const subCmd = command[1];
-    if (!subCmd) {
-      console.log(ansis.yellow(`${mainCmd} \u5B50\u547D\u4EE4:`));
-      Object.entries(cmdEntry.subcommands).forEach(([name, def]) => {
-        console.log(`  ${ansis.cyan(name)}  ${def.description}`);
-      });
-      return;
-    }
-    const subCmdDef = cmdEntry.subcommands[subCmd];
-    if (!subCmdDef) {
-      console.log(ansis.red(`\u9519\u8BEF: \u672A\u77E5\u5B50\u547D\u4EE4 '${mainCmd} ${subCmd}'`));
-      console.log(ansis.dim(`\u8FD0\u884C ccjk ${mainCmd} \u67E5\u770B\u53EF\u7528\u5B50\u547D\u4EE4`));
-      process__default.exit(1);
-    }
-    await subCmdDef.action(command.slice(2));
-  } else {
-    await cmdEntry.action(command.slice(1));
-  }
-}
-
-const cli = {
-  __proto__: null,
-  runCli: runCli
-};
-
-const coreGroup = {
-  id: "core",
-  label: {
-    "en": "Core Features",
-    "zh-CN": "\u6838\u5FC3\u529F\u80FD"
-  },
-  icon: "\u2B50",
-  priority: "core",
-  items: [
-    {
-      id: "api-config",
-      label: {
-        "en": "\u{1F511} API Configuration",
-        "zh-CN": "\u{1F511} API \u914D\u7F6E\u7BA1\u7406"
-      },
-      description: {
-        "en": "One-click setup for AI providers (Anthropic, OpenAI, Azure, etc.)",
-        "zh-CN": "\u4E00\u952E\u914D\u7F6E AI \u670D\u52A1\u63D0\u4F9B\u5546\uFF08Anthropic\u3001OpenAI\u3001Azure \u7B49\uFF09"
-      },
-      shortcut: "a",
-      action: {
-        type: "command",
-        handler: "api-config"
-      },
-      priority: "core"
-    }
-  ]
-};
-const featuresGroup = {
-  id: "features",
-  label: {
-    "en": "Features",
-    "zh-CN": "\u529F\u80FD\u6A21\u5757"
-  },
-  icon: "\u{1F6E0}\uFE0F",
-  priority: "feature",
-  items: [
-    {
-      id: "skills",
-      label: {
-        "en": "\u{1F4DA} Skills Management",
-        "zh-CN": "\u{1F4DA} Skills \u7BA1\u7406"
-      },
-      description: {
-        "en": "Manage and configure AI skill templates",
-        "zh-CN": "\u7BA1\u7406\u548C\u914D\u7F6E AI \u6280\u80FD\u6A21\u677F"
-      },
-      shortcut: "s",
-      action: {
-        type: "command",
-        handler: "skills"
-      },
-      priority: "feature"
-    },
-    {
-      id: "mcp",
-      label: {
-        "en": "\u{1F50C} MCP Servers",
-        "zh-CN": "\u{1F50C} MCP \u670D\u52A1\u5668"
-      },
-      description: {
-        "en": "Configure Model Context Protocol servers",
-        "zh-CN": "\u914D\u7F6E Model Context Protocol \u670D\u52A1\u5668"
-      },
-      shortcut: "m",
-      action: {
-        type: "command",
-        handler: "mcp"
-      },
-      priority: "feature"
-    },
-    {
-      id: "session",
-      label: {
-        "en": "\u{1F4BE} Session Management",
-        "zh-CN": "\u{1F4BE} Session \u7BA1\u7406"
-      },
-      description: {
-        "en": "Manage session history and recovery",
-        "zh-CN": "\u7BA1\u7406\u4F1A\u8BDD\u5386\u53F2\u548C\u6062\u590D"
-      },
-      shortcut: "e",
-      action: {
-        type: "command",
-        handler: "session"
-      },
-      priority: "feature"
-    }
-  ]
-};
-const settingsGroup$1 = {
-  id: "settings",
-  label: {
-    "en": "Settings",
-    "zh-CN": "\u7CFB\u7EDF\u8BBE\u7F6E"
-  },
-  icon: "\u2699\uFE0F",
-  priority: "setting",
-  items: [
-    {
-      id: "settings",
-      label: {
-        "en": "\u2699\uFE0F Settings",
-        "zh-CN": "\u2699\uFE0F \u8BBE\u7F6E"
-      },
-      description: {
-        "en": "Configure CCJK global settings",
-        "zh-CN": "\u914D\u7F6E CCJK \u5168\u5C40\u8BBE\u7F6E"
-      },
-      shortcut: "t",
-      action: {
-        type: "command",
-        handler: "settings"
-      },
-      priority: "setting"
-    }
-  ]
-};
-const footerItems = [
-  {
-    id: "help",
-    label: {
-      "en": "\u2753 Help",
-      "zh-CN": "\u2753 \u5E2E\u52A9"
-    },
-    description: {
-      "en": "View help information and documentation",
-      "zh-CN": "\u67E5\u770B\u5E2E\u52A9\u4FE1\u606F\u548C\u6587\u6863"
-    },
-    shortcut: "h",
-    action: {
-      type: "command",
-      handler: "help"
-    },
-    priority: "help"
-  },
-  {
-    id: "exit",
-    label: {
-      "en": "\u{1F6AA} Exit",
-      "zh-CN": "\u{1F6AA} \u9000\u51FA"
-    },
-    description: {
-      "en": "Exit CCJK menu",
-      "zh-CN": "\u9000\u51FA CCJK \u83DC\u5355"
-    },
-    shortcut: "q",
-    action: {
-      type: "command",
-      handler: "exit"
-    },
-    priority: "help"
-  }
-];
-const mainMenuConfig$1 = {
-  title: {
-    "en": "CCJK - Claude Code Chinese Enhanced",
-    "zh-CN": "CCJK - Claude Code \u4E2D\u6587\u589E\u5F3A\u7248"
-  },
-  groups: [coreGroup, featuresGroup, settingsGroup$1],
-  footer: footerItems
-};
-
-const apiConfigMenu = {
-  id: "api-config",
-  label: {
-    "en": "API Configuration",
-    "zh-CN": "API \u914D\u7F6E\u7BA1\u7406"
-  },
-  description: {
-    "en": "One-click API setup, start using Claude",
-    "zh-CN": "\u4E00\u952E\u914D\u7F6E API\uFF0C\u5F00\u59CB\u4F7F\u7528 Claude"
-  },
-  icon: "\u{1F511}",
-  shortcut: "1",
-  priority: "core",
-  submenu: [
-    {
-      id: "api-official",
-      label: {
-        "en": "Use Official Login (No API needed)",
-        "zh-CN": "\u4F7F\u7528\u5B98\u65B9\u767B\u5F55\uFF08\u4E0D\u914D\u7F6E API\uFF09"
-      },
-      description: {
-        "en": "Recommended for new users",
-        "zh-CN": "\u63A8\u8350\u65B0\u7528\u6237\u4F7F\u7528"
-      },
-      icon: "\u2728",
-      shortcut: "1",
-      action: { type: "command", handler: "api:official" }
-    },
-    {
-      id: "api-custom",
-      label: {
-        "en": "Custom API Configuration",
-        "zh-CN": "\u81EA\u5B9A\u4E49 API \u914D\u7F6E"
-      },
-      description: {
-        "en": "Configure API Key and URL",
-        "zh-CN": "\u914D\u7F6E API Key \u548C URL"
-      },
-      icon: "\u2699\uFE0F",
-      shortcut: "2",
-      action: { type: "command", handler: "api:custom" }
-    },
-    {
-      id: "api-ccr",
-      label: {
-        "en": "Use CCR Proxy",
-        "zh-CN": "\u4F7F\u7528 CCR \u4EE3\u7406"
-      },
-      description: {
-        "en": "Access API through proxy",
-        "zh-CN": "\u901A\u8FC7\u4EE3\u7406\u8BBF\u95EE API"
-      },
-      icon: "\u{1F310}",
-      shortcut: "3",
-      action: { type: "command", handler: "api:ccr" }
-    },
-    {
-      id: "api-switch",
-      label: {
-        "en": "Switch API Configuration",
-        "zh-CN": "\u5207\u6362 API \u914D\u7F6E"
-      },
-      description: {
-        "en": "Switch between configurations",
-        "zh-CN": "\u5728\u591A\u4E2A\u914D\u7F6E\u95F4\u5207\u6362"
-      },
-      icon: "\u{1F504}",
-      shortcut: "4",
-      action: { type: "command", handler: "api:switch" }
-    },
-    {
-      id: "api-status",
-      label: {
-        "en": "View Current Configuration",
-        "zh-CN": "\u67E5\u770B\u5F53\u524D\u914D\u7F6E"
-      },
-      description: {
-        "en": "Show current API settings",
-        "zh-CN": "\u663E\u793A\u5F53\u524D API \u8BBE\u7F6E"
-      },
-      icon: "\u{1F4CB}",
-      shortcut: "5",
-      action: { type: "command", handler: "api:status" }
-    },
-    {
-      id: "api-skip",
-      label: {
-        "en": "Skip API Configuration",
-        "zh-CN": "\u8DF3\u8FC7 API \u914D\u7F6E"
-      },
-      description: {
-        "en": "Configure later",
-        "zh-CN": "\u7A0D\u540E\u914D\u7F6E"
-      },
-      icon: "\u23ED\uFE0F",
-      shortcut: "6",
-      action: { type: "function", handler: async () => {
-      } }
-    }
-  ]
-};
-const quickStartGroup = {
-  id: "quick-start",
-  label: {
-    "en": "Quick Start",
-    "zh-CN": "\u5FEB\u901F\u5F00\u59CB"
-  },
-  icon: "\u{1F680}",
-  priority: "feature",
-  items: [
-    {
-      id: "init-project",
-      label: {
-        "en": "Initialize Project",
-        "zh-CN": "\u521D\u59CB\u5316\u9879\u76EE"
-      },
-      description: {
-        "en": "Configure CCJK for current project",
-        "zh-CN": "\u4E3A\u5F53\u524D\u9879\u76EE\u914D\u7F6E CCJK"
-      },
-      icon: "\u{1F4E6}",
-      action: { type: "command", handler: "ccjk:init" }
-    },
-    {
-      id: "install-skills",
-      label: {
-        "en": "Install Skills",
-        "zh-CN": "\u5B89\u88C5\u6280\u80FD"
-      },
-      description: {
-        "en": "One-click install common skill packs",
-        "zh-CN": "\u4E00\u952E\u5B89\u88C5\u5E38\u7528\u6280\u80FD\u5305"
-      },
-      icon: "\u{1F3AF}",
-      action: { type: "command", handler: "ccjk:skills" }
-    },
-    {
-      id: "setup-mcp",
-      label: {
-        "en": "Setup MCP Services",
-        "zh-CN": "\u914D\u7F6E MCP \u670D\u52A1"
-      },
-      description: {
-        "en": "Configure MCP service connections",
-        "zh-CN": "\u8BBE\u7F6E MCP \u670D\u52A1\u8FDE\u63A5"
-      },
-      icon: "\u{1F50C}",
-      action: { type: "command", handler: "ccjk:mcp" }
-    }
-  ]
-};
-const projectManagementGroup = {
-  id: "project-management",
-  label: {
-    "en": "Project Management",
-    "zh-CN": "\u9879\u76EE\u7BA1\u7406"
-  },
-  icon: "\u{1F6E0}\uFE0F",
-  priority: "feature",
-  items: [
-    {
-      id: "skills-management",
-      label: {
-        "en": "Skills Management",
-        "zh-CN": "Skills \u6280\u80FD\u7BA1\u7406"
-      },
-      description: {
-        "en": "Install, view, remove skills",
-        "zh-CN": "\u5B89\u88C5\u3001\u67E5\u770B\u3001\u5220\u9664\u6280\u80FD"
-      },
-      icon: "\u{1F3AF}",
-      action: { type: "command", handler: "ccjk:skills" }
-    },
-    {
-      id: "mcp-management",
-      label: {
-        "en": "MCP Services",
-        "zh-CN": "MCP \u670D\u52A1\u7BA1\u7406"
-      },
-      description: {
-        "en": "Configure, test MCP services",
-        "zh-CN": "\u914D\u7F6E\u3001\u6D4B\u8BD5 MCP \u670D\u52A1"
-      },
-      icon: "\u{1F50C}",
-      action: { type: "command", handler: "ccjk:mcp" }
-    },
-    {
-      id: "agents-management",
-      label: {
-        "en": "Agents Management",
-        "zh-CN": "Agents \u4EE3\u7406\u7BA1\u7406"
-      },
-      description: {
-        "en": "Create, edit AI agents",
-        "zh-CN": "\u521B\u5EFA\u3001\u7F16\u8F91 AI \u4EE3\u7406"
-      },
-      icon: "\u{1F916}",
-      action: { type: "command", handler: "ccjk:agents" }
-    },
-    {
-      id: "hooks-management",
-      label: {
-        "en": "Hooks Management",
-        "zh-CN": "Hooks \u94A9\u5B50\u7BA1\u7406"
-      },
-      description: {
-        "en": "Configure Git hooks",
-        "zh-CN": "\u914D\u7F6E Git \u94A9\u5B50"
-      },
-      icon: "\u{1FA9D}",
-      action: { type: "command", handler: "ccjk:hooks" }
-    }
-  ]
-};
-const sessionManagementGroup = {
-  id: "session-management",
-  label: {
-    "en": "Session & Context",
-    "zh-CN": "\u4F1A\u8BDD\u7BA1\u7406"
-  },
-  icon: "\u{1F4AC}",
-  priority: "feature",
-  items: [
-    {
-      id: "session-create",
-      label: {
-        "en": "Create New Session",
-        "zh-CN": "\u521B\u5EFA\u65B0\u4F1A\u8BDD"
-      },
-      description: {
-        "en": "Start a new conversation session",
-        "zh-CN": "\u5F00\u59CB\u65B0\u7684\u5BF9\u8BDD\u4F1A\u8BDD"
-      },
-      icon: "\u2795",
-      action: { type: "command", handler: "session:create" }
-    },
-    {
-      id: "session-restore",
-      label: {
-        "en": "Restore Session",
-        "zh-CN": "\u6062\u590D\u4F1A\u8BDD"
-      },
-      description: {
-        "en": "Continue from history",
-        "zh-CN": "\u4ECE\u5386\u53F2\u4F1A\u8BDD\u7EE7\u7EED"
-      },
-      icon: "\u{1F504}",
-      action: { type: "command", handler: "session:restore" }
-    },
-    {
-      id: "session-list",
-      label: {
-        "en": "Session List",
-        "zh-CN": "\u4F1A\u8BDD\u5217\u8868"
-      },
-      description: {
-        "en": "View all saved sessions",
-        "zh-CN": "\u67E5\u770B\u6240\u6709\u4FDD\u5B58\u7684\u4F1A\u8BDD"
-      },
-      icon: "\u{1F4CB}",
-      action: { type: "command", handler: "session:list" }
-    },
-    {
-      id: "context-management",
-      label: {
-        "en": "Context Management",
-        "zh-CN": "\u4E0A\u4E0B\u6587\u7BA1\u7406"
-      },
-      description: {
-        "en": "Compact, clean context",
-        "zh-CN": "\u538B\u7F29\u3001\u6E05\u7406\u4E0A\u4E0B\u6587"
-      },
-      icon: "\u{1F4CA}",
-      action: { type: "command", handler: "context:manage" }
-    },
-    {
-      id: "session-export",
-      label: {
-        "en": "Export Session",
-        "zh-CN": "\u5BFC\u51FA\u4F1A\u8BDD"
-      },
-      description: {
-        "en": "Export as Markdown",
-        "zh-CN": "\u5BFC\u51FA\u4E3A Markdown"
-      },
-      icon: "\u{1F4E4}",
-      action: { type: "command", handler: "session:export" }
-    },
-    {
-      id: "session-cleanup",
-      label: {
-        "en": "Cleanup Cache",
-        "zh-CN": "\u6E05\u7406\u7F13\u5B58"
-      },
-      description: {
-        "en": "Clean session cache data",
-        "zh-CN": "\u6E05\u7406\u4F1A\u8BDD\u7F13\u5B58\u6570\u636E"
-      },
-      icon: "\u{1F9F9}",
-      action: { type: "command", handler: "session:cleanup" }
-    }
-  ]
-};
-const settingsGroup = {
-  id: "settings",
-  label: {
-    "en": "Settings",
-    "zh-CN": "\u7CFB\u7EDF\u8BBE\u7F6E"
-  },
-  icon: "\u2699\uFE0F",
-  priority: "setting",
-  items: [
-    {
-      id: "language-setting",
-      label: {
-        "en": "Language",
-        "zh-CN": "\u8BED\u8A00\u8BBE\u7F6E"
-      },
-      description: {
-        "en": "Switch interface language",
-        "zh-CN": "\u5207\u6362\u754C\u9762\u8BED\u8A00 (en/zh-CN)"
-      },
-      icon: "\u{1F310}",
-      action: { type: "command", handler: "settings:language" }
-    },
-    {
-      id: "advanced-setting",
-      label: {
-        "en": "Advanced Settings",
-        "zh-CN": "\u9AD8\u7EA7\u8BBE\u7F6E"
-      },
-      description: {
-        "en": "Debug, logs, performance",
-        "zh-CN": "\u8C03\u8BD5\u3001\u65E5\u5FD7\u3001\u6027\u80FD"
-      },
-      icon: "\u{1F527}",
-      action: { type: "command", handler: "settings:advanced" }
-    },
-    {
-      id: "reset-setting",
-      label: {
-        "en": "Reset Settings",
-        "zh-CN": "\u91CD\u7F6E\u8BBE\u7F6E"
-      },
-      description: {
-        "en": "Restore default settings",
-        "zh-CN": "\u6062\u590D\u9ED8\u8BA4\u8BBE\u7F6E"
-      },
-      icon: "\u21A9\uFE0F",
-      action: { type: "command", handler: "settings:reset" }
-    }
-  ]
-};
-const helpGroup = {
-  id: "help",
-  label: {
-    "en": "Help & Documentation",
-    "zh-CN": "\u5E2E\u52A9\u6587\u6863"
-  },
-  icon: "\u{1F4DA}",
-  priority: "help",
-  items: [
-    {
-      id: "command-reference",
-      label: {
-        "en": "Command Reference",
-        "zh-CN": "\u547D\u4EE4\u53C2\u8003"
-      },
-      description: {
-        "en": "Detailed command documentation",
-        "zh-CN": "\u6240\u6709\u547D\u4EE4\u7684\u8BE6\u7EC6\u8BF4\u660E"
-      },
-      icon: "\u{1F4D6}",
-      action: { type: "command", handler: "help:commands" }
-    },
-    {
-      id: "quick-tutorial",
-      label: {
-        "en": "Quick Tutorial",
-        "zh-CN": "\u5FEB\u901F\u6559\u7A0B"
-      },
-      description: {
-        "en": "5-minute getting started guide",
-        "zh-CN": "5 \u5206\u949F\u4E0A\u624B\u6307\u5357"
-      },
-      icon: "\u{1F393}",
-      action: { type: "command", handler: "help:tutorial" }
-    },
-    {
-      id: "faq",
-      label: {
-        "en": "FAQ",
-        "zh-CN": "\u5E38\u89C1\u95EE\u9898"
-      },
-      description: {
-        "en": "FAQ and troubleshooting",
-        "zh-CN": "FAQ \u548C\u6545\u969C\u6392\u9664"
-      },
-      icon: "\u2753",
-      action: { type: "command", handler: "help:faq" }
-    },
-    {
-      id: "about",
-      label: {
-        "en": "About CCJK",
-        "zh-CN": "\u5173\u4E8E CCJK"
-      },
-      description: {
-        "en": "Version info and credits",
-        "zh-CN": "\u7248\u672C\u4FE1\u606F\u548C\u81F4\u8C22"
-      },
-      icon: "\u2139\uFE0F",
-      action: { type: "command", handler: "help:about" }
-    }
-  ]
-};
-const mainMenuConfig = {
-  title: {
-    "en": "CCJK - Claude Code JK",
-    "zh-CN": "CCJK - Claude Code JK"
-  },
-  groups: [
-    // 核心功能组（API 配置在第一位）
-    {
-      id: "core",
-      label: {
-        "en": "Core Features",
-        "zh-CN": "\u6838\u5FC3\u529F\u80FD"
-      },
-      icon: "\u2605",
-      priority: "core",
-      items: [apiConfigMenu]
-    },
-    // 功能模块组
-    quickStartGroup,
-    projectManagementGroup,
-    sessionManagementGroup,
-    settingsGroup,
-    helpGroup
-  ],
-  footer: [
-    {
-      id: "exit",
-      label: {
-        "en": "Exit",
-        "zh-CN": "\u9000\u51FA"
-      },
-      icon: "\u{1F6AA}",
-      shortcut: "q",
-      action: { type: "function", handler: async () => process.exit(0) }
-    }
-  ]
-};
-function getLocalizedLabel(label, locale = "zh-CN") {
-  if (typeof label === "string") {
-    return label;
-  }
-  return label[locale] || label.en || Object.values(label)[0] || "";
-}
-
-class MenuRenderer {
-  locale;
-  showStatusBar;
-  showBreadcrumb;
-  showShortcuts;
-  constructor(options = {}) {
-    this.locale = options.locale || "zh-CN";
-    this.showStatusBar = options.showStatusBar ?? true;
-    this.showBreadcrumb = options.showBreadcrumb ?? true;
-    this.showShortcuts = options.showShortcuts ?? true;
-  }
-  /**
-   * 渲染状态栏
-   */
-  renderStatusBar(projectInfo, apiStatus) {
-    if (!this.showStatusBar)
-      return "";
-    const lines = [];
-    const width = 60;
-    const border = "\u2500".repeat(width - 2);
-    lines.push(ansis.dim(`\u256D${border}\u256E`));
-    if (projectInfo) {
-      const projectLine = [
-        `Project: ${ansis.cyan(projectInfo.name || "Unknown")}`,
-        projectInfo.type ? `Type: ${ansis.yellow(projectInfo.type)}` : "",
-        projectInfo.language ? `Lang: ${ansis.green(projectInfo.language)}` : ""
-      ].filter(Boolean).join(" | ");
-      lines.push(ansis.dim("\u2502 ") + projectLine.padEnd(width - 4) + ansis.dim(" \u2502"));
-    }
-    if (apiStatus) {
-      const statusIcon = apiStatus.configured ? ansis.green("\u2713") : ansis.yellow("\u26A0");
-      const statusText = apiStatus.configured ? `API: ${statusIcon} ${apiStatus.mode || "configured"}` : `API: ${statusIcon} \u672A\u914D\u7F6E`;
-      lines.push(ansis.dim("\u2502 ") + statusText.padEnd(width - 4) + ansis.dim(" \u2502"));
-    }
-    lines.push(ansis.dim(`\u2570${border}\u256F`));
-    return `${lines.join("\n")}
-`;
-  }
-  /**
-   * 渲染面包屑导航
-   */
-  renderBreadcrumb(path) {
-    if (!this.showBreadcrumb || path.length === 0)
-      return "";
-    const breadcrumb = ["Home", ...path].join(" > ");
-    return `${ansis.dim(`\u{1F4CD} ${breadcrumb}`)}
-
-`;
-  }
-  /**
-   * 渲染菜单项
-   */
-  formatMenuItem(item, index) {
-    const icon = item.icon || "";
-    const label = getLocalizedLabel(item.label, this.locale);
-    const description = item.description ? ansis.dim(getLocalizedLabel(item.description, this.locale)) : "";
-    item.shortcut ? `${item.shortcut}.` : `${index + 1}.`;
-    const mainText = `${icon} ${label}`.trim();
-    const padding = " ".repeat(Math.max(1, 30 - mainText.length));
-    return `${mainText}${padding}${description}`;
-  }
-  /**
-   * 渲染菜单组分隔符
-   */
-  renderGroupSeparator(group) {
-    const label = getLocalizedLabel(group.label, this.locale);
-    const icon = group.icon || "\u25C6";
-    const separator = "\u2500".repeat(50);
-    if (group.priority === "core") {
-      return `
-  ${ansis.bold("\u2605")} ${ansis.bold(label)} ${ansis.dim(separator)}`;
-    }
-    return `
-  ${icon} ${label} ${ansis.dim(separator)}`;
-  }
-  /**
-   * 渲染主菜单
-   */
-  async renderMainMenu(config, projectInfo, apiStatus) {
-    console.clear();
-    console.log(this.renderStatusBar(projectInfo, apiStatus));
-    const choices = [];
-    for (const group of config.groups) {
-      choices.push(new inquirer.Separator(this.renderGroupSeparator(group)));
-      for (let i = 0; i < group.items.length; i++) {
-        const item = group.items[i];
-        if (item.condition) {
-          const visible = await item.condition();
-          if (!visible)
-            continue;
-        }
-        choices.push({
-          name: this.formatMenuItem(item, i),
-          value: item,
-          short: getLocalizedLabel(item.label, this.locale)
-        });
-      }
-    }
-    choices.push(new inquirer.Separator(ansis.dim(`
-  ${"\u2500".repeat(55)}`)));
-    if (config.footer) {
-      for (const item of config.footer) {
-        choices.push({
-          name: this.formatMenuItem(item, 0),
-          value: item,
-          short: getLocalizedLabel(item.label, this.locale)
-        });
-      }
-    }
-    if (this.showShortcuts) {
-      const shortcuts = ansis.dim("  q. \u9000\u51FA    h. \u5E2E\u52A9    /. \u641C\u7D22");
-      choices.push(new inquirer.Separator(shortcuts));
-    }
-    const { selection } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "selection",
-        message: this.locale === "zh-CN" ? "\u8BF7\u9009\u62E9\u64CD\u4F5C:" : "Select an action:",
-        choices,
-        pageSize: 20,
-        loop: false
-      }
-    ]);
-    return {
-      item: selection,
-      action: "select"
-    };
-  }
-  /**
-   * 渲染子菜单
-   */
-  async renderSubmenu(item, breadcrumb) {
-    if (!item.submenu || item.submenu.length === 0) {
-      return { item, action: "select" };
-    }
-    console.clear();
-    console.log(this.renderBreadcrumb(breadcrumb));
-    const title = getLocalizedLabel(item.label, this.locale);
-    const description = item.description ? getLocalizedLabel(item.description, this.locale) : "";
-    console.log(`${item.icon || ""} ${ansis.bold(title)}`);
-    if (description) {
-      console.log(ansis.dim(description));
-    }
-    console.log("");
-    const choices = [];
-    for (let i = 0; i < item.submenu.length; i++) {
-      const subItem = item.submenu[i];
-      if (subItem.condition) {
-        const visible = await subItem.condition();
-        if (!visible)
-          continue;
-      }
-      choices.push({
-        name: this.formatMenuItem(subItem, i),
-        value: subItem,
-        short: getLocalizedLabel(subItem.label, this.locale)
-      });
-    }
-    choices.push(new inquirer.Separator(ansis.dim(`
-  ${"\u2500".repeat(55)}`)));
-    choices.push({
-      name: `${ansis.dim("\u2190")} ${this.locale === "zh-CN" ? "\u8FD4\u56DE\u4E3B\u83DC\u5355" : "Back to main menu"}`,
-      value: "back",
-      short: "Back"
-    });
-    const { selection } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "selection",
-        message: this.locale === "zh-CN" ? "\u8BF7\u9009\u62E9:" : "Select:",
-        choices,
-        pageSize: 15,
-        loop: false
-      }
-    ]);
-    if (selection === "back") {
-      return { item, action: "back" };
-    }
-    return {
-      item: selection,
-      action: "select"
-    };
-  }
-  /**
-   * 设置语言
-   */
-  setLocale(locale) {
-    this.locale = locale;
-  }
-  /**
-   * 获取当前语言
-   */
-  getLocale() {
-    return this.locale;
-  }
-}
-function createMenuRenderer(options) {
-  return new MenuRenderer(options);
-}
-
-class MenuEngine {
-  renderer;
-  state;
-  config;
-  commandHandlers;
-  constructor(options = {}) {
-    this.renderer = new MenuRenderer(options);
-    this.state = {
-      currentPath: [],
-      history: [],
-      searchQuery: void 0,
-      projectInfo: void 0,
-      apiStatus: void 0
-    };
-    this.config = mainMenuConfig;
-    this.commandHandlers = /* @__PURE__ */ new Map();
-  }
-  /**
-   * 注册命令处理器
-   */
-  registerHandler(command, handler) {
-    this.commandHandlers.set(command, handler);
-  }
-  /**
-   * 批量注册命令处理器
-   */
-  registerHandlers(handlers) {
-    for (const [command, handler] of Object.entries(handlers)) {
-      this.commandHandlers.set(command, handler);
-    }
-  }
-  /**
-   * 设置项目信息
-   */
-  setProjectInfo(info) {
-    this.state.projectInfo = info;
-  }
-  /**
-   * 设置 API 状态
-   */
-  setApiStatus(status) {
-    this.state.apiStatus = status;
-  }
-  /**
-   * 刷新项目信息（按需分析）
-   */
-  async refreshProjectInfo() {
-    try {
-      const { detectProjectInfo } = await import('./chunks/project-detector.mjs');
-      this.state.projectInfo = await detectProjectInfo();
-    } catch {
-      this.state.projectInfo = {
-        name: "Unknown",
-        type: void 0,
-        language: void 0
-      };
-    }
-  }
-  /**
-   * 刷新 API 状态
-   */
-  async refreshApiStatus() {
-    try {
-      const { detectApiStatus } = await import('./chunks/api-adapter.mjs');
-      this.state.apiStatus = await detectApiStatus();
-    } catch {
-      this.state.apiStatus = {
-        configured: false,
-        mode: "none"
-      };
-    }
-  }
-  /**
-   * 执行菜单动作
-   */
-  async executeAction(item) {
-    if (!item.action)
-      return false;
-    const { type, handler } = item.action;
-    switch (type) {
-      case "command": {
-        if (typeof handler === "string") {
-          const commandHandler = this.commandHandlers.get(handler);
-          if (commandHandler) {
-            await commandHandler();
-            return true;
-          }
-          console.log(`Command not found: ${handler}`);
-          return false;
-        }
-        return false;
-      }
-      case "function": {
-        if (typeof handler === "function") {
-          await handler();
-          return true;
-        }
-        return false;
-      }
-      case "submenu": {
-        return true;
-      }
-      case "external": {
-        if (typeof handler === "string") {
-          const { exec } = await import('node:child_process');
-          exec(`open ${handler}`);
-          return true;
-        }
-        return false;
-      }
-      default:
-        return false;
-    }
-  }
-  /**
-   * 处理菜单选择
-   */
-  async handleSelection(selection) {
-    const { item, action } = selection;
-    switch (action) {
-      case "exit":
-        return "exit";
-      case "back":
-        if (this.state.currentPath.length > 0) {
-          this.state.currentPath.pop();
-          this.state.history.pop();
-        }
-        return "continue";
-      case "select": {
-        if (item.id === "exit") {
-          return "exit";
-        }
-        if (item.submenu && item.submenu.length > 0) {
-          const label = getLocalizedLabel(item.label, this.renderer.getLocale());
-          this.state.currentPath.push(label);
-          this.state.history.push(this.state.currentPath.slice());
-          const subSelection = await this.renderer.renderSubmenu(
-            item,
-            this.state.currentPath
-          );
-          return this.handleSelection(subSelection);
-        }
-        await this.executeAction(item);
-        return "continue";
-      }
-      default:
-        return "continue";
-    }
-  }
-  /**
-   * 启动菜单
-   */
-  async start() {
-    let running = true;
-    while (running) {
-      try {
-        const selection = await this.renderer.renderMainMenu(
-          this.config,
-          this.state.projectInfo,
-          this.state.apiStatus
-        );
-        const result = await this.handleSelection(selection);
-        if (result === "exit") {
-          running = false;
-        }
-      } catch (error) {
-        if (error?.isTtyError || error?.message?.includes("User force closed")) {
-          running = false;
-        } else {
-          console.error("Menu error:", error);
-          running = false;
-        }
-      }
-    }
-    process.exit(0);
-  }
-  /**
-   * 导航到指定菜单
-   */
-  async navigate(path) {
-    this.state.currentPath = path;
-    this.state.history = [path.slice()];
-  }
-  /**
-   * 返回上级
-   */
-  async back() {
-    if (this.state.currentPath.length > 0) {
-      this.state.currentPath.pop();
-      this.state.history.pop();
-    }
-  }
-  /**
-   * 退出菜单
-   */
-  exit() {
-    process.exit(0);
-  }
-  /**
-   * 获取当前状态
-   */
-  getState() {
-    return { ...this.state };
-  }
-  /**
-   * 设置语言
-   */
-  setLocale(locale) {
-    this.renderer.setLocale(locale);
-  }
-}
-function createMenuEngine(options) {
-  return new MenuEngine(options);
-}
-
-const menuEngine = {
-  __proto__: null,
-  MenuEngine: MenuEngine,
-  createMenuEngine: createMenuEngine
-};
-
-async function showMenu() {
-  const { runCli: runCli2 } = await Promise.resolve().then(function () { return cli; });
-  await runCli2();
-}
-async function startMenu(options = {}) {
-  const { createMenuEngine: createMenuEngine2 } = await Promise.resolve().then(function () { return menuEngine; });
-  const engine = createMenuEngine2({
-    locale: options.locale,
-    showStatusBar: options.showStatusBar ?? true,
-    showBreadcrumb: options.showBreadcrumb ?? true,
-    showShortcuts: options.showShortcuts ?? true
-  });
-  await registerDefaultHandlers(engine);
-  await engine.start();
-}
-async function registerDefaultHandlers(engine) {
-  engine.registerHandlers({
-    "api:official": async () => {
-      console.log("\u4F7F\u7528\u5B98\u65B9\u767B\u5F55...");
-    },
-    "api:custom": async () => {
-      const { runWizard } = await import('./chunks/api.mjs');
-      await runWizard();
-    },
-    "api:ccr": async () => {
-      const { runCcrMenuFeature } = await import('./chunks/tools.mjs').then(function (n) { return n.t; });
-      await runCcrMenuFeature();
-    },
-    "api:switch": async () => {
-      const { configSwitchCommand } = await import('./chunks/config-switch.mjs');
-      await configSwitchCommand({ codeType: "claude-code" });
-    },
-    "api:status": async () => {
-      console.log("\u67E5\u770B\u5F53\u524D API \u914D\u7F6E...");
-    }
-  });
-  engine.registerHandlers({
-    "ccjk:init": async () => {
-      const { init } = await import('./chunks/init.mjs');
-      await init({ skipBanner: true });
-    },
-    "ccjk:skills": async () => {
-      console.log("\u6280\u80FD\u7BA1\u7406...");
-    },
-    "ccjk:mcp": async () => {
-      const { mcpHelp } = await import('./chunks/mcp.mjs');
-      mcpHelp();
-    },
-    "ccjk:agents": async () => {
-      console.log("\u4EE3\u7406\u7BA1\u7406...");
-    },
-    "ccjk:hooks": async () => {
-      const { hooksSync } = await import('./chunks/hooks-sync.mjs');
-      await hooksSync({});
-    }
-  });
-  engine.registerHandlers({
-    "session:create": async () => {
-      console.log("\u521B\u5EFA\u65B0\u4F1A\u8BDD...");
-    },
-    "session:restore": async () => {
-      console.log("\u6062\u590D\u4F1A\u8BDD...");
-    },
-    "session:list": async () => {
-      console.log("\u4F1A\u8BDD\u5217\u8868...");
-    },
-    "context:manage": async () => {
-      const { showContextMenu } = await import('./chunks/context-menu.mjs');
-      await showContextMenu();
-    },
-    "session:export": async () => {
-      console.log("\u5BFC\u51FA\u4F1A\u8BDD...");
-    },
-    "session:cleanup": async () => {
-      console.log("\u6E05\u7406\u7F13\u5B58...");
-    }
-  });
-  engine.registerHandlers({
-    "settings:language": async () => {
-      const { changeScriptLanguageFeature } = await import('./chunks/features.mjs');
-      const { i18n } = await import('./chunks/index.mjs');
-      await changeScriptLanguageFeature(i18n.language);
-    },
-    "settings:advanced": async () => {
-      console.log("\u9AD8\u7EA7\u8BBE\u7F6E...");
-    },
-    "settings:reset": async () => {
-      console.log("\u91CD\u7F6E\u8BBE\u7F6E...");
-    }
-  });
-  engine.registerHandlers({
-    "help:commands": async () => {
-      console.log("\u547D\u4EE4\u53C2\u8003...");
-    },
-    "help:tutorial": async () => {
-      console.log("\u5FEB\u901F\u6559\u7A0B...");
-    },
-    "help:faq": async () => {
-      console.log("\u5E38\u89C1\u95EE\u9898...");
-    },
-    "help:about": async () => {
-      const VERSION = "1.0.0";
-      console.log(`CCJK - Claude Code JK v${VERSION}`);
-      console.log("https://github.com/anthropics/claude-code");
-    }
-  });
-}
-
-const index$7 = {
-  __proto__: null,
-  MenuEngine: MenuEngine,
-  MenuRenderer: MenuRenderer,
-  apiConfigMenu: apiConfigMenu,
-  createMenuEngine: createMenuEngine,
-  createMenuRenderer: createMenuRenderer,
-  getLocalizedLabel: getLocalizedLabel,
-  helpGroup: helpGroup,
-  mainMenuConfig: mainMenuConfig,
-  newMainMenuConfig: mainMenuConfig$1,
-  projectManagementGroup: projectManagementGroup,
-  quickStartGroup: quickStartGroup,
-  runCli: runCli,
-  sessionManagementGroup: sessionManagementGroup,
-  settingsGroup: settingsGroup,
-  showMenu: showMenu,
-  startMenu: startMenu
-};
-
 function unique(arr) {
   return [...new Set(arr)];
 }
@@ -7844,4 +3665,4 @@ function assert(condition, message) {
   }
 }
 
-export { ActionbookEngine, AiderTool, BaseCodeTool, BaseError, ClaudeCodeTool, ClineTool, CodexTool, ConfigManager, ConfigValidator, ConfigurationError, ContinueTool, CursorTool, DependencyTracker, FileWatcher, IncrementalIndexer, InternalError, Logger, MenuEngine, MenuRenderer, MultiLevelIndex, Mutex, NotFoundError, QueryAPIRouter, Semaphore, TimeoutError, ToolFactory, ToolRegistry, UnauthorizedError, ValidationError, apiConfigMenu, index$6 as array, assert, assertDefined, ast, index$5 as async, batchProcessFiles, callGraph, camelCase, capitalize, chunk, closeGlobalIndex, closeGlobalWatcher, index$4 as command, commandExists, copyFile, countLines, createConfigManager, createEngine, createLogger, createMenuEngine, createMenuRenderer, createTool, createValidator, debounce, deepClone, deepMerge, deleteDir, deleteFile, difference, ensureDir, index$3 as error, executeCommand, executeCommandStream, exists, flatten, flatten$1 as flattenArray, formatError, index$2 as fs, generateCompactWelcome, generateRecommendations, generateWelcome, get, getArchitecture, getCacheDir, getCapabilitiesByType, getCapability, getCommandPath, getCommandVersion, getConfigDir, getDataDir, getErrorMessage, getFileInfo, getFileSize, getGlobalIndex, getGlobalIndexer, getGlobalTracker, getGlobalWatcher, getHomeDir, getLocalizedLabel, getPlatform, getPlatformInfo, getQueryAPI, getRegistry, getTempDir, has, helpGroup, intersection, isArray, isBoolean, isDefined, isDirectory, isEmail, isFile, isLargeFile, isLinux, isMacOS, isNumber, isObject, isString, isURL, isUnix, isWindows, kebabCase, listDirs, listFiles, logger, logger$2 as loggerUtils, mainMenuConfig, moveFile, mainMenuConfig$1 as newMainMenuConfig, index$1 as object, omit, parallelLimit, partition, pascalCase, pick, processLargeFile, processLineByLine, projectManagementGroup, quickStartGroup, readFile, readJSON, resetGlobalIndexer, resetGlobalTracker, retry, runCli, scanCapabilities, sequence, sessionManagementGroup, set, settingsGroup, showMenu, shuffle, sleep, slugify, snakeCase, startMenu, streamJSON, streamWriteJSON, index as string, symbols, template, throttle, timeout, truncate, tryCatch, tryCatchAsync, unflatten, union, unique, validation, validators, waitFor, wrapError, writeFile, writeJSON };
+export { AiderTool, BaseCodeTool, BaseError, ClaudeCodeTool, ClineTool, CodexTool, ConfigManager, ConfigValidator, ConfigurationError, ContinueTool, CursorTool, InternalError, Logger, Mutex, NotFoundError, Semaphore, TimeoutError, ToolFactory, ToolRegistry, UnauthorizedError, ValidationError, index$6 as array, assert, assertDefined, index$5 as async, batchProcessFiles, camelCase, capitalize, chunk, index$4 as command, commandExists, copyFile, countLines, createConfigManager, createLogger, createTool, createValidator, debounce, deepClone, deepMerge, deleteDir, deleteFile, difference, ensureDir, index$3 as error, executeCommand, executeCommandStream, exists, flatten, flatten$1 as flattenArray, formatError, index$2 as fs, generateCompactWelcome, generateRecommendations, generateWelcome, get, getArchitecture, getCacheDir, getCapabilitiesByType, getCapability, getCommandPath, getCommandVersion, getConfigDir, getDataDir, getErrorMessage, getFileInfo, getFileSize, getHomeDir, getPlatform, getPlatformInfo, getRegistry, getTempDir, has, intersection, isArray, isBoolean, isDefined, isDirectory, isEmail, isFile, isLargeFile, isLinux, isMacOS, isNumber, isObject, isString, isURL, isUnix, isWindows, kebabCase, listDirs, listFiles, logger, logger$2 as loggerUtils, moveFile, index$1 as object, omit, parallelLimit, partition, pascalCase, pick, processLargeFile, processLineByLine, readFile, readJSON, retry, scanCapabilities, sequence, set, shuffle, sleep, slugify, snakeCase, streamJSON, streamWriteJSON, index as string, template, throttle, timeout, truncate, tryCatch, tryCatchAsync, unflatten, union, unique, validation, validators, waitFor, wrapError, writeFile, writeJSON };