@dataparade/cli 0.0.1

package/dist/src/platform-api/estimate-scan-footprint.d.ts

@@ -0,0 +1,8 @@
+export type ScanFootprintEstimate = {
+    fileCount: number;
+    bytesIngested: number;
+};
+/**
+ * Cheap footprint for platform quota preflight (same idea as hosted zip/git estimates).
+ */
+export declare function estimateScanFootprint(scanRootDir: string, excludePaths?: string[]): Promise<ScanFootprintEstimate>;

package/dist/src/platform-api/estimate-scan-footprint.js

@@ -0,0 +1,120 @@
+"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 });
+exports.estimateScanFootprint = estimateScanFootprint;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const gitignore_1 = require("../ingest/gitignore");
+const scan_exclusions_1 = require("../patterns/scan-exclusions");
+const MAX_FILES_TO_MEASURE = 50_000;
+function normalizeUserPattern(pattern) {
+    return (0, gitignore_1.toPosixPath)(pattern.replace(/^\.\/+/, "").trim());
+}
+function isExcludedByUserPatterns(relativePath, isDirectory, excludePaths) {
+    const rel = (0, gitignore_1.toPosixPath)(relativePath);
+    for (const rawPattern of excludePaths) {
+        const pattern = normalizeUserPattern(rawPattern);
+        if (!pattern)
+            continue;
+        if (pattern.endsWith("/**")) {
+            const prefix = pattern.slice(0, -3).replace(/\/$/, "");
+            if (rel === prefix || rel.startsWith(`${prefix}/`))
+                return true;
+        }
+        const regex = (0, gitignore_1.gitignorePatternToRegex)(pattern, isDirectory);
+        if (regex.test(rel))
+            return true;
+    }
+    return false;
+}
+async function walkFootprint(currentDir, rootDir, accumulatedRules, excludePaths, state) {
+    if (state.capped)
+        return;
+    const rules = await (0, gitignore_1.gitignoreRulesForDir)(currentDir, accumulatedRules);
+    let entries;
+    try {
+        entries = await fs_1.promises.readdir(currentDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (state.capped)
+            return;
+        const entryPath = path.join(currentDir, entry.name);
+        const relativePath = (0, gitignore_1.toPosixPath)(path.relative(rootDir, entryPath));
+        if (entry.isDirectory()) {
+            if ((0, scan_exclusions_1.shouldSkipDirectoryName)(entry.name))
+                continue;
+            if (relativePath &&
+                isExcludedByUserPatterns(relativePath, true, excludePaths)) {
+                continue;
+            }
+            if ((0, gitignore_1.isPathIgnored)(entryPath, true, rules))
+                continue;
+            await walkFootprint(entryPath, rootDir, rules, excludePaths, state);
+        }
+        else if (entry.isFile()) {
+            if (relativePath &&
+                isExcludedByUserPatterns(relativePath, false, excludePaths)) {
+                continue;
+            }
+            if ((0, gitignore_1.isPathIgnored)(entryPath, false, rules))
+                continue;
+            try {
+                const stat = await fs_1.promises.stat(entryPath);
+                state.fileCount += 1;
+                state.bytesIngested += Math.max(0, stat.size);
+                if (state.fileCount >= MAX_FILES_TO_MEASURE) {
+                    state.capped = true;
+                }
+            }
+            catch {
+                // unreadable file — skip
+            }
+        }
+    }
+}
+/**
+ * Cheap footprint for platform quota preflight (same idea as hosted zip/git estimates).
+ */
+async function estimateScanFootprint(scanRootDir, excludePaths = []) {
+    const state = { fileCount: 0, bytesIngested: 0, capped: false };
+    await walkFootprint(scanRootDir, scanRootDir, [], excludePaths, state);
+    return {
+        fileCount: Math.max(1, state.fileCount),
+        bytesIngested: Math.max(0, state.bytesIngested),
+    };
+}

package/dist/src/platform-api/scan-quota-client.d.ts

@@ -0,0 +1,28 @@
+/** Thrown when preflight/complete is rejected with HTTP 403 scan_quota_exceeded. */
+export declare class CliScanQuotaExceededError extends Error {
+    readonly code: "scan_quota_exceeded";
+    constructor(message: string);
+}
+export type CliScanPreflightResponse = {
+    allowed: boolean;
+    jobId: string;
+    scansRemaining: number;
+    aiTokensRemaining: number;
+    suggestedAiBudgetTokens: number;
+    aiDelivery?: 'platform_proxy' | 'none';
+};
+export declare function cliScanPreflight(input: {
+    apiKey: string;
+    enableAi?: boolean;
+    projectName?: string;
+    fileCount?: number;
+    bytesIngested?: number;
+}): Promise<CliScanPreflightResponse>;
+export declare function cliScanComplete(input: {
+    apiKey: string;
+    jobId: string;
+    status: "completed" | "failed";
+    aiTokensUsed?: number;
+    failureCode?: string;
+    failureMessage?: string;
+}): Promise<void>;

package/dist/src/platform-api/scan-quota-client.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliScanQuotaExceededError = void 0;
+exports.cliScanPreflight = cliScanPreflight;
+exports.cliScanComplete = cliScanComplete;
+const dataparade_api_base_url_1 = require("./dataparade-api-base-url");
+/** Thrown when preflight/complete is rejected with HTTP 403 scan_quota_exceeded. */
+class CliScanQuotaExceededError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = "scan_quota_exceeded";
+        this.name = "CliScanQuotaExceededError";
+    }
+}
+exports.CliScanQuotaExceededError = CliScanQuotaExceededError;
+function buildHeaders(apiKey) {
+    return {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+    };
+}
+async function cliScanPreflight(input) {
+    const res = await fetch(`${(0, dataparade_api_base_url_1.getDataparadeApiBaseUrl)()}/api/scans/cli/preflight`, {
+        method: "POST",
+        headers: buildHeaders(input.apiKey),
+        body: JSON.stringify({
+            enableAi: input.enableAi,
+            projectName: input.projectName,
+            fileCount: input.fileCount,
+            bytesIngested: input.bytesIngested,
+        }),
+    });
+    if (!res.ok) {
+        let message = `Scan preflight failed (${res.status})`;
+        let code;
+        try {
+            const body = (await res.json());
+            code = body.code;
+            if (typeof body.message === "string")
+                message = body.message;
+            else if (Array.isArray(body.message))
+                message = body.message.join(", ");
+        }
+        catch {
+            // ignore
+        }
+        if (res.status === 403 && code === "scan_quota_exceeded") {
+            throw new CliScanQuotaExceededError(message);
+        }
+        throw new Error(message);
+    }
+    return (await res.json());
+}
+async function cliScanComplete(input) {
+    const res = await fetch(`${(0, dataparade_api_base_url_1.getDataparadeApiBaseUrl)()}/api/scans/cli/${encodeURIComponent(input.jobId)}/complete`, {
+        method: "POST",
+        headers: buildHeaders(input.apiKey),
+        body: JSON.stringify({
+            status: input.status,
+            aiTokensUsed: input.aiTokensUsed,
+            failureCode: input.failureCode,
+            failureMessage: input.failureMessage,
+        }),
+    });
+    if (!res.ok) {
+        let message = `Scan complete report failed (${res.status})`;
+        try {
+            const body = (await res.json());
+            if (typeof body.message === "string")
+                message = body.message;
+            else if (Array.isArray(body.message))
+                message = body.message.join(", ");
+        }
+        catch {
+            // ignore
+        }
+        throw new Error(message);
+    }
+}

package/dist/src/tracing/langsmith-tracing.d.ts

@@ -0,0 +1,37 @@
+import type { InferencePipelineResult } from "../ai-enrichment/types";
+import type { OrchestratorScanResult } from "../core/pipeline/orchestrator-result";
+import type { AiInferenceSummary } from "../core/types/result";
+/**
+ * LangSmith / LangChain tracing for CLI scan and AI inference.
+ *
+ * Trace payloads are summary-only (counts and ids) so uploads stay under API
+ * size limits. Trace upload failures are logged and never fail the scan.
+ *
+ * Set:
+ * - LANGSMITH_API_KEY (or LANGCHAIN_API_KEY)
+ * - LANGCHAIN_TRACING_V2=true or LANGSMITH_TRACING=true
+ * - LANGSMITH_PROJECT (optional; also LANGCHAIN_PROJECT)
+ *
+ * @see https://docs.smith.langchain.com/
+ */
+export declare function isLangSmithTracingEnabled(): boolean;
+/** Summary sent to LangSmith instead of full scan output (keeps traces small). */
+export declare function buildLangSmithScanTraceSummary(result: OrchestratorScanResult): Record<string, unknown>;
+export declare function buildLangSmithInferencePipelineTraceSummary(result: InferencePipelineResult): Record<string, unknown>;
+export declare function buildLangSmithAiInferenceTraceSummary(summary: AiInferenceSummary): Record<string, unknown>;
+export declare function traceDataparadeScan<T extends OrchestratorScanResult>(meta: {
+    rootPath: string;
+    projectName?: string;
+    enableAiInference?: boolean;
+    run: () => Promise<T>;
+}): Promise<T>;
+export declare function traceDataparadeAiInference<T extends InferencePipelineResult>(meta: {
+    provider?: string;
+    model?: string;
+    run: () => Promise<T>;
+}): Promise<T>;
+export declare function traceDataparadeProviderInfer<T>(meta: {
+    providerId: string;
+    model: string;
+    run: () => Promise<T>;
+}): Promise<T>;

package/dist/src/tracing/langsmith-tracing.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLangSmithTracingEnabled = isLangSmithTracingEnabled;
+exports.buildLangSmithScanTraceSummary = buildLangSmithScanTraceSummary;
+exports.buildLangSmithInferencePipelineTraceSummary = buildLangSmithInferencePipelineTraceSummary;
+exports.buildLangSmithAiInferenceTraceSummary = buildLangSmithAiInferenceTraceSummary;
+exports.traceDataparadeScan = traceDataparadeScan;
+exports.traceDataparadeAiInference = traceDataparadeAiInference;
+exports.traceDataparadeProviderInfer = traceDataparadeProviderInfer;
+const traceable_1 = require("langsmith/traceable");
+/**
+ * LangSmith / LangChain tracing for CLI scan and AI inference.
+ *
+ * Trace payloads are summary-only (counts and ids) so uploads stay under API
+ * size limits. Trace upload failures are logged and never fail the scan.
+ *
+ * Set:
+ * - LANGSMITH_API_KEY (or LANGCHAIN_API_KEY)
+ * - LANGCHAIN_TRACING_V2=true or LANGSMITH_TRACING=true
+ * - LANGSMITH_PROJECT (optional; also LANGCHAIN_PROJECT)
+ *
+ * @see https://docs.smith.langchain.com/
+ */
+function isLangSmithTracingEnabled() {
+    const key = process.env.LANGSMITH_API_KEY ?? process.env.LANGCHAIN_API_KEY;
+    if (!key || key.trim().length === 0)
+        return false;
+    const on = process.env.LANGCHAIN_TRACING_V2 === "true" ||
+        process.env.LANGSMITH_TRACING === "true";
+    return on;
+}
+function warnLangsmithTraceFailure(context, err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[dataparade] LangSmith trace upload failed (${context}): ${message}\n`);
+}
+function countComponentsByType(components) {
+    const counts = {};
+    for (const component of components) {
+        counts[component.type] = (counts[component.type] ?? 0) + 1;
+    }
+    return counts;
+}
+function uniqueSectionIds(components) {
+    const ids = new Set();
+    for (const component of components) {
+        const raw = component.properties?.section_id;
+        if (typeof raw === "string" && raw.trim()) {
+            ids.add(raw.trim());
+        }
+    }
+    return [...ids].sort();
+}
+/** Summary sent to LangSmith instead of full scan output (keeps traces small). */
+function buildLangSmithScanTraceSummary(result) {
+    const scan = result.scanResult;
+    const ai = scan.aiInferenceSummary;
+    return {
+        filesScanned: scan.filesScanned,
+        filesSkipped: scan.filesSkipped,
+        totalLines: scan.totalLines,
+        scanDurationMs: scan.scanDurationMs,
+        componentCount: scan.components.length,
+        dataFlowCount: scan.dataFlows.length,
+        warningCount: scan.warnings.length,
+        errorCount: scan.errors.length,
+        findingCount: result.findings.length,
+        componentTypes: countComponentsByType(scan.components),
+        sectionIds: uniqueSectionIds(scan.components),
+        languageStats: scan.languageStats?.map((s) => ({
+            language: s.language,
+            filesParsed: s.filesParsed,
+        })),
+        aiInference: ai ? buildLangSmithAiInferenceTraceSummary(ai) : undefined,
+        terraformScanSummary: scan.terraformScanSummary,
+    };
+}
+function buildLangSmithInferencePipelineTraceSummary(result) {
+    return {
+        candidateCount: result.candidates.length,
+        proposalCount: result.proposals.length,
+        appliedProposalCount: result.mergeResult.appliedProposalIds.length,
+        rejectedProposalCount: result.mergeResult.rejectedProposalIds.length,
+        queueCount: result.plan.queues.length,
+        droppedCandidateCount: result.plan.droppedCandidates.length,
+        usageSummary: result.usageSummary,
+    };
+}
+function buildLangSmithAiInferenceTraceSummary(summary) {
+    return {
+        candidatesConsidered: summary.candidatesConsidered,
+        proposalsGenerated: summary.proposalsGenerated,
+        proposalsApplied: summary.proposalsApplied,
+        proposalsRejected: summary.proposalsRejected,
+        proposalsGeneratedHeuristic: summary.proposalsGeneratedHeuristic,
+        proposalsAppliedHeuristic: summary.proposalsAppliedHeuristic,
+        proposalsGeneratedProvider: summary.proposalsGeneratedProvider,
+        proposalsAppliedProvider: summary.proposalsAppliedProvider,
+        providerCalls: summary.providerCalls,
+        inputTokens: summary.inputTokens,
+        outputTokens: summary.outputTokens,
+        totalTokens: summary.totalTokens,
+        estimatedCostUsd: summary.estimatedCostUsd,
+        aiProvider: summary.aiProvider,
+        aiModel: summary.aiModel,
+    };
+}
+async function runWithLangSmithTrace(traced, context, run, summarize) {
+    let result;
+    try {
+        await traced({
+            run: async () => {
+                result = await run();
+                return summarize(result);
+            },
+        });
+    }
+    catch (err) {
+        if (result === undefined) {
+            throw err;
+        }
+        warnLangsmithTraceFailure(context, err);
+    }
+    return result;
+}
+const tracedScanRoot = (0, traceable_1.traceable)(async (payload) => payload.run(), {
+    name: "dataparade_scan",
+    run_type: "chain",
+    metadata: { app: "dataparade-cli" },
+});
+const tracedAiInference = (0, traceable_1.traceable)(async (payload) => payload.run(), {
+    name: "dataparade_ai_inference",
+    run_type: "chain",
+});
+const tracedProviderInfer = (0, traceable_1.traceable)(async (payload) => payload.run(), {
+    name: "dataparade_provider_infer",
+    run_type: "llm",
+});
+async function traceDataparadeScan(meta) {
+    if (!isLangSmithTracingEnabled()) {
+        return meta.run();
+    }
+    return runWithLangSmithTrace((payload) => tracedScanRoot({
+        rootPath: meta.rootPath,
+        projectName: meta.projectName,
+        enableAiInference: meta.enableAiInference,
+        run: payload.run,
+    }), "dataparade_scan", meta.run, buildLangSmithScanTraceSummary);
+}
+async function traceDataparadeAiInference(meta) {
+    if (!isLangSmithTracingEnabled()) {
+        return meta.run();
+    }
+    return runWithLangSmithTrace((payload) => tracedAiInference({
+        provider: meta.provider,
+        model: meta.model,
+        run: payload.run,
+    }), "dataparade_ai_inference", meta.run, buildLangSmithInferencePipelineTraceSummary);
+}
+async function traceDataparadeProviderInfer(meta) {
+    if (!isLangSmithTracingEnabled()) {
+        return meta.run();
+    }
+    return runWithLangSmithTrace((payload) => tracedProviderInfer({
+        providerId: meta.providerId,
+        model: meta.model,
+        run: payload.run,
+    }), "dataparade_provider_infer", meta.run, () => ({
+        providerId: meta.providerId,
+        model: meta.model,
+    }));
+}

package/dist/tests/cli/cli.spec.d.ts

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

package/dist/tests/cli/cli.spec.js

@@ -0,0 +1,87 @@
+"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 fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const cliDistPath = path_1.default.join(__dirname, "../../dist/bin/cli.js");
+describe("CLI", () => {
+    beforeAll(() => {
+        if (!(0, fs_1.existsSync)(cliDistPath)) {
+            throw new Error(`CLI not built. Run 'pnpm build' first. Expected: ${cliDistPath}`);
+        }
+    });
+    it("scan <path> writes a dataflow.json wrapper to the current directory and exits 0", () => {
+        const result = (0, child_process_1.spawnSync)("node", [cliDistPath, "scan", "."], {
+            encoding: "utf-8",
+            cwd: path_1.default.join(__dirname, "../../"),
+        });
+        expect(result.status).toBe(0);
+        const cliCwd = path_1.default.join(__dirname, "../../");
+        const outputPath = path_1.default.join(cliCwd, "dataflow.json");
+        const exists = (0, fs_1.existsSync)(outputPath);
+        expect(exists).toBe(true);
+        const contents = (0, fs_1.readFileSync)(outputPath, "utf8").trim();
+        const dataflow = JSON.parse(contents);
+        expect(dataflow.schemaVersion).toBeDefined();
+        expect(dataflow.graph).toBeDefined();
+        expect(Array.isArray(dataflow.graph.nodes)).toBe(true);
+        expect(Array.isArray(dataflow.graph.edges)).toBe(true);
+    });
+    it("scan ../frontend produces a dataflow.json wrapper with at least one node", () => {
+        const cliCwd = path_1.default.join(__dirname, "../../");
+        const frontendPath = "../frontend";
+        const result = (0, child_process_1.spawnSync)("node", [cliDistPath, "scan", frontendPath], {
+            encoding: "utf-8",
+            cwd: cliCwd,
+        });
+        expect(result.status).toBe(0);
+        const outputPath = path_1.default.join(cliCwd, "dataflow.json");
+        const contents = (0, fs_1.readFileSync)(outputPath, "utf8").trim();
+        const dataflow = JSON.parse(contents);
+        expect(Array.isArray(dataflow.graph.nodes)).toBe(true);
+        expect(dataflow.graph.nodes.length).toBeGreaterThan(0);
+    });
+    it("scan ../frontend --output writes a dataflow.json wrapper to the given file and prints a short message", () => {
+        const cliCwd = path_1.default.join(__dirname, "../../");
+        const frontendPath = "../frontend";
+        const outputFile = "scan-frontend-summary.json";
+        const result = (0, child_process_1.spawnSync)("node", [cliDistPath, "scan", frontendPath, "--output", outputFile], {
+            encoding: "utf-8",
+            cwd: cliCwd,
+        });
+        expect(result.status).toBe(0);
+        expect(result.stdout).toContain(`[scan] dataflow.json written to ${path_1.default.join(cliCwd, outputFile)}`);
+        const fileContents = (0, fs_1.readFileSync)(path_1.default.join(cliCwd, outputFile), "utf8").trim();
+        const dataflow = JSON.parse(fileContents);
+        expect(dataflow.graph).toBeDefined();
+        expect(Array.isArray(dataflow.graph.nodes)).toBe(true);
+    });
+    it("unknown command shows usage and exits non-zero", () => {
+        const result = (0, child_process_1.spawnSync)("node", [cliDistPath, "unknowncommand"], {
+            encoding: "utf-8",
+            cwd: path_1.default.join(__dirname, "../../"),
+        });
+        expect(result.status).not.toBe(0);
+        expect(result.stderr).toMatch(/Unknown command|error|usage|Usage/i);
+    });
+    it("--help shows usage", () => {
+        const result = (0, child_process_1.spawnSync)("node", [cliDistPath, "--help"], {
+            encoding: "utf-8",
+            cwd: path_1.default.join(__dirname, "../../"),
+        });
+        expect(result.status).toBe(0);
+        expect(result.stdout).toContain("dataparade");
+        expect(result.stdout).toContain("scan");
+    });
+    it("scan --help shows scan usage", () => {
+        const result = (0, child_process_1.spawnSync)("node", [cliDistPath, "scan", "--help"], {
+            encoding: "utf-8",
+            cwd: path_1.default.join(__dirname, "../../"),
+        });
+        expect(result.status).toBe(0);
+        expect(result.stdout).toMatch(/scan|path/i);
+    });
+});

package/dist/tests/fixtures/e2e-ts-sample/db-client-import.d.ts

@@ -0,0 +1,2 @@
+import "./pg-client";
+export declare function ensurePgClientLoaded(): void;

package/dist/tests/fixtures/e2e-ts-sample/db-client-import.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePgClientLoaded = ensurePgClientLoaded;
+require("./pg-client");
+function ensurePgClientLoaded() {
+    // This module exists so the TypeScript analyzer sees a module import containing
+    // "pg" and can emit a database_connection finding for tests.
+}

package/dist/tests/fixtures/e2e-ts-sample/db.d.ts

@@ -0,0 +1,3 @@
+type QueryResultRow = Record<string, unknown>;
+export declare function getUserById(id: string): Promise<QueryResultRow>;
+export {};

package/dist/tests/fixtures/e2e-ts-sample/db.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserById = getUserById;
+async function getUserById(id) {
+    const result = await pool.query("SELECT * FROM users WHERE id = $1", [id]);
+    return result.rows[0];
+}

package/dist/tests/fixtures/e2e-ts-sample/external-api.d.ts

@@ -0,0 +1 @@
+export declare function callExternalApi(): Promise<any>;

package/dist/tests/fixtures/e2e-ts-sample/external-api.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callExternalApi = callExternalApi;
+async function callExternalApi() {
+    const apiKey = process.env.API_KEY;
+    // Use a host that matches a known third-party (stripe) so the
+    // external_api_call pattern plus classifier will produce a third_party
+    // component and a corresponding data flow in tests.
+    const response = await fetch("https://api.stripe.com/v1/customers", {
+        headers: {
+            "x-api-key": apiKey ?? "test-key",
+        },
+    });
+    if (!response.ok) {
+        throw new Error("API request failed");
+    }
+    return response.json();
+}

package/dist/tests/fixtures/e2e-ts-sample/pg-client.d.ts

@@ -0,0 +1,3 @@
+type QueryResultRow = Record<string, unknown>;
+export declare function runHealthCheck(): Promise<QueryResultRow | undefined>;
+export {};

package/dist/tests/fixtures/e2e-ts-sample/pg-client.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHealthCheck = runHealthCheck;
+async function runHealthCheck() {
+    const result = await pool.query("SELECT 1", []);
+    return result.rows[0];
+}

package/dist/tests/fixtures/e2e-ts-sample/server.d.ts

@@ -0,0 +1,14 @@
+type E2eRequestLike = {
+    [key: string]: unknown;
+};
+type E2eResponseLike = {
+    send: (body: unknown) => void;
+};
+declare const e2eApp: {
+    get: (path: string, ...handlers: Array<(req: E2eRequestLike, res: E2eResponseLike, next?: () => void) => void>) => void;
+};
+declare const e2ePassport: {
+    authenticate: (strategy: string, options?: {
+        session?: boolean;
+    }) => (req: E2eRequestLike, res: E2eResponseLike, next: (() => void) | undefined) => void;
+};

package/dist/tests/fixtures/e2e-ts-sample/server.js

@@ -0,0 +1,4 @@
+"use strict";
+e2eApp.get("/users", e2ePassport.authenticate("jwt", { session: false }), (req, res) => {
+    res.send("ok");
+});

package/dist/tests/fixtures/e2e-ts-sentry-route-env/server.d.ts

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

package/dist/tests/fixtures/e2e-ts-sentry-route-env/server.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const app = (0, express_1.default)();
+// Express route (used by `express_route` detection).
+app.get("/users", (req, res) => {
+    res.send("ok");
+});
+// Env var usage (used by `env_variable` detection).
+const apiKey = process.env.API_KEY;
+const awsRegion = process.env.AWS_REGION;
+// Sentry ingestion (used by `external_api_call` detection with serviceName inference).
+async function callSentry() {
+    await fetch("https://o0.ingest.sentry.io/api/123/envelope/", {
+        method: "POST",
+        body: "{}",
+    });
+}
+void apiKey;
+void awsRegion;
+void callSentry;

package/dist/tests/fixtures/ingest-basic/src/index.d.ts

@@ -0,0 +1 @@
+export declare function main(): void;

package/dist/tests/fixtures/ingest-basic/src/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+function main() {
+    console.log("hello from index.ts");
+}

package/dist/tests/fixtures/mixed-language-basic/api.d.ts

@@ -0,0 +1,2 @@
+declare const app: any;
+export default app;