gencode-ai 0.1.0

package/docs/proposals/0040-multi-provider-enhancements.md

@@ -0,0 +1,369 @@
+# Proposal: Multi-Provider Enhancements
+
+- **Proposal ID**: 0040
+- **Author**: mycode team
+- **Status**: Draft
+- **Created**: 2025-01-15
+- **Updated**: 2025-01-15
+
+## Summary
+
+Enhance the multi-provider system with unified tool calling, provider fallbacks, automatic model selection, and cross-provider consistency for seamless switching between LLM providers.
+
+## Motivation
+
+Current multi-provider support is basic:
+
+1. **Inconsistent tool calling**: Different formats per provider
+2. **No fallbacks**: Single point of failure
+3. **Manual selection**: User must choose provider
+4. **Feature gaps**: Not all features on all providers
+5. **No cost optimization**: Can't auto-select cheapest
+
+Enhanced multi-provider enables robust, flexible LLM usage.
+
+## Detailed Design
+
+### API Design
+
+```typescript
+// src/providers/types.ts
+interface ProviderConfig {
+  name: string;
+  enabled: boolean;
+  priority: number;           // Lower = higher priority
+  models: ModelConfig[];
+  rateLimits?: RateLimitConfig;
+  fallbackTo?: string;        // Fallback provider
+}
+
+interface ModelConfig {
+  id: string;
+  aliases: string[];
+  capabilities: ModelCapability[];
+  contextWindow: number;
+  maxOutputTokens: number;
+  inputPricePer1M: number;
+  outputPricePer1M: number;
+}
+
+type ModelCapability =
+  | 'text'
+  | 'vision'
+  | 'tools'
+  | 'streaming'
+  | 'thinking'
+  | 'json_mode';
+
+interface ProviderSelector {
+  strategy: 'priority' | 'round_robin' | 'cost_optimized' | 'latency_optimized';
+  requirements?: {
+    capabilities?: ModelCapability[];
+    minContextWindow?: number;
+    maxCostPer1K?: number;
+  };
+}
+
+interface ProviderResult<T> {
+  provider: string;
+  model: string;
+  result: T;
+  usage?: TokenUsage;
+  latency: number;
+  fallbackUsed: boolean;
+}
+```
+
+### Unified Provider Manager
+
+```typescript
+// src/providers/manager.ts
+class ProviderManager {
+  private providers: Map<string, LLMProvider> = new Map();
+  private configs: Map<string, ProviderConfig> = new Map();
+  private healthStatus: Map<string, ProviderHealth> = new Map();
+
+  constructor() {
+    this.loadProviders();
+    this.startHealthChecks();
+  }
+
+  async complete(
+    request: CompletionRequest,
+    selector?: ProviderSelector
+  ): Promise<ProviderResult<CompletionResponse>> {
+    const provider = await this.selectProvider(request, selector);
+
+    const start = Date.now();
+    let fallbackUsed = false;
+
+    try {
+      const result = await provider.complete(request);
+      return {
+        provider: provider.name,
+        model: request.model,
+        result,
+        usage: result.usage,
+        latency: Date.now() - start,
+        fallbackUsed
+      };
+    } catch (error) {
+      // Try fallback
+      const fallback = await this.getFallback(provider.name, request);
+      if (fallback) {
+        fallbackUsed = true;
+        const result = await fallback.complete(request);
+        return {
+          provider: fallback.name,
+          model: request.model,
+          result,
+          usage: result.usage,
+          latency: Date.now() - start,
+          fallbackUsed
+        };
+      }
+      throw error;
+    }
+  }
+
+  private async selectProvider(
+    request: CompletionRequest,
+    selector?: ProviderSelector
+  ): Promise<LLMProvider> {
+    const strategy = selector?.strategy || 'priority';
+    const requirements = selector?.requirements || {};
+
+    // Get eligible providers
+    const eligible = Array.from(this.providers.entries())
+      .filter(([name, provider]) => {
+        const config = this.configs.get(name);
+        if (!config?.enabled) return false;
+
+        // Check health
+        const health = this.healthStatus.get(name);
+        if (health?.status === 'unhealthy') return false;
+
+        // Check capabilities
+        if (requirements.capabilities) {
+          const model = this.findModel(config, request.model);
+          if (!model) return false;
+          const hasAll = requirements.capabilities.every(c =>
+            model.capabilities.includes(c)
+          );
+          if (!hasAll) return false;
+        }
+
+        return true;
+      });
+
+    if (eligible.length === 0) {
+      throw new Error('No eligible providers available');
+    }
+
+    // Select based on strategy
+    switch (strategy) {
+      case 'priority':
+        eligible.sort((a, b) => {
+          const priorityA = this.configs.get(a[0])?.priority || 999;
+          const priorityB = this.configs.get(b[0])?.priority || 999;
+          return priorityA - priorityB;
+        });
+        return eligible[0][1];
+
+      case 'cost_optimized':
+        return this.selectCheapest(eligible, request);
+
+      case 'latency_optimized':
+        return this.selectFastest(eligible);
+
+      case 'round_robin':
+        return this.selectRoundRobin(eligible);
+
+      default:
+        return eligible[0][1];
+    }
+  }
+
+  private selectCheapest(
+    providers: [string, LLMProvider][],
+    request: CompletionRequest
+  ): LLMProvider {
+    const estimatedTokens = this.estimateTokens(request);
+
+    let cheapest: LLMProvider | null = null;
+    let lowestCost = Infinity;
+
+    for (const [name, provider] of providers) {
+      const config = this.configs.get(name);
+      const model = this.findModel(config!, request.model);
+      if (!model) continue;
+
+      const cost = (estimatedTokens.input * model.inputPricePer1M / 1_000_000) +
+                   (estimatedTokens.output * model.outputPricePer1M / 1_000_000);
+
+      if (cost < lowestCost) {
+        lowestCost = cost;
+        cheapest = provider;
+      }
+    }
+
+    return cheapest || providers[0][1];
+  }
+
+  // Tool calling normalization
+  normalizeToolCall(call: ProviderToolCall): UnifiedToolCall {
+    // Convert provider-specific format to unified format
+    return {
+      id: call.id || generateId(),
+      name: call.name || call.function?.name,
+      input: call.input || JSON.parse(call.function?.arguments || '{}')
+    };
+  }
+
+  normalizeToolResult(result: ToolResult, provider: string): ProviderToolResult {
+    // Convert unified result to provider-specific format
+    switch (provider) {
+      case 'anthropic':
+        return {
+          type: 'tool_result',
+          tool_use_id: result.id,
+          content: result.success ? result.output : `Error: ${result.error}`
+        };
+
+      case 'openai':
+        return {
+          role: 'tool',
+          tool_call_id: result.id,
+          content: result.success ? result.output : `Error: ${result.error}`
+        };
+
+      case 'gemini':
+        return {
+          functionResponse: {
+            name: result.name,
+            response: { result: result.success ? result.output : result.error }
+          }
+        };
+
+      default:
+        throw new Error(`Unknown provider: ${provider}`);
+    }
+  }
+
+  // Health monitoring
+  private startHealthChecks(): void {
+    setInterval(async () => {
+      for (const [name, provider] of this.providers) {
+        try {
+          const start = Date.now();
+          await provider.complete({
+            messages: [{ role: 'user', content: 'ping' }],
+            maxTokens: 5
+          });
+          this.healthStatus.set(name, {
+            status: 'healthy',
+            latency: Date.now() - start,
+            lastCheck: new Date()
+          });
+        } catch (error) {
+          const current = this.healthStatus.get(name);
+          this.healthStatus.set(name, {
+            status: current?.status === 'degraded' ? 'unhealthy' : 'degraded',
+            error: error instanceof Error ? error.message : 'Unknown error',
+            lastCheck: new Date()
+          });
+        }
+      }
+    }, 60000);  // Check every minute
+  }
+}
+
+export const providerManager = new ProviderManager();
+```
+
+### File Changes
+
+| File | Action | Description |
+|------|--------|-------------|
+| `src/providers/types.ts` | Modify | Enhanced types |
+| `src/providers/manager.ts` | Create | Provider management |
+| `src/providers/selector.ts` | Create | Selection strategies |
+| `src/providers/normalizer.ts` | Create | Format normalization |
+| `src/providers/health.ts` | Create | Health monitoring |
+
+## User Experience
+
+### Provider Status
+```
+User: /providers
+
+Provider Status:
+┌────────────────────────────────────────────────────────────┐
+│ Provider   Status    Latency   Models            Priority │
+├────────────────────────────────────────────────────────────┤
+│ anthropic  ● Healthy  120ms    claude-*               1   │
+│ openai     ● Healthy  95ms     gpt-4*, o1             2   │
+│ gemini     ○ Degraded 450ms    gemini-*               3   │
+└────────────────────────────────────────────────────────────┘
+
+Active: anthropic (claude-sonnet-4)
+Fallback: openai (gpt-4o)
+```
+
+### Automatic Fallback
+```
+Agent: Attempting to connect to anthropic...
+⚠️ anthropic unavailable, falling back to openai
+
+Using: openai/gpt-4o
+```
+
+### Cost-Optimized Selection
+```
+User: /settings provider strategy cost_optimized
+
+Provider strategy set to: Cost Optimized
+
+For your typical usage:
+• Small queries → gemini-2.0-flash ($0.0001/1K)
+• Complex tasks → claude-sonnet ($0.003/1K)
+• Vision tasks → gpt-4o ($0.005/1K)
+```
+
+### Model Comparison
+```
+User: /compare-models "Explain async/await"
+
+Model Comparison:
+┌────────────────────────────────────────────────────────────┐
+│ Model                  Tokens   Cost     Latency  Quality │
+├────────────────────────────────────────────────────────────┤
+│ claude-opus-4-5       1,234    $0.093   2.3s     ★★★★★   │
+│ claude-sonnet-4         892    $0.027   1.1s     ★★★★☆   │
+│ gpt-4o                  756    $0.019   0.9s     ★★★★☆   │
+│ gemini-2.0-flash        645    $0.002   0.4s     ★★★☆☆   │
+└────────────────────────────────────────────────────────────┘
+```
+
+## Security Considerations
+
+1. API key isolation per provider
+2. Secure credential storage
+3. No cross-provider data leakage
+4. Rate limit enforcement
+5. Audit logging per provider
+
+## Migration Path
+
+1. **Phase 1**: Unified tool calling
+2. **Phase 2**: Provider fallbacks
+3. **Phase 3**: Selection strategies
+4. **Phase 4**: Health monitoring
+5. **Phase 5**: Cost optimization
+
+## References
+
+- [Anthropic API](https://docs.anthropic.com/claude/reference)
+- [OpenAI API](https://platform.openai.com/docs/api-reference)
+- [Google AI API](https://ai.google.dev/docs)
+- [LiteLLM](https://github.com/BerriAI/litellm) - Multi-provider abstraction

package/docs/proposals/README.md

@@ -0,0 +1,84 @@
+# mycode Enhancement Proposals
+
+This directory contains enhancement proposals for the mycode project. Each proposal describes a feature inspired by Claude Code that we plan to implement.
+
+## Proposal Process
+
+1. **Draft**: Initial proposal written and submitted
+2. **Under Review**: Community and maintainer review
+3. **Accepted**: Approved for implementation
+4. **Implemented**: Feature has been implemented
+5. **Rejected**: Proposal was rejected with explanation
+
+## Proposal Index
+
+### P1 Priority - Core Features
+
+| ID | Title | Status |
+|----|-------|--------|
+| [0001](./0001-web-fetch-tool.md) | WebFetch Tool | Draft |
+| [0002](./0002-web-search-tool.md) | WebSearch Tool | Draft |
+| [0003](./0003-task-subagents.md) | Task Tool & Subagents | Draft |
+| [0004](./0004-plan-mode.md) | Plan Mode | Draft |
+| [0005](./0005-todo-system.md) | Todo System | Draft |
+| [0006](./0006-memory-system.md) | Memory System (MYCODE.md) | Draft |
+| [0007](./0007-context-management.md) | Context Management | Draft |
+| [0008](./0008-checkpointing.md) | Checkpointing | Draft |
+| [0009](./0009-hooks-system.md) | Hooks System | Draft |
+| [0010](./0010-mcp-integration.md) | MCP Integration | Draft |
+| [0011](./0011-custom-commands.md) | Custom Commands | Draft |
+| [0012](./0012-ask-user-question.md) | AskUserQuestion Tool | Draft |
+
+### P2 Priority - Enhanced Features
+
+| ID | Title | Status |
+|----|-------|--------|
+| [0013](./0013-multi-edit-tool.md) | MultiEdit Tool | Draft |
+| [0014](./0014-lsp-tool.md) | LSP Tool | Draft |
+| [0015](./0015-ls-tool.md) | LS Tool | Draft |
+| [0016](./0016-kill-shell-tool.md) | KillShell Tool | Draft |
+| [0017](./0017-background-tasks.md) | Background Tasks | Draft |
+| [0018](./0018-parallel-tool-execution.md) | Parallel Tool Execution | Draft |
+| [0019](./0019-session-enhancements.md) | Session Enhancements | Draft |
+| [0020](./0020-session-summarization.md) | Session Summarization | Draft |
+| [0021](./0021-skills-system.md) | Skills System | Draft |
+| [0022](./0022-plugin-system.md) | Plugin System | Draft |
+| [0023](./0023-permission-enhancements.md) | Permission Enhancements | Draft |
+| [0024](./0024-keyboard-shortcuts.md) | Keyboard Shortcuts | Draft |
+| [0025](./0025-cost-tracking.md) | Cost Tracking | Draft |
+| [0026](./0026-git-integration.md) | Git Integration | Draft |
+| [0027](./0027-enhanced-read-tool.md) | Enhanced Read Tool | Draft |
+| [0028](./0028-enhanced-bash-tool.md) | Enhanced Bash Tool | Draft |
+
+### P3 Priority - Advanced Features
+
+| ID | Title | Status |
+|----|-------|--------|
+| [0029](./0029-notebook-edit-tool.md) | NotebookEdit Tool | Draft |
+| [0030](./0030-plugin-marketplace.md) | Plugin Marketplace | Draft |
+| [0031](./0031-command-suggestions.md) | Command Suggestions | Draft |
+| [0032](./0032-ide-integrations.md) | IDE Integrations | Draft |
+| [0033](./0033-enterprise-deployment.md) | Enterprise Deployment | Draft |
+| [0034](./0034-sandboxing.md) | Sandboxing | Draft |
+| [0035](./0035-auto-updater.md) | Auto-updater | Draft |
+| [0036](./0036-enhanced-glob-tool.md) | Enhanced Glob Tool | Draft |
+| [0037](./0037-enhanced-grep-tool.md) | Enhanced Grep Tool | Draft |
+| [0038](./0038-interactive-cli-ui.md) | Interactive CLI UI | Draft |
+| [0039](./0039-streaming-enhancements.md) | Streaming Enhancements | Draft |
+| [0040](./0040-multi-provider-enhancements.md) | Multi-Provider Enhancements | Draft |
+
+## Research
+
+Background research on Claude Code's implementation is documented in [research/](./research/):
+
+- [claude-code-research.md](./research/claude-code-research.md) - Comprehensive research on Claude Code's memory, context, and session systems
+
+## Writing a Proposal
+
+Use [TEMPLATE.md](./TEMPLATE.md) as a starting point for new proposals.
+
+## References
+
+- [Claude Code Official Docs](https://code.claude.com/docs/en/overview)
+- [Claude Code GitHub](https://github.com/anthropics/claude-code)
+- [Claude Code Best Practices](https://www.anthropic.com/engineering/claude-code-best-practices)

package/docs/proposals/TEMPLATE.md

@@ -0,0 +1,57 @@
+# Proposal: [Feature Name]
+
+- **Proposal ID**: NNNN
+- **Author**: [Name]
+- **Status**: Draft | Under Review | Accepted | Implemented | Rejected
+- **Created**: YYYY-MM-DD
+- **Updated**: YYYY-MM-DD
+
+## Summary
+
+[One paragraph describing the feature]
+
+## Motivation
+
+[Why this feature is needed, what problems it solves]
+
+## Claude Code Reference
+
+[How this feature works in Claude Code, with examples]
+
+## Detailed Design
+
+### API Design
+
+[Interfaces, types, function signatures]
+
+### Implementation Approach
+
+[Technical implementation details]
+
+### File Changes
+
+[List of files to be created/modified]
+
+## User Experience
+
+[How users will interact with this feature]
+
+## Alternatives Considered
+
+[Other approaches that were considered]
+
+## Security Considerations
+
+[Security implications if any]
+
+## Testing Strategy
+
+[How to test this feature]
+
+## Migration Path
+
+[How to migrate from current state]
+
+## References
+
+[Links to Claude Code docs, related proposals, etc.]