@selesai/code 0.13.0 → 0.13.2

package/dist/extensions/pi-hermes-memory/tests/store/sqlite-native.test.ts

@@ -0,0 +1,164 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import path from "node:path";
+import {
+  BetterSqlite3LoadError,
+  formatBetterSqlite3AbiError,
+  isNativeModuleAbiMismatch,
+  loadBetterSqlite3,
+  resolveBetterSqlite3PackageRoot,
+} from "../../src/store/sqlite-native.js";
+
+const require = createRequire(import.meta.url);
+
+type RequireCache = Record<string, unknown>;
+
+function fakeRequire(
+  impl: (id: string) => unknown,
+  resolveImpl: (id: string) => string,
+): NodeRequire {
+  return Object.assign(impl, {
+    resolve: resolveImpl,
+    cache: {} as RequireCache,
+  }) as NodeRequire;
+}
+
+describe("sqlite-native loader", () => {
+  it("detects NODE_MODULE_VERSION ABI mismatch errors", () => {
+    assert.equal(
+      isNativeModuleAbiMismatch(
+        new Error(
+          "The module '/tmp/better_sqlite3.node' was compiled against a different Node.js version using NODE_MODULE_VERSION 115",
+        ),
+      ),
+      true,
+    );
+    assert.equal(isNativeModuleAbiMismatch(new Error("SQLITE_BUSY")), false);
+  });
+
+  it("detects ERR_DLOPEN_FAILED codes", () => {
+    const err = Object.assign(new Error("dlopen failed"), { code: "ERR_DLOPEN_FAILED" });
+    assert.equal(isNativeModuleAbiMismatch(err), true);
+  });
+
+  it("resolves the installed better-sqlite3 package root", () => {
+    const root = resolveBetterSqlite3PackageRoot(require);
+    assert.ok(root);
+    assert.equal(path.basename(root!), "better-sqlite3");
+  });
+
+  it("loads better-sqlite3 successfully in the current runtime", () => {
+    const Database = loadBetterSqlite3({ requireImpl: require, allowRebuild: false });
+    const db = new (Database as new (path: string) => {
+      exec: (sql: string) => void;
+      close: () => void;
+    })(":memory:");
+    db.exec("SELECT 1");
+    db.close();
+  });
+
+  it("rebuilds once on ABI mismatch then succeeds", () => {
+    let calls = 0;
+    const ctor = class FakeDb {
+      constructor(_path: string) {}
+    };
+    const req = fakeRequire(
+      (id: string) => {
+        assert.equal(id, "better-sqlite3");
+        calls += 1;
+        if (calls === 1) {
+          throw new Error(
+            "was compiled against a different Node.js version using NODE_MODULE_VERSION 115. Please try re-compiling",
+          );
+        }
+        return ctor;
+      },
+      (id: string) => {
+        assert.equal(id, "better-sqlite3");
+        return path.join("/tmp/fake-npm/node_modules/better-sqlite3/lib/index.js");
+      },
+    );
+
+    let rebuilt = false;
+    const Database = loadBetterSqlite3({
+      requireImpl: req,
+      rebuild: (packageRoot) => {
+        rebuilt = true;
+        assert.equal(packageRoot, "/tmp/fake-npm/node_modules/better-sqlite3");
+        return { ok: true, detail: "rebuilt" };
+      },
+    });
+
+    assert.equal(Database, ctor);
+    assert.equal(rebuilt, true);
+    assert.equal(calls, 2);
+  });
+
+  it("throws BetterSqlite3LoadError with recovery guidance when rebuild fails", () => {
+    const req = fakeRequire(
+      (_id: string) => {
+        throw new Error(
+          "The module 'x.node' was compiled against a different Node.js version using NODE_MODULE_VERSION 108",
+        );
+      },
+      () => path.join("/tmp/fake-npm/node_modules/better-sqlite3/lib/index.js"),
+    );
+
+    assert.throws(
+      () =>
+        loadBetterSqlite3({
+          requireImpl: req,
+          rebuild: () => ({ ok: false, detail: "npm missing" }),
+        }),
+      (error: unknown) => {
+        assert.ok(error instanceof BetterSqlite3LoadError);
+        const message = error.message;
+        assert.match(message, /pi-hermes-memory could not load the native better-sqlite3 module/);
+        assert.match(message, /npm rebuild better-sqlite3/);
+        assert.match(message, /Homebrew/);
+        assert.match(message, /npm missing/);
+        assert.equal(error.packageRoot, "/tmp/fake-npm/node_modules/better-sqlite3");
+        return true;
+      },
+    );
+  });
+
+  it("formats actionable ABI recovery text", () => {
+    const message = formatBetterSqlite3AbiError({
+      originalError: new Error("NODE_MODULE_VERSION 115"),
+      packageRoot: "/Users/me/.pi/agent/npm/node_modules/better-sqlite3",
+      rebuildAttempted: true,
+      rebuildDetail: "exit 1",
+    });
+    assert.match(message, /NODE_MODULE_VERSION/);
+    assert.match(message, /\/Users\/me\/\.pi\/agent\/npm\/node_modules\/better-sqlite3/);
+    assert.match(message, /npm rebuild better-sqlite3/);
+    assert.match(message, /Homebrew/);
+  });
+
+  it("does not rebuild for non-ABI load failures", () => {
+    let rebuilt = false;
+    const req = fakeRequire(
+      () => {
+        throw new Error("Cannot find module 'better-sqlite3'");
+      },
+      () => {
+        throw new Error("not found");
+      },
+    );
+
+    assert.throws(
+      () =>
+        loadBetterSqlite3({
+          requireImpl: req,
+          rebuild: () => {
+            rebuilt = true;
+            return { ok: true, detail: "should not run" };
+          },
+        }),
+      /Cannot find module 'better-sqlite3'/,
+    );
+    assert.equal(rebuilt, false);
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/store/standing-instructions.test.ts

@@ -0,0 +1,171 @@
+/**
+ * Standing instructions (#121) — the always-injected, user-authored block.
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { StandingInstructions } from "../../src/store/standing-instructions.js";
+import { STANDING_MAX_CHARS, STANDING_MAX_ENTRIES } from "../../src/constants.js";
+
+let root = "";
+let filePath = "";
+
+beforeEach(async () => {
+  root = await fs.mkdtemp(path.join(os.tmpdir(), "pi-standing-"));
+  filePath = path.join(root, "STANDING.md");
+});
+
+afterEach(async () => {
+  await fs.rm(root, { recursive: true, force: true });
+});
+
+async function loadedStore(contents?: string): Promise<StandingInstructions> {
+  if (contents !== undefined) await fs.writeFile(filePath, contents, "utf-8");
+  const store = new StandingInstructions(filePath);
+  await store.load();
+  return store;
+}
+
+describe("StandingInstructions parsing", () => {
+  it("treats a hand-edited Markdown file as one instruction per line", async () => {
+    const store = await loadedStore([
+      "# my rules",
+      "",
+      "- never run find / or other root-wide searches",
+      "* always use pnpm",
+      "   scope   searches   to known directories   ",
+      "",
+    ].join("\n"));
+
+    assert.deepStrictEqual(store.list(), [
+      "never run find / or other root-wide searches",
+      "always use pnpm",
+      "scope searches to known directories",
+    ]);
+  });
+
+  it("starts empty when the file does not exist yet", async () => {
+    const store = await loadedStore();
+    assert.deepStrictEqual(store.list(), []);
+    assert.strictEqual(store.formatForSystemPrompt(), "");
+  });
+});
+
+describe("StandingInstructions writes", () => {
+  it("persists a pinned instruction and reloads it", async () => {
+    const store = await loadedStore();
+    const result = await store.add("  never run find / ");
+
+    assert.strictEqual(result.success, true);
+    assert.deepStrictEqual(result.instructions, ["never run find /"]);
+    assert.strictEqual(await fs.readFile(filePath, "utf-8"), "never run find /\n");
+
+    const reloaded = await loadedStore();
+    assert.deepStrictEqual(reloaded.list(), ["never run find /"]);
+  });
+
+  it("rejects a duplicate regardless of casing", async () => {
+    const store = await loadedStore();
+    await store.add("always use pnpm");
+    const duplicate = await store.add("Always Use Pnpm");
+
+    assert.strictEqual(duplicate.success, false);
+    assert.match(duplicate.error!, /already pinned/i);
+    assert.strictEqual(store.list().length, 1);
+  });
+
+  it("refuses content the memory content scanner blocks", async () => {
+    const store = await loadedStore();
+    const result = await store.add("always export ANTHROPIC_API_KEY before running the build");
+
+    assert.strictEqual(result.success, false);
+    assert.match(result.error!, /Blocked:/);
+    assert.deepStrictEqual(store.list(), []);
+  });
+
+  it("refuses to exceed the entry cap", async () => {
+    const store = await loadedStore();
+    for (let i = 0; i < STANDING_MAX_ENTRIES; i++) {
+      assert.strictEqual((await store.add(`rule number ${i}`)).success, true);
+    }
+
+    const overflow = await store.add("one rule too many");
+    assert.strictEqual(overflow.success, false);
+    assert.match(overflow.error!, new RegExp(`capped at ${STANDING_MAX_ENTRIES} entries`));
+    assert.strictEqual(store.list().length, STANDING_MAX_ENTRIES);
+  });
+
+  it("refuses to exceed the character budget", async () => {
+    const store = await loadedStore();
+    const result = await store.add("x".repeat(STANDING_MAX_CHARS + 1));
+
+    assert.strictEqual(result.success, false);
+    assert.match(result.error!, new RegExp(`capped at ${STANDING_MAX_CHARS} characters`));
+    assert.deepStrictEqual(store.list(), []);
+  });
+
+  it("removes by position and rejects an out-of-range one", async () => {
+    const store = await loadedStore();
+    await store.add("first rule");
+    await store.add("second rule");
+
+    const removed = await store.remove(1);
+    assert.strictEqual(removed.success, true);
+    assert.deepStrictEqual(store.list(), ["second rule"]);
+
+    const bad = await store.remove(5);
+    assert.strictEqual(bad.success, false);
+    assert.match(bad.error!, /between 1 and 1/);
+  });
+
+  it("clears every instruction", async () => {
+    const store = await loadedStore();
+    await store.add("first rule");
+    await store.add("second rule");
+
+    const cleared = await store.clear();
+    assert.strictEqual(cleared.success, true);
+    assert.deepStrictEqual(store.list(), []);
+    assert.strictEqual(await fs.readFile(filePath, "utf-8"), "");
+  });
+});
+
+describe("StandingInstructions rendering", () => {
+  it("renders a numbered, fenced block that reads as user directive", async () => {
+    const store = await loadedStore("never run find /\nalways use pnpm\n");
+    const rendered = store.render();
+
+    assert.match(rendered.block, /^<standing-instructions>/);
+    assert.match(rendered.block, /<\/standing-instructions>$/);
+    assert.match(rendered.block, /1\. never run find \//);
+    assert.match(rendered.block, /2\. always use pnpm/);
+    assert.match(rendered.block, /direct\s+instructions from the user, not recalled context/);
+    assert.strictEqual(rendered.injectedCount, 2);
+    assert.strictEqual(rendered.omittedCount, 0);
+  });
+
+  it("truncates a hand-edited over-budget file loudly rather than silently", async () => {
+    // Written straight to disk: the /memory-pin cap cannot catch this path.
+    const long = Array.from({ length: 6 }, (_, i) => `${i} ${"y".repeat(450)}`);
+    const store = await loadedStore(`${long.join("\n")}\n`);
+    const rendered = store.render();
+
+    assert.ok(rendered.injectedCount > 0, "some rules still make it in");
+    assert.ok(rendered.omittedCount > 0, "the rest are dropped");
+    assert.strictEqual(rendered.injectedCount + rendered.omittedCount, 6);
+    assert.match(rendered.block, /could not be shown/);
+    assert.match(rendered.block, new RegExp(`${STANDING_MAX_CHARS}-character injection budget`));
+    assert.ok(
+      rendered.block.length < STANDING_MAX_CHARS + 1000,
+      "the block must stay near its budget, not blow past it",
+    );
+  });
+
+  it("renders nothing when no instructions are pinned", async () => {
+    const store = await loadedStore("# only a comment\n");
+    assert.deepStrictEqual(store.render(), { block: "", injectedCount: 0, omittedCount: 0 });
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/tools/memory-search-tool.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, describe, it } from 'node:test';
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { DatabaseManager } from '../../src/store/db.js';
+import { addMemory } from '../../src/store/sqlite-memory-store.js';
+import { normalizeMemoryLookupText } from '../../src/store/memory-lookup.js';
+import { registerMemorySearchTool } from '../../src/tools/memory-search-tool.js';
+
+let ROOT_DIR = '';
+
+afterEach(() => {
+  if (ROOT_DIR) fs.rmSync(ROOT_DIR, { recursive: true, force: true });
+  ROOT_DIR = '';
+});
+
+function makeDbManager(): DatabaseManager {
+  ROOT_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-memory-search-tool-test-'));
+  return new DatabaseManager(ROOT_DIR);
+}
+
+describe('registerMemorySearchTool', () => {
+  it('returns a broader natural-language match when strict term matching misses', async () => {
+    const dbManager = makeDbManager();
+    addMemory(dbManager, "user's name is Naruto", 'user');
+
+    let captured: any;
+    const mockPi = {
+      registerTool: (def: any) => {
+        captured = def;
+      },
+    } as any;
+
+    registerMemorySearchTool(mockPi, dbManager);
+
+    const result = await captured.execute('tc-1', { query: 'name identity Naruto', target: 'user' });
+
+    assert.strictEqual(result.details.success, true);
+    assert.strictEqual(result.details.count, 1);
+    assert.match(result.content[0].text, /Naruto/);
+
+    dbManager.close();
+  });
+
+  it('labels every result with its mutation target and unambiguous scope', async () => {
+    const dbManager = makeDbManager();
+    addMemory(dbManager, 'global deployment convention');
+    addMemory(dbManager, 'user deployment preference', 'user');
+    addMemory(dbManager, 'failure deployment lesson', 'failure');
+    addMemory(dbManager, 'project deployment convention', 'memory', 'project-a');
+    addMemory(dbManager, 'project failure deployment lesson', 'failure', 'project-a');
+
+    let captured: any;
+    registerMemorySearchTool({ registerTool: (def: any) => { captured = def; } } as any, dbManager);
+
+    const result = await captured.execute('tc-1', { query: 'deployment' });
+    const text = result.content[0].text;
+
+    assert.match(text, /scope=global \[target=memory\] global deployment convention/);
+    assert.match(text, /scope=global \[target=user\] user deployment preference/);
+    assert.match(text, /scope=global \[target=failure\] failure deployment lesson/);
+    assert.match(text, /scope=project:project-a \[target=project\] project deployment convention/);
+    assert.match(text, /scope=project:project-a \[target=failure\] project failure deployment lesson/);
+
+    dbManager.close();
+  });
+
+  it('keeps copied results reversible when a project name contains brackets', async () => {
+    const dbManager = makeDbManager();
+    addMemory(dbManager, 'literal project entry', 'memory', 'foo] bar');
+
+    let captured: any;
+    registerMemorySearchTool({ registerTool: (def: any) => { captured = def; } } as any, dbManager);
+
+    const result = await captured.execute('tc-1', { query: 'literal' });
+    const firstResultLine = result.content[0].text.split('\n').find((line: string) => line.startsWith('🧠'))!;
+
+    assert.match(firstResultLine, /scope=project:foo%5D%20bar \[target=project\]/);
+    assert.equal(normalizeMemoryLookupText(firstResultLine), 'literal project entry');
+
+    dbManager.close();
+  });
+});