homarus 0.1.0

package/dist/memory-index.js

@@ -0,0 +1,286 @@
+// CRC: crc-MemoryIndex.md | Seq: seq-agent-execution.md
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from "node:fs";
+import { join, dirname, extname } from "node:path";
+import { watch } from "node:fs";
+export class MemoryIndex {
+    db = null; // better-sqlite3 Database
+    embeddingProvider = null;
+    chunkSize;
+    chunkOverlap;
+    vectorWeight;
+    ftsWeight;
+    indexedPaths = [];
+    watcher = null;
+    logger;
+    initialized = false;
+    constructor(logger, options) {
+        this.logger = logger;
+        this.chunkSize = options?.chunkSize ?? 400;
+        this.chunkOverlap = options?.chunkOverlap ?? 80;
+        this.vectorWeight = options?.vectorWeight ?? 0.7;
+        this.ftsWeight = options?.ftsWeight ?? 0.3;
+    }
+    setEmbeddingProvider(provider) {
+        this.embeddingProvider = provider;
+    }
+    // CRC: crc-MemoryIndex.md — initialize()
+    async initialize(dbPath) {
+        // Dynamic import to avoid hard dependency when memory isn't used
+        const Database = (await import("better-sqlite3")).default;
+        this.db = new Database(dbPath);
+        const db = this.db;
+        db.pragma("journal_mode = WAL");
+        // Load sqlite-vec extension if available
+        try {
+            const sqliteVec = await import("sqlite-vec");
+            sqliteVec.load(db);
+        }
+        catch {
+            this.logger.warn("sqlite-vec not available, vector search disabled");
+        }
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS chunks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        path TEXT NOT NULL,
+        chunk_index INTEGER NOT NULL,
+        content TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        UNIQUE(path, chunk_index)
+      );
+      CREATE INDEX IF NOT EXISTS idx_chunks_path ON chunks(path);
+    `);
+        // FTS5 virtual table
+        db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+        content, content='chunks', content_rowid='id'
+      );
+    `);
+        // Triggers to keep FTS in sync
+        db.exec(`
+      CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
+        INSERT INTO chunks_fts(rowid, content) VALUES (new.id, new.content);
+      END;
+      CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
+        INSERT INTO chunks_fts(chunks_fts, rowid, content) VALUES('delete', old.id, old.content);
+      END;
+      CREATE TRIGGER IF NOT EXISTS chunks_au AFTER UPDATE ON chunks BEGIN
+        INSERT INTO chunks_fts(chunks_fts, rowid, content) VALUES('delete', old.id, old.content);
+        INSERT INTO chunks_fts(rowid, content) VALUES (new.id, new.content);
+      END;
+    `);
+        // Vector table (only if sqlite-vec loaded)
+        try {
+            const dims = this.embeddingProvider?.dimensions() ?? 768;
+            db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS chunks_vec USING vec0(
+          chunk_id INTEGER PRIMARY KEY,
+          embedding float[${dims}]
+        );
+      `);
+        }
+        catch {
+            this.logger.debug("Vector table creation skipped");
+        }
+        this.initialized = true;
+        this.logger.info("Memory index initialized", { dbPath });
+    }
+    // CRC: crc-MemoryIndex.md — indexFile()
+    async indexFile(path) {
+        if (!this.initialized || !this.db)
+            return;
+        if (!existsSync(path))
+            return;
+        const content = readFileSync(path, "utf-8");
+        const chunks = this.chunkContent(content, path);
+        const db = this.db;
+        const now = Date.now();
+        // Remove old chunks for this file
+        db.prepare("DELETE FROM chunks WHERE path = ?").run(path);
+        const insert = db.prepare("INSERT INTO chunks (path, chunk_index, content, updated_at) VALUES (?, ?, ?, ?)");
+        const insertMany = db.transaction((items) => {
+            for (const chunk of items) {
+                insert.run(chunk.path, chunk.index, chunk.content, now);
+            }
+        });
+        insertMany(chunks);
+        // Generate and store embeddings
+        if (this.embeddingProvider) {
+            try {
+                const texts = chunks.map((c) => c.content);
+                const embeddings = await this.embeddingProvider.embedBatch(texts);
+                const rows = db.prepare("SELECT id FROM chunks WHERE path = ? ORDER BY chunk_index").all(path);
+                const insertVec = db.prepare("INSERT OR REPLACE INTO chunks_vec (chunk_id, embedding) VALUES (?, ?)");
+                const insertVecs = db.transaction(() => {
+                    for (let i = 0; i < rows.length && i < embeddings.length; i++) {
+                        insertVec.run(rows[i].id, new Float32Array(embeddings[i]));
+                    }
+                });
+                insertVecs();
+            }
+            catch (err) {
+                this.logger.warn("Failed to generate embeddings", { path, error: String(err) });
+            }
+        }
+        this.logger.debug("Indexed file", { path, chunks: chunks.length });
+    }
+    // CRC: crc-MemoryIndex.md — indexDirectory()
+    async indexDirectory(dirPath) {
+        if (!existsSync(dirPath))
+            return;
+        const files = this.findMarkdownFiles(dirPath);
+        for (const file of files) {
+            await this.indexFile(file);
+        }
+        if (!this.indexedPaths.includes(dirPath)) {
+            this.indexedPaths.push(dirPath);
+        }
+        this.logger.info("Indexed directory", { path: dirPath, files: files.length });
+    }
+    // CRC: crc-MemoryIndex.md — search()
+    async search(query, options) {
+        if (!this.initialized || !this.db)
+            return [];
+        const db = this.db;
+        const limit = options?.limit ?? 10;
+        const minScore = options?.minScore ?? 0.3;
+        const results = new Map();
+        // FTS search
+        try {
+            const ftsResults = db.prepare(`
+        SELECT c.id, c.path, c.content, c.chunk_index,
+               bm25(chunks_fts) AS rank
+        FROM chunks_fts f
+        JOIN chunks c ON c.id = f.rowid
+        WHERE chunks_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `).all(query, limit * 2);
+            // Normalize FTS scores to 0-1 range
+            const maxRank = ftsResults.length > 0 ? Math.max(...ftsResults.map((r) => Math.abs(r.rank))) : 1;
+            for (const row of ftsResults) {
+                const normalizedScore = maxRank > 0 ? Math.abs(row.rank) / maxRank : 0;
+                results.set(row.id, {
+                    path: row.path,
+                    content: row.content,
+                    score: normalizedScore * this.ftsWeight,
+                    chunkIndex: row.chunk_index,
+                });
+            }
+        }
+        catch {
+            // FTS query may fail on certain inputs
+        }
+        // Vector search
+        if (this.embeddingProvider) {
+            try {
+                const queryEmb = await this.embeddingProvider.embed(query);
+                const vecResults = db.prepare(`
+          SELECT chunk_id, distance
+          FROM chunks_vec
+          WHERE embedding MATCH ?
+          ORDER BY distance
+          LIMIT ?
+        `).all(new Float32Array(queryEmb), limit * 2);
+                for (const row of vecResults) {
+                    const similarity = 1 - row.distance; // cosine distance → similarity
+                    const existing = results.get(row.chunk_id);
+                    if (existing) {
+                        existing.score += similarity * this.vectorWeight;
+                    }
+                    else {
+                        const chunk = db.prepare("SELECT path, content, chunk_index FROM chunks WHERE id = ?")
+                            .get(row.chunk_id);
+                        if (chunk) {
+                            results.set(row.chunk_id, {
+                                path: chunk.path,
+                                content: chunk.content,
+                                score: similarity * this.vectorWeight,
+                                chunkIndex: chunk.chunk_index,
+                            });
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                this.logger.debug("Vector search failed", { error: String(err) });
+            }
+        }
+        return [...results.values()]
+            .filter((r) => r.score >= minScore)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    // CRC: crc-MemoryIndex.md — get()
+    get(path) {
+        if (!existsSync(path))
+            return undefined;
+        return readFileSync(path, "utf-8");
+    }
+    // CRC: crc-MemoryIndex.md — store()
+    async store(content, path) {
+        const dir = dirname(path);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(path, content);
+        await this.indexFile(path);
+    }
+    // CRC: crc-MemoryIndex.md — startWatching()
+    startWatching() {
+        if (this.watcher)
+            return;
+        for (const dir of this.indexedPaths) {
+            this.watcher = watch(dir, { recursive: true }, (_eventType, filename) => {
+                if (!filename || !filename.endsWith(".md"))
+                    return;
+                const fullPath = join(dir, filename);
+                this.indexFile(fullPath).catch((err) => {
+                    this.logger.warn("Reindex failed", { path: fullPath, error: String(err) });
+                });
+            });
+        }
+    }
+    // CRC: crc-MemoryIndex.md — stopWatching()
+    stopWatching() {
+        this.watcher?.close();
+        this.watcher = null;
+    }
+    // CRC: crc-MemoryIndex.md — getStats()
+    getStats() {
+        if (!this.initialized || !this.db) {
+            return { fileCount: 0, chunkCount: 0, indexedPaths: this.indexedPaths };
+        }
+        const db = this.db;
+        const fileCount = db.prepare("SELECT COUNT(DISTINCT path) AS c FROM chunks").get().c;
+        const chunkCount = db.prepare("SELECT COUNT(*) AS c FROM chunks").get().c;
+        return { fileCount, chunkCount, indexedPaths: this.indexedPaths };
+    }
+    chunkContent(content, path) {
+        const words = content.split(/\s+/);
+        const chunks = [];
+        let i = 0;
+        let index = 0;
+        while (i < words.length) {
+            const end = Math.min(i + this.chunkSize, words.length);
+            const chunkText = words.slice(i, end).join(" ");
+            chunks.push({ path, index, content: chunkText });
+            i += this.chunkSize - this.chunkOverlap;
+            index++;
+        }
+        return chunks;
+    }
+    findMarkdownFiles(dir) {
+        const files = [];
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith(".")) {
+                files.push(...this.findMarkdownFiles(fullPath));
+            }
+            else if (entry.isFile() && extname(entry.name) === ".md") {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
+}
+//# sourceMappingURL=memory-index.js.map

package/dist/model-provider.d.ts

@@ -0,0 +1,33 @@
+import type { ChatRequest, ChatChunk, ModelInfo, AuthProfile, Logger } from "./types.js";
+export declare abstract class ModelProvider {
+    readonly id: string;
+    protected baseUrl: string;
+    protected activeProfile: AuthProfile;
+    protected logger: Logger;
+    constructor(id: string, baseUrl: string, profile: AuthProfile, logger: Logger);
+    abstract chat(request: ChatRequest): AsyncIterable<ChatChunk>;
+    abstract listModels(): Promise<ModelInfo[]>;
+    abstract supportsTools(): boolean;
+    abstract supportsStreaming(): boolean;
+    setProfile(profile: AuthProfile): void;
+    validateAuth(): Promise<boolean>;
+}
+export declare class OpenAICompatibleProvider extends ModelProvider {
+    constructor(id: string, baseUrl: string, profile: AuthProfile, logger: Logger);
+    chat(request: ChatRequest): AsyncIterable<ChatChunk>;
+    listModels(): Promise<ModelInfo[]>;
+    supportsTools(): boolean;
+    supportsStreaming(): boolean;
+    private stripProviderPrefix;
+    private buildRequestBody;
+    private parseChunk;
+}
+export declare class AnthropicProvider extends ModelProvider {
+    constructor(profile: AuthProfile, logger: Logger);
+    chat(request: ChatRequest): AsyncIterable<ChatChunk>;
+    listModels(): Promise<ModelInfo[]>;
+    supportsTools(): boolean;
+    supportsStreaming(): boolean;
+    private parseAnthropicEvent;
+}
+//# sourceMappingURL=model-provider.d.ts.map

package/dist/model-provider.js

@@ -0,0 +1,255 @@
+export class ModelProvider {
+    id;
+    baseUrl;
+    activeProfile;
+    logger;
+    constructor(id, baseUrl, profile, logger) {
+        this.id = id;
+        this.baseUrl = baseUrl;
+        this.activeProfile = profile;
+        this.logger = logger;
+    }
+    setProfile(profile) {
+        this.activeProfile = profile;
+    }
+    async validateAuth() {
+        try {
+            await this.listModels();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+// OpenAI-compatible provider (works for OpenAI, OpenRouter, Ollama, and any compatible endpoint)
+export class OpenAICompatibleProvider extends ModelProvider {
+    constructor(id, baseUrl, profile, logger) {
+        super(id, baseUrl, profile, logger);
+    }
+    async *chat(request) {
+        const body = this.buildRequestBody(request);
+        const response = await fetch(`${this.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.activeProfile.apiKey}`,
+            },
+            body: JSON.stringify({ ...body, stream: true }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`${this.id} API error ${response.status}: ${errorText}`);
+        }
+        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) {
+                const trimmed = line.trim();
+                if (!trimmed.startsWith("data: "))
+                    continue;
+                const data = trimmed.slice(6);
+                if (data === "[DONE]")
+                    return;
+                try {
+                    const parsed = JSON.parse(data);
+                    const chunk = this.parseChunk(parsed);
+                    if (chunk)
+                        yield chunk;
+                }
+                catch {
+                    // skip unparseable chunks
+                }
+            }
+        }
+    }
+    async listModels() {
+        const response = await fetch(`${this.baseUrl}/models`, {
+            headers: { Authorization: `Bearer ${this.activeProfile.apiKey}` },
+        });
+        if (!response.ok)
+            throw new Error(`Failed to list models: ${response.status}`);
+        const data = (await response.json());
+        return data.data.map((m) => ({ id: m.id, name: m.id }));
+    }
+    supportsTools() {
+        return true;
+    }
+    supportsStreaming() {
+        return true;
+    }
+    stripProviderPrefix(model) {
+        // "openrouter/anthropic/claude-sonnet-4-5" → "anthropic/claude-sonnet-4-5"
+        if (model.startsWith(this.id + "/")) {
+            return model.substring(this.id.length + 1);
+        }
+        return model;
+    }
+    buildRequestBody(request) {
+        const body = {
+            model: this.stripProviderPrefix(request.model),
+            messages: request.messages.map((m) => {
+                const msg = { role: m.role, content: m.content };
+                if (m.toolCallId)
+                    msg.tool_call_id = m.toolCallId;
+                if (m.toolCalls)
+                    msg.tool_calls = m.toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: tc.arguments },
+                    }));
+                return msg;
+            }),
+        };
+        if (request.tools?.length) {
+            body.tools = request.tools.map((t) => ({
+                type: "function",
+                function: { name: t.name, description: t.description, parameters: t.parameters },
+            }));
+        }
+        if (request.temperature !== undefined)
+            body.temperature = request.temperature;
+        if (request.maxTokens !== undefined)
+            body.max_tokens = request.maxTokens;
+        return body;
+    }
+    parseChunk(data) {
+        const choices = data.choices;
+        if (!choices?.length)
+            return null;
+        const delta = choices[0].delta;
+        if (!delta)
+            return null;
+        const chunk = {};
+        if (typeof delta.content === "string")
+            chunk.content = delta.content;
+        if (choices[0].finish_reason)
+            chunk.finishReason = choices[0].finish_reason;
+        const toolCalls = delta.tool_calls;
+        if (toolCalls) {
+            chunk.toolCalls = toolCalls.map((tc) => {
+                const fn = tc.function;
+                return { id: tc.id, name: fn.name, arguments: fn.arguments };
+            });
+        }
+        if (data.usage) {
+            const usage = data.usage;
+            chunk.usage = { inputTokens: usage.prompt_tokens ?? 0, outputTokens: usage.completion_tokens ?? 0 };
+        }
+        return chunk;
+    }
+}
+// Anthropic provider (Messages API)
+export class AnthropicProvider extends ModelProvider {
+    constructor(profile, logger) {
+        super("anthropic", "https://api.anthropic.com/v1", profile, logger);
+    }
+    async *chat(request) {
+        const systemMsg = request.messages.find((m) => m.role === "system");
+        const nonSystemMsgs = request.messages.filter((m) => m.role !== "system");
+        const body = {
+            model: request.model,
+            messages: nonSystemMsgs.map((m) => ({ role: m.role, content: m.content })),
+            max_tokens: request.maxTokens ?? 4096,
+            stream: true,
+        };
+        if (systemMsg)
+            body.system = systemMsg.content;
+        if (request.tools?.length) {
+            body.tools = request.tools.map((t) => ({
+                name: t.name, description: t.description, input_schema: t.parameters,
+            }));
+        }
+        if (request.temperature !== undefined)
+            body.temperature = request.temperature;
+        const response = await fetch(`${this.baseUrl}/messages`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": this.activeProfile.apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Anthropic API error ${response.status}: ${errorText}`);
+        }
+        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) {
+                const trimmed = line.trim();
+                if (!trimmed.startsWith("data: "))
+                    continue;
+                try {
+                    const data = JSON.parse(trimmed.slice(6));
+                    const chunk = this.parseAnthropicEvent(data);
+                    if (chunk)
+                        yield chunk;
+                }
+                catch {
+                    // skip
+                }
+            }
+        }
+    }
+    async listModels() {
+        // Anthropic doesn't have a list models endpoint; return known models
+        return [
+            { id: "claude-opus-4-5", name: "Claude Opus 4.5", contextWindow: 200000 },
+            { id: "claude-sonnet-4-5", name: "Claude Sonnet 4.5", contextWindow: 200000 },
+            { id: "claude-haiku-4-5", name: "Claude Haiku 4.5", contextWindow: 200000 },
+        ];
+    }
+    supportsTools() {
+        return true;
+    }
+    supportsStreaming() {
+        return true;
+    }
+    parseAnthropicEvent(data) {
+        const type = data.type;
+        if (type === "content_block_delta") {
+            const delta = data.delta;
+            if (delta.type === "text_delta")
+                return { content: delta.text };
+            if (delta.type === "input_json_delta")
+                return null; // handled in tool_use
+        }
+        if (type === "message_delta") {
+            const delta = data.delta;
+            const usage = data.usage;
+            return {
+                finishReason: delta.stop_reason === "tool_use" ? "tool_calls" : "stop",
+                usage: usage ? { inputTokens: usage.input_tokens ?? 0, outputTokens: usage.output_tokens ?? 0 } : undefined,
+            };
+        }
+        if (type === "message_start") {
+            const message = data.message;
+            const usage = message.usage;
+            if (usage)
+                return { usage: { inputTokens: usage.input_tokens ?? 0, outputTokens: 0 } };
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=model-provider.js.map

package/dist/model-router.d.ts

@@ -0,0 +1,32 @@
+import type { ChatRequest, ChatChunk, TokenUsage, AuthProfile, Logger } from "./types.js";
+import { ModelProvider } from "./model-provider.js";
+export interface BudgetConfig {
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+    maxTotalTokens?: number;
+}
+export declare class ModelRouter {
+    private providers;
+    private aliases;
+    private defaultModel;
+    private fallbackChain;
+    private authProfiles;
+    private tokenUsage;
+    private budgetLimits;
+    private logger;
+    constructor(logger: Logger, defaultModel: string);
+    registerProvider(provider: ModelProvider): void;
+    setAliases(aliases: Record<string, string>): void;
+    setFallbackChain(chain: string[]): void;
+    setBudget(budget: BudgetConfig): void;
+    resolve(modelSpec?: string): string;
+    getProvider(modelId: string): ModelProvider | undefined;
+    chat(request: ChatRequest, modelSpec?: string): AsyncIterable<ChatChunk>;
+    failover(error: Error, currentModel: string): "rotate" | "next" | "compact";
+    trackUsage(model: string, tokens: TokenUsage): void;
+    getUsage(): Map<string, TokenUsage>;
+    checkBudget(): boolean;
+    rotateAuthProfile(modelId: string): void;
+    setAuthProfiles(providerId: string, profiles: AuthProfile[]): void;
+}
+//# sourceMappingURL=model-router.d.ts.map