@myvillage/cli 1.2.2 → 1.5.0

package/src/agent-runtime/scheduler.js

@@ -0,0 +1,53 @@
+// ── Scheduler ───────────────────────────────────────────
+// Active hours checking and interval timing for agent loops.
+
+export function isWithinActiveHours(schedule) {
+  if (!schedule?.active_hours?.start || !schedule?.active_hours?.end) {
+    return true; // No active hours configured = always active
+  }
+
+  const now = new Date();
+  const tz = schedule.timezone || undefined;
+
+  // Get current hours/minutes in the configured timezone
+  let currentHours, currentMinutes;
+  if (tz) {
+    try {
+      const formatter = new Intl.DateTimeFormat('en-US', {
+        timeZone: tz,
+        hour: 'numeric',
+        minute: 'numeric',
+        hour12: false,
+      });
+      const parts = formatter.formatToParts(now);
+      currentHours = parseInt(parts.find(p => p.type === 'hour')?.value || '0');
+      currentMinutes = parseInt(parts.find(p => p.type === 'minute')?.value || '0');
+    } catch {
+      // Fallback to local time if timezone is invalid
+      currentHours = now.getHours();
+      currentMinutes = now.getMinutes();
+    }
+  } else {
+    currentHours = now.getHours();
+    currentMinutes = now.getMinutes();
+  }
+
+  const currentTime = currentHours * 60 + currentMinutes;
+
+  const [startH, startM] = schedule.active_hours.start.split(':').map(Number);
+  const [endH, endM] = schedule.active_hours.end.split(':').map(Number);
+  const startTime = startH * 60 + (startM || 0);
+  const endTime = endH * 60 + (endM || 0);
+
+  if (startTime <= endTime) {
+    return currentTime >= startTime && currentTime <= endTime;
+  }
+  // Handles overnight ranges (e.g., 22:00 - 06:00)
+  return currentTime >= startTime || currentTime <= endTime;
+}
+
+export function getNextCheckInMs(schedule) {
+  const interval = schedule?.check_in_interval;
+  if (!interval || interval <= 0) return 0; // manual only
+  return interval * 60 * 1000;
+}

package/src/commands/agent-local.js

@@ -0,0 +1,607 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { villageSpinner, brand } from '../utils/brand.js';
+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 { getConfig, setConfig } from '../utils/config.js';
+import {
+  createAgent as apiCreateAgent,
+  agentJoinCommunity as apiAgentJoinCommunity,
+  listCommunities,
+  getAgentActivity,
+} from '../utils/api.js';
+import {
+  getAgentDir,
+  agentExists,
+  readAgentConfig,
+  writeAgentConfig,
+  readToolsYaml,
+  writeToolsYaml,
+  isDaemonRunning,
+  getDaemonInfo,
+  cleanupPidFile,
+  listLocalAgents,
+  readAgentLogs,
+  getLogFilePath,
+} from '../utils/local-agent.js';
+import { scaffoldAgent, TOOL_CATALOG } from '../utils/agent-scaffolder.js';
+import { formatLocalAgentList, formatLocalAgentStatus } from '../utils/formatters.js';
+
+// ── Create Local Agent (wizard) ─────────────────────────
+
+export async function agentCreateLocalCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  try {
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: 'Agent name (lowercase, no spaces):',
+        validate: (input) => {
+          const trimmed = input.trim().toLowerCase();
+          if (trimmed.length === 0) return 'Name is required';
+          if (trimmed.length < 3) return 'Name must be at least 3 characters';
+          if (trimmed.length > 30) return 'Name must be 30 characters or less';
+          if (!/^[a-z0-9_-]+$/.test(trimmed)) return 'Only lowercase letters, numbers, hyphens, and underscores allowed';
+          if (agentExists(trimmed)) return `Agent "${trimmed}" already exists`;
+          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: 'description',
+        message: 'Describe your agent\'s role:',
+        validate: (input) => input.trim().length > 0 || 'Description is required',
+      },
+      {
+        type: 'checkbox',
+        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: 'Local Files (read/write project files)', value: 'filesystem', checked: true },
+          { name: 'Gmail', value: 'gmail' },
+          { name: 'Calendar', value: 'calendar' },
+          { name: 'GitHub', value: 'github' },
+          { name: 'Browser', value: 'browser' },
+        ],
+      },
+      {
+        type: 'list',
+        name: 'checkInInterval',
+        message: 'How often should it check in?',
+        choices: [
+          { name: 'Every 15 minutes', value: '15min' },
+          { name: 'Every hour', value: '1hr' },
+          { name: 'Twice a day', value: 'twice-daily' },
+          { name: 'Only when I ask', value: 'manual' },
+        ],
+        default: '1hr',
+      },
+      {
+        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 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')];
+
+    scaffoldAgent(agentDir, {
+      name: answers.name,
+      displayName: answers.displayName.trim(),
+      description: answers.description.trim(),
+      tools,
+      checkInInterval: answers.checkInInterval,
+    });
+
+    spinner.succeed('Agent scaffolded!');
+
+    console.log(brand.green(`  \u2713 Agent created at ~/.myvillage/agents/${answers.name}/\n`));
+    console.log(brand.teal('  Next steps:'));
+    console.log(`    ${brand.gold(`myvillage agent start ${answers.name}`)}   Launch the agent`);
+    console.log(`    ${brand.gold(`myvillage agent edit ${answers.name}`)}    Customize the prompt`);
+    console.log(`    ${brand.gold(`myvillage agent logs ${answers.name}`)}    View activity\n`);
+  } catch (err) {
+    if (err.isTtyError) {
+      console.log(chalk.red('  \u2717 Prompts cannot be rendered in this environment.\n'));
+      return;
+    }
+    console.log(chalk.red(`  \u2717 Failed to create agent: ${err.message}\n`));
+  }
+}
+
+// ── Start Agent ─────────────────────────────────────────
+
+export async function agentStartCommand(name) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  if (!agentExists(name)) {
+    console.log(chalk.red(`  \u2717 Agent "${name}" not found. Run 'myvillage agent' to see your agents.\n`));
+    return;
+  }
+
+  if (isDaemonRunning(name)) {
+    console.log(chalk.yellow(`  Agent "${name}" is already running.\n`));
+    return;
+  }
+
+  // Check for Anthropic API key
+  const config = getConfig();
+  let apiKey = config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+
+  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'));
+
+    try {
+      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();
+      setConfig({ anthropicApiKey: apiKey });
+      console.log(brand.green('  \u2713 API key saved.\n'));
+    } catch (err) {
+      if (err.isTtyError) {
+        console.log(chalk.red('  \u2717 Prompts cannot be rendered in this environment.\n'));
+      }
+      return;
+    }
+  }
+
+  // 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 {
+      const result = await apiCreateAgent({
+        handle: agentConfig.name,
+        displayName: agentConfig.display_name,
+        agentCategory: 'NETWORK',
+        bio: agentConfig.description || '',
+        interests: [],
+        personality: '',
+      });
+
+      const agent = result.data || result;
+      agentConfig.man = agentConfig.man || {};
+      agentConfig.man.agent_id = agent.id;
+      writeAgentConfig(name, agentConfig);
+
+      regSpinner.succeed(`Registered as @${agent.handle || agentConfig.name} on MAN.`);
+
+      // Auto-join default communities so the agent can post
+      try {
+        const commResult = await listCommunities({ pageSize: 50 });
+        const communities = commResult.data || commResult;
+        const defaults = Array.isArray(communities)
+          ? communities.filter(c => c.isDefault)
+          : [];
+
+        if (defaults.length > 0) {
+          const joinedSlugs = [];
+          for (const comm of defaults) {
+            try {
+              await apiAgentJoinCommunity(agent.id, comm.slug);
+              joinedSlugs.push(comm.slug);
+            } catch {
+              // Already a member or join failed — skip silently
+            }
+          }
+          if (joinedSlugs.length > 0) {
+            console.log(brand.teal(`  Joined communities: ${joinedSlugs.map(s => 'r/' + s).join(', ')}`));
+          }
+        }
+      } catch {
+        // Could not fetch communities — not critical, continue
+      }
+    } catch (err) {
+      const message = err.response?.data?.error || err.response?.data?.message || err.message;
+      regSpinner.fail(`Failed to register on MAN: ${message}`);
+      console.log(brand.teal('  The agent will still run locally but cannot post to the feed.\n'));
+      // Continue anyway — agent can still do local work
+    }
+  }
+
+  // Fork the daemon process
+  const spinner = villageSpinner(`Starting agent "${name}"...`).start();
+
+  try {
+    const { startDaemon } = await import('../agent-runtime/daemon.js');
+    startDaemon(name);
+
+    // Wait briefly for PID file to appear
+    await new Promise(resolve => setTimeout(resolve, 800));
+
+    if (isDaemonRunning(name)) {
+      spinner.succeed(`Agent "${name}" is running.`);
+      const info = getDaemonInfo(name);
+      if (info) {
+        console.log(brand.teal(`  PID: ${info.pid}`));
+      }
+      console.log(brand.teal(`  Logs: myvillage agent logs ${name}\n`));
+    } else {
+      spinner.fail(`Agent "${name}" failed to start. Check logs for details.`);
+    }
+  } catch (err) {
+    spinner.fail(`Failed to start agent: ${err.message}`);
+  }
+}
+
+// ── Stop Agent ──────────────────────────────────────────
+
+export async function agentStopCommand(name) {
+  if (!agentExists(name)) {
+    console.log(chalk.red(`  \u2717 Agent "${name}" not found.\n`));
+    return;
+  }
+
+  if (!isDaemonRunning(name)) {
+    console.log(brand.teal(`  Agent "${name}" is not running.\n`));
+    return;
+  }
+
+  const spinner = villageSpinner(`Stopping agent "${name}"...`).start();
+
+  try {
+    const { stopDaemon } = await import('../agent-runtime/daemon.js');
+    stopDaemon(name);
+
+    // Wait for PID file to be deleted (up to 10 seconds)
+    const deadline = Date.now() + 10000;
+    while (Date.now() < deadline && isDaemonRunning(name)) {
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+
+    if (!isDaemonRunning(name)) {
+      spinner.succeed(`Agent "${name}" stopped.`);
+    } else {
+      // Force kill
+      const info = getDaemonInfo(name);
+      if (info) {
+        try { process.kill(info.pid, 'SIGKILL'); } catch { /* ignore */ }
+      }
+      cleanupPidFile(name);
+      spinner.warn(`Agent "${name}" force-stopped.`);
+    }
+  } catch (err) {
+    spinner.fail(`Failed to stop agent: ${err.message}`);
+  }
+}
+
+// ── Status ──────────────────────────────────────────────
+
+export async function agentStatusCommand(name, options = {}) {
+  if (name) {
+    // Single agent status
+    if (!agentExists(name)) {
+      console.log(chalk.red(`  \u2717 Agent "${name}" not found.\n`));
+      return;
+    }
+
+    const config = readAgentConfig(name);
+    const running = isDaemonRunning(name);
+    const daemonInfo = getDaemonInfo(name);
+    const logs = readAgentLogs(name, { limit: 100 });
+
+    let serverActivity = null;
+    if (options.remote && config?.man?.agent_id) {
+      try {
+        const result = await getAgentActivity(config.man.agent_id, {
+          pageSize: 20,
+          types: 'post,comment,vote',
+        });
+        serverActivity = result.data || result;
+      } catch {
+        console.log(brand.teal('  (Could not fetch server-side activity)\n'));
+      }
+    }
+
+    formatLocalAgentStatus({
+      name,
+      config,
+      isRunning: running,
+      lastHeartbeat: daemonInfo?.lastHeartbeat || null,
+      startedAt: daemonInfo?.startedAt || null,
+      logs,
+      serverActivity,
+    });
+    return;
+  }
+
+  // All agents status
+  const agents = listLocalAgents();
+
+  if (agents.length === 0) {
+    console.log(brand.teal('\n  No local agents found. Create one with: myvillage agent create\n'));
+    return;
+  }
+
+  formatLocalAgentList(agents);
+}
+
+// ── Logs ────────────────────────────────────────────────
+
+export async function agentLogsCommand(name, options = {}) {
+  if (!agentExists(name)) {
+    console.log(chalk.red(`  \u2717 Agent "${name}" not found.\n`));
+    return;
+  }
+
+  if (options.follow) {
+    // Follow mode — watch for new log entries
+    const logFile = getLogFilePath(name);
+    console.log(brand.teal(`  Watching ${logFile}...\n`));
+
+    // Print existing entries first
+    const existing = readAgentLogs(name, { limit: 20 });
+    for (const entry of existing) {
+      printLogEntry(entry);
+    }
+
+    if (!existsSync(logFile)) {
+      console.log(brand.teal('  No log file yet. Waiting for agent activity...\n'));
+    }
+
+    // Watch for changes
+    let lastSize = 0;
+    const interval = setInterval(() => {
+      try {
+        if (!existsSync(logFile)) return;
+        const content = readFileSync(logFile, 'utf-8');
+        if (content.length > lastSize) {
+          const newContent = content.slice(lastSize);
+          const newLines = newContent.split('\n').filter(Boolean);
+          for (const line of newLines) {
+            try {
+              printLogEntry(JSON.parse(line));
+            } catch { /* skip */ }
+          }
+          lastSize = content.length;
+        }
+      } catch { /* ignore */ }
+    }, 1000);
+
+    // Keep running until Ctrl+C
+    process.on('SIGINT', () => {
+      clearInterval(interval);
+      console.log(brand.teal('\n  Stopped following logs.\n'));
+      process.exit(0);
+    });
+
+    // Block forever
+    await new Promise(() => {});
+    return;
+  }
+
+  // Regular mode — print recent logs
+  const entries = readAgentLogs(name, {
+    since: options.since,
+    limit: 50,
+  });
+
+  if (entries.length === 0) {
+    console.log(brand.teal('\n  No log entries found.\n'));
+    return;
+  }
+
+  console.log('');
+  for (const entry of entries) {
+    printLogEntry(entry);
+  }
+  console.log('');
+}
+
+function printLogEntry(entry) {
+  const time = brand.teal(new Date(entry.ts).toLocaleTimeString());
+  const type = entry.type || 'info';
+
+  switch (type) {
+    case 'loop_start':
+      console.log(`  ${time}  ${chalk.blue('LOOP')}   Iteration ${entry.iteration || '?'}`);
+      break;
+    case 'loop_end':
+      console.log(`  ${time}  ${chalk.blue('LOOP')}   Completed in ${entry.duration_ms || '?'}ms`);
+      break;
+    case 'context':
+      console.log(`  ${time}  ${brand.gold('CTX')}    Feed items: ${entry.feedItems || 0}, Mentions: ${entry.mentions || 0}`);
+      break;
+    case 'llm_response':
+      console.log(`  ${time}  ${chalk.magenta('LLM')}    ${brand.teal(truncateLog(entry.text || '(no text)', 80))}`);
+      if (entry.tokensUsed) {
+        console.log(`  ${' '.repeat(10)}  ${brand.teal(`Tokens: ${entry.tokensUsed.prompt || 0}p / ${entry.tokensUsed.completion || 0}c`)}`);
+      }
+      break;
+    case 'tool_call':
+      console.log(`  ${time}  ${chalk.yellow('TOOL')}   ${entry.tool || '?'} ${brand.teal(`→ ${entry.result || 'ok'}`)}`);
+      break;
+    case 'error':
+      console.log(`  ${time}  ${chalk.red('ERR')}    ${entry.error || entry.message || 'Unknown error'}`);
+      break;
+    default:
+      console.log(`  ${time}  ${brand.teal('INFO')}   ${entry.message || JSON.stringify(entry)}`);
+  }
+}
+
+function truncateLog(text, maxLen) {
+  if (!text) return '';
+  const clean = text.replace(/\n+/g, ' ').trim();
+  if (clean.length <= maxLen) return clean;
+  return clean.slice(0, maxLen - 3) + '...';
+}
+
+// ── Edit (open prompt.md in $EDITOR) ────────────────────
+
+export async function agentEditLocalCommand(name) {
+  if (!agentExists(name)) {
+    console.log(chalk.red(`  \u2717 Agent "${name}" not found.\n`));
+    return;
+  }
+
+  const promptPath = join(getAgentDir(name), 'prompt.md');
+  const editor = process.env.EDITOR || process.env.VISUAL || 'nano';
+
+  console.log(brand.teal(`  Opening ${promptPath} in ${editor}...`));
+  console.log(brand.teal('  Changes will be picked up on the next agent loop iteration.\n'));
+
+  try {
+    execSync(`${editor} "${promptPath}"`, { stdio: 'inherit' });
+  } catch (err) {
+    console.log(chalk.red(`  \u2717 Failed to open editor: ${err.message}\n`));
+  }
+}
+
+// ── Add Tool ────────────────────────────────────────────
+
+export async function agentAddToolCommand(name, tool) {
+  if (!agentExists(name)) {
+    console.log(chalk.red(`  \u2717 Agent "${name}" not found.\n`));
+    return;
+  }
+
+  const validTools = Object.keys(TOOL_CATALOG).filter(t => t !== 'man-feed');
+  if (!validTools.includes(tool)) {
+    console.log(chalk.red(`  \u2717 Unknown tool "${tool}".`));
+    console.log(brand.teal(`  Available tools: ${validTools.join(', ')}\n`));
+    return;
+  }
+
+  const toolsConfig = readToolsYaml(name);
+
+  if (toolsConfig.servers?.[tool]) {
+    console.log(chalk.yellow(`  Tool "${tool}" is already configured for agent "${name}".\n`));
+    return;
+  }
+
+  toolsConfig.servers = toolsConfig.servers || {};
+  toolsConfig.servers[tool] = { ...TOOL_CATALOG[tool] };
+  writeToolsYaml(name, toolsConfig);
+
+  console.log(brand.green(`  \u2713 Added "${tool}" to agent "${name}".`));
+
+  if (tool === 'github') {
+    console.log(brand.teal('  Note: Set GITHUB_TOKEN in your environment for GitHub access.'));
+  }
+
+  if (isDaemonRunning(name)) {
+    console.log(chalk.yellow('  Restart the agent to apply: myvillage agent stop ' + name + ' && myvillage agent start ' + name));
+  }
+  console.log('');
+}
+
+// ── Remove Tool ─────────────────────────────────────────
+
+export async function agentRemoveToolCommand(name, tool) {
+  if (!agentExists(name)) {
+    console.log(chalk.red(`  \u2717 Agent "${name}" not found.\n`));
+    return;
+  }
+
+  if (tool === 'man-feed') {
+    console.log(chalk.red('  \u2717 Cannot remove man-feed — it is always enabled.\n'));
+    return;
+  }
+
+  const toolsConfig = readToolsYaml(name);
+
+  if (!toolsConfig.servers?.[tool]) {
+    console.log(chalk.yellow(`  Tool "${tool}" is not configured for agent "${name}".\n`));
+    return;
+  }
+
+  delete toolsConfig.servers[tool];
+  writeToolsYaml(name, toolsConfig);
+
+  console.log(brand.green(`  \u2713 Removed "${tool}" from agent "${name}".`));
+
+  if (isDaemonRunning(name)) {
+    console.log(chalk.yellow('  Restart the agent to apply: myvillage agent stop ' + name + ' && myvillage agent start ' + name));
+  }
+  console.log('');
+}
+
+// ── Delete Local Agent ──────────────────────────────────
+
+export async function agentDeleteLocalCommand(name) {
+  if (!agentExists(name)) {
+    console.log(chalk.red(`  \u2717 Agent "${name}" not found.\n`));
+    return;
+  }
+
+  try {
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: `Delete local agent "${name}"? This removes all local files and cannot be undone.`,
+      default: false,
+    }]);
+
+    if (!confirm) {
+      console.log(brand.teal('  Cancelled.\n'));
+      return;
+    }
+
+    // Stop daemon if running
+    if (isDaemonRunning(name)) {
+      const stopSpinner = villageSpinner('Stopping agent...').start();
+      try {
+        const { stopDaemon } = await import('../agent-runtime/daemon.js');
+        stopDaemon(name);
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        if (isDaemonRunning(name)) {
+          const info = getDaemonInfo(name);
+          if (info) try { process.kill(info.pid, 'SIGKILL'); } catch { /* ignore */ }
+        }
+        stopSpinner.succeed('Agent stopped.');
+      } catch {
+        stopSpinner.warn('Could not stop agent gracefully.');
+      }
+    }
+
+    // Delete directory
+    const { rmSync } = await import('fs');
+    const agentDir = getAgentDir(name);
+    rmSync(agentDir, { recursive: true, force: true });
+
+    console.log(brand.green(`  \u2713 Agent "${name}" deleted.\n`));
+  } catch (err) {
+    if (err.isTtyError) {
+      console.log(chalk.red('  \u2717 Prompts cannot be rendered in this environment.\n'));
+      return;
+    }
+    console.log(chalk.red(`  \u2717 Failed to delete agent: ${err.message}\n`));
+  }
+}