Remove the disableAutoNameExtensionPack feature flag

Author: robertbrignull

extensions/ql-vscode/src/config.ts

@@ -707,20 +707,12 @@ export function showQueriesPanel(): boolean {
 
 const MODEL_SETTING = new Setting("model", ROOT_SETTING);
 const LLM_GENERATION = new Setting("llmGeneration", MODEL_SETTING);
-const DISABLE_AUTO_NAME_EXTENSION_PACK = new Setting(
-  "disableAutoNameExtensionPack",
-  MODEL_SETTING,
-);
 const EXTENSIONS_DIRECTORY = new Setting("extensionsDirectory", MODEL_SETTING);
 
 export function showLlmGeneration(): boolean {
   return !!LLM_GENERATION.getValue<boolean>();
 }
 
-export function disableAutoNameExtensionPack(): boolean {
-  return !!DISABLE_AUTO_NAME_EXTENSION_PACK.getValue<boolean>();
-}
-
 export function getExtensionsDirectory(languageId: string): string | undefined {
   return EXTENSIONS_DIRECTORY.getValue<string>({
     languageId,

extensions/ql-vscode/src/model-editor/extension-pack-picker.ts

@@ -1,30 +1,22 @@
 import { join } from "path";
 import { outputFile, pathExists, readFile } from "fs-extra";
 import { dump as dumpYaml, load as loadYaml } from "js-yaml";
-import { CancellationToken, Uri, window } from "vscode";
-import { CodeQLCliServer, QlpacksInfo } from "../codeql-cli/cli";
+import { Uri } from "vscode";
+import { CodeQLCliServer } from "../codeql-cli/cli";
 import { getOnDiskWorkspaceFolders } from "../common/vscode/workspace-folders";
 import { ProgressCallback } from "../common/vscode/progress";
 import { DatabaseItem } from "../databases/local-databases";
 import { getQlPackPath, QLPACK_FILENAMES } from "../common/ql";
 import { getErrorMessage } from "../common/helpers-pure";
 import { ExtensionPack } from "./shared/extension-pack";
 import { NotificationLogger, showAndLogErrorMessage } from "../common/logging";
-import {
-  disableAutoNameExtensionPack,
-  getExtensionsDirectory,
-} from "../config";
+import { getExtensionsDirectory } from "../config";
 import {
   autoNameExtensionPack,
   ExtensionPackName,
   formatPackName,
-  parsePackName,
-  validatePackName,
 } from "./extension-pack-name";
-import {
-  askForWorkspaceFolder,
-  autoPickExtensionsDirectory,
-} from "./extensions-workspace-folder";
+import { autoPickExtensionsDirectory } from "./extensions-workspace-folder";
 
 const maxStep = 3;
 
@@ -33,7 +25,6 @@ export async function pickExtensionPack(
   databaseItem: Pick<DatabaseItem, "name" | "language">,
   logger: NotificationLogger,
   progress: ProgressCallback,
-  token: CancellationToken,
 ): Promise<ExtensionPack | undefined> {
   progress({
     message: "Resolving extension packs...",
@@ -52,182 +43,14 @@ export async function pickExtensionPack(
     true,
   );
 
-  if (!disableAutoNameExtensionPack()) {
-    progress({
-      message: "Creating extension pack...",
-      step: 2,
-      maxStep,
-    });
-
-    return autoCreateExtensionPack(
-      databaseItem.name,
-      databaseItem.language,
-      extensionPacksInfo,
-      logger,
-    );
-  }
-
-  if (Object.keys(extensionPacksInfo).length === 0) {
-    return pickNewExtensionPack(databaseItem, token);
-  }
-
-  const extensionPacks = (
-    await Promise.all(
-      Object.entries(extensionPacksInfo).map(async ([name, paths]) => {
-        if (paths.length !== 1) {
-          void showAndLogErrorMessage(
-            logger,
-            `Extension pack ${name} resolves to multiple paths`,
-            {
-              fullMessage: `Extension pack ${name} resolves to multiple paths: ${paths.join(
-                ", ",
-              )}`,
-            },
-          );
-
-          return undefined;
-        }
-
-        const path = paths[0];
-
-        let extensionPack: ExtensionPack;
-        try {
-          extensionPack = await readExtensionPack(path, databaseItem.language);
-        } catch (e: unknown) {
-          void showAndLogErrorMessage(
-            logger,
-            `Could not read extension pack ${name}`,
-            {
-              fullMessage: `Could not read extension pack ${name} at ${path}: ${getErrorMessage(
-                e,
-              )}`,
-            },
-          );
-
-          return undefined;
-        }
-
-        return extensionPack;
-      }),
-    )
-  ).filter((info): info is ExtensionPack => info !== undefined);
-
-  const extensionPacksForLanguage = extensionPacks.filter(
-    (pack) =>
-      pack.extensionTargets[`codeql/${databaseItem.language}-all`] !==
-      undefined,
-  );
-
-  const options: Array<{
-    label: string;
-    description: string | undefined;
-    detail: string | undefined;
-    extensionPack: ExtensionPack | null;
-  }> = extensionPacksForLanguage.map((pack) => ({
-    label: pack.name,
-    description: pack.version,
-    detail: pack.path,
-    extensionPack: pack,
-  }));
-  options.push({
-    label: "Create new extension pack",
-    description: undefined,
-    detail: undefined,
-    extensionPack: null,
-  });
-
   progress({
-    message: "Choosing extension pack...",
+    message: "Creating extension pack...",
     step: 2,
     maxStep,
   });
 
-  const extensionPackOption = await window.showQuickPick(
-    options,
-    {
-      title: "Select extension pack to use",
-    },
-    token,
-  );
-  if (!extensionPackOption) {
-    return undefined;
-  }
-
-  if (!extensionPackOption.extensionPack) {
-    return pickNewExtensionPack(databaseItem, token);
-  }
-
-  return extensionPackOption.extensionPack;
-}
-
-async function pickNewExtensionPack(
-  databaseItem: Pick<DatabaseItem, "name" | "language">,
-  token: CancellationToken,
-): Promise<ExtensionPack | undefined> {
-  const workspaceFolder = await askForWorkspaceFolder();
-  if (!workspaceFolder) {
-    return undefined;
-  }
-
-  const examplePackName = autoNameExtensionPack(
-    databaseItem.name,
-    databaseItem.language,
-  );
-
-  const name = await window.showInputBox(
-    {
-      title: "Create new extension pack",
-      prompt: "Enter name of extension pack",
-      placeHolder: examplePackName
-        ? `e.g. ${formatPackName(examplePackName)}`
-        : "",
-      validateInput: async (value: string): Promise<string | undefined> => {
-        const message = validatePackName(value);
-        if (message) {
-          return message;
-        }
-
-        const packName = parsePackName(value);
-        if (!packName) {
-          return "Invalid pack name";
-        }
-
-        const packPath = join(workspaceFolder.uri.fsPath, packName.name);
-        if (await pathExists(packPath)) {
-          return `A pack already exists at ${packPath}`;
-        }
-
-        return undefined;
-      },
-    },
-    token,
-  );
-  if (!name) {
-    return undefined;
-  }
-
-  const packName = parsePackName(name);
-  if (!packName) {
-    return undefined;
-  }
-
-  const packPath = join(workspaceFolder.uri.fsPath, packName.name);
-
-  if (await pathExists(packPath)) {
-    return undefined;
-  }
-
-  return writeExtensionPack(packPath, packName, databaseItem.language);
-}
-
-async function autoCreateExtensionPack(
-  name: string,
-  language: string,
-  extensionPacksInfo: QlpacksInfo,
-  logger: NotificationLogger,
-): Promise<ExtensionPack | undefined> {
   // Get the `codeQL.model.extensionsDirectory` setting for the language
-  const userExtensionsDirectory = getExtensionsDirectory(language);
+  const userExtensionsDirectory = getExtensionsDirectory(databaseItem.language);
 
   // If the setting is not set, automatically pick a suitable directory
   const extensionsDirectory = userExtensionsDirectory
@@ -239,11 +62,14 @@ async function autoCreateExtensionPack(
   }
 
   // Generate the name of the extension pack
-  const packName = autoNameExtensionPack(name, language);
+  const packName = autoNameExtensionPack(
+    databaseItem.name,
+    databaseItem.language,
+  );
   if (!packName) {
     void showAndLogErrorMessage(
       logger,
-      `Could not automatically name extension pack for database ${name}`,
+      `Could not automatically name extension pack for database ${databaseItem.name}`,
     );
 
     return undefined;
@@ -259,7 +85,7 @@ async function autoCreateExtensionPack(
     try {
       extensionPack = await readExtensionPack(
         existingExtensionPackPaths[0],
-        language,
+        databaseItem.language,
       );
     } catch (e: unknown) {
       void showAndLogErrorMessage(
@@ -309,7 +135,7 @@ async function autoCreateExtensionPack(
     return undefined;
   }
 
-  return writeExtensionPack(packPath, packName, language);
+  return writeExtensionPack(packPath, packName, databaseItem.language);
 }
 
 async function writeExtensionPack(

extensions/ql-vscode/src/model-editor/model-editor-module.ts

@@ -101,7 +101,7 @@ export class ModelEditorModule extends DisposableObject {
         }
 
         return withProgress(
-          async (progress, token) => {
+          async (progress) => {
             if (!(await this.cliServer.cliConstraints.supportsQlpacksKind())) {
               void showAndLogErrorMessage(
                 this.app.logger,
@@ -125,7 +125,6 @@ export class ModelEditorModule extends DisposableObject {
               db,
               this.app.logger,
               progress,
-              token,
             );
             if (!modelFile) {
               return;

extensions/ql-vscode/src/model-editor/model-editor-view.ts

@@ -424,7 +424,6 @@ export class ModelEditorView extends AbstractWebview<
         addedDatabase,
         this.app.logger,
         progress,
-        token,
       );
       if (!modelFile) {
         return;