@dataparade/cli 0.0.1

package/dist/tests/unit/core/classifier-phase-regressions.spec.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const classifier_phase_1 = require("../../../src/core/pipeline/classifier-phase");
+describe("core/pipeline/classifier-phase regressions", () => {
+    it("folds dependency-manifest frontend framework helper into section main app", () => {
+        const findings = [
+            {
+                pattern: "express_route",
+                name: "Frontend Application",
+                confidence: 0.75,
+                location: {
+                    filePath: "frontend/package.json",
+                    startLine: 1,
+                    endLine: 1,
+                },
+                properties: {
+                    framework: "nextjs",
+                    sourceContext: "dependency_manifest",
+                    section_id: "frontend",
+                    section_label: "frontend",
+                },
+            },
+            {
+                pattern: "express_route",
+                name: "Route handler",
+                confidence: 0.9,
+                location: {
+                    filePath: "frontend/app/api/users/route.ts",
+                    startLine: 1,
+                    endLine: 1,
+                },
+                properties: {
+                    framework: "next_or_react_route",
+                    section_id: "frontend",
+                    section_label: "frontend",
+                },
+            },
+        ];
+        const sections = [
+            {
+                id: "frontend",
+                label: "frontend",
+                role: "service",
+                sectionDir: "frontend",
+                manifestPaths: ["frontend/package.json"],
+            },
+            {
+                id: "root",
+                label: "root",
+                role: "root",
+                sectionDir: "",
+                manifestPaths: [],
+            },
+        ];
+        const components = (0, classifier_phase_1.runClassifierPhase)(findings, sections, {
+            projectName: "proj",
+            minimumConfidence: 0,
+        });
+        expect(components.some((c) => c.name === "Nextjs")).toBe(false);
+        const frontendMain = components.find((c) => c.properties?.section_id === "frontend" &&
+            c.properties?.isMainApplication === true);
+        expect(frontendMain).toBeDefined();
+        expect(frontendMain?.name).toBe("frontend");
+        const framework = frontendMain?.properties?.framework;
+        const frameworkValues = Array.isArray(framework) ? framework : [framework];
+        expect(frameworkValues).toEqual(expect.arrayContaining(["nextjs", "next_or_react_route"]));
+    });
+});

package/dist/tests/unit/core/dependency-manifest-performance-budgets.spec.d.ts

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

package/dist/tests/unit/core/dependency-manifest-performance-budgets.spec.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const orchestrator_1 = require("../../../src/core/pipeline/orchestrator");
+// Keep the test focused on manifest-scanning budgets.
+jest.mock("../../../src/analyzers/registry", () => ({
+    runAnalyzers: jest.fn(() => []),
+}));
+function tempRootForTest() {
+    // Ensure the temp dir is inside the repo workspace (important for sandboxed CI).
+    return path_1.default.join(__dirname, "..", "..", ".tmp", `manifest-budgets-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+}
+async function createManyTypeScriptManifests(rootDir, count) {
+    const base = path_1.default.join(rootDir, "manifests_ts");
+    await promises_1.default.mkdir(base, { recursive: true });
+    // Ensure express_route evidence can be inferred if budgets allow scanning.
+    const pkgJson = JSON.stringify({
+        dependencies: { next: "1.0.0" },
+    });
+    for (let i = 0; i < count; i += 1) {
+        const dir = path_1.default.join(base, `pkg_${i}`);
+        await promises_1.default.mkdir(dir, { recursive: true });
+        await promises_1.default.writeFile(path_1.default.join(dir, "package.json"), pkgJson, "utf8");
+    }
+}
+async function createManyPythonManifests(rootDir, count) {
+    const base = path_1.default.join(rootDir, "manifests_py");
+    await promises_1.default.mkdir(base, { recursive: true });
+    const requirements = "openai==1.0.0\nsentry-sdk==2.0.0\n";
+    for (let i = 0; i < count; i += 1) {
+        await promises_1.default.writeFile(path_1.default.join(base, `requirements_${i}.txt`), requirements, "utf8");
+    }
+}
+describe("dependency-manifest performance budgets (non-fatal)", () => {
+    jest.setTimeout(30_000);
+    it("stops manifest scanning when budgets are exceeded and still succeeds", async () => {
+        const root = tempRootForTest();
+        try {
+            await promises_1.default.mkdir(root, { recursive: true });
+            // Minimal code presence for section discovery.
+            await promises_1.default.mkdir(path_1.default.join(root, "src"), { recursive: true });
+            await promises_1.default.writeFile(path_1.default.join(root, "src", "index.ts"), "// empty\n", "utf8");
+            // Create enough manifests to exceed default budgets (maxManifestFiles=500).
+            await createManyTypeScriptManifests(root, 600);
+            await createManyPythonManifests(root, 600);
+            const config = (0, orchestrator_1.createDefaultScanConfiguration)({
+                languages: ["typescript", "python"],
+                enableDataFlowDetection: false,
+                deepAnalysis: false,
+            });
+            const { scanResult } = await (0, orchestrator_1.scan)(root, config);
+            expect(Array.isArray(scanResult.components)).toBe(true);
+            expect(Array.isArray(scanResult.warnings)).toBe(true);
+            // We expect at least one budget-related warning from either TS or Python.
+            const budgetWarns = scanResult.warnings.filter((w) => /manifest scan budget exceeded/i.test(w));
+            expect(budgetWarns.length).toBeGreaterThanOrEqual(1);
+        }
+        finally {
+            await promises_1.default.rm(root, { recursive: true, force: true }).catch(() => { });
+        }
+    });
+});

package/dist/tests/unit/core/dependency-manifest-toggles-confidence.spec.d.ts

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

package/dist/tests/unit/core/dependency-manifest-toggles-confidence.spec.js

@@ -0,0 +1,132 @@
+"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 orchestrator_1 = require("../../../src/core/pipeline/orchestrator");
+const dependency_manifests_1 = require("../../../src/analyzers/python/dependency-manifests");
+const dependency_manifests_2 = require("../../../src/analyzers/typescript/dependency-manifests");
+const registry_1 = require("../../../src/analyzers/registry");
+jest.mock("../../../src/analyzers/registry", () => ({
+    runAnalyzers: jest.fn(() => []),
+}));
+jest.mock("../../../src/analyzers/typescript/dependency-manifests", () => ({
+    detectTypeScriptPatternsFromDependencyManifests: jest.fn(async () => []),
+}));
+jest.mock("../../../src/analyzers/python/dependency-manifests", () => ({
+    detectPythonPatternsFromDependencyManifests: jest.fn(async () => []),
+}));
+function makeLoc(filePath) {
+    return { filePath, startLine: 1, endLine: 1 };
+}
+function makeFinding(partial) {
+    const { locationFile, ...rest } = partial;
+    return {
+        ...rest,
+        location: makeLoc(locationFile),
+    };
+}
+function componentHasDetectedFrom(component, pattern) {
+    return !!component.detectedFrom?.some((ref) => ref.pattern === pattern);
+}
+describe("dependency-manifest toggles - APIDetection/DBDetection/minConfidence", () => {
+    const tsFindings = [
+        makeFinding({
+            pattern: "express_route",
+            name: "Frontend Application",
+            confidence: 0.75,
+            locationFile: "package.json",
+            properties: {
+                framework: "nextjs",
+                sourceContext: "dependency_manifest",
+                httpMethods: [],
+                path: undefined,
+            },
+        }),
+        makeFinding({
+            pattern: "auth_middleware",
+            name: "Auth Middleware",
+            confidence: 0.8,
+            locationFile: "package.json",
+            properties: {
+                sourceContext: "dependency_manifest",
+            },
+        }),
+        makeFinding({
+            pattern: "database_connection",
+            name: "Database",
+            confidence: 0.92,
+            locationFile: "package.json",
+            properties: {
+                databaseType: "postgres",
+                client: "pg",
+                sourceContext: "dependency_manifest",
+            },
+        }),
+    ];
+    const pyFindings = [
+        ...tsFindings.map((f) => ({
+            ...f,
+            // Keep it in the python fixture tree for section tagging.
+            location: makeLoc("requirements.txt"),
+        })),
+    ];
+    beforeEach(() => {
+        registry_1.runAnalyzers.mockReturnValue([]);
+        dependency_manifests_2.detectTypeScriptPatternsFromDependencyManifests.mockResolvedValue(tsFindings);
+        dependency_manifests_1.detectPythonPatternsFromDependencyManifests.mockResolvedValue(pyFindings);
+    });
+    function runForFixture(fixtureDirName, configOverrides) {
+        const fixturesRoot = path_1.default.join(__dirname, "..", "..", "fixtures", fixtureDirName);
+        const config = (0, orchestrator_1.createDefaultScanConfiguration)(configOverrides);
+        return (0, orchestrator_1.scan)(fixturesRoot, config);
+    }
+    it("enableAPIDetection=false removes express_route/auth_middleware components", async () => {
+        const { scanResult } = await runForFixture("typescript-dependency-manifests-basic", {
+            enableAPIDetection: false,
+            enableDatabaseDetection: true,
+            enableDataFlowDetection: false,
+            minimumConfidence: 0,
+        });
+        expect(scanResult.components.some((c) => componentHasDetectedFrom(c, "express_route"))).toBe(false);
+        expect(scanResult.components.some((c) => componentHasDetectedFrom(c, "auth_middleware"))).toBe(false);
+        // database_connection should still be present when only API detection is off.
+        expect(scanResult.components.some((c) => componentHasDetectedFrom(c, "database_connection"))).toBe(true);
+    });
+    it("enableDatabaseDetection=false removes database_connection components", async () => {
+        const { scanResult } = await runForFixture("typescript-dependency-manifests-basic", {
+            enableAPIDetection: true,
+            enableDatabaseDetection: false,
+            enableDataFlowDetection: false,
+            minimumConfidence: 0,
+        });
+        expect(scanResult.components.some((c) => componentHasDetectedFrom(c, "database_connection"))).toBe(false);
+        // express_route/auth_middleware should remain when only database detection is off.
+        expect(scanResult.components.some((c) => componentHasDetectedFrom(c, "express_route"))).toBe(true);
+    });
+    it("minimumConfidence filters manifest-derived findings too", async () => {
+        const { scanResult } = await runForFixture("typescript-dependency-manifests-basic", {
+            enableAPIDetection: true,
+            enableDatabaseDetection: true,
+            enableDataFlowDetection: false,
+            minimumConfidence: 0.9,
+        });
+        // express_route/auth_middleware are below 0.9 and should be filtered out.
+        expect(scanResult.components.some((c) => componentHasDetectedFrom(c, "express_route"))).toBe(false);
+        expect(scanResult.components.some((c) => componentHasDetectedFrom(c, "auth_middleware"))).toBe(false);
+        // database_connection is above 0.9 and should remain.
+        expect(scanResult.components.some((c) => componentHasDetectedFrom(c, "database_connection"))).toBe(true);
+    });
+    it("works for Python dependency manifests fixture too", async () => {
+        const { scanResult } = await runForFixture("python-dependency-manifests-basic", {
+            enableAPIDetection: false,
+            enableDatabaseDetection: true,
+            enableDataFlowDetection: false,
+            minimumConfidence: 0,
+        });
+        expect(scanResult.components.some((c) => componentHasDetectedFrom(c, "express_route"))).toBe(false);
+        expect(scanResult.components.some((c) => componentHasDetectedFrom(c, "auth_middleware"))).toBe(false);
+        expect(scanResult.components.some((c) => componentHasDetectedFrom(c, "database_connection"))).toBe(true);
+    });
+});

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

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

package/dist/tests/unit/core/discover-service-sections.spec.js

@@ -0,0 +1,204 @@
+"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");
+function write(p, content) {
+    fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+    fs_1.default.writeFileSync(p, content, "utf8");
+}
+describe("inferTerraformStackSectionPathDepth", () => {
+    it("prefers depths with the most main.tf directories", () => {
+        const depth = (0, discover_service_sections_1.inferTerraformStackSectionPathDepth)([
+            "a/b/main.tf",
+            "a/b/c/main.tf",
+            "a/b/c/d/main.tf",
+            "x/y/main.tf",
+            "x/y/main.tf",
+        ]);
+        expect(depth).toBe(2);
+    });
+    it("returns undefined when no terraform config paths", () => {
+        expect((0, discover_service_sections_1.inferTerraformStackSectionPathDepth)([])).toBeUndefined();
+    });
+});
+describe("discoverServiceSections — terraformStackSectionPathDepth", () => {
+    it("registers a section when dirname segment count equals N and a .tf config exists", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-tfsec-"));
+        try {
+            write(path_1.default.join(root, "a", "b", "main.tf"), 'resource "null_resource" "x" {}\n');
+            const { sections } = await (0, discover_service_sections_1.discoverServiceSections)(root, {
+                terraformStackSectionPathDepth: 2,
+                autoInferTerraformStackSectionPathDepth: false,
+            });
+            const svc = sections.find((s) => s.id === "a/b");
+            expect(svc).toBeDefined();
+            expect(svc?.role).toBe("service");
+            expect(svc?.manifestPaths).toContain("a/b/main.tf");
+            expect(svc?.isTerraformStack).toBe(true);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("does not register deeper stacks when N is smaller", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-tfsec-"));
+        try {
+            write(path_1.default.join(root, "a", "b", "c", "main.tf"), 'resource "null_resource" "x" {}\n');
+            const { sections } = await (0, discover_service_sections_1.discoverServiceSections)(root, {
+                terraformStackSectionPathDepth: 2,
+                autoInferTerraformStackSectionPathDepth: false,
+            });
+            expect(sections.some((s) => s.id === "a/b/c")).toBe(false);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("registers depth-3 stack when N is 3", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-tfsec-"));
+        try {
+            write(path_1.default.join(root, "a", "b", "c", "main.tf"), 'resource "null_resource" "x" {}\n');
+            const { sections } = await (0, discover_service_sections_1.discoverServiceSections)(root, {
+                terraformStackSectionPathDepth: 3,
+                autoInferTerraformStackSectionPathDepth: false,
+            });
+            const svc = sections.find((s) => s.id === "a/b/c");
+            expect(svc).toBeDefined();
+            expect(svc?.manifestPaths).toContain("a/b/c/main.tf");
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("registers stack with only resources.tf (no main.tf)", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-tfsec-"));
+        try {
+            write(path_1.default.join(root, "a", "b", "resources.tf"), 'resource "null_resource" "x" {}\n');
+            const { sections } = await (0, discover_service_sections_1.discoverServiceSections)(root, {
+                terraformStackSectionPathDepth: 2,
+                autoInferTerraformStackSectionPathDepth: false,
+            });
+            const svc = sections.find((s) => s.id === "a/b");
+            expect(svc).toBeDefined();
+            expect(svc?.manifestPaths).toContain("a/b/resources.tf");
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("merges main.tf with package.json in the same directory", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-tfsec-"));
+        try {
+            write(path_1.default.join(root, "x", "y", "package.json"), "{}");
+            write(path_1.default.join(root, "x", "y", "main.tf"), 'resource "null_resource" "x" {}\n');
+            const { sections } = await (0, discover_service_sections_1.discoverServiceSections)(root, {
+                terraformStackSectionPathDepth: 2,
+                autoInferTerraformStackSectionPathDepth: false,
+            });
+            const svc = sections.find((s) => s.id === "x/y");
+            expect(svc).toBeDefined();
+            expect(svc?.manifestPaths.sort()).toEqual(["x/y/main.tf", "x/y/package.json"].sort());
+            expect(svc?.isTerraformStack).toBeUndefined();
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("skips terraform stack when sectionDir matches excludePaths", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-tfsec-"));
+        try {
+            write(path_1.default.join(root, "svc", "stack", "main.tf"), 'resource "null_resource" "x" {}\n');
+            const { sections } = await (0, discover_service_sections_1.discoverServiceSections)(root, {
+                terraformStackSectionPathDepth: 2,
+                autoInferTerraformStackSectionPathDepth: false,
+                excludePaths: ["svc/stack"],
+            });
+            expect(sections.some((s) => s.id === "svc/stack")).toBe(false);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("does not add terraform-only sections when auto-infer is disabled", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-tfsec-"));
+        try {
+            write(path_1.default.join(root, "a", "b", "main.tf"), 'resource "null_resource" "x" {}\n');
+            const { sections } = await (0, discover_service_sections_1.discoverServiceSections)(root, {
+                autoInferTerraformStackSectionPathDepth: false,
+            });
+            expect(sections.some((s) => s.id === "a/b")).toBe(false);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("auto-infers depth and registers Twenty-like k8s/terraform stack", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-tfsec-twenty-"));
+        try {
+            write(path_1.default.join(root, "packages", "twenty-docker", "k8s", "terraform", "main.tf"), 'resource "kubernetes_deployment" "api" {}\n');
+            write(path_1.default.join(root, "packages", "twenty-docker", "k8s", "terraform", "variables.tf"), 'variable "x" {}\n');
+            const { sections, inferredTerraformStackSectionPathDepth } = await (0, discover_service_sections_1.discoverServiceSections)(root);
+            expect(inferredTerraformStackSectionPathDepth).toBe(4);
+            const stack = sections.find((s) => s.id === "packages/twenty-docker/k8s/terraform");
+            expect(stack).toBeDefined();
+            expect(stack?.label).toBe("terraform");
+            expect(stack?.manifestPaths).toEqual(expect.arrayContaining([
+                "packages/twenty-docker/k8s/terraform/main.tf",
+                "packages/twenty-docker/k8s/terraform/variables.tf",
+            ]));
+            expect(stack?.isTerraformStack).toBe(true);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("sets isTerraformStack for non-terraform/ layout (e.g. infra/stack)", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-tfsec-infra-"));
+        try {
+            write(path_1.default.join(root, "infra", "stack", "main.tf"), 'resource "null_resource" "x" {}\n');
+            const { sections } = await (0, discover_service_sections_1.discoverServiceSections)(root, {
+                terraformStackSectionPathDepth: 2,
+                autoInferTerraformStackSectionPathDepth: false,
+            });
+            const stack = sections.find((s) => s.id === "infra/stack");
+            expect(stack).toBeDefined();
+            expect(stack?.isTerraformStack).toBe(true);
+            expect(stack?.manifestPaths).toEqual(["infra/stack/main.tf"]);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});
+describe("tagFindingsWithServiceSections — terraform stacks", () => {
+    it("tags terraform findings with the nearest stack section, not root", async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dp-tfsec-tag-"));
+        try {
+            const tfRel = "packages/twenty-docker/k8s/terraform/main.tf";
+            write(path_1.default.join(root, tfRel), 'resource "null_resource" "x" {}\n');
+            const { sections } = await (0, discover_service_sections_1.discoverServiceSections)(root, {
+                terraformStackSectionPathDepth: 4,
+            });
+            const findings = [
+                {
+                    pattern: "terraform_resource",
+                    name: "null_resource.x",
+                    confidence: 0.9,
+                    location: { filePath: tfRel, startLine: 1, endLine: 1 },
+                    properties: {},
+                },
+            ];
+            (0, discover_service_sections_1.tagFindingsWithServiceSections)(findings, sections);
+            expect(findings[0]?.properties.section_id).toBe("packages/twenty-docker/k8s/terraform");
+            expect(findings[0]?.properties.section_label).toBe("terraform");
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/unit/core/graph-mapping.spec.d.ts

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