blackbox-cli-vscode-ide-companion 0.0.5

package/src/diff-manager.ts

@@ -0,0 +1,268 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  IdeDiffAcceptedNotificationSchema,
+  IdeDiffClosedNotificationSchema,
+} from '@blackbox_ai/blackbox-cli-core';
+import { type JSONRPCNotification } from '@modelcontextprotocol/sdk/types.js';
+import * as path from 'node:path';
+import * as vscode from 'vscode';
+import { DIFF_SCHEME } from './extension.js';
+
+export class DiffContentProvider implements vscode.TextDocumentContentProvider {
+  private content = new Map<string, string>();
+  private onDidChangeEmitter = new vscode.EventEmitter<vscode.Uri>();
+
+  get onDidChange(): vscode.Event<vscode.Uri> {
+    return this.onDidChangeEmitter.event;
+  }
+
+  provideTextDocumentContent(uri: vscode.Uri): string {
+    return this.content.get(uri.toString()) ?? '';
+  }
+
+  setContent(uri: vscode.Uri, content: string): void {
+    this.content.set(uri.toString(), content);
+    this.onDidChangeEmitter.fire(uri);
+  }
+
+  deleteContent(uri: vscode.Uri): void {
+    this.content.delete(uri.toString());
+  }
+
+  getContent(uri: vscode.Uri): string | undefined {
+    return this.content.get(uri.toString());
+  }
+}
+
+// Information about a diff view that is currently open.
+interface DiffInfo {
+  originalFilePath: string;
+  newContent: string;
+  rightDocUri: vscode.Uri;
+}
+
+/**
+ * Manages the state and lifecycle of diff views within the IDE.
+ */
+export class DiffManager {
+  private readonly onDidChangeEmitter =
+    new vscode.EventEmitter<JSONRPCNotification>();
+  readonly onDidChange = this.onDidChangeEmitter.event;
+  private diffDocuments = new Map<string, DiffInfo>();
+  private readonly subscriptions: vscode.Disposable[] = [];
+
+  constructor(
+    private readonly log: (message: string) => void,
+    private readonly diffContentProvider: DiffContentProvider,
+  ) {
+    this.subscriptions.push(
+      vscode.window.onDidChangeActiveTextEditor((editor) => {
+        this.onActiveEditorChange(editor);
+      }),
+    );
+    this.onActiveEditorChange(vscode.window.activeTextEditor);
+  }
+
+  dispose() {
+    for (const subscription of this.subscriptions) {
+      subscription.dispose();
+    }
+  }
+
+  /**
+   * Creates and shows a new diff view.
+   */
+  async showDiff(filePath: string, newContent: string) {
+    const fileUri = vscode.Uri.file(filePath);
+
+    const rightDocUri = vscode.Uri.from({
+      scheme: DIFF_SCHEME,
+      path: filePath,
+      // cache busting
+      query: `rand=${Math.random()}`,
+    });
+    this.diffContentProvider.setContent(rightDocUri, newContent);
+
+    this.addDiffDocument(rightDocUri, {
+      originalFilePath: filePath,
+      newContent,
+      rightDocUri,
+    });
+
+    const diffTitle = `${path.basename(filePath)} ↔ Modified`;
+    await vscode.commands.executeCommand(
+      'setContext',
+      'blackbox.diff.isVisible',
+      true,
+    );
+
+    let leftDocUri;
+    try {
+      await vscode.workspace.fs.stat(fileUri);
+      leftDocUri = fileUri;
+    } catch {
+      // We need to provide an empty document to diff against.
+      // Using the 'untitled' scheme is one way to do this.
+      leftDocUri = vscode.Uri.from({
+        scheme: 'untitled',
+        path: filePath,
+      });
+    }
+
+    await vscode.commands.executeCommand(
+      'vscode.diff',
+      leftDocUri,
+      rightDocUri,
+      diffTitle,
+      {
+        preview: false,
+        preserveFocus: true,
+      },
+    );
+    await vscode.commands.executeCommand(
+      'workbench.action.files.setActiveEditorWriteableInSession',
+    );
+  }
+
+  /**
+   * Closes an open diff view for a specific file.
+   */
+  async closeDiff(filePath: string) {
+    let uriToClose: vscode.Uri | undefined;
+    for (const [uriString, diffInfo] of this.diffDocuments.entries()) {
+      if (diffInfo.originalFilePath === filePath) {
+        uriToClose = vscode.Uri.parse(uriString);
+        break;
+      }
+    }
+
+    if (uriToClose) {
+      const rightDoc = await vscode.workspace.openTextDocument(uriToClose);
+      const modifiedContent = rightDoc.getText();
+      await this.closeDiffEditor(uriToClose);
+      this.onDidChangeEmitter.fire(
+        IdeDiffClosedNotificationSchema.parse({
+          jsonrpc: '2.0',
+          method: 'ide/diffClosed',
+          params: {
+            filePath,
+            content: modifiedContent,
+          },
+        }),
+      );
+      return modifiedContent;
+    }
+    return;
+  }
+
+  /**
+   * User accepts the changes in a diff view. Does not apply changes.
+   */
+  async acceptDiff(rightDocUri: vscode.Uri) {
+    const diffInfo = this.diffDocuments.get(rightDocUri.toString());
+    if (!diffInfo) {
+      this.log(`No diff info found for ${rightDocUri.toString()}`);
+      return;
+    }
+
+    const rightDoc = await vscode.workspace.openTextDocument(rightDocUri);
+    const modifiedContent = rightDoc.getText();
+    await this.closeDiffEditor(rightDocUri);
+
+    this.onDidChangeEmitter.fire(
+      IdeDiffAcceptedNotificationSchema.parse({
+        jsonrpc: '2.0',
+        method: 'ide/diffAccepted',
+        params: {
+          filePath: diffInfo.originalFilePath,
+          content: modifiedContent,
+        },
+      }),
+    );
+  }
+
+  /**
+   * Called when a user cancels a diff view.
+   */
+  async cancelDiff(rightDocUri: vscode.Uri) {
+    const diffInfo = this.diffDocuments.get(rightDocUri.toString());
+    if (!diffInfo) {
+      this.log(`No diff info found for ${rightDocUri.toString()}`);
+      // Even if we don't have diff info, we should still close the editor.
+      await this.closeDiffEditor(rightDocUri);
+      return;
+    }
+
+    const rightDoc = await vscode.workspace.openTextDocument(rightDocUri);
+    const modifiedContent = rightDoc.getText();
+    await this.closeDiffEditor(rightDocUri);
+
+    this.onDidChangeEmitter.fire(
+      IdeDiffClosedNotificationSchema.parse({
+        jsonrpc: '2.0',
+        method: 'ide/diffClosed',
+        params: {
+          filePath: diffInfo.originalFilePath,
+          content: modifiedContent,
+        },
+      }),
+    );
+  }
+
+  private async onActiveEditorChange(editor: vscode.TextEditor | undefined) {
+    let isVisible = false;
+    if (editor) {
+      isVisible = this.diffDocuments.has(editor.document.uri.toString());
+      if (!isVisible) {
+        for (const document of this.diffDocuments.values()) {
+          if (document.originalFilePath === editor.document.uri.fsPath) {
+            isVisible = true;
+            break;
+          }
+        }
+      }
+    }
+    await vscode.commands.executeCommand(
+      'setContext',
+      'blackbox.diff.isVisible',
+      isVisible,
+    );
+  }
+
+  private addDiffDocument(uri: vscode.Uri, diffInfo: DiffInfo) {
+    this.diffDocuments.set(uri.toString(), diffInfo);
+  }
+
+  private async closeDiffEditor(rightDocUri: vscode.Uri) {
+    const diffInfo = this.diffDocuments.get(rightDocUri.toString());
+    await vscode.commands.executeCommand(
+      'setContext',
+      'blackbox.diff.isVisible',
+      false,
+    );
+
+    if (diffInfo) {
+      this.diffDocuments.delete(rightDocUri.toString());
+      this.diffContentProvider.deleteContent(rightDocUri);
+    }
+
+    // Find and close the tab corresponding to the diff view
+    for (const tabGroup of vscode.window.tabGroups.all) {
+      for (const tab of tabGroup.tabs) {
+        const input = tab.input as {
+          modified?: vscode.Uri;
+          original?: vscode.Uri;
+        };
+        if (input && input.modified?.toString() === rightDocUri.toString()) {
+          await vscode.window.tabGroups.close(tab);
+          return;
+        }
+      }
+    }
+  }
+}

package/src/extension.test.ts

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as vscode from 'vscode';
+import { activate } from './extension.js';
+
+vi.mock('vscode', () => ({
+  window: {
+    createOutputChannel: vi.fn(() => ({
+      appendLine: vi.fn(),
+    })),
+    showInformationMessage: vi.fn(),
+    createTerminal: vi.fn(() => ({
+      show: vi.fn(),
+      sendText: vi.fn(),
+    })),
+    onDidChangeActiveTextEditor: vi.fn(),
+    activeTextEditor: undefined,
+    tabGroups: {
+      all: [],
+      close: vi.fn(),
+    },
+    showTextDocument: vi.fn(),
+    showWorkspaceFolderPick: vi.fn(),
+  },
+  workspace: {
+    workspaceFolders: [],
+    onDidCloseTextDocument: vi.fn(),
+    registerTextDocumentContentProvider: vi.fn(),
+    onDidChangeWorkspaceFolders: vi.fn(),
+  },
+  commands: {
+    registerCommand: vi.fn(),
+    executeCommand: vi.fn(),
+  },
+  Uri: {
+    joinPath: vi.fn(),
+  },
+  ExtensionMode: {
+    Development: 1,
+    Production: 2,
+  },
+  EventEmitter: vi.fn(() => ({
+    event: vi.fn(),
+    fire: vi.fn(),
+    dispose: vi.fn(),
+  })),
+}));
+
+describe('activate', () => {
+  let context: vscode.ExtensionContext;
+
+  beforeEach(() => {
+    context = {
+      subscriptions: [],
+      environmentVariableCollection: {
+        replace: vi.fn(),
+      },
+      globalState: {
+        get: vi.fn(),
+        update: vi.fn(),
+      },
+      extensionUri: {
+        fsPath: '/path/to/extension',
+      },
+    } as unknown as vscode.ExtensionContext;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should show the info message on first activation', async () => {
+    const showInformationMessageMock = vi
+      .mocked(vscode.window.showInformationMessage)
+      .mockResolvedValue(undefined as never);
+    vi.mocked(context.globalState.get).mockReturnValue(undefined);
+    await activate(context);
+    expect(showInformationMessageMock).toHaveBeenCalledWith(
+      'Blackbox Code Companion extension successfully installed.',
+    );
+  });
+
+  it('should not show the info message on subsequent activations', async () => {
+    vi.mocked(context.globalState.get).mockReturnValue(true);
+    await activate(context);
+    expect(vscode.window.showInformationMessage).not.toHaveBeenCalled();
+  });
+
+  it('should launch Blackbox Code when the user clicks the button', async () => {
+    const showInformationMessageMock = vi
+      .mocked(vscode.window.showInformationMessage)
+      .mockResolvedValue('Run Blackbox Code' as never);
+    vi.mocked(context.globalState.get).mockReturnValue(undefined);
+    await activate(context);
+    expect(showInformationMessageMock).toHaveBeenCalled();
+    await new Promise(process.nextTick); // Wait for the promise to resolve
+    const commandCallback = vi
+      .mocked(vscode.commands.registerCommand)
+      .mock.calls.find((call) => call[0] === 'blackbox-cli.runBlackboxCode')?.[1];
+
+    expect(commandCallback).toBeDefined();
+  });
+});

package/src/extension.ts

@@ -0,0 +1,123 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode';
+import { IDEServer } from './ide-server.js';
+import { DiffContentProvider, DiffManager } from './diff-manager.js';
+import { createLogger } from './utils/logger.js';
+
+const INFO_MESSAGE_SHOWN_KEY = 'blackboxCodeInfoMessageShown';
+export const DIFF_SCHEME = 'blackbox-diff';
+
+let ideServer: IDEServer;
+let logger: vscode.OutputChannel;
+
+let log: (message: string) => void = () => {};
+
+export async function activate(context: vscode.ExtensionContext) {
+  logger = vscode.window.createOutputChannel('Blackbox Code Companion');
+  log = createLogger(context, logger);
+  log('Extension activated');
+
+  const diffContentProvider = new DiffContentProvider();
+  const diffManager = new DiffManager(log, diffContentProvider);
+
+  context.subscriptions.push(
+    vscode.workspace.onDidCloseTextDocument((doc) => {
+      if (doc.uri.scheme === DIFF_SCHEME) {
+        diffManager.cancelDiff(doc.uri);
+      }
+    }),
+    vscode.workspace.registerTextDocumentContentProvider(
+      DIFF_SCHEME,
+      diffContentProvider,
+    ),
+    vscode.commands.registerCommand('blackbox.diff.accept', (uri?: vscode.Uri) => {
+      const docUri = uri ?? vscode.window.activeTextEditor?.document.uri;
+      if (docUri && docUri.scheme === DIFF_SCHEME) {
+        diffManager.acceptDiff(docUri);
+      }
+    }),
+    vscode.commands.registerCommand('blackbox.diff.cancel', (uri?: vscode.Uri) => {
+      const docUri = uri ?? vscode.window.activeTextEditor?.document.uri;
+      if (docUri && docUri.scheme === DIFF_SCHEME) {
+        diffManager.cancelDiff(docUri);
+      }
+    }),
+  );
+
+  ideServer = new IDEServer(log, diffManager);
+  try {
+    await ideServer.start(context);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log(`Failed to start IDE server: ${message}`);
+  }
+
+  if (!context.globalState.get(INFO_MESSAGE_SHOWN_KEY)) {
+    void vscode.window.showInformationMessage(
+      'Blackbox Code Companion extension successfully installed.',
+    );
+    context.globalState.update(INFO_MESSAGE_SHOWN_KEY, true);
+  }
+
+  context.subscriptions.push(
+    vscode.workspace.onDidChangeWorkspaceFolders(() => {
+      ideServer.updateWorkspacePath();
+    }),
+    vscode.commands.registerCommand('blackbox-cli.runBlackboxCode', async () => {
+      const workspaceFolders = vscode.workspace.workspaceFolders;
+      if (!workspaceFolders || workspaceFolders.length === 0) {
+        vscode.window.showInformationMessage(
+          'No folder open. Please open a folder to run Blackbox Code.',
+        );
+        return;
+      }
+
+      let selectedFolder: vscode.WorkspaceFolder | undefined;
+      if (workspaceFolders.length === 1) {
+        selectedFolder = workspaceFolders[0];
+      } else {
+        selectedFolder = await vscode.window.showWorkspaceFolderPick({
+          placeHolder: 'Select a folder to run Blackbox Code in',
+        });
+      }
+
+      if (selectedFolder) {
+        const blackboxCmd = 'blackbox';
+        const terminal = vscode.window.createTerminal({
+          name: `Blackbox Code (${selectedFolder.name})`,
+          cwd: selectedFolder.uri.fsPath,
+        });
+        terminal.show();
+        terminal.sendText(blackboxCmd);
+      }
+    }),
+    vscode.commands.registerCommand('blackbox-cli.showNotices', async () => {
+      const noticePath = vscode.Uri.joinPath(
+        context.extensionUri,
+        'NOTICES.txt',
+      );
+      await vscode.window.showTextDocument(noticePath);
+    }),
+  );
+}
+
+export async function deactivate(): Promise<void> {
+  log('Extension deactivated');
+  try {
+    if (ideServer) {
+      await ideServer.stop();
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log(`Failed to stop IDE server during deactivation: ${message}`);
+  } finally {
+    if (logger) {
+      logger.dispose();
+    }
+  }
+}