@dataparade/cli 0.0.1

package/dist/tests/unit/ai-enrichment/third-party-evidence.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/third-party-evidence.spec.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const third_party_evidence_1 = require("../../../src/ai-enrichment/third-party-evidence");
+function candidate(componentId) {
+    return {
+        id: `cand_${componentId}`,
+        candidateType: "third_party",
+        priority: 90,
+        componentId,
+        missingFields: ["vendor", "api_type", "authentication_method"],
+        rationale: "fill sparse third-party properties from evidence",
+        hints: [],
+    };
+}
+function component() {
+    return {
+        id: "cmp_tp_1",
+        name: "Stripe",
+        type: "third_party",
+        confidence: 0.9,
+        detectedFrom: [
+            {
+                pattern: "external_api_call",
+                sourceLocation: {
+                    filePath: "backend/services/payments/index.ts",
+                    startLine: 1,
+                    endLine: 1,
+                },
+            },
+        ],
+        sourceLocations: [
+            { filePath: "backend/services/payments/index.ts", startLine: 1, endLine: 1 },
+        ],
+        properties: {
+            section_id: "backend/services/payments",
+            vendor: null,
+            serviceName: null,
+            client: null,
+            integration_method: [],
+            api_type: null,
+            authentication_method: null,
+            documentation_url: null,
+            sdk_available: false,
+            api_endpoint: null,
+            https_enforced: null,
+            vendor_soc2_iso27001: [],
+        },
+    };
+}
+function files() {
+    return [
+        {
+            path: "backend/services/payments/index.ts",
+            name: "index.ts",
+            language: "typescript",
+            size: 200,
+            content: [
+                'import Stripe from "stripe";',
+                "const client = new Stripe(process.env.STRIPE_API_KEY || \"\", { apiVersion: \"2023-10-16\" });",
+                "await fetch(\"https://api.stripe.com/v1/customers\", {",
+                "  headers: { Authorization: `Bearer ${process.env.STRIPE_API_KEY}` }",
+                "});",
+            ].join("\n"),
+        },
+        {
+            path: "backend/services/payments/package.json",
+            name: "package.json",
+            language: "json",
+            size: 80,
+            content: JSON.stringify({
+                dependencies: {
+                    stripe: "^17.0.0",
+                },
+            }),
+        },
+    ];
+}
+describe("third-party evidence enrichment", () => {
+    it("builds an evidence-backed proposal for sparse third-party fields", () => {
+        const proposal = (0, third_party_evidence_1.buildThirdPartyHeuristicProposal)({
+            candidate: candidate("cmp_tp_1"),
+            component: component(),
+            files: files(),
+        });
+        expect(proposal).toBeDefined();
+        expect(proposal?.kind).toBe("component_patch");
+        expect(proposal?.setProperties.vendor).toBe("Stripe");
+        expect(proposal?.setProperties.authentication_method).toBe("bearer_token");
+        expect(proposal?.setProperties.api_type).toBe("rest");
+        expect(proposal?.setProperties.documentation_url).toBe("https://docs.stripe.com");
+        expect(proposal?.evidence.length).toBeGreaterThan(0);
+        expect((0, third_party_evidence_1.verifyThirdPartyProposal)(proposal)).toEqual({ ok: true });
+    });
+    it("accepts proposals for additional fields when evidence is present", () => {
+        const proposal = (0, third_party_evidence_1.buildThirdPartyHeuristicProposal)({
+            candidate: candidate("cmp_tp_1"),
+            component: {
+                ...component(),
+                properties: {
+                    ...component().properties,
+                    vendor: "Stripe",
+                    vendor_soc2_iso27001: [],
+                },
+            },
+            files: files(),
+        });
+        expect(proposal).toBeDefined();
+        if (!proposal)
+            return;
+        proposal.setProperties.vendor_soc2_iso27001 = ["soc2"];
+        proposal.propertyEvidence = {
+            ...(proposal.propertyEvidence ?? {}),
+            vendor_soc2_iso27001: proposal.evidence.slice(0, 1),
+        };
+        expect((0, third_party_evidence_1.verifyThirdPartyProposal)(proposal)).toEqual({ ok: true });
+    });
+});

package/dist/tests/unit/ai-enrichment/third-party-subtype.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/third-party-subtype.spec.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const third_party_subtype_1 = require("../../../src/ai-enrichment/third-party-subtype");
+function tp(partial) {
+    const { name, properties, ...rest } = partial;
+    return {
+        id: "cmp_1",
+        type: "third_party",
+        confidence: 0.8,
+        detectedFrom: [],
+        sourceLocations: [],
+        properties: properties ?? {},
+        name,
+        ...rest,
+    };
+}
+describe("normalizeThirdPartySubType", () => {
+    it("normalizes aliases and accepts taxonomy values", () => {
+        expect((0, third_party_subtype_1.normalizeThirdPartySubType)("AI Provider")).toBe("ai_provider");
+        expect((0, third_party_subtype_1.normalizeThirdPartySubType)("saas_service")).toBe("saas_service");
+        expect((0, third_party_subtype_1.normalizeThirdPartySubType)("payment")).toBe("payment_processor");
+    });
+});
+describe("inferThirdPartySubType", () => {
+    it("infers ai_provider for OpenAI from name", () => {
+        expect((0, third_party_subtype_1.inferThirdPartySubType)(tp({ name: "Openai", properties: { client: "openai" } }))).toBe("ai_provider");
+    });
+    it("infers payment_processor for Stripe", () => {
+        expect((0, third_party_subtype_1.inferThirdPartySubType)(tp({ name: "Stripe" }))).toBe("payment_processor");
+    });
+    it("keeps existing normalized subType", () => {
+        expect((0, third_party_subtype_1.inferThirdPartySubType)(tp({ name: "X", subType: "cloud_provider" }))).toBe("cloud_provider");
+    });
+});
+describe("ensureThirdPartySubTypes", () => {
+    it("fills missing subType on third_party components", () => {
+        const components = [
+            tp({ id: "cmp_a", name: "Auth0", subType: undefined }),
+            tp({ id: "cmp_b", name: "Internal API", type: "asset", subType: "api" }),
+        ];
+        const filled = (0, third_party_subtype_1.ensureThirdPartySubTypes)(components);
+        expect(filled).toBe(1);
+        expect(components[0].subType).toBe("saas_service");
+    });
+});

package/dist/tests/unit/ai-enrichment/tools-validation.spec.d.ts

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

package/dist/tests/unit/ai-enrichment/tools-validation.spec.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tools_1 = require("../../../src/ai-enrichment/tools");
+function ctx(files) {
+    return {
+        components: [],
+        dataFlows: [],
+        findings: [],
+        files,
+        sections: [],
+    };
+}
+function openAiPatch(filePath) {
+    return {
+        kind: "component_patch",
+        targetComponentId: "c1",
+        candidateType: "third_party",
+        setProperties: { vendor: "Acme" },
+        confidence: { score: 0.85, band: "high" },
+        evidence: [
+            {
+                filePath,
+                startLine: 1,
+                endLine: 2,
+                reason: "import acme sdk",
+            },
+        ],
+        provider: "openai",
+        model: "gpt-4o-mini",
+        agent: "tpAgent",
+    };
+}
+describe("createAgentTooling validateProposal", () => {
+    const scanned = [
+        {
+            path: "lib/x.ts",
+            name: "x.ts",
+            content: "export {}",
+            language: "typescript",
+            size: 10,
+        },
+    ];
+    it("allows mock proposals with unknown evidence path", () => {
+        const tools = (0, tools_1.createAgentTooling)(ctx(scanned), [], []);
+        const mockPatch = {
+            ...openAiPatch("unknown"),
+            provider: "mock",
+            model: "heuristic",
+            agent: "propertyAgent",
+        };
+        expect(tools.validateProposal(mockPatch)).toEqual({ ok: true });
+    });
+    it("rejects non-mock proposal when evidence path is not in scan", () => {
+        const tools = (0, tools_1.createAgentTooling)(ctx(scanned), [], []);
+        const r = tools.validateProposal(openAiPatch("nowhere.ts"));
+        expect(r).toEqual({ ok: false, reason: "evidence_path_not_in_scan" });
+    });
+    it("accepts non-mock proposal when evidence path matches a scanned file", () => {
+        const tools = (0, tools_1.createAgentTooling)(ctx(scanned), [], []);
+        expect(tools.validateProposal(openAiPatch("lib/x.ts"))).toEqual({ ok: true });
+    });
+    it("skips path check when scan has no files", () => {
+        const tools = (0, tools_1.createAgentTooling)(ctx([]), [], []);
+        expect(tools.validateProposal(openAiPatch("any.ts"))).toEqual({ ok: true });
+    });
+});

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

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

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_1 = require("../../../../src/analyzers/python/parser");
+function createPythonFile(content, path = "app.py") {
+    return {
+        path,
+        name: path,
+        content,
+        language: "python",
+        size: content.length,
+    };
+}
+describe("Python parser - parsePythonModule", () => {
+    it("indexes imports, functions, and module-level calls from a basic module", () => {
+        const content = [
+            "import requests",
+            "from fastapi import FastAPI",
+            "",
+            "app = FastAPI()",
+            "",
+            "def ping():",
+            "    return 'pong'",
+            "",
+            "@app.get('/items/{item_id}')",
+            "async def read_item(item_id: int):",
+            "    response = requests.get('https://example.com/items')",
+            "    return {'item_id': item_id, 'status': response.status_code}",
+            "",
+        ].join("\n");
+        const file = createPythonFile(content);
+        const result = (0, parser_1.parsePythonModule)(file);
+        expect(result.warnings).toEqual([]);
+        expect(result.imports.length).toBe(2);
+        expect(result.functions.length).toBe(2);
+        expect(result.moduleLevelCalls.length).toBeGreaterThanOrEqual(1);
+        const pingFn = result.functions.find((fn) => fn.name === "ping");
+        const readItemFn = result.functions.find((fn) => fn.name === "read_item");
+        expect(pingFn).toBeDefined();
+        expect(pingFn?.isAsync).toBe(false);
+        expect(pingFn?.decorators).toEqual([]);
+        expect(readItemFn).toBeDefined();
+        expect(readItemFn?.isAsync).toBe(true);
+        expect(readItemFn?.decorators).toEqual(["app.get"]);
+    });
+    it("treats non-python languages as a non-fatal warning", () => {
+        const file = {
+            path: "app.ts",
+            name: "app.ts",
+            content: "console.log('hello');",
+            language: "typescript",
+            size: 25,
+        };
+        const result = (0, parser_1.parsePythonModule)(file);
+        expect(result.imports).toEqual([]);
+        expect(result.functions).toEqual([]);
+        expect(result.moduleLevelCalls).toEqual([]);
+        expect(result.warnings.length).toBeGreaterThan(0);
+    });
+    it("returns warnings-only behavior for malformed python function signatures", () => {
+        const content = [
+            "def broken_function:",
+            "    return 1",
+            "",
+            "async def also_broken",
+            "    return 2",
+            "",
+        ].join("\n");
+        const result = (0, parser_1.parsePythonModule)(createPythonFile(content, "malformed.py"));
+        expect(result.imports).toEqual([]);
+        expect(result.functions).toEqual([]);
+        expect(result.moduleLevelCalls).toEqual([]);
+        expect(result.warnings.length).toBeGreaterThanOrEqual(1);
+        expect(result.warnings.join(" ")).toContain("Potentially malformed function signature");
+    });
+    it("treats unreadable-like python content as non-fatal warning", () => {
+        const content = "\u0000\u0000import requests\u0000";
+        const result = (0, parser_1.parsePythonModule)(createPythonFile(content, "unreadable.py"));
+        expect(result.imports).toEqual([]);
+        expect(result.functions).toEqual([]);
+        expect(result.moduleLevelCalls).toEqual([]);
+        expect(result.warnings.length).toBeGreaterThanOrEqual(1);
+        expect(result.warnings.join(" ")).toContain("appears unreadable");
+    });
+    it("extracts valid constructs while warning on malformed signatures", () => {
+        const content = [
+            "import requests",
+            "",
+            "def ok_function():",
+            "    return requests.get('https://example.com/health').status_code",
+            "",
+            "def broken_function:",
+            "    return 1",
+            "",
+            "bootstrap()",
+            "",
+        ].join("\n");
+        const result = (0, parser_1.parsePythonModule)(createPythonFile(content, "mixed.py"));
+        expect(result.imports).toHaveLength(1);
+        expect(result.functions).toHaveLength(1);
+        expect(result.functions[0].name).toBe("ok_function");
+        expect(result.moduleLevelCalls.map((call) => call.callee)).toContain("bootstrap");
+        expect(result.warnings.join(" ")).toContain("Potentially malformed function signature");
+    });
+});

package/dist/tests/unit/analyzers/python/patterns.spec.d.ts

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

package/dist/tests/unit/analyzers/python/patterns.spec.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const detector_1 = require("../../../../src/analyzers/python/detector");
+function makePythonFile(content, path = "app.py") {
+    return {
+        path,
+        name: path,
+        content,
+        language: "python",
+        size: content.length,
+    };
+}
+describe("Python analyzer patterns - DP-P0-CLI-703", () => {
+    it("detects FastAPI route handlers as express_route findings", () => {
+        const content = [
+            "from fastapi import FastAPI",
+            "",
+            "app = FastAPI()",
+            "",
+            "@app.get('/items/{item_id}')",
+            "async def read_item(item_id: int):",
+            "    return {'item_id': item_id}",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "fastapi_app.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const routeFindings = findings.filter((f) => f.pattern === "express_route");
+        expect(routeFindings.length).toBeGreaterThan(0);
+        const first = routeFindings[0];
+        expect(first.name).toContain("GET");
+        expect(first.properties.framework).toBe("fastapi");
+        // FastAPI detection should capture the route path when available.
+        expect(first.properties.path).toBe("/items/{item_id}");
+    });
+    it("detects psycopg2 connections as database_connection findings", () => {
+        const content = [
+            "import psycopg2",
+            "",
+            "conn = psycopg2.connect(dsn='postgres://example')",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "db_psycopg.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const dbFindings = findings.filter((f) => f.pattern === "database_connection");
+        expect(dbFindings.length).toBeGreaterThan(0);
+        const first = dbFindings[0];
+        expect(first.properties.client).toBe("psycopg2");
+        expect(first.properties.databaseType).toBe("postgres");
+    });
+    it("detects requests-based external HTTP calls as external_api_call findings", () => {
+        const content = [
+            "import requests",
+            "",
+            "def call_api():",
+            "    response = requests.get('https://example.com/items')",
+            "    return response.json()",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "external_requests.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const apiFindings = findings.filter((f) => f.pattern === "external_api_call");
+        expect(apiFindings.length).toBeGreaterThan(0);
+        const first = apiFindings[0];
+        expect(first.name).toBe("requests_call");
+        expect(first.properties.url).toBe("https://example.com/items");
+    });
+    it("detects jwt usage as auth_middleware findings", () => {
+        const content = [
+            "import jwt",
+            "",
+            "def make_token(payload):",
+            "    return jwt.encode(payload, 'secret', algorithm='HS256')",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "auth_jwt.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const authFindings = findings.filter((f) => f.pattern === "auth_middleware");
+        expect(authFindings.length).toBeGreaterThan(0);
+        const first = authFindings[0];
+        expect(first.name).toBe("jwt_auth");
+        expect(first.properties.strategy).toBe("jwt");
+    });
+    it("detects os.environ usage as env_variable findings", () => {
+        const content = [
+            "import os",
+            "",
+            "DB_URL = os.environ['DATABASE_URL']",
+            "API_KEY = os.getenv('API_KEY')",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "config_env.py");
+        const findings = (0, detector_1.detectPythonPatterns)(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("detects sentry_sdk usage as external_api_call findings with serviceName 'sentry'", () => {
+        const content = [
+            "import sentry_sdk",
+            "",
+            "sentry_sdk.init(dsn='https://examplePublicKey@o0.ingest.sentry.io/0')",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "sentry_sdk_example.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const sentryFindings = findings.filter((f) => f.pattern === "external_api_call");
+        expect(sentryFindings.length).toBeGreaterThan(0);
+        const first = sentryFindings[0];
+        expect(first.name).toBe("sentry");
+        expect(first.properties.serviceName).toBe("sentry");
+    });
+    it("detects Flask route handlers as express_route findings", () => {
+        const content = [
+            "from flask import Flask",
+            "",
+            "app = Flask(__name__)",
+            "",
+            "@app.route('/items/{item_id}')",
+            "def read_item(item_id):",
+            "    return {'item_id': item_id}",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "flask_app.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const routeFindings = findings.filter((f) => f.pattern === "express_route");
+        expect(routeFindings.length).toBeGreaterThan(0);
+        const first = routeFindings[0];
+        expect(first.properties.framework).toBe("flask");
+        expect(first.properties.path).toBe("/items/{item_id}");
+        expect(first.name).toContain("GET");
+    });
+    it("detects Django class-based views from urls.py route bindings", () => {
+        const content = [
+            "from django.urls import path",
+            "from .views import UserListView",
+            "",
+            "urlpatterns = [",
+            "    path('users/', UserListView.as_view(), name='user-list'),",
+            "]",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "project/urls.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const routeFindings = findings.filter((f) => f.pattern === "express_route");
+        expect(routeFindings.length).toBeGreaterThan(0);
+        const classBased = routeFindings.find((f) => f.properties.framework === "django" &&
+            f.properties.path === "users/" &&
+            f.properties.handlerType === "class_based_view");
+        expect(classBased).toBeDefined();
+    });
+    it("detects DRF function-based views using @api_view", () => {
+        const content = [
+            "from rest_framework.decorators import api_view",
+            "",
+            "@api_view(['GET', 'POST'])",
+            "def users(request):",
+            "    return None",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "api/views.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const routeFindings = findings.filter((f) => f.pattern === "express_route");
+        expect(routeFindings.length).toBeGreaterThan(0);
+        const drfFinding = routeFindings.find((f) => f.properties.framework === "drf" &&
+            f.properties.handlerType === "function_based_view");
+        expect(drfFinding).toBeDefined();
+        expect(drfFinding?.properties.httpMethods).toEqual(["GET", "POST"]);
+    });
+    it("detects DRF router.register(...) viewset routes in urls.py", () => {
+        const content = [
+            "from rest_framework.routers import DefaultRouter",
+            "from .views import UserViewSet",
+            "",
+            "router = DefaultRouter()",
+            "router.register('users', UserViewSet, basename='user')",
+            "",
+            "urlpatterns = router.urls",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "api/urls.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const routeFindings = findings.filter((f) => f.pattern === "express_route");
+        expect(routeFindings.length).toBeGreaterThan(0);
+        const drfRoute = routeFindings.find((f) => f.name === "DRF_ROUTE users" &&
+            f.properties.framework === "drf" &&
+            f.properties.handlerType === "viewset_route");
+        expect(drfRoute).toBeDefined();
+        expect(drfRoute?.properties.handler).toBe("UserViewSet");
+    });
+    it("detects login_required decorator usage as auth_middleware findings", () => {
+        const content = [
+            "from somewhere import login_required",
+            "",
+            "@login_required",
+            "def dashboard():",
+            "    return 'ok'",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "auth_login_required.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const authFindings = findings.filter((f) => f.pattern === "auth_middleware");
+        expect(authFindings.length).toBeGreaterThan(0);
+        expect(authFindings[0].name).toBe("auth_decorator");
+    });
+    it("detects dotenv usage as config_file findings (dotenv_config)", () => {
+        const content = [
+            "import os",
+            "from dotenv import load_dotenv",
+            "",
+            "load_dotenv('.env')",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "dotenv_example.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const dotenvFindings = findings.filter((f) => f.pattern === "config_file" && f.name === "dotenv_config");
+        expect(dotenvFindings.length).toBeGreaterThan(0);
+    });
+    it("detects SQLAlchemy connections as database_connection findings", () => {
+        const content = [
+            "from sqlalchemy import create_engine",
+            "",
+            "engine = create_engine('postgresql://user:pass@localhost/db')",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "db_sqlalchemy.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const dbFindings = findings.filter((f) => f.pattern === "database_connection");
+        expect(dbFindings.length).toBeGreaterThan(0);
+        const first = dbFindings[0];
+        expect(first.properties.client).toBe("sqlalchemy");
+        expect(first.properties.databaseType).toBe("sql");
+    });
+    it("detects Django ORM usage (.objects.) as database_connection findings", () => {
+        const content = [
+            "from django.db import models",
+            "",
+            "def list_users():",
+            "    return models.User.objects.all()",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "db_django_orm.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const dbFindings = findings.filter((f) => f.pattern === "database_connection");
+        expect(dbFindings.length).toBeGreaterThan(0);
+        const first = dbFindings[0];
+        expect(first.properties.client).toBe("django_orm");
+        expect(first.properties.databaseType).toBe("sql");
+    });
+    it("infers serviceName from external API URLs (e.g. requests to api.openai.com)", () => {
+        const content = [
+            "import requests",
+            "",
+            "response = requests.get('https://api.openai.com/v1/chat/completions')",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, "external_requests_openai.py");
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const apiFindings = findings.filter((f) => f.pattern === "external_api_call");
+        expect(apiFindings.length).toBeGreaterThan(0);
+        const first = apiFindings[0];
+        expect(first.name).toBe("requests_call");
+        expect(first.properties.url).toBe("https://api.openai.com/v1/chat/completions");
+        expect(first.properties.serviceName).toBe("openai");
+    });
+    it.each([
+        { moduleName: "boto3", expectedServiceName: "aws" },
+        { moduleName: "stripe", expectedServiceName: "stripe" },
+        { moduleName: "sendgrid", expectedServiceName: "sendgrid" },
+        { moduleName: "twilio.rest", expectedServiceName: "twilio" },
+        { moduleName: "openai", expectedServiceName: "openai" },
+    ])("detects common Python SDK imports as external_api_call findings (%s)", ({ moduleName, expectedServiceName }) => {
+        const content = [
+            `import ${moduleName}`,
+            "",
+            "def run():",
+            "    return True",
+            "",
+        ].join("\n");
+        const file = makePythonFile(content, `${expectedServiceName}_sdk.py`);
+        const findings = (0, detector_1.detectPythonPatterns)(file);
+        const apiFindings = findings.filter((f) => f.pattern === "external_api_call");
+        expect(apiFindings.length).toBeGreaterThan(0);
+        const serviceFinding = apiFindings.find((f) => f.name === expectedServiceName &&
+            f.properties.serviceName === expectedServiceName);
+        expect(serviceFinding).toBeDefined();
+    });
+});

package/dist/tests/unit/analyzers/registry.spec.d.ts

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