@mmmbuto/nexuscrew 0.1.0-beta.1 → 0.2.1

package/lib/server/services/summary-generator.js

@@ -0,0 +1,309 @@
+/**
+ * SummaryGenerator - produce contextual summaries for sessions.
+ *
+ * Features:
+ * - Generate AI titles for new conversations
+ * - Generate contextual summaries for sessions
+ * - Auto-save summaries to session_summaries table
+ * - Support for summary-based context bridging
+ *
+ * Note: AI generation requires external provider configuration.
+ * This implementation provides the structure; actual AI calls
+ * can be integrated via environment-provided clients or webhooks.
+ */
+
+const { v4: uuidv4 } = require('uuid');
+const { prepare, saveDb } = require('../db/adapter');
+
+class SummaryGenerator {
+  constructor(options = {}) {
+    this.options = options;
+    // AI client can be injected or configured later
+    this.aiClient = options.aiClient || null;
+  }
+
+  /**
+   * Set AI client for summary generation
+   * @param {Object} client - AI client with sendMessage method
+   */
+  setAIClient(client) {
+    this.aiClient = client;
+  }
+
+  /**
+   * Generate a short title for a new conversation (3-8 words)
+   * Called after first AI response, runs in background
+   * @param {string} userMessage - First user message
+   * @param {string} assistantResponse - First AI response (optional, for context)
+   * @returns {Promise<string>} Generated title
+   */
+  async generateTitle(userMessage, assistantResponse = '') {
+    const startedAt = Date.now();
+
+    // Keep context brief for fast generation
+    const context = assistantResponse
+      ? `User: ${userMessage.slice(0, 500)}\nAssistant: ${assistantResponse.slice(0, 500)}`
+      : `User: ${userMessage.slice(0, 800)}`;
+
+    const prompt = `Generate a brief title (3-8 words, no quotes) for this conversation:
+
+${context}
+
+Reply with ONLY the title, nothing else.`;
+
+    try {
+      if (!this.aiClient) {
+        console.warn('[SummaryGenerator] No AI client configured, using fallback title generation');
+        return this.fallbackTitle(userMessage);
+      }
+
+      const result = await this.aiClient.sendMessage({
+        prompt,
+        conversationId: uuidv4(), // Ephemeral session
+        model: 'haiku',
+        onStatus: () => {} // Silence status
+      });
+
+      // Clean up the response
+      let title = result.text.trim()
+        .replace(/^["']|["']$/g, '') // Remove surrounding quotes
+        .replace(/^Title:\s*/i, '') // Remove "Title:" prefix
+        .slice(0, 60); // Max 60 chars
+
+      console.log(`[SummaryGenerator] Title generated in ${Date.now() - startedAt}ms: ${title}`);
+      return title || 'New Chat';
+    } catch (error) {
+      console.error('[SummaryGenerator] Title generation failed:', error.message);
+      // Fallback to truncated first message
+      return this.fallbackTitle(userMessage);
+    }
+  }
+
+  /**
+   * Fallback title generation (simple truncation)
+   * @param {string} userMessage
+   * @returns {string}
+   */
+  fallbackTitle(userMessage) {
+    return userMessage.slice(0, 50).trim() + (userMessage.length > 50 ? '...' : '');
+  }
+
+  /**
+   * Generate or refresh summary for a session.
+   * @param {Object} params
+   * @param {string} params.conversationId
+   * @param {Array} params.messages - Array of {role, content, created_at}
+   * @param {Object|null} params.existingSummary
+   * @returns {Promise<Object>} summary payload
+   */
+  async generateSummary({ conversationId, messages = [], existingSummary = null }) {
+    if (!conversationId) throw new Error('conversationId is required');
+
+    const startedAt = Date.now();
+
+    // Build transcript snippet (limit to 40 latest messages for brevity)
+    const transcript = this.buildTranscript(messages.slice(-40));
+
+    const prompt = this.buildPrompt({ conversationId, transcript, existingSummary });
+
+    if (!this.aiClient) {
+      console.warn('[SummaryGenerator] No AI client configured, using fallback summary');
+      return this.fallbackSummary(messages);
+    }
+
+    const result = await this.aiClient.sendMessage({
+      prompt,
+      conversationId: uuidv4(), // Ephemeral session
+      model: 'haiku',
+      onStatus: () => {} // silence status for summaries
+    });
+
+    const parsed = this.safeParseJson(result.text);
+
+    console.log(`[SummaryGenerator] Summary for ${conversationId} took ${Date.now() - startedAt}ms`);
+
+    return parsed;
+  }
+
+  /**
+   * Fallback summary generation (rule-based)
+   * @param {Array} messages
+   * @returns {Object}
+   */
+  fallbackSummary(messages) {
+    const userMessages = messages.filter(m => m.role === 'user');
+    const assistantMessages = messages.filter(m => m.role === 'assistant');
+
+    // Extract first user message as summary
+    const firstUserMsg = userMessages[0]?.content || '';
+    const summary = firstUserMsg.slice(0, 200) + (firstUserMsg.length > 200 ? '...' : '');
+
+    return {
+      summary_short: summary,
+      summary_long: null,
+      key_decisions: [],
+      tools_used: [],
+      files_modified: []
+    };
+  }
+
+  /**
+   * Save summary to database
+   * @param {string} conversationId
+   * @param {Object} summary - {summary_short, summary_long, key_decisions, tools_used, files_modified}
+   * @returns {boolean} Success
+   */
+  saveSummary(conversationId, summary) {
+    try {
+      const stmt = prepare(`
+        INSERT OR REPLACE INTO session_summaries
+        (conversation_id, summary_short, key_decisions, files_modified, updated_at)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+
+      stmt.run(
+        conversationId,
+        summary.summary_short || '',
+        JSON.stringify(summary.key_decisions || []),
+        JSON.stringify(summary.files_modified || []),
+        Date.now()
+      );
+
+      saveDb();
+      console.log(`[SummaryGenerator] Saved summary for ${conversationId}`);
+      return true;
+    } catch (error) {
+      console.error(`[SummaryGenerator] Failed to save summary:`, error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Get existing summary from database
+   * @param {string} conversationId
+   * @returns {Object|null}
+   */
+  getSummary(conversationId) {
+    try {
+      const stmt = prepare('SELECT * FROM session_summaries WHERE conversation_id = ?');
+      const row = stmt.get(conversationId);
+
+      if (!row) return null;
+
+      return {
+        summary_short: row.summary_short,
+        summary_long: row.summary_long || null,
+        key_decisions: JSON.parse(row.key_decisions || '[]'),
+        files_modified: JSON.parse(row.files_modified || '[]'),
+        updated_at: row.updated_at
+      };
+    } catch (error) {
+      console.warn(`[SummaryGenerator] Failed to get summary:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Generate summary and save to DB (convenience method)
+   * @param {string} conversationId
+   * @param {Array} messages
+   * @returns {Promise<Object|null>}
+   */
+  async generateAndSave(conversationId, messages) {
+    try {
+      const existingSummary = this.getSummary(conversationId);
+      const summary = await this.generateSummary({ conversationId, messages, existingSummary });
+      this.saveSummary(conversationId, summary);
+      return summary;
+    } catch (error) {
+      console.error(`[SummaryGenerator] generateAndSave failed:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Get summary text for context bridging
+   * Returns a formatted string suitable for prefixing prompts
+   * @param {string} conversationId
+   * @returns {string|null}
+   */
+  getBridgeContext(conversationId) {
+    const summary = this.getSummary(conversationId);
+    if (!summary || !summary.summary_short) return null;
+
+    let context = `[Session Summary]\n${summary.summary_short}`;
+
+    if (summary.key_decisions && summary.key_decisions.length > 0) {
+      context += `\n\nKey decisions:\n- ${summary.key_decisions.slice(0, 5).join('\n- ')}`;
+    }
+
+    if (summary.files_modified && summary.files_modified.length > 0) {
+      context += `\n\nFiles worked on:\n- ${summary.files_modified.slice(0, 10).join('\n- ')}`;
+    }
+
+    return context;
+  }
+
+  buildTranscript(messages) {
+    return messages
+      .map(m => {
+        const role = m.role || 'assistant';
+        const content = (m.content || '').trim();
+        const ts = m.created_at ? new Date(m.created_at * 1000).toISOString() : '';
+        return `[${ts}] ${role.toUpperCase()}: ${content}`;
+      })
+      .join('\n')
+      .slice(-6000); // keep prompt size reasonable
+  }
+
+  buildPrompt({ conversationId, transcript, existingSummary }) {
+    const existing = existingSummary
+      ? `Existing summary (for refresh): ${JSON.stringify(existingSummary)}`
+      : 'No existing summary.';
+
+    return `
+You are a concise assistant. Summarize the coding/chat session into JSON.
+Conversation ID: ${conversationId}
+
+${existing}
+
+Provide JSON with keys:
+- summary_short (<=80 words)
+- summary_long (<=200 words, optional)
+- key_decisions (array of short bullet strings)
+- tools_used (array of tool names or commands, optional)
+- files_modified (array of file paths)
+
+Do not include any extra text outside valid JSON.
+
+Transcript:
+${transcript}
+`;
+  }
+
+  safeParseJson(text) {
+    // Try to extract JSON block
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    if (start === -1 || end === -1) {
+      throw new Error('Failed to parse summary JSON');
+    }
+
+    const jsonString = text.slice(start, end + 1);
+
+    try {
+      const parsed = JSON.parse(jsonString);
+      // Normalize array fields
+      ['key_decisions', 'tools_used', 'files_modified'].forEach(key => {
+        if (parsed[key] && !Array.isArray(parsed[key])) {
+          parsed[key] = [parsed[key]].filter(Boolean);
+        }
+      });
+      return parsed;
+    } catch (e) {
+      throw new Error('Invalid JSON returned by model');
+    }
+  }
+}
+
+module.exports = SummaryGenerator;

package/lib/server/services/workspace-manager.js

@@ -0,0 +1,79 @@
+/**
+ * Workspace Manager - NexusCrew tmux-based version
+ *
+ * Simplified version that discovers workspaces from conversations table
+ * instead of reading .claude/projects/ JSONL files (NexusCLI approach).
+ */
+
+const fs = require('fs');
+const { prepare } = require('../db/adapter');
+
+class WorkspaceManager {
+  /**
+   * Discover workspaces from conversations table
+   * Groups by workspace path and counts sessions
+   * @returns {Array} List of workspaces with metadata
+   */
+  discoverWorkspaces() {
+    const stmt = prepare(`
+      SELECT workspace, COUNT(*) as session_count,
+             MAX(updated_at) as last_activity
+      FROM conversations
+      WHERE workspace != '' AND workspace IS NOT NULL
+      GROUP BY workspace
+      ORDER BY last_activity DESC
+    `);
+
+    return stmt.all().map(row => ({
+      path: row.workspace,
+      session_count: row.session_count,
+      last_activity: row.last_activity
+    }));
+  }
+
+  /**
+   * Validate workspace path exists on filesystem
+   * @param {string} wsPath - Absolute path to workspace
+   * @returns {boolean} True if path exists and is a directory
+   */
+  validateWorkspace(wsPath) {
+    try {
+      return fs.statSync(wsPath).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get conversations for a specific workspace
+   * @param {string} workspace - Workspace path
+   * @returns {Array} List of conversations in workspace
+   */
+  getWorkspaceConversations(workspace) {
+    const stmt = prepare(`
+      SELECT * FROM conversations
+      WHERE workspace = ?
+      ORDER BY updated_at DESC
+    `);
+    return stmt.all(workspace);
+  }
+
+  /**
+   * Get workspace statistics
+   * @param {string} workspace - Workspace path
+   * @returns {Object} Statistics for the workspace
+   */
+  getWorkspaceStats(workspace) {
+    const stmt = prepare(`
+      SELECT
+        COUNT(*) as total_conversations,
+        SUM(CASE WHEN status = 'active' THEN 1 ELSE 0 END) as active_conversations,
+        SUM(CASE WHEN pinned = 1 THEN 1 ELSE 0 END) as pinned_conversations
+      FROM conversations
+      WHERE workspace = ?
+    `);
+    return stmt.get(workspace);
+  }
+}
+
+module.exports = WorkspaceManager;

package/lib/services/engine-discovery.js

@@ -37,6 +37,19 @@ const CLI_SEARCH_PATHS = {
   ]
 };
 
+const SHELL_SOURCES = [
+  '${HOME}/.zshrc',
+  '${HOME}/.bashrc',
+  '${HOME}/.bash_profile',
+  '${HOME}/.profile',
+  '${HOME}/.zprofile',
+  '${HOME}/.config/ai-shell/providers.zsh',
+  '${HOME}/.config/zsh/chutes-wrapper.zsh',
+  '${HOME}/.nexuscrew/providers.zsh'
+];
+
+const ENGINE_PREFIXES = ['claude', 'codex', 'gemini', 'qwen'];
+
 /**
  * Engine types:
  * - interactive: runs as REPL, needs PTY-like handling (send text + Enter)
@@ -187,25 +200,169 @@ class EngineDiscovery {
   }
 
   _parseProviders() {
-    if (!fs.existsSync(this.providersPath)) return [];
+    // Use universal shell discovery instead of single file
+    return this._discoverShellSources();
+  }
 
-    const content = fs.readFileSync(this.providersPath, 'utf8');
+  /**
+   * Discover shell aliases and functions from all standard shell config files
+   * Parses:
+   * - alias name='command' / alias name="command"
+   * - name() { ... } function definitions
+   * - Follows source/. directives (1 level)
+   * - Extracts model hints from env vars and command args
+   */
+  _discoverShellSources() {
+    const HOME = process.env.HOME || '';
     const aliases = [];
+    const processedFiles = new Set();
+
+    const searchPaths = SHELL_SOURCES.map(p =>
+      p.replace(/\$\{HOME\}/g, HOME)
+    );
 
-    // Match function definitions: name() { ... }
-    const funcRegex = /^(claude-[a-z0-9][a-z0-9-]*|codex-[a-z0-9][a-z0-9-]*|gemini-[a-z0-9][a-z0-9-]*|qwen-[a-z0-9][a-z0-9-]*)\(\)\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/gm;
+    for (const filePath of searchPaths) {
+      if (!fs.existsSync(filePath) || processedFiles.has(filePath)) continue;
+      processedFiles.add(filePath);
 
-    let match;
-    while ((match = funcRegex.exec(content)) !== null) {
-      aliases.push({
-        name: match[1],
-        command: match[2].trim()
-      });
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const lines = content.split('\n');
+
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i].trim();
+
+          // Skip comments and empty lines
+          if (!line || line.startsWith('#')) continue;
+
+          // Follow source/. directives (1 level deep)
+          if (line.startsWith('source ') || line.startsWith('. ')) {
+            const sourcedFile = line.replace(/^source\s+|^\.\s+/, '').replace(/['"]/g, '').trim();
+            const resolvedPath = sourcedFile.startsWith('~')
+              ? path.join(HOME, sourcedFile.slice(1))
+              : sourcedFile;
+
+            if (fs.existsSync(resolvedPath) && !processedFiles.has(resolvedPath)) {
+              processedFiles.add(resolvedPath);
+              try {
+                const sourcedContent = fs.readFileSync(resolvedPath, 'utf8');
+                this._parseShellContent(sourcedContent, aliases, resolvedPath);
+              } catch (err) {
+                // Skip unreadable sourced files
+              }
+            }
+            continue;
+          }
+
+          // Parse current line
+          this._parseShellLine(line, aliases, filePath);
+        }
+      } catch (err) {
+        // Skip unreadable files
+      }
     }
 
     return aliases;
   }
 
+  /**
+   * Parse a single line for aliases or functions
+   */
+  _parseShellLine(line, aliases, source) {
+    // Match: alias name='command' or alias name="command"
+    const aliasRegex = /^alias\s+([a-z0-9][a-z0-9-]*)\s*=\s*['"]([^'"]+)['"]/;
+    const aliasMatch = line.match(aliasRegex);
+    if (aliasMatch) {
+      const name = aliasMatch[1];
+      if (this._isEngineAlias(name)) {
+        aliases.push({
+          name,
+          command: aliasMatch[2],
+          source,
+          modelHint: this._extractModelHint(aliasMatch[2])
+        });
+      }
+      return;
+    }
+
+    // Match: name() { ... } (function definition - single line)
+    const funcRegex = /^([a-z0-9][a-z0-9-]*)\(\)\s*\{([^}]*)\}/;
+    const funcMatch = line.match(funcRegex);
+    if (funcMatch) {
+      const name = funcMatch[1];
+      if (this._isEngineAlias(name)) {
+        aliases.push({
+          name,
+          command: funcMatch[2].trim(),
+          source,
+          modelHint: this._extractModelHint(funcMatch[2])
+        });
+      }
+    }
+  }
+
+  /**
+   * Parse full file content for aliases and functions
+   */
+  _parseShellContent(content, aliases, source) {
+    const lines = content.split('\n');
+
+    // Multi-line function buffer
+    let inFunction = false;
+    let funcName = null;
+    let funcBody = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Skip comments and empty lines
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      // Function start
+      if (!inFunction) {
+        const funcStart = trimmed.match(/^([a-z0-9][a-z0-9-]*)\(\)\s*\{/);
+        if (funcStart) {
+          const name = funcStart[1];
+          if (this._isEngineAlias(name)) {
+            inFunction = true;
+            funcName = name;
+            funcBody = [];
+          }
+          continue;
+        }
+
+        // Single-line alias/function
+        this._parseShellLine(trimmed, aliases, source);
+      } else {
+        // Function end
+        if (trimmed === '}') {
+          inFunction = false;
+          if (funcName) {
+            aliases.push({
+              name: funcName,
+              command: funcBody.join(' ').trim(),
+              source,
+              modelHint: this._extractModelHint(funcBody.join(' '))
+            });
+            funcName = null;
+            funcBody = [];
+          }
+          continue;
+        }
+
+        // Accumulate function body
+        funcBody.push(trimmed);
+      }
+    }
+  }
+
+  /**
+   * Check if a name matches any engine prefix
+   */
+  _isEngineAlias(name) {
+    return ENGINE_PREFIXES.some(prefix => name.startsWith(prefix));
+  }
+
   _detectBaseEngine(name) {
     if (name.startsWith('claude')) return 'claude';
     if (name.startsWith('codex')) return 'codex';
@@ -257,9 +414,37 @@ class EngineDiscovery {
   }
 
   _extractModelHint(command) {
-    // Try to extract model name from the command
-    const modelMatch = command.match(/"([^"]+)"/);
-    return modelMatch ? modelMatch[1] : null;
+    if (!command) return null;
+
+    // Try quoted string first
+    const quotedMatch = command.match(/["']([^"']+)["']/);
+    if (quotedMatch) {
+      return quotedMatch[1];
+    }
+
+    // Extract from --model flag
+    const modelFlagMatch = command.match(/--model\s+(\S+)/);
+    if (modelFlagMatch) {
+      return modelFlagMatch[1];
+    }
+
+    // Extract from ANTHROPIC_MODEL env var
+    const anthropicMatch = command.match(/ANTHROPIC_MODEL\s*=\s*["']?([^"'\s]+)["']?/);
+    if (anthropicMatch) {
+      return anthropicMatch[1];
+    }
+
+    // Extract from OPENAI_API_BASE (indicates provider)
+    const openaiBaseMatch = command.match(/OPENAI_API_BASE\s*=\s*["']?([^"'\s]+)["']?/);
+    if (openaiBaseMatch) {
+      // Derive model from base URL if it's a known provider
+      const base = openaiBaseMatch[1];
+      if (base.includes('deepseek')) return 'deepseek';
+      if (base.includes('z.ai') || base.includes('glm')) return 'glm';
+      if (base.includes('alibaba') || base.includes('dashscope')) return 'qwen';
+    }
+
+    return null;
   }
 
   _buildModels(engineName, engine) {