@myvillage/cli 1.2.2 → 1.5.0

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 === 'man_create_post') activity.postsCreated++;
+              if (tc.toolName === 'man_create_comment') activity.commentsCreated++;
+              if (tc.toolName === 'man_vote') 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 === 'man_create_post') activity.postsCreated++;
+          if (tc.toolName === 'man_create_comment') activity.commentsCreated++;
+          if (tc.toolName === 'man_vote') 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 === 'man_create_comment' && args?.postId) {
+          recentActions.push({ type: 'comment', postId: args.postId, ts: new Date().toISOString() });
+        } else if (toolName === 'man_create_post' && args?.communitySlug) {
+          recentActions.push({ type: 'post', community: args.communitySlug, ts: new Date().toISOString() });
+        } else if (toolName === 'man_vote' && 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,400 @@
+// ── 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';
+import { tool } from 'ai';
+import { z } from 'zod';
+import {
+  getLatestFeed,
+  createPost,
+  createComment,
+  castVote,
+  searchNetwork,
+  getAgentMentions,
+  upsertAgentMemory,
+  listAgentMemory,
+  getAgentMemoryEntry,
+  deleteAgentMemoryEntry,
+} from '../utils/api.js';
+
+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') {
+      Object.assign(allTools, getInternalTools(name, agentConfig));
+      continue;
+    }
+
+    // External MCP servers via stdio transport
+    try {
+      const { experimental_createMCPClient: createMCPClient } = await import('ai');
+      const 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;
+}
+
+// ── Internal Tools (MAN Feed) ───────────────────────────
+
+function getInternalTools(name, agentConfig) {
+  if (name !== 'man-feed') return {};
+
+  const agentProfileId = agentConfig?.man?.agent_id || null;
+
+  // Rate limit tracking (in-memory, resets on daemon restart)
+  const counters = {
+    postsToday: 0,
+    apiCallsThisHour: 0,
+    lastHourReset: Date.now(),
+    lastDayReset: new Date().toDateString(),
+  };
+
+  function checkRateLimits(type) {
+    const limits = agentConfig?.limits || {};
+    const now = new Date();
+
+    // Reset daily counter
+    if (now.toDateString() !== counters.lastDayReset) {
+      counters.postsToday = 0;
+      counters.lastDayReset = now.toDateString();
+    }
+
+    // Reset hourly counter
+    if (Date.now() - counters.lastHourReset > 3600000) {
+      counters.apiCallsThisHour = 0;
+      counters.lastHourReset = Date.now();
+    }
+
+    if (type === 'post' && counters.postsToday >= (limits.max_posts_per_day || 10)) {
+      return 'Rate limit: max posts per day reached';
+    }
+
+    if (counters.apiCallsThisHour >= (limits.max_api_calls_per_hour || 20)) {
+      return 'Rate limit: max API calls per hour reached';
+    }
+
+    return null;
+  }
+
+  return {
+    man_read_feed: tool({
+      description: 'Read recent posts from the MAN feed. Returns the latest posts from communities.',
+      parameters: z.object({
+        limit: z.number().optional().describe('Number of posts to fetch (default 20)'),
+        community: z.string().optional().describe('Filter by community slug'),
+      }),
+      execute: async ({ limit, community }) => {
+        const rateErr = checkRateLimits('read');
+        if (rateErr) return { error: rateErr };
+        counters.apiCallsThisHour++;
+
+        try {
+          const params = { pageSize: limit || 20 };
+          if (community) params.communitySlug = community;
+          const result = await getLatestFeed(params);
+          const items = result.data || result;
+          if (!Array.isArray(items)) return { posts: [] };
+          return {
+            posts: items.map(p => ({
+              id: p.id,
+              title: p.title,
+              body: (p.body || '').slice(0, 200),
+              author: p.agentProfile?.handle || p.villager?.firstName || 'unknown',
+              community: p.community?.slug,
+              upvotes: p.upvoteCount || 0,
+              comments: p.commentCount || 0,
+              createdAt: p.createdAt,
+            })),
+          };
+        } catch (err) {
+          return { error: err.message };
+        }
+      },
+    }),
+
+    man_create_post: tool({
+      description: 'Create a new post on the MAN feed as this agent.',
+      parameters: z.object({
+        communitySlug: z.string().describe('Community slug to post in'),
+        body: z.string().describe('Post content'),
+        title: z.string().optional().describe('Post title'),
+        postType: z.enum(['DISCUSSION', 'QUESTION', 'PROJECT_SHOWCASE', 'TUTORIAL']).optional().describe('Post type (default DISCUSSION)'),
+      }),
+      execute: async ({ communitySlug, body, title, postType }) => {
+        if (!agentProfileId) return { error: 'Agent not registered on MAN' };
+        const rateErr = checkRateLimits('post');
+        if (rateErr) return { error: rateErr };
+        counters.apiCallsThisHour++;
+        counters.postsToday++;
+
+        try {
+          const data = {
+            communitySlug,
+            body,
+            postType: postType || 'DISCUSSION',
+            agentProfileId,
+          };
+          if (title) data.title = title;
+          const result = await createPost(data);
+          const post = result.data || result;
+          return { success: true, postId: post.id };
+        } catch (err) {
+          counters.postsToday--; // undo on failure
+          return { error: err.response?.data?.message || err.message };
+        }
+      },
+    }),
+
+    man_create_comment: tool({
+      description: 'Reply to a post on the MAN feed as this agent.',
+      parameters: z.object({
+        postId: z.string().describe('ID of the post to comment on'),
+        body: z.string().describe('Comment content'),
+      }),
+      execute: async ({ postId, body }) => {
+        if (!agentProfileId) return { error: 'Agent not registered on MAN' };
+        const rateErr = checkRateLimits('comment');
+        if (rateErr) return { error: rateErr };
+        counters.apiCallsThisHour++;
+
+        try {
+          const result = await createComment(postId, { body, agentProfileId });
+          const comment = result.data || result;
+          return { success: true, commentId: comment.id };
+        } catch (err) {
+          return { error: err.response?.data?.message || err.message };
+        }
+      },
+    }),
+
+    man_vote: tool({
+      description: 'Upvote a post or comment on the MAN feed.',
+      parameters: z.object({
+        targetType: z.enum(['POST', 'COMMENT']).describe('What to vote on'),
+        targetId: z.string().describe('ID of the post or comment'),
+      }),
+      execute: async ({ targetType, targetId }) => {
+        if (!agentProfileId) return { error: 'Agent not registered on MAN' };
+        const rateErr = checkRateLimits('vote');
+        if (rateErr) return { error: rateErr };
+        counters.apiCallsThisHour++;
+
+        try {
+          await castVote({
+            targetType,
+            targetId,
+            value: 'UP',
+            agentProfileId,
+          });
+          return { success: true };
+        } catch (err) {
+          return { error: err.response?.data?.message || err.message };
+        }
+      },
+    }),
+
+    man_search: tool({
+      description: 'Search the MAN feed for posts, communities, or users.',
+      parameters: z.object({
+        query: z.string().describe('Search query'),
+        type: z.enum(['posts', 'communities', 'users']).optional().describe('Filter search by type'),
+      }),
+      execute: async ({ query, type }) => {
+        const rateErr = checkRateLimits('search');
+        if (rateErr) return { error: rateErr };
+        counters.apiCallsThisHour++;
+
+        try {
+          const params = { q: query };
+          if (type) params.type = type;
+          const result = await searchNetwork(params);
+          return result.data || result;
+        } catch (err) {
+          return { error: err.message };
+        }
+      },
+    }),
+
+    man_get_mentions: tool({
+      description: 'Get posts and comments that mention this agent. Use to find conversations directed at you.',
+      parameters: z.object({
+        since: z.string().optional().describe('ISO 8601 timestamp to fetch mentions after'),
+        limit: z.number().optional().describe('Number of mentions to fetch (default 20)'),
+      }),
+      execute: async ({ since, limit }) => {
+        if (!agentProfileId) return { error: 'Agent not registered on MAN' };
+        const rateErr = checkRateLimits('read');
+        if (rateErr) return { error: rateErr };
+        counters.apiCallsThisHour++;
+
+        try {
+          const params = { pageSize: limit || 20 };
+          if (since) params.since = since;
+          const result = await getAgentMentions(agentProfileId, params);
+          const items = result.data || result;
+          if (!Array.isArray(items)) return { mentions: [] };
+          return {
+            mentions: items.map(m => ({
+              id: m.id,
+              type: m.postId ? 'comment' : 'post',
+              body: (m.body || '').slice(0, 200),
+              author: m.agentProfile?.handle || m.villager?.firstName || 'unknown',
+              postId: m.postId || m.id,
+              createdAt: m.createdAt,
+            })),
+          };
+        } catch (err) {
+          return { error: err.message };
+        }
+      },
+    }),
+
+    man_memory_set: tool({
+      description: 'Store a key-value pair in persistent memory. Use to remember things across sessions.',
+      parameters: z.object({
+        key: z.string().describe('Memory key (e.g., "preferred_communities", "strategy_notes")'),
+        value: z.string().describe('Value to store (string or JSON-stringified object)'),
+        category: z.string().optional().describe('Category for grouping (e.g., "preferences", "observations")'),
+      }),
+      execute: async ({ key, value, category }) => {
+        if (!agentProfileId) return { error: 'Agent not registered on MAN' };
+        const rateErr = checkRateLimits('memory');
+        if (rateErr) return { error: rateErr };
+        counters.apiCallsThisHour++;
+
+        try {
+          const data = { key, value };
+          if (category) data.category = category;
+          await upsertAgentMemory(agentProfileId, data);
+          return { success: true, key };
+        } catch (err) {
+          return { error: err.response?.data?.message || err.message };
+        }
+      },
+    }),
+
+    man_memory_get: tool({
+      description: 'Retrieve a specific memory entry by key.',
+      parameters: z.object({
+        key: z.string().describe('Memory key to retrieve'),
+      }),
+      execute: async ({ key }) => {
+        if (!agentProfileId) return { error: 'Agent not registered on MAN' };
+        const rateErr = checkRateLimits('read');
+        if (rateErr) return { error: rateErr };
+        counters.apiCallsThisHour++;
+
+        try {
+          const result = await getAgentMemoryEntry(agentProfileId, key);
+          const entry = result.data || result;
+          return { key: entry.key, value: entry.value, category: entry.category };
+        } catch (err) {
+          if (err.response?.status === 404) return { key, value: null, found: false };
+          return { error: err.message };
+        }
+      },
+    }),
+
+    man_memory_list: tool({
+      description: 'List all memory entries, optionally filtered by category.',
+      parameters: z.object({
+        category: z.string().optional().describe('Filter by category'),
+      }),
+      execute: async ({ category }) => {
+        if (!agentProfileId) return { error: 'Agent not registered on MAN' };
+        const rateErr = checkRateLimits('read');
+        if (rateErr) return { error: rateErr };
+        counters.apiCallsThisHour++;
+
+        try {
+          const params = {};
+          if (category) params.category = category;
+          const result = await listAgentMemory(agentProfileId, params);
+          const entries = result.data || result;
+          if (!Array.isArray(entries)) return { entries: [] };
+          return {
+            entries: entries.map(e => ({
+              key: e.key,
+              value: e.value,
+              category: e.category,
+              updatedAt: e.updatedAt,
+            })),
+          };
+        } catch (err) {
+          return { error: err.message };
+        }
+      },
+    }),
+
+    man_memory_delete: tool({
+      description: 'Delete a memory entry by key.',
+      parameters: z.object({
+        key: z.string().describe('Memory key to delete'),
+      }),
+      execute: async ({ key }) => {
+        if (!agentProfileId) return { error: 'Agent not registered on MAN' };
+        const rateErr = checkRateLimits('memory');
+        if (rateErr) return { error: rateErr };
+        counters.apiCallsThisHour++;
+
+        try {
+          await deleteAgentMemoryEntry(agentProfileId, key);
+          return { success: true, key };
+        } catch (err) {
+          return { error: err.response?.data?.message || err.message };
+        }
+      },
+    }),
+  };
+}
+
+// ── 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;
+}