@mingxy/cerebro 1.20.4 → 1.20.6

package/src/privacy.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect } from "vitest";
+import { stripPrivateContent, isFullyPrivate } from "./privacy.js";
+
+describe("stripPrivateContent", () => {
+  it("replaces a single <private> block with [REDACTED]", () => {
+    const input = "Hello <private>secret</private> world";
+    expect(stripPrivateContent(input)).toBe("Hello [REDACTED] world");
+  });
+
+  it("handles multiline private content", () => {
+    const input = "before <private>line1\nline2\nline3</private> after";
+    expect(stripPrivateContent(input)).toBe("before [REDACTED] after");
+  });
+
+  it("handles multiple private sections", () => {
+    const input = "a <private>x</private> b <private>y</private> c";
+    expect(stripPrivateContent(input)).toBe("a [REDACTED] b [REDACTED] c");
+  });
+
+  it("is case-insensitive (PRIVATE, Private)", () => {
+    expect(stripPrivateContent("<PRIVATE>secret</PRIVATE>")).toBe("[REDACTED]");
+    expect(stripPrivateContent("<Private>secret</Private>")).toBe("[REDACTED]");
+    expect(stripPrivateContent("<PrIvAtE>secret</PrIvAtE>")).toBe("[REDACTED]");
+  });
+
+  it("returns original text when no private tags present", () => {
+    const input = "nothing private here";
+    expect(stripPrivateContent(input)).toBe(input);
+  });
+
+  it("handles empty private block", () => {
+    expect(stripPrivateContent("<private></private>")).toBe("[REDACTED]");
+  });
+
+  it("handles private block with only whitespace", () => {
+    expect(stripPrivateContent("<private>   \n\t  </private>")).toBe("[REDACTED]");
+  });
+
+  it("handles adjacent private blocks", () => {
+    expect(stripPrivateContent("<private>a</private><private>b</private>")).toBe("[REDACTED][REDACTED]");
+  });
+
+  it("handles entire string being private", () => {
+    expect(stripPrivateContent("<private>everything</private>")).toBe("[REDACTED]");
+  });
+
+  it("preserves content outside of private tags", () => {
+    const input = "keep this <private>hide</private> and this too";
+    expect(stripPrivateContent(input)).toBe("keep this [REDACTED] and this too");
+  });
+
+  it("handles unclosed private tag gracefully (no match)", () => {
+    const input = "text <private>never closes";
+    expect(stripPrivateContent(input)).toBe(input);
+  });
+
+  it("handles nested-looking tags (non-greedy matches first pair)", () => {
+    // The regex is non-greedy, so <private>outer<private>inner</private></private>
+    // will match <private>outer<private>inner</private> as first match,
+    // leaving </private> unmatched
+    const input = "<private>outer<private>inner</private></private>";
+    const result = stripPrivateContent(input);
+    expect(result).toBe("[REDACTED]</private>");
+  });
+
+  it("handles empty string", () => {
+    expect(stripPrivateContent("")).toBe("");
+  });
+
+  it("handles private tag with special characters inside", () => {
+    expect(stripPrivateContent("<private>$#@!&*()</private>")).toBe("[REDACTED]");
+  });
+
+  it("handles private tag with unicode/CJK content", () => {
+    expect(stripPrivateContent("<private>中文内容🔐</private>")).toBe("[REDACTED]");
+  });
+});
+
+describe("isFullyPrivate", () => {
+  it("returns true when entire text is a single private block", () => {
+    expect(isFullyPrivate("<private>everything</private>")).toBe(true);
+  });
+
+  it("returns true for multiple private blocks with no other content", () => {
+    expect(isFullyPrivate("<private>a</private><private>b</private>")).toBe(true);
+  });
+
+  it("returns true for private blocks separated only by whitespace", () => {
+    expect(isFullyPrivate("<private>a</private>   <private>b</private>")).toBe(true);
+    expect(isFullyPrivate("<private>a</private>\n\t<private>b</private>")).toBe(true);
+  });
+
+  it("returns false when there is non-private content", () => {
+    expect(isFullyPrivate("Hello <private>secret</private> world")).toBe(false);
+  });
+
+  it("returns false for plain text with no private tags", () => {
+    expect(isFullyPrivate("just some text")).toBe(false);
+  });
+
+  it("returns true for empty string (nothing remains after trim)", () => {
+    // stripPrivateContent("") = "", replace redacted = "", trim = "" → length 0
+    expect(isFullyPrivate("")).toBe(true);
+  });
+
+  it("returns true for only whitespace after stripping", () => {
+    expect(isFullyPrivate("   <private>secret</private>   ")).toBe(true);
+  });
+
+  it("is case-insensitive", () => {
+    expect(isFullyPrivate("<PRIVATE>secret</PRIVATE>")).toBe(true);
+  });
+
+  it("handles multiline fully-private content", () => {
+    const input = `<private>line1
+line2
+line3</private>`;
+    expect(isFullyPrivate(input)).toBe(true);
+  });
+
+  it("returns false when non-private text remains after stripping", () => {
+    expect(isFullyPrivate("<private>hidden</private>visible")).toBe(false);
+  });
+
+  it("returns true for empty private block with no other text", () => {
+    expect(isFullyPrivate("<private></private>")).toBe(true);
+  });
+});

package/src/tags.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest";
+import { getUserTag, getProjectTag } from "./tags.js";
+
+describe("getUserTag", () => {
+  it("returns tag with omem_user_ prefix", () => {
+    const result = getUserTag("test@example.com");
+    expect(result).toMatch(/^omem_user_[a-f0-9]{16}$/);
+  });
+
+  it("is deterministic (same input → same output)", () => {
+    const email = "user@example.com";
+    expect(getUserTag(email)).toBe(getUserTag(email));
+  });
+
+  it("produces different outputs for different inputs", () => {
+    expect(getUserTag("alice@example.com")).not.toBe(getUserTag("bob@example.com"));
+  });
+
+  it("handles empty string", () => {
+    const result = getUserTag("");
+    expect(result).toMatch(/^omem_user_[a-f0-9]{16}$/);
+  });
+
+  it("produces consistent hash for known input", () => {
+    // Verify determinism by calling twice
+    const first = getUserTag("test@test.com");
+    const second = getUserTag("test@test.com");
+    expect(first).toBe(second);
+    // Verify it's exactly 16 hex chars after prefix
+    const hash = first.replace("omem_user_", "");
+    expect(hash).toHaveLength(16);
+    expect(hash).toMatch(/^[a-f0-9]+$/);
+  });
+
+  it("handles unicode email addresses", () => {
+    const result = getUserTag("用户@example.com");
+    expect(result).toMatch(/^omem_user_[a-f0-9]{16}$/);
+  });
+
+  it("handles very long input", () => {
+    const longEmail = "a".repeat(1000) + "@example.com";
+    const result = getUserTag(longEmail);
+    expect(result).toMatch(/^omem_user_[a-f0-9]{16}$/);
+  });
+});
+
+describe("getProjectTag", () => {
+  it("returns tag with omem_project_ prefix", () => {
+    const result = getProjectTag("/home/user/project");
+    expect(result).toMatch(/^omem_project_[a-f0-9]{16}$/);
+  });
+
+  it("is deterministic (same input → same output)", () => {
+    const dir = "/home/user/project";
+    expect(getProjectTag(dir)).toBe(getProjectTag(dir));
+  });
+
+  it("produces different outputs for different inputs", () => {
+    expect(getProjectTag("/path/a")).not.toBe(getProjectTag("/path/b"));
+  });
+
+  it("handles empty string", () => {
+    const result = getProjectTag("");
+    expect(result).toMatch(/^omem_project_[a-f0-9]{16}$/);
+  });
+
+  it("produces different tags than getUserTag for same input", () => {
+    const input = "test";
+    expect(getProjectTag(input)).not.toBe(getUserTag(input));
+  });
+
+  it("handles Windows-style paths", () => {
+    const result = getProjectTag("C:\\Users\\dev\\project");
+    expect(result).toMatch(/^omem_project_[a-f0-9]{16}$/);
+  });
+
+  it("handles paths with trailing slashes", () => {
+    const result = getProjectTag("/home/user/project/");
+    expect(result).toMatch(/^omem_project_[a-f0-9]{16}$/);
+  });
+
+  it("handles paths with unicode characters", () => {
+    const result = getProjectTag("/home/用户/项目");
+    expect(result).toMatch(/^omem_project_[a-f0-9]{16}$/);
+  });
+});