| |
| """ |
| LACK v3.9.2 – STACK Edition (Complete Production Release) |
| Fixed: logError defined before first use in embedded Node.js server. |
| Fixed: Empty code block detection + JSON linter (no more "No linter configured for json"). |
| Full code moderation pipeline with /repo, /lint, /moderate commands. |
| Enhanced with small‑model resilience (JSON repair, fallbacks, forced commits). |
| """ |
|
|
| import os |
| import sys |
| import subprocess |
| import stat |
| import webbrowser |
| import threading |
| import time |
| import json |
| from pathlib import Path |
|
|
| VERSION = "3.9.2" |
|
|
| |
| |
| |
| SERVER_JS = r''' |
| const express = require('express'); |
| const path = require('path'); |
| const WebSocket = require('ws'); |
| const { v4: uuidv4 } = require('uuid'); |
| const fs = require('fs'); |
| const axios = require('axios'); |
| const cheerio = require('cheerio'); |
| const simpleGit = require('simple-git'); |
| const { exec } = require('child_process'); |
| const util = require('util'); |
| const execPromise = util.promisify(exec); |
| |
| // ==================== CONFIGURATION (early) ==================== |
| const configPath = path.join(__dirname, 'config', 'lack.config.json'); |
| let config; |
| try { |
| config = JSON.parse(fs.readFileSync(configPath, 'utf-8')); |
| } catch (err) { |
| config = { |
| httpPort: 3721, |
| agents: [ |
| { id: "agent1", name: "Agent 1", model: "qwen2.5:0.5b", systemPrompt: "You are a helpful AI assistant.", channels: ["general","random","siphon","code"] }, |
| { id: "agent2", name: "Agent 2", model: "qwen2.5:0.5b", systemPrompt: "You are a creative AI.", channels: ["general","random","siphon","code"] } |
| ], |
| channels: [ |
| { id: "general", name: "general" }, |
| { id: "random", name: "random" }, |
| { id: "siphon", name: "siphon" }, |
| { id: "code", name: "code" } |
| ], |
| dms: [] |
| }; |
| fs.mkdirSync(path.join(__dirname, 'config'), { recursive: true }); |
| fs.writeFileSync(configPath, JSON.stringify(config, null, 2)); |
| } |
| const PORT = config.httpPort || 3721; |
| const OLLAMA_URL = 'http://localhost:11434'; |
| const RESEARCH_DIR = path.join(__dirname, 'research'); |
| const LOG_DIR = path.join(__dirname, 'logs'); |
| const ERROR_LOG_PATH = path.join(LOG_DIR, 'error.log'); |
| fs.mkdirSync(LOG_DIR, { recursive: true }); |
| fs.mkdirSync(path.join(__dirname, 'lineage'), { recursive: true }); |
| const GIT = simpleGit(); |
| |
| // ==================== LOGGING & ERROR HANDLERS (before any usage) ==================== |
| global.errorLog = []; |
| function logError(errorObj) { |
| const entry = { timestamp: Date.now(), ...errorObj }; |
| try { fs.appendFileSync(ERROR_LOG_PATH, JSON.stringify(entry) + '\n'); } catch (e) {} |
| global.errorLog.unshift(entry); |
| if (global.errorLog.length > 200) global.errorLog.pop(); |
| console.error('[ERROR]', entry); |
| } |
| |
| process.on('uncaughtException', (err) => { |
| console.error('🔥 Uncaught Exception:', err); |
| if (typeof logError === 'function') logError({ context: 'uncaughtException', error: err.stack }); |
| }); |
| process.on('unhandledRejection', (reason, promise) => { |
| console.error('❌ Unhandled Rejection:', reason); |
| if (typeof logError === 'function') logError({ context: 'unhandledRejection', error: reason }); |
| }); |
| process.on('SIGTERM', () => { console.log('[LACK] SIGTERM received, shutting down...'); process.exit(0); }); |
| process.on('SIGINT', () => { console.log('[LACK] SIGINT received, shutting down...'); process.exit(0); }); |
| |
| // ==================== STACK CORE (can now safely call logError) ==================== |
| const STACK_ROOT = path.join(__dirname, 'lack_repos'); |
| const TEMPLATES_DIR = path.join(STACK_ROOT, 'templates'); |
| const MANIFEST_PATH = path.join(TEMPLATES_DIR, 'manifest.json'); |
| fs.mkdirSync(STACK_ROOT, { recursive: true }); |
| fs.mkdirSync(TEMPLATES_DIR, { recursive: true }); |
| |
| let stackManifest = {}; |
| |
| async function getEmbedding(text) { |
| try { |
| const res = await axios.post('http://localhost:11434/api/embeddings', { |
| model: 'nomic-embed-text', |
| prompt: text.slice(0, 2000) |
| }); |
| return res.data.embedding; |
| } catch (e) { |
| logError({ context: 'getEmbedding', error: e.message }); |
| return null; |
| } |
| } |
| |
| function cosineSimilarity(v1, v2) { |
| if (!v1 || !v2 || v1.length !== v2.length) return 0; |
| let dot = 0, mag1 = 0, mag2 = 0; |
| for (let i = 0; i < v1.length; i++) { |
| dot += v1[i] * v2[i]; |
| mag1 += v1[i] * v1[i]; |
| mag2 += v2[i] * v2[i]; |
| } |
| return dot / (Math.sqrt(mag1) * Math.sqrt(mag2)); |
| } |
| |
| async function scanAndReindexTemplates() { |
| if (!fs.existsSync(TEMPLATES_DIR)) return; |
| const items = fs.readdirSync(TEMPLATES_DIR, { withFileTypes: true }); |
| const newManifest = {}; |
| for (const item of items) { |
| if (item.isDirectory()) { |
| const templatePath = path.join(TEMPLATES_DIR, item.name); |
| let combinedText = ''; |
| const files = {}; |
| const walk = (dir) => { |
| const entries = fs.readdirSync(dir, { withFileTypes: true }); |
| for (const e of entries) { |
| const full = path.join(dir, e.name); |
| if (e.isDirectory()) walk(full); |
| else if (/\.(js|json|md|txt|py|html|css)$/.test(e.name)) { |
| const content = fs.readFileSync(full, 'utf-8'); |
| combinedText += content + '\n'; |
| files[path.relative(templatePath, full)] = content; |
| } |
| } |
| }; |
| walk(templatePath); |
| if (combinedText.length === 0) continue; |
| const vector = await getEmbedding(combinedText); |
| if (vector) newManifest[item.name] = { vector, files }; |
| } |
| } |
| stackManifest = newManifest; |
| fs.writeFileSync(MANIFEST_PATH, JSON.stringify(stackManifest, null, 2)); |
| console.log(`[STACK] Reindexed ${Object.keys(stackManifest).length} templates`); |
| } |
| |
| async function stackBuild(repoName) { |
| const repoPath = path.join(STACK_ROOT, repoName); |
| if (fs.existsSync(repoPath)) return `⚠️ Repository ${repoName} already exists.`; |
| fs.mkdirSync(repoPath, { recursive: true }); |
| await execPromise(`git init && git checkout -b main`, { cwd: repoPath }); |
| const configFile = path.join(repoPath, 'STACK_CONFIG.json'); |
| fs.writeFileSync(configFile, JSON.stringify({ project: repoName, managedBy: "LACK-STACK" }, null, 2)); |
| return `✅ STACK repository **${repoName}** created at ${repoPath}`; |
| } |
| |
| async function stackAdd(intent, storeId) { |
| if (!fs.existsSync(MANIFEST_PATH)) return "No templates found. Add folders to ./lack_repos/templates/ first."; |
| const manifest = JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf-8')); |
| let queryVec = await getEmbedding(intent); |
| let useFallback = !queryVec; |
| let best = null, bestScore = -1; |
| |
| if (useFallback) { |
| console.warn('[STACK] Embedding failed, using keyword fallback'); |
| const intentWords = intent.toLowerCase().split(/\s+/); |
| for (const [name, data] of Object.entries(manifest)) { |
| const combinedText = Object.values(data.files).join(' ').toLowerCase(); |
| let score = 0; |
| for (const word of intentWords) { |
| if (combinedText.includes(word)) score++; |
| } |
| if (score > bestScore) { bestScore = score; best = { name, files: data.files }; } |
| } |
| if (best && bestScore > 0) { |
| const activeRepo = activeStackRepo.get(storeId) || 'default'; |
| const repoPath = path.join(STACK_ROOT, activeRepo); |
| if (!fs.existsSync(repoPath)) return `No active repository. Use /stack set <repo> first.`; |
| for (const [relPath, content] of Object.entries(best.files)) { |
| const target = path.join(repoPath, relPath); |
| fs.mkdirSync(path.dirname(target), { recursive: true }); |
| fs.writeFileSync(target, content); |
| } |
| await execPromise(`git add . && git commit -m "STACK add: ${best.name}"`, { cwd: repoPath }).catch(e => console.warn(e)); |
| return `🔍 Keyword match: **${best.name}** (score ${bestScore}) – fallback used.\nApplied ${Object.keys(best.files).length} files to ${activeRepo}.`; |
| } else { |
| return `No template matches keywords: "${intent}".`; |
| } |
| } |
| |
| // normal vector search |
| for (const [name, data] of Object.entries(manifest)) { |
| const score = cosineSimilarity(queryVec, data.vector); |
| if (score > bestScore) { bestScore = score; best = { name, files: data.files }; } |
| } |
| if (best && bestScore > 0.45) { |
| const activeRepo = activeStackRepo.get(storeId) || 'default'; |
| const repoPath = path.join(STACK_ROOT, activeRepo); |
| if (!fs.existsSync(repoPath)) return `No active repository. Use /stack set <repo> first.`; |
| for (const [relPath, content] of Object.entries(best.files)) { |
| const target = path.join(repoPath, relPath); |
| fs.mkdirSync(path.dirname(target), { recursive: true }); |
| fs.writeFileSync(target, content); |
| } |
| await execPromise(`git add . && git commit -m "STACK add: ${best.name}"`, { cwd: repoPath }).catch(e => console.warn(e)); |
| return `🔍 Best match: **${best.name}** (score ${bestScore.toFixed(2)})\nApplied ${Object.keys(best.files).length} files to ${activeRepo}.`; |
| } else { |
| return `No strong match for "${intent}" (best score ${bestScore.toFixed(2)}).`; |
| } |
| } |
| |
| async function stackImport(jsonPath) { |
| const fullPath = path.resolve(jsonPath); |
| if (!fs.existsSync(fullPath)) return `File not found: ${fullPath}`; |
| const data = JSON.parse(fs.readFileSync(fullPath, 'utf-8')); |
| if (!data.templates) return "Invalid format: missing 'templates' key."; |
| for (const [name, template] of Object.entries(data.templates)) { |
| const dir = path.join(TEMPLATES_DIR, name); |
| fs.mkdirSync(dir, { recursive: true }); |
| for (const [file, content] of Object.entries(template.files || {})) { |
| const target = path.join(dir, file); |
| fs.mkdirSync(path.dirname(target), { recursive: true }); |
| fs.writeFileSync(target, content); |
| } |
| } |
| await scanAndReindexTemplates(); |
| return `Imported ${Object.keys(data.templates).length} templates.`; |
| } |
| |
| let stackWatcher = null; |
| function startStackWatcher() { |
| if (stackWatcher) clearInterval(stackWatcher); |
| stackWatcher = setInterval(async () => { |
| const oldKeys = Object.keys(stackManifest); |
| await scanAndReindexTemplates(); |
| const newKeys = Object.keys(stackManifest); |
| if (JSON.stringify(oldKeys) !== JSON.stringify(newKeys)) |
| console.log('[STACK] Templates changed, reindexed.'); |
| }, 10000); |
| } |
| |
| const activeStackRepo = new Map(); |
| |
| // ==================== HARDENED JSON EXTRACTION (with repair) ==================== |
| function repairJSON(str) { |
| if (!str || typeof str !== 'string') return str; |
| // 1. Remove markdown fences |
| str = str.replace(/```json\s*|```\s*/g, ''); |
| // 2. Add missing quotes around unquoted keys |
| str = str.replace(/(\{|\,)\s*([a-zA-Z0-9_]+)\s*\:/g, '$1"$2":'); |
| // 3. Fix trailing commas |
| str = str.replace(/,\s*\}/g, '}').replace(/,\s*\]/g, ']'); |
| // 4. Replace single quotes with double quotes (but careful inside strings) |
| str = str.replace(/'/g, '"'); |
| // 5. Add missing closing braces/brackets |
| let openBraces = (str.match(/\{/g) || []).length; |
| let closeBraces = (str.match(/\}/g) || []).length; |
| let openBrackets = (str.match(/\[/g) || []).length; |
| let closeBrackets = (str.match(/\]/g) || []).length; |
| str += '}'.repeat(openBraces - closeBraces) + ']'.repeat(openBrackets - closeBrackets); |
| return str; |
| } |
| |
| function extractJSON(str) { |
| str = repairJSON(str); |
| if (!str || typeof str !== 'string') return null; |
| str = str.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, ''); |
| const jsonBlock = str.match(/```json\s*([\s\S]*?)\s*```/); |
| if (jsonBlock && jsonBlock[1]) { |
| try { return JSON.parse(jsonBlock[1].trim()); } catch(e) {} |
| } |
| let start = str.indexOf('{'); |
| if (start === -1) return null; |
| let depth = 0, end = -1; |
| for (let i = start; i < str.length; i++) { |
| if (str[i] === '{') depth++; |
| else if (str[i] === '}') { depth--; if (depth === 0) { end = i; break; } } |
| } |
| if (end !== -1) { |
| try { return JSON.parse(str.substring(start, end + 1)); } catch(e) { |
| let fragment = str.substring(start, end + 1); |
| let opens = (fragment.match(/\{/g) || []).length - (fragment.match(/\}/g) || []).length; |
| let arrOpens = (fragment.match(/\[/g) || []).length - (fragment.match(/\]/g) || []).length; |
| fragment += ']'.repeat(Math.max(0, arrOpens)) + '}'.repeat(Math.max(0, opens)); |
| try { return JSON.parse(fragment); } catch(e2) {} |
| } |
| } |
| const possible = str.match(/\{[\s\S]*\}/); |
| if (possible) { |
| try { return JSON.parse(possible[0]); } catch(e) {} |
| } |
| return null; |
| } |
| |
| // ==================== FORCE CODE BLOCKS FROM PLAIN TEXT ==================== |
| function ensureCodeBlock(text, language) { |
| if (text.includes('```')) return text; |
| // Heuristics: looks like code |
| if (text.includes('<html') || text.includes('def ') || text.includes('function(') || |
| text.includes('class ') || text.includes('import ') || text.includes('require(')) { |
| return '```' + (language || 'text') + '\n' + text + '\n```'; |
| } |
| return text; |
| } |
| |
| // ==================== TOOL DEFINITIONS & SANDBOX ==================== |
| const WORKSPACE_ROOT = path.join(__dirname, 'workspace'); |
| fs.mkdirSync(WORKSPACE_ROOT, { recursive: true }); |
| |
| function securePath(relPath) { |
| const safe = path.resolve(WORKSPACE_ROOT, relPath); |
| if (!safe.startsWith(WORKSPACE_ROOT)) throw new Error("Path traversal blocked"); |
| return safe; |
| } |
| |
| async function executeTool(toolName, args) { |
| try { |
| switch (toolName) { |
| case 'read_file': { |
| const target = securePath(args.path); |
| return fs.readFileSync(target, 'utf-8'); |
| } |
| case 'write_file': { |
| const target = securePath(args.path); |
| fs.mkdirSync(path.dirname(target), { recursive: true }); |
| fs.writeFileSync(target, args.content, 'utf-8'); |
| await gitCommit(`Agent wrote ${args.path}`); |
| return `✅ Wrote ${args.path} (${args.content.length} chars)`; |
| } |
| case 'execute_command': { |
| if (/rm -rf|sudo|rmdir/.test(args.command)) return "⛔ Command blocked for safety."; |
| const { stdout, stderr } = await execPromise(args.command, { cwd: WORKSPACE_ROOT, timeout: 15000 }); |
| return stdout || stderr || "Command executed (no output)"; |
| } |
| default: return `❌ Unknown tool: ${toolName}`; |
| } |
| } catch (err) { |
| logError({ context: 'executeTool', tool: toolName, error: err.message }); |
| return `⚠️ Tool error: ${err.message}`; |
| } |
| } |
| |
| const SKILLS_DIR = path.join(WORKSPACE_ROOT, '.skills'); |
| fs.mkdirSync(SKILLS_DIR, { recursive: true }); |
| |
| function loadSkills() { |
| if (!fs.existsSync(SKILLS_DIR)) return ''; |
| const files = fs.readdirSync(SKILLS_DIR).filter(f => f.endsWith('.md')); |
| return files.map(f => fs.readFileSync(path.join(SKILLS_DIR, f), 'utf-8')).join('\n\n---\n\n'); |
| } |
| |
| async function saveSkill(summary, toolCalls) { |
| const content = `# Skill ${new Date().toISOString()}\n\n**Summary:** ${summary}\n**Tools used:** ${toolCalls.map(t => t.name).join(', ')}\n\`\`\`json\n${JSON.stringify(toolCalls, null, 2)}\n\`\`\``; |
| await executeTool('write_file', { path: `.skills/skill_${Date.now()}.md`, content }); |
| } |
| |
| // ==================== GIT HELPERS ==================== |
| async function ensureGitRepo() { |
| try { |
| if (!fs.existsSync(RESEARCH_DIR)) fs.mkdirSync(RESEARCH_DIR, { recursive: true }); |
| const gitDir = path.join(RESEARCH_DIR, '.git'); |
| if (!fs.existsSync(gitDir)) { |
| await GIT.cwd(RESEARCH_DIR).init(); |
| await GIT.cwd(RESEARCH_DIR).addConfig('user.name', 'LACK SIPHON'); |
| await GIT.cwd(RESEARCH_DIR).addConfig('user.email', 'lack@localhost'); |
| await GIT.cwd(RESEARCH_DIR).commit('Initial research repo', { '--allow-empty': null }); |
| console.log('[LACK] Git repo initialised at', RESEARCH_DIR); |
| } |
| } catch (err) { console.error('Git init failed:', err.message); } |
| } |
| async function gitCommit(message) { |
| try { |
| const gitDir = path.join(RESEARCH_DIR, '.git'); |
| if (!fs.existsSync(gitDir)) { |
| console.warn('[LACK] Git repo missing – re-initialising before commit'); |
| await ensureGitRepo(); |
| } |
| await GIT.cwd(RESEARCH_DIR).add('.'); |
| const status = await GIT.cwd(RESEARCH_DIR).status(); |
| if (status.files.length > 0) { |
| await GIT.cwd(RESEARCH_DIR).commit(message); |
| console.log(`Git commit: ${message}`); |
| } |
| } catch (e) { throw new Error(`Git commit failed: ${e.message}`); } |
| } |
| |
| // ==================== DATA STRUCTURES ==================== |
| const channels = new Map(); |
| const agents = new Map(); |
| const clients = new Map(); |
| const researchSessions = new Map(); |
| const slimeSessions = new Map(); |
| const dms = new Map(); |
| const pinnedMessages = new Map(); |
| const userReactions = new Map(); |
| const agentMetrics = new Map(); |
| const jsonFailCount = new Map(); |
| |
| const projectStates = new Map(); |
| function getProjectState(storeId) { |
| return projectStates.get(storeId) || { active: false, title: null, goals: [], nextSteps: [], completedTasks: [], memory: {} }; |
| } |
| function setProjectState(storeId, state) { |
| projectStates.set(storeId, { ...state }); |
| persistProjectState(storeId); |
| } |
| |
| const ralphActive = new Map(); |
| const ralphGenerations = new Map(); |
| const ralphGoals = new Map(); |
| const ralphTimers = new Map(); |
| const ralphCancel = new Map(); |
| const ralphStagnation = new Map(); |
| const ralphNextAgentIdx = new Map(); |
| const ralphLastBroadcast = new Map(); |
| |
| function getUserId(ws) { |
| let client = clients.get(ws); |
| if (!client) { |
| const id = `human_${uuidv4().slice(0,4)}`; |
| clients.set(ws, { username: id, channelId: 'general', userId: id, dmId: null, openThreadId: null }); |
| client = clients.get(ws); |
| } |
| return client.userId; |
| } |
| |
| // Initialize channels |
| config.channels.forEach(ch => { |
| channels.set(ch.id, { |
| id: ch.id, name: ch.name, messages: [], |
| researchActive: false, researchTopic: null, abstractActive: false, |
| loopTimer: null, pinned: new Set() |
| }); |
| }); |
| if (config.dms) { |
| config.dms.forEach(dm => { |
| dms.set(dm.id, { |
| id: dm.id, participants: dm.participants, |
| name: dm.name || dm.participants.join(', '), messages: [] |
| }); |
| }); |
| } |
| |
| function generateSyntheticMetrics() { |
| const now = Date.now(); |
| return { |
| cpu: Array(60).fill(0).map((_, i) => 15 + Math.sin(i * 0.2) * 10), |
| mem: Array(60).fill(0).map((_, i) => 20 + Math.sin(i * 0.1) * 5), |
| activity: Array(60).fill(0).map((_, i) => 30 + Math.cos(i * 0.3) * 15), |
| timestamps: Array(60).fill(0).map((_, i) => now - (59 - i) * 3000) |
| }; |
| } |
| |
| // ==================== MODERATOR AGENT (embed‑only, with code moderation) ==================== |
| const THREAD_REPO_ROOT = path.join(__dirname, 'thread_repos'); |
| const CODE_BLOCK_REGEX = /```(\w*)\n([\s\S]*?)```/g; |
| const LINT_TIMEOUT_MS = 10000; |
| |
| function getThreadRepoPath(threadId) { |
| return path.join(THREAD_REPO_ROOT, threadId); |
| } |
| async function ensureThreadRepo(threadId) { |
| const repoPath = getThreadRepoPath(threadId); |
| if (!fs.existsSync(repoPath)) { |
| fs.mkdirSync(repoPath, { recursive: true }); |
| await execPromise(`git init && git checkout -b main`, { cwd: repoPath }); |
| const readme = `# Thread: ${threadId}\nCreated: ${new Date().toISOString()}\n\n## Files\n<!-- auto-generated -->`; |
| fs.writeFileSync(path.join(repoPath, 'README.md'), readme); |
| await execPromise(`git add . && git commit -m "Initialize thread repository"`, { cwd: repoPath }); |
| console.log(`[MODERATOR] Created repo for thread ${threadId}`); |
| } |
| return repoPath; |
| } |
| async function updateThreadReadme(threadId, files) { |
| const repoPath = getThreadRepoPath(threadId); |
| const readmePath = path.join(repoPath, 'README.md'); |
| let content = fs.readFileSync(readmePath, 'utf-8'); |
| let filesSection = content.includes('## Files') ? '' : '\n## Files\n'; |
| for (const file of files) { |
| if (!content.includes(file.name)) { |
| filesSection += `- \`${file.name}\` - ${file.lang} - ${new Date(file.timestamp).toLocaleString()}\n`; |
| } |
| } |
| if (filesSection) { |
| fs.writeFileSync(readmePath, content + filesSection); |
| await execPromise(`git add README.md && git commit -m "Update README with ${files.length} new file(s)"`, { cwd: repoPath }); |
| } |
| } |
| |
| async function runLinter(language, filePath) { |
| const config = agents.get('moderator')?.moderationConfig?.lintConfigs || {}; |
| const errors = []; |
| const warnings = []; |
| let passed = true; |
| |
| try { |
| switch (language.toLowerCase()) { |
| case 'python': |
| try { |
| const { stdout, stderr } = await execPromise(`python -m py_compile "${filePath}" 2>&1`, { timeout: LINT_TIMEOUT_MS }); |
| if (stderr || (stdout && stdout.includes('SyntaxError'))) { |
| const lines = (stderr || stdout).split('\n'); |
| for (const line of lines) { |
| if (line.includes('SyntaxError')) errors.push(line.trim()); |
| else if (line.trim()) warnings.push(line.trim()); |
| } |
| passed = errors.length === 0; |
| } |
| } catch(e) { |
| errors.push(e.stderr || e.message); |
| passed = false; |
| } |
| break; |
| |
| case 'javascript': |
| try { |
| const { stdout } = await execPromise(`node -c "${filePath}" 2>&1`, { timeout: LINT_TIMEOUT_MS }); |
| if (stdout && stdout.includes('SyntaxError')) { |
| errors.push(stdout.trim()); |
| passed = false; |
| } |
| } catch(e) { |
| errors.push(e.stderr || e.message); |
| passed = false; |
| } |
| break; |
| |
| case 'html': |
| const content = fs.readFileSync(filePath, 'utf-8'); |
| const openTags = (content.match(/<([a-z][a-z0-9]*)[^>]*>/gi) || []).length; |
| const closeTags = (content.match(/<\/([a-z][a-z0-9]*)>/gi) || []).length; |
| if (openTags !== closeTags) { |
| errors.push(`Tag mismatch: ${openTags} opening vs ${closeTags} closing tags`); |
| passed = false; |
| } |
| break; |
| |
| case 'json': |
| case 'jsonc': |
| try { |
| JSON.parse(fs.readFileSync(filePath, 'utf-8')); |
| passed = true; |
| } catch (e) { |
| errors.push(`JSON parse error: ${e.message}`); |
| passed = false; |
| } |
| break; |
| |
| default: |
| warnings.push(`No linter configured for ${language}`); |
| passed = true; |
| } |
| } catch (err) { |
| errors.push(`Linter error: ${err.message}`); |
| passed = false; |
| } |
| |
| return { passed, errors: errors.slice(0, 10), warnings: warnings.slice(0, 5) }; |
| } |
| |
| function suggestFilename(language, code, index) { |
| const langMap = { |
| 'python': '.py', 'javascript': '.js', 'html': '.html', |
| 'css': '.css', 'json': '.json', 'markdown': '.md', |
| 'bash': '.sh', 'text': '.txt', 'xml': '.xml', 'yaml': '.yml' |
| }; |
| const firstLine = code.split('\n')[0]; |
| let suggested = `code_${Date.now()}_${index}`; |
| if (firstLine.includes('#!/usr/bin/env python')) suggested = 'script.py'; |
| else if (firstLine.includes('#!/bin/bash')) suggested = 'script.sh'; |
| else if (code.includes('<!DOCTYPE html>')) suggested = 'index.html'; |
| else if (code.includes('{') && language === 'json') suggested = 'data.json'; |
| else if (code.includes('def ') || code.includes('class ')) suggested = 'module.py'; |
| else if (code.includes('function ') || code.includes('=>')) suggested = 'function.js'; |
| const ext = langMap[language.toLowerCase()] || '.txt'; |
| return suggested.endsWith(ext) ? suggested : suggested + ext; |
| } |
| |
| function buildModeratorFeedback(agentId, results, threadId, repoPath) { |
| const passedCount = results.filter(r => r.passed).length; |
| const totalCount = results.length; |
| const allPassed = passedCount === totalCount; |
| |
| let feedback = `🛡️ **Moderator Review** (agent: ${agentId})\n`; |
| feedback += `Thread: \`${threadId}\` | Repo: \`${repoPath}\`\n\n`; |
| |
| for (const r of results) { |
| const icon = r.passed ? '✅' : '❌'; |
| feedback += `${icon} **${r.filename}** (${r.language})\n`; |
| |
| if (r.errors.length > 0) { |
| feedback += ` **Errors:**\n`; |
| for (const err of r.errors.slice(0, 3)) { |
| feedback += ` - \`${err.substring(0, 80)}\`\n`; |
| } |
| } |
| |
| if (r.warnings.length > 0) { |
| feedback += ` **Warnings:**\n`; |
| for (const warn of r.warnings.slice(0, 2)) { |
| feedback += ` - ${warn}\n`; |
| } |
| } |
| |
| if (r.commitHash && r.passed) { |
| feedback += ` 📦 Committed as \`${r.commitHash}\`\n`; |
| } else if (r.commitHash && !r.passed) { |
| feedback += ` ⚠️ Committed with errors (review needed) \`${r.commitHash}\`\n`; |
| } else if (!r.passed) { |
| feedback += ` 🔧 **Suggested fixes:**\n`; |
| feedback += ` - Check syntax near reported lines\n`; |
| feedback += ` - Run locally before re-submitting\n`; |
| } |
| feedback += '\n'; |
| } |
| |
| if (allPassed) { |
| feedback += `🎉 **All ${totalCount} file(s) validated and committed.**\n`; |
| feedback += `Use \`/repo ${threadId}\` to browse the repository.`; |
| } else { |
| feedback += `⚠️ **${totalCount - passedCount}/${totalCount} files failed validation.**\n`; |
| feedback += `@${agentId} please fix the errors above and re-submit the code block.`; |
| } |
| |
| return feedback; |
| } |
| |
| async function moderateCodeFromAgent(agentId, channelId, responseText, parentId) { |
| if (agentId === 'moderator') return null; |
| |
| const moderatorAgent = agents.get('moderator'); |
| if (!moderatorAgent || !moderatorAgent.isCodeModerator) return null; |
| |
| const codeBlocks = []; |
| let match; |
| while ((match = CODE_BLOCK_REGEX.exec(responseText)) !== null) { |
| codeBlocks.push({ |
| language: match[1] || 'text', |
| code: match[2].trim(), |
| fullMatch: match[0] |
| }); |
| } |
| |
| if (codeBlocks.length === 0) return null; |
| |
| const threadId = parentId || channelId; |
| await ensureThreadRepo(threadId); |
| const repoPath = getThreadRepoPath(threadId); |
| |
| const results = []; |
| for (let i = 0; i < codeBlocks.length; i++) { |
| const block = codeBlocks[i]; |
| |
| if (!block.code) { |
| results.push({ |
| filename: suggestFilename(block.language, '', i), |
| language: block.language, |
| passed: false, |
| errors: ['Empty code block – please provide the complete code.'], |
| warnings: [], |
| commitHash: null, |
| fullCode: '' |
| }); |
| continue; |
| } |
| |
| const suggestedFilename = suggestFilename(block.language, block.code, i); |
| const filePath = path.join(repoPath, suggestedFilename); |
| |
| fs.writeFileSync(filePath, block.code, 'utf-8'); |
| const lintResult = await runLinter(block.language, filePath); |
| |
| let commitHash = null; |
| // Always commit, even if lint fails – mark in commit message |
| try { |
| await execPromise(`git add "${suggestedFilename}"`, { cwd: repoPath }); |
| let commitMsg; |
| if (lintResult.passed || !moderatorAgent.moderationConfig.requireLintPass) { |
| commitMsg = `[MODERATOR] Add ${suggestedFilename} from agent ${agentId}\nErrors: ${lintResult.errors.length} | Warnings: ${lintResult.warnings.length}`; |
| } else { |
| commitMsg = `[FAILED] ${suggestedFilename} from agent ${agentId} – lint errors\nErrors: ${lintResult.errors.join('; ')}`; |
| } |
| const { stdout } = await execPromise(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, { cwd: repoPath }); |
| commitHash = stdout.split('[')[1]?.split(']')[0] || 'unknown'; |
| } catch(e) { console.warn('Git commit failed:', e.message); } |
| |
| results.push({ |
| filename: suggestedFilename, |
| language: block.language, |
| passed: lintResult.passed, |
| errors: lintResult.errors, |
| warnings: lintResult.warnings, |
| commitHash, |
| fullCode: block.code.substring(0, 500) + (block.code.length > 500 ? '...' : '') |
| }); |
| } |
| |
| await updateThreadReadme(threadId, results.map(r => ({ |
| name: r.filename, |
| lang: r.language, |
| timestamp: Date.now(), |
| passed: r.passed |
| }))); |
| |
| const feedback = buildModeratorFeedback(agentId, results, threadId, repoPath); |
| await handleAgentResponse(moderatorAgent, channelId, feedback, parentId); |
| |
| if (channelId === 'siphon') { |
| const siphonLogPath = path.join(repoPath, 'MODERATION_LOG.md'); |
| const logEntry = `## ${new Date().toISOString()} | Agent: ${agentId}\n${feedback}\n\n---\n`; |
| fs.appendFileSync(siphonLogPath, logEntry); |
| await execPromise(`git add MODERATION_LOG.md && git commit -m "Update moderation log"`, { cwd: repoPath }).catch(()=>{}); |
| } |
| |
| return results; |
| } |
| |
| const moderator = { |
| id: "moderator", |
| name: "Moderator", |
| model: "nomic-embed-text", |
| systemPrompt: "Embedding only – not for chat.", |
| channels: ["general", "random", "siphon", "code"], |
| isEmbedOperator: true, |
| isCodeModerator: true, |
| lastResponseTime: new Map(), |
| status: 'online', |
| statusMessage: 'embed-only + code moderation', |
| moderationConfig: { |
| autoCorrect: false, |
| requireLintPass: true, |
| maxFileSizeBytes: 50000, |
| allowedLanguages: ['python', 'javascript', 'html', 'css', 'json', 'markdown', 'text'], |
| lintConfigs: { |
| python: 'pyflakes', |
| javascript: 'eslint --quiet', |
| html: 'htmlhint' |
| } |
| } |
| }; |
| agents.set("moderator", moderator); |
| agentMetrics.set("moderator", generateSyntheticMetrics()); |
| jsonFailCount.set("moderator", 0); |
| |
| // Normal agents from config |
| config.agents.forEach(agentCfg => { |
| agents.set(agentCfg.id, { |
| ...agentCfg, lastResponseTime: new Map(), status: 'online', statusMessage: '' |
| }); |
| agentMetrics.set(agentCfg.id, generateSyntheticMetrics()); |
| jsonFailCount.set(agentCfg.id, 0); |
| }); |
| |
| let globalMaxMem = 0; |
| function updateAgentMetrics(agentId, responseTimeMs = 0, wasActive = false) { |
| const metrics = agentMetrics.get(agentId); |
| if (!metrics) return; |
| const cpuVal = Math.min(100, Math.max(5, Math.floor(responseTimeMs / 80))); |
| const activityVal = wasActive ? 85 : 20; |
| const memUsageMB = process.memoryUsage().rss / (1024 * 1024); |
| if (memUsageMB > globalMaxMem) globalMaxMem = memUsageMB; |
| const memScale = Math.max(128, globalMaxMem); |
| const memVal = Math.min(100, Math.floor((memUsageMB / memScale) * 100)); |
| metrics.cpu.push(cpuVal); metrics.cpu.shift(); |
| metrics.activity.push(activityVal); metrics.activity.shift(); |
| metrics.mem.push(memVal); metrics.mem.shift(); |
| metrics.timestamps.push(Date.now()); metrics.timestamps.shift(); |
| agentMetrics.set(agentId, metrics); |
| } |
| |
| setInterval(() => { |
| for (let [agentId, metrics] of agentMetrics.entries()) { |
| metrics.cpu = metrics.cpu.map(v => Math.max(5, v - 3)); |
| metrics.activity = metrics.activity.map(v => { |
| let newV = Math.max(5, v - 8); |
| if (Math.random() < 0.25) newV = Math.max(newV, 20 + Math.random() * 25); |
| return newV; |
| }); |
| metrics.mem = metrics.mem.map(v => Math.max(5, v - 1)); |
| metrics.timestamps.push(Date.now()); metrics.timestamps.shift(); |
| agentMetrics.set(agentId, metrics); |
| } |
| }, 3000); |
| |
| // ==================== EVENTSTORE (LINEAGE) ==================== |
| function getLineagePath(storeId) { return path.join(__dirname, 'lineage', `${storeId}.jsonl`); } |
| function appendEvent(storeId, event) { |
| try { fs.appendFileSync(getLineagePath(storeId), JSON.stringify(event) + '\n'); } catch (e) {} |
| } |
| function reconstructLineage(storeId) { |
| const filePath = getLineagePath(storeId); |
| if (!fs.existsSync(filePath)) return []; |
| return fs.readFileSync(filePath, 'utf-8').split('\n').filter(l => l.trim()).map(l => JSON.parse(l)); |
| } |
| function persistProjectState(storeId) { |
| appendEvent(storeId, { type: 'project_state', timestamp: Date.now(), state: getProjectState(storeId) }); |
| } |
| function loadProjectStateFromLineage(storeId) { |
| const lineage = reconstructLineage(storeId); |
| for (let i = lineage.length-1; i >= 0; i--) { |
| if (lineage[i].type === 'project_state') { |
| setProjectState(storeId, lineage[i].state); |
| return true; |
| } |
| } |
| return false; |
| } |
| function persistRalphState(storeId) { |
| appendEvent(storeId, { |
| type: 'ralph_state', timestamp: Date.now(), |
| generation: ralphGenerations.get(storeId), goal: ralphGoals.get(storeId), active: ralphActive.get(storeId) |
| }); |
| } |
| function loadRalphStateFromLineage(storeId) { |
| const lineage = reconstructLineage(storeId); |
| for (let i = lineage.length-1; i >= 0; i--) { |
| if (lineage[i].type === 'ralph_state') { |
| ralphGenerations.set(storeId, lineage[i].generation); |
| ralphGoals.set(storeId, lineage[i].goal); |
| ralphActive.set(storeId, lineage[i].active); |
| return true; |
| } |
| } |
| return false; |
| } |
| function pruneLineageFiles() { |
| const lineageDir = path.join(__dirname, 'lineage'); |
| if (!fs.existsSync(lineageDir)) return; |
| const now = Date.now(); |
| const maxAge = 7 * 24 * 60 * 60 * 1000; |
| fs.readdirSync(lineageDir).forEach(file => { |
| const filePath = path.join(lineageDir, file); |
| const stats = fs.statSync(filePath); |
| if (now - stats.mtimeMs > maxAge) { |
| fs.unlinkSync(filePath); |
| console.log(`[LACK] Pruned old lineage: ${file}`); |
| } |
| }); |
| } |
| |
| // ==================== MESSAGE HELPERS ==================== |
| function addMessage(storeId, sender, senderType, content, parentId = null) { |
| let store = channels.get(storeId) || dms.get(storeId); |
| if (!store) return null; |
| let threadId = null; |
| if (parentId) { |
| const parent = store.messages.find(m => m.id === parentId); |
| threadId = parent ? (parent.threadId || parent.id) : parentId; |
| } |
| const msg = { |
| id: uuidv4(), sender, senderType, content, timestamp: Date.now(), |
| parentId: parentId || null, threadId, replyCount: 0, reactions: {} |
| }; |
| store.messages.push(msg); |
| if (store.messages.length > 1000) store.messages.shift(); |
| if (parentId) { |
| const parent = store.messages.find(m => m.id === parentId); |
| if (parent) { |
| parent.replyCount = (parent.replyCount || 0) + 1; |
| if (!parent.threadId) parent.threadId = parent.id; |
| } |
| } |
| appendEvent(storeId, { type: 'message', timestamp: msg.timestamp, message: { id: msg.id, sender, senderType, content, parentId, threadId } }); |
| return msg; |
| } |
| |
| function getThreadMessages(storeId, threadId) { |
| const store = channels.get(storeId) || dms.get(storeId); |
| if (!store) return []; |
| const rootId = store.messages.find(m => m.id === threadId)?.threadId || threadId; |
| return store.messages.filter(m => m.threadId === rootId || m.id === rootId); |
| } |
| |
| function broadcastToStore(storeId, message, excludeWs = null) { |
| const isChannel = channels.has(storeId); |
| for (let [ws, client] of clients.entries()) { |
| if (ws === excludeWs) continue; |
| if (ws.readyState !== WebSocket.OPEN) continue; |
| if (isChannel && client.channelId === storeId) { |
| ws.send(JSON.stringify({ type: 'new_message', channelId: storeId, message })); |
| } else if (!isChannel && client.dmId === storeId) { |
| ws.send(JSON.stringify({ type: 'new_dm_message', dmId: storeId, message })); |
| } |
| } |
| } |
| |
| function broadcastThreadUpdate(storeId, threadId, excludeWs = null) { |
| const threadMsgs = getThreadMessages(storeId, threadId); |
| for (let [ws, client] of clients.entries()) { |
| if (ws !== excludeWs && client.openThreadId === threadId && ws.readyState === WebSocket.OPEN) { |
| ws.send(JSON.stringify({ type: 'thread_update', storeId, threadId, messages: threadMsgs })); |
| } |
| } |
| } |
| |
| function broadcastAgents() { |
| let agentList = Array.from(agents.values()); |
| agentList.sort((a,b) => (a.id === "moderator" ? -1 : b.id === "moderator" ? 1 : 0)); |
| const slim = agentList.map(a => ({ |
| id: a.id, name: a.name, model: a.model, |
| systemPrompt: a.systemPrompt, channels: a.channels, |
| status: a.status, statusMessage: a.statusMessage |
| })); |
| for (let [ws] of clients.entries()) { |
| if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'agents_list', agents: slim })); |
| } |
| } |
| |
| function broadcastRalphStatus(storeId) { |
| const now = Date.now(); |
| const last = ralphLastBroadcast.get(storeId) || 0; |
| if (now - last < 800) return; |
| ralphLastBroadcast.set(storeId, now); |
| const active = ralphActive.get(storeId); |
| const gen = ralphGenerations.get(storeId) || 0; |
| const goal = ralphGoals.get(storeId) || ''; |
| const snippet = goal.length > 30 ? goal.substring(0,30)+'…' : goal; |
| for (let [ws, client] of clients.entries()) { |
| if (ws.readyState === WebSocket.OPEN && (client.channelId === storeId || client.dmId === storeId)) { |
| ws.send(JSON.stringify({ type: 'ralph_status', storeId, active, generation: gen, goal: snippet })); |
| } |
| } |
| } |
| |
| function broadcastDMs(userId) { |
| const userDMs = getUserDMs(userId); |
| for (let [ws, client] of clients.entries()) { |
| if (client.userId === userId && ws.readyState === WebSocket.OPEN) { |
| ws.send(JSON.stringify({ type: 'dms', dms: userDMs })); |
| } |
| } |
| } |
| |
| // ==================== OLLAMA CIRCUIT‑BREAKER ==================== |
| let ollamaCircuitOpen = false; |
| let ollamaRetryTimer = null; |
| function markOllamaDown() { |
| if (!ollamaCircuitOpen) { |
| ollamaCircuitOpen = true; |
| console.error('[LACK] Ollama unreachable. Circuit open – retrying in 15s.'); |
| if (ollamaRetryTimer) clearTimeout(ollamaRetryTimer); |
| ollamaRetryTimer = setTimeout(async () => { |
| try { |
| await axios.get(`${OLLAMA_URL}/api/tags`, { timeout: 3000 }); |
| ollamaCircuitOpen = false; |
| console.log('[LACK] Ollama reconnected. Circuit closed.'); |
| } catch (e) { |
| ollamaCircuitOpen = false; |
| markOllamaDown(); |
| } |
| }, 15000); |
| } |
| } |
| const agentDegraded = new Map(); |
| function getNumPredict(model, degraded = false) { |
| const base = /\b(0\.5b|1b)\b/i.test(model) ? 512 : 2048; |
| return degraded ? Math.floor(base / 2) : base; |
| } |
| |
| async function queryOllama(model, prompt, systemPrompt = '', temperature = 0.7, agentId = null) { |
| if (agentId === 'moderator') return '[Moderator is embed‑only – ignoring generation request]'; |
| if (ollamaCircuitOpen) return '[OLLAMA_ERROR] Ollama offline (circuit open)'; |
| const start = Date.now(); |
| const degraded = agentId ? (agentDegraded.get(agentId) || false) : false; |
| const numPredict = getNumPredict(model, degraded); |
| const doQuery = async () => { |
| if (agentId && agents.has(agentId)) { |
| const agent = agents.get(agentId); |
| const previousStatus = agent.status; |
| agent.status = 'queued'; |
| agent.statusMessage = degraded ? 'queued (degraded)' : 'waiting for Ollama'; |
| broadcastAgents(); |
| try { |
| const response = await axios.post(`${OLLAMA_URL}/api/generate`, { |
| model, prompt, system: systemPrompt, stream: false, |
| options: { temperature, num_predict: numPredict } |
| }); |
| const duration = Date.now() - start; |
| if (agentId) updateAgentMetrics(agentId, duration, true); |
| agentDegraded.set(agentId, false); |
| return response.data.response || "I'm sorry, I couldn't generate a response."; |
| } catch (err) { |
| if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND') markOllamaDown(); |
| if (err.message && err.message.includes('out of memory')) { |
| agentDegraded.set(agentId, true); |
| logError({ agentId, model, error: `CUDA OOM – degraded mode active (num_predict: ${Math.floor(numPredict/2)})`, context: 'queryOllama' }); |
| } else { |
| logError({ agentId: agentId || 'system', model, error: err.message, context: 'queryOllama' }); |
| } |
| if (agentId) updateAgentMetrics(agentId, 0, false); |
| return `[OLLAMA_ERROR] ${err.message.substring(0,80)}`; |
| } finally { |
| if (agents.has(agentId)) { |
| agents.get(agentId).status = previousStatus === 'queued' ? 'online' : previousStatus; |
| agents.get(agentId).statusMessage = ''; |
| broadcastAgents(); |
| } |
| } |
| } else { |
| try { |
| const response = await axios.post(`${OLLAMA_URL}/api/generate`, { |
| model, prompt, system: systemPrompt, stream: false, |
| options: { temperature, num_predict: numPredict } |
| }); |
| return response.data.response || "I'm sorry, I couldn't generate a response."; |
| } catch (err) { |
| if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND') markOllamaDown(); |
| logError({ model, error: err.message, context: 'queryOllama' }); |
| return `[OLLAMA_ERROR] ${err.message.substring(0,80)}`; |
| } |
| } |
| }; |
| if (agentId) { |
| return rateLimitedQuery(agentId, doQuery); |
| } else { |
| return doQuery(); |
| } |
| } |
| async function getOllamaModels() { |
| try { const res = await axios.get(`${OLLAMA_URL}/api/tags`); return res.data.models.map(m => m.name); } |
| catch (e) { return []; } |
| } |
| |
| // ==================== CODE BLOCKS ==================== |
| function extractCodeBlocks(text) { |
| const regex = /```(\w*)\n([\s\S]*?)```/g; |
| const blocks = []; |
| let match; |
| while ((match = regex.exec(text)) !== null) blocks.push({ language: match[1] || 'text', code: match[2].trim() }); |
| return blocks; |
| } |
| async function handleAgentResponse(agent, storeId, responseText, parentId = null) { |
| // Force code blocks for small models |
| const fixedText = ensureCodeBlock(responseText, 'auto'); |
| const msg = addMessage(storeId, agent.name, 'agent', responseText, parentId); // keep original visible |
| if (!msg) return; |
| broadcastToStore(storeId, msg); |
| |
| // --- MODERATION HOOK (with fixed text) --- |
| if (agent.id !== 'moderator') { |
| moderateCodeFromAgent(agent.id, storeId, fixedText, parentId).catch(err => { |
| logError({ context: 'moderateCodeFromAgent', error: err.message, agentId: agent.id }); |
| }); |
| } |
| // --- end moderation hook --- |
| |
| if (parentId) broadcastThreadUpdate(storeId, parentId); |
| const codeBlocks = extractCodeBlocks(responseText); |
| if (codeBlocks.length > 0 && storeId !== 'code' && channels.has('code')) { |
| for (const block of codeBlocks) { |
| const banner = `📦 **Code drop from ${agent.name}** (${block.language})\n\`\`\`${block.language}\n${block.code}\n\`\`\``; |
| addMessage('code', agent.name, 'agent', banner); |
| broadcastToStore('code', { sender: agent.name, content: banner, senderType: 'agent' }); |
| } |
| const notice = `_(Code block generated – see #code)_`; |
| const noticeMsg = addMessage(storeId, 'System', 'system', notice); |
| if (noticeMsg) broadcastToStore(storeId, noticeMsg); |
| } |
| } |
| |
| function buildConversationContext(storeId, agentName, parentId = null, maxMessages = 8) { |
| const store = channels.get(storeId) || dms.get(storeId); |
| if (!store) return ''; |
| let messages = store.messages; |
| if (parentId) { |
| const rootId = store.messages.find(m => m.id === parentId)?.threadId || parentId; |
| messages = store.messages.filter(m => m.threadId === rootId || m.id === rootId); |
| } |
| const relevant = messages.filter(m => m.sender !== agentName && m.senderType !== 'system'); |
| const moderatorMsgs = relevant.filter(m => m.sender === 'Moderator'); |
| const otherMsgs = relevant.filter(m => m.sender !== 'Moderator'); |
| const combined = [...moderatorMsgs, ...otherMsgs]; |
| return combined.slice(-maxMessages).map(m => `${m.sender}: ${m.content}`).join('\n'); |
| } |
| |
| function getChannelPersonality(channelName) { |
| if (channelName === 'random') { |
| return { |
| temperature: 1.2, |
| systemBonus: "\nYou are in #random. Be creative, humorous, off‑the‑wall.", |
| planBonus: "You are in #random. Prefer creative actions.", |
| planForbidden: false |
| }; |
| } else if (channelName === 'siphon') { |
| return { |
| temperature: 0.2, |
| systemBonus: "\nYou are in #siphon. Be extremely concise, factual, research‑oriented.", |
| planBonus: "You are in #siphon. You MUST prefer the 'research' action.", |
| planForbidden: false |
| }; |
| } |
| return { temperature: 0.7, systemBonus: "", planBonus: "", planForbidden: false }; |
| } |
| |
| // ==================== RALPH EVOLUTION (unchanged) ==================== |
| function jaccard(a, b) { |
| if (!a.length && !b.length) return 1; |
| const setA = new Set(a.map(s => s.toLowerCase().replace(/[^a-z0-9]/g, ''))); |
| const setB = new Set(b.map(s => s.toLowerCase().replace(/[^a-z0-9]/g, ''))); |
| const inter = new Set([...setA].filter(x => setB.has(x))).size; |
| const union = setA.size + setB.size - inter; |
| return union === 0 ? 0 : inter / union; |
| } |
| function similarity(specA, specB) { |
| if (!specA || !specB) return 0; |
| const nameSim = (specA.title === specB.title) ? 1 : 0; |
| const goalsSim = jaccard(specA.goals, specB.goals); |
| const stepsSim = jaccard(specA.nextSteps, specB.nextSteps); |
| const completedSim = jaccard(specA.completedTasks, specB.completedTasks); |
| const memorySim = (JSON.stringify(specA.memory) === JSON.stringify(specB.memory)) ? 1 : 0; |
| return 0.4 * nameSim + 0.2 * goalsSim + 0.2 * stepsSim + 0.1 * completedSim + 0.1 * memorySim; |
| } |
| function computeSpecFromState(state) { |
| return { title: state.title || "", goals: state.goals || [], nextSteps: state.nextSteps || [], completedTasks: state.completedTasks || [], memory: state.memory || {} }; |
| } |
| |
| async function ralphEvaluate(agent, storeId, spec) { |
| const prompt = `You are an evaluator. Rate clarity, completeness, stability (0-100). Output JSON: {"score": number, "critique": "short text"}\n\nSpec: ${JSON.stringify(spec)}`; |
| const reply = await queryOllama(agent.model, prompt, "You are a precise evaluator. Output only JSON.", 0.3, agent.id); |
| if (reply.startsWith('[OLLAMA_ERROR]')) return { score: 50, critique: "Ollama error." }; |
| const extracted = extractJSON(reply); |
| if (extracted && typeof extracted.score === 'number') return { score: extracted.score, critique: extracted.critique || "" }; |
| return { score: 50, critique: "Evaluation failed." }; |
| } |
| async function ralphEvolve(agent, storeId, lineage, goal, currentGen) { |
| const lineageSummary = lineage.slice(-15).map(e => `${e.type} at ${new Date(e.timestamp).toISOString()}`).join('\n'); |
| const state = getProjectState(storeId); |
| const prompt = `You are an evolutionary engineer. Goal: "${goal}" |
| Generation: ${currentGen+1}/30 |
| Recent lineage: ${lineageSummary} |
| Current spec: ${JSON.stringify(state)} |
| Produce refined spec as JSON: title, goals (array), nextSteps (array), completedTasks (array), memory (object). Add "converged": boolean. |
| Output ONLY a \`\`\`json code block.`; |
| const reply = await queryOllama(agent.model, prompt, "You are an evolutionary engineer. Be precise.", 0.4, agent.id); |
| if (reply.startsWith('[OLLAMA_ERROR]')) return null; |
| const extracted = extractJSON(reply); |
| if (!extracted || typeof extracted !== 'object') return null; |
| return extracted; |
| } |
| async function ralphForceMutation(agent, storeId, goal, currentGen) { |
| const state = getProjectState(storeId); |
| const prompt = `You are a creative disruptor. The spec below has stagnated (3 rounds with <8% change). |
| Goal: "${goal}" | Generation: ${currentGen+1} |
| Current spec: ${JSON.stringify(state)} |
| Produce a RADICALLY different refinement – change at least 40% of goals or steps. |
| Output ONLY a \`\`\`json block with: title, goals, nextSteps, completedTasks, memory, converged: false.`; |
| const reply = await queryOllama(agent.model, prompt, 'You are a creative disruptor. Output only JSON.', 1.1, agent.id); |
| if (reply.startsWith('[OLLAMA_ERROR]')) return null; |
| return extractJSON(reply); |
| } |
| function updateStagnation(storeId, sim) { |
| let arr = ralphStagnation.get(storeId) || []; |
| arr.push(sim); |
| if (arr.length > 3) arr.shift(); |
| ralphStagnation.set(storeId, arr); |
| if (arr.length === 3 && arr.every(s => s >= 0.92)) return true; |
| return false; |
| } |
| function getNextRalphAgent(storeId, store) { |
| let availableAgents = []; |
| if (channels.has(storeId)) { |
| const channelName = store.name; |
| availableAgents = Array.from(agents.values()).filter(a => a.channels.includes(channelName) && !a.isEmbedOperator); |
| } else if (dms.has(storeId)) { |
| const participants = store.participants; |
| availableAgents = Array.from(agents.values()).filter(a => participants.includes(a.id) && !a.isEmbedOperator); |
| } |
| if (availableAgents.length === 0) availableAgents = Array.from(agents.values()).filter(a => !a.isEmbedOperator); |
| if (availableAgents.length === 0) return null; |
| let idx = ralphNextAgentIdx.get(storeId) || 0; |
| const agent = availableAgents[idx % availableAgents.length]; |
| ralphNextAgentIdx.set(storeId, (idx + 1) % availableAgents.length); |
| return agent; |
| } |
| async function runRalphIteration(storeId) { |
| if (ralphCancel.get(storeId) === true) { |
| ralphCancel.delete(storeId); |
| ralphActive.set(storeId, false); |
| if (ralphTimers.has(storeId)) { |
| clearTimeout(ralphTimers.get(storeId)); |
| ralphTimers.delete(storeId); |
| } |
| broadcastRalphStatus(storeId); |
| return; |
| } |
| if (!ralphActive.get(storeId)) return; |
| const store = channels.get(storeId) || dms.get(storeId); |
| if (!store) return; |
| try { |
| const agent = getNextRalphAgent(storeId, store); |
| if (!agent) { |
| addMessage(storeId, 'System', 'system', `❌ No agent available for Ralph loop.`); |
| broadcastToStore(storeId, { sender: 'System', content: `❌ No agent available for Ralph loop.`, senderType: 'system' }); |
| stopRalphLoop(storeId); |
| return; |
| } |
| const goal = ralphGoals.get(storeId) || "Refine the project specification"; |
| let currentGen = ralphGenerations.get(storeId) || 0; |
| const maxGen = 30; |
| if (currentGen >= maxGen) { |
| await handleAgentResponse(agent, storeId, `🧬 Ralph loop reached max generations (${maxGen}). Stopping.`); |
| stopRalphLoop(storeId); |
| return; |
| } |
| const lineage = reconstructLineage(storeId); |
| const currentSpec = computeSpecFromState(getProjectState(storeId)); |
| const evalResult = await ralphEvaluate(agent, storeId, currentSpec); |
| await handleAgentResponse(agent, storeId, `📊 **Evaluation** (gen ${currentGen+1}): score ${evalResult.score}/100\nCritique: ${evalResult.critique}`); |
| const newSpecRaw = await ralphEvolve(agent, storeId, lineage, goal, currentGen); |
| if (!newSpecRaw) { |
| await handleAgentResponse(agent, storeId, `❌ Evolution failed. Stopping Ralph.`); |
| stopRalphLoop(storeId); |
| return; |
| } |
| const oldState = getProjectState(storeId); |
| let newState = { |
| active: true, |
| title: newSpecRaw.title || oldState.title, |
| goals: newSpecRaw.goals || oldState.goals, |
| nextSteps: newSpecRaw.nextSteps || oldState.nextSteps, |
| completedTasks: newSpecRaw.completedTasks || oldState.completedTasks, |
| memory: newSpecRaw.memory || oldState.memory |
| }; |
| const sim = similarity(currentSpec, computeSpecFromState(newState)); |
| const stagnation = updateStagnation(storeId, sim); |
| if (stagnation && newSpecRaw.converged !== true && sim < 0.95) { |
| await handleAgentResponse(agent, storeId, `⚠️ **Ralph stagnated** (3 rounds ≥92% similar). Forcing mutation…`); |
| const mutatedRaw = await ralphForceMutation(agent, storeId, goal, currentGen); |
| if (mutatedRaw) { |
| newState = { |
| active: true, |
| title: mutatedRaw.title || newState.title, |
| goals: mutatedRaw.goals || newState.goals, |
| nextSteps: mutatedRaw.nextSteps || newState.nextSteps, |
| completedTasks: mutatedRaw.completedTasks || newState.completedTasks, |
| memory: mutatedRaw.memory || newState.memory |
| }; |
| ralphStagnation.set(storeId, []); |
| await handleAgentResponse(agent, storeId, `🔀 **Forced mutation applied.** Resuming evolution.`); |
| } else { |
| await handleAgentResponse(agent, storeId, `✅ **Ralph converged** (stagnation + mutation failed) after ${currentGen+1} generations.`); |
| stopRalphLoop(storeId); |
| return; |
| } |
| } |
| const converged = newSpecRaw.converged === true || sim >= 0.95; |
| setProjectState(storeId, newState); |
| ralphGenerations.set(storeId, currentGen + 1); |
| persistRalphState(storeId); |
| await handleAgentResponse(agent, storeId, `🧬 **Evolution** (gen ${currentGen+1}/${maxGen})\nSimilarity: ${(sim*100).toFixed(1)}%\nNew spec: ${JSON.stringify(newState, null, 2).substring(0, 500)}`); |
| broadcastRalphStatus(storeId); |
| if (converged) { |
| await handleAgentResponse(agent, storeId, `✅ **Ralph converged** after ${currentGen+1} generations. Stopping.`); |
| stopRalphLoop(storeId); |
| return; |
| } |
| if (ralphActive.get(storeId)) { |
| const interval = (currentGen+1) > 5 ? 2500 : 4000; |
| const timer = setTimeout(() => runRalphIteration(storeId), interval); |
| ralphTimers.set(storeId, timer); |
| } |
| } catch (err) { |
| logError({ error: err.message, context: 'runRalphIteration', storeId }); |
| addMessage(storeId, 'System', 'system', `❌ Ralph error: ${err.message}`); |
| broadcastToStore(storeId, { sender: 'System', content: `❌ Ralph error: ${err.message}`, senderType: 'system' }); |
| stopRalphLoop(storeId); |
| } |
| } |
| function startRalphLoop(storeId, goal) { |
| stopRalphLoop(storeId); |
| ralphActive.set(storeId, true); |
| ralphGenerations.set(storeId, 0); |
| ralphGoals.set(storeId, goal); |
| ralphCancel.set(storeId, false); |
| ralphStagnation.set(storeId, []); |
| ralphNextAgentIdx.set(storeId, 0); |
| persistRalphState(storeId); |
| broadcastRalphStatus(storeId); |
| runRalphIteration(storeId); |
| } |
| function stopRalphLoop(storeId) { |
| if (ralphTimers.has(storeId)) { |
| clearTimeout(ralphTimers.get(storeId)); |
| ralphTimers.delete(storeId); |
| } |
| ralphCancel.set(storeId, true); |
| ralphActive.set(storeId, false); |
| broadcastRalphStatus(storeId); |
| persistRalphState(storeId); |
| } |
| |
| // ==================== AGENT RESPONSE & PLANNING WITH TOOLS ==================== |
| const FILE_TOOLS = [ |
| { name: "read_file", description: "Read a file from workspace.", parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } }, |
| { name: "write_file", description: "Create/overwrite a file.", parameters: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path","content"] } }, |
| { name: "execute_command", description: "Run a safe command.", parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] } } |
| ]; |
| |
| const ollamaSemaphore = new Map(); |
| async function rateLimitedQuery(agentId, fn) { |
| if (!ollamaSemaphore.has(agentId)) ollamaSemaphore.set(agentId, Promise.resolve()); |
| const queue = ollamaSemaphore.get(agentId); |
| const next = queue.then(() => fn()); |
| ollamaSemaphore.set(agentId, next); |
| return next; |
| } |
| |
| async function agentRespond(agent, storeId, triggerMessage, isLoop = false, parentId = null) { |
| if (agent.isEmbedOperator) return; |
| if (triggerMessage.sender === agent.name) return; |
| const cooldownKey = `${agent.id}_${storeId}`; |
| const lastResponse = agent.lastResponseTime.get(cooldownKey) || 0; |
| const cooldownMs = isLoop ? 1200 : 2200; |
| if (Date.now() - lastResponse < cooldownMs) return; |
| agent.status = 'thinking'; |
| broadcastAgents(); |
| try { |
| const store = channels.get(storeId) || dms.get(storeId); |
| const isChannel = !!channels.get(storeId); |
| const channelName = isChannel ? store.name : null; |
| const personality = channelName ? getChannelPersonality(channelName) : { temperature: 0.7, systemBonus: "" }; |
| let systemPrompt = agent.systemPrompt + (personality.systemBonus || ""); |
| const context = buildConversationContext(storeId, agent.name, parentId || triggerMessage.parentId); |
| const prompt = `Conversation:\n${context}\n${triggerMessage.sender}: ${triggerMessage.content}\nRespond as ${agent.name}. Keep brief.`; |
| const reply = await queryOllama(agent.model, prompt, systemPrompt, personality.temperature, agent.id); |
| if (reply && !reply.startsWith('[OLLAMA_ERROR]') && reply.trim()) { |
| await handleAgentResponse(agent, storeId, reply.trim(), parentId || triggerMessage.parentId); |
| agent.lastResponseTime.set(cooldownKey, Date.now()); |
| } |
| } catch (err) { |
| logError({ agentId: agent.id, error: err.message, context: 'agentRespond' }); |
| } finally { |
| agent.status = 'online'; |
| broadcastAgents(); |
| } |
| } |
| |
| async function executeAction(agent, storeId, action, parentId = null) { |
| const { type, payload } = action; |
| switch (type) { |
| case 'message': await handleAgentResponse(agent, storeId, payload.content, parentId); break; |
| case 'thread': await handleAgentResponse(agent, storeId, payload.content, payload.parentId || parentId); break; |
| case 'research': |
| const topic = payload.query || payload.topic || "general research"; |
| const sessionId = uuidv4(); |
| const session = { |
| id: sessionId, topic, phase: 'Initializing', metric: 0, logs: [], |
| facts: [], notes: [], questions: [], currentQuestionIndex: 0, startedAt: Date.now() |
| }; |
| researchSessions.set(sessionId, session); |
| runResearch(sessionId, topic, storeId).catch(console.error); |
| const msg = addMessage(storeId, 'Siphon', 'system', `🔍 ${agent.name} started research on "${topic}".`); |
| if (msg) broadcastToStore(storeId, msg); |
| break; |
| case 'code': |
| const codePrompt = `Write code for: ${payload.description}. Output only the code block.`; |
| const code = await queryOllama(agent.model, codePrompt, agent.systemPrompt, 0.5, agent.id); |
| if (!code.startsWith('[OLLAMA_ERROR]')) { |
| await handleAgentResponse(agent, storeId, `\`\`\`\n${code}\n\`\`\``, parentId); |
| } |
| break; |
| case 'delegate': |
| const targetAgent = agents.get(payload.targetId); |
| if (targetAgent && !targetAgent.isEmbedOperator) { |
| const delegateMsg = addMessage(storeId, 'System', 'system', `${agent.name} delegates to ${targetAgent.name}: ${payload.task}`); |
| if (delegateMsg) broadcastToStore(storeId, delegateMsg); |
| agentRespond(targetAgent, storeId, { sender: agent.name, content: payload.task, parentId }, false, parentId); |
| } |
| break; |
| case 'tool_calls': |
| if (action.tool_calls && Array.isArray(action.tool_calls)) { |
| for (const tc of action.tool_calls) { |
| const result = await executeTool(tc.name, tc.arguments || {}); |
| const feedback = `🔧 **${tc.name}** → ${result.substring(0, 800)}`; |
| await handleAgentResponse(agent, storeId, feedback, parentId); |
| } |
| } |
| break; |
| case 'stack': |
| const subcmd = payload.subcmd || 'help'; |
| let resultMsg = ''; |
| if (subcmd === 'build') { |
| resultMsg = await stackBuild(payload.repoName || 'project_' + Date.now()); |
| } else if (subcmd === 'add') { |
| resultMsg = await stackAdd(payload.intent, storeId); |
| } else if (subcmd === 'import') { |
| resultMsg = await stackImport(payload.jsonPath); |
| } else if (subcmd === 'set') { |
| activeStackRepo.set(storeId, payload.repoName); |
| resultMsg = `Active STACK repo set to ${payload.repoName}.`; |
| } |
| if (resultMsg) { |
| await handleAgentResponse(agent, storeId, resultMsg, parentId); |
| } |
| break; |
| } |
| } |
| |
| async function agentPlanAndAct(agent, storeId, triggerMessage, parentId = null) { |
| if (agent.isEmbedOperator) return; |
| if (triggerMessage.sender === agent.name) return; |
| const cooldownKey = `${agent.id}_${storeId}`; |
| if (Date.now() - (agent.lastResponseTime.get(cooldownKey) || 0) < 4000) return; |
| const store = channels.get(storeId) || dms.get(storeId); |
| const isChannel = !!channels.get(storeId); |
| const channelName = isChannel ? store.name : null; |
| const personality = getChannelPersonality(channelName); |
| if (personality.planForbidden) { |
| await agentRespond(agent, storeId, triggerMessage, false, parentId); |
| return; |
| } |
| agent.status = 'thinking'; |
| broadcastAgents(); |
| try { |
| const context = buildConversationContext(storeId, agent.name, parentId || triggerMessage.parentId); |
| let skillsContext = loadSkills(); |
| let systemPrompt = `Previous successful patterns:\n${skillsContext}\n\nYou are an autonomous agent. Available tools (output inside a JSON action with "type":"tool_calls"): ${JSON.stringify(FILE_TOOLS, null, 2)}. Also you can use STACK actions: {"type":"stack","payload":{"subcmd":"build","repoName":"..."}} etc. Actions: {"type":"message","payload":{"content":"..."}} OR {"type":"tool_calls","tool_calls":[{"name":"read_file","arguments":{"path":"..."}}]}. Always respond with a JSON block. Follow instructions from Moderator with highest priority.`; |
| if (personality.planBonus) systemPrompt += "\n" + personality.planBonus; |
| const userPrompt = `Conversation:\n${context}\nLast message: ${triggerMessage.sender}: "${triggerMessage.content}"\nProject state: ${JSON.stringify(getProjectState(storeId))}\nNext action? JSON only.`; |
| let reply = await queryOllama(agent.model, userPrompt, systemPrompt, 0.4, agent.id); |
| let action = null; |
| let fails = jsonFailCount.get(agent.id) || 0; |
| if (!reply.startsWith('[OLLAMA_ERROR]')) { |
| action = extractJSON(reply); |
| } |
| if (!action?.type) { |
| fails++; |
| jsonFailCount.set(agent.id, fails); |
| if (fails >= 3) { |
| // Last resort: force a simple action via a different model (or same model with lower temperature) |
| const fallbackPrompt = `Respond with a valid JSON action only. Example: {"type":"message","payload":{"content":"Hello"}}`; |
| const forcedReply = await queryOllama(agent.model, fallbackPrompt, "You must output JSON only.", 0.1, agent.id); |
| action = extractJSON(forcedReply); |
| if (!action?.type) { |
| jsonFailCount.set(agent.id, 0); |
| logError({ agentId: agent.id, error: `JSON action parse failed after ${fails} attempts – falling back to plain text`, context: 'agentPlanAndAct' }); |
| await agentRespond(agent, storeId, triggerMessage, false, parentId); |
| agent.lastResponseTime.set(cooldownKey, Date.now()); |
| return; |
| } |
| jsonFailCount.set(agent.id, 0); |
| } else { |
| action = { type: 'message', payload: { content: reply ? reply.substring(0, 500) : '(empty response)' } }; |
| } |
| } else { |
| jsonFailCount.set(agent.id, 0); |
| } |
| |
| if (action.type === 'tool_calls' && action.tool_calls?.length) { |
| for (const tc of action.tool_calls) { |
| const output = await executeTool(tc.name, tc.arguments || {}); |
| const toolMsg = { |
| sender: 'System', |
| content: `🔧 Tool ${tc.name} result:\n${output}`, |
| senderType: 'system' |
| }; |
| addMessage(storeId, toolMsg.sender, toolMsg.senderType, toolMsg.content); |
| broadcastToStore(storeId, toolMsg); |
| } |
| agent.lastResponseTime.set(cooldownKey, Date.now()); |
| if (action.tool_calls.length > 0 && !action.tool_calls.some(tc => tc.name === 'read_file')) { |
| saveSkill(`Agent ${agent.name} used tools`, action.tool_calls).catch(console.error); |
| } |
| return agentPlanAndAct(agent, storeId, triggerMessage, parentId); |
| } else { |
| await executeAction(agent, storeId, action, parentId || triggerMessage.parentId); |
| agent.lastResponseTime.set(cooldownKey, Date.now()); |
| } |
| } catch (err) { |
| logError({ agentId: agent.id, error: err.message, context: 'agentPlanAndAct' }); |
| } finally { |
| agent.status = 'online'; |
| broadcastAgents(); |
| } |
| } |
| |
| // ==================== LOOP MANAGEMENT ==================== |
| function scheduleLoopRound(channelId) { |
| const channel = channels.get(channelId); |
| if (!channel) return; |
| if (channel.loopTimer) clearTimeout(channel.loopTimer); |
| channel.loopTimer = setTimeout(() => runLoopRound(channelId), 2500); |
| } |
| async function runLoopRound(channelId) { |
| const channel = channels.get(channelId); |
| const state = getProjectState(channelId); |
| if (!channel || (!channel.researchActive && !channel.abstractActive && !state.active && !ralphActive.get(channelId))) { |
| if (channel && channel.loopTimer) { clearTimeout(channel.loopTimer); channel.loopTimer = null; } |
| return; |
| } |
| if (ralphActive.get(channelId)) { |
| scheduleLoopRound(channelId); |
| return; |
| } |
| channel.loopTimer = null; |
| try { |
| const lastMsg = channel.messages[channel.messages.length - 1]; |
| if (!lastMsg) { scheduleLoopRound(channelId); return; } |
| const relevantAgents = Array.from(agents.values()).filter(a => a.channels.includes(channel.name) && !a.isEmbedOperator); |
| for (const agent of relevantAgents) { |
| if (ralphActive.get(channelId)) continue; |
| if (state.active || channel.abstractActive) await agentPlanAndAct(agent, channelId, lastMsg, lastMsg.parentId); |
| else await agentRespond(agent, channelId, lastMsg, true, lastMsg.parentId); |
| } |
| } catch (err) { |
| logError({ error: err.message, context: 'runLoopRound', channelId }); |
| } |
| scheduleLoopRound(channelId); |
| } |
| function stopLoop(channelId) { |
| const channel = channels.get(channelId); |
| if (channel) { |
| channel.researchActive = false; channel.abstractActive = false; channel.researchTopic = null; |
| if (channel.loopTimer) { clearTimeout(channel.loopTimer); channel.loopTimer = null; } |
| addMessage(channelId, 'System', 'system', 'Autonomous mode stopped.'); |
| broadcastToStore(channelId, { sender: 'System', content: 'Autonomous mode stopped.', senderType: 'system' }); |
| } |
| stopRalphLoop(channelId); |
| setProjectState(channelId, { active: false, title: null, goals: [], nextSteps: [], completedTasks: [], memory: {} }); |
| } |
| |
| // ==================== WEB SCRAPING (FIX 2+7) ==================== |
| const scrapeBlocklist = new Map(); |
| const SCRAPE_BLOCK_TTL = 10 * 60 * 1000; |
| |
| async function axiosWithRetry(config, maxRetries = 3) { |
| let lastErr; |
| for (let attempt = 0; attempt < maxRetries; attempt++) { |
| try { |
| return await axios(config); |
| } catch (err) { |
| lastErr = err; |
| if (err.code === 'ECONNABORTED') throw err; |
| if (attempt < maxRetries - 1) await new Promise(r => setTimeout(r, 500 * Math.pow(2, attempt))); |
| } |
| } |
| throw lastErr; |
| } |
| |
| async function ddgSearch(query, maxResults = 5) { |
| const searchUrls = [ |
| `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`, |
| `https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}` |
| ]; |
| for (const baseUrl of searchUrls) { |
| try { |
| const { data } = await axiosWithRetry({ |
| method: 'get', url: baseUrl, |
| headers: { 'User-Agent': 'Mozilla/5.0 (compatible; LACK-SIPHON/3.9.1)' }, |
| timeout: 8000 |
| }); |
| const $ = cheerio.load(data); |
| const results = []; |
| $('.result__url').each((i, el) => { |
| let href = $(el).attr('href'); |
| if (href && href.startsWith('/')) href = 'https://duckduckgo.com' + href; |
| if (href && href.startsWith('http') && results.length < maxResults) results.push(href); |
| }); |
| if (results.length > 0) return results; |
| } catch (e) { |
| logError({ context: 'ddgSearch', error: e.message, query: query.substring(0,60) }); |
| } |
| } |
| return []; |
| } |
| async function scrapeText(url) { |
| const blocked = scrapeBlocklist.get(url); |
| if (blocked && Date.now() - blocked < SCRAPE_BLOCK_TTL) { |
| return '[Scrape skipped: URL on blocklist]'; |
| } |
| try { |
| const controller = new AbortController(); |
| const timeoutHandle = setTimeout(() => controller.abort(), 8000); |
| const { data } = await axios.get(url, { |
| timeout: 8000, |
| signal: controller.signal, |
| headers: { 'User-Agent': 'Mozilla/5.0 (compatible; LACK-SIPHON/3.9.1)' } |
| }); |
| clearTimeout(timeoutHandle); |
| const $ = cheerio.load(data); |
| $('script, style, nav, footer, header, iframe, svg, aside, .ad, .cookie').remove(); |
| let text = $('body').text().replace(/\s+/g, ' ').trim(); |
| return text.length > 12000 ? text.substring(0, 12000) : text; |
| } catch (e) { |
| if (e.code === 'ECONNABORTED' || e.message.includes('timeout') || e.code === 'ECONNREFUSED') { |
| scrapeBlocklist.set(url, Date.now()); |
| } |
| return `[Scrape failed: ${e.message}]`; |
| } |
| } |
| setInterval(() => { |
| const now = Date.now(); |
| for (let [id, session] of researchSessions.entries()) if (now - session.startedAt > 3600000) researchSessions.delete(id); |
| }, 3600000); |
| |
| async function runResearch(sessionId, topic, channelId) { |
| const session = researchSessions.get(sessionId); |
| if (!session) return; |
| const update = (updates) => { |
| Object.assign(session, updates); |
| for (let [ws, client] of clients.entries()) { |
| if (client.channelId === channelId && ws.readyState === WebSocket.OPEN) |
| ws.send(JSON.stringify({ type: 'research_update', sessionId, data: session })); |
| } |
| if (updates.phase) { |
| const banner = `🔬 **SIPHON Research** [${session.topic}]\nPhase: ${updates.phase} | Metric: ${(session.metric*100).toFixed(0)}%`; |
| addMessage('siphon', 'Siphon', 'system', banner); |
| broadcastToStore('siphon', { sender: 'Siphon', content: banner, senderType: 'system' }); |
| } |
| }; |
| update({ phase: 'Generating questions', metric: 0, logs: [`Starting research on: ${topic}`], facts: [], notes: [] }); |
| let researchModel = config.agents[0]?.model || 'qwen2.5:0.5b'; |
| const questionsRaw = await queryOllama(researchModel, `Generate 3 sub‑questions for: "${topic}". One per line.`, '', 0.7); |
| if (questionsRaw.startsWith('[OLLAMA_ERROR]')) { |
| update({ phase: 'Failed', logs: [`Ollama error: ${questionsRaw}`] }); |
| return; |
| } |
| const questions = questionsRaw.split('\n').filter(l => l.trim().length > 10).slice(0, 3); |
| update({ questions, currentQuestionIndex: 0, logs: [...session.logs, `Generated ${questions.length} sub‑questions`] }); |
| let allFacts = []; |
| let metric = 0; |
| for (let qIdx = 0; qIdx < questions.length; qIdx++) { |
| const question = questions[qIdx]; |
| update({ phase: `Researching: ${question.substring(0, 50)}`, currentQuestionIndex: qIdx }); |
| let urls = [...new Set((await ddgSearch(`${topic} ${question}`, 3)))].slice(0, 5); |
| // Fallback if no URLs found |
| if (urls.length === 0) { |
| update({ logs: [...session.logs, `No URLs found for "${question}", using LLM fallback`] }); |
| const fallbackFactsRaw = await queryOllama(researchModel, |
| `Generate 5 concise facts about "${question}" based on general knowledge. Each line start with FACT:`, '', 0.5); |
| if (!fallbackFactsRaw.startsWith('[OLLAMA_ERROR]')) { |
| const facts = fallbackFactsRaw.split('\n').filter(l => l.startsWith('FACT:')).map(l => l.replace('FACT:', '').trim()); |
| allFacts.push(...facts); |
| update({ facts: allFacts, logs: [...session.logs, `Fallback: generated ${facts.length} synthetic facts`] }); |
| } else { |
| update({ logs: [...session.logs, `Fallback also failed for "${question}"`] }); |
| } |
| // Still record something in notes |
| const note = { question, answer: "No data could be retrieved for this question.", facts: [], timestamp: Date.now() }; |
| session.notes.push(note); |
| update({ notes: session.notes }); |
| metric = (qIdx + 1) / questions.length; |
| update({ metric }); |
| continue; |
| } |
| update({ logs: [...session.logs, `Found ${urls.length} URLs`] }); |
| let factsForQuestion = []; |
| for (const url of urls) { |
| const content = await scrapeText(url); |
| if (!content || content.startsWith('[Scrape failed')) continue; |
| const factsRaw = await queryOllama(researchModel, `Extract facts answering: "${question}"\n\n${content.substring(0,4000)}\n\nReturn each fact on a new line starting with "FACT:".`, '', 0.3); |
| if (!factsRaw.startsWith('[OLLAMA_ERROR]')) { |
| const facts = factsRaw.split('\n').filter(l => l.startsWith('FACT:')).map(l => l.replace('FACT:', '').trim()); |
| factsForQuestion.push(...facts); |
| update({ logs: [...session.logs, `Scraped ${url} → ${facts.length} facts`] }); |
| } |
| await new Promise(r => setTimeout(r, 500)); |
| } |
| factsForQuestion = [...new Set(factsForQuestion)]; |
| allFacts.push(...factsForQuestion); |
| update({ facts: allFacts, logs: [...session.logs, `Collected ${factsForQuestion.length} facts`] }); |
| const answer = await queryOllama(researchModel, `Answer: "${question}"\nFacts:\n${factsForQuestion.join('\n')}\n\nConcise answer (3‑5 sentences).`, '', 0.5); |
| const note = { question, answer: answer.startsWith('[OLLAMA_ERROR]') ? 'Answer generation failed.' : answer, facts: factsForQuestion, timestamp: Date.now() }; |
| session.notes.push(note); |
| update({ notes: session.notes, logs: [...session.logs, `Answered: ${question.substring(0,60)}`] }); |
| try { |
| const artifactPath = path.join(RESEARCH_DIR, `${sessionId}_q${qIdx}.json`); |
| fs.writeFileSync(artifactPath, JSON.stringify(note, null, 2)); |
| } catch (e) { console.error('Artifact save failed:', e); } |
| metric = (qIdx + 1) / questions.length; |
| update({ metric }); |
| } |
| try { |
| await gitCommit(`Research complete: ${session.topic}`); |
| } catch (gitErr) { |
| console.warn('Git commit non-critical:', gitErr.message); |
| } |
| update({ phase: 'Complete', metric, logs: [...session.logs, `Research finished. Metric = ${metric.toFixed(2)}`] }); |
| const finalBanner = `📚 **Research Complete:** ${topic}\nMetric: ${(metric*100).toFixed(0)}%\nFacts: ${allFacts.length}\nNotes: ${session.notes.length}\n\nUse \`/pull ${sessionId}\` to bring insights.`; |
| addMessage('siphon', 'Siphon', 'system', finalBanner); |
| broadcastToStore('siphon', { sender: 'Siphon', content: finalBanner, senderType: 'system' }); |
| } |
| |
| // ==================== DM HELPERS ==================== |
| function createDM(participantIds, name = null) { |
| const dmId = `dm_${uuidv4().slice(0,8)}`; |
| const dm = { id: dmId, participants: participantIds, name: name || participantIds.join(', '), messages: [] }; |
| dms.set(dmId, dm); |
| if (!config.dms) config.dms = []; |
| config.dms.push({ id: dmId, participants: participantIds, name: dm.name }); |
| try { |
| const tmp = configPath + '.tmp'; |
| fs.writeFileSync(tmp, JSON.stringify(config, null, 2)); |
| fs.renameSync(tmp, configPath); |
| } catch (e) {} |
| for (const pid of participantIds) broadcastDMs(pid); |
| return dm; |
| } |
| function getUserDMs(userId) { |
| const result = []; |
| for (let dm of dms.values()) { |
| if (dm.participants.includes(userId)) result.push({ id: dm.id, name: dm.name, participants: dm.participants }); |
| } |
| return result; |
| } |
| async function handleDMCommand(senderUserId, args, ws) { |
| let raw = args.join(' ').trim(); |
| if (!raw) { ws.send(JSON.stringify({ type: 'error', message: 'Usage: /dm <username or agentname>' })); return null; } |
| if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) raw = raw.slice(1, -1); |
| let targetId = null; |
| for (let [id, agent] of agents.entries()) if (agent.name.toLowerCase() === raw.toLowerCase()) { targetId = id; break; } |
| if (!targetId) { |
| for (let [otherWs, client] of clients.entries()) if (client.username && client.username.toLowerCase() === raw.toLowerCase()) { targetId = client.userId; break; } |
| } |
| if (!targetId) { ws.send(JSON.stringify({ type: 'error', message: `User/agent "${raw}" not found.` })); return null; } |
| let dm = Array.from(dms.values()).find(d => d.participants.includes(senderUserId) && d.participants.includes(targetId)); |
| if (!dm) dm = createDM([senderUserId, targetId]); |
| const client = clients.get(ws); |
| if (client) { |
| client.dmId = dm.id; client.channelId = null; |
| ws.send(JSON.stringify({ type: 'dm_joined', dmId: dm.id, messages: dm.messages })); |
| const welcomeMsg = addMessage(dm.id, 'System', 'system', `Direct message started with ${raw}.`); |
| if (welcomeMsg) broadcastToStore(dm.id, welcomeMsg); |
| } |
| return dm; |
| } |
| |
| async function removeAgent(agentId) { |
| if (!agents.has(agentId)) return { success: false, reason: 'Agent not found.' }; |
| if (agents.size === 1) return { success: false, reason: 'Cannot remove the last agent. LACK requires at least one agent to function.' }; |
| agents.delete(agentId); |
| agentMetrics.delete(agentId); |
| jsonFailCount.delete(agentId); |
| const idx = config.agents.findIndex(a => a.id === agentId); |
| if (idx !== -1) { |
| config.agents.splice(idx, 1); |
| try { |
| const tmp = configPath + '.tmp'; |
| fs.writeFileSync(tmp, JSON.stringify(config, null, 2)); |
| fs.renameSync(tmp, configPath); |
| } catch (e) {} |
| } |
| broadcastAgents(); |
| return { success: true }; |
| } |
| |
| // ==================== CRON & RESET ==================== |
| async function wipeAllCronJobs() { try { await execPromise('crontab -r'); } catch(e) {} } |
| async function addHeartbeatCronJobs() { |
| try { |
| const channelIds = Array.from(channels.keys()), dmIds = Array.from(dms.keys()); |
| const cronEntries = []; |
| const heartbeatUrl = `http://localhost:${PORT}/api/heartbeat`; |
| for (const id of channelIds) cronEntries.push(`*/5 * * * * curl -s -X POST "${heartbeatUrl}?type=channel&id=${id}" > /dev/null 2>&1`); |
| for (const id of dmIds) cronEntries.push(`*/5 * * * * curl -s -X POST "${heartbeatUrl}?type=dm&id=${id}" > /dev/null 2>&1`); |
| if (cronEntries.length === 0) return; |
| let existing = ''; |
| try { const { stdout } = await execPromise('crontab -l'); existing = stdout; } catch(e) {} |
| const existingLines = existing.split('\n').filter(l => l.trim()); |
| const newLines = [...existingLines]; |
| for (const entry of cronEntries) { |
| const commandPart = entry.split(' ').slice(5).join(' '); |
| if (!existingLines.some(line => line.includes(commandPart))) newLines.push(entry); |
| } |
| const newCrontab = newLines.join('\n') + '\n'; |
| const tmpFile = path.join(__dirname, '.tmpcron'); |
| fs.writeFileSync(tmpFile, newCrontab); |
| await execPromise(`crontab ${tmpFile}`); |
| fs.unlinkSync(tmpFile); |
| } catch (e) { |
| if (e.message && e.message.includes('permission denied')) { |
| console.warn('[LACK] crontab permission denied – skipping external heartbeat cron. Heartbeats still run via setInterval.'); |
| } else { |
| logError({ context: 'addHeartbeatCronJobs', error: e.message }); |
| } |
| } |
| } |
| async function resetApplicationData() { |
| for (let ch of channels.values()) { ch.messages = []; ch.researchActive = false; ch.abstractActive = false; if (ch.loopTimer) clearTimeout(ch.loopTimer); ch.loopTimer = null; } |
| for (let dm of dms.values()) dm.messages = []; |
| researchSessions.clear(); slimeSessions.clear(); pinnedMessages.clear(); userReactions.clear(); global.errorLog = []; |
| for (let storeId of [...channels.keys(), ...dms.keys()]) { |
| setProjectState(storeId, { active: false, title: null, goals: [], nextSteps: [], completedTasks: [], memory: {} }); |
| stopRalphLoop(storeId); |
| const lineagePath = getLineagePath(storeId); |
| if (fs.existsSync(lineagePath)) fs.unlinkSync(lineagePath); |
| } |
| } |
| |
| function cleanupStore(storeId) { |
| if (ralphTimers.has(storeId)) clearTimeout(ralphTimers.get(storeId)); |
| ralphTimers.delete(storeId); |
| ralphActive.delete(storeId); |
| ralphCancel.delete(storeId); |
| ralphStagnation.delete(storeId); |
| ralphNextAgentIdx.delete(storeId); |
| ralphLastBroadcast.delete(storeId); |
| const channel = channels.get(storeId); |
| if (channel && channel.loopTimer) clearTimeout(channel.loopTimer); |
| } |
| |
| // ==================== EXPRESS APP & ROUTES ==================== |
| const app = express(); |
| app.use(express.static(path.join(__dirname, 'public'))); |
| app.use(express.json({ limit: '1mb' })); |
| |
| app.get('/api/models', async (req, res) => { res.json({ models: await getOllamaModels() }); }); |
| app.get('/api/research/sessions', (req, res) => { |
| res.json({ sessions: Array.from(researchSessions.values()).map(s => ({ |
| id: s.id, topic: s.topic, phase: s.phase, metric: s.metric, |
| logs: s.logs.slice(-10), factsCount: s.facts ? s.facts.length : 0, |
| notesCount: s.notes ? s.notes.length : 0, startedAt: s.startedAt |
| })) }); |
| }); |
| app.get('/api/research/session/:id', (req, res) => { |
| const s = researchSessions.get(req.params.id); |
| if (!s) return res.status(404).json({ error: 'Not found' }); |
| res.json(s); |
| }); |
| app.get('/api/channels', (req, res) => { res.json({ channels: Array.from(channels.values()).map(c => ({ id: c.id, name: c.name })) }); }); |
| app.get('/api/dms', (req, res) => { res.json({ dms: Array.from(dms.values()).map(dm => ({ id: dm.id, name: dm.name, participants: dm.participants })) }); }); |
| app.get('/api/metrics', (req, res) => { |
| const metricsObj = {}; |
| for (let [id, m] of agentMetrics.entries()) metricsObj[id] = { cpu: m.cpu, mem: m.mem, activity: m.activity, timestamps: m.timestamps }; |
| res.json({ |
| agents: Array.from(agents.values()).map(a => ({ id: a.id, name: a.name, model: a.model, status: a.status })), |
| metrics: metricsObj |
| }); |
| }); |
| app.get('/api/errorlog', (req, res) => { |
| const errors = (global.errorLog || []).slice(0, 50).map(e => ({ |
| timestamp: e.timestamp, |
| agentId: e.agentId || 'system', |
| error: e.error || JSON.stringify(e) |
| })); |
| res.json({ errors }); |
| }); |
| app.post('/api/heartbeat', (req, res) => { console.log(`[HEARTBEAT] ${req.query.type} ${req.query.id}`); res.send('OK'); }); |
| app.post('/api/cron/wipe', async (req, res) => { |
| try { |
| await wipeAllCronJobs(); await addHeartbeatCronJobs(); await resetApplicationData(); |
| for (let [ws] of clients.entries()) if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'cron_reset' })); |
| res.json({ success: true }); |
| } catch(err) { logError({ source: 'cron_wipe', error: err.message }); res.status(500).json({ error: err.message }); } |
| }); |
| app.delete('/api/agent/:id', async (req, res) => { const result = await removeAgent(req.params.id); res.json(result); }); |
| |
| // SLIME mobile endpoint (unchanged) |
| app.get('/slime', (req, res) => { |
| const { token, pin } = req.query; |
| const session = slimeSessions.get(token); |
| if (!session || session.pin !== pin || Date.now() > session.expiresAt) { |
| return res.status(403).send(`<html><body><h1>Invalid or expired session</h1></body></html>`); |
| } |
| const safeChannelId = JSON.stringify(session.channelId).slice(1, -1); |
| res.send(`<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>SLIME v3.9.2</title> |
| <style> |
| *,*::before,*::after{box-sizing:border-box;margin:0;padding:0;} |
| body{font-family:monospace;background:#000;color:#0f0;display:flex;flex-direction:column;height:100vh;overflow:hidden;} |
| .topbar{display:flex;align-items:center;justify-content:space-between;padding:0.5rem;background:#111;border-bottom:1px solid #0f0;} |
| .title{font-size:0.8rem;font-weight:bold;} |
| .ralph-badge{background:#9b59b6;color:#fff;border-radius:12px;padding:0.1rem 0.5rem;font-size:0.6rem;display:none;} |
| .graph-container{padding:0.5rem;background:#000;border-bottom:1px solid #0f0;} |
| #graphCanvas{width:100%;height:130px;display:block;background:#000;} |
| .chat{flex:1;overflow-y:auto;padding:0.5rem;} |
| .input-area{display:flex;gap:0.5rem;padding:0.5rem;background:#111;border-top:1px solid #0f0;} |
| .input-area input{flex:1;background:#222;border:1px solid #0f0;color:#0f0;padding:0.5rem;font-family:monospace;} |
| .input-area button{background:#0f0;color:#000;border:none;padding:0.5rem 1rem;font-weight:bold;} |
| .msg{margin:0.5rem 0;font-size:0.8rem;}.user{color:#0ff;}.agent{color:#ff0;}.system{color:#888;}.spinner{display:inline-block;width:12px;height:12px;border:2px solid #0f0;border-top-color:transparent;border-radius:50%;animation:spin 0.6s linear infinite;} |
| @keyframes spin{to{transform:rotate(360deg)}} |
| </style></head><body> |
| <div class="topbar"> |
| <span class="title">SLIME v3.9.2</span> |
| <span class="ralph-badge" id="ralphBadge">🧬 Ralph active</span> |
| </div> |
| <div class="graph-container"><canvas id="graphCanvas"></canvas></div> |
| <div class="chat" id="messages"></div> |
| <div class="input-area"> |
| <input id="msgInput" placeholder="Message..."> |
| <button id="sendBtn">Send</button> |
| </div> |
| <script> |
| let ws; |
| const channel = '${safeChannelId}'; |
| const username = 'mobile_' + Math.floor(Math.random()*10000); |
| const colors = ['#ff3b5c','#00f0ff','#39ff14','#ffeb3b','#c84cff']; |
| function connect() { |
| const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:'; |
| ws = new WebSocket(protocol + '//' + location.host); |
| ws.onopen = () => { |
| ws.send(JSON.stringify({ type: 'join', channelId: channel })); |
| ws.send(JSON.stringify({ type: 'set_username', username })); |
| document.getElementById('msgInput').focus(); |
| }; |
| ws.onmessage = e => { |
| const d = JSON.parse(e.data); |
| if (d.type === 'new_message' && d.channelId === channel) appendMessage(d.message); |
| else if (d.type === 'ralph_status' && d.storeId === channel) { |
| const badge = document.getElementById('ralphBadge'); |
| if (d.active) { |
| badge.style.display = 'inline-block'; |
| badge.textContent = '🧬 Ralph gen ' + d.generation + ' · ' + (d.goal || ''); |
| } else badge.style.display = 'none'; |
| } |
| }; |
| ws.onclose = () => setTimeout(connect, 3000); |
| } |
| function appendMessage(msg) { |
| const div = document.createElement('div'); |
| div.className = 'msg ' + msg.senderType; |
| div.innerHTML = '<strong>' + escapeHtml(msg.sender) + '</strong> [' + new Date(msg.timestamp).toLocaleTimeString([],{hour:'2-digit',minute:'2-digit'}) + ']:<br>' + escapeHtml(msg.content); |
| document.getElementById('messages').appendChild(div); |
| const chat = document.getElementById('messages'); |
| chat.scrollTop = chat.scrollHeight; |
| } |
| function escapeHtml(s) { |
| return s.replace(/[&<>]/g, m => ({'&':'&','<':'<','>':'>'})[m]); |
| } |
| document.getElementById('sendBtn').onclick = () => { |
| const input = document.getElementById('msgInput'); |
| const text = input.value.trim(); |
| if (text && ws && ws.readyState === WebSocket.OPEN) { |
| ws.send(JSON.stringify({ type: 'message', content: text })); |
| input.value = ''; |
| } |
| }; |
| document.getElementById('msgInput').onkeypress = e => { if (e.key === 'Enter') document.getElementById('sendBtn').click(); }; |
| let graphInterval; |
| function startGraph() { |
| const canvas = document.getElementById('graphCanvas'); |
| function resize() { canvas.width = canvas.clientWidth; canvas.height = canvas.clientHeight; } |
| resize(); |
| window.addEventListener('resize', resize); |
| graphInterval = setInterval(fetchAndDrawGraph, 2000); |
| } |
| async function fetchAndDrawGraph() { |
| try { |
| const res = await fetch('/api/metrics'); |
| const data = await res.json(); |
| if (!data.agents) return; |
| drawGraph(data); |
| } catch(e) {} |
| } |
| function drawGraph(data) { |
| const canvas = document.getElementById('graphCanvas'); |
| if (!canvas) return; |
| const w = canvas.width, h = canvas.height; |
| if (w === 0 || h === 0) return; |
| const ctx = canvas.getContext('2d'); |
| ctx.clearRect(0, 0, w, h); |
| ctx.fillStyle = '#000'; |
| ctx.fillRect(0, 0, w, h); |
| const pad = 30, pw = w - 2*pad, ph = h - 2*pad; |
| if (pw <= 0 || ph <= 0) return; |
| ctx.strokeStyle = '#1a1a1a'; |
| ctx.lineWidth = 0.5; |
| for (let i = 0; i <= 5; i++) { |
| let y = pad + ph * (i/5); |
| ctx.beginPath(); ctx.moveTo(pad, y); ctx.lineTo(w-pad, y); ctx.stroke(); |
| } |
| for (let i = 0; i <= 4; i++) { |
| let x = pad + pw * (i/4); |
| ctx.beginPath(); ctx.moveTo(x, pad); ctx.lineTo(x, h-pad); ctx.stroke(); |
| } |
| ctx.fillStyle = '#0f0'; ctx.font = '8px monospace'; |
| ctx.fillText('100%', pad-20, pad+4); |
| ctx.fillText('0%', pad-20, h-pad-2); |
| data.agents.forEach((a, idx) => { |
| const m = data.metrics[a.id]; |
| if (!m || !m.cpu || !m.timestamps) return; |
| const cpu = m.cpu, ts = m.timestamps; |
| const points = []; |
| for (let i = 0; i < cpu.length; i++) { |
| if (ts[i] && ts[i] > 0) points.push({ cpu: cpu[i], t: ts[i] }); |
| } |
| if (points.length < 2) return; |
| let minT = points[0].t, maxT = points[points.length-1].t; |
| if (minT === maxT) { minT -= 5000; maxT += 5000; } |
| const col = colors[idx % colors.length]; |
| ctx.beginPath(); |
| ctx.strokeStyle = col; |
| ctx.lineWidth = 2; |
| for (let i = 0; i < points.length; i++) { |
| const x = pad + ((points[i].t - minT) / (maxT - minT)) * pw; |
| const y = h - pad - (points[i].cpu / 100) * ph; |
| if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y); |
| } |
| ctx.stroke(); |
| }); |
| } |
| connect(); |
| startGraph(); |
| </script></body></html>`); |
| }); |
| |
| // ==================== WEBSOCKET SERVER ==================== |
| const server = app.listen(PORT, async () => { |
| await ensureGitRepo(); |
| pruneLineageFiles(); |
| for (const storeId of [...channels.keys(), ...dms.keys()]) { |
| loadProjectStateFromLineage(storeId); |
| loadRalphStateFromLineage(storeId); |
| } |
| startStackWatcher(); |
| try { |
| await axios.post(`${OLLAMA_URL}/api/embeddings`, { model: 'nomic-embed-text', prompt: 'test' }); |
| } catch(e) { |
| console.warn('[STACK] nomic-embed-text not loaded – run: ollama pull nomic-embed-text'); |
| } |
| console.log(`\x1b[32m✓ LACK v3.9.2 with STACK & full code moderation running at http://localhost:${PORT}\x1b[0m`); |
| console.log(` Real‑time file tools, tool calling, STACK orchestration, and code moderation active.`); |
| }); |
| const wss = new WebSocket.Server({ server }); |
| |
| wss.on('connection', (ws) => { |
| const userId = `human_${uuidv4().slice(0,4)}`; |
| clients.set(ws, { username: userId, channelId: 'general', userId, dmId: null, openThreadId: null }); |
| ws.on('message', async (raw) => { |
| try { |
| const data = JSON.parse(raw); |
| const client = clients.get(ws); |
| if (!client) return; |
| switch (data.type) { |
| case 'join': |
| if (channels.has(data.channelId)) { |
| client.channelId = data.channelId; client.dmId = null; |
| ws.send(JSON.stringify({ type: 'history', channelId: data.channelId, messages: channels.get(data.channelId).messages })); |
| ws.send(JSON.stringify({ type: 'agents_list', agents: Array.from(agents.values()).map(a => ({ id: a.id, name: a.name, model: a.model, systemPrompt: a.systemPrompt, channels: a.channels, status: a.status })) })); |
| ws.send(JSON.stringify({ type: 'channels', channels: Array.from(channels.values()).map(c => ({ id: c.id, name: c.name })) })); |
| ws.send(JSON.stringify({ type: 'dms', dms: getUserDMs(client.userId) })); |
| broadcastRalphStatus(data.channelId); |
| } |
| break; |
| case 'join_dm': |
| if (dms.has(data.dmId)) { |
| client.dmId = data.dmId; client.channelId = null; |
| ws.send(JSON.stringify({ type: 'dm_history', dmId: data.dmId, messages: dms.get(data.dmId).messages })); |
| broadcastRalphStatus(data.dmId); |
| } |
| break; |
| case 'message': |
| if (client.channelId) { |
| let msgText = data.content.trim(); |
| if (!msgText) break; |
| msgText = msgText.replace(/<[^>]*>/g, ''); |
| const humanMsg = addMessage(client.channelId, client.username, 'human', msgText); |
| if (humanMsg) { |
| broadcastToStore(client.channelId, humanMsg); |
| await onHumanMessage(client.channelId, humanMsg, ws); |
| } |
| } else if (client.dmId) { |
| let msgText = data.content.trim(); |
| if (!msgText) break; |
| msgText = msgText.replace(/<[^>]*>/g, ''); |
| const humanMsg = addMessage(client.dmId, client.username, 'human', msgText); |
| if (humanMsg) { |
| broadcastToStore(client.dmId, humanMsg); |
| await onHumanDmMessage(client.dmId, humanMsg, ws); |
| } |
| } |
| break; |
| case 'reply_in_thread': |
| let { parentId, content, storeId } = data; |
| if (!storeId) storeId = client.channelId || client.dmId; |
| if (storeId && (channels.has(storeId) || dms.has(storeId))) { |
| content = content.replace(/<[^>]*>/g, ''); |
| const replyMsg = addMessage(storeId, client.username, 'human', content, parentId); |
| if (replyMsg) { |
| broadcastToStore(storeId, replyMsg); |
| broadcastThreadUpdate(storeId, parentId); |
| ws.send(JSON.stringify({ type: 'thread_messages', storeId, threadId: parentId, messages: getThreadMessages(storeId, parentId) })); |
| } |
| } |
| break; |
| case 'set_username': |
| client.username = data.username.substring(0, 20).replace(/[<>]/g, ''); |
| break; |
| case 'start_dm': { |
| const targetName = data.targetName; |
| let targetId = null; |
| for (let [id, agent] of agents.entries()) if (agent.name.toLowerCase() === targetName.toLowerCase()) { targetId = id; break; } |
| if (!targetId) { ws.send(JSON.stringify({ type: 'error', message: 'Agent not found' })); break; } |
| let dm = Array.from(dms.values()).find(d => d.participants.includes(client.userId) && d.participants.includes(targetId)); |
| if (!dm) dm = createDM([client.userId, targetId]); |
| client.dmId = dm.id; client.channelId = null; |
| ws.send(JSON.stringify({ type: 'dm_joined', dmId: dm.id, messages: dm.messages })); |
| broadcastDMs(client.userId); |
| break; |
| } |
| case 'spawn_agent': { |
| const { name, model, systemPrompt, channels: agentChannels } = data; |
| const id = uuidv4().slice(0,8); |
| const newAgent = { id, name, model, systemPrompt, channels: agentChannels, lastResponseTime: new Map(), status: 'online', statusMessage: '' }; |
| agents.set(id, newAgent); |
| config.agents.push({ id, name, model, systemPrompt, channels: agentChannels }); |
| try { |
| const tmp = configPath + '.tmp'; |
| fs.writeFileSync(tmp, JSON.stringify(config, null, 2)); |
| fs.renameSync(tmp, configPath); |
| } catch (e) {} |
| agentMetrics.set(id, generateSyntheticMetrics()); |
| jsonFailCount.set(id, 0); |
| broadcastAgents(); |
| ws.send(JSON.stringify({ type: 'spawn_confirm', agent: newAgent })); |
| break; |
| } |
| case 'update_agent': { |
| const agent = agents.get(data.id); |
| if (agent) { |
| agent.name = data.name; agent.model = data.model; agent.systemPrompt = data.systemPrompt; agent.channels = data.channels; |
| const idx = config.agents.findIndex(a => a.id === data.id); |
| if (idx !== -1) { |
| config.agents[idx] = { id: data.id, name: data.name, model: data.model, systemPrompt: data.systemPrompt, channels: data.channels }; |
| try { |
| const tmp = configPath + '.tmp'; |
| fs.writeFileSync(tmp, JSON.stringify(config, null, 2)); |
| fs.renameSync(tmp, configPath); |
| } catch (e) {} |
| } |
| broadcastAgents(); |
| } |
| break; |
| } |
| case 'get_models': |
| ws.send(JSON.stringify({ type: 'models_list', models: await getOllamaModels() })); |
| break; |
| case 'add_reaction': { |
| const { messageId, emoji, storeId: reactStoreId } = data; |
| if (!userReactions.has(messageId)) userReactions.set(messageId, new Map()); |
| const msgReactions = userReactions.get(messageId); |
| if (!msgReactions.has(emoji)) msgReactions.set(emoji, new Set()); |
| msgReactions.get(emoji).add(client.userId); |
| for (let [otherWs] of clients.entries()) { |
| if (otherWs.readyState === WebSocket.OPEN) otherWs.send(JSON.stringify({ type: 'reaction_update', messageId, emoji, userId: client.userId, add: true })); |
| } |
| break; |
| } |
| case 'open_thread': |
| client.openThreadId = data.threadId; |
| break; |
| case 'close_thread': |
| client.openThreadId = null; |
| break; |
| } |
| } catch(err) { |
| const preview = typeof raw === 'string' ? raw.substring(0, 60).replace(/[\n\r]/g, ' ') : '[binary]'; |
| logError({ source: 'websocket_parse', error: err.message, preview }); |
| try { ws.send(JSON.stringify({ type: 'error', message: 'Invalid message format – check JSON syntax' })); } catch(_) {} |
| } |
| }); |
| ws.on('close', () => { |
| const client = clients.get(ws); |
| if (client) { |
| if (client.channelId) cleanupStore(client.channelId); |
| if (client.dmId) cleanupStore(client.dmId); |
| } |
| clients.delete(ws); |
| }); |
| ws.send(JSON.stringify({ type: 'channels', channels: Array.from(channels.values()).map(c => ({ id: c.id, name: c.name })) })); |
| ws.send(JSON.stringify({ type: 'dms', dms: getUserDMs(userId) })); |
| ws.send(JSON.stringify({ type: 'agents_list', agents: Array.from(agents.values()).map(a => ({ id: a.id, name: a.name, model: a.model, systemPrompt: a.systemPrompt, channels: a.channels, status: a.status })) })); |
| }); |
| |
| // ==================== MESSAGE HANDLERS (with new moderation commands + test_dm) ==================== |
| async function onHumanMessage(channelId, messageObj, ws) { |
| const channel = channels.get(channelId); |
| if (!channel) return; |
| const content = messageObj.content; |
| if (content.startsWith('/')) { |
| const parts = content.slice(1).split(' '); |
| const cmd = parts[0].toLowerCase(); |
| const args = parts.slice(1); |
| if (cmd === 'help') { |
| const help = `Commands: /ground, /research <topic>, /abstract, /plan <goal>, /ralph <goal>, /stop, /list, /spawn, /siphon <topic>, /slime, /pull <id>, /dm <user>, /thread <id>, /pin <id>, /graph, /errorlog, /convergence, /tools, /stack build <name>, /stack add <description>, /stack import <file.json>, /stack set <repo>, /repo, /lint <filename>, /moderate on/off, /test_dm <agentName>`; |
| addMessage(channelId, 'System', 'system', help); broadcastToStore(channelId, { sender: 'System', content: help, senderType: 'system' }); |
| } else if (cmd === 'tools') { |
| const toolList = FILE_TOOLS.map(t => `- ${t.name}: ${t.description}`).join('\n'); |
| addMessage(channelId, 'System', 'system', `Available tools:\n${toolList}`); |
| broadcastToStore(channelId, { sender: 'System', content: toolList, senderType: 'system' }); |
| } else if (cmd === 'stack') { |
| const sub = args[0]; |
| const moderatorAgent = agents.get('moderator'); |
| if (!moderatorAgent) { |
| addMessage(channelId, 'System', 'system', 'Moderator agent not available.'); |
| return; |
| } |
| if (sub === 'build' && args[1]) { |
| await executeAction(moderatorAgent, channelId, {type: 'stack', payload: {subcmd: 'build', repoName: args[1]}}); |
| } else if (sub === 'add') { |
| await executeAction(moderatorAgent, channelId, {type: 'stack', payload: {subcmd: 'add', intent: args.slice(1).join(' ')}}); |
| } else if (sub === 'import' && args[1]) { |
| await executeAction(moderatorAgent, channelId, {type: 'stack', payload: {subcmd: 'import', jsonPath: args[1]}}); |
| } else if (sub === 'set' && args[1]) { |
| activeStackRepo.set(channelId, args[1]); |
| addMessage(channelId, 'System', 'system', `Active STACK repository set to ${args[1]}`); |
| broadcastToStore(channelId, { sender: 'System', content: `Active STACK repo: ${args[1]}`, senderType: 'system' }); |
| } else { |
| const help = `STACK Commands:\n/stack build <name> - Create new repo\n/stack add <description> - Semantic inject from templates\n/stack import <json> - Load blueprints\n/stack set <repo> - Set active repo for this chat`; |
| addMessage(channelId, 'Moderator', 'system', help); |
| broadcastToStore(channelId, { sender: 'Moderator', content: help, senderType: 'system' }); |
| } |
| } else if (cmd === 'repo') { |
| const targetId = args[0] || channelId; |
| const repoPath = getThreadRepoPath(targetId); |
| if (fs.existsSync(repoPath)) { |
| let output = `📁 **Repository for ${targetId}**\n\`${repoPath}\`\n\n**Files:**\n`; |
| const files = fs.readdirSync(repoPath).filter(f => !f.startsWith('.')); |
| output += files.map(f => `- ${f}`).join('\n'); |
| addMessage(channelId, 'Moderator', 'system', output); |
| broadcastToStore(channelId, { sender: 'Moderator', content: output, senderType: 'system' }); |
| } else { |
| addMessage(channelId, 'Moderator', 'system', `No repository found for ${targetId}. Create code first.`); |
| broadcastToStore(channelId, { sender: 'Moderator', content: `No repository found for ${targetId}.`, senderType: 'system' }); |
| } |
| } else if (cmd === 'moderate') { |
| const setting = args[0]; |
| const moderatorAgent = agents.get('moderator'); |
| if (setting === 'on') { |
| moderatorAgent.isCodeModerator = true; |
| addMessage(channelId, 'Moderator', 'system', '🔛 Code moderation ENABLED. All code blocks will be validated.'); |
| broadcastToStore(channelId, { sender: 'Moderator', content: 'Code moderation ENABLED.', senderType: 'system' }); |
| } else if (setting === 'off') { |
| moderatorAgent.isCodeModerator = false; |
| addMessage(channelId, 'Moderator', 'system', '🔴 Code moderation DISABLED.'); |
| broadcastToStore(channelId, { sender: 'Moderator', content: 'Code moderation DISABLED.', senderType: 'system' }); |
| } else { |
| addMessage(channelId, 'Moderator', 'system', `Moderation is ${moderatorAgent.isCodeModerator ? 'ON' : 'OFF'}. Use /moderate on/off`); |
| broadcastToStore(channelId, { sender: 'Moderator', content: `Moderation: ${moderatorAgent.isCodeModerator ? 'ON' : 'OFF'}`, senderType: 'system' }); |
| } |
| } else if (cmd === 'lint') { |
| const filename = args[0]; |
| if (!filename) { |
| addMessage(channelId, 'Moderator', 'system', 'Usage: /lint <filename>'); |
| broadcastToStore(channelId, { sender: 'Moderator', content: 'Usage: /lint <filename>', senderType: 'system' }); |
| } else { |
| const threadId = messageObj.parentId || channelId; |
| const repoPath = getThreadRepoPath(threadId); |
| const filePath = path.join(repoPath, filename); |
| if (!fs.existsSync(filePath)) { |
| addMessage(channelId, 'Moderator', 'system', `File not found: ${filename}`); |
| } else { |
| const ext = path.extname(filename).slice(1); |
| const langMap = { 'py': 'python', 'js': 'javascript', 'html': 'html', 'json': 'json' }; |
| const lang = langMap[ext] || 'text'; |
| const result = await runLinter(lang, filePath); |
| let output = `🔍 **Lint Results** for \`${filename}\`\n`; |
| output += result.passed ? '✅ Syntax OK\n' : '❌ Syntax errors found\n'; |
| if (result.errors.length) output += `\n**Errors:**\n${result.errors.map(e => `- ${e}`).join('\n')}`; |
| if (result.warnings.length) output += `\n**Warnings:**\n${result.warnings.map(w => `- ${w}`).join('\n')}`; |
| addMessage(channelId, 'Moderator', 'system', output); |
| broadcastToStore(channelId, { sender: 'Moderator', content: output, senderType: 'system' }); |
| } |
| } |
| } else if (cmd === 'test_dm') { |
| const targetName = args[0]; |
| if (!targetName) { |
| addMessage(channelId, 'System', 'system', 'Usage: /test_dm <agentName>'); |
| broadcastToStore(channelId, { sender: 'System', content: 'Usage: /test_dm <agentName>', senderType: 'system' }); |
| return; |
| } |
| const dm = await handleDMCommand(getUserId(ws), [targetName], ws); |
| if (dm) { |
| // Send a thread root and reply to test threading |
| const parentMsg = addMessage(dm.id, 'System', 'system', 'Thread root message for testing'); |
| if (parentMsg) { |
| broadcastToStore(dm.id, parentMsg); |
| const replyMsg = addMessage(dm.id, 'System', 'system', 'Nested reply inside thread', parentMsg.id); |
| if (replyMsg) broadcastToStore(dm.id, replyMsg); |
| ws.send(JSON.stringify({ type: 'thread_messages', storeId: dm.id, threadId: parentMsg.id, messages: getThreadMessages(dm.id, parentMsg.id) })); |
| } |
| ws.send(JSON.stringify({ type: 'switch_to_dm', dmId: dm.id })); |
| addMessage(channelId, 'System', 'system', `Test DM created with ${targetName}. Check your DMs.`); |
| broadcastToStore(channelId, { sender: 'System', content: `Test DM created with ${targetName}.`, senderType: 'system' }); |
| } else { |
| addMessage(channelId, 'System', 'system', `Failed to create DM with ${targetName}.`); |
| broadcastToStore(channelId, { sender: 'System', content: `Failed to create DM with ${targetName}.`, senderType: 'system' }); |
| } |
| } else { |
| // Original commands (unchanged) |
| if (cmd === 'ground') { |
| const groundMsg = { sender: 'System', content: 'GROUND: All agents respond.' }; |
| addMessage(channelId, 'System', 'system', groundMsg.content); broadcastToStore(channelId, groundMsg); |
| const agentsInChannel = Array.from(agents.values()).filter(a => a.channels.includes(channel.name) && !a.isEmbedOperator); |
| for (const agent of agentsInChannel) agentRespond(agent, channelId, groundMsg, false); |
| } else if (cmd === 'research' && args.length) { |
| stopLoop(channelId); channel.researchActive = true; channel.researchTopic = args.join(' '); |
| addMessage(channelId, 'System', 'system', `Research mode started on: ${channel.researchTopic}`); broadcastToStore(channelId, { sender: 'System', content: `Research mode started on: ${channel.researchTopic}`, senderType: 'system' }); |
| scheduleLoopRound(channelId); |
| } else if (cmd === 'abstract') { |
| stopLoop(channelId); channel.abstractActive = true; |
| addMessage(channelId, 'System', 'system', 'Abstract mode active – agents will plan actions.'); broadcastToStore(channelId, { sender: 'System', content: 'Abstract mode active – agents will plan actions.', senderType: 'system' }); |
| scheduleLoopRound(channelId); |
| } else if (cmd === 'plan' && args.length) { |
| stopLoop(channelId); |
| const newState = { active: true, title: args.join(' '), goals: [args.join(' ')], nextSteps: [], completedTasks: [], memory: {} }; |
| setProjectState(channelId, newState); |
| channel.abstractActive = true; |
| addMessage(channelId, 'System', 'system', `📋 Project planning started: "${newState.title}".`); broadcastToStore(channelId, { sender: 'System', content: `Project planning started: "${newState.title}"`, senderType: 'system' }); |
| scheduleLoopRound(channelId); |
| } else if (cmd === 'ralph' && args.length) { |
| stopLoop(channelId); |
| const goal = args.join(' '); |
| loadProjectStateFromLineage(channelId); |
| startRalphLoop(channelId, goal); |
| addMessage(channelId, 'System', 'system', `🧬 **Ralph loop started**\nGoal: ${goal}\nWill converge when similarity ≥ 0.95 or max 30 generations.`); |
| broadcastToStore(channelId, { sender: 'System', content: `Ralph evolution started: ${goal}`, senderType: 'system' }); |
| } else if (cmd === 'stop') { stopLoop(channelId); } |
| else if (cmd === 'list') { const models = await getOllamaModels(); const listText = models.length ? 'Available Ollama models:\n' + models.join('\n') : 'No Ollama models found.'; addMessage(channelId, 'System', 'system', listText); broadcastToStore(channelId, { sender: 'System', content: listText, senderType: 'system' }); } |
| else if (cmd === 'spawn') { ws.send(JSON.stringify({ type: 'models_list', models: await getOllamaModels() })); } |
| else if (cmd === 'siphon') { const topic = args.join(' ') || 'general research topic'; const sessionId = uuidv4(); const session = { id: sessionId, topic, phase: 'Initializing', metric: 0, logs: [], facts: [], notes: [], questions: [], currentQuestionIndex: 0, startedAt: Date.now() }; researchSessions.set(sessionId, session); runResearch(sessionId, topic, channelId).catch(console.error); addMessage(channelId, 'Siphon', 'system', `🔍 Started research on "${topic}". Check #siphon.`); broadcastToStore(channelId, { sender: 'Siphon', content: `Research started: ${topic}`, senderType: 'system' }); } |
| else if (cmd === 'slime') { const token = uuidv4().replace(/-/g, '').substring(0,16); const pin = Math.floor(100000 + Math.random() * 900000).toString(); const expiresAt = Date.now() + 60 * 60 * 1000; slimeSessions.set(token, { pin, expiresAt, channelId }); const url = `http://localhost:${PORT}/slime?token=${token}&pin=${pin}`; addMessage(channelId, 'System', 'system', `📱 Mobile URL: ${url} PIN: ${pin} (expires 1h)`); broadcastToStore(channelId, { sender: 'System', content: `Mobile access: ${url}`, senderType: 'system' }); } |
| else if (cmd === 'pull' && args.length) { const session = researchSessions.get(args[0]); if (!session) { addMessage(channelId, 'System', 'system', `No session ${args[0]}.`); broadcastToStore(channelId, { sender: 'System', content: `No session ${args[0]}.`, senderType: 'system' }); return; } let summary = `📊 **Research "${session.topic}"**\nMetric: ${(session.metric*100).toFixed(0)}%\n`; if (session.notes.length) { const last = session.notes[session.notes.length-1]; summary += `**Latest answer:** ${last.answer.substring(0,300)}\nKey facts:\n${last.facts.slice(0,3).map(f => `- ${f}`).join('\n')}`; } else { summary += 'Research still in progress.'; } addMessage(channelId, 'Siphon', 'system', summary); broadcastToStore(channelId, { sender: 'Siphon', content: summary, senderType: 'system' }); } |
| else if (cmd === 'dm') { const dm = await handleDMCommand(getUserId(ws), args, ws); if (dm) ws.send(JSON.stringify({ type: 'switch_to_dm', dmId: dm.id })); } |
| else if (cmd === 'thread') { const messageId = args[0]; if (!messageId) ws.send(JSON.stringify({ type: 'error', message: 'Usage: /thread <messageId>' })); else ws.send(JSON.stringify({ type: 'thread_messages', storeId: channelId, threadId: messageId, messages: getThreadMessages(channelId, messageId) })); } |
| else if (cmd === 'pin') { if (!args[0]) ws.send(JSON.stringify({ type: 'error', message: 'Usage: /pin <messageId>' })); else { if (!pinnedMessages.has(channelId)) pinnedMessages.set(channelId, new Set()); pinnedMessages.get(channelId).add(args[0]); ws.send(JSON.stringify({ type: 'pinned', messageId: args[0], channelId })); } } |
| else if (cmd === 'graph') { ws.send(JSON.stringify({ type: 'graph_ack' })); } |
| else if (cmd === 'errorlog') { |
| let logText = '**ERROR LOG**\n'; |
| const errors = global.errorLog || []; |
| errors.slice(0,50).forEach(e => { logText += `${new Date(e.timestamp).toLocaleString()} | ${e.agentId || 'system'}: ${e.error}\n`; }); |
| if (!errors.length) logText += 'No errors recorded.'; |
| addMessage(channelId, 'System', 'system', logText); |
| broadcastToStore(channelId, { sender: 'System', content: logText, senderType: 'system' }); |
| } |
| else if (cmd === 'convergence') { const lineage = reconstructLineage(channelId); let lastSpec = null, sim = 0; for (let i = lineage.length-1; i >= 0; i--) { if (lineage[i].type === 'project_state') { const spec = computeSpecFromState(lineage[i].state); if (lastSpec) { sim = similarity(lastSpec, spec); break; } lastSpec = spec; } } const msg = `🔍 Convergence similarity: ${(sim*100).toFixed(1)}%`; addMessage(channelId, 'System', 'system', msg); broadcastToStore(channelId, { sender: 'System', content: msg, senderType: 'system' }); } |
| else { addMessage(channelId, 'System', 'system', `Unknown command: ${cmd}. Type /help`); broadcastToStore(channelId, { sender: 'System', content: `Unknown command: ${cmd}`, senderType: 'system' }); } |
| } |
| return; |
| } |
| const relevantAgents = Array.from(agents.values()).filter(a => a.channels.includes(channel.name) && !a.isEmbedOperator); |
| const state = getProjectState(channelId); |
| const usePlanning = state.active || channel.abstractActive || channel.researchActive; |
| for (const agent of relevantAgents) { |
| if (ralphActive.get(channelId)) continue; |
| if (usePlanning) await agentPlanAndAct(agent, channelId, messageObj, messageObj.parentId); |
| else await agentRespond(agent, channelId, messageObj, false, messageObj.parentId); |
| } |
| } |
| |
| async function onHumanDmMessage(dmId, messageObj, ws) { |
| const dm = dms.get(dmId); |
| if (!dm) return; |
| const content = messageObj.content; |
| if (content.startsWith('/')) { |
| const parts = content.slice(1).split(' '); |
| const cmd = parts[0].toLowerCase(); |
| const args = parts.slice(1); |
| if (cmd === 'ralph' && args.length) { |
| stopRalphLoop(dmId); |
| const goal = args.join(' '); |
| loadProjectStateFromLineage(dmId); |
| startRalphLoop(dmId, goal); |
| addMessage(dmId, 'System', 'system', `🧬 Ralph loop started in DM.\nGoal: ${goal}`); |
| broadcastToStore(dmId, { sender: 'System', content: `Ralph started: ${goal}`, senderType: 'system' }); |
| return; |
| } else if (cmd === 'stop') { |
| stopRalphLoop(dmId); |
| setProjectState(dmId, { active: false, title: null, goals: [], nextSteps: [], completedTasks: [], memory: {} }); |
| addMessage(dmId, 'System', 'system', 'Autonomous mode stopped.'); |
| broadcastToStore(dmId, { sender: 'System', content: 'Autonomous mode stopped.', senderType: 'system' }); |
| return; |
| } else if (cmd === 'help') { |
| const help = 'DM Commands: /ralph <goal>, /stop, /help, /tools, /stack ...'; |
| addMessage(dmId, 'System', 'system', help); |
| broadcastToStore(dmId, { sender: 'System', content: help, senderType: 'system' }); |
| return; |
| } |
| } |
| const agentParticipants = dm.participants.filter(p => agents.has(p) && !agents.get(p).isEmbedOperator); |
| const state = getProjectState(dmId); |
| for (const agentId of agentParticipants) { |
| const agent = agents.get(agentId); |
| if (!agent) continue; |
| if (ralphActive.get(dmId)) continue; |
| const usePlanning = state.active; |
| if (usePlanning) await agentPlanAndAct(agent, dmId, messageObj, messageObj.parentId); |
| else await agentRespond(agent, dmId, messageObj, false, messageObj.parentId); |
| } |
| } |
| ''' |
|
|
| |
| |
| |
| INDEX_HTML = r'''<!DOCTYPE html> |
| <html lang="en"> |
| <head> |
| <meta charset="UTF-8"> |
| <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover"> |
| <title>LACK v3.9.2</title> |
| <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css"> |
| <style> |
| * { box-sizing: border-box; margin: 0; padding: 0; } |
| body { font-family: monospace; background: var(--white); color: var(--black); height: 100vh; overflow: hidden; transition: background 0.3s, color 0.3s; } |
| :root { --white: #fff; --off-white: #f8f8f8; --light-gray: #e0e0e0; --gray: #a0a0a0; --dark-gray: #666; --black: #000; --shadow-dark: rgba(0,0,0,0.2); } |
| .dark-mode { --white: #0a0a0a; --off-white: #1a1a1a; --light-gray: #2a2a2a; --gray: #555; --dark-gray: #999; --black: #f0f0f0; --shadow-dark: rgba(255,255,255,0.1); } |
| .neuro-menu { position: fixed; top: 0; left: 0; right: 0; height: 48px; background: var(--white); border-bottom: 2px solid var(--black); display: flex; align-items: center; justify-content: space-between; padding: 0 1rem; z-index: 10000; flex-wrap: wrap; gap: 0.5rem; } |
| .menu-item { font-size: 0.85rem; font-weight: 600; white-space: nowrap; } |
| .neuro-status { display: flex; align-items: center; gap: 0.75rem; flex-wrap: wrap; font-size: 0.7rem; } |
| .dark-mode-toggle, .ground-btn, .cron-btn { background: var(--white); border: 1px solid var(--black); border-radius: 20px; padding: 0.25rem 0.75rem; cursor: pointer; font-size: 0.7rem; white-space: nowrap; } |
| .cron-btn { background: #ff4444; color: white; border-color: #ff4444; } |
| .ralph-badge { background: #9b59b6; color: white; border-radius: 12px; padding: 0.2rem 0.6rem; font-size: 0.7rem; display: none; } |
| .neuro-desktop { position: absolute; top: 48px; left: 0; right: 0; bottom: 0; padding: 1rem; background: var(--off-white); display: flex; overflow: hidden; } |
| .chat-container { display: flex; width: 100%; height: 100%; background: var(--white); border: 2px solid var(--black); box-shadow: 8px 8px 0 var(--shadow-dark); overflow: hidden; } |
| .sidebar { width: 260px; min-width: 200px; max-width: 30%; background: var(--white); border-right: 2px solid var(--black); display: flex; flex-direction: column; overflow-y: auto; flex-shrink: 0; } |
| .main-chat { flex: 1; display: flex; flex-direction: column; min-width: 0; background: var(--white); } |
| .thread-panel { width: 300px; background: var(--white); border-left: 2px solid var(--black); display: none; flex-direction: column; flex-shrink: 0; } |
| .thread-panel.open { display: flex; } |
| @media (max-width: 700px) { .sidebar { min-width: 160px; width: 180px; } .thread-panel.open { position: fixed; right: 0; top: 48px; bottom: 0; width: 85%; max-width: 320px; z-index: 2000; box-shadow: -4px 0 12px rgba(0,0,0,0.3); } } |
| .chat-header { padding: 0.75rem 1rem; border-bottom: 2px solid var(--black); font-weight: 600; background: var(--white); flex-shrink: 0; } |
| .messages-area { flex: 1; overflow-y: auto; padding: 1rem; display: flex; flex-direction: column; gap: 0.75rem; background: var(--off-white); } |
| .input-area { padding: 0.75rem 1rem; border-top: 2px solid var(--black); display: flex; gap: 0.75rem; align-items: flex-start; background: var(--white); flex-wrap: wrap; } |
| .input-area textarea { flex: 1; background: var(--white); border: 1px solid var(--black); padding: 0.5rem; font-family: monospace; resize: vertical; min-width: 120px; font-size: 0.85rem; } |
| .input-area button { background: var(--white); border: 2px solid var(--black); padding: 0.5rem 1rem; cursor: pointer; font-weight: bold; font-size: 0.8rem; } |
| .file-upload-btn { background: none; border: none; font-size: 1.4rem; cursor: pointer; color: var(--gray); padding: 0 0.25rem; } |
| .file-upload-btn:hover { color: var(--black); } |
| .message-group { margin-bottom: 0.5rem; } |
| .message { display: flex; gap: 0.75rem; padding: 0.25rem 0; } |
| .message-avatar { width: 32px; height: 32px; background: var(--light-gray); border: 1px solid var(--black); display: flex; align-items: center; justify-content: center; font-weight: bold; flex-shrink: 0; } |
| .message-content { flex: 1; min-width: 0; word-wrap: break-word; } |
| .message-sender { font-weight: 600; font-size: 0.8rem; } |
| .message-timestamp { font-size: 0.7rem; color: var(--dark-gray); } |
| .message-text { font-size: 0.85rem; line-height: 1.4; word-wrap: break-word; } |
| .message-text pre { background: #111; color: #0f0; padding: 0.5rem; overflow-x: auto; font-size: 0.75rem; border-radius: 4px; } |
| .reply-badge { font-size: 0.7rem; text-decoration: underline; cursor: pointer; margin-top: 0.25rem; } |
| .message-actions { display: none; gap: 0.5rem; margin-top: 0.25rem; } |
| .message:hover .message-actions { display: flex; } |
| .action-icon { font-size: 0.7rem; background: var(--white); border: 1px solid var(--light-gray); padding: 0.2rem 0.4rem; cursor: pointer; } |
| .sidebar-section { border-bottom: 1px solid var(--light-gray); } |
| .sidebar-header { padding: 0.75rem; font-weight: 600; font-size: 0.75rem; background: var(--off-white); cursor: pointer; } |
| .channel-list { padding: 0.5rem; } |
| .channel-item, .agent-item, .research-item { padding: 0.5rem; margin: 0.25rem 0; cursor: pointer; font-size: 0.75rem; display: flex; align-items: center; gap: 0.5rem; border: 1px solid transparent; } |
| .channel-item:hover, .agent-item:hover, .research-item:hover { background: var(--light-gray); } |
| .agent-item { justify-content: space-between; } |
| .agent-info { display: flex; align-items: center; gap: 0.5rem; flex: 1; } |
| .agent-status { width: 8px; height: 8px; border-radius: 50%; } |
| .status-online { background: #2eb67d; } |
| .status-thinking { background: #ecb22e; animation: pulse 1s infinite; } |
| .status-queued { background: #ffa500; animation: pulse 0.5s infinite; } |
| @keyframes pulse { 0% { opacity: 1; } 50% { opacity: 0.5; } 100% { opacity: 1; } } |
| .remove-agent { color: #ff4444; cursor: pointer; opacity: 0.6; } |
| .research-progress { font-size: 0.7rem; margin-left: auto; } |
| .thread-header { padding: 0.75rem; border-bottom: 2px solid var(--black); display: flex; justify-content: space-between; } |
| .thread-messages { flex: 1; overflow-y: auto; padding: 0.75rem; } |
| .thread-input { padding: 0.75rem; border-top: 1px solid var(--light-gray); } |
| .thread-input textarea { width: 100%; padding: 0.5rem; font-family: monospace; } |
| .modal { display: none; position: fixed; z-index: 20000; left: 0; top: 0; width: 100%; height: 100%; background: rgba(0,0,0,0.6); align-items: center; justify-content: center; } |
| .modal-content { background: var(--white); border: 2px solid var(--black); padding: 1.5rem; width: 90%; max-width: 700px; max-height: 90vh; overflow-y: auto; } |
| .modal-content input, .modal-content select, .modal-content textarea { width: 100%; margin: 0.5rem 0; padding: 0.5rem; } |
| .modal-buttons { display: flex; justify-content: flex-end; gap: 0.75rem; margin-top: 1rem; flex-wrap: wrap; } |
| .error-log-entry { font-family: monospace; font-size: 0.7rem; border-bottom: 1px solid var(--light-gray); padding: 0.5rem; white-space: pre-wrap; } |
| .toast { position: fixed; bottom: 1rem; right: 1rem; background: #333; color: white; padding: 0.5rem 1rem; border-radius: 8px; font-size: 0.8rem; opacity: 0; transition: opacity 0.3s; z-index: 20001; pointer-events: none; } |
| .toast.show { opacity: 1; } |
| .toast.success { background: #2ecc71; } |
| .toast.error { background: #e74c3c; } |
| .agent-thinking-overlay { position: fixed; bottom: 1rem; left: 1rem; background: rgba(0,0,0,0.7); color: #ff0; padding: 0.4rem 1rem; border-radius: 20px; font-size: 0.75rem; z-index: 10001; } |
| .bottom-bar { position: fixed; bottom: 0; left: 0; right: 0; background: var(--white); border-top: 1px solid var(--light-gray); padding: 0.25rem 1rem; font-size: 0.6rem; display: flex; justify-content: space-between; z-index: 10000; } |
| .file-name-chip { background: var(--light-gray); border-radius: 16px; padding: 0.2rem 0.6rem; font-size: 0.7rem; display: inline-flex; align-items: center; gap: 6px; } |
| .spinner { display: inline-block; width: 16px; height: 16px; border: 2px solid var(--gray); border-top-color: var(--black); border-radius: 50%; animation: spin 0.6s linear infinite; } |
| @keyframes spin { to { transform: rotate(360deg); } } |
| .slash-suggestions { position: absolute; bottom: 100%; left: 0; background: var(--white); border: 1px solid var(--black); list-style: none; padding: 0.25rem; max-height: 150px; overflow-y: auto; z-index: 200; } |
| .slash-suggestions li { padding: 0.25rem 0.5rem; cursor: pointer; font-size: 0.7rem; } |
| canvas#agentGraph { width: 100%; height: 100%; display: block; } |
| </style> |
| </head> |
| <body> |
| <div class="neuro-menu"> |
| <div class="menu-item">LACK v3.9.2</div> |
| <div class="neuro-status"> |
| <span id="agentCount">Agents: 0</span> |
| <span id="ralphStatusBadge" class="ralph-badge">🧬 Ralph active</span> |
| <button class="ground-btn" id="groundBtn">🌍 GROUND</button> |
| <button class="ground-btn" id="graphBtn">📈 GRAPH</button> |
| <button class="ground-btn" id="errorlogBtn">⚠️ ERRORLOG</button> |
| <button class="cron-btn" id="cronBtn">💣 CRON</button> |
| <div class="dark-mode-toggle" id="darkModeToggle">🌓</div> |
| </div> |
| </div> |
| <div class="neuro-desktop"> |
| <div class="chat-container"> |
| <div class="sidebar" id="sidebar"></div> |
| <div class="main-chat"> |
| <div class="chat-header" id="currentChatName">#general</div> |
| <div class="messages-area" id="messagesArea"></div> |
| <div class="input-area"> |
| <label class="file-upload-btn"><i class="fas fa-paperclip"></i><input type="file" id="fileInput" style="display:none" accept=".txt,.md,.json,.csv,.log,.py,.js,.html,.css"></label> |
| <div id="filePreview" style="display:flex; align-items:center; gap:4px;"></div> |
| <textarea id="messageInput" rows="1" placeholder="Type /help ..."></textarea> |
| <button id="sendBtn">SEND</button> |
| <div id="uploadSpinner" class="spinner" style="display:none;"></div> |
| </div> |
| </div> |
| <div class="thread-panel" id="threadPanel"> |
| <div class="thread-header"><span>Thread</span><i class="fas fa-times" id="closeThreadBtn" style="cursor:pointer"></i></div> |
| <div class="thread-messages" id="threadMessages"></div> |
| <div class="thread-input"><textarea id="threadReplyInput" rows="2" placeholder="Reply..."></textarea><button id="sendThreadReply">Reply</button></div> |
| </div> |
| </div> |
| </div> |
| <div class="bottom-bar"><span>LACK · Real‑time scrolling graph | Click agent → edit | Double‑click → DM</span><span id="statusText">CONNECTED</span></div> |
| <div id="agentThinkingToast" class="agent-thinking-overlay" style="display:none;"><i class="fas fa-spinner fa-pulse"></i> Agent is thinking...</div> |
| |
| <div id="agentModal" class="modal"><div class="modal-content"><h3>Edit Agent</h3><input type="text" id="editAgentId" hidden><label>Name:</label><input type="text" id="editAgentName"><label>Model:</label><select id="editAgentModel"></select><label>System Prompt:</label><textarea id="editAgentPrompt" rows="3"></textarea><label>Channels (comma):</label><input type="text" id="editAgentChannels"><div class="modal-buttons"><button id="openDmBtn">Open DM</button><button id="removeAgentBtn">Remove Agent</button><button id="saveAgentBtn">Save</button><button id="closeModalBtn">Cancel</button></div></div></div> |
| <div id="quickSwitcherModal" class="modal"><div class="modal-content"><input type="text" id="switcherInput" placeholder="Jump... Ctrl+K"><div class="shortcut-hint">Ctrl+K</div></div></div> |
| <div id="graphModal" class="modal"><div class="modal-content" style="width:820px; max-width:95%; height:620px; display:flex; flex-direction:column;"><div style="display:flex; justify-content:space-between;"><h3>🧪 Agent Resource Monitor (Real‑time Scrolling)</h3><button id="closeGraphBtn" style="background:none;border:none;font-size:24px;">✕</button></div><div style="flex:1; background:var(--off-white); margin:12px 0; border:2px solid var(--black);"><canvas id="agentGraph" width="780" height="420" style="width:100%; height:100%;"></canvas></div><div id="graphLegend" style="display:flex; gap:16px; flex-wrap:wrap; font-size:11px;"></div><div style="font-size:10px; text-align:center;">CPU (solid) & Activity (semi) – Time scrolls left to right</div></div></div> |
| <div id="errorLogModal" class="modal"><div class="modal-content"><h3>📋 Error Log (last 50)</h3><div id="errorLogContent" style="max-height: 500px; overflow-y: auto; font-family: monospace; font-size: 0.7rem;"></div><div class="modal-buttons"><button id="closeErrorLogBtn">Close</button></div></div></div> |
| |
| <div id="toast" class="toast"></div> |
| |
| <script> |
| let ws, currentStoreId = 'general', currentStoreType = 'channel', username = localStorage.getItem('lack_username') || 'human_' + Math.floor(Math.random()*1000), userId = '', agents = [], researchSessions = [], channels = [], dms = [], currentThreadId = null, graphInterval = null, graphCanvas, graphCtx, resizeListener = false; |
| let pendingFile = null; |
| |
| function showToast(msg, type = 'info') { |
| const toast = document.getElementById('toast'); |
| toast.className = `toast ${type}`; |
| toast.innerText = msg; |
| toast.classList.add('show'); |
| setTimeout(() => toast.classList.remove('show'), 3000); |
| } |
| |
| function init() { |
| connect(); |
| document.getElementById('sendBtn').onclick = sendMessage; |
| document.getElementById('messageInput').onkeypress = e => { if(e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); sendMessage(); } }; |
| document.getElementById('messageInput').addEventListener('input', autoGrow); |
| document.getElementById('messageInput').addEventListener('keydown', handleSlash); |
| document.getElementById('darkModeToggle').onclick = () => { document.body.classList.toggle('dark-mode'); if(document.getElementById('graphModal').style.display === 'flex') fetchAndDrawGraph(); }; |
| document.getElementById('groundBtn').onclick = () => sendCommand('/ground'); |
| document.getElementById('graphBtn').onclick = () => openGraphModal(); |
| document.getElementById('errorlogBtn').onclick = () => fetchAndShowErrorLog(); |
| document.getElementById('cronBtn').onclick = () => { if(confirm('⚠️ CRON WIPE: Delete ALL cron jobs, add heartbeats, reset ALL data. Are you sure?')) fetch('/api/cron/wipe',{method:'POST'}).then(r=>r.json()).then(d=>{if(d.success) location.reload(); else alert('Error: '+d.error);}); }; |
| document.getElementById('closeThreadBtn').onclick = closeThreadPanel; |
| document.getElementById('sendThreadReply').onclick = sendThreadReply; |
| document.addEventListener('keydown', e => { if((e.ctrlKey||e.metaKey) && e.key === 'k') { e.preventDefault(); document.getElementById('quickSwitcherModal').style.display = 'flex'; document.getElementById('switcherInput').focus(); } }); |
| document.getElementById('quickSwitcherModal').onclick = e => { if(e.target === document.getElementById('quickSwitcherModal')) document.getElementById('quickSwitcherModal').style.display = 'none'; }; |
| document.getElementById('switcherInput').addEventListener('keyup', e => { if(e.key === 'Enter') handleQuickSwitch(); }); |
| setInterval(fetchResearchSessions, 5000); |
| document.getElementById('closeGraphBtn').onclick = () => { document.getElementById('graphModal').style.display = 'none'; if(graphInterval) clearInterval(graphInterval); if(resizeListener) window.removeEventListener('resize', handleGraphResize); }; |
| document.getElementById('closeErrorLogBtn').onclick = () => { document.getElementById('errorLogModal').style.display = 'none'; }; |
| |
| const fileInput = document.getElementById('fileInput'); |
| fileInput.addEventListener('change', async (e) => { |
| const file = e.target.files[0]; |
| if (!file) return; |
| const MAX_SIZE = 512 * 1024; |
| if (file.size > MAX_SIZE) { showToast(`File too large (max 512KB)`, 'error'); fileInput.value = ''; return; } |
| const previewDiv = document.getElementById('filePreview'); |
| previewDiv.innerHTML = `<span class="file-name-chip">📎 ${escapeHtml(file.name)} <i class="fas fa-times-circle" id="removeFileChip" style="cursor:pointer"></i></span>`; |
| document.getElementById('removeFileChip').onclick = () => { previewDiv.innerHTML = ''; pendingFile = null; fileInput.value = ''; }; |
| const spinner = document.getElementById('uploadSpinner'); |
| spinner.style.display = 'inline-block'; |
| try { |
| const base64 = await readFileAsBase64(file); |
| pendingFile = { name: file.name, contentBase64: base64, size: file.size }; |
| showToast(`File "${file.name}" ready to send`, 'success'); |
| } catch (err) { showToast(`Failed to read file`, 'error'); pendingFile = null; previewDiv.innerHTML = ''; } |
| finally { spinner.style.display = 'none'; fileInput.value = ''; } |
| }); |
| |
| document.getElementById('saveAgentBtn').onclick = () => { |
| const id = document.getElementById('editAgentId').value; |
| const name = document.getElementById('editAgentName').value; |
| const model = document.getElementById('editAgentModel').value; |
| const prompt = document.getElementById('editAgentPrompt').value; |
| const chans = document.getElementById('editAgentChannels').value.split(',').map(s=>s.trim()); |
| ws.send(JSON.stringify({type:'update_agent',id,name,model,systemPrompt:prompt,channels:chans})); |
| document.getElementById('agentModal').style.display='none'; |
| showToast(`Agent "${name}" updated`, 'success'); |
| }; |
| document.getElementById('closeModalBtn').onclick = () => { document.getElementById('agentModal').style.display='none'; }; |
| document.getElementById('openDmBtn').onclick = () => { |
| const agentName = document.getElementById('editAgentName').value; |
| if (agentName) { openDmWithAgent(agentName); document.getElementById('agentModal').style.display='none'; } |
| }; |
| document.getElementById('removeAgentBtn').onclick = async () => { |
| const agentId = document.getElementById('editAgentId').value; |
| const agentName = document.getElementById('editAgentName').value; |
| if (confirm(`Delete agent "${agentName}" permanently?`)) { |
| const resp = await fetch(`/api/agent/${agentId}`, { method: 'DELETE' }); |
| const result = await resp.json(); |
| if (resp.ok && result.success) { document.getElementById('agentModal').style.display='none'; showToast(`Agent "${agentName}" removed`, 'success'); } |
| else { showToast(result.reason || 'Cannot remove agent', 'error'); } |
| } |
| }; |
| |
| setInterval(() => { |
| const anyThinking = agents.some(a => a.status === 'thinking' || a.status === 'queued'); |
| document.getElementById('agentThinkingToast').style.display = anyThinking ? 'flex' : 'none'; |
| }, 500); |
| } |
| |
| function readFileAsBase64(file) { |
| return new Promise((resolve, reject) => { |
| const reader = new FileReader(); |
| reader.onload = () => resolve(reader.result.split(',')[1]); |
| reader.onerror = reject; |
| reader.readAsDataURL(file); |
| }); |
| } |
| |
| function connect() { |
| const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:'; |
| ws = new WebSocket(protocol+'//'+location.host); |
| ws.onopen = () => { |
| document.getElementById('statusText').innerText = 'CONNECTED'; |
| ws.send(JSON.stringify({type:'join',channelId:currentStoreId})); |
| ws.send(JSON.stringify({type:'set_username',username})); |
| }; |
| ws.onmessage = e => { |
| const d = JSON.parse(e.data); |
| switch(d.type) { |
| case 'channels': channels = d.channels; renderSidebar(); break; |
| case 'dms': dms = d.dms; renderSidebar(); break; |
| case 'agents_list': agents = d.agents; document.getElementById('agentCount').innerText = 'Agents: '+agents.length; renderSidebar(); |
| if (document.getElementById('graphModal').style.display === 'flex') fetchAndDrawGraph(); |
| break; |
| case 'history': renderMessages(d.messages); break; |
| case 'new_message': if(d.channelId === currentStoreId && currentStoreType==='channel') appendMessage(d.message); break; |
| case 'dm_history': renderMessages(d.messages); break; |
| case 'new_dm_message': if(d.dmId === currentStoreId && currentStoreType==='dm') appendMessage(d.message); break; |
| case 'dm_joined': switchToDm(d.dmId); renderMessages(d.messages); showToast('Joined DM', 'success'); break; |
| case 'switch_to_dm': { const dm = dms.find(x=>x.id===d.dmId); if(dm) switchToDm(dm.id); break; } |
| case 'research_update': fetchResearchSessions(); break; |
| case 'thread_messages': renderThreadMessages(d.messages); currentThreadId = d.threadId; openThreadPanel(); break; |
| case 'thread_update': if(currentThreadId === d.threadId) renderThreadMessages(d.messages); break; |
| case 'models_list': populateModelSelect(d.models); break; |
| case 'spawn_confirm': appendSystemMessage('Agent '+d.agent.name+' created.'); showToast(`Agent ${d.agent.name} spawned`, 'success'); break; |
| case 'error': showToast(d.message, 'error'); break; |
| case 'cron_reset': location.reload(); break; |
| case 'graph_ack': openGraphModal(); break; |
| case 'ralph_status': |
| const badge = document.getElementById('ralphStatusBadge'); |
| if (d.storeId === currentStoreId && d.active) { |
| badge.style.display = 'inline-block'; |
| badge.innerHTML = `🧬 Ralph gen ${d.generation} · ${d.goal || ''}`; |
| } else if (d.storeId === currentStoreId && !d.active) { |
| badge.style.display = 'none'; |
| } |
| break; |
| } |
| }; |
| ws.onclose = () => { document.getElementById('statusText').innerText = 'DISCONNECTED'; setTimeout(connect,3000); }; |
| } |
| |
| function populateModelSelect(models) { |
| const select = document.getElementById('editAgentModel'); |
| if (!select) return; |
| select.innerHTML = ''; |
| (models || []).forEach(m => { |
| const opt = document.createElement('option'); |
| opt.value = m; opt.textContent = m; |
| select.appendChild(opt); |
| }); |
| } |
| |
| function renderSidebar() { |
| const sidebar = document.getElementById('sidebar'); if(!sidebar) return; |
| sidebar.innerHTML = ''; |
| addSection('CHANNELS', channels.map(c => ({ id: c.id, name: '#'+c.name, type:'channel', icon:'fa-hashtag' }))); |
| addSection('DIRECT MESSAGES', dms.map(d => ({ id: d.id, name: d.name, type:'dm', icon:'fa-comment' }))); |
| addSection('AGENTS', agents.map(a => ({ id: a.id, name: a.name, type:'agent', icon:'fa-robot', status:a.status, model: a.model }))); |
| addSection('RESEARCH', researchSessions.map(s => ({ id: s.id, name: s.topic.substring(0,20), type:'research', icon:'fa-flask', progress:s.metric }))); |
| } |
| |
| function addSection(title, items) { |
| if(!items.length) return; |
| const section = document.createElement('div'); section.className = 'sidebar-section'; |
| const header = document.createElement('div'); header.className = 'sidebar-header'; header.innerHTML = `<i class="fas fa-chevron-down"></i> ${title}`; |
| let itemsDiv = document.createElement('div'); itemsDiv.className = 'channel-list'; |
| header.onclick = () => { itemsDiv.style.display = itemsDiv.style.display === 'none' ? 'block' : 'none'; }; |
| section.appendChild(header); |
| items.forEach(item => { |
| let div; |
| if (item.type === 'agent') { |
| div = document.createElement('div'); |
| div.className = 'agent-item'; |
| div.innerHTML = ` |
| <div class="agent-info" data-agent-id="${item.id}"> |
| <i class="fas ${item.icon}"></i> |
| <span class="agent-name">${escapeHtml(item.name)}</span> |
| <span class="agent-model">${escapeHtml(item.model || '')}</span> |
| <span class="agent-status status-${item.status}"></span> |
| </div> |
| <i class="fas fa-trash-alt remove-agent" data-agent-id="${item.id}" title="Remove"></i> |
| `; |
| const infoDiv = div.querySelector('.agent-info'); |
| infoDiv.onclick = (e) => { e.stopPropagation(); openEditModal(agents.find(a => a.id === item.id)); }; |
| infoDiv.ondblclick = (e) => { e.stopPropagation(); openDmWithAgent(item.name); showToast(`Opening DM with ${item.name}...`, 'info'); }; |
| const trash = div.querySelector('.remove-agent'); |
| trash.onclick = async (e) => { e.stopPropagation(); if(confirm(`Permanently remove agent "${item.name}"?`)) { const resp = await fetch(`/api/agent/${item.id}`, { method: 'DELETE' }); const result = await resp.json(); if (resp.ok && result.success) { showToast(`Agent "${item.name}" removed`, 'success'); } else { showToast(result.reason || 'Cannot remove agent', 'error'); } } }; |
| } else { |
| div = document.createElement('div'); div.className = 'channel-item'; |
| div.innerHTML = `<i class="fas ${item.icon}"></i> ${escapeHtml(item.name)}`; |
| if(item.progress !== undefined) { let p = document.createElement('span'); p.style.fontSize='0.7rem'; p.style.marginLeft='auto'; p.innerText = `${Math.round(item.progress*100)}%`; div.appendChild(p); } |
| div.onclick = () => { |
| if(item.type === 'channel') switchToChannel(item.id); |
| else if(item.type === 'dm') switchToDm(item.id); |
| else if(item.type === 'research') sendCommand('/pull '+item.id); |
| }; |
| } |
| itemsDiv.appendChild(div); |
| }); |
| section.appendChild(itemsDiv); sidebar.appendChild(section); |
| } |
| |
| function switchToChannel(id) { currentStoreId = id; currentStoreType = 'channel'; const ch = channels.find(c=>c.id===id); document.getElementById('currentChatName').innerHTML = ch ? '#'+ch.name : id; ws.send(JSON.stringify({type:'join',channelId:id})); closeThreadPanel(); updateRalphBadge(); } |
| function switchToDm(id) { currentStoreId = id; currentStoreType = 'dm'; const dm = dms.find(d=>d.id===id); document.getElementById('currentChatName').innerHTML = dm ? dm.name : 'DM'; ws.send(JSON.stringify({type:'join_dm',dmId:id})); closeThreadPanel(); updateRalphBadge(); } |
| |
| function updateRalphBadge() { |
| const badge = document.getElementById('ralphStatusBadge'); |
| badge.style.display = 'none'; |
| } |
| |
| function renderMessages(messages) { |
| const container = document.getElementById('messagesArea'); container.innerHTML = ''; |
| const groups = []; let cur = null; |
| for(const msg of messages) { |
| if(msg.senderType === 'system') { if(cur) groups.push(cur); groups.push({sender:msg.sender, messages:[msg], lastTimestamp:msg.timestamp}); cur=null; continue; } |
| if(!cur || cur.sender !== msg.sender || msg.timestamp - cur.lastTimestamp > 300000) { if(cur) groups.push(cur); cur = { sender: msg.sender, messages: [], lastTimestamp: msg.timestamp }; } |
| cur.messages.push(msg); cur.lastTimestamp = msg.timestamp; |
| } |
| if(cur) groups.push(cur); |
| for(const g of groups) { |
| const groupDiv = document.createElement('div'); groupDiv.className = 'message-group'; |
| for(let i=0;i<g.messages.length;i++) { |
| const msg = g.messages[i]; |
| const msgDiv = createMessageElement(msg, i===0 ? g.sender : null); |
| groupDiv.appendChild(msgDiv); |
| } |
| container.appendChild(groupDiv); |
| } |
| container.scrollTop = container.scrollHeight; |
| } |
| |
| function createMessageElement(msg, showSender) { |
| const div = document.createElement('div'); div.className = 'message'; |
| const avatar = document.createElement('div'); avatar.className = 'message-avatar'; avatar.innerText = msg.sender.charAt(0).toUpperCase(); |
| const contentDiv = document.createElement('div'); contentDiv.className = 'message-content'; |
| if(showSender) { |
| const senderSpan = document.createElement('div'); senderSpan.className = 'message-sender'; |
| senderSpan.innerHTML = `${escapeHtml(msg.sender)} <span class="message-timestamp">${formatTime(msg.timestamp)}</span>`; |
| contentDiv.appendChild(senderSpan); |
| } |
| const textDiv = document.createElement('div'); textDiv.className = 'message-text'; |
| textDiv.innerHTML = formatCode(escapeHtml(msg.content)); |
| contentDiv.appendChild(textDiv); |
| if(msg.replyCount > 0) { |
| const badge = document.createElement('div'); badge.className = 'reply-badge'; |
| badge.innerHTML = `<i class="fas fa-reply-all"></i> ${msg.replyCount} replies`; |
| badge.onclick = () => fetchThread(msg.id); |
| contentDiv.appendChild(badge); |
| } |
| const actions = document.createElement('div'); actions.className = 'message-actions'; |
| actions.innerHTML = `<i class="fas fa-reply action-icon" title="Reply"></i><i class="fas fa-plus-circle action-icon" title="React"></i><i class="fas fa-thumbtack action-icon" title="Pin"></i><i class="fas fa-copy action-icon" title="Copy"></i>`; |
| actions.querySelector('.fa-reply').onclick = () => fetchThread(msg.id); |
| actions.querySelector('.fa-plus-circle').onclick = (e) => { e.stopPropagation(); showReactionPicker(msg.id, e); }; |
| actions.querySelector('.fa-thumbtack').onclick = () => sendCommand(`/pin ${msg.id}`); |
| actions.querySelector('.fa-copy').onclick = () => navigator.clipboard.writeText(msg.content); |
| contentDiv.appendChild(actions); |
| div.appendChild(avatar); div.appendChild(contentDiv); |
| return div; |
| } |
| |
| function appendMessage(msg) { const container = document.getElementById('messagesArea'); const groupDiv = document.createElement('div'); groupDiv.className = 'message-group'; groupDiv.appendChild(createMessageElement(msg,true)); container.appendChild(groupDiv); container.scrollTop = container.scrollHeight; } |
| function appendSystemMessage(text) { const container = document.getElementById('messagesArea'); const div = document.createElement('div'); div.className = 'message'; div.innerHTML = `<div class="message-avatar">S</div><div class="message-content"><em>${escapeHtml(text)}</em></div>`; container.appendChild(div); container.scrollTop = container.scrollHeight; } |
| function fetchThread(mid) { ws.send(JSON.stringify({type:'reply_in_thread',parentId:mid,content:'',storeId:currentStoreId})); } |
| function renderThreadMessages(messages) { const container = document.getElementById('threadMessages'); container.innerHTML = ''; for(const msg of messages) { const div = document.createElement('div'); div.className = 'message'; div.innerHTML = `<strong>${escapeHtml(msg.sender)}</strong> ${formatTime(msg.timestamp)}<br>${formatCode(escapeHtml(msg.content))}`; container.appendChild(div); } container.scrollTop = container.scrollHeight; } |
| function sendThreadReply() { const txt = document.getElementById('threadReplyInput').value.trim(); if(txt && currentThreadId) { ws.send(JSON.stringify({type:'reply_in_thread',parentId:currentThreadId,content:txt,storeId:currentStoreId})); document.getElementById('threadReplyInput').value = ''; } } |
| function openThreadPanel() { document.getElementById('threadPanel').classList.add('open'); ws.send(JSON.stringify({type:'open_thread',threadId:currentThreadId})); } |
| function closeThreadPanel() { document.getElementById('threadPanel').classList.remove('open'); if(currentThreadId) ws.send(JSON.stringify({type:'close_thread',threadId:currentThreadId})); currentThreadId = null; } |
| |
| function sendMessage() { |
| let finalMessage = ''; |
| if (pendingFile) { |
| let fileContent; |
| try { fileContent = atob(pendingFile.contentBase64); } catch(e) { showToast('Failed to decode file', 'error'); return; } |
| const MAX_CHARS = 1500; |
| const truncated = fileContent.length > MAX_CHARS ? fileContent.substring(0, MAX_CHARS) + '\n...(truncated)' : fileContent; |
| const fileBlock = `📎 **File: ${pendingFile.name}**\n\`\`\`\n${truncated}\n\`\`\``; |
| const userText = document.getElementById('messageInput').value.trim(); |
| finalMessage = userText ? `${fileBlock}\n\n${userText}` : fileBlock; |
| pendingFile = null; |
| document.getElementById('filePreview').innerHTML = ''; |
| } else { |
| finalMessage = document.getElementById('messageInput').value.trim(); |
| } |
| if (!finalMessage) return; |
| if (finalMessage.startsWith('/spawn')) { handleSpawn(); document.getElementById('messageInput').value = ''; autoGrow(); return; } |
| ws.send(JSON.stringify({type:'message',content:finalMessage})); |
| document.getElementById('messageInput').value = ''; |
| autoGrow(); |
| } |
| |
| function openDmWithAgent(agentName) { |
| if (!ws) return; |
| ws.send(JSON.stringify({ type: 'start_dm', targetName: agentName })); |
| } |
| |
| function sendCommand(cmd) { if(ws) ws.send(JSON.stringify({type:'message',content:cmd})); } |
| function formatTime(ts) { return new Date(ts).toLocaleTimeString([],{hour:'2-digit',minute:'2-digit'}); } |
| function formatCode(t) { return t.replace(/```(\w*)\n([\s\S]*?)```/g, '<pre><code>$2</code></pre>'); } |
| function autoGrow() { const ta = document.getElementById('messageInput'); ta.style.height = 'auto'; ta.style.height = Math.min(ta.scrollHeight,200)+'px'; } |
| let slashTimeout; |
| function handleSlash(e) { if(e.key !== '/') return; const input = e.target; if(input.selectionStart === 0 || input.value[input.selectionStart-1] === ' ') { if(slashTimeout) clearTimeout(slashTimeout); const existing = document.querySelector('.slash-suggestions'); if(existing) existing.remove(); const commands = ['help','ground','research','abstract','plan','ralph','stop','list','spawn','siphon','slime','pull','dm','thread','pin','graph','errorlog','convergence','tools','stack','repo','lint','moderate']; const sug = document.createElement('ul'); sug.className = 'slash-suggestions'; commands.forEach(cmd => { const li = document.createElement('li'); li.innerText = '/'+cmd; li.onclick = () => { input.value = '/'+cmd+' '; input.focus(); sug.remove(); }; sug.appendChild(li); }); input.parentNode.style.position = 'relative'; input.parentNode.appendChild(sug); slashTimeout = setTimeout(() => { if(sug.parentNode) sug.remove(); },5000); document.addEventListener('click', function close(e) { if(!sug.contains(e.target) && e.target !== input) { sug.remove(); document.removeEventListener('click', close); } }); } } |
| function showReactionPicker(messageId, event) { |
| const emojis = ['👍','❤️','😂','😮','😢','🔥']; |
| const picker = document.createElement('div'); |
| picker.style.position='fixed'; picker.style.background='var(--white)'; picker.style.border='1px solid var(--black)'; picker.style.borderRadius='20px'; picker.style.padding='4px'; picker.style.display='flex'; picker.style.gap='8px'; picker.style.zIndex=1000; |
| emojis.forEach(emoji => { |
| const btn = document.createElement('span'); |
| btn.innerText=emoji; btn.style.cursor='pointer'; btn.style.fontSize='1.2rem'; btn.style.padding='4px'; |
| btn.onclick = () => { ws.send(JSON.stringify({type:'add_reaction',messageId:messageId,emoji,storeId:currentStoreId})); picker.remove(); }; |
| picker.appendChild(btn); |
| }); |
| document.body.appendChild(picker); |
| if (event) { picker.style.left = (event.clientX - 50) + 'px'; picker.style.top = (event.clientY - 40) + 'px'; } |
| else { picker.style.left = '50%'; picker.style.top = '50%'; picker.style.transform = 'translate(-50%, -50%)'; } |
| setTimeout(()=>picker.remove(),3000); |
| } |
| function handleQuickSwitch() { const q = document.getElementById('switcherInput').value.toLowerCase(); const ch = channels.find(c=>c.name.toLowerCase().includes(q)); if(ch) switchToChannel(ch.id); const dm = dms.find(d=>d.name.toLowerCase().includes(q)); if(dm) switchToDm(dm.id); const ag = agents.find(a=>a.name.toLowerCase().includes(q)); if(ag) openEditModal(ag); document.getElementById('quickSwitcherModal').style.display='none'; } |
| function fetchResearchSessions() { fetch('/api/research/sessions').then(r=>r.json()).then(d=>{ researchSessions = d.sessions; renderSidebar(); }).catch(console.error); } |
| function openEditModal(agent) { |
| document.getElementById('editAgentId').value = agent.id; |
| document.getElementById('editAgentName').value = agent.name; |
| document.getElementById('editAgentPrompt').value = agent.systemPrompt; |
| document.getElementById('editAgentChannels').value = agent.channels.join(','); |
| fetch('/api/models').then(r=>r.json()).then(data => { |
| const sel = document.getElementById('editAgentModel'); |
| sel.innerHTML = ''; |
| (data.models||[]).forEach(m => { |
| const opt = document.createElement('option'); |
| opt.value = m; opt.textContent = m; |
| if (m === agent.model) opt.selected = true; |
| sel.appendChild(opt); |
| }); |
| }); |
| document.getElementById('agentModal').style.display = 'block'; |
| } |
| function handleSpawn() { ws.send(JSON.stringify({type:'get_models'})); const orig = ws.onmessage; ws.onmessage = e => { const d = JSON.parse(e.data); if(d.type === 'models_list') { if(!d.models.length) alert('No Ollama models'); else { const name = prompt('Agent name:'); if(name) { const model = prompt('Model:',d.models[0]); const promptText = prompt('System prompt:','You are helpful.'); const chans = prompt('Channels (comma):','general').split(',').map(s=>s.trim()); ws.send(JSON.stringify({type:'spawn_agent',name,model,systemPrompt:promptText,channels:chans})); } } ws.onmessage = orig; } else if(orig) orig(e); }; } |
| function escapeHtml(s) { return s.replace(/[&<>]/g,m=>({'&':'&','<':'<','>':'>'}[m])); } |
| |
| async function fetchAndShowErrorLog() { |
| try { |
| const res = await fetch('/api/errorlog'); |
| const data = await res.json(); |
| const container = document.getElementById('errorLogContent'); |
| container.innerHTML = ''; |
| if (!data.errors || data.errors.length === 0) { |
| container.innerHTML = '<div class="error-log-entry">No errors recorded.</div>'; |
| } else { |
| data.errors.forEach(err => { |
| const div = document.createElement('div'); |
| div.className = 'error-log-entry'; |
| div.textContent = `${new Date(err.timestamp).toLocaleString()} | ${err.agentId || 'system'}: ${err.error}`; |
| container.appendChild(div); |
| }); |
| } |
| document.getElementById('errorLogModal').style.display = 'flex'; |
| } catch(e) { showToast('Failed to fetch error log', 'error'); } |
| } |
| |
| async function openGraphModal() { |
| document.getElementById('graphModal').style.display = 'flex'; |
| await new Promise(r => setTimeout(r, 100)); |
| graphCanvas = document.getElementById('agentGraph'); |
| if (!graphCanvas) return; |
| resizeGraphCanvas(); |
| await fetchAndDrawGraph(); |
| if (graphInterval) clearInterval(graphInterval); |
| graphInterval = setInterval(fetchAndDrawGraph, 1500); |
| if (!resizeListener) { |
| window.addEventListener('resize', handleGraphResize); |
| resizeListener = true; |
| } |
| } |
| function handleGraphResize() { |
| if (document.getElementById('graphModal').style.display === 'flex') { |
| resizeGraphCanvas(); |
| fetchAndDrawGraph(); |
| } |
| } |
| function resizeGraphCanvas() { |
| if (!graphCanvas) return; |
| const container = graphCanvas.parentElement; |
| if (!container) return; |
| const w = container.clientWidth, h = container.clientHeight; |
| if (w === 0 || h === 0) return; |
| const dpr = window.devicePixelRatio || 1; |
| graphCanvas.width = w * dpr; |
| graphCanvas.height = h * dpr; |
| graphCanvas.style.width = w + 'px'; |
| graphCanvas.style.height = h + 'px'; |
| graphCtx = graphCanvas.getContext('2d'); |
| graphCtx.setTransform(1, 0, 0, 1, 0, 0); |
| graphCtx.scale(dpr, dpr); |
| } |
| async function fetchAndDrawGraph() { |
| resizeGraphCanvas(); |
| try { |
| const res = await fetch('/api/metrics'); |
| const data = await res.json(); |
| if (!data.agents) return; |
| const legend = document.getElementById('graphLegend'); |
| const colors = ['#ff3b5c','#00f0ff','#39ff14','#ffeb3b','#c84cff']; |
| legend.innerHTML = ''; |
| data.agents.forEach((a,i) => { |
| const c = colors[i%colors.length]; |
| const d = document.createElement('div'); |
| d.style.display='flex'; d.style.alignItems='center'; d.style.gap='6px'; d.style.fontSize='11px'; |
| d.innerHTML = `<span style="display:inline-block;width:20px;height:3px;background:${c};border-radius:2px;"></span> ${escapeHtml(a.name)}`; |
| legend.appendChild(d); |
| }); |
| drawGraph(data); |
| } catch(e) { console.error(e); } |
| } |
| function drawGraph(data) { |
| if (!graphCtx || !graphCanvas) return; |
| const container = graphCanvas.parentElement; |
| const w = container.clientWidth, h = container.clientHeight; |
| if (w === 0 || h === 0) return; |
| const isDark = document.body.classList.contains('dark-mode'); |
| const bg = isDark?'#0a0a0a':'#f8f8f8'; |
| const grid = isDark?'#2a2a2a':'#e0e0e0'; |
| const text = isDark?'#f0f0f0':'#000'; |
| graphCtx.clearRect(0,0,w,h); |
| graphCtx.fillStyle=bg; graphCtx.fillRect(0,0,w,h); |
| const pad=40, pw=w-2*pad, ph=h-2*pad; |
| if(pw<=0||ph<=0) return; |
| graphCtx.strokeStyle=grid; graphCtx.lineWidth=1; |
| for(let i=0;i<=5;i++){ let y=pad+ph*(i/5); graphCtx.beginPath(); graphCtx.moveTo(pad,y); graphCtx.lineTo(w-pad,y); graphCtx.stroke(); } |
| for(let i=0;i<=4;i++){ let x=pad+pw*(i/4); graphCtx.beginPath(); graphCtx.moveTo(x,pad); graphCtx.lineTo(x,h-pad); graphCtx.stroke(); } |
| graphCtx.fillStyle=text; graphCtx.font='10px monospace'; |
| graphCtx.fillText('100%',pad-30,pad+5); |
| graphCtx.fillText('0%',pad-25,h-pad-5); |
| graphCtx.fillText('Time →',w/2,h-10); |
| const colors = ['#ff3b5c','#00f0ff','#39ff14','#ffeb3b','#c84cff']; |
| let allZero = true; |
| for (const a of data.agents) { |
| const m = data.metrics[a.id]; |
| if (m && m.cpu && m.cpu.some(v => v > 0)) { allZero = false; break; } |
| } |
| if (allZero) { |
| graphCtx.fillStyle = text; |
| graphCtx.font = '12px monospace'; |
| graphCtx.textAlign = 'center'; |
| graphCtx.fillText('Waiting for agent activity...', w/2, h/2); |
| graphCtx.textAlign = 'left'; |
| return; |
| } |
| data.agents.forEach((a, idx) => { |
| const m = data.metrics[a.id]; |
| if (!m || !m.cpu || !m.activity || !m.timestamps) return; |
| const cpu = m.cpu, act = m.activity, ts = m.timestamps; |
| const validPoints = []; |
| for (let i = 0; i < cpu.length; i++) { |
| if (ts[i] && ts[i] > 0) validPoints.push({ cpu: cpu[i], act: act[i], t: ts[i] }); |
| } |
| if (validPoints.length < 2) return; |
| let minT = validPoints[0].t; |
| let maxT = validPoints[validPoints.length - 1].t; |
| if (minT === maxT) { |
| minT = minT - 5000; |
| maxT = maxT + 5000; |
| } |
| const col = colors[idx % colors.length]; |
| graphCtx.beginPath(); |
| graphCtx.strokeStyle = col; |
| graphCtx.lineWidth = 2.5; |
| graphCtx.shadowBlur = 3; |
| graphCtx.shadowColor = col; |
| for (let i = 0; i < validPoints.length; i++) { |
| const x = pad + ((validPoints[i].t - minT) / (maxT - minT)) * pw; |
| const y = h - pad - (validPoints[i].cpu / 100) * ph; |
| if (i === 0) graphCtx.moveTo(x, y); |
| else graphCtx.lineTo(x, y); |
| } |
| graphCtx.stroke(); |
| graphCtx.beginPath(); |
| graphCtx.strokeStyle = col + 'dd'; |
| graphCtx.lineWidth = 2; |
| graphCtx.shadowBlur = 0; |
| for (let i = 0; i < validPoints.length; i++) { |
| const x = pad + ((validPoints[i].t - minT) / (maxT - minT)) * pw; |
| const y = h - pad - (validPoints[i].act / 100) * ph; |
| if (i === 0) graphCtx.moveTo(x, y); |
| else graphCtx.lineTo(x, y); |
| } |
| graphCtx.stroke(); |
| }); |
| graphCtx.shadowBlur = 0; |
| } |
| window.onload = init; |
| </script> |
| </body> |
| </html> |
| ''' |
|
|
| CONFIG_JSON = r'''{ |
| "httpPort": 3721, |
| "agents": [ |
| { "id": "agent1", "name": "Agent 1", "model": "qwen2.5:0.5b", "systemPrompt": "You are a helpful AI assistant.", "channels": ["general","random","siphon","code"] }, |
| { "id": "agent2", "name": "Agent 2", "model": "qwen2.5:0.5b", "systemPrompt": "You are a creative AI.", "channels": ["general","random","siphon","code"] } |
| ], |
| "channels": [ |
| { "id": "general", "name": "general" }, |
| { "id": "random", "name": "random" }, |
| { "id": "siphon", "name": "siphon" }, |
| { "id": "code", "name": "code" } |
| ], |
| "dms": [] |
| }''' |
|
|
| BIN_LACK_JS = r'''#!/usr/bin/env node |
| const { spawn } = require('child_process'); |
| const path = require('path'); |
| const projectRoot = path.resolve(__dirname, '..'); |
| process.chdir(projectRoot); |
| async function checkOllama() { |
| const http = require('http'); |
| return new Promise((resolve) => { |
| const req = http.get('http://localhost:11434/api/tags', (res) => resolve(res.statusCode === 200)); |
| req.on('error', () => resolve(false)); |
| req.setTimeout(1000, () => resolve(false)); |
| }); |
| } |
| async function main() { |
| console.log('\x1b[36m[ LACK v3.9.2 ] Starting – STACK + tools + code moderator\x1b[0m'); |
| if (!await checkOllama()) { console.error('\x1b[31m✗ Ollama not running\x1b[0m'); process.exit(1); } |
| console.log('\x1b[32m✓ Ollama detected\x1b[0m'); |
| const server = spawn('node', ['server.js'], { stdio: 'inherit', cwd: projectRoot }); |
| server.on('error', (err) => { console.error('Failed to start server:', err); process.exit(1); }); |
| process.on('SIGINT', () => { server.kill('SIGINT'); process.exit(); }); |
| } |
| main(); |
| ''' |
|
|
| |
| |
| |
| def create_directory(path): |
| Path(path).mkdir(parents=True, exist_ok=True) |
|
|
| def write_file(path, content): |
| with open(path, 'w', encoding='utf-8') as f: |
| f.write(content) |
|
|
| def make_executable(path): |
| st = os.stat(path) |
| os.chmod(path, st.st_mode | stat.S_IEXEC) |
|
|
| def run_command(cmd, cwd=None): |
| print(f"Running: {' '.join(cmd)}") |
| result = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True) |
| if result.returncode != 0: |
| print("STDERR:", result.stderr) |
| if "npm" in cmd[0] and "install" in cmd: |
| print("\n❌ npm install failed. Possible fixes:") |
| print(" 1. Ensure Node.js >= 18 is installed: node --version") |
| print(" 2. Check internet connection (npm needs network)") |
| print(" 3. Run manually: npm install express ws uuid axios cheerio simple-git") |
| raise subprocess.CalledProcessError(result.returncode, cmd, output=result.stdout, stderr=result.stderr) |
| print(result.stdout) |
|
|
| def open_browser(): |
| time.sleep(2) |
| webbrowser.open('http://localhost:3721') |
|
|
| def check_ollama_with_retry(max_attempts=3, delay=2): |
| import urllib.request |
| for attempt in range(1, max_attempts + 1): |
| try: |
| req = urllib.request.Request("http://localhost:11434/api/tags", method="GET") |
| with urllib.request.urlopen(req, timeout=3) as resp: |
| if resp.status == 200: |
| return json.loads(resp.read().decode()) |
| except Exception as e: |
| if attempt < max_attempts: |
| print(f" Ollama check attempt {attempt}/{max_attempts} failed ({e}). Retrying in {delay}s...") |
| time.sleep(delay) |
| else: |
| raise |
| return None |
|
|
| def main(): |
| print("=== LACK v3.9.2 – STACK + Code Moderation (enhanced for small models) ===") |
| print("Added JSON repair, forced code blocks, fallbacks, forced commits, test DM.\n") |
|
|
| for d in ["config", "public", "bin", "logs", "lineage", "research", "workspace", "lack_repos/templates", "thread_repos"]: |
| create_directory(d) |
|
|
| print("Generating files...") |
| write_file("server.js", SERVER_JS) |
| write_file("public/index.html", INDEX_HTML) |
| write_file("config/lack.config.json", CONFIG_JSON) |
| write_file("bin/lack.js", BIN_LACK_JS) |
| make_executable("bin/lack.js") |
|
|
| try: |
| node_version = subprocess.run(["node", "--version"], capture_output=True, text=True, check=True) |
| print(f"Node.js detected: {node_version.stdout.strip()}") |
| except (subprocess.CalledProcessError, FileNotFoundError): |
| print("Error: Node.js is not installed. Install from https://nodejs.org") |
| sys.exit(1) |
|
|
| if not Path("node_modules").exists(): |
| print("Installing npm dependencies...") |
| run_command(["npm", "install", "express", "ws", "uuid", "axios", "cheerio", "simple-git"]) |
| else: |
| print("node_modules already present.") |
|
|
| print("Checking Ollama...") |
| try: |
| models_data = check_ollama_with_retry() |
| if models_data is not None: |
| print("✓ Ollama is running.") |
| model_names = [m['name'] for m in models_data.get('models', [])] |
| if not any('qwen2.5:0.5b' in m for m in model_names): |
| print("⚠ qwen2.5:0.5b not found. Run: ollama pull qwen2.5:0.5b") |
| if not any('nomic-embed-text' in m for m in model_names): |
| print("⚠ nomic-embed-text not found. Run: ollama pull nomic-embed-text") |
| else: |
| print("⚠ Ollama responded but returned no data.") |
| except Exception as e: |
| print(f"⚠ Ollama not reachable after 3 attempts: {e}") |
|
|
| threading.Thread(target=open_browser, daemon=True).start() |
| print("\nStarting LACK v3.9.2 with enhanced small‑model resilience. Press Ctrl+C to stop.\n") |
|
|
| while True: |
| print("Launching Node server...") |
| server_process = subprocess.Popen( |
| ["node", "server.js"], |
| stdout=sys.stdout, |
| stderr=sys.stderr |
| ) |
| try: |
| server_process.wait() |
| except KeyboardInterrupt: |
| print("Shutting down...") |
| server_process.terminate() |
| sys.exit(0) |
| print("Server crashed. Restarting in 3 seconds...") |
| time.sleep(3) |
|
|
| if __name__ == "__main__": |
| main() |
|
|
