builder-assistant-engineer 0.2.0

package/dist/digest/baseline.js

@@ -0,0 +1,192 @@
+import { baseName, languageOf } from "./files.js";
+import { findDependency } from "./manifests.js";
+export const BASELINE_CHECKS = ["tests", "lint", "formatter", "typecheck", "ci"];
+const EVIDENCE_SAMPLE = 3;
+const TEST_DEPENDENCIES = [
+    ["npm", "vitest"],
+    ["npm", "jest"],
+    ["npm", "mocha"],
+    ["npm", "ava"],
+    ["npm", "jasmine"],
+    ["npm", "@playwright/test"],
+    ["npm", "cypress"],
+    ["python", "pytest"],
+    ["java", "junit"],
+    ["java", "testng"],
+    ["php", "phpunit/phpunit"],
+    ["php", "pestphp/pest"],
+    ["ruby", "rspec"],
+    ["ruby", "minitest"],
+    ["dotnet", "xunit"],
+    ["dotnet", "nunit"],
+    ["dotnet", "mstest"],
+    ["dart", "flutter_test"],
+];
+const LINT_DEPENDENCIES = [
+    ["npm", "eslint"],
+    ["npm", "@biomejs/biome"],
+    ["npm", "oxlint"],
+    ["npm", "xo"],
+    ["npm", "standard"],
+    ["python", "ruff"],
+    ["python", "flake8"],
+    ["python", "pylint"],
+    ["php", "phpstan/phpstan"],
+    ["php", "squizlabs/php_codesniffer"],
+    ["ruby", "rubocop"],
+];
+const FORMAT_DEPENDENCIES = [
+    ["npm", "prettier"],
+    ["npm", "@biomejs/biome"],
+    ["npm", "dprint"],
+    ["python", "black"],
+    ["python", "yapf"],
+    ["python", "autopep8"],
+    ["php", "friendsofphp/php-cs-fixer"],
+    ["php", "laravel/pint"],
+];
+const TYPECHECK_DEPENDENCIES = [
+    ["npm", "typescript"],
+    ["python", "mypy"],
+    ["python", "pyright"],
+];
+const TEST_SECTIONS = [["python", "[tool.pytest"]];
+const LINT_SECTIONS = [
+    ["python", "[tool.ruff"],
+    ["python", "[tool.pylint"],
+    ["python", "[flake8]"],
+];
+const FORMAT_SECTIONS = [
+    ["python", "[tool.black"],
+    ["python", "[tool.ruff.format"],
+];
+const TYPECHECK_SECTIONS = [
+    ["python", "[tool.mypy"],
+    ["python", "[tool.pyright"],
+];
+const FORMAT_TOOLCHAINS = [
+    ["go", "gofmt (Go toolchain)"],
+    ["rust", "rustfmt (Rust toolchain)"],
+    ["dart", "dart format (Dart toolchain)"],
+];
+const TYPECHECK_TOOLCHAINS = [
+    ["go", "Go compiler"],
+    ["rust", "Rust compiler"],
+    ["java", "JVM compiler"],
+    ["dotnet", ".NET compiler"],
+    ["swift", "Swift compiler"],
+    ["dart", "Dart analyzer"],
+];
+const LINT_FILES = [
+    /^eslint\.config\.[cm]?[jt]s$/,
+    /^\.eslintrc(\..+)?$/,
+    /^biome\.jsonc?$/,
+    /^\.oxlintrc\.json$/,
+    /^\.golangci\.ya?ml$/,
+    /^\.?ruff\.toml$/,
+    /^\.flake8$/,
+    /^\.pylintrc$/,
+    /^\.rubocop\.yml$/,
+    /^phpstan\.neon(\.dist)?$/,
+    /^clippy\.toml$/,
+    /^\.swiftlint\.yml$/,
+    /^\.credo\.exs$/,
+];
+const FORMAT_FILES = [
+    /^\.prettierrc(\..+)?$/,
+    /^prettier\.config\.[cm]?[jt]s$/,
+    /^biome\.jsonc?$/,
+    /^dprint\.jsonc?$/,
+    /^\.?rustfmt\.toml$/,
+    /^\.clang-format$/,
+    /^\.php-cs-fixer(\.dist)?\.php$/,
+    /^\.swiftformat$/,
+    /^\.formatter\.exs$/,
+];
+const TYPECHECK_FILES = [/^tsconfig(\..+)?\.json$/, /^\.?mypy\.ini$/, /^pyrightconfig\.json$/];
+const CI_PATHS = [
+    /^\.github\/workflows\/[^/]+\.ya?ml$/,
+    /^\.gitlab-ci\.yml$/,
+    /^\.circleci\/config\.ya?ml$/,
+    /^azure-pipelines\.ya?ml$/,
+    /^Jenkinsfile$/,
+    /^bitbucket-pipelines\.yml$/,
+    /^\.travis\.yml$/,
+    /^\.buildkite\/.+\.ya?ml$/,
+    /^\.drone\.yml$/,
+    /^\.woodpecker(\.yml|\/.+\.ya?ml)$/,
+];
+const TEST_PATHS = [
+    /(^|\/)tests?\.(py|js|ts|mjs|cjs|rb)$/,
+    /_(?:unit)?test\.(cc|cpp|cxx|c)$/,
+    /(^|\/)(__tests__|tests?|spec|e2e|cypress)\//,
+    /\.(test|spec|cy|e2e)\.[a-z0-9]+$/i,
+    /(^|\/)test_[^/]+\.py$/,
+    /_(test|spec)\.(go|py|exs|rb)$/,
+    /Tests?\.(cs|java|kt|swift|php|scala)$/,
+];
+export function isTestFile(path) {
+    return languageOf(path) !== undefined && TEST_PATHS.some((pattern) => pattern.test(path));
+}
+export function isCiPath(path) {
+    return CI_PATHS.some((pattern) => pattern.test(path));
+}
+export function detectBaseline(paths, manifests) {
+    return {
+        tests: [
+            ...dependencyEvidence(manifests, TEST_DEPENDENCIES),
+            ...sectionEvidence(manifests, TEST_SECTIONS),
+            ...testFileEvidence(paths),
+        ],
+        lint: [
+            ...dependencyEvidence(manifests, LINT_DEPENDENCIES),
+            ...sectionEvidence(manifests, LINT_SECTIONS),
+            ...fileEvidence(paths.filter((path) => matchesName(path, LINT_FILES))),
+        ],
+        formatter: [
+            ...dependencyEvidence(manifests, FORMAT_DEPENDENCIES),
+            ...sectionEvidence(manifests, FORMAT_SECTIONS),
+            ...fileEvidence(paths.filter((path) => matchesName(path, FORMAT_FILES))),
+            ...toolchainEvidence(manifests, FORMAT_TOOLCHAINS),
+        ],
+        typecheck: [
+            ...dependencyEvidence(manifests, TYPECHECK_DEPENDENCIES),
+            ...sectionEvidence(manifests, TYPECHECK_SECTIONS),
+            ...fileEvidence(paths.filter((path) => matchesName(path, TYPECHECK_FILES))),
+            ...toolchainEvidence(manifests, TYPECHECK_TOOLCHAINS),
+        ],
+        ci: fileEvidence(paths.filter(isCiPath)),
+    };
+}
+function dependencyEvidence(manifests, markers) {
+    return markers.flatMap(([ecosystem, name]) => {
+        const manifest = findDependency(manifests, ecosystem, name);
+        return manifest ? [`${name} (${manifest.path})`] : [];
+    });
+}
+function sectionEvidence(manifests, markers) {
+    return markers.flatMap(([ecosystem, section]) => {
+        const manifest = manifests.find((candidate) => candidate.ecosystem === ecosystem && candidate.text.includes(section));
+        return manifest ? [`${section.replace(/\]?$/, "]")} (${manifest.path})`] : [];
+    });
+}
+function toolchainEvidence(manifests, markers) {
+    return markers
+        .filter(([ecosystem]) => manifests.some((manifest) => manifest.ecosystem === ecosystem))
+        .map(([, label]) => label);
+}
+function testFileEvidence(paths) {
+    const tests = paths.filter(isTestFile);
+    if (tests.length === 0)
+        return [];
+    const noun = tests.length === 1 ? "test file" : "test files";
+    return [`${tests.length} ${noun}, e.g. ${tests.slice(0, EVIDENCE_SAMPLE).join(", ")}`];
+}
+function fileEvidence(paths) {
+    const extra = paths.length - EVIDENCE_SAMPLE;
+    return [...paths.slice(0, EVIDENCE_SAMPLE), ...(extra > 0 ? [`+${extra} more`] : [])];
+}
+function matchesName(path, patterns) {
+    const name = baseName(path);
+    return patterns.some((pattern) => pattern.test(name));
+}

package/dist/digest/budget.js

@@ -0,0 +1,31 @@
+import { extensionOf } from "./files.js";
+import { codeFence, truncateText } from "./format.js";
+const MIN_PARTIAL = 1_000;
+const FENCE_SLACK = 8;
+export function renderBlock(block) {
+    return `### ${block.path}\n\n${codeFence(block.body, extensionOf(block.path).slice(1))}\n\n`;
+}
+export function fitBlocks(blocks, budget) {
+    const kept = [];
+    const omitted = [];
+    let remaining = budget;
+    for (const block of [...blocks].sort((a, b) => a.priority - b.priority)) {
+        const fitted = fitBlock(block, remaining);
+        if (fitted) {
+            kept.push(fitted);
+            remaining -= renderBlock(fitted).length;
+        }
+        else {
+            omitted.push(block.path);
+        }
+    }
+    return { blocks: kept, omitted };
+}
+function fitBlock(block, remaining) {
+    if (renderBlock(block).length <= remaining)
+        return block;
+    if (remaining < MIN_PARTIAL)
+        return undefined;
+    const overhead = renderBlock({ ...block, body: "" }).length + FENCE_SLACK;
+    return { ...block, body: truncateText(block.body, remaining - overhead) };
+}

package/dist/digest/files.js

@@ -0,0 +1,167 @@
+import { posix } from "node:path";
+const BINARY_EXTENSIONS = new Set([
+    "png jpg jpeg gif bmp ico icns webp avif tiff psd svgz",
+    "pdf doc docx xls xlsx ppt pptx odt",
+    "zip gz tgz bz2 xz 7z rar tar jar war ear",
+    "exe dll so dylib a o obj lib class pyc pyo wasm bin dat",
+    "woff woff2 ttf otf eot",
+    "mp3 mp4 m4a wav ogg flac webm mov avi mkv",
+    "sqlite sqlite3 db",
+]
+    .join(" ")
+    .split(" ")
+    .map((extension) => `.${extension}`));
+const LOCKFILES = new Set([
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "bun.lock",
+    "bun.lockb",
+    "deno.lock",
+    "Cargo.lock",
+    "poetry.lock",
+    "Pipfile.lock",
+    "uv.lock",
+    "pdm.lock",
+    "composer.lock",
+    "Gemfile.lock",
+    "go.sum",
+    "mix.lock",
+    "pubspec.lock",
+    "Podfile.lock",
+    "packages.lock.json",
+    "flake.lock",
+]);
+const SECRET_NAMES = new Set([
+    ".envrc",
+    ".netrc",
+    ".pgpass",
+    "credentials",
+    "id_rsa",
+    "id_dsa",
+    "id_ecdsa",
+    "id_ed25519",
+    ".pypirc",
+    ".git-credentials",
+    "secrets.env",
+]);
+const SECRET_EXTENSIONS = new Set([
+    ".pem",
+    ".key",
+    ".p12",
+    ".pfx",
+    ".jks",
+    ".keystore",
+    ".tfstate",
+    ".tfvars",
+    ".p8",
+    ".ppk",
+]);
+const LANGUAGES = {
+    ".ts": "TypeScript",
+    ".tsx": "TypeScript",
+    ".mts": "TypeScript",
+    ".cts": "TypeScript",
+    ".js": "JavaScript",
+    ".jsx": "JavaScript",
+    ".mjs": "JavaScript",
+    ".cjs": "JavaScript",
+    ".py": "Python",
+    ".go": "Go",
+    ".rs": "Rust",
+    ".java": "Java",
+    ".kt": "Kotlin",
+    ".kts": "Kotlin",
+    ".scala": "Scala",
+    ".cs": "C#",
+    ".fs": "F#",
+    ".php": "PHP",
+    ".rb": "Ruby",
+    ".swift": "Swift",
+    ".m": "Objective-C",
+    ".c": "C",
+    ".h": "C",
+    ".cc": "C++",
+    ".cpp": "C++",
+    ".hpp": "C++",
+    ".dart": "Dart",
+    ".ex": "Elixir",
+    ".exs": "Elixir",
+    ".erl": "Erlang",
+    ".hs": "Haskell",
+    ".lua": "Lua",
+    ".r": "R",
+    ".jl": "Julia",
+    ".zig": "Zig",
+    ".vue": "Vue",
+    ".svelte": "Svelte",
+    ".astro": "Astro",
+    ".html": "HTML",
+    ".css": "CSS",
+    ".scss": "SCSS",
+    ".sass": "SCSS",
+    ".less": "Less",
+    ".sql": "SQL",
+    ".sh": "Shell",
+    ".bash": "Shell",
+    ".ps1": "PowerShell",
+    ".tf": "Terraform",
+    ".proto": "Protocol Buffers",
+    ".graphql": "GraphQL",
+};
+export function extensionOf(path) {
+    return posix.extname(path).toLowerCase();
+}
+export function baseName(path) {
+    return posix.basename(path);
+}
+export function depthOf(path) {
+    return path.split("/").length - 1;
+}
+export function isBinaryPath(path) {
+    return BINARY_EXTENSIONS.has(extensionOf(path));
+}
+const BUILD_DIRS = new Set([
+    "dist",
+    "build",
+    "out",
+    "target",
+    "coverage",
+    "node_modules",
+    "vendor",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    ".turbo",
+    ".gradle",
+]);
+export function isBuildOutput(path) {
+    const parts = path.split("/");
+    return (parts.slice(0, -1).some((part) => BUILD_DIRS.has(part)) ||
+        /\.(pyc|tsbuildinfo)$|\.min\.(js|css|mjs)$|\.(js|css|mjs)\.map$/i.test(path));
+}
+export function isLockfile(path) {
+    return LOCKFILES.has(baseName(path));
+}
+export function isSecretPath(path) {
+    const name = baseName(path).toLowerCase();
+    if (/^\.env([.-].+)?$/.test(name))
+        return !/[.-](example|sample|template|dist)$/.test(name);
+    return SECRET_NAMES.has(name) || SECRET_EXTENSIONS.has(extensionOf(name));
+}
+export function isReadable(path) {
+    return !isBinaryPath(path) && !isLockfile(path) && !isSecretPath(path);
+}
+export function languageOf(path) {
+    return LANGUAGES[extensionOf(path)];
+}
+export function byPath(a, b) {
+    return depthOf(a) - depthOf(b) || (a < b ? -1 : a > b ? 1 : 0);
+}

package/dist/digest/format.js

@@ -0,0 +1,18 @@
+export const TRUNCATION_MARK = "\n… [truncated]";
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+export function codeFence(body, language = "") {
+    const longest = Array.from(body.matchAll(/`+/g)).reduce((max, match) => Math.max(max, match[0].length), 0);
+    const fence = "`".repeat(Math.max(3, longest + 1));
+    return `${fence}${language}\n${body}\n${fence}`;
+}
+export function truncateText(text, max) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, Math.max(0, max - TRUNCATION_MARK.length))}${TRUNCATION_MARK}`;
+}

package/dist/digest/git.js

@@ -0,0 +1,19 @@
+import { git, isGitRepo, lines } from "../core/git.js";
+import { redact } from "./redact.js";
+const COMMIT_LIMIT = 10;
+export async function readGitInfo(cwd) {
+    if (!(await isGitRepo(cwd)))
+        return undefined;
+    const [branch, branches, commits, status] = await Promise.all([
+        git(cwd, ["branch", "--show-current"]),
+        git(cwd, ["branch", "--format=%(refname:short)"]),
+        git(cwd, ["log", "-n", String(COMMIT_LIMIT), "--date=short", "--pretty=format:%h %ad %s"]),
+        git(cwd, ["status", "--porcelain"]),
+    ]);
+    return {
+        branch: (branch ?? "").trim(),
+        branches: lines(branches),
+        commits: lines(commits).map(redact),
+        changes: lines(status).length,
+    };
+}

package/dist/digest/index.js

@@ -0,0 +1,100 @@
+import { basename, resolve } from "node:path";
+import { DEFAULT_DIGEST_MAX_CHARS } from "../config/schema.js";
+import { detectMode } from "../detect/mode.js";
+import { detectBaseline } from "./baseline.js";
+import { fitBlocks } from "./budget.js";
+import { baseName, isReadable, languageOf } from "./files.js";
+import { truncateText } from "./format.js";
+import { readGitInfo } from "./git.js";
+import { detectFrameworks, detectPackageManagers, findManifestPaths, toManifest, } from "./manifests.js";
+import { readText, readTexts } from "./read.js";
+import { redact } from "./redact.js";
+import { renderContents, renderHead, renderOmitted } from "./render.js";
+import { findConfigs, findDocs, findEntryPoints } from "./select.js";
+import { countTodos } from "./todos.js";
+import { DEFAULT_TREE_DEPTH } from "./tree.js";
+import { scanFiles } from "./walk.js";
+export { BASELINE_CHECKS } from "./baseline.js";
+const CONTENT_RESERVE = 3_000;
+const MAX_CONTENT_BYTES = 1_000_000;
+const TODO_MAX_FILES = 5_000;
+const TODO_MAX_BYTES = 256_000;
+const CAPS = { manifest: 8_000, entry: 6_000, readme: 12_000, doc: 6_000, config: 3_000 };
+const GROUPS = {
+    manifests: { group: "Manifest contents", priority: 1 },
+    entries: { group: "Entry point contents", priority: 2 },
+    docs: { group: "Doc contents", priority: 3 },
+    configs: { group: "Config contents", priority: 4 },
+};
+export async function buildDigest(root, options = {}) {
+    const maxChars = options.maxChars ?? DEFAULT_DIGEST_MAX_CHARS;
+    const facts = await gatherFacts(root, options.treeDepth ?? DEFAULT_TREE_DEPTH);
+    const head = truncateText(`${renderHead(facts)}\n\n`, maxChars);
+    const blocks = await contentBlocks(root, facts);
+    const fitted = fitBlocks(blocks, maxChars - head.length - CONTENT_RESERVE);
+    const body = renderContents(fitted.blocks) + renderOmitted(fitted.omitted);
+    return {
+        text: truncateText(head + body, maxChars),
+        mode: facts.mode,
+        baseline: facts.baseline,
+        omitted: fitted.omitted,
+    };
+}
+async function gatherFacts(root, treeDepth) {
+    const scan = await scanFiles(root);
+    const paths = scan.files.map((file) => file.path);
+    const manifests = await readManifests(root, findManifestPaths(paths));
+    const [git, todoTexts] = await Promise.all([
+        readGitInfo(root),
+        readTexts(root, todoCandidates(scan.files)),
+    ]);
+    return {
+        name: basename(resolve(root)),
+        mode: detectMode(paths),
+        scan,
+        manifests,
+        frameworks: detectFrameworks(manifests),
+        packageManagers: detectPackageManagers(paths, manifests),
+        baseline: detectBaseline(paths, manifests),
+        entryPoints: findEntryPoints(paths, manifests),
+        docs: findDocs(paths),
+        configs: findConfigs(paths),
+        git,
+        todos: countTodos(todoTexts),
+        treeDepth,
+    };
+}
+async function readManifests(root, paths) {
+    const texts = await readTexts(root, paths);
+    return paths
+        .map((path) => toManifest(path, texts.get(path) ?? ""))
+        .filter((manifest) => manifest !== undefined);
+}
+function todoCandidates(files) {
+    return files
+        .filter((file) => file.size <= TODO_MAX_BYTES && languageOf(file.path) && isReadable(file.path))
+        .slice(0, TODO_MAX_FILES)
+        .map((file) => file.path);
+}
+async function contentBlocks(root, facts) {
+    const sizes = new Map(facts.scan.files.map((file) => [file.path, file.size]));
+    const read = async (path, group, cap) => {
+        if (!isReadable(path) || (sizes.get(path) ?? 0) > MAX_CONTENT_BYTES)
+            return undefined;
+        const text = await readText(root, path);
+        return text === undefined ? undefined : toBlock(path, text, group, cap);
+    };
+    const manifests = facts.manifests.map((manifest) => toBlock(manifest.path, manifest.text, GROUPS.manifests, CAPS.manifest));
+    const others = await Promise.all([
+        ...facts.entryPoints.map((path) => read(path, GROUPS.entries, CAPS.entry)),
+        ...facts.docs.map((path) => read(path, GROUPS.docs, docCap(path))),
+        ...facts.configs.map((path) => read(path, GROUPS.configs, CAPS.config)),
+    ]);
+    return [...manifests, ...others.filter((block) => block !== undefined)];
+}
+function toBlock(path, text, group, cap) {
+    return { ...group, path, body: truncateText(redact(text).trimEnd(), cap) };
+}
+function docCap(path) {
+    return /^readme/i.test(baseName(path)) ? CAPS.readme : CAPS.doc;
+}

package/dist/digest/manifests.js

@@ -0,0 +1,133 @@
+import { asRecord, parseObject } from "../core/json.js";
+import { baseName, byPath, extensionOf } from "./files.js";
+export const MAX_MANIFESTS = 20;
+const MANIFESTS = new Map([
+    ["package.json", "npm"],
+    ["deno.json", "npm"],
+    ["deno.jsonc", "npm"],
+    ["pyproject.toml", "python"],
+    ["setup.py", "python"],
+    ["setup.cfg", "python"],
+    ["Pipfile", "python"],
+    ["go.mod", "go"],
+    ["Cargo.toml", "rust"],
+    ["pom.xml", "java"],
+    ["build.gradle", "java"],
+    ["build.gradle.kts", "java"],
+    ["composer.json", "php"],
+    ["Gemfile", "ruby"],
+    ["mix.exs", "elixir"],
+    ["pubspec.yaml", "dart"],
+    ["Package.swift", "swift"],
+]);
+const DOTNET_EXTENSIONS = new Set([".csproj", ".fsproj", ".vbproj"]);
+const JSON_DEPENDENCY_FIELDS = new Map([
+    ["package.json", ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]],
+    ["composer.json", ["require", "require-dev"]],
+]);
+const LOCKFILE_MANAGERS = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["package-lock.json", "npm"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+    ["deno.lock", "deno"],
+    ["poetry.lock", "poetry"],
+    ["uv.lock", "uv"],
+    ["Pipfile.lock", "pipenv"],
+    ["pdm.lock", "pdm"],
+    ["Cargo.lock", "cargo"],
+    ["go.sum", "go modules"],
+    ["composer.lock", "composer"],
+    ["Gemfile.lock", "bundler"],
+    ["mix.lock", "mix"],
+    ["pubspec.lock", "pub"],
+];
+const FRAMEWORKS = [
+    ["Next.js", "npm", "next"],
+    ["React", "npm", "react"],
+    ["React Native", "npm", "react-native"],
+    ["Expo", "npm", "expo"],
+    ["Vue", "npm", "vue"],
+    ["Nuxt", "npm", "nuxt"],
+    ["Svelte", "npm", "svelte"],
+    ["SvelteKit", "npm", "@sveltejs/kit"],
+    ["Angular", "npm", "@angular/core"],
+    ["Astro", "npm", "astro"],
+    ["Remix", "npm", "@remix-run/react"],
+    ["Vite", "npm", "vite"],
+    ["Express", "npm", "express"],
+    ["Fastify", "npm", "fastify"],
+    ["Hono", "npm", "hono"],
+    ["Koa", "npm", "koa"],
+    ["NestJS", "npm", "@nestjs/core"],
+    ["Electron", "npm", "electron"],
+    ["Prisma", "npm", "prisma"],
+    ["Drizzle", "npm", "drizzle-orm"],
+    ["TypeORM", "npm", "typeorm"],
+    ["Mongoose", "npm", "mongoose"],
+    ["Django", "python", "django"],
+    ["Flask", "python", "flask"],
+    ["FastAPI", "python", "fastapi"],
+    ["SQLAlchemy", "python", "sqlalchemy"],
+    ["Gin", "go", "gin-gonic/gin"],
+    ["Echo", "go", "labstack/echo"],
+    ["Fiber", "go", "gofiber/fiber"],
+    ["Axum", "rust", "axum"],
+    ["Actix Web", "rust", "actix-web"],
+    ["Rocket", "rust", "rocket"],
+    ["Tokio", "rust", "tokio"],
+    ["Spring Boot", "java", "spring-boot"],
+    ["Laravel", "php", "laravel/framework"],
+    ["Symfony", "php", "symfony/framework-bundle"],
+    ["Rails", "ruby", "rails"],
+    ["ASP.NET Core", "dotnet", "microsoft.aspnetcore"],
+    ["Phoenix", "elixir", "phoenix"],
+    ["Flutter", "dart", "flutter"],
+];
+export function ecosystemOf(path) {
+    const name = baseName(path);
+    if (/^requirements.*\.txt$/.test(name))
+        return "python";
+    if (DOTNET_EXTENSIONS.has(extensionOf(name)))
+        return "dotnet";
+    return MANIFESTS.get(name);
+}
+export function findManifestPaths(paths) {
+    return paths
+        .filter((path) => ecosystemOf(path) !== undefined)
+        .sort(byPath)
+        .slice(0, MAX_MANIFESTS);
+}
+export function toManifest(path, text) {
+    const ecosystem = ecosystemOf(path);
+    if (!ecosystem)
+        return undefined;
+    const fields = JSON_DEPENDENCY_FIELDS.get(baseName(path));
+    const json = fields || path.endsWith(".json") ? parseObject(text) : undefined;
+    const dependencies = new Set((fields ?? []).flatMap((field) => Object.keys(asRecord(json?.[field]))));
+    return { path, ecosystem, text, json, dependencies };
+}
+export function findDependency(manifests, ecosystem, name) {
+    return manifests.find((manifest) => manifest.ecosystem === ecosystem && declares(manifest, name));
+}
+export function detectFrameworks(manifests) {
+    return FRAMEWORKS.filter(([, ecosystem, name]) => findDependency(manifests, ecosystem, name)).map(([label]) => label);
+}
+export function detectPackageManagers(paths, manifests) {
+    const names = new Set(paths.map(baseName));
+    const declared = manifests
+        .map((manifest) => manifest.json?.packageManager)
+        .filter((value) => typeof value === "string");
+    const locked = LOCKFILE_MANAGERS.filter(([file]) => names.has(file)).map(([, manager]) => manager);
+    return [...new Set([...declared, ...locked])];
+}
+function declares(manifest, name) {
+    if (JSON_DEPENDENCY_FIELDS.has(baseName(manifest.path)))
+        return manifest.dependencies.has(name);
+    const pattern = new RegExp(`(^|[^a-z0-9_.])${escapeRegExp(name.toLowerCase())}`, "m");
+    return pattern.test(manifest.text.toLowerCase());
+}
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+}