@skill-map/cli 0.34.0 → 0.35.0

package/dist/cli.js

@@ -470,7 +470,13 @@ var claudeProvider = {
         color: "#3b82f6",
         colorDark: "#60a5fa",
         icon: { kind: "pi", id: "pi-user" }
-      }
+      },
+      // `frontmatter.name` is the documented canonical identifier
+      // (https://code.claude.com/docs/en/agents.md); `filename-basename`
+      // is a graceful fallback for agents authored without an explicit
+      // `name:` field, the file at `.claude/agents/<id>.md` resolves
+      // `@<id>` even when frontmatter is partial.
+      identifiers: ["frontmatter.name", "filename-basename"]
     },
     command: {
       schema: "./schemas/command.schema.json",
@@ -483,7 +489,12 @@ var claudeProvider = {
           kind: "svg",
           path: "M4 17 L10 11 L4 5 M12 19 L20 19"
         }
-      }
+      },
+      // Commands share Anthropic's documented merger with skills
+      // (skills.md), so the same dual-source applies: explicit
+      // `frontmatter.name` first, filename basename fallback for
+      // `.claude/commands/<name>.md`.
+      identifiers: ["frontmatter.name", "filename-basename"]
     },
     skill: {
       schema: "./schemas/skill.schema.json",
@@ -493,7 +504,13 @@ var claudeProvider = {
         color: "#10b981",
         colorDark: "#34d399",
         icon: { kind: "pi", id: "pi-bolt" }
-      }
+      },
+      // Anthropic explicitly documents the directory name as the
+      // canonical identifier for skills (skills.md: "The directory name
+      // becomes the command you type"). `frontmatter.name` is an
+      // optional override; when absent, the dirname between
+      // `.claude/skills/` and `/SKILL.md` is the invocation handle.
+      identifiers: ["frontmatter.name", "dirname"]
     },
     /**
      * Phase 5 of the active-lens migration: MCP servers surface as
@@ -518,9 +535,24 @@ var claudeProvider = {
         color: "#8b5cf6",
         colorDark: "#a78bfa",
         icon: { kind: "pi", id: "pi-server" }
-      }
+      },
+      // MCP nodes are virtual (`mcp://<server>`), no filesystem path
+      // and no Claude invocation surface (mentions / slashes don't
+      // resolve to MCPs). `frontmatter.name` is set by the
+      // `core/mcp-tools` extractor at emission so the index stays
+      // consistent if a future link.kind ever targets MCPs by name.
+      identifiers: ["frontmatter.name"]
     }
   },
+  // Strict resolution matrix consumed by `liftResolvedLinkConfidence`:
+  // an `@<name>` mention resolves to an agent only; a `/<name>` slash
+  // resolves to a command OR skill (Anthropic merged the two surfaces
+  // per skills.md). MCP nodes are not invocable through either
+  // mention or slash, so they intentionally do not appear here.
+  resolution: {
+    mentions: ["agent"],
+    invokes: ["command", "skill"]
+  },
   // Auxiliary schemas the per-kind schemas $ref by $id. AJV needs them
   // registered via addSchema BEFORE the per-kind schemas compile, so the
   // validator builder pre-registers them. `skill-base.schema.json` is the
@@ -803,7 +835,8 @@ var geminiProvider = {
         color: "#3b82f6",
         colorDark: "#60a5fa",
         icon: { kind: "pi", id: "pi-user" }
-      }
+      },
+      identifiers: ["frontmatter.name", "filename-basename"]
     },
     skill: {
       schema: "./schemas/skill.schema.json",
@@ -813,9 +846,20 @@ var geminiProvider = {
         color: "#10b981",
         colorDark: "#34d399",
         icon: { kind: "pi", id: "pi-bolt" }
-      }
+      },
+      // Gemini skills live at `.gemini/skills/<name>/SKILL.md`; the
+      // dirname is the invocation handle per Google's docs
+      // (https://geminicli.com/docs/cli/creating-skills/).
+      identifiers: ["frontmatter.name", "dirname"]
     }
   },
+  // Gemini's invocation surfaces mirror Claude's at the kernel level
+  // (mentions for agents, slash invokes for skills). Commands are not
+  // a Gemini concept; only `skill` belongs to `invokes`.
+  resolution: {
+    mentions: ["agent"],
+    invokes: ["skill"]
+  },
   classify(path) {
     const lower = path.toLowerCase();
     if (lower.startsWith(".gemini/agents/")) return "agent";
@@ -894,9 +938,20 @@ var openaiProvider = {
         color: "#22c55e",
         colorDark: "#4ade80",
         icon: { kind: "pi", id: "pi-bolt" }
-      }
+      },
+      // Codex sub-agents are referenced by file basename
+      // (`.codex/agents/<name>.toml`). `frontmatter.name` lives inside
+      // the TOML structured frontmatter when the author declared it
+      // explicitly.
+      identifiers: ["frontmatter.name", "filename-basename"]
     }
   },
+  // Codex's invocation surface is mention-style today (`@<name>`); slash
+  // invocation and skill nodes land in Phase 6b. Empty `invokes` keeps
+  // the contract narrow until skills arrive.
+  resolution: {
+    mentions: ["agent"]
+  },
   classify(path) {
     const lower = path.toLowerCase();
     if (lower.startsWith(".codex/agents/") && lower.endsWith(".toml")) return "agent";
@@ -935,9 +990,18 @@ var agentSkillsProvider = {
         color: "#10b981",
         colorDark: "#34d399",
         icon: { kind: "pi", id: "pi-bolt" }
-      }
+      },
+      // Open-standard skills mirror Anthropic's: dirname between
+      // `.agents/skills/` and `/SKILL.md` is the canonical handle,
+      // `frontmatter.name` overrides when present.
+      identifiers: ["frontmatter.name", "dirname"]
     }
   },
+  // The open standard documents slash-style invocation of skills; no
+  // mention surface (no agents in this Provider's territory).
+  resolution: {
+    invokes: ["skill"]
+  },
   classify(path) {
     if (/^\.agents\/skills\/[^/]+\/skill\.md$/.test(path.toLowerCase())) return "skill";
     return null;
@@ -989,8 +1053,18 @@ var coreMarkdownProvider = {
           path: "M14 2 H6 a2 2 0 0 0 -2 2 V20 a2 2 0 0 0 2 2 H18 a2 2 0 0 0 2 -2 V8 L14 2 M14 2 V8 H20 M16 13 H8 M16 17 H8 M10 9 H8"
         }
       }
+      // No `identifiers`: markdown nodes are addressed by path, not by a
+      // canonical name. The name index built by `liftResolvedLinkConfidence`
+      // never sees markdown entries; resolution falls through to the
+      // path-match rule only.
     }
   },
+  // No `resolution`: `core/markdown` is the universal fallback Provider,
+  // it does not declare an invocation surface of its own. Mentions /
+  // slashes sourced from markdown bodies still resolve via OTHER
+  // Providers' resolution maps (the lookup keys on the source node's
+  // Provider id, not on `core/markdown`). Leaving the field absent keeps
+  // the contract narrow.
   classify() {
     return "markdown";
   }
@@ -1174,7 +1248,13 @@ var markdownLinkExtractor = {
         source: ctx.node.path,
         target: resolved,
         kind: "references",
-        confidence: 0.95,
+        // 1.0: the `[text](path)` syntax is unambiguous. Markdown
+        // explicitly designates an out-link via the brackets +
+        // parentheses pair; there is no inference left to discount.
+        // Whether the path resolves to a real node is a separate
+        // concern (the `core/broken-ref` analyzer flags unresolved
+        // targets), not a confidence question.
+        confidence: 1,
         sources: [ID5],
         trigger: {
           originalTrigger: original,
@@ -3134,7 +3214,7 @@ var UPDATE_CHECK_TEXTS = {
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.34.0",
+  version: "0.35.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -13583,7 +13663,7 @@ function originatingNodeOf(link2, priorNodePaths) {
 function computeCacheDecision(opts) {
   const applicableExtractors = opts.extractors.filter((ex) => {
     if (!matchesKindPrecondition(ex, opts.kind)) return false;
-    if (!matchesProviderPrecondition(ex, opts.provider, opts.activeProvider)) return false;
+    if (!matchesProviderPrecondition(ex, opts.activeProvider)) return false;
     return true;
   });
   const applicableQualifiedIds = new Set(
@@ -13607,10 +13687,9 @@ function matchesKindPrecondition(ex, kind) {
     return kindOnly === kind;
   });
 }
-function matchesProviderPrecondition(ex, nodeProvider, activeProvider) {
+function matchesProviderPrecondition(ex, activeProvider) {
   const providers = ex.precondition?.provider;
   if (!providers || providers.length === 0) return true;
-  if (!providers.includes(nodeProvider)) return false;
   if (activeProvider === null) return false;
   return providers.includes(activeProvider);
 }
@@ -13713,37 +13792,93 @@ function classifyLinkSource(source, shortIdToQualified, cachedQualifiedIds, appl
   return "obsolete";
 }
 
-// kernel/orchestrator/lift-mention-confidence.ts
-function liftMentionConfidence(links, nodes) {
-  if (!links.some((l) => l.kind === "mentions")) return;
-  const byPath3 = /* @__PURE__ */ new Set();
-  for (const node of nodes) byPath3.add(node.path);
-  const byNormalizedName = indexByNormalizedName2(nodes);
+// kernel/orchestrator/lift-resolved-link-confidence.ts
+import { posix as pathPosix4 } from "path";
+function liftResolvedLinkConfidence(links, nodes, ctx) {
+  if (!links.some((l) => l.confidence < 1)) return;
+  const indexes = buildIndexes(nodes, ctx);
   for (const link2 of links) {
-    if (link2.kind !== "mentions") continue;
-    if (isResolved2(link2, byPath3, byNormalizedName)) {
+    if (link2.confidence < 1 && resolves(link2, indexes, ctx)) {
       link2.confidence = 1;
     }
   }
 }
-function isResolved2(link2, byPath3, byNormalizedName) {
-  const normalized = link2.trigger?.normalizedTrigger;
-  if (normalized) {
-    const withoutSigil = normalized.replace(/^[/@]/, "").trim();
-    if (byNormalizedName.has(withoutSigil)) return true;
-  }
-  if (byPath3.has(link2.target)) return true;
-  return false;
-}
-function indexByNormalizedName2(nodes) {
-  const out = /* @__PURE__ */ new Map();
+function buildIndexes(nodes, ctx) {
+  const byPath3 = /* @__PURE__ */ new Set();
+  const byName = /* @__PURE__ */ new Map();
+  const nodeByPath = /* @__PURE__ */ new Map();
   for (const node of nodes) {
-    const raw = node.frontmatter?.["name"];
-    const name = typeof raw === "string" ? raw : "";
-    if (!name) continue;
-    out.set(normalizeTrigger(name), true);
+    byPath3.add(node.path);
+    nodeByPath.set(node.path, node);
+    indexNode(node, ctx, byName);
+  }
+  return { byPath: byPath3, byName, nodeByPath };
+}
+function resolves(link2, indexes, ctx) {
+  if (indexes.byPath.has(link2.target)) return true;
+  return resolvesByName(link2, indexes, ctx);
+}
+function resolvesByName(link2, indexes, ctx) {
+  const stripped = stripTriggerSigil(link2.trigger?.normalizedTrigger);
+  if (stripped === null) return false;
+  const candidates = indexes.byName.get(stripped);
+  if (!candidates?.length) return false;
+  const allowedKinds = lookupAllowedKinds(link2, indexes, ctx);
+  if (!allowedKinds?.length) return false;
+  return candidates.some((c) => allowedKinds.includes(c.kind));
+}
+function lookupAllowedKinds(link2, indexes, ctx) {
+  const sourceNode = indexes.nodeByPath.get(link2.source);
+  if (!sourceNode) return void 0;
+  return ctx.providerResolution.get(sourceNode.provider)?.[link2.kind];
+}
+function stripTriggerSigil(normalized) {
+  if (!normalized) return null;
+  const trimmed = normalized.replace(/^[/@]/, "").trim();
+  return trimmed.length === 0 ? null : trimmed;
+}
+function indexNode(node, ctx, byName) {
+  const kindDescriptor = ctx.kindRegistry.get(kindKey(node));
+  const sources = kindDescriptor?.identifiers;
+  if (!sources || sources.length === 0) return;
+  for (const source of sources) {
+    const raw = deriveIdentifier(source, node);
+    if (!raw) continue;
+    const normalized = normalizeTrigger(raw);
+    if (!normalized) continue;
+    const bucket = byName.get(normalized);
+    if (bucket) {
+      bucket.push({ kind: node.kind });
+    } else {
+      byName.set(normalized, [{ kind: node.kind }]);
+    }
   }
-  return out;
+}
+function deriveIdentifier(source, node) {
+  if (source === "frontmatter.name") return readFrontmatterName(node);
+  if (source === "filename-basename") return readFilenameBasename(node);
+  return readDirname(node);
+}
+function readFrontmatterName(node) {
+  const raw = node.frontmatter?.["name"];
+  if (typeof raw !== "string") return null;
+  return raw.length > 0 ? raw : null;
+}
+function readFilenameBasename(node) {
+  const base = pathPosix4.basename(node.path);
+  if (!base) return null;
+  const ext = pathPosix4.extname(base);
+  const stem = ext ? base.slice(0, -ext.length) : base;
+  return stem.length > 0 ? stem : null;
+}
+function readDirname(node) {
+  const dir = pathPosix4.dirname(node.path);
+  if (!dir || dir === "." || dir === "/") return null;
+  const base = pathPosix4.basename(dir);
+  return base.length > 0 ? base : null;
+}
+function kindKey(node) {
+  return `${node.provider}/${node.kind}`;
 }
 
 // kernel/orchestrator/post-walk-transforms.ts
@@ -13756,17 +13891,17 @@ var POST_WALK_TRANSFORMS = [
     }
   },
   {
-    id: "lift-mention-confidence",
-    description: "Bump resolved `mentions` links to confidence 1.0 once the full node graph is known (post-merge polish).",
-    run(links, nodes) {
-      liftMentionConfidence(links, nodes);
+    id: "lift-resolved-link-confidence",
+    description: "Bump invocation links to confidence 1.0 when target / trigger resolves against the full node graph per the source Provider rules.",
+    run(links, nodes, ctx) {
+      liftResolvedLinkConfidence(links, nodes, ctx);
     }
   }
 ];
-function applyPostWalkTransforms(links, nodes, transforms = POST_WALK_TRANSFORMS) {
+function applyPostWalkTransforms(links, nodes, ctx, transforms = POST_WALK_TRANSFORMS) {
   let current = links;
   for (const transform of transforms) {
-    const next = transform.run(current, nodes);
+    const next = transform.run(current, nodes, ctx);
     if (next) current = next;
   }
   return current;
@@ -14261,7 +14396,6 @@ async function processRawNode(raw, provider, wctx, accum, claimedPaths, nextInde
   const cacheDecision = computeCacheDecision({
     extractors: wctx.opts.extractors,
     kind,
-    provider: provider.id,
     activeProvider: wctx.opts.activeProvider,
     nodePath: raw.path,
     bodyHash,
@@ -14479,7 +14613,8 @@ async function runScanInternal(_kernel, options) {
     pluginStores: options.pluginStores,
     activeProvider: resolveActiveProviderOption(options.activeProvider, options.roots)
   });
-  walked.internalLinks = applyPostWalkTransforms(walked.internalLinks, walked.nodes);
+  const postWalkCtx = buildPostWalkTransformCtx(_kernel);
+  walked.internalLinks = applyPostWalkTransforms(walked.internalLinks, walked.nodes, postWalkCtx);
   recomputeLinkCounts(walked.nodes, walked.internalLinks);
   recomputeExternalRefsCount(walked.nodes, walked.externalLinks, walked.cachedPaths);
   await dispatchExtractorCompleted(exts.extractors, emitter, hookDispatcher);
@@ -14512,6 +14647,22 @@ async function runScanInternal(_kernel, options) {
   await hookDispatcher.dispatch("scan.completed", scanCompletedEvent);
   return buildScanReturn(walked, issues, renameOps, stats, options, setup);
 }
+function buildPostWalkTransformCtx(kernel) {
+  const kindRegistry = /* @__PURE__ */ new Map();
+  const providerResolution = /* @__PURE__ */ new Map();
+  const providers = kernel.registry.all("provider");
+  for (const provider of providers) {
+    if (provider.kinds) {
+      for (const [kindName, descriptor] of Object.entries(provider.kinds)) {
+        kindRegistry.set(`${provider.id}/${kindName}`, descriptor);
+      }
+    }
+    if (provider.resolution) {
+      providerResolution.set(provider.id, provider.resolution);
+    }
+  }
+  return { kindRegistry, providerResolution };
+}
 function buildScanSetup(options) {
   const start = Date.now();
   const emitter = options.emitter ?? new InMemoryProgressEmitter();