guildex 0.1.0

package/README.md

@@ -0,0 +1,55 @@
+# guildex CLI
+
+Install AI talent from [Guildex](https://guildex.net) directly to your OpenClaw workspace.
+
+## Usage
+
+```bash
+# Install a persona
+npx guildex install elon-musk
+
+# List all available AI talent
+npx guildex list
+
+# Search
+npx guildex search marketing
+```
+
+## Requirements
+
+- [OpenClaw](https://openclaw.ai) installed
+- `~/.openclaw/workspace/` directory exists
+
+## Where are files installed?
+
+`~/.openclaw/workspace/AI-talent/[Name]/`
+
+Each persona includes: SOUL.md, README.md, SKILLS.md, EXAMPLES.md, TESTS.md
+
+## Available Categories
+
+- `famous-figures` — Real-world iconic figures
+- `engineering` — Software & systems engineers
+- `marketing` — Growth & marketing experts
+- `design` — UI/UX & product designers
+- `product-strategy` — PMs & strategists
+- `sales-support` — Sales & customer success
+- `game-development` — Game dev specialists
+- `academic-specialized` — Academic & research personas
+- `philosophy-wisdom` — Philosophers & thinkers
+- `health-mindset` — Coaches & wellness experts
+
+## Options
+
+Set `GITHUB_TOKEN` env var to avoid GitHub rate limits:
+
+```bash
+export GITHUB_TOKEN=your_token_here
+npx guildex list
+```
+
+## Links
+
+- [Guildex](https://guildex.net) — Browse AI talent online
+- [OpenClaw](https://openclaw.ai) — AI agent platform
+- [GitHub Repo](https://github.com/joe-qiao-ai/guildex-ai-talent) — Talent source files

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "guildex",
+  "version": "0.1.0",
+  "description": "CLI for Guildex AI Talent Network — download and deploy AI talent to your OpenClaw workspace",
+  "bin": {
+    "guildex": "./src/index.js"
+  },
+  "main": "./src/index.js",
+  "type": "commonjs",
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "node-fetch": "^2.7.0"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "keywords": [
+    "guildex",
+    "ai",
+    "talent",
+    "openclaw",
+    "persona",
+    "cli"
+  ],
+  "author": "Guildex",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/joe-qiao-ai/guildex-ai-talent"
+  }
+}

package/src/index.js

@@ -0,0 +1,369 @@
+#!/usr/bin/env node
+'use strict';
+
+const fetch = require('node-fetch');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const os = require('os');
+
+// Guildex API config
+// Override with GUILDEX_API_URL env var or set in ~/.guildex/config.json
+const GUILDEX_API_URL =
+  process.env.GUILDEX_API_URL ||
+  (() => {
+    try {
+      const cfgPath = require('path').join(require('os').homedir(), '.guildex', 'config.json');
+      if (require('fs').existsSync(cfgPath)) {
+        return JSON.parse(require('fs').readFileSync(cfgPath, 'utf8')).apiUrl;
+      }
+    } catch {}
+    return null;
+  })() ||
+  'https://anonymous-guildex.convex.site';
+
+const GUILDEX_DOWNLOAD_ENDPOINT = `${GUILDEX_API_URL}/api/download`;
+
+// GitHub repo config (used for listing — list still reads GitHub directly)
+const GITHUB_OWNER = 'joe-qiao-ai';
+const GITHUB_REPO = 'guildex-ai-talent';
+const GITHUB_BRANCH = 'main';
+const GITHUB_API_BASE = 'https://api.github.com';
+const GITHUB_RAW_BASE = `https://raw.githubusercontent.com/${GITHUB_OWNER}/${GITHUB_REPO}/${GITHUB_BRANCH}`;
+
+// Categories in the repo
+const CATEGORIES = [
+  'famous-figures',
+  'engineering',
+  'marketing',
+  'design',
+  'product-strategy',
+  'sales-support',
+  'game-development',
+  'academic-specialized',
+  'philosophy-wisdom',
+  'health-mindset',
+];
+
+// Files to download for each persona
+const PERSONA_FILES = ['SOUL.md', 'README.md', 'SKILLS.md', 'EXAMPLES.md', 'TESTS.md'];
+
+// Install base path
+const INSTALL_BASE = path.join(os.homedir(), '.openclaw', 'workspace', 'AI-talent');
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function toSlug(name) {
+  return name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+}
+
+function slugMatches(slug, query) {
+  const q = query.toLowerCase().replace(/\s+/g, '-');
+  return (
+    slug === q ||
+    slug.includes(q) ||
+    slug.replace(/-/g, ' ').includes(query.toLowerCase())
+  );
+}
+
+async function githubGet(endpoint) {
+  const headers = { 'User-Agent': 'guildex-cli/0.1.0', Accept: 'application/vnd.github.v3+json' };
+  if (process.env.GITHUB_TOKEN) {
+    headers['Authorization'] = `token ${process.env.GITHUB_TOKEN}`;
+  }
+  const res = await fetch(`${GITHUB_API_BASE}${endpoint}`, { headers });
+  if (!res.ok) {
+    throw new Error(`GitHub API error ${res.status}: ${res.statusText} (${endpoint})`);
+  }
+  return res.json();
+}
+
+async function fetchRawFile(filePath) {
+  const url = `${GITHUB_RAW_BASE}/${filePath}`;
+  const res = await fetch(url);
+  if (!res.ok) return null;
+  return res.text();
+}
+
+/**
+ * List all personas across all categories.
+ * Returns: [{ name, slug, category }]
+ */
+async function fetchAllPersonas() {
+  const personas = [];
+  for (const category of CATEGORIES) {
+    let entries;
+    try {
+      entries = await githubGet(`/repos/${GITHUB_OWNER}/${GITHUB_REPO}/contents/${category}`);
+    } catch {
+      // Category might not exist yet; skip silently
+      continue;
+    }
+    if (!Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      if (entry.type === 'dir') {
+        personas.push({
+          slug: entry.name,
+          name: entry.name.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
+          category,
+          path: entry.path,
+        });
+      }
+    }
+  }
+  return personas;
+}
+
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// ─── Commands ───────────────────────────────────────────────────────────────
+
+async function cmdList() {
+  console.log(chalk.bold.cyan('\n🎭 Guildex AI Talent Network\n'));
+  console.log(chalk.gray('Fetching available talent...\n'));
+
+  let personas;
+  try {
+    personas = await fetchAllPersonas();
+  } catch (err) {
+    console.error(chalk.red('✗ Failed to fetch talent list:'), err.message);
+    process.exit(1);
+  }
+
+  if (personas.length === 0) {
+    console.log(chalk.yellow('No personas found in the repo yet.'));
+    return;
+  }
+
+  // Group by category
+  const byCategory = {};
+  for (const p of personas) {
+    if (!byCategory[p.category]) byCategory[p.category] = [];
+    byCategory[p.category].push(p);
+  }
+
+  for (const [cat, list] of Object.entries(byCategory)) {
+    const catLabel = cat.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+    console.log(chalk.bold.yellow(`📂 ${catLabel}`));
+    for (const p of list) {
+      console.log(`  ${chalk.green(p.slug.padEnd(32))} ${chalk.gray(p.name)}`);
+    }
+    console.log();
+  }
+
+  console.log(chalk.gray(`Total: ${chalk.white(personas.length)} AI talent available`));
+  console.log(chalk.gray(`\nInstall with: ${chalk.white('npx guildex install <slug>')}\n`));
+}
+
+async function cmdSearch(keyword) {
+  if (!keyword) {
+    console.error(chalk.red('Usage: guildex search <keyword>'));
+    process.exit(1);
+  }
+
+  console.log(chalk.bold.cyan('\n🔍 Searching Guildex AI Talent...\n'));
+  console.log(chalk.gray(`Fetching talent list...\n`));
+
+  let personas;
+  try {
+    personas = await fetchAllPersonas();
+  } catch (err) {
+    console.error(chalk.red('✗ Failed to fetch talent list:'), err.message);
+    process.exit(1);
+  }
+
+  const kw = keyword.toLowerCase();
+  const results = personas.filter(
+    (p) =>
+      p.slug.includes(kw) ||
+      p.name.toLowerCase().includes(kw) ||
+      p.category.includes(kw)
+  );
+
+  if (results.length === 0) {
+    console.log(chalk.yellow(`No results for "${keyword}"`));
+    console.log(chalk.gray('Try: npx guildex list'));
+    return;
+  }
+
+  console.log(chalk.bold(`Found ${results.length} match${results.length !== 1 ? 'es' : ''}:\n`));
+  for (const p of results) {
+    const catLabel = p.category.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+    console.log(`  ${chalk.green(p.slug.padEnd(32))} ${chalk.white(p.name)} ${chalk.gray(`[${catLabel}]`)}`);
+  }
+  console.log(chalk.gray(`\nInstall with: ${chalk.white('npx guildex install <slug>')}\n`));
+}
+
+async function cmdInstall(nameArg) {
+  if (!nameArg) {
+    console.error(chalk.red('Usage: guildex install <name-or-slug>'));
+    process.exit(1);
+  }
+
+  console.log(chalk.bold.cyan('\n🎭 Guildex AI Talent Installer\n'));
+  console.log(chalk.gray(`Searching for "${nameArg}"...\n`));
+
+  let personas;
+  try {
+    personas = await fetchAllPersonas();
+  } catch (err) {
+    console.error(chalk.red('✗ Failed to fetch talent list:'), err.message);
+    process.exit(1);
+  }
+
+  // Find best match
+  const slug = toSlug(nameArg);
+  let match = personas.find((p) => p.slug === slug);
+
+  if (!match) {
+    // Fuzzy: partial slug match or name match
+    const candidates = personas.filter((p) => slugMatches(p.slug, nameArg));
+    if (candidates.length === 1) {
+      match = candidates[0];
+    } else if (candidates.length > 1) {
+      console.log(chalk.yellow(`Multiple matches found for "${nameArg}":\n`));
+      candidates.forEach((p, i) => {
+        console.log(`  ${chalk.cyan(`[${i + 1}]`)} ${chalk.green(p.slug)} — ${p.name} ${chalk.gray(`[${p.category}]`)}`);
+      });
+      const answer = await prompt(chalk.bold('\nEnter number to install (or q to quit): '));
+      if (answer.toLowerCase() === 'q' || answer === '') process.exit(0);
+      const idx = parseInt(answer, 10) - 1;
+      if (isNaN(idx) || idx < 0 || idx >= candidates.length) {
+        console.error(chalk.red('Invalid selection.'));
+        process.exit(1);
+      }
+      match = candidates[idx];
+    }
+  }
+
+  if (!match) {
+    console.error(chalk.red(`✗ No AI talent found matching "${nameArg}"`));
+    console.log(chalk.gray('Run `npx guildex list` to see all available talent.'));
+    process.exit(1);
+  }
+
+  console.log(chalk.bold(`Found: ${chalk.green(match.name)} ${chalk.gray(`(${match.slug})`)}`));
+  console.log(chalk.gray(`Category: ${match.category}\n`));
+
+  // Check destination
+  const destDir = path.join(INSTALL_BASE, match.name);
+
+  if (fs.existsSync(destDir)) {
+    const answer = await prompt(
+      chalk.yellow(`⚠️  "${match.name}" already exists at:\n   ${destDir}\n\nOverwrite? [y/N] `)
+    );
+    if (answer.toLowerCase() !== 'y') {
+      console.log(chalk.gray('\nInstallation cancelled.'));
+      process.exit(0);
+    }
+  }
+
+  // Create directory
+  fs.mkdirSync(destDir, { recursive: true });
+
+  console.log(chalk.bold(`\nDownloading files to:\n  ${chalk.cyan(destDir)}\n`));
+
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const file of PERSONA_FILES) {
+    const remotePath = `${match.path}/${file}`;
+    process.stdout.write(`  ${chalk.gray('→')} ${file.padEnd(16)}`);
+    try {
+      const content = await fetchRawFile(remotePath);
+      if (content === null) {
+        console.log(chalk.yellow('(not found, skipping)'));
+        failCount++;
+      } else {
+        fs.writeFileSync(path.join(destDir, file), content, 'utf8');
+        console.log(chalk.green('✓'));
+        successCount++;
+      }
+    } catch (err) {
+      console.log(chalk.red(`✗ ${err.message}`));
+      failCount++;
+    }
+  }
+
+  console.log();
+
+  if (successCount === 0) {
+    console.error(chalk.red('✗ Installation failed — no files downloaded.'));
+    process.exit(1);
+  }
+
+  console.log(chalk.bold.green(`✅ ${match.name} installed successfully!`));
+  console.log(chalk.gray(`\n📁 Location: ${chalk.white(destDir)}`));
+  if (failCount > 0) {
+    console.log(chalk.yellow(`⚠️  ${failCount} file(s) were not found in the repo and were skipped.`));
+  }
+  console.log(chalk.gray(`\nFiles: ${PERSONA_FILES.join(', ')}`));
+  console.log(chalk.bold.cyan('\n🎉 Ready to deploy in OpenClaw!\n'));
+}
+
+function cmdHelp() {
+  console.log(`
+${chalk.bold.cyan('guildex')} — Guildex AI Talent Network CLI
+
+${chalk.bold('Usage:')}
+  ${chalk.green('npx guildex list')}                  List all available AI talent
+  ${chalk.green('npx guildex search <keyword>')}      Search AI talent by name, category, or keyword
+  ${chalk.green('npx guildex install <name>')}        Install a persona to your OpenClaw workspace
+
+${chalk.bold('Examples:')}
+  npx guildex install elon-musk
+  npx guildex install "Elon Musk"
+  npx guildex search marketing
+  npx guildex list
+
+${chalk.bold('Install location:')}
+  ${chalk.cyan('~/.openclaw/workspace/AI-talent/[Name]/')}
+
+${chalk.bold('Files per persona:')}
+  ${PERSONA_FILES.join(', ')}
+
+${chalk.gray('More info: https://guildex.net')}
+`);
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+
+async function main() {
+  const [,, command, ...args] = process.argv;
+
+  switch (command) {
+    case 'list':
+      await cmdList();
+      break;
+    case 'search':
+      await cmdSearch(args.join(' '));
+      break;
+    case 'install':
+      await cmdInstall(args.join(' '));
+      break;
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+      cmdHelp();
+      break;
+    default:
+      console.error(chalk.red(`Unknown command: ${command}`));
+      cmdHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(chalk.red('Fatal error:'), err.message);
+  process.exit(1);
+});