@dataparade/cli 0.0.1

package/dist/src/patterns/detectors/typescript.js

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectTypeScriptJavaScriptExternalApisFromHttpClients = detectTypeScriptJavaScriptExternalApisFromHttpClients;
+exports.detectTypeScriptRoutesFromConfig = detectTypeScriptRoutesFromConfig;
+exports.detectTypeScriptDatabaseFromConfig = detectTypeScriptDatabaseFromConfig;
+exports.detectTypeScriptAuthFromConfig = detectTypeScriptAuthFromConfig;
+exports.detectTypeScriptEnvAndConfigFromConfig = detectTypeScriptEnvAndConfigFromConfig;
+const external_url_third_party_1 = require("../../classifier/external-url-third-party");
+const helpers_1 = require("./helpers");
+function detectTypeScriptJavaScriptExternalApisFromHttpClients(ctx, config) {
+    if ((ctx.language !== "typescript" && ctx.language !== "javascript") ||
+        !ctx.includeThirdPartyHttpLinePatterns) {
+        return [];
+    }
+    const content = ctx.file.content ?? "";
+    const findings = [];
+    const urlHostPatterns = (0, helpers_1.buildThirdPartyUrlHostPatterns)(config);
+    for (const client of config.thirdParty.httpClients) {
+        for (const regex of client.callRegexes) {
+            const httpMatches = (0, helpers_1.findLineMatches)(content, regex);
+            for (const { line, match } of httpMatches) {
+                const [, clientName, methodMaybe, url] = match;
+                if ((0, external_url_third_party_1.shouldIgnoreExternalHttpUrl)(url)) {
+                    continue;
+                }
+                const method = typeof methodMaybe === "string"
+                    ? methodMaybe.toUpperCase()
+                    : undefined;
+                const serviceName = (0, helpers_1.inferServiceNameFromUrl)(url, urlHostPatterns) ??
+                    (0, external_url_third_party_1.defaultServiceNameFromLiteralPublicUrl)(url);
+                findings.push({
+                    pattern: client.patternId,
+                    name: url,
+                    confidence: client.confidence,
+                    location: (0, helpers_1.createLocationFromLine)(ctx.file, line, match[0]),
+                    properties: {
+                        client: clientName,
+                        url,
+                        httpMethod: method,
+                        ...(serviceName ? { serviceName } : {}),
+                    },
+                });
+            }
+        }
+    }
+    return findings;
+}
+function detectTypeScriptRoutesFromConfig(ctx, config) {
+    if ((ctx.language !== "typescript" && ctx.language !== "javascript") ||
+        !ctx.normalizedPath) {
+        return [];
+    }
+    const content = ctx.file.content ?? "";
+    const findings = [];
+    const tsCfg = config.typescript;
+    for (const fw of tsCfg.routes.frameworks) {
+        const hasFrameworkImport = fw.imports.length === 0
+            ? false
+            : fw.imports.some((mod) => (ctx.imports ?? []).some((imp) => imp.module === mod ||
+                imp.module.includes(mod) ||
+                imp.names.some((name) => name === mod || name.includes(mod))));
+        if (!hasFrameworkImport)
+            continue;
+        if (fw.id === "express") {
+            for (const regex of fw.routeCallRegexes) {
+                const matches = (0, helpers_1.findLineMatches)(content, regex);
+                for (const { line, match } of matches) {
+                    const [, , method, path] = match;
+                    const upperMethod = typeof method === "string" && method.toUpperCase
+                        ? method.toUpperCase()
+                        : "GET";
+                    findings.push({
+                        pattern: fw.patternId,
+                        name: `${upperMethod} ${path}`,
+                        confidence: fw.confidence,
+                        location: (0, helpers_1.createLocationFromLine)(ctx.file, line, match[0]),
+                        properties: {
+                            framework: "express",
+                            httpMethods: [upperMethod],
+                            path,
+                        },
+                    });
+                }
+            }
+        }
+        else if (fw.id === "nest") {
+            for (const regex of fw.controllerDecoratorRegexes) {
+                const controllerMatches = (0, helpers_1.findLineMatches)(content, regex);
+                for (const { line, match } of controllerMatches) {
+                    const [, basePath] = match;
+                    findings.push({
+                        pattern: fw.patternId,
+                        name: `NEST_CONTROLLER ${basePath || "/"}`,
+                        confidence: fw.confidence,
+                        location: (0, helpers_1.createLocationFromLine)(ctx.file, line, match[0]),
+                        properties: {
+                            framework: "nest",
+                            httpMethods: [],
+                            path: basePath || "/",
+                        },
+                    });
+                }
+            }
+            for (const regex of fw.routeDecoratorRegexes) {
+                const decoratorMatches = (0, helpers_1.findLineMatches)(content, regex);
+                for (const { line, match } of decoratorMatches) {
+                    const [, method, routePath] = match;
+                    const upperMethod = typeof method === "string" && method.toUpperCase
+                        ? method.toUpperCase()
+                        : "GET";
+                    findings.push({
+                        pattern: fw.patternId,
+                        name: `${upperMethod} ${routePath || "/"}`,
+                        confidence: fw.confidence,
+                        location: (0, helpers_1.createLocationFromLine)(ctx.file, line, match[0]),
+                        properties: {
+                            framework: "nest",
+                            httpMethods: [upperMethod],
+                            path: routePath || "/",
+                        },
+                    });
+                }
+            }
+        }
+    }
+    const normalizedPath = ctx.normalizedPath.toLowerCase();
+    if (normalizedPath.includes("pages/api/") ||
+        normalizedPath.includes("/app/") ||
+        normalizedPath.endsWith("route.ts") ||
+        normalizedPath.endsWith("route.js")) {
+        const { regex, confidence } = tsCfg.heuristics.nextRouteHandler;
+        const handlerMatches = (0, helpers_1.findLineMatches)(content, regex);
+        for (const { line, match } of handlerMatches) {
+            findings.push({
+                pattern: "express_route",
+                name: "Route handler",
+                confidence,
+                location: (0, helpers_1.createLocationFromLine)(ctx.file, line, match[0]),
+                properties: {
+                    framework: "next_or_react_route",
+                    httpMethods: [],
+                    path: undefined,
+                },
+            });
+        }
+    }
+    return findings;
+}
+function detectTypeScriptDatabaseFromConfig(ctx, config) {
+    if ((ctx.language !== "typescript" && ctx.language !== "javascript") ||
+        !ctx.normalizedPath) {
+        return [];
+    }
+    const content = ctx.file.content ?? "";
+    const findings = [];
+    const tsCfg = config.typescript;
+    for (const client of tsCfg.dbClients) {
+        const hasImport = client.importModules.some((mod) => (ctx.imports ?? []).some((imp) => imp.module === mod ||
+            imp.module.includes(mod) ||
+            imp.names.some((name) => name === mod || name.includes(mod))));
+        for (const regex of client.creationRegexes) {
+            const matches = (0, helpers_1.findLineMatches)(content, regex);
+            for (const { line, match } of matches) {
+                const matchedSnippet = String(match[0] ?? "").toLowerCase();
+                const hasClientHintInSnippet = matchedSnippet.includes(client.id.toLowerCase()) ||
+                    matchedSnippet.includes(client.databaseType.toLowerCase());
+                if (!hasImport && !hasClientHintInSnippet) {
+                    continue;
+                }
+                findings.push({
+                    pattern: client.patternId,
+                    name: client.id,
+                    confidence: client.confidence,
+                    location: (0, helpers_1.createLocationFromLine)(ctx.file, line, match[0]),
+                    properties: {
+                        client: client.id,
+                        databaseType: client.databaseType,
+                    },
+                });
+            }
+        }
+        if (hasImport) {
+            findings.push({
+                pattern: client.patternId,
+                name: client.id,
+                confidence: Math.max(0.5, client.confidence - 0.2),
+                location: (0, helpers_1.createLocationFromLine)(ctx.file, 1),
+                properties: {
+                    client: client.id,
+                    databaseType: client.databaseType,
+                },
+            });
+        }
+    }
+    const hasAnyDbClientImport = tsCfg.dbClients.some((client) => client.importModules.some((mod) => (ctx.imports ?? []).some((imp) => imp.module === mod ||
+        imp.module.includes(mod) ||
+        imp.names.some((name) => name === mod || name.includes(mod)))));
+    if (hasAnyDbClientImport &&
+        tsCfg.heuristics.sqlKeyword.regex.test(content)) {
+        findings.push({
+            pattern: tsCfg.heuristics.sqlKeyword.patternId,
+            name: "sql_query_detected",
+            confidence: tsCfg.heuristics.sqlKeyword.confidence,
+            location: (0, helpers_1.createLocationFromLine)(ctx.file, 1),
+            properties: { hint: "raw_sql_keyword" },
+        });
+    }
+    return findings;
+}
+function detectTypeScriptAuthFromConfig(ctx, config) {
+    if ((ctx.language !== "typescript" && ctx.language !== "javascript") ||
+        !ctx.normalizedPath) {
+        return [];
+    }
+    const content = ctx.file.content ?? "";
+    const findings = [];
+    const tsCfg = config.typescript;
+    for (const lib of tsCfg.auth.libraries) {
+        const hasLibraryImport = lib.importFragments.some((frag) => (ctx.imports ?? []).some((imp) => imp.module === frag ||
+            imp.module.includes(frag) ||
+            imp.names.some((name) => name === frag || name.includes(frag))));
+        if (!hasLibraryImport)
+            continue;
+        if (lib.id === "passport") {
+            let emittedSpecific = false;
+            for (const regex of lib.callRegexes) {
+                const passportMatches = (0, helpers_1.findLineMatches)(content, regex);
+                for (const { line, match } of passportMatches) {
+                    const [, strategy] = match;
+                    emittedSpecific = true;
+                    findings.push({
+                        pattern: lib.patternId,
+                        name: `passport:${strategy}`,
+                        confidence: lib.confidence,
+                        location: (0, helpers_1.createLocationFromLine)(ctx.file, line, match[0]),
+                        properties: {
+                            library: "passport",
+                            strategy,
+                        },
+                    });
+                }
+            }
+            if (!emittedSpecific) {
+                findings.push({
+                    pattern: lib.patternId,
+                    name: "passport",
+                    confidence: lib.confidence - 0.15,
+                    location: (0, helpers_1.createLocationFromLine)(ctx.file, 1),
+                    properties: {
+                        library: "passport",
+                    },
+                });
+            }
+        }
+        else if (lib.id === "jsonwebtoken") {
+            if (content.includes("jwt.sign(") || content.includes("jwt.verify(")) {
+                findings.push({
+                    pattern: lib.patternId,
+                    name: "jwt",
+                    confidence: lib.confidence,
+                    location: (0, helpers_1.createLocationFromLine)(ctx.file, 1),
+                    properties: {
+                        library: "jsonwebtoken",
+                    },
+                });
+            }
+        }
+        else if (lib.id === "nest_auth") {
+            if (content.includes("UseGuards(")) {
+                findings.push({
+                    pattern: lib.patternId,
+                    name: "nest_auth_guard",
+                    confidence: lib.confidence,
+                    location: (0, helpers_1.createLocationFromLine)(ctx.file, 1),
+                    properties: {
+                        library: "nestjs_auth",
+                    },
+                });
+            }
+        }
+    }
+    return findings;
+}
+function detectTypeScriptEnvAndConfigFromConfig(ctx, config) {
+    if ((ctx.language !== "typescript" && ctx.language !== "javascript") ||
+        !ctx.normalizedPath) {
+        return [];
+    }
+    const content = ctx.file.content ?? "";
+    const findings = [];
+    const tsCfg = config.typescript;
+    const { regex: envRegex, confidence: envConfidence } = tsCfg.heuristics.processEnv;
+    const envMatches = (0, helpers_1.findLineMatches)(content, envRegex);
+    for (const { line, match } of envMatches) {
+        const [, key] = match;
+        findings.push({
+            pattern: "env_variable",
+            name: `process.env.${key}`,
+            confidence: envConfidence,
+            location: (0, helpers_1.createLocationFromLine)(ctx.file, line, match[0]),
+            properties: {
+                key,
+            },
+        });
+    }
+    const knownKeys = new Set(tsCfg.configKeys.keys.map((k) => k.name));
+    if (knownKeys.size > 0) {
+        const configRegex = tsCfg.heuristics.configKeyAccess.regex;
+        const configMatches = (0, helpers_1.findLineMatches)(content, configRegex);
+        for (const { line, match } of configMatches) {
+            const [, key] = match;
+            if (!knownKeys.has(key))
+                continue;
+            const keyConfig = tsCfg.configKeys.keys.find((k) => k.name === key);
+            const confidence = keyConfig?.confidence ?? 0.8;
+            findings.push({
+                pattern: keyConfig?.patternId ?? "config_file",
+                name: `config.${key}`,
+                confidence,
+                location: (0, helpers_1.createLocationFromLine)(ctx.file, line, match[0]),
+                properties: {
+                    key,
+                },
+            });
+        }
+    }
+    return findings;
+}

package/dist/src/patterns/engine.d.ts

@@ -0,0 +1,40 @@
+import type { FileInfo, SourceLocation } from "../core/types/file";
+import type { RawFinding } from "../core/types/detection";
+export interface ImportLike {
+    module: string;
+    names: string[];
+}
+export interface PatternContext {
+    language: string;
+    file: FileInfo;
+    /**
+     * When true for TypeScript/JavaScript, scan file lines using
+     * `third-party.patterns.yaml` `http_clients` regexes (fetch/axios/got, etc.).
+     * Kept opt-in so other `matchPatterns` callers (routes/DB/auth/env) that pass
+     * `normalizedPath` do not duplicate the same external-API line findings.
+     */
+    includeThirdPartyHttpLinePatterns?: boolean;
+    imports?: ImportLike[];
+    moduleLevelCalls?: {
+        callee: string;
+        argumentsSnippet: string;
+        location: SourceLocation;
+    }[];
+    functions?: {
+        name: string;
+        decorators: string[];
+        location: SourceLocation;
+    }[];
+    normalizedPath?: string;
+}
+/**
+ * Detect known third-party services (catalog-backed `external_api_call`)
+ * from a language-agnostic `imports` list.
+ *
+ * This intentionally does not run other detectors (routes/DB/auth/env/etc).
+ */
+export declare function detectThirdPartyServicesFromImports(ctx: PatternContext): RawFinding[];
+/**
+ * Shared entry point for YAML-driven pattern detection across languages.
+ */
+export declare function matchPatterns(ctx: PatternContext): RawFinding[];

package/dist/src/patterns/engine.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectThirdPartyServicesFromImports = detectThirdPartyServicesFromImports;
+exports.matchPatterns = matchPatterns;
+const config_1 = require("./config");
+const python_1 = require("./detectors/python");
+const typescript_1 = require("./detectors/typescript");
+function findFirstLineMatch(content, regex) {
+    if (!regex)
+        return undefined;
+    const lines = content.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i += 1) {
+        const lineText = lines[i];
+        if (regex.test(lineText)) {
+            return { line: i + 1, code: lineText };
+        }
+    }
+    return undefined;
+}
+function detectThirdPartyServicesFromImportsWithConfig(ctx, config) {
+    const imports = ctx.imports ?? [];
+    if (imports.length === 0)
+        return [];
+    const findings = [];
+    for (const svc of config.thirdParty.services) {
+        const hasImport = svc.importFragments.some((frag) => imports.some((imp) => imp.module.includes(frag) || imp.names.some((name) => name.includes(frag))));
+        if (!hasImport)
+            continue;
+        findings.push({
+            pattern: svc.patternId,
+            name: svc.serviceName,
+            confidence: svc.confidence,
+            location: {
+                filePath: ctx.file.path,
+                startLine: 1,
+                endLine: 1,
+            },
+            properties: {
+                client: svc.serviceName,
+                serviceName: svc.serviceName,
+            },
+        });
+    }
+    return findings;
+}
+/**
+ * Detect known third-party services (catalog-backed `external_api_call`)
+ * from a language-agnostic `imports` list.
+ *
+ * This intentionally does not run other detectors (routes/DB/auth/env/etc).
+ */
+function detectThirdPartyServicesFromImports(ctx) {
+    const config = (0, config_1.loadUnifiedPatternConfig)();
+    return detectThirdPartyServicesFromImportsWithConfig(ctx, config);
+}
+function detectActorsFromConfig(ctx, config) {
+    const rules = config.actors.rules;
+    if (rules.length === 0)
+        return [];
+    const findings = [];
+    const normalizedPath = (ctx.normalizedPath ?? ctx.file.path).toLowerCase();
+    const content = ctx.file.content ?? "";
+    const lines = content.split(/\r?\n/);
+    const firstLine = lines[0] ?? "";
+    for (const rule of rules) {
+        let lineMatch;
+        if (rule.filePathRegex && rule.filePathRegex.test(normalizedPath)) {
+            lineMatch = { line: 1, code: firstLine };
+        }
+        else if (rule.contentRegex) {
+            lineMatch = findFirstLineMatch(content, rule.contentRegex);
+        }
+        if (!lineMatch)
+            continue;
+        findings.push({
+            pattern: rule.patternId,
+            name: rule.name,
+            confidence: rule.confidence,
+            location: {
+                filePath: ctx.file.path,
+                startLine: lineMatch.line,
+                endLine: lineMatch.line,
+                code: lineMatch.code,
+            },
+            properties: {
+                ...rule.properties,
+            },
+        });
+    }
+    return findings;
+}
+/**
+ * Shared entry point for YAML-driven pattern detection across languages.
+ */
+function matchPatterns(ctx) {
+    const config = (0, config_1.loadUnifiedPatternConfig)();
+    const findings = [];
+    findings.push(...detectThirdPartyServicesFromImportsWithConfig(ctx, config));
+    findings.push(...(0, typescript_1.detectTypeScriptJavaScriptExternalApisFromHttpClients)(ctx, config));
+    findings.push(...detectActorsFromConfig(ctx, config));
+    findings.push(...(0, python_1.detectPythonDatabaseConnectionsFromImportsAndContent)(ctx, config));
+    findings.push(...(0, python_1.detectPythonAuthFromConfig)(ctx, config));
+    findings.push(...(0, python_1.detectPythonEnvAndConfigFromConfig)(ctx, config));
+    findings.push(...(0, python_1.detectPythonExternalApisFromConfig)(ctx, config));
+    findings.push(...(0, python_1.detectPythonRoutesFromConfig)(ctx, config));
+    findings.push(...(0, typescript_1.detectTypeScriptRoutesFromConfig)(ctx, config));
+    findings.push(...(0, typescript_1.detectTypeScriptDatabaseFromConfig)(ctx, config));
+    findings.push(...(0, typescript_1.detectTypeScriptAuthFromConfig)(ctx, config));
+    findings.push(...(0, typescript_1.detectTypeScriptEnvAndConfigFromConfig)(ctx, config));
+    return findings;
+}

package/dist/src/patterns/flow-source-patterns.d.ts

@@ -0,0 +1,6 @@
+export declare const NON_RUNTIME_METADATA_FILE_NAMES: Set<string>;
+export declare const NON_RUNTIME_METADATA_EXTENSIONS: string[];
+export declare const FRONTEND_RUNTIME_PATH_MARKERS: string[];
+export declare const FRONTEND_RUNTIME_FILE_EXTENSIONS: string[];
+export declare const ROUTE_HANDLER_PATH_MARKERS: string[];
+export declare const ROUTE_HANDLER_FILE_SUFFIXES: string[];

package/dist/src/patterns/flow-source-patterns.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROUTE_HANDLER_FILE_SUFFIXES = exports.ROUTE_HANDLER_PATH_MARKERS = exports.FRONTEND_RUNTIME_FILE_EXTENSIONS = exports.FRONTEND_RUNTIME_PATH_MARKERS = exports.NON_RUNTIME_METADATA_EXTENSIONS = exports.NON_RUNTIME_METADATA_FILE_NAMES = void 0;
+exports.NON_RUNTIME_METADATA_FILE_NAMES = new Set(["package.json"]);
+exports.NON_RUNTIME_METADATA_EXTENSIONS = [
+    ".lock",
+    ".yaml",
+    ".yml",
+    ".toml",
+];
+exports.FRONTEND_RUNTIME_PATH_MARKERS = [
+    "/components/",
+    "/hooks/",
+    "/pages/",
+    "/app/",
+];
+exports.FRONTEND_RUNTIME_FILE_EXTENSIONS = [".tsx", ".jsx"];
+exports.ROUTE_HANDLER_PATH_MARKERS = [
+    "/app/api/",
+    "/routers/",
+    "/routes/",
+    "/controller",
+    "/controllers/",
+    "/views/",
+    "/endpoints/",
+];
+exports.ROUTE_HANDLER_FILE_SUFFIXES = [
+    "/route.ts",
+    "/route.js",
+    "/route.py",
+    "/server.ts",
+    "/server.js",
+    "/server.py",
+    "/router.py",
+    "/routes.py",
+    "/views.py",
+    "/main.py",
+    "/app.py",
+];

package/dist/src/patterns/frontend-frameworks.d.ts

@@ -0,0 +1,4 @@
+export declare const FRONTEND_FRAMEWORK_HINTS: readonly ["next_or_react_route", "nextjs", "react", "vue", "angular", "ionic", "electron", "svelte", "solid", "qwik"];
+export declare const FRONTEND_FRAMEWORK_HINTS_SET: Set<string>;
+export declare const PREFERRED_WEB_APP_FRAMEWORKS: Set<string>;
+export declare const SERVER_FRAMEWORK_HINTS: Set<string>;

package/dist/src/patterns/frontend-frameworks.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVER_FRAMEWORK_HINTS = exports.PREFERRED_WEB_APP_FRAMEWORKS = exports.FRONTEND_FRAMEWORK_HINTS_SET = exports.FRONTEND_FRAMEWORK_HINTS = void 0;
+exports.FRONTEND_FRAMEWORK_HINTS = [
+    "next_or_react_route",
+    "nextjs",
+    "react",
+    "vue",
+    "angular",
+    "ionic",
+    "electron",
+    "svelte",
+    "solid",
+    "qwik",
+];
+exports.FRONTEND_FRAMEWORK_HINTS_SET = new Set(exports.FRONTEND_FRAMEWORK_HINTS);
+exports.PREFERRED_WEB_APP_FRAMEWORKS = new Set([
+    ...exports.FRONTEND_FRAMEWORK_HINTS,
+    "frontend",
+]);
+exports.SERVER_FRAMEWORK_HINTS = new Set([
+    "nest",
+    "express",
+    "serverless",
+]);

package/dist/src/patterns/scan-exclusions.d.ts

@@ -0,0 +1,14 @@
+export declare const DEFAULT_EXCLUDED_DIRS: Set<string>;
+/**
+ * Files matching these globs are not scanned by default: they are never ingested and do not
+ * contribute findings or AI context. This keeps unit tests (`*.spec.*`, `*.test.*`) and
+ * Playwright bootstrap config, Storybook (`__stories__/`, `*.stories.*`) out of the
+ * production-oriented graph. (`.storybook/` is skipped as a hidden directory.)
+ *
+ * Values are passed as `excludePaths`; expanded explicitly (no `{a,b}` brace groups) because
+ * the matcher only supports `*`, `**`, `?`.
+ *
+ * @see createDefaultScanConfiguration — always prepends these before user `excludePaths`.
+ */
+export declare const DEFAULT_EXCLUDED_FILE_GLOBS: readonly string[];
+export declare function shouldSkipDirectoryName(dirName: string): boolean;

package/dist/src/patterns/scan-exclusions.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EXCLUDED_FILE_GLOBS = exports.DEFAULT_EXCLUDED_DIRS = void 0;
+exports.shouldSkipDirectoryName = shouldSkipDirectoryName;
+exports.DEFAULT_EXCLUDED_DIRS = new Set([
+    "node_modules",
+    "venv",
+    ".venv",
+    "site-packages",
+    "vendor",
+    "test",
+    "tests",
+    "__tests__",
+    "__stories__",
+    "e2e",
+    "storybook-static",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    "out",
+    "coverage",
+    ".vscode",
+    ".idea",
+]);
+/**
+ * Files matching these globs are not scanned by default: they are never ingested and do not
+ * contribute findings or AI context. This keeps unit tests (`*.spec.*`, `*.test.*`) and
+ * Playwright bootstrap config, Storybook (`__stories__/`, `*.stories.*`) out of the
+ * production-oriented graph. (`.storybook/` is skipped as a hidden directory.)
+ *
+ * Values are passed as `excludePaths`; expanded explicitly (no `{a,b}` brace groups) because
+ * the matcher only supports `*`, `**`, `?`.
+ *
+ * @see createDefaultScanConfiguration — always prepends these before user `excludePaths`.
+ */
+exports.DEFAULT_EXCLUDED_FILE_GLOBS = [
+    "**/*.spec.ts",
+    "*.spec.ts",
+    "**/*.spec.tsx",
+    "*.spec.tsx",
+    "**/*.spec.js",
+    "*.spec.js",
+    "**/*.spec.jsx",
+    "*.spec.jsx",
+    "**/*.test.ts",
+    "*.test.ts",
+    "**/*.test.tsx",
+    "*.test.tsx",
+    "**/*.test.js",
+    "*.test.js",
+    "**/*.test.jsx",
+    "*.test.jsx",
+    "**/playwright.config.*",
+    "playwright.config.*",
+    "**/*.stories.ts",
+    "*.stories.ts",
+    "**/*.stories.tsx",
+    "*.stories.tsx",
+    "**/*.stories.js",
+    "*.stories.js",
+    "**/*.stories.jsx",
+    "*.stories.jsx",
+    "**/*.stories.mdx",
+    "*.stories.mdx",
+    "**/.env",
+    "**/.env.*",
+    ".env",
+    ".env.*",
+];
+function shouldSkipDirectoryName(dirName) {
+    // Hidden tooling/cache directories are noisy for structural scanning.
+    if (dirName.startsWith("."))
+        return true;
+    return exports.DEFAULT_EXCLUDED_DIRS.has(dirName);
+}

package/dist/src/platform-api/dataparade-api-base-url.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Default DataParade platform API (AWS API Gateway). Used when the CLI talks to
+ * workspace quota / platform LLM proxy. Override with DATAPARADE_API_BASE_URL for
+ * local monorepo dev (e.g. http://localhost:3000).
+ */
+export declare const DEFAULT_DATAPARADE_API_BASE_URL = "https://hrfp8zmxh8.execute-api.us-east-1.amazonaws.com";
+/** Resolve platform API origin (no trailing slash). */
+export declare function getDataparadeApiBaseUrl(env?: NodeJS.ProcessEnv): string;

package/dist/src/platform-api/dataparade-api-base-url.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DATAPARADE_API_BASE_URL = void 0;
+exports.getDataparadeApiBaseUrl = getDataparadeApiBaseUrl;
+/**
+ * Default DataParade platform API (AWS API Gateway). Used when the CLI talks to
+ * workspace quota / platform LLM proxy. Override with DATAPARADE_API_BASE_URL for
+ * local monorepo dev (e.g. http://localhost:3000).
+ */
+exports.DEFAULT_DATAPARADE_API_BASE_URL = "https://hrfp8zmxh8.execute-api.us-east-1.amazonaws.com";
+/** Resolve platform API origin (no trailing slash). */
+function getDataparadeApiBaseUrl(env = process.env) {
+    const base = env.DATAPARADE_API_BASE_URL?.trim() ||
+        env.DATAPARADE_API_URL?.trim() ||
+        exports.DEFAULT_DATAPARADE_API_BASE_URL;
+    return base.replace(/\/$/, "");
+}