aegiscode 3.1.10 → 3.4.2

package/src/memory/AgentMemoryBus.ts

@@ -1,432 +0,0 @@
-/**
- * AgentMemoryBus — Shared memory bus for multi-agent communication
- *
- * Purpose:
- *   Allows multiple agents (Orchestrator sub-agents, Council members)
- *   to read/write shared contextual memory in real-time.
- *
- * Design:
- *   - In-memory fast cache for active session + SQLite persistence
- *   - Channels: each agent publishes to typed channels
- *   - Sub-agents automatically get relevant context from prior agents
- *   - Supports TTL-based expiration, importance scoring, cross-referencing
- *
- * Integration with existing SharedMemory:
- *   AgentMemoryBus uses SharedMemory as its persistent backing store,
- *   adding a lightweight pub/sub layer on top for multi-agent coordination.
- */
-
-import { sharedMemory, type MemoryEntry } from './SharedMemory.js';
-import { v4 as uuid } from 'uuid';
-import { agentDebug } from '../utils/debug.js';
-
-// ── Types ────────────────────────────────────────────────────────────────────
-
-export type AgentChannel =
-  | 'decision'       // Agent decisions / conclusions
-  | 'fact'           // Facts discovered during work
-  | 'context'        // Contextual information (files, code, env)
-  | 'intermediate'   // Intermediate results
-  | 'error'          // Errors encountered
-  | 'question'       // Questions to other agents
-  | 'suggestion';    // Suggestions for next steps
-
-export interface AgentMemoryMessage {
-  id: string;
-  channel: AgentChannel;
-  sourceAgent: string;
-  targetAgent?: string;        // If specified, only this agent should consume
-  sessionId: string;
-  content: string;
-  timestamp: string;
-  importance: number;
-  references?: string[];        // IDs of related messages
-  ttl?: number;                 // Seconds until auto-expire (0 = forever)
-  tags?: string[];
-  metadata?: Record<string, unknown>;
-}
-
-export interface AgentMemoryQuery {
-  channels?: AgentChannel[];
-  sourceAgent?: string;
-  targetAgent?: string;
-  sessionId?: string;
-  query?: string;              // Free-text search
-  limit?: number;
-  minImportance?: number;
-  maxAgeSeconds?: number;
-}
-
-// ── In-memory fast cache ─────────────────────────────────────────────────────
-
-interface CacheEntry {
-  msg: AgentMemoryMessage;
-  expiresAt: number; // 0 = never
-}
-
-class MemoryCache {
-  private cache = new Map<string, CacheEntry>();
-  private byChannel = new Map<AgentChannel, Set<string>>();
-  private bySession = new Map<string, Set<string>>();
-  private bySource = new Map<string, Set<string>>();
-
-  put(msg: AgentMemoryMessage): void {
-    const expiresAt = msg.ttl && msg.ttl > 0 ? Date.now() + msg.ttl * 1000 : 0;
-    this.cache.set(msg.id, { msg, expiresAt });
-
-    if (!this.byChannel.has(msg.channel)) this.byChannel.set(msg.channel, new Set());
-    this.byChannel.get(msg.channel)!.add(msg.id);
-
-    if (!this.bySession.has(msg.sessionId)) this.bySession.set(msg.sessionId, new Set());
-    this.bySession.get(msg.sessionId)!.add(msg.id);
-
-    if (!this.bySource.has(msg.sourceAgent)) this.bySource.set(msg.sourceAgent, new Set());
-    this.bySource.get(msg.sourceAgent)!.add(msg.id);
-  }
-
-  get(id: string): AgentMemoryMessage | null {
-    const entry = this.cache.get(id);
-    if (!entry) return null;
-    if (entry.expiresAt > 0 && Date.now() > entry.expiresAt) {
-      this.cache.delete(id);
-      return null;
-    }
-    return entry.msg;
-  }
-
-  query(q: AgentMemoryQuery): AgentMemoryMessage[] {
-    this.evictExpired();
-
-    let candidateIds = new Set(this.cache.keys());
-
-    if (q.channels && q.channels.length > 0) {
-      const channelIds = new Set<string>();
-      for (const ch of q.channels) {
-        const ids = this.byChannel.get(ch);
-        if (ids) for (const id of ids) channelIds.add(id);
-      }
-      candidateIds = intersect(candidateIds, channelIds);
-    }
-
-    if (q.sessionId) {
-      const sessionIds = this.bySession.get(q.sessionId);
-      candidateIds = sessionIds
-        ? intersect(candidateIds, sessionIds)
-        : new Set();
-    }
-
-    if (q.sourceAgent) {
-      const sourceIds = this.bySource.get(q.sourceAgent);
-      candidateIds = sourceIds
-        ? intersect(candidateIds, sourceIds)
-        : new Set();
-    }
-
-    if (q.targetAgent) {
-      const filtered = new Set<string>();
-      for (const id of candidateIds) {
-        const msg = this.cache.get(id)?.msg;
-        if (msg && (!msg.targetAgent || msg.targetAgent === q.targetAgent)) {
-          filtered.add(id);
-        }
-      }
-      candidateIds = filtered;
-    }
-
-    let results = Array.from(candidateIds)
-      .map(id => this.cache.get(id)!.msg)
-      .filter(msg => {
-        if (q.minImportance !== undefined && msg.importance < q.minImportance) return false;
-        if (q.maxAgeSeconds !== undefined) {
-          const age = (Date.now() - new Date(msg.timestamp).getTime()) / 1000;
-          if (age > q.maxAgeSeconds) return false;
-        }
-        return true;
-      });
-
-    // Free-text filter
-    if (q.query) {
-      const lower = q.query.toLowerCase();
-      results = results.filter(m =>
-        m.content.toLowerCase().includes(lower) ||
-        (m.tags || []).some(t => t.toLowerCase().includes(lower))
-      );
-    }
-
-    // Sort by importance desc, then timestamp desc
-    results.sort((a, b) => {
-      const imp = b.importance - a.importance;
-      if (imp !== 0) return imp;
-      return b.timestamp.localeCompare(a.timestamp);
-    });
-
-    return results.slice(0, q.limit || 20);
-  }
-
-  clearSession(sessionId: string): void {
-    const ids = this.bySession.get(sessionId);
-    if (!ids) return;
-    for (const id of ids) {
-      const msg = this.cache.get(id)?.msg;
-      if (msg) {
-        this.byChannel.get(msg.channel)?.delete(id);
-        this.bySource.get(msg.sourceAgent)?.delete(id);
-        this.cache.delete(id);
-      }
-    }
-    this.bySession.delete(sessionId);
-  }
-
-  size(): number {
-    this.evictExpired();
-    return this.cache.size;
-  }
-
-  private evictExpired(): void {
-    const now = Date.now();
-    for (const [id, entry] of this.cache) {
-      if (entry.expiresAt > 0 && now > entry.expiresAt) {
-        const msg = entry.msg;
-        this.byChannel.get(msg.channel)?.delete(id);
-        this.bySession.get(msg.sessionId)?.delete(id);
-        this.bySource.get(msg.sourceAgent)?.delete(id);
-        this.cache.delete(id);
-      }
-    }
-  }
-}
-
-function intersect(a: Set<string>, b: Set<string>): Set<string> {
-  const result = new Set<string>();
-  for (const item of a) {
-    if (b.has(item)) result.add(item);
-  }
-  return result;
-}
-
-// ── AgentMemoryBus ───────────────────────────────────────────────────────────
-
-export class AgentMemoryBus {
-  private cache: MemoryCache;
-  private subscribers: Map<AgentChannel, Set<(msg: AgentMemoryMessage) => void>> = new Map();
-  private globalSubscribers: Set<(msg: AgentMemoryMessage) => void> = new Set();
-  private persistenceEnabled: boolean;
-
-  constructor(persistToSharedMemory = true) {
-    this.cache = new MemoryCache();
-    this.persistenceEnabled = persistToSharedMemory;
-  }
-
-  /**
-   * Publish a message to the shared memory bus.
-   * Stored in fast cache + optionally persisted to SharedMemory SQLite.
-   */
-  async publish(msg: Omit<AgentMemoryMessage, 'id' | 'timestamp'>): Promise<AgentMemoryMessage> {
-    const full: AgentMemoryMessage = {
-      ...msg,
-      id: uuid(),
-      timestamp: new Date().toISOString(),
-    };
-
-    // 1. Fast in-memory cache
-    this.cache.put(full);
-
-    // 2. Notify subscribers
-    this.notifySubscribers(full);
-
-    // 3. Persist to SharedMemory SQLite (if enabled)
-    if (this.persistenceEnabled) {
-      const channelTag = `agent:${msg.channel}`;
-      const sourceTag = `agent:${msg.sourceAgent}`;
-      const tags = [...(msg.tags || []), channelTag, sourceTag];
-      if (msg.targetAgent) tags.push(`target:${msg.targetAgent}`);
-
-      const importance = msg.importance;
-
-      // Store as a memory entry so it appears in semantic search
-      sharedMemory.add(
-        `[AgentBus:${msg.channel}] [${msg.sourceAgent}]${msg.targetAgent ? ` → ${msg.targetAgent}` : ''}: ${msg.content}`,
-        `agent-bus-${msg.channel}`,
-        msg.sessionId,
-        tags,
-        'assistant',
-        false, // defer commit for batching
-      ).catch(() => {});
-
-      // High-importance items get stored with extra metadata
-      if (importance >= 0.7) {
-        sharedMemory.add(
-          `[AgentBus:${msg.channel}] [DECISION] ${msg.sourceAgent}: ${msg.content}`,
-          'agent-bus-decision',
-          msg.sessionId,
-          [...tags, 'high-importance', 'decision'],
-          'assistant',
-          true,
-        ).catch(() => {});
-      }
-    }
-
-    return full;
-  }
-
-  /**
-   * Query messages from the shared memory bus (cache + persistent)
-   */
-  async query(q: AgentMemoryQuery): Promise<AgentMemoryMessage[]> {
-    // 1. Get from fast cache
-    const cached = this.cache.query(q);
-
-    // 2. If we need more, search SharedMemory
-    if (cached.length < (q.limit || 20) && this.persistenceEnabled) {
-      const searchQuery = q.query || q.channels?.join(' ') || '';
-      const persisted = await sharedMemory.search(
-        `AgentBus ${searchQuery}`,
-        (q.limit || 20) - cached.length
-      );
-
-      // Convert MemoryEntry → AgentMemoryMessage (best-effort)
-      const fromPersisted: AgentMemoryMessage[] = persisted
-        .filter(e => e.content.startsWith('[AgentBus'))
-        .map(e => this.entryToMessage(e))
-        .filter((m): m is AgentMemoryMessage => m !== null);
-
-      // Merge, deduplicate by ID
-      const seen = new Set(cached.map(m => m.id));
-      for (const m of fromPersisted) {
-        if (!seen.has(m.id)) {
-          cached.push(m);
-          seen.add(m.id);
-        }
-      }
-    }
-
-    return cached;
-  }
-
-  /**
-   * Subscribe to messages on a specific channel
-   */
-  subscribe(channel: AgentChannel, callback: (msg: AgentMemoryMessage) => void): () => void {
-    if (!this.subscribers.has(channel)) {
-      this.subscribers.set(channel, new Set());
-    }
-    this.subscribers.get(channel)!.add(callback);
-    return () => this.subscribers.get(channel)?.delete(callback);
-  }
-
-  /**
-   * Subscribe to all channels
-   */
-  subscribeAll(callback: (msg: AgentMemoryMessage) => void): () => void {
-    this.globalSubscribers.add(callback);
-    return () => this.globalSubscribers.delete(callback);
-  }
-
-  /**
-   * Get context for an agent: relevant messages from other agents in the same session
-   */
-  async getContextForAgent(
-    agentName: string,
-    sessionId: string,
-    limit = 10,
-    maxAgeSeconds = 300, // last 5 minutes by default
-  ): Promise<string> {
-    const relevant = await this.query({
-      sessionId,
-      limit,
-      maxAgeSeconds,
-    });
-
-    // Filter out messages from the requesting agent
-    const others = relevant.filter(m => m.sourceAgent !== agentName);
-
-    if (others.length === 0) return '';
-
-    const lines: string[] = [
-      '--- AGENT MEMORY (shared context from other agents) ---',
-    ];
-
-    for (const m of others) {
-      const target = m.targetAgent ? ` → ${m.targetAgent}` : '';
-      lines.push(
-        `[${m.channel}] ${m.sourceAgent}${target} (${m.timestamp.slice(11, 19)}): ${m.content.slice(0, 300)}`
-      );
-      if (m.importance >= 0.8) lines.push(`  ⭐ Important: ${m.content.slice(0, 200)}`);
-    }
-
-    lines.push('--- END AGENT MEMORY ---');
-    return lines.join('\n');
-  }
-
-  /**
-   * Clear all messages for a session
-   */
-  clearSession(sessionId: string): void {
-    this.cache.clearSession(sessionId);
-  }
-
-  /**
-   * Get stats
-   */
-  stats(): { cacheSize: number; subscribers: number; channels: number } {
-    let subCount = this.globalSubscribers.size;
-    for (const subs of this.subscribers.values()) {
-      subCount += subs.size;
-    }
-    return {
-      cacheSize: this.cache.size(),
-      subscribers: subCount,
-      channels: this.subscribers.size,
-    };
-  }
-
-  // ── Private ──────────────────────────────────────────────────────────────
-
-  private notifySubscribers(msg: AgentMemoryMessage): void {
-    // Channel-specific
-    const channelSubs = this.subscribers.get(msg.channel);
-    if (channelSubs) {
-      for (const cb of channelSubs) {
-        try { cb(msg); } catch { /* subscriber error */ }
-      }
-    }
-    // Global
-    for (const cb of this.globalSubscribers) {
-      try { cb(msg); } catch { /* subscriber error */ }
-    }
-  }
-
-  private entryToMessage(entry: MemoryEntry): AgentMemoryMessage | null {
-    try {
-      const content = entry.content;
-      // Two stored formats:
-      //   normal:   [AgentBus:channel] [sourceAgent] → targetAgent?: body
-      //   decision: [AgentBus:channel] [DECISION] sourceAgent: body
-      const channelMatch = content.match(/^\[AgentBus:(\w+)\]/);
-      const decisionMatch = content.match(/\[DECISION\] (\w+):/);
-      const sourceMatch = decisionMatch ?? content.match(/\] \[(\w+)\]/);
-      const targetMatch = content.match(/\] → (\w+):/);
-      const contentStart = content.indexOf(': ', content.lastIndexOf(']'));
-
-      if (!channelMatch || !sourceMatch) return null;
-
-      return {
-        id: entry.id,
-        channel: channelMatch[1] as AgentChannel,
-        sourceAgent: sourceMatch[1],
-        targetAgent: targetMatch ? targetMatch[1] : undefined,
-        sessionId: entry.session,
-        content: contentStart > 0 ? content.slice(contentStart + 2) : content,
-        timestamp: entry.timestamp,
-        importance: entry.importance || 0.5,
-        tags: entry.tags,
-      };
-    } catch {
-      return null;
-    }
-  }
-}
-
-// ── Singleton ────────────────────────────────────────────────────────────────
-
-export const agentMemoryBus = new AgentMemoryBus(true);

package/src/memory/CloudSync.ts

@@ -1,99 +0,0 @@
-/**
- * AEGIS Memory Cloud Sync
- *
- * Pushes/pulls SharedMemory entries through aegiscloud.org so memory is
- * shared across devices (CLI + mobile) for subscribed users. Best-effort:
- * failures are swallowed, matching DriveSync's "silent fail — optional"
- * pattern. Never blocks the main session — callers fire-and-forget.
- */
-import type { MemoryEntry } from './SharedMemory.js';
-
-const MEMORY_API_BASE = process.env.AEGIS_MEMORY_API_BASE || 'https://aegiscloud.org/api/memory';
-
-// Embeddings are 384 floats — as JSON that's ~7KB per entry. The server only
-// ever does keyword (LIKE) search/dashboard listing on memory_entries, never
-// vector similarity, so transmitting them bloats every push for zero server-side
-// benefit. A bulk upload of a few thousand entries turned tens of MB of pure
-// embedding JSON across many sequential requests, which is what was actually
-// timing out — not a network problem. Dropping it: a device that pulls this
-// entry down just lacks a precomputed vector locally (falls back to keyword
-// search for it, same as any entry whose embedder failed at add()-time).
-function stripEmbedding(entries: MemoryEntry[]): Omit<MemoryEntry, 'embedding'>[] {
-  return entries.map(({ embedding, ...rest }) => rest);
-}
-
-export async function pushEntries(entries: MemoryEntry[], apiKey: string): Promise<void> {
-  if (entries.length === 0) return;
-  try {
-    await fetch(`${MEMORY_API_BASE}/save`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
-      body: JSON.stringify({ entries: stripEmbedding(entries) }),
-    });
-  } catch {
-    // silent fail — sync is optional, local memory already has the entry
-  }
-}
-
-/** Like pushEntries, but reports how many entries the server actually saved (for bulk uploads). */
-export async function pushBatch(entries: MemoryEntry[], apiKey: string): Promise<number> {
-  if (entries.length === 0) return 0;
-  try {
-    // A bulk upload can be many sequential batches — one slow/hung request
-    // without its own timeout would stall the whole pushAll() loop indefinitely,
-    // regardless of any timeout the caller process is given from outside.
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 20_000);
-    let res: Response;
-    try {
-      res = await fetch(`${MEMORY_API_BASE}/save`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
-        body: JSON.stringify({ entries: stripEmbedding(entries) }),
-        signal: controller.signal,
-      });
-    } finally {
-      clearTimeout(timer);
-    }
-    if (!res.ok) return 0;
-    const data = await res.json() as { saved?: number };
-    return data.saved ?? 0;
-  } catch {
-    return 0;
-  }
-}
-
-export async function pullSince(since: string | null, apiKey: string): Promise<MemoryEntry[]> {
-  try {
-    const res = await fetch(`${MEMORY_API_BASE}/pull`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
-      body: JSON.stringify(since ? { since } : {}),
-    });
-    if (!res.ok) return [];
-    const data = await res.json() as { entries?: MemoryEntry[] };
-    return data.entries ?? [];
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Keyword search against the caller's synced entries (catches entries written on
- * another device since the last `pullSince`). Caller is responsible for merging
- * with local results — this never throws, just returns [] on any failure.
- */
-export async function searchCloud(query: string, limit: number, apiKey: string): Promise<MemoryEntry[]> {
-  try {
-    const res = await fetch(`${MEMORY_API_BASE}/search`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
-      body: JSON.stringify({ query, limit }),
-    });
-    if (!res.ok) return [];
-    const data = await res.json() as { entries?: MemoryEntry[] };
-    return data.entries ?? [];
-  } catch {
-    return [];
-  }
-}

package/src/memory/DriveSync.ts

@@ -1,106 +0,0 @@
-/**
- * AEGIS Drive Sync
- * Uploads conversation sessions to user's Google Drive
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import * as https from 'https';
-
-const CONFIG_PATH = path.join(os.homedir(), '.aegiscode', 'config.json');
-const SESSIONS_DIR = path.join(os.homedir(), '.aegis', 'projects');
-
-function getConfig() {
-  try { return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8')); }
-  catch { return {}; }
-}
-
-async function getDriveToken(): Promise<string | null> {
-  const cfg = getConfig();
-  const apiKey = cfg?.aegiscloud?.api_key || process.env.AEGISCLOUD_API_KEY;
-  if (!apiKey) return null;
-  return new Promise((resolve) => {
-    const req = https.request({
-      hostname: 'aegiscloud.org',
-      path: '/api/drive/token',
-      method: 'GET',
-      headers: { 'X-API-Key': apiKey }
-    }, res => {
-      let data = '';
-      res.on('data', c => data += c);
-      res.on('end', () => {
-        try {
-          const d = JSON.parse(data);
-          resolve(d.connected ? d.access_token : null);
-        } catch { resolve(null); }
-      });
-    });
-    req.on('error', () => resolve(null));
-    req.end();
-  });
-}
-
-
-async function uploadToDrive(token: string, filename: string, content: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const boundary = '-------aegis_boundary';
-    const metadata = JSON.stringify({ name: filename, parents: ['root'] });
-    const body = [
-      `--${boundary}`,
-      'Content-Type: application/json; charset=UTF-8',
-      '',
-      metadata,
-      `--${boundary}`,
-      'Content-Type: text/plain',
-      '',
-      content,
-      `--${boundary}--`,
-    ].join('\r\n');
-
-    const req = https.request({
-      hostname: 'www.googleapis.com',
-      path: '/upload/drive/v3/files?uploadType=multipart',
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${token}`,
-        'Content-Type': `multipart/related; boundary=${boundary}`,
-        'Content-Length': Buffer.byteLength(body),
-      }
-    }, res => {
-      let data = '';
-      res.on('data', c => data += c);
-      res.on('end', () => {
-        if (res.statusCode === 200 || res.statusCode === 201) resolve();
-        else reject(new Error(`Drive upload failed: ${res.statusCode}`));
-      });
-    });
-    req.on('error', reject);
-    req.write(body);
-    req.end();
-  });
-}
-
-export async function syncSessionToDrive(sessionId: string): Promise<void> {
-  const token = await getDriveToken();
-  if (!token) return;
-  
-  // Find session file
-  const projects = fs.readdirSync(SESSIONS_DIR).filter(d => 
-    fs.statSync(path.join(SESSIONS_DIR, d)).isDirectory()
-  );
-
-  for (const project of projects) {
-    const sessionFile = path.join(SESSIONS_DIR, project, `${sessionId}.jsonl`);
-    if (fs.existsSync(sessionFile)) {
-      const content = fs.readFileSync(sessionFile, 'utf8');
-      const filename = `AEGIS/${project}/${sessionId}.jsonl`;
-      try {
-        await uploadToDrive(token, filename, content);
-        console.log(`\x1b[38;2;68;64;90m[Drive] Synced ${sessionId}\x1b[0m`);
-      } catch(e) {
-        // Silent fail — Drive sync is optional
-      }
-      return;
-    }
-  }
-}