qlogicagent 2.13.3 → 2.13.5

package/dist/runtime/community/community-consent-client.test.js

@@ -0,0 +1,491 @@
+import { describe, expect, it, vi } from "vitest";
+import { createCommunityConsentClient } from "./community-consent-client.js";
+describe("community consent client", () => {
+    it("uses the hub registry consent endpoint with bearer auth", async () => {
+        const fetchFn = vi.fn(async (input, init) => {
+            expect(String(input)).toBe("https://www.qlogicagent.com/api/v15/registry/community-consent");
+            expect(init?.method).toBe("PUT");
+            expect(new Headers(init?.headers).get("authorization")).toBe("Bearer jwt-123");
+            expect(JSON.parse(String(init?.body))).toEqual({ enabled: true });
+            return Response.json({
+                enabled: true,
+                methodSharingEnabled: true,
+                signalsEnabled: true,
+                encounterEnabled: true,
+            });
+        });
+        const client = createCommunityConsentClient({
+            baseUrl: "https://www.qlogicagent.com/api/",
+            token: "jwt-123",
+            fetchFn,
+        });
+        await expect(client.setConsent({ enabled: true })).resolves.toEqual({
+            enabled: true,
+            methodSharingEnabled: true,
+            signalsEnabled: true,
+            encounterEnabled: true,
+            remoteSynced: true,
+        });
+        expect(fetchFn).toHaveBeenCalledTimes(1);
+    });
+    it("lists and withdraws shared resources through registry REST routes", async () => {
+        const calls = [];
+        const fetchFn = vi.fn(async (input, init) => {
+            calls.push({
+                url: String(input),
+                method: init?.method,
+                body: init?.body ? JSON.parse(String(init.body)) : undefined,
+            });
+            if (String(input).endsWith("/api/v15/registry/mine")) {
+                return Response.json({
+                    resources: [{
+                            id: "email-ops",
+                            type: "skill",
+                            title: "Email Ops",
+                            summary: "s",
+                            visibility: "public",
+                            latestVersion: "1.0.0",
+                            withdrawn: false,
+                            withdrawnAt: null,
+                        }],
+                });
+            }
+            return Response.json({
+                id: "email-ops",
+                type: "skill",
+                title: "Email Ops",
+                summary: "s",
+                visibility: "public",
+                latestVersion: "1.0.0",
+                withdrawn: true,
+                withdrawnAt: "2026-01-01T00:00:00.000Z",
+            });
+        });
+        const client = createCommunityConsentClient({
+            baseUrl: "https://www.qlogicagent.com/api/",
+            token: "jwt-123",
+            fetchFn,
+        });
+        await expect(client.listSharedResources()).resolves.toEqual([{
+                id: "email-ops",
+                type: "skill",
+                title: "Email Ops",
+                summary: "s",
+                visibility: "public",
+                latestVersion: "1.0.0",
+                withdrawn: false,
+                withdrawnAt: null,
+            }]);
+        await expect(client.withdrawSharedResource("email-ops", "user requested")).resolves.toMatchObject({
+            id: "email-ops",
+            withdrawn: true,
+        });
+        expect(calls).toEqual([
+            { url: "https://www.qlogicagent.com/api/v15/registry/mine", method: "GET", body: undefined },
+            { url: "https://www.qlogicagent.com/api/v15/registry/resources/email-ops/withdraw", method: "POST", body: { reason: "user requested" } },
+        ]);
+    });
+    it("matches only top-k canonical registry resources through the O(1) route", async () => {
+        const calls = [];
+        const fetchFn = vi.fn(async (input, init) => {
+            calls.push({
+                url: String(input),
+                method: init?.method,
+                body: init?.body ? JSON.parse(String(init.body)) : undefined,
+            });
+            return Response.json({
+                matches: [
+                    {
+                        id: "email-ops",
+                        type: "skill",
+                        title: "Email Ops",
+                        summary: " ".repeat(8) + "Reusable email triage workflow.".repeat(12),
+                        capabilityTags: ["email", "triage", "workflow", "ops", "reply", "archive", "overflow"],
+                        sourceTier: "official",
+                        trustStage: "trusted",
+                        resourceRiskTier: "R0",
+                        effectiveRiskTier: "R0",
+                        latestVersion: "1.0.0",
+                        canonical: true,
+                    },
+                    {
+                        id: "variant-hidden",
+                        type: "skill",
+                        title: "Variant",
+                        summary: "must not surface",
+                        capabilityTags: [],
+                        sourceTier: "community",
+                        trustStage: "trial",
+                        resourceRiskTier: "R0",
+                        effectiveRiskTier: "R0",
+                        latestVersion: "1.0.0",
+                        canonical: false,
+                    },
+                ],
+            });
+        });
+        const client = createCommunityConsentClient({
+            baseUrl: "https://www.qlogicagent.com/api/",
+            token: "jwt-123",
+            fetchFn,
+        });
+        const matches = await client.matchRegistry({ intent: "triage email", topK: 2 });
+        expect(calls).toEqual([{
+                url: "https://www.qlogicagent.com/api/v15/registry/match",
+                method: "POST",
+                body: {
+                    intent: "triage email",
+                    topK: 2,
+                    prefer: "official",
+                    canonicalOnly: true,
+                },
+            }]);
+        expect(matches).toHaveLength(1);
+        expect(matches[0]).toMatchObject({
+            id: "email-ops",
+            canonical: true,
+            capabilityTags: ["email", "triage", "workflow", "ops", "reply", "archive"],
+        });
+        expect(matches[0]?.summary.length).toBeLessThanOrEqual(161);
+        expect(JSON.stringify(matches)).not.toContain("variant-hidden");
+    });
+    it("rejects registry match topK values outside the top-1..3 contract", async () => {
+        const client = createCommunityConsentClient({
+            baseUrl: "https://www.qlogicagent.com/api/",
+            token: "jwt-123",
+            fetchFn: vi.fn(),
+        });
+        await expect(client.matchRegistry({ intent: "email", topK: 4 })).rejects.toThrow("topK");
+    });
+    it("bulk withdraws shared resources through the v15 consent downshare route", async () => {
+        const calls = [];
+        const fetchFn = vi.fn(async (input, init) => {
+            calls.push({
+                url: String(input),
+                method: init?.method,
+                body: init?.body ? JSON.parse(String(init.body)) : undefined,
+            });
+            return Response.json({
+                resources: [{
+                        id: "email-ops",
+                        type: "skill",
+                        title: "Email Ops",
+                        summary: "s",
+                        visibility: "public",
+                        latestVersion: "1.0.0",
+                        withdrawn: true,
+                        withdrawnAt: "2026-01-01T00:00:00.000Z",
+                    }],
+            });
+        });
+        const client = createCommunityConsentClient({
+            baseUrl: "https://www.qlogicagent.com/api/",
+            token: "jwt-123",
+            fetchFn,
+        });
+        await expect(client.withdrawSharedResources("leaving community")).resolves.toEqual([{
+                id: "email-ops",
+                type: "skill",
+                title: "Email Ops",
+                summary: "s",
+                visibility: "public",
+                latestVersion: "1.0.0",
+                withdrawn: true,
+                withdrawnAt: "2026-01-01T00:00:00.000Z",
+            }]);
+        expect(calls).toEqual([{
+                url: "https://www.qlogicagent.com/api/v15/registry/community-consent/withdraw-shared",
+                method: "POST",
+                body: { reason: "leaving community" },
+            }]);
+    });
+    it("lists and marks registry notices through v15-only REST routes", async () => {
+        const calls = [];
+        const fetchFn = vi.fn(async (input, init) => {
+            calls.push({ url: String(input), method: init?.method });
+            if (String(input).endsWith("/api/v15/registry/notices?includeRead=true")) {
+                return Response.json({
+                    notices: [{
+                            id: 7,
+                            resourceId: "email-ops",
+                            resourceType: "skill",
+                            title: "Email Ops",
+                            event: "withdrawn",
+                            version: "1.0.0",
+                            reason: "unsafe",
+                            read: false,
+                            createdAt: "2026-01-01T00:00:00.000Z",
+                            readAt: null,
+                        }],
+                });
+            }
+            return Response.json({
+                id: 7,
+                resourceId: "email-ops",
+                resourceType: "skill",
+                title: "Email Ops",
+                event: "withdrawn",
+                version: "1.0.0",
+                reason: "unsafe",
+                read: true,
+                createdAt: "2026-01-01T00:00:00.000Z",
+                readAt: "2026-01-01T00:01:00.000Z",
+            });
+        });
+        const client = createCommunityConsentClient({
+            baseUrl: "https://www.qlogicagent.com/api/",
+            token: "jwt-123",
+            fetchFn,
+        });
+        await expect(client.listNotices({ includeRead: true })).resolves.toEqual([{
+                id: 7,
+                resourceId: "email-ops",
+                resourceType: "skill",
+                title: "Email Ops",
+                event: "withdrawn",
+                version: "1.0.0",
+                reason: "unsafe",
+                read: false,
+                createdAt: "2026-01-01T00:00:00.000Z",
+                readAt: null,
+            }]);
+        await expect(client.markNoticeRead(7)).resolves.toMatchObject({
+            id: 7,
+            read: true,
+            readAt: "2026-01-01T00:01:00.000Z",
+        });
+        expect(calls).toEqual([
+            { url: "https://www.qlogicagent.com/api/v15/registry/notices?includeRead=true", method: "GET" },
+            { url: "https://www.qlogicagent.com/api/v15/registry/notices/7/read", method: "POST" },
+        ]);
+    });
+    it("publishes shared skill metadata and optional gzip versions through v15 REST routes", async () => {
+        const calls = [];
+        const fetchFn = vi.fn(async (input, init) => {
+            const headers = new Headers(init?.headers);
+            calls.push({
+                url: String(input),
+                method: init?.method,
+                contentType: headers.get("content-type"),
+                body: init?.body instanceof Uint8Array ? Buffer.from(init.body).toString("utf-8") : init?.body ? JSON.parse(String(init.body)) : undefined,
+            });
+            if (String(input).endsWith("/api/v15/registry/resources")) {
+                return Response.json({
+                    id: "email-ops",
+                    type: "skill",
+                    title: "Email Ops",
+                    summary: "Send and triage email",
+                    visibility: "public",
+                    latestVersion: null,
+                    withdrawn: false,
+                    withdrawnAt: null,
+                });
+            }
+            return Response.json({
+                version: "1.0.0",
+                checksum: "sha256:abc",
+                sizeBytes: 3,
+            });
+        });
+        const client = createCommunityConsentClient({
+            baseUrl: "https://www.qlogicagent.com/api/",
+            token: "jwt-123",
+            fetchFn,
+        });
+        await expect(client.publishSkill({
+            id: "email-ops",
+            title: "Email Ops",
+            summary: "Send and triage email",
+            visibility: "public",
+            tags: ["email"],
+            manifest: {
+                schema_version: 15,
+                kind: "inert",
+                name: "Email Ops",
+                summary: "Send and triage email",
+                description: "Reusable skill for triaging email.",
+                triggers: ["email"],
+                entry: "SKILL.md",
+            },
+            version: "1.0.0",
+            packageGzipBase64: Buffer.from("pkg").toString("base64"),
+        })).resolves.toEqual({
+            resource: {
+                id: "email-ops",
+                type: "skill",
+                title: "Email Ops",
+                summary: "Send and triage email",
+                visibility: "public",
+                latestVersion: null,
+                withdrawn: false,
+                withdrawnAt: null,
+            },
+            version: {
+                version: "1.0.0",
+                checksum: "sha256:abc",
+                sizeBytes: 3,
+            },
+        });
+        expect(calls).toEqual([
+            {
+                url: "https://www.qlogicagent.com/api/v15/registry/resources",
+                method: "POST",
+                contentType: "application/json",
+                body: {
+                    id: "email-ops",
+                    type: "skill",
+                    title: "Email Ops",
+                    summary: "Send and triage email",
+                    visibility: "public",
+                    tags: ["email"],
+                    manifest: {
+                        schema_version: 15,
+                        kind: "inert",
+                        name: "Email Ops",
+                        summary: "Send and triage email",
+                        description: "Reusable skill for triaging email.",
+                        triggers: ["email"],
+                        entry: "SKILL.md",
+                    },
+                },
+            },
+            {
+                url: "https://www.qlogicagent.com/api/v15/registry/resources/email-ops/versions/1.0.0",
+                method: "PUT",
+                contentType: "application/gzip",
+                body: "pkg",
+            },
+        ]);
+    });
+    it("records registry signals through the v15 REST signal route", async () => {
+        const calls = [];
+        const fetchFn = vi.fn(async (input, init) => {
+            calls.push({
+                url: String(input),
+                method: init?.method,
+                body: init?.body ? JSON.parse(String(init.body)) : undefined,
+            });
+            return Response.json({ accepted: true });
+        });
+        const client = createCommunityConsentClient({
+            baseUrl: "https://www.qlogicagent.com/api/",
+            token: "jwt-123",
+            fetchFn,
+        });
+        await expect(client.recordSignal({
+            resourceId: "email-ops",
+            event: "success",
+            attribution: "selected",
+            metadata: { source: "desktop" },
+        })).resolves.toEqual({ accepted: true });
+        expect(calls).toEqual([{
+                url: "https://www.qlogicagent.com/api/v15/registry/resources/email-ops/signal",
+                method: "POST",
+                body: {
+                    event: "success",
+                    attribution: "selected",
+                    metadata: { source: "desktop" },
+                },
+            }]);
+    });
+    it("records non-resource community telemetry through the v15 REST telemetry route", async () => {
+        const calls = [];
+        const fetchFn = vi.fn(async (input, init) => {
+            calls.push({
+                url: String(input),
+                method: init?.method,
+                body: init?.body ? JSON.parse(String(init.body)) : undefined,
+            });
+            return Response.json({ accepted: true });
+        });
+        const client = createCommunityConsentClient({
+            baseUrl: "https://www.qlogicagent.com/api/",
+            token: "jwt-123",
+            fetchFn,
+        });
+        await expect(client.recordTelemetry({
+            event: "community.share.generated",
+            metadata: {
+                surface: "pet-journey",
+                journeyDay: 12,
+                content: "must be dropped before egress",
+                filePath: "C:\\Users\\alice\\.ssh\\id_rsa",
+                toolCommand: "cat C:\\Users\\alice\\.ssh\\id_rsa",
+                secret: "sk-test-secret",
+            },
+        })).resolves.toEqual({ accepted: true });
+        expect(calls).toEqual([{
+                url: "https://www.qlogicagent.com/api/v15/registry/telemetry",
+                method: "POST",
+                body: {
+                    event: "community.share.generated",
+                    metadata: {
+                        surface: "pet-journey",
+                        journeyDay: 12,
+                    },
+                },
+            }]);
+        expect(JSON.stringify(calls)).not.toContain("id_rsa");
+        expect(JSON.stringify(calls)).not.toContain("must be dropped");
+        expect(JSON.stringify(calls)).not.toContain("sk-test-secret");
+    });
+    it("resolves install info with recursive effective risk tiers through the v15 REST install route", async () => {
+        const calls = [];
+        const fetchFn = vi.fn(async (input, init) => {
+            calls.push({ url: String(input), method: init?.method });
+            return Response.json({
+                id: "crm-skill",
+                type: "skill",
+                kind: "inert",
+                sourceTier: "community",
+                trustStage: "trusted",
+                reviewStatus: "approved",
+                resourceRiskTier: "R0",
+                effectiveRiskTier: "R3",
+                requires: ["crm-mcp"],
+                dependencies: [{
+                        id: "crm-mcp",
+                        type: "mcp",
+                        kind: "endpoint",
+                        sourceTier: "official",
+                        trustStage: "trusted",
+                        reviewStatus: "approved",
+                        resourceRiskTier: "R3",
+                        effectiveRiskTier: "R3",
+                        requires: [],
+                        dependencies: [],
+                        version: "1.0.0",
+                        checksum: "sha256:mcp",
+                        sizeBytes: 456,
+                        downloadUrl: "https://oss.example/registry/crm-mcp/1.0.0.tar.gz",
+                        manifest: { schema_version: 15, kind: "endpoint", requires: [] },
+                    }],
+                version: "1.0.0",
+                checksum: "sha256:crm",
+                sizeBytes: 123,
+                downloadUrl: "https://oss.example/registry/crm-skill/1.0.0.tar.gz",
+                manifest: { schema_version: 15, kind: "inert", requires: ["crm-mcp"] },
+            });
+        });
+        const client = createCommunityConsentClient({
+            baseUrl: "https://www.qlogicagent.com/api/",
+            token: "jwt-123",
+            fetchFn,
+        });
+        await expect(client.resolveInstall("crm-skill", "1.0.0")).resolves.toMatchObject({
+            id: "crm-skill",
+            resourceRiskTier: "R0",
+            effectiveRiskTier: "R3",
+            requires: ["crm-mcp"],
+            dependencies: [{
+                    id: "crm-mcp",
+                    resourceRiskTier: "R3",
+                    effectiveRiskTier: "R3",
+                }],
+        });
+        expect(calls).toEqual([{
+                url: "https://www.qlogicagent.com/api/v15/registry/resources/crm-skill/install?version=1.0.0",
+                method: "GET",
+            }]);
+    });
+});

package/dist/runtime/community/community-desensitization-red-team-cli.d.ts

@@ -0,0 +1,7 @@
+export interface CommunityDesensitizationRedTeamCliDeps {
+    log?: {
+        info(message: string): void;
+        error(message: string): void;
+    };
+}
+export declare function runCommunityDesensitizationRedTeamCli(argv?: string[], deps?: CommunityDesensitizationRedTeamCliDeps): Promise<number>;

package/dist/runtime/community/community-desensitization-red-team-cli.js

@@ -0,0 +1,43 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { runCommunityDesensitizationRedTeam } from "./community-desensitization.js";
+export async function runCommunityDesensitizationRedTeamCli(argv = process.argv.slice(2), deps = {}) {
+    const out = parseOutPath(argv);
+    const log = deps.log ?? console;
+    if (!out) {
+        log.error("Usage: tsx src/runtime/community/community-desensitization-red-team-cli.ts --out=<path>");
+        return 2;
+    }
+    try {
+        const report = runCommunityDesensitizationRedTeam();
+        fs.mkdirSync(path.dirname(out), { recursive: true });
+        fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+        log.info(`Community desensitization red-team report written: ${out}`);
+        return report.passed ? 0 : 1;
+    }
+    catch (err) {
+        log.error(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+}
+function parseOutPath(argv) {
+    const arg = argv.find((item) => item === "--out" || item.startsWith("--out=")) ?? argv[0];
+    if (!arg)
+        return null;
+    if (arg === "--out") {
+        const value = argv[argv.indexOf(arg) + 1];
+        return value ? path.resolve(value) : null;
+    }
+    if (arg.startsWith("--out="))
+        return path.resolve(arg.slice("--out=".length));
+    return path.resolve(arg);
+}
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? "")) {
+    runCommunityDesensitizationRedTeamCli().then((code) => {
+        process.exitCode = code;
+    }).catch((err) => {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 2;
+    });
+}

package/dist/runtime/community/community-desensitization-red-team-cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/community/community-desensitization-red-team-cli.test.js

@@ -0,0 +1,23 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { runCommunityDesensitizationRedTeamCli, } from "./community-desensitization-red-team-cli.js";
+describe("community desensitization red-team cli", () => {
+    it("writes a report artifact that the hub evidence builder can consume", async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "qlogic-desensitization-redteam-"));
+        const out = path.join(dir, "desensitization.json");
+        const log = { info: vi.fn(), error: vi.fn() };
+        const code = await runCommunityDesensitizationRedTeamCli(["--out", out], { log });
+        expect(code).toBe(0);
+        const report = JSON.parse(fs.readFileSync(out, "utf8"));
+        expect(report).toMatchObject({
+            suite: "desensitization",
+            passed: true,
+            failures: 0,
+        });
+        expect(report.cases).toBeGreaterThanOrEqual(500);
+        expect(log.info).toHaveBeenCalledWith(`Community desensitization red-team report written: ${out}`);
+        fs.rmSync(dir, { recursive: true, force: true });
+    });
+});

package/dist/runtime/community/community-desensitization.d.ts

@@ -0,0 +1,29 @@
+export type CommunityDesensitizationRuleId = "sensitive-email" | "sensitive-secret" | "sensitive-path" | "sensitive-phone";
+export interface CommunityDesensitizationHit {
+    reason: string;
+    ruleId: CommunityDesensitizationRuleId;
+}
+export interface CommunityDesensitizationRedTeamCase {
+    id: string;
+    content: string;
+    expectedRuleId: CommunityDesensitizationRuleId;
+}
+export interface CommunityDesensitizationRedTeamReport {
+    suite: "desensitization";
+    generatedAt: string;
+    cases: number;
+    passed: boolean;
+    failures: number;
+    breakdown: Record<CommunityDesensitizationRuleId, {
+        cases: number;
+        failures: number;
+    }>;
+    failureDetails: Array<{
+        id: string;
+        expectedRuleId: CommunityDesensitizationRuleId;
+        actualRuleId: CommunityDesensitizationRuleId | null;
+    }>;
+}
+export declare function detectCommunityPublishSensitiveContent(content: string): CommunityDesensitizationHit | null;
+export declare function buildCommunityDesensitizationRedTeamCases(): CommunityDesensitizationRedTeamCase[];
+export declare function runCommunityDesensitizationRedTeam(cases?: CommunityDesensitizationRedTeamCase[]): CommunityDesensitizationRedTeamReport;

package/dist/runtime/community/community-desensitization.js

@@ -0,0 +1,81 @@
+export function detectCommunityPublishSensitiveContent(content) {
+    if (/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i.test(content)) {
+        return { reason: "sensitive email", ruleId: "sensitive-email" };
+    }
+    if (/\b(?:sk-[A-Za-z0-9_-]{12,}|AKIA[0-9A-Z]{16})\b/.test(content)) {
+        return { reason: "sensitive secret", ruleId: "sensitive-secret" };
+    }
+    if (/\b(?:api[_-]?key|token|secret|password)\s*[:=]\s*['"]?[A-Za-z0-9_\-.]{8,}/i.test(content)) {
+        return { reason: "sensitive secret", ruleId: "sensitive-secret" };
+    }
+    if (/\b[A-Za-z]:\\[^\s"'`]+/.test(content) || /(?:^|\s)\/(?:Users|home|var|etc)\/[^\s"'`]+/.test(content)) {
+        return { reason: "sensitive path", ruleId: "sensitive-path" };
+    }
+    if (/\b(?:\+?\d[\d -]{8,}\d)\b/.test(content)) {
+        return { reason: "sensitive phone", ruleId: "sensitive-phone" };
+    }
+    return null;
+}
+export function buildCommunityDesensitizationRedTeamCases() {
+    const cases = [];
+    for (let i = 0; i < 125; i++) {
+        cases.push({
+            id: `email-${i}`,
+            content: `Workflow note for owner${i}@example.com with reusable triage steps.`,
+            expectedRuleId: "sensitive-email",
+        });
+        cases.push({
+            id: `secret-${i}`,
+            content: i % 2 === 0
+                ? `Use sk-${"a".repeat(12)}${i.toString().padStart(3, "0")} only locally.`
+                : `token=secretvalue${i.toString().padStart(8, "0")} should never leave device.`,
+            expectedRuleId: "sensitive-secret",
+        });
+        cases.push({
+            id: `path-${i}`,
+            content: i % 2 === 0
+                ? `Read C:\\Users\\alice\\projects\\case-${i}\\notes.md before replying.`
+                : `Inspect /Users/alice/private/case-${i}/notes.md before replying.`,
+            expectedRuleId: "sensitive-path",
+        });
+        cases.push({
+            id: `phone-${i}`,
+            content: `Call +1 555 ${String(100 + i).padStart(3, "0")} ${String(2000 + i)} after drafting.`,
+            expectedRuleId: "sensitive-phone",
+        });
+    }
+    return cases;
+}
+export function runCommunityDesensitizationRedTeam(cases = buildCommunityDesensitizationRedTeamCases()) {
+    const breakdown = createEmptyBreakdown();
+    const failureDetails = [];
+    for (const testCase of cases) {
+        breakdown[testCase.expectedRuleId].cases++;
+        const hit = detectCommunityPublishSensitiveContent(testCase.content);
+        if (hit?.ruleId !== testCase.expectedRuleId) {
+            breakdown[testCase.expectedRuleId].failures++;
+            failureDetails.push({
+                id: testCase.id,
+                expectedRuleId: testCase.expectedRuleId,
+                actualRuleId: hit?.ruleId ?? null,
+            });
+        }
+    }
+    return {
+        suite: "desensitization",
+        generatedAt: new Date().toISOString(),
+        cases: cases.length,
+        passed: failureDetails.length === 0,
+        failures: failureDetails.length,
+        breakdown,
+        failureDetails,
+    };
+}
+function createEmptyBreakdown() {
+    return {
+        "sensitive-email": { cases: 0, failures: 0 },
+        "sensitive-secret": { cases: 0, failures: 0 },
+        "sensitive-path": { cases: 0, failures: 0 },
+        "sensitive-phone": { cases: 0, failures: 0 },
+    };
+}

package/dist/runtime/community/community-desensitization.test.d.ts

@@ -0,0 +1 @@
+export {};