gencode-ai 0.1.0

package/src/providers/types.ts

@@ -0,0 +1,181 @@
+/**
+ * Unified types for LLM providers
+ * Abstracts differences between OpenAI, Anthropic, and Gemini APIs
+ */
+
+// ============================================================================
+// Message Types
+// ============================================================================
+
+export type MessageRole = 'system' | 'user' | 'assistant';
+
+export interface TextContent {
+  type: 'text';
+  text: string;
+}
+
+export interface ToolUseContent {
+  type: 'tool_use';
+  id: string;
+  name: string;
+  input: Record<string, unknown>;
+}
+
+export interface ToolResultContent {
+  type: 'tool_result';
+  toolUseId: string;
+  content: string;
+  isError?: boolean;
+}
+
+export type MessageContent = TextContent | ToolUseContent | ToolResultContent;
+
+export interface Message {
+  role: MessageRole;
+  content: string | MessageContent[];
+}
+
+// ============================================================================
+// Tool Types
+// ============================================================================
+
+export interface JSONSchema {
+  type: string;
+  properties?: Record<string, JSONSchema>;
+  required?: string[];
+  description?: string;
+  items?: JSONSchema;
+  enum?: unknown[];
+  [key: string]: unknown;
+}
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters: JSONSchema;
+}
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  input: Record<string, unknown>;
+}
+
+export interface ToolResult {
+  toolUseId: string;
+  content: string;
+  isError?: boolean;
+}
+
+// ============================================================================
+// Completion Types
+// ============================================================================
+
+export interface CompletionOptions {
+  model: string;
+  messages: Message[];
+  tools?: ToolDefinition[];
+  systemPrompt?: string;
+  maxTokens?: number;
+  temperature?: number;
+  stream?: boolean;
+}
+
+export type StopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence';
+
+export interface CompletionResponse {
+  content: MessageContent[];
+  stopReason: StopReason;
+  usage?: {
+    inputTokens: number;
+    outputTokens: number;
+  };
+}
+
+// ============================================================================
+// Streaming Types
+// ============================================================================
+
+export interface StreamChunkText {
+  type: 'text';
+  text: string;
+}
+
+export interface StreamChunkToolStart {
+  type: 'tool_start';
+  id: string;
+  name: string;
+}
+
+export interface StreamChunkToolInput {
+  type: 'tool_input';
+  id: string;
+  input: string; // Partial JSON string
+}
+
+export interface StreamChunkDone {
+  type: 'done';
+  response: CompletionResponse;
+}
+
+export interface StreamChunkError {
+  type: 'error';
+  error: Error;
+}
+
+export type StreamChunk =
+  | StreamChunkText
+  | StreamChunkToolStart
+  | StreamChunkToolInput
+  | StreamChunkDone
+  | StreamChunkError;
+
+// ============================================================================
+// Provider Interface
+// ============================================================================
+
+export interface ModelInfo {
+  id: string;
+  name: string;
+  description?: string;
+}
+
+export interface LLMProvider {
+  readonly name: string;
+
+  /**
+   * Generate a completion (non-streaming)
+   */
+  complete(options: CompletionOptions): Promise<CompletionResponse>;
+
+  /**
+   * Generate a streaming completion
+   */
+  stream(options: CompletionOptions): AsyncGenerator<StreamChunk, void, unknown>;
+
+  /**
+   * List available models from the provider
+   */
+  listModels(): Promise<ModelInfo[]>;
+}
+
+// ============================================================================
+// Provider Configuration
+// ============================================================================
+
+export interface OpenAIConfig {
+  apiKey?: string;
+  baseURL?: string;
+  organization?: string;
+}
+
+export interface AnthropicConfig {
+  apiKey?: string;
+  baseURL?: string;
+}
+
+export interface GeminiConfig {
+  apiKey?: string;
+}
+
+export type ProviderConfig = OpenAIConfig | AnthropicConfig | GeminiConfig;

package/src/session/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Session Management
+ */
+
+export * from './types.js';
+export { SessionManager } from './manager.js';

package/src/session/manager.ts

@@ -0,0 +1,354 @@
+/**
+ * Session Manager - Handles session persistence and retrieval
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+import type { Message } from '../providers/types.js';
+import type {
+  Session,
+  SessionMetadata,
+  SessionListItem,
+  SessionConfig,
+} from './types.js';
+import { DEFAULT_SESSION_CONFIG } from './types.js';
+
+export class SessionManager {
+  private config: SessionConfig;
+  private storageDir: string;
+  private currentSession: Session | null = null;
+
+  constructor(config?: Partial<SessionConfig>) {
+    this.config = { ...DEFAULT_SESSION_CONFIG, ...config };
+    this.storageDir = this.config.storageDir.replace('~', os.homedir());
+  }
+
+  /**
+   * Initialize storage directory
+   */
+  async init(): Promise<void> {
+    await fs.mkdir(this.storageDir, { recursive: true });
+  }
+
+  /**
+   * Generate a new session ID
+   */
+  private generateId(): string {
+    const timestamp = Date.now().toString(36);
+    const random = crypto.randomBytes(4).toString('hex');
+    return `${timestamp}-${random}`;
+  }
+
+  /**
+   * Get session file path
+   */
+  private getSessionPath(id: string): string {
+    return path.join(this.storageDir, `${id}.json`);
+  }
+
+  /**
+   * Create a new session
+   */
+  async create(options: {
+    provider: string;
+    model: string;
+    cwd?: string;
+    title?: string;
+    parentId?: string;
+  }): Promise<Session> {
+    const id = this.generateId();
+    const now = new Date().toISOString();
+
+    const session: Session = {
+      metadata: {
+        id,
+        title: options.title ?? `Session ${new Date().toLocaleString()}`,
+        createdAt: now,
+        updatedAt: now,
+        provider: options.provider,
+        model: options.model,
+        cwd: options.cwd ?? process.cwd(),
+        messageCount: 0,
+        parentId: options.parentId,
+      },
+      messages: [],
+    };
+
+    this.currentSession = session;
+
+    if (this.config.autoSave) {
+      await this.save(session);
+    }
+
+    return session;
+  }
+
+  /**
+   * Fork an existing session
+   */
+  async fork(sessionId: string, title?: string): Promise<Session> {
+    const parent = await this.load(sessionId);
+    if (!parent) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    const id = this.generateId();
+    const now = new Date().toISOString();
+
+    const forked: Session = {
+      metadata: {
+        ...parent.metadata,
+        id,
+        title: title ?? `Fork of ${parent.metadata.title}`,
+        createdAt: now,
+        updatedAt: now,
+        parentId: sessionId,
+      },
+      messages: [...parent.messages],
+      systemPrompt: parent.systemPrompt,
+    };
+
+    this.currentSession = forked;
+
+    if (this.config.autoSave) {
+      await this.save(forked);
+    }
+
+    return forked;
+  }
+
+  /**
+   * Save a session to disk
+   */
+  async save(session: Session): Promise<void> {
+    await this.init();
+    session.metadata.updatedAt = new Date().toISOString();
+    session.metadata.messageCount = session.messages.length;
+
+    const filePath = this.getSessionPath(session.metadata.id);
+    await fs.writeFile(filePath, JSON.stringify(session, null, 2), 'utf-8');
+  }
+
+  /**
+   * Load a session from disk
+   */
+  async load(id: string): Promise<Session | null> {
+    try {
+      const filePath = this.getSessionPath(id);
+      const content = await fs.readFile(filePath, 'utf-8');
+      const session = JSON.parse(content) as Session;
+      this.currentSession = session;
+      return session;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Resume the most recent session
+   */
+  async resumeLatest(): Promise<Session | null> {
+    const sessions = await this.list();
+    if (sessions.length === 0) {
+      return null;
+    }
+    return this.load(sessions[0].id);
+  }
+
+  /**
+   * Resume by index (1-based, most recent first)
+   */
+  async resumeByIndex(index: number): Promise<Session | null> {
+    const sessions = await this.list();
+    if (index < 1 || index > sessions.length) {
+      return null;
+    }
+    return this.load(sessions[index - 1].id);
+  }
+
+  /**
+   * List sessions, optionally filtered by project directory
+   */
+  async list(options?: { cwd?: string; all?: boolean }): Promise<SessionListItem[]> {
+    await this.init();
+    const filterCwd = options?.all ? undefined : (options?.cwd ?? process.cwd());
+
+    try {
+      const files = await fs.readdir(this.storageDir);
+      const sessions: SessionListItem[] = [];
+
+      for (const file of files) {
+        if (!file.endsWith('.json')) continue;
+
+        try {
+          const filePath = path.join(this.storageDir, file);
+          const content = await fs.readFile(filePath, 'utf-8');
+          const session = JSON.parse(content) as Session;
+
+          // Filter by cwd if specified
+          if (filterCwd && session.metadata.cwd !== filterCwd) {
+            continue;
+          }
+
+          // Get first user message as preview
+          const firstUserMsg = session.messages.find((m) => m.role === 'user');
+          let preview = '';
+          if (firstUserMsg) {
+            const text =
+              typeof firstUserMsg.content === 'string'
+                ? firstUserMsg.content
+                : firstUserMsg.content
+                    .filter((c) => c.type === 'text')
+                    .map((c) => (c as { text: string }).text)
+                    .join(' ');
+            preview = text.slice(0, 80) + (text.length > 80 ? '...' : '');
+          }
+
+          sessions.push({
+            id: session.metadata.id,
+            title: session.metadata.title,
+            updatedAt: session.metadata.updatedAt,
+            messageCount: session.metadata.messageCount,
+            preview,
+          });
+        } catch {
+          // Skip invalid files
+        }
+      }
+
+      // Sort by updated time, newest first
+      sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+
+      return sessions;
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Delete a session
+   */
+  async delete(id: string): Promise<boolean> {
+    try {
+      const filePath = this.getSessionPath(id);
+      await fs.unlink(filePath);
+
+      if (this.currentSession?.metadata.id === id) {
+        this.currentSession = null;
+      }
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Clear old sessions based on config
+   */
+  async cleanup(): Promise<number> {
+    const sessions = await this.list();
+    let deleted = 0;
+
+    const now = Date.now();
+    const maxAge = this.config.maxAge * 24 * 60 * 60 * 1000;
+
+    for (let i = 0; i < sessions.length; i++) {
+      const session = sessions[i];
+      const age = now - new Date(session.updatedAt).getTime();
+
+      // Delete if too old or exceeds max count
+      if (age > maxAge || i >= this.config.maxSessions) {
+        if (await this.delete(session.id)) {
+          deleted++;
+        }
+      }
+    }
+
+    return deleted;
+  }
+
+  /**
+   * Get current session
+   */
+  getCurrent(): Session | null {
+    return this.currentSession;
+  }
+
+  /**
+   * Set current session
+   */
+  setCurrent(session: Session): void {
+    this.currentSession = session;
+  }
+
+  /**
+   * Add message to current session
+   */
+  async addMessage(message: Message): Promise<void> {
+    if (!this.currentSession) {
+      throw new Error('No active session');
+    }
+
+    this.currentSession.messages.push(message);
+
+    if (this.config.autoSave) {
+      await this.save(this.currentSession);
+    }
+  }
+
+  /**
+   * Update session title
+   */
+  async updateTitle(id: string, title: string): Promise<void> {
+    const session = await this.load(id);
+    if (session) {
+      session.metadata.title = title;
+      await this.save(session);
+    }
+  }
+
+  /**
+   * Get messages from current session
+   */
+  getMessages(): Message[] {
+    return this.currentSession?.messages ?? [];
+  }
+
+  /**
+   * Clear current session messages
+   */
+  clearMessages(): void {
+    if (this.currentSession) {
+      this.currentSession.messages = [];
+    }
+  }
+
+  /**
+   * Export session to JSON
+   */
+  async export(id: string): Promise<string> {
+    const session = await this.load(id);
+    if (!session) {
+      throw new Error(`Session not found: ${id}`);
+    }
+    return JSON.stringify(session, null, 2);
+  }
+
+  /**
+   * Import session from JSON
+   */
+  async import(json: string): Promise<Session> {
+    const session = JSON.parse(json) as Session;
+
+    // Generate new ID to avoid conflicts
+    session.metadata.id = this.generateId();
+    session.metadata.createdAt = new Date().toISOString();
+    session.metadata.updatedAt = new Date().toISOString();
+
+    await this.save(session);
+    return session;
+  }
+}

package/src/session/types.ts

@@ -0,0 +1,49 @@
+/**
+ * Session Management Types
+ */
+
+import type { Message } from '../providers/types.js';
+
+export interface SessionMetadata {
+  id: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+  provider: string;
+  model: string;
+  cwd: string;
+  messageCount: number;
+  tokenUsage?: {
+    input: number;
+    output: number;
+  };
+  parentId?: string; // For forked sessions
+}
+
+export interface Session {
+  metadata: SessionMetadata;
+  messages: Message[];
+  systemPrompt?: string;
+}
+
+export interface SessionListItem {
+  id: string;
+  title: string;
+  updatedAt: string;
+  messageCount: number;
+  preview: string; // First user message preview
+}
+
+export interface SessionConfig {
+  storageDir: string;
+  maxSessions: number;
+  maxAge: number; // Days
+  autoSave: boolean;
+}
+
+export const DEFAULT_SESSION_CONFIG: SessionConfig = {
+  storageDir: '~/.gencode/sessions',
+  maxSessions: 50,
+  maxAge: 30,
+  autoSave: true,
+};

package/src/tools/builtin/bash.ts

@@ -0,0 +1,92 @@
+/**
+ * Bash Tool - Execute shell commands
+ */
+
+import { spawn } from 'child_process';
+import type { Tool, ToolContext, ToolResult } from '../types.js';
+import { BashInputSchema, type BashInput } from '../types.js';
+
+export const bashTool: Tool<BashInput> = {
+  name: 'Bash',
+  description: 'Execute a bash command and return its output. Use for running scripts, git commands, npm, etc.',
+  parameters: BashInputSchema,
+
+  async execute(input: BashInput, context: ToolContext): Promise<ToolResult> {
+    const timeout = input.timeout ?? 30000;
+
+    return new Promise((resolve) => {
+      const proc = spawn('bash', ['-c', input.command], {
+        cwd: context.cwd,
+        env: process.env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      proc.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      // Handle timeout
+      const timer = setTimeout(() => {
+        proc.kill('SIGTERM');
+        resolve({
+          success: false,
+          output: stdout,
+          error: `Command timed out after ${timeout}ms`,
+        });
+      }, timeout);
+
+      // Handle abort signal
+      if (context.abortSignal) {
+        context.abortSignal.addEventListener('abort', () => {
+          proc.kill('SIGTERM');
+          clearTimeout(timer);
+          resolve({
+            success: false,
+            output: stdout,
+            error: 'Command aborted',
+          });
+        });
+      }
+
+      proc.on('close', (code) => {
+        clearTimeout(timer);
+
+        // Truncate output if too long
+        const maxLength = 30000;
+        let output = stdout;
+        if (output.length > maxLength) {
+          output = output.slice(0, maxLength) + '\n... (output truncated)';
+        }
+
+        if (code === 0) {
+          resolve({
+            success: true,
+            output: output || '(no output)',
+          });
+        } else {
+          resolve({
+            success: false,
+            output,
+            error: stderr || `Command exited with code ${code}`,
+          });
+        }
+      });
+
+      proc.on('error', (error) => {
+        clearTimeout(timer);
+        resolve({
+          success: false,
+          output: '',
+          error: `Failed to execute command: ${error.message}`,
+        });
+      });
+    });
+  },
+};

package/src/tools/builtin/edit.ts

@@ -0,0 +1,37 @@
+/**
+ * Edit Tool - Edit file contents with string replacement
+ */
+
+import * as fs from 'fs/promises';
+import type { Tool, ToolResult } from '../types.js';
+import { EditInputSchema, type EditInput, resolvePath, getErrorMessage } from '../types.js';
+
+export const editTool: Tool<EditInput> = {
+  name: 'Edit',
+  description: 'Edit a file by replacing a specific string with another. The old_string must be unique in the file.',
+  parameters: EditInputSchema,
+
+  async execute(input, context): Promise<ToolResult> {
+    try {
+      const filePath = resolvePath(input.file_path, context.cwd);
+      const content = await fs.readFile(filePath, 'utf-8');
+      const occurrences = content.split(input.old_string).length - 1;
+
+      if (occurrences === 0) {
+        return { success: false, output: '', error: 'The string to replace was not found in the file.' };
+      }
+      if (occurrences > 1) {
+        return { success: false, output: '', error: `The string to replace occurs ${occurrences} times. Please provide a more unique string.` };
+      }
+
+      const newContent = content.replace(input.old_string, input.new_string);
+      await fs.writeFile(filePath, newContent, 'utf-8');
+
+      const oldLines = input.old_string.split('\n').length;
+      const newLines = input.new_string.split('\n').length;
+      return { success: true, output: `Successfully edited ${filePath}: replaced ${oldLines} line(s) with ${newLines} line(s)` };
+    } catch (error) {
+      return { success: false, output: '', error: `Failed to edit file: ${getErrorMessage(error)}` };
+    }
+  },
+};