chainlesschain 0.162.148 → 0.162.150

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__/code-intelligence.integration.test.js

@@ -0,0 +1,129 @@
+/**
+ * LSP integration test — exercises the FULL stack (spawn → handshake → didOpen →
+ * query) against a REAL `typescript-language-server` if one is resolvable on
+ * PATH. When no server is installed (e.g. CI without the toolchain) the whole
+ * suite SKIPS visibly rather than passing hollowly ("不假绿" — no cosmetic green).
+ *
+ * To run it locally: `npm i -g typescript-language-server typescript` (or put a
+ * project-local one on PATH), then `npx vitest run code-intelligence.integration`.
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import os from "os";
+import fs from "fs";
+import path from "path";
+import { resolveBin } from "../lsp-server-registry.js";
+import { CodeIntelligence } from "../code-intelligence.js";
+
+const serverAvailable = Boolean(resolveBin("typescript-language-server"));
+const suite = serverAvailable ? describe : describe.skip;
+
+if (!serverAvailable) {
+  // Make the skip reason obvious in test output.
+  // eslint-disable-next-line no-console
+  console.warn(
+    "[lsp.integration] SKIP — no `typescript-language-server` on PATH. " +
+      "Install it to run real LSP integration coverage.",
+  );
+}
+
+suite("CodeIntelligence against a real typescript-language-server", () => {
+  let tmp;
+  let ci;
+
+  beforeAll(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), "cc-lsp-it-"));
+    fs.mkdirSync(path.join(tmp, "src"));
+    fs.writeFileSync(
+      path.join(tmp, "package.json"),
+      JSON.stringify({ name: "lsp-it", version: "1.0.0", private: true }),
+      "utf8",
+    );
+    fs.writeFileSync(
+      path.join(tmp, "tsconfig.json"),
+      JSON.stringify({
+        compilerOptions: {
+          strict: true,
+          target: "ES2020",
+          module: "ESNext",
+          moduleResolution: "node",
+        },
+        include: ["src"],
+      }),
+      "utf8",
+    );
+    fs.writeFileSync(
+      path.join(tmp, "src", "math.ts"),
+      "export function add(a: number, b: number): number {\n  return a + b;\n}\n",
+      "utf8",
+    );
+    fs.writeFileSync(
+      path.join(tmp, "src", "main.ts"),
+      'import { add } from "./math";\n\nconst total = add(1, 2);\nconsole.log(total);\nconst bad: number = notDeclared;\n',
+      "utf8",
+    );
+    ci = new CodeIntelligence({ projectRoot: tmp, coldStart: true });
+  });
+
+  afterAll(async () => {
+    if (ci) await ci.dispose();
+    try {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    } catch {
+      /* best effort */
+    }
+  });
+
+  it("resolves a cross-file definition", async () => {
+    // `add` usage in main.ts (line 3, col 15) → declaration in math.ts
+    const res = await ci.definition(path.join(tmp, "src", "main.ts"), 3, 15);
+    expect(res.available).toBe(true);
+    expect(res.locations.length).toBeGreaterThan(0);
+    expect(res.locations.some((l) => l.file.endsWith("math.ts"))).toBe(true);
+  }, 30000);
+
+  it("finds all references to a symbol across files", async () => {
+    // `add` declaration in math.ts (line 1, col 17)
+    const res = await ci.references(path.join(tmp, "src", "math.ts"), 1, 17);
+    expect(res.available).toBe(true);
+    // declaration + import + call site
+    expect(res.locations.length).toBeGreaterThanOrEqual(2);
+    expect(res.locations.some((l) => l.file.endsWith("main.ts"))).toBe(true);
+  }, 30000);
+
+  it("reports diagnostics for an undefined name", async () => {
+    const res = await ci.diagnostics(path.join(tmp, "src", "main.ts"), {
+      timeoutMs: 8000,
+    });
+    expect(res.available).toBe(true);
+    expect(res.diagnostics.some((d) => /notDeclared/.test(d.message))).toBe(
+      true,
+    );
+    const err = res.diagnostics.find((d) => d.severity === "error");
+    expect(err).toBeTruthy();
+  }, 30000);
+
+  it("lists document symbols", async () => {
+    const res = await ci.documentSymbols(path.join(tmp, "src", "math.ts"));
+    expect(res.available).toBe(true);
+    expect(
+      res.symbols.some((s) => s.name === "add" && s.kind === "function"),
+    ).toBe(true);
+  }, 30000);
+
+  it("previews a rename without mutating files", async () => {
+    const before = fs.readFileSync(path.join(tmp, "src", "math.ts"), "utf8");
+    const res = await ci.renamePreview(
+      path.join(tmp, "src", "math.ts"),
+      1,
+      17,
+      "sum",
+    );
+    expect(res.available).toBe(true);
+    expect(res.edits.length).toBeGreaterThan(0);
+    // preview only — the file on disk is unchanged
+    expect(fs.readFileSync(path.join(tmp, "src", "math.ts"), "utf8")).toBe(
+      before,
+    );
+  }, 30000);
+});

package/src/lib/lsp/__tests__/code-intelligence.test.js

@@ -0,0 +1,228 @@
+/**
+ * CodeIntelligence tests — result normalization + graceful degradation. Injects
+ * a fake LSPManager so no server runs; asserts that raw LSP shapes (Location vs
+ * LocationLink, DocumentSymbol vs SymbolInformation, WorkspaceEdit variants) are
+ * flattened to 1-based `{file,line,col}` and that "no server" degrades cleanly.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { CodeIntelligence, _deps } from "../code-intelligence.js";
+
+/** Fake manager: canned request results, or an "unavailable" verdict. */
+function fakeManager({ requestResult, unavailable, diagnostics } = {}) {
+  const client = {
+    request: async () => requestResult,
+    running: true,
+  };
+  return {
+    projectRoot: "/proj",
+    async ensureFor() {
+      if (unavailable) return { unavailable: true, reason: unavailable };
+      return {
+        client,
+        uri: "file:///proj/a.ts",
+        languageId: "typescript",
+        root: "/proj",
+      };
+    },
+    async didChangeFile() {
+      return this.ensureFor();
+    },
+    async waitForDiagnostics() {
+      return diagnostics || [];
+    },
+    async disposeAll() {},
+  };
+}
+
+let origRead;
+beforeEach(() => {
+  origRead = _deps.readFileSync;
+  _deps.readFileSync = () => "const foo = 1;\nfoo();\n";
+});
+afterEach(() => {
+  _deps.readFileSync = origRead;
+});
+
+describe("definition/references normalization", () => {
+  it("normalizes a plain Location to 1-based with a snippet", async () => {
+    const mgr = fakeManager({
+      requestResult: [
+        {
+          uri: "file:///proj/a.ts",
+          range: {
+            start: { line: 0, character: 6 },
+            end: { line: 0, character: 9 },
+          },
+        },
+      ],
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.definition("a.ts", 2, 1);
+    expect(res.available).toBe(true);
+    expect(res.locations[0]).toMatchObject({
+      file: expect.stringContaining("a.ts"),
+      line: 1, // 0 → 1
+      col: 7, // 6 → 7
+      endLine: 1,
+      endCol: 10,
+    });
+    expect(res.locations[0].snippet).toBe("const foo = 1;");
+  });
+
+  it("normalizes a LocationLink (targetUri/targetRange)", async () => {
+    const mgr = fakeManager({
+      requestResult: [
+        {
+          targetUri: "file:///proj/b.ts",
+          targetSelectionRange: {
+            start: { line: 4, character: 2 },
+            end: { line: 4, character: 5 },
+          },
+        },
+      ],
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.definition("a.ts", 2, 1);
+    expect(res.locations[0]).toMatchObject({ line: 5, col: 3 });
+    expect(res.locations[0].file).toContain("b.ts");
+  });
+});
+
+describe("graceful degradation", () => {
+  it("returns available:false with a reason when no server is installed", async () => {
+    const mgr = fakeManager({
+      unavailable: "no language server installed for typescript",
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.definition("a.ts", 1, 1);
+    expect(res).toEqual({
+      available: false,
+      reason: "no language server installed for typescript",
+    });
+  });
+});
+
+describe("document symbols", () => {
+  it("flattens hierarchical DocumentSymbols with container names", async () => {
+    const mgr = fakeManager({
+      requestResult: [
+        {
+          name: "MyClass",
+          kind: 5, // class
+          selectionRange: {
+            start: { line: 0, character: 6 },
+            end: { line: 0, character: 13 },
+          },
+          children: [
+            {
+              name: "method1",
+              kind: 6,
+              selectionRange: {
+                start: { line: 1, character: 2 },
+                end: { line: 1, character: 9 },
+              },
+            },
+          ],
+        },
+      ],
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.documentSymbols("a.ts");
+    expect(res.symbols).toHaveLength(2);
+    expect(res.symbols[0]).toMatchObject({
+      name: "MyClass",
+      kind: "class",
+      line: 1,
+    });
+    expect(res.symbols[1]).toMatchObject({
+      name: "method1",
+      kind: "method",
+      container: "MyClass",
+      line: 2,
+    });
+  });
+});
+
+describe("diagnostics", () => {
+  it("normalizes severity and position", async () => {
+    const mgr = fakeManager({
+      diagnostics: [
+        {
+          severity: 1,
+          message: "Cannot find name 'x'.",
+          range: {
+            start: { line: 3, character: 4 },
+            end: { line: 3, character: 5 },
+          },
+          code: 2304,
+          source: "ts",
+        },
+      ],
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.diagnostics("a.ts");
+    expect(res.diagnostics[0]).toMatchObject({
+      severity: "error",
+      message: "Cannot find name 'x'.",
+      line: 4,
+      col: 5,
+      code: "2304",
+      source: "ts",
+    });
+  });
+});
+
+describe("rename preview", () => {
+  it("flattens WorkspaceEdit.changes without applying", async () => {
+    const mgr = fakeManager({
+      requestResult: {
+        changes: {
+          "file:///proj/a.ts": [
+            {
+              range: {
+                start: { line: 0, character: 6 },
+                end: { line: 0, character: 9 },
+              },
+              newText: "bar",
+            },
+          ],
+        },
+      },
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.renamePreview("a.ts", 1, 7, "bar");
+    expect(res.edits).toHaveLength(1);
+    expect(res.edits[0].file).toContain("a.ts");
+    expect(res.edits[0].edits[0]).toMatchObject({
+      line: 1,
+      col: 7,
+      newText: "bar",
+    });
+  });
+
+  it("flattens WorkspaceEdit.documentChanges", async () => {
+    const mgr = fakeManager({
+      requestResult: {
+        documentChanges: [
+          {
+            textDocument: { uri: "file:///proj/c.ts", version: 2 },
+            edits: [
+              {
+                range: {
+                  start: { line: 9, character: 0 },
+                  end: { line: 9, character: 3 },
+                },
+                newText: "baz",
+              },
+            ],
+          },
+        ],
+      },
+    });
+    const ci = new CodeIntelligence({ manager: mgr });
+    const res = await ci.renamePreview("a.ts", 1, 1, "baz");
+    expect(res.edits[0].file).toContain("c.ts");
+    expect(res.edits[0].edits[0]).toMatchObject({ line: 10, newText: "baz" });
+  });
+});