@skill-map/cli 0.40.1 → 0.42.0

package/dist/kernel/index.d.ts

@@ -1021,6 +1021,20 @@ interface ScanResult {
     providers: string[];
     /** Implementation metadata. Populated by `runScan` for self-describing output. */
     scannedBy?: ScanScannedBy;
+    /**
+     * Effective recommended cap on the number of files the walker accepted
+     * during this scan (`scan.maxNodes` from settings, default 256). The UI
+     * raises the "oversized graph" banner when
+     * `stats.filesWalked >= recommendedNodeLimit`. Absent on synthetic fixtures
+     * that bypass the walker.
+     */
+    recommendedNodeLimit?: number;
+    /**
+     * Override applied via `--max-nodes <N>` on the verb that ran the scan, or
+     * `null` when no override was passed (the value above came from the
+     * setting). Bidirectional: can raise OR lower the recommended limit.
+     */
+    overrideMaxNodes?: number | null;
     nodes: Node[];
     links: Link[];
     issues: Issue[];
@@ -1961,9 +1975,80 @@ type TProviderKindIcon = {
     kind: 'svg';
     path: string;
 };
+/**
+ * Presentation contract for the Provider's OWN identity, distinct from
+ * its per-kind visuals (`IProviderKindUi`). Drives the active-lens
+ * dropdown label, the topbar lens chip, and the per-node provider chip
+ * on cards. Reaches the UI via the `providerRegistry` field embedded in
+ * REST envelopes (sibling of `kindRegistry`). Unlike kind colors
+ * (normalised across Providers so every `agent` paints the same),
+ * Provider colors are deliberately distinct so the chip tells the user
+ * at a glance which platform a node came from. Mirrors
+ * `spec/schemas/extensions/provider.schema.json#/properties/ui`.
+ */
+interface IProviderUi {
+    /**
+     * Human-readable Provider name shown in the lens dropdown, the topbar
+     * lens chip, and the per-node provider chip (e.g. `'Claude'`,
+     * `'OpenAI Codex'`, `'Antigravity'`, `'Open Skills'`, `'Markdown'`).
+     */
+    label: string;
+    /** Base hex color (`#RRGGBB`) for the light-theme provider chip. */
+    color: string;
+    /** Optional dark-theme variant of `color`. Falls back to `color`. */
+    colorDark?: string;
+    /** Optional decorative emoji fallback when `icon` is absent. */
+    emoji?: string;
+    /** Optional discriminated icon descriptor (preferred over `emoji`). */
+    icon?: TProviderKindIcon;
+    /**
+     * When `true`, the UI does NOT paint this Provider's chip on node
+     * cards. Reserved for the universal `markdown` fallback (carried by
+     * the majority of nodes, so badging every generic `.md` would be
+     * noise). The Provider still appears in the lens dropdown and the
+     * topbar lens chip; only the per-card badge is suppressed.
+     */
+    hideChip?: boolean;
+}
+/**
+ * Auto-detection markers for the active-provider lens. The lens resolver
+ * checks each marker path (relative to the scope root) and, when present,
+ * suggests this Provider as a candidate lens. Replaces the former
+ * hardcoded detection table: the detectable set now derives from the
+ * registered Providers. Mirrors
+ * `spec/schemas/extensions/provider.schema.json#/properties/detect`.
+ */
+interface IProviderDetect {
+    /**
+     * Paths relative to the scope root whose existence signals this
+     * Provider's presence (e.g. `['.claude']`, `['.codex', 'AGENTS.md']`).
+     * A directory or a file both count; existence is the only test.
+     */
+    markers: string[];
+}
 interface IProvider extends IExtensionBase {
     /** Discriminant injected by the loader from the folder structure. */
     kind: 'provider';
+    /**
+     * Presentation metadata for the Provider's own identity (lens dropdown
+     * label, topbar lens chip, per-node provider chip). Required so the UI
+     * never hardcodes a closed provider list: it reads every registered
+     * Provider's identity from the `providerRegistry` envelope field.
+     * Distinct from `kinds[*].ui` (per-kind node visuals).
+     *
+     * Named `presentation`, NOT `ui`: the base `IExtensionBase.ui` field is
+     * the view-contributions map (`Record<string, IViewContribution>`,
+     * declared only by `extractor` / `analyzer` kinds). Providers leave that
+     * inherited field undefined and carry their identity here instead.
+     */
+    presentation: IProviderUi;
+    /**
+     * Optional auto-detection markers for the active-provider lens. When
+     * present, the lens resolver auto-suggests this Provider if any marker
+     * path exists under the scope root. Absent means the Provider is never
+     * auto-suggested (it can still be selected manually).
+     */
+    detect?: IProviderDetect;
     /**
      * Catalog of node kinds this Provider emits. Populated by the loader
      * from the `<plugin>/kinds/<kindName>/` directory layout: each subfolder
@@ -3330,6 +3415,22 @@ interface RunScanOptions {
      *     pass `string | null` explicitly, never `undefined`.
      */
     activeProvider?: string | null;
+    /**
+     * Recommended cap on the number of nodes the walker classifies
+     * (mirror of `scan.maxNodes` in settings, default 256). Threaded
+     * through to `walkAndExtract` so the cap can fire and so
+     * `ScanResult.recommendedNodeLimit` is populated. Absent → the
+     * orchestrator falls back to 256 (the design default), keeping
+     * out-of-band callers and synthetic fixtures safe.
+     */
+    recommendedNodeLimit?: number;
+    /**
+     * Per-invocation override of the recommended cap (when `--max-nodes
+     * <N>` was passed). `null` (or absent) means no override; the
+     * recommended limit applies. Bidirectional: any positive integer
+     * replaces the recommended limit for the duration of this scan.
+     */
+    overrideMaxNodes?: number | null;
 }
 /**
  * Same as `runScan` but also returns the rename heuristic's `RenameOp[]`

package/dist/kernel/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.40.1",
+  version: "0.42.0",
   description: "skill-map reference implementation \u2014 kernel + CLI + adapters.",
   license: "MIT",
   type: "module",
@@ -775,6 +775,7 @@ var defaults_default = {
     strict: false,
     followSymlinks: false,
     maxFileSizeBytes: 1048576,
+    maxNodes: 256,
     watch: {
       debounceMs: 300
     },
@@ -1049,21 +1050,8 @@ function loadConfigForScope(opts) {
 }
 
 // core/config/active-provider.ts
-var DETECTION_RULES = [
-  { providerId: "claude", marker: ".claude" },
-  // `gemini` retired 2026-05-22: Google replaced the Gemini CLI with the
-  // Antigravity CLI (released 2026-05-19; Gemini CLI sunsets 2026-06-18).
-  // Antigravity adopted the open-standard `.agents/` instead of a
-  // vendor-specific directory, so detection of a Google CLI project
-  // falls through to the universal `agent-skills` lens (`.agents/`
-  // already classifies via that neutral provider). The lens can still
-  // be set manually via `sm config set activeProvider antigravity`.
-  { providerId: "openai", marker: ".codex" },
-  { providerId: "openai", marker: "AGENTS.md" },
-  { providerId: "cursor", marker: ".cursor" }
-];
-function resolveActiveProvider(cwd) {
-  const detected = detectProvidersFromFilesystem(cwd);
+function resolveActiveProvider(cwd, providers = []) {
+  const detected = detectProvidersFromFilesystem(cwd, providers);
   const fromConfig = readConfigValue("activeProvider", { cwd });
   if (typeof fromConfig === "string" && fromConfig.length > 0) {
     return { resolved: fromConfig, source: "config", detected };
@@ -1073,14 +1061,16 @@ function resolveActiveProvider(cwd) {
   }
   return { resolved: null, source: "none", detected };
 }
-function detectProvidersFromFilesystem(cwd) {
+function detectProvidersFromFilesystem(cwd, providers) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  for (const rule of DETECTION_RULES) {
-    if (seen.has(rule.providerId)) continue;
-    if (!existsSync5(join6(cwd, rule.marker))) continue;
-    seen.add(rule.providerId);
-    out.push(rule.providerId);
+  for (const provider of providers) {
+    if (seen.has(provider.id)) continue;
+    const markers = provider.detect?.markers;
+    if (!markers || markers.length === 0) continue;
+    if (!markers.some((marker) => existsSync5(join6(cwd, marker)))) continue;
+    seen.add(provider.id);
+    out.push(provider.id);
   }
   return out;
 }
@@ -2855,17 +2845,26 @@ async function walkAndExtract(opts) {
   const walkOptions = opts.ignoreFilter ? { ignoreFilter: opts.ignoreFilter } : {};
   let filesWalked = 0;
   let index = 0;
+  const effectiveMaxNodes = opts.overrideMaxNodes ?? opts.recommendedNodeLimit;
+  let capReached = false;
   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) {
+  const advance = async (raw, provider) => {
+    const advanced = await processRawNode(raw, provider, wctx, accum, claimedPaths, index + 1);
+    if (advanced) index += 1;
+  };
+  outer: for (const provider of activeProviders) {
     for await (const raw of resolveProviderWalk(provider)(opts.roots, walkOptions)) {
       filesWalked += 1;
       if (claimedPaths.has(raw.path)) continue;
-      const advanced = await processRawNode(raw, provider, wctx, accum, claimedPaths, index + 1);
-      if (advanced) index += 1;
+      if (accum.nodes.length >= effectiveMaxNodes) {
+        capReached = true;
+        break outer;
+      }
+      await advance(raw, provider);
     }
   }
   const orphanSidecars = discoverOrphanSidecars(opts.roots);
@@ -2876,6 +2875,9 @@ async function walkAndExtract(opts) {
     cachedPaths: accum.cachedPaths,
     frontmatterIssues: accum.frontmatterIssues,
     filesWalked,
+    recommendedNodeLimit: opts.recommendedNodeLimit,
+    overrideMaxNodes: opts.overrideMaxNodes,
+    capReached,
     enrichments: [...accum.enrichmentBuffer.values()],
     extractorRuns: accum.extractorRuns,
     contributions: accum.contributionsBuffer,
@@ -3139,7 +3141,11 @@ 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 activeProviderId = resolveActiveProviderOption(
+    options.activeProvider,
+    options.roots,
+    exts.providers
+  );
   const walked = await walkAndExtract({
     providers: exts.providers,
     extractors: exts.extractors,
@@ -3154,7 +3160,9 @@ async function runScanInternal(_kernel, options) {
     priorExtractorRuns: setup.priorExtractorRuns,
     providerFrontmatter: setup.providerFrontmatter,
     pluginStores: options.pluginStores,
-    activeProvider: activeProviderId
+    activeProvider: activeProviderId,
+    recommendedNodeLimit: options.recommendedNodeLimit ?? 256,
+    overrideMaxNodes: options.overrideMaxNodes ?? null
   });
   const activeProvider = activeProviderId ? exts.providers.find((p) => p.id === activeProviderId) ?? null : null;
   const resolved = resolveSignals({
@@ -3322,6 +3330,8 @@ function buildScanReturn(walked, issues, renameOps, stats, options, setup) {
       roots: options.roots,
       providers: setup.exts.providers.map((a) => a.id),
       scannedBy: SCANNED_BY,
+      recommendedNodeLimit: walked.recommendedNodeLimit,
+      overrideMaxNodes: walked.overrideMaxNodes,
       nodes: walked.nodes,
       links: walked.internalLinks,
       issues,
@@ -3344,12 +3354,12 @@ function validateRoots(roots) {
     }
   }
 }
-function resolveActiveProviderOption(optionValue, roots) {
+function resolveActiveProviderOption(optionValue, roots, providers) {
   if (optionValue !== void 0) return optionValue;
   for (const root of roots) {
     const absRoot = isAbsolute4(root) ? root : resolve11(root);
     if (!existsSync11(absRoot)) continue;
-    const detected = resolveActiveProvider(absRoot).resolved;
+    const detected = resolveActiveProvider(absRoot, providers).resolved;
     if (detected !== null) return detected;
   }
   return null;