Add new command: 'Go to File in Selected Database'

extensions/ql-vscode/package.json

@@ -528,6 +528,10 @@
         "command": "codeQL.runQueryContextEditor",
         "title": "CodeQL: Run Query on Selected Database"
       },
+      {
+        "command": "codeQL.goToFile",
+        "title": "CodeQL: Go to File in Selected Database"
+      },
       {
         "command": "codeQL.runWarmOverlayBaseCacheForQuery",
         "title": "CodeQL: Warm Overlay-Base Cache for Query"
@@ -1874,6 +1878,9 @@
           "command": "codeQL.gotoQLContextEditor",
           "when": "false"
         },
+        {
+          "command": "codeQL.goToFile"
+        },
         {
           "command": "codeQL.trimCache"
         },

extensions/ql-vscode/src/common/commands.ts

@@ -260,6 +260,9 @@ export type LocalDatabasesCommands = {
   // Internal commands
   "codeQLDatabases.removeOrphanedDatabases": () => Promise<void>;
   "codeQL.getCurrentDatabase": () => Promise<string | undefined>;
+
+  // Source archive file search
+  "codeQL.goToFile": () => Promise<void>;
 };
 
 // Commands tied to variant analysis

extensions/ql-vscode/src/databases/local-databases-ui.ts

@@ -45,6 +45,7 @@ import type { QueryRunner } from "../query-server";
 import type { App } from "../common/app";
 import { redactableError } from "../common/errors";
 import type { LocalDatabasesCommands } from "../common/commands";
+import { searchSourceArchiveFiles } from "./source-archive-file-search";
 import {
   createMultiSelectionCommand,
   createSingleSelectionCommand,
@@ -317,9 +318,22 @@ export class DatabaseUI extends DisposableObject {
       ),
       "codeQLDatabases.removeOrphanedDatabases":
         this.handleRemoveOrphanedDatabases.bind(this),
+      "codeQL.goToFile": this.handleGoToFile.bind(this),
     };
   }
 
+  private async handleGoToFile(): Promise<void> {
+    const currentDb = this.databaseManager.currentDatabaseItem;
+    if (!currentDb) {
+      void showAndLogErrorMessage(
+        this.app.logger,
+        "No CodeQL database selected. Please select a database first.",
+      );
+      return;
+    }
+    await searchSourceArchiveFiles(currentDb);
+  }
+
   private async handleMakeCurrentDatabase(
     databaseItem: DatabaseItem,
   ): Promise<void> {

extensions/ql-vscode/src/databases/source-archive-file-search.ts

@@ -0,0 +1,109 @@
+import type { QuickPickItem, Uri } from "vscode";
+import { FileType, window, workspace } from "vscode";
+import type { DatabaseItem } from "./local-databases";
+import {
+  encodeSourceArchiveUri,
+  decodeSourceArchiveUri,
+} from "../common/vscode/archive-filesystem-provider";
+
+interface SourceArchiveFileQuickPickItem extends QuickPickItem {
+  uri: Uri;
+}
+
+/**
+ * Recursively collects all file URIs from a source archive directory.
+ */
+async function collectFiles(
+  dirUri: Uri,
+  sourceArchiveZipPath: string,
+  prefix: string,
+): Promise<SourceArchiveFileQuickPickItem[]> {
+  const entries = await workspace.fs.readDirectory(dirUri);
+  const items: SourceArchiveFileQuickPickItem[] = [];
+
+  for (const [name, type] of entries) {
+    const childPath = prefix ? `${prefix}/${name}` : name;
+    const childUri = encodeSourceArchiveUri({
+      sourceArchiveZipPath,
+      pathWithinSourceArchive: `${decodeSourceArchiveUri(dirUri).pathWithinSourceArchive}/${name}`,
+    });
+
+    if (type === FileType.File) {
+      items.push({
+        label: name,
+        description: prefix,
+        uri: childUri,
+      });
+    } else if (type === FileType.Directory) {
+      const subItems = await collectFiles(
+        childUri,
+        sourceArchiveZipPath,
+        childPath,
+      );
+      items.push(...subItems);
+    }
+  }
+
+  return items;
+}
+
+/**
+ * Shows a Quick Pick to search for and open a file from the source archive
+ * of the given database.
+ */
+export async function searchSourceArchiveFiles(
+  databaseItem: DatabaseItem,
+): Promise<void> {
+  let explorerUri: Uri;
+  try {
+    explorerUri = databaseItem.getSourceArchiveExplorerUri();
+  } catch (e) {
+    void window.showErrorMessage(e instanceof Error ? e.message : String(e));
+    return;
+  }
+  const sourceArchiveZipPath =
+    decodeSourceArchiveUri(explorerUri).sourceArchiveZipPath;
+
+  const quickPick = window.createQuickPick<SourceArchiveFileQuickPickItem>();
+  quickPick.placeholder = "Go to File in Selected Database...";
+  quickPick.matchOnDescription = true;
+  quickPick.busy = true;
+  quickPick.show();
+
+  try {
+    const items = await collectFiles(explorerUri, sourceArchiveZipPath, "");
+    // Sort items by file name, then by path
+    items.sort((a, b) => {
+      const nameCmp = a.label.localeCompare(b.label);
+      if (nameCmp !== 0) {
+        return nameCmp;
+      }
+      return (a.description ?? "").localeCompare(b.description ?? "");
+    });
+    quickPick.items = items;
+    quickPick.busy = false;
+  } catch (e) {
+    quickPick.dispose();
+    void window.showErrorMessage(
+      `Failed to read source archive: ${e instanceof Error ? e.message : String(e)}`,
+    );
+    return;
+  }
+
+  return new Promise<void>((resolve) => {
+    quickPick.onDidAccept(async () => {
+      const selected = quickPick.selectedItems[0];
+      quickPick.dispose();
+      if (selected) {
+        const doc = await workspace.openTextDocument(selected.uri);
+        await window.showTextDocument(doc);
+      }
+      resolve();
+    });
+
+    quickPick.onDidHide(() => {
+      quickPick.dispose();
+      resolve();
+    });
+  });
+}