@dataparade/cli 0.0.1

package/dist/tests/unit/analyzers/terraform-exec.spec.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const terraform_exec_1 = require("../../../src/analyzers/terraform/terraform-exec");
+const hasTerraform = (0, child_process_1.spawnSync)("terraform", ["version"], { encoding: "utf8" }).status === 0;
+describe("terraform-exec", () => {
+    const itWithTf = hasTerraform ? it : it.skip;
+    it("returns ok:false when plan file is missing", () => {
+        const scanRoot = path_1.default.join(__dirname, "..", "..", "fixtures", "terraform-basic");
+        const res = (0, terraform_exec_1.runTerraformShowJsonSync)(scanRoot, "nonexistent.tfplan");
+        expect(res.ok).toBe(false);
+        if (res.ok)
+            return;
+        expect(res.message.length).toBeGreaterThan(0);
+    });
+    itWithTf("returns ok:false when file is not a valid Terraform plan/state", () => {
+        const jsonFixture = path_1.default.join(__dirname, "..", "..", "fixtures", "terraform-show-extra-bucket.json");
+        const scanRoot = path_1.default.dirname(jsonFixture);
+        const rel = path_1.default.basename(jsonFixture);
+        const res = (0, terraform_exec_1.runTerraformShowJsonSync)(scanRoot, rel);
+        expect(res.ok).toBe(false);
+    });
+});

package/dist/tests/unit/analyzers/terraform-show-json.spec.d.ts

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

package/dist/tests/unit/analyzers/terraform-show-json.spec.js

@@ -0,0 +1,77 @@
+"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 terraform_show_json_1 = require("../../../src/analyzers/terraform/terraform-show-json");
+describe("terraform-show-json merge", () => {
+    it("mergeTerraformShowJsonFromDoc adds resources not already in static findings", () => {
+        const existing = [
+            {
+                pattern: "terraform_resource",
+                name: "aws_s3_bucket.data",
+                confidence: 0.9,
+                location: { filePath: "main.tf", startLine: 1, endLine: 5 },
+                properties: {
+                    terraform_address: "aws_s3_bucket.data",
+                    terraform_block_kind: "resource",
+                    resource_type: "aws_s3_bucket",
+                },
+            },
+        ];
+        const doc = {
+            planned_values: {
+                root_module: {
+                    resources: [
+                        {
+                            address: "aws_s3_bucket.data",
+                            type: "aws_s3_bucket",
+                            name: "data",
+                        },
+                        {
+                            address: "aws_s3_bucket.only_in_plan",
+                            type: "aws_s3_bucket",
+                            name: "only_in_plan",
+                        },
+                    ],
+                },
+            },
+        };
+        const merged = (0, terraform_show_json_1.mergeTerraformShowJsonFromDoc)(existing, doc, "fixture.json");
+        expect(merged.mergedCount).toBe(1);
+        expect(merged.findings).toHaveLength(1);
+        expect(merged.findings[0]?.properties?.terraform_address).toBe("aws_s3_bucket.only_in_plan");
+        expect(merged.findings[0]?.properties?.terraform_json_source).toBe(true);
+    });
+    it("mergeTerraformShowJsonFromDoc does not add aws_iam_* resources", () => {
+        const existing = [];
+        const doc = {
+            planned_values: {
+                root_module: {
+                    resources: [
+                        {
+                            address: "aws_iam_role.exec",
+                            type: "aws_iam_role",
+                            name: "exec",
+                        },
+                        {
+                            address: "aws_lambda_function.api",
+                            type: "aws_lambda_function",
+                            name: "api",
+                        },
+                    ],
+                },
+            },
+        };
+        const merged = (0, terraform_show_json_1.mergeTerraformShowJsonFromDoc)(existing, doc, "plan.json");
+        expect(merged.mergedCount).toBe(1);
+        expect(merged.findings[0]?.properties?.resource_type).toBe("aws_lambda_function");
+    });
+    it("mergeTerraformShowJsonFindings reads fixture file from disk", () => {
+        const fixturePath = path_1.default.join(__dirname, "..", "..", "fixtures", "terraform-show-extra-bucket.json");
+        const merged = (0, terraform_show_json_1.mergeTerraformShowJsonFindings)([], fixturePath);
+        expect(merged.mergedCount).toBe(1);
+        expect(merged.findings[0]?.name).toBe("aws_s3_bucket.only_in_plan");
+    });
+});

package/dist/tests/unit/analyzers/typescript/dependency-manifests.spec.d.ts

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

package/dist/tests/unit/analyzers/typescript/dependency-manifests.spec.js

@@ -0,0 +1,61 @@
+"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 = require("fs");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const dependency_manifests_1 = require("../../../../src/analyzers/typescript/dependency-manifests");
+describe("analyzers/typescript/dependency-manifests", () => {
+    async function withTempProject(packageJson) {
+        const tmpDir = await fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "dp-cli-manifest-"));
+        const packageJsonPath = path_1.default.join(tmpDir, "package.json");
+        await fs_1.promises.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf8");
+        return tmpDir;
+    }
+    it("emits a frontend framework finding for React dependencies", async () => {
+        const root = await withTempProject({
+            name: "sample",
+            dependencies: {
+                react: "^19.0.0",
+            },
+        });
+        const findings = await (0, dependency_manifests_1.detectTypeScriptPatternsFromDependencyManifests)(root);
+        const frontendFinding = findings.find((f) => f.pattern === "express_route" &&
+            f.name === "Frontend Application" &&
+            f.properties.framework === "react");
+        expect(frontendFinding).toBeDefined();
+    });
+    it("prefers nextjs over react when both dependencies exist", async () => {
+        const root = await withTempProject({
+            name: "sample-next",
+            dependencies: {
+                react: "^19.0.0",
+                next: "^15.0.0",
+            },
+        });
+        const findings = await (0, dependency_manifests_1.detectTypeScriptPatternsFromDependencyManifests)(root);
+        const frontendFindings = findings.filter((f) => f.pattern === "express_route" && f.name === "Frontend Application");
+        expect(frontendFindings.length).toBe(1);
+        expect(frontendFindings[0].properties.framework).toBe("nextjs");
+    });
+    it("detects third-party services from manifest dependencies", async () => {
+        const root = await withTempProject({
+            name: "sample-frontend",
+            dependencies: {
+                "@google/genai": "^1.0.0",
+                "@supabase/supabase-js": "^2.0.0",
+                openai: "^6.0.0",
+            },
+        });
+        const findings = await (0, dependency_manifests_1.detectTypeScriptPatternsFromDependencyManifests)(root);
+        const externalFindings = findings.filter((f) => f.pattern === "external_api_call");
+        const serviceNames = new Set(externalFindings
+            .map((f) => (typeof f.properties.serviceName === "string" ? f.properties.serviceName : ""))
+            .filter(Boolean));
+        expect(serviceNames.has("google_ai")).toBe(true);
+        expect(serviceNames.has("supabase")).toBe(true);
+        expect(serviceNames.has("openai")).toBe(true);
+    });
+});

package/dist/tests/unit/analyzers/typescript/detector.spec.d.ts

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

package/dist/tests/unit/analyzers/typescript/detector.spec.js

@@ -0,0 +1,225 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const detector_1 = require("../../../../src/analyzers/typescript/detector");
+const patternConfig = __importStar(require("../../../../src/analyzers/typescript/typescript-detection-config"));
+describe("analyzers/typescript/detector - DP-P0-CLI-104", () => {
+    function makeFile(content, overrides = {}) {
+        return {
+            path: overrides.path ?? "src/example.ts",
+            name: overrides.name ?? "example.ts",
+            content,
+            language: overrides.language ?? "typescript",
+            size: overrides.size ?? content.length,
+        };
+    }
+    it("detects express-style routes as express_route findings", () => {
+        const file = makeFile(`
+        import express from "express";
+        const app = express();
+
+        app.get("/users", (req, res) => {
+          res.send("ok");
+        });
+      `);
+        const findings = (0, detector_1.detectPatterns)(file);
+        const routeFindings = findings.filter((f) => f.pattern === "express_route");
+        expect(routeFindings.length).toBeGreaterThan(0);
+        const first = routeFindings[0];
+        expect(first.name).toContain("/users");
+        expect(first.properties.framework).toBe("express");
+    });
+    it("detects database client creation as database_connection findings", () => {
+        const file = makeFile(`
+        import { Pool } from "pg";
+
+        const pool = new Pool({
+          connectionString: process.env.DATABASE_URL,
+        });
+      `);
+        const findings = (0, detector_1.detectPatterns)(file);
+        const dbFindings = findings.filter((f) => f.pattern === "database_connection");
+        expect(dbFindings.length).toBeGreaterThan(0);
+        const first = dbFindings[0];
+        expect(first.properties.client).toBe("pg");
+        expect(first.properties.databaseType).toBe("postgres");
+    });
+    it("does not misclassify supabase createClient as redis database_connection", () => {
+        const file = makeFile(`
+        import { createClient } from "@supabase/supabase-js";
+        const supabase = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_KEY);
+      `, { path: "scripts/supabase-task.mjs", name: "supabase-task.mjs", language: "javascript" });
+        const findings = (0, detector_1.detectPatterns)(file);
+        const redisFindings = findings.filter((f) => f.pattern === "database_connection" &&
+            String(f.properties?.client ?? "").toLowerCase() === "redis");
+        expect(redisFindings).toHaveLength(0);
+        const supabaseFindings = findings.filter((f) => f.pattern === "database_connection" &&
+            String(f.properties?.client ?? "").toLowerCase() === "supabase");
+        expect(supabaseFindings.length).toBeGreaterThan(0);
+    });
+    it("does not report sql_query_detected when file has no DB client import (avoids false positives from update/select/delete in UI)", () => {
+        const file = makeFile(`
+        import { updateAsset } from "@/lib/api/assets";
+        export function Form() {
+          const [selected, setSelected] = useState(null);
+          return <Select value={selected} onUpdate={setSelected} />;
+        }
+      `, { path: "app/components/CreateAssetModal.tsx" });
+        const findings = (0, detector_1.detectPatterns)(file);
+        const sqlFindings = findings.filter((f) => f.pattern === "database_connection" && f.name === "sql_query_detected");
+        expect(sqlFindings).toHaveLength(0);
+    });
+    it("reports sql_query_detected only when file uses a DB client and content has SQL keywords", () => {
+        const file = makeFile(`
+        import { Pool } from "pg";
+        const query = "SELECT * FROM users WHERE id = $1";
+        const pool = new Pool();
+      `);
+        const findings = (0, detector_1.detectPatterns)(file);
+        const sqlFindings = findings.filter((f) => f.pattern === "database_connection" && f.name === "sql_query_detected");
+        expect(sqlFindings.length).toBe(1);
+        expect(sqlFindings[0].properties?.hint).toBe("raw_sql_keyword");
+    });
+    it("detects external API calls as external_api_call findings", () => {
+        const file = makeFile(`
+        async function callApi() {
+          const res = await fetch("https://api.example.com/users");
+          return res.json();
+        }
+      `);
+        const findings = (0, detector_1.detectPatterns)(file);
+        const apiFindings = findings.filter((f) => f.pattern === "external_api_call");
+        expect(apiFindings.length).toBeGreaterThan(0);
+        const first = apiFindings[0];
+        expect(first.properties.url).toBe("https://api.example.com/users");
+    });
+    it("ignores localhost templated URLs for external_api_call detection", () => {
+        const file = makeFile(`
+        const port = process.env.PORT || "3000";
+        logger.log(\`Application is running on: http://localhost:\${port}\`);
+      `);
+        const findings = (0, detector_1.detectPatterns)(file);
+        const apiFindings = findings.filter((f) => f.pattern === "external_api_call");
+        expect(apiFindings).toHaveLength(0);
+    });
+    it("ignores comment-only URL examples for external_api_call detection", () => {
+        const file = makeFile(`
+        // Example: curl https://api.vendor/v1/resource
+        /* See also https://api.vendor/docs */
+        export const noop = true;
+      `);
+        const findings = (0, detector_1.detectPatterns)(file);
+        const apiFindings = findings.filter((f) => f.pattern === "external_api_call");
+        expect(apiFindings).toHaveLength(0);
+    });
+    it("detects url: \"https://...\" in object literals and sets serviceName from hostname (no YAML url list)", () => {
+        const file = makeFile(`
+        request.post(
+          {
+            url: "https://vectorizer.ai/api/v1/vectorize",
+            formData: {},
+          },
+          function () {},
+        );
+      `, { path: "services/vectorize.js", name: "vectorize.js", language: "javascript" });
+        const findings = (0, detector_1.detectPatterns)(file);
+        const hits = findings.filter((f) => f.pattern === "external_api_call" &&
+            String(f.properties?.url ?? "").includes("vectorizer.ai"));
+        expect(hits.length).toBeGreaterThan(0);
+        expect(hits[0].properties?.serviceName).toBe("vectorizer.ai");
+    });
+    it("detects auth-related middleware as auth_middleware findings", () => {
+        const file = makeFile(`
+        import passport from "passport";
+
+        app.get(
+          "/profile",
+          passport.authenticate("jwt", { session: false }),
+          (req, res) => res.send("ok"),
+        );
+      `);
+        const findings = (0, detector_1.detectPatterns)(file);
+        const authFindings = findings.filter((f) => f.pattern === "auth_middleware");
+        expect(authFindings.length).toBeGreaterThan(0);
+        const first = authFindings[0];
+        expect(first.properties.library).toBe("passport");
+    });
+    it("detects env variable usage as env_variable findings", () => {
+        const file = makeFile(`
+        const dbUrl = process.env.DATABASE_URL;
+        const apiKey = process.env.API_KEY;
+      `);
+        const findings = (0, detector_1.detectPatterns)(file);
+        const envFindings = findings.filter((f) => f.pattern === "env_variable");
+        expect(envFindings.length).toBeGreaterThanOrEqual(2);
+        const keys = envFindings.map((f) => f.properties.key);
+        expect(keys).toContain("DATABASE_URL");
+        expect(keys).toContain("API_KEY");
+    });
+    it("respects config_keys from YAML-driven config for config.<field> detection", () => {
+        const originalLoader = patternConfig.loadTypeScriptPatternConfig;
+        jest
+            .spyOn(patternConfig, "loadTypeScriptPatternConfig")
+            .mockImplementation(() => {
+            const base = originalLoader();
+            return {
+                ...base,
+                configKeys: {
+                    keys: [
+                        ...base.configKeys.keys,
+                        {
+                            name: "customKey",
+                            patternId: "config_file",
+                            confidence: 0.9,
+                        },
+                    ],
+                },
+            };
+        });
+        const file = {
+            path: "src/config.ts",
+            name: "config.ts",
+            content: `
+        const value = config.customKey;
+      `,
+            language: "typescript",
+            size: 0,
+        };
+        const findings = (0, detector_1.detectPatterns)(file);
+        const configFindings = findings.filter((f) => f.pattern === "config_file" && f.name === "config.customKey");
+        expect(configFindings.length).toBeGreaterThan(0);
+        patternConfig.loadTypeScriptPatternConfig.mockRestore();
+    });
+});

package/dist/tests/unit/analyzers/typescript/external-apis-auth0.spec.d.ts

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

package/dist/tests/unit/analyzers/typescript/external-apis-auth0.spec.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const third_party_detection_1 = require("../../../../src/analyzers/typescript/third-party-detection");
+const parser_1 = require("../../../../src/analyzers/typescript/parser");
+describe("TS external API detection - URL host patterns", () => {
+    it("infers serviceName 'auth0' from axios calls to Auth0 URLs", () => {
+        const content = `
+      import axios from "axios";
+
+      async function exchangeCode(code: string) {
+        return axios.post("https://example-tenant.auth0.com/oauth/token", { code });
+      }
+    `;
+        const file = {
+            path: "src/auth/auth0-example.ts",
+            name: "auth0-example.ts",
+            language: "typescript",
+            size: content.length,
+            content,
+        };
+        const model = (0, parser_1.buildCodeModel)(file);
+        const findings = (0, third_party_detection_1.detectExternalApiCalls)(file, model);
+        const auth0Finding = findings.find((f) => f.pattern === "external_api_call" && f.properties?.serviceName === "auth0");
+        expect(auth0Finding).toBeDefined();
+        expect(auth0Finding?.properties?.url).toBe("https://example-tenant.auth0.com/oauth/token");
+    });
+    it("infers serviceName 'sendgrid' from fetch calls to SendGrid API URLs", () => {
+        const content = `
+      fetch("https://api.sendgrid.com/v3/mail/send", {
+        method: "POST",
+        headers: { "Authorization": "Bearer " + process.env.SENDGRID_API_KEY },
+        body: JSON.stringify({ personalizations: [], from: {}, content: [] }),
+      });
+    `;
+        const file = {
+            path: "src/notify/send-email.mjs",
+            name: "send-email.mjs",
+            language: "javascript",
+            size: content.length,
+            content,
+        };
+        const model = (0, parser_1.buildCodeModel)(file);
+        const findings = (0, third_party_detection_1.detectExternalApiCalls)(file, model);
+        const sendgridFinding = findings.find((f) => f.pattern === "external_api_call" &&
+            f.properties?.serviceName === "sendgrid");
+        expect(sendgridFinding).toBeDefined();
+        expect(sendgridFinding?.properties?.url).toBe("https://api.sendgrid.com/v3/mail/send");
+    });
+});

package/dist/tests/unit/analyzers/typescript/external-apis-sentry.spec.d.ts

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

package/dist/tests/unit/analyzers/typescript/external-apis-sentry.spec.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const third_party_detection_1 = require("../../../../src/analyzers/typescript/third-party-detection");
+const parser_1 = require("../../../../src/analyzers/typescript/parser");
+describe("TS external API detection - Sentry", () => {
+    it("infers serviceName 'sentry' from fetch calls to Sentry ingestion URLs", () => {
+        const content = `
+      fetch("https://o123456.ingest.sentry.io/api/123/envelope/", {
+        method: "POST",
+        body: "{}",
+      });
+    `;
+        const file = {
+            path: "src/monitoring/sentry-example.ts",
+            name: "sentry-example.ts",
+            language: "typescript",
+            size: content.length,
+            content,
+        };
+        const model = (0, parser_1.buildCodeModel)(file);
+        const findings = (0, third_party_detection_1.detectExternalApiCalls)(file, model);
+        const sentryFinding = findings.find((f) => f.pattern === "external_api_call" &&
+            f.properties?.serviceName === "sentry");
+        expect(sentryFinding).toBeDefined();
+        expect(sentryFinding?.properties?.url).toBe("https://o123456.ingest.sentry.io/api/123/envelope/");
+    });
+});

package/dist/tests/unit/analyzers/typescript/fixture-integration.spec.d.ts

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

package/dist/tests/unit/analyzers/typescript/fixture-integration.spec.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const file_system_1 = require("../../../../src/ingest/file-system");
+const registry_1 = require("../../../../src/analyzers/registry");
+const typescript_1 = require("../../../../src/analyzers/typescript");
+describe("TS analyzer + ingest integration - DP-P0-CLI-105", () => {
+    const FIXTURE_ROOT = path.join(__dirname, "../../../fixtures/typescript-basic");
+    beforeEach(() => {
+        (0, registry_1.__clearAnalyzersForTest)();
+    });
+    afterAll(() => {
+        (0, registry_1.__clearAnalyzersForTest)();
+    });
+    it("detects external API calls and env variable usage via ingest + analyzer", async () => {
+        const files = await (0, file_system_1.ingestFileSystem)(FIXTURE_ROOT);
+        const tsAnalyzer = (0, typescript_1.createTypeScriptAnalyzer)();
+        (0, registry_1.registerAnalyzer)("typescript", tsAnalyzer);
+        (0, registry_1.registerAnalyzer)("javascript", tsAnalyzer);
+        const findings = (0, registry_1.runAnalyzers)(files);
+        const byPattern = (pattern) => findings.filter((f) => f.pattern === pattern);
+        const externalApis = byPattern("external_api_call");
+        const envVars = byPattern("env_variable");
+        expect(externalApis.length).toBeGreaterThan(0);
+        expect(envVars.length).toBeGreaterThan(0);
+        const externalFinding = externalApis[0];
+        expect(typeof externalFinding.properties.url).toBe("string");
+        const envKeys = envVars.map((f) => f.properties.key);
+        expect(envKeys).toContain("API_KEY");
+    });
+});

package/dist/tests/unit/analyzers/typescript/parser.spec.d.ts

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

package/dist/tests/unit/analyzers/typescript/parser.spec.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_1 = require("../../../../src/analyzers/typescript/parser");
+describe("analyzers/typescript/parser - DP-P0-CLI-103", () => {
+    it("normalizes paths to POSIX style", () => {
+        expect((0, parser_1.normalizePath)("already/posix/path.ts")).toBe("already/posix/path.ts");
+        const windowsLike = "some\\windows\\path.ts";
+        expect((0, parser_1.normalizePath)(windowsLike)).toBe("some/windows/path.ts");
+    });
+    it("builds a basic code model for a TypeScript file", () => {
+        const file = {
+            path: "src/example.ts",
+            name: "example.ts",
+            content: `
+        import fs from "fs";
+        import { join } from "path";
+
+        export function foo() {
+          return join("a", "b");
+        }
+
+        const bar = () => {
+          return fs.readFileSync("file.txt", "utf-8");
+        };
+      `,
+            language: "typescript",
+            size: 0,
+        };
+        const result = (0, parser_1.buildCodeModel)(file);
+        expect(result.language).toBe("typescript");
+        expect(result.normalizedPath).toBe("src/example.ts");
+        expect(result.warnings.length).toBe(0);
+        const moduleSpecifiers = result.imports.map((i) => i.moduleSpecifier);
+        expect(moduleSpecifiers).toContain("fs");
+        expect(moduleSpecifiers).toContain("path");
+        const importNames = result.imports.flatMap((i) => i.importedNames);
+        expect(importNames).toContain("fs");
+        expect(importNames).toContain("join");
+        const functionNames = result.functions.map((fn) => fn.name);
+        expect(functionNames).toContain("foo");
+        expect(functionNames).toContain("bar");
+        const exportedFunctions = result.functions.filter((fn) => fn.isExported);
+        const exportedNames = exportedFunctions.map((fn) => fn.name);
+        expect(exportedNames).toContain("foo");
+    });
+    it("builds a basic code model for a JavaScript file with require()", () => {
+        const file = {
+            path: "src/example.js",
+            name: "example.js",
+            content: `
+        const http = require("http");
+
+        function handler() {
+          return http.createServer();
+        }
+
+        module.exports = { handler };
+      `,
+            language: "javascript",
+            size: 0,
+        };
+        const result = (0, parser_1.buildCodeModel)(file);
+        expect(result.language).toBe("javascript");
+        expect(result.warnings.length).toBe(0);
+        const moduleSpecifiers = result.imports.map((i) => i.moduleSpecifier);
+        expect(moduleSpecifiers).toContain("http");
+        const importNames = result.imports.flatMap((i) => i.importedNames);
+        expect(importNames).toContain("http");
+        const functionNames = result.functions.map((fn) => fn.name);
+        expect(functionNames).toContain("handler");
+    });
+    it("surfaces parser diagnostics as warnings for syntactically invalid files", () => {
+        const file = {
+            path: "src/broken.ts",
+            name: "broken.ts",
+            content: `
+        import from;
+        export function oops( {
+      `,
+            language: "typescript",
+            size: 0,
+        };
+        const result = (0, parser_1.buildCodeModel)(file);
+        expect(result.warnings.length).toBeGreaterThan(0);
+    });
+    it("returns a non-fatal result with warnings for unsupported languages", () => {
+        const file = {
+            path: "config/settings.json",
+            name: "settings.json",
+            content: `{"ok": true}`,
+            language: "json",
+            size: 0,
+        };
+        const result = (0, parser_1.buildCodeModel)(file);
+        expect(result.imports).toEqual([]);
+        expect(result.functions).toEqual([]);
+        expect(result.warnings.length).toBeGreaterThan(0);
+    });
+});

package/dist/tests/unit/analyzers/typescript/pattern-config.spec.d.ts

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