@kb-labs/cli-commands 2.31.0 → 2.33.0

package/dist/registry/index.d.ts

@@ -1,5 +1,5 @@
-import { d as CommandManifest, A as AvailabilityCheck, R as RegisteredCommand, D as DiscoveryResult } from '../discover-DhqYgS-M.js';
-export { b as CacheFile, c as CommandLookupResult, e as CommandModule, f as CommandType, F as FlagDefinition, G as GlobalFlags, g as PackageCacheEntry, P as ProductGroup, _ as __test, h as discoverManifests, i as discoverManifestsByNamespace, j as findCommand, k as findCommandWithType, r as registry, l as resetInProcCache } from '../discover-DhqYgS-M.js';
+import { d as CommandManifest, A as AvailabilityCheck, R as RegisteredCommand, D as DiscoveryResult } from '../discover-Cz7X5bQp.js';
+export { b as CacheFile, c as CommandLookupResult, e as CommandModule, f as CommandType, F as FlagDefinition, G as GlobalFlags, g as PackageCacheEntry, P as ProductGroup, _ as __test, h as discoverManifests, i as discoverManifestsByNamespace, j as findCommand, k as findCommandWithType, r as registry, l as resetInProcCache } from '../discover-Cz7X5bQp.js';
 import { ILogger } from '@kb-labs/core-platform';
 import '@kb-labs/plugin-contracts';
 

package/dist/registry/index.js

@@ -320,8 +320,8 @@ async function computePluginsStateHash(cwd) {
     return "";
   }
 }
-async function computeMarketplaceLockHash(cwd) {
-  const lockPath = path2.join(cwd, ".kb", "marketplace.lock");
+async function computeMarketplaceLockHashAt(root) {
+  const lockPath = path2.join(root, ".kb", "marketplace.lock");
   try {
     const content = await promises.readFile(lockPath, "utf8");
     return createHash("sha256").update(content).digest("hex");
@@ -550,22 +550,19 @@ async function discoverWorkspace(cwd) {
       }
     }
   }
-  const localPluginPattern = path2.join(
-    ".kb",
-    "plugins",
-    "*",
-    "packages",
-    "*-entry",
-    PACKAGE_JSON
-  );
-  const localPluginFiles = await glob(localPluginPattern, {
-    cwd,
+  return loadManifestsForPackages(packageInfos, "workspace", "platform");
+}
+async function discoverProjectLocalPlugins(projectRoot) {
+  const pattern = path2.join(".kb", "plugins", "*", "packages", "*-entry", PACKAGE_JSON);
+  const files = await glob(pattern, {
+    cwd: projectRoot,
     absolute: false,
     ignore: ["**/node_modules/**"]
   });
-  for (const pkgFile of localPluginFiles) {
-    const pkgRoot = path2.dirname(path2.join(cwd, pkgFile));
-    const pkg = await readPackageJson(path2.join(cwd, pkgFile));
+  const packageInfos = [];
+  for (const pkgFile of files) {
+    const pkgRoot = path2.dirname(path2.join(projectRoot, pkgFile));
+    const pkg = await readPackageJson(path2.join(projectRoot, pkgFile));
     if (!pkg) {
       continue;
     }
@@ -574,6 +571,9 @@ async function discoverWorkspace(cwd) {
       packageInfos.push({ pkgRoot, pkg, manifestPath: manifestInfo.path });
     }
   }
+  return loadManifestsForPackages(packageInfos, "linked", "project");
+}
+async function loadManifestsForPackages(packageInfos, source, scope) {
   const loadPromises = packageInfos.map(async ({ pkgRoot, pkg, manifestPath }) => {
     const pkgStart = Date.now();
     try {
@@ -586,7 +586,8 @@ async function discoverWorkspace(cwd) {
         validateUniqueIds(manifests, pkg.name);
         return {
           manifests,
-          source: "workspace",
+          source,
+          scope,
           packageName: pkg.name,
           manifestPath: toPosixPath(manifestPath),
           pkgRoot: toPosixPath(pkgRoot)
@@ -607,7 +608,8 @@ async function discoverWorkspace(cwd) {
       const synthetic = createUnavailableManifest(pkg.name, err);
       return {
         manifests: [synthetic],
-        source: "workspace",
+        source,
+        scope,
         packageName: pkg.name,
         manifestPath: toPosixPath(manifestPath),
         pkgRoot: toPosixPath(pkgRoot)
@@ -641,6 +643,9 @@ async function discoverCurrentPackage(cwd) {
         return {
           manifests,
           source: "workspace",
+          // Current-package fallback fires in installed mode when the user's
+          // project itself exposes a manifest. That maps to the project scope.
+          scope: "project",
           packageName: pkg.name,
           manifestPath: toPosixPath(manifestInfo.path),
           pkgRoot: toPosixPath(cwd)
@@ -745,6 +750,10 @@ async function discoverNodeModules(cwd) {
           return {
             manifests,
             source: isLinked ? "linked" : "node_modules",
+            // node_modules discovery runs at the platform root. In dev mode
+            // platformRoot === projectRoot so either label is correct; we use
+            // platform to reflect where the manifest physically lives.
+            scope: "platform",
             packageName: pkg.name,
             manifestPath: toPosixPath(manifestPath),
             pkgRoot: toPosixPath(pkgRoot)
@@ -764,6 +773,7 @@ async function discoverNodeModules(cwd) {
         return {
           manifests: [synthetic],
           source: isLinked ? "linked" : "node_modules",
+          scope: "platform",
           packageName: pkg.name,
           manifestPath: toPosixPath(manifestPath),
           pkgRoot: toPosixPath(pkgRoot)
@@ -795,17 +805,35 @@ function deduplicateManifests(all) {
     const existing = byPackageName.get(result.packageName);
     if (!existing) {
       byPackageName.set(result.packageName, result);
-    } else {
-      const existingPriority = priority[existing.source] || 0;
-      const newPriority = priority[result.source] || 0;
-      if (newPriority > existingPriority) {
-        byPackageName.set(result.packageName, result);
+      continue;
+    }
+    if (existing.scope !== result.scope) {
+      if (existing.pkgRoot === result.pkgRoot) {
+        const projectEntry = existing.scope === "project" ? existing : result;
+        byPackageName.set(result.packageName, projectEntry);
+        continue;
       }
+      const winner = existing.scope === "platform" ? existing : result;
+      const loser = existing.scope === "platform" ? result : existing;
+      log("warn", JSON.stringify({
+        code: "DISCOVERY_SCOPE_COLLISION",
+        packageName: result.packageName,
+        platformPath: winner.pkgRoot,
+        projectPath: loser.pkgRoot,
+        message: "Package exists in both platform and project scopes \u2014 platform wins."
+      }));
+      byPackageName.set(result.packageName, winner);
+      continue;
+    }
+    const existingPriority = priority[existing.source] ?? 0;
+    const newPriority = priority[result.source] ?? 0;
+    if (newPriority > existingPriority) {
+      byPackageName.set(result.packageName, result);
     }
   }
   return Array.from(byPackageName.values());
 }
-async function loadCache(cwd) {
+async function loadCache(cwd, roots) {
   const cachePath = path2.join(cwd, ".kb", "cache", "cli-manifests.json");
   try {
     const content = await promises.readFile(cachePath, "utf8");
@@ -842,11 +870,26 @@ async function loadCache(cwd) {
       log("debug", "Cache invalidated: .kb/plugins.json changed");
       return null;
     }
-    const currentMarketplaceLockHash = await computeMarketplaceLockHash(cwd);
-    if (currentMarketplaceLockHash && cache.marketplaceLockHash && cache.marketplaceLockHash !== currentMarketplaceLockHash) {
-      log("debug", "Cache invalidated: .kb/marketplace.lock changed");
+    if (cache.platformRoot && cache.platformRoot !== roots.platformRoot) {
+      log("debug", `Cache invalidated: platformRoot changed (${cache.platformRoot} \u2192 ${roots.platformRoot})`);
+      return null;
+    }
+    if (cache.projectRoot && cache.projectRoot !== roots.projectRoot) {
+      log("debug", `Cache invalidated: projectRoot changed (${cache.projectRoot} \u2192 ${roots.projectRoot})`);
+      return null;
+    }
+    const currentPlatformLockHash = await computeMarketplaceLockHashAt(roots.platformRoot);
+    if (currentPlatformLockHash && cache.platformMarketplaceLockHash && cache.platformMarketplaceLockHash !== currentPlatformLockHash) {
+      log("debug", `Cache invalidated: ${roots.platformRoot}/.kb/marketplace.lock changed`);
       return null;
     }
+    if (roots.projectRoot !== roots.platformRoot) {
+      const currentProjectLockHash = await computeMarketplaceLockHashAt(roots.projectRoot);
+      if (currentProjectLockHash && cache.projectMarketplaceLockHash && cache.projectMarketplaceLockHash !== currentProjectLockHash) {
+        log("debug", `Cache invalidated: ${roots.projectRoot}/.kb/marketplace.lock changed`);
+        return null;
+      }
+    }
     const parsedCache = cache;
     parsedCache.ttlMs = parsedCache.ttlMs ?? DISK_CACHE_TTL_MS;
     for (const entry of Object.values(parsedCache.packages)) {
@@ -898,7 +941,7 @@ async function isPackageCacheStale(entry, options) {
   }
   return false;
 }
-async function saveCache(cwd, results) {
+async function saveCache(cwd, results, roots) {
   const cachePath = path2.join(cwd, ".kb", "cache", "cli-manifests.json");
   await promises.mkdir(path2.dirname(cachePath), { recursive: true });
   const packages = {};
@@ -944,7 +987,8 @@ async function saveCache(cwd, results) {
   const lockfileHash = await computeLockfileHash(cwd);
   const configHash = await computeConfigHash(cwd);
   const pluginsStateHash = await computePluginsStateHash(cwd);
-  const marketplaceLockHash = await computeMarketplaceLockHash(cwd);
+  const platformMarketplaceLockHash = await computeMarketplaceLockHashAt(roots.platformRoot);
+  const projectMarketplaceLockHash = roots.projectRoot !== roots.platformRoot ? await computeMarketplaceLockHashAt(roots.projectRoot) : "";
   if (lockfileHash) {
     stateHasher.update(lockfileHash);
   }
@@ -954,9 +998,14 @@ async function saveCache(cwd, results) {
   if (pluginsStateHash) {
     stateHasher.update(pluginsStateHash);
   }
-  if (marketplaceLockHash) {
-    stateHasher.update(marketplaceLockHash);
+  if (platformMarketplaceLockHash) {
+    stateHasher.update(platformMarketplaceLockHash);
+  }
+  if (projectMarketplaceLockHash) {
+    stateHasher.update(projectMarketplaceLockHash);
   }
+  stateHasher.update(roots.platformRoot);
+  stateHasher.update(roots.projectRoot);
   const cache = {
     version: process.version,
     cliVersion: process.env.CLI_VERSION || "0.1.0",
@@ -966,7 +1015,10 @@ async function saveCache(cwd, results) {
     lockfileHash: lockfileHash || void 0,
     configHash: configHash || void 0,
     pluginsStateHash: pluginsStateHash || void 0,
-    marketplaceLockHash: marketplaceLockHash || void 0,
+    platformMarketplaceLockHash: platformMarketplaceLockHash || void 0,
+    projectMarketplaceLockHash: projectMarketplaceLockHash || void 0,
+    platformRoot: roots.platformRoot,
+    projectRoot: roots.projectRoot,
     packages
   };
   try {
@@ -978,6 +1030,9 @@ async function saveCache(cwd, results) {
 async function discoverManifests(cwd, noCache = false, options = {}) {
   const startTime = Date.now();
   const timings = {};
+  const platformRoot = options.platformRoot ?? cwd;
+  const projectRoot = options.projectRoot ?? cwd;
+  const roots = { platformRoot, projectRoot };
   if (noCache) {
     inProcDiscoveryCache = null;
   } else if (inProcDiscoveryCache) {
@@ -994,7 +1049,7 @@ async function discoverManifests(cwd, noCache = false, options = {}) {
   }
   if (!noCache) {
     const cacheStart = Date.now();
-    const cached = await loadCache(cwd);
+    const cached = await loadCache(cwd, roots);
     timings.cacheLoad = Date.now() - cacheStart;
     if (cached) {
       log("debug", "Using cached manifests");
@@ -1037,7 +1092,7 @@ async function discoverManifests(cwd, noCache = false, options = {}) {
   let workspace = [];
   try {
     const wsStart = Date.now();
-    workspace = await discoverWorkspace(cwd);
+    workspace = await discoverWorkspace(platformRoot);
     timings.workspace = Date.now() - wsStart;
     log("info", `Discovered ${workspace.length} workspace packages with CLI manifests`);
   } catch (_err) {
@@ -1051,17 +1106,22 @@ async function discoverManifests(cwd, noCache = false, options = {}) {
     }
   }
   const nmStart = Date.now();
-  const nodeModulesRoot = options.platformRoot ?? cwd;
-  const installed = await discoverNodeModules(nodeModulesRoot);
+  const installed = await discoverNodeModules(platformRoot);
   timings.nodeModules = Date.now() - nmStart;
   if (installed.length > 0) {
     log("info", `Discovered ${installed.length} installed packages with CLI manifests`);
   }
+  const plStart = Date.now();
+  const projectLocal = await discoverProjectLocalPlugins(projectRoot);
+  timings.projectLocal = Date.now() - plStart;
+  if (projectLocal.length > 0) {
+    log("info", `Discovered ${projectLocal.length} project-local plugins`);
+  }
   const dedupStart = Date.now();
-  const results = deduplicateManifests([...workspace, ...installed]);
+  const results = deduplicateManifests([...workspace, ...installed, ...projectLocal]);
   timings.deduplicate = Date.now() - dedupStart;
   const saveStart = Date.now();
-  await saveCache(cwd, results);
+  await saveCache(cwd, results, roots);
   timings.cacheSave = Date.now() - saveStart;
   const totalTime = Date.now() - startTime;
   const sourceCounts = results.reduce((acc, r) => {