@myvillage/cli 1.5.0 → 1.6.0

package/src/commands/checkin.js

@@ -0,0 +1,149 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { z } from 'zod';
+import { isAuthenticated } from '../utils/auth.js';
+import { brand, villageSpinner } from '../utils/brand.js';
+import { createPost } from '../utils/api.js';
+import { resolveVillageContext } from '../utils/village-resolver.js';
+import { getAnthropicProvider } from '../utils/ai.js';
+import { formatCheckinSummary } from '../utils/formatters.js';
+import { discoverLogic } from './discover.js';
+
+const extractionSchema = z.object({
+  themes: z.array(z.string()).describe('Key themes from the check-in (1-4 short labels)'),
+  needs: z.array(z.string()).describe('Things the village needs help with (0-3 short labels)'),
+  offers: z.array(z.string()).describe('Things the village can offer others (0-3 short labels)'),
+  buildTrack: z.string().optional().describe('Primary build track if mentioned: game, portal, agent, data, robot, or general'),
+  summary: z.string().describe('A 2-3 sentence summary combining all responses into a cohesive check-in update'),
+});
+
+export async function checkinCommand(options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red("  \u2717 Authentication required. Run 'myvillage login' first."));
+    return;
+  }
+
+  const ctx = await resolveVillageContext();
+  if (!ctx) return;
+
+  console.log();
+  console.log(brand.gold('  \u2743 Village Check-in'));
+  console.log(chalk.dim('  Answer a few questions about your village. AI will help organize it.\n'));
+
+  // Conversational prompts
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'work',
+      message: 'What did your village work on recently?',
+      validate: (v) => v.trim().length > 0 || 'Please share what you worked on.',
+    },
+    {
+      type: 'input',
+      name: 'stuck',
+      message: 'Any problems you\'re stuck on?',
+      default: '',
+    },
+    {
+      type: 'input',
+      name: 'share',
+      message: 'Anything you want to share with the network?',
+      default: '',
+    },
+  ]);
+
+  // AI structuring
+  const spinner = villageSpinner('Organizing your check-in...').start();
+
+  let extracted;
+  try {
+    const anthropic = await getAnthropicProvider();
+    const { generateText } = await import('ai');
+
+    const userContent = [
+      `What we worked on: ${answers.work}`,
+      answers.stuck ? `Problems we're stuck on: ${answers.stuck}` : null,
+      answers.share ? `What we want to share: ${answers.share}` : null,
+    ].filter(Boolean).join('\n');
+
+    const result = await generateText({
+      model: anthropic('claude-haiku-4-5-20251001'),
+      system: `You are a community network coordinator. Extract structured metadata from a village check-in and write a concise summary. Always call the extract_checkin tool with your analysis.`,
+      messages: [{ role: 'user', content: userContent }],
+      tools: {
+        extract_checkin: {
+          description: 'Extract structured metadata from a village check-in',
+          parameters: extractionSchema,
+        },
+      },
+      toolChoice: { type: 'tool', toolName: 'extract_checkin' },
+      maxTokens: 500,
+    });
+
+    const toolCall = result.toolCalls?.[0];
+    if (!toolCall?.args) {
+      throw new Error('AI did not return structured data');
+    }
+    extracted = toolCall.args;
+    spinner.succeed('Check-in organized');
+  } catch (err) {
+    spinner.fail('AI structuring failed — posting raw check-in');
+    // Fallback: post without AI structuring
+    extracted = {
+      themes: [],
+      needs: [],
+      offers: [],
+      buildTrack: 'general',
+      summary: [answers.work, answers.stuck, answers.share].filter(Boolean).join(' '),
+    };
+  }
+
+  // Build tags
+  const tags = ['checkin'];
+  if (extracted.buildTrack) tags.push(`track:${extracted.buildTrack}`);
+  for (const t of extracted.themes) tags.push(`theme:${t}`);
+  for (const n of extracted.needs) tags.push(`need:${n}`);
+  for (const o of extracted.offers) tags.push(`offer:${o}`);
+
+  // Create post
+  try {
+    const post = await createPost({
+      communitySlug: ctx.community.slug,
+      postType: 'DISCUSSION',
+      title: `Village Check-in: ${ctx.village.name}`,
+      body: extracted.summary,
+      tags,
+    });
+
+    formatCheckinSummary(post, {
+      villageName: ctx.village.name,
+      buildTrack: extracted.buildTrack,
+      themes: extracted.themes,
+      needs: extracted.needs,
+      offers: extracted.offers,
+    });
+  } catch (err) {
+    const msg = err.response?.data?.error || err.message;
+    console.log(chalk.red(`  \u2717 Failed to post check-in: ${msg}`));
+    return;
+  }
+
+  // Auto-discover prompt
+  if (!options.skipDiscover) {
+    const { runDiscover } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'runDiscover',
+      message: 'Look for connections with other villages?',
+      default: true,
+    }]);
+
+    if (runDiscover) {
+      await discoverLogic(ctx, {
+        themes: extracted.themes,
+        needs: extracted.needs,
+        offers: extracted.offers,
+        track: extracted.buildTrack,
+      });
+    }
+  }
+}

package/src/commands/discover.js

@@ -0,0 +1,220 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { isAuthenticated, loadCredentials } from '../utils/auth.js';
+import { brand, villageSpinner } from '../utils/brand.js';
+import {
+  listPosts,
+  listPostsByFilters,
+  createPost,
+  getVillagerVillages,
+  getVillageCommunities,
+} from '../utils/api.js';
+import { resolveVillageContext } from '../utils/village-resolver.js';
+import { formatConnection } from '../utils/formatters.js';
+
+/**
+ * Parse prefixed tags into a structured map.
+ * e.g., ['checkin', 'track:game', 'theme:ai', 'need:mentors'] →
+ *   { themes: ['ai'], needs: ['mentors'], offers: [], track: 'game' }
+ */
+function parseTags(tags = []) {
+  const result = { themes: [], needs: [], offers: [], track: null };
+  for (const tag of tags) {
+    if (tag.startsWith('theme:')) result.themes.push(tag.replace('theme:', ''));
+    else if (tag.startsWith('need:')) result.needs.push(tag.replace('need:', ''));
+    else if (tag.startsWith('offer:')) result.offers.push(tag.replace('offer:', ''));
+    else if (tag.startsWith('track:')) result.track = tag.replace('track:', '');
+  }
+  return result;
+}
+
+/**
+ * Score a candidate post against the user's tags.
+ */
+function scoreMatch(myTags, theirTags) {
+  let score = 0;
+  const matchTypes = [];
+
+  // Need-to-offer matches (3 points each)
+  for (const need of myTags.needs) {
+    if (theirTags.offers.includes(need)) {
+      score += 3;
+      matchTypes.push(`They offer "${need}" (you need it)`);
+    }
+  }
+  for (const offer of myTags.offers) {
+    if (theirTags.needs.includes(offer)) {
+      score += 3;
+      matchTypes.push(`They need "${offer}" (you offer it)`);
+    }
+  }
+
+  // Same build track (2 points)
+  if (myTags.track && theirTags.track && myTags.track === theirTags.track) {
+    score += 2;
+    matchTypes.push(`Same track: ${myTags.track}`);
+  }
+
+  // Shared themes (1 point each)
+  for (const theme of myTags.themes) {
+    if (theirTags.themes.includes(theme)) {
+      score += 1;
+      matchTypes.push(`Shared theme: ${theme}`);
+    }
+  }
+
+  return { score, matchTypes };
+}
+
+/**
+ * Core discover logic, shared between standalone and post-checkin invocation.
+ */
+export async function discoverLogic(ctx, myTags) {
+  const spinner = villageSpinner('Searching for connections...').start();
+
+  try {
+    const creds = loadCredentials();
+
+    // 1. Get all the user's villages' communities (for cross-village search)
+    const villagesResult = await getVillagerVillages(ctx.villagerUuid);
+    const allVillages = villagesResult?.data || [];
+
+    const communityIds = [];
+    for (const village of allVillages) {
+      const commResult = await getVillageCommunities(village.id);
+      const comms = commResult?.data || [];
+      for (const c of comms) {
+        if (!communityIds.includes(c.id)) {
+          communityIds.push(c.id);
+        }
+      }
+    }
+
+    if (communityIds.length === 0) {
+      spinner.fail('No village communities found to search.');
+      return;
+    }
+
+    // 2. Fetch recent posts (last 14 days)
+    const since = new Date(Date.now() - 14 * 24 * 60 * 60 * 1000).toISOString();
+    const postsResult = await listPostsByFilters({
+      communityIds: communityIds.join(','),
+      tags: 'checkin,build-log,knowledge-contribution',
+      since,
+      pageSize: 50,
+      sort: 'new',
+    });
+
+    const posts = postsResult?.data || [];
+
+    // 3. Filter out current user's own posts
+    const otherPosts = posts.filter((p) => p.villagerId !== ctx.villagerUuid);
+
+    if (otherPosts.length === 0) {
+      spinner.info('No connections found right now \u2014 check back after more villages check in.');
+      return;
+    }
+
+    // 4. Score and rank matches
+    const scored = otherPosts.map((post) => {
+      const theirTags = parseTags(post.tags);
+      const { score, matchTypes } = scoreMatch(myTags, theirTags);
+      const villageName = post.community?.name || 'Unknown Village';
+      return { post, score, matchTypes, villageName, theirTags };
+    });
+
+    const topMatches = scored
+      .filter((m) => m.score > 0)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, 3);
+
+    spinner.stop();
+
+    if (topMatches.length === 0) {
+      console.log(chalk.dim('\n  No connections found right now \u2014 check back after more villages check in.\n'));
+      return;
+    }
+
+    console.log(brand.gold(`\n  Found ${topMatches.length} connection${topMatches.length > 1 ? 's' : ''}:\n`));
+
+    // 5. Display and optionally share each connection
+    for (const match of topMatches) {
+      formatConnection({
+        villageName: match.villageName,
+        topic: match.theirTags.themes[0] || match.theirTags.track || 'general',
+        matchType: match.matchTypes.join(', '),
+        score: match.score,
+      });
+
+      const { share } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'share',
+        message: 'Share this connection with the network?',
+        default: false,
+      }]);
+
+      if (share) {
+        const description = `Connection between ${ctx.village.name} and ${match.villageName}: ${match.matchTypes.join('; ')}`;
+        const connectionTags = ['connection'];
+        if (match.theirTags.track) connectionTags.push(`track:${match.theirTags.track}`);
+        for (const t of match.theirTags.themes) connectionTags.push(`theme:${t}`);
+
+        try {
+          await createPost({
+            communitySlug: ctx.community.slug,
+            postType: 'DISCUSSION',
+            title: `Connection: ${ctx.village.name} \u21C4 ${match.villageName}`,
+            body: description,
+            tags: connectionTags,
+          });
+          console.log(brand.green('  \u2713 Connection shared!\n'));
+        } catch (err) {
+          const msg = err.response?.data?.error || err.message;
+          console.log(chalk.red(`  \u2717 Failed to share connection: ${msg}\n`));
+        }
+      }
+    }
+  } catch (err) {
+    spinner.fail(`Discovery failed: ${err.message}`);
+  }
+}
+
+/**
+ * Standalone discover command — fetches user's most recent check-in,
+ * parses its tags, then runs discoverLogic.
+ */
+export async function discoverCommand(options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red("  \u2717 Authentication required. Run 'myvillage login' first."));
+    return;
+  }
+
+  const ctx = await resolveVillageContext();
+  if (!ctx) return;
+
+  // Fetch user's most recent check-in
+  const spinner = villageSpinner('Loading your latest check-in...').start();
+
+  try {
+    const result = await listPosts({
+      communitySlug: ctx.community.slug,
+      authorId: ctx.villagerUuid,
+      pageSize: 1,
+      sort: 'new',
+    });
+
+    const posts = result?.data || [];
+    const checkin = posts.find((p) => p.tags?.includes('checkin'));
+
+    if (!checkin) {
+      spinner.info('No recent check-in found. Run `myvillage checkin` first to share what your village is working on.');
+      return;
+    }
+
+    spinner.succeed('Check-in loaded');
+    const myTags = parseTags(checkin.tags);
+    await discoverLogic(ctx, myTags);
+  } catch (err) {
+    spinner.fail(`Failed to load check-in: ${err.message}`);
+  }
+}

package/src/commands/log.js

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { isAuthenticated } from '../utils/auth.js';
+import { brand } from '../utils/brand.js';
+import { createPost } from '../utils/api.js';
+import { resolveVillageContext } from '../utils/village-resolver.js';
+
+const TRACKS = ['game', 'portal', 'agent', 'data', 'robot', 'general'];
+
+export async function logCommand(text, options) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red("  \u2717 Authentication required. Run 'myvillage login' first."));
+    return;
+  }
+
+  const ctx = await resolveVillageContext();
+  if (!ctx) return;
+
+  // Get log text
+  let logText = text;
+  if (!logText) {
+    const { input } = await inquirer.prompt([{
+      type: 'input',
+      name: 'input',
+      message: 'What did you work on?',
+      validate: (v) => v.trim().length > 0 || 'Please enter something.',
+    }]);
+    logText = input.trim();
+  }
+
+  // Get track
+  let track = options.track;
+  if (!track) {
+    const { selected } = await inquirer.prompt([{
+      type: 'list',
+      name: 'selected',
+      message: 'Build track:',
+      choices: TRACKS,
+    }]);
+    track = selected;
+  }
+
+  // Build tags and post
+  const tags = ['build-log', `track:${track}`];
+
+  try {
+    await createPost({
+      communitySlug: ctx.community.slug,
+      postType: 'DISCUSSION',
+      body: logText,
+      tags,
+    });
+
+    console.log(brand.green(`  \u2713 Build log posted to ${ctx.village.name} [${track}]`));
+  } catch (err) {
+    const msg = err.response?.data?.error || err.message;
+    console.log(chalk.red(`  \u2717 Failed to post build log: ${msg}`));
+  }
+}