@dataparade/cli 0.0.1

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const platform_proxy_provider_1 = require("../../../src/ai-enrichment/providers/platform-proxy-provider");
+describe("PlatformProxyProvider", () => {
+    const originalFetch = global.fetch;
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+    it("submits a task and polls until completed", async () => {
+        const calls = [];
+        global.fetch = jest.fn(async (input, init) => {
+            const url = String(input);
+            const method = init?.method ?? "GET";
+            calls.push({ url, method });
+            if (url.endsWith("/api/scans/cli/ai/infer/tasks") && method === "POST") {
+                return new Response(JSON.stringify({
+                    tasks: [{ taskId: "t-1", status: "pending" }],
+                }), { status: 202 });
+            }
+            if (url.includes("/api/scans/cli/ai/infer/tasks?") && method === "GET") {
+                const done = calls.filter((c) => c.method === "GET").length >= 2;
+                return new Response(JSON.stringify({
+                    tasks: [
+                        {
+                            taskId: "t-1",
+                            status: done ? "completed" : "running",
+                            proposals: [{ kind: "setProperties", candidateType: "component" }],
+                            usage: { inputTokens: 1, outputTokens: 2, totalTokens: 3 },
+                        },
+                    ],
+                }), { status: 200 });
+            }
+            return new Response("not found", { status: 404 });
+        });
+        const provider = new platform_proxy_provider_1.PlatformProxyProvider({
+            apiBaseUrl: "https://api.example.com",
+            workspaceApiKey: "dp_test",
+            jobId: "job-1",
+            pollIntervalMs: 1,
+            pollTimeoutMs: 5000,
+        });
+        const result = await provider.infer({
+            prompt: "test",
+            model: "gpt-4o-mini",
+        });
+        expect(result.proposals).toHaveLength(1);
+        expect(result.usage?.totalTokens).toBe(3);
+        expect(calls.some((c) => c.method === "POST")).toBe(true);
+        expect(calls.filter((c) => c.method === "GET").length).toBeGreaterThanOrEqual(1);
+    });
+});

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

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

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

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_contract_1 = require("../../../src/ai-enrichment/providers/provider-contract");
+describe("strictParseAndNormalizeProposals / propertyEvidence", () => {
+    const defaults = {
+        provider: "openai",
+        model: "gpt-4o-mini",
+        agent: "propertyAgent",
+    };
+    const basePatch = {
+        kind: "component_patch",
+        targetComponentId: "c1",
+        candidateType: "third_party",
+        setProperties: { flag: true },
+        confidence: { score: 0.9, band: "high" },
+        propertyEvidence: {
+            flag: [
+                {
+                    filePath: "a.ts",
+                    startLine: 1,
+                    endLine: 1,
+                    reason: "literal true in source",
+                },
+            ],
+        },
+    };
+    it("clamps line range to excerpt length instead of dropping the property", () => {
+        const raw = {
+            proposals: [
+                {
+                    ...basePatch,
+                    propertyEvidence: {
+                        flag: [
+                            {
+                                filePath: "a.ts",
+                                startLine: 1,
+                                endLine: 99,
+                                reason: "model overshot endLine",
+                            },
+                        ],
+                    },
+                },
+            ],
+        };
+        const userPrompt = JSON.stringify({
+            relevantFileContents: { "a.ts": "only one line" },
+            componentContext: {
+                c1: {
+                    detectedFrom: [{ filePath: "a.ts", pattern: "p" }],
+                    sourceLocations: [],
+                },
+            },
+        });
+        const out = (0, provider_contract_1.strictParseAndNormalizeProposals)(raw, defaults, {
+            debugLabel: "test",
+            userPrompt,
+        });
+        expect(out).toHaveLength(1);
+        if (out[0]?.kind === "component_patch") {
+            expect(out[0].propertyEvidence?.flag?.[0]?.endLine).toBe(1);
+        }
+    });
+    it("keeps a property when line range fits the excerpt", () => {
+        const raw = { proposals: [basePatch] };
+        const userPrompt = JSON.stringify({
+            relevantFileContents: { "a.ts": "only one line" },
+            componentContext: {
+                c1: {
+                    detectedFrom: [{ filePath: "a.ts", pattern: "p" }],
+                    sourceLocations: [],
+                },
+            },
+        });
+        const out = (0, provider_contract_1.strictParseAndNormalizeProposals)(raw, defaults, {
+            debugLabel: "test",
+            userPrompt,
+        });
+        expect(out).toHaveLength(1);
+        if (out[0]?.kind === "component_patch") {
+            expect(out[0].setProperties.flag).toBe(true);
+            expect(out[0].propertyEvidence?.flag).toHaveLength(1);
+        }
+    });
+    it("accepts evidence file basename when it matches an excerpt/component path basename", () => {
+        const raw = { proposals: [basePatch] };
+        const userPrompt = JSON.stringify({
+            relevantFileContents: { "backend/lambdas/create-db/index.js": "line1\nline2\n" },
+            componentContext: {
+                c1: {
+                    detectedFrom: [
+                        { filePath: "backend/lambdas/create-db/index.js", pattern: "p" },
+                    ],
+                    sourceLocations: [],
+                },
+            },
+        });
+        const patch = {
+            ...basePatch,
+            propertyEvidence: {
+                flag: [
+                    {
+                        filePath: "index.js",
+                        startLine: 1,
+                        endLine: 2,
+                        reason: "basename only",
+                    },
+                ],
+            },
+        };
+        const out = (0, provider_contract_1.strictParseAndNormalizeProposals)({ proposals: [patch] }, defaults, {
+            debugLabel: "test",
+            userPrompt,
+        });
+        expect(out).toHaveLength(1);
+    });
+    it("drops a property when filePath is not in excerpt or component paths", () => {
+        const raw = { proposals: [basePatch] };
+        const userPrompt = JSON.stringify({
+            relevantFileContents: { "allowed.ts": "x" },
+            componentContext: {
+                c1: {
+                    detectedFrom: [{ filePath: "allowed.ts", pattern: "p" }],
+                    sourceLocations: [],
+                },
+            },
+        });
+        const out = (0, provider_contract_1.strictParseAndNormalizeProposals)(raw, defaults, {
+            debugLabel: "test",
+            userPrompt,
+        });
+        expect(out).toHaveLength(0);
+    });
+    it("buildProposalsValidationContext returns null on non-JSON", () => {
+        expect((0, provider_contract_1.buildProposalsValidationContext)("not json")).toBeNull();
+    });
+    it("coerces object-shaped proposals into an array before validation", () => {
+        const raw = {
+            proposals: {
+                "0": basePatch,
+            },
+        };
+        const userPrompt = JSON.stringify({
+            relevantFileContents: { "a.ts": "only one line" },
+            componentContext: {
+                c1: {
+                    detectedFrom: [{ filePath: "a.ts", pattern: "p" }],
+                    sourceLocations: [],
+                },
+            },
+        });
+        const out = (0, provider_contract_1.strictParseAndNormalizeProposals)(raw, defaults, {
+            debugLabel: "test",
+            userPrompt,
+        });
+        expect(out).toHaveLength(1);
+        if (out[0]?.kind === "component_patch") {
+            expect(out[0].targetComponentId).toBe("c1");
+            expect(out[0].setProperties.flag).toBe(true);
+        }
+    });
+    it("coerces propertyEvidence object entries into evidence arrays", () => {
+        const raw = {
+            proposals: [
+                {
+                    ...basePatch,
+                    propertyEvidence: {
+                        flag: {
+                            filePath: "a.ts",
+                            startLine: 1,
+                            endLine: 1,
+                            reason: "single object instead of array",
+                        },
+                    },
+                },
+            ],
+        };
+        const userPrompt = JSON.stringify({
+            relevantFileContents: { "a.ts": "only one line" },
+            componentContext: {
+                c1: {
+                    detectedFrom: [{ filePath: "a.ts", pattern: "p" }],
+                    sourceLocations: [],
+                },
+            },
+        });
+        const out = (0, provider_contract_1.strictParseAndNormalizeProposals)(raw, defaults, {
+            debugLabel: "test",
+            userPrompt,
+        });
+        expect(out).toHaveLength(1);
+        if (out[0]?.kind === "component_patch") {
+            expect(out[0].propertyEvidence?.flag).toHaveLength(1);
+            expect(out[0].propertyEvidence?.flag?.[0]?.reason).toContain("single object");
+        }
+    });
+    it("normalizes third-party data categories and derives cloud_provider for UI compatibility", () => {
+        const raw = {
+            proposals: [
+                {
+                    kind: "component_patch",
+                    targetComponentId: "c1",
+                    candidateType: "third_party",
+                    setProperties: {
+                        data_categories_received: ["document_files", "document_metadata"],
+                        processing_purpose: ["document_processing"],
+                        cloud_services_used: ["aws", "storage"],
+                    },
+                    confidence: { score: 0.9, band: "high" },
+                    propertyEvidence: {
+                        data_categories_received: [
+                            { filePath: "a.ts", startLine: 1, endLine: 1, reason: "docs mention files" },
+                        ],
+                        processing_purpose: [
+                            { filePath: "a.ts", startLine: 1, endLine: 1, reason: "service purpose" },
+                        ],
+                        cloud_services_used: [
+                            { filePath: "a.ts", startLine: 1, endLine: 1, reason: "aws sdk usage" },
+                        ],
+                    },
+                },
+            ],
+        };
+        const userPrompt = JSON.stringify({
+            relevantFileContents: { "a.ts": "line" },
+            componentContext: {
+                c1: {
+                    detectedFrom: [{ filePath: "a.ts", pattern: "p" }],
+                    sourceLocations: [],
+                },
+            },
+        });
+        const out = (0, provider_contract_1.strictParseAndNormalizeProposals)(raw, defaults, {
+            debugLabel: "test",
+            userPrompt,
+        });
+        expect(out).toHaveLength(1);
+        if (out[0]?.kind === "component_patch") {
+            expect(out[0].setProperties.data_categories_received).toEqual(["other"]);
+            expect(out[0].setProperties.processing_purpose).toEqual(["service_provision"]);
+            expect(out[0].setProperties.cloud_provider).toBe("AWS");
+            expect(out[0].propertyEvidence?.cloud_provider).toHaveLength(1);
+        }
+    });
+});

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_json_parse_1 = require("../../../src/ai-enrichment/providers/provider-json-parse");
+describe("provider-json-parse", () => {
+    it("stripJsonFences removes markdown fence", () => {
+        expect((0, provider_json_parse_1.stripJsonFences)('```json\n{"a":1}\n```')).toBe('{"a":1}');
+    });
+    it("extractBalancedJsonObject respects strings and nesting", () => {
+        const inner = '{"k":"}"}';
+        const full = `  ${inner} trailing junk`;
+        const start = full.indexOf("{");
+        expect((0, provider_json_parse_1.extractBalancedJsonObject)(full, start)).toBe(inner);
+    });
+    it("parseProviderJsonContent parses trailing non-JSON after object", () => {
+        const r = (0, provider_json_parse_1.parseProviderJsonContent)('{"proposals":[]}\n\nextra');
+        expect(r.ok).toBe(true);
+        if (r.ok)
+            expect(r.value).toEqual({ proposals: [] });
+    });
+    it("parseProviderJsonContent fails cleanly on truncated object", () => {
+        const r = (0, provider_json_parse_1.parseProviderJsonContent)('{"proposals":[{"k":');
+        expect(r.ok).toBe(false);
+    });
+});

package/dist/tests/unit/ai-enrichment/provider-output-token-budget.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/provider-output-token-budget.spec.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_output_token_budget_1 = require("../../../src/ai-enrichment/providers/provider-output-token-budget");
+describe("clampStructuredJsonCompletionTokens", () => {
+    it("defaults to 8192 when undefined", () => {
+        expect((0, provider_output_token_budget_1.clampStructuredJsonCompletionTokens)(undefined)).toBe(8192);
+    });
+    it("floors small values to 4096", () => {
+        expect((0, provider_output_token_budget_1.clampStructuredJsonCompletionTokens)(256)).toBe(4096);
+        expect((0, provider_output_token_budget_1.clampStructuredJsonCompletionTokens)(4096)).toBe(4096);
+    });
+    it("caps at 16384", () => {
+        expect((0, provider_output_token_budget_1.clampStructuredJsonCompletionTokens)(100_000)).toBe(16_384);
+    });
+});

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

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

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_prompt_1 = require("../../../src/ai-enrichment/provider-prompt");
+describe("buildFileExcerptsForQueue env safety", () => {
+    it("does not include .env file content in excerpts", () => {
+        const components = [
+            {
+                id: "cmp_1",
+                name: "api",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [
+                    {
+                        pattern: "file",
+                        sourceLocation: { filePath: "src/api.ts", startLine: 1, endLine: 5 },
+                    },
+                ],
+                sourceLocations: [{ filePath: "src/api.ts", startLine: 1, endLine: 5 }],
+                properties: {},
+            },
+        ];
+        const files = [
+            {
+                path: "src/api.ts",
+                name: "api.ts",
+                content: "export const x = 1;",
+                language: "typescript",
+                size: 20,
+            },
+            {
+                path: ".env",
+                name: ".env",
+                content: "API_KEY=super-secret",
+                language: "env",
+                size: 18,
+            },
+        ];
+        const queue = [
+            {
+                id: "c1",
+                candidateType: "node_property",
+                priority: 1,
+                componentId: "cmp_1",
+                missingFields: [],
+                rationale: "test",
+                hints: [],
+            },
+        ];
+        const excerpts = (0, provider_prompt_1.buildFileExcerptsForQueue)(files, queue, components, []);
+        expect(excerpts["src/api.ts"]).toContain("export const");
+        expect(excerpts[".env"]).toBeUndefined();
+        expect(JSON.stringify(excerpts)).not.toContain("super-secret");
+    });
+});

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

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

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

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_prompt_1 = require("../../../src/ai-enrichment/provider-prompt");
+describe("provider-prompt", () => {
+    it("slimComponentForLlm keeps detectedFrom paths and splits sparse keys", () => {
+        const c = {
+            id: "tp_1",
+            name: "Acme API",
+            type: "third_party",
+            confidence: 0.9,
+            detectedFrom: [
+                {
+                    pattern: "import",
+                    sourceLocation: {
+                        filePath: "src/lib/acme.ts",
+                        startLine: 3,
+                        endLine: 3,
+                    },
+                },
+            ],
+            sourceLocations: [
+                { filePath: "src/lib/acme.ts", startLine: 1, endLine: 20 },
+            ],
+            properties: {
+                section_id: "backend",
+                vendor: null,
+                integration_method: [],
+                inference_status: undefined,
+            },
+        };
+        const slim = (0, provider_prompt_1.slimComponentForLlm)(c);
+        expect(slim.detectedFrom).toHaveLength(1);
+        expect(slim.detectedFrom[0]?.filePath).toBe("src/lib/acme.ts");
+        expect(slim.propertiesSet).toEqual({ section_id: "backend" });
+        expect(slim.sparsePropertyKeys).toContain("vendor");
+        expect(slim.sparsePropertyKeys).not.toContain("inference_status");
+    });
+    it("buildProviderPromptPayload includes componentContext for queued componentIds", () => {
+        const components = [
+            {
+                id: "tp_1",
+                name: "X",
+                type: "third_party",
+                confidence: 0.8,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: {},
+            },
+        ];
+        const payload = (0, provider_prompt_1.buildProviderPromptPayload)({
+            agent: "tpAgent",
+            queue: [
+                {
+                    id: "c1",
+                    candidateType: "third_party",
+                    priority: 90,
+                    componentId: "tp_1",
+                    missingFields: [],
+                    rationale: "test",
+                    hints: [],
+                },
+            ],
+            components,
+            dataFlows: [],
+        });
+        expect(payload.agent).toBe("tpAgent");
+        expect(payload.componentContext.tp_1).toBeDefined();
+        expect(payload.componentContext.tp_1.name).toBe("X");
+        expect(String(payload.instructions)).toContain("targetComponentId` must be exactly one of canonicalComponentIds");
+        expect(payload.canonicalComponentIds).toEqual(["tp_1"]);
+    });
+    it("collectReferencedPathsForQueue includes flow endpoint component paths", () => {
+        const components = [
+            {
+                id: "a",
+                name: "A",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [{ filePath: "src/a.ts", startLine: 1, endLine: 2 }],
+                properties: {},
+            },
+            {
+                id: "b",
+                name: "B",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [{ filePath: "src/b.ts", startLine: 1, endLine: 2 }],
+                properties: {},
+            },
+        ];
+        const dataFlows = [
+            {
+                id: "f1",
+                sourceComponentId: "a",
+                targetComponentId: "b",
+                type: "api_call",
+                confidence: 0.8,
+            },
+        ];
+        const paths = (0, provider_prompt_1.collectReferencedPathsForQueue)([
+            {
+                id: "c1",
+                candidateType: "flow_direction",
+                priority: 1,
+                flowId: "f1",
+                missingFields: [],
+                rationale: "",
+                hints: [],
+            },
+        ], components, dataFlows);
+        expect(paths).toEqual(["src/a.ts", "src/b.ts"]);
+    });
+    it("buildFileExcerptsForQueue maps scan files to referenced paths", () => {
+        const components = [
+            {
+                id: "tp_1",
+                name: "X",
+                type: "third_party",
+                confidence: 0.8,
+                detectedFrom: [
+                    {
+                        pattern: "external_api_call",
+                        sourceLocation: {
+                            filePath: "pkg/handler.ts",
+                            startLine: 10,
+                            endLine: 12,
+                        },
+                    },
+                ],
+                sourceLocations: [],
+                properties: {},
+            },
+        ];
+        const files = [
+            {
+                path: "pkg/handler.ts",
+                name: "handler.ts",
+                content: "export const x = 1;\n",
+                language: "typescript",
+                size: 20,
+            },
+        ];
+        const excerpts = (0, provider_prompt_1.buildFileExcerptsForQueue)(files, [
+            {
+                id: "c1",
+                candidateType: "third_party",
+                priority: 1,
+                componentId: "tp_1",
+                missingFields: [],
+                rationale: "",
+                hints: [],
+            },
+        ], components, []);
+        expect(excerpts["pkg/handler.ts"]).toContain("export const x");
+    });
+    it("buildProviderPromptPayload adds relevantFileContents when files match queue", () => {
+        const components = [
+            {
+                id: "tp_1",
+                name: "X",
+                type: "third_party",
+                confidence: 0.8,
+                detectedFrom: [
+                    {
+                        pattern: "external_api_call",
+                        sourceLocation: {
+                            filePath: "lib/x.ts",
+                            startLine: 1,
+                            endLine: 1,
+                        },
+                    },
+                ],
+                sourceLocations: [],
+                properties: {},
+            },
+        ];
+        const payload = (0, provider_prompt_1.buildProviderPromptPayload)({
+            agent: "tpAgent",
+            queue: [
+                {
+                    id: "c1",
+                    candidateType: "third_party",
+                    priority: 1,
+                    componentId: "tp_1",
+                    missingFields: [],
+                    rationale: "",
+                    hints: [],
+                },
+            ],
+            components,
+            dataFlows: [],
+            files: [
+                {
+                    path: "lib/x.ts",
+                    name: "x.ts",
+                    content: "void 0;",
+                    language: "typescript",
+                    size: 6,
+                },
+            ],
+        });
+        expect(payload.relevantFileContents?.["lib/x.ts"]).toBe("void 0;");
+    });
+});

package/dist/tests/unit/ai-enrichment/provider-topology-terraform-aws.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/provider-topology-terraform-aws.spec.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_topology_shared_1 = require("../../../src/ai-enrichment/provider-topology-shared");
+describe("provider topology — AWS Terraform resource_type rules", () => {
+    const awsS3Node = {
+        key: "s3",
+        usageSignals: ["s3", "bucket"],
+        terraformResourceTypes: [],
+        terraformResourceTypePrefixes: ["aws_s3_"],
+    };
+    const awsLambdaNode = {
+        key: "lambda",
+        usageSignals: ["lambda", "function"],
+        terraformResourceTypes: [],
+        terraformResourceTypePrefixes: ["aws_lambda_"],
+    };
+    it("matches HashiCorp aws_s3_* types by prefix only", () => {
+        expect((0, provider_topology_shared_1.terraformResourceTypeMatchesTopologyRule)("aws_s3_bucket", [], ["aws_s3_"])).toBe(true);
+        expect((0, provider_topology_shared_1.terraformResourceTypeMatchesTopologyRule)("aws_s3_bucket_acl", [], ["aws_s3_"])).toBe(true);
+        expect((0, provider_topology_shared_1.terraformResourceTypeMatchesTopologyRule)("aws_lambda_function", [], ["aws_s3_"])).toBe(false);
+    });
+    it("matches aws_db_instance by exact type", () => {
+        expect((0, provider_topology_shared_1.terraformResourceTypeMatchesTopologyRule)("aws_db_instance", ["aws_db_instance"], [])).toBe(true);
+        expect((0, provider_topology_shared_1.terraformResourceTypeMatchesTopologyRule)("aws_db_subnet_group", ["aws_db_instance"], [])).toBe(false);
+    });
+    it("does not treat lambda_* block naming as Lambda when resource_type is S3", () => {
+        const bucket = {
+            id: "b1",
+            name: "lambda_bucket",
+            type: "asset",
+            confidence: 1,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: {
+                resource_type: "aws_s3_bucket",
+                block_name: "lambda_bucket",
+                terraform_address: "aws_s3_bucket.lambda_bucket",
+            },
+        };
+        expect((0, provider_topology_shared_1.terraformAssetMatchesManagedServiceTopologyRule)(bucket, awsLambdaNode)).toBe(false);
+        expect((0, provider_topology_shared_1.terraformAssetMatchesManagedServiceTopologyRule)(bucket, awsS3Node)).toBe(true);
+    });
+});

package/dist/tests/unit/ai-enrichment/provider-topology-terraform-kubernetes.spec.d.ts

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