@agentforge/cli 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1114 @@
+'use strict';
+
+var commander = require('commander');
+var chalk = require('chalk');
+var path = require('path');
+var ora = require('ora');
+var inquirer = require('inquirer');
+var fs = require('fs-extra');
+var glob = require('glob');
+var execa = require('execa');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var ora__default = /*#__PURE__*/_interopDefault(ora);
+var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+
+// src/index.ts
+var Logger = class {
+  spinner = null;
+  info(message) {
+    console.log(chalk__default.default.blue("\u2139"), message);
+  }
+  success(message) {
+    console.log(chalk__default.default.green("\u2714"), message);
+  }
+  warn(message) {
+    console.log(chalk__default.default.yellow("\u26A0"), message);
+  }
+  error(message) {
+    console.log(chalk__default.default.red("\u2716"), message);
+  }
+  debug(message) {
+    if (process.env.DEBUG) {
+      console.log(chalk__default.default.gray("\u{1F41B}"), message);
+    }
+  }
+  startSpinner(message) {
+    this.spinner = ora__default.default(message).start();
+  }
+  updateSpinner(message) {
+    if (this.spinner) {
+      this.spinner.text = message;
+    }
+  }
+  succeedSpinner(message) {
+    if (this.spinner) {
+      this.spinner.succeed(message);
+      this.spinner = null;
+    }
+  }
+  failSpinner(message) {
+    if (this.spinner) {
+      this.spinner.fail(message);
+      this.spinner = null;
+    }
+  }
+  stopSpinner() {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
+  newLine() {
+    console.log();
+  }
+  divider() {
+    console.log(chalk__default.default.gray("\u2500".repeat(50)));
+  }
+  header(message) {
+    this.newLine();
+    console.log(chalk__default.default.bold.cyan(message));
+    this.divider();
+  }
+  code(code) {
+    console.log(chalk__default.default.gray("  " + code));
+  }
+  list(items) {
+    items.forEach((item) => {
+      console.log(chalk__default.default.gray("  \u2022"), item);
+    });
+  }
+};
+var logger = new Logger();
+async function promptProjectSetup(defaults = {}) {
+  return inquirer__default.default.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name:",
+      default: defaults.projectName || "my-agent",
+      validate: (input) => {
+        if (!input) return "Project name is required";
+        if (!/^[a-z0-9-]+$/.test(input)) {
+          return "Project name must contain only lowercase letters, numbers, and hyphens";
+        }
+        return true;
+      }
+    },
+    {
+      type: "list",
+      name: "template",
+      message: "Select a template:",
+      choices: [
+        { name: "Minimal Starter - Basic ReAct agent", value: "minimal" },
+        { name: "Full-Featured App - Multi-agent system with all features", value: "full" },
+        { name: "API Service - Express/Fastify API with agents", value: "api" },
+        { name: "CLI Tool - Command-line agent application", value: "cli" }
+      ],
+      default: defaults.template || "minimal"
+    },
+    {
+      type: "list",
+      name: "packageManager",
+      message: "Package manager:",
+      choices: ["pnpm", "npm", "yarn"],
+      default: defaults.packageManager || "pnpm"
+    },
+    {
+      type: "confirm",
+      name: "installDependencies",
+      message: "Install dependencies?",
+      default: defaults.installDependencies !== false
+    },
+    {
+      type: "confirm",
+      name: "initGit",
+      message: "Initialize git repository?",
+      default: defaults.initGit !== false
+    },
+    {
+      type: "input",
+      name: "author",
+      message: "Author name (optional):",
+      default: defaults.author
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Project description (optional):",
+      default: defaults.description
+    }
+  ]);
+}
+async function promptAgentSetup(defaults = {}) {
+  return inquirer__default.default.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Agent name:",
+      default: defaults.name,
+      validate: (input) => {
+        if (!input) return "Agent name is required";
+        if (!/^[a-zA-Z][a-zA-Z0-9]*$/.test(input)) {
+          return "Agent name must start with a letter and contain only letters and numbers";
+        }
+        return true;
+      }
+    },
+    {
+      type: "list",
+      name: "pattern",
+      message: "Agent pattern:",
+      choices: [
+        { name: "ReAct - Reasoning and Acting", value: "react" },
+        { name: "Plan-Execute - Planning and Execution", value: "plan-execute" },
+        { name: "Reflection - Generate, Reflect, Revise", value: "reflection" },
+        { name: "Multi-Agent - Supervisor and Workers", value: "multi-agent" }
+      ],
+      default: defaults.pattern || "react"
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Agent description (optional):",
+      default: defaults.description
+    },
+    {
+      type: "confirm",
+      name: "generateTests",
+      message: "Generate tests?",
+      default: defaults.generateTests !== false
+    }
+  ]);
+}
+async function promptToolSetup(defaults = {}) {
+  return inquirer__default.default.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Tool name:",
+      default: defaults.name,
+      validate: (input) => {
+        if (!input) return "Tool name is required";
+        if (!/^[a-zA-Z][a-zA-Z0-9]*$/.test(input)) {
+          return "Tool name must start with a letter and contain only letters and numbers";
+        }
+        return true;
+      }
+    },
+    {
+      type: "list",
+      name: "category",
+      message: "Tool category:",
+      choices: [
+        { name: "Web - HTTP, scraping, parsing", value: "web" },
+        { name: "Data - JSON, CSV, XML processing", value: "data" },
+        { name: "File - File operations", value: "file" },
+        { name: "Utility - General utilities", value: "utility" }
+      ],
+      default: defaults.category || "utility"
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Tool description:",
+      default: defaults.description,
+      validate: (input) => {
+        if (!input) return "Tool description is required";
+        return true;
+      }
+    },
+    {
+      type: "confirm",
+      name: "generateTests",
+      message: "Generate tests?",
+      default: defaults.generateTests !== false
+    }
+  ]);
+}
+async function ensureDir(dir) {
+  await fs__default.default.ensureDir(dir);
+}
+async function copyTemplate(templatePath, targetPath, replacements = {}) {
+  await fs__default.default.ensureDir(targetPath);
+  const files = await glob.glob("**/*", {
+    cwd: templatePath,
+    dot: true,
+    nodir: true
+  });
+  for (const file of files) {
+    const sourcePath = path__default.default.join(templatePath, file);
+    const destPath = path__default.default.join(targetPath, file);
+    await fs__default.default.ensureDir(path__default.default.dirname(destPath));
+    let content = await fs__default.default.readFile(sourcePath, "utf-8");
+    for (const [key, value] of Object.entries(replacements)) {
+      content = content.replace(new RegExp(`{{${key}}}`, "g"), value);
+    }
+    await fs__default.default.writeFile(destPath, content);
+  }
+}
+async function writeJson(filePath, data) {
+  await fs__default.default.writeJson(filePath, data, { spaces: 2 });
+}
+async function readJson(filePath) {
+  return fs__default.default.readJson(filePath);
+}
+async function pathExists(filePath) {
+  return fs__default.default.pathExists(filePath);
+}
+async function findFiles(pattern, cwd = process.cwd()) {
+  return glob.glob(pattern, { cwd });
+}
+async function readFile(filePath) {
+  return fs__default.default.readFile(filePath, "utf-8");
+}
+async function writeFile(filePath, content) {
+  await fs__default.default.ensureDir(path__default.default.dirname(filePath));
+  await fs__default.default.writeFile(filePath, content);
+}
+function getTemplatePath(template) {
+  return path__default.default.join(__dirname, "..", "..", "templates", template);
+}
+async function isEmptyDir(dir) {
+  if (!await pathExists(dir)) {
+    return true;
+  }
+  const files = await fs__default.default.readdir(dir);
+  return files.length === 0;
+}
+async function detectPackageManager(cwd = process.cwd()) {
+  if (await fs__default.default.pathExists(path__default.default.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (await fs__default.default.pathExists(path__default.default.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (await fs__default.default.pathExists(path__default.default.join(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  try {
+    await execa.execa("pnpm", ["--version"]);
+    return "pnpm";
+  } catch {
+  }
+  try {
+    await execa.execa("yarn", ["--version"]);
+    return "yarn";
+  } catch {
+  }
+  return "npm";
+}
+async function installDependencies(cwd, packageManager = "pnpm") {
+  const commands = {
+    npm: ["install"],
+    pnpm: ["install"],
+    yarn: ["install"]
+  };
+  await execa.execa(packageManager, commands[packageManager], {
+    cwd,
+    stdio: "inherit"
+  });
+}
+async function runScript(cwd, script, packageManager = "pnpm") {
+  const commands = {
+    npm: ["run", script],
+    pnpm: ["run", script],
+    yarn: ["run", script]
+  };
+  await execa.execa(packageManager, commands[packageManager], {
+    cwd,
+    stdio: "inherit"
+  });
+}
+function getRunCommand(packageManager, script) {
+  const commands = {
+    npm: `npm run ${script}`,
+    pnpm: `pnpm ${script}`,
+    yarn: `yarn ${script}`
+  };
+  return commands[packageManager];
+}
+async function isGitInstalled() {
+  try {
+    await execa.execa("git", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function initGitRepository(cwd) {
+  await execa.execa("git", ["init"], { cwd });
+  const gitignore = `# Dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# Testing
+coverage/
+.nyc_output/
+
+# Production
+dist/
+build/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Misc
+.cache/
+.temp/
+.tmp/
+`;
+  await fs__default.default.writeFile(path__default.default.join(cwd, ".gitignore"), gitignore);
+}
+async function createInitialCommit(cwd) {
+  await execa.execa("git", ["add", "."], { cwd });
+  await execa.execa("git", ["commit", "-m", "Initial commit from AgentForge CLI"], { cwd });
+}
+
+// src/commands/create.ts
+async function createCommand(projectName, options) {
+  try {
+    logger.header("\u{1F680} Create AgentForge Project");
+    if (!projectName) {
+      logger.error("Project name is required");
+      process.exit(1);
+    }
+    const targetPath = path__default.default.join(process.cwd(), projectName);
+    if (!await isEmptyDir(targetPath)) {
+      logger.error(`Directory ${projectName} already exists and is not empty`);
+      process.exit(1);
+    }
+    const answers = await promptProjectSetup({
+      projectName,
+      template: options.template,
+      packageManager: options.packageManager,
+      installDependencies: options.install,
+      initGit: options.git
+    });
+    logger.newLine();
+    logger.info(`Creating project: ${chalk__default.default.cyan(answers.projectName)}`);
+    logger.info(`Template: ${chalk__default.default.cyan(answers.template)}`);
+    logger.info(`Package manager: ${chalk__default.default.cyan(answers.packageManager)}`);
+    logger.newLine();
+    logger.startSpinner("Creating project directory...");
+    await ensureDir(targetPath);
+    logger.succeedSpinner("Project directory created");
+    logger.startSpinner("Copying template files...");
+    const templatePath = getTemplatePath(answers.template);
+    await copyTemplate(templatePath, targetPath, {
+      PROJECT_NAME: answers.projectName,
+      AUTHOR: answers.author || "",
+      DESCRIPTION: answers.description || `AgentForge project created with ${answers.template} template`,
+      PACKAGE_MANAGER: answers.packageManager
+    });
+    logger.succeedSpinner("Template files copied");
+    logger.startSpinner("Updating package.json...");
+    const packageJsonPath = path__default.default.join(targetPath, "package.json");
+    const packageJson = await readJson(packageJsonPath);
+    packageJson.name = answers.projectName;
+    if (answers.author) {
+      packageJson.author = answers.author;
+    }
+    if (answers.description) {
+      packageJson.description = answers.description;
+    }
+    await writeJson(packageJsonPath, packageJson);
+    logger.succeedSpinner("package.json updated");
+    if (answers.installDependencies) {
+      logger.startSpinner("Installing dependencies...");
+      try {
+        await installDependencies(targetPath, answers.packageManager);
+        logger.succeedSpinner("Dependencies installed");
+      } catch (error) {
+        logger.failSpinner("Failed to install dependencies");
+        logger.warn("You can install them manually later");
+      }
+    }
+    if (answers.initGit && await isGitInstalled()) {
+      logger.startSpinner("Initializing git repository...");
+      try {
+        await initGitRepository(targetPath);
+        await createInitialCommit(targetPath);
+        logger.succeedSpinner("Git repository initialized");
+      } catch (error) {
+        logger.failSpinner("Failed to initialize git");
+        logger.warn("You can initialize it manually later");
+      }
+    }
+    logger.newLine();
+    logger.success(chalk__default.default.bold.green("\u2728 Project created successfully!"));
+    logger.newLine();
+    logger.header("\u{1F4DD} Next Steps");
+    logger.list([
+      `cd ${answers.projectName}`,
+      answers.installDependencies ? getRunCommand(answers.packageManager, "dev") : `${answers.packageManager} install`
+    ]);
+    logger.newLine();
+    logger.info("Happy coding! \u{1F389}");
+  } catch (error) {
+    logger.error(`Failed to create project: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/dev.ts
+async function devCommand(options) {
+  try {
+    logger.header("\u{1F680} Starting Development Server");
+    const cwd = process.cwd();
+    const packageManager = await detectPackageManager(cwd);
+    logger.info(`Port: ${options.port || "3000"}`);
+    logger.info(`Package manager: ${packageManager}`);
+    logger.newLine();
+    logger.startSpinner("Starting development server...");
+    if (options.port) {
+      process.env.PORT = options.port;
+    }
+    await runScript(cwd, "dev", packageManager);
+    logger.succeedSpinner("Development server started");
+  } catch (error) {
+    logger.failSpinner("Failed to start development server");
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/build.ts
+async function buildCommand(options) {
+  try {
+    logger.header("\u{1F4E6} Building for Production");
+    const cwd = process.cwd();
+    const packageManager = await detectPackageManager(cwd);
+    logger.info(`Minify: ${options.minify !== false ? "Yes" : "No"}`);
+    logger.info(`Sourcemap: ${options.sourcemap !== false ? "Yes" : "No"}`);
+    logger.newLine();
+    logger.startSpinner("Building project...");
+    process.env.NODE_ENV = "production";
+    if (options.minify === false) {
+      process.env.NO_MINIFY = "true";
+    }
+    if (options.sourcemap === false) {
+      process.env.NO_SOURCEMAP = "true";
+    }
+    await runScript(cwd, "build", packageManager);
+    logger.succeedSpinner("Build completed successfully");
+    logger.newLine();
+    logger.success("\u2728 Production build ready!");
+  } catch (error) {
+    logger.failSpinner("Build failed");
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/test.ts
+async function testCommand(options) {
+  try {
+    logger.header("\u{1F9EA} Running Tests");
+    const cwd = process.cwd();
+    const packageManager = await detectPackageManager(cwd);
+    logger.info(`Watch mode: ${options.watch ? "Yes" : "No"}`);
+    logger.info(`UI: ${options.ui ? "Yes" : "No"}`);
+    logger.info(`Coverage: ${options.coverage ? "Yes" : "No"}`);
+    logger.newLine();
+    logger.startSpinner("Running tests...");
+    let script = "test";
+    if (options.ui) {
+      script = "test:ui";
+    } else if (options.coverage) {
+      script = "test:coverage";
+    } else if (options.watch) {
+      script = "test:watch";
+    }
+    await runScript(cwd, script, packageManager);
+    logger.succeedSpinner("Tests completed");
+  } catch (error) {
+    logger.failSpinner("Tests failed");
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/lint.ts
+async function lintCommand(options) {
+  try {
+    logger.header("\u{1F50D} Linting Code");
+    const cwd = process.cwd();
+    const packageManager = await detectPackageManager(cwd);
+    logger.info(`Auto-fix: ${options.fix ? "Yes" : "No"}`);
+    logger.info(`Format: ${options.format !== false ? "Yes" : "No"}`);
+    logger.newLine();
+    logger.startSpinner("Running linter...");
+    try {
+      await runScript(cwd, options.fix ? "lint:fix" : "lint", packageManager);
+      logger.succeedSpinner("Linting completed");
+    } catch (error) {
+      logger.failSpinner("Linting found issues");
+      if (!options.fix) {
+        logger.info("Run with --fix to automatically fix issues");
+      }
+    }
+    if (options.format !== false) {
+      logger.startSpinner("Formatting code...");
+      try {
+        await runScript(cwd, "format", packageManager);
+        logger.succeedSpinner("Formatting completed");
+      } catch (error) {
+        logger.failSpinner("Formatting failed");
+      }
+    }
+    logger.newLine();
+    logger.success("\u2728 Code quality check completed!");
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+async function agentCreateCommand(name, options) {
+  try {
+    logger.header("\u{1F916} Create Agent");
+    const answers = await promptAgentSetup({
+      name,
+      pattern: options.pattern,
+      generateTests: options.test
+    });
+    logger.newLine();
+    logger.info(`Creating agent: ${chalk__default.default.cyan(answers.name)}`);
+    logger.info(`Pattern: ${chalk__default.default.cyan(answers.pattern)}`);
+    logger.newLine();
+    const cwd = process.cwd();
+    const agentDir = path__default.default.join(cwd, "src", "agents");
+    const agentFile = path__default.default.join(agentDir, `${answers.name}.ts`);
+    logger.startSpinner("Creating agent file...");
+    await ensureDir(agentDir);
+    const agentContent = generateAgentContent(answers.name, answers.pattern, answers.description);
+    await writeFile(agentFile, agentContent);
+    logger.succeedSpinner("Agent file created");
+    if (answers.generateTests) {
+      logger.startSpinner("Creating test file...");
+      const testDir = path__default.default.join(cwd, "tests", "agents");
+      const testFile = path__default.default.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(chalk__default.default.bold.green("\u2728 Agent created successfully!"));
+    logger.newLine();
+    logger.header("\u{1F4DD} Next Steps");
+    logger.list([
+      `Edit ${chalk__default.default.cyan(`src/agents/${answers.name}.ts`)} to customize your agent`,
+      answers.generateTests ? `Run ${chalk__default.default.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}`);
+    process.exit(1);
+  }
+}
+function generateAgentContent(name, pattern, description) {
+  const patterns = {
+    "react": `import { createReActAgent } from '@agentforge/patterns';
+import { ChatOpenAI } from '@langchain/openai';
+
+/**
+ * ${description || `${name} agent using ReAct pattern`}
+ */
+export async function create${capitalize(name)}Agent() {
+  const model = new ChatOpenAI({
+    modelName: 'gpt-4',
+    temperature: 0,
+  });
+
+  const agent = createReActAgent({
+    model,
+    tools: [],
+    // Add your configuration here
+  });
+
+  return agent;
+}
+`,
+    "plan-execute": `import { createPlanExecuteAgent } from '@agentforge/patterns';
+import { ChatOpenAI } from '@langchain/openai';
+
+/**
+ * ${description || `${name} agent using Plan-Execute pattern`}
+ */
+export async function create${capitalize(name)}Agent() {
+  const model = new ChatOpenAI({
+    modelName: 'gpt-4',
+    temperature: 0,
+  });
+
+  const agent = createPlanExecuteAgent({
+    model,
+    tools: [],
+    // Add your configuration here
+  });
+
+  return agent;
+}
+`,
+    "reflection": `import { createReflectionAgent } from '@agentforge/patterns';
+import { ChatOpenAI } from '@langchain/openai';
+
+/**
+ * ${description || `${name} agent using Reflection pattern`}
+ */
+export async function create${capitalize(name)}Agent() {
+  const model = new ChatOpenAI({
+    modelName: 'gpt-4',
+    temperature: 0,
+  });
+
+  const agent = createReflectionAgent({
+    model,
+    // Add your configuration here
+  });
+
+  return agent;
+}
+`,
+    "multi-agent": `import { createMultiAgentSystem } from '@agentforge/patterns';
+import { ChatOpenAI } from '@langchain/openai';
+
+/**
+ * ${description || `${name} multi-agent system`}
+ */
+export async function create${capitalize(name)}System() {
+  const model = new ChatOpenAI({
+    modelName: 'gpt-4',
+    temperature: 0,
+  });
+
+  const system = createMultiAgentSystem({
+    model,
+    workers: [],
+    // Add your configuration here
+  });
+
+  return system;
+}
+`
+  };
+  return patterns[pattern] || patterns["react"];
+}
+function generateTestContent(name, pattern) {
+  return `import { describe, it, expect } from 'vitest';
+import { create${capitalize(name)}${pattern === "multi-agent" ? "System" : "Agent"} } from '../../src/agents/${name}.js';
+
+describe('${capitalize(name)} ${pattern === "multi-agent" ? "System" : "Agent"}', () => {
+  it('should create agent successfully', async () => {
+    const agent = await create${capitalize(name)}${pattern === "multi-agent" ? "System" : "Agent"}();
+    expect(agent).toBeDefined();
+  });
+
+  // Add more tests here
+});
+`;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+async function agentListCommand(options) {
+  try {
+    logger.header("\u{1F4CB} List Agents");
+    const cwd = process.cwd();
+    const agentDir = path__default.default.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: ${chalk__default.default.cyan("agentforge agent:create <name>")}`);
+      return;
+    }
+    logger.info(`Found ${chalk__default.default.cyan(agentFiles.length)} agent(s):
+`);
+    for (const file of agentFiles) {
+      const agentName = path__default.default.basename(file, ".ts");
+      const agentPath = path__default.default.join(agentDir, file);
+      if (options.verbose) {
+        const content = await readFile(agentPath);
+        const pattern = extractPattern(content);
+        const description = extractDescription(content);
+        logger.info(chalk__default.default.bold.cyan(`  ${agentName}`));
+        if (pattern) {
+          logger.info(`    Pattern: ${pattern}`);
+        }
+        if (description) {
+          logger.info(`    Description: ${description}`);
+        }
+        logger.info(`    Path: ${chalk__default.default.gray(agentPath)}`);
+        logger.newLine();
+      } else {
+        logger.info(`  \u2022 ${chalk__default.default.cyan(agentName)}`);
+      }
+    }
+    if (!options.verbose) {
+      logger.newLine();
+      logger.info(`Use ${chalk__default.default.cyan("--verbose")} for more details`);
+    }
+  } catch (error) {
+    logger.error(`Failed to list agents: ${error.message}`);
+    process.exit(1);
+  }
+}
+function extractPattern(content) {
+  const patterns = ["ReAct", "Plan-Execute", "Reflection", "Multi-Agent"];
+  for (const pattern of patterns) {
+    if (content.includes(`create${pattern.replace("-", "")}Agent`)) {
+      return pattern;
+    }
+  }
+  return null;
+}
+function extractDescription(content) {
+  const match = content.match(/\/\*\*\s*\n\s*\*\s*(.+?)\s*\n/);
+  return match ? match[1] : null;
+}
+async function agentTestCommand(name, options) {
+  try {
+    logger.header("\u{1F9EA} Test Agent");
+    const cwd = process.cwd();
+    const testFile = path__default.default.join(cwd, "tests", "agents", `${name}.test.ts`);
+    if (!await pathExists(testFile)) {
+      logger.error(`Test file not found: ${testFile}`);
+      logger.info(`Create tests with: ${chalk__default.default.cyan(`agentforge agent:create ${name} --test`)}`);
+      process.exit(1);
+    }
+    logger.info(`Testing agent: ${chalk__default.default.cyan(name)}`);
+    logger.info(`Watch mode: ${options.watch ? "Yes" : "No"}`);
+    logger.newLine();
+    const packageManager = await detectPackageManager(cwd);
+    logger.startSpinner("Running tests...");
+    const testCommand2 = options.watch ? "test:watch" : "test";
+    process.env.TEST_FILE = testFile;
+    await runScript(cwd, testCommand2, packageManager);
+    logger.succeedSpinner("Tests completed");
+  } catch (error) {
+    logger.failSpinner("Tests failed");
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+async function agentDeployCommand(name, options) {
+  try {
+    logger.header("\u{1F680} Deploy Agent");
+    logger.info(`Agent: ${chalk__default.default.cyan(name)}`);
+    logger.info(`Environment: ${chalk__default.default.cyan(options.environment || "production")}`);
+    logger.info(`Dry run: ${options.dryRun ? "Yes" : "No"}`);
+    logger.newLine();
+    if (options.dryRun) {
+      logger.warn("Dry run mode - no actual deployment will occur");
+      logger.newLine();
+    }
+    logger.startSpinner("Preparing deployment...");
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    logger.succeedSpinner("Deployment prepared");
+    if (!options.dryRun) {
+      logger.startSpinner("Deploying agent...");
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      logger.succeedSpinner("Agent deployed successfully");
+    }
+    logger.newLine();
+    logger.success(chalk__default.default.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");
+  } catch (error) {
+    logger.failSpinner("Deployment failed");
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+async function toolCreateCommand(name, options) {
+  try {
+    logger.header("\u{1F527} Create Tool");
+    const answers = await promptToolSetup({
+      name,
+      category: options.category,
+      generateTests: options.test
+    });
+    logger.newLine();
+    logger.info(`Creating tool: ${chalk__default.default.cyan(answers.name)}`);
+    logger.info(`Category: ${chalk__default.default.cyan(answers.category)}`);
+    logger.newLine();
+    const cwd = process.cwd();
+    const toolDir = path__default.default.join(cwd, "src", "tools");
+    const toolFile = path__default.default.join(toolDir, `${answers.name}.ts`);
+    logger.startSpinner("Creating tool file...");
+    await ensureDir(toolDir);
+    const toolContent = generateToolContent(answers.name, answers.category, answers.description);
+    await writeFile(toolFile, toolContent);
+    logger.succeedSpinner("Tool file created");
+    if (answers.generateTests) {
+      logger.startSpinner("Creating test file...");
+      const testDir = path__default.default.join(cwd, "tests", "tools");
+      const testFile = path__default.default.join(testDir, `${answers.name}.test.ts`);
+      await ensureDir(testDir);
+      const testContent = generateTestContent2(answers.name);
+      await writeFile(testFile, testContent);
+      logger.succeedSpinner("Test file created");
+    }
+    logger.newLine();
+    logger.success(chalk__default.default.bold.green("\u2728 Tool created successfully!"));
+    logger.newLine();
+    logger.header("\u{1F4DD} Next Steps");
+    logger.list([
+      `Edit ${chalk__default.default.cyan(`src/tools/${answers.name}.ts`)} to implement your tool`,
+      answers.generateTests ? `Run ${chalk__default.default.cyan(`pnpm test tests/tools/${answers.name}.test.ts`)} to test your tool` : "",
+      `Register the tool in your agent's tool registry`
+    ].filter(Boolean));
+  } catch (error) {
+    logger.error(`Failed to create tool: ${error.message}`);
+    process.exit(1);
+  }
+}
+function generateToolContent(name, category, description) {
+  return `import { z } from 'zod';
+import { createTool } from '@agentforge/core';
+
+/**
+ * ${description}
+ * Category: ${category}
+ */
+export const ${name}Tool = createTool()
+  .name('${name}')
+  .description('${description}')
+  .category('${category}')
+  .schema(
+    z.object({
+      // Define your input schema here
+      input: z.string().describe('Input parameter'),
+    })
+  )
+  .implement(async ({ input }) => {
+    // Implement your tool logic here
+    return \`Processed: \${input}\`;
+  })
+  .build();
+`;
+}
+function generateTestContent2(name) {
+  return `import { describe, it, expect } from 'vitest';
+import { ${name}Tool } from '../../src/tools/${name}.js';
+
+describe('${capitalize2(name)} Tool', () => {
+  it('should have correct metadata', () => {
+    expect(${name}Tool.name).toBe('${name}');
+    expect(${name}Tool.description).toBeDefined();
+  });
+
+  it('should execute successfully', async () => {
+    const result = await ${name}Tool.invoke({
+      input: 'test',
+    });
+
+    expect(result).toBeDefined();
+  });
+
+  // Add more tests here
+});
+`;
+}
+function capitalize2(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+async function toolListCommand(options) {
+  try {
+    logger.header("\u{1F4CB} List Tools");
+    const cwd = process.cwd();
+    const toolDir = path__default.default.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: ${chalk__default.default.cyan("agentforge tool:create <name>")}`);
+      return;
+    }
+    let filteredTools = toolFiles;
+    if (options.category) {
+      filteredTools = [];
+      for (const file of toolFiles) {
+        const toolPath = path__default.default.join(toolDir, file);
+        const content = await readFile(toolPath);
+        const category = extractCategory(content);
+        if (category === options.category) {
+          filteredTools.push(file);
+        }
+      }
+    }
+    if (filteredTools.length === 0) {
+      logger.warn(`No tools found in category: ${options.category}`);
+      return;
+    }
+    logger.info(`Found ${chalk__default.default.cyan(filteredTools.length)} tool(s):
+`);
+    for (const file of filteredTools) {
+      const toolName = path__default.default.basename(file, ".ts");
+      const toolPath = path__default.default.join(toolDir, file);
+      if (options.verbose) {
+        const content = await readFile(toolPath);
+        const category = extractCategory(content);
+        const description = extractDescription2(content);
+        logger.info(chalk__default.default.bold.cyan(`  ${toolName}`));
+        if (category) {
+          logger.info(`    Category: ${category}`);
+        }
+        if (description) {
+          logger.info(`    Description: ${description}`);
+        }
+        logger.info(`    Path: ${chalk__default.default.gray(toolPath)}`);
+        logger.newLine();
+      } else {
+        logger.info(`  \u2022 ${chalk__default.default.cyan(toolName)}`);
+      }
+    }
+    if (!options.verbose) {
+      logger.newLine();
+      logger.info(`Use ${chalk__default.default.cyan("--verbose")} for more details`);
+    }
+  } catch (error) {
+    logger.error(`Failed to list tools: ${error.message}`);
+    process.exit(1);
+  }
+}
+function extractCategory(content) {
+  const match = content.match(/Category:\s*(\w+)/);
+  return match ? match[1] : null;
+}
+function extractDescription2(content) {
+  const match = content.match(/\/\*\*\s*\n\s*\*\s*(.+?)\s*\n/);
+  return match ? match[1] : null;
+}
+async function toolTestCommand(name, options) {
+  try {
+    logger.header("\u{1F9EA} Test Tool");
+    const cwd = process.cwd();
+    const testFile = path__default.default.join(cwd, "tests", "tools", `${name}.test.ts`);
+    if (!await pathExists(testFile)) {
+      logger.error(`Test file not found: ${testFile}`);
+      logger.info(`Create tests with: ${chalk__default.default.cyan(`agentforge tool:create ${name} --test`)}`);
+      process.exit(1);
+    }
+    logger.info(`Testing tool: ${chalk__default.default.cyan(name)}`);
+    logger.info(`Watch mode: ${options.watch ? "Yes" : "No"}`);
+    logger.newLine();
+    const packageManager = await detectPackageManager(cwd);
+    logger.startSpinner("Running tests...");
+    const testCommand2 = options.watch ? "test:watch" : "test";
+    process.env.TEST_FILE = testFile;
+    await runScript(cwd, testCommand2, packageManager);
+    logger.succeedSpinner("Tests completed");
+  } catch (error) {
+    logger.failSpinner("Tests failed");
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+async function toolPublishCommand(name, options) {
+  try {
+    logger.header("\u{1F4E6} Publish Tool");
+    logger.info(`Tool: ${chalk__default.default.cyan(name)}`);
+    logger.info(`Tag: ${chalk__default.default.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 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);
+    }
+    logger.startSpinner("Building tool...");
+    try {
+      await runScript(cwd, "build", packageManager);
+      logger.succeedSpinner("Build completed");
+    } catch (error) {
+      logger.failSpinner("Build failed");
+      process.exit(1);
+    }
+    if (!options.dryRun) {
+      logger.startSpinner("Publishing to npm...");
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      logger.succeedSpinner("Published to npm");
+    }
+    logger.newLine();
+    logger.success(chalk__default.default.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");
+  } catch (error) {
+    logger.failSpinner("Publishing failed");
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new commander.Command();
+program.name("agentforge").description("CLI tool for AgentForge - scaffolding, development, and deployment").version("0.1.0");
+program.command("create <project-name>").description("Create a new AgentForge project").option("-t, --template <template>", "Project template (minimal, full, api, cli)", "minimal").option("-p, --package-manager <pm>", "Package manager (npm, pnpm, yarn)", "pnpm").option("--no-install", "Skip dependency installation").option("--no-git", "Skip git initialization").action(createCommand);
+program.command("dev").description("Start development server with hot reload").option("-p, --port <port>", "Port number", "3000").option("--no-open", "Do not open browser").action(devCommand);
+program.command("build").description("Build for production").option("--no-minify", "Skip minification").option("--no-sourcemap", "Skip sourcemap generation").action(buildCommand);
+program.command("test").description("Run tests with coverage").option("-w, --watch", "Watch mode").option("--ui", "Open test UI").option("--coverage", "Generate coverage report").action(testCommand);
+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("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);
+var tool = program.command("tool").description("Manage tools");
+tool.command("create <name>").description("Create a new tool").option("-c, --category <category>", "Tool category (web, data, file, utility)", "utility").option("--no-test", "Skip test generation").action(toolCreateCommand);
+tool.command("list").description("List all tools").option("-c, --category <category>", "Filter by category").option("-v, --verbose", "Show detailed information").action(toolListCommand);
+tool.command("test <name>").description("Test a specific tool").option("-w, --watch", "Watch mode").action(toolTestCommand);
+tool.command("publish <name>").description("Publish a tool to npm").option("--tag <tag>", "npm tag", "latest").option("--dry-run", "Dry run without actual publishing").action(toolPublishCommand);
+program.exitOverride();
+async function run() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (error.code !== "commander.help" && error.code !== "commander.version") {
+      console.error(chalk__default.default.red("Error:"), error.message);
+      process.exit(1);
+    }
+  }
+}
+
+exports.program = program;
+exports.run = run;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map