@dataparade/cli 0.0.1

package/dist/tests/unit/core/invariant-tests-dedupe-determinism.spec.d.ts

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

package/dist/tests/unit/core/invariant-tests-dedupe-determinism.spec.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const graph_mapping_1 = require("../../../src/core/pipeline/graph-mapping");
+const orchestrator_1 = require("../../../src/core/pipeline/orchestrator");
+const dedupe_1 = require("../../../src/data-flow/dedupe");
+function shuffleDeterministic(arr, mode) {
+    // Avoid randomness to keep the test stable across runs.
+    if (mode === 1)
+        return [...arr].reverse();
+    // mode 2: rotate by 1
+    if (arr.length <= 1)
+        return arr;
+    return [arr[arr.length - 1], ...arr.slice(0, -1)];
+}
+describe("invariant-tests - determinism", () => {
+    it("scan() twice produces identical graph outputs", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-basic");
+        const config = (0, orchestrator_1.createDefaultScanConfiguration)({
+            deepAnalysis: false,
+        });
+        const { scanResult: scanResult1 } = await (0, orchestrator_1.scan)(fixturesRoot, config);
+        const { scanResult: scanResult2 } = await (0, orchestrator_1.scan)(fixturesRoot, config);
+        const graph1 = (0, graph_mapping_1.buildDiagramGraphFromScanResult)(scanResult1);
+        const graph2 = (0, graph_mapping_1.buildDiagramGraphFromScanResult)(scanResult2);
+        expect(graph1).toEqual(graph2);
+    });
+    it("dedupeDataFlows output is order-independent", () => {
+        const baseFlows = [
+            {
+                id: "flow_1",
+                sourceComponentId: "app",
+                targetComponentId: "db",
+                type: "database_query",
+                confidence: 0.7,
+                sourceLocation: { filePath: "src/db.ts", startLine: 20, endLine: 21 },
+            },
+            {
+                id: "flow_2",
+                sourceComponentId: "app",
+                targetComponentId: "db",
+                type: "database_query",
+                confidence: 0.9,
+                sourceLocation: { filePath: "src/db.ts", startLine: 10, endLine: 11 },
+            },
+            {
+                id: "flow_3",
+                sourceComponentId: "app",
+                targetComponentId: "db2",
+                type: "database_query",
+                confidence: 0.8,
+                sourceLocation: { filePath: "src/db2.ts", startLine: 5, endLine: 6 },
+            },
+        ];
+        const dedupedA = (0, dedupe_1.dedupeDataFlows)(baseFlows);
+        const dedupedB = (0, dedupe_1.dedupeDataFlows)(shuffleDeterministic(baseFlows, 1));
+        const dedupedC = (0, dedupe_1.dedupeDataFlows)(shuffleDeterministic(baseFlows, 2));
+        expect(dedupedA).toEqual(dedupedB);
+        expect(dedupedA).toEqual(dedupedC);
+    });
+});

package/dist/tests/unit/core/manifest-package-hub.spec.d.ts

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

package/dist/tests/unit/core/manifest-package-hub.spec.js

@@ -0,0 +1,53 @@
+"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 discover_service_sections_1 = require("../../../src/core/sectioning/discover-service-sections");
+const classify_1 = require("../../../src/classifier/classify");
+const application_injection_1 = require("../../../src/classifier/application-injection");
+const enhance_1 = require("../../../src/classifier/enhance");
+const dependency_manifests_1 = require("../../../src/analyzers/typescript/dependency-manifests");
+const discover_service_sections_2 = require("../../../src/core/sectioning/discover-service-sections");
+const data_flow_1 = require("../../../src/data-flow");
+function write(p, content) {
+    fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+    fs_1.default.writeFileSync(p, content, "utf8");
+}
+describe("manifest package hub", () => {
+    it("creates twenty-companion hub and declared edge to Anthropic from package.json", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-companion-"));
+        try {
+            write(path_1.default.join(root, "packages", "twenty-companion", "package.json"), JSON.stringify({
+                name: "twenty-companion",
+                dependencies: {
+                    "@anthropic-ai/sdk": "^0.30.0",
+                },
+            }));
+            const { sections } = await (0, discover_service_sections_1.discoverServiceSections)(root);
+            const manifestFindings = await (0, dependency_manifests_1.detectTypeScriptPatternsFromDependencyManifests)(root);
+            (0, discover_service_sections_2.tagFindingsWithServiceSections)(manifestFindings, sections);
+            const classified = (0, classify_1.classifyRawFindings)(manifestFindings);
+            const withHub = (0, application_injection_1.injectApplicationAssetsPerSectionIfMissing)(classified, sections);
+            const enhanced = (0, enhance_1.enhanceComponents)(withHub);
+            const flows = (0, data_flow_1.detectDataFlows)([], enhanced, manifestFindings, sections);
+            const hub = enhanced.find((c) => c.properties?.section_id === "packages/twenty-companion" &&
+                c.properties?.isMainApplication === true);
+            const anthropic = enhanced.find((c) => c.type === "third_party" &&
+                c.properties?.section_id === "packages/twenty-companion" &&
+                c.name.toLowerCase().includes("anthropic"));
+            expect(hub?.name).toBe("twenty-companion");
+            expect(anthropic).toBeDefined();
+            const declared = flows.find((f) => f.sourceComponentId === hub?.id &&
+                f.targetComponentId === anthropic?.id);
+            expect(declared).toBeDefined();
+            expect(declared?.enrichmentNotes).toBe("declared_dependency");
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/unit/core/monorepo-package-sections.spec.d.ts

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

package/dist/tests/unit/core/monorepo-package-sections.spec.js

@@ -0,0 +1,121 @@
+"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 discover_service_sections_1 = require("../../../src/core/sectioning/discover-service-sections");
+const application_injection_1 = require("../../../src/classifier/application-injection");
+function write(p, content) {
+    fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+    fs_1.default.writeFileSync(p, content, "utf8");
+}
+describe("monorepo package sections", () => {
+    it("inferMonorepoPackageSectionPathDepth picks shallowest depth with multiple packages", () => {
+        expect((0, discover_service_sections_1.inferMonorepoPackageSectionPathDepth)([
+            "packages/server/package.json",
+            "packages/front/package.json",
+            "packages/apps/nested/package.json",
+        ])).toBe(2);
+    });
+    it("rollupSectionIdToMonorepoDepth trims nested package paths", () => {
+        expect((0, discover_service_sections_1.rollupSectionIdToMonorepoDepth)("packages/apps/nested", 2)).toBe("packages/apps");
+    });
+    it("uses package.json name for section label and rolls up nested packages", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-mono-"));
+        try {
+            write(path_1.default.join(root, "packages", "twenty-server", "package.json"), JSON.stringify({ name: "@twenty/twenty-server" }));
+            write(path_1.default.join(root, "packages", "twenty-front", "package.json"), JSON.stringify({ name: "@twenty/twenty-front" }));
+            write(path_1.default.join(root, "packages", "twenty-apps", "hello", "package.json"), JSON.stringify({ name: "@twenty/hello-app" }));
+            write(path_1.default.join(root, "packages", "twenty-apps", "hello", "src", "routes.ts"), "export const x = 1;\n");
+            const { sections, inferredMonorepoPackageSectionPathDepth } = await (0, discover_service_sections_1.discoverServiceSections)(root);
+            expect(inferredMonorepoPackageSectionPathDepth).toBe(2);
+            const server = sections.find((s) => s.id === "packages/twenty-server");
+            expect(server?.label).toBe("twenty-server");
+            expect(server?.isPrimaryMonorepoPackage).toBe(true);
+            const appsParent = sections.find((s) => s.id === "packages/twenty-apps");
+            expect(appsParent).toBeDefined();
+            expect(appsParent?.isPrimaryMonorepoPackage).toBe(true);
+            const nested = sections.find((s) => s.id === "packages/twenty-apps/hello");
+            expect(nested?.isPrimaryMonorepoPackage).toBe(false);
+            const findings = [
+                {
+                    pattern: "express_route",
+                    name: "GET /hello",
+                    confidence: 0.9,
+                    location: {
+                        filePath: "packages/twenty-apps/hello/src/routes.ts",
+                        startLine: 1,
+                        endLine: 1,
+                    },
+                    properties: {},
+                },
+            ];
+            (0, discover_service_sections_1.tagFindingsWithServiceSections)(findings, sections, {
+                monorepoPackageSectionPathDepth: 2,
+            });
+            expect(findings[0]?.properties.section_id).toBe("packages/twenty-apps");
+            expect(findings[0]?.properties.section_label).toBe("twenty-apps");
+            expect(findings[0]?.properties.package_name).toBeUndefined();
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("discoverServiceSections honors explicit monorepoPackageSectionPathDepth override", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-mono-depth-"));
+        try {
+            write(path_1.default.join(root, "packages", "twenty-server", "package.json"), JSON.stringify({ name: "twenty-server" }));
+            write(path_1.default.join(root, "packages", "twenty-apps", "hello", "package.json"), JSON.stringify({ name: "hello" }));
+            const at2 = await (0, discover_service_sections_1.discoverServiceSections)(root, {
+                monorepoPackageSectionPathDepth: 2,
+            });
+            const helloAt2 = at2.sections.find((s) => s.id === "packages/twenty-apps/hello");
+            expect(helloAt2?.isPrimaryMonorepoPackage).toBe(false);
+            const at3 = await (0, discover_service_sections_1.discoverServiceSections)(root, {
+                monorepoPackageSectionPathDepth: 3,
+            });
+            const helloAt3 = at3.sections.find((s) => s.id === "packages/twenty-apps/hello");
+            expect(helloAt3?.isPrimaryMonorepoPackage).toBe(true);
+            expect(at3.monorepoPackageSectionPathDepth).toBe(3);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("injectApplicationAssetsPerSectionIfMissing only targets primary workspace packages", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-mono-inj-"));
+        try {
+            write(path_1.default.join(root, "packages", "api", "package.json"), JSON.stringify({ name: "api" }));
+            write(path_1.default.join(root, "packages", "ui", "package.json"), JSON.stringify({ name: "ui" }));
+            write(path_1.default.join(root, "packages", "ui", "widget", "package.json"), JSON.stringify({ name: "widget" }));
+            write(path_1.default.join(root, "packages", "docs", "package.json"), JSON.stringify({ name: "docs" }));
+            const { sections } = await (0, discover_service_sections_1.discoverServiceSections)(root);
+            const injected = (0, application_injection_1.injectApplicationAssetsPerSectionIfMissing)([
+                {
+                    id: "cmp_1",
+                    name: "Postgres",
+                    type: "asset",
+                    subType: "database",
+                    confidence: 1,
+                    detectedFrom: [],
+                    sourceLocations: [],
+                    properties: { section_id: "packages/api" },
+                },
+            ], sections, { projectName: "ignored" });
+            const placeholderIds = injected
+                .filter((c) => c.properties?.sourceContext === "injected_project_placeholder")
+                .map((c) => c.properties?.section_id)
+                .sort();
+            expect(placeholderIds).toEqual(["packages/api"]);
+            expect(placeholderIds).not.toContain("packages/ui");
+            expect(placeholderIds).not.toContain("packages/ui/widget");
+            expect(placeholderIds).not.toContain("packages/docs");
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/unit/core/no-source-code-leakage.spec.d.ts

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

package/dist/tests/unit/core/no-source-code-leakage.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const graph_mapping_1 = require("../../../src/core/pipeline/graph-mapping");
+const orchestrator_1 = require("../../../src/core/pipeline/orchestrator");
+const path_1 = __importDefault(require("path"));
+function graphNodesContainCodeKey(graph) {
+    const visited = new Set();
+    const walk = (value) => {
+        if (value === null || value === undefined)
+            return false;
+        if (typeof value !== "object")
+            return false;
+        if (visited.has(value))
+            return false;
+        visited.add(value);
+        if (Array.isArray(value)) {
+            for (const v of value) {
+                if (walk(v))
+                    return true;
+            }
+            return false;
+        }
+        for (const [k, v] of Object.entries(value)) {
+            if (k === "code")
+                return true;
+            if (walk(v))
+                return true;
+        }
+        return false;
+    };
+    for (const node of graph.nodes) {
+        if (node?.data && walk(node.data))
+            return true;
+    }
+    return false;
+}
+describe("output safety - no source code leakage (DP-P0-CLI-XXX)", () => {
+    it("does not emit `code` under graph.nodes[].data", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-basic");
+        const config = (0, orchestrator_1.createDefaultScanConfiguration)();
+        const { scanResult } = await (0, orchestrator_1.scan)(fixturesRoot, config);
+        const graph = (0, graph_mapping_1.buildDiagramGraphFromScanResult)(scanResult);
+        expect(graphNodesContainCodeKey(graph)).toBe(false);
+    });
+});

package/dist/tests/unit/core/orchestrator.spec.d.ts

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

package/dist/tests/unit/core/orchestrator.spec.js

@@ -0,0 +1,252 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
+const orchestrator_1 = require("../../../src/core/pipeline/orchestrator");
+describe("core/pipeline/orchestrator - DP-P0-CLI-401", () => {
+    it("runs the full structural pipeline for the typescript-basic fixture", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-basic");
+        const config = (0, orchestrator_1.createDefaultScanConfiguration)();
+        const { scanResult } = await (0, orchestrator_1.scan)(fixturesRoot, config);
+        expect(scanResult.components.length).toBeGreaterThan(0);
+        expect(scanResult.dataFlows.length).toBeGreaterThan(0);
+        expect(scanResult.filesScanned).toBeGreaterThan(0);
+        expect(scanResult.totalLines).toBeGreaterThan(0);
+        expect(scanResult.scanDurationMs).toBeGreaterThanOrEqual(0);
+        expect(Array.isArray(scanResult.errors)).toBe(true);
+        expect(Array.isArray(scanResult.warnings)).toBe(true);
+    });
+    it("enables Terraform and monorepo package section auto-inference by default", () => {
+        const config = (0, orchestrator_1.createDefaultScanConfiguration)();
+        expect(config.autoInferTerraformStackSectionPathDepth).toBe(true);
+        expect(config.terraformStackSectionPathDepth).toBeUndefined();
+        expect(config.autoInferMonorepoPackageSectionPathDepth).toBe(true);
+        expect(config.monorepoPackageSectionPathDepth).toBe(2);
+    });
+    it("honors excludePaths by reducing the number of scanned files", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-basic");
+        const baselineConfig = (0, orchestrator_1.createDefaultScanConfiguration)();
+        const { scanResult: baseline } = await (0, orchestrator_1.scan)(fixturesRoot, baselineConfig);
+        const configWithExcludes = (0, orchestrator_1.createDefaultScanConfiguration)({
+            excludePaths: ["**/db.ts"],
+        });
+        const { scanResult: withExcludes } = await (0, orchestrator_1.scan)(fixturesRoot, configWithExcludes);
+        expect(withExcludes.filesScanned).toBeLessThanOrEqual(baseline.filesScanned);
+    });
+    it("supports ? wildcard in excludePaths patterns", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-basic");
+        const baselineConfig = (0, orchestrator_1.createDefaultScanConfiguration)();
+        const { files: baselineFiles } = await (0, orchestrator_1.scan)(fixturesRoot, baselineConfig);
+        const configWithQuestionGlob = (0, orchestrator_1.createDefaultScanConfiguration)({
+            excludePaths: ["d?.ts"],
+        });
+        const { files: withQuestionGlob } = await (0, orchestrator_1.scan)(fixturesRoot, configWithQuestionGlob);
+        const baselineHasDbTs = baselineFiles.some((file) => file.path.endsWith("db.ts"));
+        const withQuestionGlobHasDbTs = withQuestionGlob.some((file) => file.path.endsWith("db.ts"));
+        expect(baselineHasDbTs).toBe(true);
+        expect(withQuestionGlobHasDbTs).toBe(false);
+    });
+    it("filters files by languages when languages are specified", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-basic");
+        const baselineConfig = (0, orchestrator_1.createDefaultScanConfiguration)();
+        const { scanResult: baseline } = await (0, orchestrator_1.scan)(fixturesRoot, baselineConfig);
+        const configLanguagesOnlyTs = (0, orchestrator_1.createDefaultScanConfiguration)({
+            languages: ["typescript"],
+        });
+        const { scanResult: tsOnly } = await (0, orchestrator_1.scan)(fixturesRoot, configLanguagesOnlyTs);
+        expect(tsOnly.filesScanned).toBeLessThanOrEqual(baseline.filesScanned);
+    });
+    it("enforces minimumConfidence across findings, components, and flows", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-basic");
+        const baselineConfig = (0, orchestrator_1.createDefaultScanConfiguration)({
+            minimumConfidence: 0,
+        });
+        const { scanResult: baseline, findings: baselineFindings } = await (0, orchestrator_1.scan)(fixturesRoot, baselineConfig);
+        const strictConfig = (0, orchestrator_1.createDefaultScanConfiguration)({
+            minimumConfidence: 0.95,
+        });
+        const { scanResult: strict, findings: strictFindings } = await (0, orchestrator_1.scan)(fixturesRoot, strictConfig);
+        expect(strictFindings.every((f) => f.confidence >= 0.95)).toBe(true);
+        expect(strict.components.every((c) => c.confidence >= 0.95)).toBe(true);
+        expect(strict.dataFlows.every((f) => f.confidence >= 0.95)).toBe(true);
+        expect(strictFindings.length).toBeLessThanOrEqual(baselineFindings.length);
+        expect(strict.components.length).toBeLessThanOrEqual(baseline.components.length);
+        expect(strict.dataFlows.length).toBeLessThanOrEqual(baseline.dataFlows.length);
+    });
+    it("respects enableAPIDetection and enableDatabaseDetection", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-basic");
+        const baselineConfig = (0, orchestrator_1.createDefaultScanConfiguration)();
+        const { findings: baselineFindings } = await (0, orchestrator_1.scan)(fixturesRoot, baselineConfig);
+        const apiDisabledConfig = (0, orchestrator_1.createDefaultScanConfiguration)({
+            enableAPIDetection: false,
+        });
+        const { findings: apiDisabledFindings } = await (0, orchestrator_1.scan)(fixturesRoot, apiDisabledConfig);
+        const dbDisabledConfig = (0, orchestrator_1.createDefaultScanConfiguration)({
+            enableDatabaseDetection: false,
+        });
+        const { findings: dbDisabledFindings } = await (0, orchestrator_1.scan)(fixturesRoot, dbDisabledConfig);
+        const countByPattern = (pattern, findings) => findings.filter((f) => f.pattern === pattern).length;
+        expect(countByPattern("express_route", apiDisabledFindings)).toBeLessThanOrEqual(countByPattern("express_route", baselineFindings));
+        expect(countByPattern("database_connection", dbDisabledFindings)).toBeLessThanOrEqual(countByPattern("database_connection", baselineFindings));
+    });
+    it("emits ScanProgress events in the expected phase order", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-basic");
+        const config = (0, orchestrator_1.createDefaultScanConfiguration)();
+        const phases = [];
+        await (0, orchestrator_1.scan)(fixturesRoot, config, (progress) => {
+            phases.push(progress.phase);
+            expect(progress.progress).toBeGreaterThanOrEqual(0);
+            expect(progress.progress).toBeLessThanOrEqual(1);
+        });
+        // We expect at least one occurrence of each structural phase in order.
+        const phaseString = phases.join(">");
+        expect(phaseString.indexOf("ingest")).toBeGreaterThanOrEqual(0);
+        expect(phaseString.indexOf("analyze")).toBeGreaterThan(phaseString.indexOf("ingest"));
+        expect(phaseString.indexOf("classify")).toBeGreaterThan(phaseString.indexOf("analyze"));
+        expect(phaseString.indexOf("data_flow")).toBeGreaterThan(phaseString.indexOf("classify"));
+        expect(phaseString.lastIndexOf("output")).toBeGreaterThan(phaseString.indexOf("data_flow"));
+    });
+    it("detects third-party services from Python dependency manifests", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "python-dependency-manifests-basic");
+        const config = (0, orchestrator_1.createDefaultScanConfiguration)();
+        const { scanResult } = await (0, orchestrator_1.scan)(fixturesRoot, config);
+        const thirdParties = scanResult.components.filter((c) => c.type === "third_party");
+        const serviceNames = thirdParties
+            .map((c) => c.properties?.serviceName)
+            .filter((v) => typeof v === "string");
+        expect(serviceNames).toEqual(expect.arrayContaining(["openai", "sentry", "aws"]));
+        expect(serviceNames).not.toContain("anthropic");
+    });
+    it("detects third-party services from TypeScript dependency manifests", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-dependency-manifests-basic");
+        const config = (0, orchestrator_1.createDefaultScanConfiguration)();
+        const { scanResult } = await (0, orchestrator_1.scan)(fixturesRoot, config);
+        const thirdParties = scanResult.components.filter((c) => c.type === "third_party");
+        const serviceNames = thirdParties
+            .map((c) => c.properties?.serviceName)
+            .filter((v) => typeof v === "string");
+        expect(serviceNames).toEqual(expect.arrayContaining(["stripe", "sendgrid", "aws", "sentry"]));
+        expect(serviceNames).not.toContain("twilio");
+    });
+    it("applies excludePaths to manifest scanning and section derivation", async () => {
+        const root = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "dp-orch-excludes-"));
+        try {
+            await promises_1.default.mkdir(path_1.default.join(root, "sandbox-a"), { recursive: true });
+            await promises_1.default.mkdir(path_1.default.join(root, "sandbox-b"), { recursive: true });
+            await promises_1.default.mkdir(path_1.default.join(root, "src"), { recursive: true });
+            await promises_1.default.writeFile(path_1.default.join(root, "src", "app.ts"), 'export const app = "ok";\n');
+            await promises_1.default.writeFile(path_1.default.join(root, "sandbox-a", "package.json"), JSON.stringify({
+                name: "sandbox-a",
+                dependencies: { next: "14.0.0" },
+            }));
+            await promises_1.default.writeFile(path_1.default.join(root, "sandbox-b", "package.json"), JSON.stringify({
+                name: "sandbox-b",
+                dependencies: { react: "18.0.0" },
+            }));
+            const baselineConfig = (0, orchestrator_1.createDefaultScanConfiguration)({
+                minimumConfidence: 0,
+            });
+            const { scanResult: baseline } = await (0, orchestrator_1.scan)(root, baselineConfig);
+            const excludedConfig = (0, orchestrator_1.createDefaultScanConfiguration)({
+                minimumConfidence: 0,
+                excludePaths: ["sandbox-a/**", "sandbox-b/**"],
+            });
+            const { scanResult: excluded } = await (0, orchestrator_1.scan)(root, excludedConfig);
+            const sectionIdsBaseline = baseline.components
+                .map((c) => c.properties?.section_id)
+                .filter((v) => typeof v === "string");
+            const sectionIdsExcluded = excluded.components
+                .map((c) => c.properties?.section_id)
+                .filter((v) => typeof v === "string");
+            expect(sectionIdsBaseline).toEqual(expect.arrayContaining(["sandbox-a", "sandbox-b"]));
+            expect(sectionIdsExcluded).not.toEqual(expect.arrayContaining(["sandbox-a", "sandbox-b"]));
+        }
+        finally {
+            await promises_1.default.rm(root, { recursive: true, force: true });
+        }
+    });
+    it("excludes co-located test files and playwright config by default", async () => {
+        const root = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "dp-orch-default-excludes-"));
+        try {
+            await promises_1.default.mkdir(path_1.default.join(root, "src"), { recursive: true });
+            await promises_1.default.writeFile(path_1.default.join(root, "src", "app.ts"), "export const x = 1;\n", "utf8");
+            await promises_1.default.writeFile(path_1.default.join(root, "src", "app.spec.ts"), "import { x } from './app';\n", "utf8");
+            await promises_1.default.writeFile(path_1.default.join(root, "playwright.config.ts"), "export default {};\n", "utf8");
+            const { files } = await (0, orchestrator_1.scan)(root, (0, orchestrator_1.createDefaultScanConfiguration)());
+            const paths = files.map((f) => f.path);
+            expect(paths.some((p) => p.endsWith("app.spec.ts"))).toBe(false);
+            expect(paths.some((p) => p.includes("playwright.config"))).toBe(false);
+            expect(paths.some((p) => p.endsWith("app.ts"))).toBe(true);
+        }
+        finally {
+            await promises_1.default.rm(root, { recursive: true, force: true });
+        }
+    });
+    it("produces a combined ScanResult for mixed TypeScript and Python repos", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "mixed-language-basic");
+        const config = (0, orchestrator_1.createDefaultScanConfiguration)();
+        const { scanResult, files, findings } = await (0, orchestrator_1.scan)(fixturesRoot, config);
+        const scannedLanguages = new Set(files.map((file) => file.language));
+        expect(scannedLanguages.has("typescript")).toBe(true);
+        expect(scannedLanguages.has("python")).toBe(true);
+        const findingPaths = findings.map((finding) => finding.location.filePath);
+        expect(findingPaths.some((p) => p.endsWith(".ts"))).toBe(true);
+        expect(findingPaths.some((p) => p.endsWith(".py"))).toBe(true);
+        expect(scanResult.components.length).toBeGreaterThan(0);
+        expect(scanResult.dataFlows.length).toBeGreaterThan(0);
+        const flowTypes = new Set(scanResult.dataFlows.map((flow) => flow.type));
+        expect(flowTypes.has("database_query")).toBe(true);
+        expect(flowTypes.has("api_call")).toBe(true);
+        const statsByLanguage = new Set((scanResult.languageStats ?? []).map((stat) => stat.language));
+        expect(statsByLanguage.has("python")).toBe(true);
+    });
+    it("keeps direct app -> postgres edges end-to-end when provider nodes are absent", async () => {
+        const root = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "dp-orch-provider-topology-"));
+        try {
+            await promises_1.default.mkdir(path_1.default.join(root, "src"), { recursive: true });
+            await promises_1.default.writeFile(path_1.default.join(root, "package.json"), JSON.stringify({
+                name: "provider-topology-fixture",
+                version: "1.0.0",
+                dependencies: {
+                    express: "^4.18.2",
+                    pg: "^8.13.1",
+                },
+            }, null, 2));
+            await promises_1.default.writeFile(path_1.default.join(root, "src", "app.ts"), [
+                "import express from 'express';",
+                "import { Pool } from 'pg';",
+                "",
+                "const app = express();",
+                "const pool = new Pool({ connectionString: process.env.DATABASE_URL });",
+                "",
+                "app.get('/users', async (_req, res) => {",
+                "  const result = await pool.query('SELECT * FROM users');",
+                "  res.json(result.rows ?? []);",
+                "});",
+                "",
+                "export default app;",
+                "",
+            ].join("\n"), "utf8");
+            const config = (0, orchestrator_1.createDefaultScanConfiguration)();
+            const { scanResult } = await (0, orchestrator_1.scan)(root, config);
+            const postgresTargets = scanResult.components.filter((c) => c.type === "asset" &&
+                c.subType === "database" &&
+                (String(c.properties?.databaseType ?? "").toLowerCase().includes("postgres") ||
+                    String(c.properties?.client ?? "").toLowerCase().includes("pg")));
+            expect(postgresTargets.length).toBeGreaterThan(0);
+            const hasDirectDbFlow = scanResult.dataFlows.some((f) => postgresTargets.some((db) => db.id === f.targetComponentId) &&
+                f.type === "database_query");
+            expect(hasDirectDbFlow).toBe(true);
+            const hasSupabaseNode = scanResult.components.some((c) => c.type === "third_party" &&
+                String(c.properties?.serviceName ?? "").toLowerCase() === "supabase");
+            expect(hasSupabaseNode).toBe(false);
+        }
+        finally {
+            await promises_1.default.rm(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/unit/core/output-json.spec.d.ts

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

package/dist/tests/unit/core/output-json.spec.js

@@ -0,0 +1,65 @@
+"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 graph_mapping_1 = require("../../../src/core/pipeline/graph-mapping");
+const orchestrator_1 = require("../../../src/core/pipeline/orchestrator");
+const dataflow_wrapper_schema_1 = require("../../../src/core/schema/dataflow-wrapper.schema");
+const json_1 = require("../../../src/output/json");
+describe("output/json - DP-P0-CLI-403", () => {
+    it("builds and writes a validated dataflow.json wrapper for a real ScanResult", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-basic");
+        const config = (0, orchestrator_1.createDefaultScanConfiguration)();
+        const { scanResult } = await (0, orchestrator_1.scan)(fixturesRoot, config);
+        const graph = (0, graph_mapping_1.buildDiagramGraphFromScanResult)(scanResult);
+        const wrapper = (0, json_1.buildDataflowWrapper)(scanResult, graph);
+        const validation = (0, dataflow_wrapper_schema_1.validateDataflowJson)(wrapper);
+        expect(validation.ok).toBe(true);
+        if (!validation.ok) {
+            return;
+        }
+        expect(validation.value.metadata?.componentsCount).toBe(scanResult.components.length);
+        expect(validation.value.metadata?.dataFlowsCount).toBe(scanResult.dataFlows.length);
+        expect(validation.value.metadata?.filesScanned).toBe(scanResult.filesScanned);
+        expect(validation.value.metadata?.scanDurationMs).toBe(scanResult.scanDurationMs);
+        const outputPath = path_1.default.join(os_1.default.tmpdir(), `dataparade-dataflow-${Date.now()}.json`);
+        (0, json_1.writeDataflowJson)({
+            scanResult,
+            graph,
+            outputPath,
+        });
+        const contents = fs_1.default.readFileSync(outputPath, "utf8");
+        const parsed = JSON.parse(contents);
+        const fileValidation = (0, dataflow_wrapper_schema_1.validateDataflowJson)(parsed);
+        expect(fileValidation.ok).toBe(true);
+        fs_1.default.unlinkSync(outputPath);
+    });
+    it("throws and does not write a file when validation fails", async () => {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "typescript-basic");
+        const config = (0, orchestrator_1.createDefaultScanConfiguration)();
+        const { scanResult } = await (0, orchestrator_1.scan)(fixturesRoot, config);
+        const graph = (0, graph_mapping_1.buildDiagramGraphFromScanResult)(scanResult);
+        // Create an intentionally invalid graph by clearing the first node id so
+        // that validation fails when writing the wrapper.
+        const invalidGraph = {
+            ...graph,
+            nodes: graph.nodes.map((node, index) => index === 0
+                ? {
+                    ...node,
+                    id: "",
+                }
+                : node),
+        };
+        const outputPath = path_1.default.join(os_1.default.tmpdir(), `dataparade-dataflow-invalid-${Date.now()}.json`);
+        expect(() => (0, json_1.writeDataflowJson)({
+            scanResult,
+            graph: invalidGraph,
+            outputPath,
+        })).toThrow(/Invalid dataflow\.json wrapper/);
+        expect(fs_1.default.existsSync(outputPath)).toBe(false);
+    });
+});

package/dist/tests/unit/core/parsing-error-handling-nonfatal.spec.d.ts

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