@dataparade/cli 0.0.1

package/dist/tests/unit/ai-enrichment/agent-orchestrator.spec.js

@@ -0,0 +1,483 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const agent_orchestrator_1 = require("../../../src/ai-enrichment/agent-orchestrator");
+const chat_completions_family_1 = require("../../../src/ai-enrichment/providers/families/chat-completions-family");
+function tpCandidate(id, componentId) {
+    return {
+        id,
+        candidateType: "third_party",
+        priority: 90,
+        componentId,
+        missingFields: [],
+        rationale: "r",
+        hints: [],
+    };
+}
+function propertyCandidate(id, componentId) {
+    return {
+        id,
+        candidateType: "node_property",
+        priority: 50,
+        componentId,
+        missingFields: ["encryption_at_rest"],
+        rationale: "r",
+        hints: [],
+    };
+}
+describe("generateAgenticProposals", () => {
+    let inferSpy;
+    beforeEach(() => {
+        inferSpy = jest
+            .spyOn(chat_completions_family_1.ChatCompletionsFamilyProvider.prototype, "infer")
+            .mockResolvedValue({ proposals: [] });
+    });
+    afterEach(() => {
+        inferSpy.mockRestore();
+    });
+    it("invokes the provider once per third-party queue item (tpAgent)", async () => {
+        const components = [
+            {
+                id: "tp_a",
+                name: "A",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { vendor: null },
+            },
+            {
+                id: "tp_b",
+                name: "B",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { vendor: null },
+            },
+        ];
+        const c1 = tpCandidate("c1", "tp_a");
+        const c2 = tpCandidate("c2", "tp_b");
+        await (0, agent_orchestrator_1.generateAgenticProposals)({ components, dataFlows: [] }, {
+            queues: [
+                {
+                    agent: "tpAgent",
+                    queue: [c1, c2],
+                    budgetTokens: 200_000,
+                    maxModelCalls: 10,
+                },
+            ],
+            droppedCandidates: [],
+        }, [c1, c2], {
+            provider: "openai",
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+            toolLoopMaxRounds: 1,
+        });
+        expect(inferSpy).toHaveBeenCalledTimes(2);
+        for (const call of inferSpy.mock.calls) {
+            const payload = JSON.parse(call[0].prompt);
+            expect(payload.candidates).toHaveLength(1);
+        }
+    });
+    it("batches propertyAgent into a single infer call", async () => {
+        const components = [
+            {
+                id: "asset_1",
+                name: "DB",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: {},
+            },
+            {
+                id: "asset_2",
+                name: "Cache",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: {},
+            },
+        ];
+        const c1 = propertyCandidate("p1", "asset_1");
+        const c2 = propertyCandidate("p2", "asset_2");
+        await (0, agent_orchestrator_1.generateAgenticProposals)({ components, dataFlows: [] }, {
+            queues: [
+                {
+                    agent: "propertyAgent",
+                    queue: [c1, c2],
+                    budgetTokens: 200_000,
+                    maxModelCalls: 10,
+                },
+            ],
+            droppedCandidates: [],
+        }, [c1, c2], {
+            provider: "openai",
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+            toolLoopMaxRounds: 1,
+        });
+        expect(inferSpy).toHaveBeenCalledTimes(1);
+        const payload = JSON.parse(inferSpy.mock.calls[0][0].prompt);
+        expect(payload.candidates).toHaveLength(2);
+    });
+    it("respects maxModelCalls limit for tpAgent provider calls", async () => {
+        const components = [
+            {
+                id: "tp_a",
+                name: "A",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { vendor: null },
+            },
+            {
+                id: "tp_b",
+                name: "B",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { vendor: null },
+            },
+            {
+                id: "tp_c",
+                name: "C",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { vendor: null },
+            },
+        ];
+        const c1 = tpCandidate("c1", "tp_a");
+        const c2 = tpCandidate("c2", "tp_b");
+        const c3 = tpCandidate("c3", "tp_c");
+        await (0, agent_orchestrator_1.generateAgenticProposals)({ components, dataFlows: [] }, {
+            queues: [
+                {
+                    agent: "tpAgent",
+                    queue: [c1, c2, c3],
+                    budgetTokens: 100_000,
+                    maxModelCalls: 2,
+                },
+            ],
+            droppedCandidates: [],
+        }, [c1, c2, c3], {
+            provider: "openai",
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+            toolLoopMaxRounds: 1,
+        });
+        expect(inferSpy).toHaveBeenCalledTimes(2);
+    });
+    it("respects budgetTokens and skips provider calls when budget is exhausted", async () => {
+        const components = [
+            {
+                id: "tp_a",
+                name: "A",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { vendor: null },
+            },
+        ];
+        const c1 = tpCandidate("c1", "tp_a");
+        await (0, agent_orchestrator_1.generateAgenticProposals)({ components, dataFlows: [] }, {
+            queues: [
+                {
+                    agent: "tpAgent",
+                    queue: [c1],
+                    budgetTokens: 1,
+                    maxModelCalls: 1,
+                },
+            ],
+            droppedCandidates: [],
+        }, [c1], {
+            provider: "openai",
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+            toolLoopMaxRounds: 1,
+        });
+        expect(inferSpy).toHaveBeenCalledTimes(0);
+    });
+    it("invokes the provider for interactionAgent when the queue is eligible", async () => {
+        const components = [
+            {
+                id: "asset_1",
+                name: "A",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: {},
+            },
+        ];
+        const interactionCandidate = {
+            id: "m1",
+            candidateType: "missing_interaction",
+            priority: 80,
+            missingFields: [],
+            rationale: "r",
+            hints: ["frontend", "backend"],
+        };
+        await (0, agent_orchestrator_1.generateAgenticProposals)({ components, dataFlows: [] }, {
+            queues: [
+                {
+                    agent: "interactionAgent",
+                    queue: [interactionCandidate],
+                    budgetTokens: 200_000,
+                    maxModelCalls: 10,
+                },
+            ],
+            droppedCandidates: [],
+        }, [interactionCandidate], {
+            provider: "openai",
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+            toolLoopMaxRounds: 1,
+        });
+        expect(inferSpy).toHaveBeenCalledTimes(1);
+    });
+    it("aggregates provider token usage across calls", async () => {
+        inferSpy.mockResolvedValue({
+            proposals: [],
+            usage: {
+                inputTokens: 100,
+                outputTokens: 25,
+                totalTokens: 125,
+                estimatedCostUsd: 0.001,
+            },
+        });
+        const components = [
+            {
+                id: "tp_a",
+                name: "A",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { vendor: null },
+            },
+            {
+                id: "tp_b",
+                name: "B",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { vendor: null },
+            },
+        ];
+        const c1 = tpCandidate("c1", "tp_a");
+        const c2 = tpCandidate("c2", "tp_b");
+        const out = await (0, agent_orchestrator_1.generateAgenticProposals)({ components, dataFlows: [] }, {
+            queues: [
+                {
+                    agent: "tpAgent",
+                    queue: [c1, c2],
+                    budgetTokens: 200_000,
+                    maxModelCalls: 10,
+                },
+            ],
+            droppedCandidates: [],
+        }, [c1, c2], {
+            provider: "openai",
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+            toolLoopMaxRounds: 1,
+        });
+        expect(out.usageSummary).toMatchObject({
+            providerCalls: 2,
+            inputTokens: 200,
+            outputTokens: 50,
+            totalTokens: 250,
+            estimatedCostUsd: 0.002,
+        });
+        expect(out.usageSummary?.agenticTrace?.length).toBe(2);
+    });
+    it("adds deterministic third-party heuristic proposals with evidence", async () => {
+        inferSpy.mockResolvedValue({ proposals: [] });
+        const components = [
+            {
+                id: "tp_stripe",
+                name: "Stripe",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [
+                    {
+                        pattern: "external_api_call",
+                        sourceLocation: {
+                            filePath: "backend/payments/index.ts",
+                            startLine: 1,
+                            endLine: 1,
+                        },
+                    },
+                ],
+                sourceLocations: [
+                    { filePath: "backend/payments/index.ts", startLine: 1, endLine: 1 },
+                ],
+                properties: {
+                    section_id: "backend/payments",
+                    vendor: null,
+                    api_type: null,
+                    authentication_method: null,
+                    integration_method: [],
+                },
+            },
+        ];
+        const out = await (0, agent_orchestrator_1.generateAgenticProposals)({
+            components,
+            dataFlows: [],
+            files: [
+                {
+                    path: "backend/payments/index.ts",
+                    name: "index.ts",
+                    language: "typescript",
+                    size: 180,
+                    content: [
+                        'import Stripe from "stripe";',
+                        'await fetch("https://api.stripe.com/v1/customers", {',
+                        "  headers: { Authorization: `Bearer ${process.env.STRIPE_API_KEY}` },",
+                        "});",
+                    ].join("\n"),
+                },
+                {
+                    path: "backend/payments/package.json",
+                    name: "package.json",
+                    language: "json",
+                    size: 60,
+                    content: JSON.stringify({ dependencies: { stripe: "^17.0.0" } }),
+                },
+            ],
+        }, {
+            queues: [
+                {
+                    agent: "tpAgent",
+                    queue: [tpCandidate("c1", "tp_stripe")],
+                    budgetTokens: 200_000,
+                    maxModelCalls: 1,
+                },
+            ],
+            droppedCandidates: [],
+        }, [tpCandidate("c1", "tp_stripe")], {
+            provider: "openai",
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+            toolLoopMaxRounds: 1,
+        });
+        const heuristic = out.proposals.find((item) => item.id.startsWith("heuristic_"));
+        expect(heuristic).toBeDefined();
+        expect(heuristic?.proposal.kind).toBe("component_patch");
+        if (heuristic?.proposal.kind === "component_patch") {
+            expect(Object.keys(heuristic.proposal.setProperties).length).toBeGreaterThan(0);
+            expect(heuristic.proposal.evidence.length).toBeGreaterThan(0);
+            expect(heuristic.proposal.provider).toBe("mock");
+            expect(heuristic.proposal.agent).toBe("tpAgent");
+        }
+    });
+    it("persists agentic trace for tp tool loop runs", async () => {
+        inferSpy.mockResolvedValue({ proposals: [] });
+        const components = [
+            {
+                id: "tp_trace",
+                name: "Stripe",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [{ filePath: "src/payments.ts", startLine: 1, endLine: 1 }],
+                properties: { vendor: null },
+            },
+        ];
+        const out = await (0, agent_orchestrator_1.generateAgenticProposals)({
+            components,
+            dataFlows: [],
+            files: [
+                {
+                    path: "src/payments.ts",
+                    name: "payments.ts",
+                    language: "typescript",
+                    size: 64,
+                    content: 'import x from "./client";\nexport const payments = true;',
+                },
+            ],
+        }, {
+            queues: [
+                {
+                    agent: "tpAgent",
+                    queue: [tpCandidate("c_trace", "tp_trace")],
+                    budgetTokens: 100_000,
+                    maxModelCalls: 1,
+                },
+            ],
+            droppedCandidates: [],
+        }, [tpCandidate("c_trace", "tp_trace")], {
+            provider: "openai",
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+            toolLoopMaxRounds: 1,
+        });
+        expect(out.usageSummary?.agenticTrace).toBeDefined();
+        expect(out.usageSummary?.agenticTrace?.length).toBe(1);
+        expect(out.usageSummary?.agenticTrace?.[0]?.toolCalls.length).toBeGreaterThan(0);
+    });
+    it("deduplicates repeated search hits and prefers unseen files", async () => {
+        inferSpy.mockResolvedValue({ proposals: [] });
+        const components = [
+            {
+                id: "tp_search_dedupe",
+                name: "Supabase",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [{ filePath: "src/a.ts", startLine: 1, endLine: 1 }],
+                properties: { vendor: null, section_id: "src" },
+            },
+        ];
+        const out = await (0, agent_orchestrator_1.generateAgenticProposals)({
+            components,
+            dataFlows: [],
+            files: [
+                {
+                    path: "src/a.ts",
+                    name: "a.ts",
+                    language: "typescript",
+                    size: 200,
+                    content: "const one = 'supabase';\nconst two = 'supabase';\nconst three = 'supabase';\n",
+                },
+                {
+                    path: "src/b.ts",
+                    name: "b.ts",
+                    language: "typescript",
+                    size: 120,
+                    content: "const other = 'supabase';\n",
+                },
+            ],
+        }, {
+            queues: [
+                {
+                    agent: "tpAgent",
+                    queue: [tpCandidate("c_search_dedupe", "tp_search_dedupe")],
+                    budgetTokens: 100_000,
+                    maxModelCalls: 1,
+                },
+            ],
+            droppedCandidates: [],
+        }, [tpCandidate("c_search_dedupe", "tp_search_dedupe")], {
+            provider: "openai",
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+            toolLoopMaxRounds: 1,
+        });
+        const trace = out.usageSummary?.agenticTrace?.[0];
+        expect(trace).toBeDefined();
+        const searchCall = trace?.toolCalls.find((step) => step.action === "search_text");
+        expect(searchCall).toBeDefined();
+        const touched = searchCall?.filesTouched ?? [];
+        expect(new Set(touched).size).toBe(touched.length);
+        expect(touched).toContain("src/b.ts");
+    });
+});

package/dist/tests/unit/ai-enrichment/candidate-selector.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/candidate-selector.spec.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const candidate_selector_1 = require("../../../src/ai-enrichment/candidate-selector");
+describe("ai-enrichment candidate selector", () => {
+    it("selects third-party, sparse property, flow direction, and missing interaction candidates", () => {
+        const sections = [
+            {
+                id: "frontend",
+                label: "frontend",
+                role: "service",
+                sectionDir: "frontend",
+                manifestPaths: ["frontend/package.json"],
+            },
+            {
+                id: "backend",
+                label: "backend",
+                role: "service",
+                sectionDir: "backend",
+                manifestPaths: ["backend/package.json"],
+            },
+        ];
+        const components = [
+            {
+                id: "tp_1",
+                name: "Stripe",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { section_id: "backend", dpa_signed: null },
+            },
+            {
+                id: "app_1",
+                name: "Backend",
+                type: "asset",
+                confidence: 0.95,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { section_id: "backend", encryption_at_rest: null },
+            },
+            {
+                id: "actor_1",
+                name: "Customer",
+                type: "actor",
+                confidence: 0.7,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { section_id: "frontend" },
+            },
+        ];
+        const flows = [
+            {
+                id: "flow_1",
+                sourceComponentId: "app_1",
+                targetComponentId: "actor_1",
+                type: "api_call",
+                confidence: 0.6,
+            },
+        ];
+        const candidates = (0, candidate_selector_1.selectInferenceCandidates)({ components, dataFlows: flows, sections });
+        const candidateTypes = candidates.map((candidate) => candidate.candidateType);
+        expect(candidateTypes).toContain("third_party");
+        expect(candidateTypes).toContain("node_property");
+        expect(candidateTypes).toContain("flow_direction");
+        expect(candidateTypes).toContain("missing_interaction");
+    });
+    it("third_party_only returns one third_party candidate per third-party and skips assets", () => {
+        const components = [
+            {
+                id: "tp_a",
+                name: "Stripe",
+                type: "third_party",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { section_id: "backend", subType: "payments" },
+            },
+            {
+                id: "tp_b",
+                name: "Sentry",
+                type: "third_party",
+                confidence: 0.85,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { section_id: "backend" },
+            },
+            {
+                id: "app_1",
+                name: "API",
+                type: "asset",
+                confidence: 0.95,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { section_id: "backend", encryption_at_rest: null },
+            },
+        ];
+        const candidates = (0, candidate_selector_1.selectInferenceCandidates)({
+            components,
+            dataFlows: [],
+            inferenceScope: "third_party_only",
+        });
+        expect(candidates).toHaveLength(2);
+        expect(candidates.every((c) => c.candidateType === "third_party")).toBe(true);
+        expect(new Set(candidates.map((c) => c.componentId))).toEqual(new Set(["tp_a", "tp_b"]));
+    });
+});

package/dist/tests/unit/ai-enrichment/create-ai-provider.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/create-ai-provider.spec.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const providers_1 = require("../../../src/ai-enrichment/providers");
+const chat_completions_family_1 = require("../../../src/ai-enrichment/providers/families/chat-completions-family");
+const messages_family_1 = require("../../../src/ai-enrichment/providers/families/messages-family");
+const generate_content_family_1 = require("../../../src/ai-enrichment/providers/families/generate-content-family");
+const ollama_generate_family_1 = require("../../../src/ai-enrichment/providers/families/ollama-generate-family");
+const mock_1 = require("../../../src/ai-enrichment/providers/mock");
+describe("createAiProvider", () => {
+    it("returns chat-completions family for openai preset", () => {
+        expect((0, providers_1.createAiProvider)("openai")).toBeInstanceOf(chat_completions_family_1.ChatCompletionsFamilyProvider);
+        expect((0, providers_1.createAiProvider)("openai").id).toBe("openai");
+    });
+    it("returns chat-completions family for openrouter preset", () => {
+        const p = (0, providers_1.createAiProvider)("openrouter");
+        expect(p).toBeInstanceOf(chat_completions_family_1.ChatCompletionsFamilyProvider);
+        expect(p.id).toBe("openrouter");
+    });
+    it("returns messages family for anthropic preset", () => {
+        expect((0, providers_1.createAiProvider)("anthropic")).toBeInstanceOf(messages_family_1.MessagesFamilyProvider);
+    });
+    it("returns generate-content family for gemini preset", () => {
+        expect((0, providers_1.createAiProvider)("gemini")).toBeInstanceOf(generate_content_family_1.GenerateContentFamilyProvider);
+    });
+    it("returns ollama-generate family for local preset", () => {
+        expect((0, providers_1.createAiProvider)("local")).toBeInstanceOf(ollama_generate_family_1.OllamaGenerateFamilyProvider);
+    });
+    it("returns mock for mock preset and unknown ids", () => {
+        expect((0, providers_1.createAiProvider)("mock")).toBeInstanceOf(mock_1.MockAiProvider);
+        expect((0, providers_1.createAiProvider)("not-a-vendor")).toBeInstanceOf(mock_1.MockAiProvider);
+    });
+});

package/dist/tests/unit/ai-enrichment/endpoint-resolution.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/endpoint-resolution.spec.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const endpoint_resolution_1 = require("../../../src/ai-enrichment/providers/endpoint-resolution");
+const presets_1 = require("../../../src/ai-enrichment/providers/presets");
+describe("endpoint-resolution", () => {
+    const openaiDefault = presets_1.AI_PROVIDER_PRESETS.openai.defaultEndpoint;
+    const geminiDefault = presets_1.AI_PROVIDER_PRESETS.gemini.defaultEndpoint;
+    describe("resolveChatCompletionsEndpoint", () => {
+        it("uses preset default when endpoint is empty", () => {
+            expect((0, endpoint_resolution_1.resolveChatCompletionsEndpoint)(undefined, openaiDefault)).toBe(openaiDefault);
+            expect((0, endpoint_resolution_1.resolveChatCompletionsEndpoint)("", openaiDefault)).toBe(openaiDefault);
+        });
+        it("rewrites bare api.openai.com host to preset default", () => {
+            expect((0, endpoint_resolution_1.resolveChatCompletionsEndpoint)("https://api.openai.com", openaiDefault)).toBe(openaiDefault);
+        });
+        it("keeps explicit chat/completions URLs", () => {
+            const custom = "https://proxy.example/v1/chat/completions";
+            expect((0, endpoint_resolution_1.resolveChatCompletionsEndpoint)(custom, openaiDefault)).toBe(custom);
+        });
+        it("keeps non-OpenAI custom gateways unchanged", () => {
+            const groq = "https://api.groq.com/openai/v1/chat/completions";
+            expect((0, endpoint_resolution_1.resolveChatCompletionsEndpoint)(groq, openaiDefault)).toBe(groq);
+        });
+    });
+    describe("shouldUseChatCompletionsJsonShim", () => {
+        it("returns false for chat/completions URLs", () => {
+            expect((0, endpoint_resolution_1.shouldUseChatCompletionsJsonShim)(openaiDefault)).toBe(false);
+        });
+        it("returns true for legacy shim gateways", () => {
+            expect((0, endpoint_resolution_1.shouldUseChatCompletionsJsonShim)("https://custom.gateway/infer")).toBe(true);
+        });
+    });
+    describe("resolveGeminiGenerateContentEndpoint", () => {
+        it("builds URL from preset base and model", () => {
+            const url = (0, endpoint_resolution_1.resolveGeminiGenerateContentEndpoint)(undefined, "gemini-1.5-flash", geminiDefault);
+            expect(url).toBe("https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent");
+        });
+        it("appends model to base ending in /models", () => {
+            const url = (0, endpoint_resolution_1.resolveGeminiGenerateContentEndpoint)(geminiDefault, "gemini-pro", geminiDefault);
+            expect(url).toContain("/models/gemini-pro:generateContent");
+        });
+        it("returns full URL when :generateContent already present", () => {
+            const full = "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent";
+            expect((0, endpoint_resolution_1.resolveGeminiGenerateContentEndpoint)(full, "ignored", geminiDefault)).toBe(full);
+        });
+    });
+});

package/dist/tests/unit/ai-enrichment/fallbacks.spec.d.ts

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