@useconductor/conductor 1.0.0

package/src/ai/claude.ts

@@ -0,0 +1,162 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { AIProvider, AIMessage, AIResponse } from './base.js';
+import { PluginTool } from '../plugins/manager.js';
+
+export class ClaudeProvider extends AIProvider {
+  private client: Anthropic | null = null;
+
+  async initialize(apiKey: string): Promise<void> {
+    this.client = new Anthropic({ apiKey });
+  }
+
+  getName(): string {
+    return 'Claude';
+  }
+
+  async complete(messages: AIMessage[], tools?: PluginTool[]): Promise<AIResponse> {
+    if (!this.client) throw new Error('Claude not initialized. Call initialize() first.');
+
+    const model = this.config.model || 'claude-3-5-sonnet-20241022';
+
+    const requestTools = tools?.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputSchema as Anthropic.Tool.InputSchema,
+    }));
+
+    // Separate system message from conversation messages
+    const anthropicMessages = messages
+      .filter((m) => m.role !== 'system')
+      .map((m) => {
+        if (m.role === 'tool') {
+          return {
+            role: 'user' as const,
+            content: [
+              {
+                type: 'tool_result' as const,
+                tool_use_id: m.tool_call_id!,
+                content: m.content,
+              },
+            ],
+          };
+        } else if (m.role === 'assistant' && m.tool_calls) {
+          const content: Anthropic.Messages.ContentBlockParam[] = [];
+          if (m.content) content.push({ type: 'text', text: m.content });
+          m.tool_calls.forEach((tc) => {
+            content.push({
+              type: 'tool_use',
+              id: tc.id,
+              name: tc.name,
+              input: tc.arguments,
+            });
+          });
+          return { role: 'assistant' as const, content };
+        }
+        return {
+          role: m.role as 'user' | 'assistant',
+          content: m.content,
+        };
+      });
+
+    const systemMessage = messages.find((m) => m.role === 'system');
+
+    const response = await this.client.messages.create({
+      model,
+      max_tokens: this.config.maxTokens || 4096,
+      system: systemMessage?.content,
+      messages: anthropicMessages as Anthropic.Messages.MessageParam[],
+      tools: requestTools,
+    });
+
+    const toolCalls = response.content
+      .filter((c): c is Anthropic.Messages.ToolUseBlock => c.type === 'tool_use')
+      .map((c) => ({
+        id: c.id,
+        name: c.name,
+        arguments: c.input as Record<string, unknown>,
+      }));
+
+    const textContent = response.content
+      .filter((c): c is Anthropic.Messages.TextBlock => c.type === 'text')
+      .map((c) => c.text)
+      .join('\n');
+
+    return {
+      content: textContent,
+      model: response.model,
+      tokens_used: response.usage.input_tokens + response.usage.output_tokens,
+      finish_reason: response.stop_reason || undefined,
+      tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+    };
+  }
+
+  async *stream(messages: AIMessage[], tools?: PluginTool[]): AsyncGenerator<string> {
+    if (!this.client) throw new Error('Claude not initialized');
+
+    const model = this.config.model || 'claude-3-5-sonnet-20241022';
+
+    const requestTools = tools?.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputSchema as Anthropic.Tool.InputSchema,
+    }));
+
+    const anthropicMessages = messages
+      .filter((m) => m.role !== 'system')
+      .map((m) => {
+        if (m.role === 'tool') {
+          return {
+            role: 'user' as const,
+            content: [
+              {
+                type: 'tool_result' as const,
+                tool_use_id: m.tool_call_id!,
+                content: m.content,
+              },
+            ],
+          };
+        } else if (m.role === 'assistant' && m.tool_calls) {
+          const content: Anthropic.Messages.ContentBlockParam[] = [];
+          if (m.content) content.push({ type: 'text', text: m.content });
+          m.tool_calls.forEach((tc) => {
+            content.push({
+              type: 'tool_use',
+              id: tc.id,
+              name: tc.name,
+              input: tc.arguments,
+            });
+          });
+          return { role: 'assistant' as const, content };
+        }
+        return {
+          role: m.role as 'user' | 'assistant',
+          content: m.content,
+        };
+      });
+
+    const systemMessage = messages.find((m) => m.role === 'system');
+
+    const stream = await this.client.messages.stream({
+      model,
+      max_tokens: this.config.maxTokens || 4096,
+      system: systemMessage?.content,
+      messages: anthropicMessages as Anthropic.Messages.MessageParam[],
+      tools: requestTools,
+    });
+
+    for await (const chunk of stream) {
+      if (chunk.type === 'content_block_delta' && chunk.delta.type === 'text_delta') {
+        yield chunk.delta.text;
+      }
+    }
+  }
+
+  async test(): Promise<boolean> {
+    try {
+      await this.complete([{ role: 'user', content: 'Say "OK" if you can hear me.' }]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/ai/gemini.ts

@@ -0,0 +1,188 @@
+import { GoogleGenerativeAI, type FunctionDeclaration, type Tool as GeminiTool } from '@google/generative-ai';
+import { AIProvider, AIMessage, AIResponse } from './base.js';
+import { PluginTool } from '../plugins/manager.js';
+import { google } from 'googleapis';
+import type { OAuth2Client } from 'google-auth-library';
+import http from 'http';
+import { URL } from 'url';
+
+function convertToGeminiTools(tools?: PluginTool[]): GeminiTool[] {
+  if (!tools || tools.length === 0) return [];
+
+  const declarations: FunctionDeclaration[] = tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    parameters: t.inputSchema as unknown as FunctionDeclaration['parameters'],
+  }));
+
+  return [{ functionDeclarations: declarations }];
+}
+
+export class GeminiProvider extends AIProvider {
+  private client: GoogleGenerativeAI | null = null;
+  private oauth2Client: OAuth2Client | null = null;
+
+  getName(): string {
+    return 'Gemini';
+  }
+
+  async initialize(apiKey: string): Promise<void> {
+    if (!this.config) {
+      this.config = {};
+    }
+    this.config.model = this.config.model || 'gemini-2.0-flash-exp';
+    this.client = new GoogleGenerativeAI(apiKey);
+  }
+
+  async initializeWithOAuth(
+    clientId: string,
+    clientSecret: string,
+    redirectUri = 'http://localhost:3000/google/callback',
+  ): Promise<string> {
+    this.oauth2Client = new google.auth.OAuth2(clientId, clientSecret, redirectUri);
+
+    const authUrl = this.oauth2Client.generateAuthUrl({
+      access_type: 'offline',
+      scope: ['https://www.googleapis.com/auth/generative-language'],
+    });
+
+    return authUrl;
+  }
+
+  async completeOAuthFlow(code: string): Promise<void> {
+    if (!this.oauth2Client) throw new Error('OAuth not initialized');
+
+    const { tokens } = await this.oauth2Client.getToken(code);
+    this.oauth2Client.setCredentials(tokens);
+
+    this.client = new GoogleGenerativeAI(tokens.access_token as string);
+  }
+
+  async loginWithBrowser(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url || '', 'http://localhost:3000');
+
+        if (url.pathname === '/google/callback') {
+          const code = url.searchParams.get('code');
+
+          if (code) {
+            try {
+              await this.completeOAuthFlow(code);
+
+              res.writeHead(200, { 'Content-Type': 'text/html' });
+              res.end(`
+                <html>
+                  <body style="font-family: sans-serif; text-align: center; padding: 50px;">
+                    <h1>Success!</h1>
+                    <p>You're logged in with Google.</p>
+                    <p>You can close this window and return to terminal.</p>
+                  </body>
+                </html>
+              `);
+
+              server.close();
+              resolve();
+            } catch {
+              res.writeHead(500, { 'Content-Type': 'text/html' });
+              res.end('<h1>Authentication failed</h1>');
+              server.close();
+              reject(new Error('OAuth flow failed'));
+            }
+          }
+        }
+      });
+
+      server.listen(3000);
+      server.on('error', reject);
+    });
+  }
+
+  async complete(messages: AIMessage[], tools?: PluginTool[]): Promise<AIResponse> {
+    if (!this.client) throw new Error('Gemini not initialized');
+
+    const model = this.client.getGenerativeModel({
+      model: this.config.model || 'gemini-2.0-flash-exp',
+      tools: convertToGeminiTools(tools),
+    });
+
+    const geminiMessages = messages
+      .filter((m) => m.role !== 'system')
+      .map((m) => ({
+        role: m.role === 'assistant' ? ('model' as const) : ('user' as const),
+        parts: [{ text: m.content }],
+      }));
+
+    const systemInstruction = messages.find((m) => m.role === 'system');
+
+    const chat = model.startChat({
+      history: geminiMessages.slice(0, -1),
+      systemInstruction: systemInstruction?.content,
+    });
+
+    const lastMessage = geminiMessages[geminiMessages.length - 1];
+    const result = await chat.sendMessage(lastMessage.parts[0].text);
+    const response = result.response;
+
+    // Check for function calls
+    const functionCalls = response.functionCalls();
+    if (functionCalls && functionCalls.length > 0) {
+      const fc = functionCalls[0];
+      return {
+        content: response.text() || '',
+        model: this.config.model || 'gemini-2.0-flash-exp',
+        tokens_used: response.usageMetadata?.totalTokenCount,
+        tool_calls: [
+          {
+            id: fc.name,
+            name: fc.name,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            arguments: (fc.args ?? {}) as Record<string, any>,
+          },
+        ],
+      };
+    }
+
+    return {
+      content: response.text(),
+      model: this.config.model || 'gemini-2.0-flash-exp',
+      tokens_used: response.usageMetadata?.totalTokenCount,
+    };
+  }
+
+  async *stream(messages: AIMessage[], tools?: PluginTool[]): AsyncGenerator<string> {
+    if (!this.client) throw new Error('Gemini not initialized');
+
+    const model = this.client.getGenerativeModel({
+      model: this.config.model || 'gemini-2.0-flash-exp',
+      tools: convertToGeminiTools(tools),
+    });
+
+    const geminiMessages = messages
+      .filter((m) => m.role !== 'system')
+      .map((m) => ({
+        role: m.role === 'assistant' ? ('model' as const) : ('user' as const),
+        parts: [{ text: m.content }],
+      }));
+
+    const chat = model.startChat({
+      history: geminiMessages.slice(0, -1),
+    });
+
+    const lastMessage = geminiMessages[geminiMessages.length - 1];
+    const result = await chat.sendMessageStream(lastMessage.parts[0].text);
+
+    for await (const chunk of result.stream) {
+      yield chunk.text();
+    }
+  }
+
+  async test(): Promise<boolean> {
+    try {
+      await this.complete([{ role: 'user', content: 'Say "OK"' }]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/ai/maestro.ts

@@ -0,0 +1,168 @@
+import { AIProvider, AIMessage, AIResponse } from './base.js';
+import { PluginTool } from '../plugins/manager.js';
+
+/**
+ * Maestro Provider — connects to a locally running Maestro model via Ollama.
+ * Maestro is a fine-tuned Qwen2.5-Coder 7B model by TheAlxLabs, optimized
+ * for coding assistance, bug fixing, documentation, and code explanation.
+ */
+export class MaestroProvider extends AIProvider {
+  private endpoint: string;
+  private modelName: string;
+
+  constructor(config: any) {
+    super(config);
+    this.endpoint = config.endpoint || 'http://localhost:11434';
+    this.modelName = config.model || 'maestro';
+  }
+
+  getName(): string {
+    return 'Maestro';
+  }
+
+  async initialize(): Promise<void> {
+    const isRunning = await this.test();
+    if (!isRunning) {
+      throw new Error(
+        'Maestro is not running. Make sure Ollama is running and the Maestro model is pulled.\n' +
+          'Run: ollama pull thealxlabs/maestro',
+      );
+    }
+  }
+
+  async complete(messages: AIMessage[], _tools?: PluginTool[]): Promise<AIResponse> {
+    const formattedMessages = this.formatMessages(messages);
+
+    const response = await fetch(`${this.endpoint}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: this.modelName,
+        messages: formattedMessages,
+        stream: false,
+        options: {
+          temperature: 0.2, // Lower = more precise code output
+          top_p: 0.95,
+          repeat_penalty: 1.1,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Maestro error: ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as any;
+
+    return {
+      content: data.message.content,
+      model: `maestro (${data.model})`,
+      tokens_used: data.eval_count,
+      finish_reason: data.done ? 'stop' : undefined,
+    };
+  }
+
+  async *stream(messages: AIMessage[], _tools?: PluginTool[]): AsyncGenerator<string> {
+    const formattedMessages = this.formatMessages(messages);
+
+    const response = await fetch(`${this.endpoint}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: this.modelName,
+        messages: formattedMessages,
+        stream: true,
+        options: {
+          temperature: 0.2,
+          top_p: 0.95,
+          repeat_penalty: 1.1,
+        },
+      }),
+    });
+
+    if (!response.ok || !response.body) {
+      throw new Error(`Maestro stream error: ${response.statusText}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value);
+      const lines = chunk.split('\n').filter((l) => l.trim());
+
+      for (const line of lines) {
+        try {
+          const json = JSON.parse(line);
+          if (json.message?.content) {
+            yield json.message.content;
+          }
+        } catch {
+          // Skip invalid JSON fragments
+        }
+      }
+    }
+  }
+
+  async test(): Promise<boolean> {
+    try {
+      // Check Ollama is running
+      const tagsResponse = await fetch(`${this.endpoint}/api/tags`);
+      if (!tagsResponse.ok) return false;
+
+      // Check Maestro model is available
+      const data = (await tagsResponse.json()) as any;
+      const models: string[] = data.models?.map((m: any) => m.name) || [];
+      const hasMaestro = models.some((m) => m.includes('maestro'));
+
+      if (!hasMaestro) {
+        console.warn('\n⚠️  Maestro model not found in Ollama.\n' + 'Pull it with: ollama pull thealxlabs/maestro\n');
+        return false;
+      }
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /** Pull the Maestro model via Ollama */
+  async pullModel(): Promise<void> {
+    console.log('🎼 Pulling Maestro model from Ollama registry...');
+    const response = await fetch(`${this.endpoint}/api/pull`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: this.modelName, stream: false }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to pull Maestro: ${response.statusText}`);
+    }
+
+    console.log('✅ Maestro model ready!');
+  }
+
+  /** Format messages into Ollama-compatible format with Maestro system prompt */
+  private formatMessages(messages: AIMessage[]) {
+    const hasSytem = messages.some((m) => m.role === 'system');
+
+    const maestroSystem: AIMessage = {
+      role: 'system',
+      content:
+        'You are Maestro, an elite AI coding assistant by TheAlxLabs. ' +
+        'You specialize in writing clean, efficient, well-documented code across all languages. ' +
+        'You excel at fixing bugs, explaining complex code, and writing documentation. ' +
+        'Always provide accurate, working code. Be concise but thorough.',
+    };
+
+    const allMessages = hasSytem ? messages : [maestroSystem, ...messages];
+
+    return allMessages.map((m) => ({
+      role: m.role,
+      content: m.content,
+    }));
+  }
+}