@usejarvis/brain 0.1.0

package/src/integrations/google-auth.ts

@@ -0,0 +1,175 @@
+/**
+ * Google OAuth2 Authentication
+ *
+ * Manages OAuth2 tokens for Google APIs (Gmail, Calendar).
+ * Uses raw fetch() — no googleapis package needed.
+ * Tokens stored at ~/.jarvis/google-tokens.json
+ */
+
+import path from 'node:path';
+import os from 'node:os';
+import { readFileSync, existsSync } from 'node:fs';
+
+const TOKEN_ENDPOINT = 'https://oauth2.googleapis.com/token';
+const AUTH_ENDPOINT = 'https://accounts.google.com/o/oauth2/v2/auth';
+
+export type GoogleTokens = {
+  access_token: string;
+  refresh_token: string;
+  expiry_date: number;
+  token_type: string;
+};
+
+export class GoogleAuth {
+  private clientId: string;
+  private clientSecret: string;
+  private tokens: GoogleTokens | null = null;
+  private tokensPath: string;
+  private redirectUri: string;
+
+  constructor(
+    clientId: string,
+    clientSecret: string,
+    opts?: { tokensPath?: string; redirectUri?: string }
+  ) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.tokensPath = opts?.tokensPath ?? path.join(os.homedir(), '.jarvis', 'google-tokens.json');
+    this.redirectUri = opts?.redirectUri ?? 'http://localhost:3142/api/auth/google/callback';
+    this.loadTokens();
+  }
+
+  /**
+   * Load saved tokens from disk.
+   */
+  loadTokens(): GoogleTokens | null {
+    try {
+      if (!existsSync(this.tokensPath)) return null;
+      const text = readFileSync(this.tokensPath, 'utf-8');
+      const data = JSON.parse(text);
+      if (data.access_token && data.refresh_token) {
+        this.tokens = data as GoogleTokens;
+        return this.tokens;
+      }
+    } catch {
+      // No tokens file or invalid
+    }
+    return null;
+  }
+
+  /**
+   * Save tokens to disk.
+   */
+  async saveTokens(tokens: GoogleTokens): Promise<void> {
+    this.tokens = tokens;
+    await Bun.write(this.tokensPath, JSON.stringify(tokens, null, 2));
+  }
+
+  /**
+   * Check if we have valid tokens.
+   */
+  isAuthenticated(): boolean {
+    return this.tokens !== null && !!this.tokens.refresh_token;
+  }
+
+  /**
+   * Get a valid access token. Auto-refreshes if expired.
+   */
+  async getAccessToken(): Promise<string> {
+    if (!this.tokens) {
+      throw new Error('Not authenticated. Run: bun run src/scripts/google-setup.ts');
+    }
+
+    // Check if token is expired (with 5 min buffer)
+    if (this.tokens.expiry_date && Date.now() > this.tokens.expiry_date - 5 * 60_000) {
+      await this.refreshAccessToken();
+    }
+
+    return this.tokens.access_token;
+  }
+
+  /**
+   * Generate OAuth2 consent URL.
+   */
+  getAuthUrl(scopes: string[]): string {
+    const params = new URLSearchParams({
+      client_id: this.clientId,
+      redirect_uri: this.redirectUri,
+      response_type: 'code',
+      scope: scopes.join(' '),
+      access_type: 'offline',
+      prompt: 'consent',
+    });
+    return `${AUTH_ENDPOINT}?${params.toString()}`;
+  }
+
+  /**
+   * Exchange authorization code for tokens.
+   */
+  async exchangeCode(code: string): Promise<GoogleTokens> {
+    const resp = await fetch(TOKEN_ENDPOINT, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        code,
+        client_id: this.clientId,
+        client_secret: this.clientSecret,
+        redirect_uri: this.redirectUri,
+        grant_type: 'authorization_code',
+      }),
+    });
+
+    if (!resp.ok) {
+      const err = await resp.text();
+      throw new Error(`Token exchange failed: ${err}`);
+    }
+
+    const data = await resp.json() as any;
+
+    const tokens: GoogleTokens = {
+      access_token: data.access_token,
+      refresh_token: data.refresh_token,
+      expiry_date: Date.now() + (data.expires_in ?? 3600) * 1000,
+      token_type: data.token_type ?? 'Bearer',
+    };
+
+    await this.saveTokens(tokens);
+    return tokens;
+  }
+
+  /**
+   * Refresh the access token using the refresh token.
+   */
+  private async refreshAccessToken(): Promise<void> {
+    if (!this.tokens?.refresh_token) {
+      throw new Error('No refresh token available');
+    }
+
+    const resp = await fetch(TOKEN_ENDPOINT, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        refresh_token: this.tokens.refresh_token,
+        client_id: this.clientId,
+        client_secret: this.clientSecret,
+        grant_type: 'refresh_token',
+      }),
+    });
+
+    if (!resp.ok) {
+      const err = await resp.text();
+      throw new Error(`Token refresh failed: ${err}`);
+    }
+
+    const data = await resp.json() as any;
+
+    this.tokens = {
+      ...this.tokens,
+      access_token: data.access_token,
+      expiry_date: Date.now() + (data.expires_in ?? 3600) * 1000,
+    };
+
+    await this.saveTokens(this.tokens);
+    console.log('[GoogleAuth] Token refreshed successfully');
+  }
+}

package/src/llm/README.md

@@ -0,0 +1,291 @@
+# J.A.R.V.I.S. LLM Provider System
+
+A unified abstraction layer for multiple LLM providers with automatic fallback support.
+
+## Features
+
+- **Unified Interface**: Single API for Anthropic Claude, OpenAI GPT, and Ollama (local models)
+- **Automatic Fallback**: Seamlessly switches to backup providers if primary fails
+- **Streaming Support**: Real-time response streaming for all providers
+- **Tool Calling**: Unified tool/function calling across providers
+- **Zero Dependencies**: Uses native `fetch` API (no SDKs required)
+- **Type-Safe**: Full TypeScript types for all operations
+
+## Supported Providers
+
+### 1. Anthropic Claude
+- **Models**: Claude Opus 4.6, Sonnet 4.5, Claude 3.5, Claude 3
+- **Default**: `claude-sonnet-4-5-20250929`
+- **Features**: Text generation, streaming, tool use
+- **API**: https://api.anthropic.com/v1/messages
+
+### 2. OpenAI GPT
+- **Models**: GPT-4o, GPT-4 Turbo, GPT-3.5 Turbo
+- **Default**: `gpt-4o`
+- **Features**: Text generation, streaming, function calling
+- **API**: https://api.openai.com/v1/chat/completions
+
+### 3. Ollama (Local)
+- **Models**: Llama 3, Llama 2, Mistral, Mixtral, CodeLlama, etc.
+- **Default**: `llama3`
+- **Features**: Local inference, streaming, tool use
+- **API**: http://localhost:11434/api/chat
+
+## Usage
+
+### Basic Setup
+
+```typescript
+import { LLMManager, AnthropicProvider, OpenAIProvider, OllamaProvider } from './llm/index.ts';
+
+const manager = new LLMManager();
+
+// Register providers
+const anthropic = new AnthropicProvider('sk-ant-...', 'claude-sonnet-4-5-20250929');
+manager.registerProvider(anthropic);
+
+const openai = new OpenAIProvider('sk-...', 'gpt-4o');
+manager.registerProvider(openai);
+
+const ollama = new OllamaProvider('http://localhost:11434', 'llama3');
+manager.registerProvider(ollama);
+
+// Set primary and fallbacks
+manager.setPrimary('anthropic');
+manager.setFallbackChain(['openai', 'ollama']);
+```
+
+### Simple Chat
+
+```typescript
+const messages = [
+  { role: 'system', content: 'You are a helpful assistant.' },
+  { role: 'user', content: 'What is TypeScript?' },
+];
+
+const response = await manager.chat(messages);
+console.log(response.content);
+console.log('Tokens:', response.usage);
+console.log('Model:', response.model);
+```
+
+### Streaming Responses
+
+```typescript
+for await (const event of manager.stream(messages)) {
+  if (event.type === 'text') {
+    process.stdout.write(event.text);
+  } else if (event.type === 'done') {
+    console.log('\nCompleted!');
+    console.log('Total tokens:', event.response.usage);
+  } else if (event.type === 'error') {
+    console.error('Error:', event.error);
+  }
+}
+```
+
+### Tool Calling
+
+```typescript
+const tools = [
+  {
+    name: 'get_weather',
+    description: 'Get the current weather in a location',
+    parameters: {
+      type: 'object',
+      properties: {
+        location: { type: 'string', description: 'City name' },
+        unit: { type: 'string', enum: ['celsius', 'fahrenheit'] },
+      },
+      required: ['location'],
+    },
+  },
+];
+
+const messages = [
+  { role: 'user', content: 'What is the weather in Paris?' },
+];
+
+const response = await manager.chat(messages, { tools });
+
+if (response.tool_calls.length > 0) {
+  for (const call of response.tool_calls) {
+    console.log('Tool:', call.name);
+    console.log('Arguments:', call.arguments);
+    // Execute tool and continue conversation...
+  }
+}
+```
+
+### Advanced Options
+
+```typescript
+const response = await manager.chat(messages, {
+  model: 'claude-opus-4-6',      // Override default model
+  temperature: 0.7,               // Control randomness (0-1)
+  max_tokens: 2000,               // Limit response length
+  tools: [...],                   // Tool definitions
+});
+```
+
+## Configuration
+
+Load from `~/.jarvis/config.yaml`:
+
+```typescript
+import { loadConfig } from './config/index.ts';
+
+const config = await loadConfig();
+
+// Auto-configure providers from config
+if (config.llm.anthropic?.api_key) {
+  const anthropic = new AnthropicProvider(
+    config.llm.anthropic.api_key,
+    config.llm.anthropic.model
+  );
+  manager.registerProvider(anthropic);
+}
+
+manager.setPrimary(config.llm.primary);
+manager.setFallbackChain(config.llm.fallback);
+```
+
+## Provider-Specific Usage
+
+### Direct Provider Access
+
+```typescript
+const provider = manager.getProvider('anthropic');
+if (provider) {
+  const response = await provider.chat(messages);
+}
+```
+
+### List Available Models
+
+```typescript
+const anthropic = new AnthropicProvider('sk-ant-...');
+const models = await anthropic.listModels();
+console.log('Available models:', models);
+```
+
+## Response Types
+
+### LLMResponse
+
+```typescript
+{
+  content: string;                           // Generated text
+  tool_calls: LLMToolCall[];                 // Tool calls made (if any)
+  usage: {
+    input_tokens: number;                    // Prompt tokens
+    output_tokens: number;                   // Completion tokens
+  };
+  model: string;                             // Model used
+  finish_reason: 'stop' | 'tool_use' | 'length' | 'error';
+}
+```
+
+### LLMStreamEvent
+
+```typescript
+// Text delta
+{ type: 'text'; text: string }
+
+// Tool call completed
+{ type: 'tool_call'; tool_call: LLMToolCall }
+
+// Stream finished
+{ type: 'done'; response: LLMResponse }
+
+// Error occurred
+{ type: 'error'; error: string }
+```
+
+## Error Handling
+
+The manager automatically tries fallback providers on failure:
+
+```typescript
+try {
+  const response = await manager.chat(messages);
+} catch (err) {
+  // All providers failed
+  console.error('All LLM providers failed:', err.message);
+}
+```
+
+Individual provider errors are logged but don't throw unless all providers fail.
+
+## Testing
+
+Run the test file:
+
+```bash
+bun run src/llm/test.ts
+```
+
+Make sure you have a valid config at `~/.jarvis/config.yaml` with API keys set.
+
+## Implementation Details
+
+### Message Conversion
+
+Each provider has different message formats:
+- **Anthropic**: Separates system message, converts roles
+- **OpenAI**: Standard chat format
+- **Ollama**: Chat API format
+
+The abstraction layer handles all conversions automatically.
+
+### Tool Calling Formats
+
+- **Anthropic**: `tools` array with `input_schema`
+- **OpenAI**: `tools` array with `function` wrapper
+- **Ollama**: OpenAI-compatible function calling
+
+All converted to unified `LLMToolCall` format in responses.
+
+### Streaming Implementation
+
+- **Anthropic**: Server-Sent Events (SSE) with `data: {...}` format
+- **OpenAI**: SSE with delta chunks
+- **Ollama**: Newline-delimited JSON streaming
+
+All providers return the same `LLMStreamEvent` types.
+
+## Architecture
+
+```
+LLMManager
+├── AnthropicProvider (implements LLMProvider)
+├── OpenAIProvider (implements LLMProvider)
+└── OllamaProvider (implements LLMProvider)
+
+Each provider:
+- Implements chat() for single responses
+- Implements stream() for streaming responses
+- Implements listModels() for available models
+- Handles provider-specific API formats
+- Converts to/from unified types
+```
+
+## Best Practices
+
+1. **Always use LLMManager**: Don't instantiate providers directly unless needed
+2. **Set up fallbacks**: Configure multiple providers for reliability
+3. **Handle stream errors**: Check for `error` events in stream loops
+4. **Use config system**: Load API keys from config, never hardcode
+5. **Monitor usage**: Track token usage from responses for cost control
+6. **Test locally first**: Use Ollama for development before hitting paid APIs
+
+## Future Enhancements
+
+- [ ] Response caching
+- [ ] Rate limiting
+- [ ] Usage tracking/analytics
+- [ ] Model capability detection
+- [ ] Automatic model selection based on task
+- [ ] Retry with exponential backoff
+- [ ] Cost estimation per request
+- [ ] Multi-turn conversation helpers