@orquentra/codebuddy 2.9.0 → 2.14.0

package/dist/{chunk-2WH2Q4TA.js → chunk-YJPCS2GP.js}

@@ -1,6 +1,6 @@
 import {
   refreshZvecIndex
-} from "./chunk-GXOML4UZ.js";
+} from "./chunk-LW75SKZR.js";
 import {
   PlanFileStore,
   PlanLifecycle,
@@ -11,38 +11,41 @@ import {
   configuredReranker,
   enforceContextBudget,
   llmMemoryOptions,
+  rankSemanticReuse,
   readPolicyFile,
   resolveRiskPaths
-} from "./chunk-F4BJ3DXW.js";
-import {
-  SessionCapsuleLedger,
-  coveringTestCandidates,
-  estimateTokens
-} from "./chunk-GKNYMNFM.js";
+} from "./chunk-XSNW6Y3X.js";
 import {
   readTraces,
   recordTrace
 } from "./chunk-YN7TEIUH.js";
+import {
+  SessionCapsuleLedger,
+  coveringTestCandidates,
+  estimateTokens,
+  findCoveringTest
+} from "./chunk-4DKYKDHI.js";
 import {
   codeBuddyConfigSchema,
   createRuntime,
   listFactsPage
-} from "./chunk-QN76UJP7.js";
+} from "./chunk-YWDH6DQ6.js";
 import {
   MemoryFileStore,
   VERSION
-} from "./chunk-SRA4MDVG.js";
-import {
-  generateGraphifyGraph,
-  loadProjectArchitectureMap
-} from "./chunk-TLWGZVPC.js";
+} from "./chunk-7QMHIJBA.js";
 import {
+  NON_SOURCE_PATH,
+  TEST_PATH,
   buildArchitectureMap,
+  generateGraphifyGraph,
   indexRepository,
   loadFreshIndex,
+  loadProjectArchitectureMap,
   neighbours,
-  queryMap
-} from "./chunk-ITQO632W.js";
+  queryMap,
+  taskTerms
+} from "./chunk-YNSTIMCF.js";
 import {
   redactPersisted
 } from "./chunk-AL6VBTNA.js";
@@ -303,8 +306,8 @@ async function traceCliCommand(command, started, root = process.cwd()) {
   await flushTelemetry(root);
 }
 async function installedClients(repositoryRoot) {
-  const { CLIENT_IDS } = await import("./adapters-S4HHTWJW.js");
-  const { detectClient } = await import("./install-BXM56QCD.js");
+  const { CLIENT_IDS } = await import("./adapters-OJRSVFV3.js");
+  const { detectClient } = await import("./install-EU35ERK5.js");
   const found = [];
   for (const id of CLIENT_IDS) {
     const status = await detectClient(id, repositoryRoot).catch(() => null);
@@ -328,7 +331,8 @@ var OMITTABLE_SECTIONS = [
   "handoffs",
   "architecture",
   "symbols",
-  "neighbours"
+  "neighbours",
+  "reuse"
 ];
 var SESSION_TTL_MS = 30 * 60 * 1e3;
 async function applySessionDelivery(repositoryRoot, payload, options) {
@@ -373,10 +377,88 @@ async function applySessionDelivery(repositoryRoot, payload, options) {
   }
 }
 
+// src/context/reuse.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+var REUSE_ADMISSION = { minMatched: 2, minCoverage: 0.67, limit: 3 };
+var REUSABLE_KINDS = /* @__PURE__ */ new Set(["function", "class", "method", "const"]);
+async function findReuse(repositoryRoot, task, manifest, map, admission = REUSE_ADMISSION, semanticRanker = rankSemanticReuse) {
+  const terms = new Set(taskTerms(task));
+  if (terms.size < admission.minMatched) return [];
+  const symbols = Object.values(manifest.entries).filter((entry) => !TEST_PATH.test(entry.path) && !NON_SOURCE_PATH.test(entry.path)).flatMap(
+    (entry) => (entry.symbolTable ?? []).filter((symbol) => symbol.exported && REUSABLE_KINDS.has(symbol.kind)).map((symbol) => ({ ...symbol, path: entry.path, words: new Set(taskTerms(symbol.name)) }))
+  );
+  const frequency = /* @__PURE__ */ new Map();
+  for (const symbol of symbols) {
+    for (const word of symbol.words) frequency.set(word, (frequency.get(word) ?? 0) + 1);
+  }
+  const idf = (word) => Math.log((symbols.length + 1) / ((frequency.get(word) ?? 0) + 1));
+  const ranked = symbols.map((symbol) => {
+    const matched = [...symbol.words].filter((word) => terms.has(word));
+    return {
+      symbol,
+      matched,
+      coverage: symbol.words.size > 0 ? matched.length / symbol.words.size : 0,
+      score: matched.reduce((sum, word) => sum + idf(word), 0)
+    };
+  }).filter(
+    (item) => item.matched.length >= admission.minMatched && item.coverage >= admission.minCoverage
+  ).sort((a, b) => b.score - a.score || a.symbol.path.localeCompare(b.symbol.path));
+  let semantic = false;
+  if (!ranked.length) {
+    const candidates = await semanticRanker(repositoryRoot, task, manifest);
+    const first = candidates[0];
+    if (first && first.score >= 0.84 && first.score - (candidates[1]?.score ?? 0) >= 0.04) {
+      const symbol = symbols.find((item) => item.path === first.path && item.name === first.name);
+      if (symbol) {
+        ranked.push({ symbol, matched: [], coverage: 0, score: first.score });
+        semantic = true;
+      }
+    }
+  }
+  const indexed = new Set(Object.keys(manifest.entries));
+  const seen = /* @__PURE__ */ new Set();
+  const picked = [];
+  for (const { symbol, matched, score } of ranked) {
+    const key = `${symbol.path}:${symbol.name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const usage = await usageSite(repositoryRoot, symbol.path, symbol.name, map);
+    const test = findCoveringTest(symbol.path, indexed);
+    picked.push({
+      path: symbol.path,
+      name: symbol.name,
+      signature: symbol.signature,
+      startLine: symbol.startLine,
+      endLine: symbol.endLine,
+      matched,
+      score: Math.round(score * 100) / 100,
+      ...semantic ? { evidence: "semantic" } : {},
+      ...usage ? { usage } : {},
+      ...test ? { test } : {}
+    });
+    if (picked.length === admission.limit) break;
+  }
+  return picked;
+}
+async function usageSite(root, path, name, map) {
+  const short = name.split(".").at(-1) ?? name;
+  const pattern = new RegExp(`\\b${short.replace(/[^\w$]/g, "")}\\b`);
+  const importers = (map?.edges ?? []).filter((edge) => edge.to === path && !TEST_PATH.test(edge.from)).map((edge) => edge.from).sort();
+  for (const importer of importers.slice(0, 20)) {
+    const source = await readFile2(join2(root, importer), "utf8").catch(() => "");
+    const lines = source.split("\n");
+    const index = lines.findIndex((line) => pattern.test(line) && !/^\s*import\b/.test(line));
+    if (index !== -1)
+      return `${importer}:${index + 1}: ${(lines[index] ?? "").trim().slice(0, 140)}`;
+  }
+  return void 0;
+}
+
 // src/suggest/engine.ts
 import { constants } from "fs";
 import { access } from "fs/promises";
-import { extname, join as join2, resolve } from "path";
+import { extname, join as join3, resolve } from "path";
 
 // src/suggest/types.ts
 var SEVERITY_RANK = {
@@ -413,7 +495,7 @@ async function generateSuggestions(input) {
     resolveRelevantPlan(planStore, namespace, input.planId),
     memoryStore.findIncidentFactsForPaths({ namespace, paths: targetPaths }),
     buildArchitectureMap(repositoryRoot),
-    readPolicyFile(join2(repositoryRoot, ".codebuddy", "policies.yaml"))
+    readPolicyFile(join3(repositoryRoot, ".codebuddy", "policies.yaml"))
   ]);
   const suggestions = [];
   for (const item of risks.items) {
@@ -493,7 +575,7 @@ async function generateSuggestions(input) {
   for (const rule of policyFile.rules) {
     const prefix = literalPrefix(rule.pattern);
     if (!prefix) continue;
-    if (await pathExists(join2(repositoryRoot, prefix))) continue;
+    if (await pathExists(join3(repositoryRoot, prefix))) continue;
     suggestions.push({
       id: `stale_policy:${rule.id}`,
       category: "stale_policy",
@@ -537,7 +619,7 @@ function isTestableCode(path) {
 }
 async function hasSiblingTest(repositoryRoot, path) {
   for (const candidate of coveringTestCandidates(path)) {
-    if (await pathExists(join2(repositoryRoot, candidate))) return true;
+    if (await pathExists(join3(repositoryRoot, candidate))) return true;
   }
   return false;
 }
@@ -586,6 +668,40 @@ function normalize(path) {
   return path.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 
+// src/mcp/database-retry.ts
+function isTransientDatabaseError(error) {
+  let current = error;
+  for (let depth = 0; depth < 4 && current && typeof current === "object"; depth++) {
+    const item = current;
+    if (typeof item.code === "string" && (/* @__PURE__ */ new Set([
+      "ECONNRESET",
+      "ECONNREFUSED",
+      "EPIPE",
+      "CONNECTION_CLOSED",
+      "CONNECTION_ENDED",
+      "08000",
+      "08001",
+      "08003",
+      "08006",
+      "57P01",
+      "57P02",
+      "57P03"
+    ])).has(item.code))
+      return true;
+    current = item.cause;
+  }
+  return false;
+}
+async function withDatabaseRetry(operation, readOnly, delayMs = 250) {
+  try {
+    return await operation();
+  } catch (error) {
+    if (!readOnly || !isTransientDatabaseError(error)) throw error;
+    await new Promise((resolve5) => setTimeout(resolve5, delayMs));
+    return operation();
+  }
+}
+
 // src/mcp/tool-result.ts
 function serializeToolResult(value, format = process.env.CODEBUDDY_RESPONSE_FORMAT ?? "both") {
   if (format !== "text" && format !== "both") {
@@ -631,7 +747,7 @@ var recallSchema = {
   budget: z.number().int().positive().optional(),
   callerModel: z.string().min(1).max(200).optional(),
   conflictMode: z.enum(["all", "latest", "highest_confidence"]).optional(),
-  /** Return only system, message id + content and core stats (no provenance). */
+  /** Default true: a flat list of memories (id, content, date). false = full provenance + stats. */
   compact: z.boolean().optional()
 };
 var shareSchema = {
@@ -768,6 +884,30 @@ var FILE_TOOLS = Object.keys(mcpToolInputSchemas).filter(
   (name) => !DATABASE_TOOLS.includes(name)
 );
 var DEGRADED_FALLBACK = "PostgreSQL is unavailable, so this call did nothing. File-based tools still work; read the repository directly and say recall is unavailable instead of guessing. Run `codebuddy db doctor` to diagnose; the next call after retryInMs reconnects.";
+var LEAN_TOOLS = {
+  context_pack: {
+    description: "Find the files, symbols and line ranges for a coding task. Call only when the injected CodeBuddy block names no files.",
+    defaults: { tokenBudget: 800 },
+    inputSchema: {
+      task: z.string(),
+      paths: z.array(z.string()).optional(),
+      sessionId: z.string().optional(),
+      ack: z.string().optional()
+    }
+  },
+  recall: {
+    description: "Recall stored project memory (conventions, decisions, gotchas) for a question.",
+    inputSchema: { query: z.string() },
+    defaults: { sessionId: "agent" }
+  },
+  remember: {
+    description: "Store one durable project fact (convention, decision, gotcha).",
+    inputSchema: { content: z.string() },
+    // A fact is Markdown-backed and survives reindex; the full profile's
+    // default (`interaction`) is a database-only conversation record.
+    defaults: { type: "fact" }
+  }
+};
 var CORE_TOOLS = [
   "context_pack",
   "context_bootstrap",
@@ -777,9 +917,9 @@ var CORE_TOOLS = [
   "health"
 ];
 function resolveToolProfile(value = process.env.CODEBUDDY_TOOL_PROFILE) {
-  if (value === void 0 || value === "" || value === "full") return "full";
-  if (value === "core") return "core";
-  throw new Error(`CODEBUDDY_TOOL_PROFILE must be "core" or "full", got "${value}"`);
+  if (value === void 0 || value === "" || value === "lean") return "lean";
+  if (value === "core" || value === "full") return value;
+  throw new Error(`CODEBUDDY_TOOL_PROFILE must be "lean", "core" or "full", got "${value}"`);
 }
 var PLAN_BODY_LIMIT = 8e3;
 function serializePlan(plan) {
@@ -790,7 +930,7 @@ function serializePlan(plan) {
   return { plan: { ...plan, body } };
 }
 function registerCodeBuddyTools(server, options, profile = "full") {
-  const exposed = (name) => profile === "full" || CORE_TOOLS.includes(name);
+  const exposed = (name) => profile === "full" || (profile === "lean" ? name in LEAN_TOOLS : CORE_TOOLS.includes(name));
   const config = "database" in options ? options.config : options.memory.config;
   const traceRoot = config.projectRoot ?? process.cwd();
   const register = (name, toolConfig, callback) => {
@@ -815,7 +955,29 @@ function registerCodeBuddyTools(server, options, profile = "full") {
         throw error;
       }
     });
-    const tool = server.registerTool(name, toolConfig, traced);
+    const lean = profile === "lean" ? LEAN_TOOLS[name] : void 0;
+    const full = mcpToolInputSchemas[name];
+    const tool = lean ? server.registerTool(
+      name,
+      {
+        ...toolConfig,
+        description: lean.description,
+        inputSchema: lean.inputSchema
+      },
+      // The lean schema only lists fields; the full schema enforces limits.
+      (async (input, extra) => {
+        const parsed = full.safeParse({ ...lean.defaults, ...input });
+        if (!parsed.success) {
+          return {
+            content: [
+              { type: "text", text: `Invalid input: ${parsed.error.message}` }
+            ],
+            isError: true
+          };
+        }
+        return traced(parsed.data, extra);
+      })
+    ) : server.registerTool(name, toolConfig, traced);
     if (!exposed(name)) tool.remove();
     return tool;
   };
@@ -831,7 +993,25 @@ function registerCodeBuddyTools(server, options, profile = "full") {
         isError: true
       };
     }
-    return json(await run(db));
+    try {
+      return json(
+        await withDatabaseRetry(
+          () => run(db),
+          ["recall", "list_facts", "list_namespaces"].includes(tool)
+        )
+      );
+    } catch (error) {
+      if (!isTransientDatabaseError(error)) throw error;
+      return {
+        ...json({
+          degraded: true,
+          tool,
+          database: { ...database.status(), available: false, state: "unavailable" },
+          fallback: "The database connection failed during this operation. A write may have committed; verify state before repeating it. File-based context remains available."
+        }),
+        isError: true
+      };
+    }
   };
   const namespace = config.namespace;
   const projectRoot = config.projectRoot ?? process.cwd();
@@ -880,12 +1060,12 @@ function registerCodeBuddyTools(server, options, profile = "full") {
     "recall",
     {
       title: "Recall",
-      description: "Recall prompt-ready CodeBuddy context. `budget` bounds message content (stats.tokensUsed); stats.responseTokens counts the whole JSON text returned (provenance and stats included) and stats.transportTokens the full tool result, which also repeats it as structuredContent. Pass compact=true for only message id + content.",
+      description: "Recall project memory for a query. Returns a flat list of memories (id, content, date), or an empty list when nothing is relevant. Pass compact=false for full provenance and token stats.",
       inputSchema: mcpToolInputSchemas.recall.shape
     },
     async (input) => viaDatabase(
       "recall",
-      async (db) => withResponseTokens(await db.memory.recall(toRecallInput(input)), input.compact === true)
+      async (db) => input.compact === false ? withResponseTokens(await db.memory.recall(toRecallInput(input))) : compactRecall(await db.memory.recall(toRecallInput(input)))
     )
   );
   register(
@@ -1148,24 +1328,35 @@ function registerCodeBuddyTools(server, options, profile = "full") {
       description: "Build the smallest useful context pack for a coding task. Automatically finds relevant files from the local index when paths are omitted, then includes only bounded symbols, policies, risks, incidents, architecture neighbours, and relevant team facts within the requested token budget. Use this once at the start of a task instead of manually chaining context, risk, map, and memory tools. Request evidence=source with exact paths when short excerpts omit needed behavior; source excerpts remain bounded by the token budget. Optional sessionId enables session-aware delivery: pass the previous response's delivery.deliveryId as ack and unchanged sections are omitted (listed in delivery.unchanged); pass full=true to get everything again.",
       inputSchema: mcpToolInputSchemas.context_pack.shape
     },
-    async (input) => json(
-      await applySessionDelivery(
-        projectRoot,
-        await buildBeforeEditContext({
-          repositoryRoot: projectRoot,
-          namespace,
-          task: input.task,
-          semanticRanker: rankContextFacts,
-          ...await rerankerOption(),
-          ...input.evidence ? { evidence: input.evidence } : {},
-          ...input.paths !== void 0 ? { paths: input.paths } : {},
-          ...input.planId !== void 0 ? { planId: input.planId } : {},
-          ...input.useGit !== void 0 ? { useGit: input.useGit } : {},
-          tokenBudget: input.tokenBudget ?? tokenBudget ?? 4e3
-        }),
-        deliveryOptions(input)
-      )
-    )
+    async (input) => {
+      const context = await buildBeforeEditContext({
+        repositoryRoot: projectRoot,
+        namespace,
+        task: input.task,
+        semanticRanker: rankContextFacts,
+        ...await rerankerOption(),
+        ...input.evidence ? { evidence: input.evidence } : {},
+        ...input.paths !== void 0 ? { paths: input.paths } : {},
+        ...input.planId !== void 0 ? { planId: input.planId } : {},
+        ...input.useGit !== void 0 ? { useGit: input.useGit } : {},
+        tokenBudget: input.tokenBudget ?? tokenBudget ?? 4e3
+      });
+      const reuse = await loadFreshIndex(projectRoot).then(
+        async ({ manifest }) => findReuse(
+          projectRoot,
+          input.task,
+          manifest,
+          await loadProjectArchitectureMap(projectRoot, manifest)
+        )
+      ).catch(() => []);
+      return json(
+        await applySessionDelivery(
+          projectRoot,
+          enforceContextBudget({ ...context, ...reuse.length > 0 ? { reuse } : {} }),
+          deliveryOptions(input)
+        )
+      );
+    }
   );
   register(
     "context_after_turn",
@@ -1259,21 +1450,17 @@ function toRecallInput(input) {
   const { compact: _compact, ...rest } = input;
   return cleanOptional(rest);
 }
-function withResponseTokens(result, compact) {
-  const stats = compact ? {
-    tokensUsed: result.stats.tokensUsed,
-    itemsIncluded: result.stats.itemsIncluded,
-    itemsSkipped: result.stats.itemsSkipped,
-    ...result.stats.budgetStatus ? { budgetStatus: result.stats.budgetStatus } : {}
-  } : { ...result.stats };
-  const value = compact ? {
-    system: result.system,
-    messages: result.messages.map((message) => ({
-      ...message.fact ? { id: message.fact.id } : {},
-      content: message.content
-    })),
-    stats
-  } : { ...result, stats };
+function compactRecall(result) {
+  const memories = result.messages.map((message) => ({
+    ...message.fact ? { id: message.fact.id } : {},
+    content: message.content,
+    ...message.fact?.createdAt ? { date: message.fact.createdAt.slice(0, 10) } : {}
+  }));
+  return memories.length > 0 ? { memories } : { memories, note: "nothing relevant" };
+}
+function withResponseTokens(result) {
+  const stats = { ...result.stats };
+  const value = { ...result, stats };
   for (let pass = 0; pass < 2; pass++) {
     const serialized = serializeToolResult(value);
     stats.responseTokens = estimateTokens(serialized.content[0]?.text);
@@ -1292,7 +1479,7 @@ import pino from "pino";
 
 // src/automation/project-sync.ts
 import { watch as fsWatch2 } from "fs";
-import { join as join3, relative, resolve as resolve3, sep } from "path";
+import { join as join4, relative, resolve as resolve3, sep } from "path";
 
 // src/indexer/watch.ts
 import { watch as fsWatch } from "fs";
@@ -1473,7 +1660,7 @@ function startProjectSync(options) {
         300
       );
       memoryWatcher = fsWatch2(
-        join3(repositoryRoot, ".codebuddy", "memory"),
+        join4(repositoryRoot, ".codebuddy", "memory"),
         { recursive: true },
         (_event, filename) => {
           const name = filename?.replace(/\\/g, "/") ?? "";
@@ -1676,7 +1863,7 @@ async function startMcpServer(options = {}) {
   };
   let stopping;
   const stop = () => {
-    stopping ??= shutdown().finally(() => process.exit(0));
+    if (!stopping) stopping = shutdown().finally(() => process.exit(0));
   };
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
@@ -1784,9 +1971,10 @@ export {
   showTelemetryNoticeOnce,
   flushTelemetry,
   traceCliCommand,
+  findReuse,
   generateSuggestions,
   mcpToolInputSchemas,
   registerCodeBuddyTools,
   startMcpServer
 };
-//# sourceMappingURL=chunk-2WH2Q4TA.js.map
+//# sourceMappingURL=chunk-YJPCS2GP.js.map