@skill-map/cli 0.34.1 → 0.35.0

package/dist/index.js

@@ -101,7 +101,7 @@ import cl100k_base from "js-tiktoken/ranks/cl100k_base";
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.34.1",
+  version: "0.35.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -1713,6 +1713,9 @@ function classifyLinkSource(source, shortIdToQualified, cachedQualifiedIds, appl
   return "obsolete";
 }
 
+// kernel/orchestrator/lift-resolved-link-confidence.ts
+import { posix as pathPosix } from "path";
+
 // kernel/trigger-normalize.ts
 function normalizeTrigger(source) {
   let out = source.normalize("NFD");
@@ -1723,37 +1726,92 @@ function normalizeTrigger(source) {
   return out.trim();
 }
 
-// kernel/orchestrator/lift-mention-confidence.ts
-function liftMentionConfidence(links, nodes) {
-  if (!links.some((l) => l.kind === "mentions")) return;
-  const byPath2 = /* @__PURE__ */ new Set();
-  for (const node of nodes) byPath2.add(node.path);
-  const byNormalizedName = indexByNormalizedName(nodes);
+// kernel/orchestrator/lift-resolved-link-confidence.ts
+function liftResolvedLinkConfidence(links, nodes, ctx) {
+  if (!links.some((l) => l.confidence < 1)) return;
+  const indexes = buildIndexes(nodes, ctx);
   for (const link of links) {
-    if (link.kind !== "mentions") continue;
-    if (isResolved(link, byPath2, byNormalizedName)) {
+    if (link.confidence < 1 && resolves(link, indexes, ctx)) {
       link.confidence = 1;
     }
   }
 }
-function isResolved(link, byPath2, byNormalizedName) {
-  const normalized = link.trigger?.normalizedTrigger;
-  if (normalized) {
-    const withoutSigil = normalized.replace(/^[/@]/, "").trim();
-    if (byNormalizedName.has(withoutSigil)) return true;
-  }
-  if (byPath2.has(link.target)) return true;
-  return false;
-}
-function indexByNormalizedName(nodes) {
-  const out = /* @__PURE__ */ new Map();
+function buildIndexes(nodes, ctx) {
+  const byPath2 = /* @__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);
+    byPath2.add(node.path);
+    nodeByPath.set(node.path, node);
+    indexNode(node, ctx, byName);
+  }
+  return { byPath: byPath2, byName, nodeByPath };
+}
+function resolves(link, indexes, ctx) {
+  if (indexes.byPath.has(link.target)) return true;
+  return resolvesByName(link, indexes, ctx);
+}
+function resolvesByName(link, indexes, ctx) {
+  const stripped = stripTriggerSigil(link.trigger?.normalizedTrigger);
+  if (stripped === null) return false;
+  const candidates = indexes.byName.get(stripped);
+  if (!candidates?.length) return false;
+  const allowedKinds = lookupAllowedKinds(link, indexes, ctx);
+  if (!allowedKinds?.length) return false;
+  return candidates.some((c) => allowedKinds.includes(c.kind));
+}
+function lookupAllowedKinds(link, indexes, ctx) {
+  const sourceNode = indexes.nodeByPath.get(link.source);
+  if (!sourceNode) return void 0;
+  return ctx.providerResolution.get(sourceNode.provider)?.[link.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 = pathPosix.basename(node.path);
+  if (!base) return null;
+  const ext = pathPosix.extname(base);
+  const stem = ext ? base.slice(0, -ext.length) : base;
+  return stem.length > 0 ? stem : null;
+}
+function readDirname(node) {
+  const dir = pathPosix.dirname(node.path);
+  if (!dir || dir === "." || dir === "/") return null;
+  const base = pathPosix.basename(dir);
+  return base.length > 0 ? base : null;
+}
+function kindKey(node) {
+  return `${node.provider}/${node.kind}`;
 }
 
 // kernel/orchestrator/post-walk-transforms.ts
@@ -1766,17 +1824,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;
@@ -2846,7 +2904,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);
@@ -2879,6 +2938,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();