@dataparade/cli 0.0.1

package/dist/src/analyzers/python/parser.d.ts

@@ -0,0 +1,26 @@
+import type { FileInfo, SourceLocation } from "../../core/types/file";
+export interface PythonImportEntry {
+    module: string;
+    names: string[];
+    location: SourceLocation;
+}
+export interface PythonFunctionEntry {
+    name: string;
+    isAsync: boolean;
+    decorators: string[];
+    location: SourceLocation;
+}
+export interface PythonModuleLevelCallEntry {
+    callee: string;
+    argumentsSnippet: string;
+    location: SourceLocation;
+}
+export interface PythonModuleModel {
+    file: FileInfo;
+    normalizedPath: string;
+    imports: PythonImportEntry[];
+    functions: PythonFunctionEntry[];
+    moduleLevelCalls: PythonModuleLevelCallEntry[];
+    warnings: string[];
+}
+export declare function parsePythonModule(file: FileInfo): PythonModuleModel;

package/dist/src/analyzers/python/parser.js

@@ -0,0 +1,187 @@
+"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.parsePythonModule = parsePythonModule;
+const nodePath = __importStar(require("path"));
+function parsePythonModule(file) {
+    const warnings = [];
+    const normalizedPath = normalizePath(file.path);
+    if (file.language !== "python") {
+        warnings.push(`Unsupported language '${file.language}' for Python parser in file '${file.path}'.`);
+        return {
+            file,
+            normalizedPath,
+            imports: [],
+            functions: [],
+            moduleLevelCalls: [],
+            warnings,
+        };
+    }
+    const content = file.content ?? "";
+    if (content.includes("\u0000")) {
+        warnings.push(`File '${file.path}' appears unreadable (contains null bytes); parser will continue with best-effort analysis.`);
+    }
+    const lines = content.split(/\r?\n/);
+    const imports = [];
+    const functions = [];
+    const moduleLevelCalls = [];
+    const toLocation = (startLine, endLine) => ({
+        filePath: file.path,
+        startLine,
+        endLine,
+    });
+    // Track decorators immediately above the next function definition.
+    let pendingDecorators = [];
+    const importRegex = /^(?:from\s+([a-zA-Z0-9_\.]+)\s+import\s+(.+)|import\s+(.+))\s*$/;
+    const defRegex = /^def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/;
+    const asyncDefRegex = /^async\s+def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/;
+    const decoratorRegex = /^@([a-zA-Z_][a-zA-Z0-9_\.]*)/;
+    const callRegex = /([a-zA-Z_][a-zA-Z0-9_\.]*)\s*\(/;
+    const isIndented = (line) => /^\s/.test(line) && !/^\s*#/.test(line);
+    for (let i = 0; i < lines.length; i += 1) {
+        const rawLine = lines[i];
+        const line = rawLine.trimEnd();
+        const text = line.trimStart();
+        const lineNumber = i + 1;
+        if (!text || text.startsWith("#")) {
+            continue;
+        }
+        const decoratorMatch = text.match(decoratorRegex);
+        if (decoratorMatch) {
+            pendingDecorators.push(decoratorMatch[1]);
+            continue;
+        }
+        const importMatch = text.match(importRegex);
+        if (importMatch) {
+            const fromModule = importMatch[1];
+            const fromNames = importMatch[2];
+            const directImports = importMatch[3];
+            if (fromModule) {
+                const names = fromNames
+                    .split(",")
+                    .map((part) => part.trim())
+                    .filter(Boolean)
+                    .map((part) => {
+                    const [name] = part.split(/\s+as\s+/);
+                    return name.trim();
+                });
+                imports.push({
+                    module: fromModule,
+                    names,
+                    location: toLocation(lineNumber, lineNumber),
+                });
+            }
+            else if (directImports) {
+                const modules = directImports
+                    .split(",")
+                    .map((part) => part.trim())
+                    .filter(Boolean);
+                imports.push({
+                    module: modules.join(", "),
+                    names: [],
+                    location: toLocation(lineNumber, lineNumber),
+                });
+            }
+            pendingDecorators = [];
+            continue;
+        }
+        const asyncMatch = text.match(asyncDefRegex);
+        const defMatch = text.match(defRegex);
+        if (asyncMatch || defMatch) {
+            const isAsync = !!asyncMatch;
+            const name = (asyncMatch ?? defMatch)[1];
+            let endLine = lineNumber;
+            for (let j = i + 1; j < lines.length; j += 1) {
+                const nextLine = lines[j];
+                if (!nextLine.trim()) {
+                    endLine = j + 1;
+                    continue;
+                }
+                if (!isIndented(nextLine)) {
+                    break;
+                }
+                endLine = j + 1;
+            }
+            functions.push({
+                name,
+                isAsync,
+                decorators: pendingDecorators,
+                location: toLocation(lineNumber, endLine),
+            });
+            pendingDecorators = [];
+            continue;
+        }
+        if (text.startsWith("def ") || text.startsWith("async def ")) {
+            warnings.push(`Potentially malformed function signature in '${file.path}' at line ${lineNumber}.`);
+            pendingDecorators = [];
+            continue;
+        }
+        const callMatch = text.match(callRegex);
+        if (callMatch) {
+            const callee = callMatch[1];
+            const firstParenIndex = text.indexOf("(");
+            const argsSnippet = firstParenIndex >= 0
+                ? text.slice(firstParenIndex + 1).slice(0, 120)
+                : "";
+            moduleLevelCalls.push({
+                callee,
+                argumentsSnippet: argsSnippet,
+                location: toLocation(lineNumber, lineNumber),
+            });
+            pendingDecorators = [];
+            continue;
+        }
+        pendingDecorators = [];
+    }
+    return {
+        file,
+        normalizedPath,
+        imports,
+        functions,
+        moduleLevelCalls,
+        warnings,
+    };
+}
+function normalizePath(p) {
+    if (!p)
+        return "";
+    const normalized = p.split("\\").join("/");
+    return normalizedPathIsRelativeToCwd(normalized)
+        ? normalized
+        : normalized.replace(nodePath.resolve(), "").replace(/^\/+/, "");
+}
+function normalizedPathIsRelativeToCwd(p) {
+    return !p.startsWith("/") && !p.match(/^[A-Za-z]:\//);
+}

package/dist/src/analyzers/python/patterns.d.ts

@@ -0,0 +1,7 @@
+import type { RawFinding } from "../../core/types/detection";
+import type { PythonModuleModel } from "./parser";
+export declare function detectPythonRoutePatterns(moduleModel: PythonModuleModel): RawFinding[];
+export declare function detectPythonDatabaseConnections(moduleModel: PythonModuleModel): RawFinding[];
+export declare function detectPythonExternalApiCalls(moduleModel: PythonModuleModel): RawFinding[];
+export declare function detectPythonAuthPatterns(moduleModel: PythonModuleModel): RawFinding[];
+export declare function detectPythonConfigAndEnvUsage(moduleModel: PythonModuleModel): RawFinding[];

package/dist/src/analyzers/python/patterns.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPythonRoutePatterns = detectPythonRoutePatterns;
+exports.detectPythonDatabaseConnections = detectPythonDatabaseConnections;
+exports.detectPythonExternalApiCalls = detectPythonExternalApiCalls;
+exports.detectPythonAuthPatterns = detectPythonAuthPatterns;
+exports.detectPythonConfigAndEnvUsage = detectPythonConfigAndEnvUsage;
+const engine_1 = require("../../patterns/engine");
+function createLocation(filePath, startLine, endLine, code) {
+    return {
+        filePath,
+        startLine,
+        endLine: endLine ?? startLine,
+        code,
+    };
+}
+function createFinding(params) {
+    return {
+        pattern: params.pattern,
+        name: params.name,
+        confidence: params.confidence,
+        location: params.location,
+        properties: params.properties ?? {},
+    };
+}
+function hasImportModule(imports, predicate) {
+    return imports.some((imp) => predicate(imp.module));
+}
+function hasImportedName(imports, name) {
+    return imports.some((imp) => imp.names.includes(name));
+}
+function functionHasDecorator(fn, predicate) {
+    return fn.decorators.some((dec) => predicate(dec));
+}
+function detectPythonRoutePatterns(moduleModel) {
+    const { file, imports, functions, normalizedPath } = moduleModel;
+    const importsForEngine = imports.map((imp) => ({
+        module: imp.module,
+        names: imp.names,
+    }));
+    return (0, engine_1.matchPatterns)({
+        language: "python",
+        file,
+        imports: importsForEngine,
+        functions: functions.map((fn) => ({
+            name: fn.name,
+            decorators: fn.decorators,
+            location: fn.location,
+        })),
+        normalizedPath,
+    }).filter((f) => f.pattern === "express_route");
+}
+function detectPythonDatabaseConnections(moduleModel) {
+    const { file, imports } = moduleModel;
+    const importsForEngine = imports.map((imp) => ({
+        module: imp.module,
+        names: imp.names,
+    }));
+    return (0, engine_1.matchPatterns)({
+        language: "python",
+        file,
+        imports: importsForEngine,
+    }).filter((f) => f.pattern === "database_connection");
+}
+function detectPythonExternalApiCalls(moduleModel) {
+    const { file, imports, moduleLevelCalls } = moduleModel;
+    const importsForEngine = imports.map((imp) => ({
+        module: imp.module,
+        names: imp.names,
+    }));
+    return (0, engine_1.matchPatterns)({
+        language: "python",
+        file,
+        imports: importsForEngine,
+        moduleLevelCalls: moduleLevelCalls.map((call) => ({
+            callee: call.callee,
+            argumentsSnippet: call.argumentsSnippet,
+            location: call.location,
+        })),
+    }).filter((f) => f.pattern === "external_api_call");
+}
+function detectPythonAuthPatterns(moduleModel) {
+    const { file, imports } = moduleModel;
+    const importsForEngine = imports.map((imp) => ({
+        module: imp.module,
+        names: imp.names,
+    }));
+    return (0, engine_1.matchPatterns)({
+        language: "python",
+        file,
+        imports: importsForEngine,
+    }).filter((f) => f.pattern === "auth_middleware");
+}
+function detectPythonConfigAndEnvUsage(moduleModel) {
+    const { file, imports } = moduleModel;
+    const importsForEngine = imports.map((imp) => ({
+        module: imp.module,
+        names: imp.names,
+    }));
+    return (0, engine_1.matchPatterns)({
+        language: "python",
+        file,
+        imports: importsForEngine,
+    }).filter((f) => f.pattern === "env_variable" ||
+        f.pattern === "config_file");
+}

package/dist/src/analyzers/python/python-detection-config.d.ts

@@ -0,0 +1,75 @@
+import { type PatternId } from "../../core/types/detection";
+export interface PythonDbClientConfig {
+    id: string;
+    patternId: PatternId;
+    databaseType: string;
+    importModules: string[];
+    callNames: string[];
+    confidence: number;
+    heuristics: {
+        usesObjectsAttribute: boolean;
+    };
+}
+export interface PythonPatternConfig {
+    dbClients: PythonDbClientConfig[];
+    auth: {
+        jwt?: {
+            patternId: PatternId;
+            importModules: string[];
+            contentRegexes: RegExp[];
+            strategy?: string;
+            confidence: number;
+        };
+        decorators: Array<{
+            id: string;
+            patternId: PatternId;
+            callNames: string[];
+            confidence: number;
+        }>;
+    };
+    routes: {
+        frameworks: Array<{
+            id: string;
+            patternId: PatternId;
+            importModules: string[];
+            decoratorPrefixes: string[];
+            decoratorNames: string[];
+            urlsFileSuffix?: string;
+            pathRegex?: RegExp;
+            confidence: number;
+        }>;
+    };
+    envConfig: {
+        envVariable?: {
+            patternId: PatternId;
+            regex: RegExp;
+            confidence: number;
+        };
+        djangoSettings?: {
+            patternId: PatternId;
+            fileSuffix: string;
+            name: string;
+            confidence: number;
+        };
+        dotenvConfig?: {
+            patternId: PatternId;
+            requiresOsImport: boolean;
+            contentSubstring: string;
+            name: string;
+            confidence: number;
+        };
+    };
+    externalApis: {
+        httpClients: Array<{
+            id: string;
+            patternId: PatternId;
+            clientName: string;
+            importModules: string[];
+            callNames: string[];
+            urlRegex: RegExp;
+            confidence: number;
+        }>;
+    };
+}
+export declare function clearPythonPatternConfigCache(): void;
+export declare function loadPythonPatternConfig(): PythonPatternConfig;

package/dist/src/analyzers/python/python-detection-config.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearPythonPatternConfigCache = clearPythonPatternConfigCache;
+exports.loadPythonPatternConfig = loadPythonPatternConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const detection_1 = require("../../core/types/detection");
+const DEFAULT_CONFIDENCE = 0.8;
+function validatePatternId(raw, context) {
+    const id = String(raw);
+    if (!detection_1.PATTERN_IDS.includes(id)) {
+        throw new Error(`Invalid patternId '${raw}' in ${context}`);
+    }
+    return id;
+}
+function getConfigPath() {
+    const parts = __dirname.split(path_1.default.sep);
+    const distIndex = parts.lastIndexOf("dist");
+    const cliRoot = distIndex !== -1
+        ? parts.slice(0, distIndex).join(path_1.default.sep)
+        : path_1.default.resolve(__dirname, "../../..");
+    return path_1.default.join(cliRoot, "patterns", "python.patterns.yaml");
+}
+function normalizeRawConfig(raw) {
+    const dbClients = raw.db_clients?.map((c) => {
+        const patternId = validatePatternId(c.patternId, `python.db_clients entry '${c.id}'`);
+        return {
+            id: c.id,
+            patternId,
+            databaseType: c.databaseType,
+            importModules: c.importModules ?? [],
+            callNames: c.callNames ?? [],
+            confidence: c.confidence ?? DEFAULT_CONFIDENCE,
+            heuristics: {
+                usesObjectsAttribute: c.heuristics?.usesObjectsAttribute ?? false,
+            },
+        };
+    }) ?? [];
+    const authJwtRaw = raw.auth?.jwt;
+    const authJwt = authJwtRaw && authJwtRaw.patternId
+        ? {
+            patternId: validatePatternId(authJwtRaw.patternId, "python.auth.jwt.patternId"),
+            importModules: authJwtRaw.importModules ?? [],
+            contentRegexes: (authJwtRaw.contentRegexes ?? []).map((p) => new RegExp(p)),
+            strategy: authJwtRaw.strategy,
+            confidence: authJwtRaw.confidence ?? DEFAULT_CONFIDENCE,
+        }
+        : undefined;
+    const authDecorators = raw.auth?.decorators?.map((d) => ({
+        id: d.id,
+        patternId: validatePatternId(d.patternId, `python.auth.decorators['${d.id}']`),
+        callNames: d.callNames ?? [],
+        confidence: d.confidence ?? DEFAULT_CONFIDENCE,
+    })) ?? [];
+    const routeFrameworks = raw.routes?.frameworks?.map((fw) => ({
+        id: fw.id,
+        patternId: validatePatternId(fw.patternId, `python.routes.frameworks['${fw.id}']`),
+        importModules: fw.importModules ?? [],
+        decoratorPrefixes: fw.decoratorPrefixes ?? [],
+        decoratorNames: fw.decoratorNames ?? [],
+        urlsFileSuffix: fw.urlsFileSuffix,
+        pathRegex: fw.pathRegex ? new RegExp(fw.pathRegex) : undefined,
+        confidence: fw.confidence ?? DEFAULT_CONFIDENCE,
+    })) ?? [];
+    const envVarRaw = raw.env_config?.envVariable;
+    const envVariable = envVarRaw && envVarRaw.patternId && envVarRaw.regex
+        ? {
+            patternId: validatePatternId(envVarRaw.patternId, "python.env_config.envVariable.patternId"),
+            regex: new RegExp(envVarRaw.regex),
+            confidence: envVarRaw.confidence ?? DEFAULT_CONFIDENCE,
+        }
+        : undefined;
+    const djangoSettingsRaw = raw.env_config?.djangoSettings;
+    const djangoSettings = djangoSettingsRaw && djangoSettingsRaw.patternId
+        ? {
+            patternId: validatePatternId(djangoSettingsRaw.patternId, "python.env_config.djangoSettings.patternId"),
+            fileSuffix: djangoSettingsRaw.fileSuffix ?? "settings.py",
+            name: djangoSettingsRaw.name ?? "django_settings",
+            confidence: djangoSettingsRaw.confidence ?? DEFAULT_CONFIDENCE,
+        }
+        : undefined;
+    const dotenvRaw = raw.env_config?.dotenvConfig;
+    const dotenvConfig = dotenvRaw && dotenvRaw.patternId && dotenvRaw.contentSubstring
+        ? {
+            patternId: validatePatternId(dotenvRaw.patternId, "python.env_config.dotenvConfig.patternId"),
+            requiresOsImport: dotenvRaw.requiresOsImport ?? true,
+            contentSubstring: dotenvRaw.contentSubstring,
+            name: dotenvRaw.name ?? "dotenv_config",
+            confidence: dotenvRaw.confidence ?? DEFAULT_CONFIDENCE,
+        }
+        : undefined;
+    const externalHttpClients = raw.external_apis?.httpClients?.map((client) => ({
+        id: client.id,
+        patternId: validatePatternId(client.patternId, `python.external_apis.httpClients['${client.id}']`),
+        clientName: client.clientName,
+        importModules: client.importModules ?? [],
+        callNames: client.callNames ?? [],
+        urlRegex: new RegExp(client.urlRegex ??
+            "['\\\"](https?:\\/\\/[^\\s'\\\"]+)['\\\"]"),
+        confidence: client.confidence ?? DEFAULT_CONFIDENCE,
+    })) ?? [];
+    return {
+        dbClients,
+        auth: {
+            jwt: authJwt,
+            decorators: authDecorators,
+        },
+        routes: {
+            frameworks: routeFrameworks,
+        },
+        envConfig: {
+            envVariable,
+            djangoSettings,
+            dotenvConfig,
+        },
+        externalApis: {
+            httpClients: externalHttpClients,
+        },
+    };
+}
+let cachedConfig;
+function clearPythonPatternConfigCache() {
+    cachedConfig = undefined;
+}
+function loadPythonPatternConfig() {
+    if (cachedConfig)
+        return cachedConfig;
+    const configPath = getConfigPath();
+    let rawYaml;
+    try {
+        rawYaml = fs_1.default.readFileSync(configPath, "utf8");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Python pattern config is required but could not be read from '${configPath}': ${msg}`);
+    }
+    const parsed = yaml_1.default.parse(rawYaml);
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error(`Python pattern config at '${configPath}' did not parse to an object.`);
+    }
+    const normalized = normalizeRawConfig(parsed);
+    cachedConfig = normalized;
+    return normalized;
+}

package/dist/src/analyzers/registry.d.ts

@@ -0,0 +1,13 @@
+import type { FileInfo, FileLanguage } from "../core/types/file";
+import type { RawFinding } from "../core/types/detection";
+import type { Analyzer } from "./types";
+import type { TerraformModuleCallManifest } from "./terraform/terraform-module-manifest";
+export interface RunAnalyzersOptions {
+    terraformModuleManifest?: TerraformModuleCallManifest;
+    terraformScanRootPath?: string;
+}
+export declare function registerAnalyzer(language: FileLanguage, analyzer: Analyzer): void;
+export declare function getAnalyzerForFile(file: FileInfo): Analyzer | undefined;
+export declare function runAnalyzers(files: FileInfo[], opts?: RunAnalyzersOptions): RawFinding[];
+export declare function runAnalyzersForRootPath(rootPath: string): Promise<RawFinding[]>;
+export declare function __clearAnalyzersForTest(): void;

package/dist/src/analyzers/registry.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAnalyzer = registerAnalyzer;
+exports.getAnalyzerForFile = getAnalyzerForFile;
+exports.runAnalyzers = runAnalyzers;
+exports.runAnalyzersForRootPath = runAnalyzersForRootPath;
+exports.__clearAnalyzersForTest = __clearAnalyzersForTest;
+const file_system_1 = require("../ingest/file-system");
+const python_1 = require("./python");
+const terraform_1 = require("./terraform");
+const typescript_1 = require("./typescript");
+const terraform_detection_config_1 = require("./terraform/terraform-detection-config");
+const detector_1 = require("./terraform/detector");
+const typeScriptAnalyzer = (0, typescript_1.createTypeScriptAnalyzer)();
+const pythonAnalyzer = (0, python_1.createPythonAnalyzer)();
+const terraformAnalyzer = (0, terraform_1.createTerraformAnalyzer)();
+const registry = new Map([
+    ["python", pythonAnalyzer],
+    ["terraform", terraformAnalyzer],
+    ["typescript", typeScriptAnalyzer],
+    ["javascript", typeScriptAnalyzer],
+]);
+function registerAnalyzer(language, analyzer) {
+    registry.set(language, analyzer);
+}
+function getAnalyzerForFile(file) {
+    return registry.get(file.language);
+}
+function runAnalyzers(files, opts) {
+    const findings = [];
+    const tfConfig = (0, terraform_detection_config_1.loadTerraformPatternConfig)();
+    const tfOpts = opts?.terraformModuleManifest && opts.terraformScanRootPath
+        ? {
+            manifest: opts.terraformModuleManifest,
+            scanRootPath: opts.terraformScanRootPath,
+        }
+        : undefined;
+    for (const file of files) {
+        if (file.language === "terraform") {
+            findings.push(...(0, detector_1.detectTerraformPatterns)(file, tfConfig, tfOpts));
+            continue;
+        }
+        const analyzer = registry.get(file.language);
+        if (!analyzer)
+            continue;
+        const result = analyzer.detect(file);
+        if (Array.isArray(result) && result.length > 0) {
+            findings.push(...result);
+        }
+    }
+    return findings;
+}
+async function runAnalyzersForRootPath(rootPath) {
+    const files = await (0, file_system_1.ingestFileSystem)(rootPath);
+    return runAnalyzers(files);
+}
+// Test-only helper to avoid cross-test pollution.
+function __clearAnalyzersForTest() {
+    registry.clear();
+}

package/dist/src/analyzers/shared/manifest-budgets.d.ts

@@ -0,0 +1,19 @@
+export interface ManifestScanBudgetOptions {
+    maxManifestFiles?: number;
+    maxTotalManifestReadBytes?: number;
+    maxManifestFileSizeBytes?: number;
+    excludePaths?: string[];
+    onWarning?: (msg: string) => void;
+}
+export type BudgetState = {
+    maxManifestFiles: number;
+    maxTotalManifestReadBytes: number;
+    maxManifestFileSizeBytes: number;
+    onWarning?: (msg: string) => void;
+    manifestFiles: number;
+    totalReadBytes: number;
+    stopped: boolean;
+    warned: boolean;
+};
+export declare const DEFAULT_BUDGETS: Required<Pick<ManifestScanBudgetOptions, "maxManifestFiles" | "maxTotalManifestReadBytes" | "maxManifestFileSizeBytes">>;
+export declare function budgetStateFromOptions(opts?: ManifestScanBudgetOptions): BudgetState;

package/dist/src/analyzers/shared/manifest-budgets.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BUDGETS = void 0;
+exports.budgetStateFromOptions = budgetStateFromOptions;
+exports.DEFAULT_BUDGETS = {
+    maxManifestFiles: 500,
+    maxTotalManifestReadBytes: 5 * 1024 * 1024, // 5MB
+    maxManifestFileSizeBytes: 250 * 1024, // 250KB
+};
+function budgetStateFromOptions(opts) {
+    return {
+        maxManifestFiles: opts?.maxManifestFiles ?? exports.DEFAULT_BUDGETS.maxManifestFiles,
+        maxTotalManifestReadBytes: opts?.maxTotalManifestReadBytes ?? exports.DEFAULT_BUDGETS.maxTotalManifestReadBytes,
+        maxManifestFileSizeBytes: opts?.maxManifestFileSizeBytes ?? exports.DEFAULT_BUDGETS.maxManifestFileSizeBytes,
+        onWarning: opts?.onWarning,
+        manifestFiles: 0,
+        totalReadBytes: 0,
+        stopped: false,
+        warned: false,
+    };
+}

package/dist/src/analyzers/shared/manifest-fs.d.ts

@@ -0,0 +1,13 @@
+import type { Dirent } from "fs";
+import type { BudgetState } from "./manifest-budgets";
+import { type IgnoreRule } from "../../ingest/gitignore";
+export interface WalkForManifestsOptions {
+    rootDir: string;
+    state: BudgetState;
+    excludePaths?: string[];
+    /**
+     * Predicate that selects which files in a directory should be treated as manifests.
+     */
+    isManifestFile: (entry: Dirent, entryPath: string) => boolean;
+}
+export declare function walkForManifests(dir: string, out: string[], options: WalkForManifestsOptions, accumulatedGitignoreRules?: IgnoreRule[]): Promise<void>;