@hamp10/agentforge 0.1.0

package/src/HampAgentCLI.js

@@ -0,0 +1,125 @@
+/**
+ * HampAgentCLI — drop-in replacement for OpenClawCLI.
+ * Uses claude CLI subprocess with stream-json — works with Claude Max plan, no API key needed.
+ * Emits identical events (agent_output, tool_activity, agent_image, agent_alive, agent_completed)
+ * so worker.js can route tasks to either runner transparently.
+ */
+
+import { EventEmitter } from 'events';
+import { execSync } from 'child_process';
+import { HampAgentRunner } from './hampagent/runner.js';
+import { loadSessionId, saveSessionId, clearSession } from './hampagent/sessions.js';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+
+/** Check that the claude CLI is available */
+function claudeAvailable() {
+  try { execSync('which claude', { stdio: 'pipe' }); return true; } catch { return false; }
+}
+
+export class HampAgentCLI extends EventEmitter {
+  constructor() {
+    super();
+    this.anthropicApiKey = null; // kept for API compat, not used
+    this._runners = new Map(); // agentId -> HampAgentRunner (active tasks only)
+  }
+
+  setAnthropicKey(key) { this.anthropicApiKey = key; }
+
+  async createAgent(agentId, workDir) {
+    return { agentId, workDir };
+  }
+
+  async getAgentIdentity(agentId) {
+    return null;
+  }
+
+  cancelAgent(agentId) {
+    const runner = this._runners.get(agentId);
+    if (runner) { runner.cancel(); this._runners.delete(agentId); return true; }
+    return false;
+  }
+
+  isAvailable() { return claudeAvailable(); }
+
+  async runAgentTask(agentId, task, workDir, sessionId = null, image = null, browserProfile = null, imageWorkDir = null) {
+    if (!claudeAvailable()) throw new Error('Hampagent: claude CLI not found — install Claude Code first');
+
+    // Load prior claude session ID for conversation continuity
+    const claudeSessionId = loadSessionId(agentId);
+
+    // Load AGENTFORGE.md if available in the agent workspace
+    let agentforgemd = null;
+    const afPath = path.join(workDir, 'AGENTFORGE.md');
+    if (existsSync(afPath)) {
+      try { agentforgemd = readFileSync(afPath, 'utf8'); } catch {}
+    }
+
+    const runner = new HampAgentRunner();
+    runner._agentId = agentId;
+    this._runners.set(agentId, runner);
+
+    // ── Forward runner events to worker.js as standard events ──────────────
+
+    runner.on('token', (text) => {
+      this.emit('agent_output', { agentId, output: text });
+      this.emit('agent_alive', { agentId });
+    });
+
+    runner.on('tool_start', ({ tool, label, input }) => {
+      this.emit('agent_alive', { agentId });
+      this.emit('tool_activity', {
+        agentId,
+        event: 'tool_start',
+        tool,
+        description: label,
+        toolInput: input,
+      });
+    });
+
+    runner.on('tool_end', ({ tool, success, error }) => {
+      this.emit('tool_activity', {
+        agentId,
+        event: 'tool_end',
+        tool,
+        description: success ? `✓ ${tool}` : `✗ ${tool}: ${error}`,
+      });
+    });
+
+    runner.on('image', (base64DataUrl) => {
+      this.emit('agent_image', { agentId, image: base64DataUrl });
+    });
+
+    const startTime = Date.now();
+
+    try {
+      const result = await runner.run(task, {
+        taskCwd: workDir,
+        workDir: imageWorkDir || workDir,
+        agentName: this._agentName,
+        agentEmoji: this._agentEmoji,
+        dashboardUrl: 'https://agentforgeai-production.up.railway.app/dashboard',
+        agentforgemd,
+        resumeSessionId: claudeSessionId,
+      });
+
+      // Save new claude session ID for next turn (or clear if session was stale)
+      if (result.sessionCleared) clearSession(agentId);
+      if (result.sessionId) saveSessionId(agentId, result.sessionId);
+
+      this._runners.delete(agentId);
+
+      const identity = {
+        identityName: this._agentName || agentId,
+        identityEmoji: this._agentEmoji || '🦅',
+      };
+      const duration = Date.now() - startTime;
+      this.emit('agent_completed', { agentId, duration, result: { output: result.text }, identity });
+      return { success: true, agentId, duration, result: { output: result.text }, identity };
+
+    } catch (err) {
+      this._runners.delete(agentId);
+      throw err;
+    }
+  }
+}

package/src/OllamaAgent.js

@@ -0,0 +1,415 @@
+import { exec } from 'child_process';
+import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { EventEmitter } from 'events';
+import path from 'path';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+
+const execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const TOOLS = [
+  {
+    type: 'function',
+    function: {
+      name: 'bash',
+      description: 'Execute a shell command in the working directory. Returns stdout and stderr.',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'The shell command to run' }
+        },
+        required: ['command']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'read_file',
+      description: 'Read the full contents of a file.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Path to the file (absolute or relative to workdir)' }
+        },
+        required: ['path']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'write_file',
+      description: 'Write content to a file, creating it and any missing parent directories.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Path to write (absolute or relative to workdir)' },
+          content: { type: 'string', description: 'File content to write' }
+        },
+        required: ['path', 'content']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'list_directory',
+      description: 'List files and subdirectories at a path.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Directory path (absolute or relative to workdir)' }
+        },
+        required: ['path']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'web_fetch',
+      description: 'Fetch the text content of a URL (first 4000 chars).',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'URL to fetch' }
+        },
+        required: ['url']
+      }
+    }
+  }
+];
+
+/**
+ * LocalModelAgent — drop-in replacement for OpenClawCLI.
+ * Runs an agentic tool-use loop against ANY OpenAI-compatible local model server.
+ *
+ * Compatible providers (use their OpenAI-compat endpoint):
+ *   Ollama:     http://localhost:11434  (served at /v1/chat/completions)
+ *   LM Studio:  http://localhost:1234
+ *   Jan.ai:     http://localhost:1337
+ *   llama.cpp:  http://localhost:8080
+ *   vLLM:       http://localhost:8000
+ *   Any other OpenAI-compatible server
+ *
+ * Exported as OllamaAgent for backward compat.
+ */
+export class OllamaAgent extends EventEmitter {
+  constructor(baseUrl = 'http://localhost:11434', model = 'llama3.1:8b') {
+    super();
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.model = model;
+    this.activeAgents = new Map(); // agentId -> { startTime, task, workDir, abort, proc: null }
+  }
+
+  // ─── Public interface (mirrors OpenClawCLI) ───────────────────────────────
+
+  async createAgent(agentId, workDir) {
+    mkdirSync(workDir, { recursive: true });
+
+    // Copy AgentForge template files same as OpenClawCLI does
+    const bundledTemplateDir = path.join(__dirname, '../../templates/agent');
+    const templateDir = existsSync(bundledTemplateDir) ? bundledTemplateDir : '/tmp/agentforge/templates/agent';
+
+    try {
+      if (existsSync(templateDir)) {
+        for (const fname of ['MEMORY.md', 'AGENTS.md', 'AGENTFORGE.md']) {
+          const src = path.join(templateDir, fname);
+          const dst = path.join(workDir, fname);
+          if (existsSync(src) && !existsSync(dst)) {
+            writeFileSync(dst, readFileSync(src));
+            console.log(`📁 [Ollama] Added ${fname}`);
+          }
+        }
+        const memDir = path.join(workDir, 'memory');
+        if (!existsSync(memDir)) mkdirSync(memDir, { recursive: true });
+      }
+    } catch (err) {
+      console.warn(`⚠️  [Ollama] Template setup failed: ${err.message}`);
+    }
+
+    console.log(`✓ [Ollama] Agent workspace ready: ${agentId}`);
+    return { agentId, workDir };
+  }
+
+  async runAgentTask(agentId, task, workDir, sessionId = null, image = null) {
+    const startTime = Date.now();
+    const controller = new AbortController();
+
+    // Fake proc-like object so worker.js pid checks don't crash
+    const fakeProc = { pid: null };
+    this.activeAgents.set(agentId, { startTime, task, workDir, abort: () => controller.abort(), proc: fakeProc });
+
+    console.log(`\n🦙 [Ollama/${this.model}] Running agent: ${agentId}`);
+    console.log(`   Task: ${task}`);
+    console.log(`   Working dir: ${workDir}`);
+
+    try {
+      // Load conversation history from disk (session persistence)
+      const history = this._loadHistory(agentId, workDir, sessionId);
+
+      const messages = [
+        {
+          role: 'system',
+          content: [
+            `You are an AI agent running on AgentForge.ai.`,
+            `Your working directory is: ${workDir}`,
+            `Use the available tools to complete the task autonomously.`,
+            `When you are done, write a clear summary of what you accomplished.`,
+            `Do not ask for clarification — make your best judgment and act.`
+          ].join('\n')
+        },
+        ...history,
+        { role: 'user', content: task }
+      ];
+
+      let finalContent = '';
+      const MAX_TURNS = 25;
+
+      for (let turn = 0; turn < MAX_TURNS; turn++) {
+        if (controller.signal.aborted) break;
+
+        this.emit('tool_activity', { agentId, event: 'api_call_start', description: `🦙 Calling ${this.model}...` });
+
+        let response;
+        try {
+          // OpenAI-compatible endpoint — works with Ollama, LM Studio, Jan, llama.cpp, vLLM, etc.
+          response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            signal: controller.signal,
+            body: JSON.stringify({
+              model: this.model,
+              messages,
+              tools: TOOLS,
+              tool_choice: 'auto',
+              stream: false
+            })
+          });
+        } catch (fetchErr) {
+          if (fetchErr.name === 'AbortError') break;
+          throw new Error(`Cannot reach local model server at ${this.baseUrl}. Is it running? (${fetchErr.message})`);
+        }
+
+        if (!response.ok) {
+          const body = await response.text().catch(() => '');
+          throw new Error(`Local model error ${response.status}: ${body}`);
+        }
+
+        const data = await response.json();
+        // OpenAI-compat wraps in choices[0].message; Ollama native uses data.message
+        const message = data.choices?.[0]?.message ?? data.message;
+
+        this.emit('tool_activity', {
+          agentId,
+          event: 'api_call_end',
+          description: `✅ Ollama responded`
+        });
+
+        messages.push(message);
+
+        // ── Handle tool calls ──
+        if (message.tool_calls && message.tool_calls.length > 0) {
+          for (const toolCall of message.tool_calls) {
+            if (controller.signal.aborted) break;
+
+            const { name, arguments: args } = toolCall.function;
+            const parsedArgs = typeof args === 'string' ? JSON.parse(args) : args;
+
+            this.emit('tool_activity', {
+              agentId,
+              event: 'tool_start',
+              tool: name,
+              description: this._toolDesc(name, parsedArgs)
+            });
+
+            console.log(`   [${agentId}] 🔧 ${name}: ${JSON.stringify(parsedArgs).slice(0, 120)}`);
+
+            const result = await this._executeTool(name, parsedArgs, workDir);
+
+            this.emit('tool_activity', {
+              agentId,
+              event: 'tool_end',
+              tool: name,
+              description: `✓ ${name}`
+            });
+
+            messages.push({ role: 'tool', content: String(result) });
+          }
+          // Loop back — model will respond to the tool results
+          continue;
+        }
+
+        // ── No tool calls: this is the final answer ──
+        if (message.content) {
+          finalContent = message.content;
+          // Stream the response in chunks so the UI feels live
+          const words = message.content.split(' ');
+          const CHUNK_SIZE = 8;
+          for (let i = 0; i < words.length; i += CHUNK_SIZE) {
+            if (controller.signal.aborted) break;
+            const chunk = words.slice(i, i + CHUNK_SIZE).join(' ') + (i + CHUNK_SIZE < words.length ? ' ' : '');
+            this.emit('agent_output', { agentId, output: chunk });
+          }
+        }
+        break;
+      }
+
+      // Persist history for next task
+      if (finalContent && sessionId) {
+        this._saveHistory(agentId, workDir, sessionId, [
+          ...history,
+          { role: 'user', content: task },
+          { role: 'assistant', content: finalContent }
+        ]);
+      }
+
+      const duration = Date.now() - startTime;
+      this.activeAgents.delete(agentId);
+
+      this.emit('agent_completed', {
+        agentId,
+        duration,
+        result: { output: finalContent },
+        identity: { identityName: agentId, identityEmoji: '🦙' }
+      });
+
+      console.log(`\n✅ [Ollama] Agent ${agentId} completed in ${(duration / 1000).toFixed(2)}s\n`);
+      return { success: true, agentId, duration };
+
+    } catch (err) {
+      this.activeAgents.delete(agentId);
+
+      if (err.name === 'AbortError' || controller.signal.aborted) {
+        this.emit('agent_cancelled', { agentId });
+        return { success: false, cancelled: true };
+      }
+
+      console.error(`\n❌ [Ollama] Agent ${agentId} failed: ${err.message}`);
+      this.emit('agent_failed', { agentId, error: err.message, code: 1 });
+      throw err;
+    }
+  }
+
+  cancelAgent(agentId) {
+    const info = this.activeAgents.get(agentId);
+    if (!info) return false;
+    info.abort?.();
+    this.activeAgents.delete(agentId);
+    this.emit('agent_cancelled', { agentId });
+    return true;
+  }
+
+  async listAgents() {
+    // Ollama agents don't have a registry — return empty
+    return [];
+  }
+
+  async getAgentIdentity(agentId) {
+    return { identityName: agentId, identityEmoji: '🦙' };
+  }
+
+  getActiveAgents() {
+    return Array.from(this.activeAgents.values());
+  }
+
+  // ─── Tool execution ───────────────────────────────────────────────────────
+
+  async _executeTool(name, args, workDir) {
+    try {
+      switch (name) {
+        case 'bash': {
+          const { stdout, stderr } = await execAsync(args.command, {
+            cwd: workDir,
+            timeout: 60000,
+            maxBuffer: 1024 * 1024 * 2 // 2MB
+          });
+          return (stdout + stderr).trim() || '(no output)';
+        }
+
+        case 'read_file': {
+          const fp = this._resolvePath(args.path, workDir);
+          return readFileSync(fp, 'utf-8');
+        }
+
+        case 'write_file': {
+          const fp = this._resolvePath(args.path, workDir);
+          mkdirSync(path.dirname(fp), { recursive: true });
+          writeFileSync(fp, args.content, 'utf-8');
+          return `Written ${args.content.length} bytes to ${fp}`;
+        }
+
+        case 'list_directory': {
+          const dp = this._resolvePath(args.path, workDir);
+          const entries = readdirSync(dp);
+          return entries.map(e => {
+            try {
+              return statSync(path.join(dp, e)).isDirectory() ? `${e}/` : e;
+            } catch { return e; }
+          }).join('\n') || '(empty)';
+        }
+
+        case 'web_fetch': {
+          const res = await fetch(args.url, { signal: AbortSignal.timeout(15000) });
+          const text = await res.text();
+          return text.slice(0, 4000) + (text.length > 4000 ? '\n...(truncated)' : '');
+        }
+
+        default:
+          return `Unknown tool: ${name}`;
+      }
+    } catch (err) {
+      return `Error executing ${name}: ${err.message}`;
+    }
+  }
+
+  _resolvePath(p, workDir) {
+    return path.isAbsolute(p) ? p : path.join(workDir, p);
+  }
+
+  _toolDesc(name, args) {
+    switch (name) {
+      case 'bash':
+        return args.command?.length > 60 ? args.command.slice(0, 60) + '…' : (args.command || 'bash');
+      case 'read_file':
+        return `Reading ${path.basename(args.path || '')}`;
+      case 'write_file':
+        return `Writing ${path.basename(args.path || '')}`;
+      case 'list_directory':
+        return `Listing ${args.path || '.'}`;
+      case 'web_fetch': {
+        try { return `Fetching ${new URL(args.url).hostname}`; } catch { return 'Fetching URL'; }
+      }
+      default:
+        return name;
+    }
+  }
+
+  // ─── History persistence ──────────────────────────────────────────────────
+
+  _historyPath(workDir, sessionId) {
+    return path.join(workDir, `.ollama_history_${sessionId}.json`);
+  }
+
+  _loadHistory(agentId, workDir, sessionId) {
+    if (!sessionId) return [];
+    try {
+      const fp = this._historyPath(workDir, sessionId);
+      if (existsSync(fp)) {
+        const data = JSON.parse(readFileSync(fp, 'utf-8'));
+        // Keep last 20 messages to stay within context
+        return data.slice(-20);
+      }
+    } catch {}
+    return [];
+  }
+
+  _saveHistory(agentId, workDir, sessionId, messages) {
+    try {
+      const fp = this._historyPath(workDir, sessionId);
+      writeFileSync(fp, JSON.stringify(messages.slice(-40), null, 2));
+    } catch {}
+  }
+}