crewswarm 0.8.1-beta

package/lib/bridges/integration.mjs

@@ -0,0 +1,229 @@
+/**
+ * Bridge Integration — Modular Project Message Saving
+ * 
+ * Provides a unified interface for all bridges (Telegram, WhatsApp, Slack, Discord)
+ * to save conversations to project RAG automatically.
+ * 
+ * Usage:
+ *   import { saveBridgeMessage } from './lib/bridges/integration.mjs';
+ *   saveBridgeMessage('telegram', projectId, chatId, role, content, agent, metadata);
+ */
+
+import { saveProjectMessage } from '../chat/project-messages.mjs';
+import { indexProjectMessage } from '../chat/project-messages-rag.mjs';
+
+/**
+ * Platform-specific configuration
+ */
+const PLATFORM_CONFIG = {
+  telegram: {
+    enabled: true,
+    sourcePrefix: 'telegram-topic',
+    excludeAgents: ['crew-loco'], // Chat-only agents
+    icon: '📱'
+  },
+  whatsapp: {
+    enabled: true,
+    sourcePrefix: 'whatsapp',
+    excludeAgents: ['crew-loco'],
+    icon: '💬'
+  },
+  slack: {
+    enabled: true,
+    sourcePrefix: 'slack-channel',
+    excludeAgents: [],
+    icon: '🔷'
+  },
+  discord: {
+    enabled: true,
+    sourcePrefix: 'discord-channel',
+    excludeAgents: [],
+    icon: '💜'
+  },
+  'crew-chat': {
+    enabled: true,
+    sourcePrefix: 'crew-chat',
+    excludeAgents: [],
+    icon: '💻'
+  }
+};
+
+/**
+ * Save a message from any bridge to project RAG
+ * 
+ * @param {string} platform - Platform name (telegram, whatsapp, slack, discord)
+ * @param {string} projectId - Project ID (or null for multi-project detection)
+ * @param {string} chatId - Platform-specific chat/channel ID
+ * @param {string} role - 'user' or 'assistant'
+ * @param {string} content - Message content
+ * @param {string|null} agent - Agent ID if from an agent (e.g., 'crew-pm')
+ * @param {object} metadata - Additional metadata (threadId, username, etc.)
+ * @returns {boolean} true if saved, false if skipped
+ */
+export function saveBridgeMessage(platform, projectId, chatId, role, content, agent = null, metadata = {}) {
+  // Get platform config
+  const config = PLATFORM_CONFIG[platform];
+  if (!config || !config.enabled) {
+    return false;
+  }
+  
+  // Skip if agent is excluded (e.g., crew-loco chat-only mode)
+  if (agent && config.excludeAgents.includes(agent)) {
+    return false;
+  }
+  
+  // Skip if no project context
+  if (!projectId || projectId === 'general' || projectId === 'none') {
+    return false;
+  }
+  
+  try {
+    // Build message object
+    const message = {
+      source: config.sourcePrefix,
+      role,
+      content,
+      agent: agent || null,
+      metadata: {
+        platform,
+        chatId,
+        ...metadata
+      }
+    };
+    
+    // Save to project messages
+    saveProjectMessage(projectId, message);
+    
+    // Index for semantic search
+    indexProjectMessage(projectId, message);
+    
+    console.log(`[bridge-integration] ${config.icon} Saved ${platform} message to project "${projectId}" (agent: ${agent || 'user'})`);
+    
+    return true;
+  } catch (error) {
+    console.error(`[bridge-integration] Failed to save ${platform} message:`, error.message);
+    return false;
+  }
+}
+
+/**
+ * Check if a platform/agent should save to project RAG
+ * 
+ * @param {string} platform - Platform name
+ * @param {string|null} agent - Agent ID
+ * @returns {boolean} true if should save
+ */
+export function shouldSaveToProjectRAG(platform, agent = null) {
+  const config = PLATFORM_CONFIG[platform];
+  if (!config || !config.enabled) return false;
+  if (agent && config.excludeAgents.includes(agent)) return false;
+  return true;
+}
+
+/**
+ * Get all enabled platforms
+ * @returns {string[]} List of platform names
+ */
+export function getEnabledPlatforms() {
+  return Object.entries(PLATFORM_CONFIG)
+    .filter(([_, config]) => config.enabled)
+    .map(([platform, _]) => platform);
+}
+
+/**
+ * Register a new platform (for dynamic bridge loading)
+ * 
+ * @param {string} platform - Platform name
+ * @param {object} config - Platform configuration
+ */
+export function registerPlatform(platform, config) {
+  PLATFORM_CONFIG[platform] = {
+    enabled: true,
+    sourcePrefix: config.sourcePrefix || platform,
+    excludeAgents: config.excludeAgents || [],
+    icon: config.icon || '📡'
+  };
+  console.log(`[bridge-integration] Registered platform: ${platform}`);
+}
+
+/**
+ * Multi-project detection for platforms without explicit project selection
+ * 
+ * When a message mentions a project name or uses dispatch syntax,
+ * automatically detect and route to that project.
+ * 
+ * @param {string} content - Message content
+ * @param {Array} allProjects - List of all projects { id, name, outputDir }
+ * @returns {string|null} Detected project ID or null
+ */
+export function detectProjectFromMessage(content, allProjects) {
+  if (!content || !allProjects?.length) return null;
+  
+  const lowerContent = content.toLowerCase();
+  
+  // Pattern 1: Explicit dispatch with project
+  // "dispatch crew-coder to website project: implement feature"
+  const dispatchMatch = lowerContent.match(/(?:dispatch|send|ask).*?(?:to|for)\s+(\w+[\w-]*)\s+project/i);
+  if (dispatchMatch) {
+    const projectName = dispatchMatch[1];
+    const match = allProjects.find(p => 
+      p.name.toLowerCase() === projectName.toLowerCase() || 
+      p.id.toLowerCase() === projectName.toLowerCase()
+    );
+    if (match) return match.id;
+  }
+  
+  // Pattern 2: Project mention
+  // "work on the api-server project"
+  // "in the website project"
+  for (const project of allProjects) {
+    const projectPattern = new RegExp(`\\b${project.name}\\s+project\\b`, 'i');
+    if (projectPattern.test(content)) {
+      return project.id;
+    }
+  }
+  
+  // Pattern 3: File path mentions
+  // "edit website/src/index.html"
+  for (const project of allProjects) {
+    if (project.outputDir) {
+      const dirName = project.outputDir.split('/').pop();
+      const pathPattern = new RegExp(`\\b${dirName}/`, 'i');
+      if (pathPattern.test(content)) {
+        return project.id;
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Batch save multiple messages (for history sync)
+ * 
+ * @param {string} platform - Platform name
+ * @param {string} projectId - Project ID
+ * @param {Array} messages - Array of { role, content, agent, metadata }
+ * @returns {number} Number of messages saved
+ */
+export function saveBridgeMessages(platform, projectId, messages) {
+  if (!projectId || projectId === 'general') return 0;
+  
+  let saved = 0;
+  for (const msg of messages) {
+    if (saveBridgeMessage(platform, projectId, msg.chatId, msg.role, msg.content, msg.agent, msg.metadata)) {
+      saved++;
+    }
+  }
+  
+  return saved;
+}
+
+export default {
+  saveBridgeMessage,
+  shouldSaveToProjectRAG,
+  getEnabledPlatforms,
+  registerPlatform,
+  detectProjectFromMessage,
+  saveBridgeMessages
+};

package/lib/bridges/rag-helper.mjs

@@ -0,0 +1,90 @@
+/**
+ * RAG Helper — fetch codebase context from crew-cli RAG API
+ * Shared by: crew-lead, Telegram, WhatsApp, dashboard
+ */
+
+/**
+ * Fetch codebase context from crew-cli RAG API
+ * Returns context string or empty string if RAG not available
+ */
+export async function fetchCrewCliRagContext(query, projectDir = process.cwd()) {
+  try {
+    // Check if coding keywords present
+    const codingKeywords = [
+      'implement', 'create', 'build', 'write', 'fix', 'refactor',
+      'modify', 'update', 'add', 'endpoint', 'function', 'class',
+      'component', 'how does', 'where is', 'show me', 'explain'
+    ];
+    
+    const lowerQuery = query.toLowerCase();
+    const needsRag = codingKeywords.some(kw => lowerQuery.includes(kw));
+    
+    if (!needsRag) return '';
+    
+    const ragPort = process.env.CREW_CLI_RAG_PORT || process.env.CREW_API_PORT || '4317';
+    const ragUrl = `http://127.0.0.1:${ragPort}/api/rag/search?q=${encodeURIComponent(query)}&projectDir=${encodeURIComponent(projectDir)}&mode=import-graph`;
+    
+    // Get auth token if available
+    const authToken = getAuthToken();
+    const headers = authToken ? { 'Authorization': `Bearer ${authToken}` } : {};
+    
+    const response = await fetch(ragUrl, { 
+      signal: AbortSignal.timeout(5000), // 5s timeout
+      headers
+    });
+    
+    if (!response.ok) {
+      console.warn(`[rag-helper] RAG API error: ${response.status}`);
+      return '';
+    }
+    
+    const result = await response.json();
+    
+    if (result.filesLoaded?.length > 0) {
+      console.log(`[rag-helper] RAG loaded ${result.filesLoaded.length} files: ${result.filesLoaded.slice(0, 3).join(', ')}${result.filesLoaded.length > 3 ? '...' : ''}`);
+      return `\n\n## Relevant Code Files (Auto-RAG)\n${result.context}`;
+    }
+    
+    return '';
+  } catch (error) {
+    // RAG server not running or timeout - silently skip
+    if (error.name === 'TimeoutError' || error.code === 'ECONNREFUSED') {
+      // Expected when crew serve is not running
+      return '';
+    }
+    console.warn('[rag-helper] RAG API call failed:', error.message);
+    return '';
+  }
+}
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+/**
+ * Get auth token from config
+ */
+function getAuthToken() {
+  try {
+    const configPath = join(homedir(), '.crewswarm', 'crewswarm.json');
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    return config?.rt?.authToken || '';
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Check if RAG server is available
+ */
+export async function isRagServerAvailable() {
+  try {
+    const ragPort = process.env.CREW_CLI_RAG_PORT || process.env.CREW_API_PORT || '4317';
+    const response = await fetch(`http://127.0.0.1:${ragPort}/health`, {
+      signal: AbortSignal.timeout(2000)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}

package/lib/browser/opencode-passthrough-filter.js

@@ -0,0 +1,44 @@
+/**
+ * Strip OpenCode / Ink status lines from dashboard passthrough chunks (belt-and-suspenders
+ * with crew-lead filtering). See lib/crew-lead/http-server.mjs shouldSkipOpenCodePassthroughLine.
+ */
+
+function stripAnsiPassthrough(text) {
+  return String(text || "")
+    .replace(/\u001b\[[\d;?]*[ -/]*[@-~]/g, "")
+    .replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g, "");
+}
+
+/**
+ * @param {string} line
+ * @returns {boolean} true = drop this line from chat
+ */
+export function shouldFilterOpenCodePassthroughLine(line) {
+  const t = stripAnsiPassthrough(String(line || "").replace(/\r/g, "")).trim();
+  if (!t) return true;
+  // "> build", "> run", etc. (allow no space after >)
+  if (/^>\s*(build|run|eval|install|pack|starting|sync|watch|plan)\b/i.test(t))
+    return true;
+  // Same + model id path segment (e.g. moonshotai/kimi-…)
+  if (
+    /^>\s*(build|run|eval|install|pack|starting|sync|watch|plan)\b.*\/[\w.-]+/i.test(
+      t,
+    )
+  )
+    return true;
+  // "> label · rest" with common bullet glyphs (U+00B7 middle dot, U+2022 bullet, etc.)
+  if (/^>\s*[^\n]+[\u00B7\u2022\u22C5\u2027\u30FB‧⋅]\s*\S/u.test(t)) return true;
+  if (/^[─═━\-]{3,}$/.test(t)) return true;
+  return false;
+}
+
+/**
+ * @param {string} engine
+ * @param {string} text
+ */
+export function filterOpenCodePassthroughTextChunk(engine, text) {
+  if (engine !== "opencode" && engine !== "antigravity") return String(text ?? "");
+  const s = String(text ?? "");
+  if (!s) return s;
+  return s.split("\n").filter((ln) => !shouldFilterOpenCodePassthroughLine(ln)).join("\n");
+}

package/lib/browser/passthrough-stderr.js

@@ -0,0 +1,109 @@
+/**
+ * Shared UI helpers for engine CLI passthrough stderr (dashboard + Studio).
+ * Mirrors lib/crew-lead/http-server.mjs filtering; adds line buffering for split TCP chunks.
+ */
+
+function normalizeStderrLine(line) {
+  return String(line || "").replace(/\r$/, "");
+}
+
+/** @param {string} engine */
+export function shouldDropPassthroughStderrLine(engine, line) {
+  const l = normalizeStderrLine(line);
+  if (!l.trim()) return true;
+  if (/rmcp::/i.test(l)) return true;
+  if (/error decoding response body.*initialized notification/i.test(l))
+    return true;
+  if (
+    engine === "codex" &&
+    /worker quit with fatal/i.test(l) &&
+    /rmcp|mcp/i.test(l)
+  )
+    return true;
+  if (
+    engine === "codex" &&
+    /\/mcp/i.test(l) &&
+    /127\.0\.0\.1:\d+|localhost:\d+/i.test(l) &&
+    /Connection refused|ConnectError|Transport channel closed|tcp connect error/i.test(l)
+  )
+    return true;
+  return false;
+}
+
+function stripAnsi(text) {
+  return String(text || "")
+    .replace(/\u001b\[[\d;?]*[ -/]*[@-~]/g, "")
+    .replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g, "");
+}
+
+/**
+ * @param {string} engine
+ * @returns {{ push: (chunk: string) => string, flush: () => string }}
+ */
+export function createPassthroughStderrLineFilter(engine) {
+  let partial = "";
+  return {
+    push(chunk) {
+      partial += String(chunk || "");
+      const parts = partial.split("\n");
+      partial = parts.pop() ?? "";
+      const out = [];
+      for (const line of parts) {
+        if (shouldDropPassthroughStderrLine(engine, line)) continue;
+        const cleaned = stripAnsi(normalizeStderrLine(line)).trimEnd();
+        if (cleaned) out.push(cleaned);
+      }
+      return out.length ? `${out.join("\n")}\n` : "";
+    },
+    flush() {
+      const tail = partial;
+      partial = "";
+      if (!tail) return "";
+      if (shouldDropPassthroughStderrLine(engine, tail)) return "";
+      const cleaned = stripAnsi(normalizeStderrLine(tail)).trimEnd();
+      return cleaned ? `${cleaned}\n` : "";
+    },
+  };
+}
+
+function scoreErrorLine(line) {
+  const l = String(line || "");
+  let s = 0;
+  if (/SecItemCopyMatching|keychain|Keychain/i.test(l)) s += 100;
+  if (/ERROR:\s|^ERROR\s|error:\s|FATAL|fatal|panic/i.test(l)) s += 45;
+  if (/authentication|unauthorized|\b401\b|\b403\b|not logged in/i.test(l))
+    s += 30;
+  if (/ENOTFOUND|ECONNREFUSED|ECONNRESET|certificate|TLS|SSL/i.test(l))
+    s += 25;
+  if (/command not found|No such file|ENOENT/i.test(l)) s += 20;
+  return s;
+}
+
+/**
+ * Best single line to show when exit !== 0 (after noise filter).
+ * @param {string} engine
+ */
+export function summarizePassthroughTopErrorLine(accumulated, engine) {
+  const raw = String(accumulated || "");
+  const parts = raw.split("\n");
+  const kept = [];
+  for (const line of parts) {
+    if (shouldDropPassthroughStderrLine(engine, line)) continue;
+    const c = stripAnsi(normalizeStderrLine(line)).trim();
+    if (c) kept.push(c);
+  }
+  if (!kept.length) return "";
+  let best = kept[0];
+  let bestScore = scoreErrorLine(best);
+  for (const line of kept) {
+    const sc = scoreErrorLine(line);
+    if (sc > bestScore) {
+      bestScore = sc;
+      best = line;
+    }
+  }
+  if (bestScore === 0 && kept.length > 4) {
+    return `${kept[0]} (${kept.length} lines)`;
+  }
+  return best;
+}