@marktoflow/gui 2.0.0-alpha.12 → 2.0.0-alpha.14

package/src/server/services/agents/codex-provider.ts

@@ -1,398 +0,0 @@
-/**
- * OpenAI Codex AI agent provider
- * Uses the @openai/codex-sdk for AI capabilities
- */
-
-import { parse as yamlParse } from 'yaml';
-import type {
-  AgentProvider,
-  AgentCapabilities,
-  AgentConfig,
-  PromptResult,
-  Workflow,
-} from './types.js';
-import { buildPrompt, generateSuggestions } from './prompts.js';
-
-// Dynamic import types for Codex SDK
-interface CodexSDK {
-  Codex: new (options?: CodexOptions) => CodexInstance;
-}
-
-interface CodexOptions {
-  codexPathOverride?: string;
-  baseUrl?: string;
-  apiKey?: string;
-  env?: Record<string, string>;
-}
-
-interface ThreadOptions {
-  model?: string;
-  sandboxMode?: 'read-only' | 'workspace-write' | 'danger-full-access';
-  workingDirectory?: string;
-  skipGitRepoCheck?: boolean;
-  modelReasoningEffort?: 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
-  networkAccessEnabled?: boolean;
-  webSearchMode?: 'disabled' | 'cached' | 'live';
-  approvalPolicy?: 'never' | 'on-request' | 'on-failure' | 'untrusted';
-  additionalDirectories?: string[];
-}
-
-interface ThreadItem {
-  id: string;
-  type: string;
-  text?: string;
-  command?: string;
-  aggregated_output?: string;
-  status?: string;
-  changes?: unknown[];
-}
-
-interface Usage {
-  input_tokens: number;
-  cached_input_tokens: number;
-  output_tokens: number;
-}
-
-interface TurnResult {
-  items: ThreadItem[];
-  finalResponse: string;
-  usage: Usage | null;
-}
-
-interface ThreadEvent {
-  type: string;
-  thread_id?: string;
-  item?: ThreadItem;
-  usage?: Usage;
-  message?: string;
-  error?: { message: string };
-}
-
-interface StreamedTurnResult {
-  events: AsyncGenerator<ThreadEvent>;
-}
-
-interface Thread {
-  id: string | null;
-  run(input: string, options?: unknown): Promise<TurnResult>;
-  runStreamed(input: string, options?: unknown): Promise<StreamedTurnResult>;
-}
-
-interface CodexInstance {
-  startThread(options?: ThreadOptions): Thread;
-  resumeThread(id: string, options?: ThreadOptions): Thread;
-}
-
-export class CodexProvider implements AgentProvider {
-  readonly id = 'codex';
-  readonly name = 'OpenAI Codex';
-  readonly capabilities: AgentCapabilities = {
-    streaming: true,
-    toolUse: true,
-    codeExecution: true,
-    systemPrompts: true,
-    models: [
-      'codex-1',
-      'o3',
-      'o3-mini',
-      'o4-mini',
-      'gpt-4.1',
-    ],
-  };
-
-  private codex: CodexInstance | null = null;
-  private model: string = 'codex-1';
-  private ready: boolean = false;
-  private error: string | undefined;
-  private workingDirectory: string = process.cwd();
-  private lastThreadId: string | null = null;
-
-  async initialize(config: AgentConfig): Promise<void> {
-    try {
-      // Try to import the Codex SDK (dynamic import with webpackIgnore to avoid bundling issues)
-      const sdkModule = (await import(
-        /* webpackIgnore: true */ '@openai/codex-sdk'
-      ).catch(() => null)) as CodexSDK | null;
-
-      if (!sdkModule || !sdkModule.Codex) {
-        this.ready = false;
-        this.error = 'OpenAI Codex SDK not installed. Run: npm install @openai/codex-sdk';
-        return;
-      }
-
-      const { Codex } = sdkModule;
-
-      const codexOptions: CodexOptions = {};
-
-      // API key from config or environment
-      if (config.apiKey) {
-        codexOptions.apiKey = config.apiKey;
-      } else if (process.env.OPENAI_API_KEY) {
-        codexOptions.apiKey = process.env.OPENAI_API_KEY;
-      }
-
-      // Base URL
-      if (config.baseUrl) {
-        codexOptions.baseUrl = config.baseUrl;
-      }
-
-      // Codex path override
-      if (config.options?.codexPath) {
-        codexOptions.codexPathOverride = config.options.codexPath as string;
-      }
-
-      // Environment variables
-      if (config.options?.env) {
-        codexOptions.env = config.options.env as Record<string, string>;
-      }
-
-      this.codex = new Codex(codexOptions);
-
-      if (config.model) {
-        this.model = config.model;
-      }
-
-      // Working directory
-      if (config.options?.workingDirectory) {
-        this.workingDirectory = config.options.workingDirectory as string;
-      } else if (config.options?.cwd) {
-        this.workingDirectory = config.options.cwd as string;
-      }
-
-      // Test connectivity by starting a simple thread
-      try {
-        const thread = this.codex.startThread({
-          skipGitRepoCheck: true,
-          sandboxMode: 'read-only',
-          workingDirectory: this.workingDirectory,
-        });
-        // Just verify it can be created
-        if (thread) {
-          this.ready = true;
-          this.error = undefined;
-        }
-      } catch (testError) {
-        this.ready = false;
-        this.error = `Cannot initialize Codex: ${testError instanceof Error ? testError.message : 'Unknown error'}`;
-      }
-    } catch (err) {
-      this.ready = false;
-      this.error = err instanceof Error ? err.message : 'Unknown error initializing Codex';
-    }
-  }
-
-  isReady(): boolean {
-    return this.ready;
-  }
-
-  getStatus(): { ready: boolean; model?: string; error?: string } {
-    return {
-      ready: this.ready,
-      model: this.model,
-      error: this.error,
-    };
-  }
-
-  async processPrompt(
-    prompt: string,
-    workflow: Workflow,
-    context?: { selectedStepId?: string; recentHistory?: string[] }
-  ): Promise<PromptResult> {
-    if (!this.codex || !this.ready) {
-      return {
-        explanation: 'OpenAI Codex provider not available.',
-        error: this.error || 'Provider not initialized',
-      };
-    }
-
-    try {
-      // Build context-aware prompts
-      const { systemPrompt, userPrompt } = buildPrompt(prompt, workflow, context);
-
-      // Combine system and user prompts for Codex
-      const fullPrompt = `${systemPrompt}\n\n---\n\n${userPrompt}`;
-
-      const thread = this.codex.startThread({
-        model: this.model,
-        skipGitRepoCheck: true,
-        sandboxMode: 'read-only', // Safe for workflow modifications
-        workingDirectory: this.workingDirectory,
-        modelReasoningEffort: 'medium',
-      });
-
-      const result = await thread.run(fullPrompt);
-      this.lastThreadId = thread.id;
-
-      // Extract the response text
-      const responseText = result.finalResponse ||
-        result.items.find((item) => item.type === 'agent_message')?.text || '';
-
-      return this.parseAIResponse(responseText, workflow);
-    } catch (err) {
-      return {
-        explanation: '',
-        error: err instanceof Error ? err.message : 'Unknown error',
-      };
-    }
-  }
-
-  async getSuggestions(workflow: Workflow, selectedStepId?: string): Promise<string[]> {
-    return generateSuggestions(workflow, selectedStepId);
-  }
-
-  async streamPrompt(
-    prompt: string,
-    workflow: Workflow,
-    onChunk: (chunk: string) => void,
-    context?: { selectedStepId?: string; recentHistory?: string[] }
-  ): Promise<PromptResult> {
-    if (!this.codex || !this.ready) {
-      return this.processPrompt(prompt, workflow, context);
-    }
-
-    const { systemPrompt, userPrompt } = buildPrompt(prompt, workflow, context);
-    const fullPrompt = `${systemPrompt}\n\n---\n\n${userPrompt}`;
-    let fullResponse = '';
-
-    try {
-      const thread = this.codex.startThread({
-        model: this.model,
-        skipGitRepoCheck: true,
-        sandboxMode: 'read-only',
-        workingDirectory: this.workingDirectory,
-        modelReasoningEffort: 'medium',
-      });
-
-      const streamResult = await thread.runStreamed(fullPrompt);
-
-      for await (const event of streamResult.events) {
-        if (event.type === 'thread.started') {
-          this.lastThreadId = event.thread_id || null;
-        } else if (event.type === 'item.completed' && event.item?.type === 'agent_message') {
-          const text = event.item.text || '';
-          fullResponse = text;
-          onChunk(text);
-        } else if (event.type === 'error') {
-          throw new Error(event.message || 'Stream error');
-        } else if (event.type === 'turn.failed') {
-          throw new Error(event.error?.message || 'Turn failed');
-        }
-      }
-
-      return this.parseAIResponse(fullResponse, workflow);
-    } catch (err) {
-      return {
-        explanation: '',
-        error: err instanceof Error ? err.message : 'Unknown error',
-      };
-    }
-  }
-
-  async cancel(): Promise<void> {
-    // Codex SDK doesn't have explicit cancellation, but we can reset state
-    this.lastThreadId = null;
-  }
-
-  /**
-   * Get the last thread ID for resumption
-   */
-  getLastThreadId(): string | null {
-    return this.lastThreadId;
-  }
-
-  /**
-   * Resume a previous thread
-   */
-  async resumePrompt(
-    threadId: string,
-    prompt: string,
-    workflow: Workflow,
-    context?: { selectedStepId?: string; recentHistory?: string[] }
-  ): Promise<PromptResult> {
-    if (!this.codex || !this.ready) {
-      return {
-        explanation: 'OpenAI Codex provider not available.',
-        error: this.error || 'Provider not initialized',
-      };
-    }
-
-    try {
-      const { systemPrompt, userPrompt } = buildPrompt(prompt, workflow, context);
-      const fullPrompt = `${systemPrompt}\n\n---\n\n${userPrompt}`;
-
-      const thread = this.codex.resumeThread(threadId, {
-        model: this.model,
-        skipGitRepoCheck: true,
-        sandboxMode: 'read-only',
-        workingDirectory: this.workingDirectory,
-      });
-
-      const result = await thread.run(fullPrompt);
-      this.lastThreadId = thread.id;
-
-      const responseText = result.finalResponse ||
-        result.items.find((item) => item.type === 'agent_message')?.text || '';
-
-      return this.parseAIResponse(responseText, workflow);
-    } catch (err) {
-      return {
-        explanation: '',
-        error: err instanceof Error ? err.message : 'Unknown error',
-      };
-    }
-  }
-
-  private parseAIResponse(responseText: string, originalWorkflow: Workflow): PromptResult {
-    const yamlMatch = responseText.match(/```yaml\n([\s\S]*?)\n```/);
-    let modifiedWorkflow: Workflow | undefined;
-    let explanation = responseText;
-
-    if (yamlMatch) {
-      try {
-        const parsedYaml = yamlParse(yamlMatch[1]);
-        if (parsedYaml && (parsedYaml.steps || parsedYaml.metadata)) {
-          modifiedWorkflow = parsedYaml as Workflow;
-          const explanationMatch = responseText.match(/^([\s\S]*?)```yaml/);
-          if (explanationMatch) {
-            explanation = explanationMatch[1].trim();
-          }
-        }
-      } catch {
-        // Failed to parse YAML
-      }
-    }
-
-    let diff: string | undefined;
-    if (modifiedWorkflow) {
-      diff = this.generateDiff(originalWorkflow, modifiedWorkflow);
-    }
-
-    return { explanation, workflow: modifiedWorkflow, diff };
-  }
-
-  private generateDiff(original: Workflow, modified: Workflow): string {
-    const originalStepIds = new Set(original.steps?.map((s) => s.id) || []);
-    const modifiedStepIds = new Set(modified.steps?.map((s) => s.id) || []);
-
-    const added = modified.steps?.filter((s) => !originalStepIds.has(s.id)) || [];
-    const removed = original.steps?.filter((s) => !modifiedStepIds.has(s.id)) || [];
-
-    let diff = '';
-    if (added.length > 0) {
-      diff += `+ Added ${added.length} step(s): ${added.map((s) => s.name || s.id).join(', ')}\n`;
-    }
-    if (removed.length > 0) {
-      diff += `- Removed ${removed.length} step(s): ${removed.map((s) => s.name || s.id).join(', ')}\n`;
-    }
-
-    return diff || 'No structural changes detected';
-  }
-}
-
-export function createCodexProvider(config?: AgentConfig): CodexProvider {
-  const provider = new CodexProvider();
-  if (config) {
-    provider.initialize(config);
-  }
-  return provider;
-}

package/src/server/services/agents/copilot-provider.ts

@@ -1,311 +0,0 @@
-/**
- * GitHub Copilot AI agent provider
- * Uses the @github/copilot-sdk for AI capabilities
- */
-
-import { createRequire } from 'node:module';
-import { parse as yamlParse } from 'yaml';
-import type {
-  AgentProvider,
-  AgentCapabilities,
-  AgentConfig,
-  PromptResult,
-  Workflow,
-} from './types.js';
-import { buildPrompt, generateSuggestions } from './prompts.js';
-
-// Polyfill require for ESM environments (needed by Copilot SDK dependencies)
-if (typeof globalThis.require === 'undefined') {
-  (globalThis as unknown as { require: NodeRequire }).require = createRequire(import.meta.url);
-}
-
-// Dynamic import types for Copilot SDK
-// Using loose types to handle SDK version differences
-interface CopilotClientConfig {
-  cliPath?: string;
-  cliUrl?: string;
-  autoStart?: boolean;
-  logLevel?: 'error' | 'info' | 'none' | 'warning' | 'debug' | 'all';
-}
-
-interface CopilotSessionOptions {
-  model?: string;
-  streaming?: boolean;
-  systemMessage?: { content: string };
-}
-
-interface CopilotSessionResponse {
-  data?: {
-    content?: string;
-    messageId?: string;
-  };
-}
-
-interface SessionEvent {
-  type: string;
-  data: {
-    deltaContent?: string;
-    content?: string;
-    message?: string;
-  };
-}
-
-export class CopilotProvider implements AgentProvider {
-  readonly id = 'copilot';
-  readonly name = 'GitHub Copilot';
-  readonly capabilities: AgentCapabilities = {
-    streaming: true,
-    toolUse: true,
-    codeExecution: true,
-    systemPrompts: true,
-    models: [
-      'gpt-4.1',
-      'gpt-4o',
-      'gpt-4-turbo',
-      'claude-3.5-sonnet',
-    ],
-  };
-
-  // Using 'unknown' to handle SDK version differences
-  private client: unknown = null;
-  private model: string = 'gpt-4.1';
-  private ready: boolean = false;
-  private error: string | undefined;
-  private cliPath?: string;
-  private cliUrl?: string;
-
-  async initialize(config: AgentConfig): Promise<void> {
-    try {
-      // Try to import the Copilot SDK (dynamic import with webpackIgnore to avoid bundling issues)
-      const sdkModule = await import(/* webpackIgnore: true */ '@github/copilot-sdk').catch(
-        () => null
-      );
-      if (!sdkModule || !sdkModule.CopilotClient) {
-        this.ready = false;
-        this.error = 'GitHub Copilot SDK not installed. Run: npm install @github/copilot-sdk';
-        return;
-      }
-      const { CopilotClient } = sdkModule;
-
-      this.cliPath = config.options?.cliPath as string;
-      this.cliUrl = config.baseUrl || (config.options?.cliUrl as string);
-
-      const clientConfig: CopilotClientConfig = {
-        autoStart: true,
-        logLevel: 'error',
-      };
-
-      if (this.cliUrl) {
-        clientConfig.cliUrl = this.cliUrl;
-      } else {
-        clientConfig.cliPath = this.cliPath || 'copilot';
-      }
-
-      this.client = new CopilotClient(clientConfig);
-
-      if (config.model) {
-        this.model = config.model;
-      }
-
-      // Start the client and test connectivity
-      try {
-        if (this.client) {
-          // Some SDK versions have start(), some don't (auto-start)
-          const client = this.client as { start?: () => Promise<void>; ping?: () => Promise<unknown> };
-          if (typeof client.start === 'function') {
-            await client.start();
-          }
-          if (typeof client.ping === 'function') {
-            await client.ping();
-          }
-          this.ready = true;
-          this.error = undefined;
-        }
-      } catch (pingError) {
-        this.ready = false;
-        this.error = `Cannot connect to GitHub Copilot CLI: ${pingError instanceof Error ? pingError.message : 'Unknown error'}`;
-      }
-    } catch (err) {
-      this.ready = false;
-      this.error = err instanceof Error ? err.message : 'Unknown error initializing Copilot';
-    }
-  }
-
-  isReady(): boolean {
-    return this.ready;
-  }
-
-  getStatus(): { ready: boolean; model?: string; error?: string } {
-    return {
-      ready: this.ready,
-      model: this.model,
-      error: this.error,
-    };
-  }
-
-  async processPrompt(
-    prompt: string,
-    workflow: Workflow,
-    context?: { selectedStepId?: string; recentHistory?: string[] }
-  ): Promise<PromptResult> {
-    if (!this.client || !this.ready) {
-      return {
-        explanation: 'GitHub Copilot provider not available.',
-        error: this.error || 'Provider not initialized',
-      };
-    }
-
-    try {
-      // Build context-aware prompts
-      const { systemPrompt, userPrompt } = buildPrompt(prompt, workflow, context);
-
-      const client = this.client as {
-        createSession: (opts: CopilotSessionOptions) => Promise<{
-          sendAndWait: (opts: { prompt: string }) => Promise<CopilotSessionResponse | null>;
-          destroy: () => Promise<void>;
-        }>;
-      };
-
-      const session = await client.createSession({
-        model: this.model,
-        systemMessage: { content: systemPrompt },
-      });
-
-      try {
-        const response = await session.sendAndWait({ prompt: userPrompt });
-        const responseText = response?.data?.content || '';
-        return this.parseAIResponse(responseText, workflow);
-      } finally {
-        await session.destroy();
-      }
-    } catch (err) {
-      return {
-        explanation: '',
-        error: err instanceof Error ? err.message : 'Unknown error',
-      };
-    }
-  }
-
-  async getSuggestions(workflow: Workflow, selectedStepId?: string): Promise<string[]> {
-    return generateSuggestions(workflow, selectedStepId);
-  }
-
-  async streamPrompt(
-    prompt: string,
-    workflow: Workflow,
-    onChunk: (chunk: string) => void,
-    context?: { selectedStepId?: string; recentHistory?: string[] }
-  ): Promise<PromptResult> {
-    if (!this.client || !this.ready) {
-      return this.processPrompt(prompt, workflow, context);
-    }
-
-    const { systemPrompt, userPrompt } = buildPrompt(prompt, workflow, context);
-    let fullResponse = '';
-
-    try {
-      const client = this.client as {
-        createSession: (opts: CopilotSessionOptions) => Promise<{
-          send: (opts: { prompt: string }) => Promise<void>;
-          on: (callback: (event: SessionEvent) => void) => void;
-          destroy: () => Promise<void>;
-        }>;
-      };
-
-      const session = await client.createSession({
-        model: this.model,
-        streaming: true,
-        systemMessage: { content: systemPrompt },
-      });
-
-      return new Promise((resolve, reject) => {
-        session.on((event: SessionEvent) => {
-          if (event.type === 'assistant.message_delta') {
-            const chunk = event.data.deltaContent || '';
-            fullResponse += chunk;
-            onChunk(chunk);
-          } else if (event.type === 'assistant.message') {
-            fullResponse = event.data.content || fullResponse;
-          } else if (event.type === 'session.idle') {
-            session
-              .destroy()
-              .then(() => resolve(this.parseAIResponse(fullResponse, workflow)))
-              .catch(reject);
-          } else if (event.type === 'session.error') {
-            reject(new Error(event.data.message || 'Session error'));
-          }
-        });
-
-        session.send({ prompt: userPrompt }).catch(reject);
-      });
-    } catch (err) {
-      return {
-        explanation: '',
-        error: err instanceof Error ? err.message : 'Unknown error',
-      };
-    }
-  }
-
-  async cancel(): Promise<void> {
-    if (this.client) {
-      const client = this.client as { stop?: () => Promise<unknown> };
-      if (typeof client.stop === 'function') {
-        await client.stop();
-      }
-    }
-  }
-
-  private parseAIResponse(responseText: string, originalWorkflow: Workflow): PromptResult {
-    const yamlMatch = responseText.match(/```yaml\n([\s\S]*?)\n```/);
-    let modifiedWorkflow: Workflow | undefined;
-    let explanation = responseText;
-
-    if (yamlMatch) {
-      try {
-        const parsedYaml = yamlParse(yamlMatch[1]);
-        if (parsedYaml && (parsedYaml.steps || parsedYaml.metadata)) {
-          modifiedWorkflow = parsedYaml as Workflow;
-          const explanationMatch = responseText.match(/^([\s\S]*?)```yaml/);
-          if (explanationMatch) {
-            explanation = explanationMatch[1].trim();
-          }
-        }
-      } catch {
-        // Failed to parse YAML
-      }
-    }
-
-    let diff: string | undefined;
-    if (modifiedWorkflow) {
-      diff = this.generateDiff(originalWorkflow, modifiedWorkflow);
-    }
-
-    return { explanation, workflow: modifiedWorkflow, diff };
-  }
-
-  private generateDiff(original: Workflow, modified: Workflow): string {
-    const originalStepIds = new Set(original.steps?.map((s) => s.id) || []);
-    const modifiedStepIds = new Set(modified.steps?.map((s) => s.id) || []);
-
-    const added = modified.steps?.filter((s) => !originalStepIds.has(s.id)) || [];
-    const removed = original.steps?.filter((s) => !modifiedStepIds.has(s.id)) || [];
-
-    let diff = '';
-    if (added.length > 0) {
-      diff += `+ Added ${added.length} step(s): ${added.map((s) => s.name || s.id).join(', ')}\n`;
-    }
-    if (removed.length > 0) {
-      diff += `- Removed ${removed.length} step(s): ${removed.map((s) => s.name || s.id).join(', ')}\n`;
-    }
-
-    return diff || 'No structural changes detected';
-  }
-}
-
-export function createCopilotProvider(config?: AgentConfig): CopilotProvider {
-  const provider = new CopilotProvider();
-  if (config) {
-    provider.initialize(config);
-  }
-  return provider;
-}