@dataparade/cli 0.0.1

package/dist/tests/unit/data-flow/rewire.spec.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rewire_1 = require("../../../src/data-flow/rewire");
+function makeComponent(overrides) {
+    return {
+        id: overrides.id,
+        name: overrides.name,
+        type: overrides.type,
+        subType: overrides.subType,
+        confidence: overrides.confidence ?? 0.9,
+        detectedFrom: overrides.detectedFrom ?? [],
+        sourceLocations: overrides.sourceLocations ?? [],
+        properties: overrides.properties ?? {},
+        description: overrides.description,
+        dataFlowIds: overrides.dataFlowIds,
+    };
+}
+function makeFlow(flow) {
+    return {
+        confidence: 0.8,
+        ...flow,
+    };
+}
+describe("data-flow/rewire - rewireFlowsThroughApplication", () => {
+    it("rewires actor → infra to actor → Application and Application → target", () => {
+        const components = [
+            makeComponent({
+                id: "app_1",
+                name: "Application",
+                type: "asset",
+                subType: "service",
+                properties: { isMainApplication: true },
+            }),
+            makeComponent({
+                id: "actor_1",
+                name: "User",
+                type: "actor",
+            }),
+            makeComponent({
+                id: "tp_1",
+                name: "Stripe",
+                type: "third_party",
+            }),
+        ];
+        const flows = [
+            makeFlow({
+                id: "f1",
+                sourceComponentId: "actor_1",
+                targetComponentId: "tp_1",
+                type: "api_call",
+            }),
+        ];
+        const result = (0, rewire_1.rewireFlowsThroughApplication)(components, flows);
+        const actorToApp = result.filter((f) => f.sourceComponentId === "actor_1" && f.targetComponentId === "app_1");
+        const appToTp = result.filter((f) => f.sourceComponentId === "app_1" && f.targetComponentId === "tp_1");
+        expect(actorToApp).toHaveLength(1);
+        expect(appToTp).toHaveLength(1);
+        expect(result).toHaveLength(2);
+    });
+    it("leaves flows unchanged when no Application component exists", () => {
+        const components = [
+            makeComponent({ id: "tp_1", name: "Stripe", type: "third_party" }),
+        ];
+        const flows = [
+            makeFlow({
+                id: "f1",
+                sourceComponentId: "actor_1",
+                targetComponentId: "tp_1",
+                type: "api_call",
+            }),
+        ];
+        const result = (0, rewire_1.rewireFlowsThroughApplication)(components, flows);
+        expect(result).toEqual(flows);
+    });
+    it("does not duplicate Application → target when such flow already exists", () => {
+        const components = [
+            makeComponent({
+                id: "app_1",
+                name: "Application",
+                type: "asset",
+                properties: { isMainApplication: true },
+            }),
+            makeComponent({ id: "actor_1", name: "User", type: "actor" }),
+            makeComponent({ id: "tp_1", name: "Stripe", type: "third_party" }),
+        ];
+        const flows = [
+            makeFlow({
+                id: "f1",
+                sourceComponentId: "actor_1",
+                targetComponentId: "tp_1",
+                type: "api_call",
+            }),
+            makeFlow({
+                id: "f2",
+                sourceComponentId: "app_1",
+                targetComponentId: "tp_1",
+                type: "api_call",
+            }),
+        ];
+        const result = (0, rewire_1.rewireFlowsThroughApplication)(components, flows);
+        const appToTp = result.filter((f) => f.sourceComponentId === "app_1" && f.targetComponentId === "tp_1");
+        expect(appToTp).toHaveLength(1);
+        expect(result).toHaveLength(2);
+    });
+    it("uses first api/service asset as Application when isMainApplication is not set", () => {
+        const components = [
+            makeComponent({
+                id: "app_1",
+                name: "API",
+                type: "asset",
+                subType: "api",
+            }),
+            makeComponent({ id: "actor_1", name: "User", type: "actor" }),
+            makeComponent({ id: "tp_1", name: "Stripe", type: "third_party" }),
+        ];
+        const flows = [
+            makeFlow({
+                id: "f1",
+                sourceComponentId: "actor_1",
+                targetComponentId: "tp_1",
+                type: "api_call",
+            }),
+        ];
+        const result = (0, rewire_1.rewireFlowsThroughApplication)(components, flows);
+        expect(result.some((f) => f.targetComponentId === "app_1")).toBe(true);
+        expect(result.some((f) => f.sourceComponentId === "app_1" && f.targetComponentId === "tp_1")).toBe(true);
+    });
+    it("routes synthetic project main → cloud provider (not direct) for Terraform assets", () => {
+        const components = [
+            makeComponent({
+                id: "main_1",
+                name: "learn-terraform-lambda-api-gateway-main",
+                type: "asset",
+                subType: "application",
+                properties: {
+                    isMainApplication: true,
+                    sourceContext: "injected_project_placeholder",
+                    section_id: "root",
+                },
+            }),
+            makeComponent({
+                id: "actor_1",
+                name: "User",
+                type: "actor",
+                properties: { section_id: "root" },
+            }),
+            makeComponent({
+                id: "tp_aws",
+                name: "Amazon Web Services",
+                type: "third_party",
+                properties: {
+                    terraform_address: "provider.aws",
+                    section_id: "root",
+                },
+            }),
+            makeComponent({
+                id: "s3_1",
+                name: "lambda_bucket (aws_s3_bucket)",
+                type: "asset",
+                subType: "storage",
+                properties: {
+                    terraform_address: "aws_s3_bucket.lambda_bucket",
+                    resource_type: "aws_s3_bucket",
+                    section_id: "root",
+                },
+            }),
+        ];
+        const flows = [
+            makeFlow({
+                id: "f1",
+                sourceComponentId: "actor_1",
+                targetComponentId: "s3_1",
+                type: "api_call",
+            }),
+            makeFlow({
+                id: "f2",
+                sourceComponentId: "tp_aws",
+                targetComponentId: "s3_1",
+                type: "api_call",
+            }),
+        ];
+        const result = (0, rewire_1.rewireFlowsThroughApplication)(components, flows);
+        expect(result.some((f) => f.sourceComponentId === "actor_1" &&
+            f.targetComponentId === "main_1" &&
+            f.type === "api_call")).toBe(true);
+        expect(result.some((f) => f.sourceComponentId === "main_1" &&
+            f.targetComponentId === "tp_aws" &&
+            f.type === "api_call")).toBe(true);
+        expect(result.some((f) => f.sourceComponentId === "tp_aws" &&
+            f.targetComponentId === "s3_1" &&
+            f.type === "api_call")).toBe(true);
+        expect(result.some((f) => f.sourceComponentId === "main_1" && f.targetComponentId === "s3_1")).toBe(false);
+    });
+});

package/dist/tests/unit/data-flow/terraform-flows.spec.d.ts

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

package/dist/tests/unit/data-flow/terraform-flows.spec.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const terraform_flows_1 = require("../../../src/data-flow/terraform-flows");
+const fallbacks_1 = require("../../../src/ai-enrichment/fallbacks");
+describe("data-flow/terraform-flows", () => {
+    it("findTerraformProviderForResourceAsset maps aws_* resource types to provider.aws", () => {
+        const awsProv = {
+            id: "tp_aws",
+            name: "AWS",
+            type: "third_party",
+            subType: "saas_service",
+            confidence: 1,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: { terraform_address: "provider.aws" },
+        };
+        const bucket = {
+            id: "s3",
+            name: "b",
+            type: "asset",
+            subType: "storage",
+            confidence: 1,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: {
+                terraform_address: "aws_s3_bucket.x",
+                resource_type: "aws_s3_bucket",
+            },
+        };
+        const hit = (0, terraform_flows_1.findTerraformProviderForResourceAsset)([awsProv, bucket], bucket);
+        expect(hit?.id).toBe("tp_aws");
+    });
+    it("appendTerraformBareProviderAttachmentFlows skips module-qualified resource addresses", () => {
+        const aws = {
+            id: "cmp_aws",
+            name: "Amazon Web Services",
+            type: "third_party",
+            subType: "cloud_provider",
+            confidence: 0.92,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: { terraform_address: "provider.aws" },
+        };
+        const role = {
+            id: "cmp_role",
+            name: "ecs_execution",
+            type: "asset",
+            subType: "iam",
+            confidence: 0.9,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: {
+                terraform_address: "module.ecs.aws_iam_role.execution",
+                resource_type: "aws_iam_role",
+            },
+        };
+        const flows = [];
+        const pairKeys = new Set();
+        (0, terraform_flows_1.appendTerraformBareProviderAttachmentFlows)({
+            components: [aws, role],
+            flows,
+            pairKeys,
+        });
+        expect(flows).toHaveLength(0);
+    });
+    it("creates database_query from lambda to db when references match addresses", () => {
+        const db = {
+            id: "cmp_db",
+            name: "Aws Db Instance Main",
+            type: "asset",
+            subType: "database",
+            confidence: 0.9,
+            detectedFrom: [],
+            sourceLocations: [{ filePath: "main.tf", startLine: 5, endLine: 10 }],
+            properties: { terraform_address: "aws_db_instance.main" },
+        };
+        const lambda = {
+            id: "cmp_lambda",
+            name: "Aws Lambda Function Api",
+            type: "asset",
+            subType: "function",
+            confidence: 0.9,
+            detectedFrom: [],
+            sourceLocations: [{ filePath: "main.tf", startLine: 20, endLine: 35 }],
+            properties: {
+                terraform_address: "aws_lambda_function.api",
+                terraform_references: ["aws_db_instance.main"],
+            },
+        };
+        const { flows, nextIndex } = (0, terraform_flows_1.appendTerraformDataFlows)([db, lambda], 0);
+        expect(flows).toHaveLength(1);
+        expect(flows[0].sourceComponentId).toBe("cmp_lambda");
+        expect(flows[0].targetComponentId).toBe("cmp_db");
+        expect(flows[0].type).toBe("database_query");
+        expect(nextIndex).toBe(1);
+    });
+    it("creates dependency-direction edges for non-database references (referenced → referrer)", () => {
+        const idGen = {
+            id: "cmp_idgen",
+            name: "Widget Factory Code Seed",
+            type: "asset",
+            subType: "application",
+            confidence: 0.9,
+            detectedFrom: [],
+            sourceLocations: [{ filePath: "main.tf", startLine: 1, endLine: 5 }],
+            properties: { terraform_address: "widget_factory.code_seed" },
+        };
+        const bucket = {
+            id: "cmp_bucket",
+            name: "Aws S3 Bucket",
+            type: "asset",
+            subType: "storage",
+            confidence: 0.9,
+            detectedFrom: [],
+            sourceLocations: [{ filePath: "main.tf", startLine: 10, endLine: 15 }],
+            properties: {
+                terraform_address: "aws_s3_bucket.data_store",
+                terraform_references: ["widget_factory.code_seed"],
+            },
+        };
+        const { flows } = (0, terraform_flows_1.appendTerraformDataFlows)([idGen, bucket], 0);
+        expect(flows).toHaveLength(1);
+        expect(flows[0].sourceComponentId).toBe("cmp_idgen");
+        expect(flows[0].targetComponentId).toBe("cmp_bucket");
+        expect(flows[0].type).toBe("api_call");
+    });
+    it("links aws_* resources to provider.aws via applyDeterministicInferenceFallbacks (bare attachment)", () => {
+        const aws = {
+            id: "cmp_aws",
+            name: "Amazon Web Services",
+            type: "third_party",
+            subType: "cloud_provider",
+            confidence: 0.92,
+            detectedFrom: [],
+            sourceLocations: [{ filePath: "main.tf", startLine: 1, endLine: 5 }],
+            properties: {
+                terraform_address: "provider.aws",
+                provider_name: "aws",
+            },
+        };
+        const bucket = {
+            id: "cmp_bucket",
+            name: "lambda_bucket (aws_s3_bucket)",
+            type: "asset",
+            subType: "storage",
+            confidence: 0.9,
+            detectedFrom: [],
+            sourceLocations: [{ filePath: "main.tf", startLine: 10, endLine: 15 }],
+            properties: {
+                terraform_address: "aws_s3_bucket.lambda_bucket",
+                resource_type: "aws_s3_bucket",
+                block_name: "lambda_bucket",
+            },
+        };
+        const { dataFlows, components: out } = (0, fallbacks_1.applyDeterministicInferenceFallbacks)([aws, bucket], []);
+        const edge = dataFlows.find((f) => f.sourceComponentId === "cmp_aws" && f.targetComponentId === "cmp_bucket");
+        expect(edge).toBeDefined();
+        expect(edge?.type).toBe("file_transfer");
+        const b = out.find((c) => c.id === "cmp_bucket");
+        expect(b?.properties.managed_by_provider).toBe("cmp_aws");
+        expect(b?.properties.managed_service_key).toBe("s3");
+        expect(b?.name).toBe("Aws S3");
+    });
+    it("appendTerraformBareProviderAttachmentFlows skips topology-managed assets", () => {
+        const aws = {
+            id: "cmp_aws",
+            name: "Amazon Web Services",
+            type: "third_party",
+            subType: "cloud_provider",
+            confidence: 0.92,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: { terraform_address: "provider.aws", provider_name: "aws" },
+        };
+        const bucket = {
+            id: "cmp_bucket",
+            name: "Aws S3",
+            type: "asset",
+            subType: "file_storage",
+            confidence: 0.9,
+            detectedFrom: [],
+            sourceLocations: [],
+            properties: {
+                terraform_address: "aws_s3_bucket.x",
+                resource_type: "aws_s3_bucket",
+                managed_by_provider: "cmp_aws",
+                managed_service_key: "s3",
+            },
+        };
+        const flows = [];
+        const pairKeys = new Set();
+        (0, terraform_flows_1.appendTerraformBareProviderAttachmentFlows)({
+            components: [aws, bucket],
+            flows,
+            pairKeys,
+        });
+        expect(flows).toHaveLength(0);
+    });
+});

package/dist/tests/unit/evals/metrics.spec.d.ts

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

package/dist/tests/unit/evals/metrics.spec.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metrics_1 = require("../../../src/evals/metrics");
+describe("eval metrics", () => {
+    it("computes property and interaction KPIs", () => {
+        const components = [
+            {
+                id: "front",
+                name: "Frontend",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: {
+                    section_id: "frontend",
+                    encryption_at_rest: null,
+                    authentication_methods: [],
+                    gdpr_role: null,
+                },
+            },
+            {
+                id: "back",
+                name: "Backend",
+                type: "asset",
+                confidence: 0.9,
+                detectedFrom: [],
+                sourceLocations: [],
+                properties: {
+                    section_id: "backend",
+                    encryption_at_rest: true,
+                    authentication_methods: ["jwt"],
+                    gdpr_role: "processor",
+                },
+            },
+        ];
+        const flows = [
+            {
+                id: "flow_1",
+                sourceComponentId: "front",
+                targetComponentId: "back",
+                type: "api_call",
+                confidence: 0.9,
+            },
+        ];
+        const scores = (0, metrics_1.computeEvalScores)({
+            components,
+            dataFlows: flows,
+            expectedCrossSectionLinks: [{ sourceSection: "frontend", targetSection: "backend" }],
+        });
+        expect(scores.nodePropertyFillRate).toBeGreaterThan(0);
+        expect(scores.tieredPropertyCompleteness).toBeGreaterThan(0);
+        expect(scores.interactionRecall).toBe(1);
+    });
+});

package/dist/tests/unit/ingest/env-exclusion.spec.d.ts

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

package/dist/tests/unit/ingest/env-exclusion.spec.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const file_system_1 = require("../../../src/ingest/file-system");
+describe("ingest env exclusion", () => {
+    it("does not ingest .env files by default", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-env-exclude-"));
+        try {
+            fs_1.default.writeFileSync(path_1.default.join(root, "app.ts"), "export const x = 1;", "utf8");
+            fs_1.default.writeFileSync(path_1.default.join(root, ".env"), "API_KEY=secret", "utf8");
+            fs_1.default.writeFileSync(path_1.default.join(root, ".env.local"), "TOKEN=secret", "utf8");
+            const files = await (0, file_system_1.ingestFileSystem)(root);
+            const paths = files.map((f) => f.path);
+            expect(paths).toContain("app.ts");
+            expect(paths).not.toContain(".env");
+            expect(paths).not.toContain(".env.local");
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("does not ingest a single .env file path", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-env-single-"));
+        const warnings = [];
+        try {
+            const envPath = path_1.default.join(root, ".env");
+            fs_1.default.writeFileSync(envPath, "API_KEY=secret", "utf8");
+            const files = await (0, file_system_1.ingestFileSystem)(envPath, {
+                onWarning: (w) => warnings.push(w),
+            });
+            expect(files).toHaveLength(0);
+            expect(warnings.some((w) => w.includes("excluded for security"))).toBe(true);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/unit/ingest/file-system.spec.d.ts

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