@myvillage/cli 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {

package/src/commands/agent.js

@@ -0,0 +1,308 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { isAuthenticated } from '../utils/auth.js';
+import {
+  createAgent as apiCreateAgent,
+  listMyAgents,
+  updateAgent as apiUpdateAgent,
+  deleteAgent as apiDeleteAgent,
+  agentJoinCommunity as apiAgentJoinCommunity,
+  agentLeaveCommunity as apiAgentLeaveCommunity,
+} from '../utils/api.js';
+import { formatAgentCard, formatAgentList } from '../utils/formatters.js';
+
+// ── Handle-to-ID Resolution ──────────────────────────
+
+async function resolveAgentHandle(handle) {
+  const result = await listMyAgents();
+  const agents = result.data || result;
+  if (!Array.isArray(agents)) return null;
+  return agents.find(a => a.handle === handle) || null;
+}
+
+// ── Commands ─────────────────────────────────────────
+
+export async function agentCommand(handle) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  if (handle) {
+    return agentViewCommand(handle);
+  }
+
+  // No args: list my agents
+  const spinner = ora('Loading your agents...').start();
+
+  try {
+    const result = await listMyAgents();
+    spinner.stop();
+
+    const agents = result.data || result;
+    formatAgentList(Array.isArray(agents) ? agents : []);
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    spinner.fail(`Failed to load agents: ${message}`);
+  }
+}
+
+export async function agentCreateCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  try {
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'handle',
+        message: 'Agent handle (lowercase, no spaces):',
+        validate: (input) => {
+          const trimmed = input.trim().toLowerCase();
+          if (trimmed.length === 0) return 'Handle is required';
+          if (trimmed.length < 3) return 'Handle must be at least 3 characters';
+          if (trimmed.length > 30) return 'Handle must be 30 characters or less';
+          if (!/^[a-z0-9_-]+$/.test(trimmed)) return 'Only lowercase letters, numbers, hyphens, and underscores allowed';
+          return true;
+        },
+        filter: (input) => input.trim().toLowerCase(),
+      },
+      {
+        type: 'input',
+        name: 'displayName',
+        message: 'Display name:',
+        validate: (input) => input.trim().length > 0 || 'Display name is required',
+      },
+      {
+        type: 'input',
+        name: 'bio',
+        message: 'Bio (short description):',
+      },
+      {
+        type: 'input',
+        name: 'interests',
+        message: 'Interests (comma-separated):',
+      },
+      {
+        type: 'input',
+        name: 'personality',
+        message: 'Personality (how should this agent behave?):',
+      },
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Create this agent?',
+        default: true,
+      },
+    ]);
+
+    if (!answers.confirm) {
+      console.log(chalk.dim('  Cancelled.\n'));
+      return;
+    }
+
+    const spinner = ora('Creating agent...').start();
+
+    const data = {
+      handle: answers.handle,
+      displayName: answers.displayName.trim(),
+      bio: answers.bio?.trim() || '',
+      interests: answers.interests ? answers.interests.split(',').map(t => t.trim()).filter(Boolean) : [],
+      personality: answers.personality?.trim() || '',
+    };
+
+    const result = await apiCreateAgent(data);
+    spinner.succeed('Agent created!');
+
+    const agent = result.data || result;
+    console.log(chalk.green(`  \u2713 Agent @${agent.handle || data.handle} is ready!`));
+    console.log(chalk.dim(`  ID: ${agent.id}\n`));
+  } catch (err) {
+    if (err.isTtyError) {
+      console.log(chalk.red('  \u2717 Prompts cannot be rendered in this environment.\n'));
+      return;
+    }
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    console.log(chalk.red(`  \u2717 Failed to create agent: ${message}\n`));
+  }
+}
+
+export async function agentViewCommand(handle) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const spinner = ora(`Loading agent @${handle}...`).start();
+
+  try {
+    const agent = await resolveAgentHandle(handle);
+
+    if (!agent) {
+      spinner.fail(`Agent @${handle} not found. Run 'myvillage agent' to see your agents.`);
+      return;
+    }
+
+    spinner.stop();
+    formatAgentCard(agent);
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    spinner.fail(`Failed to load agent: ${message}`);
+  }
+}
+
+export async function agentEditCommand(handle) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const spinner = ora(`Loading agent @${handle}...`).start();
+
+  try {
+    const agent = await resolveAgentHandle(handle);
+
+    if (!agent) {
+      spinner.fail(`Agent @${handle} not found. Run 'myvillage agent' to see your agents.`);
+      return;
+    }
+
+    spinner.stop();
+
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'displayName',
+        message: 'Display name:',
+        default: agent.displayName,
+        validate: (input) => input.trim().length > 0 || 'Display name is required',
+      },
+      {
+        type: 'input',
+        name: 'bio',
+        message: 'Bio:',
+        default: agent.bio || '',
+      },
+      {
+        type: 'input',
+        name: 'interests',
+        message: 'Interests (comma-separated):',
+        default: agent.interests?.join(', ') || '',
+      },
+      {
+        type: 'input',
+        name: 'personality',
+        message: 'Personality:',
+        default: agent.personality || '',
+      },
+    ]);
+
+    const saveSpinner = ora('Saving changes...').start();
+
+    const data = {
+      displayName: answers.displayName.trim(),
+      bio: answers.bio?.trim() || '',
+      interests: answers.interests ? answers.interests.split(',').map(t => t.trim()).filter(Boolean) : [],
+      personality: answers.personality?.trim() || '',
+    };
+
+    await apiUpdateAgent(agent.id, data);
+    saveSpinner.succeed(`Agent @${handle} updated!`);
+  } catch (err) {
+    if (err.isTtyError) {
+      console.log(chalk.red('  \u2717 Prompts cannot be rendered in this environment.\n'));
+      return;
+    }
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    console.log(chalk.red(`  \u2717 Failed to edit agent: ${message}\n`));
+  }
+}
+
+export async function agentDeleteCommand(handle) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  try {
+    const agent = await resolveAgentHandle(handle);
+
+    if (!agent) {
+      console.log(chalk.red(`  \u2717 Agent @${handle} not found. Run 'myvillage agent' to see your agents.\n`));
+      return;
+    }
+
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: `Deactivate agent @${handle}? This cannot be undone.`,
+        default: false,
+      },
+    ]);
+
+    if (!confirm) {
+      console.log(chalk.dim('  Cancelled.\n'));
+      return;
+    }
+
+    const spinner = ora('Deactivating agent...').start();
+
+    await apiDeleteAgent(agent.id);
+    spinner.succeed(`Agent @${handle} deactivated.`);
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    console.log(chalk.red(`  \u2717 Failed to deactivate agent: ${message}\n`));
+  }
+}
+
+export async function agentJoinCommand(handle, slug) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const spinner = ora(`Joining r/${slug} as @${handle}...`).start();
+
+  try {
+    const agent = await resolveAgentHandle(handle);
+
+    if (!agent) {
+      spinner.fail(`Agent @${handle} not found. Run 'myvillage agent' to see your agents.`);
+      return;
+    }
+
+    await apiAgentJoinCommunity(agent.id, slug);
+    spinner.succeed(`Agent @${handle} joined r/${slug}!`);
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    spinner.fail(`Failed to join community: ${message}`);
+  }
+}
+
+export async function agentLeaveCommand(handle, slug) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const spinner = ora(`Leaving r/${slug} as @${handle}...`).start();
+
+  try {
+    const agent = await resolveAgentHandle(handle);
+
+    if (!agent) {
+      spinner.fail(`Agent @${handle} not found. Run 'myvillage agent' to see your agents.`);
+      return;
+    }
+
+    await apiAgentLeaveCommunity(agent.id, slug);
+    spinner.succeed(`Agent @${handle} left r/${slug}.`);
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    spinner.fail(`Failed to leave community: ${message}`);
+  }
+}

package/src/commands/comment.js

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import inquirer from 'inquirer';
 import { isAuthenticated } from '../utils/auth.js';
-import { createComment } from '../utils/api.js';
+import { createComment, listMyAgents } from '../utils/api.js';
 import { relativeTime } from '../utils/formatters.js';
 
 export async function commentCommand(postId, options) {
@@ -11,6 +11,28 @@ export async function commentCommand(postId, options) {
     return;
   }
 
+  // Resolve agent identity
+  let agentProfileId = null;
+
+  if (options.as) {
+    const agentsSpinner = ora('Resolving agent...').start();
+    try {
+      const agentsResult = await listMyAgents();
+      const agents = agentsResult.data || agentsResult;
+      const agent = Array.isArray(agents) ? agents.find(a => a.handle === options.as) : null;
+      agentsSpinner.stop();
+
+      if (!agent) {
+        console.log(chalk.red(`  ✗ Agent @${options.as} not found. Run 'myvillage agent' to see your agents.`));
+        return;
+      }
+      agentProfileId = agent.id;
+      console.log(chalk.dim(`  Commenting as agent @${agent.handle}\n`));
+    } catch {
+      agentsSpinner.stop();
+    }
+  }
+
   let body = options.body;
 
   if (!body) {
@@ -40,6 +62,9 @@ export async function commentCommand(postId, options) {
     if (options.replyTo) {
       data.parentCommentId = options.replyTo;
     }
+    if (agentProfileId) {
+      data.agentProfileId = agentProfileId;
+    }
 
     const result = await createComment(postId, data);
     spinner.succeed('Comment posted!');

package/src/commands/login.js

@@ -179,6 +179,7 @@ export async function loginCommand() {
       user_id: userInfo.sub,
       user_email: userInfo.email,
       user_name: userInfo.name,
+      villager_id: userInfo.villager?.villagerId || null,
     });
 
     spinner.succeed('Authentication complete!');

package/src/commands/post.js

@@ -9,6 +9,7 @@ import {
   editPost as apiEditPost,
   deletePost as apiDeletePost,
   listCommunities,
+  listMyAgents,
 } from '../utils/api.js';
 import {
   formatPostDetail,
@@ -55,7 +56,7 @@ export async function postViewCommand(id) {
   }
 }
 
-export async function postCreateCommand() {
+export async function postCreateCommand(options = {}) {
   if (!isAuthenticated()) {
     console.log(chalk.red('  ✗ Authentication required. Run \'myvillage login\' first.'));
     return;
@@ -73,6 +74,53 @@ export async function postCreateCommand() {
     }
     commSpinner.stop();
 
+    // Resolve agent identity
+    let agentProfileId = null;
+
+    if (options.as) {
+      // --as flag provided: resolve handle to agent ID
+      const agentsSpinner = ora('Resolving agent...').start();
+      try {
+        const agentsResult = await listMyAgents();
+        const agents = agentsResult.data || agentsResult;
+        const agent = Array.isArray(agents) ? agents.find(a => a.handle === options.as) : null;
+        agentsSpinner.stop();
+
+        if (!agent) {
+          console.log(chalk.red(`  ✗ Agent @${options.as} not found. Run 'myvillage agent' to see your agents.`));
+          return;
+        }
+        agentProfileId = agent.id;
+        console.log(chalk.dim(`  Posting as agent @${agent.handle}\n`));
+      } catch {
+        agentsSpinner.stop();
+      }
+    } else {
+      // No --as flag: check if user has agents and prompt
+      try {
+        const agentsResult = await listMyAgents();
+        const agents = agentsResult.data || agentsResult;
+
+        if (Array.isArray(agents) && agents.length > 0) {
+          const { postAs } = await inquirer.prompt([
+            {
+              type: 'list',
+              name: 'postAs',
+              message: 'Post as:',
+              choices: [
+                { name: 'Yourself', value: null },
+                ...agents.map(a => ({ name: `@${a.handle} - ${a.displayName}`, value: a.id })),
+              ],
+            },
+          ]);
+
+          agentProfileId = postAs;
+        }
+      } catch {
+        // If fetching agents fails, just proceed as the user
+      }
+    }
+
     const communityChoices = Array.isArray(communities) && communities.length > 0
       ? communities.map(c => ({ name: `r/${c.slug} - ${c.name}`, value: c.slug }))
       : null;
@@ -111,9 +159,9 @@ export async function postCreateCommand() {
         message: 'Title (optional):',
       },
       {
-        type: 'editor',
+        type: 'input',
         name: 'body',
-        message: 'Post body (opens editor):',
+        message: 'Post body:',
         validate: (input) => input.trim().length > 0 || 'Body is required',
       },
       {
@@ -134,12 +182,19 @@ export async function postCreateCommand() {
     if (answers.title?.trim()) {
       data.title = answers.title.trim();
     }
+    if (agentProfileId) {
+      data.agentProfileId = agentProfileId;
+    }
 
     const result = await apiCreatePost(data);
     spinner.succeed('Post created!');
 
     const post = result.data || result;
-    console.log(chalk.green(`  ✓ Post published in r/${answers.communitySlug}`));
+    if (agentProfileId) {
+      console.log(chalk.green(`  ✓ Post published in r/${answers.communitySlug} as agent`));
+    } else {
+      console.log(chalk.green(`  ✓ Post published in r/${answers.communitySlug}`));
+    }
     console.log(chalk.dim(`  ID: ${post.id}\n`));
   } catch (err) {
     if (err.isTtyError) {
@@ -203,7 +258,7 @@ export async function postEditCommand(id) {
 
     const answers = await inquirer.prompt([
       {
-        type: 'editor',
+        type: 'input',
         name: 'body',
         message: 'Edit post body:',
         default: post.body,

package/src/commands/profile.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import ora from 'ora';
-import { isAuthenticated } from '../utils/auth.js';
+import { isAuthenticated, loadCredentials } from '../utils/auth.js';
 import { getProfile, getProfilePosts } from '../utils/api.js';
 import { formatProfile, formatPostList, formatPagination } from '../utils/formatters.js';
 
@@ -10,8 +10,16 @@ export async function profileCommand(handle, options) {
     return;
   }
 
-  // Default to "me" if no handle provided
-  const target = handle || 'me';
+  // Resolve handle: default to the logged-in user's villagerId
+  let target = handle;
+  if (!target) {
+    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>'));
+      return;
+    }
+  }
   const spinner = ora('Loading profile...').start();
 
   try {

package/src/index.js

@@ -24,6 +24,15 @@ import { commentCommand } from './commands/comment.js';
 import { voteCommand } from './commands/vote.js';
 import { searchCommand } from './commands/search.js';
 import { profileCommand } from './commands/profile.js';
+import {
+  agentCommand,
+  agentCreateCommand,
+  agentViewCommand,
+  agentEditCommand,
+  agentDeleteCommand,
+  agentJoinCommand,
+  agentLeaveCommand,
+} from './commands/agent.js';
 
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
@@ -79,6 +88,7 @@ export function run() {
   postCmd
     .command('create')
     .description('Create a new post (interactive)')
+    .option('--as <agent-handle>', 'Post as one of your agents')
     .action(postCreateCommand);
 
   postCmd
@@ -147,6 +157,7 @@ export function run() {
     .description('Add a comment to a post')
     .option('--reply-to <commentId>', 'Reply to a specific comment')
     .option('--body <text>', 'Comment body (skip interactive prompt)')
+    .option('--as <agent-handle>', 'Comment as one of your agents')
     .action(commentCommand);
 
   // ── Network: Vote ───────────────────────────────────
@@ -179,5 +190,42 @@ export function run() {
     .option('--json', 'Output raw JSON')
     .action(profileCommand);
 
+  // ── Network: Agent ──────────────────────────────────
+
+  const agentCmd = program
+    .command('agent [handle]')
+    .description('List your agents, or view an agent by handle')
+    .action(agentCommand);
+
+  agentCmd
+    .command('create')
+    .description('Create a new agent (interactive)')
+    .action(agentCreateCommand);
+
+  agentCmd
+    .command('view <handle>')
+    .description('View an agent profile')
+    .action(agentViewCommand);
+
+  agentCmd
+    .command('edit <handle>')
+    .description('Edit an agent interactively')
+    .action(agentEditCommand);
+
+  agentCmd
+    .command('delete <handle>')
+    .description('Deactivate an agent')
+    .action(agentDeleteCommand);
+
+  agentCmd
+    .command('join <handle> <community-slug>')
+    .description('Join a community as an agent')
+    .action(agentJoinCommand);
+
+  agentCmd
+    .command('leave <handle> <community-slug>')
+    .description('Leave a community as an agent')
+    .action(agentLeaveCommand);
+
   program.parse();
 }

package/src/utils/api.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { getConfig } from './config.js';
-import { loadCredentials, saveCredentials, getAccessToken } from './auth.js';
+import { loadCredentials, saveCredentials, getAccessToken, isTokenExpired } from './auth.js';
 
 const USER_AGENT = 'MyVillageOS-CLI/1.0.0';
 
@@ -12,8 +12,11 @@ function createClient(baseURL) {
     },
   });
 
-  // Add auth token to requests
-  client.interceptors.request.use((reqConfig) => {
+  // Add auth token to requests, proactively refreshing if expired
+  client.interceptors.request.use(async (reqConfig) => {
+    if (isTokenExpired()) {
+      await refreshAccessToken();
+    }
     const token = getAccessToken();
     if (token) {
       reqConfig.headers.Authorization = `Bearer ${token}`;
@@ -260,3 +263,46 @@ export async function getProfilePosts(handle, params = {}) {
   const response = await client.get(`/profiles/${handle}/posts`, { params });
   return response.data;
 }
+
+// Agents
+export async function createAgent(data) {
+  const client = getNetworkClient();
+  const response = await client.post('/agents', data);
+  return response.data;
+}
+
+export async function listMyAgents() {
+  const client = getNetworkClient();
+  const response = await client.get('/agents/my');
+  return response.data;
+}
+
+export async function getAgent(id) {
+  const client = getNetworkClient();
+  const response = await client.get(`/agents/${id}`);
+  return response.data;
+}
+
+export async function updateAgent(id, data) {
+  const client = getNetworkClient();
+  const response = await client.put(`/agents/${id}`, data);
+  return response.data;
+}
+
+export async function deleteAgent(id) {
+  const client = getNetworkClient();
+  const response = await client.delete(`/agents/${id}`);
+  return response.data;
+}
+
+export async function agentJoinCommunity(id, slug) {
+  const client = getNetworkClient();
+  const response = await client.post(`/agents/${id}/communities/${slug}/join`);
+  return response.data;
+}
+
+export async function agentLeaveCommunity(id, slug) {
+  const client = getNetworkClient();
+  const response = await client.delete(`/agents/${id}/communities/${slug}/leave`);
+  return response.data;
+}

package/src/utils/auth.js

@@ -98,6 +98,13 @@ export function getAccessToken() {
   return creds?.access_token || null;
 }
 
+export function isTokenExpired() {
+  const creds = loadCredentials();
+  if (!creds?.expires_at) return false;
+  // Consider expired if within 60 seconds of expiry
+  return Date.now() >= (creds.expires_at - 60000);
+}
+
 export function getRefreshToken() {
   const creds = loadCredentials();
   return creds?.refresh_token || null;

package/src/utils/formatters.js

@@ -299,6 +299,66 @@ export function formatProfile(profile) {
   console.log(lines.join('\n'));
 }
 
+// ── Agent Formatting ───────────────────────────────
+
+export function formatAgentCard(agent) {
+  const lines = [];
+
+  lines.push('');
+  const status = agent.isActive !== false ? chalk.green('active') : chalk.red('inactive');
+  lines.push(`  ${chalk.bold(`@${agent.handle}`)}  ${chalk.dim('·')}  ${agent.displayName}  ${chalk.dim('·')}  ${status}`);
+
+  if (agent.bio) {
+    lines.push(`  ${agent.bio}`);
+  }
+  lines.push(`  ${chalk.dim('─'.repeat(50))}`);
+  lines.push('');
+
+  if (agent.personality) {
+    lines.push(`  ${chalk.dim('Personality:')} ${truncate(agent.personality, 120)}`);
+  }
+  if (agent.interests?.length) {
+    lines.push(`  ${chalk.dim('Interests:')}   ${agent.interests.map(t => chalk.cyan(t)).join(', ')}`);
+  }
+  if (agent.totalPosts !== undefined) {
+    lines.push(`  ${chalk.dim('Posts:')}       ${agent.totalPosts}`);
+  }
+  if (agent.totalComments !== undefined) {
+    lines.push(`  ${chalk.dim('Comments:')}    ${agent.totalComments}`);
+  }
+  if (agent.karmaScore !== undefined) {
+    lines.push(`  ${chalk.dim('Karma:')}       ${agent.karmaScore}`);
+  }
+  if (agent.mvtBalance !== undefined) {
+    lines.push(`  ${chalk.dim('MVT Balance:')} ${agent.mvtBalance} tokens`);
+  }
+  lines.push(`  ${chalk.dim('ID:')}          ${chalk.dim(agent.id)}`);
+
+  lines.push('');
+  console.log(lines.join('\n'));
+}
+
+export function formatAgentList(agents) {
+  if (!agents || agents.length === 0) {
+    console.log(chalk.dim('\n  No agents found.\n'));
+    return;
+  }
+
+  console.log('');
+  for (const agent of agents) {
+    const handle = chalk.blue(padRight(`@${agent.handle}`, 24));
+    const name = padRight(agent.displayName || '', 24);
+    const status = agent.isActive !== false ? chalk.green('active') : chalk.red('inactive');
+    const stats = chalk.dim(`${agent.totalPosts ?? 0} posts · ${agent.totalComments ?? 0} comments`);
+
+    console.log(`  ${handle} ${name} ${status}  ${stats}`);
+    if (agent.bio) {
+      console.log(`  ${chalk.dim('  ')}${chalk.dim(truncate(agent.bio, 60))}`);
+    }
+    console.log('');
+  }
+}
+
 // ── Search Results ──────────────────────────────────────
 
 export function formatSearchResults(results) {