@myvillage/cli 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {
@@ -26,16 +26,17 @@
   "author": "MyVillage Project",
   "license": "MIT",
   "dependencies": {
-    "commander": "^11.1.0",
-    "inquirer": "^9.2.12",
+    "@ai-sdk/anthropic": "^1.0.0",
+    "ai": "^4.0.0",
     "axios": "^1.6.2",
     "chalk": "^5.3.0",
-    "ora": "^8.0.1",
-    "open": "^10.0.3",
+    "commander": "^11.1.0",
     "conf": "^12.0.0",
+    "inquirer": "^9.2.12",
+    "open": "^10.0.3",
+    "ora": "^8.0.1",
+    "p-limit": "^5.0.0",
     "update-notifier": "^7.0.0",
-    "ai": "^4.0.0",
-    "@ai-sdk/anthropic": "^1.0.0",
     "yaml": "^2.3.0",
     "zod": "^3.22.0"
   }

package/src/agent-runtime/loop.js

@@ -131,9 +131,9 @@ export async function agentLoop(agentName, { signal }) {
           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 (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) {
@@ -160,9 +160,9 @@ export async function agentLoop(agentName, { signal }) {
       } 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++;
+          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,
@@ -174,11 +174,11 @@ export async function agentLoop(agentName, { signal }) {
 
       // Record actions for dedup in future iterations
       const collectActions = (toolName, args) => {
-        if (toolName === 'man_create_comment' && args?.postId) {
+        if (toolName === 'comment_create' && args?.postId) {
           recentActions.push({ type: 'comment', postId: args.postId, ts: new Date().toISOString() });
-        } else if (toolName === 'man_create_post' && args?.communitySlug) {
+        } else if (toolName === 'post_create' && args?.communitySlug) {
           recentActions.push({ type: 'post', community: args.communitySlug, ts: new Date().toISOString() });
-        } else if (toolName === 'man_vote' && args?.targetId) {
+        } else if (toolName === 'vote_cast' && args?.targetId) {
           recentActions.push({ type: 'vote', targetId: args.targetId, targetType: args.targetType, ts: new Date().toISOString() });
         }
       };

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

@@ -5,20 +5,6 @@
 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 = [];
 
@@ -37,21 +23,42 @@ export async function getMCPTools(agentDir, agentConfig) {
 
   for (const [name, server] of Object.entries(toolsConfig.servers || {})) {
     if (server.command === 'internal') {
-      Object.assign(allTools, getInternalTools(name, agentConfig));
+      // Legacy internal tools — skip (replaced by MCP server)
       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 || {}) },
-        },
-      });
+      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);
@@ -71,320 +78,6 @@ export async function cleanupMCPClients() {
   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) {

package/src/commands/agent-local.js

@@ -5,7 +5,7 @@ import inquirer from 'inquirer';
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { execSync } from 'child_process';
-import { isAuthenticated } from '../utils/auth.js';
+import { isAuthenticated, getAccessToken } from '../utils/auth.js';
 import { getConfig, setConfig } from '../utils/config.js';
 import {
   createAgent as apiCreateAgent,
@@ -72,7 +72,7 @@ export async function agentCreateLocalCommand() {
         name: 'tools',
         message: 'Which tools should your agent have?',
         choices: [
-          { name: 'MAN Feed (post, read, react)', value: 'man-feed', checked: true, disabled: 'always enabled' },
+          { name: 'MyVillageOS MCP (feed, posts, communities, wallet)', value: 'myvillage', checked: true, disabled: 'always enabled' },
           { name: 'Local Files (read/write project files)', value: 'filesystem', checked: true },
           { name: 'Gmail', value: 'gmail' },
           { name: 'Calendar', value: 'calendar' },
@@ -109,8 +109,8 @@ export async function agentCreateLocalCommand() {
 
     const agentDir = getAgentDir(answers.name);
 
-    // man-feed is always included even though disabled in checkbox
-    const tools = ['man-feed', ...answers.tools.filter(t => t !== 'man-feed')];
+    // myvillage is always included even though disabled in checkbox
+    const tools = ['myvillage', ...answers.tools.filter(t => t !== 'myvillage')];
 
     scaffoldAgent(agentDir, {
       name: answers.name,
@@ -236,6 +236,23 @@ export async function agentStartCommand(name) {
     }
   }
 
+  // Migrate tools.yaml: replace man-feed with myvillage MCP server
+  const toolsConfig = readToolsYaml(name);
+  if (toolsConfig.servers?.['man-feed'] && !toolsConfig.servers?.['myvillage']) {
+    delete toolsConfig.servers['man-feed'];
+    toolsConfig.servers = { myvillage: TOOL_CATALOG['myvillage'], ...toolsConfig.servers };
+    writeToolsYaml(name, toolsConfig);
+  }
+
+  // Pass MyVillage credentials to daemon for MCP server
+  const accessToken = getAccessToken();
+  if (accessToken) {
+    process.env.MYVILLAGE_ACCESS_TOKEN = accessToken;
+  }
+  if (agentConfig.man?.agent_id) {
+    process.env.MYVILLAGE_AGENT_ID = agentConfig.man.agent_id;
+  }
+
   // Fork the daemon process
   const spinner = villageSpinner(`Starting agent "${name}"...`).start();
 
@@ -492,7 +509,7 @@ export async function agentAddToolCommand(name, tool) {
     return;
   }
 
-  const validTools = Object.keys(TOOL_CATALOG).filter(t => t !== 'man-feed');
+  const validTools = Object.keys(TOOL_CATALOG).filter(t => t !== 'myvillage');
   if (!validTools.includes(tool)) {
     console.log(chalk.red(`  \u2717 Unknown tool "${tool}".`));
     console.log(brand.teal(`  Available tools: ${validTools.join(', ')}\n`));
@@ -530,8 +547,8 @@ export async function agentRemoveToolCommand(name, tool) {
     return;
   }
 
-  if (tool === 'man-feed') {
-    console.log(chalk.red('  \u2717 Cannot remove man-feed — it is always enabled.\n'));
+  if (tool === 'myvillage') {
+    console.log(chalk.red('  \u2717 Cannot remove myvillage — it is always enabled.\n'));
     return;
   }
 

package/src/commands/bizreqs.js

@@ -100,31 +100,7 @@ const recommendationParams = z.object({
 
 // ── Helper: Get Anthropic client ────────────────────────
 
-async function getAnthropicProvider() {
-  const { createAnthropic } = await import('@ai-sdk/anthropic');
-  const config = getConfig();
-  let apiKey = config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
-
-  if (!apiKey) {
-    console.log(chalk.yellow('\n  Anthropic API key required for AI-powered intake.'));
-    console.log(brand.teal('  Get yours at: https://console.anthropic.com\n'));
-
-    const { key } = await inquirer.prompt([{
-      type: 'password',
-      name: 'key',
-      message: 'Anthropic API key:',
-      mask: '*',
-      validate: (input) => input.trim().length > 0 || 'API key is required',
-    }]);
-
-    apiKey = key.trim();
-    const { setConfig } = await import('../utils/config.js');
-    setConfig({ anthropicApiKey: apiKey });
-    console.log(brand.green('  ✓ API key saved to ~/.myvillage/config.json\n'));
-  }
-
-  return createAnthropic({ apiKey });
-}
+import { getAnthropicProvider } from '../utils/ai.js';
 
 
 // ── bizreqs list ────────────────────────────────────────