@kb-labs/cli-commands 1.0.0 → 1.1.0

package/dist/index.js

@@ -1,10 +1,10 @@
 import { safeColors, safeSymbols, getContextCwd, formatTable, toPosixPath, TimingTracker, sideBorderBox, formatCommandHelp } from '@kb-labs/shared-cli-ui';
 export { TimingTracker } from '@kb-labs/shared-cli-ui';
 import { z } from 'zod';
-import { promises, existsSync } from 'fs';
-import path2 from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
+import { promises, existsSync } from 'fs';
 import { createHash } from 'crypto';
+import path from 'path';
 import { parse } from 'yaml';
 import { glob } from 'glob';
 import { defineSystemCommand, defineSystemCommandGroup } from '@kb-labs/shared-command-kit';
@@ -161,225 +161,6 @@ var init_schema = __esm({
   }
 });
 
-// src/commands/system/plugin-setup-rollback.ts
-var plugin_setup_rollback_exports = {};
-__export(plugin_setup_rollback_exports, {
-  createPluginSetupRollbackCommand: () => createPluginSetupRollbackCommand
-});
-function createPluginSetupRollbackCommand(options) {
-  const { namespace } = options;
-  return {
-    name: `${namespace}:setup:rollback`,
-    describe: `Rollback setup changes applied by ${namespace}`,
-    category: namespace,
-    examples: [
-      `kb ${namespace} setup:rollback --list`,
-      `kb ${namespace} setup:rollback --log .kb/logs/setup/${namespace}-<id>.json --yes`
-    ],
-    flags: ROLLBACK_COMMAND_FLAGS,
-    async run(ctx, _argv, rawFlags) {
-      const presenter = ctx.presenter ?? {};
-      const output = ctx.output;
-      const logger = ctx.platform?.logger;
-      const cwd = getContextCwd(ctx) ?? process.cwd();
-      logger?.info("Plugin setup rollback started", { namespace });
-      const logsDir = path2.join(cwd, ".kb", "logs", "setup");
-      const listOnly = rawFlags.list === true;
-      const autoConfirm = rawFlags.yes === true;
-      const logFlag = typeof rawFlags.log === "string" ? rawFlags.log : void 0;
-      try {
-        await promises.mkdir(logsDir, { recursive: true });
-        if (listOnly) {
-          await listLogs(logsDir, namespace, output || presenter, logger);
-          return 0;
-        }
-        const resolvedLogPath = logFlag ? resolveLogPath(logsDir, logFlag, cwd) : await findLatestLog(logsDir, namespace);
-        if (!resolvedLogPath) {
-          logger?.warn("No setup log found", { namespace, logFlag });
-          (output || presenter)?.error?.(
-            `\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D \u043D\u0438 \u043E\u0434\u0438\u043D \u043B\u043E\u0433 setup \u0434\u043B\u044F ${namespace}. \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439\u0442\u0435 --log \u0434\u043B\u044F \u0443\u043A\u0430\u0437\u0430\u043D\u0438\u044F \u0444\u0430\u0439\u043B\u0430.`
-          );
-          return 1;
-        }
-        logger?.info("Using setup log", { logPath: resolvedLogPath });
-        (output || presenter)?.info?.(`~ \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0435\u043C \u043B\u043E\u0433: ${path2.relative(cwd, resolvedLogPath)}`);
-        if (!autoConfirm) {
-          (output || presenter)?.warn?.("\u0414\u043E\u0431\u0430\u0432\u044C\u0442\u0435 \u0444\u043B\u0430\u0433 --yes \u0434\u043B\u044F \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u044F \u043E\u0442\u043A\u0430\u0442\u0430.");
-          return 1;
-        }
-        const entries = await readJournalEntries(resolvedLogPath);
-        if (entries.length === 0) {
-          logger?.warn("Setup log is empty", { logPath: resolvedLogPath });
-          (output || presenter)?.warn?.("\u041B\u043E\u0433 \u043F\u0443\u0441\u0442\u043E\u0439, \u043E\u0442\u043A\u0430\u0442\u044B\u0432\u0430\u0442\u044C \u043D\u0435\u0447\u0435\u0433\u043E.");
-          return 0;
-        }
-        logger?.info("Applying rollback", { entriesCount: entries.length });
-        await applyRollback(entries, cwd, output || presenter, logger);
-        logger?.info("Rollback completed");
-        (output || presenter)?.info?.("\u2713 \u041E\u0442\u043A\u0430\u0442 \u0437\u0430\u0432\u0435\u0440\u0448\u0451\u043D.");
-        return 0;
-      } catch (error) {
-        logger?.error("Rollback failed", {
-          error: error instanceof Error ? error.message : String(error)
-        });
-        (output || presenter)?.error?.(error);
-        return 1;
-      }
-    }
-  };
-}
-function resolveLogPath(logsDir, inputPath, cwd) {
-  const candidate = path2.isAbsolute(inputPath) ? inputPath : path2.resolve(cwd, inputPath);
-  if (candidate.startsWith(logsDir)) {
-    return candidate;
-  }
-  return candidate;
-}
-async function listLogs(logsDir, namespace, output, logger) {
-  const files = await safeReadDir(logsDir);
-  const filtered = files.filter((file) => file.startsWith(namespace) && file.endsWith(".json")).sort().reverse();
-  logger?.info("Listing setup logs", { namespace, count: filtered.length });
-  if (filtered.length === 0) {
-    output?.info?.("\u041B\u043E\u0433\u0438 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u044B.");
-    return;
-  }
-  output?.info?.("\u0414\u043E\u0441\u0442\u0443\u043F\u043D\u044B\u0435 \u043B\u043E\u0433\u0438 setup:");
-  for (const file of filtered) {
-    output?.info?.(` \u2022 ${file}`);
-  }
-}
-async function safeReadDir(dir) {
-  try {
-    return await promises.readdir(dir);
-  } catch (error) {
-    if (error?.code === "ENOENT") {
-      return [];
-    }
-    throw error;
-  }
-}
-async function findLatestLog(logsDir, namespace) {
-  const entries = await safeReadDir(logsDir);
-  const candidates = await Promise.all(
-    entries.filter((file) => file.startsWith(namespace) && file.endsWith(".json")).map(async (file) => {
-      const fullPath = path2.join(logsDir, file);
-      const stat = await promises.stat(fullPath);
-      return { path: fullPath, mtime: stat.mtimeMs };
-    })
-  );
-  if (candidates.length === 0) {
-    return null;
-  }
-  candidates.sort((a, b) => b.mtime - a.mtime);
-  return candidates[0]?.path ?? null;
-}
-async function readJournalEntries(logPath) {
-  const content = await promises.readFile(logPath, "utf8");
-  const parsed = JSON.parse(content);
-  if (!Array.isArray(parsed)) {
-    throw new Error("\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442 \u043B\u043E\u0433\u0430 setup.");
-  }
-  return parsed;
-}
-async function applyRollback(entries, cwd, output, logger) {
-  logger?.info("Applying rollback operations", { entriesCount: entries.length });
-  for (const entry of [...entries].reverse()) {
-    const operation = entry.operation?.operation;
-    if (!operation) {
-      continue;
-    }
-    switch (operation.kind) {
-      case "file":
-      case "config":
-      case "script":
-        await restoreFileLikeOperation(entry, cwd, output, logger);
-        break;
-      default:
-        logger?.warn("Skipping operation (rollback not implemented)", { kind: operation.kind });
-        output?.warn?.(
-          `\u041F\u0440\u043E\u043F\u0443\u0441\u043A \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0438 ${operation.kind} (\u043E\u0442\u043A\u0430\u0442 \u043D\u0435 \u0440\u0435\u0430\u043B\u0438\u0437\u043E\u0432\u0430\u043D).`
-        );
-    }
-  }
-}
-async function restoreFileLikeOperation(entry, cwd, output, logger) {
-  const operation = entry.operation.operation;
-  const relativePath = operation.kind === "script" ? operation.file : operation.path;
-  const targetPath = resolveWithinWorkspace(cwd, relativePath);
-  if (entry.backupPath) {
-    await copyBackup(entry.backupPath, targetPath, output, logger);
-    return;
-  }
-  if (entry.before?.exists === false) {
-    await promises.rm(targetPath, { force: true, recursive: false });
-    logger?.info("File removed during rollback", { path: targetPath });
-    output?.info?.(`\u2212 \u0423\u0434\u0430\u043B\u0451\u043D ${path2.relative(cwd, targetPath)}`);
-    return;
-  }
-  if (typeof entry.before?.content === "string") {
-    if (entry.before.content.startsWith("<truncated")) {
-      logger?.warn("Skipping truncated file", { path: targetPath });
-      output?.warn?.(
-        `\u041F\u0440\u043E\u043F\u0443\u0441\u043A ${path2.relative(cwd, targetPath)} \u2014 \u0441\u043E\u0434\u0435\u0440\u0436\u0438\u043C\u043E\u0435 \u043B\u043E\u0433\u0430 \u0443\u0441\u0435\u0447\u0435\u043D\u043E.`
-      );
-      return;
-    }
-    await promises.mkdir(path2.dirname(targetPath), { recursive: true });
-    await promises.writeFile(targetPath, entry.before.content, "utf8");
-    logger?.info("File restored from log", { path: targetPath });
-    output?.info?.(`\u21BA \u0412\u043E\u0441\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D ${path2.relative(cwd, targetPath)}`);
-    return;
-  }
-  logger?.warn("Skipping file (no restore data)", { path: targetPath });
-  output?.warn?.(
-    `\u041F\u0440\u043E\u043F\u0443\u0441\u043A ${path2.relative(cwd, targetPath)} \u2014 \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u044E\u0442 \u0434\u0430\u043D\u043D\u044B\u0435 \u0434\u043B\u044F \u0432\u043E\u0441\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u044F.`
-  );
-}
-function resolveWithinWorkspace(workspace, target) {
-  const resolvedWorkspace = path2.resolve(workspace);
-  const resolvedTarget = path2.resolve(resolvedWorkspace, target);
-  if (!resolvedTarget.startsWith(resolvedWorkspace)) {
-    throw new Error(`\u041F\u0443\u0442\u044C ${target} \u0432\u044B\u0445\u043E\u0434\u0438\u0442 \u0437\u0430 \u043F\u0440\u0435\u0434\u0435\u043B\u044B \u0440\u0430\u0431\u043E\u0447\u0435\u0439 \u0434\u0438\u0440\u0435\u043A\u0442\u043E\u0440\u0438\u0438.`);
-  }
-  return resolvedTarget;
-}
-async function copyBackup(backupPath, destination, output, logger) {
-  try {
-    await promises.access(backupPath);
-  } catch {
-    logger?.warn("Backup not found", { backupPath });
-    output?.warn?.(`\u041F\u0440\u043E\u043F\u0443\u0441\u043A \u2014 backup ${backupPath} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D.`);
-    return;
-  }
-  await promises.mkdir(path2.dirname(destination), { recursive: true });
-  await promises.copyFile(backupPath, destination);
-  logger?.info("File restored from backup", { backupPath, destination });
-  output?.info?.(`\u21BA \u0412\u043E\u0441\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D \u0438\u0437 backup ${path2.basename(destination)}`);
-}
-var ROLLBACK_COMMAND_FLAGS;
-var init_plugin_setup_rollback = __esm({
-  "src/commands/system/plugin-setup-rollback.ts"() {
-    ROLLBACK_COMMAND_FLAGS = [
-      {
-        name: "log",
-        type: "string",
-        description: "Path to a setup change log JSON file. Defaults to latest log for the namespace."
-      },
-      {
-        name: "list",
-        type: "boolean",
-        description: "List available setup change logs and exit."
-      },
-      {
-        name: "yes",
-        type: "boolean",
-        alias: "y",
-        description: "Apply rollback without confirmation prompt."
-      }
-    ];
-  }
-});
-
 // src/registry/discover.ts
 var discover_exports = {};
 __export(discover_exports, {
@@ -394,41 +175,9 @@ function createManifestV3Loader(commandId) {
     );
   };
 }
-async function loadSetupRollbackCommandModule({
-  manifestV2,
-  namespace,
-  pkgName,
-  pkgRoot
-}) {
-  const module = await Promise.resolve().then(() => (init_plugin_setup_rollback(), plugin_setup_rollback_exports));
-  if (typeof module.createPluginSetupRollbackCommand !== "function") {
-    throw new Error("Failed to load plugin setup rollback command factory");
-  }
-  const command = module.createPluginSetupRollbackCommand({
-    namespace,
-    packageName: pkgName,
-    pkgRoot
-  });
-  return {
-    run: async (ctx, argv, flags) => {
-      const result = await command.run(ctx, argv, flags);
-      return typeof result === "number" ? result : void 0;
-    }
-  };
-}
 function ensureManifestLoader(manifest) {
   if (typeof manifest.loader !== "function") {
     const commandId = manifest.id || manifest.group || "unknown";
-    if (manifest.isSetupRollback) {
-      log("debug", `[plugins][cache] Rehydrated setup rollback loader for ${commandId}`);
-      manifest.loader = () => loadSetupRollbackCommandModule({
-        manifestV2: manifest.manifestV2,
-        namespace: manifest.namespace || manifest.group || deriveNamespace(manifest.package || commandId),
-        pkgName: manifest.package || commandId,
-        pkgRoot: manifest.pkgRoot
-      });
-      return;
-    }
     log("debug", `[plugins][cache] Rehydrated loader for ${commandId}`);
     manifest.loader = createManifestV3Loader(commandId);
   }
@@ -468,7 +217,7 @@ async function computeManifestHash(manifestPath) {
   }
 }
 async function computeLockfileHash(cwd) {
-  const lockfilePath = path2.join(cwd, "pnpm-lock.yaml");
+  const lockfilePath = path.join(cwd, "pnpm-lock.yaml");
   try {
     const content = await promises.readFile(lockfilePath, "utf8");
     return createHash("sha256").update(content).digest("hex");
@@ -477,7 +226,7 @@ async function computeLockfileHash(cwd) {
   }
 }
 async function computeConfigHash(cwd) {
-  const configPath = path2.join(cwd, ".kb", "kb.config.json");
+  const configPath = path.join(cwd, ".kb", "kb.config.json");
   try {
     const content = await promises.readFile(configPath, "utf8");
     return createHash("sha256").update(content).digest("hex");
@@ -486,7 +235,7 @@ async function computeConfigHash(cwd) {
   }
 }
 async function computePluginsStateHash(cwd) {
-  const pluginsPath = path2.join(cwd, ".kb", "plugins.json");
+  const pluginsPath = path.join(cwd, ".kb", "plugins.json");
   try {
     const content = await promises.readFile(pluginsPath, "utf8");
     return createHash("sha256").update(content).digest("hex");
@@ -499,7 +248,7 @@ async function detectNewWorkspacePackages(cwd, cachedPackages) {
     return true;
   }
   try {
-    const workspaceYaml = path2.join(cwd, "pnpm-workspace.yaml");
+    const workspaceYaml = path.join(cwd, "pnpm-workspace.yaml");
     const content = await promises.readFile(workspaceYaml, "utf8");
     const parsed = parse(content);
     if (!Array.isArray(parsed.packages)) {
@@ -507,15 +256,15 @@ async function detectNewWorkspacePackages(cwd, cachedPackages) {
     }
     const knownPackages = new Set(Object.keys(cachedPackages));
     for (const pattern of parsed.packages) {
-      const pkgPattern = path2.join(pattern, PACKAGE_JSON);
+      const pkgPattern = path.join(pattern, PACKAGE_JSON);
       const pkgFiles = await glob(pkgPattern, {
         cwd,
         absolute: false,
         ignore: [".kb/**", "node_modules/**", "**/node_modules/**"]
       });
       for (const pkgFile of pkgFiles) {
-        const pkgRoot = path2.dirname(path2.join(cwd, pkgFile));
-        const pkg = await readPackageJson(path2.join(cwd, pkgFile));
+        const pkgRoot = path.dirname(path.join(cwd, pkgFile));
+        const pkg = await readPackageJson(path.join(cwd, pkgFile));
         if (!pkg || !pkg.name) {
           continue;
         }
@@ -558,11 +307,6 @@ function getNamespaceFromManifest(manifestV2, packageName) {
   const last = parts[parts.length - 1] || packageName;
   return last.replace(/^@/, "");
 }
-function deriveNamespace(packageName) {
-  const parts = packageName.split("/");
-  const lastPart = parts[parts.length - 1] || packageName;
-  return lastPart.replace(/^@/, "");
-}
 async function loadManifest(manifestPath, pkgName, pkgRoot) {
   const fileUrl = pathToFileURL(manifestPath).href;
   const mod = await import(fileUrl);
@@ -571,7 +315,7 @@ async function loadManifest(manifestPath, pkgName, pkgRoot) {
     throw new Error(`Unsupported manifest format in ${pkgName}. Only kb.plugin/3 schema is supported.`);
   }
   const namespace = getNamespaceFromManifest(manifest, pkgName);
-  const manifestDir = path2.dirname(manifestPath);
+  const manifestDir = path.dirname(manifestPath);
   const baseRoot = pkgRoot || manifestDir;
   const cliCommands = Array.isArray(manifest.cli?.commands) ? manifest.cli.commands : [];
   if (cliCommands.length === 0 && !manifest.setup) {
@@ -616,7 +360,7 @@ async function readPackageJson(pkgPath) {
   }
 }
 async function loadConfig(cwd) {
-  const configPath = path2.join(cwd, ".kb", "kb.config.json");
+  const configPath = path.join(cwd, ".kb", "kb.config.json");
   try {
     const content = await promises.readFile(configPath, "utf8");
     const config = JSON.parse(content);
@@ -631,7 +375,7 @@ async function loadConfig(cwd) {
 }
 async function findManifestPath(pkgRoot, pkg) {
   if (pkg.kb?.manifest) {
-    const manifestPath = path2.join(pkgRoot, pkg.kb.manifest);
+    const manifestPath = path.join(pkgRoot, pkg.kb.manifest);
     try {
       await promises.access(manifestPath);
       return { path: manifestPath, deprecated: false };
@@ -643,7 +387,7 @@ async function findManifestPath(pkgRoot, pkg) {
     const exportPath = pkg.exports["./kb/commands"];
     const manifestPath = typeof exportPath === "string" ? exportPath : exportPath.default || exportPath.import;
     if (manifestPath) {
-      const resolved = path2.resolve(pkgRoot, manifestPath);
+      const resolved = path.resolve(pkgRoot, manifestPath);
       try {
         await promises.access(resolved);
         return { path: resolved, deprecated: false };
@@ -688,7 +432,7 @@ function validateUniqueIds(manifests, pkgName) {
   }
 }
 async function discoverWorkspace(cwd) {
-  const workspaceYaml = path2.join(cwd, "pnpm-workspace.yaml");
+  const workspaceYaml = path.join(cwd, "pnpm-workspace.yaml");
   const content = await promises.readFile(workspaceYaml, "utf8");
   const parsed = parse(content);
   if (!parsed.packages || !Array.isArray(parsed.packages)) {
@@ -696,7 +440,7 @@ async function discoverWorkspace(cwd) {
   }
   const packageInfos = [];
   for (const pattern of parsed.packages) {
-    const pkgPattern = path2.join(pattern, PACKAGE_JSON);
+    const pkgPattern = path.join(pattern, PACKAGE_JSON);
     const pkgFiles = await glob(pkgPattern, {
       cwd,
       absolute: false,
@@ -704,8 +448,8 @@ async function discoverWorkspace(cwd) {
       // Ignore .kb, node_modules
     });
     for (const pkgFile of pkgFiles) {
-      const pkgRoot = path2.dirname(path2.join(cwd, pkgFile));
-      const pkg = await readPackageJson(path2.join(cwd, pkgFile));
+      const pkgRoot = path.dirname(path.join(cwd, pkgFile));
+      const pkg = await readPackageJson(path.join(cwd, pkgFile));
       if (!pkg) {
         continue;
       }
@@ -770,7 +514,7 @@ async function discoverWorkspace(cwd) {
 }
 async function discoverCurrentPackage(cwd) {
   try {
-    const pkg = await readPackageJson(path2.join(cwd, PACKAGE_JSON));
+    const pkg = await readPackageJson(path.join(cwd, PACKAGE_JSON));
     if (!pkg) {
       return null;
     }
@@ -798,7 +542,7 @@ async function discoverCurrentPackage(cwd) {
   return null;
 }
 async function discoverNodeModules(cwd) {
-  const nmDir = path2.join(cwd, "node_modules");
+  const nmDir = path.join(cwd, "node_modules");
   const config = await loadConfig(cwd);
   try {
     const entries = await promises.readdir(nmDir, { withFileTypes: true });
@@ -812,12 +556,12 @@ async function discoverNodeModules(cwd) {
         let pkgRoot;
         let pkg;
         if (entry.name.startsWith("@")) {
-          const scopeDir = path2.join(nmDir, entry.name);
+          const scopeDir = path.join(nmDir, entry.name);
           try {
             const scopedDirs = await promises.readdir(scopeDir, { withFileTypes: true });
             for (const scopedEntry of scopedDirs.filter((d) => d.isDirectory())) {
-              pkgRoot = path2.join(scopeDir, scopedEntry.name);
-              pkg = await readPackageJson(path2.join(pkgRoot, PACKAGE_JSON));
+              pkgRoot = path.join(scopeDir, scopedEntry.name);
+              pkg = await readPackageJson(path.join(pkgRoot, PACKAGE_JSON));
               if (!pkg) {
                 continue;
               }
@@ -851,8 +595,8 @@ async function discoverNodeModules(cwd) {
           } catch {
           }
         } else {
-          pkgRoot = path2.join(nmDir, entry.name);
-          pkg = await readPackageJson(path2.join(pkgRoot, PACKAGE_JSON));
+          pkgRoot = path.join(nmDir, entry.name);
+          pkg = await readPackageJson(path.join(pkgRoot, PACKAGE_JSON));
           if (!pkg) {
             return;
           }
@@ -951,7 +695,7 @@ function deduplicateManifests(all) {
   return Array.from(byPackageName.values());
 }
 async function loadCache(cwd) {
-  const cachePath = path2.join(cwd, ".kb", "cache", "cli-manifests.json");
+  const cachePath = path.join(cwd, ".kb", "cache", "cli-manifests.json");
   try {
     const content = await promises.readFile(cachePath, "utf8");
     const cache = JSON.parse(content);
@@ -1001,8 +745,8 @@ async function loadCache(cwd) {
   }
 }
 async function isPackageCacheStale(entry, options) {
-  const manifestFsPath = entry.manifestPath.split("/").join(path2.sep);
-  const pkgJsonPath = path2.join(entry.result.pkgRoot.split("/").join(path2.sep), PACKAGE_JSON);
+  const manifestFsPath = entry.manifestPath.split("/").join(path.sep);
+  const pkgJsonPath = path.join(entry.result.pkgRoot.split("/").join(path.sep), PACKAGE_JSON);
   try {
     const pkgStat = await promises.stat(pkgJsonPath);
     if (pkgStat.mtimeMs !== entry.pkgJsonMtime) {
@@ -1039,19 +783,19 @@ async function isPackageCacheStale(entry, options) {
   return false;
 }
 async function saveCache(cwd, results) {
-  const cachePath = path2.join(cwd, ".kb", "cache", "cli-manifests.json");
-  await promises.mkdir(path2.dirname(cachePath), { recursive: true });
+  const cachePath = path.join(cwd, ".kb", "cache", "cli-manifests.json");
+  await promises.mkdir(path.dirname(cachePath), { recursive: true });
   const packages = {};
   const now = Date.now();
   const stateHasher = createHash("sha256");
   for (const result of results) {
     try {
       const manifestHash = await computeManifestHash(result.manifestPath);
-      const pkgJsonPath = path2.join(result.pkgRoot.split("/").join(path2.sep), PACKAGE_JSON);
+      const pkgJsonPath = path.join(result.pkgRoot.split("/").join(path.sep), PACKAGE_JSON);
       const pkgStat = await promises.stat(pkgJsonPath);
       const pkg = await readPackageJson(pkgJsonPath);
       const version2 = pkg?.version || "0.1.0";
-      const manifestStat = await promises.stat(result.manifestPath.split("/").join(path2.sep));
+      const manifestStat = await promises.stat(result.manifestPath.split("/").join(path.sep));
       const manifestsForCache = result.manifests.map((manifest) => {
         const manifestCopy = { ...manifest };
         delete manifestCopy.loader;
@@ -1255,7 +999,7 @@ __export(plugins_state_exports, {
   unlinkPlugin: () => unlinkPlugin
 });
 function getPluginsStatePath(cwd) {
-  return path2.join(cwd, ".kb", "plugins.json");
+  return path.join(cwd, ".kb", "plugins.json");
 }
 async function loadPluginsState(cwd) {
   const statePath = getPluginsStatePath(cwd);
@@ -1278,7 +1022,7 @@ async function loadPluginsState(cwd) {
 }
 async function savePluginsState(cwd, state) {
   const statePath = getPluginsStatePath(cwd);
-  const dir = path2.dirname(statePath);
+  const dir = path.dirname(statePath);
   await promises.mkdir(dir, { recursive: true });
   state.lastUpdated = Date.now();
   await promises.writeFile(statePath, JSON.stringify(state, null, 2), "utf8");
@@ -1310,7 +1054,7 @@ async function disablePlugin(cwd, packageName) {
 }
 async function linkPlugin(cwd, pluginPath) {
   const state = await loadPluginsState(cwd);
-  const absPath = path2.resolve(cwd, pluginPath);
+  const absPath = path.resolve(cwd, pluginPath);
   if (!state.linked.includes(absPath)) {
     state.linked.push(absPath);
   }
@@ -1318,7 +1062,7 @@ async function linkPlugin(cwd, pluginPath) {
 }
 async function unlinkPlugin(cwd, pluginPath) {
   const state = await loadPluginsState(cwd);
-  const absPath = path2.resolve(cwd, pluginPath);
+  const absPath = path.resolve(cwd, pluginPath);
   state.linked = state.linked.filter((p) => p !== absPath);
   await savePluginsState(cwd, state);
 }
@@ -1345,7 +1089,7 @@ async function recordCrash(cwd, packageName) {
 }
 async function computePackageIntegrity(pkgRoot) {
   try {
-    const pkgJsonPath = path2.join(pkgRoot, "package.json");
+    const pkgJsonPath = path.join(pkgRoot, "package.json");
     const content = await promises.readFile(pkgJsonPath, "utf8");
     const hash = createHash("sha256").update(content).digest("base64");
     return `sha256-${hash}`;
@@ -1355,12 +1099,12 @@ async function computePackageIntegrity(pkgRoot) {
 }
 async function clearCache(cwd, options) {
   const cleared = [];
-  const cacheDir = path2.join(cwd, ".kb", "cache");
+  const cacheDir = path.join(cwd, ".kb", "cache");
   try {
     const entries = await promises.readdir(cacheDir);
     for (const entry of entries) {
       if (entry.includes("manifest") || entry.includes("plugin")) {
-        const entryPath = path2.join(cacheDir, entry);
+        const entryPath = path.join(cacheDir, entry);
         await promises.unlink(entryPath);
         cleared.push(entry);
       }
@@ -1925,7 +1669,7 @@ var diag = defineSystemCommand({
       });
     }
     try {
-      const cachePath = path2.join(cwd, ".kb", "cache", "cli-manifests.json");
+      const cachePath = path.join(cwd, ".kb", "cache", "cli-manifests.json");
       const cacheExists = await promises.access(cachePath).then(() => true).catch(() => false);
       if (cacheExists) {
         const cache = JSON.parse(await promises.readFile(cachePath, "utf8"));
@@ -2135,7 +1879,7 @@ var pluginsList = defineSystemCommand({
         let version2 = "unknown";
         if (cmd.pkgRoot) {
           try {
-            const pkgPath = path2.join(cmd.pkgRoot, "package.json");
+            const pkgPath = path.join(cmd.pkgRoot, "package.json");
             const pkgJson = JSON.parse(await promises.readFile(pkgPath, "utf8"));
             version2 = pkgJson.version || "unknown";
           } catch {
@@ -2143,22 +1887,22 @@ var pluginsList = defineSystemCommand({
         }
         if (version2 === "unknown") {
           try {
-            const pkgPath = path2.join(cwd, "node_modules", pkgName, "package.json");
+            const pkgPath = path.join(cwd, "node_modules", pkgName, "package.json");
             const pkgJson = JSON.parse(await promises.readFile(pkgPath, "utf8"));
             version2 = pkgJson.version || "unknown";
           } catch {
             try {
-              const pkgPath = path2.join(cwd, "packages", namespace.replace("@kb-labs/", "").replace("-cli", ""), "package.json");
+              const pkgPath = path.join(cwd, "packages", namespace.replace("@kb-labs/", "").replace("-cli", ""), "package.json");
               const pkgJson = JSON.parse(await promises.readFile(pkgPath, "utf8"));
               version2 = pkgJson.version || "unknown";
             } catch {
               try {
-                const workspaceRoot = path2.resolve(cwd, "..");
-                const pkgDirs = await promises.readdir(path2.join(workspaceRoot, "packages"), { withFileTypes: true });
+                const workspaceRoot = path.resolve(cwd, "..");
+                const pkgDirs = await promises.readdir(path.join(workspaceRoot, "packages"), { withFileTypes: true });
                 for (const dir of pkgDirs) {
                   if (dir.isDirectory()) {
                     try {
-                      const pkgPath = path2.join(workspaceRoot, "packages", dir.name, "package.json");
+                      const pkgPath = path.join(workspaceRoot, "packages", dir.name, "package.json");
                       const pkgJson = JSON.parse(await promises.readFile(pkgPath, "utf8"));
                       if (pkgJson.name === pkgName) {
                         version2 = pkgJson.version || "unknown";
@@ -2600,9 +2344,9 @@ var pluginsLink = defineSystemCommand({
       throw new Error("Please specify a plugin path to link");
     }
     const cwd = getContextCwd(ctx);
-    const absPath = path2.resolve(cwd, pluginPath);
+    const absPath = path.resolve(cwd, pluginPath);
     ctx.platform?.logger?.info("Linking plugin", { pluginPath, absPath });
-    const pkgJsonPath = path2.join(absPath, "package.json");
+    const pkgJsonPath = path.join(absPath, "package.json");
     await promises.access(pkgJsonPath);
     const pkgJson = JSON.parse(await promises.readFile(pkgJsonPath, "utf8"));
     const hasManifest = pkgJson.kb?.commandsManifest || pkgJson.exports?.["./kb/commands"];
@@ -2613,7 +2357,7 @@ var pluginsLink = defineSystemCommand({
     ctx.platform?.logger?.info("Plugin linked", { packageName: pkgJson.name, absPath });
     let configUpdated = false;
     try {
-      const configPath = path2.join(cwd, ".kb", "kb.config.json");
+      const configPath = path.join(cwd, ".kb", "kb.config.json");
       const config = JSON.parse(await promises.readFile(configPath, "utf8"));
       if (!config.plugins) {
         config.plugins = {};
@@ -2679,7 +2423,7 @@ var pluginsUnlink = defineSystemCommand({
     ctx.platform?.logger?.info("Unlinking plugin", { identifier });
     let absPath;
     try {
-      absPath = path2.resolve(cwd, identifier);
+      absPath = path.resolve(cwd, identifier);
       await promises.access(absPath);
     } catch {
       const matched = state.linked.find((p) => p.includes(identifier) || p.endsWith(identifier));
@@ -2709,12 +2453,12 @@ var pluginsUnlink = defineSystemCommand({
   }
 });
 function detectRepoRoot(start = process.cwd()) {
-  let cur = path2.resolve(start);
+  let cur = path.resolve(start);
   while (true) {
-    if (existsSync(path2.join(cur, ".git"))) {
+    if (existsSync(path.join(cur, ".git"))) {
       return cur;
     }
-    const parent = path2.dirname(cur);
+    const parent = path.dirname(cur);
     if (parent === cur) {
       return start;
     }
@@ -2723,7 +2467,7 @@ function detectRepoRoot(start = process.cwd()) {
 }
 async function findRestApiManifestPath(pkgRoot, pkg) {
   if (pkg.kbLabs?.manifest) {
-    const manifestPath = path2.isAbsolute(pkg.kbLabs.manifest) ? pkg.kbLabs.manifest : path2.join(pkgRoot, pkg.kbLabs.manifest);
+    const manifestPath = path.isAbsolute(pkg.kbLabs.manifest) ? pkg.kbLabs.manifest : path.join(pkgRoot, pkg.kbLabs.manifest);
     try {
       await promises.access(manifestPath);
       return manifestPath;
@@ -2732,7 +2476,7 @@ async function findRestApiManifestPath(pkgRoot, pkg) {
     }
   }
   if (pkg.kb?.manifest) {
-    const manifestPath = path2.isAbsolute(pkg.kb.manifest) ? pkg.kb.manifest : path2.join(pkgRoot, pkg.kb.manifest);
+    const manifestPath = path.isAbsolute(pkg.kb.manifest) ? pkg.kb.manifest : path.join(pkgRoot, pkg.kb.manifest);
     try {
       await promises.access(manifestPath);
       return manifestPath;
@@ -2742,7 +2486,7 @@ async function findRestApiManifestPath(pkgRoot, pkg) {
   }
   if (Array.isArray(pkg.kbLabs?.plugins)) {
     for (const pluginPath of pkg.kbLabs.plugins) {
-      const manifestPath = path2.isAbsolute(pluginPath) ? pluginPath : path2.join(pkgRoot, pluginPath);
+      const manifestPath = path.isAbsolute(pluginPath) ? pluginPath : path.join(pkgRoot, pluginPath);
       try {
         await promises.access(manifestPath);
         return manifestPath;
@@ -2753,7 +2497,7 @@ async function findRestApiManifestPath(pkgRoot, pkg) {
   }
   if (Array.isArray(pkg.kb?.plugins)) {
     for (const pluginPath of pkg.kb.plugins) {
-      const manifestPath = path2.isAbsolute(pluginPath) ? pluginPath : path2.join(pkgRoot, pluginPath);
+      const manifestPath = path.isAbsolute(pluginPath) ? pluginPath : path.join(pkgRoot, pluginPath);
       try {
         await promises.access(manifestPath);
         return manifestPath;
@@ -2762,22 +2506,22 @@ async function findRestApiManifestPath(pkgRoot, pkg) {
       }
     }
   }
-  const pluginsDir = path2.join(pkgRoot, ".kblabs", "plugins");
+  const pluginsDir = path.join(pkgRoot, ".kblabs", "plugins");
   try {
     const entries = await promises.readdir(pluginsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
-        return path2.join(pluginsDir, entry.name);
+        return path.join(pluginsDir, entry.name);
       }
     }
   } catch {
   }
   const conventionalPaths = [
-    path2.join(pkgRoot, "dist", "manifest.v2.js"),
-    path2.join(pkgRoot, "dist", "manifest.v2.ts"),
-    path2.join(pkgRoot, "src", "manifest.v2.ts"),
-    path2.join(pkgRoot, "manifest.v2.ts"),
-    path2.join(pkgRoot, "manifest.v2.js")
+    path.join(pkgRoot, "dist", "manifest.v2.js"),
+    path.join(pkgRoot, "dist", "manifest.v2.ts"),
+    path.join(pkgRoot, "src", "manifest.v2.ts"),
+    path.join(pkgRoot, "manifest.v2.ts"),
+    path.join(pkgRoot, "manifest.v2.js")
   ];
   for (const manifestPath of conventionalPaths) {
     try {
@@ -2791,7 +2535,7 @@ async function findRestApiManifestPath(pkgRoot, pkg) {
 }
 async function discoverRestApiPlugins(repoRoot) {
   const results = [];
-  const workspaceYaml = path2.join(repoRoot, "pnpm-workspace.yaml");
+  const workspaceYaml = path.join(repoRoot, "pnpm-workspace.yaml");
   let workspacePatterns = [];
   try {
     const content = await promises.readFile(workspaceYaml, "utf8");
@@ -2803,19 +2547,19 @@ async function discoverRestApiPlugins(repoRoot) {
   if (workspacePatterns.length === 0) {
     let currentDir = repoRoot;
     for (let i = 0; i < 3; i++) {
-      const parentYaml = path2.join(path2.dirname(currentDir), "pnpm-workspace.yaml");
+      const parentYaml = path.join(path.dirname(currentDir), "pnpm-workspace.yaml");
       try {
         const content = await promises.readFile(parentYaml, "utf8");
         const parsed = parse(content);
         if (parsed.packages && parsed.packages.length > 0) {
           workspacePatterns = parsed.packages;
-          repoRoot = path2.dirname(currentDir);
+          repoRoot = path.dirname(currentDir);
           break;
         }
       } catch {
       }
-      currentDir = path2.dirname(currentDir);
-      if (currentDir === path2.dirname(currentDir)) {
+      currentDir = path.dirname(currentDir);
+      if (currentDir === path.dirname(currentDir)) {
         break;
       }
     }
@@ -2835,7 +2579,7 @@ async function discoverRestApiPlugins(repoRoot) {
   }
   const uniquePaths = Array.from(new Set(packageJsonPaths));
   for (const pkgJsonPath of uniquePaths) {
-    const pkgRoot = path2.dirname(pkgJsonPath);
+    const pkgRoot = path.dirname(pkgJsonPath);
     try {
       const pkgContent = await promises.readFile(pkgJsonPath, "utf8");
       const pkg = JSON.parse(pkgContent);
@@ -2850,7 +2594,7 @@ async function discoverRestApiPlugins(repoRoot) {
           const manifestV2 = manifest;
           results.push({
             manifest: manifestV2,
-            manifestPath: path2.resolve(manifestPath),
+            manifestPath: path.resolve(manifestPath),
             pluginRoot: pkgRoot
           });
         }
@@ -3041,7 +2785,7 @@ var pluginsDoctor = defineSystemCommand({
       }
       if (cmd.manifest.engine?.module) {
         const required = cmd.manifest.engine.module;
-        const pkgJsonPath = path2.join(cmd.pkgRoot || cwd, "package.json");
+        const pkgJsonPath = path.join(cmd.pkgRoot || cwd, "package.json");
         try {
           const pkgJson = JSON.parse(await promises.readFile(pkgJsonPath, "utf8"));
           const isESM = pkgJson.type === "module";
@@ -3189,7 +2933,7 @@ var pluginsScaffold = defineSystemCommand({
     const moduleType = isESM ? "module" : "commonjs";
     const tsupFormat = isESM ? "esm" : "cjs";
     const baseDir = getContextCwd(ctx);
-    const dir = path2.join(baseDir, pluginName);
+    const dir = path.join(baseDir, pluginName);
     try {
       await promises.access(dir);
       ctx.platform?.logger?.warn("Directory already exists", { dir });
@@ -3200,9 +2944,9 @@ var pluginsScaffold = defineSystemCommand({
       }
     }
     await promises.mkdir(dir, { recursive: true });
-    await promises.mkdir(path2.join(dir, "src"), { recursive: true });
-    await promises.mkdir(path2.join(dir, "src", "kb"), { recursive: true });
-    await promises.mkdir(path2.join(dir, "src", "commands"), { recursive: true });
+    await promises.mkdir(path.join(dir, "src"), { recursive: true });
+    await promises.mkdir(path.join(dir, "src", "kb"), { recursive: true });
+    await promises.mkdir(path.join(dir, "src", "commands"), { recursive: true });
     const packageJson = {
       name: `@your-scope/${pluginName}-cli`,
       version: "1.0.0",
@@ -3232,7 +2976,7 @@ var pluginsScaffold = defineSystemCommand({
         typescript: "^5.6.3"
       }
     };
-    await promises.writeFile(path2.join(dir, "package.json"), JSON.stringify(packageJson, null, 2), "utf8");
+    await promises.writeFile(path.join(dir, "package.json"), JSON.stringify(packageJson, null, 2), "utf8");
     const tsconfig = {
       extends: "@kb-labs/devkit/tsconfig/lib.json",
       compilerOptions: {
@@ -3241,7 +2985,7 @@ var pluginsScaffold = defineSystemCommand({
       },
       include: ["src/**/*"]
     };
-    await promises.writeFile(path2.join(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2), "utf8");
+    await promises.writeFile(path.join(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2), "utf8");
     const manifestContent = `import type { ManifestV2 } from '@kb-labs/plugin-contracts';
 
 export const manifest: ManifestV2 = {
@@ -3274,7 +3018,7 @@ export const manifest: ManifestV2 = {
   }
 };
 `;
-    await promises.writeFile(path2.join(dir, "src", "kb", `manifest.${extension}`), manifestContent, "utf8");
+    await promises.writeFile(path.join(dir, "src", "kb", `manifest.${extension}`), manifestContent, "utf8");
     const commandContent = `import { defineCommand, type CommandResult } from '@kb-labs/shared-command-kit';
 
 // Define flag types for type safety
@@ -3344,7 +3088,7 @@ export const run = defineCommand<${pluginName.charAt(0).toUpperCase() + pluginNa
 // Remove both type parameters for quick prototyping:
 // export const run = defineCommand({ ... });
 `;
-    await promises.writeFile(path2.join(dir, "src", "commands", `hello.${extension}`), commandContent, "utf8");
+    await promises.writeFile(path.join(dir, "src", "commands", `hello.${extension}`), commandContent, "utf8");
     const tsupConfig = `import config from "@kb-labs/devkit/tsup/node.js";
 
 export default {
@@ -3354,7 +3098,7 @@ export default {
   dts: true,
 };
 `;
-    await promises.writeFile(path2.join(dir, "tsup.config.ts"), tsupConfig, "utf8");
+    await promises.writeFile(path.join(dir, "tsup.config.ts"), tsupConfig, "utf8");
     const readme = `# ${pluginName} CLI Plugin
 
 KB Labs CLI plugin for ${pluginName}.
@@ -3384,13 +3128,13 @@ pnpm dev
 kb plugins link ./${pluginName}
 \`\`\`
 `;
-    await promises.writeFile(path2.join(dir, "README.md"), readme, "utf8");
+    await promises.writeFile(path.join(dir, "README.md"), readme, "utf8");
     const gitignore = `node_modules
 dist
 *.log
 .DS_Store
 `;
-    await promises.writeFile(path2.join(dir, ".gitignore"), gitignore, "utf8");
+    await promises.writeFile(path.join(dir, ".gitignore"), gitignore, "utf8");
     ctx.platform?.logger?.info("Plugin scaffold created", { pluginName, dir });
     return {
       ok: true,
@@ -3423,7 +3167,7 @@ dist
 });
 async function validateManifestAgainstContracts(manifest, contractsPath) {
   try {
-    const contractsModule = await import(path2.resolve(contractsPath));
+    const contractsModule = await import(path.resolve(contractsPath));
     const contracts = contractsModule.pluginContractsManifest || contractsModule.default;
     if (!contracts) {
       return { ok: false, issues: ["Contracts file does not export pluginContractsManifest"] };
@@ -3477,7 +3221,7 @@ var pluginValidate = defineSystemCommand({
   },
   async handler(ctx, argv, flags) {
     const cwd = getContextCwd(ctx);
-    const manifestPath = path2.resolve(cwd, flags.manifest || "manifest.v2.ts");
+    const manifestPath = path.resolve(cwd, flags.manifest || "manifest.v2.ts");
     ctx.ui.write(`Validating manifest: ${manifestPath}
 `);
     let manifestContent;
@@ -3513,7 +3257,7 @@ var pluginValidate = defineSystemCommand({
     }
     ctx.ui.success("\u2705 Manifest structure is valid!\n");
     if (flags.contracts) {
-      const contractsPath = path2.resolve(cwd, flags.contracts);
+      const contractsPath = path.resolve(cwd, flags.contracts);
       ctx.ui.write(`
 Validating against contracts: ${contractsPath}
 `);
@@ -3630,7 +3374,7 @@ var docsGenerateCliReference = defineSystemCommand({
   // eslint-disable-next-line sonarjs/cognitive-complexity -- Complex markdown generation with nested loops for product groups, commands, and formatting
   async handler(ctx, argv, flags) {
     const cwd = getContextCwd(ctx);
-    const outputPath = flags.output || path2.join(cwd, "CLI-REFERENCE.md");
+    const outputPath = flags.output || path.join(cwd, "CLI-REFERENCE.md");
     const commands = registry.list();
     const productGroups = registry.listProductGroups();
     ctx.platform?.logger?.info("Generating CLI reference", {
@@ -4657,15 +4401,15 @@ var logsGroup = defineSystemCommandGroup("logs", "Log viewing and analysis comma
 ]);
 var req = createRequire(import.meta.url);
 var __filename$1 = fileURLToPath(import.meta.url);
-var __dirname$1 = path2.dirname(__filename$1);
+var __dirname$1 = path.dirname(__filename$1);
 function resolveFromCwd(spec, cwd) {
-  const cliRoot = path2.resolve(__dirname$1, "../../..");
+  const cliRoot = path.resolve(__dirname$1, "../../..");
   let monorepoRoot = cwd;
-  while (monorepoRoot !== path2.dirname(monorepoRoot)) {
-    if (existsSync(path2.join(monorepoRoot, "pnpm-workspace.yaml"))) {
+  while (monorepoRoot !== path.dirname(monorepoRoot)) {
+    if (existsSync(path.join(monorepoRoot, "pnpm-workspace.yaml"))) {
       break;
     }
-    monorepoRoot = path2.dirname(monorepoRoot);
+    monorepoRoot = path.dirname(monorepoRoot);
   }
   const pathsToTry = [
     cwd,
@@ -4674,9 +4418,9 @@ function resolveFromCwd(spec, cwd) {
     // CLI installation directory
     monorepoRoot,
     // Monorepo root (if found)
-    path2.join(monorepoRoot, "../kb-labs-cli"),
+    path.join(monorepoRoot, "../kb-labs-cli"),
     // Explicit kb-labs-cli path
-    path2.join(monorepoRoot, "../kb-labs-mind")
+    path.join(monorepoRoot, "../kb-labs-mind")
     // Explicit kb-labs-mind path
   ].filter(Boolean);
   for (const searchPath of pathsToTry) {
@@ -4694,12 +4438,12 @@ function checkRequires(manifest, options = {}) {
   }
   let isInMonorepo = false;
   let monorepoRoot = cwd;
-  while (monorepoRoot !== path2.dirname(monorepoRoot)) {
-    if (existsSync(path2.join(monorepoRoot, "pnpm-workspace.yaml"))) {
+  while (monorepoRoot !== path.dirname(monorepoRoot)) {
+    if (existsSync(path.join(monorepoRoot, "pnpm-workspace.yaml"))) {
       isInMonorepo = true;
       break;
     }
-    monorepoRoot = path2.dirname(monorepoRoot);
+    monorepoRoot = path.dirname(monorepoRoot);
   }
   for (const dep of manifest.requires) {
     try {
@@ -4723,8 +4467,8 @@ function checkRequires(manifest, options = {}) {
         if (!packageName) {
           continue;
         }
-        const cliRoot = path2.resolve(__dirname$1, "../../..");
-        const packagePath = scope ? path2.join(cliRoot, "node_modules", "@" + scope, packageName, "package.json") : path2.join(cliRoot, "node_modules", packageName, "package.json");
+        const cliRoot = path.resolve(__dirname$1, "../../..");
+        const packagePath = scope ? path.join(cliRoot, "node_modules", "@" + scope, packageName, "package.json") : path.join(cliRoot, "node_modules", packageName, "package.json");
         if (existsSync(packagePath)) {
           continue;
         }