@side-quest/kit 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,2509 +1,8 @@
-// src/lib/ast/languages.ts
-import { createRequire } from "node:module";
-import { ResourcePool } from "@side-quest/core/concurrency";
-import { Language, Parser } from "web-tree-sitter";
-
-// src/lib/logger.ts
-import {
-  createCorrelationId,
-  createPluginLogger
-} from "@side-quest/core/logging";
-var {
-  initLogger,
-  rootLogger: logger,
-  getSubsystemLogger,
-  logDir,
-  logFile
-} = createPluginLogger({
-  name: "kit",
-  subsystems: [
-    "grep",
-    "semantic",
-    "symbols",
-    "fileTree",
-    "fileContent",
-    "usages",
-    "ast",
-    "commit",
-    "summarize"
-  ]
-});
-var grepLogger = getSubsystemLogger("grep");
-var semanticLogger = getSubsystemLogger("semantic");
-var symbolsLogger = getSubsystemLogger("symbols");
-var fileTreeLogger = getSubsystemLogger("fileTree");
-var fileContentLogger = getSubsystemLogger("fileContent");
-var usagesLogger = getSubsystemLogger("usages");
-var astLogger = getSubsystemLogger("ast");
-var commitLogger = getSubsystemLogger("commit");
-var summarizeLogger = getSubsystemLogger("summarize");
-function getKitLogger() {
-  return logger;
-}
-function getGrepLogger() {
-  return grepLogger;
-}
-function getSemanticLogger() {
-  return semanticLogger;
-}
-function getSymbolsLogger() {
-  return symbolsLogger;
-}
-function getFileTreeLogger() {
-  return fileTreeLogger;
-}
-function getFileContentLogger() {
-  return fileContentLogger;
-}
-function getUsagesLogger() {
-  return usagesLogger;
-}
-function getAstLogger() {
-  return astLogger;
-}
-
-// src/lib/ast/languages.ts
-var require2 = createRequire(import.meta.url);
-var LANGUAGES = {
-  ".ts": "typescript",
-  ".tsx": "tsx",
-  ".mts": "typescript",
-  ".cts": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascript",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".py": "python"
-};
-var SUPPORTED_LANGUAGES = [
-  "typescript",
-  "tsx",
-  "javascript",
-  "python"
-];
-var languagePool = new ResourcePool;
-var parserPool = new ResourcePool;
-var initialized = false;
-async function initParser() {
-  if (initialized)
-    return;
-  const logger2 = getAstLogger();
-  logger2.debug("Initializing tree-sitter parser");
-  try {
-    await Parser.init();
-    initialized = true;
-    logger2.debug("Tree-sitter parser initialized successfully");
-  } catch (error) {
-    logger2.error("Failed to initialize tree-sitter parser", {
-      error: error instanceof Error ? error.message : String(error)
-    });
-    throw error;
-  }
-}
-async function getParser(language) {
-  await initParser();
-  const logger2 = getAstLogger();
-  return parserPool.getOrCreate(language, async (lang) => {
-    logger2.debug("Creating new parser for language", { language: lang });
-    const parser = new Parser;
-    const grammar = await loadLanguage(lang);
-    parser.setLanguage(grammar);
-    return parser;
-  });
-}
-async function loadLanguage(language) {
-  const logger2 = getAstLogger();
-  return languagePool.getOrCreate(language, async (lang) => {
-    logger2.debug("Loading language grammar from WASM", { language: lang });
-    try {
-      const wasmPath = require2.resolve(`tree-sitter-wasms/out/tree-sitter-${lang}.wasm`);
-      const grammar = await Language.load(wasmPath);
-      logger2.debug("Language grammar loaded successfully", {
-        language: lang,
-        wasmPath
-      });
-      return grammar;
-    } catch (error) {
-      logger2.error("Failed to load language grammar", {
-        language: lang,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  });
-}
-function detectLanguage(filePath) {
-  const lastDot = filePath.lastIndexOf(".");
-  if (lastDot === -1)
-    return null;
-  const ext = filePath.substring(lastDot).toLowerCase();
-  const language = LANGUAGES[ext];
-  if (language && SUPPORTED_LANGUAGES.includes(language)) {
-    return language;
-  }
-  return null;
-}
-function isSupported(filePath) {
-  return detectLanguage(filePath) !== null;
-}
-function getSupportedGlob() {
-  const extensions = Object.keys(LANGUAGES).map((ext) => ext.slice(1));
-  return `**/*.{${extensions.join(",")}}`;
-}
-// src/lib/ast/types.ts
-var SearchMode;
-((SearchMode2) => {
-  SearchMode2["SIMPLE"] = "simple";
-  SearchMode2["PATTERN"] = "pattern";
-})(SearchMode ||= {});
-var AST_SEARCH_TIMEOUT = 60000;
-
-// src/lib/ast/pattern.ts
-var FUNCTION_NODE_TYPES = [
-  "function_declaration",
-  "function_expression",
-  "arrow_function",
-  "method_definition",
-  "generator_function_declaration",
-  "function_definition"
-];
-var CLASS_NODE_TYPES = [
-  "class_declaration",
-  "class_expression",
-  "class_definition"
-];
-var TRY_NODE_TYPES = [
-  "try_statement"
-];
-
-class ASTPattern {
-  pattern;
-  mode;
-  isAsync = false;
-  isDef = false;
-  isClass = false;
-  isTry = false;
-  isImport = false;
-  isExport = false;
-  criteria = {};
-  constructor(pattern, mode = "simple" /* SIMPLE */) {
-    this.pattern = pattern;
-    this.mode = mode;
-    this.compile();
-  }
-  compile() {
-    if (this.mode === "simple" /* SIMPLE */) {
-      this.compileSimple();
-    } else if (this.mode === "pattern" /* PATTERN */) {
-      this.compilePattern();
-    }
-  }
-  compileSimple() {
-    const lower = this.pattern.toLowerCase();
-    this.isAsync = lower.includes("async");
-    this.isDef = lower.includes("function") || lower.includes("def") || lower.includes("method");
-    this.isClass = lower.includes("class");
-    this.isTry = lower.includes("try") || lower.includes("catch");
-    this.isImport = lower.includes("import");
-    this.isExport = lower.includes("export");
-    if (!this.isAsync && !this.isDef && !this.isClass && !this.isTry && !this.isImport && !this.isExport) {
-      this.criteria = { textMatch: this.pattern };
-    }
-  }
-  compilePattern() {
-    try {
-      this.criteria = JSON.parse(this.pattern);
-    } catch (error) {
-      const logger2 = getAstLogger();
-      logger2.debug("Pattern JSON parse failed, using text match fallback", {
-        pattern: this.pattern,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      this.criteria = { textMatch: this.pattern };
-    }
-  }
-  matches(node, source) {
-    if (this.mode === "simple" /* SIMPLE */) {
-      return this.matchesSimple(node, source);
-    } else if (this.mode === "pattern" /* PATTERN */) {
-      return this.matchesPattern(node, source);
-    }
-    return false;
-  }
-  matchesSimple(node, source) {
-    const nodeType = node.type;
-    if (this.isDef || this.isClass || this.isTry || this.isImport || this.isExport) {
-      if (this.isDef && !this.isFunctionNode(nodeType))
-        return false;
-      if (this.isClass && !this.isClassNode(nodeType))
-        return false;
-      if (this.isTry && !TRY_NODE_TYPES.includes(nodeType))
-        return false;
-      if (this.isImport && !nodeType.includes("import"))
-        return false;
-      if (this.isExport && !nodeType.includes("export"))
-        return false;
-      if (this.isAsync && this.isDef) {
-        if (!this.hasAsyncModifier(node))
-          return false;
-      }
-      return true;
-    }
-    if (this.criteria.textMatch) {
-      const text = this.getNodeText(node, source);
-      return text.includes(this.criteria.textMatch);
-    }
-    return false;
-  }
-  matchesPattern(node, source) {
-    if (this.criteria.type && node.type !== this.criteria.type) {
-      return false;
-    }
-    if (this.criteria.async !== undefined) {
-      if (this.hasAsyncModifier(node) !== this.criteria.async) {
-        return false;
-      }
-    }
-    if (this.criteria.name) {
-      const name = this.getNodeName(node, source);
-      if (name !== this.criteria.name) {
-        return false;
-      }
-    }
-    if (this.criteria.textMatch) {
-      const text = this.getNodeText(node, source);
-      if (!text.includes(this.criteria.textMatch)) {
-        return false;
-      }
-    }
-    if (!this.criteria.type && !this.criteria.async && !this.criteria.name && !this.criteria.textMatch) {
-      return false;
-    }
-    return true;
-  }
-  isFunctionNode(type) {
-    return FUNCTION_NODE_TYPES.includes(type);
-  }
-  isClassNode(type) {
-    return CLASS_NODE_TYPES.includes(type);
-  }
-  hasAsyncModifier(node) {
-    for (const child of node.children) {
-      if (child && child.type === "async")
-        return true;
-    }
-    const firstPart = node.text?.slice(0, 10) ?? "";
-    return firstPart.includes("async");
-  }
-  getNodeName(node, source) {
-    for (const child of node.children) {
-      if (!child)
-        continue;
-      if (child.type === "identifier" || child.type === "type_identifier" || child.type === "property_identifier") {
-        return source.substring(child.startIndex, child.endIndex);
-      }
-    }
-    const nameChild = node.childForFieldName("name");
-    if (nameChild) {
-      return source.substring(nameChild.startIndex, nameChild.endIndex);
-    }
-    return;
-  }
-  getNodeText(node, source) {
-    return source.substring(node.startIndex, node.endIndex);
-  }
-}
-// src/lib/ast/searcher.ts
-import { readdir, readFile, stat } from "node:fs/promises";
-import { join, relative } from "node:path";
-import { processInParallelChunks } from "@side-quest/core/concurrency";
-
-// src/lib/types.ts
-var ResponseFormat;
-((ResponseFormat2) => {
-  ResponseFormat2["MARKDOWN"] = "markdown";
-  ResponseFormat2["JSON"] = "json";
-})(ResponseFormat ||= {});
-function isError(result) {
-  return typeof result === "object" && result !== null && "error" in result;
-}
-var KIT_DEFAULT_PATH_ENV = "KIT_DEFAULT_PATH";
-function getDefaultKitPath() {
-  return process.env[KIT_DEFAULT_PATH_ENV] || process.cwd();
-}
-var GREP_TIMEOUT = 30000;
-var SEMANTIC_TIMEOUT = 60000;
-var SYMBOLS_TIMEOUT = 45000;
-var FILE_TREE_TIMEOUT = 30000;
-var FILE_CONTENT_TIMEOUT = 15000;
-var USAGES_TIMEOUT = 45000;
-var COMMIT_TIMEOUT = 60000;
-var SUMMARIZE_TIMEOUT = 60000;
-var DEFAULT_MAX_RESULTS = 100;
-var DEFAULT_TOP_K = 5;
-
-// src/lib/ast/searcher.ts
-var MAX_FILE_SIZE = 5 * 1024 * 1024;
-var MAX_TEXT_LENGTH = 500;
-var PARALLEL_CHUNK_SIZE = 10;
-var SKIP_DIRS = new Set([
-  "node_modules",
-  ".git",
-  ".svn",
-  ".hg",
-  "__pycache__",
-  ".pytest_cache",
-  ".mypy_cache",
-  "dist",
-  "build",
-  ".next",
-  ".nuxt",
-  "coverage",
-  ".coverage",
-  "venv",
-  ".venv",
-  "env",
-  ".env"
-]);
-
-class ASTSearcher {
-  repoPath;
-  constructor(repoPath) {
-    this.repoPath = repoPath ?? getDefaultKitPath();
-  }
-  async searchPattern(options) {
-    const {
-      pattern,
-      mode = "simple" /* SIMPLE */,
-      filePattern,
-      maxResults = 100
-    } = options;
-    const astPattern = new ASTPattern(pattern, mode);
-    const files = await this.getMatchingFiles(filePattern);
-    const logger2 = getAstLogger();
-    logger2.debug("File search results", {
-      fileCount: files.length,
-      repoPath: this.repoPath,
-      filePattern,
-      firstFiles: files.slice(0, 3)
-    });
-    const matches = await processInParallelChunks({
-      items: files,
-      chunkSize: PARALLEL_CHUNK_SIZE,
-      maxResults,
-      processor: (filePath) => this.searchFile(filePath, astPattern),
-      onError: (filePath, error) => {
-        logger2.error("Error parsing file", {
-          filePath,
-          error: error.message
-        });
-        return [];
-      }
-    });
-    return {
-      count: matches.length,
-      matches,
-      pattern,
-      mode,
-      path: this.repoPath
-    };
-  }
-  async getMatchingFiles(filePattern) {
-    const files = [];
-    await this.walkDirectory(this.repoPath, files, filePattern);
-    return files;
-  }
-  async walkDirectory(dir, files, filePattern) {
-    const logger2 = getAstLogger();
-    let entries;
-    try {
-      entries = await readdir(dir);
-    } catch (error) {
-      logger2.warn("Failed to read directory", {
-        dir,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return;
-    }
-    await Promise.all(entries.map(async (entry) => {
-      if (SKIP_DIRS.has(entry) || entry.startsWith("."))
-        return;
-      const fullPath = join(dir, entry);
-      let stats;
-      try {
-        stats = await stat(fullPath);
-      } catch (error) {
-        logger2.debug("Failed to stat entry", {
-          path: fullPath,
-          error: error instanceof Error ? error.message : String(error)
-        });
-        return;
-      }
-      if (stats.isDirectory()) {
-        await this.walkDirectory(fullPath, files, filePattern);
-      } else if (stats.isFile()) {
-        if (stats.size > MAX_FILE_SIZE) {
-          logger2.warn("Skipping large file", {
-            path: fullPath,
-            size: stats.size,
-            maxSize: MAX_FILE_SIZE
-          });
-          return;
-        }
-        if (!isSupported(fullPath))
-          return;
-        if (filePattern && !this.matchesFilePattern(fullPath, filePattern)) {
-          return;
-        }
-        files.push(fullPath);
-      }
-    }));
-  }
-  matchesFilePattern(filePath, pattern) {
-    const relativePath = relative(this.repoPath, filePath);
-    const glob = new Bun.Glob(pattern);
-    return glob.match(relativePath);
-  }
-  async searchFile(filePath, pattern) {
-    const language = detectLanguage(filePath);
-    if (!language)
-      return [];
-    const parser = await getParser(language);
-    const source = await readFile(filePath, "utf8");
-    const tree = parser.parse(source);
-    if (!tree)
-      return [];
-    const matches = [];
-    this.searchNode(tree.rootNode, source, pattern, filePath, matches);
-    return matches;
-  }
-  searchNode(node, source, pattern, filePath, matches) {
-    if (pattern.matches(node, source)) {
-      const match = this.createMatch(node, source, filePath);
-      matches.push(match);
-    }
-    for (let i = 0;i < node.childCount; i++) {
-      const child = node.child(i);
-      if (child) {
-        this.searchNode(child, source, pattern, filePath, matches);
-      }
-    }
-  }
-  createMatch(node, source, filePath) {
-    return {
-      file: relative(this.repoPath, filePath),
-      line: node.startPosition.row + 1,
-      column: node.startPosition.column,
-      nodeType: node.type,
-      text: this.truncateText(source.substring(node.startIndex, node.endIndex)),
-      context: this.getContext(node, source)
-    };
-  }
-  getContext(node, source) {
-    const context = { nodeType: node.type };
-    let parent = node.parent;
-    while (parent) {
-      if (this.isFunctionNode(parent.type)) {
-        context.parentFunction = this.getNodeName(parent, source);
-        break;
-      }
-      if (this.isClassNode(parent.type)) {
-        context.parentClass = this.getNodeName(parent, source);
-        break;
-      }
-      parent = parent.parent;
-    }
-    return context;
-  }
-  getNodeName(node, source) {
-    const nameChild = node.childForFieldName("name");
-    if (nameChild) {
-      return source.substring(nameChild.startIndex, nameChild.endIndex);
-    }
-    for (let i = 0;i < node.childCount; i++) {
-      const child = node.child(i);
-      if (child && (child.type === "identifier" || child.type === "type_identifier")) {
-        return source.substring(child.startIndex, child.endIndex);
-      }
-    }
-    return;
-  }
-  isFunctionNode(type) {
-    return [
-      "function_declaration",
-      "function_definition",
-      "function_expression",
-      "arrow_function",
-      "method_definition",
-      "generator_function_declaration"
-    ].includes(type);
-  }
-  isClassNode(type) {
-    return [
-      "class_declaration",
-      "class_definition",
-      "class_expression"
-    ].includes(type);
-  }
-  truncateText(text) {
-    if (text.length <= MAX_TEXT_LENGTH)
-      return text;
-    return `${text.slice(0, MAX_TEXT_LENGTH - 3)}...`;
-  }
-}
-// src/lib/errors.ts
-import {
-  detectErrorFromOutput as coreDetectErrorFromOutput,
-  isTimeoutOutput,
-  PluginError
-} from "@side-quest/core/instrumentation";
-var KitErrorType;
-((KitErrorType2) => {
-  KitErrorType2["KitNotInstalled"] = "KitNotInstalled";
-  KitErrorType2["InvalidPath"] = "InvalidPath";
-  KitErrorType2["InvalidInput"] = "InvalidInput";
-  KitErrorType2["SemanticNotAvailable"] = "SemanticNotAvailable";
-  KitErrorType2["SemanticIndexNotBuilt"] = "SemanticIndexNotBuilt";
-  KitErrorType2["TooManyResults"] = "TooManyResults";
-  KitErrorType2["KitCommandFailed"] = "KitCommandFailed";
-  KitErrorType2["OutputParseError"] = "OutputParseError";
-  KitErrorType2["Timeout"] = "Timeout";
-})(KitErrorType ||= {});
-var ERROR_MESSAGES = {
-  ["KitNotInstalled" /* KitNotInstalled */]: {
-    message: "Kit CLI is not installed or not found in PATH.",
-    hint: "Install Kit with: uv tool install cased-kit"
-  },
-  ["InvalidPath" /* InvalidPath */]: {
-    message: "The specified path does not exist or is not accessible.",
-    hint: "Check the path exists and you have read permissions."
-  },
-  ["InvalidInput" /* InvalidInput */]: {
-    message: "Invalid input provided.",
-    hint: "Check your search pattern or options for syntax errors."
-  },
-  ["SemanticNotAvailable" /* SemanticNotAvailable */]: {
-    message: "Semantic search is not available.",
-    hint: `Install ML dependencies: pip install 'cased-kit[ml]' or uv tool install 'cased-kit[ml]'`
-  },
-  ["SemanticIndexNotBuilt" /* SemanticIndexNotBuilt */]: {
-    message: "Vector index has not been built for this repository yet.",
-    hint: "Build it by running the CLI command provided in the error details. After building (one-time), semantic search will be fast and cached."
-  },
-  ["TooManyResults" /* TooManyResults */]: {
-    message: "Query returned too many results.",
-    hint: "Try a more specific query or use --max-results to limit output."
-  },
-  ["KitCommandFailed" /* KitCommandFailed */]: {
-    message: "Kit command failed to execute.",
-    hint: "Check the error details below for more information."
-  },
-  ["OutputParseError" /* OutputParseError */]: {
-    message: "Failed to parse Kit output.",
-    hint: "This may be a bug. Check logs for details."
-  },
-  ["Timeout" /* Timeout */]: {
-    message: "Operation timed out (this may take longer on large repositories).",
-    hint: "Try again—the vector index will be cached. If it times out again, clear .kit/vector_db and rebuild with build_index: true."
-  }
-};
-
-class KitError extends PluginError {
-  constructor(type, details, stderr) {
-    const errorInfo = ERROR_MESSAGES[type];
-    super("KitError", type, errorInfo.message, errorInfo.hint, details, stderr);
-  }
-}
-var SEMANTIC_INSTALL_HINT = `
-Semantic search is not available. Using text search instead.
-
-To enable semantic search, install the ML dependencies:
-  pip install 'cased-kit[ml]'
-
-Or if using uv:
-  uv tool install 'cased-kit[ml]'
-`.trim();
-function isSemanticUnavailableError(stderr) {
-  const patterns = [
-    "sentence-transformers",
-    "chromadb",
-    "semantic search",
-    "vector index",
-    "embedding"
-  ];
-  const lowerStderr = stderr.toLowerCase();
-  return patterns.some((p) => lowerStderr.includes(p));
-}
-var isTimeoutError = isTimeoutOutput;
-var KIT_ERROR_PATTERNS = [
-  {
-    type: "SemanticNotAvailable" /* SemanticNotAvailable */,
-    patterns: [
-      "sentence-transformers",
-      "chromadb",
-      "semantic search",
-      "vector index",
-      "embedding"
-    ]
-  },
-  {
-    type: "InvalidPath" /* InvalidPath */,
-    patterns: ["no such file", "not found", "does not exist"]
-  },
-  {
-    type: "Timeout" /* Timeout */,
-    patterns: ["timeout", "timed out", "etimedout"]
-  },
-  {
-    type: "TooManyResults" /* TooManyResults */,
-    patterns: ["too many", "limit"]
-  }
-];
-function detectErrorType(stderr, _exitCode) {
-  return coreDetectErrorFromOutput(stderr, KIT_ERROR_PATTERNS, "KitCommandFailed" /* KitCommandFailed */);
-}
-function createErrorFromOutput(stderr, exitCode) {
-  const errorType = detectErrorType(stderr, exitCode);
-  return new KitError(errorType, undefined, stderr.trim());
-}
-// src/lib/formatters.ts
-import { formatBytes } from "@side-quest/core/formatters";
-import { capitalize, truncate } from "@side-quest/core/utils";
-function formatGrepResults(result, format = "markdown" /* MARKDOWN */) {
-  if (isError(result)) {
-    return formatError(result, format);
-  }
-  if (format === "json" /* JSON */) {
-    return JSON.stringify(result, null, 2);
-  }
-  const lines = [];
-  lines.push(`## Grep Results`);
-  lines.push("");
-  lines.push(`Found **${result.count}** matches for \`${result.pattern}\``);
-  lines.push("");
-  if (result.matches.length === 0) {
-    lines.push("_No matches found._");
-    return lines.join(`
-`);
-  }
-  const byFile = new Map;
-  for (const match of result.matches) {
-    const existing = byFile.get(match.file) ?? [];
-    existing.push(match);
-    byFile.set(match.file, existing);
-  }
-  for (const [file, matches] of byFile) {
-    lines.push(`### ${file}`);
-    lines.push("");
-    for (const match of matches) {
-      const lineNum = match.line ? `:${match.line}` : "";
-      lines.push(`- **${file}${lineNum}**: ${truncate(match.content, 100)}`);
-    }
-    lines.push("");
-  }
-  return lines.join(`
-`);
-}
-function formatSemanticResults(result, format = "markdown" /* MARKDOWN */) {
-  if (isError(result)) {
-    return formatError(result, format);
-  }
-  if (format === "json" /* JSON */) {
-    return JSON.stringify(result, null, 2);
-  }
-  const lines = [];
-  lines.push(`## Semantic Search Results`);
-  lines.push("");
-  if (result.fallback && result.installHint) {
-    lines.push(`> **Note:** ${result.installHint.split(`
-`)[0]}`);
-    lines.push(">");
-    lines.push("> Using text search fallback. Results may be less relevant than semantic search.");
-    lines.push("");
-  }
-  lines.push(`Found **${result.count}** matches for query: _"${result.query}"_`);
-  lines.push("");
-  if (result.matches.length === 0) {
-    lines.push("_No matches found._");
-    return lines.join(`
-`);
-  }
-  result.matches.forEach((match, i) => {
-    const score = (match.score * 100).toFixed(1);
-    const lineInfo = match.startLine && match.endLine ? `:${match.startLine}-${match.endLine}` : match.startLine ? `:${match.startLine}` : "";
-    lines.push(`### ${i + 1}. ${match.file}${lineInfo} (${score}% relevance)`);
-    lines.push("");
-    lines.push("```");
-    lines.push(truncate(match.chunk, 500));
-    lines.push("```");
-    lines.push("");
-  });
-  return lines.join(`
-`);
-}
-function formatSymbolsResults(result, format = "markdown" /* MARKDOWN */) {
-  if (isError(result)) {
-    return formatError(result, format);
-  }
-  if (format === "json" /* JSON */) {
-    return JSON.stringify(result, null, 2);
-  }
-  const lines = [];
-  lines.push(`## Code Symbols`);
-  lines.push("");
-  lines.push(`Found **${result.count}** symbols in \`${result.path}\``);
-  lines.push("");
-  if (result.symbols.length === 0) {
-    lines.push("_No symbols found._");
-    return lines.join(`
-`);
-  }
-  const byType = new Map;
-  for (const symbol of result.symbols) {
-    const existing = byType.get(symbol.type) ?? [];
-    existing.push(symbol);
-    byType.set(symbol.type, existing);
-  }
-  const sortedTypes = [...byType.keys()].sort();
-  for (const type of sortedTypes) {
-    const symbols = byType.get(type);
-    const icon = getSymbolIcon(type);
-    lines.push(`### ${icon} ${capitalize(type)}s (${symbols.length})`);
-    lines.push("");
-    for (const symbol of symbols) {
-      const loc = symbol.endLine ? `${symbol.startLine}-${symbol.endLine}` : String(symbol.startLine);
-      lines.push(`- **${symbol.name}** - \`${symbol.file}:${loc}\``);
-    }
-    lines.push("");
-  }
-  return lines.join(`
-`);
-}
-function formatError(error, format = "markdown" /* MARKDOWN */) {
-  if (format === "json" /* JSON */) {
-    return JSON.stringify(error, null, 2);
-  }
-  const lines = [];
-  lines.push(`## Error`);
-  lines.push("");
-  lines.push(`**${error.error}**`);
-  if (error.hint) {
-    lines.push("");
-    lines.push(`\uD83D\uDCA1 **Hint:** ${error.hint}`);
-  }
-  return lines.join(`
-`);
-}
-function getSymbolIcon(type) {
-  const icons = {
-    function: "\uD83D\uDCE6",
-    class: "\uD83D\uDCDA",
-    method: "\uD83D\uDD27",
-    property: "\uD83C\uDFF7️",
-    variable: "\uD83D\uDCCC",
-    constant: "\uD83D\uDD12",
-    type: "\uD83D\uDCDD",
-    interface: "\uD83D\uDCCB",
-    enum: "\uD83D\uDCCA",
-    module: "\uD83D\uDCC1"
-  };
-  return icons[type.toLowerCase()] ?? "•";
-}
-function formatFileTreeResults(result, format = "markdown" /* MARKDOWN */) {
-  if (isError(result)) {
-    return formatError(result, format);
-  }
-  if (format === "json" /* JSON */) {
-    return JSON.stringify(result, null, 2);
-  }
-  const lines = [];
-  lines.push(`## File Tree`);
-  lines.push("");
-  if (result.subpath) {
-    lines.push(`Showing \`${result.subpath}\` in \`${result.path}\``);
-  } else {
-    lines.push(`Repository: \`${result.path}\``);
-  }
-  lines.push("");
-  lines.push(`**${result.count}** entries`);
-  lines.push("");
-  if (result.entries.length === 0) {
-    lines.push("_No files found._");
-    return lines.join(`
-`);
-  }
-  for (const entry of result.entries) {
-    const icon = entry.isDir ? "\uD83D\uDCC1" : "\uD83D\uDCC4";
-    const size = entry.isDir ? "" : ` (${formatBytes(entry.size)})`;
-    lines.push(`- ${icon} \`${entry.path}\`${size}`);
-  }
-  return lines.join(`
-`);
-}
-function formatFileContentResults(result, format = "markdown" /* MARKDOWN */) {
-  if (isError(result)) {
-    return formatError(result, format);
-  }
-  if (format === "json" /* JSON */) {
-    return JSON.stringify(result, null, 2);
-  }
-  const lines = [];
-  lines.push(`## File Contents`);
-  lines.push("");
-  const found = result.files.filter((f) => f.found).length;
-  const notFound = result.files.length - found;
-  lines.push(`**${found}** of **${result.count}** files retrieved`);
-  if (notFound > 0) {
-    lines.push(` (${notFound} not found)`);
-  }
-  lines.push("");
-  for (const file of result.files) {
-    lines.push(`### ${file.file}`);
-    lines.push("");
-    if (!file.found) {
-      lines.push(`> **Error:** ${file.error || "File not found"}`);
-    } else {
-      const ext = file.file.split(".").pop() || "";
-      const lang = getLanguageForExtension(ext);
-      lines.push(`\`\`\`${lang}`);
-      lines.push(truncate(file.content, 5000));
-      lines.push("```");
-    }
-    lines.push("");
-  }
-  return lines.join(`
-`);
-}
-function getLanguageForExtension(ext) {
-  const langMap = {
-    ts: "typescript",
-    tsx: "tsx",
-    js: "javascript",
-    jsx: "jsx",
-    py: "python",
-    rb: "ruby",
-    go: "go",
-    rs: "rust",
-    java: "java",
-    kt: "kotlin",
-    swift: "swift",
-    c: "c",
-    cpp: "cpp",
-    h: "c",
-    hpp: "cpp",
-    cs: "csharp",
-    php: "php",
-    sh: "bash",
-    bash: "bash",
-    zsh: "bash",
-    json: "json",
-    yaml: "yaml",
-    yml: "yaml",
-    toml: "toml",
-    xml: "xml",
-    html: "html",
-    css: "css",
-    scss: "scss",
-    md: "markdown",
-    sql: "sql"
-  };
-  return langMap[ext.toLowerCase()] || "";
-}
-function formatUsagesResults(result, format = "markdown" /* MARKDOWN */) {
-  if (isError(result)) {
-    return formatError(result, format);
-  }
-  if (format === "json" /* JSON */) {
-    return JSON.stringify(result, null, 2);
-  }
-  const lines = [];
-  lines.push(`## Symbol Definitions`);
-  lines.push("");
-  lines.push(`Found **${result.count}** definition(s) for \`${result.symbolName}\``);
-  lines.push("");
-  if (result.usages.length === 0) {
-    lines.push("_No definitions found._");
-    return lines.join(`
-`);
-  }
-  for (const usage of result.usages) {
-    const icon = getSymbolTypeIcon(usage.type);
-    const lineInfo = usage.line ? `:${usage.line}` : "";
-    lines.push(`### ${icon} ${usage.name}`);
-    lines.push("");
-    lines.push(`- **Type:** ${usage.type}`);
-    lines.push(`- **File:** \`${usage.file}${lineInfo}\``);
-    if (usage.context) {
-      lines.push("");
-      lines.push("```");
-      lines.push(usage.context);
-      lines.push("```");
-    }
-    lines.push("");
-  }
-  return lines.join(`
-`);
-}
-function getSymbolTypeIcon(type) {
-  const icons = {
-    function: "\uD83D\uDCE6",
-    class: "\uD83D\uDCDA",
-    method: "\uD83D\uDD27",
-    property: "\uD83C\uDFF7️",
-    variable: "\uD83D\uDCCC",
-    constant: "\uD83D\uDD12",
-    type: "\uD83D\uDCDD",
-    interface: "\uD83D\uDCCB",
-    enum: "\uD83D\uDCCA",
-    module: "\uD83D\uDCC1"
-  };
-  return icons[type.toLowerCase()] ?? "•";
-}
-function formatAstSearchResults(result, format = "markdown" /* MARKDOWN */) {
-  if (isError(result)) {
-    return formatError(result, format);
-  }
-  if (format === "json" /* JSON */) {
-    return JSON.stringify(result, null, 2);
-  }
-  const lines = [];
-  lines.push("## AST Search Results");
-  lines.push("");
-  lines.push(`Found **${result.count}** matches for pattern \`${result.pattern}\` (${result.mode} mode)`);
-  lines.push("");
-  if (result.matches.length === 0) {
-    lines.push("_No matches found._");
-    return lines.join(`
-`);
-  }
-  const byFile = new Map;
-  for (const match of result.matches) {
-    const existing = byFile.get(match.file) ?? [];
-    existing.push(match);
-    byFile.set(match.file, existing);
-  }
-  for (const [file, matches] of byFile) {
-    lines.push(`### ${file}`);
-    lines.push("");
-    for (const m of matches) {
-      const ctx = m.context.parentFunction ? ` in \`${m.context.parentFunction}\`` : m.context.parentClass ? ` in class \`${m.context.parentClass}\`` : "";
-      lines.push(`- **L${m.line}** \`${m.nodeType}\`${ctx}`);
-      lines.push("```");
-      lines.push(truncate(m.text, 200));
-      lines.push("```");
-    }
-    lines.push("");
-  }
-  return lines.join(`
-`);
-}
-// src/lib/utils/index-parser.ts
-import { dirname, join as join2, resolve } from "node:path";
-import { findUpSync, pathExistsSync } from "@side-quest/core/fs";
-async function findProjectIndex(startDir = process.cwd()) {
-  const indexPath = findUpSync("PROJECT_INDEX.json", startDir);
-  if (indexPath) {
-    return indexPath;
-  }
-  throw new Error(`PROJECT_INDEX.json not found in current directory or any parent directory.
-` + "Run: bun run src/cli.ts prime");
-}
-function resolveExplicitIndexPath(explicitPath) {
-  const resolved = resolve(explicitPath);
-  if (resolved.endsWith("PROJECT_INDEX.json")) {
-    if (pathExistsSync(resolved)) {
-      return resolved;
-    }
-    throw new Error(`PROJECT_INDEX.json not found at: ${resolved}`);
-  }
-  const indexInDir = join2(resolved, "PROJECT_INDEX.json");
-  if (pathExistsSync(indexInDir)) {
-    return indexInDir;
-  }
-  throw new Error(`PROJECT_INDEX.json not found at: ${indexInDir}
-` + `Specify either:
-` + `  - Path to PROJECT_INDEX.json file
-` + "  - Directory containing PROJECT_INDEX.json");
-}
-async function loadProjectIndex(explicitPath) {
-  const indexPath = explicitPath ? resolveExplicitIndexPath(explicitPath) : await findProjectIndex();
-  const file = Bun.file(indexPath);
-  return await file.json();
-}
-function findSymbol(index, symbolName) {
-  const results = [];
-  for (const [file, symbols] of Object.entries(index.symbols)) {
-    for (const symbol of symbols) {
-      if (symbol.name === symbolName) {
-        results.push({ file, symbol });
-      }
-    }
-  }
-  return results;
-}
-function findSymbolFuzzy(index, query) {
-  const results = [];
-  const lowerQuery = query.toLowerCase();
-  for (const [file, symbols] of Object.entries(index.symbols)) {
-    for (const symbol of symbols) {
-      const lowerName = symbol.name.toLowerCase();
-      if (lowerName === lowerQuery) {
-        results.push({ file, symbol, score: 100 });
-      } else if (lowerName.startsWith(lowerQuery)) {
-        results.push({ file, symbol, score: 75 });
-      } else if (lowerName.includes(lowerQuery)) {
-        results.push({ file, symbol, score: 50 });
-      }
-    }
-  }
-  return results.sort((a, b) => {
-    if (b.score !== a.score)
-      return b.score - a.score;
-    return a.symbol.name.localeCompare(b.symbol.name);
-  });
-}
-function getFileSymbols(index, filePath) {
-  if (index.symbols[filePath]) {
-    return index.symbols[filePath];
-  }
-  for (const [path, symbols] of Object.entries(index.symbols)) {
-    if (path.endsWith(filePath)) {
-      return symbols;
-    }
-  }
-  return [];
-}
-function getSymbolTypeDistribution(index) {
-  const distribution = {
-    function: 0,
-    class: 0,
-    interface: 0,
-    type: 0,
-    constant: 0,
-    variable: 0
-  };
-  for (const symbols of Object.values(index.symbols)) {
-    for (const symbol of symbols) {
-      distribution[symbol.type] = (distribution[symbol.type] || 0) + 1;
-    }
-  }
-  return distribution;
-}
-function groupSymbolsByDirectory(index) {
-  const dirCounts = {};
-  for (const [file, symbols] of Object.entries(index.symbols)) {
-    const dir = dirname(file);
-    dirCounts[dir] = (dirCounts[dir] || 0) + symbols.length;
-  }
-  return dirCounts;
-}
-function getComplexityHotspots(index, topN = 10) {
-  const dirCounts = groupSymbolsByDirectory(index);
-  const sorted = Object.entries(dirCounts).map(([directory, symbolCount]) => ({ directory, symbolCount })).sort((a, b) => b.symbolCount - a.symbolCount);
-  return sorted.slice(0, topN);
-}
-
-// src/lib/index-tools.ts
-import { join as join3, resolve as resolve2 } from "node:path";
-import { getFileAgeHours, getFileSizeMB } from "@side-quest/core/fs";
-import {
-  ensureCommandAvailable,
-  spawnWithTimeout
-} from "@side-quest/core/spawn";
-async function executeIndexFind(symbolName, indexPath) {
-  try {
-    const index = await loadProjectIndex(indexPath);
-    let results = findSymbol(index, symbolName);
-    let matchType = "exact";
-    if (results.length === 0) {
-      const fuzzyResults = findSymbolFuzzy(index, symbolName);
-      matchType = "fuzzy";
-      results = fuzzyResults.map(({ file, symbol }) => ({ file, symbol }));
-      return {
-        query: symbolName,
-        matchType,
-        count: fuzzyResults.length,
-        results: fuzzyResults.map(({ file, symbol, score }) => ({
-          file,
-          name: symbol.name,
-          type: symbol.type,
-          line: symbol.start_line,
-          code: symbol.code,
-          score
-        }))
-      };
-    }
-    return {
-      query: symbolName,
-      matchType,
-      count: results.length,
-      results: results.map(({ file, symbol }) => ({
-        file,
-        name: symbol.name,
-        type: symbol.type,
-        line: symbol.start_line,
-        code: symbol.code
-      }))
-    };
-  } catch (error) {
-    return {
-      error: error instanceof Error ? error.message : "Unknown error",
-      isError: true
-    };
-  }
-}
-async function executeIndexStats(indexPath, topN = 5) {
-  try {
-    const index = await loadProjectIndex(indexPath);
-    const distribution = getSymbolTypeDistribution(index);
-    const hotspots = getComplexityHotspots(index, topN);
-    const totalSymbols = Object.values(distribution).reduce((sum, count) => sum + count, 0);
-    return {
-      files: Object.keys(index.symbols).length,
-      totalSymbols,
-      distribution,
-      hotspots
-    };
-  } catch (error) {
-    return {
-      error: error instanceof Error ? error.message : "Unknown error",
-      isError: true
-    };
-  }
-}
-async function executeIndexOverview(filePath, indexPath) {
-  try {
-    const index = await loadProjectIndex(indexPath);
-    const symbols = getFileSymbols(index, filePath);
-    return {
-      file: filePath,
-      symbolCount: symbols.length,
-      symbols: symbols.map((s) => ({
-        name: s.name,
-        type: s.type,
-        line: s.start_line
-      }))
-    };
-  } catch (error) {
-    return {
-      error: error instanceof Error ? error.message : "Unknown error",
-      isError: true
-    };
-  }
-}
-var INDEX_FILE = "PROJECT_INDEX.json";
-var MAX_AGE_HOURS = 24;
-async function findGitRoot() {
-  const gitCmd = ensureCommandAvailable("git");
-  const result = await spawnWithTimeout([gitCmd, "rev-parse", "--show-toplevel"], 1e4);
-  if (result.timedOut || result.exitCode !== 0) {
-    return null;
-  }
-  if (result.stdout) {
-    return result.stdout.trim();
-  }
-  return null;
-}
-async function getTargetDir(customPath) {
-  if (customPath) {
-    return resolve2(customPath);
-  }
-  const gitRoot = await findGitRoot();
-  if (gitRoot) {
-    return gitRoot;
-  }
-  return process.cwd();
-}
-async function executeIndexPrime(force = false, customPath) {
-  try {
-    const targetDir = await getTargetDir(customPath);
-    const kitCmd = ensureCommandAvailable("kit");
-    const indexPath = join3(targetDir, INDEX_FILE);
-    const ageHours = getFileAgeHours(indexPath);
-    if (ageHours !== null && ageHours <= MAX_AGE_HOURS && !force) {
-      const index2 = await loadProjectIndex(indexPath);
-      const symbolCount2 = Object.values(index2.symbols).reduce((sum, symbols) => sum + symbols.length, 0);
-      const sizeMB2 = getFileSizeMB(indexPath);
-      return {
-        status: "exists",
-        location: targetDir,
-        ageHours: Number.parseFloat(ageHours.toFixed(1)),
-        files: Object.keys(index2.symbols).length,
-        symbols: symbolCount2,
-        size: `${sizeMB2} MB`,
-        message: "Index is less than 24 hours old. Use force=true to regenerate."
-      };
-    }
-    const startTime = Date.now();
-    const result = await spawnWithTimeout([kitCmd, "index", targetDir, "-o", indexPath], 60000);
-    if (result.timedOut) {
-      return {
-        error: "kit index timed out",
-        isError: true
-      };
-    }
-    if (result.exitCode !== 0) {
-      return {
-        error: `kit index failed: ${result.stderr}`,
-        isError: true
-      };
-    }
-    const durationSec = (Date.now() - startTime) / 1000;
-    const index = await loadProjectIndex(indexPath);
-    const symbolCount = Object.values(index.symbols).reduce((sum, symbols) => sum + symbols.length, 0);
-    const sizeMB = getFileSizeMB(indexPath);
-    return {
-      success: true,
-      location: targetDir,
-      files: Object.keys(index.symbols).length,
-      symbols: symbolCount,
-      size: `${sizeMB} MB`,
-      durationSec: Number.parseFloat(durationSec.toFixed(1))
-    };
-  } catch (error) {
-    return {
-      error: error instanceof Error ? error.message : "Unknown error",
-      isError: true
-    };
-  }
-}
-function formatIndexFindResults(result, format) {
-  if ("isError" in result) {
-    return format === "json" ? JSON.stringify(result, null, 2) : `**Error:** ${result.error}`;
-  }
-  if (format === "json") {
-    return JSON.stringify(result, null, 2);
-  }
-  if (result.count === 0) {
-    return `No symbols found matching: ${result.query}`;
-  }
-  let output = `Found ${result.count} ${result.matchType} match(es) for "${result.query}":
-
-`;
-  for (const r of result.results) {
-    output += `- **${r.name}** (${r.type}) in \`${r.file}:${r.line}\``;
-    if (r.score !== undefined) {
-      output += ` [score: ${r.score}]`;
-    }
-    output += `
-`;
-  }
-  return output;
-}
-function formatIndexStatsResults(result, format) {
-  if ("isError" in result) {
-    return format === "json" ? JSON.stringify(result, null, 2) : `**Error:** ${result.error}`;
-  }
-  if (format === "json") {
-    return JSON.stringify(result, null, 2);
-  }
-  let output = `## Codebase Statistics
-
-`;
-  output += `- **Files:** ${result.files}
-`;
-  output += `- **Total Symbols:** ${result.totalSymbols}
-
-`;
-  output += `### Symbol Distribution
-`;
-  for (const [type, count] of Object.entries(result.distribution)) {
-    if (count > 0) {
-      output += `- ${type}: ${count}
-`;
-    }
-  }
-  output += `
-### Complexity Hotspots
-`;
-  for (const { directory, symbolCount } of result.hotspots) {
-    output += `- \`${directory}\`: ${symbolCount} symbols
-`;
-  }
-  return output;
-}
-function formatIndexOverviewResults(result, format) {
-  if ("isError" in result) {
-    return format === "json" ? JSON.stringify(result, null, 2) : `**Error:** ${result.error}`;
-  }
-  if (format === "json") {
-    return JSON.stringify(result, null, 2);
-  }
-  if (result.symbolCount === 0) {
-    return `No symbols found in: ${result.file}`;
-  }
-  let output = `## ${result.file}
-
-`;
-  output += `**${result.symbolCount} symbol(s)**
-
-`;
-  const byType = {};
-  for (const sym of result.symbols) {
-    if (!byType[sym.type]) {
-      byType[sym.type] = [];
-    }
-    byType[sym.type].push(sym);
-  }
-  for (const [type, symbols] of Object.entries(byType)) {
-    output += `### ${type}s
-`;
-    for (const sym of symbols) {
-      output += `- \`${sym.name}\` (line ${sym.line})
-`;
-    }
-    output += `
-`;
-  }
-  return output;
-}
-function formatIndexPrimeResults(result, format) {
-  if ("isError" in result) {
-    return format === "json" ? JSON.stringify(result, null, 2) : `**Error:** ${result.error}`;
-  }
-  if (format === "json") {
-    return JSON.stringify(result, null, 2);
-  }
-  if ("status" in result && result.status === "exists") {
-    return `## Index Already Exists
-
-` + `- **Location:** ${result.location}
-` + `- **Age:** ${result.ageHours} hours
-` + `- **Files:** ${result.files}
-` + `- **Symbols:** ${result.symbols}
-` + `- **Size:** ${result.size}
-
-` + `> ${result.message}`;
-  }
-  const primeResult = result;
-  return `## Index Generated Successfully
-
-` + `- **Location:** ${primeResult.location}
-` + `- **Files:** ${primeResult.files}
-` + `- **Symbols:** ${primeResult.symbols}
-` + `- **Size:** ${primeResult.size}
-` + `- **Duration:** ${primeResult.durationSec}s`;
-}
-// src/lib/kit-wrapper.ts
-import { join as join4 } from "node:path";
-import { TimeoutError, withTimeout } from "@side-quest/core/concurrency";
-import {
-  ensureCacheDir,
-  isCachePopulated,
-  withTempJsonFileSync
-} from "@side-quest/core/fs";
-import {
-  buildEnhancedPath,
-  ensureCommandAvailable as ensureCommandAvailable2,
-  spawnSyncCollect
-} from "@side-quest/core/spawn";
-function isKitInstalled() {
-  try {
-    ensureCommandAvailable2("kit");
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getKitVersion() {
-  try {
-    const result = spawnSyncCollect(["kit", "--version"], {
-      env: {
-        ...process.env,
-        PATH: buildEnhancedPath()
-      }
-    });
-    if (result.exitCode === 0 && result.stdout) {
-      return result.stdout.trim();
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function executeKit(args, options = {}) {
-  const { cwd } = options;
-  const result = spawnSyncCollect(["kit", ...args], {
-    env: {
-      ...process.env,
-      PATH: buildEnhancedPath()
-    },
-    ...cwd && { cwd }
-  });
-  return {
-    stdout: result.stdout || "",
-    stderr: result.stderr || "",
-    exitCode: result.exitCode ?? 1
-  };
-}
-function executeKitGrep(options) {
-  const cid = createCorrelationId();
-  const startTime = Date.now();
-  if (!isKitInstalled()) {
-    grepLogger.error("Kit not installed", { cid });
-    return new KitError("KitNotInstalled" /* KitNotInstalled */).toJSON();
-  }
-  const {
-    pattern,
-    path = getDefaultKitPath(),
-    caseSensitive = true,
-    include,
-    exclude,
-    maxResults = 100,
-    directory
-  } = options;
-  const args = ["grep", path, pattern];
-  if (!caseSensitive) {
-    args.push("--ignore-case");
-  }
-  if (include) {
-    args.push("--include", include);
-  }
-  if (exclude) {
-    args.push("--exclude", exclude);
-  }
-  args.push("--max-results", String(maxResults));
-  if (directory) {
-    args.push("--directory", directory);
-  }
-  grepLogger.info("Executing kit grep", {
-    cid,
-    pattern,
-    path,
-    args
-  });
-  try {
-    const rawMatches = withTempJsonFileSync(`kit-grep-${cid}`, (tempFile) => {
-      args.push("--output", tempFile);
-      const result = executeKit(args, { timeout: GREP_TIMEOUT });
-      return {
-        exitCode: result.exitCode,
-        stderr: result.stderr
-      };
-    });
-    const matches = rawMatches.map((m) => ({
-      file: m.file,
-      line: m.line_number,
-      content: m.line_content
-    }));
-    grepLogger.info("Grep completed", {
-      cid,
-      pattern,
-      matchCount: matches.length,
-      durationMs: Date.now() - startTime
-    });
-    return {
-      count: matches.length,
-      matches,
-      pattern,
-      path
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    grepLogger.error("Grep threw exception", { cid, error: message });
-    if (message.includes("Operation failed with exit code")) {
-      const exitCode = Number.parseInt(message.match(/exit code (\d+)/)?.[1] || "1", 10);
-      const stderr = message.split(": ").slice(2).join(": ") || message;
-      return createErrorFromOutput(stderr, exitCode).toJSON();
-    }
-    return new KitError("KitCommandFailed" /* KitCommandFailed */, message).toJSON();
-  }
-}
-function executeKitSymbols(options) {
-  const cid = createCorrelationId();
-  const startTime = Date.now();
-  if (!isKitInstalled()) {
-    symbolsLogger.error("Kit not installed", { cid });
-    return new KitError("KitNotInstalled" /* KitNotInstalled */).toJSON();
-  }
-  const { path = getDefaultKitPath(), pattern, symbolType, file } = options;
-  const args = ["symbols", path, "--format", "json"];
-  if (file) {
-    args.push("--file", file);
-  }
-  if (pattern) {}
-  symbolsLogger.info("Executing kit symbols", {
-    cid,
-    path,
-    pattern,
-    symbolType
-  });
-  try {
-    const result = executeKit(args, { timeout: SYMBOLS_TIMEOUT });
-    if (result.exitCode !== 0) {
-      symbolsLogger.error("Symbols failed", {
-        cid,
-        exitCode: result.exitCode,
-        stderr: result.stderr,
-        durationMs: Date.now() - startTime
-      });
-      return createErrorFromOutput(result.stderr, result.exitCode).toJSON();
-    }
-    let rawSymbols;
-    try {
-      rawSymbols = JSON.parse(result.stdout);
-    } catch {
-      symbolsLogger.error("Failed to parse symbols output", {
-        cid,
-        stdout: result.stdout
-      });
-      return new KitError("OutputParseError" /* OutputParseError */, "Failed to parse symbols JSON output").toJSON();
-    }
-    let symbols = rawSymbols.map((s) => ({
-      name: s.name,
-      type: s.type,
-      file: s.file,
-      startLine: s.start_line,
-      endLine: s.end_line,
-      code: s.code
-    }));
-    if (symbolType) {
-      symbols = symbols.filter((s) => s.type.toLowerCase() === symbolType.toLowerCase());
-    }
-    if (pattern) {
-      const regex = globToRegex(pattern);
-      symbols = symbols.filter((s) => regex.test(s.file));
-    }
-    symbolsLogger.info("Symbols completed", {
-      cid,
-      symbolCount: symbols.length,
-      durationMs: Date.now() - startTime
-    });
-    return {
-      count: symbols.length,
-      symbols,
-      path
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    symbolsLogger.error("Symbols threw exception", { cid, error: message });
-    return new KitError("KitCommandFailed" /* KitCommandFailed */, message).toJSON();
-  }
-}
-function executeKitSemantic(options) {
-  const cid = createCorrelationId();
-  const startTime = Date.now();
-  if (!isKitInstalled()) {
-    semanticLogger.error("Kit not installed", { cid });
-    return new KitError("KitNotInstalled" /* KitNotInstalled */).toJSON();
-  }
-  const {
-    query,
-    path = getDefaultKitPath(),
-    topK = 5,
-    chunkBy = "symbols",
-    buildIndex = false
-  } = options;
-  if (!buildIndex && !isSemanticIndexBuilt(path)) {
-    semanticLogger.info("Semantic index not built, instructing user to build", {
-      cid,
-      path
-    });
-    const buildCommand = `kit search-semantic "${path}" "${query}" --build-index`;
-    const error = new KitError("SemanticIndexNotBuilt" /* SemanticIndexNotBuilt */, `To use semantic search, build the vector index with:
-
-  ${buildCommand}
-
-After building (one-time), semantic search will be fast and cached.`);
-    return error.toJSON();
-  }
-  const persistDir = getSemanticCacheDir(path);
-  const args = [
-    "search-semantic",
-    path,
-    query,
-    "--top-k",
-    String(topK),
-    "--format",
-    "json",
-    "--chunk-by",
-    chunkBy,
-    "--persist-dir",
-    persistDir
-  ];
-  if (buildIndex) {
-    args.push("--build-index");
-  }
-  semanticLogger.info("Executing kit semantic search", {
-    cid,
-    query,
-    path,
-    topK,
-    chunkBy,
-    persistDir
-  });
-  try {
-    const result = executeKit(args, { timeout: SEMANTIC_TIMEOUT });
-    const combinedOutput = `${result.stdout}
-${result.stderr}`;
-    if (result.exitCode !== 0 && isSemanticUnavailableError(combinedOutput)) {
-      semanticLogger.warn("Semantic search unavailable, falling back to grep", {
-        cid,
-        output: combinedOutput.slice(0, 200)
-      });
-      return fallbackToGrep(query, path, topK, cid);
-    }
-    if (result.exitCode !== 0 && isTimeoutError(combinedOutput)) {
-      semanticLogger.warn("Semantic search timed out on large repository", {
-        cid,
-        query,
-        durationMs: Date.now() - startTime
-      });
-      return new KitError("Timeout" /* Timeout */, `Semantic search timed out after ${SEMANTIC_TIMEOUT}ms. On first run, building the vector index may take longer. Try again to use the cached index.`).toJSON();
-    }
-    if (result.exitCode !== 0) {
-      semanticLogger.error("Semantic search failed", {
-        cid,
-        exitCode: result.exitCode,
-        output: combinedOutput.slice(0, 500),
-        durationMs: Date.now() - startTime
-      });
-      return createErrorFromOutput(combinedOutput, result.exitCode).toJSON();
-    }
-    let rawMatches;
-    try {
-      rawMatches = JSON.parse(result.stdout);
-    } catch {
-      semanticLogger.error("Failed to parse semantic output", {
-        cid,
-        stdout: result.stdout
-      });
-      return new KitError("OutputParseError" /* OutputParseError */, "Failed to parse semantic search JSON output").toJSON();
-    }
-    const matches = rawMatches.map((m) => ({
-      file: m.file,
-      chunk: m.code,
-      score: m.score,
-      startLine: m.start_line,
-      endLine: m.end_line
-    }));
-    semanticLogger.info("Semantic search completed", {
-      cid,
-      query,
-      matchCount: matches.length,
-      durationMs: Date.now() - startTime
-    });
-    return {
-      count: matches.length,
-      matches,
-      query,
-      path
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    semanticLogger.error("Semantic search threw exception", {
-      cid,
-      error: message
-    });
-    return new KitError("KitCommandFailed" /* KitCommandFailed */, message).toJSON();
-  }
-}
-function fallbackToGrep(query, path, limit, cid) {
-  const keywords = query.split(/\s+/).filter((w) => w.length > 2).slice(0, 3);
-  const pattern = keywords.join("|");
-  semanticLogger.info("Fallback grep search", { cid, pattern, path });
-  const grepResult = executeKitGrep({
-    pattern,
-    path,
-    maxResults: limit,
-    caseSensitive: false
-  });
-  if ("error" in grepResult) {
-    return grepResult;
-  }
-  const matches = grepResult.matches.map((m, idx) => ({
-    file: m.file,
-    chunk: m.content,
-    score: Math.max(0.1, 1 - idx * 0.05),
-    startLine: m.line,
-    endLine: m.line
-  }));
-  return {
-    count: matches.length,
-    matches,
-    query,
-    path,
-    fallback: true,
-    installHint: SEMANTIC_INSTALL_HINT
-  };
-}
-function executeKitFileTree(options) {
-  const cid = createCorrelationId();
-  const startTime = Date.now();
-  if (!isKitInstalled()) {
-    fileTreeLogger.error("Kit not installed", { cid });
-    return new KitError("KitNotInstalled" /* KitNotInstalled */).toJSON();
-  }
-  const { path = getDefaultKitPath(), subpath } = options;
-  const args = ["file-tree", path];
-  if (subpath) {
-    args.push("--path", subpath);
-  }
-  fileTreeLogger.info("Executing kit file-tree", {
-    cid,
-    path,
-    subpath,
-    args
-  });
-  try {
-    const rawEntries = withTempJsonFileSync(`kit-file-tree-${cid}`, (tempFile) => {
-      const argsWithOutput = [...args, "--output", tempFile];
-      const result = executeKit(argsWithOutput, {
-        timeout: FILE_TREE_TIMEOUT
-      });
-      return {
-        exitCode: result.exitCode,
-        stderr: result.stderr
-      };
-    });
-    const entries = rawEntries.map((e) => ({
-      path: e.path,
-      name: e.name,
-      isDir: e.is_dir,
-      size: e.size
-    }));
-    fileTreeLogger.info("File tree completed", {
-      cid,
-      entryCount: entries.length,
-      durationMs: Date.now() - startTime
-    });
-    return {
-      count: entries.length,
-      entries,
-      path,
-      subpath
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    fileTreeLogger.error("File tree threw exception", { cid, error: message });
-    if (message.includes("Operation failed with exit code")) {
-      const exitCode = Number.parseInt(message.match(/exit code (\d+)/)?.[1] || "1", 10);
-      const stderr = message.split(": ").slice(2).join(": ") || message;
-      return createErrorFromOutput(stderr, exitCode).toJSON();
-    }
-    return new KitError("KitCommandFailed" /* KitCommandFailed */, message).toJSON();
-  }
-}
-function executeKitFileContent(options) {
-  const cid = createCorrelationId();
-  const startTime = Date.now();
-  if (!isKitInstalled()) {
-    fileContentLogger.error("Kit not installed", { cid });
-    return new KitError("KitNotInstalled" /* KitNotInstalled */).toJSON();
-  }
-  const { path = getDefaultKitPath(), filePaths } = options;
-  if (!filePaths || filePaths.length === 0) {
-    return new KitError("InvalidInput" /* InvalidInput */, "At least one file path is required").toJSON();
-  }
-  fileContentLogger.info("Executing kit file-content", {
-    cid,
-    path,
-    fileCount: filePaths.length
-  });
-  const files = [];
-  for (const filePath of filePaths) {
-    const args = ["file-content", path, filePath];
-    try {
-      const result = executeKit(args, { timeout: FILE_CONTENT_TIMEOUT });
-      if (result.exitCode !== 0) {
-        files.push({
-          file: filePath,
-          content: "",
-          found: false,
-          error: result.stderr.trim() || "File not found"
-        });
-      } else {
-        files.push({
-          file: filePath,
-          content: result.stdout,
-          found: true
-        });
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      fileContentLogger.warn("Failed to fetch file content", {
-        cid,
-        filePath,
-        error: message
-      });
-      files.push({
-        file: filePath,
-        content: "",
-        found: false,
-        error: message
-      });
-    }
-  }
-  fileContentLogger.info("File content completed", {
-    cid,
-    fileCount: files.length,
-    foundCount: files.filter((f) => f.found).length,
-    durationMs: Date.now() - startTime
-  });
-  return {
-    count: files.length,
-    files,
-    path
-  };
-}
-function executeKitUsages(options) {
-  const cid = createCorrelationId();
-  const startTime = Date.now();
-  if (!isKitInstalled()) {
-    usagesLogger.error("Kit not installed", { cid });
-    return new KitError("KitNotInstalled" /* KitNotInstalled */).toJSON();
-  }
-  const { path = getDefaultKitPath(), symbolName, symbolType } = options;
-  if (!symbolName || symbolName.trim() === "") {
-    return new KitError("InvalidInput" /* InvalidInput */, "Symbol name is required").toJSON();
-  }
-  const args = ["usages", path, symbolName.trim()];
-  if (symbolType) {
-    args.push("--type", symbolType);
-  }
-  usagesLogger.info("Executing kit usages", {
-    cid,
-    path,
-    symbolName,
-    symbolType,
-    args
-  });
-  try {
-    const rawUsages = withTempJsonFileSync(`kit-usages-${cid}`, (tempFile) => {
-      const argsWithOutput = [...args, "--output", tempFile];
-      const result = executeKit(argsWithOutput, { timeout: USAGES_TIMEOUT });
-      return {
-        exitCode: result.exitCode,
-        stderr: result.stderr
-      };
-    });
-    const usages = rawUsages.map((u) => ({
-      file: u.file,
-      type: u.type,
-      name: u.name,
-      line: u.line,
-      context: u.context
-    }));
-    usagesLogger.info("Usages completed", {
-      cid,
-      symbolName,
-      usageCount: usages.length,
-      durationMs: Date.now() - startTime
-    });
-    return {
-      count: usages.length,
-      usages,
-      symbolName: symbolName.trim(),
-      path
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    usagesLogger.error("Usages threw exception", { cid, error: message });
-    if (message.includes("Operation failed with exit code")) {
-      const exitCode = Number.parseInt(message.match(/exit code (\d+)/)?.[1] || "1", 10);
-      const stderr = message.split(": ").slice(2).join(": ") || message;
-      return createErrorFromOutput(stderr, exitCode).toJSON();
-    }
-    return new KitError("KitCommandFailed" /* KitCommandFailed */, message).toJSON();
-  }
-}
-function executeKitCommit(options) {
-  const cid = createCorrelationId();
-  const startTime = Date.now();
-  if (!isKitInstalled()) {
-    commitLogger.error("Kit not installed", { cid });
-    return new KitError("KitNotInstalled" /* KitNotInstalled */).toJSON();
-  }
-  const { dryRun = true, model, cwd } = options;
-  const args = ["commit"];
-  if (dryRun) {
-    args.push("--dry-run");
-  }
-  if (model) {
-    args.push("--model", model);
-  }
-  commitLogger.info("Executing kit commit", {
-    cid,
-    dryRun,
-    model,
-    cwd,
-    args
-  });
-  try {
-    const result = executeKit(args, { timeout: COMMIT_TIMEOUT, cwd });
-    if (result.exitCode !== 0) {
-      commitLogger.error("Commit failed", {
-        cid,
-        exitCode: result.exitCode,
-        stderr: result.stderr,
-        durationMs: Date.now() - startTime
-      });
-      return createErrorFromOutput(result.stderr, result.exitCode).toJSON();
-    }
-    const output = result.stdout.trim();
-    commitLogger.info("Commit completed", {
-      cid,
-      dryRun,
-      committed: !dryRun,
-      durationMs: Date.now() - startTime
-    });
-    return {
-      message: output,
-      committed: !dryRun,
-      model
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    commitLogger.error("Commit threw exception", { cid, error: message });
-    return new KitError("KitCommandFailed" /* KitCommandFailed */, message).toJSON();
-  }
-}
-async function executeAstSearch(options) {
-  const cid = createCorrelationId();
-  const startTime = Date.now();
-  const { pattern, mode, filePattern, path, maxResults } = options;
-  astLogger.info("Executing AST search", {
-    cid,
-    pattern,
-    mode,
-    filePattern,
-    path,
-    maxResults
-  });
-  try {
-    const searcher = new ASTSearcher(path);
-    const result = await withTimeout(searcher.searchPattern(options), AST_SEARCH_TIMEOUT, "AST search timed out");
-    astLogger.info("AST search completed", {
-      cid,
-      pattern,
-      matchCount: result.count,
-      durationMs: Date.now() - startTime
-    });
-    return result;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    const timeoutInfo = error instanceof TimeoutError ? ` after ${error.timeoutMs}ms` : "";
-    astLogger.error("AST search failed", {
-      cid,
-      error: message + timeoutInfo
-    });
-    return new KitError("KitCommandFailed" /* KitCommandFailed */, message).toJSON();
-  }
-}
-function executeKitSummarize(options) {
-  const cid = createCorrelationId();
-  const startTime = Date.now();
-  if (!isKitInstalled()) {
-    summarizeLogger.error("Kit not installed", { cid });
-    return new KitError("KitNotInstalled" /* KitNotInstalled */).toJSON();
-  }
-  const {
-    prUrl,
-    updatePrBody = false,
-    model,
-    repoPath
-  } = options;
-  const args = ["summarize", prUrl];
-  if (updatePrBody) {
-    args.push("--update-pr-body");
-  }
-  if (model) {
-    args.push("--model", model);
-  }
-  if (repoPath) {
-    args.push("--repo-path", repoPath);
-  }
-  args.push("--plain");
-  summarizeLogger.info("Executing kit summarize", {
-    cid,
-    prUrl,
-    updatePrBody,
-    model,
-    repoPath
-  });
-  try {
-    const result = executeKit(args, { timeout: SUMMARIZE_TIMEOUT });
-    if (result.exitCode !== 0) {
-      summarizeLogger.error("Summarize failed", {
-        cid,
-        exitCode: result.exitCode,
-        stderr: result.stderr,
-        durationMs: Date.now() - startTime
-      });
-      return createErrorFromOutput(result.stderr, result.exitCode).toJSON();
-    }
-    const summary = result.stdout.trim();
-    if (!summary) {
-      summarizeLogger.error("Empty summary returned", { cid });
-      return new KitError("OutputParseError" /* OutputParseError */, "Summarize completed but returned empty output").toJSON();
-    }
-    summarizeLogger.info("Summarize completed", {
-      cid,
-      prUrl,
-      updated: updatePrBody,
-      summaryLength: summary.length,
-      durationMs: Date.now() - startTime
-    });
-    return {
-      prUrl,
-      summary,
-      updated: updatePrBody,
-      ...model && { model }
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    summarizeLogger.error("Summarize threw exception", {
-      cid,
-      error: message
-    });
-    return new KitError("KitCommandFailed" /* KitCommandFailed */, message).toJSON();
-  }
-}
-function globToRegex(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/{{GLOBSTAR}}/g, ".*");
-  return new RegExp(escaped);
-}
-function getSemanticCacheDir(repoPath) {
-  return ensureCacheDir(repoPath, "vector_db");
-}
-function isSemanticIndexBuilt(repoPath) {
-  const cacheDir = join4(repoPath, ".kit", "vector_db");
-  return isCachePopulated(cacheDir);
-}
-// src/lib/validators.ts
-import { normalizePath, pathExistsSync as pathExistsSync2, statSync } from "@side-quest/core/fs";
-import {
-  validateGlob,
-  validateInteger,
-  validateRegex
-} from "@side-quest/core/validation";
-function validatePath(inputPath, options = {}) {
-  const { basePath, mustBeDirectory = true, mustExist = true } = options;
-  if (!inputPath || inputPath.trim() === "") {
-    return { valid: false, error: "Path cannot be empty" };
-  }
-  const normalizedPath = normalizePath(inputPath, basePath);
-  if (basePath) {
-    const normalizedBase = normalizePath(basePath);
-    if (!normalizedPath.startsWith(normalizedBase)) {
-      return {
-        valid: false,
-        error: "Path traversal detected: path escapes base directory"
-      };
-    }
-  }
-  if (mustExist && !pathExistsSync2(normalizedPath)) {
-    return { valid: false, error: `Path does not exist: ${normalizedPath}` };
-  }
-  if (mustExist && mustBeDirectory) {
-    try {
-      const stats = statSync(normalizedPath);
-      if (!stats.isDirectory()) {
-        return {
-          valid: false,
-          error: `Path is not a directory: ${normalizedPath}`
-        };
-      }
-    } catch {
-      return { valid: false, error: `Cannot access path: ${normalizedPath}` };
-    }
-  }
-  return { valid: true, path: normalizedPath };
-}
-function validatePositiveInt(value, options) {
-  return validateInteger(value, {
-    name: options.name,
-    min: options.min ?? 1,
-    max: options.max ?? 1e4,
-    defaultValue: options.defaultValue
-  });
-}
-function validateGrepInputs(inputs) {
-  const errors = [];
-  const patternResult = validateRegex(inputs.pattern);
-  if (!patternResult.valid) {
-    errors.push(patternResult.error);
-  }
-  const pathResult = validatePath(inputs.path || getDefaultKitPath());
-  if (!pathResult.valid) {
-    errors.push(pathResult.error);
-  }
-  let validatedInclude;
-  if (inputs.include) {
-    const includeResult = validateGlob(inputs.include);
-    if (!includeResult.valid) {
-      errors.push(`Include pattern: ${includeResult.error}`);
-    } else {
-      validatedInclude = includeResult.value;
-    }
-  }
-  let validatedExclude;
-  if (inputs.exclude) {
-    const excludeResult = validateGlob(inputs.exclude);
-    if (!excludeResult.valid) {
-      errors.push(`Exclude pattern: ${excludeResult.error}`);
-    } else {
-      validatedExclude = excludeResult.value;
-    }
-  }
-  const maxResultsResult = validatePositiveInt(inputs.maxResults, {
-    name: "maxResults",
-    min: 1,
-    max: 1000,
-    defaultValue: 100
-  });
-  if (!maxResultsResult.valid) {
-    errors.push(maxResultsResult.error);
-  }
-  if (errors.length > 0) {
-    return { valid: false, errors };
-  }
-  return {
-    valid: true,
-    errors: [],
-    validated: {
-      pattern: patternResult.value.source,
-      path: pathResult.path,
-      include: validatedInclude,
-      exclude: validatedExclude,
-      maxResults: maxResultsResult.value
-    }
-  };
-}
-function validateSemanticInputs(inputs) {
-  const errors = [];
-  if (!inputs.query || inputs.query.trim() === "") {
-    errors.push("Query cannot be empty");
-  }
-  const pathResult = validatePath(inputs.path || getDefaultKitPath());
-  if (!pathResult.valid) {
-    errors.push(pathResult.error);
-  }
-  const topKResult = validatePositiveInt(inputs.topK, {
-    name: "topK",
-    min: 1,
-    max: 50,
-    defaultValue: 5
-  });
-  if (!topKResult.valid) {
-    errors.push(topKResult.error);
-  }
-  if (errors.length > 0) {
-    return { valid: false, errors };
-  }
-  return {
-    valid: true,
-    errors: [],
-    validated: {
-      query: inputs.query.trim(),
-      path: pathResult.path,
-      topK: topKResult.value
-    }
-  };
-}
-function validateSymbolsInputs(inputs) {
-  const errors = [];
-  const pathResult = validatePath(inputs.path || getDefaultKitPath());
-  if (!pathResult.valid) {
-    errors.push(pathResult.error);
-  }
-  let validatedFile;
-  if (inputs.file) {
-    const trimmed = inputs.file.trim();
-    if (trimmed.includes("..")) {
-      errors.push("File path cannot contain path traversal sequences");
-    } else {
-      validatedFile = trimmed;
-    }
-  }
-  let validatedPattern;
-  if (inputs.pattern) {
-    const patternResult = validateGlob(inputs.pattern);
-    if (!patternResult.valid) {
-      errors.push(`File pattern: ${patternResult.error}`);
-    } else {
-      validatedPattern = patternResult.value;
-    }
-  }
-  let validatedSymbolType;
-  if (inputs.symbolType) {
-    const sanitized = inputs.symbolType.trim().toLowerCase();
-    const validTypes = [
-      "function",
-      "class",
-      "variable",
-      "type",
-      "interface",
-      "method",
-      "property",
-      "constant"
-    ];
-    if (sanitized && !validTypes.includes(sanitized)) {
-      errors.push(`Invalid symbol type: ${inputs.symbolType}. Valid types: ${validTypes.join(", ")}`);
-    } else {
-      validatedSymbolType = sanitized || undefined;
-    }
-  }
-  if (errors.length > 0) {
-    return { valid: false, errors };
-  }
-  return {
-    valid: true,
-    errors: [],
-    validated: {
-      path: pathResult.path,
-      pattern: validatedPattern,
-      symbolType: validatedSymbolType,
-      file: validatedFile
-    }
-  };
-}
-function validateFileTreeInputs(inputs) {
-  const errors = [];
-  const pathResult = validatePath(inputs.path || getDefaultKitPath());
-  if (!pathResult.valid) {
-    errors.push(pathResult.error);
-  }
-  let validatedSubpath;
-  if (inputs.subpath) {
-    const trimmed = inputs.subpath.trim();
-    if (trimmed.includes("..")) {
-      errors.push("Subpath cannot contain path traversal sequences");
-    } else {
-      validatedSubpath = trimmed;
-    }
-  }
-  if (errors.length > 0) {
-    return { valid: false, errors };
-  }
-  return {
-    valid: true,
-    errors: [],
-    validated: {
-      path: pathResult.path,
-      subpath: validatedSubpath
-    }
-  };
-}
-function validateFileContentInputs(inputs) {
-  const errors = [];
-  const pathResult = validatePath(inputs.path || getDefaultKitPath());
-  if (!pathResult.valid) {
-    errors.push(pathResult.error);
-  }
-  if (!inputs.filePaths || inputs.filePaths.length === 0) {
-    errors.push("At least one file path is required");
-  } else {
-    const validatedPaths = [];
-    for (const filePath of inputs.filePaths) {
-      const trimmed = filePath.trim();
-      if (!trimmed) {
-        errors.push("File paths cannot be empty");
-      } else if (trimmed.includes("..")) {
-        errors.push(`File path "${trimmed}" cannot contain path traversal sequences`);
-      } else {
-        validatedPaths.push(trimmed);
-      }
-    }
-    if (validatedPaths.length > 20) {
-      errors.push("Cannot request more than 20 files at once");
-    }
-  }
-  if (errors.length > 0) {
-    return { valid: false, errors };
-  }
-  return {
-    valid: true,
-    errors: [],
-    validated: {
-      path: pathResult.path,
-      filePaths: inputs.filePaths.map((p) => p.trim())
-    }
-  };
-}
-function validateUsagesInputs(inputs) {
-  const errors = [];
-  const pathResult = validatePath(inputs.path || getDefaultKitPath());
-  if (!pathResult.valid) {
-    errors.push(pathResult.error);
-  }
-  if (!inputs.symbolName || inputs.symbolName.trim() === "") {
-    errors.push("Symbol name is required");
-  }
-  let validatedSymbolType;
-  if (inputs.symbolType) {
-    const sanitized = inputs.symbolType.trim().toLowerCase();
-    const validTypes = [
-      "function",
-      "class",
-      "variable",
-      "type",
-      "interface",
-      "method",
-      "property",
-      "constant"
-    ];
-    if (sanitized && !validTypes.includes(sanitized)) {
-      errors.push(`Invalid symbol type: ${inputs.symbolType}. Valid types: ${validTypes.join(", ")}`);
-    } else {
-      validatedSymbolType = sanitized || undefined;
-    }
-  }
-  if (errors.length > 0) {
-    return { valid: false, errors };
-  }
-  return {
-    valid: true,
-    errors: [],
-    validated: {
-      path: pathResult.path,
-      symbolName: inputs.symbolName.trim(),
-      symbolType: validatedSymbolType
-    }
-  };
-}
-function validateAstSearchInputs(inputs) {
-  const errors = [];
-  if (!inputs.pattern || inputs.pattern.trim() === "") {
-    errors.push("Pattern cannot be empty");
-  }
-  const validModes = ["simple", "pattern"];
-  const mode = (inputs.mode || "simple").toLowerCase();
-  if (!validModes.includes(mode)) {
-    errors.push(`Invalid mode: ${inputs.mode}. Valid modes: ${validModes.join(", ")}`);
-  }
-  if (mode === "pattern" && inputs.pattern) {
-    try {
-      JSON.parse(inputs.pattern);
-    } catch {}
-  }
-  let validatedFilePattern;
-  if (inputs.filePattern) {
-    const patternResult = validateGlob(inputs.filePattern);
-    if (!patternResult.valid) {
-      errors.push(`File pattern: ${patternResult.error}`);
-    } else {
-      validatedFilePattern = patternResult.value;
-    }
-  }
-  const pathResult = validatePath(inputs.path || getDefaultKitPath());
-  if (!pathResult.valid) {
-    errors.push(pathResult.error);
-  }
-  const maxResultsResult = validatePositiveInt(inputs.maxResults, {
-    name: "maxResults",
-    min: 1,
-    max: 500,
-    defaultValue: 100
-  });
-  if (!maxResultsResult.valid) {
-    errors.push(maxResultsResult.error);
-  }
-  if (errors.length > 0) {
-    return { valid: false, errors };
-  }
-  return {
-    valid: true,
-    errors: [],
-    validated: {
-      pattern: inputs.pattern.trim(),
-      mode,
-      filePattern: validatedFilePattern,
-      path: pathResult.path,
-      maxResults: maxResultsResult.value
-    }
-  };
-}
-export {
-  validateUsagesInputs,
-  validateSymbolsInputs,
-  validateSemanticInputs,
-  validatePositiveInt,
-  validatePath,
-  validateGrepInputs,
-  validateFileTreeInputs,
-  validateFileContentInputs,
-  validateAstSearchInputs,
-  usagesLogger,
-  symbolsLogger,
-  semanticLogger,
-  logger,
-  logFile,
-  logDir,
-  isTimeoutError,
-  isSupported,
-  isSemanticUnavailableError,
-  isSemanticIndexBuilt,
-  isKitInstalled,
-  isError,
-  initParser,
-  initLogger,
-  grepLogger,
-  getUsagesLogger,
-  getSymbolsLogger,
-  getSupportedGlob,
-  getSemanticLogger,
-  getSemanticCacheDir,
-  getParser,
-  getKitVersion,
-  getKitLogger,
-  getGrepLogger,
-  getFileTreeLogger,
-  getFileContentLogger,
-  getDefaultKitPath,
-  getAstLogger,
-  formatUsagesResults,
-  formatSymbolsResults,
-  formatSemanticResults,
-  formatIndexStatsResults,
-  formatIndexPrimeResults,
-  formatIndexOverviewResults,
-  formatIndexFindResults,
-  formatGrepResults,
-  formatFileTreeResults,
-  formatFileContentResults,
-  formatError,
-  formatAstSearchResults,
-  fileTreeLogger,
-  fileContentLogger,
-  executeKitUsages,
-  executeKitSymbols,
-  executeKitSummarize,
-  executeKitSemantic,
-  executeKitGrep,
-  executeKitFileTree,
-  executeKitFileContent,
-  executeKitCommit,
-  executeIndexStats,
-  executeIndexPrime,
-  executeIndexOverview,
-  executeIndexFind,
-  executeAstSearch,
-  detectLanguage,
-  detectErrorType,
-  createErrorFromOutput,
-  createCorrelationId,
-  astLogger,
-  USAGES_TIMEOUT,
-  SearchMode,
-  SYMBOLS_TIMEOUT,
-  SUPPORTED_LANGUAGES,
-  SUMMARIZE_TIMEOUT,
-  SEMANTIC_TIMEOUT,
-  SEMANTIC_INSTALL_HINT,
-  ResponseFormat,
-  LANGUAGES,
-  KitErrorType,
-  KitError,
-  KIT_DEFAULT_PATH_ENV,
-  GREP_TIMEOUT,
-  FILE_TREE_TIMEOUT,
-  FILE_CONTENT_TIMEOUT,
-  ERROR_MESSAGES,
-  DEFAULT_TOP_K,
-  DEFAULT_MAX_RESULTS,
-  COMMIT_TIMEOUT,
-  AST_SEARCH_TIMEOUT,
-  ASTSearcher,
-  ASTPattern
-};
+/**
+ * @side-quest/kit
+ *
+ * Kit CLI integration for intelligent code search - MCP server with 7 tools
+ * for token-efficient codebase navigation.
+ */
+export * from './lib/index.js';
+//# sourceMappingURL=index.js.map