@kb-labs/cli-commands 2.4.0 → 2.5.0

package/dist/discover-8_R7njIS.d.ts

@@ -0,0 +1,234 @@
+import { ManifestV3 } from '@kb-labs/plugin-contracts';
+
+/**
+ * @kb-labs/cli-commands/registry
+ * Type definitions for the plugin system
+ */
+
+interface CommandManifest {
+    manifestVersion: '1.0';
+    id: string;
+    aliases?: string[];
+    group: string;
+    subgroup?: string;
+    describe: string;
+    longDescription?: string;
+    requires?: string[];
+    flags?: FlagDefinition[];
+    examples?: string[];
+    loader?: () => Promise<CommandModule>;
+    package?: string;
+    namespace?: string;
+    engine?: {
+        node?: string;
+        kbCli?: string;
+        module?: 'esm' | 'cjs';
+    };
+    permissions?: string[];
+    telemetry?: 'opt-in' | 'off';
+    manifestV2?: ManifestV3;
+}
+interface FlagDefinition {
+    name: string;
+    type: "string" | "boolean" | "number" | "array";
+    alias?: string;
+    default?: any;
+    description?: string;
+    describe?: string;
+    choices?: string[];
+    required?: boolean;
+    examples?: string[];
+}
+interface RegisteredCommand {
+    manifest: CommandManifest;
+    v3Manifest?: ManifestV3;
+    available: boolean;
+    unavailableReason?: string;
+    hint?: string;
+    source: 'workspace' | 'node_modules' | 'linked' | 'builtin';
+    shadowed: boolean;
+    pkgRoot?: string;
+    packageName?: string;
+}
+interface CommandModule {
+    run: (ctx: any, argv: string[], flags: Record<string, any>) => Promise<number | void>;
+}
+interface DiscoveryResult {
+    source: 'workspace' | 'node_modules' | 'linked' | 'builtin';
+    packageName: string;
+    manifestPath: string;
+    pkgRoot: string;
+    manifests: CommandManifest[];
+}
+interface GlobalFlags {
+    json?: boolean;
+    onlyAvailable?: boolean;
+    noCache?: boolean;
+    verbose?: boolean;
+    quiet?: boolean;
+    help?: boolean;
+    version?: boolean;
+    dryRun?: boolean;
+}
+interface PackageCacheEntry {
+    version: string;
+    manifestHash: string;
+    manifestPath: string;
+    pkgJsonMtime: number;
+    manifestMtime: number;
+    cachedAt: number;
+    result: DiscoveryResult;
+}
+interface CacheFile {
+    version: string;
+    cliVersion: string;
+    timestamp: number;
+    ttlMs?: number;
+    stateHash?: string;
+    lockfileHash?: string;
+    configHash?: string;
+    pluginsStateHash?: string;
+    packages: Record<string, PackageCacheEntry>;
+}
+type AvailabilityCheck = {
+    available: true;
+} | {
+    available: false;
+    reason: string;
+    hint?: string;
+};
+
+/**
+ * Legacy V2 types for backward compatibility
+ * These types were removed from cli-contracts but are still needed
+ * for the adapter layer in service.ts
+ */
+
+interface CommandRun {
+    (ctx: any, argv: string[], flags: Record<string, any>): Promise<number | void>;
+}
+interface Command {
+    name: string;
+    category?: string;
+    describe: string;
+    longDescription?: string;
+    aliases?: string[];
+    flags?: FlagDefinition[];
+    examples?: string[];
+    run: CommandRun;
+}
+interface CommandGroup {
+    name: string;
+    describe?: string;
+    commands: Command[];
+    subgroups?: CommandGroup[];
+}
+interface CommandRegistry {
+    register(cmd: Command): void;
+    registerGroup(group: CommandGroup): void;
+    registerManifest(cmd: any): void;
+    list(): Command[];
+    listGroups(): CommandGroup[];
+    listManifests(): any[];
+    markPartial(isPartial: boolean): void;
+    isPartial(): boolean;
+}
+
+interface ProductGroup {
+    name: string;
+    describe?: string;
+    commands: RegisteredCommand[];
+}
+type CommandType = 'system' | 'plugin';
+interface CommandLookupResult {
+    cmd: Command | CommandGroup;
+    type: CommandType;
+}
+declare class InMemoryRegistry implements CommandRegistry {
+    private systemCommands;
+    private pluginCommands;
+    private byName;
+    private groups;
+    private manifests;
+    private partial;
+    register(cmd: Command): void;
+    registerGroup(group: CommandGroup): void;
+    registerManifest(cmd: RegisteredCommand): void;
+    markPartial(partial: boolean): void;
+    isPartial(): boolean;
+    getManifest(id: string): RegisteredCommand | undefined;
+    listManifests(): RegisteredCommand[];
+    has(name: string): boolean;
+    /**
+     * Get command with type information for secure routing
+     *
+     * Returns type='system' for commands from registerGroup() - execute in-process
+     * Returns type='plugin' for commands from registerManifest() - execute in subprocess
+     *
+     * This separation prevents malicious plugins from escaping the sandbox.
+     */
+    getWithType(nameOrPath: string | string[]): CommandLookupResult | undefined;
+    get(nameOrPath: string | string[]): Command | CommandGroup | undefined;
+    list(): Command[];
+    listGroups(): CommandGroup[];
+    getGroupsByPrefix(prefix: string): CommandGroup[];
+    getCommandsByGroupPrefix(prefix: string): Command[];
+    listProductGroups(): ProductGroup[];
+    getCommandsByGroup(group: string): RegisteredCommand[];
+    getManifestCommand(idOrAlias: string): RegisteredCommand | undefined;
+}
+declare const registry: InMemoryRegistry;
+declare function findCommand(nameOrPath: string | string[]): Command | CommandGroup | undefined;
+/**
+ * Find command with type information for secure routing
+ *
+ * Use this in bootstrap.ts to determine execution path:
+ * - type='system' → execute via cmd.run() in-process
+ * - type='plugin' → execute via executePlugin() in plugin-executor
+ */
+declare function findCommandWithType(nameOrPath: string | string[]): CommandLookupResult | undefined;
+
+/**
+ * @kb-labs/cli-commands/registry
+ * Command manifest discovery - workspace, node_modules, current package
+ */
+
+/**
+ * Create loader stub for ManifestV3 commands.
+ * Loader should never be executed directly – CLI adapters must handle execution.
+ */
+declare function createManifestV3Loader(commandId: string): () => Promise<{
+    run: any;
+}>;
+/**
+ * Ensure manifest has loader function (rehydrate after JSON serialization).
+ */
+declare function ensureManifestLoader(manifest: CommandManifest): void;
+declare const __test: {
+    ensureManifestLoader: typeof ensureManifestLoader;
+    createManifestV3Loader: typeof createManifestV3Loader;
+};
+/**
+ * Main discovery function — discovers command manifests from workspace,
+ * current package, and `node_modules`.
+ *
+ * @param cwd      Project cwd. Used for workspace discovery (monorepo dev mode)
+ *                 and for the disk cache location.
+ * @param noCache  Bypass both the in-process and disk caches.
+ * @param options  Extra options:
+ *   - `platformRoot`: When provided, `discoverNodeModules` scans
+ *     `<platformRoot>/node_modules` instead of `<cwd>/node_modules`. This is
+ *     required in installed mode, where the KB Labs platform lives in a
+ *     different directory from the user's project. In dev mode `platformRoot`
+ *     typically equals `cwd` and the two paths coincide.
+ */
+declare function discoverManifests(cwd: string, noCache?: boolean, options?: {
+    platformRoot?: string;
+}): Promise<DiscoveryResult[]>;
+/**
+ * Lazy load manifests for a specific namespace
+ * Only loads manifests from packages matching the namespace
+ */
+declare function discoverManifestsByNamespace(cwd: string, namespace: string, noCache?: boolean): Promise<DiscoveryResult[]>;
+
+export { type AvailabilityCheck as A, type CommandGroup as C, type DiscoveryResult as D, type FlagDefinition as F, type GlobalFlags as G, type ProductGroup as P, type RegisteredCommand as R, __test as _, type Command as a, findCommandWithType as b, type CommandType as c, type CommandLookupResult as d, discoverManifestsByNamespace as e, findCommand as f, discoverManifests as g, type CommandManifest as h, type CommandModule as i, type PackageCacheEntry as j, type CacheFile as k, registry as r };

package/dist/index.d.ts

@@ -1,200 +1,22 @@
-import { ManifestV3 } from '@kb-labs/plugin-contracts';
+import { C as CommandGroup, P as ProductGroup, a as Command, R as RegisteredCommand } from './discover-8_R7njIS.js';
+export { A as AvailabilityCheck, k as CacheFile, d as CommandLookupResult, h as CommandManifest, i as CommandModule, c as CommandType, D as DiscoveryResult, F as FlagDefinition, G as GlobalFlags, j as PackageCacheEntry, g as discoverManifests, e as discoverManifestsByNamespace, f as findCommand, b as findCommandWithType, r as registry } from './discover-8_R7njIS.js';
 import { ILogger } from '@kb-labs/core-platform';
 export { TimingTracker } from '@kb-labs/shared-cli-ui';
 import * as _kb_labs_shared_command_kit from '@kb-labs/shared-command-kit';
-
-/**
- * @kb-labs/cli-commands/registry
- * Type definitions for the plugin system
- */
-
-interface CommandManifest {
-    manifestVersion: '1.0';
-    id: string;
-    aliases?: string[];
-    group: string;
-    subgroup?: string;
-    describe: string;
-    longDescription?: string;
-    requires?: string[];
-    flags?: FlagDefinition[];
-    examples?: string[];
-    loader?: () => Promise<CommandModule>;
-    package?: string;
-    namespace?: string;
-    engine?: {
-        node?: string;
-        kbCli?: string;
-        module?: 'esm' | 'cjs';
-    };
-    permissions?: string[];
-    telemetry?: 'opt-in' | 'off';
-    manifestV2?: ManifestV3;
-}
-interface FlagDefinition {
-    name: string;
-    type: "string" | "boolean" | "number" | "array";
-    alias?: string;
-    default?: any;
-    description?: string;
-    describe?: string;
-    choices?: string[];
-    required?: boolean;
-    examples?: string[];
-}
-interface RegisteredCommand {
-    manifest: CommandManifest;
-    v3Manifest?: ManifestV3;
-    available: boolean;
-    unavailableReason?: string;
-    hint?: string;
-    source: 'workspace' | 'node_modules' | 'linked' | 'builtin';
-    shadowed: boolean;
-    pkgRoot?: string;
-    packageName?: string;
-}
-interface CommandModule {
-    run: (ctx: any, argv: string[], flags: Record<string, any>) => Promise<number | void>;
-}
-interface DiscoveryResult {
-    source: 'workspace' | 'node_modules' | 'linked' | 'builtin';
-    packageName: string;
-    manifestPath: string;
-    pkgRoot: string;
-    manifests: CommandManifest[];
-}
-interface GlobalFlags {
-    json?: boolean;
-    onlyAvailable?: boolean;
-    noCache?: boolean;
-    verbose?: boolean;
-    quiet?: boolean;
-    help?: boolean;
-    version?: boolean;
-    dryRun?: boolean;
-}
-interface PackageCacheEntry {
-    version: string;
-    manifestHash: string;
-    manifestPath: string;
-    pkgJsonMtime: number;
-    manifestMtime: number;
-    cachedAt: number;
-    result: DiscoveryResult;
-}
-interface CacheFile {
-    version: string;
-    cliVersion: string;
-    timestamp: number;
-    ttlMs?: number;
-    stateHash?: string;
-    lockfileHash?: string;
-    configHash?: string;
-    pluginsStateHash?: string;
-    packages: Record<string, PackageCacheEntry>;
-}
-type AvailabilityCheck = {
-    available: true;
-} | {
-    available: false;
-    reason: string;
-    hint?: string;
-};
-
-/**
- * Legacy V2 types for backward compatibility
- * These types were removed from cli-contracts but are still needed
- * for the adapter layer in service.ts
- */
-
-interface CommandRun {
-    (ctx: any, argv: string[], flags: Record<string, any>): Promise<number | void>;
-}
-interface Command {
-    name: string;
-    category?: string;
-    describe: string;
-    longDescription?: string;
-    aliases?: string[];
-    flags?: FlagDefinition[];
-    examples?: string[];
-    run: CommandRun;
-}
-interface CommandGroup {
-    name: string;
-    describe?: string;
-    commands: Command[];
-    subgroups?: CommandGroup[];
-}
-interface CommandRegistry {
-    register(cmd: Command): void;
-    registerGroup(group: CommandGroup): void;
-    registerManifest(cmd: any): void;
-    list(): Command[];
-    listGroups(): CommandGroup[];
-    listManifests(): any[];
-    markPartial(isPartial: boolean): void;
-    isPartial(): boolean;
-}
-
-interface ProductGroup {
-    name: string;
-    describe?: string;
-    commands: RegisteredCommand[];
-}
-type CommandType = 'system' | 'plugin';
-interface CommandLookupResult {
-    cmd: Command | CommandGroup;
-    type: CommandType;
-}
-declare class InMemoryRegistry implements CommandRegistry {
-    private systemCommands;
-    private pluginCommands;
-    private byName;
-    private groups;
-    private manifests;
-    private partial;
-    register(cmd: Command): void;
-    registerGroup(group: CommandGroup): void;
-    registerManifest(cmd: RegisteredCommand): void;
-    markPartial(partial: boolean): void;
-    isPartial(): boolean;
-    getManifest(id: string): RegisteredCommand | undefined;
-    listManifests(): RegisteredCommand[];
-    has(name: string): boolean;
-    /**
-     * Get command with type information for secure routing
-     *
-     * Returns type='system' for commands from registerGroup() - execute in-process
-     * Returns type='plugin' for commands from registerManifest() - execute in subprocess
-     *
-     * This separation prevents malicious plugins from escaping the sandbox.
-     */
-    getWithType(nameOrPath: string | string[]): CommandLookupResult | undefined;
-    get(nameOrPath: string | string[]): Command | CommandGroup | undefined;
-    list(): Command[];
-    listGroups(): CommandGroup[];
-    getGroupsByPrefix(prefix: string): CommandGroup[];
-    getCommandsByGroupPrefix(prefix: string): Command[];
-    listProductGroups(): ProductGroup[];
-    getCommandsByGroup(group: string): RegisteredCommand[];
-    getManifestCommand(idOrAlias: string): RegisteredCommand | undefined;
-}
-declare const registry: InMemoryRegistry;
-declare function findCommand(nameOrPath: string | string[]): Command | CommandGroup | undefined;
-/**
- * Find command with type information for secure routing
- *
- * Use this in bootstrap.ts to determine execution path:
- * - type='system' → execute via cmd.run() in-process
- * - type='plugin' → execute via executePlugin() in plugin-executor
- */
-declare function findCommandWithType(nameOrPath: string | string[]): CommandLookupResult | undefined;
+import '@kb-labs/plugin-contracts';
 
 interface RegisterBuiltinCommandsInput {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
     logger?: ILogger;
+    /**
+     * Where the KB Labs platform is installed (parent of
+     * `node_modules/@kb-labs/*`). Forwarded to `discoverManifests` so that
+     * plugin discovery scans the platform `node_modules` regardless of where
+     * the CLI is invoked from. When omitted, falls back to `cwd` — this keeps
+     * dev-mode behavior unchanged.
+     */
+    platformRoot?: string;
 }
 declare function registerBuiltinCommands(input?: RegisterBuiltinCommandsInput): Promise<void>;
 
@@ -231,22 +53,6 @@ interface ExampleCase {
 }
 declare function generateExamples(commandName: string, productName: string, cases: ExampleCase[]): string[];
 
-/**
- * @kb-labs/cli-commands/registry
- * Command manifest discovery - workspace, node_modules, current package
- */
-
-/**
- * Main discovery function
- * Discovers command manifests from workspace, current package, and node_modules
- */
-declare function discoverManifests(cwd: string, noCache?: boolean): Promise<DiscoveryResult[]>;
-/**
- * Lazy load manifests for a specific namespace
- * Only loads manifests from packages matching the namespace
- */
-declare function discoverManifestsByNamespace(cwd: string, namespace: string, noCache?: boolean): Promise<DiscoveryResult[]>;
-
 declare const hello: _kb_labs_shared_command_kit.Command;
 
 declare const health: _kb_labs_shared_command_kit.Command;
@@ -291,4 +97,4 @@ declare const logsGet: _kb_labs_shared_command_kit.Command;
  */
 declare const logsStats: _kb_labs_shared_command_kit.Command;
 
-export { type AvailabilityCheck, type CacheFile, type CommandLookupResult, type CommandManifest, type CommandModule, type CommandType, type DiscoveryResult, type ExampleCase, type FlagDefinition, type GlobalFlags, type PackageCacheEntry, type ProductGroup, type RegisteredCommand, discoverManifests, discoverManifestsByNamespace, findCommand, findCommandWithType, generateExamples, health, hello, logsContext, logsDiagnose, logsGet, logsQuery, logsSearch, logsStats, logsSummarize, registerBuiltinCommands, registry, renderGlobalHelp, renderGlobalHelpNew, renderGroupHelp, renderHelp, renderManifestCommandHelp, renderPluginsHelp, renderProductHelp, version };
+export { type ExampleCase, ProductGroup, RegisteredCommand, generateExamples, health, hello, logsContext, logsDiagnose, logsGet, logsQuery, logsSearch, logsStats, logsSummarize, registerBuiltinCommands, renderGlobalHelp, renderGlobalHelpNew, renderGroupHelp, renderHelp, renderManifestCommandHelp, renderPluginsHelp, renderProductHelp, version };

package/dist/index.js

@@ -851,7 +851,7 @@ async function saveCache(cwd, results) {
     log("debug", `Failed to save cache: ${err.message}`);
   }
 }
-async function discoverManifests(cwd, noCache = false) {
+async function discoverManifests(cwd, noCache = false, options = {}) {
   const startTime = Date.now();
   const timings = {};
   if (noCache) {
@@ -927,7 +927,8 @@ async function discoverManifests(cwd, noCache = false) {
     }
   }
   const nmStart = Date.now();
-  const installed = await discoverNodeModules(cwd);
+  const nodeModulesRoot = options.platformRoot ?? cwd;
+  const installed = await discoverNodeModules(nodeModulesRoot);
   timings.nodeModules = Date.now() - nmStart;
   if (installed.length > 0) {
     log("info", `Discovered ${installed.length} installed packages with CLI manifests`);
@@ -1524,7 +1525,8 @@ var diag = defineSystemCommand({
       details: { nodeVersion, cliVersion, platform: platform11, arch }
     });
     try {
-      const discovered = await discoverManifests(cwd, false);
+      const platformRoot = process.env.KB_PLATFORM_ROOT;
+      const discovered = await discoverManifests(cwd, false, { platformRoot });
       const manifests = registry.listManifests();
       const enabled = manifests.filter((m) => m.available && !m.shadowed).length;
       const disabled = manifests.filter((m) => !m.available).length;
@@ -3660,7 +3662,9 @@ async function registerBuiltinCommands(input = {}) {
     const env = input.env ?? process.env;
     const noCache = process.argv.includes("--no-cache") || env.KB_PLUGIN_NO_CACHE === "1";
     const { discoverManifests: discoverManifests2 } = await Promise.resolve().then(() => (init_discover(), discover_exports));
-    const discovered = await discoverManifests2(cwd, noCache);
+    const discovered = await discoverManifests2(cwd, noCache, {
+      platformRoot: input.platformRoot
+    });
     if (discovered.length > 0) {
       log3.info(`Discovered ${discovered.length} packages with CLI manifests`);
       const { valid: readyToRegister, skipped: preflightSkipped } = preflightManifests(discovered, log3);