thatgfsj-code 0.3.0

package/src/prompts/index.ts

@@ -0,0 +1,123 @@
+/**
+ * System Prompt Builder - Dynamic prompt construction
+ * Migrated from old src/core/system-prompt.ts
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import type { Tool } from '../tools/types.js';
+
+export interface SystemPromptConfig {
+  cwd?: string;
+  tools?: Tool[];
+  includeProjectMd?: boolean;
+  permissionMode?: 'accept' | 'deny' | 'ask';
+  date?: Date;
+}
+
+export class SystemPromptBuilder {
+  private config: Required<SystemPromptConfig>;
+
+  constructor(config: SystemPromptConfig = {}) {
+    this.config = {
+      cwd: config.cwd ?? process.cwd(),
+      tools: config.tools ?? [],
+      includeProjectMd: config.includeProjectMd ?? true,
+      permissionMode: config.permissionMode ?? 'ask',
+      date: config.date ?? new Date(),
+    };
+  }
+
+  build(): string {
+    const fragments: string[] = [
+      this.buildIdentity(),
+      this.buildToolInstructions(),
+      this.buildEnvironment(),
+      this.buildPermissionMode(),
+      this.buildProjectInstructions(),
+      this.buildDateInfo(),
+    ];
+    return fragments.filter(Boolean).join('\n\n');
+  }
+
+  private buildIdentity(): string {
+    return [
+      'You are Thatgfsj Code, an interactive coding agent running in the user\'s terminal.',
+      '',
+      'You have access to tools (file operations, shell commands, git, search) that let you',
+      'read, write, and modify files and run commands to help with coding tasks.',
+      '',
+      'When working on a task:',
+      '1. First understand what files are involved',
+      '2. Read necessary files to understand the codebase',
+      '3. Make changes using appropriate tools',
+      '4. Verify the changes work',
+      '',
+      'Be concise but thorough. Show your reasoning.',
+      '',
+      'When using tools:',
+      '- Prefer small, targeted operations over large batch changes',
+      '- Confirm destructive operations (rm, git push --force, etc.)',
+      '- Explain what you are going to do before doing it',
+    ].join('\n');
+  }
+
+  private buildToolInstructions(): string {
+    const tools = this.config.tools;
+    if (tools.length === 0) {
+      return '## Tools\n\nNo tools are currently registered.';
+    }
+
+    const toolDescs = tools.map(t => {
+      const params = t.parameters
+        .map(p => `  - ${p.name} (${p.type}${p.required ? ', required' : ''}): ${p.description}`)
+        .join('\n');
+      return `### ${t.name}\n${t.description}\n\nParameters:\n${params}`;
+    }).join('\n\n');
+
+    return `## Tools\n\nYou have access to the following tools:\n\n${toolDescs}\n\nTo use a tool, respond with a tool call. Each tool call must include the tool name and parameters as a JSON object.`;
+  }
+
+  private buildEnvironment(): string {
+    return `## Environment\n\nWorking directory: ${this.config.cwd}`;
+  }
+
+  private buildPermissionMode(): string {
+    const mode = this.config.permissionMode;
+    const explanations: Record<string, string> = {
+      accept: 'All tool calls are automatically allowed without confirmation.',
+      deny: 'All tool calls are blocked. You may only read and discuss.',
+      ask: 'Dangerous or destructive commands require user confirmation before execution.',
+    };
+    return `## Permission Mode\n\nCurrent mode: ${mode}\n\n${explanations[mode] || ''}`;
+  }
+
+  private buildProjectInstructions(): string {
+    if (!this.config.includeProjectMd) return '';
+
+    const cwd = this.config.cwd;
+    const paths = [join(cwd, 'CLAUDE.md'), join(cwd, '.claude.md'), join(cwd, 'AGENTS.md')];
+
+    for (const path of paths) {
+      if (existsSync(path)) {
+        try {
+          const content = readFileSync(path, 'utf-8');
+          return `## Project Instructions (from ${path.split(/[/\\]/).pop()})\n\n${content}`;
+        } catch {
+          // Ignore
+        }
+      }
+    }
+    return '';
+  }
+
+  private buildDateInfo(): string {
+    const now = this.config.date;
+    const iso = now.toISOString().replace('T', ' ').split('.')[0];
+    return `## Current Time\n\n${iso}`;
+  }
+
+  setTools(tools: Tool[]): this { this.config.tools = tools; return this; }
+  setCwd(cwd: string): this { this.config.cwd = cwd; return this; }
+  setPermissionMode(mode: 'accept' | 'deny' | 'ask'): this { this.config.permissionMode = mode; return this; }
+}

package/src/session/compactor.ts

@@ -0,0 +1,103 @@
+/**
+ * Context Compactor - Progressive compression for conversation history
+ * Migrated from old src/core/context-compactor.ts
+ *
+ * Strategy:
+ * 1. Within limit: no compression
+ * 2. Beyond limit: keep system + recent N turns + summarize middle
+ */
+
+import type { ChatMessage } from '../types.js';
+
+export interface CompactorConfig {
+  /** Max messages before compression kicks in */
+  maxMessages?: number;
+  /** How many recent turns to always preserve */
+  preserveRecent?: number;
+}
+
+export interface CompressionResult {
+  originalCount: number;
+  compactedCount: number;
+  removedCount: number;
+}
+
+export class ContextCompactor {
+  private maxMessages: number;
+  private preserveRecent: number;
+
+  constructor(config: CompactorConfig = {}) {
+    this.maxMessages = config.maxMessages ?? 50;
+    this.preserveRecent = config.preserveRecent ?? 10;
+  }
+
+  /**
+   * Compact messages if needed
+   */
+  compact(messages: ChatMessage[]): { compacted: ChatMessage[]; result: CompressionResult } {
+    if (messages.length <= this.maxMessages) {
+      return {
+        compacted: messages,
+        result: { originalCount: messages.length, compactedCount: messages.length, removedCount: 0 },
+      };
+    }
+
+    const systemMsg = messages.find(m => m.role === 'system');
+    const others = messages.filter(m => m.role !== 'system');
+
+    if (others.length <= this.preserveRecent) {
+      return {
+        compacted: messages,
+        result: { originalCount: messages.length, compactedCount: messages.length, removedCount: 0 },
+      };
+    }
+
+    // Keep recent N turns
+    const recent = others.slice(-this.preserveRecent);
+
+    // Summarize the middle portion
+    const middle = others.slice(0, -this.preserveRecent);
+    const summary: ChatMessage = {
+      role: 'system',
+      content: `[Earlier conversation summary: ${middle.length} messages covering ${this.extractTopics(middle)}]`,
+    };
+
+    const compacted = systemMsg
+      ? [systemMsg, summary, ...recent]
+      : [summary, ...recent];
+
+    return {
+      compacted,
+      result: {
+        originalCount: messages.length,
+        compactedCount: compacted.length,
+        removedCount: messages.length - compacted.length,
+      },
+    };
+  }
+
+  /**
+   * Auto-compact if messages exceed limit
+   */
+  autoCompact(messages: ChatMessage[]): { compacted: ChatMessage[]; result: CompressionResult } {
+    return this.compact(messages);
+  }
+
+  /**
+   * Estimate token count (rough: ~4 chars per token)
+   */
+  estimateTokens(messages: ChatMessage[]): number {
+    return messages.reduce((sum, m) => sum + Math.ceil(m.content.length / 4) + 10, 0);
+  }
+
+  /**
+   * Extract topic summary from messages
+   */
+  private extractTopics(msgs: ChatMessage[]): string {
+    const topics = msgs
+      .filter(m => m.role === 'user')
+      .map(m => m.content.slice(0, 30))
+      .slice(0, 3);
+    return topics.join(', ') || 'various topics';
+  }
+}

package/src/session/index.ts

@@ -0,0 +1,81 @@
+/**
+ * Session Manager - Manages conversation history
+ * Migrated from old src/core/session.ts
+ */
+
+import type { ChatMessage } from '../types.js';
+import { ContextCompactor } from './compactor.js';
+
+export class SessionManager {
+  private messages: ChatMessage[] = [];
+  private sessionId: string;
+  private createdAt: Date;
+  private compactor: ContextCompactor;
+
+  constructor(maxMessages = 50) {
+    this.sessionId = `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    this.createdAt = new Date();
+    this.compactor = new ContextCompactor({ maxMessages });
+  }
+
+  /**
+   * Add a message to the session
+   */
+  addMessage(role: ChatMessage['role'], content: string, extras?: Partial<ChatMessage>): void {
+    this.messages.push({ role, content, ...extras });
+  }
+
+  /**
+   * Get all messages (copy)
+   */
+  getMessages(): ChatMessage[] {
+    return [...this.messages];
+  }
+
+  /**
+   * Get message count
+   */
+  getMessageCount(): number {
+    return this.messages.length;
+  }
+
+  /**
+   * Clear session history
+   */
+  clear(): void {
+    this.messages = [];
+  }
+
+  /**
+   * Truncate messages to fit context window
+   */
+  truncate(maxMessages?: number): void {
+    if (maxMessages) {
+      this.compactor = new ContextCompactor({ maxMessages });
+    }
+    const { compacted } = this.compactor.autoCompact(this.messages);
+    this.messages = compacted;
+  }
+
+  /**
+   * Get session ID
+   */
+  getId(): string {
+    return this.sessionId;
+  }
+
+  /**
+   * Get session info
+   */
+  getInfo(): { id: string; messageCount: number; createdAt: Date } {
+    return {
+      id: this.sessionId,
+      messageCount: this.messages.length,
+      createdAt: this.createdAt,
+    };
+  }
+}
+
+export { ContextCompactor } from './compactor.js';
+export type { CompactorConfig, CompressionResult } from './compactor.js';
+export * from './message.js';

package/src/session/message.ts

@@ -0,0 +1,42 @@
+/**
+ * Message types and utilities
+ */
+
+import type { ChatMessage, Role } from '../types.js';
+
+export { ChatMessage, Role };
+
+/**
+ * Create a message
+ */
+export function createMessage(role: Role, content: string, extras?: Partial<ChatMessage>): ChatMessage {
+  return { role, content, ...extras };
+}
+
+/**
+ * Create a system message
+ */
+export function systemMessage(content: string): ChatMessage {
+  return { role: 'system', content };
+}
+
+/**
+ * Create a user message
+ */
+export function userMessage(content: string): ChatMessage {
+  return { role: 'user', content };
+}
+
+/**
+ * Create an assistant message
+ */
+export function assistantMessage(content: string): ChatMessage {
+  return { role: 'assistant', content };
+}
+
+/**
+ * Create a tool result message
+ */
+export function toolMessage(content: string, toolCallId: string, name: string): ChatMessage {
+  return { role: 'tool', content, tool_call_id: toolCallId, name };
+}

package/src/tools/file.ts

@@ -0,0 +1,117 @@
+/**
+ * File Tool - File operations
+ */
+
+import type { Tool, ToolResult } from './types.js';
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync, unlinkSync } from 'fs';
+import { join, dirname, basename, extname } from 'path';
+
+export class FileTool implements Tool {
+  name = 'file';
+  description = 'Perform file operations: read, write, list, delete, etc.';
+
+  inputSchema = {
+    type: 'object' as const,
+    properties: {
+      action: { type: 'string', description: 'Action: read, write, list, delete, exists, mkdir' },
+      path: { type: 'string', description: 'File or directory path' },
+      content: { type: 'string', description: 'Content to write (for write action)' }
+    },
+    required: ['action', 'path']
+  };
+
+  metadata = {
+    permissions: ['read', 'write'] as ('read' | 'write' | 'execute' | 'network')[],
+    tags: ['file', 'filesystem'],
+    maxDuration: 30000,
+    version: '1.0.0'
+  };
+
+  parameters = [
+    { name: 'action', type: 'string', description: 'Action to perform: read, write, list, delete, exists', required: true },
+    { name: 'path', type: 'string', description: 'File or directory path', required: true },
+    { name: 'content', type: 'string', description: 'Content to write (for write action)', required: false }
+  ];
+
+  async execute(params: Record<string, any>): Promise<ToolResult> {
+    const { action, path, content } = params;
+    
+    try {
+      switch (action) {
+        case 'read':
+          return this.readFile(path);
+        case 'write':
+          return this.writeFile(path, content || '');
+        case 'list':
+          return this.listDir(path);
+        case 'delete':
+          return this.deleteFile(path);
+        case 'exists':
+          return this.checkExists(path);
+        case 'mkdir':
+          return this.mkdir(path);
+        default:
+          return { success: false, error: `Unknown action: ${action}` };
+      }
+    } catch (error: any) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  private readFile(path: string): ToolResult {
+    if (!existsSync(path)) {
+      return { success: false, error: `File not found: ${path}` };
+    }
+    
+    const content = readFileSync(path, 'utf-8');
+    return { success: true, output: content };
+  }
+
+  private writeFile(path: string, content: string): ToolResult {
+    const dir = dirname(path);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    
+    writeFileSync(path, content, 'utf-8');
+    return { success: true, output: `File written: ${path}` };
+  }
+
+  private listDir(path: string): ToolResult {
+    if (!existsSync(path)) {
+      return { success: false, error: `Directory not found: ${path}` };
+    }
+    
+    const files = readdirSync(path);
+    const items = files.map(f => {
+      const fullPath = join(path, f);
+      const stat = statSync(fullPath);
+      return {
+        name: f,
+        type: stat.isDirectory() ? 'dir' : 'file',
+        size: stat.size,
+        modified: stat.mtime.toISOString()
+      };
+    });
+    
+    return { success: true, output: JSON.stringify(items, null, 2) };
+  }
+
+  private deleteFile(path: string): ToolResult {
+    if (!existsSync(path)) {
+      return { success: false, error: `Path not found: ${path}` };
+    }
+    
+    unlinkSync(path);
+    return { success: true, output: `Deleted: ${path}` };
+  }
+
+  private checkExists(path: string): ToolResult {
+    return { success: true, output: existsSync(path) ? 'true' : 'false' };
+  }
+
+  private mkdir(path: string): ToolResult {
+    mkdirSync(path, { recursive: true });
+    return { success: true, output: `Created: ${path}` };
+  }
+}

package/src/tools/git.ts

@@ -0,0 +1,132 @@
+/**
+ * Git Tool - Git operations
+ */
+
+import type { Tool, ToolResult } from './types.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { existsSync } from 'fs';
+
+const execAsync = promisify(exec);
+
+export class GitTool implements Tool {
+  name = 'git';
+  description = 'Git operations: status, log, diff, commit, branch, etc.';
+
+  inputSchema = {
+    type: 'object' as const,
+    properties: {
+      action: { type: 'string', description: 'Git action: status, log, diff, commit, branch, checkout, pull, push' },
+      args: { type: 'string', description: 'Additional arguments' },
+      message: { type: 'string', description: 'Commit message' },
+      cwd: { type: 'string', description: 'Working directory' }
+    },
+    required: ['action']
+  };
+
+  metadata = {
+    permissions: ['execute'] as ('read' | 'write' | 'execute' | 'network')[],
+    tags: ['git', 'vcs'],
+    version: '1.0.0'
+  };
+
+  parameters = [
+    { name: 'action', type: 'string', description: 'Git action: status, log, diff, commit, branch, checkout, pull, push', required: true },
+    { name: 'args', type: 'string', description: 'Additional arguments', required: false },
+    { name: 'message', type: 'string', description: 'Commit message (for commit action)', required: false },
+    { name: 'cwd', type: 'string', description: 'Working directory', required: false }
+  ];
+
+  async execute(params: Record<string, any>): Promise<ToolResult> {
+    const { action, args, message, cwd } = params;
+    const workDir = cwd || process.cwd();
+    
+    // Check if git repo exists
+    if (!existsSync(`${workDir}/.git`)) {
+      return { success: false, error: 'Not a git repository' };
+    }
+    
+    try {
+      switch (action) {
+        case 'status':
+          return await this.status(workDir);
+        case 'log':
+          return await this.log(workDir, args || '10');
+        case 'diff':
+          return await this.diff(workDir, args || '');
+        case 'commit':
+          return await this.commit(workDir, message || args);
+        case 'branch':
+          return await this.branch(workDir);
+        case 'checkout':
+          return await this.checkout(workDir, args);
+        case 'pull':
+          return await this.pull(workDir);
+        case 'push':
+          return await this.push(workDir);
+        case 'add':
+          return await this.add(workDir, args || '.');
+        default:
+          return { success: false, error: `Unknown action: ${action}` };
+      }
+    } catch (error: any) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  private async status(cwd: string): Promise<ToolResult> {
+    const { stdout } = await execAsync('git status --short', { cwd });
+    return { success: true, output: stdout || '(clean)' };
+  }
+
+  private async log(cwd: string, limit: string): Promise<ToolResult> {
+    const { stdout } = await execAsync(`git log --oneline -n ${limit}`, { cwd });
+    return { success: true, output: stdout || 'No commits yet' };
+  }
+
+  private async diff(cwd: string, args: string): Promise<ToolResult> {
+    const { stdout } = await execAsync(`git diff ${args}`, { cwd });
+    return { success: true, output: stdout || 'No changes' };
+  }
+
+  private async commit(cwd: string, message: string): Promise<ToolResult> {
+    if (!message) {
+      return { success: false, error: 'Commit message required' };
+    }
+    
+    // Stage all changes
+    await execAsync('git add -A', { cwd });
+    
+    const { stdout } = await execAsync(`git commit -m "${message}"`, { cwd });
+    return { success: true, output: stdout || 'Committed successfully' };
+  }
+
+  private async branch(cwd: string): Promise<ToolResult> {
+    const { stdout } = await execAsync('git branch -a', { cwd });
+    return { success: true, output: stdout };
+  }
+
+  private async checkout(cwd: string, branch: string): Promise<ToolResult> {
+    if (!branch) {
+      return { success: false, error: 'Branch name required' };
+    }
+    
+    const { stdout } = await execAsync(`git checkout ${branch}`, { cwd });
+    return { success: true, output: stdout };
+  }
+
+  private async pull(cwd: string): Promise<ToolResult> {
+    const { stdout } = await execAsync('git pull', { cwd });
+    return { success: true, output: stdout };
+  }
+
+  private async push(cwd: string): Promise<ToolResult> {
+    const { stdout } = await execAsync('git push', { cwd });
+    return { success: true, output: stdout };
+  }
+
+  private async add(cwd: string, files: string): Promise<ToolResult> {
+    const { stdout } = await execAsync(`git add ${files}`, { cwd });
+    return { success: true, output: stdout || 'Added successfully' };
+  }
+}