agent-protocol-cli 1.0.0

package/bin/commands/search.js

@@ -0,0 +1,67 @@
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { buildCorpus, search as semanticSearch } from '../../vectorizer.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const INDEX_PATH = join(__dirname, '..', '..', 'data', 'index.json');
+
+export async function searchCommand(query, options) {
+  const limit = parseInt(options.limit || '10');
+  const asJson = options.json || false;
+
+  if (!query || !query.trim()) {
+    const index = loadIndex();
+    printResults(index.slice(0, limit), query, asJson);
+    return;
+  }
+
+  const index = loadIndex();
+  try {
+    const corpus = buildCorpus(index);
+    const results = semanticSearch(query, corpus, index, limit);
+    printResults(results, query, asJson);
+  } catch (err) {
+    // Fallback: keyword match
+    const kw = query.toLowerCase();
+    const results = index.filter(m => {
+      const text = [m.name, m.description, m.id, ...(m.tags || [])].join(' ').toLowerCase();
+      return text.includes(kw);
+    }).slice(0, limit);
+    printResults(results, query, asJson);
+  }
+}
+
+function loadIndex() {
+  if (!existsSync(INDEX_PATH)) {
+    console.error('❌ 索引文件未找到。请重新安装 agent-protocol-cli');
+    process.exit(1);
+  }
+  return JSON.parse(readFileSync(INDEX_PATH, 'utf-8'));
+}
+
+function printResults(results, query, asJson) {
+  if (asJson) {
+    console.log(JSON.stringify({ query, total: results.length, results }, null, 2));
+    return;
+  }
+
+  if (results.length === 0) {
+    console.log(`\n  🔍 未找到匹配 "${query}" 的 Skill\n`);
+    return;
+  }
+
+  console.log(`\n  📦 找到 ${results.length} 个匹配的 Skill（查询: "${query}"）\n`);
+  console.log('  ' + '─'.repeat(64));
+
+  results.forEach((m, i) => {
+    const capCount = m.capabilities?.length || 0;
+    const repo = m._repo || m.id?.replace(/\./g, '/') || 'unknown';
+    const score = m.score ? (m.score * 100).toFixed(1) + '% 匹配' : '';
+    console.log(`  ${(i + 1).toString().padStart(2)}. ${m.name}  v${m.version || '0.1'}  ${score}`);
+    console.log(`     描述: ${(m.description || '暂无').slice(0, 80)}`);
+    console.log(`     能力: ${capCount} 个 | 引擎: ${m.runtime?.engine || '未指定'}`);
+    console.log(`     安装: agent install ${repo}`);
+    console.log('');
+  });
+}

package/bin/commands/update.js

@@ -0,0 +1,339 @@
+import { spawnSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import chalk from 'chalk';
+import { createInterface } from 'readline';
+
+const AGENTS_DIR = join(homedir(), '.agents');
+const CONFIG_PATH = join(AGENTS_DIR, '.agent-config.json');
+
+export async function updateCommand(skillName, options) {
+  const all = options.all || !skillName;
+  const isRollback = options.rollback || false;
+  const force = options.force || false;
+  const checkOnly = options.check || options.dryRun || false;
+
+  // Load config
+  const config = loadConfig();
+  const installed = config.installed || {};
+  const names = Object.keys(installed);
+
+  // If a specific skill name is given, update only that one
+  const targets = skillName
+    ? (installed[skillName] ? [skillName] : [])
+    : names;
+
+  if (names.length === 0) {
+    console.log(chalk.yellow('  尚未安装任何 Skill。'));
+    console.log(chalk.gray('  使用: agent install user/repo'));
+    return;
+  }
+
+  if (skillName && !installed[skillName]) {
+    console.error(chalk.red(`❌ 未找到已安装的 Skill: ${skillName}`));
+    console.log(chalk.gray('  已安装的: ' + names.join(', ')));
+    process.exit(1);
+  }
+
+  if (targets.length === 0) {
+    console.log(chalk.yellow('  没有需要更新的 Skill。'));
+    return;
+  }
+
+  // ── Rollback mode ──
+  if (isRollback) {
+    await rollbackSkill(skillName, options, installed);
+    return;
+  }
+
+  // ── Check-only mode ──
+  if (checkOnly) {
+    await checkUpdates(targets, installed);
+    return;
+  }
+
+  // ── Update mode ──
+  console.log(chalk.blue(all
+    ? `🔄 更新所有已安装的 Skill (${targets.length} 个)...`
+    : `🔄 更新 ${chalk.bold(skillName)}...`));
+  console.log('');
+
+  let successCount = 0;
+  let failCount = 0;
+  let skippedCount = 0;
+
+  for (const name of targets) {
+    const skill = installed[name];
+
+    if (!existsSync(skill.dir)) {
+      console.log(chalk.yellow(`  ⚠ ${chalk.bold(name)}: 目录不存在，跳过`));
+      const answer = await ask(chalk.yellow(`    是否从配置中移除？[y/N] `));
+      if (answer.toLowerCase() === 'y') {
+        delete installed[name];
+        writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+        console.log(chalk.gray(`    ✓ ${name} 已从注册表中移除`));
+      }
+      skippedCount++;
+      continue;
+    }
+
+    // Check if update is available
+    const updateAvailable = await checkRemoteUpdate(name, skill);
+    if (!updateAvailable && !force) {
+      console.log(chalk.gray(`  - ${chalk.bold(name)}: 已是最新版本 (v${skill.version})`));
+      skippedCount++;
+      continue;
+    }
+
+    // Stash local changes before pull
+    try {
+      const stashResult = spawnSync('git', ['stash'], {
+        cwd: skill.dir, stdio: 'pipe', encoding: 'utf-8', timeout: 10000,
+      });
+      const hasStash = stashResult.stdout?.includes('Saved') || false;
+
+      // Pull latest
+      console.log(chalk.gray(`  ${chalk.bold(name)}: git pull...`));
+      const pullResult = spawnSync('git', ['pull', '--rebase', '--autostash'], {
+        cwd: skill.dir, stdio: 'pipe', encoding: 'utf-8', timeout: 30000,
+      });
+
+      if (pullResult.status !== 0) {
+        // Fallback to simple pull
+        const fallback = spawnSync('git', ['pull'], {
+          cwd: skill.dir, stdio: 'pipe', encoding: 'utf-8', timeout: 30000,
+        });
+        if (fallback.status !== 0) {
+          throw new Error(fallback.stderr?.split('\n')[0]?.slice(0, 100) || 'git pull 失败');
+        }
+      }
+
+      // Get new commit hash
+      const newCommit = getCommitHash(skill.dir);
+      const newManifestVersion = getUpdatedManifestVersion(skill.dir);
+
+      // Update config
+      installed[name].updated_at = new Date().toISOString();
+      installed[name].last_commit = newCommit;
+      if (newManifestVersion) {
+        installed[name].previous_version = skill.version;
+        installed[name].version = newManifestVersion;
+      }
+
+      // Run on_update lifecycle hook if manifest has one
+      const manifest = tryLoadManifest(skill.dir);
+      if (manifest?.lifecycle?.on_update) {
+        console.log(chalk.blue(`    🎣 执行更新钩子...`));
+        await runHook(skill.dir, manifest.lifecycle.on_update, 'on_update');
+      }
+
+      writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+      console.log(chalk.green(`  ✓ ${chalk.bold(name)}: ${newManifestVersion ? `v${skill.version} → v${newManifestVersion}` : '已更新'}`));
+      successCount++;
+
+    } catch (err) {
+      // Attempt to restore stash
+      try {
+        spawnSync('git', ['stash', 'pop'], { cwd: skill.dir, stdio: 'ignore', timeout: 5000 });
+      } catch {}
+
+      console.log(chalk.red(`  ✗ ${chalk.bold(name)}: ${err.message}`));
+      failCount++;
+    }
+  }
+
+  // ── Summary ──
+  console.log('');
+  if (checkOnly) return;
+
+  const total = successCount + failCount + skippedCount;
+  console.log(all
+    ? chalk.green(`✅ 更新完成: ${successCount} 成功, ${failCount} 失败, ${skippedCount} 跳过`)
+    : (failCount === 0
+      ? chalk.green(`✅ ${skillName} 已更新`)
+      : chalk.red(`❌ ${skillName} 更新失败`)));
+}
+
+// ─── Check-only mode ───
+async function checkUpdates(targets, installed) {
+  console.log(chalk.blue('🔍 检查更新...'));
+  console.log('');
+
+  let hasUpdates = false;
+
+  for (const name of targets) {
+    const skill = installed[name];
+    if (!existsSync(skill.dir)) {
+      console.log(chalk.yellow(`  ⚠ ${name}: 目录不存在`));
+      continue;
+    }
+
+    const localVersion = skill.version || '?';
+    const remoteVersion = await getRemoteVersion(name, skill);
+
+    if (remoteVersion && remoteVersion !== localVersion) {
+      console.log(chalk.green(`  📦 ${chalk.bold(name)}: v${localVersion} → v${remoteVersion}`));
+      hasUpdates = true;
+    } else {
+      console.log(chalk.gray(`  ✓ ${chalk.bold(name)}: v${localVersion}（最新）`));
+    }
+  }
+
+  console.log('');
+  if (!hasUpdates) {
+    console.log(chalk.green('✅ 所有 Skill 已是最新版本'));
+  } else {
+    console.log(chalk.green('  使用 agent update --all 更新全部'));
+  }
+}
+
+async function checkRemoteUpdate(name, skill) {
+  try {
+    const result = spawnSync('git', ['fetch', '--dry-run'], {
+      cwd: skill.dir, stdio: 'pipe', encoding: 'utf-8', timeout: 15000,
+    });
+    return result.stderr?.includes('->') || false;
+  } catch {
+    return false;
+  }
+}
+
+async function getRemoteVersion(name, skill) {
+  try {
+    // Try to get version from remote agent.json
+    const rawUrl = `https://raw.githubusercontent.com/${skill.repo}/main/agent.json`;
+    // We'll use a simpler approach: fetch via git
+    const fetchResult = spawnSync('git', ['ls-remote', '--tags', `https://github.com/${skill.repo}.git`], {
+      stdio: 'pipe', encoding: 'utf-8', timeout: 15000,
+    });
+    const tags = fetchResult.stdout?.match(/v?\d+\.\d+\.\d+/g);
+    if (tags?.length) {
+      return tags.sort(semverSort).pop();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// ─── Rollback ───
+async function rollbackSkill(name, options, installed) {
+  if (!name) {
+    console.error(chalk.red('❌ 请指定要回滚的 Skill: agent update <name> --rollback'));
+    process.exit(1);
+  }
+
+  const skill = installed[name];
+  if (!skill) {
+    console.error(chalk.red(`❌ 未找到已安装的 Skill: ${name}`));
+    process.exit(1);
+  }
+
+  if (!existsSync(skill.dir)) {
+    console.error(chalk.red(`❌ 目录不存在: ${skill.dir}`));
+    process.exit(1);
+  }
+
+  // List recent git refs
+  console.log(chalk.blue(`🕒 查看 ${name} 的版本历史...`));
+  const logResult = spawnSync('git', ['log', '--oneline', '-10'], {
+    cwd: skill.dir, stdio: 'pipe', encoding: 'utf-8', timeout: 10000,
+  });
+  console.log(chalk.gray(logResult.stdout || '无历史记录'));
+
+  const targetRef = options.ref || options.to;
+  if (!targetRef) {
+    console.log(chalk.yellow('  使用 --to <commit> 指定要回滚到的版本'));
+    process.exit(1);
+  }
+
+  console.log(chalk.blue(`  git checkout ${targetRef}...`));
+  const result = spawnSync('git', ['checkout', targetRef], {
+    cwd: skill.dir, stdio: 'pipe', encoding: 'utf-8', timeout: 15000,
+  });
+
+  if (result.status === 0) {
+    console.log(chalk.green(`✅ ${name} 已回滚到 ${targetRef}`));
+    installed[name].rollback_ref = targetRef;
+    installed[name].updated_at = new Date().toISOString();
+    writeFileSync(CONFIG_PATH, JSON.stringify({ installed }, null, 2));
+  } else {
+    console.error(chalk.red(`❌ 回滚失败: ${result.stderr?.slice(0, 200)}`));
+  }
+}
+
+// ─── Helpers ───
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function getCommitHash(dir) {
+  try {
+    const result = spawnSync('git', ['rev-parse', '--short', 'HEAD'], {
+      cwd: dir, stdio: 'pipe', encoding: 'utf-8', timeout: 5000,
+    });
+    return result.stdout?.trim() || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+function getUpdatedManifestVersion(dir) {
+  try {
+    const path = join(dir, 'agent.json');
+    if (existsSync(path)) {
+      const manifest = JSON.parse(readFileSync(path, 'utf-8'));
+      return manifest.version || null;
+    }
+  } catch {}
+  return null;
+}
+
+function tryLoadManifest(dir) {
+  try {
+    const path = join(dir, 'agent.json');
+    if (existsSync(path)) {
+      return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+  } catch {}
+  return null;
+}
+
+async function runHook(dir, hook, hookName) {
+  if (!hook) return;
+
+  if (hook.requires_approval) {
+    const answer = await ask(chalk.yellow(`  更新钩子: ${hook.description || hookName}\n  确认？[y/N] `));
+    if (answer.toLowerCase() !== 'y') {
+      console.log(chalk.gray(`  跳过 ${hookName}`));
+      return;
+    }
+  }
+
+  try {
+    if (hook.command) {
+      spawnSync(hook.command, { cwd: dir, shell: true, timeout: hook.timeout_ms || 30000, stdio: 'pipe', encoding: 'utf-8' });
+    }
+  } catch {}
+}
+
+function semverSort(a, b) {
+  const clean = v => v.replace(/^v/, '').split('.').map(Number);
+  const [a1, a2, a3] = clean(a);
+  const [b1, b2, b3] = clean(b);
+  return a1 - b1 || a2 - b2 || a3 - b3;
+}
+
+function ask(query) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(query, answer => {
+    rl.close();
+    resolve(answer);
+  }));
+}

package/bin/commands/validate.js

@@ -0,0 +1,102 @@
+import { readFileSync, existsSync } from 'fs';
+import chalk from 'chalk';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SCHEMA_PATH = join(__dirname, '..', 'data', 'manifest.schema.json');
+
+export async function validateCommand(path) {
+  if (!existsSync(path)) {
+    console.error(chalk.red(`❌ 文件不存在: ${path}`));
+    process.exit(1);
+  }
+
+  console.log(chalk.blue(`🔍 校验: ${path}`));
+  console.log();
+
+  let manifest;
+  try {
+    const content = readFileSync(path, 'utf-8');
+    // Try JSON first, could also support YAML later
+    manifest = JSON.parse(content);
+  } catch (err) {
+    console.error(chalk.red(`❌ 解析失败: ${err.message}`));
+    process.exit(1);
+  }
+
+  // Load schema
+  let schema;
+  try {
+    schema = JSON.parse(readFileSync(SCHEMA_PATH, 'utf-8'));
+  } catch {
+    console.log(chalk.yellow('  ⚠ 无法加载 Schema 文件，执行基础校验...'));
+    basicValidate(manifest);
+    return;
+  }
+
+  // Dynamic import of ajv for JSON Schema validation
+  try {
+    const Ajv = (await import('ajv')).default;
+    const addFormats = (await import('ajv-formats')).default;
+    const ajv = new Ajv({ allErrors: true });
+    addFormats(ajv);
+    const validate = ajv.compile(schema);
+    const valid = validate(manifest);
+
+    if (valid) {
+      console.log(chalk.green('✅ Manifest 验证通过！'));
+      console.log();
+      printSummary(manifest);
+    } else {
+      console.log(chalk.red(`❌ 发现 ${validate.errors.length} 个问题：`));
+      for (const err of validate.errors) {
+        const path = err.instancePath || '/';
+        console.log(`  ${chalk.red('✗')} ${path} ${err.message}`);
+      }
+      process.exit(1);
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠ 高级校验不可用: ${err.message}`));
+    basicValidate(manifest);
+  }
+}
+
+function basicValidate(manifest) {
+  const errors = [];
+
+  if (!manifest.id) errors.push('缺少必需字段: id');
+  if (!manifest.name) errors.push('缺少必需字段: name');
+  if (!manifest.version) errors.push('缺少必需字段: version');
+  if (!manifest.capabilities || !Array.isArray(manifest.capabilities) || manifest.capabilities.length === 0) {
+    errors.push('必须至少声明一个 capability');
+  }
+
+  if (errors.length > 0) {
+    console.log(chalk.red(`❌ 发现 ${errors.length} 个问题：`));
+    for (const err of errors) {
+      console.log(`  ${chalk.red('✗')} ${err}`);
+    }
+    process.exit(1);
+  }
+
+  console.log(chalk.green('✅ 基础验证通过！'));
+  printSummary(manifest);
+}
+
+function printSummary(manifest) {
+  console.log(`  ${chalk.bold(manifest.name)} v${manifest.version}`);
+  console.log(`  ID: ${chalk.cyan(manifest.id)}`);
+  console.log(`  能力数: ${chalk.green(manifest.capabilities?.length || 0)}`);
+  
+  const caps = manifest.capabilities || [];
+  for (const cap of caps) {
+    const intentCount = cap.intents?.length || 0;
+    const hasInput = cap.input ? '✓' : '✗';
+    console.log(`    ${chalk.cyan('·')} ${cap.name} (intents: ${intentCount}, input: ${hasInput})`);
+  }
+
+  if (manifest.trust?.permissions?.length) {
+    console.log(`  声明的权限: ${chalk.yellow(manifest.trust.permissions.join(', '))}`);
+  }
+}