@agentforge/cli 0.16.64 → 0.16.66

package/dist/index.js

@@ -1210,123 +1210,27 @@ async function toolTestCommand(name, options) {
     return exitWithCommandError(error, { spinnerFailureText: "Tests failed" });
   }
 }
-async function toolPublishCommand(name, options) {
-  try {
-    logger.header("\u{1F4E6} Publish Tool");
-    logger.info(`Tool: ${chalk4.cyan(name)}`);
-    logger.info(`Tag: ${chalk4.cyan(options.tag || "latest")}`);
-    logger.info(`Dry run: ${options.dryRun ? "Yes" : "No"}`);
-    logger.newLine();
-    if (options.dryRun) {
-      logger.warn("Dry run mode - no actual publishing will occur");
-      logger.newLine();
-    }
-    const { toolPath, hasTestScript, hasBuildScript } = await resolveToolPath(name);
-    const packageManager = await detectPackageManager(toolPath);
-    if (hasTestScript) {
-      logger.startSpinner("Running tests...");
-      try {
-        await runScript(toolPath, "test", packageManager);
-        logger.succeedSpinner("Tests passed");
-      } catch (error) {
-        return exitWithCommandError(error, {
-          spinnerFailureText: "Tests failed",
-          message: "Cannot publish tool with failing tests"
-        });
-      }
-    } else {
-      logger.info("\u26A0\uFE0F  Skipping tests (no test script found)");
-    }
-    if (hasBuildScript) {
-      logger.startSpinner("Building tool...");
-      try {
-        await runScript(toolPath, "build", packageManager);
-        logger.succeedSpinner("Build completed");
-      } catch (error) {
-        return exitWithCommandError(error, { spinnerFailureText: "Build failed" });
-      }
-    } else {
-      logger.info("\u26A0\uFE0F  Skipping build (no build script found)");
-    }
-    logger.startSpinner(options.dryRun ? "Running dry-run publish..." : "Publishing to npm...");
-    try {
-      await publishPackage(toolPath, {
-        tag: options.tag,
-        access: "public",
-        dryRun: options.dryRun
-      });
-      if (options.dryRun) {
-        logger.succeedSpinner("Dry-run completed - no actual publishing occurred");
-      } else {
-        logger.succeedSpinner("Published to npm");
-      }
-    } catch (error) {
-      const errorMessage = getErrorMessage(error);
-      logger.failSpinner("Publishing failed");
-      if (errorMessage.includes("ENEEDAUTH") || errorMessage.includes("E401")) {
-        logger.error("Not authenticated with npm");
-        logger.info("Run: npm login");
-      } else if (errorMessage.includes("E403")) {
-        logger.error("Permission denied - you may not have access to publish this package");
-        logger.info("Check package name and npm organization permissions");
-      } else if (errorMessage.includes("EPUBLISHCONFLICT") || errorMessage.includes("E409")) {
-        logger.error("Version already published");
-        logger.info("Update the version in package.json before publishing");
-      } else {
-        logger.error(errorMessage);
-      }
-      return exitWithCommandError(error, {
-        logError: false
-      });
-    }
-    logger.newLine();
-    if (options.dryRun) {
-      logger.success(chalk4.bold.green("\u2728 Dry-run completed successfully!"));
-      logger.newLine();
-      logger.info("No changes were made. Remove --dry-run to publish for real.");
-    } else {
-      logger.success(chalk4.bold.green("\u2728 Tool published successfully!"));
-      logger.newLine();
-      logger.info(`Published ${chalk4.cyan(name)} with tag ${chalk4.cyan(options.tag || "latest")}`);
-      logger.info("Users can now install with: npm install " + name);
-    }
-  } catch (error) {
-    return exitWithCommandError(error, { spinnerFailureText: "Publishing failed" });
-  }
-}
 async function resolveToolPath(name) {
   const cwd = process.cwd();
   const isScopedPackage = /^@[^/]+\/[^/]+$/.test(name);
   const isPath = !isScopedPackage && (name.includes("/") || name.includes("\\"));
   if (isPath) {
     const absolutePath = path12.isAbsolute(name) ? name : path12.resolve(cwd, name);
-    return await validateToolPath(absolutePath, name);
+    return validateToolPath(absolutePath, name);
   }
   const cwdPackageJsonPath = path12.join(cwd, "package.json");
   if (await fs.pathExists(cwdPackageJsonPath)) {
     const cwdPackageJson = await fs.readJson(cwdPackageJsonPath);
     if (cwdPackageJson.name === name || cwdPackageJson.name === `@agentforge/${name}`) {
-      return await validateToolPath(cwd, name);
+      return validateToolPath(cwd, name);
     }
   }
-  const unscopedName = isScopedPackage ? name.split("/")[1] : name;
-  const possiblePaths = [
-    path12.join(cwd, "tools", name),
-    path12.join(cwd, "packages", name),
-    path12.join(cwd, name)
-  ];
-  if (isScopedPackage) {
-    possiblePaths.push(
-      path12.join(cwd, "tools", unscopedName),
-      path12.join(cwd, "packages", unscopedName),
-      path12.join(cwd, unscopedName)
-    );
-  }
+  const possiblePaths = buildPossiblePaths(cwd, name, isScopedPackage);
   for (const possiblePath of possiblePaths) {
     if (await fs.pathExists(possiblePath)) {
       const packageJsonPath = path12.join(possiblePath, "package.json");
       if (await fs.pathExists(packageJsonPath)) {
-        return await validateToolPath(possiblePath, name);
+        return validateToolPath(possiblePath, name);
       }
     }
   }
@@ -1335,7 +1239,7 @@ async function resolveToolPath(name) {
   logger.info("Tried the following locations:");
   logger.list([
     `Current directory (${cwd})`,
-    ...possiblePaths.map((p) => path12.relative(cwd, p) || ".")
+    ...possiblePaths.map((possiblePath) => path12.relative(cwd, possiblePath) || ".")
   ]);
   logger.newLine();
   logger.info("Make sure you are either:");
@@ -1346,6 +1250,22 @@ async function resolveToolPath(name) {
   ]);
   return exitWithCommandError(`Could not find tool package: ${name}`, { logError: false });
 }
+function buildPossiblePaths(cwd, name, isScopedPackage) {
+  const possiblePaths = [
+    path12.join(cwd, "tools", name),
+    path12.join(cwd, "packages", name),
+    path12.join(cwd, name)
+  ];
+  if (isScopedPackage) {
+    const unscopedName = name.split("/")[1];
+    possiblePaths.push(
+      path12.join(cwd, "tools", unscopedName),
+      path12.join(cwd, "packages", unscopedName),
+      path12.join(cwd, unscopedName)
+    );
+  }
+  return possiblePaths;
+}
 async function validateToolPath(toolPath, expectedName) {
   if (!await fs.pathExists(toolPath)) {
     return exitWithCommandError(`Tool directory not found: ${toolPath}`);
@@ -1364,20 +1284,136 @@ async function validateToolPath(toolPath, expectedName) {
   if (!packageJson.name) {
     return exitWithCommandError('package.json must have a "name" field');
   }
-  const packageName = packageJson.name;
+  logPackageNameMismatch(expectedName, packageJson.name);
+  return {
+    toolPath,
+    hasTestScript: !!packageJson.scripts?.test,
+    hasBuildScript: !!packageJson.scripts?.build
+  };
+}
+function logPackageNameMismatch(expectedName, packageName) {
   const nameMatches = packageName === expectedName || packageName === `@agentforge/${expectedName}` || packageName.endsWith(`/${expectedName}`);
   if (!nameMatches) {
     logger.warn(`Package name mismatch: expected ${chalk4.cyan(expectedName)}, found ${chalk4.cyan(packageName)}`);
     logger.info(`Publishing package: ${chalk4.cyan(packageName)}`);
     logger.newLine();
   }
-  const hasTestScript = !!packageJson.scripts?.test;
-  const hasBuildScript = !!packageJson.scripts?.build;
-  return {
+}
+
+// src/commands/tool/publish-preflight.ts
+async function runPublishPreflight(toolPath, packageManager, toolInfo) {
+  await runOptionalScript({
+    enabled: toolInfo.hasTestScript,
+    skipMessage: "\u26A0\uFE0F  Skipping tests (no test script found)",
+    startMessage: "Running tests...",
+    successMessage: "Tests passed",
+    scriptName: "test",
     toolPath,
-    hasTestScript,
-    hasBuildScript
-  };
+    packageManager,
+    failureOptions: {
+      spinnerFailureText: "Tests failed",
+      message: "Cannot publish tool with failing tests"
+    }
+  });
+  await runOptionalScript({
+    enabled: toolInfo.hasBuildScript,
+    skipMessage: "\u26A0\uFE0F  Skipping build (no build script found)",
+    startMessage: "Building tool...",
+    successMessage: "Build completed",
+    scriptName: "build",
+    toolPath,
+    packageManager,
+    failureOptions: {
+      spinnerFailureText: "Build failed"
+    }
+  });
+}
+async function runOptionalScript(options) {
+  if (!options.enabled) {
+    logger.info(options.skipMessage);
+    return;
+  }
+  logger.startSpinner(options.startMessage);
+  try {
+    await runScript(options.toolPath, options.scriptName, options.packageManager);
+    logger.succeedSpinner(options.successMessage);
+  } catch (error) {
+    return exitWithCommandError(error, options.failureOptions);
+  }
+}
+async function publishToolPackage(toolPath, options) {
+  logger.startSpinner(options.dryRun ? "Running dry-run publish..." : "Publishing to npm...");
+  try {
+    await publishPackage(toolPath, {
+      tag: options.tag,
+      access: "public",
+      dryRun: options.dryRun
+    });
+    logger.succeedSpinner(
+      options.dryRun ? "Dry-run completed - no actual publishing occurred" : "Published to npm"
+    );
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    logger.failSpinner("Publishing failed");
+    logPublishError(errorMessage);
+    return exitWithCommandError(error, { logError: false });
+  }
+}
+function logPublishSummary(name, options) {
+  logger.newLine();
+  if (options.dryRun) {
+    logger.success(chalk4.bold.green("\u2728 Dry-run completed successfully!"));
+    logger.newLine();
+    logger.info("No changes were made. Remove --dry-run to publish for real.");
+    return;
+  }
+  logger.success(chalk4.bold.green("\u2728 Tool published successfully!"));
+  logger.newLine();
+  logger.info(`Published ${chalk4.cyan(name)} with tag ${chalk4.cyan(options.tag || "latest")}`);
+  logger.info("Users can now install with: npm install " + name);
+}
+function logPublishError(errorMessage) {
+  if (errorMessage.includes("ENEEDAUTH") || errorMessage.includes("E401")) {
+    logger.error("Not authenticated with npm");
+    logger.info("Run: npm login");
+    return;
+  }
+  if (errorMessage.includes("E403")) {
+    logger.error("Permission denied - you may not have access to publish this package");
+    logger.info("Check package name and npm organization permissions");
+    return;
+  }
+  if (errorMessage.includes("EPUBLISHCONFLICT") || errorMessage.includes("E409")) {
+    logger.error("Version already published");
+    logger.info("Update the version in package.json before publishing");
+    return;
+  }
+  logger.error(errorMessage);
+}
+
+// src/commands/tool/publish.ts
+async function toolPublishCommand(name, options) {
+  try {
+    logPublishHeader(name, options);
+    const toolInfo = await resolveToolPath(name);
+    const packageManager = await detectPackageManager(toolInfo.toolPath);
+    await runPublishPreflight(toolInfo.toolPath, packageManager, toolInfo);
+    await publishToolPackage(toolInfo.toolPath, options);
+    logPublishSummary(name, options);
+  } catch (error) {
+    return exitWithCommandError(error, { spinnerFailureText: "Publishing failed" });
+  }
+}
+function logPublishHeader(name, options) {
+  logger.header("\u{1F4E6} Publish Tool");
+  logger.info(`Tool: ${chalk4.cyan(name)}`);
+  logger.info(`Tag: ${chalk4.cyan(options.tag || "latest")}`);
+  logger.info(`Dry run: ${options.dryRun ? "Yes" : "No"}`);
+  logger.newLine();
+  if (options.dryRun) {
+    logger.warn("Dry run mode - no actual publishing will occur");
+    logger.newLine();
+  }
 }
 
 // src/index.ts