@skill-map/cli 0.54.0 → 0.56.0

package/dist/index.js

@@ -1,6 +1,6 @@
 // kernel/i18n/registry.texts.ts
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="f476faaa-267b-52a2-84d7-7b8859286768")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="2dc805c3-48a5-5cde-8fdd-5ba75f99be02")}catch(e){}}();
 var REGISTRY_TEXTS = {
   duplicateExtension: "Extension already registered: {{kind}}:{{qualifiedId}}",
   unknownKind: "Unknown extension kind: {{kind}}",
@@ -102,7 +102,7 @@ import { Tiktoken as Tiktoken2 } from "js-tiktoken/lite";
 // package.json
 var package_default = {
   name: "@skill-map/cli",
-  version: "0.54.0",
+  version: "0.56.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -745,6 +745,10 @@ function matchesFilter(hook, event) {
 function buildHookContext(_hook, trigger, event) {
   const data = event.data ?? {};
   const ctx = {
+    // `settings` is always populated (possibly empty) so hooks can read
+    // `ctx.settings.<id>` without a presence check. The composer
+    // populated `resolvedSettings` on each composed hook.
+    settings: _hook.resolvedSettings ?? {},
     event: {
       type: trigger,
       timestamp: event.timestamp,
@@ -1190,8 +1194,83 @@ function isExternalUrlLink(link) {
   return EXTERNAL_URL_SCHEME_RE.test(link.target);
 }
 
+// kernel/orchestrator/action-projections.ts
+function runActionProjections(actions, nodes, links, emitter) {
+  const contributions = [];
+  const contributionErrors = [];
+  const validators = loadSchemaValidators();
+  for (const action of actions) {
+    if (typeof action.project !== "function") continue;
+    const qualifiedId = qualifiedExtensionId(action.pluginId, action.id);
+    const declaredContributions = readDeclaredContributionRefs(action);
+    const emitContribution = (nodePath, ref, payload) => {
+      const declared = typeof ref === "object" && ref !== null ? declaredContributions.get(ref) : void 0;
+      if (!declared) {
+        const message = tx(ORCHESTRATOR_TEXTS.extensionErrorContributionUndeclaredRef, {
+          extractorId: qualifiedId,
+          nodePath
+        });
+        emitExtensionError(emitter, qualifiedId, nodePath, {
+          phase: "emitContribution",
+          reason: "undeclared-contribution-ref",
+          message
+        });
+        contributionErrors.push({
+          pluginId: action.pluginId,
+          extensionId: action.id,
+          nodePath,
+          reason: "undeclared-contribution-ref",
+          message,
+          emittedAt: Date.now()
+        });
+        return;
+      }
+      const result = validators.validateContributionPayload(declared.slot, payload);
+      if (!result.ok) {
+        const message = tx(ORCHESTRATOR_TEXTS.extensionErrorContributionPayloadInvalid, {
+          extractorId: qualifiedId,
+          contributionId: declared.id,
+          nodePath,
+          slot: declared.slot,
+          errors: result.errors
+        });
+        emitExtensionError(emitter, qualifiedId, nodePath, {
+          phase: "emitContribution",
+          contributionId: declared.id,
+          slot: declared.slot,
+          reason: result.errors,
+          message
+        });
+        contributionErrors.push({
+          pluginId: action.pluginId,
+          extensionId: action.id,
+          nodePath,
+          reason: result.errors,
+          message,
+          contributionId: declared.id,
+          slot: declared.slot,
+          emittedAt: Date.now()
+        });
+        return;
+      }
+      contributions.push({
+        pluginId: action.pluginId,
+        extensionId: action.id,
+        nodePath,
+        contributionId: declared.id,
+        slot: declared.slot,
+        payload,
+        emittedAt: Date.now()
+      });
+    };
+    const ctx = { nodes, links, emitContribution };
+    action.project(ctx);
+  }
+  return { contributions, contributionErrors };
+}
+
 // kernel/orchestrator/analyzers.ts
-async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sidecarRoots, annotationContributions, viewContributions, orphanJobFiles, referenceablePaths, cwd, registeredActionIds, emitter, hookDispatcher, reservedNodePaths, signals, seedIssues = []) {
+async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sidecarRoots, annotationContributions, viewContributions, orphanJobFiles, referenceablePaths, cwd, registeredActionIds, emitter, hookDispatcher, reservedNodePaths, brokenLinks, signals, seedIssues = []) {
   const issues = [...seedIssues];
   const contributions = [];
   const contributionErrors = [];
@@ -1268,6 +1347,10 @@ async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sid
     const emitted = await analyzer.evaluate({
       nodes,
       links: internalLinks,
+      // `settings` is always populated (possibly empty) so analyzers can
+      // read `ctx.settings.<id>` without a presence check. The composer
+      // populated `resolvedSettings` on each composed analyzer.
+      settings: analyzer.resolvedSettings ?? {},
       orphanSidecars: analyzerOrphans,
       sidecarRoots,
       annotationContributions,
@@ -1281,6 +1364,7 @@ async function runAnalyzers(analyzers, nodes, internalLinks, orphanSidecars, sid
       ...referenceablePaths ? { referenceablePaths } : {},
       ...cwd ? { cwd } : {},
       ...reservedNodePaths ? { reservedNodePaths } : {},
+      ...brokenLinks ? { brokenLinks } : {},
       ...signals && signals.length > 0 ? { signals } : {},
       emitContribution
     });
@@ -1560,16 +1644,34 @@ function readDirname(node) {
 
 // kernel/orchestrator/lift-resolved-link-confidence.ts
 var RESERVED_TARGET_CONFIDENCE = 0.1;
+var BROKEN_TARGET_CONFIDENCE = 0.5;
 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.confidence >= 1) continue;
-    const resolution = resolve5(link, indexes, ctx);
-    if (resolution === "none") continue;
-    link.confidence = ctx.reservedNodePaths.has(resolution) ? RESERVED_TARGET_CONFIDENCE : 1;
-    link.resolvedTarget = resolution;
+    if (link.confidence < 1) applyResolution(link, indexes, ctx);
+  }
+}
+function collectBrokenLinks(links, nodes, ctx) {
+  const broken = /* @__PURE__ */ new Set();
+  if (links.length === 0) return broken;
+  const indexes = buildIndexes(nodes, ctx);
+  for (const link of links) {
+    if (isGenuinelyBroken(link, indexes)) broken.add(link);
   }
+  return broken;
+}
+function applyResolution(link, indexes, ctx) {
+  const resolution = resolve5(link, indexes, ctx);
+  if (resolution === "none") {
+    if (isGenuinelyBroken(link, indexes)) {
+      link.confidence = Math.min(link.confidence, BROKEN_TARGET_CONFIDENCE);
+    }
+    return;
+  }
+  link.resolvedTarget = resolution;
+  if (indexes.nodeByPath.get(resolution)?.virtual) return;
+  link.confidence = ctx.reservedNodePaths.has(resolution) ? RESERVED_TARGET_CONFIDENCE : 1;
 }
 function buildIndexes(nodes, ctx) {
   const byPath2 = /* @__PURE__ */ new Set();
@@ -1586,6 +1688,12 @@ function resolve5(link, indexes, ctx) {
   if (indexes.byPath.has(link.target)) return link.target;
   return resolveByName(link, indexes, ctx);
 }
+function isGenuinelyBroken(link, indexes) {
+  if (indexes.byPath.has(link.target)) return false;
+  const stripped = stripTriggerSigil(link.trigger?.normalizedTrigger);
+  if (stripped !== null && indexes.byName.has(stripped)) return false;
+  return true;
+}
 function resolveByName(link, indexes, ctx) {
   const stripped = stripTriggerSigil(link.trigger?.normalizedTrigger);
   if (stripped === null) return "none";
@@ -2146,11 +2254,11 @@ async function* walkContent(roots, options) {
   const extensions = options.extensions;
   const sizeLimit = buildSizeLimit(options);
   for (const root of roots) {
-    for await (const file of walkRoot(root, root, filter, extensions, sizeLimit)) {
-      const relPath = relative2(root, file).split(sep).join("/");
+    for await (const entry of walkRoot(root, root, filter, extensions, sizeLimit)) {
+      const relPath = relative2(root, entry.full).split(sep).join("/");
       let raw;
       try {
-        raw = await readFile(file, "utf8");
+        raw = await readFile(entry.full, "utf8");
       } catch {
         continue;
       }
@@ -2160,6 +2268,9 @@ async function* walkContent(roots, options) {
         body: parsed.body,
         frontmatterRaw: parsed.frontmatterRaw,
         frontmatter: parsed.frontmatter,
+        // File mtime from the TOCTOU `lstat` (zero extra syscalls).
+        // Threaded onto the persisted `Node` as `modifiedAtMs`.
+        modifiedAtMs: entry.modifiedAtMs,
         // Audit L1: forward parser diagnostics (e.g. malformed YAML)
         // through the IRawNode surface so the orchestrator can
         // convert them into warn-level kernel `Issue` rows. Omitted
@@ -2200,7 +2311,7 @@ async function* walkRoot(root, current, filter, extensions, sizeLimit) {
           sizeLimit.onOversizedFile?.({ path: rel, bytes: s.size });
           continue;
         }
-        yield full;
+        yield { full, modifiedAtMs: Math.round(s.mtimeMs) };
       } catch {
       }
     }
@@ -2491,6 +2602,7 @@ function buildNode(args) {
     externalRefsCount: 0,
     frontmatter: args.frontmatter
   };
+  if (args.modifiedAtMs !== void 0) node.modifiedAtMs = args.modifiedAtMs;
   if (args.encoder) {
     node.tokens = countTokens(args.encoder, args.frontmatterRaw, args.body);
   }
@@ -2606,7 +2718,10 @@ function buildFreshNodeAndValidateFrontmatter(opts) {
     frontmatter: opts.raw.frontmatter,
     bodyHash: opts.bodyHash,
     frontmatterHash: opts.frontmatterHash,
-    encoder: opts.encoder
+    encoder: opts.encoder,
+    // Thread the walker's mtime through; `buildNode` only attaches it
+    // when present, so virtual / walk()-without-stat sources stay absent.
+    modifiedAtMs: opts.raw.modifiedAtMs
   });
   const frontmatterIssues = [];
   if (opts.raw.parseIssues && opts.raw.parseIssues.length > 0) {
@@ -3027,6 +3142,7 @@ async function runScanInternal(_kernel, options) {
   walked.signals = resolved.resolvedSignals;
   const postWalkCtx = buildPostWalkTransformCtx(exts.providers, walked.nodes, activeProviderId);
   walked.internalLinks = applyPostWalkTransforms(walked.internalLinks, walked.nodes, postWalkCtx);
+  const brokenLinks = collectBrokenLinks(walked.internalLinks, walked.nodes, postWalkCtx);
   recomputeLinkCounts(walked.nodes, walked.internalLinks);
   recomputeExternalRefsCount(walked.nodes, walked.externalLinks, walked.cachedPaths);
   await dispatchExtractorCompleted(exts.extractors, emitter, hookDispatcher);
@@ -3048,6 +3164,7 @@ async function runScanInternal(_kernel, options) {
     emitter,
     hookDispatcher,
     postWalkCtx.reservedNodePaths,
+    brokenLinks,
     walked.signals,
     // Seed the accumulator with orchestrator-emitted frontmatter
     // issues so the aggregate phase (`core/issue-counter`) counts
@@ -3056,6 +3173,13 @@ async function runScanInternal(_kernel, options) {
     walked.frontmatterIssues
   );
   mergeAnalyzerEmissions(walked, analyzerResult, exts.analyzers);
+  const projectionResult = runActionProjections(
+    exts.actions ?? [],
+    walked.nodes,
+    walked.internalLinks,
+    emitter
+  );
+  mergeActionProjections(walked, projectionResult, exts.actions);
   const issues = analyzerResult.issues;
   const silenced = options.ignoreFilter ? (path) => options.ignoreFilter.ignores(path) : void 0;
   const renameOps = prior ? detectRenamesAndOrphans(prior, walked.nodes, issues, silenced) : [];
@@ -3164,6 +3288,16 @@ function mergeAnalyzerEmissions(walked, analyzerResult, analyzers) {
     }
   }
 }
+function mergeActionProjections(walked, projectionResult, actions) {
+  for (const c of projectionResult.contributions) walked.contributions.push(c);
+  for (const e of projectionResult.contributionErrors) walked.contributionErrors.push(e);
+  for (const action of actions ?? []) {
+    if (action.ui === void 0 || typeof action.project !== "function") continue;
+    for (const node of walked.nodes) {
+      walked.freshlyRunTuples.add(`${action.pluginId}\0${action.id}\0${node.path}`);
+    }
+  }
+}
 function buildScanStats(walked, issues, start) {
   return {
     // `filesSkipped` is "files walked but not classified by any
@@ -3632,4 +3766,4 @@ export {
   runScanWithRenames
 };
 //# sourceMappingURL=index.js.map
-//# debugId=f476faaa-267b-52a2-84d7-7b8859286768
+//# debugId=2dc805c3-48a5-5cde-8fdd-5ba75f99be02