codex-linux 1.0.0

package/packages/vscode-extension/src/extension.ts

@@ -0,0 +1,161 @@
+import * as vscode from 'vscode';
+import { CodexAPI } from './api';
+import { AgentsProvider } from './providers/agentsProvider';
+import { ChatPanel } from './panels/chatPanel';
+import { CreateAgentPanel } from './panels/createAgentPanel';
+
+export function activate(context: vscode.ExtensionContext) {
+  console.log('Codex Linux extension is now active');
+
+  // Initialize API client
+  const config = vscode.workspace.getConfiguration('codex');
+  const api = new CodexAPI(
+    config.get('api.host', 'localhost'),
+    config.get('api.port', 3001),
+    config.get('api.key', '')
+  );
+
+  // Tree data provider for agents
+  const agentsProvider = new AgentsProvider(api);
+  vscode.window.registerTreeDataProvider('codex.agents', agentsProvider);
+
+  // Register commands
+  const disposables = [
+    // Start Codex
+    vscode.commands.registerCommand('codex.start', async () => {
+      const terminal = vscode.window.createTerminal('Codex Linux');
+      terminal.sendText('codex');
+      terminal.show();
+      
+      // Check if server is running
+      const isHealthy = await api.checkHealth();
+      if (!isHealthy) {
+        vscode.window.showWarningMessage('Codex server is not running. Please start it first.');
+      }
+    }),
+
+    // Refresh agents
+    vscode.commands.registerCommand('codex.refreshAgents', () => {
+      agentsProvider.refresh();
+    }),
+
+    // Create agent
+    vscode.commands.registerCommand('codex.createAgent', () => {
+      CreateAgentPanel.createOrShow(context.extensionUri, api, () => {
+        agentsProvider.refresh();
+      });
+    }),
+
+    // Chat with agent
+    vscode.commands.registerCommand('codex.chat', async () => {
+      const agents = await api.getAgents();
+      if (agents.length === 0) {
+        vscode.window.showInformationMessage('No agents found. Create one first.');
+        return;
+      }
+      
+      const items = agents.map(a => ({ label: a.name, id: a.id }));
+      const selected = await vscode.window.showQuickPick(items, {
+        placeHolder: 'Select an agent to chat with'
+      });
+      
+      if (selected) {
+        ChatPanel.createOrShow(context.extensionUri, api, selected.id);
+      }
+    }),
+
+    // Open agent chat from tree
+    vscode.commands.registerCommand('codex.openAgent', (agentId: string) => {
+      ChatPanel.createOrShow(context.extensionUri, api, agentId);
+    }),
+
+    // Explain selected code
+    vscode.commands.registerCommand('codex.explain', async () => {
+      const editor = vscode.window.activeTextEditor;
+      if (!editor) return;
+
+      const selection = editor.document.getText(editor.selection);
+      if (!selection) {
+        vscode.window.showWarningMessage('No code selected');
+        return;
+      }
+
+      const agents = await api.getAgents();
+      if (agents.length === 0) {
+        vscode.window.showInformationMessage('Create an agent first to use this feature.');
+        return;
+      }
+
+      const panel = ChatPanel.createOrShow(context.extensionUri, api, agents[0].id);
+      panel.sendMessage(`Explain this code:\n\n${selection}`);
+    }),
+
+    // Refactor selected code
+    vscode.commands.registerCommand('codex.refactor', async () => {
+      const editor = vscode.window.activeTextEditor;
+      if (!editor) return;
+
+      const selection = editor.document.getText(editor.selection);
+      if (!selection) {
+        vscode.window.showWarningMessage('No code selected');
+        return;
+      }
+
+      const agents = await api.getAgents();
+      if (agents.length === 0) {
+        vscode.window.showInformationMessage('Create an agent first to use this feature.');
+        return;
+      }
+
+      const panel = ChatPanel.createOrShow(context.extensionUri, api, agents[0].id);
+      panel.sendMessage(`Refactor this code to improve readability and performance:\n\n${selection}`);
+    }),
+
+    // Generate tests
+    vscode.commands.registerCommand('codex.test', async () => {
+      const editor = vscode.window.activeTextEditor;
+      if (!editor) return;
+
+      const document = editor.document;
+      const fileName = document.fileName;
+      const language = document.languageId;
+
+      const agents = await api.getAgents();
+      if (agents.length === 0) {
+        vscode.window.showInformationMessage('Create an agent first to use this feature.');
+        return;
+      }
+
+      const panel = ChatPanel.createOrShow(context.extensionUri, api, agents[0].id);
+      panel.sendMessage(`Generate comprehensive tests for the code in ${fileName} (${language})`);
+    }),
+
+    // Delete agent
+    vscode.commands.registerCommand('codex.deleteAgent', async (agentId: string) => {
+      const confirm = await vscode.window.showWarningMessage(
+        'Are you sure you want to delete this agent?',
+        'Yes',
+        'No'
+      );
+      
+      if (confirm === 'Yes') {
+        try {
+          await api.deleteAgent(agentId);
+          agentsProvider.refresh();
+          vscode.window.showInformationMessage('Agent deleted successfully');
+        } catch (error) {
+          vscode.window.showErrorMessage(`Failed to delete agent: ${error}`);
+        }
+      }
+    })
+  ];
+
+  context.subscriptions.push(...disposables);
+
+  // Set context
+  vscode.commands.executeCommand('setContext', 'codex.enabled', true);
+}
+
+export function deactivate() {
+  console.log('Codex Linux extension is now deactivated');
+}

package/packages/vscode-extension/src/panels/chatPanel.ts

@@ -0,0 +1,265 @@
+import * as vscode from 'vscode';
+import { CodexAPI } from '../api';
+
+export class ChatPanel {
+  public static currentPanel: ChatPanel | undefined;
+  private readonly _panel: vscode.WebviewPanel;
+  private _disposables: vscode.Disposable[] = [];
+  private _agentId: string;
+
+  public static createOrShow(extensionUri: vscode.Uri, api: CodexAPI, agentId: string) {
+    const column = vscode.window.activeTextEditor
+      ? vscode.window.activeTextEditor.viewColumn
+      : undefined;
+
+    // If we already have a panel, show it
+    if (ChatPanel.currentPanel) {
+      ChatPanel.currentPanel._panel.reveal(column);
+      ChatPanel.currentPanel._agentId = agentId;
+      return ChatPanel.currentPanel;
+    }
+
+    // Otherwise, create a new panel
+    const panel = vscode.window.createWebviewPanel(
+      'codexChat',
+      'Codex Chat',
+      column || vscode.ViewColumn.One,
+      {
+        enableScripts: true,
+        retainContextWhenHidden: true,
+        localResourceRoots: [extensionUri]
+      }
+    );
+
+    ChatPanel.currentPanel = new ChatPanel(panel, api, agentId, extensionUri);
+    return ChatPanel.currentPanel;
+  }
+
+  private constructor(
+    panel: vscode.WebviewPanel,
+    private _api: CodexAPI,
+    agentId: string,
+    private readonly _extensionUri: vscode.Uri
+  ) {
+    this._panel = panel;
+    this._agentId = agentId;
+    this._panel.webview.html = this._getHtmlForWebview();
+    
+    // Set agent info
+    this._updateAgentInfo();
+
+    // Handle messages from the webview
+    this._panel.webview.onDidReceiveMessage(
+      async message => {
+        switch (message.command) {
+          case 'sendMessage':
+            await this._sendMessage(message.text);
+            return;
+        }
+      },
+      null,
+      this._disposables
+    );
+
+    this._panel.onDidDispose(() => this.dispose(), null, this._disposables);
+  }
+
+  public sendMessage(text: string) {
+    this._panel.webview.postMessage({ command: 'addUserMessage', text });
+    this._sendMessage(text);
+  }
+
+  private async _sendMessage(text: string) {
+    try {
+      this._panel.webview.postMessage({ command: 'setLoading', loading: true });
+      
+      const response = await this._api.sendMessage(this._agentId, text);
+      
+      this._panel.webview.postMessage({
+        command: 'addAssistantMessage',
+        text: response.content
+      });
+    } catch (error) {
+      this._panel.webview.postMessage({
+        command: 'addError',
+        text: `Error: ${error}`
+      });
+    } finally {
+      this._panel.webview.postMessage({ command: 'setLoading', loading: false });
+    }
+  }
+
+  private async _updateAgentInfo() {
+    try {
+      const agent = await this._api.getAgent(this._agentId);
+      if (agent) {
+        this._panel.title = `Chat: ${agent.name}`;
+        this._panel.webview.postMessage({
+          command: 'setAgentInfo',
+          name: agent.name,
+          status: agent.status
+        });
+      }
+    } catch (error) {
+      console.error('Failed to load agent info:', error);
+    }
+  }
+
+  private _getHtmlForWebview() {
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <style>
+    body {
+      font-family: var(--vscode-font-family);
+      padding: 20px;
+      color: var(--vscode-editor-foreground);
+      background: var(--vscode-editor-background);
+    }
+    .header {
+      margin-bottom: 20px;
+      padding-bottom: 10px;
+      border-bottom: 1px solid var(--vscode-panel-border);
+    }
+    .messages {
+      height: calc(100vh - 150px);
+      overflow-y: auto;
+      margin-bottom: 20px;
+    }
+    .message {
+      margin-bottom: 15px;
+      padding: 10px;
+      border-radius: 6px;
+    }
+    .user {
+      background: var(--vscode-button-background);
+      color: var(--vscode-button-foreground);
+      margin-left: 20%;
+    }
+    .assistant {
+      background: var(--vscode-editor-inactiveSelectionBackground);
+      margin-right: 20%;
+    }
+    .error {
+      background: var(--vscode-inputValidation-errorBackground);
+      color: var(--vscode-inputValidation-errorForeground);
+    }
+    .input-container {
+      display: flex;
+      gap: 10px;
+    }
+    input {
+      flex: 1;
+      padding: 8px;
+      background: var(--vscode-input-background);
+      color: var(--vscode-input-foreground);
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 4px;
+    }
+    button {
+      padding: 8px 16px;
+      background: var(--vscode-button-background);
+      color: var(--vscode-button-foreground);
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+    }
+    button:hover {
+      background: var(--vscode-button-hoverBackground);
+    }
+    button:disabled {
+      opacity: 0.5;
+      cursor: not-allowed;
+    }
+    .loading {
+      text-align: center;
+      color: var(--vscode-descriptionForeground);
+      font-style: italic;
+    }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h2 id="agentName">Chat</h2>
+    <span id="agentStatus"></span>
+  </div>
+  
+  <div class="messages" id="messages"></div>
+  
+  <div class="loading" id="loading" style="display: none;">Thinking...</div>
+  
+  <div class="input-container">
+    <input type="text" id="messageInput" placeholder="Type your message..." />
+    <button id="sendButton">Send</button>
+  </div>
+
+  <script>
+    const vscode = acquireVsCodeApi();
+    const messagesDiv = document.getElementById('messages');
+    const messageInput = document.getElementById('messageInput');
+    const sendButton = document.getElementById('sendButton');
+    const loadingDiv = document.getElementById('loading');
+
+    function addMessage(text, type) {
+      const div = document.createElement('div');
+      div.className = 'message ' + type;
+      div.textContent = text;
+      messagesDiv.appendChild(div);
+      messagesDiv.scrollTop = messagesDiv.scrollHeight;
+    }
+
+    sendButton.addEventListener('click', () => {
+      const text = messageInput.value.trim();
+      if (text) {
+        addMessage(text, 'user');
+        vscode.postMessage({ command: 'sendMessage', text });
+        messageInput.value = '';
+      }
+    });
+
+    messageInput.addEventListener('keypress', (e) => {
+      if (e.key === 'Enter') {
+        sendButton.click();
+      }
+    });
+
+    window.addEventListener('message', event => {
+      const message = event.data;
+      switch (message.command) {
+        case 'addUserMessage':
+          addMessage(message.text, 'user');
+          break;
+        case 'addAssistantMessage':
+          addMessage(message.text, 'assistant');
+          break;
+        case 'addError':
+          addMessage(message.text, 'error');
+          break;
+        case 'setLoading':
+          loadingDiv.style.display = message.loading ? 'block' : 'none';
+          sendButton.disabled = message.loading;
+          break;
+        case 'setAgentInfo':
+          document.getElementById('agentName').textContent = message.name;
+          document.getElementById('agentStatus').textContent = message.status;
+          break;
+      }
+    });
+  </script>
+</body>
+</html>`;
+  }
+
+  public dispose() {
+    ChatPanel.currentPanel = undefined;
+    this._panel.dispose();
+    while (this._disposables.length) {
+      const x = this._disposables.pop();
+      if (x) {
+        x.dispose();
+      }
+    }
+  }
+}

package/packages/vscode-extension/src/panels/createAgentPanel.ts

@@ -0,0 +1,227 @@
+import * as vscode from 'vscode';
+import { CodexAPI } from '../api';
+
+export class CreateAgentPanel {
+  public static currentPanel: CreateAgentPanel | undefined;
+  private readonly _panel: vscode.WebviewPanel;
+  private _disposables: vscode.Disposable[] = [];
+
+  public static createOrShow(
+    extensionUri: vscode.Uri,
+    api: CodexAPI,
+    onCreated: () => void
+  ) {
+    const column = vscode.window.activeTextEditor
+      ? vscode.window.activeTextEditor.viewColumn
+      : undefined;
+
+    if (CreateAgentPanel.currentPanel) {
+      CreateAgentPanel.currentPanel._panel.reveal(column);
+      return CreateAgentPanel.currentPanel;
+    }
+
+    const panel = vscode.window.createWebviewPanel(
+      'codexCreateAgent',
+      'Create Agent',
+      column || vscode.ViewColumn.One,
+      {
+        enableScripts: true,
+        localResourceRoots: [extensionUri]
+      }
+    );
+
+    CreateAgentPanel.currentPanel = new CreateAgentPanel(panel, api, onCreated, extensionUri);
+  }
+
+  private constructor(
+    panel: vscode.WebviewPanel,
+    private _api: CodexAPI,
+    private _onCreated: () => void,
+    private readonly _extensionUri: vscode.Uri
+  ) {
+    this._panel = panel;
+    this._panel.webview.html = this._getHtmlForWebview();
+
+    this._panel.webview.onDidReceiveMessage(
+      async message => {
+        switch (message.command) {
+          case 'createAgent':
+            await this._createAgent(message.config);
+            return;
+        }
+      },
+      null,
+      this._disposables
+    );
+
+    this._panel.onDidDispose(() => this.dispose(), null, this._disposables);
+  }
+
+  private async _createAgent(config: any) {
+    try {
+      this._panel.webview.postMessage({ command: 'setLoading', loading: true });
+      
+      await this._api.createAgent(config);
+      
+      vscode.window.showInformationMessage('Agent created successfully!');
+      this._onCreated();
+      this._panel.dispose();
+    } catch (error) {
+      this._panel.webview.postMessage({
+        command: 'showError',
+        text: `Failed to create agent: ${error}`
+      });
+    } finally {
+      this._panel.webview.postMessage({ command: 'setLoading', loading: false });
+    }
+  }
+
+  private _getHtmlForWebview() {
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <style>
+    body {
+      font-family: var(--vscode-font-family);
+      padding: 20px;
+      color: var(--vscode-editor-foreground);
+      background: var(--vscode-editor-background);
+    }
+    h2 {
+      margin-bottom: 20px;
+      color: var(--vscode-foreground);
+    }
+    .form-group {
+      margin-bottom: 15px;
+    }
+    label {
+      display: block;
+      margin-bottom: 5px;
+      font-weight: 500;
+    }
+    input, select {
+      width: 100%;
+      padding: 8px;
+      background: var(--vscode-input-background);
+      color: var(--vscode-input-foreground);
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 4px;
+      box-sizing: border-box;
+    }
+    input:focus, select:focus {
+      outline: none;
+      border-color: var(--vscode-focusBorder);
+    }
+    button {
+      padding: 10px 20px;
+      background: var(--vscode-button-background);
+      color: var(--vscode-button-foreground);
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 14px;
+    }
+    button:hover {
+      background: var(--vscode-button-hoverBackground);
+    }
+    button:disabled {
+      opacity: 0.5;
+      cursor: not-allowed;
+    }
+    .error {
+      color: var(--vscode-inputValidation-errorForeground);
+      background: var(--vscode-inputValidation-errorBackground);
+      padding: 8px;
+      border-radius: 4px;
+      margin-bottom: 15px;
+      display: none;
+    }
+  </style>
+</head>
+<body>
+  <h2>Create New Agent</h2>
+  
+  <div class="error" id="error"></div>
+  
+  <div class="form-group">
+    <label for="name">Agent Name</label>
+    <input type="text" id="name" placeholder="My Coding Agent" />
+  </div>
+  
+  <div class="form-group">
+    <label for="projectPath">Project Path</label>
+    <input type="text" id="projectPath" placeholder="/path/to/project" />
+  </div>
+  
+  <div class="form-group">
+    <label for="provider">AI Provider</label>
+    <select id="provider">
+      <option value="openai">OpenAI</option>
+      <option value="anthropic">Anthropic</option>
+    </select>
+  </div>
+  
+  <div class="form-group">
+    <label for="model">Model</label>
+    <select id="model">
+      <option value="gpt-4o">GPT-4o</option>
+      <option value="gpt-4o-mini">GPT-4o Mini</option>
+      <option value="claude-3-5-sonnet-20241022">Claude 3.5 Sonnet</option>
+      <option value="claude-3-opus-20240229">Claude 3 Opus</option>
+    </select>
+  </div>
+  
+  <button id="createButton">Create Agent</button>
+
+  <script>
+    const vscode = acquireVsCodeApi();
+    const errorDiv = document.getElementById('error');
+    const createButton = document.getElementById('createButton');
+
+    createButton.addEventListener('click', () => {
+      const name = document.getElementById('name').value;
+      const projectPath = document.getElementById('projectPath').value;
+      const providerId = document.getElementById('provider').value;
+      const model = document.getElementById('model').value;
+
+      if (!name || !projectPath) {
+        errorDiv.textContent = 'Please fill in all required fields';
+        errorDiv.style.display = 'block';
+        return;
+      }
+
+      errorDiv.style.display = 'none';
+      
+      vscode.postMessage({
+        command: 'createAgent',
+        config: { name, projectPath, providerId, model }
+      });
+    });
+
+    window.addEventListener('message', event => {
+      const message = event.data;
+      if (message.command === 'setLoading') {
+        createButton.disabled = message.loading;
+        createButton.textContent = message.loading ? 'Creating...' : 'Create Agent';
+      } else if (message.command === 'showError') {
+        errorDiv.textContent = message.text;
+        errorDiv.style.display = 'block';
+      }
+    });
+  </script>
+</body>
+</html>`;
+  }
+
+  public dispose() {
+    CreateAgentPanel.currentPanel = undefined;
+    this._panel.dispose();
+    while (this._disposables.length) {
+      const x = this._disposables.pop();
+      if (x) {
+        x.dispose();
+      }
+    }
+  }
+}