@dataparade/cli 0.0.1

package/dist/tests/unit/ai-enrichment/families/chat-completions-family.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/families/chat-completions-family.spec.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chat_completions_family_1 = require("../../../../src/ai-enrichment/providers/families/chat-completions-family");
+const resolve_provider_1 = require("../../../../src/ai-enrichment/providers/resolve-provider");
+describe("ChatCompletionsFamilyProvider", () => {
+    const originalFetch = global.fetch;
+    const originalJsonSchema = process.env.DATAPARADE_AI_OPENAI_JSON_SCHEMA;
+    function provider() {
+        return new chat_completions_family_1.ChatCompletionsFamilyProvider((0, resolve_provider_1.resolveProviderConfig)("openai"));
+    }
+    afterEach(() => {
+        global.fetch = originalFetch;
+        if (originalJsonSchema === undefined) {
+            delete process.env.DATAPARADE_AI_OPENAI_JSON_SCHEMA;
+        }
+        else {
+            process.env.DATAPARADE_AI_OPENAI_JSON_SCHEMA = originalJsonSchema;
+        }
+        jest.restoreAllMocks();
+    });
+    it("returns [] without API key", async () => {
+        const p = provider();
+        await expect(p.infer({
+            prompt: "{}",
+            model: "gpt-4o-mini",
+        })).resolves.toEqual({ proposals: [] });
+    });
+    it("calls OpenRouter chat/completions endpoint for openrouter preset", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                choices: [{ message: { content: JSON.stringify({ proposals: [] }) } }],
+            }),
+        });
+        const p = new chat_completions_family_1.ChatCompletionsFamilyProvider((0, resolve_provider_1.resolveProviderConfig)("openrouter"));
+        await p.infer({
+            prompt: "{}",
+            model: "openai/gpt-4o-mini",
+            apiKey: "sk-or-test",
+        });
+        const [url] = global.fetch.mock.calls[0];
+        expect(url).toBe("https://openrouter.ai/api/v1/chat/completions");
+        const [, reqInit] = global.fetch.mock.calls[0];
+        const body = JSON.parse(reqInit.body);
+        expect(body.model).toBe("openai/gpt-4o-mini");
+    });
+    it("uses apiKey from resolved config when request omits it", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                choices: [{ message: { content: JSON.stringify({ proposals: [] }) } }],
+            }),
+        });
+        const p = new chat_completions_family_1.ChatCompletionsFamilyProvider((0, resolve_provider_1.resolveProviderConfig)("openai", { apiKey: "sk-from-config" }));
+        await p.infer({
+            prompt: "{}",
+            model: "gpt-4o-mini",
+        });
+        const [, reqInit] = global.fetch.mock.calls[0];
+        expect(reqInit.headers).toMatchObject({
+            authorization: "Bearer sk-from-config",
+        });
+    });
+    it("parses chat completions JSON and normalizes proposals", async () => {
+        const proposals = [
+            {
+                kind: "component_patch",
+                targetComponentId: "tp_1",
+                candidateType: "third_party",
+                setProperties: { integration_method: ["sdk"] },
+                propertyEvidence: {
+                    integration_method: [
+                        {
+                            filePath: "package.json",
+                            startLine: 1,
+                            endLine: 5,
+                            reason: "dependency declaration",
+                        },
+                    ],
+                },
+                confidence: { score: 0.85, band: "high" },
+            },
+        ];
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                choices: [
+                    {
+                        message: {
+                            content: JSON.stringify({ proposals }),
+                        },
+                    },
+                ],
+            }),
+        });
+        const p = provider();
+        const out = await p.infer({
+            prompt: JSON.stringify({ agent: "tpAgent", candidates: [] }),
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+        });
+        expect(global.fetch).toHaveBeenCalled();
+        const [, reqInit] = global.fetch.mock.calls[0];
+        const url = global.fetch.mock.calls[0][0];
+        expect(url).toContain("chat/completions");
+        const parsedBody = JSON.parse(reqInit.body);
+        expect(parsedBody.response_format?.type).toBe("json_schema");
+        expect(parsedBody.response_format?.json_schema?.name).toBe("dataparade_proposals");
+        expect(out.proposals).toHaveLength(1);
+        expect(out.proposals[0]?.kind).toBe("component_patch");
+        if (out.proposals[0]?.kind === "component_patch") {
+            expect(out.proposals[0].targetComponentId).toBe("tp_1");
+            expect(out.proposals[0].provider).toBe("openai");
+            expect(out.proposals[0].model).toBe("gpt-4o-mini");
+            expect(out.proposals[0].agent).toBe("tpAgent");
+        }
+    });
+    it("drops proposals with no evidence", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                choices: [
+                    {
+                        message: {
+                            content: JSON.stringify({
+                                proposals: [
+                                    {
+                                        kind: "component_patch",
+                                        targetComponentId: "x",
+                                        candidateType: "third_party",
+                                        setProperties: { a: 1 },
+                                        propertyEvidence: {},
+                                        confidence: { score: 0.9, band: "high" },
+                                    },
+                                ],
+                            }),
+                        },
+                    },
+                ],
+            }),
+        });
+        const p = provider();
+        const out = await p.infer({
+            prompt: "{}",
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+        });
+        expect(out).toEqual({ proposals: [] });
+    });
+    it("drops placeholder-only setProperties from provider output", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                choices: [
+                    {
+                        message: {
+                            content: JSON.stringify({
+                                proposals: [
+                                    {
+                                        kind: "component_patch",
+                                        targetComponentId: "x",
+                                        candidateType: "node_property",
+                                        setProperties: {
+                                            inference_status: "needs_review",
+                                            access_controls_for_delivery: null,
+                                            api_versioning_strategy: "none",
+                                            cloud_services_used: [],
+                                        },
+                                        propertyEvidence: {},
+                                        confidence: { score: 0.9, band: "high" },
+                                    },
+                                ],
+                            }),
+                        },
+                    },
+                ],
+            }),
+        });
+        const p = provider();
+        const out = await p.infer({
+            prompt: "{}",
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+        });
+        expect(out).toEqual({ proposals: [] });
+    });
+    it("uses json_object when DATAPARADE_AI_OPENAI_JSON_SCHEMA=0", async () => {
+        process.env.DATAPARADE_AI_OPENAI_JSON_SCHEMA = "0";
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                choices: [{ message: { content: JSON.stringify({ proposals: [] }) } }],
+            }),
+        });
+        const p = provider();
+        await p.infer({
+            prompt: "{}",
+            model: "gpt-4o-mini",
+            apiKey: "sk-test",
+        });
+        const [, reqInit] = global.fetch.mock.calls[0];
+        const parsedBody = JSON.parse(reqInit.body);
+        expect(parsedBody.response_format?.type).toBe("json_object");
+    });
+    it("returns [] on HTTP error", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: false,
+            status: 401,
+            text: async () => '{"error":{"message":"invalid"}}',
+        });
+        const p = provider();
+        const out = await p.infer({
+            prompt: "{}",
+            model: "gpt-4o-mini",
+            apiKey: "sk-bad",
+        });
+        expect(out).toEqual({ proposals: [] });
+    });
+});

package/dist/tests/unit/ai-enrichment/families/generate-content-family.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/families/generate-content-family.spec.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generate_content_family_1 = require("../../../../src/ai-enrichment/providers/families/generate-content-family");
+const resolve_provider_1 = require("../../../../src/ai-enrichment/providers/resolve-provider");
+describe("GenerateContentFamilyProvider", () => {
+    const originalFetch = global.fetch;
+    afterEach(() => {
+        global.fetch = originalFetch;
+        jest.restoreAllMocks();
+    });
+    it("does not call fetch when query-key auth has no API key", async () => {
+        global.fetch = jest.fn();
+        const provider = new generate_content_family_1.GenerateContentFamilyProvider((0, resolve_provider_1.resolveProviderConfig)("gemini"));
+        const out = await provider.infer({
+            prompt: "{}",
+            model: "gemini-1.5-flash",
+        });
+        expect(global.fetch).not.toHaveBeenCalled();
+        expect(out).toEqual({ proposals: [] });
+    });
+    it("uses apiKey from resolved config when request omits it", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                candidates: [
+                    {
+                        content: {
+                            parts: [{ text: JSON.stringify({ proposals: [] }) }],
+                        },
+                    },
+                ],
+            }),
+        });
+        const provider = new generate_content_family_1.GenerateContentFamilyProvider((0, resolve_provider_1.resolveProviderConfig)("gemini", { apiKey: "gem-from-config" }));
+        await provider.infer({
+            prompt: "{}",
+            model: "gemini-1.5-flash",
+        });
+        const [url] = global.fetch.mock.calls[0];
+        expect(url).toContain("key=gem-from-config");
+    });
+    it("calls generateContent endpoint and normalizes proposals", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                candidates: [
+                    {
+                        content: {
+                            parts: [
+                                {
+                                    text: JSON.stringify({
+                                        proposals: [
+                                            {
+                                                kind: "component_patch",
+                                                targetComponentId: "tp_1",
+                                                candidateType: "third_party",
+                                                setProperties: { integration_method: ["api"] },
+                                                propertyEvidence: {
+                                                    integration_method: [
+                                                        {
+                                                            filePath: "src/index.ts",
+                                                            startLine: 10,
+                                                            endLine: 20,
+                                                            reason: "api usage",
+                                                        },
+                                                    ],
+                                                },
+                                                confidence: { score: 0.82, band: "high" },
+                                            },
+                                        ],
+                                    }),
+                                },
+                            ],
+                        },
+                    },
+                ],
+            }),
+        });
+        const provider = new generate_content_family_1.GenerateContentFamilyProvider((0, resolve_provider_1.resolveProviderConfig)("gemini"));
+        const out = await provider.infer({
+            prompt: JSON.stringify({ agent: "tpAgent", candidates: [] }),
+            model: "gemini-1.5-flash",
+            apiKey: "gem-key",
+        });
+        expect(global.fetch).toHaveBeenCalledTimes(1);
+        const [url, reqInit] = global.fetch.mock.calls[0];
+        expect(url).toContain("/models/gemini-1.5-flash:generateContent");
+        expect(url).toContain("key=gem-key");
+        expect(reqInit.method).toBe("POST");
+        expect(out.proposals).toHaveLength(1);
+        expect(out.proposals[0]?.kind).toBe("component_patch");
+        if (out.proposals[0]?.kind === "component_patch") {
+            expect(out.proposals[0].provider).toBe("gemini");
+            expect(out.proposals[0].model).toBe("gemini-1.5-flash");
+            expect(out.proposals[0].agent).toBe("tpAgent");
+        }
+    });
+    it("returns [] when provider response is not parseable JSON proposals", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                candidates: [
+                    {
+                        content: {
+                            parts: [{ text: "not-json" }],
+                        },
+                    },
+                ],
+            }),
+        });
+        const provider = new generate_content_family_1.GenerateContentFamilyProvider((0, resolve_provider_1.resolveProviderConfig)("gemini"));
+        const out = await provider.infer({
+            prompt: "{}",
+            model: "gemini-1.5-flash",
+            apiKey: "gem-key",
+        });
+        expect(out).toEqual({ proposals: [] });
+    });
+});

package/dist/tests/unit/ai-enrichment/families/messages-family.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/families/messages-family.spec.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const messages_family_1 = require("../../../../src/ai-enrichment/providers/families/messages-family");
+const resolve_provider_1 = require("../../../../src/ai-enrichment/providers/resolve-provider");
+describe("MessagesFamilyProvider", () => {
+    const originalFetch = global.fetch;
+    function provider() {
+        return new messages_family_1.MessagesFamilyProvider((0, resolve_provider_1.resolveProviderConfig)("anthropic"));
+    }
+    afterEach(() => {
+        global.fetch = originalFetch;
+        jest.restoreAllMocks();
+    });
+    it("returns [] without API key", async () => {
+        const p = provider();
+        await expect(p.infer({
+            prompt: "{}",
+            model: "claude-sonnet-4-6",
+        })).resolves.toEqual({ proposals: [] });
+    });
+    it("uses apiKey from resolved config when request omits it", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                content: [{ type: "text", text: '{"proposals":[]}' }],
+            }),
+        });
+        const p = new messages_family_1.MessagesFamilyProvider((0, resolve_provider_1.resolveProviderConfig)("anthropic", { apiKey: "sk-ant-config" }));
+        await p.infer({
+            prompt: "{}",
+            model: "claude-sonnet-4-6",
+        });
+        const [, reqInit] = global.fetch.mock.calls[0];
+        expect(reqInit.headers).toMatchObject({
+            "x-api-key": "sk-ant-config",
+        });
+    });
+    it("calls Anthropic messages API and normalizes proposals", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            proposals: [
+                                {
+                                    kind: "component_patch",
+                                    targetComponentId: "tp_1",
+                                    candidateType: "third_party",
+                                    setProperties: { integration_method: ["sdk"] },
+                                    propertyEvidence: {
+                                        integration_method: [
+                                            {
+                                                filePath: "package.json",
+                                                startLine: 1,
+                                                endLine: 3,
+                                                reason: "dependency declaration",
+                                            },
+                                        ],
+                                    },
+                                    confidence: { score: 0.85, band: "high" },
+                                },
+                            ],
+                        }),
+                    },
+                ],
+            }),
+        });
+        const p = provider();
+        const out = await p.infer({
+            prompt: JSON.stringify({ agent: "tpAgent", candidates: [] }),
+            model: "claude-sonnet-4-6",
+            apiKey: "sk-ant-test",
+        });
+        expect(global.fetch).toHaveBeenCalledTimes(1);
+        const [url, reqInit] = global.fetch.mock.calls[0];
+        expect(url).toContain("/v1/messages");
+        expect(reqInit.headers).toMatchObject({
+            "content-type": "application/json",
+            "x-api-key": "sk-ant-test",
+            "anthropic-version": "2023-06-01",
+        });
+        const body = JSON.parse(String(global.fetch.mock.calls[0][1]?.body));
+        expect(body.max_tokens).toBeGreaterThanOrEqual(4096);
+        expect(String(body.system)).toContain("Output discipline");
+        expect(out.proposals).toHaveLength(1);
+        expect(out.proposals[0]?.kind).toBe("component_patch");
+        if (out.proposals[0]?.kind === "component_patch") {
+            expect(out.proposals[0].provider).toBe("anthropic");
+            expect(out.proposals[0].model).toBe("claude-sonnet-4-6");
+            expect(out.proposals[0].agent).toBe("tpAgent");
+            expect(out.proposals[0].targetComponentId).toBe("tp_1");
+        }
+    });
+    it("clamps max_tokens when DATAPARADE_AI_MAX_TOKENS is very low", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                content: [{ type: "text", text: '{"proposals":[]}' }],
+                stop_reason: "end_turn",
+                usage: { input_tokens: 10, output_tokens: 5 },
+            }),
+        });
+        const p = provider();
+        await p.infer({
+            prompt: "{}",
+            model: "claude-sonnet-4-6",
+            apiKey: "sk-ant-test",
+            maxTokens: 200,
+        });
+        const body = JSON.parse(String(global.fetch.mock.calls[0][1]?.body));
+        expect(body.max_tokens).toBe(4096);
+    });
+    it("returns [] on HTTP error", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: false,
+            status: 401,
+            text: async () => '{"error":{"message":"invalid"}}',
+        });
+        const p = provider();
+        const out = await p.infer({
+            prompt: "{}",
+            model: "claude-sonnet-4-6",
+            apiKey: "sk-ant-bad",
+        });
+        expect(out).toEqual({ proposals: [] });
+    });
+});

package/dist/tests/unit/ai-enrichment/families/ollama-generate-family.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/families/ollama-generate-family.spec.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ollama_generate_family_1 = require("../../../../src/ai-enrichment/providers/families/ollama-generate-family");
+const resolve_provider_1 = require("../../../../src/ai-enrichment/providers/resolve-provider");
+describe("OllamaGenerateFamilyProvider", () => {
+    const originalFetch = global.fetch;
+    afterEach(() => {
+        global.fetch = originalFetch;
+        jest.restoreAllMocks();
+    });
+    it("calls Ollama /api/generate and normalizes proposals", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                response: JSON.stringify({
+                    proposals: [
+                        {
+                            kind: "component_patch",
+                            targetComponentId: "tp_1",
+                            candidateType: "third_party",
+                            setProperties: { integration_method: ["sdk"] },
+                            propertyEvidence: {
+                                integration_method: [
+                                    {
+                                        filePath: "package.json",
+                                        startLine: 1,
+                                        endLine: 4,
+                                        reason: "dependency",
+                                    },
+                                ],
+                            },
+                            confidence: { score: 0.8, band: "high" },
+                        },
+                    ],
+                }),
+            }),
+        });
+        const provider = new ollama_generate_family_1.OllamaGenerateFamilyProvider((0, resolve_provider_1.resolveProviderConfig)("local"));
+        const out = await provider.infer({
+            prompt: JSON.stringify({ agent: "tpAgent", candidates: [] }),
+            model: "llama3.1",
+        });
+        expect(global.fetch).toHaveBeenCalledTimes(1);
+        const [url, reqInit] = global.fetch.mock.calls[0];
+        expect(url).toBe("http://localhost:11434/api/generate");
+        const parsed = JSON.parse(reqInit.body);
+        expect(parsed.stream).toBe(false);
+        expect(parsed.options?.num_predict).toBeDefined();
+        expect(parsed.prompt).toContain("You are enriching a DataParade data-flow scan.");
+        expect(out.proposals).toHaveLength(1);
+        expect(out.proposals[0]?.kind).toBe("component_patch");
+        if (out.proposals[0]?.kind === "component_patch") {
+            expect(out.proposals[0].provider).toBe("local");
+            expect(out.proposals[0].agent).toBe("tpAgent");
+        }
+    });
+    it("returns [] for invalid local JSON output", async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({ response: "{invalid" }),
+        });
+        const provider = new ollama_generate_family_1.OllamaGenerateFamilyProvider((0, resolve_provider_1.resolveProviderConfig)("local"));
+        const out = await provider.infer({
+            prompt: "{}",
+            model: "llama3.1",
+        });
+        expect(out).toEqual({ proposals: [] });
+    });
+});

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

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