myaiforone 1.0.0

package/src/memory/store.ts

@@ -0,0 +1,189 @@
+/**
+ * Vector store — JSON default, auto-upgrades to SQLite if better-sqlite3 is available.
+ * Stores text chunks with their embedding vectors for semantic search.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { log } from "../logger.js";
+
+export interface MemoryChunk {
+  id: string;
+  text: string;
+  vector: number[];
+  source: string;       // "daily", "context", "conversation", "manual"
+  timestamp: string;    // ISO date
+  metadata?: Record<string, string>;
+}
+
+export interface VectorStore {
+  name: string;
+  add(chunk: MemoryChunk): Promise<void>;
+  addBatch(chunks: MemoryChunk[]): Promise<void>;
+  getAll(): Promise<MemoryChunk[]>;
+  remove(id: string): Promise<void>;
+  clear(): Promise<void>;
+  count(): Promise<number>;
+}
+
+// ─── JSON Store (default) ────────────────────────────────────────────
+
+class JSONStore implements VectorStore {
+  name = "json";
+  private filePath: string;
+  private chunks: MemoryChunk[] = [];
+  private loaded = false;
+
+  constructor(memoryDir: string) {
+    mkdirSync(memoryDir, { recursive: true });
+    this.filePath = join(memoryDir, "vectors.json");
+  }
+
+  private load(): void {
+    if (this.loaded) return;
+    if (existsSync(this.filePath)) {
+      try {
+        this.chunks = JSON.parse(readFileSync(this.filePath, "utf-8"));
+      } catch {
+        this.chunks = [];
+      }
+    }
+    this.loaded = true;
+  }
+
+  private save(): void {
+    writeFileSync(this.filePath, JSON.stringify(this.chunks));
+  }
+
+  async add(chunk: MemoryChunk): Promise<void> {
+    this.load();
+    // Replace if same ID exists
+    this.chunks = this.chunks.filter(c => c.id !== chunk.id);
+    this.chunks.push(chunk);
+    this.save();
+  }
+
+  async addBatch(chunks: MemoryChunk[]): Promise<void> {
+    this.load();
+    const newIds = new Set(chunks.map(c => c.id));
+    this.chunks = this.chunks.filter(c => !newIds.has(c.id));
+    this.chunks.push(...chunks);
+    this.save();
+  }
+
+  async getAll(): Promise<MemoryChunk[]> {
+    this.load();
+    return [...this.chunks];
+  }
+
+  async remove(id: string): Promise<void> {
+    this.load();
+    this.chunks = this.chunks.filter(c => c.id !== id);
+    this.save();
+  }
+
+  async clear(): Promise<void> {
+    this.chunks = [];
+    this.loaded = true;
+    this.save();
+  }
+
+  async count(): Promise<number> {
+    this.load();
+    return this.chunks.length;
+  }
+}
+
+// ─── SQLite Store (auto-upgrade if available) ────────────────────────
+
+async function trySQLiteStore(memoryDir: string): Promise<VectorStore | null> {
+  try {
+    // Dynamic import — only works if better-sqlite3 is installed
+    // Use createRequire to avoid TypeScript module resolution errors
+    const { createRequire } = await import("node:module");
+    const require = createRequire(import.meta.url);
+    const Database = require("better-sqlite3");
+
+    const dbPath = join(memoryDir, "vectors.sqlite");
+    const db = new Database(dbPath);
+
+    // Create table
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS chunks (
+        id TEXT PRIMARY KEY,
+        text TEXT NOT NULL,
+        vector TEXT NOT NULL,
+        source TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        metadata TEXT
+      )
+    `);
+
+    const store: VectorStore = {
+      name: "sqlite",
+
+      async add(chunk: MemoryChunk) {
+        db.prepare(`
+          INSERT OR REPLACE INTO chunks (id, text, vector, source, timestamp, metadata)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `).run(
+          chunk.id, chunk.text, JSON.stringify(chunk.vector),
+          chunk.source, chunk.timestamp, chunk.metadata ? JSON.stringify(chunk.metadata) : null
+        );
+      },
+
+      async addBatch(chunks: MemoryChunk[]) {
+        const stmt = db.prepare(`
+          INSERT OR REPLACE INTO chunks (id, text, vector, source, timestamp, metadata)
+          VALUES (?, ?, ?, ?, ?, ?)
+        `);
+        const tx = db.transaction((items: MemoryChunk[]) => {
+          for (const c of items) {
+            stmt.run(c.id, c.text, JSON.stringify(c.vector), c.source, c.timestamp,
+              c.metadata ? JSON.stringify(c.metadata) : null);
+          }
+        });
+        tx(chunks);
+      },
+
+      async getAll(): Promise<MemoryChunk[]> {
+        const rows = db.prepare("SELECT * FROM chunks").all() as any[];
+        return rows.map(r => ({
+          id: r.id, text: r.text, vector: JSON.parse(r.vector),
+          source: r.source, timestamp: r.timestamp,
+          metadata: r.metadata ? JSON.parse(r.metadata) : undefined,
+        }));
+      },
+
+      async remove(id: string) {
+        db.prepare("DELETE FROM chunks WHERE id = ?").run(id);
+      },
+
+      async clear() {
+        db.exec("DELETE FROM chunks");
+      },
+
+      async count(): Promise<number> {
+        const row = db.prepare("SELECT COUNT(*) as cnt FROM chunks").get() as any;
+        return row.cnt;
+      },
+    };
+
+    log.info("Memory store: SQLite (better-sqlite3)");
+    return store;
+  } catch {
+    return null;
+  }
+}
+
+// ─── Store factory ───────────────────────────────────────────────────
+
+export async function createStore(memoryDir: string): Promise<VectorStore> {
+  // Try SQLite first
+  const sqlite = await trySQLiteStore(memoryDir);
+  if (sqlite) return sqlite;
+
+  // Fall back to JSON
+  log.info("Memory store: JSON (install better-sqlite3 for faster search at scale)");
+  return new JSONStore(memoryDir);
+}

package/src/ollama-executor.ts

@@ -0,0 +1,126 @@
+import { log } from "./logger.js";
+
+export interface OllamaOptions {
+  model: string;         // e.g., "gemma2", "llama3.1"
+  systemPrompt: string;
+  message: string;
+  baseUrl?: string;      // default: "http://localhost:11434"
+  timeout?: number;      // default: 300000 (5 min)
+}
+
+export async function executeOllama(opts: OllamaOptions): Promise<string> {
+  const baseUrl = opts.baseUrl || "http://localhost:11434";
+  const timeout = opts.timeout || 300_000;
+
+  log.info(`[Ollama] Executing ${opts.model}: ${opts.message.slice(0, 200)}`);
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const res = await fetch(`${baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: opts.model,
+        messages: [
+          { role: "system", content: opts.systemPrompt },
+          { role: "user", content: opts.message },
+        ],
+        stream: false,
+      }),
+      signal: controller.signal,
+    });
+
+    if (!res.ok) {
+      const errText = await res.text();
+      log.error(`[Ollama] Error ${res.status}: ${errText}`);
+      throw new Error(`Ollama API error ${res.status}: ${errText}`);
+    }
+
+    const data = await res.json() as { message?: { content?: string }; error?: string };
+    if (data.error) {
+      throw new Error(`Ollama error: ${data.error}`);
+    }
+
+    const response = data.message?.content || "";
+    log.info(`[Ollama] Response from ${opts.model}: ${response.slice(0, 200)}`);
+    return response;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function* streamOllama(opts: OllamaOptions): AsyncGenerator<string> {
+  const baseUrl = opts.baseUrl || "http://localhost:11434";
+  const timeout = opts.timeout || 300_000;
+
+  log.info(`[Ollama] Streaming ${opts.model}: ${opts.message.slice(0, 200)}`);
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const res = await fetch(`${baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: opts.model,
+        messages: [
+          { role: "system", content: opts.systemPrompt },
+          { role: "user", content: opts.message },
+        ],
+        stream: true,
+      }),
+      signal: controller.signal,
+    });
+
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error(`Ollama API error ${res.status}: ${errText}`);
+    }
+
+    const reader = res.body?.getReader();
+    if (!reader) throw new Error("No response body");
+
+    const decoder = new TextDecoder();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, { stream: true });
+      // Ollama streams newline-delimited JSON
+      for (const line of chunk.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line) as { message?: { content?: string }; done?: boolean };
+          if (parsed.message?.content) {
+            yield parsed.message.content;
+          }
+        } catch { /* skip unparseable lines */ }
+      }
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Check if Ollama is running and the model is available
+ */
+export async function checkOllamaHealth(baseUrl?: string, model?: string): Promise<{ ok: boolean; error?: string }> {
+  const url = baseUrl || "http://localhost:11434";
+  try {
+    const res = await fetch(`${url}/api/tags`);
+    if (!res.ok) return { ok: false, error: `Ollama not responding (${res.status})` };
+    if (model) {
+      const data = await res.json() as { models?: Array<{ name: string }> };
+      const models = data.models?.map(m => m.name.replace(/:latest$/, "")) || [];
+      if (!models.some(m => m === model || m.startsWith(model + ":"))) {
+        return { ok: false, error: `Model "${model}" not found. Available: ${models.join(", ")}` };
+      }
+    }
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: `Ollama not running at ${url}: ${err}` };
+  }
+}

package/src/openai-executor.ts

@@ -0,0 +1,259 @@
+/**
+ * OpenAI-compatible executor — handles OpenAI, xAI (Grok), Groq, Together, Mistral,
+ * and any other provider that implements the OpenAI Chat Completions API.
+ *
+ * Executor format: "openai:gpt-4o", "grok:grok-3", "groq:llama-3.3-70b-versatile",
+ *                  "together:meta-llama/Llama-3.3-70B-Instruct", "mistral:mistral-large-latest"
+ */
+
+import { log } from "./logger.js";
+
+// ─── Provider registry ─────────────────────────────────────────
+export interface ProviderConfig {
+  name: string;
+  baseUrl: string;
+  keyField: string; // field name in providerKeys, e.g., "openai"
+  modelsEndpoint?: string; // path to list models (default: /models)
+}
+
+export const PROVIDERS: Record<string, ProviderConfig> = {
+  openai: {
+    name: "OpenAI",
+    baseUrl: "https://api.openai.com/v1",
+    keyField: "openai",
+  },
+  grok: {
+    name: "xAI (Grok)",
+    baseUrl: "https://api.x.ai/v1",
+    keyField: "xai",
+  },
+  groq: {
+    name: "Groq",
+    baseUrl: "https://api.groq.com/openai/v1",
+    keyField: "groq",
+  },
+  together: {
+    name: "Together",
+    baseUrl: "https://api.together.xyz/v1",
+    keyField: "together",
+  },
+  mistral: {
+    name: "Mistral",
+    baseUrl: "https://api.mistral.ai/v1",
+    keyField: "mistral",
+  },
+};
+
+// ─── Options ────────────────────────────────────────────────────
+export interface OpenAICompatOptions {
+  provider: string;       // "openai", "grok", "groq", "together", "mistral"
+  model: string;          // "gpt-4o", "grok-3", "llama-3.3-70b-versatile", etc.
+  apiKey: string;
+  systemPrompt: string;
+  message: string;
+  baseUrl?: string;       // override provider default
+  timeout?: number;       // default: 300000 (5 min)
+  temperature?: number;   // default: 0.7
+  maxTokens?: number;     // default: 4096
+}
+
+// ─── Response types ─────────────────────────────────────────────
+interface ChatCompletionResponse {
+  id: string;
+  choices: Array<{
+    message: { role: string; content: string | null };
+    finish_reason: string;
+  }>;
+  usage?: { prompt_tokens: number; completion_tokens: number; total_tokens: number };
+  error?: { message: string; type: string; code?: string };
+}
+
+interface ChatCompletionChunk {
+  choices: Array<{
+    delta: { content?: string; role?: string };
+    finish_reason: string | null;
+  }>;
+}
+
+// ─── Execute (non-streaming) ────────────────────────────────────
+export async function executeOpenAICompat(opts: OpenAICompatOptions): Promise<string> {
+  const providerConfig = PROVIDERS[opts.provider];
+  const baseUrl = opts.baseUrl || providerConfig?.baseUrl;
+  if (!baseUrl) throw new Error(`Unknown provider: ${opts.provider}`);
+
+  const timeout = opts.timeout || 300_000;
+  const providerName = providerConfig?.name || opts.provider;
+
+  log.info(`[${providerName}] Executing ${opts.model}: ${opts.message.slice(0, 200)}`);
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const res = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${opts.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: opts.model,
+        messages: [
+          { role: "system", content: opts.systemPrompt },
+          { role: "user", content: opts.message },
+        ],
+        temperature: opts.temperature ?? 0.7,
+        max_tokens: opts.maxTokens ?? 4096,
+        stream: false,
+      }),
+      signal: controller.signal,
+    });
+
+    if (!res.ok) {
+      const errText = await res.text();
+      log.error(`[${providerName}] Error ${res.status}: ${errText}`);
+
+      // Parse structured error if possible
+      try {
+        const errJson = JSON.parse(errText);
+        const errMsg = errJson.error?.message || errJson.message || errText;
+        throw new Error(`${providerName} API error ${res.status}: ${errMsg}`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith(providerName)) throw e;
+        throw new Error(`${providerName} API error ${res.status}: ${errText}`);
+      }
+    }
+
+    const data = await res.json() as ChatCompletionResponse;
+
+    if (data.error) {
+      throw new Error(`${providerName} error: ${data.error.message}`);
+    }
+
+    const response = data.choices?.[0]?.message?.content || "";
+
+    if (data.usage) {
+      log.debug(`[${providerName}] ${opts.model} usage: ${data.usage.prompt_tokens}+${data.usage.completion_tokens} tokens`);
+    }
+
+    log.info(`[${providerName}] Response from ${opts.model}: ${response.slice(0, 200)}`);
+    return response;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ─── Stream ─────────────────────────────────────────────────────
+export async function* streamOpenAICompat(opts: OpenAICompatOptions): AsyncGenerator<string> {
+  const providerConfig = PROVIDERS[opts.provider];
+  const baseUrl = opts.baseUrl || providerConfig?.baseUrl;
+  if (!baseUrl) throw new Error(`Unknown provider: ${opts.provider}`);
+
+  const timeout = opts.timeout || 300_000;
+  const providerName = providerConfig?.name || opts.provider;
+
+  log.info(`[${providerName}] Streaming ${opts.model}: ${opts.message.slice(0, 200)}`);
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const res = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${opts.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: opts.model,
+        messages: [
+          { role: "system", content: opts.systemPrompt },
+          { role: "user", content: opts.message },
+        ],
+        temperature: opts.temperature ?? 0.7,
+        max_tokens: opts.maxTokens ?? 4096,
+        stream: true,
+      }),
+      signal: controller.signal,
+    });
+
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error(`${providerName} API error ${res.status}: ${errText}`);
+    }
+
+    const reader = res.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() || ""; // keep incomplete last line
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed === "data: [DONE]") continue;
+        if (!trimmed.startsWith("data: ")) continue;
+
+        const jsonStr = trimmed.slice(6);
+        try {
+          const chunk = JSON.parse(jsonStr) as ChatCompletionChunk;
+          const content = chunk.choices?.[0]?.delta?.content;
+          if (content) {
+            yield content;
+          }
+        } catch { /* skip unparseable lines */ }
+      }
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ─── Health check ───────────────────────────────────────────────
+export async function checkOpenAICompatHealth(
+  provider: string,
+  apiKey: string,
+  baseUrl?: string,
+): Promise<{ ok: boolean; error?: string; models?: string[] }> {
+  const providerConfig = PROVIDERS[provider];
+  const url = baseUrl || providerConfig?.baseUrl;
+  if (!url) return { ok: false, error: `Unknown provider: ${provider}` };
+
+  const providerName = providerConfig?.name || provider;
+
+  try {
+    const res = await fetch(`${url}/models`, {
+      headers: { "Authorization": `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(10_000),
+    });
+
+    if (res.status === 401 || res.status === 403) {
+      return { ok: false, error: `${providerName}: Invalid API key` };
+    }
+
+    if (!res.ok) {
+      return { ok: false, error: `${providerName}: API returned ${res.status}` };
+    }
+
+    const data = await res.json() as { data?: Array<{ id: string }> };
+    const models = data.data?.map(m => m.id) || [];
+    return { ok: true, models: models.slice(0, 20) };
+  } catch (err) {
+    return { ok: false, error: `${providerName}: ${err}` };
+  }
+}
+
+/**
+ * Resolve provider prefix to config.
+ * Returns null if the prefix is not an OpenAI-compatible provider.
+ */
+export function resolveProvider(prefix: string): ProviderConfig | null {
+  return PROVIDERS[prefix] || null;
+}