archbyte 0.1.0

package/dist/agents/providers/anthropic.js

@@ -0,0 +1,117 @@
+import Anthropic from "@anthropic-ai/sdk";
+export class AnthropicProvider {
+    name = "anthropic";
+    client;
+    constructor(apiKey) {
+        this.client = new Anthropic({ apiKey });
+    }
+    async chat(params) {
+        const response = await this.client.messages.create({
+            model: params.model ?? "claude-sonnet-4-5-20250929",
+            max_tokens: params.maxTokens ?? 8192,
+            system: params.system,
+            messages: params.messages.map((m) => ({
+                role: m.role,
+                content: typeof m.content === "string"
+                    ? m.content
+                    : m.content.map((block) => this.toAnthropicBlock(block)),
+            })),
+            ...(params.tools?.length
+                ? {
+                    tools: params.tools.map((t) => ({
+                        name: t.name,
+                        description: t.description,
+                        input_schema: t.input_schema,
+                    })),
+                }
+                : {}),
+        });
+        return {
+            content: response.content.map((block) => this.fromAnthropicBlock(block)),
+            stopReason: response.stop_reason === "tool_use" ? "tool_use" : "end_turn",
+            usage: {
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+            },
+        };
+    }
+    async *stream(params) {
+        const stream = this.client.messages.stream({
+            model: params.model ?? "claude-sonnet-4-5-20250929",
+            max_tokens: params.maxTokens ?? 8192,
+            system: params.system,
+            messages: params.messages.map((m) => ({
+                role: m.role,
+                content: typeof m.content === "string"
+                    ? m.content
+                    : m.content.map((block) => this.toAnthropicBlock(block)),
+            })),
+            ...(params.tools?.length
+                ? {
+                    tools: params.tools.map((t) => ({
+                        name: t.name,
+                        description: t.description,
+                        input_schema: t.input_schema,
+                    })),
+                }
+                : {}),
+        });
+        for await (const event of stream) {
+            if (event.type === "content_block_delta" &&
+                event.delta.type === "text_delta") {
+                yield { type: "text", text: event.delta.text };
+            }
+            else if (event.type === "content_block_start" &&
+                event.content_block.type === "tool_use") {
+                yield {
+                    type: "tool_use_start",
+                    toolName: event.content_block.name,
+                    toolId: event.content_block.id,
+                };
+            }
+            else if (event.type === "content_block_delta" &&
+                event.delta.type === "input_json_delta") {
+                yield { type: "tool_use_input", input: event.delta.partial_json };
+            }
+            else if (event.type === "message_stop") {
+                yield { type: "done" };
+            }
+        }
+    }
+    toAnthropicBlock(block) {
+        if (block.type === "text") {
+            return { type: "text", text: block.text ?? "" };
+        }
+        if (block.type === "tool_use") {
+            return {
+                type: "tool_use",
+                id: block.id ?? "",
+                name: block.name ?? "",
+                input: block.input ?? {},
+            };
+        }
+        if (block.type === "tool_result") {
+            return {
+                type: "tool_result",
+                tool_use_id: block.tool_use_id ?? "",
+                content: block.content ?? "",
+                is_error: block.is_error,
+            };
+        }
+        return { type: "text", text: "" };
+    }
+    fromAnthropicBlock(block) {
+        if (block.type === "text") {
+            return { type: "text", text: block.text };
+        }
+        if (block.type === "tool_use") {
+            return {
+                type: "tool_use",
+                id: block.id,
+                name: block.name,
+                input: block.input,
+            };
+        }
+        return { type: "text", text: "" };
+    }
+}

package/dist/agents/providers/google.d.ts

@@ -0,0 +1,10 @@
+import type { LLMProvider, ChatParams, LLMResponse, LLMChunk } from "../runtime/types.js";
+export declare class GoogleProvider implements LLMProvider {
+    name: "google";
+    private client;
+    constructor(apiKey: string);
+    chat(params: ChatParams): Promise<LLMResponse>;
+    stream(params: ChatParams): AsyncIterable<LLMChunk>;
+    private toGeminiContents;
+    private toGeminiFunctionDecl;
+}

package/dist/agents/providers/google.js

@@ -0,0 +1,136 @@
+import { GoogleGenerativeAI, SchemaType, } from "@google/generative-ai";
+export class GoogleProvider {
+    name = "google";
+    client;
+    constructor(apiKey) {
+        this.client = new GoogleGenerativeAI(apiKey);
+    }
+    async chat(params) {
+        const model = this.client.getGenerativeModel({
+            model: params.model ?? "gemini-2.5-pro",
+            systemInstruction: params.system,
+            ...(params.tools?.length
+                ? {
+                    tools: [
+                        {
+                            functionDeclarations: params.tools.map((t) => this.toGeminiFunctionDecl(t)),
+                        },
+                    ],
+                }
+                : {}),
+        });
+        const contents = this.toGeminiContents(params.messages);
+        const result = await model.generateContent({ contents });
+        const response = result.response;
+        const content = [];
+        let hasToolCalls = false;
+        for (const candidate of response.candidates ?? []) {
+            for (const part of candidate.content?.parts ?? []) {
+                if (part.text) {
+                    content.push({ type: "text", text: part.text });
+                }
+                if (part.functionCall) {
+                    hasToolCalls = true;
+                    content.push({
+                        type: "tool_use",
+                        id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+                        name: part.functionCall.name,
+                        input: part.functionCall.args ?? {},
+                    });
+                }
+            }
+        }
+        return {
+            content,
+            stopReason: hasToolCalls ? "tool_use" : "end_turn",
+            usage: {
+                inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
+                outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
+            },
+        };
+    }
+    async *stream(params) {
+        const model = this.client.getGenerativeModel({
+            model: params.model ?? "gemini-2.5-pro",
+            systemInstruction: params.system,
+            ...(params.tools?.length
+                ? {
+                    tools: [
+                        {
+                            functionDeclarations: params.tools.map((t) => this.toGeminiFunctionDecl(t)),
+                        },
+                    ],
+                }
+                : {}),
+        });
+        const contents = this.toGeminiContents(params.messages);
+        const result = await model.generateContentStream({ contents });
+        for await (const chunk of result.stream) {
+            for (const candidate of chunk.candidates ?? []) {
+                for (const part of candidate.content?.parts ?? []) {
+                    if (part.text) {
+                        yield { type: "text", text: part.text };
+                    }
+                    if (part.functionCall) {
+                        yield {
+                            type: "tool_use_start",
+                            toolName: part.functionCall.name,
+                            toolId: `call_${Date.now()}`,
+                        };
+                        yield {
+                            type: "tool_use_input",
+                            input: JSON.stringify(part.functionCall.args ?? {}),
+                        };
+                    }
+                }
+            }
+        }
+        yield { type: "done" };
+    }
+    toGeminiContents(messages) {
+        return messages.map((m) => {
+            const parts = [];
+            if (typeof m.content === "string") {
+                parts.push({ text: m.content });
+            }
+            else {
+                for (const block of m.content) {
+                    if (block.type === "text" && block.text) {
+                        parts.push({ text: block.text });
+                    }
+                    if (block.type === "tool_use") {
+                        parts.push({
+                            functionCall: {
+                                name: block.name ?? "",
+                                args: block.input ?? {},
+                            },
+                        });
+                    }
+                    if (block.type === "tool_result") {
+                        parts.push({
+                            functionResponse: {
+                                name: block.tool_use_id ?? "",
+                                response: { result: block.content ?? "" },
+                            },
+                        });
+                    }
+                }
+            }
+            return {
+                role: m.role === "assistant" ? "model" : "user",
+                parts,
+            };
+        });
+    }
+    toGeminiFunctionDecl(tool) {
+        return {
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+                type: SchemaType.OBJECT,
+                properties: (tool.input_schema.properties ?? {}),
+                required: tool.input_schema.required ?? [],
+            },
+        };
+    }
+}

package/dist/agents/providers/ollama.d.ts

@@ -0,0 +1,9 @@
+import type { LLMProvider, ChatParams, LLMResponse, LLMChunk } from "../runtime/types.js";
+export declare class OllamaProvider implements LLMProvider {
+    name: "ollama";
+    private baseUrl;
+    constructor(baseUrl?: string);
+    chat(params: ChatParams): Promise<LLMResponse>;
+    stream(params: ChatParams): AsyncIterable<LLMChunk>;
+    private toOllamaMessage;
+}

package/dist/agents/providers/ollama.js

@@ -0,0 +1,162 @@
+export class OllamaProvider {
+    name = "ollama";
+    baseUrl;
+    constructor(baseUrl = "http://localhost:11434") {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+    }
+    async chat(params) {
+        const messages = [
+            { role: "system", content: params.system },
+            ...params.messages.map((m) => this.toOllamaMessage(m)),
+        ];
+        const body = {
+            model: params.model ?? "llama3.3",
+            messages,
+            stream: false,
+        };
+        if (params.tools?.length) {
+            body.tools = params.tools.map((t) => ({
+                type: "function",
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.input_schema,
+                },
+            }));
+        }
+        const response = await fetch(`${this.baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Ollama error ${response.status}: ${text}`);
+        }
+        const data = (await response.json());
+        const content = [];
+        if (data.message.content) {
+            content.push({ type: "text", text: data.message.content });
+        }
+        let hasToolCalls = false;
+        if (data.message.tool_calls) {
+            hasToolCalls = true;
+            for (const tc of data.message.tool_calls) {
+                content.push({
+                    type: "tool_use",
+                    id: tc.id ?? `call_${Date.now()}`,
+                    name: tc.function.name,
+                    input: JSON.parse(tc.function.arguments),
+                });
+            }
+        }
+        return {
+            content,
+            stopReason: hasToolCalls ? "tool_use" : "end_turn",
+            usage: {
+                inputTokens: data.prompt_eval_count ?? 0,
+                outputTokens: data.eval_count ?? 0,
+            },
+        };
+    }
+    async *stream(params) {
+        const messages = [
+            { role: "system", content: params.system },
+            ...params.messages.map((m) => this.toOllamaMessage(m)),
+        ];
+        const body = {
+            model: params.model ?? "llama3.3",
+            messages,
+            stream: true,
+        };
+        if (params.tools?.length) {
+            body.tools = params.tools.map((t) => ({
+                type: "function",
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.input_schema,
+                },
+            }));
+        }
+        const response = await fetch(`${this.baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Ollama error ${response.status}: ${text}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error("No response body");
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                const data = JSON.parse(line);
+                if (data.message?.content) {
+                    yield { type: "text", text: data.message.content };
+                }
+                if (data.message?.tool_calls) {
+                    for (const tc of data.message.tool_calls) {
+                        yield {
+                            type: "tool_use_start",
+                            toolName: tc.function.name,
+                            toolId: tc.id ?? `call_${Date.now()}`,
+                        };
+                        yield { type: "tool_use_input", input: tc.function.arguments };
+                    }
+                }
+                if (data.done) {
+                    yield { type: "done" };
+                }
+            }
+        }
+    }
+    toOllamaMessage(m) {
+        if (typeof m.content === "string") {
+            return { role: m.role, content: m.content };
+        }
+        const toolResults = m.content.filter((b) => b.type === "tool_result");
+        if (toolResults.length > 0) {
+            return {
+                role: "tool",
+                content: toolResults[0].content ?? "",
+                tool_call_id: toolResults[0].tool_use_id,
+            };
+        }
+        const toolUses = m.content.filter((b) => b.type === "tool_use");
+        if (toolUses.length > 0) {
+            const text = m.content
+                .filter((b) => b.type === "text")
+                .map((b) => b.text ?? "")
+                .join("");
+            return {
+                role: "assistant",
+                content: text,
+                tool_calls: toolUses.map((b) => ({
+                    id: b.id ?? "",
+                    type: "function",
+                    function: {
+                        name: b.name ?? "",
+                        arguments: JSON.stringify(b.input ?? {}),
+                    },
+                })),
+            };
+        }
+        return {
+            role: m.role,
+            content: m.content.map((b) => b.text ?? "").join(""),
+        };
+    }
+}

package/dist/agents/providers/openai.d.ts

@@ -0,0 +1,9 @@
+import type { LLMProvider, ChatParams, LLMResponse, LLMChunk } from "../runtime/types.js";
+export declare class OpenAIProvider implements LLMProvider {
+    name: "openai";
+    private client;
+    constructor(apiKey: string);
+    chat(params: ChatParams): Promise<LLMResponse>;
+    stream(params: ChatParams): AsyncIterable<LLMChunk>;
+    private toOpenAIMessage;
+}

package/dist/agents/providers/openai.js

@@ -0,0 +1,142 @@
+import OpenAI from "openai";
+export class OpenAIProvider {
+    name = "openai";
+    client;
+    constructor(apiKey) {
+        this.client = new OpenAI({ apiKey });
+    }
+    async chat(params) {
+        const messages = [
+            { role: "system", content: params.system },
+            ...params.messages.map((m) => this.toOpenAIMessage(m)),
+        ];
+        const response = await this.client.chat.completions.create({
+            model: params.model ?? "gpt-4o",
+            max_tokens: params.maxTokens ?? 8192,
+            messages,
+            ...(params.tools?.length
+                ? {
+                    tools: params.tools.map((t) => ({
+                        type: "function",
+                        function: {
+                            name: t.name,
+                            description: t.description,
+                            parameters: t.input_schema,
+                        },
+                    })),
+                }
+                : {}),
+        });
+        const choice = response.choices[0];
+        const content = [];
+        if (choice.message.content) {
+            content.push({ type: "text", text: choice.message.content });
+        }
+        if (choice.message.tool_calls) {
+            for (const tc of choice.message.tool_calls) {
+                const fn = tc.function;
+                content.push({
+                    type: "tool_use",
+                    id: tc.id,
+                    name: fn.name,
+                    input: JSON.parse(fn.arguments),
+                });
+            }
+        }
+        return {
+            content,
+            stopReason: choice.finish_reason === "tool_calls" ? "tool_use" : "end_turn",
+            usage: {
+                inputTokens: response.usage?.prompt_tokens ?? 0,
+                outputTokens: response.usage?.completion_tokens ?? 0,
+            },
+        };
+    }
+    async *stream(params) {
+        const messages = [
+            { role: "system", content: params.system },
+            ...params.messages.map((m) => this.toOpenAIMessage(m)),
+        ];
+        const stream = await this.client.chat.completions.create({
+            model: params.model ?? "gpt-4o",
+            max_tokens: params.maxTokens ?? 8192,
+            messages,
+            stream: true,
+            ...(params.tools?.length
+                ? {
+                    tools: params.tools.map((t) => ({
+                        type: "function",
+                        function: {
+                            name: t.name,
+                            description: t.description,
+                            parameters: t.input_schema,
+                        },
+                    })),
+                }
+                : {}),
+        });
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            if (!delta)
+                continue;
+            if (delta.content) {
+                yield { type: "text", text: delta.content };
+            }
+            if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                    if (tc.function?.name) {
+                        yield {
+                            type: "tool_use_start",
+                            toolName: tc.function.name,
+                            toolId: tc.id ?? "",
+                        };
+                    }
+                    if (tc.function?.arguments) {
+                        yield { type: "tool_use_input", input: tc.function.arguments };
+                    }
+                }
+            }
+            if (chunk.choices[0]?.finish_reason) {
+                yield { type: "done" };
+            }
+        }
+    }
+    toOpenAIMessage(m) {
+        if (typeof m.content === "string") {
+            return { role: m.role, content: m.content };
+        }
+        // Handle tool results — OpenAI uses separate "tool" role messages
+        const toolResults = m.content.filter((b) => b.type === "tool_result");
+        if (toolResults.length > 0) {
+            // Return first tool result as a tool message
+            const tr = toolResults[0];
+            return {
+                role: "tool",
+                tool_call_id: tr.tool_use_id ?? "",
+                content: tr.content ?? "",
+            };
+        }
+        // Handle assistant messages with tool_use
+        const toolUses = m.content.filter((b) => b.type === "tool_use");
+        if (toolUses.length > 0) {
+            const textParts = m.content.filter((b) => b.type === "text");
+            return {
+                role: "assistant",
+                content: textParts.map((b) => b.text ?? "").join("") || null,
+                tool_calls: toolUses.map((b) => ({
+                    id: b.id ?? "",
+                    type: "function",
+                    function: {
+                        name: b.name ?? "",
+                        arguments: JSON.stringify(b.input ?? {}),
+                    },
+                })),
+            };
+        }
+        // Plain text blocks
+        return {
+            role: m.role,
+            content: m.content.map((b) => b.text ?? "").join(""),
+        };
+    }
+}

package/dist/agents/providers/router.d.ts

@@ -0,0 +1,7 @@
+import type { LLMProvider, ArchByteConfig } from "../runtime/types.js";
+export declare function createProvider(config: ArchByteConfig): LLMProvider;
+/**
+ * Auto-detect provider from environment variables.
+ * Checks in order: ARCHBYTE_PROVIDER, then falls back to whichever API key is set.
+ */
+export declare function detectConfig(): ArchByteConfig | null;

package/dist/agents/providers/router.js

@@ -0,0 +1,55 @@
+import { AnthropicProvider } from "./anthropic.js";
+import { OpenAIProvider } from "./openai.js";
+import { GoogleProvider } from "./google.js";
+import { OllamaProvider } from "./ollama.js";
+export function createProvider(config) {
+    switch (config.provider) {
+        case "anthropic":
+            return new AnthropicProvider(config.apiKey);
+        case "openai":
+            return new OpenAIProvider(config.apiKey);
+        case "google":
+            return new GoogleProvider(config.apiKey);
+        case "ollama":
+            return new OllamaProvider(config.ollamaBaseUrl ?? "http://localhost:11434");
+        default:
+            throw new Error(`Unknown provider: ${config.provider}`);
+    }
+}
+/**
+ * Auto-detect provider from environment variables.
+ * Checks in order: ARCHBYTE_PROVIDER, then falls back to whichever API key is set.
+ */
+export function detectConfig() {
+    const explicit = process.env.ARCHBYTE_PROVIDER;
+    const apiKey = process.env.ARCHBYTE_API_KEY;
+    if (explicit && apiKey) {
+        return {
+            provider: explicit,
+            apiKey,
+            ollamaBaseUrl: process.env.OLLAMA_BASE_URL,
+        };
+    }
+    // Auto-detect from known env vars
+    if (process.env.ANTHROPIC_API_KEY) {
+        return { provider: "anthropic", apiKey: process.env.ANTHROPIC_API_KEY };
+    }
+    if (process.env.OPENAI_API_KEY) {
+        return { provider: "openai", apiKey: process.env.OPENAI_API_KEY };
+    }
+    if (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY) {
+        return {
+            provider: "google",
+            apiKey: process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY ?? "",
+        };
+    }
+    // Ollama doesn't need an API key
+    if (explicit === "ollama") {
+        return {
+            provider: "ollama",
+            apiKey: "",
+            ollamaBaseUrl: process.env.OLLAMA_BASE_URL ?? "http://localhost:11434",
+        };
+    }
+    return null;
+}

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

@@ -0,0 +1,34 @@
+import type { ArchByteAgent, AgentContext, LLMProvider, ToolBackend, License, PipelineResult, ArchByteConfig } from "./types.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 declare class Orchestrator {
+    private agents;
+    private provider;
+    private tools;
+    private projectRoot;
+    private config;
+    private license;
+    constructor(opts: {
+        provider: LLMProvider;
+        tools: ToolBackend;
+        projectRoot: string;
+        config: ArchByteConfig;
+        license: License;
+    });
+    register(agent: ArchByteAgent): void;
+    registerAll(agents: ArchByteAgent[]): void;
+    run(onProgress?: (msg: string) => void): Promise<PipelineResult>;
+    private isAllowed;
+    private runAgent;
+}
+/**
+ * Execute a tool_use loop for an agent.
+ * This is the core pattern: send prompt → get tool calls → execute tools → send results → repeat.
+ */
+export declare function executeToolLoop(context: AgentContext, systemPrompt: string, userMessage: string, maxIterations?: number): Promise<string>;