@myvillage/cli 1.10.2 → 1.18.0

package/src/utils/formatters.js

@@ -396,6 +396,78 @@ export function formatAgentList(agents) {
   }
 }
 
+// ── Client Agent Formatting ────────────────────────────
+
+function workflowTypeBadge(type) {
+  switch (type) {
+    case 'SUBMISSION_PROCESSOR': return chalk.blue('[SUBMISSIONS]');
+    case 'DIGEST_GENERATOR': return chalk.green('[DIGEST]');
+    case 'MEMBER_MATCHER': return chalk.magenta('[MATCHER]');
+    case 'STALE_DATA_DETECTOR': return chalk.yellow('[STALE_DATA]');
+    case 'CUSTOM': return chalk.cyan('[CUSTOM]');
+    default: return chalk.dim(`[${type}]`);
+  }
+}
+
+export function formatClientAgentConfig(config) {
+  const lines = [];
+
+  lines.push('');
+  const status = config.isActive !== false ? chalk.green('active') : chalk.red('inactive');
+  const badge = workflowTypeBadge(config.workflowType);
+  lines.push(`  ${chalk.bold(config.clientName)}  ${chalk.dim('·')}  ${badge}  ${chalk.dim('·')}  ${status}`);
+  lines.push(`  ${chalk.dim(config.baseUrl)}`);
+  lines.push(`  ${'─'.repeat(50)}`);
+
+  lines.push(`  ${chalk.dim('Client ID:')}   ${config.clientId}`);
+  const agentName = config.villageAgent?.name || config.villageAgentId;
+  lines.push(`  ${chalk.dim('Agent:')}       ${agentName}`);
+  lines.push(`  ${chalk.dim('Schedule:')}    ${config.schedule || 'None (manual)'}`);
+  lines.push(`  ${chalk.dim('Timezone:')}    ${config.timezone || 'America/Chicago'}`);
+
+  if (config.lastRunAt) {
+    const lastRunStatus = config.lastRunStatus === 'success'
+      ? chalk.green(config.lastRunStatus)
+      : config.lastRunStatus === 'failed'
+        ? chalk.red(config.lastRunStatus)
+        : chalk.yellow(config.lastRunStatus || 'unknown');
+    lines.push(`  ${chalk.dim('Last Run:')}    ${relativeTime(config.lastRunAt)} (${lastRunStatus})`);
+  } else {
+    lines.push(`  ${chalk.dim('Last Run:')}    ${chalk.dim('Never')}`);
+  }
+
+  if (config.workflowConfig) {
+    lines.push(`  ${chalk.dim('Config:')}      ${chalk.dim(JSON.stringify(config.workflowConfig))}`);
+  }
+
+  lines.push(`  ${chalk.dim('Config ID:')}  ${chalk.dim(config.id)}`);
+  lines.push('');
+  console.log(lines.join('\n'));
+}
+
+export function formatClientAgentList(configs) {
+  if (!configs || configs.length === 0) {
+    console.log(chalk.dim('\n  No client agent configs found.\n'));
+    return;
+  }
+
+  console.log('');
+  for (const config of configs) {
+    const name = chalk.blue(padRight(config.clientName || '', 24));
+    const clientId = padRight(config.clientId || '', 16);
+    const badge = workflowTypeBadge(config.workflowType);
+    const status = config.isActive !== false ? chalk.green('active') : chalk.red('inactive');
+    const schedule = config.schedule ? chalk.dim(config.schedule) : chalk.dim('(manual)');
+
+    console.log(`  ${name} ${clientId} ${badge} ${status}  ${schedule}`);
+    const agentName = config.villageAgent?.name || config.villageAgentId || '';
+    if (agentName) {
+      console.log(`  ${chalk.dim('  ')}${chalk.dim(`Agent: ${agentName}`)}`);
+    }
+    console.log('');
+  }
+}
+
 // ── Local Agent Formatting ──────────────────────────────
 
 export function formatLocalAgentList(agents) {

package/src/utils/wisdom.js

@@ -0,0 +1,102 @@
+// Wisdom file format helpers
+//
+// A `.wisdom` file is a Claude-Code-SKILLS-style document used by a local
+// agent: YAML frontmatter (metadata the loop reads at start-up) followed by
+// a markdown body (the skill content the model uses when the trigger applies).
+//
+//   ---
+//   name: gentle-greeter
+//   description: How to welcome new villagers warmly
+//   trigger: when a new villager joins a community I'm in
+//   villageBookId: a3f2...        # only set after `myvillage wisdom push`
+//   ---
+//   <markdown body>
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+
+// Mirrors the backend parser at app/api/village-books/import/route.ts.
+// Kept tiny and dependency-free so the loop start-up isn't slow.
+export function parseWisdom(text) {
+  const match = text.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
+  if (!match) return { frontmatter: {}, body: text };
+  const [, yamlBlock, body] = match;
+  const frontmatter = {};
+  for (const line of yamlBlock.split('\n')) {
+    const m = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*)$/);
+    if (!m) continue;
+    const key = m[1];
+    let value = m[2].trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+    }
+    frontmatter[key] = value;
+  }
+  return { frontmatter, body: body.replace(/^\n+/, '') };
+}
+
+function escapeYamlString(value) {
+  if (/^[a-zA-Z0-9 _.,'\-:/]+$/.test(value) && !value.startsWith(' ') && !value.endsWith(' ')) {
+    return value;
+  }
+  return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+export function serializeWisdom({ frontmatter = {}, body = '' }) {
+  const lines = ['---'];
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (value == null || value === '') continue;
+    lines.push(`${key}: ${escapeYamlString(String(value))}`);
+  }
+  lines.push('---');
+  return `${lines.join('\n')}\n\n${body.trim()}\n`;
+}
+
+export function slugify(name) {
+  return String(name).toLowerCase().trim()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60) || 'wisdom';
+}
+
+export function getAgentWisdomDir(agentName) {
+  return join(homedir(), '.myvillage', 'agents', agentName, 'wisdom');
+}
+
+export function ensureWisdomDir(agentName) {
+  const dir = getAgentWisdomDir(agentName);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// Reads every .wisdom file in the agent's wisdom dir, returning parsed entries
+// in stable filename order. The loop calls this once per iteration.
+export function readAgentWisdom(agentName) {
+  const dir = getAgentWisdomDir(agentName);
+  if (!existsSync(dir)) return [];
+  const files = readdirSync(dir).filter(f => f.endsWith('.wisdom')).sort();
+  const out = [];
+  for (const file of files) {
+    try {
+      const text = readFileSync(join(dir, file), 'utf-8');
+      const parsed = parseWisdom(text);
+      out.push({
+        file,
+        path: join(dir, file),
+        name: parsed.frontmatter.name || basename(file, '.wisdom'),
+        description: parsed.frontmatter.description || '',
+        trigger: parsed.frontmatter.trigger || '',
+        villageBookId: parsed.frontmatter.villageBookId || null,
+        body: parsed.body,
+      });
+    } catch {
+      // Skip unreadable files — don't crash the loop over one bad file
+    }
+  }
+  return out;
+}
+
+export function writeWisdomFile(filePath, payload) {
+  writeFileSync(filePath, serializeWisdom(payload));
+}