@myvillage/cli 1.6.0 → 1.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {
@@ -27,6 +27,7 @@
   "license": "MIT",
   "dependencies": {
     "@ai-sdk/anthropic": "^1.0.0",
+    "@ai-sdk/openai": "^3.0.33",
     "ai": "^4.0.0",
     "axios": "^1.6.2",
     "chalk": "^5.3.0",

package/src/agent-runtime/loop.js

@@ -4,6 +4,7 @@
 
 import { generateText } from 'ai';
 import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAI } from '@ai-sdk/openai';
 import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
@@ -18,24 +19,47 @@ export async function agentLoop(agentName, { signal }) {
   const configPath = join(agentDir, 'agent.config.yaml');
   const config = parseYaml(readFileSync(configPath, 'utf-8'));
 
-  // Read API key from global config or environment
+  // Determine provider and resolve API key
+  const provider = config.brain?.provider || 'anthropic';
   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 */ }
+  let apiKey;
+
+  if (provider === 'openai') {
+    apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey && existsSync(globalConfigPath)) {
+      try {
+        const globalConfig = JSON.parse(readFileSync(globalConfigPath, 'utf-8'));
+        apiKey = globalConfig.openaiApiKey;
+      } catch { /* ignore */ }
+    }
+    if (!apiKey) {
+      logActivity(agentDir, { type: 'error', error: 'No OpenAI API key configured' });
+      throw new Error('No OpenAI API key configured. Set OPENAI_API_KEY or run: myvillage agent start ' + agentName);
+    }
+  } else {
+    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. Set ANTHROPIC_API_KEY or run: myvillage agent start ' + agentName);
+    }
   }
 
-  if (!apiKey) {
-    logActivity(agentDir, { type: 'error', error: 'No Anthropic API key configured' });
-    throw new Error('No Anthropic API key configured');
+  // Create provider and model
+  const modelId = config.brain?.model || (provider === 'openai' ? 'gpt-4o' : 'claude-sonnet-4-5-20250929');
+  let model;
+  if (provider === 'openai') {
+    const openai = createOpenAI({ apiKey });
+    model = openai(modelId);
+  } else {
+    const anthropic = createAnthropic({ apiKey });
+    model = anthropic(modelId);
   }
-
-  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

package/src/commands/agent-local.js

@@ -80,6 +80,35 @@ export async function agentCreateLocalCommand() {
           { name: 'Browser', value: 'browser' },
         ],
       },
+      {
+        type: 'list',
+        name: 'provider',
+        message: 'AI provider:',
+        choices: [
+          { name: 'Anthropic (Claude)', value: 'anthropic' },
+          { name: 'OpenAI (GPT)', value: 'openai' },
+        ],
+        default: 'anthropic',
+      },
+      {
+        type: 'list',
+        name: 'model',
+        message: 'Model:',
+        choices: (prev) => {
+          if (prev.provider === 'openai') {
+            return [
+              { name: 'gpt-4o (recommended)', value: 'gpt-4o' },
+              { name: 'gpt-4o-mini', value: 'gpt-4o-mini' },
+              { name: 'gpt-4.1', value: 'gpt-4.1' },
+              { name: 'gpt-4.1-mini', value: 'gpt-4.1-mini' },
+            ];
+          }
+          return [
+            { name: 'Claude Sonnet 4.5 (recommended)', value: 'claude-sonnet-4-5-20250929' },
+            { name: 'Claude Haiku 3.5', value: 'claude-3-5-haiku-20241022' },
+          ];
+        },
+      },
       {
         type: 'list',
         name: 'checkInInterval',
@@ -118,6 +147,8 @@ export async function agentCreateLocalCommand() {
       description: answers.description.trim(),
       tools,
       checkInInterval: answers.checkInInterval,
+      provider: answers.provider,
+      model: answers.model,
     });
 
     spinner.succeed('Agent scaffolded!');
@@ -154,25 +185,43 @@ export async function agentStartCommand(name) {
     return;
   }
 
-  // Check for Anthropic API key
-  const config = getConfig();
-  let apiKey = config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+  // Read agent's configured provider and check for the correct API key
+  const agentConfig = readAgentConfig(name);
+  const provider = agentConfig?.brain?.provider || 'anthropic';
+  const cliConfig = getConfig();
+
+  let apiKey;
+  let configKeyName;
+  let providerLabel;
+  let consoleUrl;
+
+  if (provider === 'openai') {
+    apiKey = cliConfig.openaiApiKey || process.env.OPENAI_API_KEY;
+    configKeyName = 'openaiApiKey';
+    providerLabel = 'OpenAI';
+    consoleUrl = 'https://platform.openai.com/api-keys';
+  } else {
+    apiKey = cliConfig.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+    configKeyName = 'anthropicApiKey';
+    providerLabel = 'Anthropic';
+    consoleUrl = 'https://console.anthropic.com';
+  }
 
   if (!apiKey) {
-    console.log(chalk.yellow('\n  Anthropic API key required for local agents.'));
-    console.log(brand.teal('  Get yours at: https://console.anthropic.com\n'));
+    console.log(chalk.yellow(`\n  ${providerLabel} API key required for this agent.`));
+    console.log(brand.teal(`  Get yours at: ${consoleUrl}\n`));
 
     try {
       const { key } = await inquirer.prompt([{
         type: 'password',
         name: 'key',
-        message: 'Anthropic API key:',
+        message: `${providerLabel} API key:`,
         mask: '*',
         validate: (input) => input.trim().length > 0 || 'API key is required',
       }]);
 
       apiKey = key.trim();
-      setConfig({ anthropicApiKey: apiKey });
+      setConfig({ [configKeyName]: apiKey });
       console.log(brand.green('  \u2713 API key saved.\n'));
     } catch (err) {
       if (err.isTtyError) {
@@ -183,7 +232,6 @@ export async function agentStartCommand(name) {
   }
 
   // Register on MAN if first start
-  const agentConfig = readAgentConfig(name);
   if (!agentConfig.man?.agent_id) {
     const regSpinner = villageSpinner('Registering agent on the MAN network...').start();
     try {

package/src/commands/agent.js

@@ -242,7 +242,7 @@ export async function agentViewCommand(handle) {
     const agent = await resolveAgentHandle(handle);
 
     if (!agent) {
-      spinner.fail(`Agent @${handle} not found. Run 'myvillage agent' to see your agents.`);
+      spinner.fail(`Agent @${handle} not found. Run 'myvillage agent' to see your agents, or 'myvillage agent start ${handle}' if you haven't started it yet.`);
       return;
     }
 
@@ -271,7 +271,7 @@ export async function agentEditCommand(handle) {
     const agent = await resolveAgentHandle(handle);
 
     if (!agent) {
-      spinner.fail(`Agent @${handle} not found. Run 'myvillage agent' to see your agents.`);
+      spinner.fail(`Agent @${handle} not found. Run 'myvillage agent' to see your agents, or 'myvillage agent start ${handle}' if you haven't started it yet.`);
       return;
     }
 
@@ -406,7 +406,7 @@ export async function agentDeleteCommand(handle) {
     const agent = await resolveAgentHandle(handle);
 
     if (!agent) {
-      console.log(chalk.red(`  \u2717 Agent @${handle} not found. Run 'myvillage agent' to see your agents.\n`));
+      console.log(chalk.red(`  \u2717 Agent @${handle} not found. Run 'myvillage agent' to see your agents, or 'myvillage agent start ${handle}' if you haven't started it yet.\n`));
       return;
     }
 
@@ -446,7 +446,7 @@ export async function agentJoinCommand(handle, slug) {
     const agent = await resolveAgentHandle(handle);
 
     if (!agent) {
-      spinner.fail(`Agent @${handle} not found. Run 'myvillage agent' to see your agents.`);
+      spinner.fail(`Agent @${handle} not found. Run 'myvillage agent' to see your agents, or 'myvillage agent start ${handle}' if you haven't started it yet.`);
       return;
     }
 
@@ -470,7 +470,7 @@ export async function agentLeaveCommand(handle, slug) {
     const agent = await resolveAgentHandle(handle);
 
     if (!agent) {
-      spinner.fail(`Agent @${handle} not found. Run 'myvillage agent' to see your agents.`);
+      spinner.fail(`Agent @${handle} not found. Run 'myvillage agent' to see your agents, or 'myvillage agent start ${handle}' if you haven't started it yet.`);
       return;
     }
 
@@ -492,7 +492,7 @@ export async function agentRunCommand(handle, options = {}) {
     const agent = await resolveAgentHandle(handle);
 
     if (!agent) {
-      console.log(chalk.red(`  \u2717 Agent @${handle} not found. Run 'myvillage agent' to see your agents.\n`));
+      console.log(chalk.red(`  \u2717 Agent @${handle} not found. Run 'myvillage agent' to see your agents, or 'myvillage agent start ${handle}' if you haven't started it yet.\n`));
       return;
     }
 

package/src/commands/checkin.js

@@ -1,22 +1,12 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
-import { z } from 'zod';
 import { isAuthenticated } from '../utils/auth.js';
 import { brand, villageSpinner } from '../utils/brand.js';
-import { createPost } from '../utils/api.js';
+import { createPost, structureCheckin } from '../utils/api.js';
 import { resolveVillageContext } from '../utils/village-resolver.js';
-import { getAnthropicProvider } from '../utils/ai.js';
 import { formatCheckinSummary } from '../utils/formatters.js';
 import { discoverLogic } from './discover.js';
 
-const extractionSchema = z.object({
-  themes: z.array(z.string()).describe('Key themes from the check-in (1-4 short labels)'),
-  needs: z.array(z.string()).describe('Things the village needs help with (0-3 short labels)'),
-  offers: z.array(z.string()).describe('Things the village can offer others (0-3 short labels)'),
-  buildTrack: z.string().optional().describe('Primary build track if mentioned: game, portal, agent, data, robot, or general'),
-  summary: z.string().describe('A 2-3 sentence summary combining all responses into a cohesive check-in update'),
-});
-
 export async function checkinCommand(options) {
   if (!isAuthenticated()) {
     console.log(chalk.red("  \u2717 Authentication required. Run 'myvillage login' first."));
@@ -52,42 +42,19 @@ export async function checkinCommand(options) {
     },
   ]);
 
-  // AI structuring
+  // AI structuring (backend-proxied)
   const spinner = villageSpinner('Organizing your check-in...').start();
 
   let extracted;
   try {
-    const anthropic = await getAnthropicProvider();
-    const { generateText } = await import('ai');
-
-    const userContent = [
-      `What we worked on: ${answers.work}`,
-      answers.stuck ? `Problems we're stuck on: ${answers.stuck}` : null,
-      answers.share ? `What we want to share: ${answers.share}` : null,
-    ].filter(Boolean).join('\n');
-
-    const result = await generateText({
-      model: anthropic('claude-haiku-4-5-20251001'),
-      system: `You are a community network coordinator. Extract structured metadata from a village check-in and write a concise summary. Always call the extract_checkin tool with your analysis.`,
-      messages: [{ role: 'user', content: userContent }],
-      tools: {
-        extract_checkin: {
-          description: 'Extract structured metadata from a village check-in',
-          parameters: extractionSchema,
-        },
-      },
-      toolChoice: { type: 'tool', toolName: 'extract_checkin' },
-      maxTokens: 500,
+    extracted = await structureCheckin({
+      work: answers.work,
+      stuck: answers.stuck || undefined,
+      share: answers.share || undefined,
     });
-
-    const toolCall = result.toolCalls?.[0];
-    if (!toolCall?.args) {
-      throw new Error('AI did not return structured data');
-    }
-    extracted = toolCall.args;
     spinner.succeed('Check-in organized');
   } catch (err) {
-    spinner.fail('AI structuring failed — posting raw check-in');
+    spinner.fail('AI structuring failed \u2014 posting raw check-in');
     // Fallback: post without AI structuring
     extracted = {
       themes: [],

package/src/commands/comment.js

@@ -24,7 +24,7 @@ export async function commentCommand(postId, options) {
       agentsSpinner.stop();
 
       if (!agent) {
-        console.log(chalk.red(`  ✗ Agent @${options.as} not found. Run 'myvillage agent' to see your agents.`));
+        console.log(chalk.red(`  \u2717 Agent @${options.as} not found. Run 'myvillage agent' to see your agents, or 'myvillage agent start ${options.as}' if you haven't started it yet.`));
         return;
       }
       agentProfileId = agent.id;

package/src/commands/post.js

@@ -88,7 +88,7 @@ export async function postCreateCommand(options = {}) {
         agentsSpinner.stop();
 
         if (!agent) {
-          console.log(chalk.red(`  ✗ Agent @${options.as} not found. Run 'myvillage agent' to see your agents.`));
+          console.log(chalk.red(`  \u2717 Agent @${options.as} not found. Run 'myvillage agent' to see your agents, or 'myvillage agent start ${options.as}' if you haven't started it yet.`));
           return;
         }
         agentProfileId = agent.id;

package/src/commands/profile.js

@@ -1,8 +1,8 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { villageSpinner, brand } from '../utils/brand.js';
-import { isAuthenticated, loadCredentials } from '../utils/auth.js';
-import { getProfile, getProfilePosts } from '../utils/api.js';
+import { isAuthenticated, loadCredentials, saveCredentials } from '../utils/auth.js';
+import { getProfile, getProfilePosts, getUserInfo, getAccessToken } from '../utils/api.js';
 import { formatProfile, formatPostList, formatPagination } from '../utils/formatters.js';
 
 export async function profileCommand(handle, options) {
@@ -13,18 +13,47 @@ export async function profileCommand(handle, options) {
 
   // Resolve handle: default to the logged-in user's villagerId
   let target = handle;
-  if (!target) {
+  const isSelf = !target;
+  if (isSelf) {
     const creds = loadCredentials();
     target = creds?.villager_id;
     if (!target) {
-      console.log(chalk.red('  ✗ No villager ID found. Try logging out and back in, or provide a handle: myvillage profile <handle>'));
+      console.log(chalk.red('  \u2717 No villager ID found. Try logging out and back in, or provide a handle: myvillage profile <handle>'));
       return;
     }
   }
   const spinner = villageSpinner('Loading profile...').start();
 
   try {
-    const result = await getProfile(target);
+    let result;
+    try {
+      result = await getProfile(target);
+    } catch (err) {
+      // If own profile lookup fails with 404, refresh userinfo and retry
+      if (isSelf && err.response?.status === 404) {
+        spinner.text = 'Refreshing user info...';
+        const accessToken = getAccessToken();
+        if (accessToken) {
+          const userInfo = await getUserInfo(accessToken);
+          const freshId = userInfo.villager?.villagerId;
+          if (freshId && freshId !== target) {
+            // Update stored credentials with the fresh villagerId
+            const creds = loadCredentials();
+            saveCredentials({ ...creds, villager_id: freshId });
+            target = freshId;
+            spinner.text = 'Loading profile...';
+            result = await getProfile(target);
+          } else {
+            throw err;
+          }
+        } else {
+          throw err;
+        }
+      } else {
+        throw err;
+      }
+    }
+
     spinner.stop();
 
     const profile = result.data || result;
@@ -54,5 +83,8 @@ export async function profileCommand(handle, options) {
   } catch (err) {
     const message = err.response?.data?.error || err.response?.data?.message || err.message;
     spinner.fail(`Failed to load profile: ${message}`);
+    if (isSelf && err.response?.status === 404) {
+      console.log(brand.teal('  Your stored villager ID may be out of sync. Try running \'myvillage logout\' then \'myvillage login\'.'));
+    }
   }
 }

package/src/commands/vote.js

@@ -20,7 +20,7 @@ export async function voteCommand(options) {
       const agent = Array.isArray(agents) ? agents.find(a => a.handle === options.as) : null;
 
       if (!agent) {
-        console.log(chalk.red(`  \u2717 Agent @${options.as} not found. Run 'myvillage agent' to see your agents.\n`));
+        console.log(chalk.red(`  \u2717 Agent @${options.as} not found. Run 'myvillage agent' to see your agents, or 'myvillage agent start ${options.as}' if you haven't started it yet.\n`));
         return;
       }
       agentProfileId = agent.id;

package/src/utils/agent-scaffolder.js

@@ -52,7 +52,7 @@ const INTERVAL_MAP = {
 // ── Scaffolding ─────────────────────────────────────────
 
 export function scaffoldAgent(agentDir, options) {
-  const { name, displayName, description, tools, checkInInterval } = options;
+  const { name, displayName, description, tools, checkInInterval, provider, model } = options;
 
   // Create directories
   mkdirSync(join(agentDir, 'routines'), { recursive: true });
@@ -61,7 +61,7 @@ export function scaffoldAgent(agentDir, options) {
   // Write agent.config.yaml
   writeFileSync(
     join(agentDir, 'agent.config.yaml'),
-    generateAgentConfig({ name, displayName, description, checkInInterval })
+    generateAgentConfig({ name, displayName, description, checkInInterval, provider, model })
   );
 
   // Write prompt.md
@@ -82,7 +82,7 @@ export function scaffoldAgent(agentDir, options) {
 
 // ── Config Generation ───────────────────────────────────
 
-function generateAgentConfig({ name, displayName, description, checkInInterval }) {
+function generateAgentConfig({ name, displayName, description, checkInInterval, provider, model }) {
   const intervalMin = INTERVAL_MAP[checkInInterval] || 60;
 
   const config = {
@@ -105,8 +105,8 @@ function generateAgentConfig({ name, displayName, description, checkInInterval }
     },
 
     brain: {
-      provider: 'anthropic',
-      model: 'claude-sonnet-4-5-20250929',
+      provider: provider || 'anthropic',
+      model: model || (provider === 'openai' ? 'gpt-4o' : 'claude-sonnet-4-5-20250929'),
       max_tokens_per_loop: 1000,
       fallback_provider: null,
     },

package/src/utils/api.js

@@ -367,6 +367,14 @@ export async function deleteAgentMemoryEntry(id, key) {
   return response.data;
 }
 
+// ── Checkin AI Structuring ────────────────────────────────
+
+export async function structureCheckin(data) {
+  const client = getNetworkClient();
+  const response = await client.post('/checkin/structure', data);
+  return response.data;
+}
+
 // ── OAuth Client Registration ────────────────────────────
 
 export async function registerOAuthClient(name, appType, redirectUris) {

package/src/utils/config.js

@@ -15,6 +15,7 @@ const DEFAULT_CONFIG = {
   clientId: 'mvos_aG_c729fuQxvvqYHOnkgTQ',
   callbackPort: 3737,
   anthropicApiKey: null,
+  openaiApiKey: null,
 };
 
 function ensureConfigDir() {
@@ -40,10 +41,13 @@ export function getConfig() {
     delete fileConfig.clientId;
     delete fileConfig.oauthBaseUrl;
     const config = { ...DEFAULT_CONFIG, ...fileConfig };
-    // Environment variable override for Anthropic API key
+    // Environment variable overrides for API keys
     if (process.env.ANTHROPIC_API_KEY) {
       config.anthropicApiKey = process.env.ANTHROPIC_API_KEY;
     }
+    if (process.env.OPENAI_API_KEY) {
+      config.openaiApiKey = process.env.OPENAI_API_KEY;
+    }
     return config;
   } catch {
     return { ...DEFAULT_CONFIG };

package/src/utils/formatters.js

@@ -502,10 +502,12 @@ export function formatLocalAgentStatus(agent) {
   const toolsStr = Object.keys(agent.config?.tools || {}).join(', ') || 'none';
   lines.push(`  ${chalk.dim('Tools:')}        ${toolsStr}`);
 
-  // Model
+  // Model & provider
   const model = agent.config?.brain?.model;
   if (model) {
-    lines.push(`  ${chalk.dim('Model:')}        ${model}`);
+    const prov = agent.config?.brain?.provider;
+    const provLabel = prov === 'openai' ? 'OpenAI' : prov === 'anthropic' ? 'Anthropic' : prov || '';
+    lines.push(`  ${chalk.dim('Model:')}        ${model}${provLabel ? chalk.dim(` (${provLabel})`) : ''}`);
   }
 
   lines.push('');