@jhizzard/termdeck 0.2.0

package/packages/server/src/rag.js

@@ -0,0 +1,216 @@
+// RAG integration - multi-layer memory system
+// Layers: session → project → developer (cross-project)
+// Syncs to Supabase tables with configurable namespaces
+
+const { logRagEvent, getUnsyncedRagEvents, markRagEventsSynced } = require('./database');
+
+class RAGIntegration {
+  constructor(config, db) {
+    this.config = config;
+    this.db = db;
+    this.supabaseUrl = config.rag?.supabaseUrl || null;
+    this.supabaseKey = config.rag?.supabaseKey || null;
+    this.enabled = !!(config.rag?.enabled && this.supabaseUrl && this.supabaseKey);
+    this.syncInterval = config.rag?.syncIntervalMs || 10000;
+    this._syncTimer = null;
+
+    // Table configuration matching Josh's multi-layer schema
+    this.tables = {
+      sessionMemory: config.rag?.tables?.session || 'engram_session_memory',
+      projectMemory: config.rag?.tables?.project || 'engram_project_memory',
+      developerMemory: config.rag?.tables?.developer || 'engram_developer_memory',
+      commandLog: config.rag?.tables?.commands || 'engram_commands'
+    };
+
+    if (this.enabled) {
+      this._startSync();
+    }
+  }
+
+  // Record an event locally (always works, even offline)
+  record(sessionId, eventType, payload, project) {
+    if (!this.db) return;
+
+    logRagEvent(this.db, sessionId, eventType, payload, project);
+
+    // Also attempt immediate push if enabled
+    if (this.enabled) {
+      this._pushEvent({
+        session_id: sessionId,
+        event_type: eventType,
+        payload,
+        project,
+        timestamp: new Date().toISOString()
+      }).catch(() => {}); // Silent fail, sync will retry
+    }
+  }
+
+  // Event types to record
+  onSessionCreated(session) {
+    this.record(session.id, 'session_created', {
+      type: session.meta.type,
+      command: session.meta.command,
+      cwd: session.meta.cwd,
+      reason: session.meta.reason
+    }, session.meta.project);
+  }
+
+  onCommandExecuted(session, command, outputSnippet) {
+    this.record(session.id, 'command_executed', {
+      command,
+      output_snippet: outputSnippet?.slice(0, 500), // Truncate for storage
+      type: session.meta.type
+    }, session.meta.project);
+  }
+
+  onStatusChanged(session, oldStatus, newStatus) {
+    this.record(session.id, 'status_changed', {
+      from: oldStatus,
+      to: newStatus,
+      detail: session.meta.statusDetail,
+      type: session.meta.type
+    }, session.meta.project);
+  }
+
+  onSessionEnded(session) {
+    this.record(session.id, 'session_ended', {
+      type: session.meta.type,
+      duration_ms: Date.now() - new Date(session.meta.createdAt).getTime(),
+      command_count: session.meta.lastCommands.length,
+      exit_code: session.meta.exitCode
+    }, session.meta.project);
+  }
+
+  onFileEdited(session, filepath, editType) {
+    this.record(session.id, 'file_edited', {
+      filepath,
+      edit_type: editType,
+      type: session.meta.type
+    }, session.meta.project);
+  }
+
+  // Push a single event to Supabase
+  async _pushEvent(event) {
+    if (!this.enabled) return;
+
+    const layer = this._determineLayer(event);
+    const table = this.tables[layer];
+
+    try {
+      const response = await fetch(`${this.supabaseUrl}/rest/v1/${table}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'apikey': this.supabaseKey,
+          'Authorization': `Bearer ${this.supabaseKey}`,
+          'Prefer': 'return=minimal'
+        },
+        body: JSON.stringify({
+          session_id: event.session_id,
+          event_type: event.event_type,
+          payload: typeof event.payload === 'string' ? event.payload : JSON.stringify(event.payload),
+          project: event.project,
+          timestamp: event.timestamp,
+          developer_id: this.config.rag?.developerId || 'default'
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`Supabase responded ${response.status}`);
+      }
+    } catch (err) {
+      // Will be retried by sync loop
+      console.error('[engram] Push failed:', err.message);
+    }
+  }
+
+  // Determine which memory layer an event belongs to
+  _determineLayer(event) {
+    // File edits and significant commands → project memory (shared across sessions)
+    if (event.event_type === 'file_edited' || event.event_type === 'command_executed') {
+      return 'projectMemory';
+    }
+    // Session lifecycle → session memory
+    if (event.event_type === 'session_created' || event.event_type === 'session_ended') {
+      return 'sessionMemory';
+    }
+    // Status changes, errors → developer memory (cross-project patterns)
+    return 'developerMemory';
+  }
+
+  // Periodic sync of unsynced events
+  _startSync() {
+    this._syncTimer = setInterval(async () => {
+      try {
+        const events = getUnsyncedRagEvents(this.db);
+        if (events.length === 0) return;
+
+        const synced = [];
+        for (const event of events) {
+          try {
+            await this._pushEvent({
+              ...event,
+              payload: JSON.parse(event.payload)
+            });
+            synced.push(event.id);
+          } catch (err) {
+            console.error('[rag] sync push failed for event', event.id + ':', err);
+            break; // Stop on first failure, retry next cycle
+          }
+        }
+
+        if (synced.length > 0) {
+          markRagEventsSynced(this.db, synced);
+        }
+      } catch (err) {
+        console.error('[engram] Sync cycle error:', err.message);
+      }
+    }, this.syncInterval);
+  }
+
+  // Query cross-project context (for the prompt bar AI features)
+  async queryContext(query, options = {}) {
+    if (!this.enabled) return [];
+
+    const table = options.project
+      ? this.tables.projectMemory
+      : this.tables.developerMemory;
+
+    try {
+      // Uses Supabase's full-text search or pgvector if configured
+      const params = new URLSearchParams({
+        select: '*',
+        order: 'timestamp.desc',
+        limit: options.limit || 20
+      });
+
+      if (options.project) {
+        params.append('project', `eq.${options.project}`);
+      }
+
+      const response = await fetch(
+        `${this.supabaseUrl}/rest/v1/${table}?${params}`,
+        {
+          headers: {
+            'apikey': this.supabaseKey,
+            'Authorization': `Bearer ${this.supabaseKey}`
+          }
+        }
+      );
+
+      if (!response.ok) return [];
+      return await response.json();
+    } catch (err) {
+      console.error('[rag] queryContext failed:', err);
+      return [];
+    }
+  }
+
+  stop() {
+    if (this._syncTimer) {
+      clearInterval(this._syncTimer);
+    }
+  }
+}
+
+module.exports = { RAGIntegration };

package/packages/server/src/session-logger.js

@@ -0,0 +1,166 @@
+// Session-log summarizer (T2.5 / Tier 1 feature).
+// On session exit, writes a markdown session log to ~/.termdeck/sessions/.
+// Optional LLM summary via Anthropic if ANTHROPIC_API_KEY is set.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+let warnedNoKey = false;
+
+function slugify(str) {
+  return String(str || 'session')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40) || 'session';
+}
+
+function buildMarkdown({ session, summary, commands, edits, errors }) {
+  const meta = session.meta;
+  const opened = meta.createdAt;
+  const closed = new Date().toISOString();
+  const lines = [];
+  lines.push('---');
+  lines.push(`session_id: ${session.id}`);
+  lines.push(`project: ${meta.project || ''}`);
+  lines.push(`type: ${meta.type}`);
+  lines.push(`opened_at: ${opened}`);
+  lines.push(`closed_at: ${closed}`);
+  lines.push(`command_count: ${commands.length}`);
+  if (meta.exitCode !== null && meta.exitCode !== undefined) {
+    lines.push(`exit_code: ${meta.exitCode}`);
+  }
+  lines.push('---');
+  lines.push('');
+  lines.push(`# TermDeck session ${session.id.slice(0, 8)} — ${meta.label || meta.type}`);
+  lines.push('');
+  lines.push('## What ran');
+  lines.push('');
+  if (commands.length === 0) {
+    lines.push('_(no commands recorded)_');
+  } else {
+    for (const c of commands) {
+      const ts = c.timestamp || c.created_at || '';
+      lines.push(`- \`${c.command}\`${ts ? ` — ${ts}` : ''}`);
+    }
+  }
+  lines.push('');
+  lines.push('## What was edited');
+  lines.push('');
+  if (edits.length === 0) {
+    lines.push('_(no edits detected)_');
+  } else {
+    for (const e of edits) lines.push(`- ${e}`);
+  }
+  lines.push('');
+  lines.push('## What errored');
+  lines.push('');
+  if (errors.length === 0) {
+    lines.push('_(no errors detected)_');
+  } else {
+    for (const e of errors) lines.push(`- ${e}`);
+  }
+  lines.push('');
+  if (summary) {
+    lines.push('## Summary');
+    lines.push('');
+    lines.push(summary);
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+async function summarizeWithLLM({ session, commands, edits, errors, model, apiKey }) {
+  const prompt = [
+    `You are summarizing a TermDeck terminal session in 2-4 sentences.`,
+    `Session type: ${session.meta.type}`,
+    `Project: ${session.meta.project || 'untagged'}`,
+    `Commands (${commands.length}): ${commands.slice(-20).map((c) => c.command).join(' | ')}`,
+    `Edits: ${edits.slice(-10).join(' | ') || 'none'}`,
+    `Errors: ${errors.slice(-5).join(' | ') || 'none'}`,
+    `Write a concise summary of what the user accomplished, what broke, and what state the session ended in.`
+  ].join('\n');
+
+  const res = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01'
+    },
+    body: JSON.stringify({
+      model: model || 'claude-haiku-4-5',
+      max_tokens: 400,
+      messages: [{ role: 'user', content: prompt }]
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Anthropic API ${res.status}: ${body}`);
+  }
+  const data = await res.json();
+  const block = data.content?.[0];
+  return block?.text?.trim() || '';
+}
+
+function writeSessionLog({ session, config, db, getSessionHistory }) {
+  try {
+    const enabled = config.sessionLogs?.enabled === true || process.env.TERMDECK_SESSION_LOGS === '1';
+    if (!enabled) return;
+
+    const sessionsDir = path.join(os.homedir(), '.termdeck', 'sessions');
+    fs.mkdirSync(sessionsDir, { recursive: true });
+
+    const commands = (db && typeof getSessionHistory === 'function')
+      ? getSessionHistory(db, session.id).slice().reverse()
+      : session.meta.lastCommands.slice();
+
+    // Heuristics: classify commands as edits or errors (also scan command output snippets)
+    const edits = [];
+    const errors = [];
+    for (const c of commands) {
+      const text = `${c.command || ''} ${c.output_snippet || ''}`;
+      if (/\b(vim|nano|nvim|code|edit|Edit |Create |Update |Delete )\b/.test(text)) {
+        edits.push(c.command);
+      }
+      if (/\b(error|Error|fatal|Traceback|panic|ECONN|ENOENT)\b/.test(text)) {
+        errors.push(c.command);
+      }
+    }
+
+    const apiKey = config.rag?.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+    const model = config.sessionLogs?.summaryModel || 'claude-haiku-4-5';
+
+    const finishWrite = (summary) => {
+      const markdown = buildMarkdown({ session, summary, commands, edits, errors });
+      const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+      const slug = slugify(session.meta.label || session.meta.type);
+      const filename = `${ts}-${session.id.slice(0, 8)}-${slug}.md`;
+      const filepath = path.join(sessionsDir, filename);
+      fs.writeFileSync(filepath, markdown, 'utf-8');
+      console.log(`[session-logger] wrote ${filepath}`);
+    };
+
+    if (!apiKey) {
+      if (!warnedNoKey) {
+        console.warn('[session-logger] ANTHROPIC_API_KEY not set — writing logs without LLM summary');
+        warnedNoKey = true;
+      }
+      finishWrite(null);
+      return;
+    }
+
+    // Fire-and-forget: do not block session teardown
+    summarizeWithLLM({ session, commands, edits, errors, model, apiKey })
+      .then((summary) => finishWrite(summary))
+      .catch((err) => {
+        console.warn('[session-logger] LLM summary failed, writing without summary:', err.message);
+        finishWrite(null);
+      });
+  } catch (err) {
+    console.error('[session-logger] writeSessionLog failed:', err);
+  }
+}
+
+module.exports = { writeSessionLog };