@causyne/agent 0.0.0-stage → 1.10.1

package/src/tools/memoryWrite.js

@@ -0,0 +1,99 @@
+import { getMemory, saveMemory } from '../memory.js';
+import { cortexDb } from '../cortex/vectorDb.js';
+
+// Persistent memory write.
+//
+// This tool used to append facts to `{cwd}/.causyne_memory_store.json` — a file
+// that nothing in the codebase ever reads. The facts the agent is actually shown
+// come from `getMemoryContextString()`, which reads `~/.causyne/memory.json`, and
+
+// never connected, so every fact the agent chose to remember was written into a
+// per-project dead end and silently lost. It now writes where the agent reads.
+
+const MAX_FACTS = 100;
+
+export const memoryWrite = {
+  schema: {
+    name: 'memory_write',
+    description: "Save a durable fact about the user, their machine, or their project into persistent memory. Facts saved here are injected into your system context on every future task, so record only things worth remembering across sessions (preferences, conventions, paths, stack choices). After completing a web or UI design, also pass creativePattern so you do not repeat the same aesthetic next time.",
+    parameters: {
+      type: 'object',
+      properties: {
+        fact: {
+          type: 'string',
+          description: 'The concise, durable fact to remember. One fact per call.'
+        },
+        creativePattern: {
+          type: 'object',
+          description: 'Optional. Record a completed design so future projects deliberately differ from it.',
+          properties: {
+            project: { type: 'string', description: 'What was built, e.g. "coffee roaster landing page".' },
+            designApproach: { type: 'string', description: 'The design movement committed to, e.g. "Swiss International", "Brutalism".' },
+            colorPalette: { type: 'string', description: 'The palette used, e.g. "warm neutrals + oxblood accent".' },
+            fonts: { type: 'string', description: 'Typefaces used, e.g. "Space Grotesk / Inter".' }
+          }
+        }
+      },
+      required: ['fact']
+    }
+  },
+
+  execute: async (args, dependencies) => {
+    if (!args || !args.fact) {
+      return { success: false, error: "Missing 'fact' parameter." };
+    }
+
+    try {
+      const memory = getMemory();
+      if (!Array.isArray(memory.facts)) memory.facts = [];
+
+      const fact = String(args.fact).trim();
+      const alreadyKnown = memory.facts.includes(fact);
+
+      if (!alreadyKnown) {
+        memory.facts.push(fact);
+        // Self-culling: keep the store bounded so it cannot grow into the
+        // system prompt without limit.
+        while (memory.facts.length > MAX_FACTS) {
+          memory.facts.shift();
+        }
+        saveMemory(memory);
+      }
+
+      // Anti-slop creative memory. saveCreativePattern() existed but had no
+      // caller anywhere, so getRecentCreativePatterns() always returned empty
+      // and the "DO NOT REPEAT RECENT PATTERNS" directive never once fired.
+      let creativeSaved = false;
+      if (args.creativePattern && args.creativePattern.designApproach) {
+        try {
+          await cortexDb.saveCreativePattern({
+            project: args.creativePattern.project || 'untitled project',
+            designApproach: args.creativePattern.designApproach,
+            colorPalette: args.creativePattern.colorPalette || 'unspecified',
+            fonts: args.creativePattern.fonts || 'unspecified'
+          });
+          creativeSaved = true;
+        } catch (e) {
+          console.error('[CORTEX] Creative pattern save failed:', e.message);
+        }
+      }
+
+      if (dependencies && dependencies.broadcast) {
+        dependencies.broadcast({
+          type: 'agent_message',
+          content: `🧠 Persistent memory updated: "${fact}"`
+        });
+      }
+
+      const notes = [
+        alreadyKnown ? 'Fact already known, not duplicated.' : 'Fact saved.',
+        `Total persistent facts: ${memory.facts.length}.`,
+        creativeSaved ? 'Creative pattern recorded in the V5 Cortex.' : ''
+      ].filter(Boolean);
+
+      return { success: true, output: notes.join(' ') };
+    } catch (e) {
+      return { success: false, error: `Failed to save memory: ${e.message}` };
+    }
+  }
+};

package/src/tools/multiEdit.js

@@ -0,0 +1,107 @@
+import fs from 'fs/promises';
+import os from 'os';
+
+// Phase 3 AGI Upgrade: Fast Levenshtein Distance for Fuzzy Matching
+function getLevenshteinDistance(a, b) {
+  const matrix = Array(a.length + 1).fill(null).map(() => Array(b.length + 1).fill(null));
+
+  for (let i = 0; i <= a.length; i++) matrix[i][0] = i;
+  for (let j = 0; j <= b.length; j++) matrix[0][j] = j;
+
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const indicator = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1, // deletion
+        matrix[i][j - 1] + 1, // insertion
+        matrix[i - 1][j - 1] + indicator // substitution
+      );
+    }
+  }
+  return matrix[a.length][b.length];
+}
+
+function calculateConfidence(original, match) {
+  const dist = getLevenshteinDistance(original, match);
+  const maxLen = Math.max(original.length, match.length);
+  if (maxLen === 0) return 100;
+  return ((maxLen - dist) / maxLen) * 100;
+}
+
+export const multiEdit = {
+  schema: {
+    name: 'MultiEdit',
+    description: 'Make multiple edits to a single file atomically. Replaces old_string with new_string. If exact match fails, uses fuzzy matching (requires 90% confidence). Includes atomic rollback.',
+    parameters: {
+      type: 'object',
+      properties: {
+        file_path: { type: 'string' },
+        edits: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              old_string: { type: 'string' },
+              new_string: { type: 'string' }
+            },
+            required: ['old_string', 'new_string']
+          },
+          minItems: 1
+        }
+      },
+      required: ['file_path', 'edits']
+    }
+  },
+  async execute(args) {
+    try {
+      const target = args.file_path.replace(/^~\//, os.homedir() + '/');
+      let originalContent = await fs.readFile(target, 'utf8');
+      let workingContent = originalContent; // Phase 3 AGI Upgrade: Atomic Rollback prep
+      
+      let replacements = 0;
+      for (let i = 0; i < args.edits.length; i++) {
+        const edit = args.edits[i];
+        
+        // Try exact match first
+        if (workingContent.includes(edit.old_string)) {
+          workingContent = workingContent.replace(edit.old_string, edit.new_string);
+          replacements++;
+          continue;
+        }
+        
+        // Phase 3 AGI Upgrade: Fuzzy Match Fallback
+        // Find the best sliding window match (simplified for performance: split by line, scan chunks)
+        const lines = workingContent.split('\n');
+        const oldLines = edit.old_string.split('\n');
+        let bestMatch = null;
+        let highestConfidence = 0;
+        
+        for (let j = 0; j <= lines.length - oldLines.length; j++) {
+          const chunk = lines.slice(j, j + oldLines.length).join('\n');
+          const conf = calculateConfidence(edit.old_string, chunk);
+          if (conf > highestConfidence) {
+            highestConfidence = conf;
+            bestMatch = chunk;
+          }
+        }
+
+        if (highestConfidence >= 90 && bestMatch) {
+          workingContent = workingContent.replace(bestMatch, edit.new_string);
+          replacements++;
+        } else {
+          // Atomic Rollback
+          return { 
+            success: false, 
+            error: `ATOMIC ROLLBACK: Edit index ${i} failed. Exact match not found, and fuzzy match confidence was too low (${highestConfidence.toFixed(2)}% < 90%). Previous edits in this batch were rolled back.` 
+          };
+        }
+      }
+      
+      // Commit the transaction
+      await fs.writeFile(target, workingContent, 'utf8');
+      return { success: true, output: `Transaction Success: ${replacements} atomic edits applied to ${args.file_path}` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/palmierAutomator.js

@@ -0,0 +1,104 @@
+import os from 'os';
+import fs from 'fs';
+
+// MCP server URL for Palmier Pro
+const MCP_URL = 'http://127.0.0.1:19789/mcp';
+
+export const palmierAutomator = {
+  schema: {
+    name: 'palmier_act',
+    description: 'Automate an existing Palmier Pro installation through its local MCP server. Causyne does not download or install the application.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: { 
+          type: 'string', 
+          enum: ['checkConnection', 'importAndAssemble'] 
+        },
+        mediaPath: { 
+          type: 'string', 
+          description: 'Absolute path to media directory to import (for importAndAssemble)' 
+        },
+        fps: { 
+          type: 'string', 
+          description: 'Timeline framerate (e.g. 23.976) or "auto"' 
+        },
+        resolution_x: { 
+          type: 'string', 
+          description: 'Timeline width or "auto"' 
+        },
+        resolution_y: { 
+          type: 'string', 
+          description: 'Timeline height or "auto"' 
+        }
+      },
+      required: ['action']
+    }
+  },
+  async execute(args) {
+    if (os.platform() !== 'darwin') {
+      return { success: false, error: 'Palmier Pro is a macOS native application. Not supported on this OS.' };
+    }
+
+    const { action } = args;
+
+    // JSON-RPC to MCP server
+    const sendMcpRequest = async (method, params) => {
+      try {
+        const response = await fetch(MCP_URL, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: Date.now(),
+            method: method,
+            params: params
+          })
+        });
+        
+        if (!response.ok) {
+          throw new Error(`HTTP Error: ${response.status} ${response.statusText}`);
+        }
+        
+        const data = await response.json();
+        if (data.error) throw new Error(data.error.message || JSON.stringify(data.error));
+        return data.result;
+      } catch (err) {
+        throw new Error(`MCP Connection Error (Is Palmier Pro running?): ${err.message}`);
+      }
+    };
+
+    try {
+      if (action === 'checkConnection') {
+        const res = await sendMcpRequest('tools/list', {});
+        return { 
+          success: true, 
+          message: 'Successfully connected to Palmier Pro MCP Server.', 
+          tools: res.tools 
+        };
+      }
+      
+      if (action === 'importAndAssemble') {
+        if (!args.mediaPath || !fs.existsSync(args.mediaPath)) {
+          return { success: false, error: `Media path not found: ${args.mediaPath}` };
+        }
+        // Call the MCP tool exposed by Palmier Pro
+        const res = await sendMcpRequest('tools/call', {
+          name: 'import_and_assemble',
+          arguments: {
+            mediaPath: args.mediaPath,
+            fps: args.fps || 'auto',
+            resolution_x: args.resolution_x || 'auto',
+            resolution_y: args.resolution_y || 'auto'
+          }
+        });
+        
+        return { success: true, message: 'Successfully imported and assembled media in Palmier Pro via MCP.', result: res };
+      }
+      
+      return { success: false, error: `Unknown action: ${action}` };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+};

package/src/tools/pdfReader.js

@@ -0,0 +1,112 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Lightweight, zero-dependency PDF text extractor
+// Extracts printable ASCII/UTF-8 text streams and string literals inside PDF objects () and []
+// This allows Causyne Agent to read documents like resumes, theses, and scripts without heavy C++/binary dependencies.
+function extractTextFromPdfBuffer(buffer) {
+  const textChunks = [];
+  const content = buffer.toString('binary');
+  
+  // 1. Look for text objects inside BT (Begin Text) ... ET (End Text) blocks
+  const btEtRegex = /BT[\s\S]*?ET/g;
+  let match;
+  
+  while ((match = btEtRegex.exec(content)) !== null) {
+    const block = match[0];
+    // Match string literals inside parentheses (e.g., (Hello World) Tj or [(Hello) -10 (World)] TJ)
+    const strRegex = /\(([^)]+)\)/g;
+    let strMatch;
+    while ((strMatch = strRegex.exec(block)) !== null) {
+      let rawText = strMatch[1];
+      // Basic PDF octal/escape decoding
+      rawText = rawText
+        .replace(/\\n/g, '\n')
+        .replace(/\\r/g, '\r')
+        .replace(/\\t/g, '\t')
+        .replace(/\\\(/g, '(')
+        .replace(/\\\)/g, ')')
+        .replace(/\\\\/g, '\\')
+        .replace(/\\(\d{1,3})/g, (m, oct) => String.fromCharCode(parseInt(oct, 8)));
+      
+      // Filter out raw font names / binary junk
+      if (rawText && rawText.trim().length > 0 && !rawText.startsWith('F') && !rawText.includes('\x00')) {
+        textChunks.push(rawText);
+      }
+    }
+  }
+
+  // 2. Fallback if PDF is uncompressed or structured differently (e.g. standard printable strings > 4 chars)
+  if (textChunks.length < 5) {
+    const printableRegex = /[\x20-\x7E\r\n\t]{5,}/g;
+    const matches = content.match(printableRegex) || [];
+    const filtered = matches.filter(s => {
+      const trimmed = s.trim();
+      if (trimmed.length < 5) return false;
+      // Skip common PDF internal keywords
+      const keywords = ['obj', 'endobj', 'stream', 'endstream', 'xref', 'trailer', 'startxref', 'Catalog', 'Pages', 'Font', 'XObject', 'ProcSet', 'MediaBox'];
+      if (keywords.some(k => trimmed === k || trimmed.startsWith('/') || trimmed.includes('<<') || trimmed.includes('>>'))) return false;
+      return true;
+    });
+    if (filtered.length > textChunks.length) {
+      return filtered.join('\n');
+    }
+  }
+
+  return textChunks.join(' ');
+}
+
+export const pdfRead = {
+  schema: {
+    name: 'pdf_read',
+    description: 'Extract text content from a local PDF document file. Ideal for reading attached PDFs, reports, scripts, and theses.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { 
+          type: 'string',
+          description: 'Absolute path to the .pdf file.'
+        },
+        maxChars: {
+          type: 'number',
+          description: 'Maximum characters to return (defaults to 30000 to protect context window).'
+        }
+      },
+      required: ['path']
+    }
+  },
+  async execute(args) {
+    try {
+      const target = args.path.replace(/^~\//, os.homedir() + '/');
+      
+      if (!fsSync.existsSync(target)) {
+        return { success: false, error: `PDF file does not exist at path: ${target}` };
+      }
+
+      const buffer = await fs.readFile(target);
+      let extractedText = extractTextFromPdfBuffer(buffer);
+      
+      // Clean up whitespace
+      extractedText = extractedText.replace(/\s{3,}/g, '\n\n').trim();
+      
+      if (!extractedText || extractedText.length < 20) {
+        return { 
+          success: true, 
+          output: `[NOTICE: Only minimal text extracted (${extractedText.length} chars). The PDF might be scanned/image-based or heavily FlateDecode-compressed. For image-based PDFs, try converting pages to images or using OCR.]`,
+          rawExtracted: extractedText 
+        };
+      }
+
+      const maxLimit = args.maxChars || 30000;
+      if (extractedText.length > maxLimit) {
+        extractedText = extractedText.substring(0, maxLimit) + `\n\n[... PDF TEXT TRUNCATED TO ${maxLimit} CHARACTERS ...]`;
+      }
+
+      return { success: true, output: extractedText, charCount: extractedText.length };
+    } catch (e) {
+      return { success: false, error: `Failed to read PDF: ${e.message}` };
+    }
+  }
+};

package/src/tools/persistentShell.js

@@ -0,0 +1,148 @@
+import { spawn } from 'child_process';
+import os from 'os';
+import path from 'path';
+
+// Singleton map of active persistent shell sessions
+const sessions = new Map();
+
+export function cleanupPersistentShells() {
+  for (const [id, session] of sessions.entries()) {
+    try {
+      session.process.kill('SIGTERM');
+    } catch (e) {}
+  }
+  sessions.clear();
+}
+
+// Ensure cleanup on process exit
+process.on('exit', cleanupPersistentShells);
+process.on('SIGINT', () => { cleanupPersistentShells(); process.exit(); });
+process.on('SIGTERM', () => { cleanupPersistentShells(); process.exit(); });
+
+export const persistentShell = {
+  schema: {
+    name: 'terminal.persistent_shell',
+    description: 'Executes shell commands in a stateful, persistent REPL session where working directory (cd), virtual environment activation, and environment variables persist across sequential calls. Surpasses stateless execution.',
+    parameters: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'Shell command line string to execute inside the persistent session.' },
+        sessionId: { type: 'string', description: 'Unique identifier for the shell session. Defaults to "default".' },
+        reset: { type: 'boolean', description: 'Set to true to kill the existing session and spawn a fresh terminal shell.' },
+        timeoutMs: { type: 'integer', description: 'Maximum execution time in milliseconds before timing out. Defaults to 30000.' }
+      },
+      required: ['command']
+    }
+  },
+
+  async execute(args, context = {}) {
+    try {
+      const command = args.command;
+      if (!command) return { success: false, error: 'Command parameter is required.' };
+
+      const sessionId = args.sessionId || 'default';
+      const reset = args.reset === true;
+      const timeoutMs = args.timeoutMs || 30000;
+
+      if (reset && sessions.has(sessionId)) {
+        try { sessions.get(sessionId).process.kill('SIGTERM'); } catch (e) {}
+        sessions.delete(sessionId);
+      }
+
+      let session = sessions.get(sessionId);
+      if (!session) {
+        const isWin = process.platform === 'win32';
+        const shellBin = isWin ? 'powershell.exe' : (process.env.SHELL || '/bin/zsh');
+        const shellArgs = isWin ? ['-NoLogo', '-NoExit', '-Command', '-'] : ['-l'];
+
+        const proc = spawn(shellBin, shellArgs, {
+          cwd: process.cwd(),
+          env: { ...process.env, CAUSYNE_PERSISTENT_SHELL: '1', PS1: '' },
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        proc.on('error', (err) => {
+          sessions.delete(sessionId);
+        });
+
+        proc.on('exit', () => {
+          sessions.delete(sessionId);
+        });
+
+        session = {
+          process: proc,
+          currentCwd: process.cwd()
+        };
+        sessions.set(sessionId, session);
+      }
+
+      return new Promise((resolve) => {
+        const markerToken = `__CAUSYNE_PTY_DONE_${Date.now()}_${Math.random().toString(36).substr(2, 6)}__`;
+        let outputBuffer = '';
+        let errorBuffer = '';
+        let isDone = false;
+
+        const onData = (data) => {
+          const str = data.toString('utf8');
+          outputBuffer += str;
+          if (outputBuffer.includes(markerToken)) {
+            finish();
+          }
+        };
+
+        const onErrorData = (data) => {
+          errorBuffer += data.toString('utf8');
+        };
+
+        const timer = setTimeout(() => {
+          if (!isDone) {
+            isDone = true;
+            cleanupListeners();
+            resolve({
+              success: false,
+              error: `Command timed out after ${timeoutMs}ms. Output captured so far:\n${outputBuffer}\n${errorBuffer}`
+            });
+          }
+        }, timeoutMs);
+
+        const cleanupListeners = () => {
+          session.process.stdout.removeListener('data', onData);
+          session.process.stderr.removeListener('data', onErrorData);
+          clearTimeout(timer);
+        };
+
+        const finish = () => {
+          if (isDone) return;
+          isDone = true;
+          cleanupListeners();
+
+          // Clean marker token from output buffer
+          const markerIndex = outputBuffer.indexOf(markerToken);
+          let cleanOutput = markerIndex !== -1 ? outputBuffer.substring(0, markerIndex) : outputBuffer;
+          cleanOutput = cleanOutput.replace(new RegExp(`echo\\s+"?${markerToken}"?`, 'g'), '').trim();
+
+          // Try to query current cwd asynchronously for status info
+          resolve({
+            success: true,
+            output: JSON.stringify({
+              sessionId: sessionId,
+              status: 'Executed cleanly in stateful session',
+              stdout: cleanOutput || (errorBuffer ? '' : '[No output]'),
+              stderr: errorBuffer.trim() || undefined
+            }, null, 2)
+          });
+        };
+
+        session.process.stdout.on('data', onData);
+        session.process.stderr.on('data', onErrorData);
+
+        // Send command followed by echo marker
+        const isWin = process.platform === 'win32';
+        const markerCmd = isWin ? `echo "${markerToken}"` : `echo "${markerToken}"`;
+        session.process.stdin.write(`${command}\n${markerCmd}\n`);
+      });
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};