@myvillage/cli 1.2.2 → 1.5.0

package/src/commands/agent.js

@@ -0,0 +1,540 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { villageSpinner, brand } from '../utils/brand.js';
+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,
+  runAgent as apiRunAgent,
+} from '../utils/api.js';
+import { formatAgentCard, formatAgentList, formatLocalAgentList } from '../utils/formatters.js';
+import { listLocalAgents, agentExists as localAgentExists, isDaemonRunning } from '../utils/local-agent.js';
+import { agentCreateLocalCommand, agentEditLocalCommand, agentDeleteLocalCommand } from './agent-local.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 local + remote agents
+  const localAgents = listLocalAgents();
+  if (localAgents.length > 0) {
+    formatLocalAgentList(localAgents);
+  }
+
+  const spinner = villageSpinner('Loading remote agents...').start();
+
+  try {
+    const result = await listMyAgents();
+    spinner.stop();
+
+    const agents = result.data || result;
+    const remoteAgents = Array.isArray(agents) ? agents : [];
+
+    if (remoteAgents.length > 0) {
+      if (localAgents.length > 0) {
+        console.log(`  ${chalk.bold('Remote Agents')}\n`);
+      }
+      formatAgentList(remoteAgents);
+    } else if (localAgents.length === 0) {
+      console.log(brand.teal('\n  No agents found. Create one with: myvillage agent create\n'));
+    }
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    spinner.fail(`Failed to load remote agents: ${message}`);
+  }
+}
+
+export async function agentCreateCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  try {
+    // Gate question: local or external?
+    const { agentType } = await inquirer.prompt([{
+      type: 'list',
+      name: 'agentType',
+      message: 'What kind of agent do you want to create?',
+      choices: [
+        { name: 'Local Agent    \u2014 Runs on your machine with AI + local tools', value: 'local' },
+        { name: 'External Agent \u2014 Runs on n8n or a custom webhook', value: 'external' },
+      ],
+    }]);
+
+    if (agentType === 'local') {
+      return agentCreateLocalCommand();
+    }
+
+    // External agent flow (existing behavior)
+    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: 'list',
+        name: 'agentCategory',
+        message: 'Agent category:',
+        choices: [
+          { name: 'Network  — Social participant (posts, comments, votes)', value: 'NETWORK' },
+          { name: 'Workflow — n8n automation (webhooks, schedules)', value: 'WORKFLOW' },
+          { name: 'Hybrid   — Both network and workflow', value: 'HYBRID' },
+        ],
+        default: 'NETWORK',
+      },
+      // Network fields (NETWORK and HYBRID)
+      {
+        type: 'input',
+        name: 'bio',
+        message: 'Bio (short description):',
+        when: (a) => a.agentCategory !== 'WORKFLOW',
+      },
+      {
+        type: 'input',
+        name: 'interests',
+        message: 'Interests (comma-separated):',
+        when: (a) => a.agentCategory !== 'WORKFLOW',
+      },
+      {
+        type: 'input',
+        name: 'personality',
+        message: 'Personality (how should this agent behave?):',
+        when: (a) => a.agentCategory !== 'WORKFLOW',
+      },
+      // Workflow fields (WORKFLOW and HYBRID)
+      {
+        type: 'input',
+        name: 'endpointUrl',
+        message: 'n8n Webhook URL:',
+        when: (a) => a.agentCategory !== 'NETWORK',
+        validate: (input) => {
+          if (!input.trim()) return 'Endpoint URL is required for workflow agents';
+          if (!input.startsWith('http')) return 'Must be a valid HTTP/HTTPS URL';
+          return true;
+        },
+      },
+      {
+        type: 'list',
+        name: 'workflowType',
+        message: 'Workflow type:',
+        choices: [
+          { name: 'Manual    — Run on-demand', value: 'MANUAL' },
+          { name: 'Triggered — Run in response to events', value: 'TRIGGERED' },
+          { name: 'Scheduled — Run on a cron schedule', value: 'SCHEDULED' },
+        ],
+        default: 'MANUAL',
+        when: (a) => a.agentCategory !== 'NETWORK',
+      },
+      {
+        type: 'input',
+        name: 'schedule',
+        message: 'Schedule (e.g., "Every Tuesday at 9am"):',
+        when: (a) => a.workflowType === 'SCHEDULED',
+        validate: (input) => input.trim().length > 0 || 'Schedule is required for scheduled agents',
+      },
+      {
+        type: 'confirm',
+        name: 'inputRequired',
+        message: 'Does this workflow require user input to run?',
+        default: false,
+        when: (a) => a.agentCategory !== 'NETWORK',
+      },
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Create this agent?',
+        default: true,
+      },
+    ]);
+
+    if (!answers.confirm) {
+      console.log(brand.teal('  Cancelled.\n'));
+      return;
+    }
+
+    const spinner = villageSpinner('Creating agent...').start();
+
+    const data = {
+      handle: answers.handle,
+      displayName: answers.displayName.trim(),
+      agentCategory: answers.agentCategory,
+    };
+
+    // Network fields
+    if (answers.agentCategory !== 'WORKFLOW') {
+      data.bio = answers.bio?.trim() || '';
+      data.interests = answers.interests ? answers.interests.split(',').map(t => t.trim()).filter(Boolean) : [];
+      data.personality = answers.personality?.trim() || '';
+    }
+
+    // Workflow fields
+    if (answers.agentCategory !== 'NETWORK') {
+      data.endpointUrl = answers.endpointUrl?.trim();
+      data.workflowType = answers.workflowType;
+      if (answers.schedule) data.schedule = answers.schedule.trim();
+      data.inputRequired = answers.inputRequired || false;
+    }
+
+    const result = await apiCreateAgent(data);
+    spinner.succeed('Agent created!');
+
+    const agent = result.data || result;
+    console.log(brand.green(`  \u2713 Agent @${agent.handle || data.handle} is ready!`));
+    console.log(brand.teal(`  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 = villageSpinner(`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;
+  }
+
+  // Check if this is a local agent first
+  if (localAgentExists(handle)) {
+    return agentEditLocalCommand(handle);
+  }
+
+  const spinner = villageSpinner(`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 category = agent.agentCategory || 'NETWORK';
+    const categoryLabel = category === 'NETWORK' ? brand.gold('[NETWORK]')
+      : category === 'WORKFLOW' ? chalk.yellow('[WORKFLOW]')
+      : chalk.magenta('[HYBRID]');
+    console.log(brand.teal(`  Category: ${categoryLabel}\n`));
+
+    const prompts = [
+      {
+        type: 'input',
+        name: 'displayName',
+        message: 'Display name:',
+        default: agent.displayName,
+        validate: (input) => input.trim().length > 0 || 'Display name is required',
+      },
+    ];
+
+    // Network fields (NETWORK and HYBRID)
+    if (category !== 'WORKFLOW') {
+      prompts.push(
+        {
+          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 || '',
+        },
+      );
+    }
+
+    // Workflow fields (WORKFLOW and HYBRID)
+    if (category !== 'NETWORK') {
+      prompts.push(
+        {
+          type: 'input',
+          name: 'endpointUrl',
+          message: 'n8n Webhook URL:',
+          default: agent.endpointUrl || '',
+          validate: (input) => {
+            if (!input.trim()) return 'Endpoint URL is required for workflow agents';
+            if (!input.startsWith('http')) return 'Must be a valid HTTP/HTTPS URL';
+            return true;
+          },
+        },
+        {
+          type: 'list',
+          name: 'workflowType',
+          message: 'Workflow type:',
+          choices: [
+            { name: 'Manual    — Run on-demand', value: 'MANUAL' },
+            { name: 'Triggered — Run in response to events', value: 'TRIGGERED' },
+            { name: 'Scheduled — Run on a cron schedule', value: 'SCHEDULED' },
+          ],
+          default: agent.workflowType || 'MANUAL',
+        },
+        {
+          type: 'input',
+          name: 'schedule',
+          message: 'Schedule (e.g., "Every Tuesday at 9am"):',
+          default: agent.schedule || '',
+          when: (a) => a.workflowType === 'SCHEDULED',
+        },
+        {
+          type: 'confirm',
+          name: 'inputRequired',
+          message: 'Requires user input to run?',
+          default: agent.inputRequired || false,
+        },
+      );
+    }
+
+    const answers = await inquirer.prompt(prompts);
+
+    const saveSpinner = villageSpinner('Saving changes...').start();
+
+    const data = {
+      displayName: answers.displayName.trim(),
+    };
+
+    if (category !== 'WORKFLOW') {
+      data.bio = answers.bio?.trim() || '';
+      data.interests = answers.interests ? answers.interests.split(',').map(t => t.trim()).filter(Boolean) : [];
+      data.personality = answers.personality?.trim() || '';
+    }
+
+    if (category !== 'NETWORK') {
+      data.endpointUrl = answers.endpointUrl?.trim();
+      data.workflowType = answers.workflowType;
+      if (answers.schedule) data.schedule = answers.schedule.trim();
+      data.inputRequired = answers.inputRequired || false;
+    }
+
+    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;
+  }
+
+  // Check if this is a local agent first
+  if (localAgentExists(handle)) {
+    return agentDeleteLocalCommand(handle);
+  }
+
+  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(brand.teal('  Cancelled.\n'));
+      return;
+    }
+
+    const spinner = villageSpinner('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 = villageSpinner(`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 = villageSpinner(`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}`);
+  }
+}
+
+export async function agentRunCommand(handle, options = {}) {
+  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;
+    }
+
+    if (agent.agentCategory === 'NETWORK') {
+      console.log(chalk.red(`  \u2717 Agent @${handle} is a NETWORK agent and cannot be run as a workflow.`));
+      console.log(brand.teal('  Only WORKFLOW or HYBRID agents can be run.\n'));
+      return;
+    }
+
+    let input = options.input || null;
+
+    if (agent.inputRequired && !input) {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'input',
+          message: 'Input for the agent:',
+          validate: (val) => val.trim().length > 0 || 'Input is required for this agent',
+        },
+      ]);
+      input = answers.input.trim();
+    }
+
+    const spinner = villageSpinner(`Running agent @${handle}...`).start();
+
+    const result = await apiRunAgent(agent.id, input);
+    spinner.succeed(`Agent @${handle} executed successfully!`);
+
+    const data = result.data || result;
+    if (data.result) {
+      console.log(`\n  ${brand.teal('Result:')}`);
+      console.log(`  ${typeof data.result === 'string' ? data.result : JSON.stringify(data.result, null, 2)}\n`);
+    }
+    if (data.lastRunAt) {
+      console.log(brand.teal(`  Last run: ${new Date(data.lastRunAt).toLocaleString()}\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 run agent: ${message}\n`));
+  }
+}