gencode-ai 0.1.0

package/src/config/manager.ts

@@ -0,0 +1,77 @@
+/**
+ * Settings Manager - Persists user settings (Claude Code style)
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import type { Settings, SettingsManagerOptions } from './types.js';
+import { DEFAULT_SETTINGS_DIR, SETTINGS_FILE_NAME } from './types.js';
+
+export class SettingsManager {
+  private settingsDir: string;
+  private settingsPath: string;
+  private settings: Settings = {};
+
+  constructor(options: SettingsManagerOptions = {}) {
+    const dir = options.settingsDir ?? DEFAULT_SETTINGS_DIR;
+    this.settingsDir = dir.replace('~', os.homedir());
+    this.settingsPath = path.join(this.settingsDir, SETTINGS_FILE_NAME);
+  }
+
+  /**
+   * Ensure settings directory exists
+   */
+  private async ensureDir(): Promise<void> {
+    try {
+      await fs.mkdir(this.settingsDir, { recursive: true });
+    } catch {
+      // Directory may already exist
+    }
+  }
+
+  /**
+   * Load settings from disk
+   */
+  async load(): Promise<Settings> {
+    try {
+      const content = await fs.readFile(this.settingsPath, 'utf-8');
+      this.settings = JSON.parse(content);
+      return this.settings;
+    } catch {
+      // File doesn't exist or is invalid
+      this.settings = {};
+      return this.settings;
+    }
+  }
+
+  /**
+   * Save settings to disk (merges with existing)
+   */
+  async save(updates: Partial<Settings>): Promise<void> {
+    await this.ensureDir();
+
+    // Merge updates with existing settings
+    this.settings = { ...this.settings, ...updates };
+
+    await fs.writeFile(
+      this.settingsPath,
+      JSON.stringify(this.settings, null, 2),
+      'utf-8'
+    );
+  }
+
+  /**
+   * Get current settings
+   */
+  get(): Settings {
+    return { ...this.settings };
+  }
+
+  /**
+   * Get settings file path
+   */
+  getPath(): string {
+    return this.settingsPath;
+  }
+}

package/src/config/types.ts

@@ -0,0 +1,25 @@
+/**
+ * Settings Types - User settings persistence (Claude Code style)
+ */
+
+export type ProviderName = 'openai' | 'anthropic' | 'gemini';
+
+/**
+ * Settings file structure (~/.gencode/settings.json)
+ * Similar to Claude Code's settings.json
+ */
+export interface Settings {
+  model?: string;
+  provider?: ProviderName;
+  permissions?: {
+    allow?: string[];
+    deny?: string[];
+  };
+}
+
+export interface SettingsManagerOptions {
+  settingsDir?: string;
+}
+
+export const DEFAULT_SETTINGS_DIR = '~/.gencode';
+export const SETTINGS_FILE_NAME = 'settings.json';

package/src/index.ts

@@ -0,0 +1,86 @@
+/**
+ * Recode - Multi-LLM Agent SDK
+ *
+ * A unified SDK for building AI agents with support for
+ * OpenAI, Anthropic, and Google Gemini models.
+ */
+
+// Providers
+export {
+  // Types
+  type LLMProvider,
+  type Message,
+  type MessageRole,
+  type MessageContent,
+  type TextContent,
+  type ToolUseContent,
+  type ToolResultContent,
+  type ToolDefinition,
+  type ToolCall,
+  type ToolResult,
+  type CompletionOptions,
+  type CompletionResponse,
+  type StreamChunk,
+  type StopReason,
+  type OpenAIConfig,
+  type AnthropicConfig,
+  type GeminiConfig,
+  type ProviderConfig,
+  type ProviderName,
+  // Providers
+  OpenAIProvider,
+  AnthropicProvider,
+  GeminiProvider,
+  // Factory
+  createProvider,
+  inferProvider,
+  ModelAliases,
+} from './providers/index.js';
+
+// Tools
+export {
+  type Tool,
+  type ToolContext,
+  type ToolResult as ToolExecutionResult,
+  ToolRegistry,
+  createDefaultRegistry,
+  builtinTools,
+  readTool,
+  writeTool,
+  editTool,
+  bashTool,
+  globTool,
+  grepTool,
+} from './tools/index.js';
+
+// Permissions
+export {
+  type PermissionMode,
+  type PermissionRule,
+  type PermissionConfig,
+  type ConfirmCallback,
+  PermissionManager,
+  DEFAULT_PERMISSION_CONFIG,
+} from './permissions/index.js';
+
+// Agent
+export {
+  type AgentConfig,
+  type AgentEvent,
+  type AgentEventText,
+  type AgentEventToolStart,
+  type AgentEventToolResult,
+  type AgentEventError,
+  type AgentEventDone,
+  Agent,
+} from './agent/index.js';
+
+// Session
+export {
+  type Session,
+  type SessionMetadata,
+  type SessionListItem,
+  type SessionConfig,
+  SessionManager,
+  DEFAULT_SESSION_CONFIG,
+} from './session/index.js';

package/src/permissions/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Permission System
+ */
+
+export * from './types.js';
+export { PermissionManager } from './manager.js';
+export type { ConfirmCallback } from './manager.js';

package/src/permissions/manager.ts

@@ -0,0 +1,97 @@
+/**
+ * Permission Manager - Controls tool execution permissions
+ */
+
+import type { PermissionConfig, PermissionMode } from './types.js';
+import { DEFAULT_PERMISSION_CONFIG } from './types.js';
+
+export type ConfirmCallback = (
+  tool: string,
+  input: unknown
+) => Promise<boolean>;
+
+export class PermissionManager {
+  private config: PermissionConfig;
+  private confirmCallback?: ConfirmCallback;
+  private approvedTools: Set<string> = new Set();
+
+  constructor(config?: Partial<PermissionConfig>) {
+    this.config = {
+      ...DEFAULT_PERMISSION_CONFIG,
+      ...config,
+    };
+  }
+
+  /**
+   * Set the confirmation callback
+   */
+  setConfirmCallback(callback: ConfirmCallback): void {
+    this.confirmCallback = callback;
+  }
+
+  /**
+   * Get the permission mode for a tool
+   */
+  getModeForTool(tool: string): PermissionMode {
+    for (const rule of this.config.rules) {
+      if (typeof rule.tool === 'string') {
+        if (rule.tool === tool) {
+          return rule.mode;
+        }
+      } else if (rule.tool.test(tool)) {
+        return rule.mode;
+      }
+    }
+    return this.config.defaultMode;
+  }
+
+  /**
+   * Check if a tool can be executed
+   */
+  async checkPermission(tool: string, input: unknown): Promise<boolean> {
+    const mode = this.getModeForTool(tool);
+
+    switch (mode) {
+      case 'auto':
+        return true;
+
+      case 'deny':
+        return false;
+
+      case 'confirm':
+        // Check if already approved this session
+        const key = `${tool}:${JSON.stringify(input)}`;
+        if (this.approvedTools.has(key)) {
+          return true;
+        }
+
+        if (!this.confirmCallback) {
+          // No callback, auto-approve in non-interactive mode
+          return true;
+        }
+
+        const approved = await this.confirmCallback(tool, input);
+        if (approved) {
+          this.approvedTools.add(key);
+        }
+        return approved;
+
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Approve a tool for this session
+   */
+  approveToolForSession(tool: string): void {
+    this.approvedTools.add(tool);
+  }
+
+  /**
+   * Clear all session approvals
+   */
+  clearApprovals(): void {
+    this.approvedTools.clear();
+  }
+}

package/src/permissions/types.ts

@@ -0,0 +1,29 @@
+/**
+ * Permission System Types
+ */
+
+export type PermissionMode = 'auto' | 'confirm' | 'deny';
+
+export interface PermissionRule {
+  tool: string | RegExp;
+  mode: PermissionMode;
+}
+
+export interface PermissionConfig {
+  defaultMode: PermissionMode;
+  rules: PermissionRule[];
+}
+
+export const DEFAULT_PERMISSION_CONFIG: PermissionConfig = {
+  defaultMode: 'confirm',
+  rules: [
+    // Read-only tools are auto-approved
+    { tool: 'Read', mode: 'auto' },
+    { tool: 'Glob', mode: 'auto' },
+    { tool: 'Grep', mode: 'auto' },
+    // Write operations require confirmation
+    { tool: 'Write', mode: 'confirm' },
+    { tool: 'Edit', mode: 'confirm' },
+    { tool: 'Bash', mode: 'confirm' },
+  ],
+};

package/src/providers/anthropic.ts

@@ -0,0 +1,224 @@
+/**
+ * Anthropic Provider Implementation
+ * Supports Claude 3.5 Sonnet, Claude 3 Opus, Claude 3 Haiku, etc.
+ */
+
+import Anthropic from '@anthropic-ai/sdk';
+import type {
+  LLMProvider,
+  CompletionOptions,
+  CompletionResponse,
+  StreamChunk,
+  Message,
+  MessageContent,
+  ToolDefinition,
+  StopReason,
+  AnthropicConfig,
+  ModelInfo,
+} from './types.js';
+
+type AnthropicMessage = Anthropic.MessageParam;
+type AnthropicTool = Anthropic.Tool;
+type AnthropicContent = Anthropic.ContentBlockParam;
+
+export class AnthropicProvider implements LLMProvider {
+  readonly name = 'anthropic';
+  private client: Anthropic;
+
+  constructor(config: AnthropicConfig = {}) {
+    this.client = new Anthropic({
+      apiKey: config.apiKey ?? process.env.ANTHROPIC_API_KEY,
+      baseURL: config.baseURL,
+    });
+  }
+
+  async complete(options: CompletionOptions): Promise<CompletionResponse> {
+    const messages = this.convertMessages(options.messages);
+    const tools = options.tools ? this.convertTools(options.tools) : undefined;
+
+    const response = await this.client.messages.create({
+      model: options.model,
+      messages,
+      tools,
+      system: options.systemPrompt,
+      max_tokens: options.maxTokens ?? 4096,
+      temperature: options.temperature,
+    });
+
+    return this.convertResponse(response);
+  }
+
+  async *stream(options: CompletionOptions): AsyncGenerator<StreamChunk, void, unknown> {
+    const messages = this.convertMessages(options.messages);
+    const tools = options.tools ? this.convertTools(options.tools) : undefined;
+
+    const stream = this.client.messages.stream({
+      model: options.model,
+      messages,
+      tools,
+      system: options.systemPrompt,
+      max_tokens: options.maxTokens ?? 4096,
+      temperature: options.temperature,
+    });
+
+    const toolInputBuffers: Map<number, { id: string; name: string; input: string }> = new Map();
+
+    for await (const event of stream) {
+      if (event.type === 'content_block_start') {
+        const block = event.content_block;
+
+        if (block.type === 'tool_use') {
+          toolInputBuffers.set(event.index, {
+            id: block.id,
+            name: block.name,
+            input: '',
+          });
+          yield { type: 'tool_start', id: block.id, name: block.name };
+        }
+      } else if (event.type === 'content_block_delta') {
+        const delta = event.delta;
+
+        if (delta.type === 'text_delta') {
+          yield { type: 'text', text: delta.text };
+        } else if (delta.type === 'input_json_delta') {
+          const buffer = toolInputBuffers.get(event.index);
+          if (buffer) {
+            buffer.input += delta.partial_json;
+            yield { type: 'tool_input', id: buffer.id, input: delta.partial_json };
+          }
+        }
+      }
+    }
+
+    // Get final message
+    const finalMessage = await stream.finalMessage();
+    const content = this.convertContent(finalMessage.content);
+
+    yield {
+      type: 'done',
+      response: {
+        content,
+        stopReason: this.convertStopReason(finalMessage.stop_reason),
+        usage: {
+          inputTokens: finalMessage.usage.input_tokens,
+          outputTokens: finalMessage.usage.output_tokens,
+        },
+      },
+    };
+  }
+
+  private convertMessages(messages: Message[]): AnthropicMessage[] {
+    const result: AnthropicMessage[] = [];
+
+    for (const msg of messages) {
+      // Skip system messages - handled separately
+      if (msg.role === 'system') {
+        continue;
+      }
+
+      if (msg.role === 'user') {
+        const content = this.convertToAnthropicContent(msg.content, 'user');
+        result.push({ role: 'user', content });
+      } else if (msg.role === 'assistant') {
+        const content = this.convertToAnthropicContent(msg.content, 'assistant');
+        result.push({ role: 'assistant', content });
+      }
+    }
+
+    return result;
+  }
+
+  private convertToAnthropicContent(
+    content: string | MessageContent[],
+    role: 'user' | 'assistant'
+  ): AnthropicContent[] | string {
+    if (typeof content === 'string') {
+      return content;
+    }
+
+    const result: AnthropicContent[] = [];
+
+    for (const item of content) {
+      if (item.type === 'text') {
+        result.push({ type: 'text', text: item.text });
+      } else if (item.type === 'tool_use' && role === 'assistant') {
+        result.push({
+          type: 'tool_use',
+          id: item.id,
+          name: item.name,
+          input: item.input,
+        });
+      } else if (item.type === 'tool_result' && role === 'user') {
+        result.push({
+          type: 'tool_result',
+          tool_use_id: item.toolUseId,
+          content: item.content,
+          is_error: item.isError,
+        });
+      }
+    }
+
+    return result.length > 0 ? result : '';
+  }
+
+  private convertTools(tools: ToolDefinition[]): AnthropicTool[] {
+    return tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.parameters as Anthropic.Tool.InputSchema,
+    }));
+  }
+
+  private convertResponse(response: Anthropic.Message): CompletionResponse {
+    return {
+      content: this.convertContent(response.content),
+      stopReason: this.convertStopReason(response.stop_reason),
+      usage: {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+      },
+    };
+  }
+
+  private convertContent(content: Anthropic.ContentBlock[]): MessageContent[] {
+    return content.map((block) => {
+      if (block.type === 'text') {
+        return { type: 'text' as const, text: block.text };
+      } else if (block.type === 'tool_use') {
+        return {
+          type: 'tool_use' as const,
+          id: block.id,
+          name: block.name,
+          input: block.input as Record<string, unknown>,
+        };
+      }
+      // Fallback for unknown types
+      return { type: 'text' as const, text: '' };
+    });
+  }
+
+  private convertStopReason(reason: Anthropic.Message['stop_reason']): StopReason {
+    switch (reason) {
+      case 'tool_use':
+        return 'tool_use';
+      case 'max_tokens':
+        return 'max_tokens';
+      case 'stop_sequence':
+        return 'stop_sequence';
+      case 'end_turn':
+      default:
+        return 'end_turn';
+    }
+  }
+
+  async listModels(): Promise<ModelInfo[]> {
+    const models: ModelInfo[] = [];
+    for await (const model of this.client.models.list()) {
+      models.push({
+        id: model.id,
+        name: model.display_name || model.id,
+      });
+    }
+    return models;
+  }
+}