agent-root 0.1.0

package/bin/agentroot.js

@@ -0,0 +1,432 @@
+#!/usr/bin/env node
+
+// AgentRoot CLI — zero-dependency, runs via npx
+// npx agentroot install stripe.com/payments --tool claude
+
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const {
+  API_BASE, MANIFEST_FILE, TOOL_DIRS, TOOL_NAMES,
+  detectTools, resolveToolDir, hashContent, scanInstalled, writeSkill,
+} = require('@agent-root/core');
+
+// ─── Colors (ANSI) ────────────────────────────────────────────────────────
+
+const c = {
+  reset: '\x1b[0m',
+  bold:  '\x1b[1m',
+  dim:   '\x1b[2m',
+  green: '\x1b[32m',
+  cyan:  '\x1b[36m',
+  yellow:'\x1b[33m',
+  red:   '\x1b[31m',
+  magenta:'\x1b[35m',
+};
+
+// ─── Helpers ───────────────────────────────────────────────────────────────
+
+function fetch(url) {
+  return new Promise((resolve, reject) => {
+    const mod = url.startsWith('https') ? https : http;
+    mod.get(url, { headers: { 'User-Agent': 'agentroot-cli/0.1.0' } }, (res) => {
+      // Follow redirects
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return fetch(res.headers.location).then(resolve, reject);
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+      }
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => resolve(data));
+    }).on('error', reject);
+  });
+}
+
+function fetchJSON(url) {
+  return fetch(url).then(d => JSON.parse(d));
+}
+
+function fatal(msg) {
+  console.error(`${c.red}error${c.reset} ${msg}`);
+  process.exit(1);
+}
+
+// ─── Argument Parsing ──────────────────────────────────────────────────────
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const cmd = args[0];
+  const positional = [];
+  const flags = {};
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i].startsWith('--')) {
+      const key = args[i].slice(2);
+      // Boolean flags
+      if (key === 'all' || key === 'project' || key === 'help' || key === 'json') {
+        flags[key] = true;
+      } else if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+        flags[key] = args[i + 1];
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(args[i]);
+    }
+  }
+  return { cmd, positional, flags };
+}
+
+// ─── Commands ──────────────────────────────────────────────────────────────
+
+async function cmdInstall(positional, flags) {
+  if (positional.length === 0) {
+    fatal('Usage: agentroot install <domain>/<skill-id> [--tool claude|codex|gemini|cursor|agents] [--project]');
+  }
+
+  const input = positional[0];
+  const isProject = !!flags.project;
+  const installAll = !!flags.all;
+
+  // Parse domain/skill-id
+  const slashIdx = input.indexOf('/');
+  if (slashIdx === -1 && !installAll) {
+    fatal('Expected format: <domain>/<skill-id> or <domain> --all');
+  }
+
+  const domain = installAll ? input : input.slice(0, slashIdx);
+  const skillId = installAll ? null : input.slice(slashIdx + 1);
+
+  if (!domain) fatal('Missing domain');
+  if (!installAll && !skillId) fatal('Missing skill ID');
+
+  // Resolve target tool
+  let tools = [];
+  if (flags.tool) {
+    tools = [flags.tool];
+  } else {
+    tools = detectTools();
+    if (tools.length === 0) {
+      tools = ['agents']; // fallback to cross-tool standard
+      console.log(`${c.dim}No AI tools detected, using cross-tool .agents/skills/ directory${c.reset}`);
+    } else {
+      console.log(`${c.dim}Detected tools: ${tools.join(', ')}${c.reset}`);
+    }
+  }
+
+  // Fetch skill(s) info
+  let skillsToInstall = [];
+
+  if (installAll) {
+    // Get all skills for a domain
+    console.log(`${c.cyan}Fetching skills for ${domain}...${c.reset}`);
+    const data = await fetchJSON(`${API_BASE}/api/skills/${encodeURIComponent(domain)}`);
+    if (!data.skill || !data.skill.skills || data.skill.skills.length === 0) {
+      fatal(`No skills found for domain: ${domain}`);
+    }
+    skillsToInstall = data.skill.skills.map(s => ({
+      id: s.skill_id,
+      name: s.name,
+      description: s.description,
+      url: s.skill_md_url,
+      domain: domain,
+    }));
+  } else {
+    // Get single skill
+    console.log(`${c.cyan}Fetching ${domain}/${skillId}...${c.reset}`);
+    const data = await fetchJSON(`${API_BASE}/api/skills/${encodeURIComponent(domain)}/item/${encodeURIComponent(skillId)}`);
+    if (!data.skill) {
+      fatal(`Skill not found: ${domain}/${skillId}`);
+    }
+    const s = data.skill;
+    skillsToInstall = [{
+      id: s.skill_id,
+      name: s.name,
+      description: s.description,
+      url: s.skill_md_url,
+      domain: domain,
+    }];
+  }
+
+  // Install each skill for each tool
+  let installed = 0;
+  for (const skill of skillsToInstall) {
+    if (!skill.url) {
+      console.log(`${c.yellow}skip${c.reset} ${skill.id} — no SKILL.md URL`);
+      continue;
+    }
+
+    // Fetch SKILL.md content
+    let content;
+    try {
+      content = await fetch(skill.url);
+    } catch (err) {
+      console.log(`${c.red}fail${c.reset} ${skill.id} — could not fetch SKILL.md: ${err.message}`);
+      continue;
+    }
+
+    for (const tool of tools) {
+      const baseDir = resolveToolDir(tool, isProject);
+      const skillDir = path.join(baseDir, skill.id);
+      const skillPath = path.join(skillDir, 'SKILL.md');
+
+      const manifest = {
+        source_domain: skill.domain,
+        skill_id: skill.id,
+        name: skill.name,
+        description: skill.description,
+        skill_md_url: skill.url,
+        installed_at: new Date().toISOString(),
+        version_hash: hashContent(content),
+        tool: tool,
+      };
+      writeSkill(skillDir, content, manifest);
+
+      console.log(`${c.green}installed${c.reset} ${c.bold}${skill.id}${c.reset} → ${skillPath}`);
+      installed++;
+    }
+  }
+
+  if (installed > 0) {
+    console.log(`\n${c.green}✓${c.reset} ${installed} skill(s) installed successfully`);
+  }
+}
+
+async function cmdSearch(positional, flags) {
+  const query = positional.join(' ');
+  if (!query) {
+    fatal('Usage: agentroot search <query>');
+  }
+
+  console.log(`${c.cyan}Searching for "${query}"...${c.reset}\n`);
+  const data = await fetchJSON(`${API_BASE}/api/find-skills?q=${encodeURIComponent(query)}`);
+
+  if (!data.skills || data.skills.length === 0) {
+    console.log('No skills found.');
+    return;
+  }
+
+  if (flags.json) {
+    console.log(JSON.stringify(data.skills, null, 2));
+    return;
+  }
+
+  for (const s of data.skills) {
+    const id = `${s.domain}/${s.skill_id}`;
+    console.log(`  ${c.bold}${s.name || s.skill_id}${c.reset} ${c.dim}(${id})${c.reset}`);
+    if (s.description) {
+      console.log(`  ${c.dim}${s.description}${c.reset}`);
+    }
+    console.log(`  ${c.cyan}npx agentroot install ${id}${c.reset}`);
+    console.log();
+  }
+
+  console.log(`${c.dim}${data.count} result(s)${c.reset}`);
+}
+
+async function cmdList() {
+  const results = scanInstalled();
+
+  if (results.length === 0) {
+    console.log('No AgentRoot skills installed.');
+    console.log(`${c.dim}Install one: npx agentroot install <domain>/<skill-id>${c.reset}`);
+    return;
+  }
+
+  console.log(`${c.bold}Installed AgentRoot Skills${c.reset}\n`);
+  for (const r of results) {
+    console.log(`  ${c.bold}${r.skill_id}${c.reset} ${c.dim}(${r.domain})${c.reset}`);
+    console.log(`  ${c.dim}tool:${c.reset} ${r.tool}  ${c.dim}scope:${c.reset} ${r.scope}  ${c.dim}installed:${c.reset} ${r.installed_at ? r.installed_at.split('T')[0] : 'unknown'}`);
+    console.log(`  ${c.dim}path:${c.reset} ${r.path}`);
+    console.log();
+  }
+
+  console.log(`${c.dim}${results.length} skill(s) total${c.reset}`);
+}
+
+async function cmdUpdate(positional, flags) {
+  if (positional.length === 0) {
+    fatal('Usage: agentroot update <domain>/<skill-id> [--tool claude|codex|gemini|cursor|agents]');
+  }
+
+  const input = positional[0];
+  const slashIdx = input.indexOf('/');
+  if (slashIdx === -1) fatal('Expected format: <domain>/<skill-id>');
+
+  const domain = input.slice(0, slashIdx);
+  const skillId = input.slice(slashIdx + 1);
+
+  // Find all installed copies
+  const updated = [];
+  for (const [tool, dirs] of Object.entries(TOOL_DIRS)) {
+    if (flags.tool && flags.tool !== tool) continue;
+
+    const paths = [dirs.global, dirs.project].filter(Boolean);
+    for (const baseDir of paths) {
+      const manifestPath = path.join(baseDir, skillId, MANIFEST_FILE);
+      if (!fs.existsSync(manifestPath)) continue;
+
+      let manifest;
+      try {
+        manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+      } catch { continue; }
+
+      if (manifest.source_domain !== domain) continue;
+
+      // Re-fetch SKILL.md
+      const url = manifest.skill_md_url;
+      if (!url) {
+        console.log(`${c.yellow}skip${c.reset} ${tool}:${skillId} — no SKILL.md URL in manifest`);
+        continue;
+      }
+
+      console.log(`${c.cyan}Updating ${tool}:${skillId}...${c.reset}`);
+      let content;
+      try {
+        content = await fetch(url);
+      } catch (err) {
+        console.log(`${c.red}fail${c.reset} ${tool}:${skillId} — ${err.message}`);
+        continue;
+      }
+
+      const newHash = hashContent(content);
+      if (newHash === manifest.version_hash) {
+        console.log(`${c.dim}no changes${c.reset} ${tool}:${skillId}`);
+        continue;
+      }
+
+      const skillPath = path.join(baseDir, skillId, 'SKILL.md');
+      fs.writeFileSync(skillPath, content, 'utf-8');
+
+      manifest.version_hash = newHash;
+      manifest.updated_at = new Date().toISOString();
+      fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+
+      console.log(`${c.green}updated${c.reset} ${c.bold}${tool}:${skillId}${c.reset}`);
+      updated.push(`${tool}:${skillId}`);
+    }
+  }
+
+  if (updated.length === 0) {
+    console.log(`No installed copies found for ${domain}/${skillId}.`);
+    console.log(`${c.dim}Install it first: npx agentroot install ${domain}/${skillId}${c.reset}`);
+  } else {
+    console.log(`\n${c.green}✓${c.reset} ${updated.length} skill(s) updated`);
+  }
+}
+
+async function cmdUninstall(positional, flags) {
+  if (positional.length === 0) {
+    fatal('Usage: agentroot uninstall <skill-id> [--tool claude|codex|gemini|cursor|agents]');
+  }
+
+  const skillId = positional[0];
+  // Remove domain prefix if provided
+  const actualId = skillId.includes('/') ? skillId.split('/').pop() : skillId;
+  let removed = 0;
+
+  for (const [tool, dirs] of Object.entries(TOOL_DIRS)) {
+    if (flags.tool && flags.tool !== tool) continue;
+
+    const paths = [dirs.global, dirs.project].filter(Boolean);
+    for (const baseDir of paths) {
+      const skillDir = path.join(baseDir, actualId);
+      const manifestPath = path.join(skillDir, MANIFEST_FILE);
+
+      // Only remove if it has our manifest (don't delete non-agentroot skills)
+      if (!fs.existsSync(manifestPath)) continue;
+
+      fs.rmSync(skillDir, { recursive: true, force: true });
+      console.log(`${c.green}removed${c.reset} ${tool}:${actualId} (${skillDir})`);
+      removed++;
+    }
+  }
+
+  if (removed === 0) {
+    console.log(`No installed AgentRoot skill found with id: ${actualId}`);
+  } else {
+    console.log(`\n${c.green}✓${c.reset} ${removed} skill(s) removed`);
+  }
+}
+
+// ─── Help ──────────────────────────────────────────────────────────────────
+
+function showHelp() {
+  console.log(`
+${c.bold}agentroot${c.reset} — Install AI agent skills in one command
+
+${c.bold}USAGE${c.reset}
+  npx agentroot <command> [options]
+
+${c.bold}COMMANDS${c.reset}
+  ${c.cyan}install${c.reset} <domain>/<skill-id>   Download and install a skill
+  ${c.cyan}search${c.reset}  <query>               Search the AgentRoot registry
+  ${c.cyan}list${c.reset}                          Show installed AgentRoot skills
+  ${c.cyan}update${c.reset}  <domain>/<skill-id>   Re-fetch a skill from source
+  ${c.cyan}uninstall${c.reset} <skill-id>          Remove an installed skill
+
+${c.bold}OPTIONS${c.reset}
+  --tool <name>    Target tool: claude, codex, gemini, cursor, agents
+  --project        Install to project directory (not global)
+  --all            Install all skills from a domain
+  --json           Output search results as JSON
+
+${c.bold}EXAMPLES${c.reset}
+  npx agentroot install stripe.com/payments --tool claude
+  npx agentroot install stripe.com --all
+  npx agentroot search "github actions"
+  npx agentroot list
+  npx agentroot update stripe.com/payments
+  npx agentroot uninstall payments
+
+${c.bold}AUTO-DETECT${c.reset}
+  When --tool is omitted, agentroot detects which AI tools are installed
+  by checking for ~/.claude/, ~/.codex/, ~/.gemini/, .cursor/ directories.
+  Falls back to .agents/skills/ (cross-tool standard) if none found.
+`);
+}
+
+// ─── Main ──────────────────────────────────────────────────────────────────
+
+async function main() {
+  const { cmd, positional, flags } = parseArgs(process.argv);
+
+  if (!cmd || cmd === 'help' || flags.help) {
+    showHelp();
+    return;
+  }
+
+  try {
+    switch (cmd) {
+      case 'install': case 'i':
+        await cmdInstall(positional, flags);
+        break;
+      case 'search': case 's':
+        await cmdSearch(positional, flags);
+        break;
+      case 'list': case 'ls':
+        await cmdList(positional, flags);
+        break;
+      case 'update': case 'up':
+        await cmdUpdate(positional, flags);
+        break;
+      case 'uninstall': case 'rm': case 'remove':
+        await cmdUninstall(positional, flags);
+        break;
+      default:
+        fatal(`Unknown command: ${cmd}. Run "agentroot help" for usage.`);
+    }
+  } catch (err) {
+    if (err.code === 'ENOTFOUND' || err.code === 'ECONNREFUSED') {
+      fatal('Could not connect to agentroot.io. Check your internet connection.');
+    }
+    fatal(err.message);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "agent-root",
+  "version": "0.1.0",
+  "description": "Install AI agent skills in one command. Works with Claude Code, Codex CLI, Gemini CLI, Cursor, and more.",
+  "bin": {
+    "agentroot": "./bin/agentroot.js"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "keywords": [
+    "ai",
+    "agent",
+    "skills",
+    "claude",
+    "codex",
+    "gemini",
+    "cursor",
+    "cli"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/d3-inc/agentroot"
+  },
+  "dependencies": {
+    "@agent-root/core": "^0.1.0"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}