@iservu-inc/adf-cli 0.12.12 → 0.14.0

package/lib/commands/guide.js

@@ -7,57 +7,68 @@ const TOOL_GUIDES = {
     name: 'Codeium Windsurf',
     files: [
       { path: '.windsurfrules', desc: 'Legacy rules file (deprecated)' },
-      { path: '.windsurf/rules/*.md', desc: 'Modular rules (one per agent)' },
+      { path: '.windsurf/rules/*.md', desc: 'Modular rules (max 12000 chars per file)' },
       { path: '.windsurf/workflows/*.md', desc: 'Workflow definitions' },
       { path: 'AGENTS.md', desc: 'Universal agent manifest (ANDF standard)' }
     ],
     setup: [
-      '1. Open your project in Windsurf IDE',
-      '2. Windsurf automatically detects .windsurfrules and .windsurf/ directory',
-      '3. Agent rules are loaded when you start a coding session',
-      '4. Use Cmd/Ctrl+L to open AI chat with agent context'
+      '1. Download and install Windsurf from: https://codeium.com/windsurf',
+      '2. Open your project in Windsurf IDE',
+      '3. Create .windsurf/rules/ directory for modular rules',
+      '4. Each .md file in rules/ directory auto-loaded (max 12000 chars)',
+      '5. Rules active immediately in Cascade AI'
     ],
     usage: [
-      '• Start coding - agents automatically follow project rules',
-      '• Use @agents.md to reference the agent manifest',
-      '• Access workflows via Cmd/Ctrl+K → Select Workflow',
-      '• Agents adapt based on your workflow level (rapid/balanced/comprehensive)'
+      '• Cmd/Ctrl+L - Open Cascade AI chat',
+      '• Rules from .windsurf/rules/*.md applied automatically',
+      '• Character limit: 12000 chars per rule file',
+      '• Split large agents across multiple .md files if needed',
+      '• Use @agents.md to reference manifest explicitly',
+      '• Workflows in .windsurf/workflows/ directory',
+      '• Docs: https://docs.windsurf.com/windsurf/cascade/memories'
     ],
     mcpServers: [],
     troubleshooting: [
-      '• Rules not loading? Check .windsurf/rules/ contains .md files',
-      '• Restart Windsurf if rules don\'t update',
-      '• Check Output → Windsurf for any parsing errors'
+      '• Rules not loading? Check each .md file is ≤12000 characters',
+      '• Verify .windsurf/rules/ directory exists',
+      '• Restart Windsurf IDE after adding new rules',
+      '• Check View → Output → Windsurf for parsing errors'
     ]
   },
 
   'cursor': {
     name: 'Cursor AI IDE',
     files: [
-      { path: '.cursor/rules', desc: 'Cursor rules file (symlink to AGENTS.md)' },
-      { path: '.cursorrules', desc: 'Deprecated - shows migration notice' },
+      { path: '.cursor/rules/*.mdc', desc: 'Cursor rules with YAML frontmatter' },
+      { path: '.cursorrules', desc: 'Legacy single-file rules (deprecated)' },
       { path: 'AGENTS.md', desc: 'Universal agent manifest' },
       { path: '.context/', desc: 'Deep context (architecture, glossary)' }
     ],
     setup: [
-      '1. Open your project in Cursor',
-      '2. Cursor automatically reads .cursor/rules (which links to AGENTS.md)',
-      '3. Rules are active in all AI interactions (Cmd/Ctrl+K and Cmd/Ctrl+L)',
-      '4. No additional setup needed!'
+      '1. Download and install Cursor from: https://cursor.sh',
+      '2. Open your project in Cursor',
+      '3. Create .cursor/rules/ directory',
+      '4. Add .mdc files with YAML frontmatter (see usage)',
+      '5. Rules auto-apply to Agent (Cmd/Ctrl+L) and Cmd+K'
     ],
     usage: [
-      '• Cmd/Ctrl+K - Inline code generation with agent context',
-      '• Cmd/Ctrl+L - Chat with AI using project rules',
-      '• Use @AGENTS.md to explicitly reference agent instructions',
-      '• Use @.context/memory/ for architecture details',
+      '• Cmd/Ctrl+K - Inline editing with rules applied',
+      '• Cmd/Ctrl+L - Chat (Agent) with rules applied',
+      '• Rules format (.mdc file):',
+      '  ---',
+      '  title: Developer Agent',
+      '  description: Development guidelines',
+      '  ---',
+      '  [Your agent instructions here]',
+      '• Use @AGENTS.md to reference manifest',
       '• Tab to accept AI suggestions'
     ],
     mcpServers: [],
     troubleshooting: [
-      '• Rules not active? Check .cursor/rules exists',
-      '• Verify symlink: should point to ../AGENTS.md',
-      '• Restart Cursor if rules don\'t apply',
-      '• Check Settings → Features → Rules enabled'
+      '• Rules not active? Check .cursor/rules/ directory exists',
+      '• Verify .mdc files have valid YAML frontmatter',
+      '• Restart Cursor after adding new rules',
+      '• Check Cursor Settings → Features → Rules enabled'
     ]
   },
 
@@ -65,103 +76,106 @@ const TOOL_GUIDES = {
     name: 'Visual Studio Code (GitHub Copilot)',
     files: [
       { path: '.github/copilot-instructions.md', desc: 'GitHub Copilot custom instructions' },
-      { path: '.vscode/settings.json', desc: 'Custom chat participants and commands' },
+      { path: '.vscode/settings.json', desc: 'Workspace settings' },
       { path: 'AGENTS.md', desc: 'Universal agent manifest' },
       { path: '.context/', desc: 'Deep context directory' }
     ],
     setup: [
-      '1. Install GitHub Copilot extension in VS Code',
-      '2. Open your project - settings load automatically',
-      '3. Custom instructions are read by Copilot automatically',
-      '4. Restart VS Code to load custom chat modes'
+      '1. Download VS Code from: https://code.visualstudio.com',
+      '2. Install GitHub Copilot extension from marketplace',
+      '3. Create .github/copilot-instructions.md in project root',
+      '4. Copilot automatically reads instructions on chat start',
+      '5. No restart needed - instructions load per conversation'
     ],
     usage: [
-      '• Use @workspace to include project context in Copilot chat',
+      '• Cmd/Ctrl+I - Inline Copilot chat',
+      '• Cmd/Ctrl+Shift+I - Copilot panel (sidebar)',
       '• Copilot reads .github/copilot-instructions.md automatically',
-      '• Custom chat participants defined in settings.json:',
-      '  - @architect - Architecture discussions',
-      '  - @reviewer - Code review',
-      '  - @planner - Planning and estimation',
-      '• Inline suggestions follow your project\'s patterns'
+      '• Use @workspace to include entire workspace context',
+      '• Reference specific files: @filename.js',
+      '• Instructions format: Plain markdown in copilot-instructions.md',
+      '• Documentation: https://docs.github.com/copilot'
     ],
     mcpServers: [],
     troubleshooting: [
-      '• Instructions not working? Check GitHub Copilot is active',
-      '• Verify .github/copilot-instructions.md exists',
-      '• Settings not loading? Reload VS Code window',
-      '• Check Copilot status in bottom-right status bar'
+      '• Instructions not loading? Verify .github/ directory exists',
+      '• Check Copilot status icon in bottom-right corner',
+      '• Restart Copilot: Cmd/Ctrl+Shift+P → "Copilot: Restart"',
+      '• Verify GitHub Copilot subscription is active'
     ]
   },
 
   'zed': {
     name: 'Zed Editor',
     files: [
-      { path: '.zed/settings.json', desc: 'Zed-specific settings with MCP config' },
-      { path: '.zed/keymap.json', desc: 'Agent switching shortcuts' },
-      { path: '.zed/rules', desc: 'Symlink to AGENTS.md' },
+      { path: '.zed/settings.json', desc: 'Project-specific settings' },
       { path: 'AGENTS.md', desc: 'Universal agent manifest' },
-      { path: '.context/', desc: 'Deep context accessible via MCP' }
+      { path: '.context/', desc: 'Deep context directory' }
     ],
     setup: [
-      '1. Open your project in Zed',
-      '2. Zed reads .zed/settings.json automatically',
-      '3. MCP servers start automatically (project_context, archon)',
-      '4. Use keyboard shortcuts to switch agents (Ctrl+Shift+A)'
+      '1. Download and install Zed from: https://zed.dev',
+      '2. Open your project in Zed',
+      '3. Create .zed/settings.json in project root (optional)',
+      '4. Global settings at: ~/.config/zed/settings.json',
+      '5. MCP servers configured in settings.json'
     ],
     usage: [
-      '• Ctrl+Shift+A - Switch active agent',
-      '• Ctrl+Enter - Quick agent action',
-      '• Ctrl+Shift+L - List available tools/workflows',
-      '• Agents access .context/ via MCP filesystem server',
-      '• Use /assistant to interact with current agent'
+      '• /assistant - Open AI assistant panel',
+      '• Cmd/Ctrl+Enter - Submit to assistant',
+      '• Configure MCP servers in settings.json:',
+      '  {',
+      '    "context_servers": {',
+      '      "project": {',
+      '        "command": "npx",',
+      '        "args": ["@modelcontextprotocol/server-filesystem", ".context"]',
+      '      }',
+      '    }',
+      '  }',
+      '• Reference AGENTS.md manually in conversation'
     ],
     mcpServers: [
       {
-        name: 'project_context',
-        command: 'npx @modelcontextprotocol/server-filesystem .context',
-        desc: 'Provides read-only access to .context/ directory'
-      },
-      {
-        name: 'archon',
-        url: 'http://archon.ad.iservu.cc:8051/mcp',
-        desc: 'Internal API documentation and RAG (if available)'
+        name: 'filesystem',
+        command: 'npx @modelcontextprotocol/server-filesystem',
+        desc: 'Provides file access via MCP protocol'
       }
     ],
     troubleshooting: [
-      '• Rules not loading? Check .zed/rules symlink exists',
-      '• MCP servers not starting? Check Node.js is installed',
-      '• Verify MCP config in .zed/settings.json',
-      '• Check Zed logs: View → Debug → Show Logs'
+      '• MCP servers not starting? Check Node.js installed',
+      '• Verify settings.json syntax is valid JSON',
+      '• Check Zed logs: View → Debug → Developer Tools',
+      '• Documentation: https://zed.dev/docs'
     ]
   },
 
   'antigravity': {
     name: 'Google Antigravity',
     files: [
-      { path: '.antigravity/agents.yaml', desc: 'Antigravity agent configuration' },
-      { path: 'AGENTS.md', desc: 'Universal agent manifest (mounted in container)' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest' },
       { path: '.context/', desc: 'Deep context (architecture, glossary)' }
     ],
     setup: [
-      '1. Open your project in Antigravity',
-      '2. Antigravity reads .antigravity/agents.yaml',
-      '3. AGENTS.md is mounted read-only in agent filesystem',
-      '4. Agent automatically reads AGENTS.md on startup',
-      '5. No additional setup needed!'
+      '1. Access Antigravity (Google internal tool)',
+      '2. Open your project or codebase',
+      '3. Click ... menu → Customizations',
+      '4. Add Rules and Workflows via customization UI',
+      '5. Rules and workflows saved automatically'
     ],
     usage: [
-      '• Agent has access to AGENTS.md via file system mount',
-      '• .context/ directory accessible for architecture details',
-      '• Use conversational commands: "follow the dev agent workflow"',
-      '• Agent references AGENTS.md automatically for instructions',
-      '• Switch agent modes by referencing different roles in AGENTS.md'
+      '• Access customizations: Click ... → Customizations',
+      '• Rules: Add custom instructions for AI behavior',
+      '• Workflows: Define multi-step processes',
+      '• Reference project files in conversation',
+      '• Use "Read AGENTS.md" to access agent manifest',
+      '• Conversational commands: "Follow dev workflow"',
+      '• .context/ directory accessible for detailed docs'
     ],
     mcpServers: [],
     troubleshooting: [
-      '• Agent not following rules? Check .antigravity/agents.yaml exists',
-      '• Verify AGENTS.md file path in filesystem mount',
-      '• Check agent logs for AGENTS.md read confirmation',
-      '• Restart Antigravity session if config doesn\'t load'
+      '• Customizations not applying? Check ... → Customizations menu',
+      '• Restart Antigravity session if changes not reflected',
+      '• Verify rules syntax is correct in customization UI',
+      '• Contact Google internal support for Antigravity issues'
     ]
   },
 
@@ -169,77 +183,84 @@ const TOOL_GUIDES = {
     name: 'Claude Code CLI',
     files: [
       { path: '.framework/agents/*.md', desc: 'Agent definition files (analyst, pm, dev, qa, etc.)' },
+      { path: '.claude/commands/', desc: 'Custom commands directory' },
       { path: 'AGENTS.md', desc: 'Universal agent manifest' },
       { path: '.context/', desc: 'Deep context directory' }
     ],
     setup: [
-      '1. Navigate to your project directory',
-      '2. Run: claude-code --agents .framework/agents/',
-      '3. Or configure in .claude/settings.json:',
-      '   {',
-      '     "agentsPath": ".framework/agents/"',
-      '   }',
-      '4. Claude Code loads agents automatically'
+      '1. Install Claude Code: curl -fsSL https://claude.ai/install.sh | bash',
+      '2. Authenticate: Follow prompts after installation',
+      '3. Navigate to your project directory',
+      '4. Custom commands in .claude/commands/ (optional)',
+      '5. Reference agent files manually in conversation'
     ],
     usage: [
       '• Start chat: claude-code',
-      '• Agents are available as slash commands:',
-      '  /dev - Switch to developer agent',
-      '  /pm - Switch to product manager agent',
-      '  /qa - Switch to QA engineer agent',
-      '• Reference AGENTS.md in chat: "read AGENTS.md"',
-      '• Access requirements: "show me .adf/sessions/*/outputs/"'
+      '• Interactive terminal-based chat with Claude',
+      '• Reference project files: "read .framework/agents/dev.md"',
+      '• Access AGENTS.md: "follow instructions in AGENTS.md"',
+      '• Custom commands: Place scripts in .claude/commands/',
+      '• Requirements: "show .adf/sessions/*/outputs/"',
+      '• Documentation: https://claude.ai/code'
     ],
     mcpServers: [
       {
         name: 'filesystem',
-        desc: 'Can be configured to access project files',
-        command: 'Add to .claude/settings.json MCP servers config'
+        desc: 'Can be configured via .claude/settings.json',
+        command: 'Configure MCP servers in settings file'
       }
     ],
     troubleshooting: [
-      '• Agents not loading? Check .framework/agents/ contains .md files',
-      '• Verify agentsPath in .claude/settings.json',
-      '• Run: claude-code doctor to check configuration',
-      '• Check for agent file read permissions'
+      '• Installation issues? Check: https://claude.ai/code',
+      '• Command not found? Restart terminal after install',
+      '• Authentication failed? Run installation script again',
+      '• Custom commands not working? Check .claude/commands/ permissions'
     ]
   },
 
   'opencode': {
     name: 'OpenCode CLI',
     files: [
-      { path: '.opencode.json', desc: 'OpenCode project configuration' },
-      { path: 'AGENTS.md', desc: 'Universal agent manifest' },
+      { path: '.opencode.json', desc: 'OpenCode multi-agent configuration' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest (auto-referenced)' },
       { path: '.context/', desc: 'Deep context directory' }
     ],
     setup: [
-      '1. Navigate to your project directory',
-      '2. Run: opencode init (if not already initialized)',
-      '3. OpenCode reads .opencode.json automatically',
-      '4. MCP filesystem server starts automatically',
-      '5. Agents configured based on workflow level'
+      '1. Install: npm install -g opencode-ai@latest',
+      '2. Or quick install: curl -fsSL https://opencode.ai/install | bash',
+      '3. Authenticate: opencode (interactive provider setup)',
+      '4. Navigate to your project directory',
+      '5. OpenCode reads .opencode.json automatically'
     ],
     usage: [
-      '• Start coding session: opencode',
-      '• Agents automatically have project context',
-      '• MCP provides access to all project files',
-      '• Use natural language for tasks:',
-      '  "Implement the login feature"',
-      '  "Review the authentication code"',
-      '  "Run tests and fix failures"'
+      '• Start session: opencode',
+      '• Terminal-based AI coding agent (TUI)',
+      '• Supports multiple AI providers (Anthropic, OpenAI, Google, OpenRouter)',
+      '• Multi-agent system with specialized agents:',
+      '  - dev (primary): Senior software engineer',
+      '  - analyst: Business analyst for requirements',
+      '  - pm: Product manager for planning',
+      '  - architect: Solutions architect for design',
+      '  - qa: QA engineer for testing',
+      '  - sm: Scrum master for agile workflow',
+      '• Configuration schema: https://opencode.ai/config.json',
+      '• Auto-loads AGENTS.md and session outputs',
+      '• Documentation: https://opencode.ai/docs'
     ],
     mcpServers: [
       {
-        name: 'filesystem',
-        command: 'npx -y @modelcontextprotocol/server-filesystem',
-        desc: 'Provides full project file access'
+        name: 'project_filesystem',
+        desc: 'Provides project file access via MCP protocol',
+        command: 'npx -y @modelcontextprotocol/server-filesystem'
       }
     ],
     troubleshooting: [
-      '• Config not loading? Check .opencode.json syntax',
-      '• MCP errors? Ensure npx is available',
-      '• Verify Node.js version >= 18.0.0',
-      '• Run: opencode --version to check installation'
+      '• Command not found? Restart terminal after install',
+      '• Config errors? Validate against: https://opencode.ai/config.json',
+      '• Provider auth issues? Run: opencode (interactive setup)',
+      '• Check version: opencode --version',
+      '• Documentation: https://opencode.ai/docs',
+      '• GitHub: https://github.com/anomalyco/opencode/issues'
     ]
   },
 
@@ -251,26 +272,26 @@ const TOOL_GUIDES = {
       { path: '.context/', desc: 'Deep context directory' }
     ],
     setup: [
-      '1. Install Gemini CLI: npm install -g @google/generative-ai-cli',
-      '2. Configure API key: export GOOGLE_API_KEY=your_key',
-      '3. Navigate to your project directory',
-      '4. Gemini CLI automatically detects GEMINI.md'
+      '1. Install Gemini CLI: npm install -g @google/gemini-cli',
+      '2. Configure API key: gemini auth (interactive setup)',
+      '3. Or set manually: export GOOGLE_API_KEY=your_key',
+      '4. Navigate to your project directory',
+      '5. Start CLI: gemini (not gemini-cli)'
     ],
     usage: [
-      '• Start session: gemini-cli',
-      '• Gemini reads GEMINI.md automatically for context',
-      '• Reference project docs:',
-      '  "Read the requirements in .adf/sessions/"',
-      '  "Follow the workflow defined in GEMINI.md"',
-      '• Use for code generation, review, and planning',
-      '• Agent adapts based on your workflow level'
+      '• Start session: gemini',
+      '• Interactive chat interface with Google Gemini models',
+      '• Reference project files: gemini --file path/to/file',
+      '• Use GEMINI.md for project context (reference manually)',
+      '• Access requirements: "Read .adf/sessions/*/outputs/"',
+      '• Documentation: https://geminicli.com'
     ],
     mcpServers: [],
     troubleshooting: [
-      '• GEMINI.md not detected? Check file exists in project root',
-      '• API key issues? Verify GOOGLE_API_KEY is set',
-      '• Check Gemini CLI version: gemini-cli --version',
-      '• Review GEMINI.md for correct formatting'
+      '• Command not found? Verify npm global install path in PATH',
+      '• API key issues? Run: gemini auth',
+      '• Check installation: gemini --version',
+      '• Documentation: https://geminicli.com/docs'
     ]
   },
 
@@ -282,24 +303,26 @@ const TOOL_GUIDES = {
       { path: 'AGENTS.md', desc: 'Universal agent manifest' }
     ],
     setup: [
-      '1. Install DeepAgent: pip install deepagent',
-      '2. Navigate to your project directory',
-      '3. Run: deepagent init (loads .deepagent/ config)',
-      '4. Agents are loaded automatically'
+      '1. Install Abacus.ai CLI: npm install -g @abacus-ai/cli',
+      '2. Authenticate: abacusai login',
+      '3. Navigate to your project directory',
+      '4. DeepAgent configurations in .deepagent/ directory',
+      '5. Use command: abacusai (not deepagent)'
     ],
     usage: [
-      '• Start session: deepagent',
-      '• Switch agents: deepagent --agent dev',
-      '• Agents read their .md files for instructions',
-      '• Use natural language for development tasks',
-      '• DeepAgent follows workflow level automatically'
+      '• Start session: abacusai',
+      '• Terminal/CLI interface for Abacus.ai platform',
+      '• Access DeepAgent features via CLI commands',
+      '• Agent markdown files can be referenced manually',
+      '• Check available commands: abacusai --help',
+      '• Documentation: https://abacus.ai/docs'
     ],
     mcpServers: [],
     troubleshooting: [
-      '• Agents not loading? Check .deepagent/agents/ directory',
-      '• Verify agent .md files are present',
-      '• Check DeepAgent version: deepagent --version',
-      '• Review .deepagent/README.md for setup info'
+      '• Command not found? Verify npm global install: npm list -g @abacus-ai/cli',
+      '• Authentication issues? Run: abacusai login',
+      '• Check CLI version: abacusai --version',
+      '• Documentation: https://abacus.ai/docs'
     ]
   }
 };

package/lib/commands/tools.js

@@ -0,0 +1,38 @@
+const chalk = require('chalk');
+const ToolFeatureRegistry = require('../utils/tool-feature-registry');
+
+/**
+ * Tools Audit Command
+ * Displays a report of supported tools and their features.
+ */
+async function audit() {
+  const report = ToolFeatureRegistry.audit();
+
+  console.log(chalk.cyan.bold('\n🛠️  ADF Tool Support Audit\n'));
+  console.log(chalk.gray(`Total Tools: ${report.totalCount}`));
+  console.log(chalk.gray(`Timestamp:   ${new Date(report.timestamp).toLocaleString()}\n`));
+
+  console.log(chalk.white.bold('ID'.padEnd(15)) + chalk.white.bold('Name'.padEnd(20)) + chalk.white.bold('Status'));
+  console.log(chalk.gray('─'.repeat(50)));
+
+  for (const [id, tool] of Object.entries(report.tools)) {
+    let statusColor = chalk.green;
+    if (tool.status === 'partial') statusColor = chalk.yellow;
+    if (tool.status === 'deprecated') statusColor = chalk.red;
+
+    console.log(
+      chalk.cyan(id.padEnd(15)) + 
+      chalk.white(tool.name.padEnd(20)) + 
+      statusColor(tool.status)
+    );
+    
+    if (tool.features && tool.features.length > 0) {
+      console.log(chalk.gray(`   Features: ${tool.features.join(', ')}`));
+    }
+    console.log('');
+  }
+
+  console.log(chalk.yellow('💡 Use "adf deploy <tool>" to configure any of these targets.\n'));
+}
+
+module.exports = audit;

package/lib/generators/codex-cli-generator.js

@@ -0,0 +1,41 @@
+const ToolConfigGenerator = require('./tool-config-generator');
+const path = require('path');
+const fs = require('fs-extra');
+
+/**
+ * Generator for Codex CLI
+ */
+class CodexCLIGenerator extends ToolConfigGenerator {
+  async generate() {
+    await this.initialize();
+    await this.ensureDir('.codex');
+
+    const projectContext = await this.getProjectContext();
+
+    const config = `# Codex CLI Configuration
+# AgentDevFramework
+
+[framework]
+name = "AgentDevFramework"
+version = "1.0.0"
+project = "${projectContext.name}"
+
+[project_structure]
+framework = ".adf/"
+docs = "docs/"
+specs = "specs/"
+`;
+
+    await this.writeToProject('.codex/config.toml', config);
+
+    const instructions = `# Codex Instructions - ${projectContext.name}
+Follow AgentDevFramework standards for all development.
+Always prioritize TDD and high code coverage.
+`;
+    await this.writeToProject('.codex/instructions.md', instructions);
+
+    return { config: '.codex/config.toml' };
+  }
+}
+
+module.exports = CodexCLIGenerator;

package/lib/generators/index.js

@@ -12,6 +12,9 @@ const AntigravityGenerator = require('./antigravity-generator');
 const OpenCodeGenerator = require('./opencode-generator');
 const GeminiCLIGenerator = require('./gemini-cli-generator');
 const DeepAgentGenerator = require('./deepagent-generator');
+const KiroGenerator = require('./kiro-generator');
+const TraeGenerator = require('./trae-generator');
+const CodexCLIGenerator = require('./codex-cli-generator');
 const ToolConfigGenerator = require('./tool-config-generator');
 
 /**
@@ -129,6 +132,30 @@ async function generateDeepAgent(sessionPath, projectPath, framework) {
   return await generator.generate();
 }
 
+/**
+ * Generate Kiro configurations
+ */
+async function generateKiro(sessionPath, projectPath, framework) {
+  const generator = new KiroGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
+/**
+ * Generate Trae configurations
+ */
+async function generateTrae(sessionPath, projectPath, framework) {
+  const generator = new TraeGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
+/**
+ * Generate Codex CLI configurations
+ */
+async function generateCodexCLI(sessionPath, projectPath, framework) {
+  const generator = new CodexCLIGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
 module.exports = {
   generateAll,
   generateAgentsMd,
@@ -140,6 +167,9 @@ module.exports = {
   generateOpenCode,
   generateGeminiCLI,
   generateDeepAgent,
+  generateKiro,
+  generateTrae,
+  generateCodexCLI,
   AgentsMdGenerator,
   WindsurfGenerator,
   CursorGenerator,
@@ -149,5 +179,8 @@ module.exports = {
   OpenCodeGenerator,
   GeminiCLIGenerator,
   DeepAgentGenerator,
+  KiroGenerator,
+  TraeGenerator,
+  CodexCLIGenerator,
   ToolConfigGenerator
 };