@rxpm/forge-cli 0.0.1

package/src/agent/loop.ts

@@ -0,0 +1,68 @@
+import { stepCountIs, ToolLoopAgent } from 'ai';
+import { ollama, defaultModel } from '../llm/provider.js';
+import { tools } from '../tools/index.js';
+import { ActivityDisplay } from '../ui/activity.js';
+
+const SYSTEM_PROMPT = `
+You are a senior AI coding agent operating in a real filesystem.
+Your goal is to solve the user's coding task by following a logical process:
+1. Explore the codebase to understand the current state.
+2. Plan your changes carefully.
+3. Execute the changes by writing complete, valid files or code blocks.
+4. Verify your work using the tools provided.
+
+## Core Rules:
+1. ALWAYS read a file before modifying it.
+2. NEVER guess file content.
+3. When writing a file, PROVIDE THE FULL CONTENT of the file unless instructed otherwise.
+4. Use small, verifiable steps.
+5. If a command fails, analyze the error and try a different approach.
+6. Be concise and professional. No fluff.
+
+## Tools Available:
+- read_file(path): Returns the full content of a file.
+- write_file(path, content): Writes the EXACT content to a file.
+- list_files(path): Lists all files in the given directory.
+- search_code(query): Searches for a string in the codebase.
+- open_file_lines(path, start, end): Reads specific lines (1-indexed).
+- run_command(cmd): Executes a shell command.
+- git_status(), git_diff(), git_commit(message): Git operations.
+
+Always verify your changes after writing.
+`;
+
+/**
+ * Runs the AI agent to solve the given task.
+ * @param task The task to solve.
+ * @param maxIterations The maximum number of iterations to run the agent for.
+ */
+export async function runAgent(task: string, maxIterations = 10) {
+    const display = new ActivityDisplay();
+
+    try {
+        // Show branded banner
+        ActivityDisplay.printBanner(task);
+
+        // Start thinking indicator
+        display.startThinking();
+
+        const agent = new ToolLoopAgent({
+            model: ollama(defaultModel),
+            instructions: SYSTEM_PROMPT,
+            tools,
+            maxRetries: 2,
+            toolChoice: 'required',
+            stopWhen: stepCountIs(maxIterations),
+            onStepFinish(step) {
+                display.onStepFinish(step);
+            },
+        });
+
+        await agent.generate({ prompt: task });
+
+        display.printSummary('success');
+    } catch (error: any) {
+        display.printSummary('error', error.message);
+    }
+}
+

package/src/cli/commands.ts

@@ -0,0 +1,44 @@
+import { Command } from 'commander';
+import { runAgent } from '../agent/loop.js';
+import { logger } from '../utils/logger.js';
+
+const program = new Command();
+
+program
+    .name('forge')
+    .description('AI coding agent CLI tool')
+    .version('0.0.1')
+    .argument('[task]', 'The task to execute (default if no command provided)')
+    .option('-i, --iterations <number>', 'Maximum number of iterations', '10')
+    .action(async function (task, options) {
+        if (task) {
+            await runAgent(task, parseInt(options.iterations));
+        } else {
+            program.help();
+        }
+    });
+
+program
+    .command('chat')
+    .description('Interactive mode (v1: executes a single multi-step task)')
+    .action(async function () {
+        logger.warn('Interactive chat mode is currently limited to executing single tasks via main "agent <task>" command.');
+    });
+
+program
+    .command('explain')
+    .argument('<file>', 'The file to explain')
+    .action(async function (file) {
+        const task = `Explain the code in the file: ${file}`;
+        await runAgent(task);
+    });
+
+program
+    .command('fix')
+    .description('Detect and fix errors in the project')
+    .action(async function () {
+        const task = `Search for errors in the project, check git status, and try to fix any obvious bugs.`;
+        await runAgent(task);
+    });
+
+export { program };

package/src/config/env.ts

@@ -0,0 +1,17 @@
+export default {
+    /** Get the API URL for the Ollama server. */
+    get ollamaApiUrl(): string {
+        const baseUrl = process.env.OLLAMA_API_URL || 'http://localhost:11434';
+        return `${baseUrl}/api`;
+    },
+
+    /** Get the API secret for the Ollama server. */
+    get ollamaApiSecret(): string {
+        return process.env.OLLAMA_API_KEY || '';
+    },
+
+    /** Get the default model to use for the AI agent. */
+    get defaultModel(): string {
+        return process.env.OLLAMA_DEFAULT_MODEL || 'gpt-oss:120b';
+    },
+};

package/src/index.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+/**
+ * File: src/index.ts
+ * Author: Rajat Sharma
+ * Description: The main entry point for the CLI tool.
+ */
+
+import { program } from './cli/commands.js';
+import { logger } from './utils/logger.js';
+
+/** The main function that parses the command line arguments and executes the corresponding command. */
+async function main() {
+    try {
+        await program.parseAsync(process.argv);
+    } catch (error: any) {
+        logger.error(`CLI execution failed: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+main();

package/src/llm/provider.ts

@@ -0,0 +1,13 @@
+import { createOllama } from 'ollama-ai-provider-v2';
+import env from '../config/env.js';
+
+/** The default model to use for the AI agent. */
+export const defaultModel = env.defaultModel;
+
+/** The Ollama client for the AI agent. */
+export const ollama = createOllama({
+    baseURL: env.ollamaApiUrl + '/api',
+    headers: {
+        Authorization: `Bearer ${env.ollamaApiSecret}`,
+    },
+});

package/src/tools/code.ts

@@ -0,0 +1,53 @@
+/**
+ * File: code.ts
+ * Author: Rajat Sharma
+ * Description: Code tools for the AI agent.
+ */
+
+import fs from 'fs/promises';
+import { z } from 'zod';
+import { tool } from 'ai';
+import { execa } from 'execa';
+
+/** Searches for a string in the codebase using grep. */
+export const searchCodeTool = tool({
+    title: 'SearchCode',
+    description: 'Search for a string in the codebase using grep.',
+    inputSchema: z.object({
+        query: z.string().describe('The search query string.'),
+    }),
+    async execute({ query }) {
+        try {
+            // Use grep to search for the query string.
+            // -r: recursive, -n: show line numbers, -l: show only filenames (optional),
+            // -i: ignore case (optional), -E: extended regex
+            const { stdout } = await execa('grep', ['-rnE', query, '.', '--exclude-dir={node_modules,dist,.git}'], {
+                reject: false, // Don't throw if grep finds nothing (it exits with code 1)
+            });
+            return stdout || 'No matches found.';
+        } catch (error: any) {
+            return `Error searching code: ${error.message}`;
+        }
+    },
+});
+
+/** Opens a file and reads specific line range. */
+export const openFileLinesTool = tool({
+    title: 'OpenFileLines',
+    description: 'Open a file and read specific line range.',
+    inputSchema: z.object({
+        path: z.string().describe('The path to the file.'),
+        start: z.coerce.number().describe('The start line number (1-based).'),
+        end: z.coerce.number().describe('The end line number (inclusive).'),
+    }),
+    async execute({ path, start, end }) {
+        try {
+            const content = await fs.readFile(path, 'utf-8');
+            const lines = content.split('\n');
+            const slicedLines = lines.slice(Math.max(0, start - 1), end);
+            return slicedLines.join('\n');
+        } catch (error: any) {
+            return `Error reading file lines: ${error.message}`;
+        }
+    },
+});

package/src/tools/fs.ts

@@ -0,0 +1,71 @@
+/**
+ * File: fs.ts
+ * Author: Rajat Sharma
+ * Description: File system tools for the AI agent.
+ */
+
+import fs from 'fs/promises';
+import { z } from 'zod';
+import { tool } from 'ai';
+import { glob } from 'glob';
+
+/** Reads the contents of a file. */
+export const readFileTool = tool({
+    title: 'ReadFile',
+    description: 'Read the contents of a file. LIMIT file size (max 5000 lines per read).',
+    inputSchema: z.object({
+        path: z.string().describe('The path to the file to read.'),
+    }),
+    async execute({ path }) {
+        try {
+            const content = await fs.readFile(path, 'utf-8');
+            const lines = content.split('\n');
+            if (lines.length > 5000) {
+                return `File too large: ${lines.length} lines. Max 5000 lines.`;
+            }
+            return content;
+        } catch (error: any) {
+            return `Error reading file: ${error.message}`;
+        }
+    },
+});
+
+/** Writes content to a file. */
+export const writeFileTool = tool({
+    title: 'WriteFile',
+    description: 'Write content to a file. Justify large rewrites.',
+    inputSchema: z.object({
+        path: z.string().describe('The path to the file to write.'),
+        content: z.string().describe('The content to write to the file.'),
+    }),
+    async execute({ path, content }) {
+        try {
+            await fs.writeFile(path, content, 'utf-8');
+            return `Successfully wrote to ${path}`;
+        } catch (error: any) {
+            return `Error writing file: ${error.message}`;
+        }
+    },
+});
+
+/** Lists files in a directory recursively. */
+export const listFilesTool = tool({
+    title: 'ListFiles',
+    description: 'List files in a directory recursively.',
+    inputSchema: z.object({
+        path: z.string().describe('The directory path to list files from. Defaults to ".".').default('.'),
+    }),
+    async execute({ path }) {
+        try {
+            const files = await glob('**/*', {
+                cwd: path,
+                nodir: true,
+                ignore: ['node_modules/**', 'dist/**', '.git/**', '.gitignore'],
+            });
+
+            return files.join('\n');
+        } catch (error: any) {
+            return `Error listing files: ${error.message}`;
+        }
+    },
+});

package/src/tools/git.ts

@@ -0,0 +1,60 @@
+/**
+ * File: git.ts
+ * Author: Rajat Sharma
+ * Description: Git tools for the AI agent.
+ */
+
+import { z } from 'zod';
+import { tool } from 'ai';
+import { execa } from 'execa';
+
+/** Checks the git status of the project. */
+export const gitStatusTool = tool({
+    title: 'GitStatus',
+    description: 'Check the git status of the project.',
+    inputSchema: z.object({}),
+    async execute() {
+        try {
+            const { stdout } = await execa('git', ['status']);
+            return stdout || 'No output from git status.';
+        } catch (error: any) {
+            return `Error checking git status: ${error.message}`;
+        }
+    },
+});
+
+/** Shows git diff for staged and unstaged changes. */
+export const gitDiffTool = tool({
+    title: 'GitDiff',
+    description: 'Show git diff for staged and unstaged changes.',
+    inputSchema: z.object({
+        staged: z.boolean().optional().describe('Show staged changes only.').default(false),
+    }),
+    async execute({ staged }) {
+        try {
+            const args = ['diff'];
+            if (staged) args.push('--staged');
+            const { stdout } = await execa('git', args);
+            return stdout || 'No differences found.';
+        } catch (error: any) {
+            return `Error showing git diff: ${error.message}`;
+        }
+    },
+});
+
+/** Commits staged changes to git with a message. */
+export const gitCommitTool = tool({
+    title: 'GitCommit',
+    description: 'Commit staged changes to git with a message.',
+    inputSchema: z.object({
+        message: z.string().describe('The commit message.'),
+    }),
+    async execute({ message }) {
+        try {
+            const { stdout } = await execa('git', ['commit', '-m', message]);
+            return stdout || 'Committed changes.';
+        } catch (error: any) {
+            return `Error committing changes: ${error.message}`;
+        }
+    },
+});

package/src/tools/index.ts

@@ -0,0 +1,23 @@
+/**
+ * File: index.ts
+ * Author: Rajat Sharma
+ * Description: Index of all tools for the AI agent.
+ */
+
+import { readFileTool, writeFileTool, listFilesTool } from './fs.js';
+import { searchCodeTool, openFileLinesTool } from './code.js';
+import { runCommandTool } from './shell.js';
+import { gitStatusTool, gitDiffTool, gitCommitTool } from './git.js';
+
+// Export all tools
+export const tools = {
+    read_file: readFileTool,
+    write_file: writeFileTool,
+    list_files: listFilesTool,
+    search_code: searchCodeTool,
+    open_file_lines: openFileLinesTool,
+    run_command: runCommandTool,
+    git_status: gitStatusTool,
+    git_diff: gitDiffTool,
+    git_commit: gitCommitTool,
+};

package/src/tools/shell.ts

@@ -0,0 +1,32 @@
+/**
+ * File: shell.ts
+ * Author: Rajat Sharma
+ * Description: Shell tools for the AI agent.
+ */
+
+import { z } from 'zod';
+import { tool } from 'ai';
+import { execa } from 'execa';
+
+/** Runs a shell command in the project root. */
+export const runCommandTool = tool({
+    title: 'RunCommand',
+    description: 'Run a shell command in the project root. DO NOT run destructive commands without confirmation.',
+    inputSchema: z.object({
+        command: z.string().describe('The shell command to execute.'),
+    }),
+    async execute({ command }) {
+        // Simple safety check for common destructive commands
+        const destructive = ['rm -rf', 'sudo', 'chmod', 'chown', 'mkfs', 'dd'];
+        if (destructive.some((d) => command.includes(d))) {
+            return `Error: Command "${command}" is considered potentially destructive and requires manual execution or explicit user confirmation.`;
+        }
+
+        try {
+            const { stdout, stderr } = await execa(command, { shell: true });
+            return stdout || stderr || 'Command executed successfully (no output).';
+        } catch (error: any) {
+            return `Error executing command: ${error.message}\n${error.stderr || ''}`;
+        }
+    },
+});