archbyte 0.1.0

package/dist/agents/llm/index.js

@@ -0,0 +1,185 @@
+// LLM Enhancement — Single Call Enhancer
+// One chat() call, NO tools. Fails gracefully → static results unchanged.
+import { resolveModel } from "../runtime/types.js";
+import { buildSystemPrompt, buildUserPrompt } from "./prompt-builder.js";
+import { parseLLMResponse } from "./response-parser.js";
+/**
+ * Enhance static analysis with a single LLM call.
+ * Returns the merged analysis. On any failure, returns the original unchanged.
+ */
+export async function enhanceWithLLM(analysis, provider, config, projectRoot, onProgress) {
+    try {
+        onProgress?.("Building LLM prompt...");
+        const systemPrompt = buildSystemPrompt();
+        const userPrompt = await buildUserPrompt(analysis, projectRoot);
+        if (analysis.gaps.length > 0) {
+            onProgress?.(`Including ${analysis.gaps.length} gap(s) for LLM resolution`);
+        }
+        const model = resolveModel(config.provider, "standard", config.modelOverrides);
+        onProgress?.(`Calling ${model} for enhancement...`);
+        const response = await provider.chat({
+            model,
+            system: systemPrompt,
+            messages: [{ role: "user", content: userPrompt }],
+            maxTokens: 4096,
+            // NO tools — pure text→JSON
+        });
+        // Extract text from response
+        const text = response.content
+            .filter((b) => b.type === "text")
+            .map((b) => b.text ?? "")
+            .join("");
+        if (!text) {
+            onProgress?.("LLM returned empty response, using static results");
+            return analysis;
+        }
+        onProgress?.(`LLM response: ${response.usage.inputTokens} in / ${response.usage.outputTokens} out tokens`);
+        // Parse with 4-strategy extraction
+        const componentIds = new Set(analysis.components.components.map((c) => c.id));
+        const enhancement = parseLLMResponse(text, componentIds);
+        if (!enhancement) {
+            onProgress?.("Could not parse LLM response, using static results");
+            return analysis;
+        }
+        // Log what the LLM resolved
+        const resolved = [];
+        if (enhancement.componentDescriptions)
+            resolved.push(`${Object.keys(enhancement.componentDescriptions).length} descriptions`);
+        if (enhancement.componentTypeCorrections)
+            resolved.push(`${Object.keys(enhancement.componentTypeCorrections).length} type corrections`);
+        if (enhancement.additionalConnections?.length)
+            resolved.push(`${enhancement.additionalConnections.length} connections`);
+        if (enhancement.databases?.length)
+            resolved.push(`${enhancement.databases.length} databases`);
+        if (enhancement.externalServices?.length)
+            resolved.push(`${enhancement.externalServices.length} external services`);
+        if (enhancement.flows?.length)
+            resolved.push(`${enhancement.flows.length} flows`);
+        if (enhancement.primaryLanguage)
+            resolved.push(`language=${enhancement.primaryLanguage}`);
+        if (resolved.length > 0) {
+            onProgress?.(`LLM resolved: ${resolved.join(", ")}`);
+        }
+        // Merge enhancement into analysis
+        return mergeEnhancement(analysis, enhancement);
+    }
+    catch (err) {
+        onProgress?.(`LLM enhancement failed: ${err instanceof Error ? err.message : String(err)}`);
+        return analysis;
+    }
+}
+function mergeEnhancement(analysis, enhancement) {
+    // Clone to avoid mutation
+    const result = structuredClone(analysis);
+    // Project description: LLM wins if longer
+    if (enhancement.projectDescription &&
+        enhancement.projectDescription.length > (result.docs.projectDescription?.length ?? 0)) {
+        result.docs.projectDescription = enhancement.projectDescription;
+    }
+    // Primary language: LLM fills if unknown
+    if (enhancement.primaryLanguage && result.structure.language === "unknown") {
+        result.structure.language = enhancement.primaryLanguage;
+    }
+    // Component descriptions: LLM wins if longer than static
+    if (enhancement.componentDescriptions) {
+        for (const comp of result.components.components) {
+            const llmDesc = enhancement.componentDescriptions[comp.id];
+            if (llmDesc && llmDesc.length > (comp.description?.length ?? 0)) {
+                comp.description = llmDesc;
+            }
+        }
+    }
+    // Component type corrections: LLM can fix mistyped components
+    if (enhancement.componentTypeCorrections) {
+        for (const comp of result.components.components) {
+            const corrected = enhancement.componentTypeCorrections[comp.id];
+            if (corrected) {
+                comp.type = corrected;
+            }
+        }
+    }
+    // Additional connections: deduplicate against existing
+    if (enhancement.additionalConnections) {
+        const existingKeys = new Set(result.connections.connections.map((c) => `${c.from}::${c.to}::${c.type}`));
+        for (const conn of enhancement.additionalConnections) {
+            const key = `${conn.from}::${conn.to}::${conn.type}`;
+            if (!existingKeys.has(key)) {
+                existingKeys.add(key);
+                result.connections.connections.push({
+                    from: conn.from,
+                    to: conn.to,
+                    type: conn.type,
+                    description: conn.description,
+                    confidence: 70, // LLM-inferred = lower confidence
+                    async: false,
+                });
+            }
+        }
+    }
+    // Databases: store on the result for buildAnalysisFromStatic to pick up
+    if (enhancement.databases && enhancement.databases.length > 0) {
+        // Store as components with type="database" and layer="data"
+        for (const db of enhancement.databases) {
+            const exists = result.components.components.some((c) => c.id === db.id);
+            if (!exists) {
+                result.components.components.push({
+                    id: db.id,
+                    name: db.name,
+                    type: "database",
+                    layer: "data",
+                    path: "",
+                    description: db.description,
+                    technologies: [db.type],
+                });
+                // Add connections from components that use this database
+                for (const userId of db.usedBy) {
+                    result.connections.connections.push({
+                        from: userId,
+                        to: db.id,
+                        type: "database",
+                        description: `${userId} uses ${db.name}`,
+                        confidence: 70,
+                        async: false,
+                    });
+                }
+            }
+        }
+    }
+    // External services: store as components with layer="external"
+    if (enhancement.externalServices && enhancement.externalServices.length > 0) {
+        for (const svc of enhancement.externalServices) {
+            const exists = result.components.components.some((c) => c.id === svc.id);
+            if (!exists) {
+                result.components.components.push({
+                    id: svc.id,
+                    name: svc.name,
+                    type: "service",
+                    layer: "external",
+                    path: "",
+                    description: svc.description,
+                    technologies: [svc.type],
+                });
+                // Add connections from components that use this service
+                for (const userId of svc.usedBy) {
+                    result.connections.connections.push({
+                        from: userId,
+                        to: svc.id,
+                        type: "http",
+                        description: `${userId} uses ${svc.name}`,
+                        confidence: 70,
+                        async: false,
+                    });
+                }
+            }
+        }
+    }
+    // Flows: LLM provides these (static has none)
+    if (enhancement.flows && enhancement.flows.length > 0) {
+        result.connections.flows = enhancement.flows.map((f) => ({
+            name: f.name,
+            description: f.description,
+            steps: f.steps,
+        }));
+    }
+    return result;
+}

package/dist/agents/llm/prompt-builder.d.ts

@@ -0,0 +1,3 @@
+import type { StaticAnalysisResult } from "../static/types.js";
+export declare function buildSystemPrompt(): string;
+export declare function buildUserPrompt(analysis: StaticAnalysisResult, projectRoot: string): Promise<string>;

package/dist/agents/llm/prompt-builder.js

@@ -0,0 +1,251 @@
+// LLM Enhancement — Prompt Builder
+// Builds a structured prompt from static analysis results + gaps + docs + key file excerpts
+import { LocalFSBackend } from "../tools/local-fs.js";
+const MAX_FILE_LINES = 100;
+const MAX_FILE_EXCERPTS = 8;
+export function buildSystemPrompt() {
+    return `You are an architecture analysis assistant. You will receive:
+1. Static analysis results for a software project (components, connections, infrastructure)
+2. Documentation context (architecture notes, API endpoints, external dependencies)
+3. **Gaps** — specific questions the static analyzer couldn't resolve
+
+Your job is to:
+1. **Resolve the gaps** — answer each question using the provided context
+2. **Enhance descriptions** for components (1-2 sentences each)
+3. **Add missing connections** between components
+4. **Identify databases and external services** used by the project
+5. **Suggest user flows** — 2-4 key end-to-end flows through the system
+
+## Rules
+- Respond with ONLY valid JSON matching the schema below. No markdown, no explanation.
+- Component IDs in connections MUST match the provided component IDs exactly.
+- Only add connections you are confident about (>80% confidence).
+- Don't repeat connections that already exist.
+- Keep descriptions concise (1-2 sentences max).
+- For databases/externalServices, the "usedBy" array must contain valid component IDs.
+- Flow steps format: "ComponentName → ComponentName" (use the component names, not IDs).
+
+## JSON Schema
+{
+  "projectDescription": "string — 1-2 sentence project description",
+  "primaryLanguage": "string — primary programming language (e.g. TypeScript, Python, Rust, Go)",
+  "componentDescriptions": { "component-id": "description string" },
+  "componentTypeCorrections": { "component-id": "corrected-type (frontend|api|service|cli|library|database|gateway|worker)" },
+  "additionalConnections": [
+    { "from": "component-id", "to": "component-id", "type": "http|import|database|queue|event|grpc|websocket", "description": "string" }
+  ],
+  "databases": [
+    { "id": "slug-id", "name": "Display Name", "type": "postgresql|mysql|mongodb|redis|sqlite", "description": "string", "usedBy": ["component-id"] }
+  ],
+  "externalServices": [
+    { "id": "slug-id", "name": "Display Name", "type": "api|auth|storage|analytics|payment|ai|maps|messaging", "description": "string", "usedBy": ["component-id"] }
+  ],
+  "flows": [
+    { "name": "Flow Name", "description": "string", "steps": ["ComponentA → ComponentB", "ComponentB → ComponentC"] }
+  ]
+}
+
+Only include fields where you have meaningful additions. Omit empty arrays/objects.`;
+}
+export async function buildUserPrompt(analysis, projectRoot) {
+    const parts = [];
+    // Project summary
+    parts.push("## Project Summary");
+    parts.push(`Name: ${analysis.structure.projectName}`);
+    parts.push(`Language: ${analysis.structure.language}${analysis.structure.languages.length > 1 ? ` (also: ${analysis.structure.languages.join(", ")})` : ""}`);
+    parts.push(`Framework: ${analysis.structure.framework ?? "none"}`);
+    parts.push(`Monorepo: ${analysis.structure.isMonorepo}${analysis.structure.monorepoTool ? ` (${analysis.structure.monorepoTool})` : ""}`);
+    parts.push(`Package Manager: ${analysis.structure.packageManager ?? "unknown"}`);
+    if (analysis.docs.projectDescription) {
+        parts.push(`Description: ${analysis.docs.projectDescription.slice(0, 300)}`);
+    }
+    parts.push("");
+    // Components with IDs
+    parts.push("## Components (valid IDs for connections)");
+    for (const c of analysis.components.components) {
+        parts.push(`- **${c.id}** (type=${c.type}, layer=${c.layer}): ${c.name} @ \`${c.path}\``);
+        if (c.technologies.length > 0) {
+            parts.push(`  Tech: ${c.technologies.join(", ")}`);
+        }
+        if (c.description) {
+            parts.push(`  Desc: ${c.description.slice(0, 200)}`);
+        }
+    }
+    parts.push("");
+    // Existing connections
+    if (analysis.connections.connections.length > 0) {
+        parts.push("## Existing Connections (do NOT repeat these)");
+        for (const c of analysis.connections.connections) {
+            parts.push(`- ${c.from} → ${c.to} (${c.type}): ${c.description}`);
+        }
+        parts.push("");
+    }
+    // Infrastructure — Docker
+    if (analysis.infra.docker.composeFile) {
+        parts.push("## Docker Compose Services");
+        if (analysis.infra.docker.composeFilePath) {
+            parts.push(`Located in: ${analysis.infra.docker.composeFilePath}/`);
+        }
+        for (const s of analysis.infra.docker.services) {
+            const details = [];
+            if (s.image)
+                details.push(`image=${s.image}`);
+            if (s.buildContext)
+                details.push(`build=${s.buildContext}`);
+            if (s.ports?.length)
+                details.push(`ports=${s.ports.join(",")}`);
+            if (s.dependsOn?.length)
+                details.push(`depends_on=[${s.dependsOn.join(",")}]`);
+            parts.push(`- **${s.name}**: ${details.join(", ")}`);
+            if (s.environment && Object.keys(s.environment).length > 0) {
+                const envVars = Object.entries(s.environment)
+                    .slice(0, 5)
+                    .map(([k, v]) => `${k}=${v?.slice(0, 60) ?? ""}`)
+                    .join(", ");
+                parts.push(`  Env: ${envVars}`);
+            }
+        }
+        parts.push("");
+    }
+    // Infrastructure — Kubernetes
+    if (analysis.infra.kubernetes.resources.length > 0) {
+        parts.push("## Kubernetes Resources");
+        for (const r of analysis.infra.kubernetes.resources.slice(0, 15)) {
+            parts.push(`- ${r.kind}: ${r.name}${r.namespace ? ` (ns: ${r.namespace})` : ""}`);
+        }
+        parts.push("");
+    }
+    // Infrastructure — Cloud
+    if (analysis.infra.cloud.provider) {
+        parts.push(`## Cloud: ${analysis.infra.cloud.provider}`);
+        if (analysis.infra.cloud.iac)
+            parts.push(`IaC: ${analysis.infra.cloud.iac}`);
+        if (analysis.infra.cloud.services.length > 0) {
+            parts.push(`Services: ${analysis.infra.cloud.services.join(", ")}`);
+        }
+        parts.push("");
+    }
+    // CI/CD
+    if (analysis.infra.ci.platform) {
+        parts.push(`## CI/CD: ${analysis.infra.ci.platform}`);
+        if (analysis.infra.ci.pipelines.length > 0) {
+            parts.push(`Pipelines: ${analysis.infra.ci.pipelines.join(", ")}`);
+        }
+        parts.push("");
+    }
+    // Event-driven patterns
+    if (analysis.events.hasEDA) {
+        parts.push("## Event-Driven Patterns");
+        for (const p of analysis.events.patterns) {
+            parts.push(`- ${p.technology} (${p.dependency})`);
+        }
+        if (analysis.events.events.length > 0) {
+            parts.push("Event usage:");
+            for (const e of analysis.events.events.slice(0, 8)) {
+                parts.push(`  - ${e.type} in ${e.file}: ${e.pattern}`);
+            }
+        }
+        parts.push("");
+    }
+    // Documentation context — architecture notes
+    if (analysis.docs.architectureNotes.length > 0) {
+        parts.push("## Architecture Notes (from documentation)");
+        for (const note of analysis.docs.architectureNotes.slice(0, 20)) {
+            parts.push(`- ${note}`);
+        }
+        parts.push("");
+    }
+    // Documentation context — API endpoints
+    if (analysis.docs.apiEndpoints.length > 0) {
+        parts.push("## API Endpoints (from docs/OpenAPI)");
+        for (const ep of analysis.docs.apiEndpoints.slice(0, 15)) {
+            parts.push(`- ${ep.method} ${ep.path}: ${ep.description}`);
+        }
+        parts.push("");
+    }
+    // Documentation context — external dependencies
+    if (analysis.docs.externalDependencies.length > 0) {
+        parts.push("## External Dependencies (mentioned in docs)");
+        parts.push(analysis.docs.externalDependencies.join(", "));
+        parts.push("");
+    }
+    // Environments
+    if (analysis.envs.environments.length > 0) {
+        parts.push("## Environments");
+        for (const env of analysis.envs.environments) {
+            parts.push(`- ${env.name}: ${env.variables.slice(0, 5).join(", ")}${env.variables.length > 5 ? ` (+${env.variables.length - 5} more)` : ""}`);
+        }
+        parts.push("");
+    }
+    // === GAPS — the key section ===
+    if (analysis.gaps.length > 0) {
+        parts.push("## ⚠ Gaps to Resolve");
+        parts.push("The static analyzer identified the following uncertainties. Please resolve as many as possible:");
+        parts.push("");
+        for (let i = 0; i < analysis.gaps.length; i++) {
+            const gap = analysis.gaps[i];
+            parts.push(`### Gap ${i + 1}: ${gap.category}`);
+            parts.push(gap.description);
+            if (gap.context) {
+                parts.push(`Context: ${JSON.stringify(gap.context)}`);
+            }
+            parts.push("");
+        }
+    }
+    // Key file excerpts
+    parts.push("## Key File Excerpts");
+    const excerpts = await getKeyFileExcerpts(analysis, projectRoot);
+    for (const { file, content } of excerpts) {
+        parts.push(`### ${file}`);
+        parts.push("```");
+        parts.push(content);
+        parts.push("```");
+        parts.push("");
+    }
+    return parts.join("\n");
+}
+async function getKeyFileExcerpts(analysis, projectRoot) {
+    const fs = new LocalFSBackend(projectRoot);
+    const excerpts = [];
+    const candidateFiles = [];
+    // Entry points
+    for (const ep of analysis.structure.entryPoints) {
+        candidateFiles.push(ep);
+    }
+    // Main index/app files for each component
+    for (const comp of analysis.components.components) {
+        if (comp.path === ".")
+            continue;
+        candidateFiles.push(`${comp.path}/src/index.ts`, `${comp.path}/src/index.js`, `${comp.path}/src/main.ts`, `${comp.path}/src/main.rs`, `${comp.path}/src/app.ts`, `${comp.path}/src/app.py`, `${comp.path}/main.py`, `${comp.path}/index.ts`, `${comp.path}/index.js`, `${comp.path}/Cargo.toml`, `${comp.path}/pyproject.toml`);
+    }
+    // Docker compose (check subdirectories too)
+    candidateFiles.push("docker-compose.yml", "docker-compose.yaml", "compose.yml");
+    if (analysis.infra.docker.composeFilePath) {
+        const dir = analysis.infra.docker.composeFilePath;
+        candidateFiles.push(`${dir}/docker-compose.yml`, `${dir}/docker-compose.yaml`, `${dir}/compose.yml`);
+    }
+    // Root package.json
+    candidateFiles.push("package.json");
+    // Deduplicate
+    const seen = new Set();
+    const uniqueCandidates = candidateFiles.filter((f) => {
+        if (seen.has(f))
+            return false;
+        seen.add(f);
+        return true;
+    });
+    // Try each candidate, take first N that exist
+    for (const file of uniqueCandidates) {
+        if (excerpts.length >= MAX_FILE_EXCERPTS)
+            break;
+        try {
+            const content = await fs.readFile(file);
+            const lines = content.split("\n").slice(0, MAX_FILE_LINES);
+            excerpts.push({ file, content: lines.join("\n") });
+        }
+        catch {
+            // File doesn't exist, skip
+        }
+    }
+    return excerpts;
+}

package/dist/agents/llm/response-parser.d.ts

@@ -0,0 +1,6 @@
+import type { LLMEnhancement } from "./types.js";
+/**
+ * Parse LLM response with 4 fallback strategies.
+ * Returns null if all fail (static results used unchanged).
+ */
+export declare function parseLLMResponse(raw: string, validComponentIds: Set<string>): LLMEnhancement | null;

package/dist/agents/llm/response-parser.js

@@ -0,0 +1,174 @@
+// LLM Enhancement — Response Parser
+// 4-strategy JSON extraction + ID validation
+/**
+ * Parse LLM response with 4 fallback strategies.
+ * Returns null if all fail (static results used unchanged).
+ */
+export function parseLLMResponse(raw, validComponentIds) {
+    const parsed = extractJSON(raw);
+    if (!parsed)
+        return null;
+    return validateEnhancement(parsed, validComponentIds);
+}
+function extractJSON(raw) {
+    // Strategy 1: Direct parse
+    try {
+        const obj = JSON.parse(raw);
+        if (typeof obj === "object" && obj !== null)
+            return obj;
+    }
+    catch {
+        // Continue to next strategy
+    }
+    // Strategy 2: Extract from markdown code block
+    const codeBlockMatch = raw.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    if (codeBlockMatch) {
+        try {
+            const obj = JSON.parse(codeBlockMatch[1]);
+            if (typeof obj === "object" && obj !== null)
+                return obj;
+        }
+        catch {
+            // Continue
+        }
+    }
+    // Strategy 3: Extract first {...} block
+    const braceMatch = raw.match(/\{[\s\S]*\}/);
+    if (braceMatch) {
+        try {
+            const obj = JSON.parse(braceMatch[0]);
+            if (typeof obj === "object" && obj !== null)
+                return obj;
+        }
+        catch {
+            // Continue
+        }
+    }
+    // Strategy 4: Return null — static results unchanged
+    return null;
+}
+function validateEnhancement(raw, validIds) {
+    const result = {};
+    // Project description
+    if (typeof raw.projectDescription === "string" && raw.projectDescription.length > 20) {
+        result.projectDescription = raw.projectDescription;
+    }
+    // Primary language
+    if (typeof raw.primaryLanguage === "string" && raw.primaryLanguage.length > 0) {
+        result.primaryLanguage = raw.primaryLanguage;
+    }
+    // Component descriptions
+    if (raw.componentDescriptions && typeof raw.componentDescriptions === "object") {
+        const descs = {};
+        for (const [id, desc] of Object.entries(raw.componentDescriptions)) {
+            if (validIds.has(id) && typeof desc === "string" && desc.length > 0) {
+                descs[id] = desc;
+            }
+        }
+        if (Object.keys(descs).length > 0) {
+            result.componentDescriptions = descs;
+        }
+    }
+    // Component type corrections
+    if (raw.componentTypeCorrections && typeof raw.componentTypeCorrections === "object") {
+        const validTypes = new Set(["frontend", "api", "service", "cli", "library", "database", "gateway", "worker"]);
+        const corrections = {};
+        for (const [id, type] of Object.entries(raw.componentTypeCorrections)) {
+            if (validIds.has(id) && typeof type === "string" && validTypes.has(type)) {
+                corrections[id] = type;
+            }
+        }
+        if (Object.keys(corrections).length > 0) {
+            result.componentTypeCorrections = corrections;
+        }
+    }
+    // Additional connections — validate every from/to
+    if (Array.isArray(raw.additionalConnections)) {
+        const conns = [];
+        for (const c of raw.additionalConnections) {
+            if (typeof c === "object" && c !== null &&
+                typeof c.from === "string" && validIds.has(c.from) &&
+                typeof c.to === "string" && validIds.has(c.to) &&
+                c.from !== c.to &&
+                typeof c.type === "string") {
+                conns.push({
+                    from: c.from,
+                    to: c.to,
+                    type: c.type,
+                    description: typeof c.description === "string" ? c.description : "",
+                });
+            }
+            // Invalid entries silently dropped
+        }
+        if (conns.length > 0) {
+            result.additionalConnections = conns;
+        }
+    }
+    // Databases
+    if (Array.isArray(raw.databases)) {
+        const dbs = [];
+        for (const db of raw.databases) {
+            if (typeof db === "object" && db !== null &&
+                typeof db.id === "string" &&
+                typeof db.name === "string" &&
+                typeof db.type === "string") {
+                const usedBy = Array.isArray(db.usedBy)
+                    ? db.usedBy.filter((id) => validIds.has(id))
+                    : [];
+                dbs.push({
+                    id: db.id,
+                    name: db.name,
+                    type: db.type,
+                    description: typeof db.description === "string" ? db.description : "",
+                    usedBy,
+                });
+            }
+        }
+        if (dbs.length > 0) {
+            result.databases = dbs;
+        }
+    }
+    // External services
+    if (Array.isArray(raw.externalServices)) {
+        const svcs = [];
+        for (const svc of raw.externalServices) {
+            if (typeof svc === "object" && svc !== null &&
+                typeof svc.id === "string" &&
+                typeof svc.name === "string" &&
+                typeof svc.type === "string") {
+                const usedBy = Array.isArray(svc.usedBy)
+                    ? svc.usedBy.filter((id) => validIds.has(id))
+                    : [];
+                svcs.push({
+                    id: svc.id,
+                    name: svc.name,
+                    type: svc.type,
+                    description: typeof svc.description === "string" ? svc.description : "",
+                    usedBy,
+                });
+            }
+        }
+        if (svcs.length > 0) {
+            result.externalServices = svcs;
+        }
+    }
+    // Flows
+    if (Array.isArray(raw.flows)) {
+        const flows = [];
+        for (const f of raw.flows) {
+            if (typeof f === "object" && f !== null &&
+                typeof f.name === "string" &&
+                Array.isArray(f.steps)) {
+                flows.push({
+                    name: f.name,
+                    description: typeof f.description === "string" ? f.description : "",
+                    steps: f.steps.filter((s) => typeof s === "string"),
+                });
+            }
+        }
+        if (flows.length > 0) {
+            result.flows = flows;
+        }
+    }
+    return result;
+}

package/dist/agents/llm/types.d.ts

@@ -0,0 +1,31 @@
+export interface LLMEnhancement {
+    projectDescription?: string;
+    primaryLanguage?: string;
+    componentDescriptions?: Record<string, string>;
+    componentTypeCorrections?: Record<string, string>;
+    additionalConnections?: Array<{
+        from: string;
+        to: string;
+        type: string;
+        description: string;
+    }>;
+    databases?: Array<{
+        id: string;
+        name: string;
+        type: string;
+        description: string;
+        usedBy: string[];
+    }>;
+    externalServices?: Array<{
+        id: string;
+        name: string;
+        type: string;
+        description: string;
+        usedBy: string[];
+    }>;
+    flows?: Array<{
+        name: string;
+        description: string;
+        steps: string[];
+    }>;
+}

package/dist/agents/llm/types.js

@@ -0,0 +1,2 @@
+// LLM Enhancement — Types
+export {};

package/dist/agents/pipeline/agents/component-identifier.d.ts

@@ -0,0 +1,3 @@
+import type { PipelineAgent } from "../types.js";
+import "../../prompt-data.js";
+export declare const componentIdentifier: PipelineAgent;