@aicodepulse/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1344 @@
+// src/types.ts
+var DEFAULT_CONFIG = {
+  exclude: ["node_modules", ".git", "dist", "build", ".next", "__pycache__", "*.min.js"],
+  maxFileSizeBytes: 512 * 1024,
+  defaultBudgetTokens: 4e3,
+  layerWeights: {
+    repo_overview: 0.1,
+    directory_map: 0.2,
+    symbol_table: 0.45,
+    import_graph: 0.15,
+    focus: 0.1
+  }
+};
+
+// src/storage/Database.ts
+import BetterSqlite3 from "better-sqlite3";
+var SCHEMA_VERSION = 1;
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS index_meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS file_records (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  path         TEXT NOT NULL UNIQUE,
+  language     TEXT NOT NULL,
+  content_hash TEXT NOT NULL,
+  size_bytes   INTEGER NOT NULL,
+  lines_total  INTEGER NOT NULL,
+  indexed_at   INTEGER NOT NULL,
+  is_deleted   INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_file_language ON file_records(language);
+CREATE INDEX IF NOT EXISTS idx_file_deleted  ON file_records(is_deleted);
+
+CREATE TABLE IF NOT EXISTS symbols (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  file_id      INTEGER NOT NULL REFERENCES file_records(id) ON DELETE CASCADE,
+  file_path    TEXT NOT NULL,
+  name         TEXT NOT NULL,
+  kind         TEXT NOT NULL,
+  line         INTEGER NOT NULL,
+  end_line     INTEGER NOT NULL,
+  is_exported  INTEGER NOT NULL DEFAULT 0,
+  signature    TEXT,
+  doc_comment  TEXT,
+  parent_name  TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_symbol_file     ON symbols(file_id);
+CREATE INDEX IF NOT EXISTS idx_symbol_name     ON symbols(name);
+CREATE INDEX IF NOT EXISTS idx_symbol_exported ON symbols(is_exported);
+
+CREATE TABLE IF NOT EXISTS import_edges (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  from_file_id    INTEGER NOT NULL REFERENCES file_records(id) ON DELETE CASCADE,
+  from_path       TEXT NOT NULL,
+  to_path         TEXT,
+  to_package      TEXT,
+  imported_names  TEXT NOT NULL,
+  is_type_only    INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_import_from ON import_edges(from_file_id);
+CREATE INDEX IF NOT EXISTS idx_import_to   ON import_edges(to_path);
+`;
+function openDatabase(dbPath) {
+  const db = new BetterSqlite3(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  runMigrations(db);
+  return db;
+}
+function runMigrations(db) {
+  db.exec(SCHEMA_SQL);
+  const existing = db.prepare("SELECT value FROM index_meta WHERE key = 'schema_version'").get();
+  if (!existing) {
+    db.prepare("INSERT INTO index_meta (key, value) VALUES ('schema_version', ?)").run(String(SCHEMA_VERSION));
+  }
+}
+
+// src/storage/FileRepository.ts
+function rowToFile(row) {
+  return {
+    id: row.id,
+    path: row.path,
+    language: row.language,
+    contentHash: row.content_hash,
+    sizeBytes: row.size_bytes,
+    linesTotal: row.lines_total,
+    indexedAt: row.indexed_at,
+    isDeleted: Boolean(row.is_deleted)
+  };
+}
+var FileRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  upsert(file) {
+    const result = this.db.prepare(`
+      INSERT INTO file_records (path, language, content_hash, size_bytes, lines_total, indexed_at, is_deleted)
+      VALUES (@path, @language, @contentHash, @sizeBytes, @linesTotal, @indexedAt, @isDeleted)
+      ON CONFLICT(path) DO UPDATE SET
+        language     = excluded.language,
+        content_hash = excluded.content_hash,
+        size_bytes   = excluded.size_bytes,
+        lines_total  = excluded.lines_total,
+        indexed_at   = excluded.indexed_at,
+        is_deleted   = excluded.is_deleted
+    `).run({
+      path: file.path,
+      language: file.language,
+      contentHash: file.contentHash,
+      sizeBytes: file.sizeBytes,
+      linesTotal: file.linesTotal,
+      indexedAt: file.indexedAt,
+      isDeleted: file.isDeleted ? 1 : 0
+    });
+    return result.lastInsertRowid;
+  }
+  getByPath(path) {
+    const row = this.db.prepare("SELECT * FROM file_records WHERE path = ?").get(path);
+    return row ? rowToFile(row) : null;
+  }
+  markDeleted(path) {
+    this.db.prepare("UPDATE file_records SET is_deleted = 1 WHERE path = ?").run(path);
+  }
+  getAllActive() {
+    const rows = this.db.prepare("SELECT * FROM file_records WHERE is_deleted = 0 ORDER BY path").all();
+    return rows.map(rowToFile);
+  }
+  getLanguageStats() {
+    return this.db.prepare(`
+      SELECT language, COUNT(*) as count
+      FROM file_records WHERE is_deleted = 0
+      GROUP BY language ORDER BY count DESC
+    `).all();
+  }
+};
+
+// src/storage/SymbolRepository.ts
+function rowToSymbol(row) {
+  return {
+    id: row.id,
+    fileId: row.file_id,
+    filePath: row.file_path,
+    name: row.name,
+    kind: row.kind,
+    line: row.line,
+    endLine: row.end_line,
+    isExported: Boolean(row.is_exported),
+    signature: row.signature,
+    docComment: row.doc_comment,
+    parentName: row.parent_name
+  };
+}
+function rowToImport(row) {
+  return {
+    id: row.id,
+    fromFileId: row.from_file_id,
+    fromPath: row.from_path,
+    toPath: row.to_path,
+    toPackage: row.to_package,
+    importedNames: JSON.parse(row.imported_names),
+    isTypeOnly: Boolean(row.is_type_only)
+  };
+}
+var SymbolRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  insertSymbols(fileId, symbols) {
+    const stmt = this.db.prepare(`
+      INSERT INTO symbols (file_id, file_path, name, kind, line, end_line, is_exported, signature, doc_comment, parent_name)
+      VALUES (@fileId, @filePath, @name, @kind, @line, @endLine, @isExported, @signature, @docComment, @parentName)
+    `);
+    for (const s of symbols) {
+      stmt.run({
+        fileId: s.fileId,
+        filePath: s.filePath,
+        name: s.name,
+        kind: s.kind,
+        line: s.line,
+        endLine: s.endLine,
+        isExported: s.isExported ? 1 : 0,
+        signature: s.signature,
+        docComment: s.docComment,
+        parentName: s.parentName
+      });
+    }
+  }
+  insertImports(fileId, edges) {
+    const stmt = this.db.prepare(`
+      INSERT INTO import_edges (from_file_id, from_path, to_path, to_package, imported_names, is_type_only)
+      VALUES (@fromFileId, @fromPath, @toPath, @toPackage, @importedNames, @isTypeOnly)
+    `);
+    for (const e of edges) {
+      stmt.run({
+        fromFileId: e.fromFileId,
+        fromPath: e.fromPath,
+        toPath: e.toPath,
+        toPackage: e.toPackage,
+        importedNames: JSON.stringify(e.importedNames),
+        isTypeOnly: e.isTypeOnly ? 1 : 0
+      });
+    }
+  }
+  deleteByFileId(fileId) {
+    this.db.prepare("DELETE FROM symbols WHERE file_id = ?").run(fileId);
+    this.db.prepare("DELETE FROM import_edges WHERE from_file_id = ?").run(fileId);
+  }
+  getExportedByFile(filePath) {
+    const rows = this.db.prepare(
+      "SELECT * FROM symbols WHERE file_path = ? AND is_exported = 1 ORDER BY line"
+    ).all(filePath);
+    return rows.map(rowToSymbol);
+  }
+  getAllExported() {
+    const rows = this.db.prepare(
+      "SELECT * FROM symbols WHERE is_exported = 1 ORDER BY file_path, line"
+    ).all();
+    return rows.map(rowToSymbol);
+  }
+  search(query, limit = 20) {
+    const rows = this.db.prepare(
+      "SELECT * FROM symbols WHERE name LIKE ? AND is_exported = 1 LIMIT ?"
+    ).all(`%${query}%`, limit);
+    return rows.map(rowToSymbol);
+  }
+  getImportsFrom(filePath) {
+    const rows = this.db.prepare(
+      "SELECT * FROM import_edges WHERE from_path = ?"
+    ).all(filePath);
+    return rows.map(rowToImport);
+  }
+  getImportersOf(filePath) {
+    const rows = this.db.prepare(
+      "SELECT DISTINCT from_path FROM import_edges WHERE to_path = ?"
+    ).all(filePath);
+    return rows.map((r) => r.from_path);
+  }
+  getTopImportedFiles(limit = 20) {
+    return this.db.prepare(`
+      SELECT to_path as path, COUNT(*) as importerCount
+      FROM import_edges WHERE to_path IS NOT NULL
+      GROUP BY to_path ORDER BY importerCount DESC LIMIT ?
+    `).all(limit);
+  }
+};
+
+// src/storage/MetaRepository.ts
+var MetaRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  get(key) {
+    const row = this.db.prepare("SELECT value FROM index_meta WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  set(key, value) {
+    this.db.prepare("INSERT OR REPLACE INTO index_meta (key, value) VALUES (?, ?)").run(key, value);
+  }
+  getIndexMeta() {
+    const fileCount = this.db.prepare("SELECT COUNT(*) as c FROM file_records WHERE is_deleted = 0").get().c;
+    const symbolCount = this.db.prepare("SELECT COUNT(*) as c FROM symbols").get().c;
+    return {
+      schemaVersion: Number(this.get("schema_version") ?? 1),
+      lastIndexedCommit: this.get("last_indexed_commit") ?? "",
+      lastIndexedAt: Number(this.get("last_indexed_at") ?? 0),
+      repoRoot: this.get("repo_root") ?? "",
+      totalFiles: fileCount,
+      totalSymbols: symbolCount
+    };
+  }
+  saveIndexMeta(commit, repoRoot) {
+    this.set("last_indexed_commit", commit);
+    this.set("last_indexed_at", String(Date.now()));
+    this.set("repo_root", repoRoot);
+  }
+};
+
+// src/indexer/Indexer.ts
+import Parser from "tree-sitter";
+import { readFileSync as readFileSync2, statSync } from "fs";
+import { join as join2 } from "path";
+
+// src/parser/ParserRegistry.ts
+import { createRequire } from "module";
+var req = createRequire(import.meta.url);
+var registry = null;
+function buildRegistry() {
+  const map = /* @__PURE__ */ new Map();
+  const entries = [
+    [[".js", ".mjs", ".cjs"], "javascript", "tree-sitter-javascript"],
+    [[".ts", ".tsx", ".mts", ".cts"], "typescript", "tree-sitter-typescript", (m) => m.typescript],
+    [[".py", ".pyw"], "python", "tree-sitter-python"],
+    [[".go"], "go", "tree-sitter-go"],
+    [[".rs"], "rust", "tree-sitter-rust"],
+    [[".java"], "java", "tree-sitter-java"],
+    [[".c", ".h"], "c", "tree-sitter-c"],
+    [[".cpp", ".cc", ".cxx", ".hpp", ".hxx"], "cpp", "tree-sitter-cpp"],
+    [[".cs"], "csharp", "tree-sitter-c-sharp"],
+    [[".rb"], "ruby", "tree-sitter-ruby"],
+    [[".php"], "php", "tree-sitter-php", (m) => m.php],
+    [[".sh", ".bash"], "bash", "tree-sitter-bash"],
+    [[".kt", ".kts"], "kotlin", "tree-sitter-kotlin"],
+    [[".swift"], "swift", "tree-sitter-swift"]
+  ];
+  for (const [exts, name, pkg, extract] of entries) {
+    try {
+      const mod = req(pkg);
+      const lang = extract ? extract(mod) : mod;
+      const config = { language: lang, extensions: exts, name };
+      for (const ext of exts) map.set(ext, config);
+    } catch {
+    }
+  }
+  return map;
+}
+function getRegistry() {
+  if (!registry) registry = buildRegistry();
+  return registry;
+}
+function getLanguageForExtension(ext) {
+  return getRegistry().get(ext) ?? null;
+}
+function extensionFromPath(filePath) {
+  const dot = filePath.lastIndexOf(".");
+  return dot === -1 ? "" : filePath.slice(dot).toLowerCase();
+}
+
+// src/parser/languages/typescript.ts
+var typescriptQueries = {
+  symbols: `
+    (export_statement
+      (function_declaration name: (identifier) @name) @node
+      (#set! kind "function"))
+
+    (export_statement
+      (class_declaration name: (type_identifier) @name) @node
+      (#set! kind "class"))
+
+    (export_statement
+      (interface_declaration name: (type_identifier) @name) @node
+      (#set! kind "interface"))
+
+    (export_statement
+      (type_alias_declaration name: (type_identifier) @name) @node
+      (#set! kind "type"))
+
+    (export_statement
+      (enum_declaration name: (identifier) @name) @node
+      (#set! kind "enum"))
+
+    (export_statement
+      (lexical_declaration
+        (variable_declarator name: (identifier) @name)) @node
+      (#set! kind "variable"))
+
+    (export_statement
+      declaration: (function_declaration name: (identifier) @name) @node
+      (#set! kind "function"))
+
+    (export_default_declaration
+      (function_declaration name: (identifier) @name) @node
+      (#set! kind "function"))
+
+    (export_default_declaration
+      (class_declaration name: (type_identifier) @name) @node
+      (#set! kind "class"))
+  `,
+  imports: `
+    (import_statement
+      source: (string (string_fragment) @source)
+      (import_clause
+        (named_imports
+          (import_specifier name: (identifier) @specifier)))) @node
+
+    (import_statement
+      source: (string (string_fragment) @source)) @node
+  `
+};
+var javascriptQueries = typescriptQueries;
+
+// src/parser/languages/python.ts
+var pythonQueries = {
+  symbols: `
+    (function_definition name: (identifier) @name) @node
+
+    (class_definition name: (identifier) @name) @node
+
+    (expression_statement
+      (assignment
+        left: (identifier) @name)) @node
+  `,
+  imports: `
+    (import_statement
+      name: (dotted_name) @source) @node
+
+    (import_from_statement
+      module_name: (dotted_name) @source
+      name: (import_from_as_names
+        (dotted_name) @specifier)) @node
+
+    (import_from_statement
+      module_name: (dotted_name) @source) @node
+  `
+};
+
+// src/parser/languages/go.ts
+var goQueries = {
+  symbols: `
+    (function_declaration name: (identifier) @name) @node
+
+    (method_declaration name: (field_identifier) @name) @node
+
+    (type_declaration
+      (type_spec name: (type_identifier) @name)) @node
+
+    (var_declaration
+      (var_spec name: (identifier) @name)) @node
+
+    (const_declaration
+      (const_spec name: (identifier) @name)) @node
+  `,
+  imports: `
+    (import_spec path: (interpreted_string_literal) @source) @node
+  `
+};
+
+// src/parser/languages/rust.ts
+var rustQueries = {
+  symbols: `
+    (function_item name: (identifier) @name) @node
+
+    (struct_item name: (type_identifier) @name) @node
+
+    (enum_item name: (type_identifier) @name) @node
+
+    (trait_item name: (type_identifier) @name) @node
+
+    (impl_item type: (type_identifier) @name) @node
+
+    (type_item name: (type_identifier) @name) @node
+
+    (const_item name: (identifier) @name) @node
+  `,
+  imports: `
+    (use_declaration
+      argument: (scoped_identifier path: (identifier) @source)) @node
+
+    (extern_crate_declaration name: (identifier) @source) @node
+  `
+};
+
+// src/parser/languages/java.ts
+var javaQueries = {
+  symbols: `
+    (class_declaration name: (identifier) @name) @node
+
+    (interface_declaration name: (identifier) @name) @node
+
+    (enum_declaration name: (identifier) @name) @node
+
+    (method_declaration name: (identifier) @name) @node
+
+    (field_declaration
+      declarator: (variable_declarator name: (identifier) @name)) @node
+  `,
+  imports: `
+    (import_declaration (scoped_identifier) @source) @node
+  `
+};
+
+// src/parser/languages/c.ts
+var cQueries = {
+  symbols: `
+    (function_definition
+      declarator: (function_declarator
+        declarator: (identifier) @name)) @node
+
+    (declaration
+      declarator: (function_declarator
+        declarator: (identifier) @name)) @node
+
+    (struct_specifier name: (type_identifier) @name) @node
+
+    (enum_specifier name: (type_identifier) @name) @node
+
+    (type_definition
+      declarator: (type_identifier) @name) @node
+  `,
+  imports: `
+    (preproc_include path: (string_literal) @source) @node
+    (preproc_include path: (system_lib_string) @source) @node
+  `
+};
+var cppQueries = {
+  symbols: `
+    (function_definition
+      declarator: (function_declarator
+        declarator: (identifier) @name)) @node
+
+    (function_definition
+      declarator: (function_declarator
+        declarator: (qualified_identifier name: (identifier) @name))) @node
+
+    (class_specifier name: (type_identifier) @name) @node
+
+    (struct_specifier name: (type_identifier) @name) @node
+
+    (enum_specifier name: (type_identifier) @name) @node
+
+    (namespace_definition name: (identifier) @name) @node
+  `,
+  imports: `
+    (preproc_include path: (string_literal) @source) @node
+    (preproc_include path: (system_lib_string) @source) @node
+  `
+};
+
+// src/parser/languages/csharp.ts
+var csharpQueries = {
+  symbols: `
+    (class_declaration name: (identifier) @name) @node
+
+    (interface_declaration name: (identifier) @name) @node
+
+    (enum_declaration name: (identifier) @name) @node
+
+    (struct_declaration name: (identifier) @name) @node
+
+    (method_declaration name: (identifier) @name) @node
+
+    (property_declaration name: (identifier) @name) @node
+
+    (record_declaration name: (identifier) @name) @node
+  `,
+  imports: `
+    (using_directive (qualified_name) @source) @node
+    (using_directive (identifier) @source) @node
+  `
+};
+
+// src/parser/languages/ruby.ts
+var rubyQueries = {
+  symbols: `
+    (method name: (identifier) @name) @node
+
+    (singleton_method name: (identifier) @name) @node
+
+    (class name: (constant) @name) @node
+
+    (module name: (constant) @name) @node
+  `,
+  imports: `
+    (call
+      method: (identifier) @method
+      arguments: (argument_list (string (string_content) @source))
+      (#match? @method "^(require|require_relative|load)$")) @node
+  `
+};
+
+// src/parser/languages/php.ts
+var phpQueries = {
+  symbols: `
+    (function_definition name: (name) @name) @node
+
+    (class_declaration name: (name) @name) @node
+
+    (interface_declaration name: (name) @name) @node
+
+    (trait_declaration name: (name) @name) @node
+
+    (enum_declaration name: (name) @name) @node
+
+    (method_declaration name: (name) @name) @node
+  `,
+  imports: `
+    (namespace_use_declaration
+      (namespace_use_clause (qualified_name) @source)) @node
+
+    (require_expression (string (string_value) @source)) @node
+    (include_expression (string (string_value) @source)) @node
+  `
+};
+
+// src/parser/languages/bash.ts
+var bashQueries = {
+  symbols: `
+    (function_definition name: (word) @name) @node
+  `,
+  imports: `
+    (command
+      name: (command_name (word) @cmd)
+      argument: (word) @source
+      (#match? @cmd "^(source|\\.)$")) @node
+  `
+};
+
+// src/parser/languages/kotlin.ts
+var kotlinQueries = {
+  symbols: `
+    (function_declaration (simple_identifier) @name) @node
+
+    (class_declaration (type_identifier) @name) @node
+
+    (object_declaration (type_identifier) @name) @node
+
+    (interface_declaration (type_identifier) @name) @node
+  `,
+  imports: `
+    (import_header (identifier) @source) @node
+  `
+};
+
+// src/parser/languages/swift.ts
+var swiftQueries = {
+  symbols: `
+    (function_declaration name: (simple_identifier) @name) @node
+
+    (class_declaration name: (type_identifier) @name) @node
+
+    (struct_declaration name: (type_identifier) @name) @node
+
+    (enum_declaration name: (type_identifier) @name) @node
+
+    (protocol_declaration name: (type_identifier) @name) @node
+
+    (typealias_declaration name: (type_identifier) @name) @node
+  `,
+  imports: `
+    (import_declaration (identifier) @source) @node
+  `
+};
+
+// src/parser/SymbolExtractor.ts
+var LANGUAGE_QUERIES = {
+  typescript: typescriptQueries,
+  javascript: javascriptQueries,
+  python: pythonQueries,
+  go: goQueries,
+  rust: rustQueries,
+  java: javaQueries,
+  c: cQueries,
+  cpp: cppQueries,
+  csharp: csharpQueries,
+  ruby: rubyQueries,
+  php: phpQueries,
+  bash: bashQueries,
+  kotlin: kotlinQueries,
+  swift: swiftQueries
+};
+var KIND_DEFAULTS = {
+  function_definition: "function",
+  function_declaration: "function",
+  function_item: "function",
+  method_declaration: "method",
+  method_definition: "method",
+  class_declaration: "class",
+  class_definition: "class",
+  class_specifier: "class",
+  class_item: "class",
+  interface_declaration: "interface",
+  interface_item: "interface",
+  type_alias_declaration: "type",
+  type_item: "type",
+  type_definition: "type",
+  enum_declaration: "enum",
+  enum_item: "enum",
+  struct_item: "class",
+  struct_specifier: "class",
+  trait_item: "interface",
+  trait_declaration: "interface",
+  export_statement: "variable",
+  lexical_declaration: "variable",
+  var_declaration: "variable",
+  const_item: "constant",
+  const_declaration: "constant"
+};
+function inferKind(node) {
+  const type = node.type;
+  if (KIND_DEFAULTS[type]) return KIND_DEFAULTS[type];
+  for (const child of node.children) {
+    if (KIND_DEFAULTS[child.type]) return KIND_DEFAULTS[child.type];
+  }
+  return "variable";
+}
+function extractDocComment(node) {
+  const prev = node.previousNamedSibling;
+  if (!prev) return null;
+  const text = prev.text;
+  if (text.startsWith("/**") || text.startsWith("///") || text.startsWith("#")) {
+    const line = text.split("\n")[0].replace(/^[/*#\s]+/, "").trim();
+    return line || null;
+  }
+  return null;
+}
+function extractSignature(node, name) {
+  const params = node.childForFieldName("parameters") ?? node.children.find((c) => c.type === "formal_parameters" || c.type === "parameters");
+  if (!params) return null;
+  const retType = node.childForFieldName("return_type") ?? node.childForFieldName("type");
+  const sig = retType ? `${params.text}: ${retType.text}` : params.text;
+  return sig.length > 80 ? sig.slice(0, 77) + "..." : sig;
+}
+function extractSymbols(tree, filePath, fileId, language, source) {
+  const queries = LANGUAGE_QUERIES[language];
+  if (!queries) return [];
+  const symbols = [];
+  const lines = source.split("\n");
+  const isExportedLang = ["typescript", "javascript"].includes(language);
+  function walk(node, depth = 0) {
+    const nodeType = node.type;
+    const nameNode = node.childForFieldName("name");
+    if (nameNode && KIND_DEFAULTS[nodeType]) {
+      const name = nameNode.text;
+      const isExported = isExportedLang ? node.parent?.type === "export_statement" || node.parent?.type === "export_default_declaration" : name.length > 0 && name[0] === name[0].toUpperCase();
+      if (name && name.length > 0) {
+        symbols.push({
+          fileId,
+          filePath,
+          name,
+          kind: inferKind(node),
+          line: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1,
+          isExported,
+          signature: extractSignature(node, name),
+          docComment: extractDocComment(node),
+          parentName: null
+        });
+      }
+    }
+    for (const child of node.children) {
+      if (depth < 6) walk(child, depth + 1);
+    }
+  }
+  walk(tree.rootNode);
+  return symbols;
+}
+
+// src/parser/ImportExtractor.ts
+import { resolve, dirname, extname } from "path";
+function resolveImportPath(source, fromFile) {
+  if (source.startsWith(".")) {
+    const dir = dirname(fromFile);
+    let resolved = resolve(dir, source);
+    if (!extname(resolved)) resolved += ".ts";
+    return { toPath: resolved, toPackage: null };
+  }
+  const parts = source.split("/");
+  const pkg = source.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  return { toPath: null, toPackage: pkg };
+}
+function walkForImports(node, filePath, fileId, language, edges, depth = 0) {
+  if (depth > 4) return;
+  const type = node.type;
+  if (type === "import_statement") {
+    const sourceNode = node.children.find((c) => c.type === "string");
+    if (sourceNode) {
+      const raw = sourceNode.text.replace(/['"]/g, "");
+      const { toPath, toPackage } = resolveImportPath(raw, filePath);
+      const isTypeOnly = node.children.some((c) => c.text === "type");
+      const names = [];
+      const namedImports = node.children.find((c) => c.type === "import_clause");
+      if (namedImports) {
+        const named = namedImports.children.find((c) => c.type === "named_imports");
+        if (named) {
+          for (const spec of named.children) {
+            if (spec.type === "import_specifier") {
+              const n = spec.childForFieldName("name");
+              if (n) names.push(n.text);
+            }
+          }
+        }
+        if (names.length === 0) names.push("*");
+      }
+      edges.push({ fromFileId: fileId, fromPath: filePath, toPath, toPackage, importedNames: names, isTypeOnly });
+    }
+  }
+  if (language === "python") {
+    if (type === "import_statement") {
+      const name = node.children.find((c) => c.type === "dotted_name");
+      if (name) {
+        const mod = name.text.replace(/\./g, "/");
+        edges.push({ fromFileId: fileId, fromPath: filePath, toPath: null, toPackage: mod, importedNames: ["*"], isTypeOnly: false });
+      }
+    }
+    if (type === "import_from_statement") {
+      const mod = node.childForFieldName("module_name")?.text ?? "";
+      const names = [];
+      const nameList = node.children.find((c) => c.type === "import_from_as_names");
+      if (nameList) {
+        for (const c of nameList.children) {
+          if (c.type === "dotted_name") names.push(c.text);
+        }
+      }
+      if (names.length === 0) names.push("*");
+      const isRelative = mod.startsWith(".");
+      const { toPath, toPackage } = isRelative ? resolveImportPath(mod, filePath) : { toPath: null, toPackage: mod };
+      edges.push({ fromFileId: fileId, fromPath: filePath, toPath, toPackage, importedNames: names, isTypeOnly: false });
+    }
+  }
+  if (language === "go" && type === "import_spec") {
+    const pathNode = node.childForFieldName("path");
+    if (pathNode) {
+      const raw = pathNode.text.replace(/"/g, "");
+      edges.push({ fromFileId: fileId, fromPath: filePath, toPath: null, toPackage: raw, importedNames: ["*"], isTypeOnly: false });
+    }
+  }
+  if (language === "rust" && type === "use_declaration") {
+    const arg = node.children.find((c) => c.type !== "use" && c.type !== ";");
+    if (arg) {
+      edges.push({ fromFileId: fileId, fromPath: filePath, toPath: null, toPackage: arg.text, importedNames: ["*"], isTypeOnly: false });
+    }
+  }
+  for (const child of node.children) {
+    walkForImports(child, filePath, fileId, language, edges, depth + 1);
+  }
+}
+function extractImports(tree, filePath, fileId, language) {
+  const edges = [];
+  walkForImports(tree.rootNode, filePath, fileId, language, edges);
+  return edges;
+}
+
+// src/indexer/HashUtil.ts
+import { createHash } from "crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+
+// src/indexer/FileWalker.ts
+import { glob } from "glob";
+import Ignore from "ignore";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+async function walkFiles(repoRoot, config) {
+  const ig = Ignore.default();
+  const gitignorePath = join(repoRoot, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    ig.add(readFileSync(gitignorePath, "utf8"));
+  }
+  ig.add(config.exclude);
+  const pattern = "**/*";
+  const files = await glob(pattern, {
+    cwd: repoRoot,
+    nodir: true,
+    dot: false,
+    absolute: false
+  });
+  const result = [];
+  for (const rel of files) {
+    if (ig.ignores(rel)) continue;
+    result.push({
+      absolutePath: join(repoRoot, rel),
+      relativePath: rel.replace(/\\/g, "/")
+    });
+  }
+  return result;
+}
+
+// src/indexer/GitDiff.ts
+import { execSync } from "child_process";
+function getHeadCommit(repoRoot) {
+  try {
+    return execSync("git rev-parse HEAD", { cwd: repoRoot, encoding: "utf8" }).trim();
+  } catch {
+    return "";
+  }
+}
+function getChangedFiles(repoRoot, sinceCommit) {
+  if (!sinceCommit) return null;
+  try {
+    const output = execSync(
+      `git diff --name-status ${sinceCommit} HEAD`,
+      { cwd: repoRoot, encoding: "utf8" }
+    );
+    const changes = [];
+    for (const line of output.trim().split("\n")) {
+      if (!line) continue;
+      const parts = line.split("	");
+      const rawStatus = parts[0].charAt(0);
+      const status = ["M", "A", "D", "R"].includes(rawStatus) ? rawStatus : "M";
+      if (status === "R") {
+        changes.push({ status: "D", path: parts[1] });
+        changes.push({ status: "A", path: parts[2] });
+      } else {
+        changes.push({ status, path: parts[1] });
+      }
+    }
+    return changes;
+  } catch {
+    return null;
+  }
+}
+
+// src/indexer/Indexer.ts
+var Indexer = class {
+  constructor(db, repoRoot, config) {
+    this.db = db;
+    this.repoRoot = repoRoot;
+    this.config = config;
+    this.files = new FileRepository(db);
+    this.symbols = new SymbolRepository(db);
+    this.meta = new MetaRepository(db);
+  }
+  db;
+  repoRoot;
+  config;
+  parser = new Parser();
+  files;
+  symbols;
+  meta;
+  async runFull() {
+    const start = Date.now();
+    const allFiles = await walkFiles(this.repoRoot, this.config);
+    let added = 0, updated = 0, skipped = 0;
+    const transaction = this.db.transaction(() => {
+      for (const { absolutePath, relativePath } of allFiles) {
+        const result = this.indexFile(absolutePath, relativePath);
+        if (result === "added") added++;
+        else if (result === "updated") updated++;
+        else skipped++;
+      }
+    });
+    transaction();
+    const commit = getHeadCommit(this.repoRoot);
+    this.meta.saveIndexMeta(commit, this.repoRoot);
+    const metaInfo = this.meta.getIndexMeta();
+    return {
+      filesAdded: added,
+      filesUpdated: updated,
+      filesDeleted: 0,
+      filesSkipped: skipped,
+      symbolsTotal: metaInfo.totalSymbols,
+      durationMs: Date.now() - start,
+      mode: "full"
+    };
+  }
+  async runIncremental() {
+    const start = Date.now();
+    const lastCommit = this.meta.get("last_indexed_commit") ?? "";
+    const currentCommit = getHeadCommit(this.repoRoot);
+    if (!lastCommit || lastCommit === currentCommit) {
+      if (!lastCommit) return this.runFull();
+      return { filesAdded: 0, filesUpdated: 0, filesDeleted: 0, filesSkipped: 0, symbolsTotal: this.meta.getIndexMeta().totalSymbols, durationMs: 0, mode: "incremental" };
+    }
+    const changes = getChangedFiles(this.repoRoot, lastCommit);
+    if (!changes) return this.runFull();
+    let added = 0, updated = 0, deleted = 0, skipped = 0;
+    const transaction = this.db.transaction(() => {
+      for (const change of changes) {
+        const absPath = join2(this.repoRoot, change.path);
+        if (change.status === "D") {
+          const existing = this.files.getByPath(change.path);
+          if (existing) {
+            this.symbols.deleteByFileId(existing.id);
+            this.files.markDeleted(change.path);
+            deleted++;
+          }
+        } else {
+          const result = this.indexFile(absPath, change.path);
+          if (result === "added") added++;
+          else if (result === "updated") updated++;
+          else skipped++;
+        }
+      }
+    });
+    transaction();
+    this.meta.saveIndexMeta(currentCommit, this.repoRoot);
+    const metaInfo = this.meta.getIndexMeta();
+    return {
+      filesAdded: added,
+      filesUpdated: updated,
+      filesDeleted: deleted,
+      filesSkipped: skipped,
+      symbolsTotal: metaInfo.totalSymbols,
+      durationMs: Date.now() - start,
+      mode: "incremental"
+    };
+  }
+  indexFile(absolutePath, relativePath) {
+    let stat;
+    try {
+      stat = statSync(absolutePath);
+    } catch {
+      return "skipped";
+    }
+    if (stat.size > this.config.maxFileSizeBytes) return "skipped";
+    const ext = extensionFromPath(relativePath);
+    let content;
+    try {
+      content = readFileSync2(absolutePath, "utf8");
+    } catch {
+      return "skipped";
+    }
+    const contentHash = hashContent(content);
+    const existing = this.files.getByPath(relativePath);
+    if (existing && existing.contentHash === contentHash && !existing.isDeleted) {
+      return "skipped";
+    }
+    const isNew = !existing;
+    const lines = content.split("\n").length;
+    const langConfig = null;
+    const fileId = this.files.upsert({
+      path: relativePath,
+      language: "unknown",
+      contentHash,
+      sizeBytes: stat.size,
+      linesTotal: lines,
+      indexedAt: Date.now(),
+      isDeleted: false
+    });
+    const record = this.files.getByPath(relativePath);
+    if (!record) return "skipped";
+    this.symbols.deleteByFileId(record.id);
+    return isNew ? "added" : "updated";
+  }
+  async parseAndIndex(absolutePath, relativePath) {
+    const langConfig = getLanguageForExtension(extensionFromPath(relativePath));
+    if (!langConfig) return;
+    let content;
+    try {
+      content = readFileSync2(absolutePath, "utf8");
+    } catch {
+      return;
+    }
+    this.parser.setLanguage(langConfig.language);
+    const tree = this.parser.parse(content);
+    const record = this.files.getByPath(relativePath);
+    if (!record) return;
+    this.files.upsert({ ...record, language: langConfig.name });
+    const symbols = extractSymbols(tree, relativePath, record.id, langConfig.name, content);
+    const imports = extractImports(tree, relativePath, record.id, langConfig.name);
+    this.symbols.deleteByFileId(record.id);
+    if (symbols.length > 0) this.symbols.insertSymbols(record.id, symbols);
+    if (imports.length > 0) this.symbols.insertImports(record.id, imports);
+  }
+  async runFullWithParsing(onProgress) {
+    const start = Date.now();
+    const allFiles = await walkFiles(this.repoRoot, this.config);
+    const transaction = this.db.transaction(() => {
+      for (const { absolutePath, relativePath } of allFiles) {
+        this.indexFile(absolutePath, relativePath);
+      }
+    });
+    transaction();
+    const parseable = allFiles.filter((f) => {
+      const ext = extensionFromPath(f.relativePath);
+      return ext !== "";
+    });
+    let done = 0;
+    for (const { absolutePath, relativePath } of parseable) {
+      await this.parseAndIndex(absolutePath, relativePath);
+      done++;
+      onProgress?.(done, parseable.length);
+    }
+    const commit = getHeadCommit(this.repoRoot);
+    this.meta.saveIndexMeta(commit, this.repoRoot);
+    const metaInfo = this.meta.getIndexMeta();
+    return {
+      filesAdded: parseable.length,
+      filesUpdated: 0,
+      filesDeleted: 0,
+      filesSkipped: allFiles.length - parseable.length,
+      symbolsTotal: metaInfo.totalSymbols,
+      durationMs: Date.now() - start,
+      mode: "full"
+    };
+  }
+  async runIncrementalWithParsing(onProgress) {
+    const start = Date.now();
+    const lastCommit = this.meta.get("last_indexed_commit") ?? "";
+    const currentCommit = getHeadCommit(this.repoRoot);
+    if (!lastCommit) return this.runFullWithParsing(onProgress);
+    if (lastCommit === currentCommit) {
+      const metaInfo2 = this.meta.getIndexMeta();
+      return { filesAdded: 0, filesUpdated: 0, filesDeleted: 0, filesSkipped: 0, symbolsTotal: metaInfo2.totalSymbols, durationMs: 0, mode: "incremental" };
+    }
+    const changes = getChangedFiles(this.repoRoot, lastCommit);
+    if (!changes) return this.runFullWithParsing(onProgress);
+    let added = 0, updated = 0, deleted = 0;
+    const toReparse = [];
+    for (const change of changes) {
+      const absPath = join2(this.repoRoot, change.path);
+      if (change.status === "D") {
+        const existing = this.files.getByPath(change.path);
+        if (existing) {
+          this.symbols.deleteByFileId(existing.id);
+          this.files.markDeleted(change.path);
+          deleted++;
+        }
+      } else {
+        const result = this.indexFile(absPath, change.path);
+        if (result !== "skipped") {
+          toReparse.push({ abs: absPath, rel: change.path });
+          if (result === "added") added++;
+          else updated++;
+        }
+      }
+    }
+    let done = 0;
+    for (const { abs, rel } of toReparse) {
+      await this.parseAndIndex(abs, rel);
+      done++;
+      onProgress?.(done, toReparse.length);
+    }
+    this.meta.saveIndexMeta(currentCommit, this.repoRoot);
+    const metaInfo = this.meta.getIndexMeta();
+    return {
+      filesAdded: added,
+      filesUpdated: updated,
+      filesDeleted: deleted,
+      filesSkipped: 0,
+      symbolsTotal: metaInfo.totalSymbols,
+      durationMs: Date.now() - start,
+      mode: "incremental"
+    };
+  }
+};
+
+// src/context/BudgetAllocator.ts
+function allocateBudget(totalTokens, config, hasFocusPath, layers) {
+  const weights = { ...config.layerWeights };
+  if (!hasFocusPath) {
+    const focusWeight = weights.focus;
+    delete weights.focus;
+    const remaining = layers.filter((l) => l !== "focus");
+    const total = remaining.reduce((s, l) => s + (weights[l] ?? 0), 0);
+    for (const l of remaining) {
+      weights[l] = (weights[l] ?? 0) / total * (1 - focusWeight / 1) + (l === "symbol_table" ? focusWeight : 0);
+    }
+  }
+  const activeLayers = hasFocusPath ? layers : layers.filter((l) => l !== "focus");
+  const activeTotal = activeLayers.reduce((s, l) => s + (weights[l] ?? 0), 0);
+  return activeLayers.map((layer) => ({
+    layer,
+    tokens: Math.floor(totalTokens * (weights[layer] ?? 0) / activeTotal)
+  }));
+}
+
+// src/context/TokenCounter.ts
+import { encode } from "gpt-tokenizer";
+function countTokens(text) {
+  return encode(text).length;
+}
+
+// src/context/layers/RepoOverviewLayer.ts
+import { basename } from "path";
+function renderRepoOverview(db, budget) {
+  const meta = new MetaRepository(db).getIndexMeta();
+  const files = new FileRepository(db);
+  const langStats = files.getLanguageStats();
+  const repoName = basename(meta.repoRoot) || "unknown";
+  const lastIndexed = meta.lastIndexedAt ? new Date(meta.lastIndexedAt).toISOString().slice(0, 10) : "never";
+  const langSummary = langStats.slice(0, 8).map((l) => `${l.language}: ${l.count}`).join(", ");
+  const content = [
+    `# Repository: ${repoName}`,
+    `Files: ${meta.totalFiles} | Symbols: ${meta.totalSymbols} | Last indexed: ${lastIndexed}`,
+    `Languages: ${langSummary}`
+  ].join("\n");
+  return { content, truncated: countTokens(content) > budget };
+}
+
+// src/context/layers/DirectoryMapLayer.ts
+function renderTree(paths, maxLines) {
+  const dirs = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const slash = p.lastIndexOf("/");
+    const dir = slash === -1 ? "." : p.slice(0, slash);
+    if (!dirs.has(dir)) dirs.set(dir, []);
+    dirs.get(dir).push(slash === -1 ? p : p.slice(slash + 1));
+  }
+  const lines = [];
+  const topLevel = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const top = p.split("/")[0];
+    topLevel.set(top, (topLevel.get(top) ?? 0) + 1);
+  }
+  for (const [dir, count] of [...topLevel.entries()].sort()) {
+    if (lines.length >= maxLines) {
+      lines.push("...");
+      break;
+    }
+    lines.push(`${dir}/ (${count} files)`);
+  }
+  return lines.join("\n");
+}
+function renderDirectoryMap(db, budget) {
+  const allFiles = new FileRepository(db).getAllActive();
+  const paths = allFiles.map((f) => f.path);
+  const charsPerToken = 4;
+  const maxLines = Math.floor(budget * charsPerToken / 30);
+  const content = renderTree(paths, maxLines);
+  return { content, truncated: countTokens(content) > budget };
+}
+
+// src/context/layers/SymbolTableLayer.ts
+function renderSymbolTable(db, budget) {
+  const repo = new SymbolRepository(db);
+  const symbols = repo.getAllExported();
+  const byFile = /* @__PURE__ */ new Map();
+  for (const s of symbols) {
+    if (!byFile.has(s.filePath)) byFile.set(s.filePath, []);
+    byFile.get(s.filePath).push(s);
+  }
+  const sorted = [...byFile.entries()].sort((a, b) => b[1].length - a[1].length);
+  const lines = [];
+  let usedTokens = 0;
+  let truncated = false;
+  for (const [file, syms] of sorted) {
+    const header = `### ${file}`;
+    const symLines = syms.map((s) => {
+      const sig = s.signature ? `${s.name}${s.signature}` : s.name;
+      const doc = s.docComment ? ` \u2014 ${s.docComment}` : "";
+      return `  ${s.kind} ${sig}${doc}`;
+    });
+    const block = [header, ...symLines].join("\n");
+    const blockTokens = countTokens(block);
+    if (usedTokens + blockTokens > budget) {
+      truncated = true;
+      break;
+    }
+    lines.push(block);
+    usedTokens += blockTokens;
+  }
+  return { content: lines.join("\n\n"), truncated };
+}
+
+// src/context/layers/ImportGraphLayer.ts
+function renderImportGraph(db, budget) {
+  const repo = new SymbolRepository(db);
+  const hubs = repo.getTopImportedFiles(30);
+  const lines = ["### Most-imported modules"];
+  let usedTokens = countTokens(lines[0]);
+  let truncated = false;
+  for (const { path, importerCount } of hubs) {
+    const line = `  ${path} \u2190 imported by ${importerCount} files`;
+    const t = countTokens(line);
+    if (usedTokens + t > budget) {
+      truncated = true;
+      break;
+    }
+    lines.push(line);
+    usedTokens += t;
+  }
+  return { content: lines.join("\n"), truncated };
+}
+
+// src/context/layers/FocusLayer.ts
+function renderFocusLayer(db, focusPath, budget) {
+  const symRepo = new SymbolRepository(db);
+  const fileRepo = new FileRepository(db);
+  const allFiles = fileRepo.getAllActive().filter((f) => f.path.startsWith(focusPath));
+  const lines = [`### Focus: ${focusPath}`];
+  let usedTokens = countTokens(lines[0]);
+  let truncated = false;
+  for (const file of allFiles) {
+    const syms = symRepo.getExportedByFile(file.path);
+    if (syms.length === 0) continue;
+    const importers = symRepo.getImportersOf(file.path);
+    const fileLines = [`  ${file.path}:`];
+    for (const s of syms) {
+      const sig = s.signature ? `${s.name}${s.signature}` : s.name;
+      fileLines.push(`    ${s.kind} ${sig}`);
+    }
+    if (importers.length > 0) {
+      fileLines.push(`    \u2190 imported by: ${importers.slice(0, 3).join(", ")}${importers.length > 3 ? ` +${importers.length - 3} more` : ""}`);
+    }
+    const block = fileLines.join("\n");
+    const t = countTokens(block);
+    if (usedTokens + t > budget) {
+      truncated = true;
+      break;
+    }
+    lines.push(block);
+    usedTokens += t;
+  }
+  return { content: lines.join("\n"), truncated };
+}
+
+// src/context/ContextGenerator.ts
+var DEFAULT_LAYERS = ["repo_overview", "directory_map", "symbol_table", "import_graph", "focus"];
+function renderLayer(db, layer, budget, focusPath) {
+  switch (layer) {
+    case "repo_overview":
+      return renderRepoOverview(db, budget);
+    case "directory_map":
+      return renderDirectoryMap(db, budget);
+    case "symbol_table":
+      return renderSymbolTable(db, budget);
+    case "import_graph":
+      return renderImportGraph(db, budget);
+    case "focus":
+      return focusPath ? renderFocusLayer(db, focusPath, budget) : { content: "", truncated: false };
+    default:
+      return { content: "", truncated: false };
+  }
+}
+function wrapMarkdown(layers) {
+  return layers.map((l) => l.content).filter(Boolean).join("\n\n");
+}
+function wrapXML(layers) {
+  const inner = layers.filter((l) => l.content).map((l) => `  <${l.layer}>
+${l.content}
+  </${l.layer}>`).join("\n");
+  return `<codebase_context>
+${inner}
+</codebase_context>`;
+}
+function generateContext(db, request, config) {
+  const layers = request.layers ?? DEFAULT_LAYERS;
+  const hasFocus = Boolean(request.focusPath);
+  const budgets = allocateBudget(request.budgetTokens, config, hasFocus, layers);
+  let remainingSurplus = 0;
+  const results = [];
+  for (const { layer, tokens } of budgets) {
+    const layerBudget = tokens + remainingSurplus;
+    const { content, truncated } = renderLayer(db, layer, layerBudget, request.focusPath);
+    const used = countTokens(content);
+    remainingSurplus = truncated ? 0 : layerBudget - used;
+    results.push({ layer, tokensUsed: used, content, truncated });
+  }
+  const rendered = request.format === "xml" ? wrapXML(results) : wrapMarkdown(results);
+  const totalTokens = countTokens(rendered);
+  return {
+    totalTokens,
+    budgetTokens: request.budgetTokens,
+    layers: results,
+    rendered
+  };
+}
+export {
+  DEFAULT_CONFIG,
+  FileRepository,
+  Indexer,
+  MetaRepository,
+  SymbolRepository,
+  generateContext,
+  openDatabase
+};
+//# sourceMappingURL=index.js.map