codex-linux 1.0.0

package/src/main/ide/IDEIntegration.ts

@@ -0,0 +1,288 @@
+import { EventEmitter } from 'events';
+import * as child_process from 'child_process';
+import * as path from 'path';
+import log from 'electron-log';
+
+interface IDEConfig {
+  name: string;
+  command: string;
+  args: string[];
+  windowsCommand?: string;
+  macosCommand?: string;
+  linuxCommand?: string;
+}
+
+interface IDESession {
+  ide: string;
+  projectPath: string;
+  process?: child_process.ChildProcess;
+}
+
+const supportedIDEs: IDEConfig[] = [
+  {
+    name: 'VS Code',
+    command: 'code',
+    args: ['.'],
+    windowsCommand: 'code.cmd',
+    macosCommand: 'code',
+    linuxCommand: 'code'
+  },
+  {
+    name: 'WebStorm',
+    command: 'webstorm',
+    args: ['.'],
+    windowsCommand: 'webstorm64.exe',
+    macosCommand: 'webstorm',
+    linuxCommand: 'webstorm.sh'
+  },
+  {
+    name: 'IntelliJ IDEA',
+    command: 'idea',
+    args: ['.'],
+    windowsCommand: 'idea64.exe',
+    macosCommand: 'idea',
+    linuxCommand: 'idea.sh'
+  },
+  {
+    name: 'Cursor',
+    command: 'cursor',
+    args: ['.'],
+    windowsCommand: 'Cursor.exe',
+    macosCommand: 'cursor',
+    linuxCommand: 'cursor'
+  },
+  {
+    name: 'Sublime Text',
+    command: 'subl',
+    args: ['.'],
+    windowsCommand: 'subl.exe',
+    macosCommand: 'subl',
+    linuxCommand: 'subl'
+  },
+  {
+    name: 'Vim',
+    command: 'vim',
+    args: ['.'],
+    linuxCommand: 'vim',
+    macosCommand: 'vim'
+  },
+  {
+    name: 'Neovim',
+    command: 'nvim',
+    args: ['.'],
+    linuxCommand: 'nvim',
+    macosCommand: 'nvim'
+  }
+];
+
+export class IDEIntegration extends EventEmitter {
+  private activeSessions: Map<string, IDESession> = new Map();
+  private platform: string;
+
+  constructor() {
+    super();
+    this.platform = process.platform;
+  }
+
+  async detectAvailableIDEs(): Promise<IDEConfig[]> {
+    const available: IDEConfig[] = [];
+
+    for (const ide of supportedIDEs) {
+      try {
+        const command = this.getPlatformCommand(ide);
+        if (await this.isCommandAvailable(command)) {
+          available.push(ide);
+        }
+      } catch (error) {
+        log.debug(`${ide.name} not found`);
+      }
+    }
+
+    return available;
+  }
+
+  async openInIDE(projectPath: string, ideName: string): Promise<void> {
+    const ide = supportedIDEs.find(i => i.name === ideName);
+    if (!ide) {
+      throw new Error(`IDE ${ideName} not supported`);
+    }
+
+    const command = this.getPlatformCommand(ide);
+    const args = ide.args.map(arg => 
+      arg === '.' ? projectPath : arg
+    );
+
+    try {
+      const process = child_process.spawn(command, args, {
+        cwd: projectPath,
+        detached: true,
+        stdio: 'ignore'
+      });
+
+      process.unref();
+
+      const sessionId = `ide-${Date.now()}`;
+      this.activeSessions.set(sessionId, {
+        ide: ideName,
+        projectPath,
+        process
+      });
+
+      this.emit('ide:opened', { sessionId, ide: ideName, projectPath });
+      log.info(`Opened ${ideName} at ${projectPath}`);
+
+    } catch (error) {
+      log.error(`Failed to open ${ideName}:`, error);
+      throw error;
+    }
+  }
+
+  async openVSCodeAtLine(filePath: string, line: number, column: number = 0): Promise<void> {
+    try {
+      const args = [
+        '--goto',
+        `${filePath}:${line}:${column}`
+      ];
+
+      const process = child_process.spawn('code', args, {
+        detached: true,
+        stdio: 'ignore'
+      });
+
+      process.unref();
+
+      this.emit('ide:openedAtLine', { filePath, line, column });
+      log.info(`Opened ${filePath} at line ${line} in VS Code`);
+
+    } catch (error) {
+      log.error('Failed to open file in VS Code:', error);
+      throw error;
+    }
+  }
+
+  async installExtension(ideName: string, extensionId: string): Promise<void> {
+    if (ideName !== 'VS Code') {
+      throw new Error('Extension installation only supported for VS Code');
+    }
+
+    try {
+      await new Promise<void>((resolve, reject) => {
+        const process = child_process.spawn('code', ['--install-extension', extensionId], {
+          stdio: 'pipe'
+        });
+
+        let output = '';
+        process.stdout?.on('data', (data) => {
+          output += data.toString();
+        });
+
+        process.on('close', (code) => {
+          if (code === 0) {
+            resolve();
+          } else {
+            reject(new Error(`Extension installation failed: ${output}`));
+          }
+        });
+      });
+
+      this.emit('ide:extensionInstalled', { ide: ideName, extensionId });
+      log.info(`Installed extension ${extensionId} in VS Code`);
+
+    } catch (error) {
+      log.error('Failed to install extension:', error);
+      throw error;
+    }
+  }
+
+  async configureWorkspace(projectPath: string, settings: Record<string, any>): Promise<void> {
+    const vscodeDir = path.join(projectPath, '.vscode');
+    const settingsPath = path.join(vscodeDir, 'settings.json');
+
+    try {
+      // Create .vscode directory if it doesn't exist
+      await fs.promises.mkdir(vscodeDir, { recursive: true });
+
+      // Read existing settings or create new
+      let existingSettings = {};
+      try {
+        const content = await fs.promises.readFile(settingsPath, 'utf-8');
+        existingSettings = JSON.parse(content);
+      } catch {
+        // File doesn't exist or is invalid, start fresh
+      }
+
+      // Merge settings
+      const newSettings = {
+        ...existingSettings,
+        ...settings
+      };
+
+      // Write settings
+      await fs.promises.writeFile(
+        settingsPath,
+        JSON.stringify(newSettings, null, 2)
+      );
+
+      this.emit('ide:workspaceConfigured', { projectPath, settings });
+      log.info(`Configured VS Code workspace at ${projectPath}`);
+
+    } catch (error) {
+      log.error('Failed to configure workspace:', error);
+      throw error;
+    }
+  }
+
+  getActiveSessions(): IDESession[] {
+    return Array.from(this.activeSessions.values());
+  }
+
+  closeSession(sessionId: string): void {
+    const session = this.activeSessions.get(sessionId);
+    if (session?.process) {
+      session.process.kill();
+      this.activeSessions.delete(sessionId);
+      this.emit('ide:closed', { sessionId });
+    }
+  }
+
+  private getPlatformCommand(ide: IDEConfig): string {
+    switch (this.platform) {
+      case 'win32':
+        return ide.windowsCommand || ide.command;
+      case 'darwin':
+        return ide.macosCommand || ide.command;
+      case 'linux':
+        return ide.linuxCommand || ide.command;
+      default:
+        return ide.command;
+    }
+  }
+
+  private async isCommandAvailable(command: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      const checkCommand = this.platform === 'win32' 
+        ? `where ${command}` 
+        : `which ${command}`;
+
+      child_process.exec(checkCommand, (error) => {
+        resolve(!error);
+      });
+    });
+  }
+
+  cleanup(): void {
+    // Close all active sessions
+    for (const [_sessionId, session] of this.activeSessions) {
+      if (session.process) {
+        session.process.kill();
+      }
+    }
+    this.activeSessions.clear();
+    this.removeAllListeners();
+  }
+}
+
+// Import fs at the end to avoid circular dependencies
+import * as fs from 'fs';
+
+export default IDEIntegration;

package/src/main/integrations/LinearManager.ts

@@ -0,0 +1,327 @@
+import { EventEmitter } from 'events';
+import log from 'electron-log';
+import fetch from 'node-fetch';
+
+export interface LinearConfig {
+  apiKey: string;
+  organizationId?: string;
+}
+
+export interface LinearIssue {
+  id: string;
+  title: string;
+  description?: string;
+  state: { name: string; type: string };
+  priority: number;
+  assignee?: { name: string; email: string };
+  labels: Array<{ name: string; color: string }>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface LinearComment {
+  id: string;
+  body: string;
+  user: { name: string };
+  createdAt: string;
+}
+
+export class LinearManager extends EventEmitter {
+  private config: LinearConfig | null = null;
+  private baseUrl = 'https://api.linear.app/graphql';
+
+  constructor() {
+    super();
+  }
+
+  async configure(config: LinearConfig): Promise<void> {
+    this.config = config;
+    log.info('Linear configured', { organizationId: config.organizationId });
+  }
+
+  private async graphqlRequest(query: string, variables?: Record<string, any>): Promise<any> {
+    if (!this.config) throw new Error('Linear not configured');
+
+    const response = await fetch(this.baseUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': this.config.apiKey,
+      },
+      body: JSON.stringify({ query, variables }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Linear API error: ${response.statusText}`);
+    }
+
+    const jsonData = await response.json() as any;
+
+    if (jsonData.errors) {
+      throw new Error(`Linear GraphQL error: ${jsonData.errors[0].message}`);
+    }
+
+    return jsonData.data;
+  }
+
+  async listIssues(options?: {
+    teamId?: string;
+    assigneeId?: string;
+    labels?: string[];
+    limit?: number;
+  }): Promise<LinearIssue[]> {
+    const query = `
+      query Issues($first: Int, $filter: IssueFilter) {
+        issues(first: $first, filter: $filter) {
+          nodes {
+            id
+            title
+            description
+            priority
+            createdAt
+            updatedAt
+            state { name type }
+            assignee { name email }
+            labels { nodes { name color } }
+          }
+        }
+      }
+    `;
+
+    const variables: Record<string, any> = {
+      first: options?.limit || 50,
+      filter: {},
+    };
+
+    if (options?.teamId) {
+      variables.filter.team = { id: { eq: options.teamId } };
+    }
+    if (options?.assigneeId) {
+      variables.filter.assignee = { id: { eq: options.assigneeId } };
+    }
+
+    const data = await this.graphqlRequest(query, variables);
+    return data.issues.nodes.map((issue: any) => ({
+      ...issue,
+      labels: issue.labels?.nodes || [],
+    }));
+  }
+
+  async getIssue(issueId: string): Promise<LinearIssue> {
+    const query = `
+      query Issue($id: String!) {
+        issue(id: $id) {
+          id
+          title
+          description
+          priority
+          createdAt
+          updatedAt
+          state { name type }
+          assignee { name email }
+          labels { nodes { name color } }
+        }
+      }
+    `;
+
+    const data = await this.graphqlRequest(query, { id: issueId });
+    const issue = data.issue;
+    return {
+      ...issue,
+      labels: issue.labels?.nodes || [],
+    };
+  }
+
+  async createIssue(options: {
+    teamId: string;
+    title: string;
+    description?: string;
+    priority?: number;
+    assigneeId?: string;
+    labels?: string[];
+  }): Promise<LinearIssue> {
+    const mutation = `
+      mutation CreateIssue($input: IssueCreateInput!) {
+        issueCreate(input: $input) {
+          success
+          issue {
+            id
+            title
+            description
+            priority
+            createdAt
+            updatedAt
+            state { name type }
+            assignee { name email }
+          }
+        }
+      }
+    `;
+
+    const variables = {
+      input: {
+        teamId: options.teamId,
+        title: options.title,
+        description: options.description,
+        priority: options.priority || 0,
+        assigneeId: options.assigneeId,
+        labelIds: options.labels,
+      },
+    };
+
+    const data = await this.graphqlRequest(mutation, variables);
+
+    if (!data.issueCreate.success) {
+      throw new Error('Failed to create issue');
+    }
+
+    return data.issueCreate.issue;
+  }
+
+  async updateIssue(issueId: string, updates: {
+    title?: string;
+    description?: string;
+    priority?: number;
+    assigneeId?: string;
+    stateId?: string;
+  }): Promise<LinearIssue> {
+    const mutation = `
+      mutation UpdateIssue($id: String!, $input: IssueUpdateInput!) {
+        issueUpdate(id: $id, input: $input) {
+          success
+          issue {
+            id
+            title
+            description
+            priority
+            updatedAt
+            state { name type }
+          }
+        }
+      }
+    `;
+
+    const variables = {
+      id: issueId,
+      input: updates,
+    };
+
+    const data = await this.graphqlRequest(mutation, variables);
+
+    if (!data.issueUpdate.success) {
+      throw new Error('Failed to update issue');
+    }
+
+    return data.issueUpdate.issue;
+  }
+
+  async addComment(issueId: string, body: string): Promise<LinearComment> {
+    const mutation = `
+      mutation CreateComment($input: CommentCreateInput!) {
+        commentCreate(input: $input) {
+          success
+          comment {
+            id
+            body
+            user { name }
+            createdAt
+          }
+        }
+      }
+    `;
+
+    const variables = {
+      input: {
+        issueId,
+        body,
+      },
+    };
+
+    const data = await this.graphqlRequest(mutation, variables);
+
+    if (!data.commentCreate.success) {
+      throw new Error('Failed to add comment');
+    }
+
+    return data.commentCreate.comment;
+  }
+
+  async listComments(issueId: string): Promise<LinearComment[]> {
+    const query = `
+      query Comments($issueId: ID!) {
+        comments(filter: { issue: { id: { eq: $issueId } } }) {
+          nodes {
+            id
+            body
+            user { name }
+            createdAt
+          }
+        }
+      }
+    `;
+
+    const data = await this.graphqlRequest(query, { issueId });
+    return data.comments.nodes;
+  }
+
+  async archiveIssue(issueId: string): Promise<void> {
+    const mutation = `
+      mutation ArchiveIssue($id: String!) {
+        issueArchive(id: $id) {
+          success
+        }
+      }
+    `;
+
+    const data = await this.graphqlRequest(mutation, { id: issueId });
+
+    if (!data.issueArchive.success) {
+      throw new Error('Failed to archive issue');
+    }
+  }
+
+  async listTeams(): Promise<Array<{ id: string; name: string; key: string }>> {
+    const query = `
+      query Teams {
+        teams {
+          nodes {
+            id
+            name
+            key
+          }
+        }
+      }
+    `;
+
+    const data = await this.graphqlRequest(query);
+    return data.teams.nodes;
+  }
+
+  async listLabels(): Promise<Array<{ id: string; name: string; color: string }>> {
+    const query = `
+      query Labels {
+        labels {
+          nodes {
+            id
+            name
+            color
+          }
+        }
+      }
+    `;
+
+    const data = await this.graphqlRequest(query);
+    return data.labels.nodes;
+  }
+
+  getConfig(): LinearConfig | null {
+    return this.config ? { ...this.config, apiKey: '***' } : null;
+  }
+
+  cleanup(): void {
+    this.config = null;
+    this.removeAllListeners();
+  }
+}
+
+export default LinearManager;