archbyte 0.1.0

package/dist/agents/runtime/orchestrator.js

@@ -0,0 +1,193 @@
+import { resolveModel } from "./types.js";
+import { AGENT_TOOLS } from "../tools/tool-definitions.js";
+/**
+ * Agent Orchestrator — runs the multi-agent analysis pipeline.
+ *
+ * Phase 1 (parallel): structure-scanner, doc-parser, infra-analyzer,
+ *                      component-detector, event-detector, env-detector
+ * Phase 2 (sequential): connection-mapper (needs Phase 1 results)
+ * Phase 3 (sequential): validator (needs Phase 2 results)
+ */
+export class Orchestrator {
+    agents = [];
+    provider;
+    tools;
+    projectRoot;
+    config;
+    license;
+    constructor(opts) {
+        this.provider = opts.provider;
+        this.tools = opts.tools;
+        this.projectRoot = opts.projectRoot;
+        this.config = opts.config;
+        this.license = opts.license;
+    }
+    register(agent) {
+        this.agents.push(agent);
+    }
+    registerAll(agents) {
+        for (const agent of agents) {
+            this.register(agent);
+        }
+    }
+    async run(onProgress) {
+        const start = Date.now();
+        const results = [];
+        const errors = [];
+        // Filter agents by license tier
+        const allowed = this.agents.filter((a) => this.isAllowed(a));
+        const blocked = this.agents.filter((a) => !this.isAllowed(a));
+        if (blocked.length > 0) {
+            onProgress?.(`Skipping ${blocked.length} premium agent(s) — upgrade to Pro to unlock`);
+        }
+        // Split into phases
+        const parallel = allowed.filter((a) => a.phase === "parallel");
+        const sequential = allowed.filter((a) => a.phase === "sequential");
+        // Phase 1: Run parallel agents
+        onProgress?.(`Running ${parallel.length} agents in parallel...`);
+        const parallelResults = await Promise.allSettled(parallel.map((agent) => this.runAgent(agent, {}, onProgress)));
+        const resultMap = {};
+        for (let i = 0; i < parallel.length; i++) {
+            const result = parallelResults[i];
+            if (result.status === "fulfilled") {
+                results.push(result.value);
+                resultMap[parallel[i].id] = result.value;
+            }
+            else {
+                const errorMsg = result.reason instanceof Error
+                    ? result.reason.message
+                    : String(result.reason);
+                errors.push({ agentId: parallel[i].id, error: errorMsg });
+                onProgress?.(`Agent ${parallel[i].name} failed: ${errorMsg}`);
+            }
+        }
+        // Phase 2+3: Run sequential agents with prior results
+        for (const agent of sequential) {
+            onProgress?.(`Running ${agent.name}...`);
+            try {
+                const result = await this.runAgent(agent, resultMap, onProgress);
+                results.push(result);
+                resultMap[agent.id] = result;
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                errors.push({ agentId: agent.id, error: errorMsg });
+                onProgress?.(`Agent ${agent.name} failed: ${errorMsg}`);
+            }
+        }
+        return {
+            agents: results,
+            totalDuration: Date.now() - start,
+            success: errors.length === 0,
+            errors,
+        };
+    }
+    isAllowed(agent) {
+        if (agent.tier === "free")
+            return true;
+        if (agent.tier === "premium" && this.license.tier === "premium")
+            return true;
+        return false;
+    }
+    async runAgent(agent, priorResults, onProgress) {
+        const model = resolveModel(this.config.provider, agent.modelTier, this.config.modelOverrides);
+        // Create a model-routed provider wrapper
+        const routedProvider = {
+            name: this.provider.name,
+            chat: (params) => this.provider.chat({ ...params, model: params.model ?? model }),
+            stream: (params) => this.provider.stream({ ...params, model: params.model ?? model }),
+        };
+        const context = {
+            llm: routedProvider,
+            tools: this.tools,
+            projectRoot: this.projectRoot,
+            priorResults: Object.keys(priorResults).length > 0 ? priorResults : undefined,
+            onProgress,
+        };
+        onProgress?.(`Starting ${agent.name}...`);
+        const start = Date.now();
+        const result = await agent.run(context);
+        result.duration = Date.now() - start;
+        onProgress?.(`${agent.name} completed in ${result.duration}ms`);
+        return result;
+    }
+}
+/**
+ * Execute a tool_use loop for an agent.
+ * This is the core pattern: send prompt → get tool calls → execute tools → send results → repeat.
+ */
+export async function executeToolLoop(context, systemPrompt, userMessage, maxIterations = 20) {
+    const messages = [{ role: "user", content: userMessage }];
+    for (let i = 0; i < maxIterations; i++) {
+        const response = await context.llm.chat({
+            system: systemPrompt,
+            messages,
+            tools: AGENT_TOOLS,
+            maxTokens: 8192,
+        });
+        // Collect text output
+        const textParts = response.content
+            .filter((b) => b.type === "text")
+            .map((b) => b.text ?? "");
+        // Check for tool calls
+        const toolCalls = response.content.filter((b) => b.type === "tool_use");
+        if (toolCalls.length === 0 || response.stopReason !== "tool_use") {
+            // No more tool calls — return final text
+            return textParts.join("\n");
+        }
+        // Add assistant response to messages
+        messages.push({ role: "assistant", content: response.content });
+        // Execute each tool call and add results
+        const toolResults = [];
+        for (const tc of toolCalls) {
+            const result = await executeTool(context.tools, tc.name, tc.input);
+            context.onProgress?.(`Tool ${tc.name}(${summarizeInput(tc.input)})`);
+            toolResults.push({
+                type: "tool_result",
+                tool_use_id: tc.id,
+                content: result,
+            });
+        }
+        messages.push({ role: "user", content: toolResults });
+    }
+    throw new Error("Agent exceeded maximum tool iterations");
+}
+async function executeTool(tools, name, input) {
+    try {
+        switch (name) {
+            case "read_file": {
+                const content = await tools.readFile(input.path);
+                // Truncate very large files
+                if (content.length > 50000) {
+                    return content.slice(0, 50000) + "\n\n[... truncated, file too large]";
+                }
+                return content;
+            }
+            case "glob": {
+                const files = await tools.glob(input.pattern);
+                return files.join("\n") || "No files found";
+            }
+            case "grep": {
+                const results = await tools.grep(input.pattern, input.path);
+                return (results.map((r) => `${r.file}:${r.line}: ${r.content}`).join("\n") ||
+                    "No matches found");
+            }
+            case "list_dir": {
+                const entries = await tools.listDir(input.path);
+                return entries
+                    .map((e) => `${e.type === "directory" ? "d" : "f"} ${e.name}${e.size ? ` (${e.size}B)` : ""}`)
+                    .join("\n") || "Empty directory";
+            }
+            default:
+                return `Unknown tool: ${name}`;
+        }
+    }
+    catch (err) {
+        return `Error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+function summarizeInput(input) {
+    const val = input.path ?? input.pattern ?? "";
+    const s = String(val);
+    return s.length > 40 ? s.slice(0, 40) + "..." : s;
+}

package/dist/agents/runtime/registry.d.ts

@@ -0,0 +1,23 @@
+import type { ArchByteAgent, AgentTier } from "./types.js";
+/**
+ * Agent Registry — discovers and manages available agents.
+ * Handles tier gating (free vs pro vs enterprise).
+ */
+export declare class AgentRegistry {
+    private agents;
+    register(agent: ArchByteAgent): void;
+    get(id: string): ArchByteAgent | undefined;
+    getAll(): ArchByteAgent[];
+    getByTier(tier: AgentTier): ArchByteAgent[];
+    /**
+     * Get agents that the given license tier can access.
+     * free → only free agents
+     * premium → all agents (free + premium)
+     */
+    getAccessible(licenseTier: AgentTier): ArchByteAgent[];
+    getCoreAgents(): ArchByteAgent[];
+    getPremiumAgents(): ArchByteAgent[];
+    getParallelAgents(licenseTier: AgentTier): ArchByteAgent[];
+    getSequentialAgents(licenseTier: AgentTier): ArchByteAgent[];
+}
+export declare function getRegistry(): AgentRegistry;

package/dist/agents/runtime/registry.js

@@ -0,0 +1,56 @@
+/**
+ * Agent Registry — discovers and manages available agents.
+ * Handles tier gating (free vs pro vs enterprise).
+ */
+export class AgentRegistry {
+    agents = new Map();
+    register(agent) {
+        if (this.agents.has(agent.id)) {
+            throw new Error(`Agent already registered: ${agent.id}`);
+        }
+        this.agents.set(agent.id, agent);
+    }
+    get(id) {
+        return this.agents.get(id);
+    }
+    getAll() {
+        return Array.from(this.agents.values());
+    }
+    getByTier(tier) {
+        return this.getAll().filter((a) => a.tier === tier);
+    }
+    /**
+     * Get agents that the given license tier can access.
+     * free → only free agents
+     * premium → all agents (free + premium)
+     */
+    getAccessible(licenseTier) {
+        return this.getAll().filter((a) => {
+            if (a.tier === "free")
+                return true;
+            if (a.tier === "premium" && licenseTier === "premium")
+                return true;
+            return false;
+        });
+    }
+    getCoreAgents() {
+        return this.getByTier("free");
+    }
+    getPremiumAgents() {
+        return this.getByTier("premium");
+    }
+    getParallelAgents(licenseTier) {
+        return this.getAccessible(licenseTier).filter((a) => a.phase === "parallel");
+    }
+    getSequentialAgents(licenseTier) {
+        return this.getAccessible(licenseTier).filter((a) => a.phase === "sequential");
+    }
+}
+// Singleton registry
+let globalRegistry = null;
+export function getRegistry() {
+    if (!globalRegistry) {
+        globalRegistry = new AgentRegistry();
+    }
+    return globalRegistry;
+}

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

@@ -0,0 +1,117 @@
+export interface Message {
+    role: "user" | "assistant";
+    content: string | ContentBlock[];
+}
+export interface ContentBlock {
+    type: "text" | "tool_use" | "tool_result";
+    text?: string;
+    id?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+    tool_use_id?: string;
+    content?: string;
+    is_error?: boolean;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}
+export interface ChatParams {
+    model?: string;
+    system: string;
+    messages: Message[];
+    tools?: ToolDefinition[];
+    maxTokens?: number;
+}
+export interface LLMResponse {
+    content: ContentBlock[];
+    stopReason: "end_turn" | "tool_use" | "max_tokens" | "stop_sequence";
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+export interface LLMChunk {
+    type: "text" | "tool_use_start" | "tool_use_input" | "done";
+    text?: string;
+    toolName?: string;
+    toolId?: string;
+    input?: string;
+}
+export type ModelTier = "fast" | "standard" | "advanced";
+export interface LLMProvider {
+    name: string;
+    chat(params: ChatParams): Promise<LLMResponse>;
+    stream(params: ChatParams): AsyncIterable<LLMChunk>;
+}
+export interface GrepResult {
+    file: string;
+    line: number;
+    content: string;
+}
+export interface DirEntry {
+    name: string;
+    type: "file" | "directory";
+    size?: number;
+}
+export interface ToolBackend {
+    readFile(path: string): Promise<string>;
+    glob(pattern: string, cwd?: string): Promise<string[]>;
+    grep(pattern: string, path?: string): Promise<GrepResult[]>;
+    listDir(path: string): Promise<DirEntry[]>;
+}
+export type AgentTier = "free" | "premium";
+export type AgentPhase = "parallel" | "sequential";
+export type ToolName = "read_file" | "glob" | "grep" | "list_dir";
+export interface AgentContext {
+    llm: LLMProvider;
+    tools: ToolBackend;
+    projectRoot: string;
+    priorResults?: Record<string, AgentResult>;
+    onProgress?: (msg: string) => void;
+}
+export interface AgentResult {
+    agentId: string;
+    data: unknown;
+    confidence: number;
+    duration: number;
+}
+export interface ArchByteAgent {
+    id: string;
+    name: string;
+    description: string;
+    tier: AgentTier;
+    phase: AgentPhase;
+    modelTier: ModelTier;
+    systemPrompt: string;
+    requiredTools: ToolName[];
+    run(context: AgentContext): Promise<AgentResult>;
+}
+export interface License {
+    tier: AgentTier | "none";
+    userId: string;
+    email: string;
+    scansUsed: number;
+    scansAllowed: number;
+    expiresAt: string;
+    isValid: boolean;
+}
+export type ProviderName = "anthropic" | "openai" | "google" | "ollama";
+export interface ArchByteConfig {
+    provider: ProviderName;
+    apiKey: string;
+    modelOverrides?: Partial<Record<ModelTier, string>>;
+    ollamaBaseUrl?: string;
+}
+export interface PipelineResult {
+    agents: AgentResult[];
+    totalDuration: number;
+    success: boolean;
+    errors: Array<{
+        agentId: string;
+        error: string;
+    }>;
+}
+export declare const MODEL_MAP: Record<ProviderName, Record<ModelTier, string>>;
+export declare function resolveModel(provider: ProviderName, tier: ModelTier, overrides?: Partial<Record<ModelTier, string>>): string;

package/dist/agents/runtime/types.js

@@ -0,0 +1,29 @@
+// ArchByte Agent Framework — Core Types
+// === Model Routing ===
+export const MODEL_MAP = {
+    anthropic: {
+        fast: "claude-haiku-4-5-20251001",
+        standard: "claude-sonnet-4-5-20250929",
+        advanced: "claude-opus-4-6",
+    },
+    openai: {
+        fast: "gpt-4o-mini",
+        standard: "gpt-4o",
+        advanced: "o3",
+    },
+    google: {
+        fast: "gemini-2.0-flash",
+        standard: "gemini-2.5-pro",
+        advanced: "gemini-2.5-pro",
+    },
+    ollama: {
+        fast: "llama3.2",
+        standard: "llama3.3",
+        advanced: "llama3.3",
+    },
+};
+export function resolveModel(provider, tier, overrides) {
+    if (overrides?.[tier])
+        return overrides[tier];
+    return MODEL_MAP[provider][tier];
+}

package/dist/agents/static/code-sampler.d.ts

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

package/dist/agents/static/code-sampler.js

@@ -0,0 +1,153 @@
+// Static Analysis — Code Sampler
+// Collects key file excerpts, import graph, and config files for LLM context
+const MAX_EXCERPT_LINES = 80;
+const MAX_IMPORT_GREP = 500;
+const MAX_ROUTE_GREP = 100;
+/** Config file names to look for at the project root and in workspace dirs */
+const CONFIG_FILES = [
+    "package.json",
+    "docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml",
+    "Cargo.toml", "go.mod", "pyproject.toml", "requirements.txt",
+    "Makefile", "Dockerfile",
+    "tsconfig.json", "vite.config.ts", "vite.config.js",
+    "next.config.js", "next.config.ts", "next.config.mjs",
+    "nest-cli.json", "angular.json",
+];
+/** Common entry point filenames */
+const ENTRY_POINTS = [
+    "src/index.ts", "src/index.js", "src/main.ts", "src/main.js",
+    "src/app.ts", "src/app.js", "src/server.ts", "src/server.js",
+    "index.ts", "index.js", "main.ts", "main.js",
+    "app.ts", "app.js", "server.ts", "server.js",
+    "main.py", "app.py", "manage.py",
+    "main.go", "cmd/main.go", "cmd/server/main.go",
+    "src/main.rs", "src/lib.rs",
+];
+export async function collectCodeSamples(tk) {
+    const samples = [];
+    const configFiles = [];
+    const importMap = {};
+    // 1. Find workspace directories (dirs with a build config)
+    const rootEntries = await tk.listDir(".");
+    const topDirs = rootEntries
+        .filter((e) => e.type === "directory" && !e.name.startsWith(".") && !isVendored(e.name))
+        .map((e) => e.name);
+    // 2. Collect config files at root level
+    await collectConfigs(tk, ".", configFiles);
+    // 3. Collect config files in top-level directories
+    const configPromises = topDirs.map((dir) => collectConfigs(tk, dir, configFiles));
+    await Promise.all(configPromises);
+    // Also check for sub-workspace dirs (e.g., apps/web, packages/core)
+    const subDirChecks = ["apps", "packages", "services", "libs", "modules", "crates"];
+    for (const parent of subDirChecks) {
+        if (!topDirs.includes(parent))
+            continue;
+        const subEntries = await tk.listDir(parent);
+        const subDirs = subEntries
+            .filter((e) => e.type === "directory" && !e.name.startsWith("."))
+            .map((e) => `${parent}/${e.name}`);
+        await Promise.all(subDirs.map((dir) => collectConfigs(tk, dir, configFiles)));
+    }
+    // 4. Collect entry point excerpts for dirs that have configs
+    const dirsWithConfigs = new Set();
+    for (const cf of configFiles) {
+        const dir = cf.path.includes("/") ? cf.path.substring(0, cf.path.lastIndexOf("/")) : ".";
+        dirsWithConfigs.add(dir);
+    }
+    for (const dir of dirsWithConfigs) {
+        await collectEntryPoint(tk, dir, samples);
+    }
+    // 5. Build import map from grep
+    try {
+        const importResults = await tk.grepFiles("import\\s.*from\\s|require\\(");
+        for (const r of importResults.slice(0, MAX_IMPORT_GREP)) {
+            if (isVendoredPath(r.file))
+                continue;
+            const imported = extractImportPath(r.content);
+            if (imported) {
+                if (!importMap[r.file])
+                    importMap[r.file] = [];
+                importMap[r.file].push(imported);
+            }
+        }
+    }
+    catch {
+        // grep failed, skip import map
+    }
+    // 6. Collect route file samples
+    try {
+        const routeResults = await tk.grepFiles("app\\.(get|post|put|delete|patch|use)\\(|router\\.|@(Get|Post|Put|Delete|Patch)\\(|@app\\.route");
+        const routeFiles = new Set();
+        for (const r of routeResults.slice(0, MAX_ROUTE_GREP)) {
+            if (isVendoredPath(r.file))
+                continue;
+            routeFiles.add(r.file);
+        }
+        // Read first 80 lines of each unique route file (up to 10)
+        let routeCount = 0;
+        for (const filePath of routeFiles) {
+            if (routeCount >= 10)
+                break;
+            if (samples.some((s) => s.path === filePath))
+                continue;
+            const content = await tk.readFileSafe(filePath);
+            if (!content)
+                continue;
+            const excerpt = content.split("\n").slice(0, MAX_EXCERPT_LINES).join("\n");
+            samples.push({ path: filePath, excerpt, category: "route-file" });
+            routeCount++;
+        }
+    }
+    catch {
+        // grep failed, skip route files
+    }
+    return { samples, importMap, configFiles };
+}
+async function collectConfigs(tk, dir, configFiles) {
+    for (const name of CONFIG_FILES) {
+        const filePath = dir === "." ? name : `${dir}/${name}`;
+        const content = await tk.readFileSafe(filePath);
+        if (content) {
+            // Cap config content at 5000 chars to avoid blowing context
+            configFiles.push({
+                path: filePath,
+                content: content.length > 5000 ? content.slice(0, 5000) + "\n... (truncated)" : content,
+            });
+        }
+    }
+}
+async function collectEntryPoint(tk, dir, samples) {
+    for (const ep of ENTRY_POINTS) {
+        const filePath = dir === "." ? ep : `${dir}/${ep}`;
+        if (samples.some((s) => s.path === filePath))
+            continue;
+        const content = await tk.readFileSafe(filePath);
+        if (content) {
+            const excerpt = content.split("\n").slice(0, MAX_EXCERPT_LINES).join("\n");
+            samples.push({ path: filePath, excerpt, category: "entry-point" });
+            return; // one entry point per dir is enough
+        }
+    }
+}
+function extractImportPath(line) {
+    // ES import: import ... from "path"
+    const esMatch = line.match(/from\s+["']([^"']+)["']/);
+    if (esMatch)
+        return esMatch[1];
+    // CommonJS: require("path")
+    const cjsMatch = line.match(/require\(\s*["']([^"']+)["']\s*\)/);
+    if (cjsMatch)
+        return cjsMatch[1];
+    return null;
+}
+const VENDORED = new Set([
+    "node_modules", "dist", "build", ".git", "venv", "__pycache__",
+    "target", "coverage", "vendor", ".next", ".nuxt",
+]);
+function isVendored(name) {
+    return VENDORED.has(name);
+}
+function isVendoredPath(filePath) {
+    const parts = filePath.split("/");
+    return parts.some((p) => VENDORED.has(p));
+}

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

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