agent-termo 0.0.0-stage → 1.0.0

package/package.json

@@ -1,6 +1,90 @@
-{
-  "name": "agent-termo",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+{
+  "name": "agent-termo",
+  "version": "1.0.0",
+  "description": "Terminal-based AI coding agent that replicates Claude Code experience",
+  "type": "module",
+  "main": "dist/main.js",
+  "bin": {
+    "agent-termo": "./dist/cli.js"
+  },
+  "scripts": {
+    "dev": "tsx watch src/cli.ts",
+    "build": "tsx scripts/build.mjs",
+    "build:tsc": "tsc",
+    "build:esbuild": "node scripts/build.mjs",
+    "build:pkg": "pkg --targets node20-win-x64,node20-macos-x64,node20-linux-x64 --output dist/",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "cli": "tsx src/cli.ts"
+  },
+  "keywords": [
+    "cli",
+    "terminal",
+    "ai",
+    "agent",
+    "coding",
+    "llm",
+    "nvidia",
+    "nim"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/krish2312005/agent-termo.git"
+  },
+  "homepage": "https://github.com/krish2312005/agent-termo#readme",
+  "bugs": {
+    "url": "https://github.com/krish2312005/agent-termo/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "blessed": "^0.1.10",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "fs-extra": "^11.2.0",
+    "marked": "^12.0.0",
+    "openai": "^4.50.0",
+    "simple-git": "^3.24.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/glob": "^8.1.0",
+    "@types/node": "^20.12.0",
+    "@vitest/coverage-v8": "^1.5.0",
+    "esbuild": "^0.21.0",
+    "eslint": "^9.4.0",
+    "pkg": "^5.8.1",
+    "tsx": "^4.10.0",
+    "typescript": "^5.4.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^1.5.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "dist",
+    "src",
+    ".claude"
+  ],
+  "pkg": {
+    "targets": [
+      "node20-win-x64",
+      "node20-macos-x64",
+      "node20-linux-x64"
+    ],
+    "assets": [
+      ".claude/agents/**/*",
+      ".claude/commands/**/*",
+      ".claude/skills/**/*"
+    ],
+    "outputPath": "dist"
+  }
 }

package/src/agents/index.ts

@@ -0,0 +1,94 @@
+// =============================================================================
+// Agent Loader + System Prompt Builder
+// =============================================================================
+
+import { readdirSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Agent } from '../types/index.js';
+
+function parseAgentMeta(content: string): { description: string; tools: string[] } {
+  const descMatch = content.match(/^description:\s*(.+)$/m);
+  const toolsMatch = content.match(/^tools:\s*\[(.+)\]/m);
+  const toolsStr = toolsMatch?.[1] ?? '';
+  const tools = toolsStr
+    ? toolsStr.split(',').map((t) => t.trim().replace(/^["']|["']$/g, ''))
+    : ['file:read', 'file:write', 'file:edit', 'file:glob', 'grep', 'bash:execute', 'git:status', 'git:commit', 'git:push', 'git:log'];
+  return { description: descMatch?.[1]?.trim() ?? '', tools };
+}
+
+export function loadAgentPrompt(agentName: string, agentDir: string): string | null {
+  const candidate = resolve(agentDir, 'agents', agentName + '.md');
+  try {
+    const content = readFileSync(candidate, 'utf-8');
+    const withoutFrontmatter = content.replace(/^---[\s\S]+?---\n/, '');
+    return withoutFrontmatter.trim();
+  } catch {
+    return null;
+  }
+}
+
+export function loadAllAgents(agentDir: string): Agent[] {
+  const agentsDir = resolve(agentDir, 'agents');
+  try {
+    const files = readdirSync(agentsDir).filter((f) => f.endsWith('.md'));
+    const agents: Agent[] = files.map((file) => {
+      const agentId = file.replace(/\.md$/, '');
+      const content = readFileSync(resolve(agentsDir, file), 'utf-8');
+      const meta = parseAgentMeta(content);
+      const withoutFrontmatter = content.replace(/^---[\s\S]+?---\n/, '').trim();
+      return { name: agentId, description: meta.description, systemPrompt: withoutFrontmatter, tools: meta.tools };
+    });
+    return agents.sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+}
+
+// =============================================================================
+// Agent System Prompt Builder
+// =============================================================================
+
+const SYSTEM_BASE = `You are Agent-Termo, a helpful AI assistant in a terminal.
+
+RESPONSE RULES (follow these strictly):
+- Be concise and direct. 1-3 sentences for simple questions.
+- Never output verbose chain-of-thought or reasoning — just the answer.
+- For coding tasks: briefly explain what you did, show key code.
+- Never write "null" or placeholders in your response.
+- When using function calls, respond with the function only — no preamble.
+
+CONVERSATION MODE (default):
+Just chat. Say things like "I'm doing well!" or "2+2 is 4." — no tools needed.
+
+TOOL MODE (when asked to code/build/fix files):
+Use these functions (JSON tool_calls format):
+{"tool_calls":[{"id":"call_1","name":"function_name","arguments":{"key":"value"}}]}
+
+Available functions:
+- file:read(path) → read a file
+- file:write(path, content) → overwrite a file completely
+- file:edit(path, old_string, new_string) → edit a specific line section
+- file:glob(pattern) → list files matching a glob (e.g. "src/**/*.ts")
+- grep(pattern, path, glob?) → search for text in files
+- bash:execute(command) → run a shell command
+- git:status() / git:commit(message) / git:push() → version control
+
+When done, say "Done: <brief summary>."
+
+AVAILABLE FILES:
+- docs/MEMORY.md — project context
+- docs/TIMELINE.md — recent activity log`;
+
+export function buildSystemPrompt(memory: string, timeline: string, _agentDir: string): string {
+  let prompt = SYSTEM_BASE;
+
+  if (memory) {
+    prompt += '\n\n## Project Memory\n' + memory;
+  }
+
+  if (timeline) {
+    prompt += '\n\n## Recent Timeline (last entries)\n' + timeline.slice(-1500);
+  }
+
+  return prompt;
+}

package/src/cli.ts

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+// =============================================================================
+// CLI Entry Point — Agent-Termo
+// =============================================================================
+
+import { Command } from 'commander';
+import { runRepl } from './main.js';
+
+const program = new Command();
+
+program
+  .name('agent-termo')
+  .description('Terminal AI coding agent with Nvidia NIM APIs')
+  .version('1.0.0')
+  .argument('[project]', 'Project directory to operate in', process.cwd())
+  .option('-k, --api-key <key>', 'Nvidia NIM API key')
+  .option('-m, --model <model>', 'Model name to use')
+  .option('--debug', 'Enable debug logging')
+  .action(async (project: string, options: { apiKey?: string; model?: string; debug?: boolean }) => {
+    // Apply CLI overrides to env before main initializes
+    if (options.apiKey) process.env.NIM_API_KEY = options.apiKey;
+    if (options.model) process.env.NIM_MODEL = options.model;
+    if (options.debug) process.env.LOG_LEVEL = 'debug';
+
+    console.log(`Starting Agent-Termo in: ${project}`);
+    await runRepl(project);
+  });
+
+program
+  .command('init')
+  .description('Initialize Agent-Termo in a project directory')
+  .argument('[dir]', 'Directory to initialize', '.')
+  .action(async (dir: string) => {
+    const { mkdirSync, writeFileSync, existsSync } = await import('node:fs');
+    const { resolve } = await import('node:path');
+
+    const dirsToCreate = [resolve(dir, 'docs'), resolve(dir, '.claude', 'agents'), resolve(dir, 'src')];
+    for (const d of dirsToCreate) {
+      mkdirSync(d, { recursive: true });
+    }
+
+    // Create stub docs
+    const memoryPath = resolve(dir, 'docs', 'MEMORY.md');
+    if (!existsSync(memoryPath)) {
+      writeFileSync(memoryPath, '# Project Memory\n\n## Project Context\n(Add project context here)\n', 'utf-8');
+    }
+
+    const timelinePath = resolve(dir, 'docs', 'TIMELINE.md');
+    if (!existsSync(timelinePath)) {
+      writeFileSync(
+        timelinePath,
+        '# Project Timeline\n\n## Initialization\n- [date] Agent-Termo initialized\n',
+        'utf-8',
+      );
+    }
+
+    console.log(`\n✓ Initialized Agent-Termo in ${resolve(dir)}`);
+    console.log('  Created: docs/MEMORY.md, docs/TIMELINE.md');
+    console.log('  Create a .env file with your NIM_API_KEY to get started.');
+  });
+
+async function main() {
+  // Check for unparsed arguments — if none, run repl mode
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    await runRepl(process.cwd());
+    return;
+  }
+
+  await program.parseAsync(process.argv);
+}
+
+main().catch((err) => {
+  console.error(`\nFatal error: ${err instanceof Error ? err.message : err}`);
+  process.exit(1);
+});

package/src/diff/index.ts

@@ -0,0 +1,255 @@
+// =============================================================================
+// Diff Engine — line-level diff computation for file change review
+// =============================================================================
+// Uses LCS (Longest Common Subsequence) to compute minimal line-level diffs.
+
+import type { DiffLine, DiffResult } from '../types/index.js';
+
+// ── LCS-based Diff Algorithm ────────────────────────────────────────────────
+
+export function computeDiff(original: string, proposed: string): DiffResult {
+	const originalLines = original.split('\n');
+	const proposedLines = proposed.split('\n');
+
+	if (originalLines.length === 1 && originalLines[0] === '') {
+		const lines: DiffLine[] = proposedLines.map((content, i) => ({
+			type: 'add',
+			lineNumber: i + 1,
+			content,
+		}));
+		return { file: '', lines, additions: proposedLines.length, deletions: 0 };
+	}
+
+	if (original === proposed) {
+		return { file: '', lines: [], additions: 0, deletions: 0 };
+	}
+
+	const m = originalLines.length;
+	const n = proposedLines.length;
+	const stride = n + 1;
+	const table = new Int32Array((m + 1) * (n + 1));
+
+	const get = (i: number, j: number): number => table[i * stride + j]!;
+	const set = (i: number, j: number, val: number) => { table[i * stride + j] = val; };
+
+	for (let i = 1; i <= m; i++) {
+		for (let j = 1; j <= n; j++) {
+			if (originalLines[i - 1] === proposedLines[j - 1]) {
+				set(i, j, get(i - 1, j - 1) + 1);
+			} else {
+				set(i, j, Math.max(get(i - 1, j), get(i, j - 1)));
+			}
+		}
+	}
+
+	const ops = backtrackLCS(get, originalLines, proposedLines);
+	const diffLines = opsToDiffLines(ops);
+
+	let additions = 0;
+	let deletions = 0;
+	for (const line of diffLines) {
+		if (line.type === 'add') additions++;
+		if (line.type === 'remove') deletions++;
+	}
+
+	return { file: '', lines: diffLines, additions, deletions };
+}
+
+interface DiffOp {
+	type: 'same' | 'add' | 'remove';
+	originalIndex: number;
+	proposedIndex: number;
+	originalLine?: string;
+	proposedLine?: string;
+}
+
+function backtrackLCS(
+	get: (i: number, j: number) => number,
+	a: string[],
+	b: string[],
+): DiffOp[] {
+	const ops: DiffOp[] = [];
+	const m = a.length;
+	const n = b.length;
+	let i = m;
+	let j = n;
+
+	while (i > 0 || j > 0) {
+		if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+			ops.unshift({
+				type: 'same',
+				originalIndex: i,
+				proposedIndex: j,
+				originalLine: a[i - 1],
+				proposedLine: b[j - 1],
+			});
+			i--;
+			j--;
+		} else if (j > 0 && (i === 0 || get(i, j - 1) >= get(i - 1, j))) {
+			ops.unshift({
+				type: 'add',
+				proposedIndex: j,
+				originalIndex: i,
+				proposedLine: b[j - 1],
+			});
+			j--;
+		} else {
+			ops.unshift({
+				type: 'remove',
+				originalIndex: i,
+				proposedIndex: j,
+				originalLine: a[i - 1],
+			});
+			i--;
+		}
+	}
+
+	return ops;
+}
+
+function opsToDiffLines(ops: DiffOp[]): DiffLine[] {
+	const lines: DiffLine[] = [];
+	let originalLineNum = 0;
+	let proposedLineNum = 0;
+
+	for (const op of ops) {
+		switch (op.type) {
+			case 'same': {
+				originalLineNum++;
+				proposedLineNum++;
+				lines.push({
+					type: 'context',
+					lineNumber: originalLineNum,
+					content: op.originalLine ?? '',
+				});
+				break;
+			}
+			case 'remove': {
+				originalLineNum++;
+				lines.push({
+					type: 'remove',
+					lineNumber: originalLineNum,
+					content: op.originalLine ?? '',
+				});
+				break;
+			}
+			case 'add': {
+				proposedLineNum++;
+				lines.push({
+					type: 'add',
+					lineNumber: proposedLineNum,
+					content: op.proposedLine ?? '',
+				});
+				break;
+			}
+		}
+	}
+
+	return lines;
+}
+
+// ── Context Extraction for large files ──────────────────────────────────────
+
+export interface DiffOptions {
+	contextLines?: number;
+	maxLines?: number;
+}
+
+export function applyDiffContext(diff: DiffResult, options: DiffOptions = {}): DiffResult {
+	const { contextLines = 3, maxLines = 0 } = options;
+
+	if (contextLines <= 0 && maxLines <= 0) {
+		return diff;
+	}
+
+	// Identify contiguous change regions
+	const changeRegions: { start: number; end: number }[] = [];
+	let inChange = false;
+	let regionStart = 0;
+
+	for (let i = 0; i < diff.lines.length; i++) {
+		const line = diff.lines[i]!;
+		if (line.type === 'add' || line.type === 'remove') {
+			if (!inChange) {
+				regionStart = i;
+				inChange = true;
+			}
+		} else {
+			if (inChange) {
+				changeRegions.push({ start: regionStart, end: i - 1 });
+				inChange = false;
+			}
+		}
+	}
+	if (inChange) {
+		changeRegions.push({ start: regionStart, end: diff.lines.length - 1 });
+	}
+
+	// Build merged ranges — use parallel arrays to avoid tuple strict-null issues
+	// All accesses use ! because arrays are never sparse at these indices
+	const mergeStarts: number[] = [];
+	const mergeEnds: number[] = [];
+
+	for (const region of changeRegions) {
+		const start = Math.max(0, region.start - contextLines);
+		const end = Math.min(diff.lines.length - 1, region.end + contextLines);
+
+		const lastIdx = mergeStarts.length - 1;
+		if (mergeStarts.length > 0 && start <= mergeEnds[lastIdx]! + 1) {
+			mergeEnds[lastIdx] = Math.max(mergeEnds[lastIdx]!, end);
+		} else {
+			mergeStarts.push(start);
+			mergeEnds.push(end);
+		}
+	}
+
+	// Build filtered diff lines with ellipsis between non-adjacent ranges
+	const filteredLines: DiffLine[] = [];
+
+	for (let r = 0; r < mergeStarts.length; r++) {
+		const rangeStart = mergeStarts[r]!;
+		const rangeEnd = mergeEnds[r]!;
+		const prevEnd = r > 0 ? mergeEnds[r - 1]! : -1;
+
+		if (r > 0 && rangeStart > prevEnd + 1) {
+			const omitted = rangeStart - prevEnd - 1;
+			filteredLines.push({
+				type: 'context',
+				lineNumber: 0,
+				content: '... ' + omitted + ' unchanged lines omitted ...',
+			});
+		}
+
+		for (let i = rangeStart; i <= rangeEnd; i++) {
+			const line = diff.lines[i]!;
+			filteredLines.push(line);
+		}
+	}
+
+	let finalLines = filteredLines;
+	if (maxLines > 0 && finalLines.length > maxLines) {
+		const halfMax = Math.floor(maxLines / 2);
+		finalLines = [
+			...finalLines.slice(0, halfMax),
+			{
+				type: 'context',
+				lineNumber: 0,
+				content: '... ' + (finalLines.length - maxLines) + ' more lines ...',
+			},
+			...finalLines.slice(finalLines.length - halfMax),
+		];
+	}
+
+	let additions = 0;
+	let deletions = 0;
+	for (const line of finalLines) {
+		if (line.type === 'add') additions++;
+		if (line.type === 'remove') deletions++;
+	}
+
+	return { ...diff, lines: finalLines, additions, deletions };
+}
+
+export function isNoOpDiff(diff: DiffResult): boolean {
+	return diff.lines.length === 0 && diff.additions === 0 && diff.deletions === 0;
+}