kyawthiha-nextjs-agent-cli 1.0.0

package/dist/agent/tools/shell-tools.js

@@ -0,0 +1,334 @@
+/**
+ * Shell tools for the AI Agent
+ * Safe shell execution with command validation
+ */
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+const execAsync = promisify(exec);
+/**
+ * Dangerous commands and patterns that should be blocked
+ */
+const DANGEROUS_PATTERNS = [
+    /rm\s+(-rf?|--recursive)\s+[\/\\]/, // rm -rf /
+    /rm\s+(-rf?|--recursive)\s+~/, // rm -rf ~
+    /rm\s+(-rf?|--recursive)\s+\*/, // rm -rf *
+    /del\s+\/[sf]\s+[a-z]:\\/i, // Windows: del /s C:\
+    /format\s+[a-z]:/i, // Windows: format C:
+    /mkfs\./i, // Linux filesystem format
+    /dd\s+if=.*of=\/dev/i, // dd to device
+    />\s*\/dev\/sd[a-z]/i, // Write to disk device
+    /chmod\s+777\s+\//i, // chmod 777 /
+    /chown\s+-R.*\//i, // chown -R /
+    /:\s*\(\)\s*\{\s*:\|:&\s*\}/, // Fork bomb
+    /wget.*\|\s*(ba)?sh/i, // Download and execute
+    /curl.*\|\s*(ba)?sh/i, // Download and execute
+    /shutdown/i,
+    /reboot/i,
+    /init\s+0/,
+    /halt/i,
+    /poweroff/i,
+];
+/**
+ * Commands that require extra caution but aren't blocked
+ */
+const CAUTION_PATTERNS = [
+    /npm\s+publish/i,
+    /git\s+push\s+--force/i,
+    /git\s+push\s+-f/i,
+    /DROP\s+TABLE/i,
+    /DROP\s+DATABASE/i,
+    /TRUNCATE/i,
+    /DELETE\s+FROM.*WHERE\s+1\s*=\s*1/i,
+];
+/**
+ * Check if a command is safe to execute
+ */
+function validateCommand(command) {
+    // Check for dangerous patterns
+    for (const pattern of DANGEROUS_PATTERNS) {
+        if (pattern.test(command)) {
+            return {
+                safe: false,
+                reason: `Blocked: Command matches dangerous pattern. Pattern: ${pattern.toString()}`
+            };
+        }
+    }
+    // Check for caution patterns
+    for (const pattern of CAUTION_PATTERNS) {
+        if (pattern.test(command)) {
+            return {
+                safe: true,
+                caution: `Warning: This command may have significant effects: ${pattern.toString()}`
+            };
+        }
+    }
+    return { safe: true };
+}
+/**
+ * Tool: Execute Command
+ * Safe shell execution with validation
+ */
+export const execCommandTool = {
+    name: 'exec_command',
+    description: `Execute a shell command safely.
+Blocks dangerous commands (rm -rf /, format, etc.)
+Captures stdout, stderr, and exit code.
+
+Automatically uses the correct shell for the OS:
+- Windows: PowerShell
+- Unix: bash
+
+Best for:
+- Running build commands (npm, pnpm, yarn)
+- Git operations
+- File operations
+- Development servers`,
+    parameters: {
+        type: 'object',
+        properties: {
+            command: {
+                type: 'string',
+                description: 'The shell command to execute'
+            },
+            cwd: {
+                type: 'string',
+                description: 'Working directory for the command'
+            },
+            timeout: {
+                type: 'string',
+                description: 'Timeout in seconds (default: 60, max: 300)'
+            },
+            background: {
+                type: 'string',
+                description: 'Run command in background (for servers)',
+                enum: ['true', 'false']
+            }
+        },
+        required: ['command']
+    },
+    execute: async (input) => {
+        try {
+            const command = input.command;
+            const cwd = input.cwd || process.cwd();
+            const timeoutSec = Math.min(parseInt(input.timeout || '60', 10), 300);
+            const background = input.background === 'true';
+            // Validate command
+            const validation = validateCommand(command);
+            if (!validation.safe) {
+                return `Error: ${validation.reason}`;
+            }
+            // Check cwd exists
+            try {
+                await fs.access(cwd);
+            }
+            catch {
+                return `Error: Working directory does not exist: ${cwd}`;
+            }
+            const shell = process.platform === 'win32' ? 'powershell.exe' : '/bin/bash';
+            // Output any caution warnings
+            let output = '';
+            if (validation.caution) {
+                output += `⚠️ ${validation.caution}\n\n`;
+            }
+            if (background) {
+                // For background processes, use spawn and detach
+                const args = process.platform === 'win32'
+                    ? ['-Command', command]
+                    : ['-c', command];
+                const child = spawn(shell, args, {
+                    cwd,
+                    detached: true,
+                    stdio: 'ignore'
+                });
+                child.unref();
+                return output + `Started background process with PID: ${child.pid}\nCommand: ${command}\nWorking directory: ${cwd}`;
+            }
+            // Execute command
+            try {
+                const { stdout, stderr } = await execAsync(command, {
+                    cwd,
+                    shell,
+                    timeout: timeoutSec * 1000,
+                    maxBuffer: 10 * 1024 * 1024, // 10MB
+                    encoding: 'utf-8'
+                });
+                output += `Command: ${command}\n`;
+                output += `Working directory: ${cwd}\n`;
+                output += `Exit code: 0\n\n`;
+                if (stdout) {
+                    const lines = stdout.split('\n');
+                    if (lines.length > 100) {
+                        output += `--- STDOUT (${lines.length} lines, showing last 100) ---\n`;
+                        output += lines.slice(-100).join('\n');
+                    }
+                    else {
+                        output += `--- STDOUT ---\n${stdout}`;
+                    }
+                }
+                if (stderr) {
+                    output += `\n--- STDERR ---\n${stderr}`;
+                }
+                if (!stdout && !stderr) {
+                    output += '(no output)';
+                }
+                return output;
+            }
+            catch (error) {
+                output += `Command: ${command}\n`;
+                output += `Working directory: ${cwd}\n`;
+                output += `Exit code: ${error.code || 'unknown'}\n\n`;
+                if (error.stdout) {
+                    output += `--- STDOUT ---\n${error.stdout}\n`;
+                }
+                if (error.stderr) {
+                    output += `--- STDERR ---\n${error.stderr}\n`;
+                }
+                if (!error.stdout && !error.stderr) {
+                    output += `Error: ${error.message}`;
+                }
+                return output;
+            }
+        }
+        catch (error) {
+            return `Error: ${error.message}`;
+        }
+    }
+};
+/**
+ * Tool: Get Process Info
+ * Check if a process is running
+ */
+export const processInfoTool = {
+    name: 'process_info',
+    description: `Get information about running processes.
+Search by name or PID.
+
+Useful for checking if servers are running.`,
+    parameters: {
+        type: 'object',
+        properties: {
+            name: {
+                type: 'string',
+                description: 'Process name to search for'
+            },
+            pid: {
+                type: 'string',
+                description: 'Process ID to check'
+            }
+        },
+        required: []
+    },
+    execute: async (input) => {
+        try {
+            const name = input.name;
+            const pid = input.pid;
+            const shell = process.platform === 'win32' ? 'powershell.exe' : '/bin/bash';
+            let command;
+            if (process.platform === 'win32') {
+                if (pid) {
+                    command = `Get-Process -Id ${pid} | Format-List Name,Id,CPU,WorkingSet`;
+                }
+                else if (name) {
+                    command = `Get-Process -Name *${name}* | Format-Table Name,Id,CPU,WorkingSet -AutoSize`;
+                }
+                else {
+                    command = `Get-Process | Sort-Object CPU -Descending | Select-Object -First 10 | Format-Table Name,Id,CPU,WorkingSet -AutoSize`;
+                }
+            }
+            else {
+                if (pid) {
+                    command = `ps -p ${pid} -o pid,ppid,user,%cpu,%mem,command`;
+                }
+                else if (name) {
+                    command = `ps aux | grep -i "${name}" | grep -v grep | head -20`;
+                }
+                else {
+                    command = `ps aux --sort=-%cpu | head -11`;
+                }
+            }
+            try {
+                const { stdout } = await execAsync(command, { shell, timeout: 10000 });
+                if (!stdout.trim()) {
+                    return 'No matching processes found';
+                }
+                return `Process Information:\n${stdout}`;
+            }
+            catch {
+                return 'No matching processes found';
+            }
+        }
+        catch (error) {
+            return `Error: ${error.message}`;
+        }
+    }
+};
+/**
+ * Tool: Kill Process
+ * Terminate a process by PID
+ */
+export const killProcessTool = {
+    name: 'kill_process',
+    description: `Terminate a process by PID.
+Use with caution - only kill processes you started.`,
+    parameters: {
+        type: 'object',
+        properties: {
+            pid: {
+                type: 'string',
+                description: 'Process ID to terminate'
+            },
+            force: {
+                type: 'string',
+                description: 'Force kill (SIGKILL)',
+                enum: ['true', 'false']
+            }
+        },
+        required: ['pid']
+    },
+    execute: async (input) => {
+        try {
+            const pid = parseInt(input.pid, 10);
+            const force = input.force === 'true';
+            if (isNaN(pid)) {
+                return 'Error: Invalid PID';
+            }
+            // Safety check - don't kill system processes
+            if (pid <= 1) {
+                return 'Error: Cannot kill system processes';
+            }
+            const shell = process.platform === 'win32' ? 'powershell.exe' : '/bin/bash';
+            let command;
+            if (process.platform === 'win32') {
+                command = force
+                    ? `Stop-Process -Id ${pid} -Force`
+                    : `Stop-Process -Id ${pid}`;
+            }
+            else {
+                command = force
+                    ? `kill -9 ${pid}`
+                    : `kill ${pid}`;
+            }
+            try {
+                await execAsync(command, { shell, timeout: 5000 });
+                return `Process ${pid} terminated successfully`;
+            }
+            catch (error) {
+                return `Error terminating process: ${error.message}`;
+            }
+        }
+        catch (error) {
+            return `Error: ${error.message}`;
+        }
+    }
+};
+/**
+ * Get all shell tools
+ */
+export function getShellTools() {
+    return [
+        execCommandTool,
+        processInfoTool,
+        killProcessTool,
+    ];
+}

package/dist/agent/types.js

@@ -0,0 +1,4 @@
+/**
+ * Core types for the AI Agent system
+ */
+export {};

package/dist/cli/commands/config.js

@@ -0,0 +1,61 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { logger } from '../../utils/logger.js';
+import { getCredPath, getGeminiApiKey, setGeminiApiKey } from '../../utils/cred-store.js';
+export const configCommand = new Command('config')
+    .description('Manage CLI configuration');
+/**
+ * Subcommand: set-api-key
+ * Prompts for and saves the Gemini API key to credential store
+ */
+configCommand
+    .command('set-api-key')
+    .description('Set or update the Gemini API key')
+    .action(async () => {
+    try {
+        const currentKey = await getGeminiApiKey();
+        if (currentKey) {
+            const redactedKey = currentKey.slice(0, 6) + '...' + currentKey.slice(-4);
+            logger.info(`Current API key: ${redactedKey}`);
+        }
+        const answer = await inquirer.prompt([{
+                type: 'password',
+                name: 'apiKey',
+                message: 'Enter your Gemini API Key:',
+                validate: (input) => input.length > 0 ? true : 'API Key is required'
+            }]);
+        await setGeminiApiKey(answer.apiKey);
+        logger.success(`API key saved to ${getCredPath()}`);
+    }
+    catch (error) {
+        logger.error(`Failed to set API key: ${error.message}`);
+        process.exit(1);
+    }
+});
+/**
+ * Subcommand: show
+ * Displays current configuration info
+ */
+configCommand
+    .command('show')
+    .description('Show current configuration')
+    .action(async () => {
+    try {
+        const credPath = getCredPath();
+        const apiKey = await getGeminiApiKey();
+        console.log('\n--- Configuration ---');
+        console.log(`Config file: ${credPath}`);
+        if (apiKey) {
+            const redactedKey = apiKey.slice(0, 6) + '...' + apiKey.slice(-4);
+            console.log(`Gemini API Key: ${redactedKey}`);
+        }
+        else {
+            console.log('Gemini API Key: (not set)');
+        }
+        console.log('');
+    }
+    catch (error) {
+        logger.error(`Failed to show config: ${error.message}`);
+        process.exit(1);
+    }
+});

package/dist/cli/commands/start.js

@@ -0,0 +1,236 @@
+import 'dotenv/config'; // Load env vars
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import { logger } from '../../utils/logger.js';
+import { Agent } from '../../agent/index.js';
+import path from 'path';
+import { getGeminiApiKey, setGeminiApiKey, getCredPath } from '../../utils/cred-store.js';
+/**
+ * Display welcome banner
+ */
+function showWelcomeBanner() {
+    console.log('');
+    console.log(chalk.cyan.bold('╔═══════════════════════════════════════════════════════════╗'));
+    console.log(chalk.cyan.bold('║') + chalk.white.bold('     🚀 Next.js Fullstack Agent CLI                        ') + chalk.cyan.bold('║'));
+    console.log(chalk.cyan.bold('║') + chalk.gray('     Build full-stack apps with AI assistance              ') + chalk.cyan.bold('║'));
+    console.log(chalk.cyan.bold('╚═══════════════════════════════════════════════════════════╝'));
+    console.log('');
+}
+export const startCommand = new Command('start')
+    .description('Start the AI Agent')
+    .option('-n, --project-name <name>', 'Project name (will be created in current directory)')
+    .option('-m, --max-iterations <number>', 'Maximum agent iterations', '500')
+    .option('--skip-db', 'Skip PostgreSQL configuration (for static sites)')
+    .option('--no-verbose', 'Disable verbose logging')
+    .action(async (options) => {
+    try {
+        // Show welcome banner
+        showWelcomeBanner();
+        const spinner = ora({
+            text: chalk.blue('Initializing Next.js Agent...'),
+            spinner: 'dots'
+        }).start();
+        // Small delay for visual effect
+        await new Promise(resolve => setTimeout(resolve, 500));
+        spinner.succeed(chalk.green('Ready to build!'));
+        console.log('');
+        // 1. Initial Input Resolution
+        let currentPrompt;
+        let projectName = options.projectName;
+        if (!projectName) {
+            const answer = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'projectName',
+                    message: 'What is your project name?',
+                    default: 'my-app',
+                    validate: (input) => {
+                        // Validate project name (no spaces, special chars)
+                        if (/^[a-z0-9-]+$/.test(input))
+                            return true;
+                        return 'Project name should only contain lowercase letters, numbers, and hyphens';
+                    }
+                }]);
+            projectName = answer.projectName;
+        }
+        // Derive projectPath from projectName (absolute path for consistency)
+        const projectPath = path.resolve(process.cwd(), projectName);
+        // API Key resolution: env -> credential store -> prompt
+        let geminiKey = process.env.GEMINI_API_KEY;
+        if (!geminiKey) {
+            // Try credential store
+            geminiKey = await getGeminiApiKey();
+            if (geminiKey) {
+                logger.info(`Using API key from ${getCredPath()}`);
+            }
+        }
+        if (!geminiKey) {
+            // Prompt for key
+            const answers = await inquirer.prompt([{
+                    type: 'password',
+                    name: 'apiKey',
+                    message: 'Please enter your Gemini API Key:',
+                    validate: (input) => input.length > 0 ? true : 'API Key is required'
+                }]);
+            const key = answers.apiKey;
+            // Ask if user wants to save to credential store
+            const saveAnswer = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'save',
+                    message: 'Save API key for future sessions?',
+                    default: true
+                }]);
+            if (saveAnswer.save) {
+                await setGeminiApiKey(key);
+                logger.success(`API key saved to ${getCredPath()}`);
+            }
+            geminiKey = key;
+        }
+        if (!geminiKey) {
+            logger.error('Failed to resolve Gemini API Key');
+            process.exit(1);
+        }
+        const maxIterations = parseInt(options.maxIterations, 10);
+        const verbose = options.verbose ?? true; // Commander with --no-verbose sets this to true by default, false if flag used.
+        // 2. Interactive Loop
+        let iteration = 1;
+        let active = true;
+        // Ask for model selection
+        const modelAnswer = await inquirer.prompt([{
+                type: 'select',
+                name: 'model',
+                message: 'Select Gemini Model:',
+                choices: [
+                    'gemini-3-flash-preview',
+                    'gemini-3-pro-preview'
+                ],
+                default: 'gemini-3-flash-preview'
+            }]);
+        // Database Creds (Step-by-Step) - Skip if --skip-db is used
+        let databaseUrl;
+        if (!options.skipDb) {
+            const defaultDbName = projectName;
+            console.log('\n--- PostgreSQL Configuration ---');
+            const dbCreds = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'host',
+                    message: 'Host:',
+                    default: 'localhost'
+                },
+                {
+                    type: 'input',
+                    name: 'port',
+                    message: 'Port:',
+                    default: '5432'
+                },
+                {
+                    type: 'input',
+                    name: 'username',
+                    message: 'Username:',
+                    default: 'postgres'
+                },
+                {
+                    type: 'input',
+                    name: 'password',
+                    message: 'Password:',
+                    default: 'postgres'
+                },
+                {
+                    type: 'input',
+                    name: 'dbName',
+                    message: 'Database Name:',
+                    default: defaultDbName
+                }
+            ]);
+            databaseUrl = `postgresql://${dbCreds.username}:${dbCreds.password}@${dbCreds.host}:${dbCreds.port}/${dbCreds.dbName}`;
+        }
+        else {
+            logger.info('Skipping PostgreSQL configuration (--skip-db)');
+        }
+        const config = {
+            geminiApiKey: geminiKey,
+            maxIterations: maxIterations,
+            verbose: verbose,
+            modelName: modelAnswer.model,
+        };
+        // Initialize agent once
+        const agent = new Agent(config);
+        await agent.init();
+        while (active) {
+            if (!currentPrompt) {
+                const answer = await inquirer.prompt([{
+                        type: 'input',
+                        name: 'prompt',
+                        message: 'What do you want to build or modify?',
+                        validate: (input) => input.trim() !== '' ? true : 'Prompt is required'
+                    }]);
+                currentPrompt = answer.prompt;
+            }
+            if (currentPrompt && currentPrompt.toLowerCase() === 'exit') {
+                console.log('Exiting...');
+                break;
+            }
+            logger.info(`\n--- Iteration ${iteration} ---`);
+            logger.info(`Goal: ${currentPrompt}`);
+            logger.info(`Project: ${projectPath}`);
+            // Enhance prompt with serial artifact instructions
+            const enhancedPrompt = `${currentPrompt}\n\nIMPORTANT RULES:
+1. You MUST create the following plan files inside "${projectPath}/.agent":
+   - "plan${iteration}.md" (Implementation Plan)
+   - "task${iteration}.md" (Task Checklist)
+   - Update "task${iteration}.md" as you progress.
+2. If creating a new project, use "create_nextjs_project" with "projectPath" set EXACTLY to "${projectPath}".
+3. CRITICAL: Treat "${projectPath}" as your ROOT working directory. All file writes and commands must be executed relative to this path. Do NOT create arbitrary subdirectories for the project itself.`;
+            // Execute agent
+            try {
+                if (iteration === 1) {
+                    const task = {
+                        prompt: enhancedPrompt,
+                        projectPath: projectPath,
+                        databaseUrl: databaseUrl
+                    };
+                    await agent.start(task);
+                }
+                else {
+                    await agent.chat(enhancedPrompt);
+                }
+                logger.success(`Iteration ${iteration} completed!`);
+                // Post-generation Guide
+                console.log(`\n--------------------------------------------`);
+                console.log(`To run your project:`);
+                console.log(`  cd ${projectPath}`);
+                console.log(`  pnpm dev`);
+                console.log(`--------------------------------------------`);
+                console.log(`Artifacts stored in: ${projectPath}/.agent/plan${iteration}.md`);
+                console.log(`--------------------------------------------\n`);
+            }
+            catch (error) {
+                logger.error(`Iteration failed: ${error.message}`);
+                // Don't exit process, allow user to try again or exit
+            }
+            // Prepare for next loop
+            iteration++;
+            currentPrompt = ''; // Reset prompt to force simple ask
+            // Simple "Next" Prompt
+            const nextStep = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'next',
+                    message: 'Enter your next request, feedback, or type "exit" to quit:'
+                }]);
+            const userNext = nextStep.next.trim();
+            if (userNext.toLowerCase() === 'exit') {
+                active = false;
+            }
+            else {
+                currentPrompt = userNext;
+            }
+        }
+        logger.success('Session ended. Happy coding!');
+    }
+    catch (error) {
+        logger.error(`Error: ${error.message || 'Unknown error'}`);
+        process.exit(1);
+    }
+});

package/dist/cli/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { startCommand } from './commands/start.js';
+import { configCommand } from './commands/config.js';
+const program = new Command();
+program
+    .name('next-agent')
+    .description('Next.js Fullstack Agent CLI')
+    .version('1.0.0');
+program.addCommand(startCommand);
+program.addCommand(configCommand);
+program.parse();