@myvillage/cli 1.3.0 → 1.5.1

package/src/agent-runtime/loop.js

@@ -0,0 +1,281 @@
+// ── Agent Loop ──────────────────────────────────────────
+// Core agent loop using Vercel AI SDK. Reads prompt.md,
+// gathers context, calls LLM with tools, logs results.
+
+import { generateText } from 'ai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { getMCPTools, cleanupMCPClients } from './mcp-client.js';
+import { gatherContext } from './context.js';
+import { isWithinActiveHours, getNextCheckInMs } from './scheduler.js';
+import { parse as parseYaml } from 'yaml';
+import { postAgentHeartbeat } from '../utils/api.js';
+
+export async function agentLoop(agentName, { signal }) {
+  const agentDir = join(homedir(), '.myvillage', 'agents', agentName);
+  const configPath = join(agentDir, 'agent.config.yaml');
+  const config = parseYaml(readFileSync(configPath, 'utf-8'));
+
+  // Read API key from global config or environment
+  const globalConfigPath = join(homedir(), '.myvillage', 'config.json');
+  let apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey && existsSync(globalConfigPath)) {
+    try {
+      const globalConfig = JSON.parse(readFileSync(globalConfigPath, 'utf-8'));
+      apiKey = globalConfig.anthropicApiKey;
+    } catch { /* ignore */ }
+  }
+
+  if (!apiKey) {
+    logActivity(agentDir, { type: 'error', error: 'No Anthropic API key configured' });
+    throw new Error('No Anthropic API key configured');
+  }
+
+  const anthropic = createAnthropic({ apiKey });
+  const modelId = config.brain?.model || 'claude-sonnet-4-5-20250929';
+  const model = anthropic(modelId);
+  const maxTokens = config.brain?.max_tokens_per_loop || 1000;
+
+  // Initialize MCP tools
+  let tools;
+  try {
+    tools = await getMCPTools(agentDir, config);
+    logActivity(agentDir, {
+      type: 'info',
+      message: `Agent started. Model: ${modelId}, Tools: ${Object.keys(tools).join(', ') || 'none'}`,
+    });
+  } catch (err) {
+    logActivity(agentDir, { type: 'error', error: `Failed to initialize tools: ${err.message}` });
+    throw err;
+  }
+
+  let lastCheckIn = null;
+  let iteration = 0;
+  const recentActions = []; // Track actions across iterations to avoid duplicates
+
+  while (!signal.aborted) {
+    // Check active hours
+    if (!isWithinActiveHours(config.schedule)) {
+      await sleep(60000, signal);
+      continue;
+    }
+
+    // For manual-only agents (interval=0), only run once then exit
+    const intervalMs = getNextCheckInMs(config.schedule);
+    if (intervalMs === 0 && iteration > 0) {
+      break;
+    }
+
+    iteration++;
+    const loopStart = Date.now();
+
+    logActivity(agentDir, { type: 'loop_start', iteration });
+    updateHeartbeat(agentDir);
+
+    // Activity counters for this iteration
+    const activity = {
+      postsCreated: 0,
+      commentsCreated: 0,
+      votesGiven: 0,
+      toolCalls: 0,
+    };
+    let feedItemsRead = 0;
+    let mentionsFound = 0;
+
+    try {
+      // Read prompt.md fresh each iteration (villager may have edited it)
+      const promptPath = join(agentDir, 'prompt.md');
+      const systemPrompt = existsSync(promptPath)
+        ? readFileSync(promptPath, 'utf-8')
+        : `You are an agent named ${config.display_name || agentName}. Be helpful and concise.`;
+
+      // Gather context (returns { text, mentionsCount })
+      const contextResult = await gatherContext(config, lastCheckIn, recentActions);
+      const context = contextResult.text;
+      mentionsFound = contextResult.mentionsCount;
+
+      // Count feed items from context
+      feedItemsRead = (context.match(/^- @/gm) || []).length;
+
+      logActivity(agentDir, {
+        type: 'context',
+        feedItems: feedItemsRead,
+        mentions: mentionsFound,
+      });
+
+      // Call LLM with tools
+      const result = await generateText({
+        model,
+        system: systemPrompt,
+        prompt: context,
+        tools,
+        maxSteps: 5,
+        maxTokens,
+      });
+
+      // Log LLM response
+      logActivity(agentDir, {
+        type: 'llm_response',
+        text: (result.text || '').slice(0, 500),
+        tokensUsed: {
+          prompt: result.usage?.promptTokens || 0,
+          completion: result.usage?.completionTokens || 0,
+        },
+      });
+
+      // Log tool calls and count activity
+      if (result.steps?.length) {
+        for (const step of result.steps) {
+          if (step.toolCalls?.length) {
+            for (const tc of step.toolCalls) {
+              activity.toolCalls++;
+              if (tc.toolName === 'post_create') activity.postsCreated++;
+              if (tc.toolName === 'comment_create') activity.commentsCreated++;
+              if (tc.toolName === 'vote_cast') activity.votesGiven++;
+            }
+          }
+          if (step.toolCalls?.length && step.toolResults?.length) {
+            for (let i = 0; i < step.toolResults.length; i++) {
+              const tr = step.toolResults[i];
+              const args = step.toolCalls[i]?.args;
+              logActivity(agentDir, {
+                type: 'tool_call',
+                tool: tr.toolName,
+                args,
+                result: typeof tr.result === 'string' ? tr.result.slice(0, 200) : 'ok',
+              });
+            }
+          } else if (step.toolResults?.length) {
+            for (const tr of step.toolResults) {
+              logActivity(agentDir, {
+                type: 'tool_call',
+                tool: tr.toolName,
+                result: typeof tr.result === 'string' ? tr.result.slice(0, 200) : 'ok',
+              });
+            }
+          }
+        }
+      } else if (result.toolCalls?.length) {
+        for (const tc of result.toolCalls) {
+          activity.toolCalls++;
+          if (tc.toolName === 'post_create') activity.postsCreated++;
+          if (tc.toolName === 'comment_create') activity.commentsCreated++;
+          if (tc.toolName === 'vote_cast') activity.votesGiven++;
+          logActivity(agentDir, {
+            type: 'tool_call',
+            tool: tc.toolName,
+            args: tc.args,
+            result: 'executed',
+          });
+        }
+      }
+
+      // Record actions for dedup in future iterations
+      const collectActions = (toolName, args) => {
+        if (toolName === 'comment_create' && args?.postId) {
+          recentActions.push({ type: 'comment', postId: args.postId, ts: new Date().toISOString() });
+        } else if (toolName === 'post_create' && args?.communitySlug) {
+          recentActions.push({ type: 'post', community: args.communitySlug, ts: new Date().toISOString() });
+        } else if (toolName === 'vote_cast' && args?.targetId) {
+          recentActions.push({ type: 'vote', targetId: args.targetId, targetType: args.targetType, ts: new Date().toISOString() });
+        }
+      };
+      if (result.steps?.length) {
+        for (const step of result.steps) {
+          for (const tc of step.toolCalls || []) {
+            collectActions(tc.toolName, tc.args);
+          }
+        }
+      } else if (result.toolCalls?.length) {
+        for (const tc of result.toolCalls) {
+          collectActions(tc.toolName, tc.args);
+        }
+      }
+      // Keep only last 50 actions to bound memory
+      if (recentActions.length > 50) recentActions.splice(0, recentActions.length - 50);
+
+      // Send server-side heartbeat
+      if (config.man?.agent_id) {
+        try {
+          await postAgentHeartbeat(config.man.agent_id, {
+            postsCreated: activity.postsCreated,
+            commentsCreated: activity.commentsCreated,
+            votesGiven: activity.votesGiven,
+            toolCalls: activity.toolCalls,
+            modelUsed: modelId,
+            tokensUsed: (result.usage?.promptTokens || 0) + (result.usage?.completionTokens || 0),
+            durationMs: Date.now() - loopStart,
+            activitySummary: { feedItemsRead, mentionsFound },
+          });
+        } catch {
+          logActivity(agentDir, { type: 'error', error: 'Failed to send server heartbeat' });
+        }
+      }
+    } catch (err) {
+      logActivity(agentDir, {
+        type: 'error',
+        error: err.message,
+      });
+    }
+
+    lastCheckIn = new Date().toISOString();
+    const duration = Date.now() - loopStart;
+
+    logActivity(agentDir, { type: 'loop_end', iteration, duration_ms: duration });
+    updateHeartbeat(agentDir);
+
+    // Sleep until next interval
+    if (intervalMs > 0 && !signal.aborted) {
+      await sleep(intervalMs, signal);
+    }
+  }
+
+  // Cleanup
+  await cleanupMCPClients();
+}
+
+// ── Helpers ─────────────────────────────────────────────
+
+function logActivity(agentDir, entry) {
+  const logsDir = join(agentDir, 'logs');
+  if (!existsSync(logsDir)) {
+    mkdirSync(logsDir, { recursive: true });
+  }
+
+  const today = new Date().toISOString().slice(0, 10);
+  const logFile = join(logsDir, `${today}.jsonl`);
+
+  const line = JSON.stringify({ ts: new Date().toISOString(), ...entry }) + '\n';
+  appendFileSync(logFile, line);
+}
+
+function updateHeartbeat(agentDir) {
+  const pidFile = join(agentDir, 'daemon.pid');
+  if (!existsSync(pidFile)) return;
+
+  try {
+    const info = JSON.parse(readFileSync(pidFile, 'utf-8'));
+    info.lastHeartbeat = new Date().toISOString();
+    writeFileSync(pidFile, JSON.stringify(info));
+  } catch {
+    // PID file may be momentarily unreadable, skip
+  }
+}
+
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) { resolve(); return; }
+
+    const timer = setTimeout(resolve, ms);
+
+    if (signal) {
+      const onAbort = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+  });
+}

package/src/agent-runtime/mcp-client.js

@@ -0,0 +1,93 @@
+// ── MCP Client Manager ──────────────────────────────────
+// Reads tools.yaml, spawns MCP servers, and exposes tools
+// to the Vercel AI SDK for use in the agent loop.
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { parse as parseYaml } from 'yaml';
+
+const activeClients = [];
+
+// ── Public API ──────────────────────────────────────────
+
+export async function getMCPTools(agentDir, agentConfig) {
+  const toolsPath = join(agentDir, 'tools.yaml');
+  let toolsConfig;
+  try {
+    toolsConfig = parseYaml(readFileSync(toolsPath, 'utf-8'));
+  } catch {
+    toolsConfig = { servers: {} };
+  }
+
+  const allTools = {};
+
+  for (const [name, server] of Object.entries(toolsConfig.servers || {})) {
+    if (server.command === 'internal') {
+      // Legacy internal tools — skip (replaced by MCP server)
+      continue;
+    }
+
+    try {
+      const { experimental_createMCPClient: createMCPClient } = await import('ai');
+      let client;
+
+      if (server.url) {
+        // Remote MCP server via Streamable HTTP transport
+        const headers = {};
+        if (process.env.MYVILLAGE_ACCESS_TOKEN) {
+          headers['Authorization'] = `Bearer ${process.env.MYVILLAGE_ACCESS_TOKEN}`;
+        }
+        if (process.env.MYVILLAGE_AGENT_ID) {
+          headers['X-Agent-Id'] = process.env.MYVILLAGE_AGENT_ID;
+        }
+        client = await createMCPClient({
+          transport: {
+            type: 'sse',
+            url: server.url,
+            headers,
+          },
+        });
+      } else {
+        // Local MCP servers via stdio transport
+        client = await createMCPClient({
+          transport: {
+            type: 'stdio',
+            command: server.command,
+            args: server.args || [],
+            env: { ...process.env, ...resolveEnvVars(server.env || {}) },
+          },
+        });
+      }
+
+      activeClients.push(client);
+      const tools = await client.tools();
+      Object.assign(allTools, tools);
+    } catch (err) {
+      // Log but don't fail — agent can still work with other tools
+      console.error(`[mcp-client] Failed to connect to ${name}: ${err.message}`);
+    }
+  }
+
+  return allTools;
+}
+
+export async function cleanupMCPClients() {
+  for (const client of activeClients) {
+    try { await client.close(); } catch { /* ignore */ }
+  }
+  activeClients.length = 0;
+}
+
+// ── Helpers ─────────────────────────────────────────────
+
+function resolveEnvVars(envMap) {
+  const resolved = {};
+  for (const [key, val] of Object.entries(envMap)) {
+    if (typeof val === 'string') {
+      resolved[key] = val.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] || '');
+    } else {
+      resolved[key] = val;
+    }
+  }
+  return resolved;
+}

package/src/agent-runtime/scheduler.js

@@ -0,0 +1,53 @@
+// ── Scheduler ───────────────────────────────────────────
+// Active hours checking and interval timing for agent loops.
+
+export function isWithinActiveHours(schedule) {
+  if (!schedule?.active_hours?.start || !schedule?.active_hours?.end) {
+    return true; // No active hours configured = always active
+  }
+
+  const now = new Date();
+  const tz = schedule.timezone || undefined;
+
+  // Get current hours/minutes in the configured timezone
+  let currentHours, currentMinutes;
+  if (tz) {
+    try {
+      const formatter = new Intl.DateTimeFormat('en-US', {
+        timeZone: tz,
+        hour: 'numeric',
+        minute: 'numeric',
+        hour12: false,
+      });
+      const parts = formatter.formatToParts(now);
+      currentHours = parseInt(parts.find(p => p.type === 'hour')?.value || '0');
+      currentMinutes = parseInt(parts.find(p => p.type === 'minute')?.value || '0');
+    } catch {
+      // Fallback to local time if timezone is invalid
+      currentHours = now.getHours();
+      currentMinutes = now.getMinutes();
+    }
+  } else {
+    currentHours = now.getHours();
+    currentMinutes = now.getMinutes();
+  }
+
+  const currentTime = currentHours * 60 + currentMinutes;
+
+  const [startH, startM] = schedule.active_hours.start.split(':').map(Number);
+  const [endH, endM] = schedule.active_hours.end.split(':').map(Number);
+  const startTime = startH * 60 + (startM || 0);
+  const endTime = endH * 60 + (endM || 0);
+
+  if (startTime <= endTime) {
+    return currentTime >= startTime && currentTime <= endTime;
+  }
+  // Handles overnight ranges (e.g., 22:00 - 06:00)
+  return currentTime >= startTime || currentTime <= endTime;
+}
+
+export function getNextCheckInMs(schedule) {
+  const interval = schedule?.check_in_interval;
+  if (!interval || interval <= 0) return 0; // manual only
+  return interval * 60 * 1000;
+}