Add files using upload-large-folder tool

projects/ui/DeepCode/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "pip" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

projects/ui/DeepCode/.github/pull_request_template.md

@@ -0,0 +1,32 @@
+<!--
+Thanks for contributing to DeepCode!
+
+Please ensure your pull request is ready for review before submitting.
+
+About this template
+
+This template helps contributors provide a clear and concise description of their changes. Feel free to adjust it as needed.
+-->
+
+## Description
+
+[Briefly describe the changes made in this pull request.]
+
+## Related Issues
+
+[Reference any related issues or tasks addressed by this pull request.]
+
+## Changes Made
+
+[List the specific changes made in this pull request.]
+
+## Checklist
+
+- [ ] Changes tested locally
+- [ ] Code reviewed
+- [ ] Documentation updated (if necessary)
+- [ ] Unit tests added (if applicable)
+
+## Additional Notes
+
+[Add any additional notes or context for the reviewer(s).]

projects/ui/qwen-code/packages/core/src/utils/filesearch/result-cache.ts

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Implements an in-memory cache for file search results.
+ * This cache optimizes subsequent searches by leveraging previously computed results.
+ */
+export class ResultCache {
+  private readonly cache: Map<string, string[]>;
+  private hits = 0;
+  private misses = 0;
+
+  constructor(private readonly allFiles: string[]) {
+    this.cache = new Map();
+  }
+
+  /**
+   * Retrieves cached search results for a given query, or provides a base set
+   * of files to search from.
+   * @param query The search query pattern.
+   * @returns An object containing the files to search and a boolean indicating
+   *          if the result is an exact cache hit.
+   */
+  async get(
+    query: string,
+  ): Promise<{ files: string[]; isExactMatch: boolean }> {
+    const isCacheHit = this.cache.has(query);
+
+    if (isCacheHit) {
+      this.hits++;
+      return { files: this.cache.get(query)!, isExactMatch: true };
+    }
+
+    this.misses++;
+
+    // This is the core optimization of the memory cache.
+    // If a user first searches for "foo", and then for "foobar",
+    // we don't need to search through all files again. We can start
+    // from the results of the "foo" search.
+    // This finds the most specific, already-cached query that is a prefix
+    // of the current query.
+    let bestBaseQuery = '';
+    for (const key of this.cache?.keys?.() ?? []) {
+      if (query.startsWith(key) && key.length > bestBaseQuery.length) {
+        bestBaseQuery = key;
+      }
+    }
+
+    const filesToSearch = bestBaseQuery
+      ? this.cache.get(bestBaseQuery)!
+      : this.allFiles;
+
+    return { files: filesToSearch, isExactMatch: false };
+  }
+
+  /**
+   * Stores search results in the cache.
+   * @param query The search query pattern.
+   * @param results The matching file paths to cache.
+   */
+  set(query: string, results: string[]): void {
+    this.cache.set(query, results);
+  }
+}

projects/ui/qwen-code/packages/test-utils/src/file-system-test-helpers.ts

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+
+/**
+ * Defines the structure of a virtual file system to be created for testing.
+ * Keys are file or directory names, and values can be:
+ * - A string: The content of a file.
+ * - A `FileSystemStructure` object: Represents a subdirectory with its own structure.
+ * - An array of strings or `FileSystemStructure` objects: Represents a directory
+ *   where strings are empty files and objects are subdirectories.
+ *
+ * @example
+ * // Example 1: Simple files and directories
+ * const structure1 = {
+ *   'file1.txt': 'Hello, world!',
+ *   'empty-dir': [],
+ *   'src': {
+ *     'main.js': '// Main application file',
+ *     'utils.ts': '// Utility functions',
+ *   },
+ * };
+ *
+ * @example
+ * // Example 2: Nested directories and empty files within an array
+ * const structure2 = {
+ *   'config.json': '{ "port": 3000 }',
+ *   'data': [
+ *     'users.csv',
+ *     'products.json',
+ *     {
+ *       'logs': [
+ *         'error.log',
+ *         'access.log',
+ *       ],
+ *     },
+ *   ],
+ * };
+ */
+export type FileSystemStructure = {
+  [name: string]:
+    | string
+    | FileSystemStructure
+    | Array<string | FileSystemStructure>;
+};
+
+/**
+ * Recursively creates files and directories based on the provided `FileSystemStructure`.
+ * @param dir The base directory where the structure will be created.
+ * @param structure The `FileSystemStructure` defining the files and directories.
+ */
+async function create(dir: string, structure: FileSystemStructure) {
+  for (const [name, content] of Object.entries(structure)) {
+    const newPath = path.join(dir, name);
+    if (typeof content === 'string') {
+      await fs.writeFile(newPath, content);
+    } else if (Array.isArray(content)) {
+      await fs.mkdir(newPath, { recursive: true });
+      for (const item of content) {
+        if (typeof item === 'string') {
+          await fs.writeFile(path.join(newPath, item), '');
+        } else {
+          await create(newPath, item as FileSystemStructure);
+        }
+      }
+    } else if (typeof content === 'object' && content !== null) {
+      await fs.mkdir(newPath, { recursive: true });
+      await create(newPath, content as FileSystemStructure);
+    }
+  }
+}
+
+/**
+ * Creates a temporary directory and populates it with a given file system structure.
+ * @param structure The `FileSystemStructure` to create within the temporary directory.
+ * @returns A promise that resolves to the absolute path of the created temporary directory.
+ */
+export async function createTmpDir(
+  structure: FileSystemStructure,
+): Promise<string> {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gemini-cli-test-'));
+  await create(tmpDir, structure);
+  return tmpDir;
+}
+
+/**
+ * Cleans up (deletes) a temporary directory and its contents.
+ * @param dir The absolute path to the temporary directory to clean up.
+ */
+export async function cleanupTmpDir(dir: string) {
+  await fs.rm(dir, { recursive: true, force: true });
+}

projects/ui/qwen-code/packages/test-utils/src/index.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export * from './file-system-test-helpers.js';

projects/ui/qwen-code/packages/vscode-ide-companion/.vscode/launch.json

@@ -0,0 +1,13 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Run Extension",
+      "type": "extensionHost",
+      "request": "launch",
+      "args": ["--extensionDevelopmentPath=${workspaceFolder}"],
+      "outFiles": ["${workspaceFolder}/out/**/*.js"],
+      "preLaunchTask": "${defaultBuildTask}"
+    }
+  ]
+}

projects/ui/qwen-code/packages/vscode-ide-companion/.vscode/tasks.json

@@ -0,0 +1,18 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "npm",
+      "script": "watch",
+      "problemMatcher": "$tsc-watch",
+      "isBackground": true,
+      "presentation": {
+        "reveal": "never"
+      },
+      "group": {
+        "kind": "build",
+        "isDefault": true
+      }
+    }
+  ]
+}

projects/ui/qwen-code/packages/vscode-ide-companion/scripts/generate-notices.js

@@ -0,0 +1,158 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const projectRoot = path.resolve(
+  path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..'),
+);
+const packagePath = path.join(projectRoot, 'packages', 'vscode-ide-companion');
+const noticeFilePath = path.join(packagePath, 'NOTICES.txt');
+
+async function getDependencyLicense(depName, depVersion) {
+  let depPackageJsonPath;
+  let licenseContent = 'License text not found.';
+  let repositoryUrl = 'No repository found';
+
+  try {
+    depPackageJsonPath = path.join(
+      projectRoot,
+      'node_modules',
+      depName,
+      'package.json',
+    );
+    if (!(await fs.stat(depPackageJsonPath).catch(() => false))) {
+      depPackageJsonPath = path.join(
+        packagePath,
+        'node_modules',
+        depName,
+        'package.json',
+      );
+    }
+
+    const depPackageJsonContent = await fs.readFile(
+      depPackageJsonPath,
+      'utf-8',
+    );
+    const depPackageJson = JSON.parse(depPackageJsonContent);
+
+    repositoryUrl = depPackageJson.repository?.url || repositoryUrl;
+
+    const packageDir = path.dirname(depPackageJsonPath);
+    const licenseFileCandidates = [
+      depPackageJson.licenseFile,
+      'LICENSE',
+      'LICENSE.md',
+      'LICENSE.txt',
+      'LICENSE-MIT.txt',
+    ].filter(Boolean);
+
+    let licenseFile;
+    for (const candidate of licenseFileCandidates) {
+      const potentialFile = path.join(packageDir, candidate);
+      if (await fs.stat(potentialFile).catch(() => false)) {
+        licenseFile = potentialFile;
+        break;
+      }
+    }
+
+    if (licenseFile) {
+      try {
+        licenseContent = await fs.readFile(licenseFile, 'utf-8');
+      } catch (e) {
+        console.warn(
+          `Warning: Failed to read license file for ${depName}: ${e.message}`,
+        );
+      }
+    } else {
+      console.warn(`Warning: Could not find license file for ${depName}`);
+    }
+  } catch (e) {
+    console.warn(
+      `Warning: Could not find package.json for ${depName}: ${e.message}`,
+    );
+  }
+
+  return {
+    name: depName,
+    version: depVersion,
+    repository: repositoryUrl,
+    license: licenseContent,
+  };
+}
+
+function collectDependencies(packageName, packageLock, dependenciesMap) {
+  if (dependenciesMap.has(packageName)) {
+    return;
+  }
+
+  const packageInfo = packageLock.packages[`node_modules/${packageName}`];
+  if (!packageInfo) {
+    console.warn(
+      `Warning: Could not find package info for ${packageName} in package-lock.json.`,
+    );
+    return;
+  }
+
+  dependenciesMap.set(packageName, packageInfo.version);
+
+  if (packageInfo.dependencies) {
+    for (const depName of Object.keys(packageInfo.dependencies)) {
+      collectDependencies(depName, packageLock, dependenciesMap);
+    }
+  }
+}
+
+async function main() {
+  try {
+    const packageJsonPath = path.join(packagePath, 'package.json');
+    const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8');
+    const packageJson = JSON.parse(packageJsonContent);
+
+    const packageLockJsonPath = path.join(projectRoot, 'package-lock.json');
+    const packageLockJsonContent = await fs.readFile(
+      packageLockJsonPath,
+      'utf-8',
+    );
+    const packageLockJson = JSON.parse(packageLockJsonContent);
+
+    const allDependencies = new Map();
+    const directDependencies = Object.keys(packageJson.dependencies);
+
+    for (const depName of directDependencies) {
+      collectDependencies(depName, packageLockJson, allDependencies);
+    }
+
+    const dependencyEntries = Array.from(allDependencies.entries());
+
+    const licensePromises = dependencyEntries.map(([depName, depVersion]) =>
+      getDependencyLicense(depName, depVersion),
+    );
+
+    const dependencyLicenses = await Promise.all(licensePromises);
+
+    let noticeText =
+      'This file contains third-party software notices and license terms.\n\n';
+
+    for (const dep of dependencyLicenses) {
+      noticeText +=
+        '============================================================\n';
+      noticeText += `${dep.name}@${dep.version}\n`;
+      noticeText += `(${dep.repository})\n\n`;
+      noticeText += `${dep.license}\n\n`;
+    }
+
+    await fs.writeFile(noticeFilePath, noticeText);
+    console.log(`NOTICES.txt generated at ${noticeFilePath}`);
+  } catch (error) {
+    console.error('Error generating NOTICES.txt:', error);
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);

projects/ui/qwen-code/packages/vscode-ide-companion/src/diff-manager.ts

@@ -0,0 +1,267 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  IdeDiffAcceptedNotificationSchema,
+  IdeDiffClosedNotificationSchema,
+} from '@qwen-code/qwen-code-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',
+      'qwen.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,
+      },
+    );
+    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',
+      'qwen.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',
+      'qwen.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;
+        }
+      }
+    }
+  }
+}

projects/ui/qwen-code/packages/vscode-ide-companion/src/extension-multi-folder.test.ts

@@ -0,0 +1,211 @@
+/**
+ * @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 * as path from 'path';
+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(),
+  },
+  workspace: {
+    workspaceFolders: [],
+    onDidCloseTextDocument: vi.fn(),
+    registerTextDocumentContentProvider: vi.fn(),
+    onDidChangeWorkspaceFolders: vi.fn(),
+  },
+  commands: {
+    registerCommand: vi.fn(),
+    executeCommand: vi.fn(),
+  },
+  Uri: {
+    joinPath: vi.fn(),
+    file: (path: string) => ({ fsPath: path }),
+  },
+  ExtensionMode: {
+    Development: 1,
+    Production: 2,
+  },
+  EventEmitter: vi.fn(() => ({
+    event: vi.fn(),
+    fire: vi.fn(),
+    dispose: vi.fn(),
+  })),
+}));
+
+describe('activate with multiple folders', () => {
+  let context: vscode.ExtensionContext;
+  let onDidChangeWorkspaceFoldersCallback: (
+    e: vscode.WorkspaceFoldersChangeEvent,
+  ) => void;
+
+  beforeEach(() => {
+    context = {
+      subscriptions: [],
+      environmentVariableCollection: {
+        replace: vi.fn(),
+      },
+      globalState: {
+        get: vi.fn().mockReturnValue(true),
+        update: vi.fn(),
+      },
+      extensionUri: {
+        fsPath: '/path/to/extension',
+      },
+    } as unknown as vscode.ExtensionContext;
+
+    vi.mocked(vscode.workspace.onDidChangeWorkspaceFolders).mockImplementation(
+      (callback) => {
+        onDidChangeWorkspaceFoldersCallback = callback;
+        return { dispose: vi.fn() };
+      },
+    );
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should set a single folder path', async () => {
+    const workspaceFoldersSpy = vi.spyOn(
+      vscode.workspace,
+      'workspaceFolders',
+      'get',
+    );
+    workspaceFoldersSpy.mockReturnValue([
+      { uri: { fsPath: '/foo/bar' } },
+    ] as vscode.WorkspaceFolder[]);
+
+    await activate(context);
+
+    expect(context.environmentVariableCollection.replace).toHaveBeenCalledWith(
+      'QWEN_CODE_IDE_WORKSPACE_PATH',
+      '/foo/bar',
+    );
+  });
+
+  it('should set multiple folder paths, separated by OS-specific path delimiter', async () => {
+    const workspaceFoldersSpy = vi.spyOn(
+      vscode.workspace,
+      'workspaceFolders',
+      'get',
+    );
+    workspaceFoldersSpy.mockReturnValue([
+      { uri: { fsPath: '/foo/bar' } },
+      { uri: { fsPath: '/baz/qux' } },
+    ] as vscode.WorkspaceFolder[]);
+
+    await activate(context);
+
+    expect(context.environmentVariableCollection.replace).toHaveBeenCalledWith(
+      'QWEN_CODE_IDE_WORKSPACE_PATH',
+      ['/foo/bar', '/baz/qux'].join(path.delimiter),
+    );
+  });
+
+  it('should set an empty string if no folders are open', async () => {
+    const workspaceFoldersSpy = vi.spyOn(
+      vscode.workspace,
+      'workspaceFolders',
+      'get',
+    );
+    workspaceFoldersSpy.mockReturnValue([]);
+
+    await activate(context);
+
+    expect(context.environmentVariableCollection.replace).toHaveBeenCalledWith(
+      'QWEN_CODE_IDE_WORKSPACE_PATH',
+      '',
+    );
+  });
+
+  it('should update the path when workspace folders change', async () => {
+    const workspaceFoldersSpy = vi.spyOn(
+      vscode.workspace,
+      'workspaceFolders',
+      'get',
+    );
+    workspaceFoldersSpy.mockReturnValue([
+      { uri: { fsPath: '/foo/bar' } },
+    ] as vscode.WorkspaceFolder[]);
+
+    await activate(context);
+
+    expect(context.environmentVariableCollection.replace).toHaveBeenCalledWith(
+      'QWEN_CODE_IDE_WORKSPACE_PATH',
+      '/foo/bar',
+    );
+
+    // Simulate adding a folder
+    workspaceFoldersSpy.mockReturnValue([
+      { uri: { fsPath: '/foo/bar' } },
+      { uri: { fsPath: '/baz/qux' } },
+    ] as vscode.WorkspaceFolder[]);
+    onDidChangeWorkspaceFoldersCallback({
+      added: [{ uri: { fsPath: '/baz/qux' } } as vscode.WorkspaceFolder],
+      removed: [],
+    });
+
+    expect(context.environmentVariableCollection.replace).toHaveBeenCalledWith(
+      'QWEN_CODE_IDE_WORKSPACE_PATH',
+      ['/foo/bar', '/baz/qux'].join(path.delimiter),
+    );
+
+    // Simulate removing a folder
+    workspaceFoldersSpy.mockReturnValue([
+      { uri: { fsPath: '/baz/qux' } },
+    ] as vscode.WorkspaceFolder[]);
+    onDidChangeWorkspaceFoldersCallback({
+      added: [],
+      removed: [{ uri: { fsPath: '/foo/bar' } } as vscode.WorkspaceFolder],
+    });
+
+    expect(context.environmentVariableCollection.replace).toHaveBeenCalledWith(
+      'QWEN_CODE_IDE_WORKSPACE_PATH',
+      '/baz/qux',
+    );
+  });
+
+  it.skipIf(process.platform !== 'win32')(
+    'should handle windows paths',
+    async () => {
+      const workspaceFoldersSpy = vi.spyOn(
+        vscode.workspace,
+        'workspaceFolders',
+        'get',
+      );
+      workspaceFoldersSpy.mockReturnValue([
+        { uri: { fsPath: 'c:/foo/bar' } },
+        { uri: { fsPath: 'd:/baz/qux' } },
+      ] as vscode.WorkspaceFolder[]);
+
+      await activate(context);
+
+      expect(
+        context.environmentVariableCollection.replace,
+      ).toHaveBeenCalledWith(
+        'QWEN_CODE_IDE_WORKSPACE_PATH',
+        'c:/foo/bar;d:/baz/qux',
+      );
+    },
+  );
+});

projects/ui/qwen-code/packages/vscode-ide-companion/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(
+      'Qwen 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 Qwen Code when the user clicks the button', async () => {
+    const showInformationMessageMock = vi
+      .mocked(vscode.window.showInformationMessage)
+      .mockResolvedValue('Run Qwen 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] === 'qwen-code.runQwenCode')?.[1];
+
+    expect(commandCallback).toBeDefined();
+  });
+});

projects/ui/qwen-code/packages/vscode-ide-companion/src/extension.ts

@@ -0,0 +1,145 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode';
+import * as path from 'path';
+import { IDEServer } from './ide-server.js';
+import { DiffContentProvider, DiffManager } from './diff-manager.js';
+import { createLogger } from './utils/logger.js';
+
+const INFO_MESSAGE_SHOWN_KEY = 'qwenCodeInfoMessageShown';
+const IDE_WORKSPACE_PATH_ENV_VAR = 'QWEN_CODE_IDE_WORKSPACE_PATH';
+export const DIFF_SCHEME = 'qwen-diff';
+
+let ideServer: IDEServer;
+let logger: vscode.OutputChannel;
+
+let log: (message: string) => void = () => {};
+
+function updateWorkspacePath(context: vscode.ExtensionContext) {
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+  if (workspaceFolders && workspaceFolders.length > 0) {
+    const workspacePaths = workspaceFolders
+      .map((folder) => folder.uri.fsPath)
+      .join(path.delimiter);
+    context.environmentVariableCollection.replace(
+      IDE_WORKSPACE_PATH_ENV_VAR,
+      workspacePaths,
+    );
+  } else {
+    context.environmentVariableCollection.replace(
+      IDE_WORKSPACE_PATH_ENV_VAR,
+      '',
+    );
+  }
+}
+
+export async function activate(context: vscode.ExtensionContext) {
+  logger = vscode.window.createOutputChannel('Qwen Code Companion');
+  log = createLogger(context, logger);
+  log('Extension activated');
+
+  updateWorkspacePath(context);
+
+  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('qwen.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('qwen.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(
+      'Qwen Code Companion extension successfully installed.',
+    );
+    context.globalState.update(INFO_MESSAGE_SHOWN_KEY, true);
+  }
+
+  context.subscriptions.push(
+    vscode.workspace.onDidChangeWorkspaceFolders(() => {
+      updateWorkspacePath(context);
+    }),
+    vscode.commands.registerCommand('qwen-code.runQwenCode', async () => {
+      const workspaceFolders = vscode.workspace.workspaceFolders;
+      if (!workspaceFolders || workspaceFolders.length === 0) {
+        vscode.window.showInformationMessage(
+          'No folder open. Please open a folder to run Qwen 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 Qwen Code in',
+        });
+      }
+
+      if (selectedFolder) {
+        const qwenCmd = 'qwen';
+        const terminal = vscode.window.createTerminal({
+          name: `Qwen Code (${selectedFolder.name})`,
+          cwd: selectedFolder.uri.fsPath,
+        });
+        terminal.show();
+        terminal.sendText(qwenCmd);
+      }
+    }),
+    vscode.commands.registerCommand('qwen-code.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();
+    }
+  }
+}

projects/ui/qwen-code/packages/vscode-ide-companion/src/ide-server.ts

@@ -0,0 +1,301 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode';
+import { IdeContextNotificationSchema } from '@qwen-code/qwen-code-core';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import express, { type Request, type Response } from 'express';
+import { randomUUID } from 'node:crypto';
+import { type Server as HTTPServer } from 'node:http';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import { z } from 'zod';
+import { DiffManager } from './diff-manager.js';
+import { OpenFilesManager } from './open-files-manager.js';
+
+const MCP_SESSION_ID_HEADER = 'mcp-session-id';
+const IDE_SERVER_PORT_ENV_VAR = 'QWEN_CODE_IDE_SERVER_PORT';
+
+function sendIdeContextUpdateNotification(
+  transport: StreamableHTTPServerTransport,
+  log: (message: string) => void,
+  openFilesManager: OpenFilesManager,
+) {
+  const ideContext = openFilesManager.state;
+
+  const notification = IdeContextNotificationSchema.parse({
+    jsonrpc: '2.0',
+    method: 'ide/contextUpdate',
+    params: ideContext,
+  });
+
+  log(
+    `Sending IDE context update notification: ${JSON.stringify(
+      notification,
+      null,
+      2,
+    )}`,
+  );
+  transport.send(notification);
+}
+
+export class IDEServer {
+  private server: HTTPServer | undefined;
+  private context: vscode.ExtensionContext | undefined;
+  private log: (message: string) => void;
+  private portFile: string;
+  diffManager: DiffManager;
+
+  constructor(log: (message: string) => void, diffManager: DiffManager) {
+    this.log = log;
+    this.diffManager = diffManager;
+    this.portFile = path.join(
+      os.tmpdir(),
+      `gemini-ide-server-${process.ppid}.json`,
+    );
+  }
+
+  async start(context: vscode.ExtensionContext) {
+    this.context = context;
+    const sessionsWithInitialNotification = new Set<string>();
+    const transports: { [sessionId: string]: StreamableHTTPServerTransport } =
+      {};
+
+    const app = express();
+    app.use(express.json());
+    const mcpServer = createMcpServer(this.diffManager);
+
+    const openFilesManager = new OpenFilesManager(context);
+    const onDidChangeSubscription = openFilesManager.onDidChange(() => {
+      for (const transport of Object.values(transports)) {
+        sendIdeContextUpdateNotification(
+          transport,
+          this.log.bind(this),
+          openFilesManager,
+        );
+      }
+    });
+    context.subscriptions.push(onDidChangeSubscription);
+    const onDidChangeDiffSubscription = this.diffManager.onDidChange(
+      (notification) => {
+        for (const transport of Object.values(transports)) {
+          transport.send(notification);
+        }
+      },
+    );
+    context.subscriptions.push(onDidChangeDiffSubscription);
+
+    app.post('/mcp', async (req: Request, res: Response) => {
+      const sessionId = req.headers[MCP_SESSION_ID_HEADER] as
+        | string
+        | undefined;
+      let transport: StreamableHTTPServerTransport;
+
+      if (sessionId && transports[sessionId]) {
+        transport = transports[sessionId];
+      } else if (!sessionId && isInitializeRequest(req.body)) {
+        transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID(),
+          onsessioninitialized: (newSessionId) => {
+            this.log(`New session initialized: ${newSessionId}`);
+            transports[newSessionId] = transport;
+          },
+        });
+        const keepAlive = setInterval(() => {
+          try {
+            transport.send({ jsonrpc: '2.0', method: 'ping' });
+          } catch (e) {
+            this.log(
+              'Failed to send keep-alive ping, cleaning up interval.' + e,
+            );
+            clearInterval(keepAlive);
+          }
+        }, 60000); // 60 sec
+
+        transport.onclose = () => {
+          clearInterval(keepAlive);
+          if (transport.sessionId) {
+            this.log(`Session closed: ${transport.sessionId}`);
+            sessionsWithInitialNotification.delete(transport.sessionId);
+            delete transports[transport.sessionId];
+          }
+        };
+        mcpServer.connect(transport);
+      } else {
+        this.log(
+          'Bad Request: No valid session ID provided for non-initialize request.',
+        );
+        res.status(400).json({
+          jsonrpc: '2.0',
+          error: {
+            code: -32000,
+            message:
+              'Bad Request: No valid session ID provided for non-initialize request.',
+          },
+          id: null,
+        });
+        return;
+      }
+
+      try {
+        await transport.handleRequest(req, res, req.body);
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : 'Unknown error';
+        this.log(`Error handling MCP request: ${errorMessage}`);
+        if (!res.headersSent) {
+          res.status(500).json({
+            jsonrpc: '2.0' as const,
+            error: {
+              code: -32603,
+              message: 'Internal server error',
+            },
+            id: null,
+          });
+        }
+      }
+    });
+
+    const handleSessionRequest = async (req: Request, res: Response) => {
+      const sessionId = req.headers[MCP_SESSION_ID_HEADER] as
+        | string
+        | undefined;
+      if (!sessionId || !transports[sessionId]) {
+        this.log('Invalid or missing session ID');
+        res.status(400).send('Invalid or missing session ID');
+        return;
+      }
+
+      const transport = transports[sessionId];
+      try {
+        await transport.handleRequest(req, res);
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : 'Unknown error';
+        this.log(`Error handling session request: ${errorMessage}`);
+        if (!res.headersSent) {
+          res.status(400).send('Bad Request');
+        }
+      }
+
+      if (!sessionsWithInitialNotification.has(sessionId)) {
+        sendIdeContextUpdateNotification(
+          transport,
+          this.log.bind(this),
+          openFilesManager,
+        );
+        sessionsWithInitialNotification.add(sessionId);
+      }
+    };
+
+    app.get('/mcp', handleSessionRequest);
+
+    this.server = app.listen(0, () => {
+      const address = (this.server as HTTPServer).address();
+      if (address && typeof address !== 'string') {
+        const port = address.port;
+        context.environmentVariableCollection.replace(
+          IDE_SERVER_PORT_ENV_VAR,
+          port.toString(),
+        );
+        this.log(`IDE server listening on port ${port}`);
+        fs.writeFile(this.portFile, JSON.stringify({ port })).catch((err) => {
+          this.log(`Failed to write port to file: ${err}`);
+        });
+        this.log(this.portFile);
+      }
+    });
+  }
+
+  async stop(): Promise<void> {
+    if (this.server) {
+      await new Promise<void>((resolve, reject) => {
+        this.server!.close((err?: Error) => {
+          if (err) {
+            this.log(`Error shutting down IDE server: ${err.message}`);
+            return reject(err);
+          }
+          this.log(`IDE server shut down`);
+          resolve();
+        });
+      });
+      this.server = undefined;
+    }
+
+    if (this.context) {
+      this.context.environmentVariableCollection.clear();
+    }
+    try {
+      await fs.unlink(this.portFile);
+    } catch (_err) {
+      // Ignore errors if the file doesn't exist.
+    }
+  }
+}
+
+const createMcpServer = (diffManager: DiffManager) => {
+  const server = new McpServer(
+    {
+      name: 'qwen-code-companion-mcp-server',
+      version: '1.0.0',
+    },
+    { capabilities: { logging: {} } },
+  );
+  server.registerTool(
+    'openDiff',
+    {
+      description:
+        '(IDE Tool) Open a diff view to create or modify a file. Returns a notification once the diff has been accepted or rejcted.',
+      inputSchema: z.object({
+        filePath: z.string(),
+        // TODO(chrstn): determine if this should be required or not.
+        newContent: z.string().optional(),
+      }).shape,
+    },
+    async ({
+      filePath,
+      newContent,
+    }: {
+      filePath: string;
+      newContent?: string;
+    }) => {
+      await diffManager.showDiff(filePath, newContent ?? '');
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Showing diff for ${filePath}`,
+          },
+        ],
+      };
+    },
+  );
+  server.registerTool(
+    'closeDiff',
+    {
+      description: '(IDE Tool) Close an open diff view for a specific file.',
+      inputSchema: z.object({
+        filePath: z.string(),
+      }).shape,
+    },
+    async ({ filePath }: { filePath: string }) => {
+      const content = await diffManager.closeDiff(filePath);
+      const response = { content: content ?? undefined };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(response),
+          },
+        ],
+      };
+    },
+  );
+  return server;
+};

projects/ui/qwen-code/packages/vscode-ide-companion/src/open-files-manager.test.ts

@@ -0,0 +1,440 @@
+/**
+ * @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 { OpenFilesManager, MAX_FILES } from './open-files-manager.js';
+
+vi.mock('vscode', () => ({
+  EventEmitter: vi.fn(() => {
+    const listeners: Array<(e: void) => unknown> = [];
+    return {
+      event: vi.fn((listener) => {
+        listeners.push(listener);
+        return { dispose: vi.fn() };
+      }),
+      fire: vi.fn(() => {
+        listeners.forEach((listener) => listener(undefined));
+      }),
+      dispose: vi.fn(),
+    };
+  }),
+  window: {
+    onDidChangeActiveTextEditor: vi.fn(),
+    onDidChangeTextEditorSelection: vi.fn(),
+  },
+  workspace: {
+    onDidDeleteFiles: vi.fn(),
+    onDidCloseTextDocument: vi.fn(),
+    onDidRenameFiles: vi.fn(),
+  },
+  Uri: {
+    file: (path: string) => ({
+      fsPath: path,
+      scheme: 'file',
+    }),
+  },
+  TextEditorSelectionChangeKind: {
+    Mouse: 2,
+  },
+}));
+
+describe('OpenFilesManager', () => {
+  let context: vscode.ExtensionContext;
+  let onDidChangeActiveTextEditorListener: (
+    editor: vscode.TextEditor | undefined,
+  ) => void;
+  let onDidChangeTextEditorSelectionListener: (
+    e: vscode.TextEditorSelectionChangeEvent,
+  ) => void;
+  let onDidDeleteFilesListener: (e: vscode.FileDeleteEvent) => void;
+  let onDidCloseTextDocumentListener: (doc: vscode.TextDocument) => void;
+  let onDidRenameFilesListener: (e: vscode.FileRenameEvent) => void;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+
+    vi.mocked(vscode.window.onDidChangeActiveTextEditor).mockImplementation(
+      (listener) => {
+        onDidChangeActiveTextEditorListener = listener;
+        return { dispose: vi.fn() };
+      },
+    );
+    vi.mocked(vscode.window.onDidChangeTextEditorSelection).mockImplementation(
+      (listener) => {
+        onDidChangeTextEditorSelectionListener = listener;
+        return { dispose: vi.fn() };
+      },
+    );
+    vi.mocked(vscode.workspace.onDidDeleteFiles).mockImplementation(
+      (listener) => {
+        onDidDeleteFilesListener = listener;
+        return { dispose: vi.fn() };
+      },
+    );
+    vi.mocked(vscode.workspace.onDidCloseTextDocument).mockImplementation(
+      (listener) => {
+        onDidCloseTextDocumentListener = listener;
+        return { dispose: vi.fn() };
+      },
+    );
+    vi.mocked(vscode.workspace.onDidRenameFiles).mockImplementation(
+      (listener) => {
+        onDidRenameFilesListener = listener;
+        return { dispose: vi.fn() };
+      },
+    );
+
+    context = {
+      subscriptions: [],
+    } as unknown as vscode.ExtensionContext;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  const getUri = (path: string) =>
+    vscode.Uri.file(path) as unknown as vscode.Uri;
+
+  const addFile = (uri: vscode.Uri) => {
+    onDidChangeActiveTextEditorListener({
+      document: {
+        uri,
+        getText: () => '',
+      },
+      selection: {
+        active: { line: 0, character: 0 },
+      },
+    } as unknown as vscode.TextEditor);
+  };
+
+  it('adds a file to the list', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri = getUri('/test/file1.txt');
+    addFile(uri);
+    await vi.advanceTimersByTimeAsync(100);
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(1);
+    expect(manager.state.workspaceState!.openFiles![0].path).toBe(
+      '/test/file1.txt',
+    );
+  });
+
+  it('moves an existing file to the top', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri1 = getUri('/test/file1.txt');
+    const uri2 = getUri('/test/file2.txt');
+    addFile(uri1);
+    addFile(uri2);
+    addFile(uri1);
+    await vi.advanceTimersByTimeAsync(100);
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(2);
+    expect(manager.state.workspaceState!.openFiles![0].path).toBe(
+      '/test/file1.txt',
+    );
+  });
+
+  it('does not exceed the max number of files', async () => {
+    const manager = new OpenFilesManager(context);
+    for (let i = 0; i < MAX_FILES + 5; i++) {
+      const uri = getUri(`/test/file${i}.txt`);
+      addFile(uri);
+    }
+    await vi.advanceTimersByTimeAsync(100);
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(MAX_FILES);
+    expect(manager.state.workspaceState!.openFiles![0].path).toBe(
+      `/test/file${MAX_FILES + 4}.txt`,
+    );
+    expect(manager.state.workspaceState!.openFiles![MAX_FILES - 1].path).toBe(
+      `/test/file5.txt`,
+    );
+  });
+
+  it('fires onDidChange when a file is added', async () => {
+    const manager = new OpenFilesManager(context);
+    const onDidChangeSpy = vi.fn();
+    manager.onDidChange(onDidChangeSpy);
+
+    const uri = getUri('/test/file1.txt');
+    addFile(uri);
+
+    await vi.advanceTimersByTimeAsync(100);
+    expect(onDidChangeSpy).toHaveBeenCalled();
+  });
+
+  it('removes a file when it is closed', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri = getUri('/test/file1.txt');
+    addFile(uri);
+    await vi.advanceTimersByTimeAsync(100);
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(1);
+
+    onDidCloseTextDocumentListener({ uri } as vscode.TextDocument);
+    await vi.advanceTimersByTimeAsync(100);
+
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(0);
+  });
+
+  it('fires onDidChange when a file is removed', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri = getUri('/test/file1.txt');
+    addFile(uri);
+    await vi.advanceTimersByTimeAsync(100);
+
+    const onDidChangeSpy = vi.fn();
+    manager.onDidChange(onDidChangeSpy);
+
+    onDidCloseTextDocumentListener({ uri } as vscode.TextDocument);
+    await vi.advanceTimersByTimeAsync(100);
+
+    expect(onDidChangeSpy).toHaveBeenCalled();
+  });
+
+  it('removes a file when it is deleted', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri1 = getUri('/test/file1.txt');
+    const uri2 = getUri('/test/file2.txt');
+    addFile(uri1);
+    addFile(uri2);
+    await vi.advanceTimersByTimeAsync(100);
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(2);
+
+    onDidDeleteFilesListener({ files: [uri1] });
+    await vi.advanceTimersByTimeAsync(100);
+
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(1);
+    expect(manager.state.workspaceState!.openFiles![0].path).toBe(
+      '/test/file2.txt',
+    );
+  });
+
+  it('fires onDidChange when a file is deleted', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri = getUri('/test/file1.txt');
+    addFile(uri);
+    await vi.advanceTimersByTimeAsync(100);
+
+    const onDidChangeSpy = vi.fn();
+    manager.onDidChange(onDidChangeSpy);
+
+    onDidDeleteFilesListener({ files: [uri] });
+    await vi.advanceTimersByTimeAsync(100);
+
+    expect(onDidChangeSpy).toHaveBeenCalled();
+  });
+
+  it('removes multiple files when they are deleted', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri1 = getUri('/test/file1.txt');
+    const uri2 = getUri('/test/file2.txt');
+    const uri3 = getUri('/test/file3.txt');
+    addFile(uri1);
+    addFile(uri2);
+    addFile(uri3);
+    await vi.advanceTimersByTimeAsync(100);
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(3);
+
+    onDidDeleteFilesListener({ files: [uri1, uri3] });
+    await vi.advanceTimersByTimeAsync(100);
+
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(1);
+    expect(manager.state.workspaceState!.openFiles![0].path).toBe(
+      '/test/file2.txt',
+    );
+  });
+
+  it('fires onDidChange only once when adding an existing file', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri = getUri('/test/file1.txt');
+    addFile(uri);
+    await vi.advanceTimersByTimeAsync(100);
+
+    const onDidChangeSpy = vi.fn();
+    manager.onDidChange(onDidChangeSpy);
+
+    addFile(uri);
+    await vi.advanceTimersByTimeAsync(100);
+    expect(onDidChangeSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('updates the file when it is renamed', async () => {
+    const manager = new OpenFilesManager(context);
+    const oldUri = getUri('/test/file1.txt');
+    const newUri = getUri('/test/file2.txt');
+    addFile(oldUri);
+    await vi.advanceTimersByTimeAsync(100);
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(1);
+    expect(manager.state.workspaceState!.openFiles![0].path).toBe(
+      '/test/file1.txt',
+    );
+
+    onDidRenameFilesListener({ files: [{ oldUri, newUri }] });
+    await vi.advanceTimersByTimeAsync(100);
+
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(1);
+    expect(manager.state.workspaceState!.openFiles![0].path).toBe(
+      '/test/file2.txt',
+    );
+  });
+
+  it('adds a file when the active editor changes', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri = getUri('/test/file1.txt');
+
+    addFile(uri);
+    await vi.advanceTimersByTimeAsync(100);
+
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(1);
+    expect(manager.state.workspaceState!.openFiles![0].path).toBe(
+      '/test/file1.txt',
+    );
+  });
+
+  it('updates the cursor position on selection change', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri = getUri('/test/file1.txt');
+    addFile(uri);
+    await vi.advanceTimersByTimeAsync(100);
+
+    const selection = {
+      active: { line: 10, character: 20 },
+    } as vscode.Selection;
+
+    onDidChangeTextEditorSelectionListener({
+      textEditor: {
+        document: { uri, getText: () => '' },
+        selection,
+      } as vscode.TextEditor,
+      selections: [selection],
+      kind: vscode.TextEditorSelectionChangeKind.Mouse,
+    });
+
+    await vi.advanceTimersByTimeAsync(100);
+
+    const file = manager.state.workspaceState!.openFiles![0];
+    expect(file.cursor).toEqual({ line: 11, character: 20 });
+  });
+
+  it('updates the selected text on selection change', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri = getUri('/test/file1.txt');
+    const selection = {
+      active: { line: 10, character: 20 },
+    } as vscode.Selection;
+
+    // We need to override the mock for getText for this test
+    const textEditor = {
+      document: {
+        uri,
+        getText: vi.fn().mockReturnValue('selected text'),
+      },
+      selection,
+    } as unknown as vscode.TextEditor;
+
+    onDidChangeActiveTextEditorListener(textEditor);
+    await vi.advanceTimersByTimeAsync(100);
+
+    onDidChangeTextEditorSelectionListener({
+      textEditor,
+      selections: [selection],
+      kind: vscode.TextEditorSelectionChangeKind.Mouse,
+    });
+
+    await vi.advanceTimersByTimeAsync(100);
+
+    const file = manager.state.workspaceState!.openFiles![0];
+    expect(file.selectedText).toBe('selected text');
+    expect(textEditor.document.getText).toHaveBeenCalledWith(selection);
+  });
+
+  it('truncates long selected text', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri = getUri('/test/file1.txt');
+    const longText = 'a'.repeat(20000);
+    const truncatedText = longText.substring(0, 16384) + '... [TRUNCATED]';
+
+    const selection = {
+      active: { line: 10, character: 20 },
+    } as vscode.Selection;
+
+    const textEditor = {
+      document: {
+        uri,
+        getText: vi.fn().mockReturnValue(longText),
+      },
+      selection,
+    } as unknown as vscode.TextEditor;
+
+    onDidChangeActiveTextEditorListener(textEditor);
+    await vi.advanceTimersByTimeAsync(100);
+
+    onDidChangeTextEditorSelectionListener({
+      textEditor,
+      selections: [selection],
+      kind: vscode.TextEditorSelectionChangeKind.Mouse,
+    });
+
+    await vi.advanceTimersByTimeAsync(100);
+
+    const file = manager.state.workspaceState!.openFiles![0];
+    expect(file.selectedText).toBe(truncatedText);
+  });
+
+  it('deactivates the previously active file', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri1 = getUri('/test/file1.txt');
+    const uri2 = getUri('/test/file2.txt');
+
+    addFile(uri1);
+    await vi.advanceTimersByTimeAsync(100);
+
+    const selection = {
+      active: { line: 10, character: 20 },
+    } as vscode.Selection;
+
+    onDidChangeTextEditorSelectionListener({
+      textEditor: {
+        document: { uri: uri1, getText: () => '' },
+        selection,
+      } as vscode.TextEditor,
+      selections: [selection],
+      kind: vscode.TextEditorSelectionChangeKind.Mouse,
+    });
+    await vi.advanceTimersByTimeAsync(100);
+
+    let file1 = manager.state.workspaceState!.openFiles![0];
+    expect(file1.isActive).toBe(true);
+    expect(file1.cursor).toBeDefined();
+
+    addFile(uri2);
+    await vi.advanceTimersByTimeAsync(100);
+
+    file1 = manager.state.workspaceState!.openFiles!.find(
+      (f) => f.path === '/test/file1.txt',
+    )!;
+    const file2 = manager.state.workspaceState!.openFiles![0];
+
+    expect(file1.isActive).toBe(false);
+    expect(file1.cursor).toBeUndefined();
+    expect(file1.selectedText).toBeUndefined();
+    expect(file2.path).toBe('/test/file2.txt');
+    expect(file2.isActive).toBe(true);
+  });
+
+  it('ignores non-file URIs', async () => {
+    const manager = new OpenFilesManager(context);
+    const uri = {
+      fsPath: '/test/file1.txt',
+      scheme: 'untitled',
+    } as vscode.Uri;
+
+    addFile(uri);
+    await vi.advanceTimersByTimeAsync(100);
+
+    expect(manager.state.workspaceState!.openFiles).toHaveLength(0);
+  });
+});

projects/ui/qwen-code/packages/vscode-ide-companion/src/open-files-manager.ts

@@ -0,0 +1,178 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode';
+import type { File, IdeContext } from '@qwen-code/qwen-code-core';
+
+export const MAX_FILES = 10;
+const MAX_SELECTED_TEXT_LENGTH = 16384; // 16 KiB limit
+
+/**
+ * Keeps track of the workspace state, including open files, cursor position, and selected text.
+ */
+export class OpenFilesManager {
+  private readonly onDidChangeEmitter = new vscode.EventEmitter<void>();
+  readonly onDidChange = this.onDidChangeEmitter.event;
+  private debounceTimer: NodeJS.Timeout | undefined;
+  private openFiles: File[] = [];
+
+  constructor(private readonly context: vscode.ExtensionContext) {
+    const editorWatcher = vscode.window.onDidChangeActiveTextEditor(
+      (editor) => {
+        if (editor && this.isFileUri(editor.document.uri)) {
+          this.addOrMoveToFront(editor);
+          this.fireWithDebounce();
+        }
+      },
+    );
+
+    const selectionWatcher = vscode.window.onDidChangeTextEditorSelection(
+      (event) => {
+        if (this.isFileUri(event.textEditor.document.uri)) {
+          this.updateActiveContext(event.textEditor);
+          this.fireWithDebounce();
+        }
+      },
+    );
+
+    const closeWatcher = vscode.workspace.onDidCloseTextDocument((document) => {
+      if (this.isFileUri(document.uri)) {
+        this.remove(document.uri);
+        this.fireWithDebounce();
+      }
+    });
+
+    const deleteWatcher = vscode.workspace.onDidDeleteFiles((event) => {
+      for (const uri of event.files) {
+        if (this.isFileUri(uri)) {
+          this.remove(uri);
+        }
+      }
+      this.fireWithDebounce();
+    });
+
+    const renameWatcher = vscode.workspace.onDidRenameFiles((event) => {
+      for (const { oldUri, newUri } of event.files) {
+        if (this.isFileUri(oldUri)) {
+          if (this.isFileUri(newUri)) {
+            this.rename(oldUri, newUri);
+          } else {
+            // The file was renamed to a non-file URI, so we should remove it.
+            this.remove(oldUri);
+          }
+        }
+      }
+      this.fireWithDebounce();
+    });
+
+    context.subscriptions.push(
+      editorWatcher,
+      selectionWatcher,
+      closeWatcher,
+      deleteWatcher,
+      renameWatcher,
+    );
+
+    // Just add current active file on start-up.
+    if (
+      vscode.window.activeTextEditor &&
+      this.isFileUri(vscode.window.activeTextEditor.document.uri)
+    ) {
+      this.addOrMoveToFront(vscode.window.activeTextEditor);
+    }
+  }
+
+  private isFileUri(uri: vscode.Uri): boolean {
+    return uri.scheme === 'file';
+  }
+
+  private addOrMoveToFront(editor: vscode.TextEditor) {
+    // Deactivate previous active file
+    const currentActive = this.openFiles.find((f) => f.isActive);
+    if (currentActive) {
+      currentActive.isActive = false;
+      currentActive.cursor = undefined;
+      currentActive.selectedText = undefined;
+    }
+
+    // Remove if it exists
+    const index = this.openFiles.findIndex(
+      (f) => f.path === editor.document.uri.fsPath,
+    );
+    if (index !== -1) {
+      this.openFiles.splice(index, 1);
+    }
+
+    // Add to the front as active
+    this.openFiles.unshift({
+      path: editor.document.uri.fsPath,
+      timestamp: Date.now(),
+      isActive: true,
+    });
+
+    // Enforce max length
+    if (this.openFiles.length > MAX_FILES) {
+      this.openFiles.pop();
+    }
+
+    this.updateActiveContext(editor);
+  }
+
+  private remove(uri: vscode.Uri) {
+    const index = this.openFiles.findIndex((f) => f.path === uri.fsPath);
+    if (index !== -1) {
+      this.openFiles.splice(index, 1);
+    }
+  }
+
+  private rename(oldUri: vscode.Uri, newUri: vscode.Uri) {
+    const index = this.openFiles.findIndex((f) => f.path === oldUri.fsPath);
+    if (index !== -1) {
+      this.openFiles[index].path = newUri.fsPath;
+    }
+  }
+
+  private updateActiveContext(editor: vscode.TextEditor) {
+    const file = this.openFiles.find(
+      (f) => f.path === editor.document.uri.fsPath,
+    );
+    if (!file || !file.isActive) {
+      return;
+    }
+
+    file.cursor = editor.selection.active
+      ? {
+          line: editor.selection.active.line + 1,
+          character: editor.selection.active.character,
+        }
+      : undefined;
+
+    let selectedText: string | undefined =
+      editor.document.getText(editor.selection) || undefined;
+    if (selectedText && selectedText.length > MAX_SELECTED_TEXT_LENGTH) {
+      selectedText =
+        selectedText.substring(0, MAX_SELECTED_TEXT_LENGTH) + '... [TRUNCATED]';
+    }
+    file.selectedText = selectedText;
+  }
+
+  private fireWithDebounce() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.onDidChangeEmitter.fire();
+    }, 50); // 50ms
+  }
+
+  get state(): IdeContext {
+    return {
+      workspaceState: {
+        openFiles: [...this.openFiles],
+      },
+    };
+  }
+}

projects/ui/qwen-code/packages/vscode-ide-companion/src/utils/logger.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode';
+
+export function createLogger(
+  context: vscode.ExtensionContext,
+  logger: vscode.OutputChannel,
+) {
+  return (message: string) => {
+    if (context.extensionMode === vscode.ExtensionMode.Development) {
+      logger.appendLine(message);
+    }
+  };
+}

projects/ui/qwen-code/scripts/tests/get-release-version.test.js

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { getReleaseVersion } from '../get-release-version';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+
+vi.mock('child_process', () => ({
+  execSync: vi.fn(),
+}));
+
+vi.mock('fs', async (importOriginal) => {
+  const mod = await importOriginal();
+  return {
+    ...mod,
+    default: {
+      ...mod.default,
+      readFileSync: vi.fn(),
+    },
+  };
+});
+
+describe('getReleaseVersion', () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    vi.resetModules();
+    process.env = { ...originalEnv };
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+    vi.clearAllMocks();
+    vi.useRealTimers();
+  });
+
+  it('should calculate nightly version when IS_NIGHTLY is true', () => {
+    process.env.IS_NIGHTLY = 'true';
+    vi.mocked(fs.default.readFileSync).mockReturnValue(
+      JSON.stringify({ version: '0.1.0' }),
+    );
+    // Mock git tag command to return empty (no existing nightly tags)
+    vi.mocked(execSync).mockReturnValue('');
+    const { releaseTag, releaseVersion, npmTag } = getReleaseVersion();
+    expect(releaseTag).toBe('v0.1.1-nightly.0');
+    expect(releaseVersion).toBe('0.1.1-nightly.0');
+    expect(npmTag).toBe('nightly');
+  });
+
+  it('should use manual version when provided', () => {
+    process.env.MANUAL_VERSION = '1.2.3';
+    const { releaseTag, releaseVersion, npmTag } = getReleaseVersion();
+    expect(releaseTag).toBe('v1.2.3');
+    expect(releaseVersion).toBe('1.2.3');
+    expect(npmTag).toBe('latest');
+  });
+
+  it('should prepend v to manual version if missing', () => {
+    process.env.MANUAL_VERSION = '1.2.3';
+    const { releaseTag } = getReleaseVersion();
+    expect(releaseTag).toBe('v1.2.3');
+  });
+
+  it('should handle pre-release versions correctly', () => {
+    process.env.MANUAL_VERSION = 'v1.2.3-beta.1';
+    const { releaseTag, releaseVersion, npmTag } = getReleaseVersion();
+    expect(releaseTag).toBe('v1.2.3-beta.1');
+    expect(releaseVersion).toBe('1.2.3-beta.1');
+    expect(npmTag).toBe('beta');
+  });
+
+  it('should throw an error for invalid version format', () => {
+    process.env.MANUAL_VERSION = '1.2';
+    expect(() => getReleaseVersion()).toThrow(
+      'Error: Version must be in the format vX.Y.Z or vX.Y.Z-prerelease',
+    );
+  });
+
+  it('should throw an error if no version is provided for non-nightly release', () => {
+    expect(() => getReleaseVersion()).toThrow(
+      'Error: No version specified and this is not a nightly release.',
+    );
+  });
+
+  it('should throw an error for versions with build metadata', () => {
+    process.env.MANUAL_VERSION = 'v1.2.3+build456';
+    expect(() => getReleaseVersion()).toThrow(
+      'Error: Versions with build metadata (+) are not supported for releases.',
+    );
+  });
+});
+
+describe('get-release-version script', () => {
+  it('should print version JSON to stdout when executed directly', () => {
+    const expectedJson = {
+      releaseTag: 'v0.1.1-nightly.0',
+      releaseVersion: '0.1.1-nightly.0',
+      npmTag: 'nightly',
+    };
+    execSync.mockReturnValue(JSON.stringify(expectedJson));
+
+    const result = execSync('node scripts/get-release-version.js').toString();
+    expect(JSON.parse(result)).toEqual(expectedJson);
+  });
+});

projects/ui/qwen-code/scripts/tests/test-setup.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi } from 'vitest';
+
+vi.mock('fs', () => ({
+  ...vi.importActual('fs'),
+  appendFileSync: vi.fn(),
+}));

projects/ui/qwen-code/scripts/tests/vitest.config.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['scripts/tests/**/*.test.js'],
+    setupFiles: ['scripts/tests/test-setup.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'lcov'],
+    },
+  },
+});