@dataparade/cli 0.0.1

package/dist/tests/fixtures/mixed-language-basic/api.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const app = (0, express_1.default)();
+app.get("/health", async (_req, res) => {
+    await fetch("https://api.stripe.com/v1/charges");
+    res.json({ ok: true });
+});
+exports.default = app;

package/dist/tests/fixtures/monorepo-app-plus-terraform/packages/app/app/route.d.ts

@@ -0,0 +1 @@
+export declare function GET(): Promise<void>;

package/dist/tests/fixtures/monorepo-app-plus-terraform/packages/app/app/route.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+async function GET() {
+    // Minimal route handler for express_route detection in the app section.
+}

package/dist/tests/fixtures/monorepo-front-back-sections/backend/app/route.d.ts

@@ -0,0 +1 @@
+export declare function GET(): Promise<void>;

package/dist/tests/fixtures/monorepo-front-back-sections/backend/app/route.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+async function GET() {
+    // Minimal route handler for backend section (express_route detection).
+}

package/dist/tests/fixtures/monorepo-front-back-sections/frontend/app/route.d.ts

@@ -0,0 +1 @@
+export declare function GET(): Promise<void>;

package/dist/tests/fixtures/monorepo-front-back-sections/frontend/app/route.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+async function GET() {
+    // Minimal Next.js-style route handler used to trigger express_route
+    // detection via heuristics.
+}

package/dist/tests/fixtures/typescript-basic/app/route.d.ts

@@ -0,0 +1 @@
+export declare function GET(): Promise<void>;

package/dist/tests/fixtures/typescript-basic/app/route.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = GET;
+async function GET() {
+    // Minimal Next.js-style route handler used to trigger express_route
+    // detection via heuristics; body is irrelevant for tests.
+}

package/dist/tests/fixtures/typescript-basic/db-client-import.d.ts

@@ -0,0 +1,2 @@
+import "./pg-client";
+export declare function ensurePgClientLoaded(): void;

package/dist/tests/fixtures/typescript-basic/db-client-import.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePgClientLoaded = ensurePgClientLoaded;
+require("./pg-client");
+function ensurePgClientLoaded() {
+    // This module exists so the TypeScript analyzer sees a module import containing
+    // \"pg\" and can emit a database_connection finding for tests.
+}

package/dist/tests/fixtures/typescript-basic/db.d.ts

@@ -0,0 +1,3 @@
+type QueryResultRow = Record<string, unknown>;
+export declare function getUserById(id: string): Promise<QueryResultRow>;
+export {};

package/dist/tests/fixtures/typescript-basic/db.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserById = getUserById;
+async function getUserById(id) {
+    const result = await pool.query("SELECT * FROM users WHERE id = $1", [id]);
+    return result.rows[0];
+}

package/dist/tests/fixtures/typescript-basic/external-api.d.ts

@@ -0,0 +1 @@
+export declare function callExternalApi(): Promise<any>;

package/dist/tests/fixtures/typescript-basic/external-api.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callExternalApi = callExternalApi;
+async function callExternalApi() {
+    const apiKey = process.env.API_KEY;
+    // Use a host that matches a known third-party (stripe) so the
+    // external_api_call pattern plus classifier will produce a third_party
+    // component and a corresponding data flow in tests.
+    const response = await fetch("https://api.stripe.com/v1/customers", {
+        headers: {
+            "x-api-key": apiKey ?? "test-key",
+        },
+    });
+    if (!response.ok) {
+        throw new Error("API request failed");
+    }
+    return response.json();
+}

package/dist/tests/fixtures/typescript-basic/pg-client.d.ts

@@ -0,0 +1,3 @@
+type QueryResultRow = Record<string, unknown>;
+export declare function runHealthCheck(): Promise<QueryResultRow | undefined>;
+export {};

package/dist/tests/fixtures/typescript-basic/pg-client.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHealthCheck = runHealthCheck;
+async function runHealthCheck() {
+    const result = await pool.query("SELECT 1", []);
+    return result.rows[0];
+}

package/dist/tests/fixtures/typescript-basic/server.d.ts

@@ -0,0 +1,14 @@
+type RequestLike = {
+    [key: string]: unknown;
+};
+type ResponseLike = {
+    send: (body: unknown) => void;
+};
+declare const app: {
+    get: (path: string, ...handlers: Array<(req: RequestLike, res: ResponseLike, next?: () => void) => void>) => void;
+};
+declare const passport: {
+    authenticate: (strategy: string, options?: {
+        session?: boolean;
+    }) => (req: RequestLike, res: ResponseLike, next: (() => void) | undefined) => void;
+};

package/dist/tests/fixtures/typescript-basic/server.js

@@ -0,0 +1,4 @@
+"use strict";
+app.get("/users", passport.authenticate("jwt", { session: false }), (req, res) => {
+    res.send("ok");
+});

package/dist/tests/fixtures/typescript-dependency-manifests-basic/src/index.js

@@ -0,0 +1,2 @@
+"use strict";
+// Intentionally empty: we rely on package.json for third-party detection.

package/dist/tests/helpers/scan-result-builders.d.ts

@@ -0,0 +1,2 @@
+import type { DetectedComponent } from "../../src/core/types/component";
+export declare function testAsset(id: string, name: string, props: Record<string, unknown>, subType?: string): DetectedComponent;

package/dist/tests/helpers/scan-result-builders.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testAsset = testAsset;
+function testAsset(id, name, props, subType = "application") {
+    return {
+        id,
+        name,
+        type: "asset",
+        subType,
+        confidence: 0.9,
+        detectedFrom: [],
+        sourceLocations: [],
+        properties: props,
+    };
+}

package/dist/tests/schema/dataflow-wrapper.schema.spec.d.ts

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

package/dist/tests/schema/dataflow-wrapper.schema.spec.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dataflow_wrapper_schema_1 = require("../../src/core/schema/dataflow-wrapper.schema");
+describe("dataflowWrapperSchema", () => {
+    it("accepts a valid dataflow.json wrapper", () => {
+        const input = {
+            schemaVersion: "1.0",
+            graph: {
+                nodes: [
+                    {
+                        id: "n1",
+                        type: "asset",
+                        position: { x: 0, y: 0 },
+                        data: { label: "Node 1", privacy: {} },
+                    },
+                ],
+                edges: [],
+                viewport: { x: 0, y: 0, zoom: 1 },
+            },
+            metadata: {
+                componentsCount: 1,
+                dataFlowsCount: 0,
+                filesScanned: 10,
+                scanDurationMs: 100,
+            },
+        };
+        const result = (0, dataflow_wrapper_schema_1.validateDataflowJson)(input);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.value.graph.nodes[0].id).toBe("n1");
+        }
+    });
+    it("accepts metadata.terraform when shape matches CLI output", () => {
+        const input = {
+            schemaVersion: "1.0",
+            graph: {
+                nodes: [
+                    {
+                        id: "n1",
+                        type: "asset",
+                        position: { x: 0, y: 0 },
+                        data: { label: "Node 1", privacy: {} },
+                    },
+                ],
+                edges: [],
+            },
+            metadata: {
+                componentsCount: 1,
+                terraform: {
+                    mode: "json_overlay",
+                    staticTfFiles: 2,
+                    jsonInputPath: "/tmp/plan.json",
+                    jsonFindingsMerged: 1,
+                },
+            },
+        };
+        const result = (0, dataflow_wrapper_schema_1.validateDataflowJson)(input);
+        expect(result.ok).toBe(true);
+    });
+    it("rejects wrappers missing schemaVersion or graph", () => {
+        const input = {
+            graph: {},
+        };
+        const result = (0, dataflow_wrapper_schema_1.validateDataflowJson)(input);
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            const message = result.errors.join(" | ");
+            expect(message).toMatch(/schemaVersion/);
+        }
+    });
+    it("rejects invalid graph structures", () => {
+        const input = {
+            schemaVersion: "1.0",
+            graph: {
+                nodes: [
+                    {
+                        id: "",
+                        type: "asset",
+                        position: { x: 0, y: 0 },
+                        data: { label: "Invalid Node", privacy: {} },
+                    },
+                ],
+                edges: [],
+            },
+        };
+        const result = dataflow_wrapper_schema_1.dataflowWrapperSchema.safeParse(input);
+        expect(result.success).toBe(false);
+    });
+});

package/dist/tests/schema/diagram-graph.schema.spec.d.ts

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

package/dist/tests/schema/diagram-graph.schema.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const diagram_graph_schema_1 = require("../../src/core/schema/diagram-graph.schema");
+describe("diagramGraphJsonSchema", () => {
+    it("accepts a minimal valid graph", () => {
+        const input = {
+            nodes: [
+                {
+                    id: "n1",
+                    type: "asset",
+                    position: { x: 0, y: 0 },
+                    data: {
+                        label: "Node 1",
+                        privacy: {},
+                    },
+                },
+            ],
+            edges: [
+                {
+                    id: "e1",
+                    source: "n1",
+                    target: "n1",
+                    type: "data_flow",
+                    data: {
+                        label: "self",
+                    },
+                },
+            ],
+            viewport: { x: 0, y: 0, zoom: 1 },
+        };
+        const result = diagram_graph_schema_1.diagramGraphJsonSchema.safeParse(input);
+        expect(result.success).toBe(true);
+    });
+    it("rejects graphs with invalid nodes/edges", () => {
+        const input = {
+            nodes: [],
+            edges: [
+                {
+                    id: "e1",
+                    source: "",
+                    target: "n1",
+                },
+            ],
+        };
+        const result = diagram_graph_schema_1.diagramGraphJsonSchema.safeParse(input);
+        expect(result.success).toBe(false);
+    });
+});

package/dist/tests/schema/scan-config.schema.spec.d.ts

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

package/dist/tests/schema/scan-config.schema.spec.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scan_config_schema_1 = require("../../src/core/schema/scan-config.schema");
+describe("scanConfigurationSchema", () => {
+    it("accepts a minimal valid configuration", () => {
+        const input = {
+            enableAPIDetection: true,
+            enableDatabaseDetection: true,
+            enableDataFlowDetection: true,
+            minimumConfidence: 0.5,
+        };
+        const result = (0, scan_config_schema_1.validateScanConfiguration)(input);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.value.minimumConfidence).toBe(0.5);
+        }
+    });
+    it("rejects invalid minimumConfidence and missing flags", () => {
+        const input = {
+            enableAPIDetection: "true",
+            enableDatabaseDetection: true,
+            enableDataFlowDetection: true,
+            minimumConfidence: 2,
+        };
+        const result = (0, scan_config_schema_1.validateScanConfiguration)(input);
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            const message = result.errors.join(" | ");
+            expect(message).toMatch(/enableAPIDetection/);
+            expect(message).toMatch(/minimumConfidence/);
+        }
+    });
+    it("accepts python in languages", () => {
+        const input = {
+            enableAPIDetection: true,
+            enableDatabaseDetection: true,
+            enableDataFlowDetection: true,
+            minimumConfidence: 0.5,
+            languages: ["python"],
+        };
+        const result = (0, scan_config_schema_1.validateScanConfiguration)(input);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.value.languages).toEqual(["python"]);
+        }
+    });
+    it("accepts openrouter as aiProvider", () => {
+        const input = {
+            enableAPIDetection: true,
+            enableDatabaseDetection: true,
+            enableDataFlowDetection: true,
+            minimumConfidence: 0.5,
+            aiProvider: "openrouter",
+            aiModel: "openai/gpt-4o-mini",
+        };
+        const result = (0, scan_config_schema_1.validateScanConfiguration)(input);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.value.aiProvider).toBe("openrouter");
+        }
+    });
+    it("accepts positive aiProviderConcurrency", () => {
+        const input = {
+            enableAPIDetection: true,
+            enableDatabaseDetection: true,
+            enableDataFlowDetection: true,
+            minimumConfidence: 0.5,
+            aiProviderConcurrency: 3,
+        };
+        const result = (0, scan_config_schema_1.validateScanConfiguration)(input);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.value.aiProviderConcurrency).toBe(3);
+        }
+    });
+    it("accepts terraformJsonPath and terraformPlanPath", () => {
+        const input = {
+            enableAPIDetection: true,
+            enableDatabaseDetection: true,
+            enableDataFlowDetection: true,
+            minimumConfidence: 0.5,
+            terraformJsonPath: "./show.json",
+            terraformPlanPath: "tfplan",
+        };
+        const result = (0, scan_config_schema_1.validateScanConfiguration)(input);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.value.terraformJsonPath).toBe("./show.json");
+            expect(result.value.terraformPlanPath).toBe("tfplan");
+        }
+    });
+    it("accepts terraformStackSectionPathDepth when positive integer", () => {
+        const input = {
+            enableAPIDetection: true,
+            enableDatabaseDetection: true,
+            enableDataFlowDetection: true,
+            minimumConfidence: 0.5,
+            terraformStackSectionPathDepth: 2,
+        };
+        const result = (0, scan_config_schema_1.validateScanConfiguration)(input);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.value.terraformStackSectionPathDepth).toBe(2);
+        }
+    });
+    it("rejects non-positive terraformStackSectionPathDepth", () => {
+        const input = {
+            enableAPIDetection: true,
+            enableDatabaseDetection: true,
+            enableDataFlowDetection: true,
+            minimumConfidence: 0.5,
+            terraformStackSectionPathDepth: 0,
+        };
+        const result = (0, scan_config_schema_1.validateScanConfiguration)(input);
+        expect(result.ok).toBe(false);
+    });
+    it("accepts workspace key + preflight job for platform AI", () => {
+        const input = {
+            enableAPIDetection: true,
+            enableDatabaseDetection: true,
+            enableDataFlowDetection: true,
+            minimumConfidence: 0.5,
+            enableAiInference: true,
+            workspaceApiKey: "dp_live_1234567890abcdef",
+            cliQuotaJobId: "8fb246ac-9b92-4809-a901-602615c97eda",
+            aiMode: "platform",
+        };
+        const result = (0, scan_config_schema_1.validateScanConfiguration)(input);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.value.workspaceApiKey).toBe("dp_live_1234567890abcdef");
+            expect(result.value.cliQuotaJobId).toBe("8fb246ac-9b92-4809-a901-602615c97eda");
+        }
+    });
+});

package/dist/tests/schema/scan-result.schema.spec.d.ts

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

package/dist/tests/schema/scan-result.schema.spec.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scan_result_schema_1 = require("../../src/core/schema/scan-result.schema");
+describe("scanResultSchema", () => {
+    it("accepts a minimal valid scan result", () => {
+        const input = {
+            components: [
+                {
+                    id: "comp-1",
+                    name: "Application",
+                    type: "asset",
+                    confidence: 0.9,
+                    detectedFrom: [],
+                    sourceLocations: [],
+                    properties: {},
+                },
+            ],
+            dataFlows: [],
+            filesScanned: 10,
+            filesSkipped: 0,
+            totalLines: 100,
+            scanDurationMs: 50,
+            warnings: [],
+            errors: [],
+        };
+        const result = (0, scan_result_schema_1.validateScanResult)(input);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.value.components[0].id).toBe("comp-1");
+        }
+    });
+    it("rejects invalid numeric fields", () => {
+        const input = {
+            components: [],
+            dataFlows: [],
+            filesScanned: -1,
+            filesSkipped: 0,
+            totalLines: 100,
+            scanDurationMs: 50,
+            warnings: [],
+            errors: [],
+        };
+        const result = (0, scan_result_schema_1.validateScanResult)(input);
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            const message = result.errors.join(" | ");
+            expect(message).toMatch(/filesScanned/);
+        }
+    });
+    it("accepts python in file info schema", () => {
+        const input = {
+            path: "service/app.py",
+            name: "app.py",
+            content: "print('ok')",
+            language: "python",
+            size: 11,
+        };
+        const result = scan_result_schema_1.fileInfoSchema.safeParse(input);
+        expect(result.success).toBe(true);
+    });
+    it("accepts third-party property coverage in aiInferenceSummary", () => {
+        const input = {
+            components: [],
+            dataFlows: [],
+            filesScanned: 1,
+            filesSkipped: 0,
+            totalLines: 1,
+            scanDurationMs: 5,
+            warnings: [],
+            errors: [],
+            aiInferenceSummary: {
+                ran: true,
+                candidatesConsidered: 2,
+                proposalsGenerated: 2,
+                proposalsApplied: 1,
+                proposalsRejected: 1,
+                proposalsGeneratedHeuristic: 1,
+                proposalsAppliedHeuristic: 1,
+                proposalsGeneratedProvider: 1,
+                proposalsAppliedProvider: 0,
+                providerCalls: 1,
+                inputTokens: 10,
+                outputTokens: 4,
+                totalTokens: 14,
+                aiProvider: "openai",
+                aiModel: "gpt",
+                thirdPartyPropertyCoverage: {
+                    autofilled: { vendor: 1 },
+                    suggested: { api_type: 1 },
+                    unknown: { vendor_soc2_iso27001: 3 },
+                },
+                agenticTrace: [
+                    {
+                        candidateId: "cand_1",
+                        componentId: "tp_1",
+                        filesReviewed: ["src/payments.ts"],
+                        rounds: 2,
+                        finalProposalCount: 1,
+                        toolCalls: [
+                            {
+                                round: 1,
+                                action: "search_text",
+                                detail: "Search term: stripe",
+                                filesTouched: ["src/payments.ts"],
+                                stats: { hits: 1 },
+                            },
+                        ],
+                    },
+                ],
+            },
+        };
+        const result = (0, scan_result_schema_1.validateScanResult)(input);
+        expect(result.ok).toBe(true);
+    });
+    it("accepts third-party data flow summary in aiInferenceSummary", () => {
+        const input = {
+            components: [],
+            dataFlows: [],
+            filesScanned: 1,
+            filesSkipped: 0,
+            totalLines: 1,
+            scanDurationMs: 5,
+            warnings: [],
+            errors: [],
+            aiInferenceSummary: {
+                ran: true,
+                candidatesConsidered: 1,
+                proposalsGenerated: 1,
+                proposalsApplied: 1,
+                proposalsRejected: 0,
+                proposalsGeneratedHeuristic: 0,
+                proposalsAppliedHeuristic: 0,
+                proposalsGeneratedProvider: 1,
+                proposalsAppliedProvider: 1,
+                providerCalls: 1,
+                inputTokens: 8,
+                outputTokens: 5,
+                totalTokens: 13,
+                aiProvider: "openai",
+                aiModel: "gpt",
+                thirdPartyDataFlow: {
+                    entries: [
+                        {
+                            componentId: "cmp_tp_1",
+                            componentName: "Supabase",
+                            capabilities: ["auth", "storage"],
+                            direction: "outbound_to_third_party",
+                            dataShared: [
+                                {
+                                    category: "credentials",
+                                    labels: ["user_email", "user_password"],
+                                },
+                            ],
+                            confidence: 0.89,
+                            confidenceBand: "high",
+                            source: "provider_plus_heuristic",
+                            evidence: [
+                                {
+                                    filePath: "src/auth/supabase.ts",
+                                    startLine: 12,
+                                    endLine: 12,
+                                    reason: "matched credentials signal",
+                                },
+                            ],
+                        },
+                    ],
+                    totals: {
+                        thirdPartiesAnalyzed: 1,
+                        withDataShared: 1,
+                    },
+                },
+            },
+        };
+        const result = (0, scan_result_schema_1.validateScanResult)(input);
+        expect(result.ok).toBe(true);
+    });
+});

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

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