@agentforge/cli 0.1.0

package/templates/api/src/routes/agent.ts

@@ -0,0 +1,54 @@
+import { Router } from 'express';
+import { ChatOpenAI } from '@langchain/openai';
+import { createReActAgent } from '@agentforge/patterns';
+import { createLogger } from '@agentforge/core';
+
+const router = Router();
+const logger = createLogger({ level: 'info' });
+
+// Initialize the agent
+const model = new ChatOpenAI({
+  modelName: process.env.OPENAI_MODEL || 'gpt-4',
+  temperature: 0,
+});
+
+const agent = createReActAgent({
+  model,
+  tools: [],
+  systemPrompt: 'You are a helpful AI assistant API.',
+});
+
+const compiledAgent = agent.compile();
+
+// POST /api/agent/chat
+router.post('/chat', async (req, res) => {
+  try {
+    const { message } = req.body;
+
+    if (!message) {
+      return res.status(400).json({ error: 'Message is required' });
+    }
+
+    logger.info('Processing chat request');
+
+    const result = await compiledAgent.invoke({
+      messages: [{ role: 'user', content: message }],
+    });
+
+    const response = result.messages[result.messages.length - 1].content;
+
+    res.json({
+      success: true,
+      response,
+    });
+  } catch (error: any) {
+    logger.error('Chat error:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message,
+    });
+  }
+});
+
+export { router as agentRouter };
+

package/templates/api/src/routes/health.ts

@@ -0,0 +1,15 @@
+import { Router } from 'express';
+
+const router = Router();
+
+// GET /health
+router.get('/', (req, res) => {
+  res.json({
+    status: 'healthy',
+    timestamp: new Date().toISOString(),
+    uptime: process.uptime(),
+  });
+});
+
+export { router as healthRouter };
+

package/templates/api/src/server.ts

@@ -0,0 +1,41 @@
+import 'dotenv/config';
+import express from 'express';
+import cors from 'cors';
+import { createLogger } from '@agentforge/core';
+import { agentRouter } from './routes/agent.js';
+import { healthRouter } from './routes/health.js';
+
+const logger = createLogger({ level: 'info' });
+const app = express();
+const port = process.env.PORT || 3000;
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+
+// Request logging
+app.use((req, res, next) => {
+  logger.info(`${req.method} ${req.path}`);
+  next();
+});
+
+// Routes
+app.use('/health', healthRouter);
+app.use('/api/agent', agentRouter);
+
+// Error handling
+app.use((err: Error, req: express.Request, res: express.Response, next: express.NextFunction) => {
+  logger.error('Error:', err);
+  res.status(500).json({
+    error: 'Internal server error',
+    message: err.message,
+  });
+});
+
+// Start server
+app.listen(port, () => {
+  logger.info(`🚀 Server running on http://localhost:${port}`);
+  logger.info(`📊 Health check: http://localhost:${port}/health`);
+  logger.info(`🤖 Agent API: http://localhost:${port}/api/agent`);
+});
+

package/templates/api/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}
+

package/templates/cli/.env.example

@@ -0,0 +1,13 @@
+# OpenAI Configuration
+OPENAI_API_KEY=your-api-key-here
+OPENAI_MODEL=gpt-4
+
+# LangSmith Configuration (optional)
+LANGCHAIN_TRACING_V2=false
+LANGCHAIN_API_KEY=your-langsmith-api-key
+LANGCHAIN_PROJECT={{PROJECT_NAME}}
+
+# Application Configuration
+NODE_ENV=development
+LOG_LEVEL=info
+

package/templates/cli/README.md

@@ -0,0 +1,164 @@
+# {{PROJECT_NAME}}
+
+{{PROJECT_DESCRIPTION}}
+
+A command-line interface powered by AgentForge agents.
+
+## Features
+
+- ✅ Interactive chat command
+- ✅ File analysis command
+- ✅ Commander.js CLI framework
+- ✅ Colored output (chalk)
+- ✅ Spinners and progress (ora)
+- ✅ Interactive prompts (inquirer)
+- ✅ ReAct agent integration
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js 18+
+- pnpm (recommended) or npm
+- OpenAI API key
+
+### Installation
+
+```bash
+pnpm install
+```
+
+### Configuration
+
+1. Copy `.env.example` to `.env`:
+```bash
+cp .env.example .env
+```
+
+2. Add your OpenAI API key to `.env`:
+```
+OPENAI_API_KEY=your-api-key-here
+```
+
+### Development
+
+```bash
+# Run in development mode
+pnpm dev chat
+
+# Build for production
+pnpm build
+
+# Run built CLI
+pnpm start chat
+```
+
+## Commands
+
+### Chat
+Start an interactive chat session with the AI:
+
+```bash
+{{PROJECT_NAME}} chat
+
+# Use a different model
+{{PROJECT_NAME}} chat --model gpt-3.5-turbo
+```
+
+### Analyze
+Analyze a file using AI:
+
+```bash
+{{PROJECT_NAME}} analyze myfile.txt
+
+# Save results to a file
+{{PROJECT_NAME}} analyze myfile.txt --output analysis.txt
+```
+
+## Project Structure
+
+```
+{{PROJECT_NAME}}/
+├── src/
+│   ├── cli.ts                # CLI entry point
+│   └── commands/
+│       ├── chat.ts           # Chat command
+│       └── analyze.ts        # Analyze command
+├── .env.example              # Environment variables template
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+## Adding Commands
+
+Create a new command file in `src/commands/`:
+
+```typescript
+import chalk from 'chalk';
+import ora from 'ora';
+
+interface MyCommandOptions {
+  option?: string;
+}
+
+export async function myCommand(options: MyCommandOptions) {
+  console.log(chalk.cyan('Running my command...'));
+  
+  const spinner = ora('Processing...').start();
+  
+  try {
+    // Command logic here
+    spinner.succeed('Done!');
+  } catch (error: any) {
+    spinner.fail('Failed');
+    console.error(chalk.red('Error:'), error.message);
+  }
+}
+```
+
+Then register it in `src/cli.ts`:
+
+```typescript
+import { myCommand } from './commands/my-command.js';
+
+program
+  .command('my-command')
+  .description('Description of my command')
+  .option('-o, --option <value>', 'Option description')
+  .action(myCommand);
+```
+
+## Building for Distribution
+
+```bash
+# Build
+pnpm build
+
+# Link globally for testing
+npm link
+
+# Now you can run from anywhere
+{{PROJECT_NAME}} chat
+```
+
+## Publishing
+
+```bash
+# Update version in package.json
+npm version patch
+
+# Publish to npm
+npm publish
+```
+
+## Learn More
+
+- [AgentForge Documentation](../../docs/)
+- [Commander.js Documentation](https://github.com/tj/commander.js)
+- [CLI Best Practices](../../docs/guides/cli-best-practices.md)
+
+## License
+
+MIT
+

package/templates/cli/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "description": "{{PROJECT_DESCRIPTION}}",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "{{PROJECT_NAME}}": "./dist/cli.js"
+  },
+  "scripts": {
+    "dev": "tsx watch src/cli.ts",
+    "build": "tsup",
+    "start": "node dist/cli.js",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write ."
+  },
+  "dependencies": {
+    "@agentforge/core": "workspace:*",
+    "@agentforge/patterns": "workspace:*",
+    "@langchain/openai": "^0.3.14",
+    "langchain": "^0.3.7",
+    "zod": "^3.24.1",
+    "dotenv": "^16.4.7",
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.1.1",
+    "inquirer": "^12.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "eslint": "^9.17.0",
+    "prettier": "^3.4.2",
+    "tsup": "^8.3.5",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}
+

package/templates/cli/src/cli.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { chatCommand } from './commands/chat.js';
+import { analyzeCommand } from './commands/analyze.js';
+
+const program = new Command();
+
+program
+  .name('{{PROJECT_NAME}}')
+  .description('{{PROJECT_DESCRIPTION}}')
+  .version('0.1.0');
+
+// Chat command
+program
+  .command('chat')
+  .description('Start an interactive chat session')
+  .option('-m, --model <model>', 'LLM model to use', 'gpt-4')
+  .action(chatCommand);
+
+// Analyze command
+program
+  .command('analyze <file>')
+  .description('Analyze a file using AI')
+  .option('-o, --output <file>', 'Output file for results')
+  .action(analyzeCommand);
+
+// Parse arguments
+program.parse();
+

package/templates/cli/src/commands/analyze.ts

@@ -0,0 +1,65 @@
+import fs from 'fs/promises';
+import chalk from 'chalk';
+import ora from 'ora';
+import { ChatOpenAI } from '@langchain/openai';
+import { createReActAgent } from '@agentforge/patterns';
+
+interface AnalyzeOptions {
+  output?: string;
+}
+
+export async function analyzeCommand(file: string, options: AnalyzeOptions) {
+  console.log(chalk.bold.cyan('\n📊 File Analysis\n'));
+
+  const spinner = ora('Reading file...').start();
+
+  try {
+    // Read the file
+    const content = await fs.readFile(file, 'utf-8');
+    spinner.text = 'Analyzing with AI...';
+
+    // Create agent
+    const model = new ChatOpenAI({
+      modelName: 'gpt-4',
+      temperature: 0,
+    });
+
+    const agent = createReActAgent({
+      model,
+      tools: [],
+      systemPrompt: 'You are a code analysis expert. Analyze the provided file and give insights.',
+    });
+
+    const compiledAgent = agent.compile();
+
+    // Analyze
+    const result = await compiledAgent.invoke({
+      messages: [
+        {
+          role: 'user',
+          content: `Analyze this file:\n\n${content}`,
+        },
+      ],
+    });
+
+    const analysis = result.messages[result.messages.length - 1].content;
+
+    spinner.succeed('Analysis complete');
+
+    console.log(chalk.bold('\nAnalysis Results:\n'));
+    console.log(analysis);
+
+    // Save to file if output specified
+    if (options.output) {
+      await fs.writeFile(options.output, analysis);
+      console.log(chalk.green(`\n✅ Results saved to ${options.output}`));
+    }
+
+    console.log();
+  } catch (error: any) {
+    spinner.fail('Analysis failed');
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+}
+

package/templates/cli/src/commands/chat.ts

@@ -0,0 +1,65 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { ChatOpenAI } from '@langchain/openai';
+import { createReActAgent } from '@agentforge/patterns';
+
+interface ChatOptions {
+  model?: string;
+}
+
+export async function chatCommand(options: ChatOptions) {
+  console.log(chalk.bold.cyan('\n🤖 AI Chat Session\n'));
+  console.log(chalk.gray('Type "exit" or "quit" to end the session\n'));
+
+  const model = new ChatOpenAI({
+    modelName: options.model || 'gpt-4',
+    temperature: 0.7,
+  });
+
+  const agent = createReActAgent({
+    model,
+    tools: [],
+    systemPrompt: 'You are a helpful AI assistant in a CLI chat session.',
+  });
+
+  const compiledAgent = agent.compile();
+  const messages: any[] = [];
+
+  while (true) {
+    const { message } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'message',
+        message: chalk.green('You:'),
+      },
+    ]);
+
+    if (message.toLowerCase() === 'exit' || message.toLowerCase() === 'quit') {
+      console.log(chalk.yellow('\n👋 Goodbye!\n'));
+      break;
+    }
+
+    if (!message.trim()) {
+      continue;
+    }
+
+    const spinner = ora('Thinking...').start();
+
+    try {
+      messages.push({ role: 'user', content: message });
+
+      const result = await compiledAgent.invoke({ messages });
+      const response = result.messages[result.messages.length - 1].content;
+
+      messages.push({ role: 'assistant', content: response });
+
+      spinner.stop();
+      console.log(chalk.blue('AI:'), response, '\n');
+    } catch (error: any) {
+      spinner.fail('Error');
+      console.error(chalk.red('Error:'), error.message, '\n');
+    }
+  }
+}
+

package/templates/cli/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}
+

package/templates/full/.env.example

@@ -0,0 +1,13 @@
+# OpenAI Configuration
+OPENAI_API_KEY=your-api-key-here
+OPENAI_MODEL=gpt-4
+
+# LangSmith Configuration (optional)
+LANGCHAIN_TRACING_V2=false
+LANGCHAIN_API_KEY=your-langsmith-api-key
+LANGCHAIN_PROJECT={{PROJECT_NAME}}
+
+# Application Configuration
+NODE_ENV=development
+LOG_LEVEL=info
+

package/templates/full/README.md

@@ -0,0 +1,151 @@
+# {{PROJECT_NAME}}
+
+{{PROJECT_DESCRIPTION}}
+
+## Features
+
+- ✅ ReAct agent pattern with tool support
+- ✅ Example tool implementation
+- ✅ Logging and error handling
+- ✅ Environment configuration
+- ✅ Test suite with Vitest
+- ✅ TypeScript support
+- ✅ Hot reload development
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js 18+
+- pnpm (recommended) or npm
+- OpenAI API key
+
+### Installation
+
+```bash
+pnpm install
+```
+
+### Configuration
+
+1. Copy `.env.example` to `.env`:
+```bash
+cp .env.example .env
+```
+
+2. Add your OpenAI API key to `.env`:
+```
+OPENAI_API_KEY=your-api-key-here
+```
+
+### Development
+
+```bash
+# Run in development mode with hot reload
+pnpm dev
+
+# Build for production
+pnpm build
+
+# Run tests
+pnpm test
+
+# Run tests with UI
+pnpm test:ui
+
+# Run tests with coverage
+pnpm test:coverage
+
+# Type check
+pnpm typecheck
+
+# Lint code
+pnpm lint
+```
+
+## Project Structure
+
+```
+{{PROJECT_NAME}}/
+├── src/
+│   ├── index.ts              # Main entry point
+│   └── tools/
+│       └── example.ts        # Example tool
+├── tests/
+│   └── example.test.ts       # Example tests
+├── .env.example              # Environment variables template
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+## Adding Tools
+
+Create a new tool in `src/tools/`:
+
+```typescript
+import { z } from 'zod';
+import { createTool } from '@agentforge/core';
+
+export const myTool = createTool()
+  .name('my_tool')
+  .description('Description of what the tool does')
+  .category('utility')
+  .schema(
+    z.object({
+      input: z.string().describe('Input parameter'),
+    })
+  )
+  .implement(async ({ input }) => {
+    // Tool implementation
+    return `Result: ${input}`;
+  })
+  .build();
+```
+
+Then register it in `src/index.ts`:
+
+```typescript
+import { myTool } from './tools/my-tool.js';
+
+const agent = createReActAgent({
+  model,
+  tools: [exampleTool, myTool],
+  // ...
+});
+```
+
+## Testing
+
+Write tests in the `tests/` directory:
+
+```typescript
+import { describe, it, expect } from 'vitest';
+import { myTool } from '../src/tools/my-tool.js';
+
+describe('My Tool', () => {
+  it('should work correctly', async () => {
+    const result = await myTool.invoke({ input: 'test' });
+    expect(result).toBeDefined();
+  });
+});
+```
+
+## Deployment
+
+See the [deployment guides](../../templates/deployment/) for deploying to:
+- AWS (Lambda, ECS, EKS)
+- Google Cloud (Cloud Run, GKE)
+- Azure (Container Apps, AKS)
+
+## Learn More
+
+- [AgentForge Documentation](../../docs/)
+- [Agent Patterns Guide](../../docs/guides/patterns/)
+- [Tool Development Guide](../../docs/guides/tools/)
+- [Middleware Guide](../../docs/guides/middleware-guide.md)
+
+## License
+
+MIT
+