@agentforge/cli 0.5.1 → 0.5.2

package/dist/index.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
-import chalk7 from 'chalk';
-import path from 'path';
+import chalk4 from 'chalk';
+import path6 from 'path';
 import ora from 'ora';
 import inquirer from 'inquirer';
 import fs from 'fs-extra';
@@ -12,20 +12,20 @@ import { execa } from 'execa';
 var Logger = class {
   spinner = null;
   info(message) {
-    console.log(chalk7.blue("\u2139"), message);
+    console.log(chalk4.blue("\u2139"), message);
   }
   success(message) {
-    console.log(chalk7.green("\u2714"), message);
+    console.log(chalk4.green("\u2714"), message);
   }
   warn(message) {
-    console.log(chalk7.yellow("\u26A0"), message);
+    console.log(chalk4.yellow("\u26A0"), message);
   }
   error(message) {
-    console.log(chalk7.red("\u2716"), message);
+    console.log(chalk4.red("\u2716"), message);
   }
   debug(message) {
     if (process.env.DEBUG) {
-      console.log(chalk7.gray("\u{1F41B}"), message);
+      console.log(chalk4.gray("\u{1F41B}"), message);
     }
   }
   startSpinner(message) {
@@ -58,19 +58,19 @@ var Logger = class {
     console.log();
   }
   divider() {
-    console.log(chalk7.gray("\u2500".repeat(50)));
+    console.log(chalk4.gray("\u2500".repeat(50)));
   }
   header(message) {
     this.newLine();
-    console.log(chalk7.bold.cyan(message));
+    console.log(chalk4.bold.cyan(message));
     this.divider();
   }
   code(code) {
-    console.log(chalk7.gray("  " + code));
+    console.log(chalk4.gray("  " + code));
   }
   list(items) {
     items.forEach((item) => {
-      console.log(chalk7.gray("  \u2022"), item);
+      console.log(chalk4.gray("  \u2022"), item);
     });
   }
 };
@@ -250,7 +250,7 @@ async function promptToolSetup(defaults = {}) {
   };
 }
 var __filename$1 = fileURLToPath(import.meta.url);
-var __dirname$1 = path.dirname(__filename$1);
+var __dirname$1 = path6.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 = path.join(templatePath, file);
-    const destPath = path.join(targetPath, file);
-    await fs.ensureDir(path.dirname(destPath));
+    const sourcePath = path6.join(templatePath, file);
+    const destPath = path6.join(targetPath, file);
+    await fs.ensureDir(path6.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(path.dirname(filePath));
+  await fs.ensureDir(path6.dirname(filePath));
   await fs.writeFile(filePath, content);
 }
 function getTemplatePath(template) {
-  return path.join(__dirname$1, "..", "templates", template);
+  return path6.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(path.join(cwd, "pnpm-lock.yaml"))) {
+  if (await fs.pathExists(path6.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (await fs.pathExists(path.join(cwd, "yarn.lock"))) {
+  if (await fs.pathExists(path6.join(cwd, "yarn.lock"))) {
     return "yarn";
   }
-  if (await fs.pathExists(path.join(cwd, "package-lock.json"))) {
+  if (await fs.pathExists(path6.join(cwd, "package-lock.json"))) {
     return "npm";
   }
   try {
@@ -411,7 +411,7 @@ pnpm-debug.log*
 .temp/
 .tmp/
 `;
-  await fs.writeFile(path.join(cwd, ".gitignore"), gitignore);
+  await fs.writeFile(path6.join(cwd, ".gitignore"), gitignore);
 }
 async function createInitialCommit(cwd) {
   await execa("git", ["add", "."], { cwd });
@@ -426,7 +426,7 @@ async function createCommand(projectName, options) {
       logger.error("Project name is required");
       process.exit(1);
     }
-    const targetPath = path.join(process.cwd(), projectName);
+    const targetPath = path6.join(process.cwd(), projectName);
     if (!await isEmptyDir(targetPath)) {
       logger.error(`Directory ${projectName} already exists and is not empty`);
       process.exit(1);
@@ -439,9 +439,9 @@ async function createCommand(projectName, options) {
       initGit: options.git
     });
     logger.newLine();
-    logger.info(`Creating project: ${chalk7.cyan(answers.projectName)}`);
-    logger.info(`Template: ${chalk7.cyan(answers.template)}`);
-    logger.info(`Package manager: ${chalk7.cyan(answers.packageManager)}`);
+    logger.info(`Creating project: ${chalk4.cyan(answers.projectName)}`);
+    logger.info(`Template: ${chalk4.cyan(answers.template)}`);
+    logger.info(`Package manager: ${chalk4.cyan(answers.packageManager)}`);
     logger.newLine();
     logger.startSpinner("Creating project directory...");
     await ensureDir(targetPath);
@@ -456,7 +456,7 @@ async function createCommand(projectName, options) {
     });
     logger.succeedSpinner("Template files copied");
     logger.startSpinner("Updating package.json...");
-    const packageJsonPath = path.join(targetPath, "package.json");
+    const packageJsonPath = path6.join(targetPath, "package.json");
     const packageJson = await readJson(packageJsonPath);
     packageJson.name = answers.projectName;
     if (answers.author) {
@@ -489,7 +489,7 @@ async function createCommand(projectName, options) {
       }
     }
     logger.newLine();
-    logger.success(chalk7.bold.green("\u2728 Project created successfully!"));
+    logger.success(chalk4.bold.green("\u2728 Project created successfully!"));
     logger.newLine();
     logger.header("\u{1F4DD} Next Steps");
     logger.list([
@@ -626,12 +626,12 @@ async function agentCreateCommand(name, options) {
       generateTests: options.test
     });
     logger.newLine();
-    logger.info(`Creating agent: ${chalk7.cyan(answers.name)}`);
-    logger.info(`Pattern: ${chalk7.cyan(answers.pattern)}`);
+    logger.info(`Creating agent: ${chalk4.cyan(answers.name)}`);
+    logger.info(`Pattern: ${chalk4.cyan(answers.pattern)}`);
     logger.newLine();
     const cwd = process.cwd();
-    const agentDir = path.join(cwd, "src", "agents");
-    const agentFile = path.join(agentDir, `${answers.name}.ts`);
+    const agentDir = path6.join(cwd, "src", "agents");
+    const agentFile = path6.join(agentDir, `${answers.name}.ts`);
     logger.startSpinner("Creating agent file...");
     await ensureDir(agentDir);
     const agentContent = generateAgentContent(answers.name, answers.pattern, answers.description);
@@ -639,20 +639,20 @@ async function agentCreateCommand(name, options) {
     logger.succeedSpinner("Agent file created");
     if (answers.generateTests) {
       logger.startSpinner("Creating test file...");
-      const testDir = path.join(cwd, "tests", "agents");
-      const testFile = path.join(testDir, `${answers.name}.test.ts`);
+      const testDir = path6.join(cwd, "tests", "agents");
+      const testFile = path6.join(testDir, `${answers.name}.test.ts`);
       await ensureDir(testDir);
       const testContent = generateTestContent(answers.name, answers.pattern);
       await writeFile(testFile, testContent);
       logger.succeedSpinner("Test file created");
     }
     logger.newLine();
-    logger.success(chalk7.bold.green("\u2728 Agent created successfully!"));
+    logger.success(chalk4.bold.green("\u2728 Agent created successfully!"));
     logger.newLine();
     logger.header("\u{1F4DD} Next Steps");
     logger.list([
-      `Edit ${chalk7.cyan(`src/agents/${answers.name}.ts`)} to customize your agent`,
-      answers.generateTests ? `Run ${chalk7.cyan(`pnpm test tests/agents/${answers.name}.test.ts`)} to test your agent` : ""
+      `Edit ${chalk4.cyan(`src/agents/${answers.name}.ts`)} to customize your agent`,
+      answers.generateTests ? `Run ${chalk4.cyan(`pnpm test tests/agents/${answers.name}.test.ts`)} to test your agent` : ""
     ].filter(Boolean));
   } catch (error) {
     logger.error(`Failed to create agent: ${error.message}`);
@@ -764,42 +764,129 @@ describe('${capitalize(name)} ${pattern === "multi-agent" ? "System" : "Agent"}'
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
+async function agentCreateReusableCommand(name, options) {
+  try {
+    logger.header("\u{1F4E6} Create Reusable Agent");
+    const answers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "Agent name (e.g., customer-support):",
+        default: name,
+        validate: (input) => {
+          if (!input) return "Agent name is required";
+          if (!/^[a-z][a-z0-9-]*$/.test(input)) {
+            return "Agent name must be lowercase with hyphens (e.g., customer-support)";
+          }
+          return true;
+        }
+      },
+      {
+        type: "input",
+        name: "description",
+        message: "Agent description:",
+        default: options.description || `A reusable ${name} agent`
+      },
+      {
+        type: "input",
+        name: "author",
+        message: "Author name:",
+        default: options.author || ""
+      }
+    ]);
+    logger.newLine();
+    logger.info(`Creating reusable agent: ${chalk4.cyan(answers.name)}`);
+    logger.info(`Description: ${chalk4.gray(answers.description)}`);
+    logger.newLine();
+    const cwd = process.cwd();
+    const agentDir = path6.join(cwd, answers.name);
+    const agentNameKebab = answers.name;
+    const agentNamePascal = kebabToPascal(agentNameKebab);
+    const agentNameCamel = kebabToCamel(agentNameKebab);
+    const packageName = `@agentforge/${agentNameKebab}`;
+    const replacements = {
+      AGENT_NAME_KEBAB: agentNameKebab,
+      AGENT_NAME_PASCAL: agentNamePascal,
+      AGENT_NAME_CAMEL: agentNameCamel,
+      AGENT_DESCRIPTION: answers.description,
+      PACKAGE_NAME: packageName,
+      AUTHOR: answers.author || "Your Name"
+    };
+    logger.startSpinner("Creating agent structure...");
+    const templatePath = getTemplatePath("reusable-agent");
+    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"));
+    logger.succeedSpinner("Files organized");
+    logger.newLine();
+    logger.success(chalk4.bold.green("\u2728 Reusable agent created successfully!"));
+    logger.newLine();
+    logger.header("\u{1F4DD} Next Steps");
+    const nextSteps = [
+      `cd ${chalk4.cyan(answers.name)}`,
+      `Install dependencies: ${chalk4.cyan("pnpm install")}`,
+      `Edit ${chalk4.cyan("prompts/system.md")} to customize the agent prompt`,
+      `Edit ${chalk4.cyan("src/index.ts")} to add tools and configuration`,
+      `Run tests: ${chalk4.cyan("pnpm test")}`,
+      `Build: ${chalk4.cyan("pnpm build")}`
+    ];
+    logger.list(nextSteps);
+    logger.newLine();
+    logger.info(chalk4.gray("\u{1F4A1} Tip: See examples/reusable-agents/ for reference implementations"));
+  } catch (error) {
+    logger.error(`Failed to create reusable agent: ${error.message}`);
+    process.exit(1);
+  }
+}
+function kebabToPascal(str) {
+  return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function kebabToCamel(str) {
+  const pascal = kebabToPascal(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
 async function agentListCommand(options) {
   try {
     logger.header("\u{1F4CB} List Agents");
     const cwd = process.cwd();
-    const agentDir = path.join(cwd, "src", "agents");
+    const agentDir = path6.join(cwd, "src", "agents");
     const agentFiles = await findFiles("*.ts", agentDir);
     if (agentFiles.length === 0) {
       logger.warn("No agents found");
-      logger.info(`Create an agent with: ${chalk7.cyan("agentforge agent:create <name>")}`);
+      logger.info(`Create an agent with: ${chalk4.cyan("agentforge agent:create <name>")}`);
       return;
     }
-    logger.info(`Found ${chalk7.cyan(agentFiles.length)} agent(s):
+    logger.info(`Found ${chalk4.cyan(agentFiles.length)} agent(s):
 `);
     for (const file of agentFiles) {
-      const agentName = path.basename(file, ".ts");
-      const agentPath = path.join(agentDir, file);
+      const agentName = path6.basename(file, ".ts");
+      const agentPath = path6.join(agentDir, file);
       if (options.verbose) {
         const content = await readFile(agentPath);
         const pattern = extractPattern(content);
         const description = extractDescription(content);
-        logger.info(chalk7.bold.cyan(`  ${agentName}`));
+        logger.info(chalk4.bold.cyan(`  ${agentName}`));
         if (pattern) {
           logger.info(`    Pattern: ${pattern}`);
         }
         if (description) {
           logger.info(`    Description: ${description}`);
         }
-        logger.info(`    Path: ${chalk7.gray(agentPath)}`);
+        logger.info(`    Path: ${chalk4.gray(agentPath)}`);
         logger.newLine();
       } else {
-        logger.info(`  \u2022 ${chalk7.cyan(agentName)}`);
+        logger.info(`  \u2022 ${chalk4.cyan(agentName)}`);
       }
     }
     if (!options.verbose) {
       logger.newLine();
-      logger.info(`Use ${chalk7.cyan("--verbose")} for more details`);
+      logger.info(`Use ${chalk4.cyan("--verbose")} for more details`);
     }
   } catch (error) {
     logger.error(`Failed to list agents: ${error.message}`);
@@ -823,13 +910,13 @@ async function agentTestCommand(name, options) {
   try {
     logger.header("\u{1F9EA} Test Agent");
     const cwd = process.cwd();
-    const testFile = path.join(cwd, "tests", "agents", `${name}.test.ts`);
+    const testFile = path6.join(cwd, "tests", "agents", `${name}.test.ts`);
     if (!await pathExists(testFile)) {
       logger.error(`Test file not found: ${testFile}`);
-      logger.info(`Create tests with: ${chalk7.cyan(`agentforge agent:create ${name} --test`)}`);
+      logger.info(`Create tests with: ${chalk4.cyan(`agentforge agent:create ${name} --test`)}`);
       process.exit(1);
     }
-    logger.info(`Testing agent: ${chalk7.cyan(name)}`);
+    logger.info(`Testing agent: ${chalk4.cyan(name)}`);
     logger.info(`Watch mode: ${options.watch ? "Yes" : "No"}`);
     logger.newLine();
     const packageManager = await detectPackageManager(cwd);
@@ -847,8 +934,8 @@ async function agentTestCommand(name, options) {
 async function agentDeployCommand(name, options) {
   try {
     logger.header("\u{1F680} Deploy Agent");
-    logger.info(`Agent: ${chalk7.cyan(name)}`);
-    logger.info(`Environment: ${chalk7.cyan(options.environment || "production")}`);
+    logger.info(`Agent: ${chalk4.cyan(name)}`);
+    logger.info(`Environment: ${chalk4.cyan(options.environment || "production")}`);
     logger.info(`Dry run: ${options.dryRun ? "Yes" : "No"}`);
     logger.newLine();
     if (options.dryRun) {
@@ -864,7 +951,7 @@ async function agentDeployCommand(name, options) {
       logger.succeedSpinner("Agent deployed successfully");
     }
     logger.newLine();
-    logger.success(chalk7.bold.green("\u2728 Deployment completed!"));
+    logger.success(chalk4.bold.green("\u2728 Deployment completed!"));
     logger.newLine();
     logger.info("Note: Actual deployment implementation coming soon");
     logger.info("For now, please use the deployment templates in the templates/deployment directory");
@@ -885,9 +972,9 @@ async function toolCreateCommand(name, options) {
       generateTests: options.test
     });
     logger.newLine();
-    logger.info(`Creating tool: ${chalk7.cyan(answers.name)}`);
-    logger.info(`Category: ${chalk7.cyan(answers.category)}`);
-    logger.info(`Structure: ${chalk7.cyan(answers.structure)}`);
+    logger.info(`Creating tool: ${chalk4.cyan(answers.name)}`);
+    logger.info(`Category: ${chalk4.cyan(answers.category)}`);
+    logger.info(`Structure: ${chalk4.cyan(answers.structure)}`);
     logger.newLine();
     const cwd = process.cwd();
     if (answers.structure === "multi") {
@@ -896,18 +983,18 @@ async function toolCreateCommand(name, options) {
       await createSingleFileTool(cwd, answers);
     }
     logger.newLine();
-    logger.success(chalk7.bold.green("\u2728 Tool created successfully!"));
+    logger.success(chalk4.bold.green("\u2728 Tool created successfully!"));
     logger.newLine();
     logger.header("\u{1F4DD} Next Steps");
     const nextSteps = answers.structure === "multi" ? [
-      `Edit ${chalk7.cyan(`src/tools/${answers.name}/index.ts`)} to implement your tool`,
-      `Add providers in ${chalk7.cyan(`src/tools/${answers.name}/providers/`)}`,
-      `Define types in ${chalk7.cyan(`src/tools/${answers.name}/types.ts`)}`,
-      answers.generateTests ? `Run ${chalk7.cyan(`pnpm test ${answers.name}`)} to test your tool` : "",
+      `Edit ${chalk4.cyan(`src/tools/${answers.name}/index.ts`)} to implement your tool`,
+      `Add providers in ${chalk4.cyan(`src/tools/${answers.name}/providers/`)}`,
+      `Define types in ${chalk4.cyan(`src/tools/${answers.name}/types.ts`)}`,
+      answers.generateTests ? `Run ${chalk4.cyan(`pnpm test ${answers.name}`)} to test your tool` : "",
       `Register the tool in your agent's tool registry`
     ] : [
-      `Edit ${chalk7.cyan(`src/tools/${answers.name}.ts`)} to implement your tool`,
-      answers.generateTests ? `Run ${chalk7.cyan(`pnpm test tests/tools/${answers.name}.test.ts`)} to test your tool` : "",
+      `Edit ${chalk4.cyan(`src/tools/${answers.name}.ts`)} to implement your tool`,
+      answers.generateTests ? `Run ${chalk4.cyan(`pnpm test tests/tools/${answers.name}.test.ts`)} to test your tool` : "",
       `Register the tool in your agent's tool registry`
     ];
     logger.list(nextSteps.filter(Boolean));
@@ -967,8 +1054,8 @@ function capitalize2(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 async function createSingleFileTool(cwd, answers) {
-  const toolDir = path.join(cwd, "src", "tools");
-  const toolFile = path.join(toolDir, `${answers.name}.ts`);
+  const toolDir = path6.join(cwd, "src", "tools");
+  const toolFile = path6.join(toolDir, `${answers.name}.ts`);
   logger.startSpinner("Creating tool file...");
   await ensureDir(toolDir);
   const toolContent = generateToolContent(answers.name, answers.category, answers.description);
@@ -976,8 +1063,8 @@ async function createSingleFileTool(cwd, answers) {
   logger.succeedSpinner("Tool file created");
   if (answers.generateTests) {
     logger.startSpinner("Creating test file...");
-    const testDir = path.join(cwd, "tests", "tools");
-    const testFile = path.join(testDir, `${answers.name}.test.ts`);
+    const testDir = path6.join(cwd, "tests", "tools");
+    const testFile = path6.join(testDir, `${answers.name}.test.ts`);
     await ensureDir(testDir);
     const testContent = generateTestContent2(answers.name);
     await writeFile(testFile, testContent);
@@ -985,7 +1072,7 @@ async function createSingleFileTool(cwd, answers) {
   }
 }
 async function createMultiFileTool(cwd, answers) {
-  const toolDir = path.join(cwd, "src", "tools", answers.name);
+  const toolDir = path6.join(cwd, "src", "tools", answers.name);
   logger.startSpinner("Creating tool directory structure...");
   await ensureDir(toolDir);
   const templatePath = getTemplatePath("tool-multi");
@@ -1001,7 +1088,7 @@ async function createMultiFileTool(cwd, answers) {
   if (!answers.generateTests) {
     logger.startSpinner("Cleaning up test files...");
     const fs4 = await import('fs-extra');
-    const testDir = path.join(toolDir, "__tests__");
+    const testDir = path6.join(toolDir, "__tests__");
     await fs4.remove(testDir);
     logger.succeedSpinner("Test files removed");
   }
@@ -1010,18 +1097,18 @@ async function toolListCommand(options) {
   try {
     logger.header("\u{1F4CB} List Tools");
     const cwd = process.cwd();
-    const toolDir = path.join(cwd, "src", "tools");
+    const toolDir = path6.join(cwd, "src", "tools");
     const toolFiles = await findFiles("*.ts", toolDir);
     if (toolFiles.length === 0) {
       logger.warn("No tools found");
-      logger.info(`Create a tool with: ${chalk7.cyan("agentforge tool:create <name>")}`);
+      logger.info(`Create a tool with: ${chalk4.cyan("agentforge tool:create <name>")}`);
       return;
     }
     let filteredTools = toolFiles;
     if (options.category) {
       filteredTools = [];
       for (const file of toolFiles) {
-        const toolPath = path.join(toolDir, file);
+        const toolPath = path6.join(toolDir, file);
         const content = await readFile(toolPath);
         const category = extractCategory(content);
         if (category === options.category) {
@@ -1033,31 +1120,31 @@ async function toolListCommand(options) {
       logger.warn(`No tools found in category: ${options.category}`);
       return;
     }
-    logger.info(`Found ${chalk7.cyan(filteredTools.length)} tool(s):
+    logger.info(`Found ${chalk4.cyan(filteredTools.length)} tool(s):
 `);
     for (const file of filteredTools) {
-      const toolName = path.basename(file, ".ts");
-      const toolPath = path.join(toolDir, file);
+      const toolName = path6.basename(file, ".ts");
+      const toolPath = path6.join(toolDir, file);
       if (options.verbose) {
         const content = await readFile(toolPath);
         const category = extractCategory(content);
         const description = extractDescription2(content);
-        logger.info(chalk7.bold.cyan(`  ${toolName}`));
+        logger.info(chalk4.bold.cyan(`  ${toolName}`));
         if (category) {
           logger.info(`    Category: ${category}`);
         }
         if (description) {
           logger.info(`    Description: ${description}`);
         }
-        logger.info(`    Path: ${chalk7.gray(toolPath)}`);
+        logger.info(`    Path: ${chalk4.gray(toolPath)}`);
         logger.newLine();
       } else {
-        logger.info(`  \u2022 ${chalk7.cyan(toolName)}`);
+        logger.info(`  \u2022 ${chalk4.cyan(toolName)}`);
       }
     }
     if (!options.verbose) {
       logger.newLine();
-      logger.info(`Use ${chalk7.cyan("--verbose")} for more details`);
+      logger.info(`Use ${chalk4.cyan("--verbose")} for more details`);
     }
   } catch (error) {
     logger.error(`Failed to list tools: ${error.message}`);
@@ -1076,13 +1163,13 @@ async function toolTestCommand(name, options) {
   try {
     logger.header("\u{1F9EA} Test Tool");
     const cwd = process.cwd();
-    const testFile = path.join(cwd, "tests", "tools", `${name}.test.ts`);
+    const testFile = path6.join(cwd, "tests", "tools", `${name}.test.ts`);
     if (!await pathExists(testFile)) {
       logger.error(`Test file not found: ${testFile}`);
-      logger.info(`Create tests with: ${chalk7.cyan(`agentforge tool:create ${name} --test`)}`);
+      logger.info(`Create tests with: ${chalk4.cyan(`agentforge tool:create ${name} --test`)}`);
       process.exit(1);
     }
-    logger.info(`Testing tool: ${chalk7.cyan(name)}`);
+    logger.info(`Testing tool: ${chalk4.cyan(name)}`);
     logger.info(`Watch mode: ${options.watch ? "Yes" : "No"}`);
     logger.newLine();
     const packageManager = await detectPackageManager(cwd);
@@ -1100,8 +1187,8 @@ async function toolTestCommand(name, options) {
 async function toolPublishCommand(name, options) {
   try {
     logger.header("\u{1F4E6} Publish Tool");
-    logger.info(`Tool: ${chalk7.cyan(name)}`);
-    logger.info(`Tag: ${chalk7.cyan(options.tag || "latest")}`);
+    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) {
@@ -1133,7 +1220,7 @@ async function toolPublishCommand(name, options) {
       logger.succeedSpinner("Published to npm");
     }
     logger.newLine();
-    logger.success(chalk7.bold.green("\u2728 Tool published successfully!"));
+    logger.success(chalk4.bold.green("\u2728 Tool published successfully!"));
     logger.newLine();
     logger.info("Note: Actual npm publishing implementation coming soon");
     logger.info("For now, please use npm publish manually");
@@ -1154,6 +1241,7 @@ program.command("test").description("Run tests with coverage").option("-w, --wat
 program.command("lint").description("Lint and format code").option("--fix", "Auto-fix issues").option("--no-format", "Skip formatting").action(lintCommand);
 var agent = program.command("agent").description("Manage agents");
 agent.command("create <name>").description("Create a new agent").option("-p, --pattern <pattern>", "Agent pattern (react, plan-execute, reflection, multi-agent)", "react").option("--no-test", "Skip test generation").action(agentCreateCommand);
+agent.command("create-reusable <name>").description("Create a new reusable agent (production template)").option("-d, --description <description>", "Agent description").option("-a, --author <author>", "Author name").action(agentCreateReusableCommand);
 agent.command("list").description("List all agents").option("-v, --verbose", "Show detailed information").action(agentListCommand);
 agent.command("test <name>").description("Test a specific agent").option("-w, --watch", "Watch mode").action(agentTestCommand);
 agent.command("deploy <name>").description("Deploy an agent").option("-e, --environment <env>", "Deployment environment", "production").option("--dry-run", "Dry run without actual deployment").action(agentDeployCommand);
@@ -1168,7 +1256,7 @@ async function run() {
     await program.parseAsync(process.argv);
   } catch (error) {
     if (error.code !== "commander.help" && error.code !== "commander.version") {
-      console.error(chalk7.red("Error:"), error.message);
+      console.error(chalk4.red("Error:"), error.message);
       process.exit(1);
     }
   }