@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-2WXYNLBA.js

@@ -0,0 +1,29 @@
+// src/ast/project-scoped-identity.ts
+function projectRelativePath(filePath, projectRoot) {
+  if (!projectRoot) return null;
+  const root = stripTrailingSlashes(projectRoot.split("\\").join("/"));
+  const file = stripTrailingSlashes(filePath.split("\\").join("/"));
+  if (root.length === 0 || file === root || !file.startsWith(root + "/")) return null;
+  return file.slice(root.length + 1);
+}
+function stripTrailingSlashes(p) {
+  let end = p.length;
+  while (end > 0 && p.charAt(end - 1) === "/") end--;
+  return p.slice(0, end);
+}
+function documentDirScope(filePath, projectRoot) {
+  const rel = projectRelativePath(filePath, projectRoot);
+  if (rel === null) return "";
+  const cut = rel.lastIndexOf("/");
+  if (cut < 0) return "";
+  return rel.slice(0, cut).split("/").filter((s) => s.length > 0).join(".");
+}
+function applyDocumentScope(basename, scope) {
+  return scope.length > 0 ? `${scope}.${basename}` : basename;
+}
+
+export {
+  projectRelativePath,
+  documentDirScope,
+  applyDocumentScope
+};

package/dist/chunk-3CTFIJJB.js

@@ -0,0 +1,17 @@
+// src/intelligence/source-utils.ts
+import { readFile } from "fs/promises";
+async function readSymbolSnippet(filePath, lineStart, lineEnd, maxLines = 12) {
+  if (!filePath || !lineStart) return void 0;
+  let text = "";
+  try {
+    text = await readFile(filePath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const end = Math.min(Math.max(lineEnd || lineStart, lineStart), lineStart + maxLines - 1);
+  return text.split("\n").slice(lineStart - 1, end).join("\n");
+}
+
+export {
+  readSymbolSnippet
+};

package/dist/chunk-3LFTSMIV.js

@@ -0,0 +1,174 @@
+import {
+  ParallelIndexerConfig,
+  parallelIndexerCliSkipPatterns
+} from "./chunk-PJTNGD3Z.js";
+
+// src/ast/fingerprint.ts
+import { createHash } from "crypto";
+import { readFile, readdir, stat, open } from "fs/promises";
+import path from "path";
+function relativePathFingerprint(sortedRel) {
+  return createHash("sha1").update(Array.from(new Set(sortedRel)).sort().join("\n")).digest("hex").substring(0, 40);
+}
+async function gitIdentity(root) {
+  try {
+    const { execFile } = await import("child_process");
+    const run = (args) => new Promise((resolve) => {
+      execFile("git", ["-C", root, ...args], { timeout: 4e3 }, (err, stdout) => {
+        resolve(err ? "" : stdout.toString().trim());
+      });
+    });
+    const remote = await run(["remote", "get-url", "origin"]);
+    const head = await run(["rev-parse", "HEAD"]);
+    if (!remote && !head) return null;
+    return `${remote || "(no-remote)"}|${head || "(no-head)"}`;
+  } catch {
+    return null;
+  }
+}
+var FULL_AST_LIMIT = 1 * 1024 * 1024;
+var STRUCTURAL_LIMIT = 5 * 1024 * 1024;
+var skipDirNames = /* @__PURE__ */ new Set([".git", ".svn", ".hg", ".cache", ".nyc_output", ".venv", ".next", ".nuxt", ".svelte-kit", ".turbo"]);
+var compiledDirTokens = ["/perf/", "/Microbenchmarks/", "/wwwroot/", "/coverage/", "/node_modules/", "/dist/", "/build/", "/.git/", "/obj/", "/bin/", "/testData/"];
+var cliSkipPatterns = Array.from(
+  /* @__PURE__ */ new Set([...ParallelIndexerConfig.skipPatterns, ...parallelIndexerCliSkipPatterns()])
+);
+async function loadIgnores(root, ownPath, parentIg) {
+  try {
+    const ignore = (await import("ignore")).default;
+    const ig = ignore({ ignorecase: false }).add(parentIg);
+    const entries = await readdir(ownPath, { withFileTypes: true });
+    for (const name of [".gitignore", ".bbignore"]) {
+      const f = entries.find((e) => e.isFile() && e.name === name);
+      if (!f) continue;
+      try {
+        const content = await readFile(path.join(ownPath, f.name), "utf8");
+        ig.add(content);
+      } catch {
+      }
+    }
+    return ig;
+  } catch {
+    return parentIg;
+  }
+}
+var DEFAULT_IGNORE_PATTERNS = [
+  "**/perf/**",
+  "**/Microbenchmarks/**",
+  "**/wwwroot/**",
+  "**/testassets/**",
+  "**/benchmarkapps/**",
+  "**/coverage/**",
+  "**/testData/**"
+];
+async function readShebang(p) {
+  try {
+    const fh = await open(p, "r");
+    try {
+      const buf = Buffer.alloc(256);
+      const { bytesRead } = await fh.read(buf, 0, 256, 0);
+      return buf.subarray(0, bytesRead).toString("utf8");
+    } finally {
+      await fh.close();
+    }
+  } catch {
+    return "";
+  }
+}
+async function walk(root, dir, ig, depth, rel) {
+  if (depth > 50) return;
+  let entries = [];
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  if (dir !== root && entries.some((e) => e.isDirectory() && e.name === ".git")) return;
+  const localIg = await loadIgnores(root, dir, ig);
+  const { detectLanguageFromPath } = await import("./language-detection-DFCAU5DZ.js");
+  const jobs = [];
+  for (const entry of entries) {
+    if (entry.isDirectory() && skipDirNames.has(entry.name)) continue;
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = path.relative(root, fullPath);
+    const withSlash = relativePath + (entry.isDirectory() ? "/" : "");
+    const normPath = "/" + relativePath + (entry.isDirectory() ? "/" : "");
+    if (compiledDirTokens.some((t) => normPath.includes(t))) continue;
+    if (localIg.ignores(withSlash)) continue;
+    if (entry.isDirectory()) {
+      jobs.push(walk(root, fullPath, localIg, depth + 1, rel));
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const baseName = entry.name;
+    const hasExt = baseName.lastIndexOf(".") > 0;
+    let detected = null;
+    if (hasExt) {
+      detected = detectLanguageFromPath(fullPath);
+    } else {
+      detected = detectLanguageFromPath(fullPath);
+      if (!detected) detected = detectLanguageFromPath(fullPath, await readShebang(fullPath));
+    }
+    if (!detected) continue;
+    if (cliSkipPatterns.some((p) => p.test(normPath))) continue;
+    jobs.push(
+      (async () => {
+        try {
+          const s = await stat(fullPath);
+          if (s.size > STRUCTURAL_LIMIT) return;
+          rel.push(relativePath);
+        } catch {
+        }
+      })()
+    );
+  }
+  await Promise.all(jobs);
+}
+async function computeCheckoutFingerprint(root) {
+  const { default: ignore } = await import("ignore");
+  const ig = ignore({ ignorecase: false }).add(DEFAULT_IGNORE_PATTERNS);
+  const rel = [];
+  await walk(root, root, ig, 0, rel);
+  const sorted = Array.from(new Set(rel)).sort();
+  const git = await gitIdentity(root);
+  const fingerprint = createHash("sha1").update(sorted.join("\n")).update(git ?? "").digest("hex").substring(0, 40);
+  return { fingerprint, fileCount: sorted.length, git };
+}
+function computeDbFingerprint(raw, git) {
+  const rows = raw.prepare("SELECT relative_path FROM brain_file").all();
+  const sorted = rows.map((r) => String(r.relative_path)).sort();
+  return createHash("sha1").update(sorted.join("\n")).update(git ?? "").digest("hex").substring(0, 40);
+}
+function readStoredFingerprint(raw, projectId) {
+  try {
+    const row = raw.prepare(
+      "SELECT codebase_fingerprint FROM brain_index_status WHERE project_id = ?"
+    ).get(projectId);
+    return row?.codebase_fingerprint ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function persistProjectFingerprint(projectId, projectPath) {
+  try {
+    const cf = await computeCheckoutFingerprint(projectPath);
+    const { BrainDatabase } = await import("./database-TCTZDLE5.js");
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    raw.prepare(
+      `UPDATE brain_index_status SET codebase_fingerprint = ?, codebase_git = ?, time_updated = strftime('%s','now')*1000
+         WHERE project_id = ?`
+    ).run(cf.fingerprint, cf.git ?? null, projectId);
+    return cf.fingerprint;
+  } catch {
+    return "";
+  }
+}
+
+export {
+  relativePathFingerprint,
+  gitIdentity,
+  computeCheckoutFingerprint,
+  computeDbFingerprint,
+  readStoredFingerprint,
+  persistProjectFingerprint
+};