chainlesschain 0.162.149 → 0.162.151

package/src/lib/hardening-manager.js

@@ -67,6 +67,79 @@ export function ensureHardeningTables(db) {
   `);
 }
 
+/**
+ * Rehydrate _baselines/_audits from the persisted performance_baselines/
+ * hardening_audits tables. The `cc` CLI runs every command in a fresh process,
+ * so without this the Maps start empty and a baseline/audit collected in a
+ * prior invocation is invisible (`cc hardening baseline list`/`audit reports`
+ * show nothing; `baseline compare`/`audit report <id>` throw "not found"; and —
+ * most damagingly — `cc hardening deploy-check` reports "No baseline / No audit"
+ * and yields a silently-wrong go/no-go verdict even when the rows exist). Call
+ * after ensureHardeningTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _baselines.clear();
+  _audits.clear();
+
+  const baselineRows = db.prepare(`SELECT * FROM performance_baselines`).all();
+  for (const row of baselineRows) {
+    let metrics = {};
+    let environment = {};
+    try {
+      metrics = row.metrics ? JSON.parse(row.metrics) : {};
+    } catch {
+      metrics = {};
+    }
+    try {
+      environment = row.environment ? JSON.parse(row.environment) : {};
+    } catch {
+      environment = {};
+    }
+    _baselines.set(row.id, {
+      id: row.id,
+      name: row.name,
+      version: row.version,
+      status: row.status,
+      metrics,
+      environment,
+      sampleCount: row.sample_count ?? 0,
+      createdAt: row.created_at ?? null,
+      completedAt: row.completed_at ?? null,
+    });
+  }
+
+  const auditRows = db.prepare(`SELECT * FROM hardening_audits`).all();
+  for (const row of auditRows) {
+    let checks = [];
+    let recommendations = [];
+    try {
+      checks = row.checks ? JSON.parse(row.checks) : [];
+    } catch {
+      checks = [];
+    }
+    try {
+      recommendations = row.recommendations
+        ? JSON.parse(row.recommendations)
+        : [];
+    } catch {
+      recommendations = [];
+    }
+    _audits.set(row.id, {
+      id: row.id,
+      name: row.name,
+      checks,
+      passed: row.passed ?? 0,
+      failed: row.failed ?? 0,
+      score: row.score ?? 0,
+      recommendations,
+      createdAt: row.created_at ?? null,
+    });
+  }
+
+  return _baselines.size + _audits.size;
+}
+
 /* ── Baseline Collection ──────────────────────────────────── */
 
 export function collectBaseline(db, name, version) {

package/src/lib/hierarchical-memory.js

@@ -5,6 +5,8 @@
  * with Ebbinghaus forgetting curve and spacing effect reinforcement.
  */
 
+import { escapeLike } from "./sql-like.js";
+
 // ─── Configuration ───────────────────────────────────────────────
 export const MEMORY_CONFIG = {
   workingCapacity: 50,
@@ -292,8 +294,10 @@ export function recallMemory(db, query, options = {}) {
   // Search long-term memory (DB)
   ensureMemoryTables(db);
   const ltRows = db
-    .prepare(`SELECT * FROM memory_long_term WHERE content LIKE ? LIMIT ?`)
-    .all(`%${query}%`, limit);
+    .prepare(
+      `SELECT * FROM memory_long_term WHERE content LIKE ? ESCAPE '\\' LIMIT ?`,
+    )
+    .all(`%${escapeLike(query)}%`, limit);
   for (const row of ltRows) {
     const retention = calcRetention(row.last_accessed);
     if (retention >= MEMORY_CONFIG.recallThreshold) {
@@ -316,8 +320,10 @@ export function recallMemory(db, query, options = {}) {
 
   // Search core memory (DB) — core memories don't decay
   const coreRows = db
-    .prepare(`SELECT * FROM memory_core WHERE content LIKE ? LIMIT ?`)
-    .all(`%${query}%`, limit);
+    .prepare(
+      `SELECT * FROM memory_core WHERE content LIKE ? ESCAPE '\\' LIMIT ?`,
+    )
+    .all(`%${escapeLike(query)}%`, limit);
   for (const row of coreRows) {
     db.prepare(
       `UPDATE memory_core SET access_count = access_count + 1, last_accessed = ? WHERE id = ?`,
@@ -444,9 +450,9 @@ function _searchByType(db, query, type, options = {}) {
   ensureMemoryTables(db);
   const ltRows = db
     .prepare(
-      `SELECT * FROM memory_long_term WHERE type = ? AND content LIKE ? LIMIT ?`,
+      `SELECT * FROM memory_long_term WHERE type = ? AND content LIKE ? ESCAPE '\\' LIMIT ?`,
     )
-    .all(type, `%${query}%`, limit);
+    .all(type, `%${escapeLike(query)}%`, limit);
   for (const row of ltRows) {
     results.push({
       id: row.id,
@@ -462,9 +468,9 @@ function _searchByType(db, query, type, options = {}) {
 
   const coreRows = db
     .prepare(
-      `SELECT * FROM memory_core WHERE type = ? AND content LIKE ? LIMIT ?`,
+      `SELECT * FROM memory_core WHERE type = ? AND content LIKE ? ESCAPE '\\' LIMIT ?`,
     )
-    .all(type, `%${query}%`, limit);
+    .all(type, `%${escapeLike(query)}%`, limit);
   for (const row of coreRows) {
     results.push({
       id: row.id,

package/src/lib/knowledge-exporter.js

@@ -78,7 +78,10 @@ export function sanitizeFilename(name) {
  * Convert a note to markdown with YAML frontmatter.
  */
 export function noteToMarkdown(note) {
-  const tags = JSON.parse(note.tags || "[]");
+  // safeJsonParse (not bare JSON.parse): exportToMarkdown loops over every note,
+  // so one corrupt/hand-edited `tags` cell would otherwise throw and abort the
+  // ENTIRE export mid-way. Matches generateIndexHtml, which already guards.
+  const tags = safeJsonParse(note.tags, []);
   const lines = [
     "---",
     `title: "${note.title.replace(/"/g, '\\"')}"`,
@@ -136,7 +139,10 @@ export function exportToMarkdown(db, outputDir, options = {}) {
  * Generate a minimal HTML page for a note.
  */
 export function noteToHtml(note) {
-  const tags = JSON.parse(note.tags || "[]");
+  // safeJsonParse (not bare JSON.parse): exportToSite loops over every note, so
+  // one corrupt `tags` cell would otherwise throw and abort the whole site
+  // export — after index.html was already written, leaving dangling links.
+  const tags = safeJsonParse(note.tags, []);
   const tagsHtml = tags
     .map((t) => `<span class="tag">${escapeHtml(t)}</span>`)
     .join(" ");

package/src/lib/knowledge-graph.js

@@ -95,6 +95,85 @@ export function ensureKnowledgeGraphTables(db) {
   );
 }
 
+/**
+ * Hydrate the in-memory graph from the DB. The CLI is one-shot: _entities/
+ * _relations/_outEdges/_inEdges start empty every process. Writes dual-write
+ * (Map + INSERT), but every read is Map-only and nothing ever SELECTed the
+ * tables back — so persisted entities/relations were invisible on the next
+ * invocation (list/show/stats/export empty; add-relation threw "Source entity
+ * not found"; remove returned false and left the row). Call after
+ * ensureKnowledgeGraphTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureKnowledgeGraphTables(db);
+  _entities.clear();
+  _relations.clear();
+  _outEdges.clear();
+  _inEdges.clear();
+
+  const entityRows = db
+    .prepare(
+      `SELECT id, name, type, properties, tags, created_at, updated_at
+         FROM kg_entities ORDER BY created_at ASC`,
+    )
+    .all();
+  for (const r of entityRows) {
+    // A single corrupt properties/tags cell must not crash the whole load.
+    let properties = null;
+    let tags = null;
+    try {
+      properties = r.properties ? JSON.parse(r.properties) : null;
+    } catch {
+      properties = null;
+    }
+    try {
+      tags = r.tags ? JSON.parse(r.tags) : null;
+    } catch {
+      tags = null;
+    }
+    _entities.set(r.id, {
+      id: r.id,
+      name: r.name,
+      type: r.type,
+      properties,
+      tags,
+      createdAt: Number(r.created_at),
+      updatedAt: Number(r.updated_at),
+      _seq: ++_seq,
+    });
+  }
+
+  const relationRows = db
+    .prepare(
+      `SELECT id, source_id, target_id, relation_type, weight, properties, created_at
+         FROM kg_relationships ORDER BY created_at ASC`,
+    )
+    .all();
+  for (const r of relationRows) {
+    let properties = null;
+    try {
+      properties = r.properties ? JSON.parse(r.properties) : null;
+    } catch {
+      properties = null;
+    }
+    const relation = {
+      id: r.id,
+      sourceId: r.source_id,
+      targetId: r.target_id,
+      relationType: r.relation_type,
+      weight: Number(r.weight),
+      properties,
+      createdAt: Number(r.created_at),
+      _seq: ++_seq,
+    };
+    _relations.set(r.id, relation);
+    _indexRelation(relation);
+  }
+
+  return _entities.size + _relations.size;
+}
+
 /* ── Catalogs ──────────────────────────────────────────────── */
 
 export function listEntityTypes() {

package/src/lib/llm-providers.js

@@ -292,20 +292,29 @@ export class LLMProviderRegistry {
     if (!this.providers.has(name)) {
       throw new Error(`Provider "${name}" not found`);
     }
-    // Reset all
-    this.db.prepare("UPDATE llm_providers SET is_active = 0 WHERE 1=1").run();
-    // Set active
-    this.db
-      .prepare(
-        "INSERT OR REPLACE INTO llm_providers (name, display_name, base_url, api_key_env, models, is_active) VALUES (?, ?, ?, ?, ?, 1)",
-      )
-      .run(
-        name,
-        this.providers.get(name).displayName,
-        this.providers.get(name).baseUrl,
-        this.providers.get(name).apiKeyEnv,
-        JSON.stringify(this.providers.get(name).models),
-      );
+    // Clear every active flag then mark the new provider active atomically.
+    // Without a transaction, a failure on the second statement leaves NO
+    // provider active — which getActive() silently masks as the "ollama"
+    // fallback, so a failed switch would quietly lose the current provider.
+    const applyWrites = () => {
+      this.db.prepare("UPDATE llm_providers SET is_active = 0 WHERE 1=1").run();
+      this.db
+        .prepare(
+          "INSERT OR REPLACE INTO llm_providers (name, display_name, base_url, api_key_env, models, is_active) VALUES (?, ?, ?, ?, ?, 1)",
+        )
+        .run(
+          name,
+          this.providers.get(name).displayName,
+          this.providers.get(name).baseUrl,
+          this.providers.get(name).apiKeyEnv,
+          JSON.stringify(this.providers.get(name).models),
+        );
+    };
+    if (this.db && typeof this.db.transaction === "function") {
+      this.db.transaction(applyWrites)();
+    } else {
+      applyWrites();
+    }
     return this.providers.get(name);
   }
 

package/src/lib/logger.js

@@ -24,7 +24,10 @@ export function success(message, ...args) {
 }
 
 export function warn(message, ...args) {
-  console.log(chalk.yellow("⚠"), message, ...args);
+  // stderr, not stdout: a warning must never interleave with a command's
+  // machine-readable stdout (e.g. `--json` payloads), which `| jq` and other
+  // consumers parse. Like error(), warn is never gated by quiet mode.
+  console.error(chalk.yellow("⚠"), message, ...args);
 }
 
 export function error(message, ...args) {

package/src/lib/lsp/__tests__/benchmark.test.js

@@ -0,0 +1,88 @@
+/**
+ * benchmark stats tests — the pure percentile/summarize helpers that turn raw
+ * latency samples into a report. No spawning; the harness itself is exercised by
+ * the live `cc code-intel bench` run.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  percentile,
+  summarize,
+  sumSubtreeRss,
+  sumSubtreeRssFromWmicCsv,
+} from "../benchmark.js";
+
+describe("percentile", () => {
+  it("returns the value for a single sample", () => {
+    expect(percentile([5], 50)).toBe(5);
+    expect(percentile([5], 95)).toBe(5);
+  });
+  it("computes median and p95 with interpolation", () => {
+    const s = [10, 20, 30, 40, 50];
+    expect(percentile(s, 50)).toBe(30);
+    // p95 of 5 points: rank = 0.95*4 = 3.8 → 40 + (50-40)*0.8 = 48
+    expect(percentile(s, 95)).toBeCloseTo(48, 5);
+  });
+  it("is order-independent (sorts internally)", () => {
+    expect(percentile([50, 10, 30, 40, 20], 50)).toBe(30);
+  });
+  it("returns null for an empty sample", () => {
+    expect(percentile([], 50)).toBeNull();
+  });
+});
+
+describe("summarize", () => {
+  it("reports n/min/median/p95/max/mean rounded to 0.1ms", () => {
+    const s = summarize([12.34, 5.6, 8.9, 20.1, 3.33]);
+    expect(s.n).toBe(5);
+    expect(s.min).toBe(3.3);
+    expect(s.max).toBe(20.1);
+    expect(s.median).toBe(8.9);
+    expect(s.mean).toBe(10.1); // (12.34+5.6+8.9+20.1+3.33)/5 = 10.054 → 10.1
+  });
+  it("handles an empty sample", () => {
+    expect(summarize([])).toEqual({ n: 0 });
+  });
+});
+
+describe("sumSubtreeRss", () => {
+  // launcher(100) → node server(200) → worker(300); sibling(400) unrelated
+  const rows = [
+    { pid: 100, ppid: 1, val: 5 },
+    { pid: 200, ppid: 100, val: 120 },
+    { pid: 300, ppid: 200, val: 40 },
+    { pid: 400, ppid: 1, val: 999 },
+  ];
+  it("sums a pid and all its transitive descendants (not the launcher alone)", () => {
+    expect(sumSubtreeRss(rows, 100)).toBe(165); // 5 + 120 + 40
+  });
+  it("returns just the leaf when it has no children", () => {
+    expect(sumSubtreeRss(rows, 300)).toBe(40);
+  });
+  it("returns null when the root pid is absent", () => {
+    expect(sumSubtreeRss(rows, 555)).toBeNull();
+  });
+  it("does not loop on a cyclic parent relationship", () => {
+    const cyclic = [
+      { pid: 1, ppid: 2, val: 10 },
+      { pid: 2, ppid: 1, val: 20 },
+    ];
+    expect(sumSubtreeRss(cyclic, 1)).toBe(30);
+  });
+});
+
+describe("sumSubtreeRssFromWmicCsv", () => {
+  it("parses wmic CSV and sums the subtree in bytes", () => {
+    const csv = [
+      "Node,ParentProcessId,ProcessId,WorkingSetSize",
+      "HOST,1,100,5000",
+      "HOST,100,200,120000",
+      "HOST,200,300,40000",
+      "HOST,1,400,999000",
+    ].join("\r\n");
+    expect(sumSubtreeRssFromWmicCsv(csv, 100)).toBe(165000);
+  });
+  it("returns null on malformed input", () => {
+    expect(sumSubtreeRssFromWmicCsv("garbage\r\n", 100)).toBeNull();
+  });
+});

package/src/lib/lsp/__tests__/lsp-client.test.js

@@ -90,6 +90,17 @@ describe("LSPClient handshake", () => {
       expect.objectContaining({ shell: false }),
     );
   });
+
+  it("kills the spawned server when the initialize handshake times out (no orphan)", async () => {
+    const child = new FakeChild({ autoInit: false }); // never answers initialize
+    const client = makeClient(child);
+    await expect(client.start({ initTimeoutMs: 20 })).rejects.toThrow(
+      /timed out/,
+    );
+    // The spawned process must be torn down, not left running forever.
+    expect(child.killed).toBe(true);
+    expect(client.running).toBe(false);
+  });
 });
 
 describe("LSPClient request/response", () => {

package/src/lib/lsp/__tests__/lsp-manager.test.js

@@ -141,6 +141,38 @@ describe("ensureFor", () => {
     await mgr.disposeAll();
   });
 
+  it("spawns only ONE server when two concurrent calls race the same key", async () => {
+    // Regression: ensureFor did Map.get(miss)→await start→Map.set with no
+    // in-flight dedupe, so two concurrent calls (the read-only agent batch fires
+    // several code_intelligence calls at once) both spawned a server; the second
+    // set() orphaned the first process. Gate start() so both calls interleave
+    // inside the await window, then assert a single spawn.
+    let created = 0;
+    let releaseStart;
+    const gate = new Promise((r) => {
+      releaseStart = r;
+    });
+    _deps.createClient = (opts) => {
+      created += 1;
+      lastClient = new FakeClient(opts);
+      const origStart = lastClient.start.bind(lastClient);
+      lastClient.start = async () => {
+        await gate; // hold both starts open until released
+        return origStart();
+      };
+      return lastClient;
+    };
+    const mgr = new LSPManager();
+    const p1 = mgr.ensureFor("/proj/src/a.ts");
+    const p2 = mgr.ensureFor("/proj/src/b.ts");
+    releaseStart();
+    const [r1, r2] = await Promise.all([p1, p2]);
+    expect(created).toBe(1); // NOT two — the race is deduped
+    expect(mgr.activeServerCount).toBe(1);
+    expect(r1.client).toBe(r2.client);
+    await mgr.disposeAll();
+  });
+
   it("returns unavailable for an unsupported extension", async () => {
     const mgr = new LSPManager();
     const ready = await mgr.ensureFor("/proj/readme.txt");
@@ -251,6 +283,43 @@ describe("diagnostics", () => {
     expect(diags[0].message).toBe("boom");
     await mgr.disposeAll();
   });
+
+  it("clears stale diagnostics + readiness state when the server crashes", async () => {
+    const { pathToFileUri } = await import("../lsp-client.js");
+    const mgr = new LSPManager();
+    await mgr.ensureFor("/proj/src/a.ts");
+    lastClient.emit("notify:textDocument/publishDiagnostics", {
+      uri: pathToFileUri(path.resolve("/proj/src/a.ts")),
+      diagnostics: [
+        {
+          message: "boom",
+          severity: 1,
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: 1 },
+          },
+        },
+      ],
+    });
+    expect(mgr.getDiagnostics("/proj/src/a.ts")).toHaveLength(1);
+
+    // Server crashes. Its diagnostics + publish bookkeeping must NOT survive —
+    // otherwise the readiness waiters resolve on the pre-crash publish and a
+    // post-restart query returns these stale results.
+    lastClient.running = false;
+    lastClient.emit("exit", 1, null);
+    expect(mgr.getDiagnostics("/proj/src/a.ts")).toEqual([]);
+
+    // A fresh query re-spawns the server; before it publishes, waitForDiagnostics
+    // must not hand back the stale set (returns empty within the timeout budget).
+    await mgr.ensureFor("/proj/src/a.ts");
+    const afterRestart = await mgr.waitForDiagnostics("/proj/src/a.ts", {
+      timeoutMs: 60,
+      settleMs: 20,
+    });
+    expect(afterRestart).toEqual([]);
+    await mgr.disposeAll();
+  });
 });
 
 describe("disposeAll", () => {