@datafog/fogclaw 0.1.4 → 0.1.6

package/tests/plugin-smoke.test.ts

@@ -9,12 +9,14 @@ function createApi() {
   return {
     pluginConfig: {
       model: "invalid:/not/real/model",
+      auditEnabled: true,
     },
     hooks,
     tools,
     logger: {
       info: vi.fn(),
       warn: vi.fn(),
+      error: vi.fn(),
     },
     on: vi.fn((event: string, handler: (event: any) => Promise<any>) => {
       hooks.push({ event, handler });
@@ -46,14 +48,18 @@ describe("FogClaw OpenClaw plugin contract (integration path)", () => {
 
     expect(typeof plugin.register).toBe("function");
     expect(api.on).toHaveBeenCalledWith("before_agent_start", expect.any(Function));
-    expect(api.registerTool).toHaveBeenCalledTimes(2);
+    expect(api.registerTool).toHaveBeenCalledTimes(3);
 
     const scanTool = api.tools.find((tool: any) => tool.id === "fogclaw_scan");
+    const previewTool = api.tools.find((tool: any) => tool.id === "fogclaw_preview");
     const redactTool = api.tools.find((tool: any) => tool.id === "fogclaw_redact");
 
     expect(scanTool).toBeDefined();
+    expect(previewTool).toBeDefined();
     expect(redactTool).toBeDefined();
+
     expect(scanTool.schema.required).toContain("text");
+    expect(previewTool.schema.required).toContain("text");
     expect(redactTool.schema.required).toContain("text");
   });
 
@@ -96,6 +102,29 @@ describe("FogClaw OpenClaw plugin contract (integration path)", () => {
     expect(redactParsed.redacted_text).not.toContain("john@example.com");
   });
 
+  it("supports preview output with action plan and redacted text", async () => {
+    const api = createApi();
+
+    plugin.register(api);
+
+    const previewTool = api.tools.find((tool: any) => tool.id === "fogclaw_preview");
+
+    const previewOutput = await previewTool.handler({
+      text: "Email me at john@example.com about Acme Corp tomorrow.",
+    });
+
+    const parsed = JSON.parse(previewOutput.content[0].text);
+    expect(parsed.totalEntities).toBeGreaterThan(0);
+    expect(parsed.actionPlan).toEqual(
+      expect.objectContaining({
+        blocked: expect.objectContaining({ count: expect.any(Number) }),
+        warned: expect.objectContaining({ count: expect.any(Number) }),
+        redacted: expect.objectContaining({ count: expect.any(Number) }),
+      }),
+    );
+    expect(typeof parsed.redactedText).toBe("string");
+  });
+
   it("passes custom_labels through tool path in real execution", async () => {
     const api = createApi();
 

package/tests/scanner.test.ts

@@ -1,4 +1,12 @@
-import { beforeAll, beforeEach, afterAll, describe, it, expect, vi } from "vitest";
+import {
+  beforeAll,
+  beforeEach,
+  afterAll,
+  describe,
+  it,
+  expect,
+  vi,
+} from "vitest";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -186,6 +194,58 @@ describe("Scanner", () => {
     expect(email!.source).toBe("regex");
   });
 
+  it("applies per-entity confidence threshold overrides", async () => {
+    const strictScanner = new Scanner(
+      makeConfig({
+        entityConfidenceThresholds: {
+          PERSON: 0.98,
+        },
+      }),
+    );
+    await strictScanner.initialize();
+
+    const result = await strictScanner.scan("My name is John Smith.");
+    expect(result.entities.find((e) => e.label === "PERSON")).toBeUndefined();
+  });
+
+  it("supports allowlist exact matches across global and per-entity rules", async () => {
+    const allowlistScanner = new Scanner(
+      makeConfig({
+        allowlist: {
+          values: ["john@example.com"],
+          patterns: ["^internal-"],
+          entities: {
+            PERSON: ["john smith"],
+          },
+        },
+      }),
+    );
+    await allowlistScanner.initialize();
+
+    const result = await allowlistScanner.scan(
+      "John Smith can be reached at john@example.com.",
+    );
+
+    expect(result.entities.find((e) => e.label === "EMAIL")).toBeUndefined();
+    expect(result.entities.find((e) => e.label === "PERSON")).toBeUndefined();
+  });
+
+  it("applies allowlist regex patterns", async () => {
+    const allowlistScanner = new Scanner(
+      makeConfig({
+        allowlist: {
+          values: [],
+          patterns: ["test@example\\.com"],
+          entities: {},
+        },
+      }),
+    );
+    await allowlistScanner.initialize();
+
+    const result = await allowlistScanner.scan("This is test@example.com for redaction.");
+    expect(result.entities.find((e) => e.label === "EMAIL")).toBeUndefined();
+  });
+
   it("deduplicates overlapping spans keeping higher confidence", async () => {
     // Scan text that might produce overlapping entities
     // The dedup logic should keep higher confidence when spans overlap