@dataparade/cli 0.0.1

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

@@ -0,0 +1,422 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const merge_rules_1 = require("../../../src/ai-enrichment/merge-rules");
+function makeBaseComponents() {
+    return [
+        {
+            id: "asset_frontend",
+            name: "Frontend",
+            type: "asset",
+            confidence: 0.9,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: {},
+        },
+        {
+            id: "asset_backend",
+            name: "Backend",
+            type: "asset",
+            confidence: 0.9,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: {},
+        },
+    ];
+}
+function makeBaseFlows() {
+    return [
+        {
+            id: "flow_1",
+            sourceComponentId: "asset_frontend",
+            targetComponentId: "asset_backend",
+            type: "api_call",
+            confidence: 0.8,
+        },
+    ];
+}
+describe("ai-enrichment merge rules", () => {
+    it("remaps provider component target from path alias to canonical component id", () => {
+        const components = [
+            {
+                id: "cmp_11",
+                name: "auth-helper",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [
+                    {
+                        filePath: "backend/lambdas/auth-helper/index.js",
+                        startLine: 1,
+                        endLine: 20,
+                    },
+                ],
+                properties: {},
+            },
+        ];
+        const proposals = [
+            {
+                id: "provider_1",
+                proposal: {
+                    kind: "component_patch",
+                    targetComponentId: "backend/lambdas/auth-helper",
+                    candidateType: "node_property",
+                    setProperties: { programming_language: ["javascript"] },
+                    confidence: { score: 0.82, band: "high" },
+                    evidence: [
+                        {
+                            filePath: "backend/lambdas/auth-helper/index.js",
+                            startLine: 1,
+                            endLine: 10,
+                            reason: "lambda source file",
+                        },
+                    ],
+                    provider: "openai",
+                    model: "gpt-4o-mini",
+                    agent: "propertyAgent",
+                },
+            },
+        ];
+        const result = (0, merge_rules_1.mergeAiProposals)(components, [], proposals);
+        expect(result.appliedProposalIds).toEqual(["provider_1"]);
+        expect(result.rejectedProposalIds).toEqual([]);
+        expect(result.components[0]?.id).toBe("cmp_11");
+        expect(result.components[0]?.properties.programming_language).toEqual([
+            "javascript",
+        ]);
+    });
+    it("applies only the highest-ranked proposal per target", () => {
+        const proposals = [
+            {
+                id: "p_low",
+                proposal: {
+                    kind: "component_patch",
+                    targetComponentId: "asset_backend",
+                    candidateType: "node_property",
+                    setProperties: { pii: false },
+                    confidence: { score: 0.8, band: "medium" },
+                    evidence: [
+                        {
+                            filePath: "src/backend.ts",
+                            startLine: 10,
+                            endLine: 20,
+                            reason: "no pii path",
+                        },
+                    ],
+                    provider: "openai",
+                    model: "x",
+                    agent: "propertyAgent",
+                },
+            },
+            {
+                id: "p_high",
+                proposal: {
+                    kind: "component_patch",
+                    targetComponentId: "asset_backend",
+                    candidateType: "node_property",
+                    setProperties: { pii: true },
+                    confidence: { score: 0.92, band: "high" },
+                    evidence: [
+                        {
+                            filePath: "src/backend.ts",
+                            startLine: 10,
+                            endLine: 20,
+                            reason: "user email persisted",
+                        },
+                        {
+                            filePath: "src/db.ts",
+                            startLine: 1,
+                            endLine: 4,
+                            reason: "email column present",
+                        },
+                    ],
+                    provider: "openai",
+                    model: "x",
+                    agent: "propertyAgent",
+                },
+            },
+        ];
+        const result = (0, merge_rules_1.mergeAiProposals)(makeBaseComponents(), makeBaseFlows(), proposals);
+        const backend = result.components.find((c) => c.id === "asset_backend");
+        expect(backend?.properties.pii).toBe(true);
+        expect(result.appliedProposalIds).toEqual(["p_high"]);
+        expect(result.rejectedProposalIds).toEqual([
+            {
+                proposalId: "p_low",
+                reason: "target_already_modified_by_higher_ranked_proposal",
+            },
+        ]);
+    });
+    it("rejects flow inserts below insert threshold", () => {
+        const proposals = [
+            {
+                id: "insert_low_confidence",
+                proposal: {
+                    kind: "flow_patch",
+                    candidateType: "missing_interaction",
+                    insertIfMissing: true,
+                    sourceComponentId: "asset_backend",
+                    targetComponentId: "asset_frontend",
+                    setType: "api_call",
+                    confidence: { score: 0.8, band: "medium" },
+                    evidence: [
+                        {
+                            filePath: "src/api.ts",
+                            startLine: 3,
+                            endLine: 5,
+                            reason: "response mapper reference",
+                        },
+                    ],
+                    provider: "openai",
+                    model: "x",
+                    agent: "interactionAgent",
+                },
+            },
+        ];
+        const result = (0, merge_rules_1.mergeAiProposals)(makeBaseComponents(), makeBaseFlows(), proposals);
+        expect(result.appliedProposalIds).toEqual([]);
+        expect(result.rejectedProposalIds).toEqual([
+            {
+                proposalId: "insert_low_confidence",
+                reason: "confidence_below_threshold:0.85",
+            },
+        ]);
+        expect(result.dataFlows).toHaveLength(1);
+    });
+    it("rejects flow_patch when preserving data-flow topology even above insert threshold", () => {
+        const proposals = [
+            {
+                id: "insert_high_confidence",
+                proposal: {
+                    kind: "flow_patch",
+                    candidateType: "missing_interaction",
+                    insertIfMissing: true,
+                    sourceComponentId: "asset_backend",
+                    targetComponentId: "asset_frontend",
+                    setType: "api_call",
+                    confidence: { score: 0.95, band: "high" },
+                    evidence: [
+                        {
+                            filePath: "src/api.ts",
+                            startLine: 3,
+                            endLine: 5,
+                            reason: "response mapper reference",
+                        },
+                    ],
+                    provider: "openai",
+                    model: "x",
+                    agent: "interactionAgent",
+                },
+            },
+        ];
+        const result = (0, merge_rules_1.mergeAiProposals)(makeBaseComponents(), makeBaseFlows(), proposals, {}, { preserveDataFlowTopology: true });
+        expect(result.appliedProposalIds).toEqual([]);
+        expect(result.rejectedProposalIds).toEqual([
+            {
+                proposalId: "insert_high_confidence",
+                reason: "data_flow_topology_preserved",
+            },
+        ]);
+        expect(result.dataFlows).toHaveLength(1);
+        expect(result.dataFlows[0]?.targetComponentId).toBe("asset_backend");
+    });
+    it("rejects flow_patch when intra-section gate is enabled and endpoints are in different sections", () => {
+        const components = [
+            {
+                id: "asset_frontend",
+                name: "Frontend",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { section_id: "frontend" },
+            },
+            {
+                id: "asset_backend",
+                name: "Backend",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { section_id: "backend" },
+            },
+        ];
+        const proposals = [
+            {
+                id: "insert_cross_section",
+                proposal: {
+                    kind: "flow_patch",
+                    candidateType: "missing_interaction",
+                    insertIfMissing: true,
+                    sourceComponentId: "asset_frontend",
+                    targetComponentId: "asset_backend",
+                    setType: "api_call",
+                    confidence: { score: 0.95, band: "high" },
+                    evidence: [
+                        {
+                            filePath: "src/api.ts",
+                            startLine: 3,
+                            endLine: 5,
+                            reason: "request path observed",
+                        },
+                    ],
+                    provider: "openai",
+                    model: "x",
+                    agent: "interactionAgent",
+                },
+            },
+        ];
+        const result = (0, merge_rules_1.mergeAiProposals)(components, [], proposals, {}, {
+            enforceIntraSectionFlowChangesOnly: true,
+        });
+        expect(result.appliedProposalIds).toEqual([]);
+        expect(result.rejectedProposalIds).toEqual([
+            {
+                proposalId: "insert_cross_section",
+                reason: "cross_section_flow_change_blocked",
+            },
+        ]);
+    });
+    it("applies flow_patch when intra-section gate is enabled and endpoints share a section", () => {
+        const components = [
+            {
+                id: "asset_frontend_api",
+                name: "Frontend API",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { section_id: "frontend" },
+            },
+            {
+                id: "asset_frontend_worker",
+                name: "Frontend Worker",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: { section_id: "frontend" },
+            },
+        ];
+        const proposals = [
+            {
+                id: "insert_same_section",
+                proposal: {
+                    kind: "flow_patch",
+                    candidateType: "missing_interaction",
+                    insertIfMissing: true,
+                    sourceComponentId: "asset_frontend_api",
+                    targetComponentId: "asset_frontend_worker",
+                    setType: "api_call",
+                    confidence: { score: 0.95, band: "high" },
+                    evidence: [
+                        {
+                            filePath: "src/frontend.ts",
+                            startLine: 12,
+                            endLine: 20,
+                            reason: "internal call observed",
+                        },
+                    ],
+                    provider: "openai",
+                    model: "x",
+                    agent: "interactionAgent",
+                },
+            },
+        ];
+        const result = (0, merge_rules_1.mergeAiProposals)(components, [], proposals, {}, {
+            enforceIntraSectionFlowChangesOnly: true,
+        });
+        expect(result.appliedProposalIds).toEqual(["insert_same_section"]);
+        expect(result.rejectedProposalIds).toEqual([]);
+        expect(result.dataFlows).toHaveLength(1);
+        expect(result.dataFlows[0]?.sourceComponentId).toBe("asset_frontend_api");
+        expect(result.dataFlows[0]?.targetComponentId).toBe("asset_frontend_worker");
+    });
+    it("rejects component patch when all updates are no-op or empty-equivalent", () => {
+        const components = makeBaseComponents();
+        components[1].properties = {
+            inference_status: undefined,
+            api_versioning_strategy: null,
+            access_controls_for_delivery: null,
+            cloud_services_used: [],
+        };
+        const proposals = [
+            {
+                id: "p_noop",
+                proposal: {
+                    kind: "component_patch",
+                    targetComponentId: "asset_backend",
+                    candidateType: "node_property",
+                    setProperties: {
+                        inference_status: "needs_review",
+                        api_versioning_strategy: "none",
+                        access_controls_for_delivery: null,
+                        cloud_services_used: null,
+                    },
+                    confidence: { score: 0.9, band: "high" },
+                    evidence: [
+                        {
+                            filePath: "src/backend.ts",
+                            startLine: 1,
+                            endLine: 2,
+                            reason: "existing metadata only",
+                        },
+                    ],
+                    provider: "openai",
+                    model: "x",
+                    agent: "propertyAgent",
+                },
+            },
+        ];
+        const result = (0, merge_rules_1.mergeAiProposals)(components, makeBaseFlows(), proposals);
+        const backend = result.components.find((c) => c.id === "asset_backend");
+        expect(result.appliedProposalIds).toEqual([]);
+        expect(result.rejectedProposalIds).toEqual([
+            { proposalId: "p_noop", reason: "no_meaningful_changes" },
+        ]);
+        expect(backend?.properties).toEqual({
+            inference_status: undefined,
+            api_versioning_strategy: null,
+            access_controls_for_delivery: null,
+            cloud_services_used: [],
+        });
+    });
+    it("applies component patch when at least one property meaningfully changes", () => {
+        const components = makeBaseComponents();
+        components[1].properties = {
+            cloud_services_used: [],
+            inference_status: undefined,
+        };
+        const proposals = [
+            {
+                id: "p_meaningful",
+                proposal: {
+                    kind: "component_patch",
+                    targetComponentId: "asset_backend",
+                    candidateType: "node_property",
+                    setProperties: {
+                        inference_status: "needs_review",
+                        cloud_services_used: ["aws"],
+                    },
+                    confidence: { score: 0.9, band: "high" },
+                    evidence: [
+                        {
+                            filePath: "src/backend.ts",
+                            startLine: 1,
+                            endLine: 2,
+                            reason: "cloud provider usage",
+                        },
+                    ],
+                    provider: "openai",
+                    model: "x",
+                    agent: "propertyAgent",
+                },
+            },
+        ];
+        const result = (0, merge_rules_1.mergeAiProposals)(components, makeBaseFlows(), proposals);
+        const backend = result.components.find((c) => c.id === "asset_backend");
+        expect(result.appliedProposalIds).toEqual(["p_meaningful"]);
+        expect(result.rejectedProposalIds).toEqual([]);
+        expect(backend?.properties.inference_status).toBeUndefined();
+        expect(backend?.properties.cloud_services_used).toEqual(["aws"]);
+    });
+});

package/dist/tests/unit/ai-enrichment/openai-proposals-response.schema.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/openai-proposals-response.schema.spec.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const openai_proposals_response_schema_1 = require("../../../src/ai-enrichment/openai-proposals-response.schema");
+describe("openAiProposalsResponseSchema", () => {
+    it("parses a minimal valid component_patch payload", () => {
+        const r = openai_proposals_response_schema_1.openAiProposalsResponseSchema.safeParse({
+            proposals: [
+                {
+                    kind: "component_patch",
+                    targetComponentId: "c1",
+                    candidateType: "third_party",
+                    setProperties: { integration_method: ["api"] },
+                    propertyEvidence: {
+                        integration_method: [
+                            { filePath: "a.ts", startLine: 1, endLine: 2, reason: "uses SDK" },
+                        ],
+                    },
+                    confidence: { score: 0.8, band: "high" },
+                },
+            ],
+        });
+        expect(r.success).toBe(true);
+    });
+    it("getOpenAiProposalsResponseJsonSchemaForApi omits $schema", () => {
+        const j = (0, openai_proposals_response_schema_1.getOpenAiProposalsResponseJsonSchemaForApi)();
+        expect(j.name).toBe("dataparade_proposals");
+        expect(j.schema.$schema).toBeUndefined();
+        expect(j.schema.type).toBe("object");
+    });
+});

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

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

package/dist/tests/unit/ai-enrichment/pipeline.spec.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pipeline_1 = require("../../../src/ai-enrichment/pipeline");
+function baseComponents() {
+    return [
+        {
+            id: "actor_1",
+            name: "Customer",
+            type: "actor",
+            confidence: 0.8,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: { section_id: "frontend" },
+        },
+        {
+            id: "asset_1",
+            name: "Backend",
+            type: "asset",
+            confidence: 0.9,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: { section_id: "backend", encryption_at_rest: null },
+        },
+    ];
+}
+function baseFlows() {
+    return [
+        {
+            id: "flow_1",
+            sourceComponentId: "asset_1",
+            targetComponentId: "actor_1",
+            type: "api_call",
+            confidence: 0.7,
+        },
+    ];
+}
+describe("ai-enrichment pipeline", () => {
+    it("returns dry-run merge output when no proposal generator is supplied", async () => {
+        const result = await (0, pipeline_1.runInferencePipeline)({
+            components: baseComponents(),
+            dataFlows: baseFlows(),
+        });
+        expect(result.candidates.length).toBeGreaterThan(0);
+        expect(result.mergeResult.appliedProposalIds).toEqual([]);
+        expect(result.mergeResult.components[1]?.properties.encryption_at_rest).toBeNull();
+    });
+    it("applies generated proposals through merge rules", async () => {
+        const result = await (0, pipeline_1.runInferencePipeline)({
+            components: baseComponents(),
+            dataFlows: baseFlows(),
+        }, {
+            generateProposals: async () => ({
+                proposals: [
+                    {
+                        id: "p1",
+                        proposal: {
+                            kind: "component_patch",
+                            targetComponentId: "asset_1",
+                            candidateType: "node_property",
+                            setProperties: { encryption_at_rest: true },
+                            confidence: { score: 0.92, band: "high" },
+                            evidence: [
+                                {
+                                    filePath: "backend/src/db.ts",
+                                    startLine: 1,
+                                    endLine: 8,
+                                    reason: "database encryption enabled",
+                                },
+                            ],
+                            provider: "openai",
+                            model: "x",
+                            agent: "propertyAgent",
+                        },
+                    },
+                ],
+            }),
+        });
+        const backend = result.mergeResult.components.find((c) => c.id === "asset_1");
+        expect(backend?.properties.encryption_at_rest).toBe(true);
+        expect(result.mergeResult.appliedProposalIds).toEqual(["p1"]);
+    });
+    it("does not apply cross-section flow_patch proposals (intra-section gate)", async () => {
+        const flows = baseFlows();
+        const result = await (0, pipeline_1.runInferencePipeline)({
+            components: baseComponents(),
+            dataFlows: flows,
+        }, {
+            generateProposals: async () => ({
+                proposals: [
+                    {
+                        id: "fp1",
+                        proposal: {
+                            kind: "flow_patch",
+                            candidateType: "missing_interaction",
+                            insertIfMissing: true,
+                            sourceComponentId: "actor_1",
+                            targetComponentId: "asset_1",
+                            setType: "api_call",
+                            confidence: { score: 0.95, band: "high" },
+                            evidence: [
+                                {
+                                    filePath: "x.ts",
+                                    startLine: 1,
+                                    endLine: 2,
+                                    reason: "test",
+                                },
+                            ],
+                            provider: "openai",
+                            model: "x",
+                            agent: "interactionAgent",
+                        },
+                    },
+                ],
+            }),
+        });
+        expect(result.mergeResult.appliedProposalIds).toEqual([]);
+        expect(result.mergeResult.rejectedProposalIds.some((r) => r.reason === "cross_section_flow_change_blocked")).toBe(true);
+        expect(result.mergeResult.dataFlows).toEqual(flows);
+    });
+});

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

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

package/dist/tests/unit/ai-enrichment/planner.spec.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const planner_1 = require("../../../src/ai-enrichment/planner");
+describe("ai-enrichment planner", () => {
+    it("partitions candidates by agent and allocates budgets", () => {
+        const candidates = [
+            {
+                id: "c1",
+                candidateType: "node_property",
+                priority: 90,
+                componentId: "asset_1",
+                missingFields: ["encryption_at_rest"],
+                rationale: "missing",
+                hints: [],
+            },
+            {
+                id: "c2",
+                candidateType: "third_party",
+                priority: 80,
+                componentId: "tp_1",
+                missingFields: ["subType"],
+                rationale: "missing",
+                hints: [],
+            },
+            {
+                id: "c3",
+                candidateType: "flow_direction",
+                priority: 70,
+                flowId: "flow_1",
+                missingFields: [],
+                rationale: "uncertain",
+                hints: [],
+            },
+        ];
+        const plan = (0, planner_1.planInferenceQueues)(candidates, {
+            totalBudgetTokens: 9000,
+            maxModelCalls: 9,
+        });
+        expect(plan.queues).toHaveLength(3);
+        expect(plan.queues.reduce((sum, q) => sum + q.budgetTokens, 0)).toBe(9000);
+        expect(plan.queues.reduce((sum, q) => sum + q.maxModelCalls, 0)).toBe(9);
+        expect(plan.droppedCandidates).toEqual([]);
+    });
+    it("drops candidates when agent queue capacity is exceeded", () => {
+        const candidates = [
+            {
+                id: "c1",
+                candidateType: "node_property",
+                priority: 90,
+                componentId: "asset_1",
+                missingFields: [],
+                rationale: "x",
+                hints: [],
+            },
+            {
+                id: "c2",
+                candidateType: "node_property",
+                priority: 80,
+                componentId: "asset_2",
+                missingFields: [],
+                rationale: "x",
+                hints: [],
+            },
+        ];
+        const plan = (0, planner_1.planInferenceQueues)(candidates, {
+            maxCandidatesPerAgent: 1,
+            totalBudgetTokens: 1000,
+            maxModelCalls: 2,
+        });
+        expect(plan.queues).toHaveLength(1);
+        expect(plan.queues[0]?.queue).toHaveLength(1);
+        expect(plan.droppedCandidates).toEqual([
+            { candidateId: "c2", reason: "agent_queue_capacity_exceeded" },
+        ]);
+    });
+    it("treats maxCandidatesPerAgent 0 as unlimited", () => {
+        const candidates = [
+            {
+                id: "c1",
+                candidateType: "node_property",
+                priority: 90,
+                componentId: "asset_1",
+                missingFields: [],
+                rationale: "x",
+                hints: [],
+            },
+            {
+                id: "c2",
+                candidateType: "node_property",
+                priority: 80,
+                componentId: "asset_2",
+                missingFields: [],
+                rationale: "x",
+                hints: [],
+            },
+        ];
+        const plan = (0, planner_1.planInferenceQueues)(candidates, {
+            maxCandidatesPerAgent: 0,
+            totalBudgetTokens: 1000,
+            maxModelCalls: 2,
+        });
+        expect(plan.queues).toHaveLength(1);
+        expect(plan.queues[0]?.queue).toHaveLength(2);
+        expect(plan.droppedCandidates).toEqual([]);
+    });
+});

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

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