aegiscode 3.1.10 → 3.2.0

package/src/services/LearningCollector.ts

@@ -1,291 +0,0 @@
-/**
- * LearningCollector — Collect + push daily AI learnings to aegiscloud.org
- *
- * Extracts high-value facts, decisions, and solutions from interactions and
- * memory entries, then pushes them to the cloud for the daily digest.
- *
- * The admin panel aggregates learnings from all AEGIS instances (CLI + GUI)
- * and produces a daily summary of what "all AEGIS instances learned today."
- *
- * Pro-tier (logged-in) users contribute to the collective pool.
- * Ultimate-tier users can also pull the daily digest.
- *
- * Fire-and-forget, never blocks. Silently swallows all errors.
- */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import * as https from 'node:https';
-
-const HOST = 'aegiscloud.org';
-const PUSH_URL = '/api/learnings/push';
-const DIGEST_URL = '/api/learnings/daily';
-const TIMEOUT_MS = 8000;
-
-const LAST_DIGEST_FILE = path.join(os.homedir(), '.aegiscode', 'memory', '.last-digest');
-
-// ── Config helpers ──────────────────────────────────────────────────────────
-
-function getConfig(): Record<string, any> {
-  try {
-    const cfgPath = path.join(os.homedir(), '.aegiscode', 'config.json');
-    return JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
-  } catch { return {}; }
-}
-
-function getApiKey(): string | null {
-  return getConfig()?.aegiscloud?.api_key ?? null;
-}
-
-// ── Types ───────────────────────────────────────────────────────────────────
-
-export interface Learning {
-  /** Unique id (uuid) */
-  id: string;
-  /** When the learning was extracted */
-  timestamp: string;
-  /** The learned fact, decision, or solution text */
-  content: string;
-  /** Category: 'fact' | 'decision' | 'solution' | 'insight' | 'pattern' */
-  category: string;
-  /** Source client: 'cli' | 'gui' */
-  client: string;
-  /** Version of the client that produced this */
-  version: string;
-  /** Topics extracted from the content */
-  topics: string[];
-  /** Entities (code patterns, file paths, function names, etc.) */
-  entities: string[];
-  /** How important 0–1 */
-  importance: number;
-  /** Session this came from */
-  sessionId?: string;
-  /** Model that was used when this learning was generated */
-  model?: string;
-}
-
-// ── Category detection ──────────────────────────────────────────────────────
-
-function detectCategory(content: string): Learning['category'] {
-  const lower = content.toLowerCase();
-  if (/decided|decision|chose|elected|going with|pick/i.test(lower)) return 'decision';
-  if (/solved|fixed|resolved|solution|workaround|patch|bug.*fix/i.test(lower)) return 'solution';
-  if (/pattern|anti.?pattern|common|always|never|typically/i.test(lower)) return 'pattern';
-  if (/insight|realized|understood|now know|important/i.test(lower)) return 'insight';
-  return 'fact';
-}
-
-function extractTopics(content: string): string[] {
-  const topicMap: Record<string, RegExp> = {
-    'coding':       /```|function|class|const|let|import|export|interface/i,
-    'debugging':    /bug|error|fix|issue|crash|broken|not working/i,
-    'deployment':   /deploy|railway|docker|container|cloud/i,
-    'architecture': /architecture|design pattern|scalab|refactor/i,
-    'database':     /sqlite|postgres|sql|query|mongo/i,
-    'frontend':     /react|vue|css|html|component|ui|interface/i,
-    'backend':      /api|endpoint|server|flask|express|route/i,
-    'security':     /auth|token|password|encrypt|security|vulnerab/i,
-    'devops':       /ci|cd|github|action|pipeline|monitoring/i,
-    'ai-ml':        /model|train|embed|vector|llm|token|inference/i,
-  };
-  return Object.entries(topicMap)
-    .filter(([_, re]) => re.test(content))
-    .map(([topic]) => topic);
-}
-
-function extractEntities(content: string): string[] {
-  const entities: string[] = [];
-  const funcMatches = content.match(/(?:function|class|def|const)\s+(\w+)/g);
-  if (funcMatches) entities.push(...funcMatches.map(m => m.split(/\s+/)[1]));
-  const fileMatches = content.match(/(?:`[^`]+`)/g);
-  if (fileMatches) entities.push(...fileMatches.map(m => m.replace(/`/g, '')));
-  const pkgMatches = content.match(/(?:from\s+|require\s*\(\s*['"])['"]([^'"]+)['"]/g);
-  if (pkgMatches) entities.push(...pkgMatches.map(m => {
-    const inner = m.match(/['"]([^'"]+)['"]/);
-    return inner ? inner[1] : '';
-  }));
-  const toolMatches = content.match(/(docker|npm|yarn|git|pip|node|python|react|flask|sqlite|postgres)/gi);
-  if (toolMatches) entities.push(...toolMatches.map(m => m.toLowerCase()));
-  return [...new Set(entities)].filter(Boolean).slice(0, 10);
-}
-
-// ── HTTP helper (fire-and-forget POST) ──────────────────────────────────────
-
-function postJson(path: string, payload: object): Promise<unknown> {
-  return new Promise((resolve, reject) => {
-    const body = JSON.stringify(payload);
-    const req = https.request(
-      {
-        hostname: HOST,
-        path,
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(body),
-        },
-      },
-      (res) => {
-        let data = '';
-        res.on('data', (chunk: Buffer) => { data += chunk.toString(); });
-        res.on('end', () => {
-          try { resolve(JSON.parse(data)); }
-          catch { resolve(data); }
-        });
-      },
-    );
-    req.on('error', reject);
-    req.setTimeout(TIMEOUT_MS, () => { req.destroy(); reject(new Error('timeout')); });
-    req.write(body);
-    req.end();
-  });
-}
-
-// ── Main API ────────────────────────────────────────────────────────────────
-
-/**
- * Extract a Learning from a piece of content (user message or assistant response).
- * Returns null if the content isn't important enough to be a "learning".
- */
-export function extractLearning(
-  content: string,
-  role: 'user' | 'assistant',
-  sessionId?: string,
-  model?: string,
-): Learning | null {
-  if (!content || content.length < 30) return null;
-
-  // Only assistant responses with sufficient importance qualify as learnings
-  // (user messages provide context but aren't learnings themselves)
-  if (role !== 'assistant') return null;
-
-  // Must contain substantive information
-  const lower = content.toLowerCase();
-  const hasSubstance =
-    /```/g.test(content) ||                          // Code
-    /(?:is|are|was|were|should|must|can|will)\s+.{20,}/.test(lower) || // Statements
-    /step[s]?\s+\d|first|second|finally|solution|fix|method|approach/.test(lower); // Process
-
-  if (!hasSubstance) return null;
-
-  // Detect importance heuristically
-  let importance = 0.5;
-  if (/\bimportant|key|crucial|critical|essential|must|never|always\b/i.test(content)) importance += 0.15;
-  if (/\bdecision|conclusion|resolved|solved|fixed\b/i.test(content)) importance += 0.15;
-  if (content.length > 300) importance += 0.1;
-
-  if (importance < 0.6) return null; // Not interesting enough
-
-  const { v4: uuid } = require('uuid');
-
-  return {
-    id: uuid(),
-    timestamp: new Date().toISOString(),
-    content: content.slice(0, 500),
-    category: detectCategory(content),
-    client: process.env.AEGIS_CLIENT_TYPE || 'cli',
-    version: process.env.npm_package_version || 'unknown',
-    topics: extractTopics(content),
-    entities: extractEntities(content),
-    importance: Math.min(1, importance),
-    sessionId: sessionId || 'unknown',
-    model,
-  };
-}
-
-/**
- * Push a batch of learnings to the cloud. Fire-and-forget.
- * Returns how many the server accepted.
- */
-export async function pushLearnings(learnings: Learning[]): Promise<number> {
-  const apiKey = getApiKey();
-  if (!apiKey || learnings.length === 0) return 0;
-
-  try {
-    const result = await postJson(PUSH_URL, { learnings }) as any;
-    return result?.saved ?? 0;
-  } catch {
-    return 0;
-  }
-}
-
-/**
- * Push all learnings from local memory that are new, then mark them as pushed.
- * Designed to run at the end of a session or periodically.
- */
-export async function flushPendingLearnings(
-  getSentinel: () => string,
-  setSentinel: (ts: string) => void,
-): Promise<{ total: number; pushed: number }> {
-  // The caller provides access to its memory entries and passes a sentinel timestamp
-  // so we only push learnings not yet seen by the cloud.
-  return { total: 0, pushed: 0 }; // placeholder — real impl reads from SharedMemory
-}
-
-/**
- * Pull today's collective digest — what all AEGIS instances learned today.
- * Only available to Ultimate-tier users.
- *
- * Returns a formatted string suitable for display in the UI.
- */
-export async function fetchDailyDigest(): Promise<string | null> {
-  const apiKey = getApiKey();
-  if (!apiKey) return null;
-
-  try {
-    const result = await postJson(DIGEST_URL, {}) as any;
-    if (!result?.entries || !Array.isArray(result.entries)) return null;
-
-    const entries = result.entries as Learning[];
-    if (entries.length === 0) return 'No new learnings today yet.';
-
-    const byCategory: Record<string, Learning[]> = {};
-    for (const e of entries) {
-      if (!byCategory[e.category]) byCategory[e.category] = [];
-      byCategory[e.category].push(e);
-    }
-
-    const lines: string[] = [
-      `═══ AEGIS Daily Digest ═══`,
-      `${entries.length} learnings from ${new Set(entries.map(e => e.sessionId)).size} sessions`,
-      ``,
-    ];
-
-    for (const [cat, items] of Object.entries(byCategory)) {
-      lines.push(`▸ ${cat.toUpperCase()} (${items.length})`);
-      for (const item of items.slice(0, 5)) {
-        lines.push(`  • ${item.content.slice(0, 120)}`);
-        if (item.topics.length > 0) lines.push(`    [${item.topics.join(', ')}]`);
-      }
-      if (items.length > 5) lines.push(`  … and ${items.length - 5} more`);
-      lines.push('');
-    }
-
-    lines.push('═══ End Digest ═══');
-    return lines.join('\n');
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Check if we've already fetched today's digest.
- */
-export function hasFetchedToday(): boolean {
-  try {
-    if (!fs.existsSync(LAST_DIGEST_FILE)) return false;
-    const last = fs.readFileSync(LAST_DIGEST_FILE, 'utf8').trim();
-    const today = new Date().toISOString().slice(0, 10);
-    return last === today;
-  } catch { return false; }
-}
-
-/**
- * Mark digest as fetched for today.
- */
-export function markDigestFetched(): void {
-  try {
-    const dir = path.dirname(LAST_DIGEST_FILE);
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(LAST_DIGEST_FILE, new Date().toISOString().slice(0, 10));
-  } catch {}
-}

package/src/services/OllamaInstaller.ts

@@ -1,342 +0,0 @@
-/**
- * OllamaInstaller — auto-install, start, and validate Ollama when a local
- * Ollama model is selected.
- *
- * Flow:
- *  1. Detect if baseURL points to a local Ollama instance
- *  2. Ensure server is running (install if missing)
- *  3. Ensure the requested model is pulled
- *  4. Check that the model supports tools — auto-swap to best installed capable model if not
- *  5. Return the final model name to use (may differ from the input)
- */
-
-import { execSync, spawn } from 'child_process';
-import { platform } from 'os';
-
-const POLL_INTERVAL_MS = 600;
-const START_TIMEOUT_MS = 15_000;
-const TOOLS_CAPABLE_FALLBACK = 'llama3.2';
-
-// Models confirmed to NOT support tools in Ollama.
-// llama3.1 / llama3.2 / llama3.3 DO support tools; bare "llama3" does not.
-const TOOL_INCAPABLE_PATTERNS = [
-  /^llama3$/,
-  /^llama3:latest$/,
-  /^llama2(:|$)/,
-  /^codellama(:|$)/,
-  /^phi[23](:|$)/,
-  /^gemma(:|$)/,
-  /^gemma2(:|$)/,
-  /^orca-mini(:|$)/,
-  /^vicuna(:|$)/,
-];
-
-// ── Types ─────────────────────────────────────────────────────────────────────
-
-export interface OllamaModelInfo {
-  name: string;
-  supportsTools: boolean;
-  sizeGB?: number;
-  isLoaded: boolean;
-}
-
-// ── Session cache ─────────────────────────────────────────────────────────────
-// Keyed by model name. isLoaded is always fetched fresh (changes at runtime);
-// supportsTools and sizeGB are stable per model and cached after first fetch.
-
-const detailsCache = new Map<string, { supportsTools: boolean; sizeGB?: number }>();
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-export function isLocalOllamaUrl(baseURL?: string): boolean {
-  if (!baseURL) return false;
-  return (
-    baseURL.includes('localhost:11434') ||
-    baseURL.includes('127.0.0.1:11434') ||
-    baseURL.includes('0.0.0.0:11434')
-  );
-}
-
-// Strip /v1 (OpenAI-compat path) to get the Ollama server root for management APIs
-function ollamaRoot(baseURL: string): string {
-  return baseURL.replace(/\/v1\/?$/, '').replace(/\/+$/, '');
-}
-
-function log(msg: string): void {
-  process.stderr.write(`\x1b[38;2;83;74;183m[Ollama]\x1b[0m ${msg}\n`);
-}
-
-function nameMatchesBare(installed: string, bare: string): boolean {
-  return installed === bare || installed.startsWith(bare + ':') || installed === bare + ':latest';
-}
-
-async function isOllamaResponding(baseURL: string): Promise<boolean> {
-  try {
-    const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(), 2000);
-    const res = await fetch(ollamaRoot(baseURL) + '/api/tags', { signal: ctrl.signal });
-    clearTimeout(timer);
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-
-function isBinaryInstalled(): boolean {
-  try { execSync('which ollama', { stdio: 'ignore' }); return true; } catch {}
-  try { execSync('ollama --version', { stdio: 'ignore' }); return true; } catch {}
-  const paths = [
-    '/usr/local/bin/ollama',
-    '/usr/bin/ollama',
-    `${process.env.HOME}/.local/bin/ollama`,
-    `${process.env.HOME}/bin/ollama`,
-  ];
-  for (const p of paths) {
-    try { execSync(`test -x "${p}"`, { stdio: 'ignore' }); return true; } catch {}
-  }
-  return false;
-}
-
-// ── Model info fetchers ───────────────────────────────────────────────────────
-
-// /api/show — capabilities + disk size. Results cached per model name.
-async function fetchModelDetails(base: string, model: string): Promise<{ supportsTools: boolean; sizeGB?: number }> {
-  const cached = detailsCache.get(model);
-  if (cached) return cached;
-
-  try {
-    const res = await fetch(base + '/api/show', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ name: model }),
-    });
-    if (res.ok) {
-      const data = await res.json() as {
-        capabilities?: string[];
-        size?: number;
-      };
-
-      const supportsTools = Array.isArray(data.capabilities)
-        ? data.capabilities.includes('tools')
-        : !TOOL_INCAPABLE_PATTERNS.some(re => re.test(model.toLowerCase().replace(/^registry\.ollama\.ai\/library\//, '')));
-
-      const sizeGB = typeof data.size === 'number' && data.size > 0
-        ? Math.round(data.size / 1e8) / 10   // round to 1 decimal GB
-        : undefined;
-
-      const result = { supportsTools, sizeGB };
-      detailsCache.set(model, result);
-      return result;
-    }
-  } catch {}
-
-  // Fallback: name heuristic only
-  const tag = model.toLowerCase().replace(/^registry\.ollama\.ai\/library\//, '');
-  const result = { supportsTools: !TOOL_INCAPABLE_PATTERNS.some(re => re.test(tag)) };
-  detailsCache.set(model, result);
-  return result;
-}
-
-// /api/tags — all installed models with their disk sizes
-async function getInstalledModels(base: string): Promise<{ name: string; size: number }[]> {
-  try {
-    const res = await fetch(base + '/api/tags');
-    if (!res.ok) return [];
-    const data = await res.json() as { models?: { name: string; size?: number }[] };
-    return (data.models || []).map(m => ({ name: m.name, size: m.size ?? 0 }));
-  } catch {
-    return [];
-  }
-}
-
-// /api/ps — models currently loaded in memory (respond instantly, no cold-start)
-async function getLoadedModels(base: string): Promise<string[]> {
-  try {
-    const res = await fetch(base + '/api/ps');
-    if (!res.ok) return [];
-    const data = await res.json() as { models?: { name: string }[] };
-    return (data.models || []).map(m => m.name);
-  } catch {
-    return [];
-  }
-}
-
-// ── Public: enriched model list ───────────────────────────────────────────────
-
-/**
- * Returns enriched info for every model installed in a local Ollama instance.
- * Used by the /model selector to show size, tool support, and loaded status.
- * Returns [] if baseURL is not a local Ollama URL or the server is not running.
- */
-export async function getOllamaModels(baseURL?: string): Promise<OllamaModelInfo[]> {
-  if (!isLocalOllamaUrl(baseURL)) return [];
-  const base = ollamaRoot(baseURL!);
-
-  if (!await isOllamaResponding(base)) return [];
-
-  const [installed, loadedNames] = await Promise.all([
-    getInstalledModels(base),
-    getLoadedModels(base),
-  ]);
-
-  const loadedSet = new Set(loadedNames.map(n => n.split(':')[0]));
-
-  return Promise.all(
-    installed.map(async ({ name, size }) => {
-      const details = await fetchModelDetails(base, name);
-      // Use size from /api/tags if /api/show didn't return it
-      const sizeGB = details.sizeGB ?? (size > 0 ? Math.round(size / 1e8) / 10 : undefined);
-      const isLoaded = loadedSet.has(name.split(':')[0]);
-      return { name, supportsTools: details.supportsTools, sizeGB, isLoaded };
-    })
-  );
-}
-
-// ── Install ───────────────────────────────────────────────────────────────────
-
-async function installOllama(): Promise<boolean> {
-  if (isBinaryInstalled()) {
-    log('Ollama is already installed.');
-    return true;
-  }
-
-  if (platform() === 'win32') {
-    log('Auto-install not supported on Windows. Download from https://ollama.com/download');
-    return false;
-  }
-
-  log('Installing Ollama...');
-  return new Promise((resolve) => {
-    const child = spawn('sh', ['-c', 'curl -fsSL https://ollama.com/install.sh | sh'], {
-      stdio: ['ignore', 'inherit', 'inherit'],
-    });
-    child.on('close', (code) => {
-      if (code === 0) { log('Ollama installed successfully.'); resolve(true); }
-      else { log(`Install failed (exit ${code}). Try: curl -fsSL https://ollama.com/install.sh | sh`); resolve(false); }
-    });
-    child.on('error', (err) => { log(`Install error: ${err.message}`); resolve(false); });
-  });
-}
-
-// ── Start server ─────────────────────────────────────────────────────────────
-
-async function startOllamaServer(): Promise<boolean> {
-  log('Starting Ollama server...');
-  try {
-    spawn('ollama', ['serve'], { stdio: 'ignore', detached: true })
-      .on('error', () => {})
-      .unref();
-  } catch { return false; }
-
-  const deadline = Date.now() + START_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    await new Promise(r => setTimeout(r, POLL_INTERVAL_MS));
-    if (await isOllamaResponding('http://localhost:11434')) {
-      log('Ollama server is up.');
-      return true;
-    }
-  }
-  log('Ollama server did not respond in time. Try: ollama serve');
-  return false;
-}
-
-// ── Model pull ────────────────────────────────────────────────────────────────
-
-async function pullModel(modelName: string): Promise<void> {
-  const tag = modelName.replace(/^registry\.ollama\.ai\/library\//, '').split('/').pop() || modelName;
-  log(`Pulling model "${tag}" (this may take a few minutes)...`);
-  await new Promise<void>((resolve) => {
-    const child = spawn('ollama', ['pull', tag], { stdio: ['ignore', 'inherit', 'inherit'] });
-    child.on('close', (code) => {
-      if (code === 0) log(`Model "${tag}" ready.`);
-      else log(`Pull exited ${code} — run manually: ollama pull ${tag}`);
-      resolve();
-    });
-    child.on('error', () => resolve());
-  });
-}
-
-// ── Public entry point ────────────────────────────────────────────────────────
-
-/**
- * Called by Agent.initialize() before the first API request.
- *
- * Returns the model name that should actually be used — this may differ from
- * the `model` argument when the requested model does not support tools and
- * has been swapped for a capable alternative.
- *
- * Returns undefined if baseURL is not a local Ollama endpoint (no-op).
- */
-export async function ensureOllama(baseURL?: string, model?: string): Promise<string | undefined> {
-  if (!isLocalOllamaUrl(baseURL)) return undefined;
-
-  const base = ollamaRoot(baseURL!) || 'http://localhost:11434';
-
-  // ── Ensure server is up ───────────────────────────────────────────────────
-  if (!await isOllamaResponding(base)) {
-    if (isBinaryInstalled()) {
-      log('Ollama is installed but not running.');
-      if (!await startOllamaServer()) return model;
-    } else {
-      log('Ollama not found.');
-      if (!await installOllama()) return model;
-      if (!await startOllamaServer()) return model;
-    }
-  }
-
-  // ── Ensure model is pulled ────────────────────────────────────────────────
-  const installed = await getInstalledModels(base);
-  const installedNames = installed.map(m => m.name);
-  const requestedTag = (model || '').replace(/^registry\.ollama\.ai\/library\//, '');
-
-  if (installedNames.length === 0) {
-    await pullModel(requestedTag || TOOLS_CAPABLE_FALLBACK);
-  } else if (requestedTag) {
-    const bare = requestedTag.split(':')[0];
-    const exists = installedNames.some(m => nameMatchesBare(m, bare) || m === requestedTag);
-    if (!exists) await pullModel(requestedTag);
-  }
-
-  // ── Check tool support ────────────────────────────────────────────────────
-  const effectiveModel = requestedTag || TOOLS_CAPABLE_FALLBACK;
-  const { supportsTools } = await fetchModelDetails(base, effectiveModel);
-
-  if (!supportsTools) {
-    // Prefer an already-installed tool-capable model over pulling a new one
-    const freshInstalled = await getInstalledModels(base);
-    const capableFallback = await findBestInstalledCapableModel(base, freshInstalled.map(m => m.name));
-
-    if (capableFallback) {
-      log(`"${effectiveModel}" does not support tools. Switching to installed model "${capableFallback}".`);
-      return capableFallback;
-    }
-
-    // Nothing capable installed — pull the default fallback
-    log(`"${effectiveModel}" does not support tools. Pulling ${TOOLS_CAPABLE_FALLBACK}...`);
-    await pullModel(TOOLS_CAPABLE_FALLBACK);
-    return TOOLS_CAPABLE_FALLBACK;
-  }
-
-  return effectiveModel || model;
-}
-
-// Find the best already-installed model that supports tools.
-// Prefers loaded models, then prefers well-known capable models.
-async function findBestInstalledCapableModel(base: string, names: string[]): Promise<string | undefined> {
-  const loadedNames = await getLoadedModels(base);
-  const loadedSet = new Set(loadedNames.map(n => n.split(':')[0]));
-
-  const capable: string[] = [];
-  for (const name of names) {
-    const { supportsTools } = await fetchModelDetails(base, name);
-    if (supportsTools) capable.push(name);
-  }
-
-  if (capable.length === 0) return undefined;
-
-  // Prefer a currently loaded model
-  const loadedCapable = capable.find(n => loadedSet.has(n.split(':')[0]));
-  if (loadedCapable) return loadedCapable;
-
-  return capable[0];
-}