aegiscode 3.1.8 → 3.1.10

package/src/memory/AgentMemoryBus.ts

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

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

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