pi-memory-stone 0.1.0

package/test/parser.test.ts

@@ -0,0 +1,261 @@
+/**
+ * Tests for the session parser module.
+ * Run with: node --experimental-sqlite --test test/parser.test.ts
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { parseEntries, turnsToRecords } from "../src/indexing/parser.js";
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function makeUserEntry(id: string, text: string) {
+  return {
+    type: "message",
+    id,
+    parentId: id === "001" ? null : String(Number(id) - 1).padStart(3, "0"),
+    timestamp: new Date().toISOString(),
+    message: {
+      role: "user",
+      content: text,
+      timestamp: Date.now(),
+    },
+  };
+}
+
+function makeAssistantEntry(id: string, text: string, toolCalls: Array<{ id: string; name: string; arguments: Record<string, unknown> }> = []) {
+  const content: Array<Record<string, unknown>> = [];
+  if (text) {
+    content.push({ type: "text", text });
+  }
+  for (const tc of toolCalls) {
+    content.push({ type: "toolCall", ...tc });
+  }
+  return {
+    type: "message",
+    id,
+    parentId: String(Number(id) - 1).padStart(3, "0"),
+    timestamp: new Date().toISOString(),
+    message: {
+      role: "assistant",
+      content,
+      provider: "anthropic",
+      model: "claude-sonnet-4-5",
+      usage: { totalTokens: 100 },
+      stopReason: "stop",
+      timestamp: Date.now(),
+    },
+  };
+}
+
+function makeToolResultEntry(id: string, toolCallId: string, toolName: string, text: string, isError = false) {
+  return {
+    type: "message",
+    id,
+    parentId: String(Number(id) - 1).padStart(3, "0"),
+    timestamp: new Date().toISOString(),
+    message: {
+      role: "toolResult",
+      toolCallId,
+      toolName,
+      content: [{ type: "text", text }],
+      isError,
+      timestamp: Date.now(),
+    },
+  };
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────
+
+describe("parseEntries", () => {
+  it("parses a simple user-assistant turn", () => {
+    const entries = [
+      makeUserEntry("001", "Hello, can you help me?"),
+      makeAssistantEntry("002", "Of course! How can I assist?"),
+    ];
+
+    const { turns } = parseEntries(entries as any);
+    assert.equal(turns.length, 1);
+    assert.equal(turns[0].userEntryId, "001");
+    assert.ok(turns[0].userPrompt.includes("Hello"));
+    assert.ok(turns[0].assistantText.includes("Of course"));
+    assert.equal(turns[0].toolCalls.length, 0);
+    assert.equal(turns[0].errors.length, 0);
+  });
+
+  it("parses a turn with tool calls", () => {
+    const entries = [
+      makeUserEntry("001", "Read package.json"),
+      makeAssistantEntry("002", "Let me read that file.", [
+        { id: "call_1", name: "read", arguments: { path: "package.json" } },
+      ]),
+      makeToolResultEntry("003", "call_1", "read", '{"name": "my-package"}'),
+    ];
+
+    const { turns } = parseEntries(entries as any);
+    assert.equal(turns.length, 1);
+    assert.equal(turns[0].toolCalls.length, 1);
+    assert.equal(turns[0].toolCalls[0].toolName, "read");
+    assert.deepEqual(turns[0].toolCalls[0].args, { path: "package.json" });
+    assert.equal(turns[0].toolCalls[0].resultText, '{"name": "my-package"}');
+  });
+
+  it("preserves assistant tool calls without tool results", () => {
+    const entries = [
+      makeUserEntry("001", "Read package.json"),
+      makeAssistantEntry("002", "Let me read that file.", [
+        { id: "call_1", name: "read", arguments: { path: "package.json" } },
+      ]),
+    ];
+
+    const { turns } = parseEntries(entries as any);
+    assert.equal(turns.length, 1);
+    assert.equal(turns[0].toolCalls.length, 1);
+    assert.equal(turns[0].toolCalls[0].toolCallId, "call_1");
+    assert.equal(turns[0].toolCalls[0].toolName, "read");
+    assert.deepEqual(turns[0].toolCalls[0].args, { path: "package.json" });
+    assert.equal(turns[0].toolCalls[0].resultText, "");
+  });
+
+  it("parses multiple turns", () => {
+    const entries = [
+      makeUserEntry("001", "Question 1"),
+      makeAssistantEntry("002", "Answer 1"),
+      makeUserEntry("003", "Question 2"),
+      makeAssistantEntry("004", "Answer 2"),
+    ];
+
+    const { turns } = parseEntries(entries as any);
+    assert.equal(turns.length, 2);
+    assert.equal(turns[0].userEntryId, "001");
+    assert.equal(turns[1].userEntryId, "003");
+  });
+
+  it("detects errors in tool results", () => {
+    const entries = [
+      makeUserEntry("001", "Run a command"),
+      makeAssistantEntry("002", "Running...", [
+        { id: "call_1", name: "bash", arguments: { command: "invalid" } },
+      ]),
+      makeToolResultEntry("003", "call_1", "bash", "Command not found", true),
+    ];
+
+    const { turns } = parseEntries(entries as any);
+    assert.equal(turns[0].errors.length, 1);
+    assert.equal(turns[0].errors[0].toolName, "bash");
+  });
+
+  it("detects file activities from tool calls", () => {
+    const entries = [
+      makeUserEntry("001", "Check package.json"),
+      makeAssistantEntry("002", "Let me check.", [
+        { id: "call_1", name: "read", arguments: { path: "src/index.ts" } },
+        { id: "call_2", name: "edit", arguments: { path: "src/utils.ts" } },
+      ]),
+      makeToolResultEntry("003", "call_1", "read", "content..."),
+      makeToolResultEntry("004", "call_2", "edit", "edited"),
+    ];
+
+    const { fileActivities } = parseEntries(entries as any);
+
+    const reads = fileActivities.filter((f) => f.action === "read");
+    const edits = fileActivities.filter((f) => f.action === "edit");
+
+    assert.equal(reads.length, 1);
+    assert.equal(edits.length, 1);
+    assert.equal(reads[0].path, "src/index.ts");
+    assert.equal(edits[0].path, "src/utils.ts");
+  });
+
+  it("skips sensitive file paths", () => {
+    const entries = [
+      makeUserEntry("001", "Check env"),
+      makeAssistantEntry("002", "Checking...", [
+        { id: "call_1", name: "read", arguments: { path: ".env" } },
+        { id: "call_2", name: "read", arguments: { path: "src/app.ts" } },
+      ]),
+      makeToolResultEntry("003", "call_1", "read", "SECRET=abc"),
+      makeToolResultEntry("004", "call_2", "read", "code..."),
+    ];
+
+    const { fileActivities } = parseEntries(entries as any);
+    const envActivity = fileActivities.filter((f) => f.path.includes(".env"));
+    const normalActivity = fileActivities.filter((f) => f.path === "src/app.ts");
+
+    assert.equal(envActivity.length, 0, "Should skip .env files");
+    assert.equal(normalActivity.length, 1, "Should keep normal files once");
+  });
+
+  it("handles compactions", () => {
+    const entries = [
+      makeUserEntry("001", "Test"),
+      makeAssistantEntry("002", "Response"),
+      {
+        type: "compaction",
+        id: "003",
+        parentId: "002",
+        timestamp: new Date().toISOString(),
+        summary: "Previous context summarized",
+        firstKeptEntryId: "001",
+        tokensBefore: 5000,
+      },
+    ];
+
+    const { compactions } = parseEntries(entries as any);
+    assert.equal(compactions.length, 1);
+    assert.ok(compactions[0].summary.includes("Previous"));
+  });
+});
+
+describe("turnsToRecords", () => {
+  it("generates turn_summary records", () => {
+    const turns = [
+      {
+        userEntryId: "001",
+        userPrompt: "Fix the authentication bug",
+        assistantEntryIds: ["002"],
+        assistantText: "I found the issue in auth.ts and fixed it.",
+        toolCalls: [
+          {
+            entryId: "003",
+            toolName: "read",
+            args: { path: "src/auth.ts" },
+            resultText: "code...",
+            isError: false,
+          },
+        ],
+        errors: [],
+      },
+    ];
+
+    const records = turnsToRecords(turns, "/home/project", "session-1", "/path/session.jsonl");
+    assert.ok(records.length >= 1);
+    assert.equal(records[0].kind, "turn_summary");
+    assert.ok(records[0].text.includes("Fix the authentication"));
+    assert.ok(records[0].text.includes("auth.ts"));
+  });
+
+  it("generates error_resolution records for errors", () => {
+    const turns = [
+      {
+        userEntryId: "001",
+        userPrompt: "Run deployment",
+        assistantEntryIds: ["002"],
+        assistantText: "Running deploy...",
+        toolCalls: [],
+        errors: [
+          {
+            entryId: "003",
+            toolName: "bash",
+            message: "Permission denied: cannot write to /etc",
+          },
+        ],
+      },
+    ];
+
+    const records = turnsToRecords(turns, "/home/project", "session-1", "/path/session.jsonl");
+    const errorRecords = records.filter((r) => r.kind === "error_resolution");
+    assert.equal(errorRecords.length, 1);
+    assert.ok(errorRecords[0].text.includes("Permission denied"));
+  });
+});

package/test/privacy.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Tests for the privacy/redaction module.
+ * Run with: node --experimental-sqlite --test test/privacy.test.ts
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { redactSecrets, isSensitivePath, shouldIgnoreFile } from "../src/privacy/index.js";
+
+describe("redactSecrets", () => {
+  it("redacts OpenAI API keys", () => {
+    const input = "My key is sk-proj-abc123def456ghi789jkl012mno345pqr678stu";
+    const result = redactSecrets(input);
+    assert.ok(result.includes("[REDACTED:openai-key]"));
+    assert.ok(!result.includes("sk-proj-"));
+  });
+
+  it("redacts GitHub tokens", () => {
+    const input = "export GITHUB_TOKEN=ghp_abc123def456ghi789jkl012mno345pqr678";
+    const result = redactSecrets(input);
+    assert.ok(result.includes("[REDACTED:github-token]"));
+  });
+
+  it("redacts JWT tokens", () => {
+    const input = "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U";
+    const result = redactSecrets(input);
+    assert.ok(result.includes("[REDACTED:jwt]"));
+  });
+
+  it("redacts passwords in assignments", () => {
+    const input = 'password="superSecret123" and pwd="admin123"';
+    const result = redactSecrets(input);
+    assert.ok(result.includes("[REDACTED:password]"));
+    assert.ok(!result.includes("superSecret123"));
+    assert.ok(!result.includes("admin123"));
+  });
+
+  it("redacts unquoted password, token, and secret assignments", () => {
+    const input = "password=superSecret123 pwd=admin123 TOKEN=abcdef0123456789 SECRET=shhDontKeepMe";
+    const result = redactSecrets(input);
+    assert.ok(result.includes("[REDACTED:password]"));
+    assert.ok(result.includes("[REDACTED:token]"));
+    assert.ok(result.includes("[REDACTED:secret]"));
+    assert.ok(!result.includes("superSecret123"));
+    assert.ok(!result.includes("abcdef0123456789"));
+    assert.ok(!result.includes("shhDontKeepMe"));
+  });
+
+  it("redacts connection strings", () => {
+    const input = "DATABASE_URL=mongodb://user:pass@localhost:27017/db";
+    const result = redactSecrets(input);
+    assert.ok(result.includes("[REDACTED]@"));
+    assert.ok(!result.includes("user:pass@"));
+  });
+
+  it("redacts private keys", () => {
+    const input = `-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC...
+-----END PRIVATE KEY-----`;
+    const result = redactSecrets(input);
+    assert.ok(result.includes("[REDACTED:private-key]"));
+    assert.ok(!result.includes("MIIEvQ"));
+  });
+
+  it("preserves normal text", () => {
+    const input = "Just some normal conversation about code";
+    const result = redactSecrets(input);
+    assert.equal(result, input);
+  });
+});
+
+describe("isSensitivePath", () => {
+  it("flags .env files", () => {
+    assert.ok(isSensitivePath(".env"));
+    assert.ok(isSensitivePath(".env.local"));
+    assert.ok(isSensitivePath("path/to/.env.production"));
+  });
+
+  it("flags key/cert files", () => {
+    assert.ok(isSensitivePath("cert.pem"));
+    assert.ok(isSensitivePath("private.key"));
+    assert.ok(isSensitivePath("path/to/server.crt"));
+  });
+
+  it("flags SSH keys", () => {
+    assert.ok(isSensitivePath("~/.ssh/id_rsa"));
+    assert.ok(isSensitivePath("/home/user/.ssh/id_ed25519"));
+  });
+
+  it("flags AWS credentials", () => {
+    assert.ok(isSensitivePath("~/.aws/credentials"));
+    assert.ok(isSensitivePath("~/.aws/config"));
+  });
+
+  it("flags node_modules", () => {
+    assert.ok(isSensitivePath("node_modules/foo/bar.ts"));
+  });
+
+  it("flags .git directory", () => {
+    assert.ok(isSensitivePath(".git/config"));
+  });
+
+  it("allows normal source files", () => {
+    assert.ok(!isSensitivePath("src/index.ts"));
+    assert.ok(!isSensitivePath("components/Button.tsx"));
+    assert.ok(!isSensitivePath("README.md"));
+  });
+});
+
+describe("shouldIgnoreFile", () => {
+  it("returns true for sensitive files", () => {
+    assert.ok(shouldIgnoreFile(".env"));
+    assert.ok(shouldIgnoreFile("secrets/config.json"));
+  });
+
+  it("returns false for normal files", () => {
+    assert.ok(!shouldIgnoreFile("src/utils.ts"));
+    assert.ok(!shouldIgnoreFile("package.json"));
+  });
+});