@selesai/code 0.13.0 → 0.13.1

package/dist/extensions/pi-hermes-memory/tests/store/recovery-maintenance.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Regression tests for the dormant-store snapshot retention sweep (#202).
+ *
+ * Seeds .recovery-* / .retired-* sidecar files directly on disk and proves
+ * caps converge without any MemoryStore write.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import { describe, it, beforeEach, afterEach } from "node:test";
+
+import {
+  listMemoryStoreDirs,
+  runRecoveryMaintenance,
+} from "../../src/store/recovery-maintenance.js";
+import { DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_USER_CHAR_LIMIT } from "../../src/constants.js";
+import type { MemoryConfig } from "../../src/types.js";
+
+const TEST_MARKER = "[RECOVERY-MAINTENANCE-TEST]";
+let tmpDir = "";
+let globalDir = "";
+let projectsRoot = "";
+
+function makeConfig(overrides?: Partial<MemoryConfig>): MemoryConfig {
+  return {
+    memoryMode: "legacy-inject",
+    memoryCharLimit: DEFAULT_MEMORY_CHAR_LIMIT,
+    userCharLimit: DEFAULT_USER_CHAR_LIMIT,
+    projectCharLimit: 5000,
+    nudgeInterval: 10,
+    reviewEnabled: false,
+    flushOnCompact: false,
+    flushOnShutdown: false,
+    flushMinTurns: 6,
+    autoConsolidate: false,
+    correctionDetection: false,
+    failureInjectionEnabled: true,
+    failureInjectionMaxAgeDays: 7,
+    failureInjectionMaxEntries: 5,
+    nudgeToolCalls: 15,
+    consolidationTimeoutMs: 30000,
+    memoryDir: globalDir,
+    projectsMemoryDir: projectsRoot,
+    ...overrides,
+  };
+}
+
+function recoveryPathFor(memoryDir: string, basename = "MEMORY.md"): string {
+  return path.join(memoryDir, `.${basename}.recovery-${Date.now()}-${randomUUID()}`);
+}
+
+function retiredPathFor(memoryDir: string, basename = "MEMORY.md"): string {
+  return path.join(memoryDir, `.${basename}.retired-${Date.now()}-${randomUUID()}`);
+}
+
+async function writeRaw(filePath: string, content: string): Promise<void> {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content, "utf-8");
+}
+
+async function countFiles(dir: string, prefix: string): Promise<number> {
+  const names = await fs.readdir(dir);
+  return names.filter((name) => name.startsWith(prefix)).length;
+}
+
+describe("recovery maintenance sweep", () => {
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "recovery-maintenance-test-"));
+    globalDir = path.join(tmpDir, "global");
+    projectsRoot = path.join(tmpDir, "projects-memory");
+    await fs.mkdir(globalDir, { recursive: true });
+    await fs.mkdir(projectsRoot, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("bounds dormant recovery snapshots by count without a write", async () => {
+    const projectDir = path.join(projectsRoot, "project-a");
+    for (let index = 0; index < 40; index++) {
+      await writeRaw(recoveryPathFor(projectDir), `${TEST_MARKER} recovery ${index}`);
+    }
+
+    const result = await runRecoveryMaintenance({ config: makeConfig(), globalDir });
+    assert.equal(result.storesMaintained, 2);
+    assert.deepEqual(result.failedStores, []);
+
+    const recoveryCount = await countFiles(projectDir, ".MEMORY.md.recovery-");
+    assert.ok(recoveryCount <= 32, `expected <= 32 recovery files, found ${recoveryCount}`);
+    assert.ok(recoveryCount > 0, "newest active recovery must be retained");
+
+    const retiredCount = await countFiles(projectDir, ".MEMORY.md.retired-");
+    assert.ok(retiredCount <= 32, `expected <= 32 retired files, found ${retiredCount}`);
+
+    const sizes = await Promise.all(
+      (await fs.readdir(projectDir))
+        .filter((name) => name.startsWith(".MEMORY.md.recovery-"))
+        .map((name) => fs.stat(path.join(projectDir, name))),
+    );
+    const totalBytes = sizes.reduce((total, stat) => total + stat.size, 0);
+    assert.ok(totalBytes <= 64 * 1024 * 1024);
+  });
+
+  it("removes retired snapshots past the age cap in a dormant store", async () => {
+    const staleRetiredPath = retiredPathFor(globalDir);
+    await writeRaw(staleRetiredPath, `${TEST_MARKER} stale retired`);
+    const stale = new Date(Date.now() - 31 * 24 * 60 * 60 * 1000);
+    await fs.utimes(staleRetiredPath, stale, stale);
+
+    const freshPath = retiredPathFor(globalDir);
+    await writeRaw(freshPath, `${TEST_MARKER} fresh retired`);
+
+    await runRecoveryMaintenance({ config: makeConfig(), globalDir });
+
+    await assert.rejects(
+      fs.stat(staleRetiredPath),
+      (error: NodeJS.ErrnoException) => error.code === "ENOENT",
+    );
+    assert.equal(await fs.readFile(freshPath, "utf-8"), `${TEST_MARKER} fresh retired`);
+  });
+
+  it("sweeps every enumerated store directory", async () => {
+    const dirs = [
+      path.join(projectsRoot, "project-one"),
+      path.join(projectsRoot, "project-two"),
+    ];
+    for (const dir of dirs) {
+      for (let index = 0; index < 35; index++) {
+        await writeRaw(recoveryPathFor(dir, "USER.md"), `${TEST_MARKER} user recovery`);
+      }
+    }
+
+    const discovered = await listMemoryStoreDirs({ config: makeConfig(), globalDir });
+    assert.deepEqual(discovered.sort(), [globalDir, ...dirs].sort());
+
+    await runRecoveryMaintenance({ config: makeConfig(), globalDir });
+    for (const dir of dirs) {
+      const userRecoveryCount = await countFiles(dir, ".USER.md.recovery-");
+      assert.ok(userRecoveryCount <= 32, `expected <= 32 in ${dir}, found ${userRecoveryCount}`);
+    }
+  });
+
+  it("never follows symlinked project directories", async () => {
+    if (process.platform === "win32") return;
+    const outsideDir = path.join(tmpDir, "outside");
+    await fs.mkdir(outsideDir, { recursive: true });
+    await writeRaw(recoveryPathFor(outsideDir), `${TEST_MARKER} outside decoy`);
+
+    await fs.symlink(outsideDir, path.join(projectsRoot, "linked-project"));
+
+    const discovered = await listMemoryStoreDirs({ config: makeConfig(), globalDir });
+    assert.deepEqual(discovered, [globalDir]);
+  });
+
+  it("is idempotent across repeated sweeps", async () => {
+    const resultA = await runRecoveryMaintenance({ config: makeConfig(), globalDir });
+    assert.deepEqual(resultA.failedStores, []);
+    const siblingsAfterFirst = (await fs.readdir(globalDir)).length;
+
+    const resultB = await runRecoveryMaintenance({ config: makeConfig(), globalDir });
+    assert.deepEqual(resultB.failedStores, []);
+    const siblingsAfterSecond = (await fs.readdir(globalDir)).length;
+
+    assert.equal(siblingsAfterSecond, siblingsAfterFirst);
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/store/session-anchor-search.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, afterEach } 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 { searchSessionAnchors } from "../../src/store/session-anchor-search.js";
+
+let ROOT_DIR = "";
+
+function makeSessionsDir(): string {
+  ROOT_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "pi-session-anchor-search-test-"));
+  return ROOT_DIR;
+}
+
+function writeJsonl(relativePath: string, events: unknown[]): string {
+  const filePath = path.join(ROOT_DIR, relativePath);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, events.map((event) => JSON.stringify(event)).join("\n") + "\n");
+  return filePath;
+}
+
+function message(timestamp: string, text: string, extra: Record<string, unknown> = {}): unknown {
+  return {
+    type: "message",
+    timestamp,
+    sessionId: "session-1",
+    cwd: "/work/project",
+    message: { role: "user", content: text },
+    ...extra,
+  };
+}
+
+afterEach(() => {
+  if (ROOT_DIR) fs.rmSync(ROOT_DIR, { recursive: true, force: true });
+  ROOT_DIR = "";
+});
+
+describe("searchSessionAnchors", () => {
+  it("accepts a minimal time window and caps limit", () => {
+    const sessionsDir = makeSessionsDir();
+    const events = Array.from({ length: 210 }, (_, index) => (
+      index % 2 === 0
+        ? message(`2026-05-15T12:${String(index % 60).padStart(2, "0")}:00.000Z`, `event ${index}`)
+        : message(`2026-05-14T12:${String(index % 60).padStart(2, "0")}:00.000Z`, `outside ${index}`)
+    ));
+    writeJsonl("session.jsonl", events);
+
+    const result = searchSessionAnchors("from: 2026-05-15\nto: 2026-05-15\nlimit: 200", { sessionsDir });
+
+    assert.strictEqual(result.success, true);
+    assert.strictEqual(result.ranges.length, 100);
+    assert.strictEqual(result.ranges[0].startLine, 1);
+    assert.strictEqual(result.ranges[0].reason, "time window");
+  });
+
+  it("returns diagnostics for duplicate, unknown, empty, and unconstrained requests", () => {
+    const sessionsDir = makeSessionsDir();
+
+    assert.match(searchSessionAnchors("", { sessionsDir }).message ?? "", /markdown is required/);
+    assert.match(searchSessionAnchors("since: 2026-05-15", { sessionsDir }).message ?? "", /Invalid field 'since'/);
+    assert.match(searchSessionAnchors("from: 2026-05-15\nfrom: 2026-05-16", { sessionsDir }).message ?? "", /Duplicate field 'from'/);
+    assert.match(searchSessionAnchors("limit: 0", { sessionsDir }).message ?? "", /Invalid limit/);
+    assert.match(searchSessionAnchors("all:\n- ", { sessionsDir }).message ?? "", /Invalid markdown line|Empty term/);
+    assert.match(searchSessionAnchors("limit: 10", { sessionsDir }).message ?? "", /needs at least one constraint/);
+  });
+
+  it("measures broadness with scan caps instead of rejecting request shape", () => {
+    const sessionsDir = makeSessionsDir();
+    writeJsonl("one.jsonl", [
+      message("2026-05-15T10:00:00.000Z", "a"),
+      message("2026-05-15T11:00:00.000Z", "b"),
+    ]);
+    writeJsonl("two.jsonl", [message("2026-05-15T12:00:00.000Z", "a")]);
+
+    const shortTerm = searchSessionAnchors("any:\n- a", { sessionsDir });
+    assert.strictEqual(shortTerm.success, true);
+    assert.strictEqual(shortTerm.ranges.length, 2);
+
+    const fileCap = searchSessionAnchors("any:\n- a", { sessionsDir, maxFiles: 1 });
+    assert.strictEqual(fileCap.success, false);
+    assert.match(fileCap.message ?? "", /2 session files exceed/);
+
+    const lineCap = searchSessionAnchors("any:\n- a", { sessionsDir, maxLines: 1 });
+    assert.strictEqual(lineCap.success, false);
+    assert.match(lineCap.message ?? "", /scan cap/);
+  });
+
+  it("allows cwd-only requests as bounded source anchors", () => {
+    const sessionsDir = makeSessionsDir();
+    writeJsonl("session.jsonl", [
+      message("2026-05-15T10:00:00.000Z", "inside cwd"),
+      message("2026-05-15T11:00:00.000Z", "outside cwd", { cwd: "/other/project" }),
+    ]);
+
+    const result = searchSessionAnchors("cwd: /work/project", { sessionsDir });
+
+    assert.strictEqual(result.success, true);
+    assert.strictEqual(result.ranges.length, 1);
+    assert.strictEqual(result.ranges[0].startLine, 1);
+    assert.strictEqual(result.ranges[0].reason, "cwd");
+  });
+
+  it("carries the real session event id onto matching message ranges", () => {
+    const sessionsDir = makeSessionsDir();
+    writeJsonl("session.jsonl", [
+      { type: "session", version: 1, id: "session-real", timestamp: "2026-05-15T09:00:00.000Z", cwd: "/work/project" },
+      { type: "message", id: "message-1", parentId: "session-real", timestamp: "2026-05-15T10:00:00.000Z", message: { role: "user", content: "needle" } },
+    ]);
+
+    const result = searchSessionAnchors("any:\n- needle", { sessionsDir });
+
+    assert.strictEqual(result.success, true);
+    assert.strictEqual(result.ranges.length, 1);
+    assert.strictEqual(result.ranges[0].sessionId, "session-real");
+    assert.strictEqual(result.ranges[0].startLine, 2);
+  });
+
+  it("does not match metadata fields as text", () => {
+    const sessionsDir = makeSessionsDir();
+    writeJsonl("session.jsonl", [
+      message("2026-05-15T10:00:00.000Z", "actual content"),
+    ]);
+
+    const result = searchSessionAnchors("any:\n- /work/project", { sessionsDir });
+
+    assert.strictEqual(result.success, true);
+    assert.strictEqual(result.ranges.length, 0);
+  });
+
+  it("returns contiguous timestamped ranges for time-window-only queries", () => {
+    const sessionsDir = makeSessionsDir();
+    const filePath = writeJsonl("session.jsonl", [
+      message("2026-05-14T12:00:00.000Z", "before"),
+      message("2026-05-15T10:00:00.000Z", "inside one"),
+      message("2026-05-15T11:00:00.000Z", "inside two"),
+      message("2026-05-16T12:00:00.000Z", "after"),
+    ]);
+
+    const result = searchSessionAnchors("from: 2026-05-15\nto: 2026-05-15", { sessionsDir });
+
+    assert.strictEqual(result.success, true);
+    assert.deepStrictEqual(result.ranges.map((range) => ({ path: range.path, startLine: range.startLine, endLine: range.endLine })), [
+      { path: filePath, startLine: 2, endLine: 3 },
+    ]);
+    assert.strictEqual(result.ranges[0].startTime, "2026-05-15T10:00:00.000Z");
+    assert.strictEqual(result.ranges[0].endTime, "2026-05-15T11:00:00.000Z");
+  });
+
+  it("matches all and any terms as case-insensitive literal substrings", () => {
+    const sessionsDir = makeSessionsDir();
+    writeJsonl("session.jsonl", [
+      message("2026-05-15T10:00:00.000Z", "Alpha beta phrase"),
+      message("2026-05-15T11:00:00.000Z", "Contains GAMMA only"),
+      message("2026-05-15T12:00:00.000Z", "nothing useful"),
+    ]);
+
+    const allResult = searchSessionAnchors("all:\n- alpha beta", { sessionsDir });
+    assert.strictEqual(allResult.success, true);
+    assert.strictEqual(allResult.ranges.length, 1);
+    assert.strictEqual(allResult.ranges[0].startLine, 1);
+    assert.strictEqual(allResult.ranges[0].reason, "matched all: alpha beta");
+
+    const anyResult = searchSessionAnchors("any:\n- gamma\n- delta", { sessionsDir });
+    assert.strictEqual(anyResult.success, true);
+    assert.strictEqual(anyResult.ranges.length, 1);
+    assert.strictEqual(anyResult.ranges[0].startLine, 2);
+    assert.strictEqual(anyResult.ranges[0].reason, "matched any: gamma");
+  });
+
+  it("removes ranges containing exclude terms", () => {
+    const sessionsDir = makeSessionsDir();
+    writeJsonl("session.jsonl", [
+      message("2026-05-15T10:00:00.000Z", "alpha keep"),
+      message("2026-05-15T10:30:00.000Z", "separator"),
+      message("2026-05-15T11:00:00.000Z", "alpha secret drop"),
+    ]);
+
+    const result = searchSessionAnchors("any:\n- alpha\nexclude:\n- secret", { sessionsDir });
+
+    assert.strictEqual(result.success, true);
+    assert.strictEqual(result.ranges.length, 1);
+    assert.strictEqual(result.ranges[0].startLine, 1);
+  });
+
+  it("returns single-line hits as startLine equal to endLine", () => {
+    const sessionsDir = makeSessionsDir();
+    writeJsonl("nested/session.jsonl", [
+      message("2026-05-15T10:00:00.000Z", "first"),
+      message("2026-05-15T11:00:00.000Z", "needle"),
+    ]);
+
+    const result = searchSessionAnchors("any:\n- needle", { sessionsDir });
+
+    assert.strictEqual(result.success, true);
+    assert.strictEqual(result.ranges.length, 1);
+    assert.strictEqual(result.ranges[0].startLine, 2);
+    assert.strictEqual(result.ranges[0].endLine, 2);
+  });
+
+  it("fails on invalid JSON lines with path and line", () => {
+    const sessionsDir = makeSessionsDir();
+    const filePath = path.join(sessionsDir, "bad.jsonl");
+    fs.writeFileSync(filePath, `${JSON.stringify(message("2026-05-15T10:00:00.000Z", "ok"))}\n{bad json}\n`);
+
+    const result = searchSessionAnchors("from: 2026-05-15", { sessionsDir });
+
+    assert.strictEqual(result.success, false);
+    assert.match(result.message ?? "", new RegExp(`${filePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:2`));
+  });
+});