archbyte 0.1.0

package/dist/agents/static/doc-parser.js

@@ -0,0 +1,358 @@
+// Static Analysis — Doc Parser
+// Deep-scans README, CLAUDE.md, architecture docs, API docs, mermaid diagrams
+// to extract project description, components, connections, endpoints, and external deps
+const KNOWN_SERVICES = [
+    { pattern: /aws\s*s3|amazon\s*s3|@aws-sdk\/client-s3/i, name: "AWS S3" },
+    { pattern: /dynamodb|@aws-sdk\/client-dynamodb/i, name: "DynamoDB" },
+    { pattern: /aws\s*lambda|@aws-sdk\/client-lambda/i, name: "AWS Lambda" },
+    { pattern: /sqs|@aws-sdk\/client-sqs/i, name: "AWS SQS" },
+    { pattern: /sns|@aws-sdk\/client-sns/i, name: "AWS SNS" },
+    { pattern: /cloudflare\s*workers|wrangler/i, name: "Cloudflare Workers" },
+    { pattern: /redis|ioredis|@upstash\/redis/i, name: "Redis" },
+    { pattern: /postgres(?:ql)?|pg\b|@prisma|prisma|tokio-postgres|neon/i, name: "PostgreSQL" },
+    { pattern: /mysql|mariadb/i, name: "MySQL" },
+    { pattern: /mongodb|mongoose/i, name: "MongoDB" },
+    { pattern: /firebase|firestore/i, name: "Firebase" },
+    { pattern: /supabase/i, name: "Supabase" },
+    { pattern: /stripe/i, name: "Stripe" },
+    { pattern: /twilio/i, name: "Twilio" },
+    { pattern: /sendgrid|@sendgrid/i, name: "SendGrid" },
+    { pattern: /elasticsearch|opensearch/i, name: "Elasticsearch" },
+    { pattern: /rabbitmq|amqplib/i, name: "RabbitMQ" },
+    { pattern: /kafka|kafkajs/i, name: "Kafka" },
+    { pattern: /nats\.io|nats/i, name: "NATS" },
+    { pattern: /auth0/i, name: "Auth0" },
+    { pattern: /clerk/i, name: "Clerk" },
+    { pattern: /sentry/i, name: "Sentry" },
+    { pattern: /datadog/i, name: "Datadog" },
+    { pattern: /vercel/i, name: "Vercel" },
+    { pattern: /netlify/i, name: "Netlify" },
+    { pattern: /openai|gpt-4|gpt-3/i, name: "OpenAI" },
+    { pattern: /anthropic|claude/i, name: "Anthropic" },
+    { pattern: /mapbox/i, name: "Mapbox" },
+    { pattern: /google\s*places|google\s*maps/i, name: "Google Maps/Places" },
+    { pattern: /nginx/i, name: "NGINX" },
+];
+export async function parseDocs(tk) {
+    const result = {
+        projectDescription: "",
+        architectureNotes: [],
+        apiEndpoints: [],
+        externalDependencies: [],
+    };
+    // Discover all markdown files worth reading
+    const docFiles = await discoverDocFiles(tk);
+    // Read root README first for project description
+    const readme = await tk.readFileSafe("README.md");
+    if (readme) {
+        result.projectDescription = extractDescription(readme);
+        scanForExternalDeps(readme, result);
+    }
+    // Read all discovered doc files in parallel (batch of 15)
+    const contents = await Promise.all(docFiles.slice(0, 15).map(async (f) => ({
+        path: f,
+        content: await tk.readFileSafe(f),
+    })));
+    for (const { path, content } of contents) {
+        if (!content)
+            continue;
+        // Extract architecture notes from architecture/design docs
+        if (isArchitectureDoc(path)) {
+            const notes = extractArchitectureNotes(path, content);
+            result.architectureNotes.push(...notes);
+        }
+        // Extract API endpoints from docs
+        const endpoints = extractAPIEndpoints(content);
+        result.apiEndpoints.push(...endpoints);
+        // Scan all docs for external service mentions
+        scanForExternalDeps(content, result);
+    }
+    // Parse OpenAPI spec if available
+    const [openApiYaml, openApiJson] = await Promise.all([
+        tk.readYAML("openapi.yaml"),
+        tk.readJSON("openapi.json"),
+    ]);
+    parseOpenAPI(openApiYaml ?? openApiJson, result);
+    // Also scan package.json/Cargo.toml deps for known services
+    await scanBuildDepsForServices(tk, result);
+    return result;
+}
+/**
+ * Find all documentation files worth reading — READMEs, CLAUDE.md, docs/, architecture docs
+ */
+async function discoverDocFiles(tk) {
+    const files = [];
+    // Root-level docs
+    const rootEntries = await tk.listDir(".");
+    const rootDirs = rootEntries.filter((e) => e.type === "directory").map((e) => e.name);
+    // Root markdown files
+    for (const entry of rootEntries) {
+        if (entry.type === "file" && /\.(md|markdown)$/i.test(entry.name)) {
+            files.push(entry.name);
+        }
+    }
+    // docs/ directory (central documentation hub)
+    if (rootDirs.includes("docs")) {
+        const docEntries = await tk.listDir("docs");
+        for (const entry of docEntries) {
+            if (entry.type === "file" && /\.(md|markdown)$/i.test(entry.name)) {
+                files.push(`docs/${entry.name}`);
+            }
+        }
+    }
+    // Scan each top-level directory for CLAUDE.md, README.md, and docs/ subdirs
+    for (const dir of rootDirs) {
+        if (dir.startsWith(".") || dir === "node_modules" || dir === "dist" || dir === "target")
+            continue;
+        const entries = await tk.listDir(dir);
+        const fileNames = entries.map((e) => e.name);
+        // CLAUDE.md — often has the best architecture descriptions
+        if (fileNames.includes("CLAUDE.md")) {
+            files.push(`${dir}/CLAUDE.md`);
+        }
+        // Sub-README
+        if (fileNames.includes("README.md")) {
+            files.push(`${dir}/README.md`);
+        }
+        // Component docs/ subdirectory (e.g., server/docs/architecture.md)
+        if (fileNames.includes("docs") && entries.find((e) => e.name === "docs")?.type === "directory") {
+            const subDocs = await tk.listDir(`${dir}/docs`);
+            for (const entry of subDocs) {
+                if (entry.type === "file" && /\.(md|markdown)$/i.test(entry.name)) {
+                    files.push(`${dir}/docs/${entry.name}`);
+                }
+            }
+        }
+    }
+    // Deduplicate
+    return [...new Set(files)];
+}
+function isArchitectureDoc(path) {
+    const lower = path.toLowerCase();
+    return (lower.includes("architect") ||
+        lower.includes("design") ||
+        lower.includes("overview") ||
+        lower.includes("claude.md") ||
+        lower.includes("system") ||
+        lower.includes("api.md") ||
+        lower.includes("readme.md"));
+}
+function extractDescription(readme) {
+    const lines = readme.split("\n").slice(0, 500);
+    let capturing = false;
+    const descLines = [];
+    for (const line of lines) {
+        if (!capturing && /^#\s+/.test(line)) {
+            capturing = true;
+            continue;
+        }
+        if (capturing && /^##\s+/.test(line))
+            break;
+        if (capturing)
+            descLines.push(line);
+    }
+    return descLines
+        .join("\n")
+        .trim()
+        .replace(/\n{3,}/g, "\n\n")
+        .slice(0, 500);
+}
+/**
+ * Extract architecture notes from a documentation file.
+ * Looks for: technology tables, ASCII diagrams, component descriptions,
+ * section headers mentioning architecture/components/services.
+ */
+function extractArchitectureNotes(path, content) {
+    const notes = [];
+    const lines = content.split("\n");
+    // Extract technology stack tables (markdown tables with | Component | Technology |)
+    const tableBlocks = extractMarkdownTables(content);
+    if (tableBlocks.length > 0) {
+        notes.push(`[${path}] Tech stack: ${tableBlocks[0].slice(0, 400)}`);
+    }
+    // Extract ASCII architecture diagrams (blocks between ``` that contain box-drawing chars or arrows)
+    const codeBlocks = extractCodeBlocks(content);
+    for (const block of codeBlocks) {
+        if (isAsciiDiagram(block)) {
+            notes.push(`[${path}] Architecture diagram: ${block.slice(0, 500)}`);
+        }
+    }
+    // Extract key sections: Architecture, Components, Services, Overview, Stack
+    const sections = extractSections(content, [
+        "architecture", "components", "services", "overview",
+        "technology stack", "tech stack", "system design",
+        "quick overview", "core components", "key directories",
+    ]);
+    for (const section of sections.slice(0, 3)) {
+        notes.push(`[${path}] ${section.title}: ${section.content.slice(0, 400)}`);
+    }
+    // Extract service connection descriptions (patterns like "X calls Y", "X → Y")
+    const connectionDescs = extractConnectionDescriptions(content);
+    if (connectionDescs.length > 0) {
+        notes.push(`[${path}] Connections: ${connectionDescs.join("; ").slice(0, 400)}`);
+    }
+    return notes;
+}
+/**
+ * Extract API endpoints documented in markdown.
+ * Looks for: GET /path, POST /path patterns, markdown tables with endpoints
+ */
+function extractAPIEndpoints(content) {
+    const endpoints = [];
+    const seen = new Set();
+    // Pattern 1: HTTP method + path (e.g., "GET /api/health", "POST /api/login")
+    const methodPathRegex = /\b(GET|POST|PUT|PATCH|DELETE)\s+(\/[a-zA-Z0-9/_\-{}:.*]+)/g;
+    let match;
+    while ((match = methodPathRegex.exec(content)) !== null) {
+        const key = `${match[1]}:${match[2]}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        // Try to find description on the same or next line
+        const lineStart = content.lastIndexOf("\n", match.index) + 1;
+        const lineEnd = content.indexOf("\n", match.index + match[0].length);
+        const line = content.slice(lineStart, lineEnd > 0 ? lineEnd : undefined).trim();
+        // Strip the method+path to get remaining description
+        const desc = line
+            .replace(match[0], "")
+            .replace(/^[\s|*-]+/, "")
+            .replace(/[|`]+/g, "")
+            .trim()
+            .slice(0, 100);
+        endpoints.push({
+            method: match[1],
+            path: match[2],
+            description: desc,
+        });
+    }
+    return endpoints;
+}
+function extractMarkdownTables(content) {
+    const tables = [];
+    const lines = content.split("\n");
+    let inTable = false;
+    let tableLines = [];
+    for (const line of lines) {
+        if (line.includes("|") && line.trim().startsWith("|")) {
+            inTable = true;
+            tableLines.push(line);
+        }
+        else if (inTable) {
+            if (tableLines.length >= 2) {
+                tables.push(tableLines.join("\n"));
+            }
+            inTable = false;
+            tableLines = [];
+        }
+    }
+    if (inTable && tableLines.length >= 2) {
+        tables.push(tableLines.join("\n"));
+    }
+    return tables;
+}
+function extractCodeBlocks(content) {
+    const blocks = [];
+    const regex = /```[^\n]*\n([\s\S]*?)```/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        blocks.push(match[1]);
+    }
+    return blocks;
+}
+function isAsciiDiagram(block) {
+    // Contains box-drawing characters, arrows, or flow indicators
+    return (/[┌┐└┘│─├┤┬┴┼╔╗╚╝║═]/.test(block) ||
+        (/[→←↓↑▶◀]/.test(block) && block.includes("|")) ||
+        (block.includes("-->") && block.includes("[")) || // mermaid-like
+        (/\+-+\+/.test(block) && block.includes("|")) // ASCII box
+    );
+}
+function extractSections(content, keywords) {
+    const sections = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const headingMatch = line.match(/^(#{1,3})\s+(.+)/);
+        if (!headingMatch)
+            continue;
+        const title = headingMatch[2].trim().toLowerCase();
+        if (!keywords.some((kw) => title.includes(kw)))
+            continue;
+        // Collect content until next heading of same or higher level
+        const level = headingMatch[1].length;
+        const contentLines = [];
+        for (let j = i + 1; j < lines.length; j++) {
+            const nextHeading = lines[j].match(/^(#{1,3})\s+/);
+            if (nextHeading && nextHeading[1].length <= level)
+                break;
+            contentLines.push(lines[j]);
+        }
+        sections.push({
+            title: headingMatch[2].trim(),
+            content: contentLines.join("\n").trim(),
+        });
+    }
+    return sections;
+}
+/**
+ * Extract service connection descriptions from text.
+ * Looks for patterns like "X calls Y", "X → Y", "X sends to Y"
+ */
+function extractConnectionDescriptions(content) {
+    const descs = [];
+    // "ServiceA calls ServiceB", "frontend talks to backend"
+    const callPatterns = content.match(/\b\w+\s+(?:calls?|connects?\s+to|talks?\s+to|sends?\s+to|communicates?\s+with|depends?\s+on|queries)\s+\w+/gi);
+    if (callPatterns) {
+        descs.push(...callPatterns.slice(0, 10));
+    }
+    // Arrow patterns in prose: "Backend → Database", "Client → Server"
+    const arrowPatterns = content.match(/\b\w+\s*[→→>-]+\s*\w+/g);
+    if (arrowPatterns) {
+        for (const p of arrowPatterns.slice(0, 10)) {
+            if (p.length < 50)
+                descs.push(p);
+        }
+    }
+    return descs;
+}
+function scanForExternalDeps(content, result) {
+    for (const svc of KNOWN_SERVICES) {
+        if (svc.pattern.test(content) && !result.externalDependencies.includes(svc.name)) {
+            result.externalDependencies.push(svc.name);
+        }
+    }
+}
+function parseOpenAPI(spec, result) {
+    if (!spec || typeof spec !== "object")
+        return;
+    const s = spec;
+    const paths = s.paths;
+    if (!paths)
+        return;
+    for (const [path, methods] of Object.entries(paths)) {
+        for (const [method, def] of Object.entries(methods)) {
+            if (["get", "post", "put", "patch", "delete"].includes(method)) {
+                const op = def;
+                result.apiEndpoints.push({
+                    method: method.toUpperCase(),
+                    path,
+                    description: op.summary ?? op.description ?? "",
+                });
+            }
+        }
+    }
+}
+async function scanBuildDepsForServices(tk, result) {
+    const pkg = await tk.readJSON("package.json");
+    if (pkg) {
+        const depString = Object.keys({
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+        }).join(" ");
+        scanForExternalDeps(depString, result);
+    }
+    // Also check Cargo.toml at root
+    const cargo = await tk.readFileSafe("Cargo.toml");
+    if (cargo)
+        scanForExternalDeps(cargo, result);
+}

package/dist/agents/static/env-detector.d.ts

@@ -0,0 +1,3 @@
+import type { EnvResult } from "./types.js";
+import type { StaticToolkit } from "./utils.js";
+export declare function detectEnvironments(tk: StaticToolkit): Promise<EnvResult>;

package/dist/agents/static/env-detector.js

@@ -0,0 +1,73 @@
+// Static Analysis — Environment Detector
+// Detects environments, config patterns, and secrets management from .env files
+const SECRET_DEPS = [
+    "dotenv", "@aws-sdk/client-secrets-manager", "vault", "node-vault",
+    "@google-cloud/secret-manager", "@azure/keyvault-secrets", "infisical-sdk",
+];
+export async function detectEnvironments(tk) {
+    const result = {
+        environments: [],
+        configPattern: null,
+        hasSecrets: false,
+    };
+    // Find .env files
+    const envFiles = await tk.globFiles(".env*");
+    // Parse environment names from file names
+    const seenEnvs = new Set();
+    for (const file of envFiles) {
+        const name = file.replace(/^\.env\.?/, "").replace(/\.example$|\.sample$|\.template$/, "");
+        const envName = name || "default";
+        // Skip example/sample templates for environment detection, but still parse vars
+        const isTemplate = /\.example$|\.sample$|\.template$/.test(file);
+        if (!seenEnvs.has(envName) && !isTemplate) {
+            seenEnvs.add(envName);
+        }
+        // Read variable NAMES (not values)
+        const content = await tk.readFileSafe(file);
+        if (content) {
+            const varNames = content
+                .split("\n")
+                .filter((line) => /^[A-Z_][A-Z0-9_]*=/.test(line.trim()))
+                .map((line) => line.split("=")[0].trim());
+            // Look for the matching environment or create one
+            const existing = result.environments.find((e) => e.name === envName);
+            if (existing) {
+                for (const v of varNames) {
+                    if (!existing.variables.includes(v))
+                        existing.variables.push(v);
+                }
+            }
+            else {
+                result.environments.push({ name: envName, variables: varNames });
+            }
+        }
+    }
+    // If no .env files, check for config directories
+    if (result.environments.length === 0) {
+        const configFiles = await tk.globFiles("config/**/*");
+        if (configFiles.length > 0) {
+            result.configPattern = "config-directory";
+            // Try to detect env names from config file names
+            for (const f of configFiles) {
+                const match = f.match(/(?:config\/)?(development|production|staging|test|local)\./);
+                if (match && !seenEnvs.has(match[1])) {
+                    seenEnvs.add(match[1]);
+                    result.environments.push({ name: match[1], variables: [] });
+                }
+            }
+        }
+    }
+    // Check for secrets management in deps
+    const pkg = await tk.readJSON("package.json");
+    if (pkg) {
+        const allDeps = Object.keys({
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+        });
+        result.hasSecrets = allDeps.some((d) => SECRET_DEPS.includes(d));
+        if (allDeps.includes("dotenv")) {
+            result.configPattern = result.configPattern ?? "dotenv";
+        }
+    }
+    return result;
+}

package/dist/agents/static/event-detector.d.ts

@@ -0,0 +1,3 @@
+import type { EventResult } from "./types.js";
+import type { StaticToolkit } from "./utils.js";
+export declare function detectEvents(tk: StaticToolkit): Promise<EventResult>;

package/dist/agents/static/event-detector.js

@@ -0,0 +1,70 @@
+// Static Analysis — Event Detector
+// Detects event-driven architecture patterns from deps and code grep
+const EDA_DEPS = [
+    { dep: "kafkajs", technology: "Kafka" },
+    { dep: "@confluentinc/kafka-javascript", technology: "Kafka" },
+    { dep: "amqplib", technology: "RabbitMQ" },
+    { dep: "bullmq", technology: "Redis Streams (BullMQ)" },
+    { dep: "bull", technology: "Redis Streams (Bull)" },
+    { dep: "bee-queue", technology: "Redis Streams (Bee-Queue)" },
+    { dep: "socket.io", technology: "WebSocket (Socket.IO)" },
+    { dep: "ws", technology: "WebSocket" },
+    { dep: "@google-cloud/pubsub", technology: "Google Pub/Sub" },
+    { dep: "@aws-sdk/client-sqs", technology: "AWS SQS" },
+    { dep: "@aws-sdk/client-sns", technology: "AWS SNS" },
+    { dep: "@aws-sdk/client-eventbridge", technology: "AWS EventBridge" },
+    { dep: "nats", technology: "NATS" },
+    { dep: "mqtt", technology: "MQTT" },
+    { dep: "@azure/service-bus", technology: "Azure Service Bus" },
+    { dep: "@azure/event-hubs", technology: "Azure Event Hubs" },
+    { dep: "sse-channel", technology: "Server-Sent Events" },
+    { dep: "better-sse", technology: "Server-Sent Events" },
+];
+export async function detectEvents(tk) {
+    const result = {
+        hasEDA: false,
+        patterns: [],
+        events: [],
+    };
+    // Check package.json deps
+    const pkg = await tk.readJSON("package.json");
+    if (pkg) {
+        const allDeps = Object.keys({
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+        });
+        for (const edaDep of EDA_DEPS) {
+            if (allDeps.includes(edaDep.dep)) {
+                result.hasEDA = true;
+                result.patterns.push({
+                    technology: edaDep.technology,
+                    dependency: edaDep.dep,
+                });
+            }
+        }
+    }
+    // Grep for event patterns (filtered to exclude vendored code)
+    const [publishResults, subscribeResults, emitResults] = await Promise.all([
+        tk.grepFiles("\\.publish\\(|\\.send\\(|\\.produce\\("),
+        tk.grepFiles("\\.subscribe\\(|\\.consume\\(|\\.on\\("),
+        tk.grepFiles("\\.emit\\(|\\.dispatch\\(|\\.trigger\\("),
+    ]);
+    // Exclude vendored/generated dirs from all results
+    const excludeDirs = /\/(node_modules|venv|\.venv|__pycache__|dist|build|\.git|vendor|target)\//;
+    const filterVendored = (results) => results.filter((r) => !excludeDirs.test("/" + r.file));
+    // Filter subscribe results to only EDA-relevant ones (skip generic .on() calls)
+    const filteredSubscribe = filterVendored(subscribeResults).filter((r) => /\.(subscribe|consume)\(/.test(r.content));
+    for (const r of filterVendored(publishResults).slice(0, 20)) {
+        result.events.push({ type: "publish", file: r.file, pattern: r.content.slice(0, 100) });
+    }
+    for (const r of filteredSubscribe.slice(0, 20)) {
+        result.events.push({ type: "subscribe", file: r.file, pattern: r.content.slice(0, 100) });
+    }
+    for (const r of filterVendored(emitResults).slice(0, 20)) {
+        result.events.push({ type: "emit", file: r.file, pattern: r.content.slice(0, 100) });
+    }
+    if (result.events.length > 0) {
+        result.hasEDA = true;
+    }
+    return result;
+}

package/dist/agents/static/file-tree-collector.d.ts

@@ -0,0 +1,3 @@
+import type { FileTreeResult } from "./types.js";
+import type { StaticToolkit } from "./utils.js";
+export declare function collectFileTree(tk: StaticToolkit): Promise<FileTreeResult>;

package/dist/agents/static/file-tree-collector.js

@@ -0,0 +1,51 @@
+// Static Analysis — File Tree Collector
+// Collects depth-limited directory tree for LLM context
+const SKIP_DIRS = new Set([
+    "node_modules", "dist", "build", ".git", "venv", "__pycache__",
+    "target", "coverage", ".next", ".nuxt", ".output", ".cache",
+    ".turbo", ".nx", "vendor", ".venv", "env",
+]);
+const MAX_ENTRIES = 2000;
+const MAX_DEPTH = 3;
+export async function collectFileTree(tk) {
+    let totalFiles = 0;
+    let totalDirs = 0;
+    let entryCount = 0;
+    async function walk(dirPath, depth) {
+        if (depth > MAX_DEPTH || entryCount >= MAX_ENTRIES)
+            return [];
+        const entries = await tk.listDir(dirPath);
+        const result = [];
+        // Sort: directories first, then files
+        const sorted = entries.sort((a, b) => {
+            if (a.type !== b.type)
+                return a.type === "directory" ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+        for (const entry of sorted) {
+            if (entryCount >= MAX_ENTRIES)
+                break;
+            // Skip hidden dirs and vendored dirs
+            if (entry.type === "directory") {
+                if (entry.name.startsWith(".") && entry.name !== ".github")
+                    continue;
+                if (SKIP_DIRS.has(entry.name))
+                    continue;
+            }
+            const entryPath = dirPath === "." ? entry.name : `${dirPath}/${entry.name}`;
+            entryCount++;
+            if (entry.type === "directory") {
+                totalDirs++;
+                const children = await walk(entryPath, depth + 1);
+                result.push({ path: entryPath, type: "directory", children });
+            }
+            else {
+                totalFiles++;
+                result.push({ path: entryPath, type: "file" });
+            }
+        }
+        return result;
+    }
+    const tree = await walk(".", 0);
+    return { tree, totalFiles, totalDirs };
+}

package/dist/agents/static/index.d.ts

@@ -0,0 +1,19 @@
+import type { StaticAnalysisResult, StaticContext } from "./types.js";
+export type { StaticAnalysisResult, StaticContext } from "./types.js";
+export { validateAnalysis } from "./validator.js";
+/**
+ * Run all static analysis scanners.
+ *
+ * Pipeline:
+ *   1. Parallel: structure, docs, infra, events, envs
+ *   2. Sequential: components (needs structure), connections (needs components+infra+events)
+ *   3. Validation + auto-repair
+ *   4. Gap detection — identify what the LLM should resolve
+ */
+export declare function runStaticAnalysis(projectRoot: string, onProgress?: (msg: string) => void): Promise<StaticAnalysisResult>;
+/**
+ * Collect raw static context from all 7 scanners.
+ * This runs ONLY fact-collectors (no component-detector, connection-mapper, or validator).
+ * Output is consumed by the pipeline LLM agents.
+ */
+export declare function runStaticContextCollection(projectRoot: string, onProgress?: (msg: string) => void): Promise<StaticContext>;