@rxpm/forge-cli 0.0.1

package/src/ui/activity.ts

@@ -0,0 +1,504 @@
+/**
+ * File: activity.ts
+ * Author: Rajat Sharma
+ * Description: Gemini-inspired terminal activity display for the AI agent.
+ */
+
+import { execSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { relative } from 'node:path';
+import chalk from 'chalk';
+import ora, { type Ora } from 'ora';
+import { defaultModel } from '../llm/provider.js';
+
+const ANSI_PATTERN = /\x1B\[[0-9;]*m/g;
+
+const box = {
+    topLeft: '╭',
+    topRight: '╮',
+    bottomLeft: '╰',
+    bottomRight: '╯',
+    horizontal: '─',
+    vertical: '│',
+    teeLeft: '┤',
+    teeRight: '├',
+};
+
+const theme = {
+    accent: chalk.yellowBright,
+    accentStrong: chalk.yellowBright.bold,
+    success: chalk.greenBright,
+    error: chalk.red,
+    warning: chalk.yellow,
+    info: chalk.blue,
+    text: chalk.white,
+    soft: chalk.white,
+    muted: chalk.dim,
+    border: chalk.gray,
+    panel: chalk.gray,
+    strong: chalk.bold,
+};
+
+interface ToolCallEntry {
+    id: string;
+    name: string;
+    displayName: string;
+    args: Record<string, any>;
+    startTime: number;
+    endTime?: number;
+    result?: string;
+    status: 'running' | 'done' | 'error';
+}
+
+interface StepToolCall {
+    toolName: string;
+    toolCallId: string;
+    args?: Record<string, any>;
+    title?: string;
+}
+
+interface StepToolResult {
+    toolName: string;
+    toolCallId: string;
+    output?: any;
+    result?: any;
+    title?: string;
+}
+
+function terminalWidth(): number {
+    const width = process.stdout.columns || 100;
+    return Math.max(76, Math.min(width, 118));
+}
+
+function contentWidth(totalWidth = terminalWidth()): number {
+    return totalWidth - 4;
+}
+
+function visibleLength(value: string): number {
+    return value.replace(ANSI_PATTERN, '').length;
+}
+
+function padLine(value: string, width: number): string {
+    const gap = Math.max(0, width - visibleLength(value));
+    return value + ' '.repeat(gap);
+}
+
+function truncate(value: string, maxLen: number): string {
+    if (value.length <= maxLen) return value;
+    if (maxLen <= 1) return value.slice(0, maxLen);
+    return value.slice(0, maxLen - 1) + '…';
+}
+
+function wrapText(value: string, width: number): string[] {
+    if (!value) return [''];
+
+    const chunks = value.replace(/\t/g, '  ').split('\n');
+    const lines: string[] = [];
+
+    for (const chunk of chunks) {
+        if (!chunk.trim()) {
+            lines.push('');
+            continue;
+        }
+
+        let current = '';
+        const words = chunk.split(/\s+/);
+
+        for (const word of words) {
+            if (!current) {
+                current = word;
+                continue;
+            }
+
+            const next = `${current} ${word}`;
+            if (next.length <= width) {
+                current = next;
+                continue;
+            }
+
+            lines.push(current);
+
+            if (word.length <= width) {
+                current = word;
+                continue;
+            }
+
+            let remaining = word;
+            while (remaining.length > width) {
+                lines.push(remaining.slice(0, width - 1) + '…');
+                remaining = remaining.slice(width - 1);
+            }
+            current = remaining;
+        }
+
+        if (current) lines.push(current);
+    }
+
+    return lines.length > 0 ? lines : [''];
+}
+
+function formatDuration(ms: number): string {
+    if (ms < 1000) return `${ms}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+
+function safeStringify(value: unknown): string {
+    if (typeof value === 'string') return value;
+    try {
+        return JSON.stringify(value);
+    } catch {
+        return String(value);
+    }
+}
+
+function formatResultPreview(result: string): string {
+    if (!result) return 'No output';
+
+    const trimmed = result.trim();
+    if (!trimmed) return 'No output';
+
+    const lines = trimmed.split('\n');
+    const firstLine = truncate(lines[0], 72);
+    return lines.length > 1 ? `${firstLine} (+${lines.length - 1} lines)` : firstLine;
+}
+
+function getToolResultValue(result: StepToolResult | undefined): unknown {
+    if (!result) return undefined;
+    if ('output' in result && result.output !== undefined) return result.output;
+    return result.result;
+}
+
+function formatToolBody(call: StepToolCall, result: StepToolResult | undefined): string[] {
+    const rawValue = getToolResultValue(result);
+    if (rawValue === undefined) return [theme.warning('No output captured')];
+
+    const text = safeStringify(rawValue).trim();
+    if (!text) return [theme.muted('No output')];
+
+    const lines = text.split('\n');
+    const isError = text.toLowerCase().startsWith('error');
+    const colorize = isError ? theme.error : theme.muted;
+
+    if (call.toolName === 'run_command' || call.toolName === 'RunCommand') {
+        const preview = lines.slice(0, 6).map((line) => colorize(line));
+        if (lines.length > 6) {
+            preview.push(theme.muted(`... (+${lines.length - 6} more lines)`));
+        }
+        return preview;
+    }
+
+    return [colorize(formatResultPreview(text))];
+}
+
+function getWorkspaceLabel(): string {
+    const cwd = process.cwd();
+    const home = homedir();
+    if (cwd.startsWith(home)) {
+        const rel = relative(home, cwd);
+        return rel ? `~/${rel}` : '~';
+    }
+    return cwd;
+}
+
+function getBranchName(): string {
+    try {
+        return (
+            execSync('git branch --show-current', {
+                cwd: process.cwd(),
+                stdio: ['ignore', 'pipe', 'ignore'],
+                encoding: 'utf8',
+            }).trim() || 'detached'
+        );
+    } catch {
+        return 'unknown';
+    }
+}
+
+function summarizeTool(toolName: string, args: Record<string, any>): string {
+    switch (toolName) {
+        case 'ReadFile':
+        case 'read_file':
+            return args.path ? truncate(args.path, 54) : 'Inspect file';
+        case 'WriteFile':
+        case 'write_file':
+            return args.path ? truncate(args.path, 54) : 'Write file';
+        case 'ListFiles':
+        case 'list_files':
+            return args.path ? truncate(args.path, 54) : '.';
+        case 'SearchCode':
+        case 'search_code':
+            return args.query ? `"${truncate(args.query, 42)}"` : 'Search codebase';
+        case 'OpenFileLines':
+        case 'open_file_lines':
+            return args.path ? `${truncate(args.path, 36)}:${args.start}-${args.end}` : 'Open file range';
+        case 'RunCommand':
+        case 'run_command':
+            return args.command ? truncate(args.command, 54) : 'Run command';
+        case 'GitDiff':
+        case 'git_diff':
+            return args.staged ? 'staged changes' : 'working tree';
+        case 'GitCommit':
+        case 'git_commit':
+            return args.message ? `"${truncate(args.message, 42)}"` : 'Create commit';
+        default:
+            return Object.keys(args).length > 0 ? truncate(safeStringify(args), 54) : 'Working';
+    }
+}
+
+function formatToolLabel(toolName: string): string {
+    switch (toolName) {
+        case 'ReadFile':
+        case 'read_file':
+            return 'Read';
+        case 'WriteFile':
+        case 'write_file':
+            return 'Edit';
+        case 'ListFiles':
+        case 'list_files':
+            return 'List';
+        case 'SearchCode':
+        case 'search_code':
+            return 'Search';
+        case 'OpenFileLines':
+        case 'open_file_lines':
+            return 'Inspect';
+        case 'RunCommand':
+        case 'run_command':
+            return 'Shell';
+        case 'GitStatus':
+        case 'git_status':
+            return 'Git status';
+        case 'GitDiff':
+        case 'git_diff':
+            return 'Git diff';
+        case 'GitCommit':
+        case 'git_commit':
+            return 'Commit';
+        default:
+            return toolName.replace(/_/g, ' ');
+    }
+}
+
+function buildTopBorder(title: string, width = terminalWidth()): string {
+    const plain = ` ${title} `;
+    const fill = Math.max(0, width - visibleLength(plain) - 1);
+    return theme.border(`${box.topLeft}${box.horizontal}${title}${box.horizontal.repeat(fill)}${box.topRight}`);
+}
+
+function buildBottomBorder(width = terminalWidth()): string {
+    return theme.border(`${box.bottomLeft}${box.horizontal.repeat(width - 2)}${box.bottomRight}`);
+}
+
+function renderPanel(title: string, rows: string[], width = terminalWidth()): void {
+    const innerWidth = contentWidth(width);
+    console.log(buildTopBorder(title, width));
+
+    for (const row of rows) {
+        const wrapped = wrapText(row, innerWidth);
+        for (const line of wrapped) {
+            console.log(`${theme.border(box.vertical)} ${padLine(line, innerWidth)} ${theme.border(box.vertical)}`);
+        }
+    }
+
+    console.log(buildBottomBorder(width));
+}
+
+function createMetaRow(label: string, value: string, width: number): string[] {
+    const left = theme.muted(`${label.padEnd(10)} `);
+    const wrapped = wrapText(value, width - 11);
+    return wrapped.map((line, index) => {
+        if (index === 0) return `${left}${theme.text(line)}`;
+        return `${' '.repeat(11)}${theme.text(line)}`;
+    });
+}
+
+function renderStatusLine(label: string, status: 'success' | 'error' | 'info', meta?: string): void {
+    const color = status === 'success' ? theme.success : status === 'error' ? theme.error : theme.info;
+    const summary = meta ? `${label} ${theme.muted(meta)}` : label;
+    console.log(`${color('●')} ${theme.text(summary)}`);
+}
+
+export class ActivityDisplay {
+    private spinner: Ora | null = null;
+    private stepCount = 0;
+    private toolCalls: ToolCallEntry[] = [];
+    private startTime = Date.now();
+    private readonly branch = getBranchName();
+
+    startThinking(): void {
+        if (!process.stdout.isTTY || !process.stderr.isTTY) return;
+        if (this.spinner) return;
+
+        this.spinner = ora({
+            text: theme.soft('Forge is working...'),
+            spinner: 'dots',
+            color: 'yellow',
+            stream: process.stdout,
+        }).start();
+    }
+
+    stopThinking(): void {
+        if (!this.spinner) return;
+        this.spinner.clear();
+        this.spinner.stop();
+        this.spinner = null;
+    }
+
+    onStepStart(): void {
+        this.stopThinking();
+    }
+
+    onToolCall(call: { toolName: string; toolCallId: string; args: Record<string, any> }): void {
+        this.stopThinking();
+
+        const entry: ToolCallEntry = {
+            id: call.toolCallId,
+            name: call.toolName,
+            displayName: formatToolLabel(call.toolName),
+            args: call.args,
+            startTime: Date.now(),
+            status: 'running',
+        };
+
+        this.toolCalls.push(entry);
+
+        const label = `${entry.displayName} ${summarizeTool(call.toolName, call.args)}`;
+        renderStatusLine(label, 'info');
+    }
+
+    onToolResult(result: { toolName: string; toolCallId: string; output?: any; result?: any }): void {
+        const entry = this.toolCalls.find((item) => item.id === result.toolCallId);
+        if (entry) {
+            entry.endTime = Date.now();
+            entry.result = safeStringify(getToolResultValue(result));
+            entry.status = entry.result.toLowerCase().startsWith('error') ? 'error' : 'done';
+            const duration = formatDuration(entry.endTime - entry.startTime);
+            const preview = formatResultPreview(entry.result);
+            renderStatusLine(preview, entry.status === 'error' ? 'error' : 'success', `· ${duration}`);
+        }
+
+        this.startThinking();
+    }
+
+    onText(text: string): void {
+        this.stopThinking();
+        if (!text.trim()) return;
+
+        const width = terminalWidth();
+        const rows: string[] = [];
+
+        for (const block of text.trim().split('\n')) {
+            const prefix = block.trim() ? `${theme.accent('✦')} ${theme.text(block.trim())}` : '';
+            rows.push(prefix);
+        }
+
+        renderPanel(theme.panel(' Response '), rows, width);
+    }
+
+    onStepFinish(step: { toolCalls: StepToolCall[]; toolResults: StepToolResult[]; text?: string }): void {
+        this.stopThinking();
+        this.stepCount++;
+
+        const width = terminalWidth();
+        const rows: string[] = [];
+        const resultsById = new Map(step.toolResults.map((result) => [result.toolCallId, result]));
+
+        for (const call of step.toolCalls) {
+            const args = call.args || {};
+            const label = call.title || formatToolLabel(call.toolName);
+            const summary = summarizeTool(call.toolName, args);
+            const result = resultsById.get(call.toolCallId);
+            const resultValue = getToolResultValue(result);
+            const resultText = formatResultPreview(safeStringify(resultValue ?? ''));
+            const isError = safeStringify(resultValue ?? '')
+                .toLowerCase()
+                .startsWith('error');
+
+            const existing = this.toolCalls.find((entry) => entry.id === call.toolCallId);
+            if (!existing) {
+                this.toolCalls.push({
+                    id: call.toolCallId,
+                    name: call.toolName,
+                    displayName: label,
+                    args,
+                    startTime: Date.now(),
+                    endTime: Date.now(),
+                    result: safeStringify(resultValue ?? ''),
+                    status: isError ? 'error' : 'done',
+                });
+            }
+
+            const icon = isError ? theme.error('✕') : theme.success('✓');
+            rows.push(`${icon} ${theme.strong(label)} ${theme.soft(summary)}`);
+            for (const bodyLine of formatToolBody(call, result)) {
+                rows.push(`  ${bodyLine}`);
+            }
+            rows.push('');
+        }
+
+        if (rows.length > 0 && rows[rows.length - 1] === '') {
+            rows.pop();
+        }
+
+        if (rows.length > 0) {
+            renderPanel(`${theme.text(` Step ${this.stepCount} `)}${theme.muted(`· ${step.toolCalls.length} tool${step.toolCalls.length === 1 ? '' : 's'}`)} `, rows, width);
+        }
+
+        if (step.text?.trim()) {
+            const responseRows: string[] = [];
+            for (const line of step.text.trim().split('\n')) {
+                if (!line.trim()) {
+                    responseRows.push('');
+                    continue;
+                }
+                responseRows.push(`${theme.accent('✦')} ${theme.text(line.trim())}`);
+            }
+            renderPanel(theme.panel(' Response '), responseRows, width);
+        }
+
+        this.startThinking();
+    }
+
+    printSummary(status: 'success' | 'error', message?: string): void {
+        this.stopThinking();
+
+        const elapsed = formatDuration(Date.now() - this.startTime);
+        const title =
+            status === 'success'
+                ? `${theme.success(' Task complete ')}${theme.muted(`· ${this.stepCount} steps · ${elapsed}`)}`
+                : `${theme.error(' Task failed ')}${theme.muted(`· ${this.stepCount} steps · ${elapsed}`)}`;
+
+        const rows = status === 'error' && message ? [theme.error(message)] : [theme.soft('Session finished. You can run another task with `forge "<task>"`.')];
+
+        console.log('');
+        renderPanel(title, rows);
+        this.renderFooter();
+    }
+
+    private renderFooter(): void {
+        const width = terminalWidth();
+        const inner = contentWidth(width);
+        const rows = [
+            ...createMetaRow('workspace', getWorkspaceLabel(), inner),
+            ...createMetaRow('branch', this.branch, inner),
+            ...createMetaRow('provider', 'Ollama', inner),
+            ...createMetaRow('model', defaultModel, inner),
+        ];
+
+        renderPanel(theme.panel(' Session '), rows, width);
+    }
+
+    static printBanner(task: string): void {
+        const width = terminalWidth();
+        const inner = contentWidth(width);
+        const rows = [
+            ...createMetaRow('task', task, inner),
+            ...createMetaRow('workspace', getWorkspaceLabel(), inner),
+            ...createMetaRow('branch', getBranchName(), inner),
+            ...createMetaRow('model', `${defaultModel} via Ollama`, inner),
+        ];
+
+        console.log('');
+        renderPanel(`${theme.accentStrong(' Forge ')}${theme.muted('· terminal coding agent')}`, rows, width);
+    }
+}

package/src/utils/logger.ts

@@ -0,0 +1,10 @@
+import chalk from 'chalk';
+
+export const logger = {
+    info: (msg: string) => console.log(chalk.blue('ℹ'), msg),
+    success: (msg: string) => console.log(chalk.green('✔'), msg),
+    error: (msg: string) => console.log(chalk.red('✖'), msg),
+    warn: (msg: string) => console.log(chalk.yellow('⚠'), msg),
+    tool: (name: string, params: any) => console.log(chalk.cyan('⚒'), chalk.bold(name), chalk.gray(JSON.stringify(params))),
+    step: (msg: string) => console.log(chalk.magenta('➜'), msg),
+};

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "types": ["node"],
+        "strict": false,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "sourceMap": true,
+        "declaration": true
+    },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "dist"]
+}