archbyte 0.1.0

package/dist/agents/pipeline/agents/component-identifier.js

@@ -0,0 +1,102 @@
+// Pipeline Agent — Component Identifier
+// Parallel, fast tier: identifies all architecturally significant components
+import { extractJSON } from "../response-parser.js";
+import { getPrompt } from "../../prompts.js";
+import "../../prompt-data.js";
+function formatFileTree(ctx) {
+    // Show directories + key files only (not all 1000+ files) to stay within context limits
+    const lines = [];
+    const MAX_LINES = 300;
+    function walk(entries, indent) {
+        for (const e of entries) {
+            if (lines.length >= MAX_LINES)
+                return;
+            if (e.type === "directory") {
+                const fileCount = e.children?.filter((c) => c.type === "file").length ?? 0;
+                const dirCount = e.children?.filter((c) => c.type === "directory").length ?? 0;
+                lines.push(`${"  ".repeat(indent)}${e.path}/ (${fileCount} files, ${dirCount} dirs)`);
+                if (e.children)
+                    walk(e.children, indent + 1);
+            }
+            else {
+                // Only show key files at top level or config-like files
+                if (indent <= 1 || isKeyFile(e.path)) {
+                    lines.push(`${"  ".repeat(indent)}${e.path}`);
+                }
+            }
+        }
+    }
+    walk(ctx.fileTree.tree, 0);
+    if (lines.length >= MAX_LINES)
+        lines.push("... (truncated)");
+    return lines.join("\n");
+}
+function isKeyFile(path) {
+    const name = path.split("/").pop() ?? "";
+    return /^(package\.json|Cargo\.toml|go\.mod|pyproject\.toml|Dockerfile|docker-compose|compose|Makefile|README|tsconfig|index\.(ts|js)|main\.(ts|js|py|go|rs)|app\.(ts|js|py)|server\.(ts|js))/i.test(name);
+}
+function formatConfigs(ctx) {
+    return ctx.codeSamples.configFiles
+        .map((cf) => `--- ${cf.path} ---\n${cf.content}`)
+        .join("\n\n");
+}
+export const componentIdentifier = {
+    id: "component-identifier",
+    name: "Component Identifier",
+    modelTier: "fast",
+    phase: "parallel",
+    buildPrompt(ctx) {
+        const system = getPrompt("pipeline/component-identifier");
+        const fileTree = formatFileTree(ctx);
+        const configs = formatConfigs(ctx);
+        const structureInfo = [
+            `Project: ${ctx.structure.projectName || "(unknown)"}`,
+            `Language: ${ctx.structure.language}`,
+            `Languages: ${ctx.structure.languages.join(", ") || "none detected"}`,
+            `Framework: ${ctx.structure.framework ?? "none"}`,
+            `Monorepo: ${ctx.structure.isMonorepo} ${ctx.structure.monorepoTool ? `(${ctx.structure.monorepoTool})` : ""}`,
+            `Build: ${ctx.structure.buildSystem ?? "none"}`,
+            `Entry points: ${ctx.structure.entryPoints.join(", ") || "none"}`,
+        ].join("\n");
+        const docNotes = ctx.docs.architectureNotes.length > 0
+            ? `\n\nArchitecture notes from docs:\n${ctx.docs.architectureNotes.join("\n")}`
+            : "";
+        const dockerInfo = ctx.infra.docker.composeFile
+            ? `\n\nDocker Compose services:\n${ctx.infra.docker.services.map((s) => `- ${s.name}${s.image ? ` (image: ${s.image})` : ""}${s.buildContext ? ` (build: ${s.buildContext})` : ""}${s.dependsOn?.length ? ` depends_on: ${s.dependsOn.join(", ")}` : ""}`).join("\n")}`
+            : "";
+        const user = `Analyze this project and identify ALL architecturally significant components.
+
+${structureInfo}
+${docNotes}
+${dockerInfo}
+
+## File Tree (depth 3, ${ctx.fileTree.totalFiles} files, ${ctx.fileTree.totalDirs} dirs)
+${fileTree}
+
+## Configuration Files
+${configs}`;
+        return { system, user };
+    },
+    parseResponse(raw) {
+        const parsed = extractJSON(raw);
+        if (!parsed || !Array.isArray(parsed.components))
+            return null;
+        const components = [];
+        for (const c of parsed.components) {
+            if (typeof c !== "object" || !c)
+                continue;
+            if (typeof c.id !== "string" || typeof c.name !== "string")
+                continue;
+            components.push({
+                id: c.id,
+                name: c.name,
+                type: typeof c.type === "string" ? c.type : "service",
+                layer: typeof c.layer === "string" ? c.layer : "application",
+                path: typeof c.path === "string" ? c.path : "",
+                description: typeof c.description === "string" ? c.description : "",
+                technologies: Array.isArray(c.technologies) ? c.technologies.filter((t) => typeof t === "string") : [],
+            });
+        }
+        return components.length > 0 ? { components } : null;
+    },
+};

package/dist/agents/pipeline/agents/connection-mapper.d.ts

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

package/dist/agents/pipeline/agents/connection-mapper.js

@@ -0,0 +1,126 @@
+// Pipeline Agent — Connection Mapper
+// Sequential, standard tier: maps ALL connections between components
+import { extractJSON } from "../response-parser.js";
+import { getPrompt } from "../../prompts.js";
+import "../../prompt-data.js";
+export const connectionMapper = {
+    id: "connection-mapper",
+    name: "Connection Mapper",
+    modelTier: "standard",
+    phase: "sequential",
+    buildPrompt(ctx, priorResults) {
+        const system = getPrompt("pipeline/connection-mapper");
+        const parts = [];
+        // Components from Phase 1
+        const components = priorResults?.["component-identifier"];
+        if (components?.components) {
+            parts.push("## Components (use these exact IDs)");
+            for (const c of components.components) {
+                parts.push(`- ${c.id}: ${c.name} (type=${c.type}, path=${c.path}, tech=[${(c.technologies || []).join(", ")}])`);
+            }
+        }
+        // Databases and external services from Phase 1
+        const services = priorResults?.["service-describer"];
+        if (services?.databases?.length) {
+            parts.push("\n## Databases");
+            for (const db of services.databases) {
+                parts.push(`- ${db.id}: ${db.name} (${db.type})`);
+            }
+        }
+        if (services?.externalServices?.length) {
+            parts.push("\n## External Services");
+            for (const svc of services.externalServices) {
+                parts.push(`- ${svc.id}: ${svc.name} (${svc.type})`);
+            }
+        }
+        // Event connections from Phase 1
+        const flows = priorResults?.["flow-detector"];
+        if (flows?.eventConnections?.length) {
+            parts.push("\n## Detected Event Patterns");
+            for (const ec of flows.eventConnections) {
+                parts.push(`- ${ec.publisher} → ${ec.subscriber} via ${ec.channel} (${ec.technology})`);
+            }
+        }
+        if (flows?.apiRoutes?.length) {
+            parts.push("\n## Detected API Routes");
+            for (const ar of flows.apiRoutes.slice(0, 30)) {
+                parts.push(`- ${ar.method} ${ar.path} (${ar.handlerFile})`);
+            }
+        }
+        // Import map
+        const importEntries = Object.entries(ctx.codeSamples.importMap);
+        if (importEntries.length > 0) {
+            parts.push(`\n## Import Graph (${importEntries.length} files)`);
+            // Summarize by directory to keep it concise
+            const dirImports = {};
+            for (const [file, imports] of importEntries) {
+                const dir = file.includes("/") ? file.substring(0, file.lastIndexOf("/")) : ".";
+                if (!dirImports[dir])
+                    dirImports[dir] = new Set();
+                for (const imp of imports) {
+                    if (imp.startsWith(".") || imp.startsWith("/"))
+                        continue; // skip relative
+                    dirImports[dir].add(imp);
+                }
+            }
+            for (const [dir, imports] of Object.entries(dirImports)) {
+                if (imports.size > 0) {
+                    parts.push(`  ${dir}/: imports [${[...imports].slice(0, 10).join(", ")}]`);
+                }
+            }
+        }
+        // Docker depends_on
+        if (ctx.infra.docker.composeFile) {
+            const deps = ctx.infra.docker.services
+                .filter((s) => s.dependsOn?.length)
+                .map((s) => `${s.name} → ${s.dependsOn.join(", ")}`);
+            if (deps.length > 0) {
+                parts.push(`\n## Docker depends_on\n${deps.join("\n")}`);
+            }
+        }
+        // Kubernetes resources
+        if (ctx.infra.kubernetes.resources.length > 0) {
+            parts.push("\n## Kubernetes Resources");
+            for (const r of ctx.infra.kubernetes.resources) {
+                parts.push(`- ${r.kind}: ${r.name}${r.namespace ? ` (ns=${r.namespace})` : ""}`);
+            }
+        }
+        return { system, user: parts.join("\n") };
+    },
+    parseResponse(raw) {
+        const parsed = extractJSON(raw);
+        if (!parsed)
+            return null;
+        const result = {
+            connections: [],
+            flows: [],
+        };
+        if (Array.isArray(parsed.connections)) {
+            for (const c of parsed.connections) {
+                if (typeof c === "object" && c &&
+                    typeof c.from === "string" && typeof c.to === "string" &&
+                    c.from !== c.to) {
+                    result.connections.push({
+                        from: c.from,
+                        to: c.to,
+                        type: typeof c.type === "string" ? c.type : "import",
+                        description: typeof c.description === "string" ? c.description : "",
+                        async: typeof c.async === "boolean" ? c.async : false,
+                    });
+                }
+            }
+        }
+        if (Array.isArray(parsed.flows)) {
+            for (const f of parsed.flows) {
+                if (typeof f === "object" && f && typeof f.name === "string") {
+                    result.flows.push({
+                        name: f.name,
+                        description: typeof f.description === "string" ? f.description : "",
+                        steps: Array.isArray(f.steps) ? f.steps.filter((s) => typeof s === "string") : [],
+                    });
+                }
+            }
+        }
+        return result;
+    },
+};

package/dist/agents/pipeline/agents/flow-detector.d.ts

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

package/dist/agents/pipeline/agents/flow-detector.js

@@ -0,0 +1,101 @@
+// Pipeline Agent — Flow Detector
+// Parallel, fast tier: identifies event-driven patterns and API routes
+import { extractJSON } from "../response-parser.js";
+import { getPrompt } from "../../prompts.js";
+import "../../prompt-data.js";
+export const flowDetector = {
+    id: "flow-detector",
+    name: "Flow Detector",
+    modelTier: "fast",
+    phase: "parallel",
+    buildPrompt(ctx) {
+        const system = getPrompt("pipeline/flow-detector");
+        const parts = [];
+        // Event patterns from static scanner
+        if (ctx.events.hasEDA) {
+            parts.push("Event-driven patterns detected:");
+            for (const p of ctx.events.patterns) {
+                parts.push(`  Technology: ${p.technology} (dep: ${p.dependency})`);
+            }
+            parts.push("\nEvent occurrences in code:");
+            for (const e of ctx.events.events.slice(0, 30)) {
+                parts.push(`  [${e.type}] ${e.file}: ${e.pattern}`);
+            }
+        }
+        else {
+            parts.push("No event-driven patterns detected by static scanner.");
+        }
+        // API endpoints from docs
+        if (ctx.docs.apiEndpoints.length > 0) {
+            parts.push(`\nAPI endpoints from docs (${ctx.docs.apiEndpoints.length}):`);
+            for (const ep of ctx.docs.apiEndpoints.slice(0, 20)) {
+                parts.push(`  ${ep.method} ${ep.path} — ${ep.description}`);
+            }
+        }
+        // Route file samples
+        const routeSamples = ctx.codeSamples.samples.filter((s) => s.category === "route-file");
+        if (routeSamples.length > 0) {
+            parts.push("\nRoute file excerpts:");
+            for (const s of routeSamples.slice(0, 5)) {
+                parts.push(`\n--- ${s.path} ---\n${s.excerpt}`);
+            }
+        }
+        // Entry points for context
+        const entrySamples = ctx.codeSamples.samples.filter((s) => s.category === "entry-point");
+        if (entrySamples.length > 0) {
+            parts.push("\nEntry point excerpts:");
+            for (const s of entrySamples.slice(0, 3)) {
+                parts.push(`\n--- ${s.path} ---\n${s.excerpt}`);
+            }
+        }
+        // Docker info for queue/broker identification
+        if (ctx.infra.docker.composeFile) {
+            const queueServices = ctx.infra.docker.services.filter((s) => {
+                const img = (s.image ?? "").toLowerCase();
+                return img.includes("rabbit") || img.includes("kafka") || img.includes("redis") ||
+                    img.includes("nats") || img.includes("pulsar");
+            });
+            if (queueServices.length > 0) {
+                parts.push("\nMessage broker/queue Docker services:");
+                for (const s of queueServices) {
+                    parts.push(`  ${s.name} (image: ${s.image})`);
+                }
+            }
+        }
+        return { system, user: parts.join("\n") };
+    },
+    parseResponse(raw) {
+        const parsed = extractJSON(raw);
+        if (!parsed)
+            return null;
+        const result = {
+            eventConnections: [],
+            apiRoutes: [],
+        };
+        if (Array.isArray(parsed.eventConnections)) {
+            for (const ec of parsed.eventConnections) {
+                if (typeof ec === "object" && ec &&
+                    typeof ec.publisher === "string" && typeof ec.subscriber === "string") {
+                    result.eventConnections.push({
+                        publisher: ec.publisher,
+                        subscriber: ec.subscriber,
+                        channel: typeof ec.channel === "string" ? ec.channel : "",
+                        technology: typeof ec.technology === "string" ? ec.technology : "unknown",
+                    });
+                }
+            }
+        }
+        if (Array.isArray(parsed.apiRoutes)) {
+            for (const ar of parsed.apiRoutes) {
+                if (typeof ar === "object" && ar && typeof ar.path === "string") {
+                    result.apiRoutes.push({
+                        path: ar.path,
+                        method: typeof ar.method === "string" ? ar.method : "GET",
+                        handlerFile: typeof ar.handlerFile === "string" ? ar.handlerFile : "",
+                    });
+                }
+            }
+        }
+        return result;
+    },
+};

package/dist/agents/pipeline/agents/service-describer.d.ts

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

package/dist/agents/pipeline/agents/service-describer.js

@@ -0,0 +1,100 @@
+// Pipeline Agent — Service Describer
+// Parallel, fast tier: identifies project description, primary language, databases, external services
+import { extractJSON } from "../response-parser.js";
+import { getPrompt } from "../../prompts.js";
+import "../../prompt-data.js";
+export const serviceDescriber = {
+    id: "service-describer",
+    name: "Service Describer",
+    modelTier: "fast",
+    phase: "parallel",
+    buildPrompt(ctx) {
+        const system = getPrompt("pipeline/service-describer");
+        const parts = [];
+        // Structure info
+        parts.push(`Project: ${ctx.structure.projectName || "(unknown)"}`);
+        parts.push(`Detected language: ${ctx.structure.language}`);
+        parts.push(`Languages: ${ctx.structure.languages.join(", ") || "none"}`);
+        parts.push(`Framework: ${ctx.structure.framework ?? "none"}`);
+        // Docs
+        if (ctx.docs.projectDescription) {
+            parts.push(`\nFrom docs: ${ctx.docs.projectDescription}`);
+        }
+        if (ctx.docs.externalDependencies.length > 0) {
+            parts.push(`\nExternal dependencies mentioned: ${ctx.docs.externalDependencies.join(", ")}`);
+        }
+        // Docker services
+        if (ctx.infra.docker.composeFile) {
+            const svcInfo = ctx.infra.docker.services.map((s) => {
+                const details = [s.name];
+                if (s.image)
+                    details.push(`image=${s.image}`);
+                if (s.ports?.length)
+                    details.push(`ports=${s.ports.join(",")}`);
+                if (s.environment) {
+                    const envKeys = Object.keys(s.environment).join(", ");
+                    details.push(`env=[${envKeys}]`);
+                }
+                return details.join(" ");
+            });
+            parts.push(`\nDocker services:\n${svcInfo.join("\n")}`);
+        }
+        // Env vars
+        if (ctx.envs.environments.length > 0) {
+            for (const env of ctx.envs.environments) {
+                parts.push(`\nEnv file "${env.name}" variables: ${env.variables.join(", ")}`);
+            }
+        }
+        // Code samples (entry points)
+        const entrySamples = ctx.codeSamples.samples.filter((s) => s.category === "entry-point");
+        if (entrySamples.length > 0) {
+            parts.push("\nEntry point excerpts:");
+            for (const s of entrySamples.slice(0, 5)) {
+                parts.push(`\n--- ${s.path} ---\n${s.excerpt}`);
+            }
+        }
+        // Cloud info
+        if (ctx.infra.cloud.provider) {
+            parts.push(`\nCloud: ${ctx.infra.cloud.provider}, services: ${ctx.infra.cloud.services.join(", ")}`);
+        }
+        return { system, user: parts.join("\n") };
+    },
+    parseResponse(raw) {
+        const parsed = extractJSON(raw);
+        if (!parsed)
+            return null;
+        const result = {
+            projectDescription: typeof parsed.projectDescription === "string" ? parsed.projectDescription : "",
+            primaryLanguage: typeof parsed.primaryLanguage === "string" ? parsed.primaryLanguage : "",
+            databases: [],
+            externalServices: [],
+        };
+        if (Array.isArray(parsed.databases)) {
+            for (const db of parsed.databases) {
+                if (typeof db === "object" && db && typeof db.id === "string" && typeof db.name === "string") {
+                    result.databases.push({
+                        id: db.id,
+                        name: db.name,
+                        type: typeof db.type === "string" ? db.type : "unknown",
+                        description: typeof db.description === "string" ? db.description : "",
+                        usedBy: Array.isArray(db.usedBy) ? db.usedBy.filter((x) => typeof x === "string") : [],
+                    });
+                }
+            }
+        }
+        if (Array.isArray(parsed.externalServices)) {
+            for (const svc of parsed.externalServices) {
+                if (typeof svc === "object" && svc && typeof svc.id === "string" && typeof svc.name === "string") {
+                    result.externalServices.push({
+                        id: svc.id,
+                        name: svc.name,
+                        type: typeof svc.type === "string" ? svc.type : "unknown",
+                        description: typeof svc.description === "string" ? svc.description : "",
+                        usedBy: Array.isArray(svc.usedBy) ? svc.usedBy.filter((x) => typeof x === "string") : [],
+                    });
+                }
+            }
+        }
+        return result;
+    },
+};

package/dist/agents/pipeline/agents/validator.d.ts

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

package/dist/agents/pipeline/agents/validator.js

@@ -0,0 +1,102 @@
+// Pipeline Agent — Validator
+// Sequential, fast tier: validates complete analysis, suggests corrections
+import { extractJSON } from "../response-parser.js";
+import { getPrompt } from "../../prompts.js";
+import "../../prompt-data.js";
+export const validator = {
+    id: "validator",
+    name: "Validator",
+    modelTier: "fast",
+    phase: "sequential",
+    buildPrompt(ctx, priorResults) {
+        const system = getPrompt("pipeline/validator");
+        const parts = [];
+        // Components
+        const components = priorResults?.["component-identifier"];
+        if (components?.components) {
+            parts.push("## Components");
+            for (const c of components.components) {
+                parts.push(`- ${c.id}: ${c.name} (type=${c.type}, layer=${c.layer}, path=${c.path})`);
+                parts.push(`  description: ${c.description || "(none)"}`);
+                parts.push(`  tech: [${(c.technologies || []).join(", ")}]`);
+            }
+        }
+        // Services
+        const services = priorResults?.["service-describer"];
+        if (services?.databases?.length) {
+            parts.push("\n## Databases");
+            for (const db of services.databases) {
+                parts.push(`- ${db.id}: ${db.name} (${db.type}) — ${db.description}`);
+            }
+        }
+        if (services?.externalServices?.length) {
+            parts.push("\n## External Services");
+            for (const svc of services.externalServices) {
+                parts.push(`- ${svc.id}: ${svc.name} (${svc.type}) — ${svc.description}`);
+            }
+        }
+        // Connections
+        const connections = priorResults?.["connection-mapper"];
+        if (connections?.connections) {
+            parts.push("\n## Connections");
+            for (const c of connections.connections) {
+                parts.push(`- ${c.from} → ${c.to} (${c.type}) ${c.async ? "[async]" : ""}: ${c.description}`);
+            }
+        }
+        // Structure context for validation
+        parts.push(`\n## Project Context`);
+        parts.push(`Language: ${ctx.structure.language}`);
+        parts.push(`Framework: ${ctx.structure.framework ?? "none"}`);
+        parts.push(`Monorepo: ${ctx.structure.isMonorepo}`);
+        if (ctx.docs.projectDescription) {
+            parts.push(`Description: ${ctx.docs.projectDescription}`);
+        }
+        return { system, user: parts.join("\n") };
+    },
+    parseResponse(raw) {
+        const parsed = extractJSON(raw);
+        if (!parsed)
+            return null;
+        const result = {
+            componentTypeCorrections: {},
+            componentDescriptions: {},
+            addedConnections: [],
+            removedConnectionKeys: [],
+            confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0.7,
+            issues: Array.isArray(parsed.issues) ? parsed.issues.filter((i) => typeof i === "string") : [],
+        };
+        if (parsed.componentTypeCorrections && typeof parsed.componentTypeCorrections === "object") {
+            for (const [id, type] of Object.entries(parsed.componentTypeCorrections)) {
+                if (typeof type === "string") {
+                    result.componentTypeCorrections[id] = type;
+                }
+            }
+        }
+        if (parsed.componentDescriptions && typeof parsed.componentDescriptions === "object") {
+            for (const [id, desc] of Object.entries(parsed.componentDescriptions)) {
+                if (typeof desc === "string" && desc.length > 0) {
+                    result.componentDescriptions[id] = desc;
+                }
+            }
+        }
+        if (Array.isArray(parsed.addedConnections)) {
+            for (const c of parsed.addedConnections) {
+                if (typeof c === "object" && c &&
+                    typeof c.from === "string" && typeof c.to === "string" &&
+                    c.from !== c.to) {
+                    result.addedConnections.push({
+                        from: c.from,
+                        to: c.to,
+                        type: typeof c.type === "string" ? c.type : "import",
+                        description: typeof c.description === "string" ? c.description : "",
+                        async: typeof c.async === "boolean" ? c.async : false,
+                    });
+                }
+            }
+        }
+        if (Array.isArray(parsed.removedConnectionKeys)) {
+            result.removedConnectionKeys = parsed.removedConnectionKeys.filter((k) => typeof k === "string");
+        }
+        return result;
+    },
+};

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

@@ -0,0 +1,13 @@
+import type { StaticContext } from "../static/types.js";
+import type { StaticAnalysisResult } from "../static/types.js";
+import type { LLMProvider, ArchByteConfig } from "../runtime/types.js";
+/**
+ * Run the multi-agent pipeline: 3 parallel fast agents → 2 sequential agents.
+ * Each agent gets a single chat() call with pre-collected static context.
+ */
+export declare function runPipeline(ctx: StaticContext, provider: LLMProvider, config: ArchByteConfig, onProgress?: (msg: string) => void): Promise<StaticAnalysisResult & {
+    tokenUsage?: {
+        input: number;
+        output: number;
+    };
+}>;