@myvillage/cli 1.3.0 → 1.5.1

package/src/commands/agent.js

@@ -1,5 +1,6 @@
 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 {
@@ -9,8 +10,11 @@ import {
   deleteAgent as apiDeleteAgent,
   agentJoinCommunity as apiAgentJoinCommunity,
   agentLeaveCommunity as apiAgentLeaveCommunity,
+  runAgent as apiRunAgent,
 } from '../utils/api.js';
-import { formatAgentCard, formatAgentList } from '../utils/formatters.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 ──────────────────────────
 
@@ -33,18 +37,32 @@ export async function agentCommand(handle) {
     return agentViewCommand(handle);
   }
 
-  // No args: list my agents
-  const spinner = ora('Loading your agents...').start();
+  // 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;
-    formatAgentList(Array.isArray(agents) ? agents : []);
+    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 agents: ${message}`);
+    spinner.fail(`Failed to load remote agents: ${message}`);
   }
 }
 
@@ -55,6 +73,22 @@ export async function agentCreateCommand() {
   }
 
   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',
@@ -76,20 +110,73 @@ export async function agentCreateCommand() {
         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',
@@ -100,26 +187,39 @@ export async function agentCreateCommand() {
     ]);
 
     if (!answers.confirm) {
-      console.log(chalk.dim('  Cancelled.\n'));
+      console.log(brand.teal('  Cancelled.\n'));
       return;
     }
 
-    const spinner = ora('Creating agent...').start();
+    const spinner = villageSpinner('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() || '',
+      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(chalk.green(`  \u2713 Agent @${agent.handle || data.handle} is ready!`));
-    console.log(chalk.dim(`  ID: ${agent.id}\n`));
+    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'));
@@ -136,7 +236,7 @@ export async function agentViewCommand(handle) {
     return;
   }
 
-  const spinner = ora(`Loading agent @${handle}...`).start();
+  const spinner = villageSpinner(`Loading agent @${handle}...`).start();
 
   try {
     const agent = await resolveAgentHandle(handle);
@@ -160,7 +260,12 @@ export async function agentEditCommand(handle) {
     return;
   }
 
-  const spinner = ora(`Loading agent @${handle}...`).start();
+  // 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);
@@ -172,7 +277,13 @@ export async function agentEditCommand(handle) {
 
     spinner.stop();
 
-    const answers = await inquirer.prompt([
+    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',
@@ -180,35 +291,94 @@ export async function agentEditCommand(handle) {
         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 || '',
-      },
-    ]);
+    ];
+
+    // 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 = ora('Saving changes...').start();
+    const saveSpinner = villageSpinner('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() || '',
     };
 
+    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) {
@@ -227,6 +397,11 @@ export async function agentDeleteCommand(handle) {
     return;
   }
 
+  // Check if this is a local agent first
+  if (localAgentExists(handle)) {
+    return agentDeleteLocalCommand(handle);
+  }
+
   try {
     const agent = await resolveAgentHandle(handle);
 
@@ -245,11 +420,11 @@ export async function agentDeleteCommand(handle) {
     ]);
 
     if (!confirm) {
-      console.log(chalk.dim('  Cancelled.\n'));
+      console.log(brand.teal('  Cancelled.\n'));
       return;
     }
 
-    const spinner = ora('Deactivating agent...').start();
+    const spinner = villageSpinner('Deactivating agent...').start();
 
     await apiDeleteAgent(agent.id);
     spinner.succeed(`Agent @${handle} deactivated.`);
@@ -265,7 +440,7 @@ export async function agentJoinCommand(handle, slug) {
     return;
   }
 
-  const spinner = ora(`Joining r/${slug} as @${handle}...`).start();
+  const spinner = villageSpinner(`Joining r/${slug} as @${handle}...`).start();
 
   try {
     const agent = await resolveAgentHandle(handle);
@@ -289,7 +464,7 @@ export async function agentLeaveCommand(handle, slug) {
     return;
   }
 
-  const spinner = ora(`Leaving r/${slug} as @${handle}...`).start();
+  const spinner = villageSpinner(`Leaving r/${slug} as @${handle}...`).start();
 
   try {
     const agent = await resolveAgentHandle(handle);
@@ -306,3 +481,60 @@ export async function agentLeaveCommand(handle, slug) {
     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`));
+  }
+}