tokrepo-mcp-server 2.6.0 → 2.7.0

package/README.md

@@ -42,6 +42,7 @@ Once connected, your AI assistant can:
 - **Plan before install** — get install plan v2 with policy decisions, rollback, and verification
 - **Safe Codex install** — dry-run by default; risky assets must be staged or explicitly approved
 - **Lifecycle control** — list, update, uninstall, and roll back managed Codex installs
+- **Project memory** — pair with `tokrepo init-agent --target all` so future agents know to call TokRepo during planning
 
 ## Available Tools
 
@@ -73,6 +74,16 @@ AI: [calls tokrepo_codex_install with dry_run=false, confirm=true] → Writes on
 AI: [calls tokrepo_rollback with dry_run=true] → Shows exactly what would be removed before rollback
 ```
 
+## Make Future Agents Discover TokRepo
+
+Run this once in a project:
+
+```bash
+npx tokrepo init-agent --target all
+```
+
+It writes managed instructions to `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, Cursor rules, and `.mcp.json`. The rule is simple: during planning, when the agent sees a capability gap, it should call `tokrepo_discover` before inventing a one-off local tool. After a task, agents can run `tokrepo agent-handoff --json` to suggest reusable files for user-confirmed private publishing.
+
 ## Why TokRepo?
 
 TokRepo is the **open registry for AI assets** — like npm for packages, but for AI skills, prompts, MCP configs, and workflows.

package/bin/server.js

@@ -19,7 +19,7 @@ const API_BASE = process.env.TOKREPO_API || 'https://api.tokrepo.com';
 const TOKREPO_URL = 'https://tokrepo.com';
 const TOKREPO_TOKEN = process.env.TOKREPO_TOKEN || '';
 const TOKREPO_CLI = process.env.TOKREPO_CLI || '';
-const SERVER_VERSION = '2.6.0';
+const SERVER_VERSION = '2.7.0';
 
 // ─── MCP Protocol (JSON-RPC over stdio) ───
 
@@ -701,7 +701,60 @@ function buildDiscoveryQuery(task, environment, constraints) {
   return compactText([...new Set(parts)].join(' '), 100);
 }
 
-function buildCandidate(item, target) {
+function scoreDiscoveryCandidate(item, task, target, constraints = {}) {
+  const metadata = itemAgentMetadata(item);
+  const fit = itemAgentFit(item);
+  const tags = itemTags(item);
+  const targets = candidateTargets(item, metadata);
+  const terms = extractSearchTerms(task, 10);
+  const haystack = [
+    item.title,
+    item.description,
+    tags.join(' '),
+    metadata.entrypoint,
+    metadata.asset_kind,
+  ].filter(Boolean).join(' ').toLowerCase();
+  let score = Number.isFinite(Number(fit.score)) ? Number(fit.score) : 45;
+  const reasons = [];
+  const matched = terms.filter(term => haystack.includes(term));
+  if (matched.length) {
+    score += Math.min(24, matched.length * 4);
+    reasons.push(`task term match: ${matched.slice(0, 5).join(', ')}`);
+  }
+  if (target && target !== 'any') {
+    if (targets.includes(target) || fit.target === target) {
+      score += 12;
+      reasons.push(`target matches ${target}`);
+    } else if (targets.length) {
+      score -= 10;
+      reasons.push(`target metadata is ${targets.join(', ')}`);
+    }
+  }
+  const kind = candidateKind(item, metadata, fit);
+  if (constraints.kind && String(kind).toLowerCase() === String(constraints.kind).toLowerCase()) {
+    score += 8;
+    reasons.push(`kind matches ${constraints.kind}`);
+  }
+  const policy = fit.policy || item.policy || '';
+  if (policy === 'allow') {
+    score += 6;
+    reasons.push('policy allow');
+  } else if (policy === 'deny') {
+    score -= 35;
+    reasons.push('policy deny');
+  } else if (policy === 'stage_only' || policy === 'confirm') {
+    score -= 6;
+    reasons.push(`policy ${policy}`);
+  }
+  const trust = item.trust || item.agent_trust || {};
+  if (trust.review_status === 'reviewed' || trust.verified_publisher) {
+    score += 4;
+    reasons.push('reviewed or verified');
+  }
+  return { score: Math.max(0, Math.min(100, Math.round(score))), reasons };
+}
+
+function buildCandidate(item, target, ranking = {}) {
   const uuid = candidateUuid(item);
   const metadata = itemAgentMetadata(item);
   const fit = itemAgentFit(item);
@@ -734,6 +787,7 @@ function buildCandidate(item, target) {
       policy: compactText(fit.policy || item.policy || '', 64),
       why,
     },
+    ranking,
     next_mcp_calls: [
       { tool: 'tokrepo_detail', arguments: { uuid } },
       { tool: 'tokrepo_install_plan', arguments: { uuid, target: planTarget } },
@@ -832,7 +886,11 @@ async function handleDiscover(args) {
       'Use the installed capability only for the matching subtask, then verify the user goal.',
       'If the agent creates a reusable improvement, ask before publishing and use tokrepo_push with explicit files.',
     ],
-    candidates: items.slice(0, limit).map(item => buildCandidate(item, target)).filter(candidate => candidate.uuid),
+    candidates: items
+      .map(item => buildCandidate(item, target, scoreDiscoveryCandidate(item, task, target, constraints)))
+      .filter(candidate => candidate.uuid)
+      .sort((a, b) => (b.ranking?.score || 0) - (a.ranking?.score || 0))
+      .slice(0, limit),
     empty_state: items.length ? null : {
       message: discoveryError
         ? `TokRepo discovery could not fetch live candidates for "${selectedQuery}".`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokrepo-mcp-server",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "Agent-native MCP server for TokRepo — search, plan, safely install, and push AI assets from MCP clients.",
   "mcpName": "io.github.tokrepo/mcp-server",
   "bin": {