@polycode-projects/seonix 0.6.0 → 0.7.0

package/src/chat.mjs

@@ -41,14 +41,19 @@ import { join } from "node:path";
 import { createWriteStream } from "node:fs";
 import { mkdir, readFile } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
-import { randomBytes } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import { dispatchTool } from "./server.mjs";
 import { loadConfig, DEFAULT_GRAPH_REL } from "./config.mjs";
 import { parseEntities } from "./codegraph.mjs";
 import { SESSIONS_DIR_REL, appendSessionToGraph } from "./sessions.mjs";
+import { uuidv7 } from "./uuid.mjs";
+import { createTelemetry } from "./telemetry.mjs";
 import * as defaultSource from "./source.mjs";
 
+// uuidv7 lives in ./uuid.mjs (shared with telemetry + the bench stamp); re-exported
+// here because callers/tests still import it from chat.mjs.
+export { uuidv7 };
+
 /** Where session logs live, relative to the target repo. `.seonix/` is the repo's
  *  one artifact directory (gitignored, machine-local) — flip this single constant
  *  if the operator prefers a different location. */
@@ -131,15 +136,74 @@ function countableKinds(graph) {
   return Object.keys(CLASS_LABELS).filter((c) => present.has(c)).map((c) => CLASS_LABELS[c][1]);
 }
 
+// ---- misspelled count-noun repair (self-contained; no ask-engine coupling) ----
+// The count path intercepts "how many X" BEFORE the ask engine, so a typo'd count noun
+// ("how many clases") would otherwise never reach the ask engine's own spell/fuzzy repair
+// and land on the honest "I can't count" message — whereas a structural-query typo, routed
+// to ask.mjs, IS corrected. We repair it HERE instead of falling through, because chat's
+// ask.mjs imports are LAZY-by-contract (file docblock) and answerCount is synchronous: a
+// small bounded edit-distance over the COUNT_NOUNS keys keeps the count path self-
+// contained and never crashes a turn on the engine's concurrent evolution.
+
+/** Bounded Damerau-Levenshtein (optimal string alignment: sub/ins/del + adjacent
+ *  transposition) with an early row-minimum exit — a self-contained copy of the ask
+ *  engine's own bounded distance (ask.mjs editDistance), deliberately kept local so the
+ *  count path carries no static dependency on the ask engine. Returns the distance, or
+ *  max+1 as soon as it provably exceeds `max`. */
+function editDistance(a, b, max) {
+  if (a === b) return 0;
+  if (Math.abs(a.length - b.length) > max) return max + 1;
+  let prev2 = null;
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i += 1) {
+    const cur = [i];
+    let rowMin = i;
+    for (let j = 1; j <= b.length; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      let v = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) v = Math.min(v, prev2[j - 2] + cost);
+      cur[j] = v;
+      if (v < rowMin) rowMin = v;
+    }
+    if (rowMin > max) return max + 1;
+    prev2 = prev;
+    prev = cur;
+  }
+  return prev[b.length];
+}
+
+const COUNT_NOUN_KEYS = Object.keys(COUNT_NOUNS);
+
+/** Repair a misspelled count noun to its individual `class` via a bounded edit-distance
+ *  match over the COUNT_NOUNS keys — 1 edit for short tokens, 2 for longer, the same
+ *  curated budget the ask engine's fuzzy tier uses. Accepts a hit ONLY when every
+ *  closest-within-bound key maps to the SAME class, so "classe" (1 edit from both "class"
+ *  AND "classes", both → Class) resolves cleanly while a genuine cross-class tie is refused
+ *  (→ the honest "I can't count" message). Exact matches never reach here — resolveObject's
+ *  own discipline: a real ambiguity is stated, never guessed. Returns the class or null. */
+function fuzzyCountClass(noun) {
+  const bound = noun.length <= 5 ? 1 : 2;
+  let best = bound + 1;
+  let classes = new Set();
+  for (const key of COUNT_NOUN_KEYS) {
+    const d = editDistance(noun, key, bound);
+    if (d > bound) continue;
+    if (d < best) { best = d; classes = new Set([COUNT_NOUNS[key]]); }
+    else if (d === best) classes.add(COUNT_NOUNS[key]);
+  }
+  return best <= bound && classes.size === 1 ? [...classes][0] : null;
+}
+
 /** Recognise a count/aggregate question and answer it from the graph header, or
  *  null if it isn't one (→ fall through to seonix_ask). "how many X [are there]",
- *  "count [the] X", "number of X". An unknown kind lists what it CAN count. */
+ *  "count [the] X", "number of X". A misspelled kind is repaired by a bounded fuzzy
+ *  match (fuzzyCountClass); a still-unknown kind lists what it CAN count. */
 export function answerCount(graph, query) {
   if (!graph) return null;
   const m = String(query).match(/\b(?:how many|number of|count(?:\s+the)?)\s+([a-z]+)\b/i);
   if (!m) return null;
   const noun = m[1].toLowerCase();
-  const cls = COUNT_NOUNS[noun];
+  const cls = COUNT_NOUNS[noun] || fuzzyCountClass(noun);
   if (!cls) {
     return `I can't count "${noun}". I count: ${countableKinds(graph).join(", ")}. ` +
       `Try "how many classes are there".`;
@@ -438,17 +502,6 @@ export function gitToplevel(cwd = process.cwd()) {
   return null;
 }
 
-/** UUID v7 (RFC 9562): 48-bit big-endian unix-ms timestamp, then version/variant
- *  bits over crypto-random tail — time-sortable, unlike crypto.randomUUID()'s v4. */
-export function uuidv7(now = Date.now()) {
-  const b = randomBytes(16);
-  b.writeUIntBE(now, 0, 6); // 48-bit unix-ms timestamp, big-endian
-  b[6] = (b[6] & 0x0f) | 0x70; // version 7
-  b[8] = (b[8] & 0x3f) | 0x80; // variant 10xx
-  const h = b.toString("hex");
-  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
-}
-
 /** Mirror bin/cli.mjs's configFor: an explicit repo pins the artifact path; no
  *  repo falls back to the cwd/env-derived default. */
 function configFor(repoPath) {
@@ -694,6 +747,11 @@ export async function runChat({
   const moduleCount = graph.individuals.filter((i) => (i.class || "") === "Module").length;
   const { version } = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
 
+  // Opt-in telemetry (default OFF → null → the loop's `tel?.record` is a no-op, and
+  // nothing is written). The conversational session log + sidecar above stay the
+  // authoritative chat record; this is the machine-readable query telemetry.
+  const tel = createTelemetry({ env, config, surface: "chat" });
+
   const sessionId = uuidv7();
   const logDir = join(repo, SESSION_LOG_DIR);
   const sessionsDir = join(repo, SESSIONS_DIR_REL);
@@ -766,6 +824,13 @@ export async function runChat({
       await writeLog(logLines.join("\n") + "\n");
       await writeSidecar(record);
       turnRecords.push(record);
+      // One telemetry line per dispatched turn (OFF by default → no-op). query.raw is
+      // the user's line; `tool` the slash-command if any; count the cited entity ids.
+      tel?.record({
+        tool: record.command,
+        query: { raw: line },
+        response: { count: (record.answeredIds || []).length, node_ids: record.answeredIds || [] },
+      });
       await upsertGraph(record.ts);
       turns += 1;
       rl.setPrompt(promptFor(focus));

package/src/codegraph.mjs

@@ -1,5 +1,6 @@
 import { lookupByProseTokens, proseLayerHits } from "./prose.mjs";
 import { cosine } from "./embed.mjs";
+import { expandGraphPayload } from "./graph-format.mjs";
 
 // Pure (no-network, no-fs) query logic over the typed `entities` payload that the
 // deterministic indexer writes to <repo>/.seonix/graph.json (shape produced by
@@ -25,6 +26,12 @@ import { cosine } from "./embed.mjs";
 // ---- payload parsing ---------------------------------------------------------
 
 export function parseEntities(payload) {
+  // Defensive A6 passthrough: source.mjs already expands the interned v2 wire form, but
+  // scripts that JSON.parse graph.json and call parseEntities directly (tune-search, the
+  // rank gate) land here first — expand is idempotent on an already in-memory payload
+  // (format absent → passthrough). The `typeof` guard keeps this working inside viz's browser
+  // bundle: askSource() strips the graph-format import, and that askData is already expanded.
+  if (typeof expandGraphPayload !== "undefined") payload = expandGraphPayload(payload);
   const individuals = Array.isArray(payload?.individuals) ? payload.individuals : [];
   const byId = new Map();
   for (const ind of individuals) {

package/src/config.mjs

@@ -8,6 +8,7 @@
 //                     artifact `cli index_repository` wrote there — no config needed.
 
 import { join } from "node:path";
+import { storeFileFor } from "./store.mjs";
 
 export const DEFAULT_GRAPH_REL = join(".seonix", "graph.json");
 
@@ -24,5 +25,10 @@ export function loadConfig(env = process.env, cwd = process.cwd()) {
   const graphFile = env.SEONIX_GRAPH_FILE && env.SEONIX_GRAPH_FILE.trim()
     ? env.SEONIX_GRAPH_FILE.trim()
     : join(cwd, DEFAULT_GRAPH_REL);
-  return { graphFile };
+  // C12 (opt-in): SEONIX_STORE=sqlite selects the resident node:sqlite store for the
+  // LOAD path (source.mjs). Explicit opt-in only — auto-when-present is rejected because
+  // it would silently flip benchmark runs. Unset → store is null and nothing sqlite loads.
+  const store = env.SEONIX_STORE && env.SEONIX_STORE.trim() === "sqlite" ? "sqlite" : null;
+  const storeFile = store ? storeFileFor(graphFile) : null;
+  return { graphFile, store, storeFile };
 }