osai-agent 4.0.0

package/src/llm/direct.js

@@ -0,0 +1,317 @@
+import OpenAI from 'openai';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import Conf from 'conf';
+import { decrypt, deriveKey } from '../services/crypto.js';
+import pkg from 'node-machine-id';
+const { machineIdSync } = pkg;
+
+const SDK_DEFAULT_MODELS = {
+  anthropic: 'claude-sonnet-4-6',
+  gemini: 'gemini-2.5-flash',
+  openai: 'gpt-5.4-mini',
+  groq: 'llama-3.3-70b-versatile',
+  mistral: 'mistral-large-2506',
+  deepseek: 'deepseek-chat',
+  xai: 'grok-3',
+  cohere: 'command-r-plus',
+  perplexity: 'sonar-pro',
+  together: 'mistralai/Mixtral-8x22B-Instruct-v0.1',
+  fireworks: 'accounts/fireworks/models/llama-v3p3-70b-instruct',
+  cerebras: 'llama3.1-8b',
+  openrouter: 'auto',
+  ollama: 'llama3.2',
+  'ollama-cloud': 'llama3.2',
+};
+
+const DEFAULT_BASE_URLS = {
+  openai: 'https://api.openai.com/v1',
+  anthropic: 'https://api.anthropic.com',
+  gemini: 'https://generativelanguage.googleapis.com',
+  groq: 'https://api.groq.com/openai/v1',
+  mistral: 'https://api.mistral.ai/v1',
+  deepseek: 'https://api.deepseek.com/v1',
+  xai: 'https://api.x.ai/v1',
+  cohere: 'https://api.cohere.ai/compatibility/v1',
+  perplexity: 'https://api.perplexity.ai',
+  together: 'https://api.together.ai/v1',
+  fireworks: 'https://api.fireworks.ai/inference/v1',
+  cerebras: 'https://api.cerebras.ai/v1',
+  openrouter: 'https://openrouter.ai/api/v1',
+  huggingface: 'https://router.huggingface.co/v1',
+  github: 'https://models.github.ai/inference',
+  siliconflow: 'https://api.siliconflow.cn/v1',
+  hyperbolic: 'https://api.hyperbolic.xyz/v1',
+  novita: 'https://api.novita.ai/v3/openai',
+  deepinfra: 'https://api.deepinfra.com/v1/openai',
+  qwen: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+  moonshot: 'https://api.moonshot.ai/v1',
+  zhipu: 'https://open.bigmodel.cn/api/paas/v4',
+  yi: 'https://api.lingyiwanwu.com/v1',
+  nvidia: 'https://integrate.api.nvidia.com/v1',
+  baidu: 'https://qianfan.baidubce.com/v2',
+  codestral: 'https://codestral.mistral.ai/v1',
+  nebius: 'https://api.studio.nebius.ai/v1',
+  ollama: 'http://localhost:11434/v1',
+  'ollama-cloud': 'https://ollama.com/v1',
+};
+
+function getLocalKey() {
+  return deriveKey(machineIdSync());
+}
+
+export function getLocalProviderConfig() {
+  const config = new Conf({ projectName: 'osai-agent' });
+  // migrate from old single-provider format
+  const old = config.get('localProvider');
+  if (old && !config.get('localProviders')) {
+    const parsed = typeof old === 'string' ? JSON.parse(old) : old;
+    const { type, apiKeyEnc, model, baseUrl } = parsed;
+    if (type) {
+      config.set('localProviders', { [type]: { apiKeyEnc: apiKeyEnc || null, model: model || null, baseUrl: baseUrl || null } });
+      config.set('currentLocalProvider', type);
+    }
+    config.delete('localProvider');
+  }
+  const current = config.get('currentLocalProvider');
+  if (!current) return null;
+  const providers = config.get('localProviders', {});
+  const entry = providers[current];
+  if (!entry) return null;
+  try {
+    const key = getLocalKey();
+    const apiKey = entry.apiKeyEnc ? decrypt(entry.apiKeyEnc, key) : null;
+    return {
+      type: current,
+      apiKey,
+      model: entry.model || SDK_DEFAULT_MODELS[current] || SDK_DEFAULT_MODELS.openai,
+      baseUrl: entry.baseUrl || DEFAULT_BASE_URLS[current] || null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function fetchLocalModels({ type, apiKey, baseUrl }) {
+  if (type === 'anthropic') {
+    const res = await fetch('https://api.anthropic.com/v1/models', {
+      headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
+    });
+    if (!res.ok) throw new Error(`Anthropic API ${res.status}`);
+    const data = await res.json();
+    return (data.data || []).map(m => m.id || m.name);
+  }
+
+  if (type === 'gemini') {
+    const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
+    if (!res.ok) throw new Error(`Gemini API ${res.status}`);
+    const data = await res.json();
+    return (data.models || []).map(m => m.name.replace('models/', '')).filter(n => !n.includes('/'));
+  }
+
+  const url = (baseUrl || DEFAULT_BASE_URLS[type] || '').replace(/\/+$/, '');
+  if (!url) throw new Error(`No base URL for ${type}`);
+  const hasApiVersion = /\/v\d+$/.test(url);
+  const modelsPath = hasApiVersion ? '/models' : '/v1/models';
+  const res = await fetch(`${url}${modelsPath}`, {
+    headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+  });
+  if (!res.ok) throw new Error(`${type} API ${res.status}`);
+  const data = await res.json();
+  return (data.data || []).map(m => m.id);
+}
+
+export function createLocalOpenAiClient({ apiKey, baseUrl, defaultHeaders = {} }) {
+  return new OpenAI({
+    apiKey: apiKey || 'no-key-required',
+    baseURL: baseUrl || undefined,
+    defaultHeaders: Object.keys(defaultHeaders).length ? defaultHeaders : undefined,
+  });
+}
+
+export async function callLocalCompletion({ provider, message, signal }) {
+  if (provider.type === 'anthropic') {
+    const resp = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': provider.apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify({
+        model: provider.model,
+        max_tokens: 4096,
+        messages: [{ role: 'user', content: message }],
+      }),
+      signal,
+    });
+    if (!resp.ok) {
+      const detail = await resp.text().catch(() => '');
+      throw new Error(`Anthropic API Error (${resp.status})${detail ? `: ${detail}` : ''}`);
+    }
+    const data = await resp.json();
+    return data.content?.[0]?.text || '';
+  }
+
+  if (provider.type === 'gemini') {
+    const genAI = new GoogleGenerativeAI(provider.apiKey);
+    const model = genAI.getGenerativeModel({ model: provider.model });
+    const result = await model.generateContent(message);
+    return result.response.text() || '';
+  }
+
+  const client = createLocalOpenAiClient({
+    apiKey: provider.apiKey,
+    baseUrl: provider.baseUrl,
+  });
+  const completion = await client.chat.completions.create({
+    model: provider.model,
+    messages: [{ role: 'user', content: message }],
+  });
+  return completion.choices?.[0]?.message?.content || '';
+}
+
+function extractOpenAiDeltaText(chunk) {
+  const delta = chunk?.choices?.[0]?.delta;
+  if (!delta) return '';
+  return delta.content || delta.reasoning_content || delta.text || '';
+}
+
+export function streamLocalCompletion({
+  provider, systemPrompt, history, message, signal,
+}) {
+  const encoder = new TextEncoder();
+  const effectiveModel = provider.model || SDK_DEFAULT_MODELS[provider.type] || SDK_DEFAULT_MODELS.openai;
+
+  const sendChunk = (controller, content) => {
+    controller.enqueue(encoder.encode(`data: ${JSON.stringify({
+      type: 'chunk',
+      content,
+      provider: provider.type,
+      model: effectiveModel,
+    })}\n\n`));
+  };
+  const sendDone = (controller) => {
+    controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+  };
+
+  const messages = [
+    { role: 'system', content: systemPrompt },
+    ...(history || [])
+      .filter(h => h.role === 'user' || h.role === 'assistant')
+      .map(h => ({ role: h.role, content: typeof h.content === 'string' ? h.content : JSON.stringify(h.content) })),
+    { role: 'user', content: message },
+  ];
+
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        if (provider.type === 'anthropic') {
+          const resp = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'x-api-key': provider.apiKey,
+              'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify({
+              model: effectiveModel,
+              max_tokens: 4096,
+              stream: true,
+              system: systemPrompt,
+              messages: (history || [])
+                .filter(h => h.role === 'user' || h.role === 'assistant')
+                .map(h => ({
+                  role: h.role === 'assistant' ? 'assistant' : 'user',
+                  content: typeof h.content === 'string' ? h.content : JSON.stringify(h.content),
+                })),
+            }),
+            signal,
+          });
+
+          if (!resp.ok) {
+            const detail = await resp.text().catch(() => '');
+            throw new Error(`Anthropic API error (${resp.status})${detail ? `: ${detail}` : ''}`);
+          }
+
+          const contentType = resp.headers.get('content-type') || '';
+          if (contentType.includes('text/event-stream') && resp.body) {
+            const reader = resp.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            while (true) {
+              if (signal?.aborted) break;
+              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.startsWith('data: ')) continue;
+                const payload = line.slice(6).trim();
+                if (!payload || payload === '[DONE]') continue;
+                try {
+                  const event = JSON.parse(payload);
+                  if (event.type === 'content_block_delta' && event.delta?.text) {
+                    sendChunk(controller, event.delta.text);
+                  }
+                } catch {}
+              }
+            }
+          } else {
+            const data = await resp.json();
+            const text = (data.content || [])
+              .filter(part => part?.type === 'text' && part.text)
+              .map(part => part.text)
+              .join('');
+            if (text) sendChunk(controller, text);
+          }
+        } else if (provider.type === 'gemini') {
+          const genAI = new GoogleGenerativeAI(provider.apiKey);
+          const geminiModel = genAI.getGenerativeModel({ model: effectiveModel });
+          const geminiHistory = messages
+            .filter(m => m.role !== 'system')
+            .slice(0, -1)
+            .map(m => ({
+              role: m.role === 'assistant' ? 'model' : 'user',
+              parts: [{ text: m.content }],
+            }));
+          const chat = geminiModel.startChat({
+            history: geminiHistory,
+            systemInstruction: systemPrompt,
+          });
+          const result = await chat.sendMessageStream(message);
+          for await (const chunk of result.stream) {
+            if (signal?.aborted) break;
+            try {
+              const text = chunk.text();
+              if (text) sendChunk(controller, text);
+            } catch {}
+          }
+        } else {
+          const client = createLocalOpenAiClient({
+            apiKey: provider.apiKey,
+            baseUrl: provider.baseUrl,
+          });
+          const completion = await client.chat.completions.create({
+            model: effectiveModel,
+            messages,
+            stream: true,
+          }, { signal });
+
+          for await (const chunk of completion) {
+            if (signal?.aborted) break;
+            const text = extractOpenAiDeltaText(chunk);
+            if (text) sendChunk(controller, text);
+          }
+        }
+        sendDone(controller);
+        controller.close();
+      } catch (err) {
+        if (err.name !== 'AbortError') {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', message: err.message })}\n\n`));
+        }
+        controller.close();
+      }
+    },
+  });
+}

package/src/memory/store.js

@@ -0,0 +1,215 @@
+// =============================================================================
+// OS AI Agent — Memory Store
+// =============================================================================
+// Lightweight JSON-based memory system that stores actions, results, and
+// failures across sessions. Enables the agent to learn from past interactions.
+// Implements a 6-layer memory model inspired by Claude Code's architecture:
+//   1. System Prompt (static)
+//   2. Session Messages (current conversation)
+//   3. Compact History (auto-trimmed)
+//   4. Project Knowledge (instructions.md)
+//   5. Persistent Memory (this store - actions/failures/preferences)
+//   6. Semantic Search (future — keyword-based for now)
+// =============================================================================
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { DEFAULTS } from '../utils/constants.js';
+import { logger } from '../utils/logger.js';
+
+const MEMORY_DIR = path.join(os.homedir(), '.osai-agent', 'memory');
+const MEMORY_FILE = path.join(MEMORY_DIR, 'memory.json');
+
+/**
+ * MemoryStore — Persistent JSON-based memory for the agent.
+ */
+export class MemoryStore {
+  constructor() {
+    this.memory = null;
+    this.loaded = false;
+  }
+
+  async _ensureLoaded() {
+    if (this.loaded) return;
+    try {
+      await fs.mkdir(MEMORY_DIR, { recursive: true });
+      try {
+        const data = await fs.readFile(MEMORY_FILE, 'utf-8');
+        this.memory = JSON.parse(data);
+      } catch {
+        this.memory = this._emptyMemory();
+      }
+      this.loaded = true;
+    } catch (err) {
+      logger.error('Failed to initialize memory store', { error: err.message });
+      this.memory = this._emptyMemory();
+      this.loaded = true;
+    }
+  }
+
+  _emptyMemory() {
+    return {
+      version: 2,
+      created: new Date().toISOString(),
+      updated: new Date().toISOString(),
+      actions: [],
+      results: [],
+      failures: [],
+      preferences: {},
+      patterns: [],
+    };
+  }
+
+  async _save() {
+    try {
+      this.memory.updated = new Date().toISOString();
+      this._trimEntries();
+      await fs.writeFile(MEMORY_FILE, JSON.stringify(this.memory, null, 2), 'utf-8');
+    } catch (err) {
+      logger.error('Failed to save memory', { error: err.message });
+    }
+  }
+
+  _trimEntries() {
+    const max = DEFAULTS.MAX_MEMORY_ENTRIES;
+    for (const key of ['actions', 'results', 'failures', 'patterns']) {
+      if (this.memory[key].length > max) {
+        this.memory[key] = this.memory[key].slice(-max);
+      }
+    }
+  }
+
+  async recordAction(entry) {
+    await this._ensureLoaded();
+    this.memory.actions.push({ ...entry, timestamp: new Date().toISOString() });
+    await this._save();
+  }
+
+  async recordResult(entry) {
+    await this._ensureLoaded();
+    this.memory.results.push({ ...entry, timestamp: new Date().toISOString() });
+    await this._save();
+  }
+
+  async recordFailure(entry) {
+    await this._ensureLoaded();
+    this.memory.failures.push({ ...entry, timestamp: new Date().toISOString() });
+    await this._save();
+  }
+
+  async setPreference(key, value) {
+    await this._ensureLoaded();
+    this.memory.preferences[key] = { value, updatedAt: new Date().toISOString() };
+    await this._save();
+  }
+
+  async getPreference(key, defaultValue = null) {
+    await this._ensureLoaded();
+    const pref = this.memory.preferences[key];
+    return pref ? pref.value : defaultValue;
+  }
+
+  async getRecentActions(count = 10) {
+    await this._ensureLoaded();
+    return this.memory.actions.slice(-count);
+  }
+
+  async getRecentFailures(count = 10) {
+    await this._ensureLoaded();
+    return this.memory.failures.slice(-count);
+  }
+
+  async search(query, count = 20) {
+    await this._ensureLoaded();
+    const lower = query.toLowerCase();
+    const results = [];
+    for (const action of this.memory.actions) {
+      if (JSON.stringify(action).toLowerCase().includes(lower)) {
+        results.push({ type: 'action', ...action });
+      }
+    }
+    for (const failure of this.memory.failures) {
+      if (JSON.stringify(failure).toLowerCase().includes(lower)) {
+        results.push({ type: 'failure', ...failure });
+      }
+    }
+    return results.slice(-count);
+  }
+
+  async getStats() {
+    await this._ensureLoaded();
+    return {
+      totalActions: this.memory.actions.length,
+      totalResults: this.memory.results.length,
+      totalFailures: this.memory.failures.length,
+      totalPreferences: Object.keys(this.memory.preferences).length,
+      lastUpdated: this.memory.updated,
+      created: this.memory.created,
+    };
+  }
+
+  /**
+   * Build a context summary for the LLM prompt.
+   * Includes recent failures to avoid and recent successful patterns.
+   */
+  async buildContextSummary(maxEntries = 5) {
+    await this._ensureLoaded();
+    const lines = [];
+
+    const recentFailures = this.memory.failures.slice(-maxEntries);
+    if (recentFailures.length > 0) {
+      lines.push('RECENT FAILURES TO AVOID:');
+      for (const f of recentFailures) {
+        lines.push(`  - ${f.command || f.tool}: ${f.error || f.reason}`);
+      }
+    }
+
+    const recentActions = this.memory.actions.slice(-maxEntries);
+    if (recentActions.length > 0) {
+      lines.push('RECENT SUCCESSFUL ACTIONS:');
+      for (const a of recentActions) {
+        lines.push(`  - ${a.command || a.tool}: ${a.status || 'completed'}`);
+      }
+    }
+
+    const recentVerification = this.memory.results
+      .slice()
+      .reverse()
+      .find((r) => r && r.verification);
+    if (recentVerification?.verification) {
+      const v = recentVerification.verification;
+      lines.push('VERIFICATION METRICS:');
+      lines.push(`  - Files read (ops): ${v.filesReadOps ?? 0}`);
+      lines.push(`  - Files read (unique): ${v.filesReadUnique ?? 0}`);
+      lines.push(`  - Blocked writes without read: ${v.blockedWritesWithoutRead ?? 0}`);
+    }
+
+    const verificationState = this.memory.preferences?.verification_state?.value;
+    if (verificationState) {
+      lines.push('PERSISTENT VERIFICATION STATE:');
+      lines.push(`  - Freshness window: ${verificationState.freshnessWindow ?? 20} interactions`);
+      lines.push(`  - Current interaction index: ${verificationState.interactionIndex ?? 0}`);
+      lines.push(`  - Tracked files: ${Object.keys(verificationState.trackedFiles || {}).length}`);
+    }
+
+    // Include preferences if any
+    const prefKeys = Object.keys(this.memory.preferences);
+    if (prefKeys.length > 0) {
+      lines.push('USER PREFERENCES:');
+      for (const key of prefKeys.slice(0, maxEntries)) {
+        const pref = this.memory.preferences[key];
+        lines.push(`  - ${key}: ${pref.value}`);
+      }
+    }
+
+    return lines.length > 0 ? lines.join('\n') : null;
+  }
+
+  async clear() {
+    this.memory = this._emptyMemory();
+    this.loaded = true;
+    await this._save();
+  }
+}
+
+export const memory = new MemoryStore();

package/src/mock-readline.js

@@ -0,0 +1,27 @@
+import { EventEmitter } from 'events';
+
+export class MockReadline extends EventEmitter {
+  constructor() {
+    super();
+    this.output = {
+      write: (data) => {
+        // Drop standard writes, as we handle output via React state
+        // but AgentLoop calls output.write('\n') around questions.
+      }
+    };
+    this.pendingQuestion = null;
+  }
+
+  question(prompt, callback) {
+    this.pendingQuestion = { prompt, callback };
+    this.emit('question', prompt);
+  }
+
+  answer(response) {
+    if (this.pendingQuestion) {
+      const { callback } = this.pendingQuestion;
+      this.pendingQuestion = null;
+      callback(response);
+    }
+  }
+}

package/src/parser/dependencies.js

@@ -0,0 +1,71 @@
+// =============================================================================
+// OS AI Agent — Dependency Analysis Utilities
+// =============================================================================
+// Pure functions for extracting imports and exports from source code.
+// Used by the GET_DEPENDENCIES tool and dependency auto-resolution.
+// =============================================================================
+
+/**
+ * Extract exported symbol names from JS/TS source content.
+ * Handles both ESM (export function/const/class/default/{...})
+ * and CommonJS (module.exports = {...}, module.exports.x, exports.x).
+ */
+export function extractExports(content) {
+  if (!content) return [];
+  const exports = new Set();
+
+  let m;
+  let re = /export\s+(?:async\s+)?function\s*(?:\*\s*)?(\w+)/g;
+  while ((m = re.exec(content)) !== null) exports.add(m[1]);
+
+  re = /export\s+(?:default\s+)?class\s+(\w+)/g;
+  while ((m = re.exec(content)) !== null) exports.add(m[1]);
+
+  re = /export\s+(?:const|let|var)\s+(\w+)/g;
+  while ((m = re.exec(content)) !== null) exports.add(m[1]);
+
+  re = /export\s+default\s+(\w+)/g;
+  while ((m = re.exec(content)) !== null) exports.add(m[1]);
+
+  re = /export\s+\{([^}]+)\}/g;
+  while ((m = re.exec(content)) !== null) {
+    m[1].split(',').forEach(s => {
+      const name = s.trim().match(/^(\w+)/);
+      if (name) exports.add(name[1]);
+    });
+  }
+
+  re = /module\.exports\s*=\s*\{([^}]*)\}/g;
+  while ((m = re.exec(content)) !== null) {
+    m[1].split(',').forEach(s => {
+      const name = s.trim().match(/^(\w+)/);
+      if (name) exports.add(name[1]);
+    });
+  }
+
+  re = /module\.exports\.(\w+)\s*=/g;
+  while ((m = re.exec(content)) !== null) exports.add(m[1]);
+
+  re = /exports\.(\w+)\s*=/g;
+  while ((m = re.exec(content)) !== null) exports.add(m[1]);
+
+  return [...exports];
+}
+
+/**
+ * Extract local import paths (relative or absolute starting with . or /)
+ * from JS/TS source content.
+ */
+export function extractLocalImports(content) {
+  if (!content) return [];
+  const imports = [];
+  const re = /(?:import\s+(?:[\s\S]*?\s+from\s+)?["']([^"']+)["']|require\s*\(\s*["']([^"']+)["']\s*\))/g;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    const spec = m[1] || m[2];
+    if (spec && (spec.startsWith('.') || spec.startsWith('/'))) {
+      imports.push(spec);
+    }
+  }
+  return imports;
+}