@skill-map/cli 0.36.0 → 0.38.0

package/dist/index.js

@@ -43,7 +43,7 @@ var DuplicateExtensionError = class extends Error {
   }
 };
 var Registry = class {
-  /** kind → qualifiedId → Extension. */
+  /** kind → qualifiedId → IExtension. */
   #byKind;
   constructor() {
     this.#byKind = new Map(
@@ -101,7 +101,7 @@ import cl100k_base from "js-tiktoken/ranks/cl100k_base";
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.36.0",
+  version: "0.38.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -184,7 +184,7 @@ var package_default = {
     semver: "7.7.4",
     "smol-toml": "1.6.1",
     typanion: "3.14.0",
-    ws: "8.20.0"
+    ws: "8.21.0"
   },
   devDependencies: {
     "@eslint/js": "10.0.1",
@@ -197,7 +197,7 @@ var package_default = {
     eslint: "10.2.1",
     "eslint-plugin-import-x": "4.16.2",
     tsup: "8.5.1",
-    tsx: "4.21.0",
+    tsx: "4.22.3",
     typescript: "5.9.3",
     "typescript-eslint": "8.59.1"
   },
@@ -700,7 +700,7 @@ import { join as join6 } from "path";
 
 // core/config/helper.ts
 import { homedir as osHomedir } from "os";
-import { isAbsolute as isAbsolute2, join as join5, resolve as resolve6 } from "path";
+import { isAbsolute as isAbsolute2, join as join5, resolve as resolve6, sep } from "path";
 
 // kernel/config/loader.ts
 import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
@@ -1396,6 +1396,20 @@ function dedupeLinks(links) {
       if (link.confidence > existing.confidence) {
         existing.confidence = link.confidence;
       }
+      if (link.occurrences && link.occurrences.length > 0) {
+        const existingOccurrences = existing.occurrences ?? [];
+        const occKey = (o) => `${o.extractor}\0${o.originalTrigger}\0${o.location?.line ?? -1}`;
+        const occSeen = new Set(existingOccurrences.map(occKey));
+        const merged = [...existingOccurrences];
+        for (const occ of link.occurrences) {
+          const k = occKey(occ);
+          if (!occSeen.has(k)) {
+            occSeen.add(k);
+            merged.push(occ);
+          }
+        }
+        existing.occurrences = merged;
+      }
       continue;
     }
     out.set(key, link);
@@ -1419,12 +1433,23 @@ function recomputeLinkCounts(nodes, links) {
 function recomputeExternalRefsCount(nodes, externalLinks, cachedPaths) {
   const byPath2 = /* @__PURE__ */ new Map();
   for (const node of nodes) {
-    if (!cachedPaths.has(node.path)) node.externalRefsCount = 0;
+    if (!cachedPaths.has(node.path)) {
+      node.externalRefsCount = 0;
+      delete node.externalRefs;
+    }
     byPath2.set(node.path, node);
   }
   for (const link of externalLinks) {
     const source = byPath2.get(link.source);
-    if (source && !cachedPaths.has(source.path)) source.externalRefsCount += 1;
+    if (!source || cachedPaths.has(source.path)) continue;
+    source.externalRefsCount += 1;
+    const refs = source.externalRefs ?? [];
+    refs.push({
+      url: link.target,
+      ...link.location?.line !== void 0 ? { line: link.location.line } : {},
+      ...link.trigger?.originalTrigger ? { originalTrigger: link.trigger.originalTrigger } : {}
+    });
+    source.externalRefs = refs;
   }
 }
 var EXTERNAL_URL_SCHEME_RE = /^[a-z][a-z0-9+\-.]+:/i;
@@ -1435,7 +1460,7 @@ function isExternalUrlLink(link) {
 }
 
 // kernel/orchestrator/analyzers.ts
-async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sidecarRoots, annotationContributions, viewContributions, orphanJobFiles, referenceablePaths, cwd, registeredActionIds, emitter, hookDispatcher, reservedNodePaths) {
+async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sidecarRoots, annotationContributions, viewContributions, orphanJobFiles, referenceablePaths, cwd, registeredActionIds, emitter, hookDispatcher, reservedNodePaths, signals) {
   const issues = [];
   const contributions = [];
   const validators = loadSchemaValidators();
@@ -1500,6 +1525,7 @@ async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sid
       ...referenceablePaths ? { referenceablePaths } : {},
       ...cwd ? { cwd } : {},
       ...reservedNodePaths ? { reservedNodePaths } : {},
+      ...signals && signals.length > 0 ? { signals } : {},
       emitContribution
     });
     for (const issue of emitted) {
@@ -1780,6 +1806,7 @@ function liftResolvedLinkConfidence(links, nodes, ctx) {
     const resolution = resolve7(link, indexes, ctx);
     if (resolution === "none") continue;
     link.confidence = ctx.reservedNodePaths.has(resolution) ? RESERVED_TARGET_CONFIDENCE : 1;
+    link.resolvedTarget = resolution;
   }
 }
 function buildIndexes(nodes, ctx) {
@@ -1860,6 +1887,190 @@ function applyPostWalkTransforms(links, nodes, ctx, transforms = POST_WALK_TRANS
   return current;
 }
 
+// kernel/orchestrator/resolver.ts
+function resolveSignals(opts) {
+  const kindPriority = opts.activeProvider?.resolverRules?.kindPriority ?? [];
+  const extractorRank = buildExtractorRank(opts.extractorOrder);
+  for (const signal of opts.signals) {
+    signal.resolution = pickIntraWinner(signal, kindPriority, extractorRank);
+  }
+  const bySource = /* @__PURE__ */ new Map();
+  for (const signal of opts.signals) {
+    if (signal.resolution?.outcome !== "materialised") continue;
+    const bucket = bySource.get(signal.source) ?? [];
+    bucket.push(signal);
+    bySource.set(signal.source, bucket);
+  }
+  for (const [, signals] of bySource) {
+    const clusters = buildOverlapClusters(signals);
+    for (const cluster of clusters) {
+      if (cluster.length < 2) continue;
+      if (everyCandidateIsExternalUrl(cluster)) continue;
+      resolveCluster(cluster, kindPriority, extractorRank);
+    }
+  }
+  const links = [];
+  for (const signal of opts.signals) {
+    if (signal.resolution?.outcome !== "materialised") continue;
+    const winnerIndex = signal.resolution.winnerIndex ?? 0;
+    const winner = signal.candidates[winnerIndex];
+    if (!winner) continue;
+    links.push(materialise(signal, winner));
+  }
+  return { links, resolvedSignals: [...opts.signals] };
+}
+function buildExtractorRank(order) {
+  const rank = /* @__PURE__ */ new Map();
+  for (let i = 0; i < order.length; i += 1) rank.set(order[i], i);
+  return rank;
+}
+function pickIntraWinner(signal, kindPriority, extractorRank) {
+  let bestIndex = 0;
+  for (let i = 1; i < signal.candidates.length; i += 1) {
+    if (compareCandidates(signal.candidates[i], signal.candidates[bestIndex], kindPriority, extractorRank) < 0) {
+      bestIndex = i;
+    }
+  }
+  return { outcome: "materialised", winnerIndex: bestIndex };
+}
+function compareCandidates(a, b, kindPriority, extractorRank) {
+  const kindCmp = compareKindPriority(a.kind, b.kind, kindPriority);
+  if (kindCmp !== 0) return kindCmp;
+  if (a.confidence !== b.confidence) return b.confidence - a.confidence;
+  const aRank = extractorRank.get(a.extractorId) ?? Number.MAX_SAFE_INTEGER;
+  const bRank = extractorRank.get(b.extractorId) ?? Number.MAX_SAFE_INTEGER;
+  return aRank - bRank;
+}
+function compareKindPriority(aKind, bKind, kindPriority) {
+  if (kindPriority.length === 0) return 0;
+  const aIdx = kindPriority.indexOf(aKind);
+  const bIdx = kindPriority.indexOf(bKind);
+  const aEff = aIdx === -1 ? Number.MAX_SAFE_INTEGER : aIdx;
+  const bEff = bIdx === -1 ? Number.MAX_SAFE_INTEGER : bIdx;
+  return aEff - bEff;
+}
+function buildOverlapClusters(signals) {
+  const bodySignals = signals.filter((s) => s.scope === "body" && s.range);
+  const others = signals.filter((s) => !(s.scope === "body" && s.range));
+  const parent = bodySignals.map((_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+  for (let i = 0; i < bodySignals.length; i += 1) {
+    for (let j = i + 1; j < bodySignals.length; j += 1) {
+      if (rangesOverlap(bodySignals[i].range, bodySignals[j].range)) {
+        union(i, j);
+      }
+    }
+  }
+  const byRoot = /* @__PURE__ */ new Map();
+  for (let i = 0; i < bodySignals.length; i += 1) {
+    const root = find(i);
+    const bucket = byRoot.get(root) ?? [];
+    bucket.push(bodySignals[i]);
+    byRoot.set(root, bucket);
+  }
+  return [...byRoot.values(), ...others.map((s) => [s])];
+}
+function rangesOverlap(a, b) {
+  return a.end > b.start && b.end > a.start;
+}
+function everyCandidateIsExternalUrl(cluster) {
+  for (const signal of cluster) {
+    const winnerIndex = signal.resolution?.winnerIndex ?? 0;
+    const winner = signal.candidates[winnerIndex];
+    if (!winner) return false;
+    if (!isExternalUrl(winner.target)) return false;
+  }
+  return true;
+}
+function isExternalUrl(target) {
+  return target.startsWith("http://") || target.startsWith("https://");
+}
+function resolveCluster(cluster, kindPriority, extractorRank) {
+  let winnerIdx = 0;
+  for (let i = 1; i < cluster.length; i += 1) {
+    const result = compareClusterMembers(cluster[i], cluster[winnerIdx], kindPriority, extractorRank);
+    if (result.winner === "challenger") winnerIdx = i;
+  }
+  const winner = cluster[winnerIdx];
+  const winnerCandidate = winner.candidates[winner.resolution?.winnerIndex ?? 0];
+  for (let i = 0; i < cluster.length; i += 1) {
+    if (i === winnerIdx) continue;
+    const loser = cluster[i];
+    loser.resolution = {
+      outcome: "rejected",
+      rejectedBy: {
+        source: winner.source,
+        range: winner.range,
+        extractorId: winnerCandidate.extractorId,
+        reason: whyLost(loser, winner, kindPriority, extractorRank)
+      }
+    };
+  }
+}
+function compareClusterMembers(challenger, champion, kindPriority, extractorRank) {
+  const cWinner = challenger.candidates[challenger.resolution?.winnerIndex ?? 0];
+  const xWinner = champion.candidates[champion.resolution?.winnerIndex ?? 0];
+  const kindCmp = compareKindPriority(cWinner.kind, xWinner.kind, kindPriority);
+  if (kindCmp < 0) return { winner: "challenger", reason: "kind-priority" };
+  if (kindCmp > 0) return { winner: "champion", reason: "kind-priority" };
+  if (cWinner.confidence !== xWinner.confidence) {
+    return cWinner.confidence > xWinner.confidence ? { winner: "challenger", reason: "higher-confidence" } : { winner: "champion", reason: "higher-confidence" };
+  }
+  const cLen = rangeLength(challenger.range);
+  const xLen = rangeLength(champion.range);
+  if (cLen !== xLen) {
+    return cLen > xLen ? { winner: "challenger", reason: "longer-range" } : { winner: "champion", reason: "longer-range" };
+  }
+  const cRank = extractorRank.get(cWinner.extractorId) ?? Number.MAX_SAFE_INTEGER;
+  const xRank = extractorRank.get(xWinner.extractorId) ?? Number.MAX_SAFE_INTEGER;
+  if (cRank !== xRank) {
+    return cRank < xRank ? { winner: "challenger", reason: "earlier-declaration" } : { winner: "champion", reason: "earlier-declaration" };
+  }
+  return { winner: "tie", reason: "earlier-declaration" };
+}
+function rangeLength(range) {
+  if (!range) return 0;
+  return range.end - range.start;
+}
+function whyLost(loser, winner, kindPriority, extractorRank) {
+  return compareClusterMembers(winner, loser, kindPriority, extractorRank).reason;
+}
+function materialise(signal, winner) {
+  const link = {
+    source: signal.source,
+    target: winner.target,
+    kind: winner.kind,
+    confidence: winner.confidence,
+    sources: [winner.extractorId],
+    raw: signal.raw
+  };
+  if (winner.trigger) link.trigger = winner.trigger;
+  if (signal.range) {
+    link.location = { line: signal.range.line ?? 1, offset: signal.range.start };
+  }
+  const occurrenceTrigger = winner.trigger?.originalTrigger ?? signal.raw;
+  const occurrenceLocation = signal.range ? { line: signal.range.line ?? 1 } : null;
+  link.occurrences = [
+    {
+      extractor: winner.extractorId,
+      originalTrigger: occurrenceTrigger,
+      location: occurrenceLocation
+    }
+  ];
+  return link;
+}
+
 // kernel/orchestrator/renames.ts
 function findHighConfidenceRenames(opts) {
   const ops = [];
@@ -1994,7 +2205,7 @@ function detectRenamesAndOrphans(prior, current, issues, silenced) {
 
 // kernel/scan/walk-content.ts
 import { readFile, readdir, lstat } from "fs/promises";
-import { join as join7, relative as relative2, sep } from "path";
+import { join as join7, relative as relative2, sep as sep2 } from "path";
 
 // kernel/scan/ignore.ts
 import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
@@ -2151,7 +2362,7 @@ async function* walkContent(roots, options) {
   const extensions = options.extensions;
   for (const root of roots) {
     for await (const file of walkRoot(root, root, filter, extensions)) {
-      const relPath = relative2(root, file).split(sep).join("/");
+      const relPath = relative2(root, file).split(sep2).join("/");
       let raw;
       try {
         raw = await readFile(file, "utf8");
@@ -2183,7 +2394,7 @@ async function* walkRoot(root, current, filter, extensions) {
   for (const entry of entries) {
     const name = entry.name;
     const full = join7(current, name);
-    const rel = relative2(root, full).split(sep).join("/");
+    const rel = relative2(root, full).split(sep2).join("/");
     if (filter.ignores(rel)) continue;
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
@@ -2339,7 +2550,7 @@ function computeDriftStatus(args) {
 
 // kernel/sidecar/discover-orphans.ts
 import { existsSync as existsSync8, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { join as join8, relative as relative3, sep as sep2 } from "path";
+import { join as join8, relative as relative3, sep as sep3 } from "path";
 function discoverOrphanSidecars(roots, shouldSkip) {
   const out = [];
   for (const root of roots) {
@@ -2356,7 +2567,7 @@ function walk(root, current, shouldSkip, out) {
   }
   for (const entry of entries) {
     const full = join8(current, entry.name);
-    const rel = relative3(root, full).split(sep2).join("/");
+    const rel = relative3(root, full).split(sep3).join("/");
     if (shouldSkip(rel)) continue;
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
@@ -2632,7 +2843,12 @@ async function walkAndExtract(opts) {
   const walkOptions = opts.ignoreFilter ? { ignoreFilter: opts.ignoreFilter } : {};
   let filesWalked = 0;
   let index = 0;
-  for (const provider of opts.providers) {
+  const activeProviders = opts.providers.filter((provider) => {
+    if (!provider.gatedByActiveLens) return true;
+    if (opts.activeProvider === null) return true;
+    return provider.id === opts.activeProvider;
+  });
+  for (const provider of activeProviders) {
     for await (const raw of resolveProviderWalk(provider)(opts.roots, walkOptions)) {
       filesWalked += 1;
       if (claimedPaths.has(raw.path)) continue;
@@ -2653,7 +2869,8 @@ async function walkAndExtract(opts) {
     contributions: accum.contributionsBuffer,
     freshlyRunTuples: accum.freshlyRunTuples,
     orphanSidecars,
-    sidecarRoots: accum.sidecarRoots
+    sidecarRoots: accum.sidecarRoots,
+    signals: accum.signals
   };
 }
 function createWalkAccumulators() {
@@ -2661,6 +2878,7 @@ function createWalkAccumulators() {
     nodes: [],
     internalLinks: [],
     externalLinks: [],
+    signals: [],
     cachedPaths: /* @__PURE__ */ new Set(),
     frontmatterIssues: [],
     enrichmentBuffer: /* @__PURE__ */ new Map(),
@@ -2806,6 +3024,7 @@ function recordFreshlyRunTuples(extractors, nodePath, accum) {
 function mergeExtractResult(extractResult, accum) {
   for (const link of extractResult.internalLinks) accum.internalLinks.push(link);
   for (const link of extractResult.externalLinks) accum.externalLinks.push(link);
+  for (const signal of extractResult.signals) accum.signals.push(signal);
   for (const enr of extractResult.enrichments) {
     accum.enrichmentBuffer.set(`${enr.nodePath}\0${enr.extractorId}`, enr);
   }
@@ -2908,6 +3127,7 @@ async function runScanInternal(_kernel, options) {
   const scanStartedEvent = makeEvent("scan.started", { roots: options.roots });
   emitter.emit(scanStartedEvent);
   await hookDispatcher.dispatch("scan.started", scanStartedEvent);
+  const activeProviderId = resolveActiveProviderOption(options.activeProvider, options.roots);
   const walked = await walkAndExtract({
     providers: exts.providers,
     extractors: exts.extractors,
@@ -2922,9 +3142,20 @@ async function runScanInternal(_kernel, options) {
     priorExtractorRuns: setup.priorExtractorRuns,
     providerFrontmatter: setup.providerFrontmatter,
     pluginStores: options.pluginStores,
-    activeProvider: resolveActiveProviderOption(options.activeProvider, options.roots)
+    activeProvider: activeProviderId
+  });
+  const activeProvider = activeProviderId ? exts.providers.find((p) => p.id === activeProviderId) ?? null : null;
+  const resolved = resolveSignals({
+    signals: walked.signals,
+    activeProvider,
+    extractorOrder: exts.extractors.map((e) => e.id)
   });
-  const postWalkCtx = buildPostWalkTransformCtx(_kernel, walked.nodes);
+  for (const link of resolved.links) {
+    if (isExternalUrlLink(link)) walked.externalLinks.push(link);
+    else walked.internalLinks.push(link);
+  }
+  walked.signals = resolved.resolvedSignals;
+  const postWalkCtx = buildPostWalkTransformCtx(exts.providers, walked.nodes);
   walked.internalLinks = applyPostWalkTransforms(walked.internalLinks, walked.nodes, postWalkCtx);
   recomputeLinkCounts(walked.nodes, walked.internalLinks);
   recomputeExternalRefsCount(walked.nodes, walked.externalLinks, walked.cachedPaths);
@@ -2946,7 +3177,8 @@ async function runScanInternal(_kernel, options) {
     registeredActionIds,
     emitter,
     hookDispatcher,
-    postWalkCtx.reservedNodePaths
+    postWalkCtx.reservedNodePaths,
+    walked.signals
   );
   mergeAnalyzerEmissions(walked, analyzerResult, exts.analyzers);
   const issues = analyzerResult.issues;
@@ -2959,8 +3191,8 @@ async function runScanInternal(_kernel, options) {
   await hookDispatcher.dispatch("scan.completed", scanCompletedEvent);
   return buildScanReturn(walked, issues, renameOps, stats, options, setup);
 }
-function buildPostWalkTransformCtx(kernel, nodes) {
-  const { kindRegistry, providerResolution, reservedNamesByProviderKind } = buildProviderIndexes(kernel);
+function buildPostWalkTransformCtx(providers, nodes) {
+  const { kindRegistry, providerResolution, reservedNamesByProviderKind } = buildProviderIndexes(providers);
   const reservedNodePaths = buildReservedNodePaths(
     nodes,
     kindRegistry,
@@ -2968,11 +3200,10 @@ function buildPostWalkTransformCtx(kernel, nodes) {
   );
   return { kindRegistry, providerResolution, reservedNodePaths };
 }
-function buildProviderIndexes(kernel) {
+function buildProviderIndexes(providers) {
   const kindRegistry = /* @__PURE__ */ new Map();
   const providerResolution = /* @__PURE__ */ new Map();
   const reservedNamesByProviderKind = /* @__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)) {
@@ -3109,7 +3340,7 @@ function resolveActiveProviderOption(optionValue, roots) {
 }
 
 // kernel/scan/watcher.ts
-import { resolve as resolve12, relative as relative4, sep as sep3 } from "path";
+import { resolve as resolve12, relative as relative4, sep as sep4 } from "path";
 import chokidar from "chokidar";
 function createChokidarWatcher(opts) {
   const absRoots = opts.roots.map((r) => resolve12(opts.cwd, r));
@@ -3207,8 +3438,8 @@ function relativePathFromRoots2(absolute, absRoots) {
   for (const root of absRoots) {
     const rel = relative4(root, absolute);
     if (rel === "" || rel === ".") return "";
-    if (!rel.startsWith("..") && !rel.startsWith(`..${sep3}`)) {
-      return rel.split(sep3).join("/");
+    if (!rel.startsWith("..") && !rel.startsWith(`..${sep4}`)) {
+      return rel.split(sep4).join("/");
     }
   }
   return null;