@causyne/agent 0.0.0-stage → 1.10.0

package/src/tools/registry.js

@@ -0,0 +1,277 @@
+import { sysRun, sysRunBg } from './sysRun.js';
+import { fsRead } from './fsRead.js';
+import { fsWrite } from './fsWrite.js';
+import { fsEdit } from './fsEdit.js';
+import { fsSearch } from './fsSearch.js';
+import { fsFind } from './fsFind.js';
+import { fsList } from './fsList.js';
+import { fsMove } from './fsMove.js';
+import { fsDelete } from './fsDelete.js';
+import { gitExec } from './gitExec.js';
+import { processList } from './processList.js';
+import { procTerm } from './procTerm.js';
+import { webFetch } from './webFetch.js';
+import { desktopOpen } from './desktopOpen.js';
+import { todoWrite } from './todoWrite.js';
+import { multiEdit } from './multiEdit.js';
+import { codebaseSearch } from './codebaseSearch.js';
+import { browserAct } from './browserAutomator.js';
+import { blenderAct } from './blenderAutomator.js';
+import { resolveAutomator } from './resolveAutomator.js';
+import { palmierAutomator } from './palmierAutomator.js';
+import { viewImage } from './viewImage.js';
+import { webSearch } from './webSearch.js';
+import { updatePlan } from './updatePlan.js';
+import { clipboard } from './clipboard.js';
+import { screenshot } from './screenshot.js';
+import { axSnapshot } from './axSnapshot.js';
+import { desktopAct } from './desktopAct.js';
+import { archive } from './archive.js';
+import { checkSystemSpecs } from './checkSystemSpecs.js';
+import { executeProceduralMedia } from './executeProceduralMedia.js';
+import { manageLocalAiDependencies } from './manageLocalAiDependencies.js';
+import { generateMediaViaApi } from './generateMediaViaApi.js';
+import { memoryWrite } from './memoryWrite.js';
+import { printerPrint, printerList, printerStatus } from './printer.js';
+import { toolForgeTool } from './toolForge.js';
+import { astryxOracle } from './astryxOracle.js';
+import { pdfRead } from './pdfReader.js';
+import { codeVerifySyntax, codeListSymbols } from './codeTools.js';
+import { codeSearcher } from './codeSearcher.js';
+import { codeSearchAst } from './codeSearchAst.js';
+import { persistentShell } from './persistentShell.js';
+import { subagentOrchestrator } from './subagentOrchestrator.js';
+import { deferredMcpSearch } from './deferredMcpSearch.js';
+import { visionInspector } from './visionInspector.js';
+import { godotAutomator } from './godotAutomator.js';
+import { gameBuilder } from './gameBuilder.js';
+import { gameAssetFetcher } from './gameAssetFetcher.js';
+import { gameLoreForge } from './gameLoreForge.js';
+import { gameDialogueTreeGen } from './gameDialogueTreeGen.js';
+import { gameQuestArcBuilder } from './gameQuestArcBuilder.js';
+import { gameAnimationRig } from './gameAnimationRig.js';
+import { gameAiBehaviorTree } from './gameAiBehaviorTree.js';
+import { gameCinematicSequencer } from './gameCinematicSequencer.js';
+import { gameAssetHarvester } from './gameAssetHarvester.js';
+import { gameAudioSynth } from './gameAudioSynth.js';
+import { gameVfxEmitterGen } from './gameVfxEmitterGen.js';
+import { gameShaderForge } from './gameShaderForge.js';
+import { gameSceneBuilder } from './gameSceneBuilder.js';
+import { gameEntitySpawner } from './gameEntitySpawner.js';
+import { gameTilemapGenerator } from './gameTilemapGenerator.js';
+import { gameUiHudBuilder } from './gameUiHudBuilder.js';
+import { gameEconomyBalancer } from './gameEconomyBalancer.js';
+import { gameDataForge } from './gameDataForge.js';
+import { gameWebRuntimeInspector } from './gameWebRuntimeInspector.js';
+import { gameCanvasAudit } from './gameCanvasAudit.js';
+import readNativeSkill from './readNativeSkill.js';
+import { createSkill } from './createSkill.js';
+import { resolveActiveTools } from '../toolPacks.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { discoverTools, resolveMcpTool, isMcpToolName } from '../mcp/mcpRegistry.js';
+import { causyneHome } from '../utils/paths.js';
+
+// Phase 6 AGI Upgrade: Schema Validation Hook
+function validateSchema(schema) {
+  if (!schema || !schema.name || !schema.description) {
+    console.error(`[REGISTRY WARNING] Tool schema missing required name or description:`, schema);
+    return false;
+  }
+  return true;
+}
+
+/**
+ * The one place a tool name is canonicalised. Schemas are authored with dots
+ * (`fs.read`) because that reads well; every provider's function-name grammar
+ * only allows [a-zA-Z0-9_-], so the wire name is always the underscored form.
+ *
+ * Every lookup — the agent loop, the sandbox, the pack resolver — must go
+ * through this, or the two namespaces drift apart again.
+ */
+// MCP is imported lazily-safe: this module is on the hot path of every LLM
+// call, and mcpRegistry only touches config until a server is actually granted.
+export function normalizeToolName(name) {
+  return String(name || '').replace(/\./g, '_');
+}
+
+// SINGLE SOURCE OF TRUTH.
+//
+// TOOL_DEFINITIONS (what the model is told exists) and toolRegistry (what can
+// actually run) are both derived from this one list, so a tool can never be
+// advertised without being executable. The previous design kept a separate
+// hand-written registry map, and four tools had silently drifted out of it:
+// fs_find (a CORE tool, in context on every task), proc_term, palmier_act and
+// code_search_ast. Every model on every provider got "Tool does not exist".
+const TOOL_MODULES = [
+  sysRun, sysRunBg, fsRead, fsWrite,
+  fsEdit, fsFind, fsSearch, fsList, fsMove,
+  fsDelete, gitExec, processList, procTerm,
+  webFetch, desktopOpen, todoWrite, multiEdit,
+  codebaseSearch, browserAct, viewImage, webSearch,
+  updatePlan, clipboard, screenshot, axSnapshot, desktopAct, archive,
+  checkSystemSpecs, executeProceduralMedia, manageLocalAiDependencies,
+  generateMediaViaApi, memoryWrite, printerPrint, printerList, printerStatus, toolForgeTool,
+  astryxOracle, pdfRead, codeVerifySyntax, codeListSymbols, blenderAct, resolveAutomator, palmierAutomator,
+  codeSearchAst, codeSearcher, persistentShell, subagentOrchestrator, deferredMcpSearch, visionInspector,
+  godotAutomator, gameBuilder, gameAssetFetcher,
+  gameLoreForge, gameDialogueTreeGen, gameQuestArcBuilder,
+  gameAnimationRig, gameAiBehaviorTree, gameCinematicSequencer,
+  gameAssetHarvester, gameAudioSynth, gameVfxEmitterGen,
+  gameShaderForge, gameSceneBuilder, gameEntitySpawner,
+  gameTilemapGenerator, gameUiHudBuilder, gameEconomyBalancer,
+  gameDataForge, gameWebRuntimeInspector, gameCanvasAudit, readNativeSkill, createSkill
+];
+
+// Base static definitions (backwards compatible). Order is preserved from the
+// list above because every provider's prompt cache binds on the tool array, and
+// reshuffling it invalidates the cached prefix mid-task.
+export const TOOL_DEFINITIONS = [];
+export const toolRegistry = {};
+
+for (const module of TOOL_MODULES) {
+  if (!module || !validateSchema(module.schema)) continue;
+
+  const name = normalizeToolName(module.schema.name);
+  if (typeof module.execute !== 'function') {
+    console.error(`[REGISTRY WARNING] Tool "${name}" has no execute() and cannot run — skipping.`);
+    continue;
+  }
+
+  TOOL_DEFINITIONS.push({ ...module.schema, name });
+  toolRegistry[name] = module;
+}
+
+// Names that older releases (and any chat history persisted under them) used for
+// a tool whose canonical schema name is different. Resolved only at execution
+// time — never advertised, so they cost no context.
+const TOOL_ALIASES = {
+  manage_local_ai_dependencies: 'manage_local_dependencies',
+  procTerm: 'proc_term',
+  gitExec: 'gitOp',
+  // Renamed once a real MCP client existed: this tool searches Causyne's own
+  // registry and never spoke the protocol its old name advertised. The alias
+  // stays so a model that learned the old name still resolves.
+  tool_deferred_mcp_search: 'tool_search'
+};
+
+/** Resolve a name the model produced to a runnable tool, following aliases. */
+export function resolveTool(name) {
+  const normalized = normalizeToolName(name);
+  const native = toolRegistry[normalized] || toolRegistry[TOOL_ALIASES[normalized]] || null;
+  if (native) return native;
+  // MCP tools are namespaced `mcp__server__tool`, so they can never shadow a
+  // native name — the native lookup always wins above.
+  if (isMcpToolName(name)) return resolveMcpTool(name);
+  return null;
+}
+
+/** The canonical catalogue name for anything the model might call it. */
+export function canonicalToolName(name) {
+  const normalized = normalizeToolName(name);
+  if (toolRegistry[normalized]) return normalized;
+  return TOOL_ALIASES[normalized] || normalized;
+}
+
+// Forged tools are hot-reloadable, but re-importing them with a cache-busting
+// query string on every single agent step leaked one ES module per step and
+// changed the tool ordering between requests, which silently defeats OpenAI and
+// DeepSeek automatic prompt caching. We reload only when a file actually
+// changes, keyed on path + mtime.
+const forgedModuleCache = new Map();
+
+async function loadForgedTools() {
+  const CUSTOM_TOOLS_DIR = path.join(causyneHome(), 'custom_tools');
+  if (!fs.existsSync(CUSTOM_TOOLS_DIR)) return [];
+
+  const forged = [];
+  // Sorted so the resulting schema order is identical across requests.
+  const files = fs.readdirSync(CUSTOM_TOOLS_DIR).filter(f => f.endsWith('.js')).sort();
+
+  for (const file of files) {
+    const fullPath = path.join(CUSTOM_TOOLS_DIR, file);
+    try {
+      const mtime = fs.statSync(fullPath).mtimeMs;
+      const cached = forgedModuleCache.get(fullPath);
+      let imported;
+
+      if (cached && cached.mtime === mtime) {
+        imported = cached.module;
+      } else {
+        imported = await import(`file://${fullPath}?v=${mtime}`);
+        forgedModuleCache.set(fullPath, { mtime, module: imported });
+      }
+
+      for (const key of Object.keys(imported)) {
+        if (imported[key] && imported[key].schema) {
+          const normalizedName = imported[key].schema.name.replace(/\./g, '_');
+          forged.push({ ...imported[key].schema, name: normalizedName });
+          if (!toolRegistry[normalizedName]) {
+            toolRegistry[normalizedName] = imported[key];
+          }
+        }
+      }
+    } catch (e) {
+      console.error(`[TOOL FORGE] Failed to load custom tool ${file}:`, e.message);
+    }
+  }
+
+  return forged;
+}
+
+// Phase 6 AGI Upgrade & V5 Cortex: Dynamic Tool Culling and Hot-Reloading Engine
+//
+// options.unlockedPacks / options.unlockedTools drive Sovereign Progressive
+// Disclosure (see src/toolPacks.js). No tool is ever removed from the catalogue
+// — deferred schemas simply stay out of the context window until the agent
+// pre-warms or searches for them. options.grantAllTools restores the legacy
+// behaviour of loading all 69 schemas up front.
+export async function getDynamicTools(autonomyMode = 'C', supportsVision = true, options = {}) {
+  const forged = await loadForgedTools();
+  // Tools from user-configured MCP servers, appended last so the native
+  // schema order — which the provider prompt caches depend on — never shifts.
+  let mcp = [];
+  try {
+    mcp = await discoverTools();
+  } catch (e) { /* a broken third-party server must not take the catalogue down */ }
+  let tools = [...TOOL_DEFINITIONS, ...forged, ...mcp];
+
+  if (!options.grantAllTools) {
+    tools = resolveActiveTools(tools, options.unlockedPacks, options.unlockedTools, options.unlockOrder, {
+      residentOnly: options.residentOnly === true
+    });
+  }
+
+  // Vision Toggle Culling
+  if (!supportsVision) {
+    // Phase 6 Fix: Do not hide view_image. Allow it to serve as a Text-Only OCR Fallback for blind LLMs.
+    tools = tools.filter(t => t.name !== 'screenshot' && t.name !== 'vision_inspect_ui');
+  }
+
+  // Capability Culling (finding D-6).
+  //
+  // A tool the user has explicitly DECLINED can never run, so showing its
+  // schema only invites the model to spend a step discovering that. A tool that
+  // is merely un-granted stays visible: calling it is how the model learns to
+  // ask for the capability, which is the intended flow.
+  try {
+    const { declinedToolNames } = await import('../provisioning/capabilityTools.js');
+    const declined = declinedToolNames();
+    if (declined.size > 0) tools = tools.filter(t => !declined.has(t.name));
+  } catch (e) { /* provisioning unavailable: show everything rather than hide capability */ }
+
+  // Autonomy Mode Culling (Save tokens and prevent hallucinations on Mode A).
+  // Names here are canonical catalogue names — the legacy dotted/camelCase
+  // variants that used to pad these sets never matched a schema name and so
+  // culled nothing.
+  if (autonomyMode === 'A') {
+    const dangerousTools = new Set(['proc_term', 'gitOp', 'fs_delete', 'sysRun', 'sysRunBg', 'terminal_persistent_shell', 'manage_local_dependencies']);
+    tools = tools.filter(t => !dangerousTools.has(t.name));
+  } else if (autonomyMode === 'B') {
+    const dangerousTools = new Set(['proc_term', 'manage_local_dependencies']);
+    tools = tools.filter(t => !dangerousTools.has(t.name));
+  }
+
+  return tools;
+}

package/src/tools/resolveAutomator.js

@@ -0,0 +1,102 @@
+import { readFileSync } from 'node:fs';
+import os from 'os';
+import { spawn } from 'child_process';
+
+
+const MAC_RESOLVE_API = "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting";
+const MAC_RESOLVE_LIB = "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so";
+
+
+const PYTHON_SCRIPT = readFileSync(new URL('../tool-scripts/resolve_automator.py', import.meta.url), 'utf8');
+
+export const resolveAutomator = {
+  schema: {
+    name: 'resolve.act',
+    description: 'Automate DaVinci Resolve Studio for native Cinema Workflows. Requires Resolve to be running with External Scripting: Local enabled.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: { 
+          type: 'string', 
+          enum: ['checkConnection', 'setupColorManagement', 'importAndAssemble'] 
+        },
+        mediaPath: { 
+          type: 'string', 
+          description: 'Absolute path to media directory to import' 
+        },
+        color_space_mode: {
+          type: 'string',
+          enum: ['automatic', 'custom'],
+          description: 'Use automatic (Resolve auto-detects based on metadata) or custom.'
+        },
+        fps: { 
+          type: 'string', 
+          description: 'Timeline framerate (e.g. 23.976) or "auto" to detect from clip metadata' 
+        },
+        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: "Currently, only macOS is fully supported for this Resolve script pipeline." };
+    }
+
+    const payload = JSON.stringify(args);
+
+    return new Promise((resolvePromise) => {
+      const env = {
+        ...process.env,
+        RESOLVE_SCRIPT_API: MAC_RESOLVE_API,
+        RESOLVE_SCRIPT_LIB: MAC_RESOLVE_LIB,
+        PYTHONPATH: `${process.env.PYTHONPATH || ''}:${MAC_RESOLVE_API}/Modules/`
+      };
+
+      
+      const pyBin = "python3";
+
+      
+      const child = spawn(pyBin, ['-', payload], { env });
+
+      let outputData = '';
+      let errorData = '';
+
+      child.stdout.on('data', (data) => {
+        outputData += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        errorData += data.toString();
+      });
+
+      child.on('close', (code) => {
+        if (outputData.trim()) {
+          try {
+            const lines = outputData.trim().split('\n');
+            const jsonLine = lines.find(l => l.trim().startsWith('{') && l.trim().endsWith('}'));
+            if (jsonLine) {
+              resolvePromise(JSON.parse(jsonLine));
+              return;
+            }
+          } catch (e) {}
+        }
+        resolvePromise({
+          success: false,
+          error: errorData.trim() || outputData.trim() || `Python process exited with code ${code}`
+        });
+      });
+
+      const decodedScript = PYTHON_SCRIPT;
+      child.stdin.write(decodedScript);
+      child.stdin.end();
+    });
+  }
+};

package/src/tools/screenshot.js

@@ -0,0 +1,75 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { ensureCapability, loadCapabilityPackage } from '../provisioning/capabilityProvisioner.js';
+
+export const screenshot = {
+  schema: {
+    name: 'screenshot',
+    description: 'Visual Spatial Coordinator. Captures the screen and uses OCR to extract Bounding Box (X,Y) coordinates of UI elements, allowing AGI to "see" the OS.',
+    parameters: {
+      type: 'object',
+      properties: {
+        analyzeText: { type: 'boolean', description: 'If true, runs OCR to map text coordinates.' }
+      }
+    }
+  },
+  async execute(args) {
+    try {
+      const vision = await ensureCapability('vision');
+      if (!vision.ok) return { success: false, error: vision.reason, requiresConsent: vision.requiresConsent };
+      const screenshotDesktop = await loadCapabilityPackage('screenshot-desktop');
+
+      const tempDir = path.join(os.tmpdir(), 'causyne_vision');
+      await fs.mkdir(tempDir, { recursive: true });
+      const dest = path.join(tempDir, `vision_${Date.now()}.png`);
+
+      // Phase 5 AGI Upgrade: Cross-Platform Native Capture
+      await screenshotDesktop({ filename: dest });
+
+      if (!args.analyzeText) {
+        return { success: true, output: `Screenshot saved to ${dest}` };
+      }
+
+      // Phase 5 AGI Upgrade: OCR Bounding Box Integration
+      const ocr = await ensureCapability('ocr');
+      if (!ocr.ok) {
+        await fs.unlink(dest);
+        return { success: false, error: ocr.reason, requiresConsent: ocr.requiresConsent };
+      }
+      const Tesseract = await loadCapabilityPackage('tesseract.js');
+
+      // Tesseract runs in its own Worker thread automatically
+      const worker = await Tesseract.createWorker('eng');
+      const { data: { words } } = await worker.recognize(dest);
+      await worker.terminate();
+      
+      // Delete temporary image to protect privacy
+      await fs.unlink(dest);
+
+      if (!words || words.length === 0) {
+        return { success: true, output: "Screenshot taken, but no readable text found on screen." };
+      }
+
+      let markdownMap = `👁️ OS Visual Spatial Map:\n\n`;
+      // We'll return the top 50 most confident words to prevent context overload
+      const confidentWords = words.filter(w => w.confidence > 75).slice(0, 50);
+      
+      for (const w of confidentWords) {
+        const { x0, y0, x1, y1 } = w.bbox;
+        const centerX = Math.floor((x0 + x1) / 2);
+        const centerY = Math.floor((y0 + y1) / 2);
+        markdownMap += `- Text: "${w.text}" | Center Coordinates: X:${centerX}, Y:${centerY} | Confidence: ${w.confidence.toFixed(1)}%\n`;
+      }
+      
+      if (words.length > 50) {
+        markdownMap += `\n[... Truncated ${words.length - 50} elements to protect AGI Context ...]`;
+      }
+
+      return { success: true, output: markdownMap };
+
+    } catch (e) {
+      return { success: false, error: `Vision Error: ${e.message}` };
+    }
+  }
+};