aegiscode 3.1.7 → 3.1.10

package/src/services/LearningCollector.ts

@@ -0,0 +1,291 @@
+/**
+ * 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

@@ -0,0 +1,342 @@
+/**
+ * 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];
+}