@agentforge/cli 0.11.4 → 0.11.6

package/dist/index.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import chalk4 from 'chalk';
-import path6 from 'path';
+import path12 from 'path';
 import ora from 'ora';
 import inquirer from 'inquirer';
 import fs from 'fs-extra';
@@ -250,7 +250,7 @@ async function promptToolSetup(defaults = {}) {
   };
 }
 var __filename$1 = fileURLToPath(import.meta.url);
-var __dirname$1 = path6.dirname(__filename$1);
+var __dirname$1 = path12.dirname(__filename$1);
 async function ensureDir(dir) {
   await fs.ensureDir(dir);
 }
@@ -268,9 +268,9 @@ async function copyTemplate(templatePath, targetPath, replacements = {}) {
     throw new Error(`No files found in template: ${templatePath}`);
   }
   for (const file of files) {
-    const sourcePath = path6.join(templatePath, file);
-    const destPath = path6.join(targetPath, file);
-    await fs.ensureDir(path6.dirname(destPath));
+    const sourcePath = path12.join(templatePath, file);
+    const destPath = path12.join(targetPath, file);
+    await fs.ensureDir(path12.dirname(destPath));
     let content = await fs.readFile(sourcePath, "utf-8");
     for (const [key, value] of Object.entries(replacements)) {
       content = content.replace(new RegExp(`{{${key}}}`, "g"), value);
@@ -294,11 +294,11 @@ async function readFile(filePath) {
   return fs.readFile(filePath, "utf-8");
 }
 async function writeFile(filePath, content) {
-  await fs.ensureDir(path6.dirname(filePath));
+  await fs.ensureDir(path12.dirname(filePath));
   await fs.writeFile(filePath, content);
 }
 function getTemplatePath(template) {
-  return path6.join(__dirname$1, "..", "templates", template);
+  return path12.join(__dirname$1, "..", "templates", template);
 }
 async function isEmptyDir(dir) {
   if (!await pathExists(dir)) {
@@ -308,13 +308,13 @@ async function isEmptyDir(dir) {
   return files.length === 0;
 }
 async function detectPackageManager(cwd = process.cwd()) {
-  if (await fs.pathExists(path6.join(cwd, "pnpm-lock.yaml"))) {
+  if (await fs.pathExists(path12.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (await fs.pathExists(path6.join(cwd, "yarn.lock"))) {
+  if (await fs.pathExists(path12.join(cwd, "yarn.lock"))) {
     return "yarn";
   }
-  if (await fs.pathExists(path6.join(cwd, "package-lock.json"))) {
+  if (await fs.pathExists(path12.join(cwd, "package-lock.json"))) {
     return "npm";
   }
   try {
@@ -422,7 +422,7 @@ pnpm-debug.log*
 .temp/
 .tmp/
 `;
-  await fs.writeFile(path6.join(cwd, ".gitignore"), gitignore);
+  await fs.writeFile(path12.join(cwd, ".gitignore"), gitignore);
 }
 async function createInitialCommit(cwd) {
   await execa("git", ["add", "."], { cwd });
@@ -437,7 +437,7 @@ async function createCommand(projectName, options) {
       logger.error("Project name is required");
       process.exit(1);
     }
-    const targetPath = path6.join(process.cwd(), projectName);
+    const targetPath = path12.join(process.cwd(), projectName);
     if (!await isEmptyDir(targetPath)) {
       logger.error(`Directory ${projectName} already exists and is not empty`);
       process.exit(1);
@@ -467,7 +467,7 @@ async function createCommand(projectName, options) {
     });
     logger.succeedSpinner("Template files copied");
     logger.startSpinner("Updating package.json...");
-    const packageJsonPath = path6.join(targetPath, "package.json");
+    const packageJsonPath = path12.join(targetPath, "package.json");
     const packageJson = await readJson(packageJsonPath);
     packageJson.name = answers.projectName;
     if (answers.author) {
@@ -641,8 +641,8 @@ async function agentCreateCommand(name, options) {
     logger.info(`Pattern: ${chalk4.cyan(answers.pattern)}`);
     logger.newLine();
     const cwd = process.cwd();
-    const agentDir = path6.join(cwd, "src", "agents");
-    const agentFile = path6.join(agentDir, `${answers.name}.ts`);
+    const agentDir = path12.join(cwd, "src", "agents");
+    const agentFile = path12.join(agentDir, `${answers.name}.ts`);
     logger.startSpinner("Creating agent file...");
     await ensureDir(agentDir);
     const agentContent = generateAgentContent(answers.name, answers.pattern, answers.description);
@@ -650,8 +650,8 @@ async function agentCreateCommand(name, options) {
     logger.succeedSpinner("Agent file created");
     if (answers.generateTests) {
       logger.startSpinner("Creating test file...");
-      const testDir = path6.join(cwd, "tests", "agents");
-      const testFile = path6.join(testDir, `${answers.name}.test.ts`);
+      const testDir = path12.join(cwd, "tests", "agents");
+      const testFile = path12.join(testDir, `${answers.name}.test.ts`);
       await ensureDir(testDir);
       const testContent = generateTestContent(answers.name, answers.pattern);
       await writeFile(testFile, testContent);
@@ -810,7 +810,7 @@ async function agentCreateReusableCommand(name, options) {
     logger.info(`Description: ${chalk4.gray(answers.description)}`);
     logger.newLine();
     const cwd = process.cwd();
-    const agentDir = path6.join(cwd, answers.name);
+    const agentDir = path12.join(cwd, answers.name);
     const agentNameKebab = answers.name;
     const agentNamePascal = kebabToPascal(agentNameKebab);
     const agentNameCamel = kebabToCamel(agentNameKebab);
@@ -828,12 +828,12 @@ async function agentCreateReusableCommand(name, options) {
     await copyTemplate(templatePath, agentDir, replacements);
     logger.succeedSpinner("Agent structure created");
     logger.startSpinner("Organizing files...");
-    const fs4 = await import('fs-extra');
-    const srcDir = path6.join(agentDir, "src");
-    await fs4.ensureDir(srcDir);
-    await fs4.move(path6.join(agentDir, "index.ts"), path6.join(srcDir, "index.ts"));
-    await fs4.move(path6.join(agentDir, "prompt-loader.ts"), path6.join(srcDir, "prompt-loader.ts"));
-    await fs4.move(path6.join(agentDir, "index.test.ts"), path6.join(srcDir, "index.test.ts"));
+    const fs5 = await import('fs-extra');
+    const srcDir = path12.join(agentDir, "src");
+    await fs5.ensureDir(srcDir);
+    await fs5.move(path12.join(agentDir, "index.ts"), path12.join(srcDir, "index.ts"));
+    await fs5.move(path12.join(agentDir, "prompt-loader.ts"), path12.join(srcDir, "prompt-loader.ts"));
+    await fs5.move(path12.join(agentDir, "index.test.ts"), path12.join(srcDir, "index.test.ts"));
     logger.succeedSpinner("Files organized");
     logger.newLine();
     logger.success(chalk4.bold.green("\u2728 Reusable agent created successfully!"));
@@ -866,7 +866,7 @@ async function agentListCommand(options) {
   try {
     logger.header("\u{1F4CB} List Agents");
     const cwd = process.cwd();
-    const agentDir = path6.join(cwd, "src", "agents");
+    const agentDir = path12.join(cwd, "src", "agents");
     const agentFiles = await findFiles("*.ts", agentDir);
     if (agentFiles.length === 0) {
       logger.warn("No agents found");
@@ -876,8 +876,8 @@ async function agentListCommand(options) {
     logger.info(`Found ${chalk4.cyan(agentFiles.length)} agent(s):
 `);
     for (const file of agentFiles) {
-      const agentName = path6.basename(file, ".ts");
-      const agentPath = path6.join(agentDir, file);
+      const agentName = path12.basename(file, ".ts");
+      const agentPath = path12.join(agentDir, file);
       if (options.verbose) {
         const content = await readFile(agentPath);
         const pattern = extractPattern(content);
@@ -921,7 +921,7 @@ async function agentTestCommand(name, options) {
   try {
     logger.header("\u{1F9EA} Test Agent");
     const cwd = process.cwd();
-    const testFile = path6.join(cwd, "tests", "agents", `${name}.test.ts`);
+    const testFile = path12.join(cwd, "tests", "agents", `${name}.test.ts`);
     if (!await pathExists(testFile)) {
       logger.error(`Test file not found: ${testFile}`);
       logger.info(`Create tests with: ${chalk4.cyan(`agentforge agent:create ${name} --test`)}`);
@@ -1072,8 +1072,8 @@ function capitalize2(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 async function createSingleFileTool(cwd, answers) {
-  const toolDir = path6.join(cwd, "src", "tools");
-  const toolFile = path6.join(toolDir, `${answers.name}.ts`);
+  const toolDir = path12.join(cwd, "src", "tools");
+  const toolFile = path12.join(toolDir, `${answers.name}.ts`);
   logger.startSpinner("Creating tool file...");
   await ensureDir(toolDir);
   const toolContent = generateToolContent(answers.name, answers.category, answers.description);
@@ -1081,8 +1081,8 @@ async function createSingleFileTool(cwd, answers) {
   logger.succeedSpinner("Tool file created");
   if (answers.generateTests) {
     logger.startSpinner("Creating test file...");
-    const testDir = path6.join(cwd, "tests", "tools");
-    const testFile = path6.join(testDir, `${answers.name}.test.ts`);
+    const testDir = path12.join(cwd, "tests", "tools");
+    const testFile = path12.join(testDir, `${answers.name}.test.ts`);
     await ensureDir(testDir);
     const testContent = generateTestContent2(answers.name);
     await writeFile(testFile, testContent);
@@ -1090,7 +1090,7 @@ async function createSingleFileTool(cwd, answers) {
   }
 }
 async function createMultiFileTool(cwd, answers) {
-  const toolDir = path6.join(cwd, "src", "tools", answers.name);
+  const toolDir = path12.join(cwd, "src", "tools", answers.name);
   logger.startSpinner("Creating tool directory structure...");
   await ensureDir(toolDir);
   const templatePath = getTemplatePath("tool-multi");
@@ -1105,9 +1105,9 @@ async function createMultiFileTool(cwd, answers) {
   logger.succeedSpinner("Tool directory structure created");
   if (!answers.generateTests) {
     logger.startSpinner("Cleaning up test files...");
-    const fs4 = await import('fs-extra');
-    const testDir = path6.join(toolDir, "__tests__");
-    await fs4.remove(testDir);
+    const fs5 = await import('fs-extra');
+    const testDir = path12.join(toolDir, "__tests__");
+    await fs5.remove(testDir);
     logger.succeedSpinner("Test files removed");
   }
 }
@@ -1115,7 +1115,7 @@ async function toolListCommand(options) {
   try {
     logger.header("\u{1F4CB} List Tools");
     const cwd = process.cwd();
-    const toolDir = path6.join(cwd, "src", "tools");
+    const toolDir = path12.join(cwd, "src", "tools");
     const toolFiles = await findFiles("*.ts", toolDir);
     if (toolFiles.length === 0) {
       logger.warn("No tools found");
@@ -1126,7 +1126,7 @@ async function toolListCommand(options) {
     if (options.category) {
       filteredTools = [];
       for (const file of toolFiles) {
-        const toolPath = path6.join(toolDir, file);
+        const toolPath = path12.join(toolDir, file);
         const content = await readFile(toolPath);
         const category = extractCategory(content);
         if (category === options.category) {
@@ -1141,8 +1141,8 @@ async function toolListCommand(options) {
     logger.info(`Found ${chalk4.cyan(filteredTools.length)} tool(s):
 `);
     for (const file of filteredTools) {
-      const toolName = path6.basename(file, ".ts");
-      const toolPath = path6.join(toolDir, file);
+      const toolName = path12.basename(file, ".ts");
+      const toolPath = path12.join(toolDir, file);
       if (options.verbose) {
         const content = await readFile(toolPath);
         const category = extractCategory(content);
@@ -1181,7 +1181,7 @@ async function toolTestCommand(name, options) {
   try {
     logger.header("\u{1F9EA} Test Tool");
     const cwd = process.cwd();
-    const testFile = path6.join(cwd, "tests", "tools", `${name}.test.ts`);
+    const testFile = path12.join(cwd, "tests", "tools", `${name}.test.ts`);
     if (!await pathExists(testFile)) {
       logger.error(`Test file not found: ${testFile}`);
       logger.info(`Create tests with: ${chalk4.cyan(`agentforge tool:create ${name} --test`)}`);
@@ -1213,28 +1213,36 @@ async function toolPublishCommand(name, options) {
       logger.warn("Dry run mode - no actual publishing will occur");
       logger.newLine();
     }
-    const cwd = process.cwd();
-    const packageManager = await detectPackageManager(cwd);
-    logger.startSpinner("Running tests...");
-    try {
-      await runScript(cwd, "test", packageManager);
-      logger.succeedSpinner("Tests passed");
-    } catch (error) {
-      logger.failSpinner("Tests failed");
-      logger.error("Cannot publish tool with failing tests");
-      process.exit(1);
+    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) {
+        logger.failSpinner("Tests failed");
+        logger.error("Cannot publish tool with failing tests");
+        process.exit(1);
+      }
+    } else {
+      logger.info("\u26A0\uFE0F  Skipping tests (no test script found)");
     }
-    logger.startSpinner("Building tool...");
-    try {
-      await runScript(cwd, "build", packageManager);
-      logger.succeedSpinner("Build completed");
-    } catch (error) {
-      logger.failSpinner("Build failed");
-      process.exit(1);
+    if (hasBuildScript) {
+      logger.startSpinner("Building tool...");
+      try {
+        await runScript(toolPath, "build", packageManager);
+        logger.succeedSpinner("Build completed");
+      } catch (error) {
+        logger.failSpinner("Build failed");
+        process.exit(1);
+      }
+    } 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(cwd, {
+      await publishPackage(toolPath, {
         tag: options.tag,
         access: "public",
         dryRun: options.dryRun
@@ -1277,6 +1285,95 @@ async function toolPublishCommand(name, options) {
     process.exit(1);
   }
 }
+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);
+  }
+  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);
+    }
+  }
+  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)
+    );
+  }
+  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);
+      }
+    }
+  }
+  logger.error(`Could not find tool package: ${chalk4.cyan(name)}`);
+  logger.newLine();
+  logger.info("Tried the following locations:");
+  logger.list([
+    `Current directory (${cwd})`,
+    ...possiblePaths.map((p) => path12.relative(cwd, p) || ".")
+  ]);
+  logger.newLine();
+  logger.info("Make sure you are either:");
+  logger.list([
+    "In the tool package directory with matching package.json name",
+    "Providing a path to the tool package directory",
+    "Have the tool in a standard location (./tools/<name>, ./packages/<name>)"
+  ]);
+  process.exit(1);
+}
+async function validateToolPath(toolPath, expectedName) {
+  if (!await fs.pathExists(toolPath)) {
+    logger.error(`Tool directory not found: ${toolPath}`);
+    process.exit(1);
+  }
+  const packageJsonPath = path12.join(toolPath, "package.json");
+  if (!await fs.pathExists(packageJsonPath)) {
+    logger.error(`package.json not found in: ${toolPath}`);
+    logger.info("Tool packages must have a package.json file");
+    process.exit(1);
+  }
+  let packageJson;
+  try {
+    packageJson = await fs.readJson(packageJsonPath);
+  } catch (error) {
+    logger.error(`Failed to read package.json: ${error.message}`);
+    process.exit(1);
+  }
+  if (!packageJson.name) {
+    logger.error('package.json must have a "name" field');
+    process.exit(1);
+  }
+  const packageName = packageJson.name;
+  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 {
+    toolPath,
+    hasTestScript,
+    hasBuildScript
+  };
+}
 
 // src/index.ts
 var program = new Command();