agent-termo 0.0.0-stage → 1.0.1

package/src/main.ts

@@ -0,0 +1,427 @@
+// =============================================================================
+// Agent-Termo — Main REPL entry point
+// =============================================================================
+
+import { NimClient } from './llm/client.js';
+import { TOOL_DEFINITIONS } from './llm/tools.js';
+import { executeTool, applyFileChange } from './tools/index.js';
+import { loadMemory, logToTimeline, logAgentTermoTimeline } from './memory/index.js';
+import { loadAllAgents } from './agents/index.js';
+import { buildSystemPrompt } from './agents/index.js';
+import { resolveProjectRoot } from './utils/config.js';
+import {
+	printWelcome,
+	printUserMessage,
+	printAssistantMessage,
+	printToolCall,
+	printToolResult,
+	printError,
+	printSuccess,
+	printInfo,
+	printHelp,
+	printAgentsList,
+	printMemoryFile,
+	printTimelineFile,
+	startSpinner,
+	stopSpinner,
+	clearScreen,
+	createInput,
+	moveToFreshLine,
+	promptAcceptReject,
+} from './ui/index.js';
+import type { ConversationMessage, ToolCall, ProposedFileChange } from './types/index.js';
+
+const TOOL_KEYWORDS = [
+	'build', 'create', 'write', 'edit', 'modify', 'file', 'code', 'function', 'class',
+	'component', 'debug', 'fix', 'git', 'commit', 'push', 'install', 'npm', 'run',
+	'bash', 'shell', 'command', 'read', 'grep', 'check', 'show', 'implement',
+	'configure', 'setup', 'src', 'package', 'app', 'project', 'api', 'deploy',
+	'test', 'compile', 'typescript', 'javascript', 'python', 'node', 'add', 'delete',
+];
+
+function mightNeedTools(message: string): boolean {
+	const lower = message.toLowerCase();
+	return TOOL_KEYWORDS.some((w) => lower.includes(w));
+}
+
+function dedup(arr: ToolCall[]): ToolCall[] {
+	const seen = new Set<string>();
+	return arr.filter((tc) => {
+		if (seen.has(tc.id)) return false;
+		seen.add(tc.id);
+		return true;
+	});
+}
+
+function extractProposedChange(toolName: string, resultOutput: string): ProposedFileChange | undefined {
+	const isFileTool = toolName === 'file:write' || toolName === 'file:edit';
+	if (!isFileTool) return undefined;
+	try {
+		const parsed = JSON.parse(resultOutput);
+		if (parsed?.needsApproval && parsed?.proposedChange) {
+			return parsed.proposedChange as ProposedFileChange;
+		}
+	} catch {
+		// Not JSON — tool returned a simple string
+	}
+	return undefined;
+}
+
+interface InputController {
+	close(): void;
+	showPrompt(): void;
+}
+
+/**
+ * Open a VS Code diff window for the proposed change.
+ * Writes original + proposed content to temp files and launches `code --diff`.
+ */
+async function openVsCodeDiff(change: ProposedFileChange): Promise<void> {
+	try {
+		const { exec } = await import('node:child_process');
+		const { promisify } = await import('node:util');
+		const { mkdtemp, writeFile } = await import('node:fs/promises');
+		const { basename } = await import('node:path');
+		const { tmpdir } = await import('node:os');
+
+		const execAsync = promisify(exec);
+
+		const originalPath = change.path;
+		const tmpDir = await mkdtemp(tmpdir() + '/agent-termo-diff-');
+		const tmpFile = tmpDir + '/' + basename(originalPath);
+
+		await writeFile(tmpFile, change.proposedContent, 'utf-8');
+
+		// Write original content to a temp file for diff display
+		if (!change.isNewFile && change.originalContent.length > 0) {
+			const originalTmp = tmpDir + '/original-' + basename(originalPath);
+			await writeFile(originalTmp, change.originalContent, 'utf-8');
+			execAsync(`code --diff "${originalTmp}" "${tmpFile}" --wait`).catch(() => {
+				// VS Code not available or user closed — continue silently
+			});
+		} else {
+			// New file: just open the proposed file
+			execAsync(`code "${tmpFile}" --wait`).catch(() => {
+				// Silently fall back
+			});
+		}
+	} catch {
+		// Silently fall back to terminal diff view
+	}
+}
+
+async function executeToolWithReview(
+	toolName: string,
+	args: Record<string, unknown>,
+	projectRoot: string,
+	input: InputController,
+): Promise<{ toolResult: { success: boolean; output?: string; error?: string }; change?: ProposedFileChange; applied: boolean }> {
+	console.log('');
+	printToolCall(toolName, args);
+	startSpinner('Running ' + toolName);
+	const toolResult = await executeTool(toolName, args, projectRoot);
+	stopSpinner(toolResult.success);
+
+	const proposedChange = extractProposedChange(toolName, toolResult.output ?? '');
+
+	if (proposedChange) {
+		// Pause REPL input to prevent stale listeners from interfering with promptAcceptReject
+		input.close();
+
+		// Show terminal diff viewer
+		printToolResult(toolName, { success: toolResult.success, output: toolResult.output, error: toolResult.error }, { needsApproval: true, proposedChange });
+
+		// Also open VS Code diff window (non-blocking, fire-and-forget)
+		openVsCodeDiff(proposedChange);
+
+		const decision = await promptAcceptReject('Accept this change?');
+
+		// Restore input for next REPL iteration
+		input.showPrompt();
+
+		if (decision === 'accept') {
+			startSpinner('Writing to disk');
+			const applyResult = await applyFileChange(proposedChange, projectRoot);
+			stopSpinner(applyResult.success);
+			if (applyResult.success) {
+				printSuccess(applyResult.output ?? 'Change applied');
+				return { toolResult: applyResult, change: proposedChange, applied: true };
+			} else {
+				printError(applyResult.error ?? 'Failed to apply change');
+				return { toolResult: applyResult, change: proposedChange, applied: false };
+			}
+		} else {
+			printInfo('Change rejected — file was not modified');
+			return { toolResult, change: proposedChange, applied: false };
+		}
+	}
+
+	printToolResult(toolName, toolResult);
+	return { toolResult, applied: false };
+}
+
+/**
+ * Run the tool-call loop: execute tools, feed results back to the LLM,
+ * and repeat until the LLM stops issuing tool calls.
+ */
+async function runToolLoop(
+	conversation: ConversationMessage[],
+	projectRoot: string,
+	initialToolCalls: ToolCall[],
+	input: InputController,
+	nimClient: NimClient,
+): Promise<string> {
+	let toolCalls = initialToolCalls;
+	let finalText = '';
+
+	// Continue looping while the LLM keeps issuing tool calls
+	while (toolCalls.length > 0) {
+		// Execute all tool calls from this turn
+		for (const tc of toolCalls) {
+			const execution = await executeToolWithReview(tc.name, tc.arguments, projectRoot, input);
+
+			const toolResult = execution.toolResult;
+			const statusText = toolResult.success ? 'OK' : ('ERR: ' + (toolResult.error ? toolResult.error.slice(0, 80) : 'unknown error'));
+			const changeNote = execution.change ? (execution.applied ? ' (applied)' : ' (rejected)') : '';
+
+			conversation.push({
+				id: crypto.randomUUID(),
+				role: 'tool',
+				content: (toolResult.success ? 'Result: ' : 'Error: ') + (toolResult.success ? (toolResult.output ?? '') : toolResult.error) + changeNote,
+				timestamp: new Date(),
+			});
+
+			logToTimeline(projectRoot, 'Tool: ' + tc.name + ' -- ' + statusText + changeNote);
+			logAgentTermoTimeline('Tool: ' + tc.name + ' -- ' + statusText + changeNote);
+		}
+
+		// Send conversation (including tool results) back to the LLM
+		// The LLM will either produce text or more tool calls
+		moveToFreshLine();
+		startSpinner('Working...');
+		try {
+			const tools = nimClient.buildToolDefs(TOOL_DEFINITIONS);
+			const result = await nimClient.complete(conversation, tools);
+			finalText = result.content;
+			toolCalls = dedup(result.toolCalls);
+			process.stdout.write('\n');
+			stopSpinner(true);
+
+			// If the LLM produced text alongside tool calls, save it
+			if (finalText && finalText.trim() && finalText.trim() !== 'null') {
+				conversation.push({
+					id: crypto.randomUUID(),
+					role: 'assistant',
+					content: finalText.trim(),
+					timestamp: new Date(),
+				});
+			}
+		} catch (err) {
+			process.stdout.write('\n');
+			stopSpinner(false);
+			printError('LLM error: ' + (err instanceof Error ? err.message : String(err)));
+			break;
+		}
+	}
+
+	return finalText;
+}
+
+export async function runRepl(projectRoot?: string): Promise<void> {
+	projectRoot = resolveProjectRoot(projectRoot);
+
+	const memory = await loadMemory(projectRoot);
+	const nimClient = new NimClient(projectRoot);
+	const systemPrompt = buildSystemPrompt(memory, '', projectRoot);
+
+	const session = { id: crypto.randomUUID(), projectRoot, startedAt: new Date() };
+
+	const conversation: ConversationMessage[] = [
+		{
+			id: crypto.randomUUID(),
+			role: 'system',
+			content: systemPrompt,
+			timestamp: new Date(),
+		},
+	];
+
+	printWelcome(projectRoot);
+	console.log('Model: ' + nimClient.getModel());
+	logAgentTermoTimeline('Agent-Termo session started. Model: ' + nimClient.getModel());
+	logToTimeline(projectRoot, 'Agent-Termo session started. Model: ' + nimClient.getModel());
+	logAgentTermoTimeline('Commands: /help /clear /memory /timeline /model /agents /history');
+	logToTimeline(projectRoot, 'Commands: /help /clear /memory /timeline /model /agents /history');
+
+	const input = createInput();
+
+	const cleanup = () => {
+		input.close();
+		process.stdout.write('\n');
+		console.log(
+			'Session complete. ' +
+			Math.round((Date.now() - session.startedAt.getTime()) / 60000) +
+			' minutes.',
+		);
+		process.exit(0);
+	};
+	process.on('SIGINT', cleanup);
+
+	mainLoop: while (true) {
+		try {
+			const userInput = await input.question('');
+			if (!userInput) continue;
+			if (userInput === 'exit' || userInput === 'quit') {
+				cleanup();
+				break;
+			}
+
+			if (userInput.startsWith('/')) {
+				const cmd = userInput.toLowerCase().trim();
+
+				if (cmd === '/help' || cmd === '/') {
+					printHelp();
+					continue mainLoop;
+				}
+				if (cmd === '/clear' || cmd === '/cls') {
+					conversation.length = 1;
+					clearScreen();
+					printWelcome(projectRoot);
+					printSuccess('Conversation cleared.');
+					continue mainLoop;
+				}
+				if (cmd === '/memory') {
+					await printMemoryFile();
+					continue mainLoop;
+				}
+				if (cmd === '/timeline' || cmd === '/tl') {
+					await printTimelineFile();
+					continue mainLoop;
+				}
+				if (cmd === '/model') {
+					printInfo('Current model: ' + nimClient.getModel());
+					continue mainLoop;
+				}
+				if (cmd === '/agents') {
+					const agents = loadAllAgents(process.env.AGENT_TERMO_DIR || '.claude');
+					printAgentsList(agents);
+					continue mainLoop;
+				}
+				if (cmd === '/history' || cmd === '/hist') {
+					printInfo('Conversation (excluding system): ' + (conversation.length - 1) + ' messages');
+					continue mainLoop;
+				}
+				if (cmd === '/exit' || cmd === '/quit') {
+					cleanup();
+					break;
+				}
+
+				console.log('');
+				printHelp();
+				console.log('Unknown command: ' + cmd);
+				console.log('Type /help for available commands.\n');
+				continue mainLoop;
+			}
+
+			const userMsg: ConversationMessage = {
+				id: crypto.randomUUID(),
+				role: 'user',
+				content: userInput,
+				timestamp: new Date(),
+			};
+			conversation.push(userMsg);
+			printUserMessage(userMsg);
+
+			moveToFreshLine();
+
+			const useTools = mightNeedTools(userInput);
+			const tools = useTools ? nimClient.buildToolDefs(TOOL_DEFINITIONS) : undefined;
+
+			if (useTools) {
+				startSpinner('Working...');
+				try {
+					const result = await nimClient.complete(conversation, tools);
+					const fullText = result.content;
+					let toolCalls = dedup(result.toolCalls);
+					stopSpinner(true);
+
+					if (toolCalls.length === 0) {
+						// No tool calls — just display the text response
+						const cleanText = (fullText ?? '').trim().replace(/^null$/, '').trim();
+						if (cleanText) {
+							conversation.push({
+								id: crypto.randomUUID(),
+								role: 'assistant',
+								content: cleanText,
+								timestamp: new Date(),
+							});
+						}
+					} else {
+						// Run the tool-call loop: execute tools, feed results back, repeat
+						const finalText = await runToolLoop(conversation, projectRoot, toolCalls, input, nimClient);
+						if (finalText && finalText.trim() && finalText.trim() !== 'null') {
+							printAssistantMessage(finalText.trim());
+						}
+					}
+				} catch (err) {
+					process.stdout.write('\n');
+					stopSpinner(false);
+					printError('LLM error: ' + (err instanceof Error ? err.message : String(err)));
+					conversation.pop();
+					continue mainLoop;
+				}
+			} else {
+				// No tools — stream the response
+				startSpinner('Thinking...');
+				try {
+					const gen = nimClient.streamComplete(conversation, undefined, (text: string) => {
+						process.stdout.write(text);
+					});
+					let receivedContent = false;
+					for await (const result of gen) {
+						if (result.content && result.content.trim()) {
+							receivedContent = true;
+						}
+					}
+					if (receivedContent) {
+						process.stdout.write('\n');
+						stopSpinner(true);
+					} else {
+						process.stdout.write('\n');
+						stopSpinner(undefined);
+					}
+				} catch {
+					process.stdout.write('\n');
+					stopSpinner(false);
+					startSpinner('Retrying...');
+					try {
+						const result = await nimClient.complete(conversation, undefined);
+						process.stdout.write('\n');
+						stopSpinner(true);
+						const cleanText = (result.content ?? '').trim();
+						if (cleanText) {
+							conversation.push({
+								id: crypto.randomUUID(),
+								role: 'assistant',
+								content: cleanText,
+								timestamp: new Date(),
+							});
+						}
+					} catch (err2) {
+						process.stdout.write('\n');
+						stopSpinner(false);
+						printError('LLM error: ' + (err2 instanceof Error ? err2.message : String(err2)));
+						conversation.pop();
+						continue mainLoop;
+					}
+				}
+			}
+
+			if (conversation.length > 42) {
+				conversation.splice(1, conversation.length - 42);
+			}
+		} catch (err) {
+			stopSpinner(false);
+			printError('Session error: ' + (err instanceof Error ? err.message : String(err)));
+		}
+	}
+}

package/src/memory/index.ts

@@ -0,0 +1,130 @@
+// =============================================================================
+// Memory & Timeline Runtime
+// =============================================================================
+
+import { readFileSync as readFile, appendFileSync as appendFile, writeFileSync as writeFile, existsSync, mkdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+// ── Agent-Termo Home Memory ──────────────────────────────────────────────────
+
+function ensureAgentTermoDir(): string {
+ const dir = resolve(process.env.HOME || process.env.USERPROFILE || '.', '.agent-termo');
+ try {
+   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+ } catch {
+   // non-fatal; callers will handle missing file
+ }
+ return dir;
+}
+
+const AGENT_TERMO_MEMORY_PATH = resolve(ensureAgentTermoDir(), 'memory.md');
+
+export function loadAgentTermoMemory(): string {
+ if (!existsSync(AGENT_TERMO_MEMORY_PATH)) return '';
+ try {
+   return readFile(AGENT_TERMO_MEMORY_PATH, 'utf-8');
+ } catch {
+   return '';
+ }
+}
+
+export function appendToAgentTermoMemory(entry: string): void {
+ const timestamp = new Date().toISOString().split('T')[0];
+ const content = '\n\n## ' + timestamp + '\n\n' + entry;
+ try {
+   appendFile(AGENT_TERMO_MEMORY_PATH, content, 'utf-8');
+ } catch {
+   // ignore persistence failure
+ }
+}
+
+const AGENT_TERMO_TIMELINE_PATH = resolve(ensureAgentTermoDir(), 'timeline.md');
+
+export function loadAgentTermoTimeline(): string {
+ if (!existsSync(AGENT_TERMO_TIMELINE_PATH)) return '';
+ try {
+   return readFile(AGENT_TERMO_TIMELINE_PATH, 'utf-8');
+ } catch {
+   return '';
+ }
+}
+
+export function logAgentTermoTimeline(message: string): void {
+ const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 16);
+ const entry = '\n- [' + timestamp + '] ' + message;
+ try {
+   appendFile(AGENT_TERMO_TIMELINE_PATH, entry, 'utf-8');
+ } catch {
+   // ignore persistence failure
+ }
+}
+
+// ── Project Memory & Timeline Runtime ──────────────────────────────────────
+
+export async function loadMemory(projectRoot: string): Promise<string> {
+ const path = resolve(projectRoot, 'docs', 'MEMORY.md');
+ if (!existsSync(path)) return '';
+ try {
+   return readFile(path, 'utf-8');
+ } catch {
+   return '';
+ }
+}
+
+export async function appendToMemory(projectRoot: string, entry: string): Promise<void> {
+ const path = resolve(projectRoot, 'docs', 'MEMORY.md');
+ const timestamp = new Date().toISOString().split('T')[0];
+ appendFile(path, '\n\n## ' + timestamp + '\n\n' + entry, 'utf-8');
+}
+
+// ── Timeline System ──────────────────────────────────────────────────────────
+
+const TIMELINE_TEMPLATE = '# Project Timeline\n\nThis document tracks the complete chronological history of the project.\n\n---\n\n';
+
+export async function loadTimeline(projectRoot: string): Promise<string> {
+ const path = resolve(projectRoot, 'docs', 'TIMELINE.md');
+ if (!existsSync(path)) {
+   try {
+     writeFile(path, TIMELINE_TEMPLATE, 'utf-8');
+   } catch {
+     // ignore
+   }
+   return '';
+ }
+ try {
+   return readFile(path, 'utf-8');
+ } catch {
+   return '';
+ }
+}
+
+export async function appendToTimeline(
+ projectRoot: string,
+ agent: string,
+ phase: string,
+ actions: string[],
+ notes: string[] = [],
+): Promise<void> {
+ const path = resolve(projectRoot, 'docs', 'TIMELINE.md');
+ const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 16);
+
+ const entry =
+   '\n\n---\n\n## [' +
+   timestamp +
+   '] - ' +
+   agent +
+   '\n\n### Phase/Activity\n' +
+   phase +
+   '\n\n### Actions Taken\n' +
+   actions.map((a) => '- ' + a).join('\n') +
+   '\n\n### Notes\n' +
+   (notes.length > 0 ? notes.map((n) => '- ' + n).join('\n') : '- (none)');
+
+ appendFile(path, entry, 'utf-8');
+}
+
+export async function logToTimeline(projectRoot: string, message: string): Promise<void> {
+ const path = resolve(projectRoot, 'docs', 'TIMELINE.md');
+ const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 16);
+ appendFile(path, '\n- [' + timestamp + '] ' + message, 'utf-8');
+}