@polycode-projects/the-mechanical-code-talker 3.0.10 → 3.1.2

package/src/tools/handlers/kit.mjs

@@ -26,8 +26,10 @@ export function resolveOrThrow(svc, symbol, what) {
   return { match, candidates };
 }
 
-/** The shape most cold tools share: one required `symbol`, resolved, then rendered. */
-export const symbolHandler = (render) => (args, { graph, svc }) => {
+/** The shape most cold tools share: one required `symbol`, resolved, then rendered.
+ *  `config.toolNamePrefix` (default "tmct_", set by e.g. seonix's own tool naming)
+ *  threads through so a render's own follow-up hints stay accurate outside tmct. */
+export const symbolHandler = (render) => (args, { graph, svc, config }) => {
   const { match } = resolveOrThrow(svc, requiredArg(args, "symbol"), "symbol");
-  return render(graph, match);
+  return render(graph, match, { toolNamePrefix: config?.toolNamePrefix });
 };

package/src/tools/handlers/tmct-context.mjs

@@ -36,6 +36,7 @@ export async function buildContextBundle(args, { config, source = defaultSource,
   // bodies) with top-up, and it OVERRIDES trim so even secondary modules get the full bundle. Used
   // by the tmct-max arm to test whether more injection re-bloats.
   const max = Boolean(args?.max);
+  const toolNamePrefix = config?.toolNamePrefix || "tmct_";
   const graph = await loadGraph(config, source);
   // repo root = the dir containing .tmct/ (graphFile = <repo>/.tmct/graph.json) — computed
   // before createGraphService so the RI service can be constructed source-capable: this
@@ -123,7 +124,7 @@ export async function buildContextBundle(args, { config, source = defaultSource,
       out.push(`  ${s.class} ${s.label}${s.site ? ` :${s.site.start}` : ""}  ${dec}${sig}${r}`);
     }
     if (plan.siblings.length > plan.siblingCap) {
-      out.push(`  …+${plan.siblings.length - plan.siblingCap} more (use tmct_search kind=function or tmct_snippet <name> for any of them)`);
+      out.push(`  …+${plan.siblings.length - plan.siblingCap} more (use ${toolNamePrefix}search kind=function or ${toolNamePrefix}snippet <name> for any of them)`);
     }
   }
   if (mask.allExports && plan.allExports) {
@@ -148,7 +149,7 @@ export async function buildContextBundle(args, { config, source = defaultSource,
   out.push(`\nYou now have the snippet, the sibling style, the registration anchor and the tests. ` +
     `Write the new code with Edit/Write — do NOT Read ${plan.moduleLabel}.`);
   if (tier !== "FULL") {
-    out.push(`(bundle tier ${tier}; for any omitted sections run tmct_context_more {"symbol":"${symbol}"}, or tmct_context with depth="full".)`);
+    out.push(`(bundle tier ${tier}; for any omitted sections run ${toolNamePrefix}context_more {"symbol":"${symbol}"}, or ${toolNamePrefix}context with depth="full".)`);
   }
   return { text: out.join("\n"), tier, topup };
 }

package/src/tools/handlers/tmct-export.mjs

@@ -10,13 +10,19 @@ import { serializeFactsJsonl } from "../../adapters/memory/export-jsonl.mjs";
 import { dirname } from "node:path";
 import { loadMemory, openConfiguredMemoryBackend } from "../../adapters/memory/core.mjs";
 
-export async function tmct_export(_args, { config }) {
-  const { dir, close } = await openConfiguredMemoryBackend(dirname(dirname(config.graphFile)));
+export async function tmct_export(_args, { config, memoryBackend = null }) {
+  // Prefer a caller-supplied backend handle (e.g. an already-open session's
+  // memory store) over re-deriving one from config/tmct.toml — re-deriving
+  // can silently land on a different backend than the one the caller is
+  // actually using. A caller-supplied handle is caller-owned, so it is never
+  // closed here; only a backend this call opened itself gets closed.
+  const opened = memoryBackend ? null : await openConfiguredMemoryBackend(dirname(dirname(config.graphFile)));
+  const dir = memoryBackend || opened.dir;
   try {
     const jsonl = serializeFactsJsonl(await loadMemory(dir));
     return jsonl || "(the memory store holds no facts to export)";
   } finally {
-    await close();
+    if (opened) await opened.close();
   }
 }
 

package/src/tools/handlers/tmct-members.mjs

@@ -9,7 +9,7 @@ import { requiredArg, resolveOrThrow } from "./kit.mjs";
 export async function tmct_members(args, { graph, svc, config }) {
   const symbol = requiredArg(args, "class");
   const { match } = resolveSymbol(svc.graph, symbol);
-  if (match) return renderMembers(graph, match); // code-map wins when present
+  if (match) return renderMembers(graph, match, { toolNamePrefix: config?.toolNamePrefix }); // code-map wins when present
   const fallback = renderMemorySubclasses(await memoryFactRows(config), symbol);
   if (fallback) return fallback;
   resolveOrThrow(svc, symbol, "class"); // the honest miss

package/src/tools/handlers/tmct-search.mjs

@@ -13,6 +13,7 @@ export async function tmct_search(args, { graph, config }) {
     kind,
     decorator: String(args?.decorator || "").trim(),
     name: String(args?.name || "").trim(),
+    toolNamePrefix: config?.toolNamePrefix,
   });
   if (!kind && /^no module matches/.test(out)) {
     const fallback = renderMemoryDefinition(await memoryFactRows(config), query);

package/src/tools/server.mjs

@@ -44,7 +44,7 @@ export const TOOLS = HOT_TOOLS.map(({ name, agentDescription, inputSchema }) =>
   inputSchema,
 }));
 
-export async function dispatchTool(name, args, { config, source = defaultSource, tel = null, ingest = null } = {}) {
+export async function dispatchTool(name, args, { config, source = defaultSource, tel = null, ingest = null, memoryBackend = null } = {}) {
   // Reject an unknown tool BEFORE touching the graph — an unknown name never
   // triggers a load. hasOwn, so an inherited name ("constructor", "toString")
   // is unknown rather than a callable found on the prototype chain.
@@ -52,13 +52,18 @@ export async function dispatchTool(name, args, { config, source = defaultSource,
   const handle = HANDLERS[name];
   // `ingest` is the recognizer seam a caller in the service layer injects (the
   // tool layer sits UNDER services and must not import one, so a tool that needs
-  // the chat recognizer receives it here rather than importing it).
-  if (handle.ownsGraphLoad) return handle(args, { config, source, tel, ingest });
+  // the chat recognizer receives it here rather than importing it). `memoryBackend`
+  // is the same kind of seam for a caller that already holds an open memory-store
+  // handle (e.g. a session's own `memoryDir`) — a handler that reads the
+  // conversational memory store (tmct_export) prefers it over re-deriving a
+  // backend from config when one is supplied; every other caller leaves it null
+  // and gets today's re-derive-from-config behaviour unchanged.
+  if (handle.ownsGraphLoad) return handle(args, { config, source, tel, ingest, memoryBackend });
   const graph = await loadGraph(config, source);
   // repo root = the dir containing .tmct/ (graphFile = <repo>/.tmct/graph.json). Passed to
   // createGraphService so svc.snippet()/svc.context() are usable directly, and on to the
   // handlers that do their own safe source reads.
   const repoRoot = dirname(dirname(config.graphFile));
   const svc = createGraphService(graph, { sourceAccess: true, repoRoot, readFile, tel, ask });
-  return handle(args, { graph, svc, config, repoRoot });
+  return handle(args, { graph, svc, config, repoRoot, memoryBackend });
 }