clispark 1.20.0 → 1.22.0

package/dist/cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path21 from "path";
+import path22 from "path";
 import { Command } from "commander";
 
 // src/wizard.ts
 import { intro, outro, text as text2, select as select2, log, isCancel as isCancel2, cancel as cancel2 } from "@clack/prompts";
 
 // src/languages/packs/node-oclif.ts
-import path6 from "path";
+import path7 from "path";
 
 // src/package-root.ts
 import { existsSync, readFileSync } from "fs";
@@ -31,8 +31,8 @@ function findPackageRoot() {
 }
 
 // src/update/adapters/node-oclif.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import path3 from "path";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import path4 from "path";
 
 // src/update/reconcile.ts
 function reconcileEntry(currentLiveValue, oldManifestValue, newTemplateValue, isEqual) {
@@ -73,6 +73,24 @@ async function stripLintTooling(targetDir) {
   await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
 }
 
+// src/languages/autocomplete-support/node.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+var AUTOCOMPLETE_DEPENDENCY_NAME = "@oclif/plugin-autocomplete";
+function withoutAutocompletePlugin(oclif) {
+  if (!oclif || typeof oclif !== "object") return oclif;
+  const shape = oclif;
+  if (!Array.isArray(shape.plugins)) return oclif;
+  return { ...shape, plugins: shape.plugins.filter((name) => name !== AUTOCOMPLETE_DEPENDENCY_NAME) };
+}
+async function stripAutocompleteSupport(targetDir) {
+  const pkgPath = path3.join(targetDir, "package.json");
+  const pkg = JSON.parse(await readFile2(pkgPath, "utf8"));
+  delete pkg.dependencies?.[AUTOCOMPLETE_DEPENDENCY_NAME];
+  pkg.oclif = withoutAutocompletePlugin(pkg.oclif);
+  await writeFile2(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+
 // src/update/adapters/node-oclif.ts
 var CORE_FILE_PATHS = [
   "bin/run.ts",
@@ -117,7 +135,7 @@ function mergePackageJson(currentPkg, oldManifest, newTemplatePkg) {
   const coreDependencies = {};
   const dependencyNames = new Set(
     [...Object.keys(newTemplatePkg.dependencies ?? {}), ...Object.keys(newTemplatePkg.devDependencies ?? {})].filter(
-      (name) => oldManifest.lintEnabled || !LINT_DEPENDENCY_NAMES.includes(name)
+      (name) => (oldManifest.lintEnabled || !LINT_DEPENDENCY_NAMES.includes(name)) && (oldManifest.autocompleteEnabled || name !== AUTOCOMPLETE_DEPENDENCY_NAME)
     )
   );
   for (const name of dependencyNames) {
@@ -169,7 +187,8 @@ function mergePackageJson(currentPkg, oldManifest, newTemplatePkg) {
     }
   }
   if (newTemplatePkg.oclif !== void 0) {
-    const oclifResult = reconcileEntry(currentPkg.oclif, oldCoreFields.oclif, newTemplatePkg.oclif, deepEquals);
+    const effectiveTemplateOclif = oldManifest.autocompleteEnabled ? newTemplatePkg.oclif : withoutAutocompletePlugin(newTemplatePkg.oclif);
+    const oclifResult = reconcileEntry(currentPkg.oclif, oldCoreFields.oclif, effectiveTemplateOclif, deepEquals);
     fields.push({ key: "oclif", outcome: oclifResult.outcome });
     oclifValue = oclifResult.value;
     if (oclifResult.outcome !== "skipped" && !deepEquals(oclifResult.value, currentPkg.oclif)) {
@@ -197,11 +216,11 @@ var nodeOclifAdapter = {
   },
   manifestFileName: "package.json",
   async readManifestFile(dir) {
-    const content = await readFile2(path3.join(dir, "package.json"), "utf8");
+    const content = await readFile3(path4.join(dir, "package.json"), "utf8");
     return JSON.parse(content);
   },
   async writeManifestFile(dir, content) {
-    await writeFile2(path3.join(dir, "package.json"), JSON.stringify(content, null, 2) + "\n");
+    await writeFile3(path4.join(dir, "package.json"), JSON.stringify(content, null, 2) + "\n");
   },
   parseManifestFile(rawContent) {
     return JSON.parse(rawContent);
@@ -218,8 +237,8 @@ var nodeOclifAdapter = {
 };
 
 // src/languages/registry-checkers/npm.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import path4 from "path";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import path5 from "path";
 var NPM_DEFAULT_REGISTRY_URL = "https://registry.npmjs.org";
 var FETCH_TIMEOUT_MS = 5e3;
 async function checkNameAvailability(name, registryUrl) {
@@ -234,13 +253,13 @@ async function checkNameAvailability(name, registryUrl) {
   }
 }
 async function applyPrivateIntent(targetDir) {
-  const packageJsonPath = path4.join(targetDir, "package.json");
-  const pkg = JSON.parse(await readFile3(packageJsonPath, "utf8"));
+  const packageJsonPath = path5.join(targetDir, "package.json");
+  const pkg = JSON.parse(await readFile4(packageJsonPath, "utf8"));
   pkg.private = true;
-  await writeFile3(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+  await writeFile4(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
 }
 async function applyRegistryUrl(targetDir, registryUrl) {
-  await writeFile3(path4.join(targetDir, ".npmrc"), `registry=${registryUrl}
+  await writeFile4(path5.join(targetDir, ".npmrc"), `registry=${registryUrl}
 `);
 }
 var npmRegistryChecker = {
@@ -250,8 +269,8 @@ var npmRegistryChecker = {
 };
 
 // src/languages/command-generators/node-oclif.ts
-import { mkdir, readdir, writeFile as writeFile4 } from "fs/promises";
-import path5 from "path";
+import { mkdir, readdir, writeFile as writeFile5 } from "fs/promises";
+import path6 from "path";
 
 // src/languages/command-generator.ts
 function buildCommandTree(paths2) {
@@ -283,20 +302,20 @@ async function collectCommandFiles(dir, baseDir = dir) {
   const entries = await readdir(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = path5.join(dir, entry.name);
+    const fullPath = path6.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await collectCommandFiles(fullPath, baseDir));
     } else if (entry.name.endsWith(".ts") && !entry.name.endsWith(".test.ts")) {
-      files.push(path5.relative(baseDir, fullPath));
+      files.push(path6.relative(baseDir, fullPath));
     }
   }
   return files;
 }
 function toCommandPath(relativeFilePath) {
-  return relativeFilePath.replace(/\.ts$/, "").split(path5.sep).join(" ");
+  return relativeFilePath.replace(/\.ts$/, "").split(path6.sep).join(" ");
 }
 async function listExistingCommands(targetDir) {
-  const commandsDir = path5.join(targetDir, "src", "commands");
+  const commandsDir = path6.join(targetDir, "src", "commands");
   const files = await collectCommandFiles(commandsDir);
   return buildCommandTree(files.map(toCommandPath));
 }
@@ -356,13 +375,13 @@ describe('${commandInvocation}', () => {
 `;
 }
 async function generateCommand(targetDir, spec) {
-  const relDir = path5.join("src", "commands", ...spec.pathSegments.slice(0, -1));
+  const relDir = path6.join("src", "commands", ...spec.pathSegments.slice(0, -1));
   const fileName = spec.pathSegments[spec.pathSegments.length - 1];
-  const commandRelPath = path5.join(relDir, `${fileName}.ts`);
-  const testRelPath = path5.join(relDir, `${fileName}.test.ts`);
-  await mkdir(path5.join(targetDir, relDir), { recursive: true });
-  await writeFile4(path5.join(targetDir, commandRelPath), generateCommandFileContent(spec));
-  await writeFile4(path5.join(targetDir, testRelPath), generateTestFileContent(spec));
+  const commandRelPath = path6.join(relDir, `${fileName}.ts`);
+  const testRelPath = path6.join(relDir, `${fileName}.test.ts`);
+  await mkdir(path6.join(targetDir, relDir), { recursive: true });
+  await writeFile5(path6.join(targetDir, commandRelPath), generateCommandFileContent(spec));
+  await writeFile5(path6.join(targetDir, testRelPath), generateTestFileContent(spec));
   return { commandFile: commandRelPath, testFile: testRelPath };
 }
 var nodeOclifCommandGenerator = {
@@ -381,7 +400,7 @@ function validateProjectName(value) {
 var nodeOclifPack = {
   id: "node",
   displayName: "Node.js / TypeScript (oclif)",
-  templateDir: path6.join(findPackageRoot(), "templates", "node"),
+  templateDir: path7.join(findPackageRoot(), "templates", "node"),
   scaffoldCommands: [
     { command: "npm", args: ["install"] },
     { command: "npm", args: ["run", "build"] }
@@ -396,15 +415,17 @@ var nodeOclifPack = {
     applyRegistryUrl: npmRegistryChecker.applyRegistryUrl
   },
   commandGenerator: nodeOclifCommandGenerator,
-  stripLintTooling
+  stripLintTooling,
+  supportsAutocompleteOptIn: true,
+  stripAutocompleteSupport
 };
 
 // src/languages/packs/dotnet.ts
-import path11 from "path";
+import path12 from "path";
 
 // src/update/adapters/dotnet.ts
-import { readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import path7 from "path";
+import { readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
+import path8 from "path";
 var CORE_FILE_PATHS2 = [
   "Cli.slnx",
   "src/Program.cs",
@@ -564,11 +585,11 @@ var dotnetAdapter = {
   },
   manifestFileName: "src/Cli.csproj",
   async readManifestFile(dir) {
-    const content = await readFile4(path7.join(dir, "src", "Cli.csproj"), "utf8");
+    const content = await readFile5(path8.join(dir, "src", "Cli.csproj"), "utf8");
     return parseManifestFile(content);
   },
   async writeManifestFile(dir, content) {
-    await writeFile5(path7.join(dir, "src", "Cli.csproj"), content.raw);
+    await writeFile6(path8.join(dir, "src", "Cli.csproj"), content.raw);
   },
   parseManifestFile,
   readProjectName(manifestFile) {
@@ -583,8 +604,8 @@ var dotnetAdapter = {
 };
 
 // src/languages/registry-checkers/nuget.ts
-import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
-import path8 from "path";
+import { mkdir as mkdir2, readFile as readFile6, writeFile as writeFile7 } from "fs/promises";
+import path9 from "path";
 var NUGET_DEFAULT_REGISTRY_URL = "https://api.nuget.org/v3/index.json";
 var NUGET_FLATCONTAINER_BASE = "https://api.nuget.org/v3-flatcontainer";
 var FETCH_TIMEOUT_MS2 = 5e3;
@@ -600,13 +621,13 @@ async function checkNameAvailability2(name) {
   }
 }
 async function applyPrivateIntent2(targetDir) {
-  const csprojPath = path8.join(targetDir, "src", "Cli.csproj");
-  const content = await readFile5(csprojPath, "utf8");
+  const csprojPath = path9.join(targetDir, "src", "Cli.csproj");
+  const content = await readFile6(csprojPath, "utf8");
   const updated = content.replace(
     /(<PropertyGroup>\s*\n)/,
     "$1    <IsPackable>false</IsPackable>\n"
   );
-  await writeFile6(csprojPath, updated);
+  await writeFile7(csprojPath, updated);
 }
 async function applyRegistryUrl2(targetDir, registryUrl) {
   const config = [
@@ -620,7 +641,7 @@ async function applyRegistryUrl2(targetDir, registryUrl) {
     ""
   ].join("\n");
   await mkdir2(targetDir, { recursive: true });
-  await writeFile6(path8.join(targetDir, "NuGet.config"), config);
+  await writeFile7(path9.join(targetDir, "NuGet.config"), config);
 }
 var nugetRegistryChecker = {
   checkNameAvailability: checkNameAvailability2,
@@ -629,15 +650,15 @@ var nugetRegistryChecker = {
 };
 
 // src/languages/command-generators/dotnet.ts
-import { mkdir as mkdir3, readFile as readFile6, readdir as readdir2, writeFile as writeFile7 } from "fs/promises";
-import path9 from "path";
+import { mkdir as mkdir3, readFile as readFile7, readdir as readdir2, writeFile as writeFile8 } from "fs/promises";
+import path10 from "path";
 async function listExistingCommands2(targetDir) {
-  const commandsDir = path9.join(targetDir, "src", "Commands");
+  const commandsDir = path10.join(targetDir, "src", "Commands");
   const files = await readdir2(commandsDir);
   const paths2 = [];
   for (const file of files) {
     if (!file.endsWith(".cs")) continue;
-    const content = await readFile6(path9.join(commandsDir, file), "utf8");
+    const content = await readFile7(path10.join(commandsDir, file), "utf8");
     const match = content.match(/\[CommandPath\("([^"]+)"\)\]/);
     if (match) paths2.push(match[1]);
   }
@@ -729,12 +750,12 @@ public class ${className}Tests
 }
 async function generateCommand2(targetDir, spec) {
   const className = toClassName2(spec.pathSegments);
-  const commandRelPath = path9.join("src", "Commands", `${className}.cs`);
-  const testRelPath = path9.join("tests", `${className}Tests.cs`);
-  await mkdir3(path9.join(targetDir, "src", "Commands"), { recursive: true });
-  await mkdir3(path9.join(targetDir, "tests"), { recursive: true });
-  await writeFile7(path9.join(targetDir, commandRelPath), generateCommandFileContent2(spec));
-  await writeFile7(path9.join(targetDir, testRelPath), generateTestFileContent2(spec));
+  const commandRelPath = path10.join("src", "Commands", `${className}.cs`);
+  const testRelPath = path10.join("tests", `${className}Tests.cs`);
+  await mkdir3(path10.join(targetDir, "src", "Commands"), { recursive: true });
+  await mkdir3(path10.join(targetDir, "tests"), { recursive: true });
+  await writeFile8(path10.join(targetDir, commandRelPath), generateCommandFileContent2(spec));
+  await writeFile8(path10.join(targetDir, testRelPath), generateTestFileContent2(spec));
   return { commandFile: commandRelPath, testFile: testRelPath };
 }
 var dotnetCommandGenerator = {
@@ -743,16 +764,16 @@ var dotnetCommandGenerator = {
 };
 
 // src/languages/lint-support/dotnet.ts
-import { readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
+import path11 from "path";
 async function stripLintTooling2(targetDir) {
-  const csprojPath = path10.join(targetDir, "src", "Cli.csproj");
-  const content = await readFile7(csprojPath, "utf8");
+  const csprojPath = path11.join(targetDir, "src", "Cli.csproj");
+  const content = await readFile8(csprojPath, "utf8");
   const updated = content.replace(
     /\r?\n\s*<PropertyGroup>\s*\r?\n\s*<EnableNETAnalyzers>[\s\S]*?<\/PropertyGroup>\r?\n/,
     "\n"
   );
-  await writeFile8(csprojPath, updated);
+  await writeFile9(csprojPath, updated);
 }
 
 // src/languages/packs/dotnet.ts
@@ -766,7 +787,7 @@ function validateProjectName2(value) {
 var dotnetPack = {
   id: "dotnet",
   displayName: ".NET / C# (System.CommandLine)",
-  templateDir: path11.join(findPackageRoot(), "templates", "dotnet"),
+  templateDir: path12.join(findPackageRoot(), "templates", "dotnet"),
   scaffoldCommands: [
     { command: "dotnet", args: ["restore"] },
     { command: "dotnet", args: ["build"] }
@@ -781,15 +802,18 @@ var dotnetPack = {
     applyRegistryUrl: nugetRegistryChecker.applyRegistryUrl
   },
   commandGenerator: dotnetCommandGenerator,
-  stripLintTooling: stripLintTooling2
+  stripLintTooling: stripLintTooling2,
+  supportsAutocompleteOptIn: false,
+  stripAutocompleteSupport: async () => {
+  }
 };
 
 // src/languages/packs/powershell.ts
-import path15 from "path";
+import path16 from "path";
 
 // src/update/adapters/powershell.ts
-import { readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
-import path12 from "path";
+import { readFile as readFile9, writeFile as writeFile10 } from "fs/promises";
+import path13 from "path";
 import spawn from "cross-spawn";
 var CORE_FILE_PATHS3 = [
   "Module.psm1",
@@ -910,8 +934,8 @@ var powershellAdapter = {
   },
   manifestFileName: "Module.psd1",
   async readManifestFile(dir) {
-    const manifestPath = path12.join(dir, "Module.psd1");
-    const raw = await readFile8(manifestPath, "utf8");
+    const manifestPath = path13.join(dir, "Module.psd1");
+    const raw = await readFile9(manifestPath, "utf8");
     const parsedViaPwsh = await readManifestViaPwsh(manifestPath);
     return {
       raw,
@@ -920,7 +944,7 @@ var powershellAdapter = {
     };
   },
   async writeManifestFile(dir, content) {
-    await writeFile9(path12.join(dir, "Module.psd1"), content.raw);
+    await writeFile10(path13.join(dir, "Module.psd1"), content.raw);
   },
   parseManifestFile: parseManifestFile2,
   readProjectName() {
@@ -935,8 +959,8 @@ var powershellAdapter = {
 };
 
 // src/languages/registry-checkers/powershell-gallery.ts
-import { mkdir as mkdir4, writeFile as writeFile10 } from "fs/promises";
-import path13 from "path";
+import { mkdir as mkdir4, writeFile as writeFile11 } from "fs/promises";
+import path14 from "path";
 var POWERSHELL_GALLERY_DEFAULT_URL = "https://www.powershellgallery.com/api/v2";
 var FETCH_TIMEOUT_MS3 = 5e3;
 async function checkNameAvailability3(name, registryUrl) {
@@ -962,7 +986,7 @@ async function applyRegistryUrl3(targetDir, registryUrl) {
     ""
   ].join("\n");
   await mkdir4(targetDir, { recursive: true });
-  await writeFile10(path13.join(targetDir, ".psresource-repository"), content);
+  await writeFile11(path14.join(targetDir, ".psresource-repository"), content);
 }
 var powershellGalleryRegistryChecker = {
   checkNameAvailability: checkNameAvailability3,
@@ -971,8 +995,8 @@ var powershellGalleryRegistryChecker = {
 };
 
 // src/languages/command-generators/powershell.ts
-import { mkdir as mkdir5, readdir as readdir3, writeFile as writeFile11 } from "fs/promises";
-import path14 from "path";
+import { mkdir as mkdir5, readdir as readdir3, writeFile as writeFile12 } from "fs/promises";
+import path15 from "path";
 import { select, text, isCancel, cancel } from "@clack/prompts";
 var APPROVED_VERBS = [
   "Get",
@@ -996,7 +1020,7 @@ function exitIfCancelled(value) {
   }
 }
 async function listExistingCommands3(targetDir) {
-  const publicDir = path14.join(targetDir, "Public");
+  const publicDir = path15.join(targetDir, "Public");
   const files = await readdir3(publicDir);
   const paths2 = files.filter((f) => f.endsWith(".ps1")).map((f) => f.replace(/\.ps1$/, ""));
   return buildCommandTree(paths2);
@@ -1051,12 +1075,12 @@ function generateTestFileContent3(spec) {
 }
 async function generateCommand3(targetDir, spec) {
   const funcName = spec.pathSegments[spec.pathSegments.length - 1];
-  const commandRelPath = path14.join("Public", `${funcName}.ps1`);
-  const testRelPath = path14.join("tests", `${funcName}.Tests.ps1`);
-  await mkdir5(path14.join(targetDir, "Public"), { recursive: true });
-  await mkdir5(path14.join(targetDir, "tests"), { recursive: true });
-  await writeFile11(path14.join(targetDir, commandRelPath), generateCommandFileContent3(spec));
-  await writeFile11(path14.join(targetDir, testRelPath), generateTestFileContent3(spec));
+  const commandRelPath = path15.join("Public", `${funcName}.ps1`);
+  const testRelPath = path15.join("tests", `${funcName}.Tests.ps1`);
+  await mkdir5(path15.join(targetDir, "Public"), { recursive: true });
+  await mkdir5(path15.join(targetDir, "tests"), { recursive: true });
+  await writeFile12(path15.join(targetDir, commandRelPath), generateCommandFileContent3(spec));
+  await writeFile12(path15.join(targetDir, testRelPath), generateTestFileContent3(spec));
   return { commandFile: commandRelPath.replace(/\\/g, "/"), testFile: testRelPath.replace(/\\/g, "/") };
 }
 async function promptCommandIdentity(_pathSegments, existingPaths) {
@@ -1094,7 +1118,7 @@ function validateProjectName3(value) {
 var powershellPack = {
   id: "powershell",
   displayName: "PowerShell (7.4+)",
-  templateDir: path15.join(findPackageRoot(), "templates", "powershell"),
+  templateDir: path16.join(findPackageRoot(), "templates", "powershell"),
   scaffoldCommands: [
     {
       command: "pwsh",
@@ -1112,6 +1136,9 @@ var powershellPack = {
   },
   commandGenerator: powershellCommandGenerator,
   stripLintTooling: async () => {
+  },
+  supportsAutocompleteOptIn: false,
+  stripAutocompleteSupport: async () => {
   }
 };
 
@@ -1186,6 +1213,19 @@ async function runWizard(deps = defaultDeps) {
   });
   exitIfCancelled2(lintEnabledValue);
   const lintEnabled = lintEnabledValue;
+  let autocompleteEnabled = false;
+  if (pack.supportsAutocompleteOptIn) {
+    const autocompleteEnabledValue = await select2({
+      message: "Set up shell autocompletion?",
+      options: [
+        { value: false, label: "No" },
+        { value: true, label: "Yes" }
+      ],
+      initialValue: false
+    });
+    exitIfCancelled2(autocompleteEnabledValue);
+    autocompleteEnabled = autocompleteEnabledValue;
+  }
   let nameAvailability = "skipped";
   if (publishIntent) {
     nameAvailability = await pack.registry.checkNameAvailability(projectName, registryUrl);
@@ -1204,19 +1244,28 @@ async function runWizard(deps = defaultDeps) {
     }
   }
   outro(`Ready to scaffold "${projectName}".`);
-  return { language: pack.id, projectName, profile, registryUrl, publishIntent, nameAvailability, lintEnabled };
+  return {
+    language: pack.id,
+    projectName,
+    profile,
+    registryUrl,
+    publishIntent,
+    nameAvailability,
+    lintEnabled,
+    autocompleteEnabled
+  };
 }
 
 // src/scaffold.ts
-import { cp, readdir as readdir4, readFile as readFile10, rename, writeFile as writeFile13 } from "fs/promises";
-import path17 from "path";
+import { cp, readdir as readdir4, readFile as readFile11, rename, writeFile as writeFile14 } from "fs/promises";
+import path18 from "path";
 import spawn2 from "cross-spawn";
 
 // src/update/manifest.ts
 import { createHash } from "crypto";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile12 } from "fs/promises";
-import path16 from "path";
+import { mkdir as mkdir6, readFile as readFile10, writeFile as writeFile13 } from "fs/promises";
+import path17 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/errors.ts
@@ -1234,27 +1283,30 @@ function hashContent(content) {
 async function hashCoreFiles(dir, adapter, flags) {
   const entries = await Promise.all(
     adapter.coreFilePaths(flags).map(async (relativePath) => {
-      const content = await readFile9(path16.join(dir, relativePath), "utf8");
+      const content = await readFile10(path17.join(dir, relativePath), "utf8");
       return [relativePath, hashContent(content)];
     })
   );
   return Object.fromEntries(entries);
 }
-async function buildManifest(targetDir, generatorVersion, language, adapter, lintEnabled) {
-  const coreFiles = await hashCoreFiles(targetDir, adapter, { lintEnabled });
+async function buildManifest(targetDir, generatorVersion, language, adapter, lintEnabled, autocompleteEnabled) {
+  const coreFiles = await hashCoreFiles(targetDir, adapter, { lintEnabled, autocompleteEnabled });
   const manifestFile = await adapter.readManifestFile(targetDir);
-  const { coreDependencies, coreScripts, coreFields } = adapter.extractCoreFields(manifestFile, { lintEnabled });
-  return { generatorVersion, language, lintEnabled, coreFiles, coreDependencies, coreScripts, coreFields };
+  const { coreDependencies, coreScripts, coreFields } = adapter.extractCoreFields(manifestFile, {
+    lintEnabled,
+    autocompleteEnabled
+  });
+  return { generatorVersion, language, lintEnabled, autocompleteEnabled, coreFiles, coreDependencies, coreScripts, coreFields };
 }
-var MANIFEST_RELATIVE_PATH = path16.join(".clispark", "manifest.json");
+var MANIFEST_RELATIVE_PATH = path17.join(".clispark", "manifest.json");
 async function writeManifest(targetDir, manifest) {
-  const manifestPath = path16.join(targetDir, MANIFEST_RELATIVE_PATH);
-  await mkdir6(path16.dirname(manifestPath), { recursive: true });
-  await writeFile12(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  const manifestPath = path17.join(targetDir, MANIFEST_RELATIVE_PATH);
+  await mkdir6(path17.dirname(manifestPath), { recursive: true });
+  await writeFile13(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
 }
 async function readManifest(targetDir) {
   try {
-    const content = await readFile9(path16.join(targetDir, MANIFEST_RELATIVE_PATH), "utf8");
+    const content = await readFile10(path17.join(targetDir, MANIFEST_RELATIVE_PATH), "utf8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -1270,14 +1322,14 @@ async function requireManifest(targetDir) {
   return manifest;
 }
 function getGeneratorVersion() {
-  let dir = path16.dirname(fileURLToPath2(import.meta.url));
+  let dir = path17.dirname(fileURLToPath2(import.meta.url));
   while (true) {
-    const pkgPath = path16.join(dir, "package.json");
+    const pkgPath = path17.join(dir, "package.json");
     if (existsSync2(pkgPath)) {
       const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
       if (pkg.name === "clispark") return pkg.version;
     }
-    const parentDir = path16.dirname(dir);
+    const parentDir = path17.dirname(dir);
     if (parentDir === dir) {
       throw new Error("Could not locate clispark's own package.json.");
     }
@@ -1304,7 +1356,7 @@ async function collectFiles(dir) {
   const entries = await readdir4(dir, { withFileTypes: true });
   const files = await Promise.all(
     entries.map((entry) => {
-      const fullPath = path17.join(dir, entry.name);
+      const fullPath = path18.join(dir, entry.name);
       return entry.isDirectory() ? collectFiles(fullPath) : Promise.resolve([fullPath]);
     })
   );
@@ -1314,9 +1366,9 @@ async function replacePlaceholdersInTree(targetDir, projectName) {
   const files = await collectFiles(targetDir);
   await Promise.all(
     files.map(async (filePath) => {
-      const content = await readFile10(filePath, "utf8");
+      const content = await readFile11(filePath, "utf8");
       if (content.includes("{{projectName}}")) {
-        await writeFile13(filePath, applyPlaceholders(content, projectName));
+        await writeFile14(filePath, applyPlaceholders(content, projectName));
       }
     })
   );
@@ -1325,7 +1377,7 @@ async function copyTemplate(options, pack) {
   const { projectName, targetDir, registryUrl, publishIntent } = options;
   await assertTargetDirIsUsable(targetDir);
   await cp(pack.templateDir, targetDir, { recursive: true });
-  await rename(path17.join(targetDir, "gitignore"), path17.join(targetDir, ".gitignore"));
+  await rename(path18.join(targetDir, "gitignore"), path18.join(targetDir, ".gitignore"));
   await replacePlaceholdersInTree(targetDir, projectName);
   if (publishIntent === false) {
     await pack.registry.applyPrivateIntent(targetDir);
@@ -1355,7 +1407,18 @@ async function scaffoldProject(options, pack, deps = defaultScaffoldDeps) {
   if (!lintEnabled) {
     await pack.stripLintTooling(targetDir);
   }
-  const manifest = await buildManifest(targetDir, getGeneratorVersion(), pack.id, pack.updateAdapter, lintEnabled);
+  const autocompleteEnabled = options.autocompleteEnabled ?? false;
+  if (!autocompleteEnabled) {
+    await pack.stripAutocompleteSupport(targetDir);
+  }
+  const manifest = await buildManifest(
+    targetDir,
+    getGeneratorVersion(),
+    pack.id,
+    pack.updateAdapter,
+    lintEnabled,
+    autocompleteEnabled
+  );
   await writeManifest(targetDir, manifest);
   await deps.runCommand("git", ["init"], targetDir);
   await deps.runCommand("git", ["add", "-A"], targetDir);
@@ -1368,7 +1431,7 @@ async function scaffoldProject(options, pack, deps = defaultScaffoldDeps) {
 // src/logger.ts
 import { randomBytes } from "crypto";
 import { mkdirSync, readdirSync, statSync, unlinkSync, writeFileSync } from "fs";
-import path18 from "path";
+import path19 from "path";
 import envPaths from "env-paths";
 import pino from "pino";
 var paths = envPaths("clispark", { suffix: "" });
@@ -1404,7 +1467,7 @@ var SWEEP_MARKER_FILE = ".last-sweep";
 var SWEEP_THROTTLE_MS = 24 * 60 * 60 * 1e3;
 function sweepOldLogs(logDir) {
   safely(() => {
-    const markerPath = path18.join(logDir, SWEEP_MARKER_FILE);
+    const markerPath = path19.join(logDir, SWEEP_MARKER_FILE);
     let shouldSweep = true;
     try {
       shouldSweep = Date.now() - statSync(markerPath).mtimeMs >= SWEEP_THROTTLE_MS;
@@ -1414,7 +1477,7 @@ function sweepOldLogs(logDir) {
     const cutoffMs = Date.now() - getRetentionDays() * 24 * 60 * 60 * 1e3;
     for (const file of readdirSync(logDir)) {
       if (file === SWEEP_MARKER_FILE) continue;
-      const filePath = path18.join(logDir, file);
+      const filePath = path19.join(logDir, file);
       if (statSync(filePath).mtimeMs < cutoffMs) {
         unlinkSync(filePath);
       }
@@ -1425,7 +1488,7 @@ function sweepOldLogs(logDir) {
 function createLogger(commandName, logDir = paths.log) {
   mkdirSync(logDir, { recursive: true });
   sweepOldLogs(logDir);
-  const logFilePath = path18.join(logDir, buildLogFileName(commandName));
+  const logFilePath = path19.join(logDir, buildLogFileName(commandName));
   const fileDestination = pino.destination({ dest: logFilePath, sync: true, mode: 384 });
   const destination = process.env.DEBUG ? pino.multistream([{ stream: fileDestination }, { stream: process.stdout }]) : fileDestination;
   const logger = pino({ redact: buildRedactPaths([...SENSITIVE_LOG_KEYS, "registryUrl"]) }, destination);
@@ -1463,8 +1526,8 @@ function withLogging(commandName, action, logDir = paths.log, loggerFactory = cr
 }
 
 // src/update/update.ts
-import { mkdir as mkdir7, readFile as readFile11, writeFile as writeFile14 } from "fs/promises";
-import path19 from "path";
+import { mkdir as mkdir7, readFile as readFile12, writeFile as writeFile15 } from "fs/promises";
+import path20 from "path";
 import spawn3 from "cross-spawn";
 
 // src/update/releasenotes.ts
@@ -1550,7 +1613,7 @@ async function updateProject(targetDir, adapter, templateDir, language, deps = d
   const currentManifestFile = await adapter.readManifestFile(targetDir);
   const projectName = adapter.readProjectName(currentManifestFile);
   const newTemplateRaw = applyPlaceholders(
-    await readFile11(path19.join(templateDir, adapter.manifestFileName), "utf8"),
+    await readFile12(path20.join(templateDir, adapter.manifestFileName), "utf8"),
     projectName
   );
   const newTemplateManifestFile = adapter.parseManifestFile(newTemplateRaw);
@@ -1560,13 +1623,13 @@ async function updateProject(targetDir, adapter, templateDir, language, deps = d
   const perFileResults = await Promise.all(
     adapter.coreFilePaths(oldManifest).map(async (relativePath) => {
       const newContent = applyPlaceholders(
-        await readFile11(path19.join(templateDir, adapter.templateSourcePath(relativePath)), "utf8"),
+        await readFile12(path20.join(templateDir, adapter.templateSourcePath(relativePath)), "utf8"),
         projectName
       );
       const newHash = hashContent(newContent);
       let currentHash;
       try {
-        currentHash = hashContent(await readFile11(path19.join(targetDir, relativePath), "utf8"));
+        currentHash = hashContent(await readFile12(path20.join(targetDir, relativePath), "utf8"));
       } catch {
         currentHash = void 0;
       }
@@ -1578,13 +1641,13 @@ async function updateProject(targetDir, adapter, templateDir, language, deps = d
     files.push({ path: relativePath, outcome: result.outcome });
     newCoreFiles[relativePath] = result.value;
     if (result.outcome === "added" || result.outcome === "replaced") {
-      fileWrites.push({ targetPath: path19.join(targetDir, relativePath), content: newContent });
+      fileWrites.push({ targetPath: path20.join(targetDir, relativePath), content: newContent });
     }
   }
   for (const relativePath of Object.keys(oldManifest.coreFiles)) {
     if (adapter.coreFilePaths(oldManifest).includes(relativePath)) continue;
     try {
-      await readFile11(path19.join(targetDir, relativePath), "utf8");
+      await readFile12(path20.join(targetDir, relativePath), "utf8");
       files.push({ path: relativePath, outcome: "no-longer-core" });
     } catch {
     }
@@ -1606,8 +1669,8 @@ async function updateProject(targetDir, adapter, templateDir, language, deps = d
     };
   }
   for (const write of fileWrites) {
-    await mkdir7(path19.dirname(write.targetPath), { recursive: true });
-    await writeFile14(write.targetPath, write.content);
+    await mkdir7(path20.dirname(write.targetPath), { recursive: true });
+    await writeFile15(write.targetPath, write.content);
   }
   if (fileMerge.changed) {
     await adapter.writeManifestFile(targetDir, fileMerge.updatedFile);
@@ -1616,6 +1679,7 @@ async function updateProject(targetDir, adapter, templateDir, language, deps = d
     generatorVersion: toVersion,
     language,
     lintEnabled: oldManifest.lintEnabled ?? false,
+    autocompleteEnabled: oldManifest.autocompleteEnabled ?? false,
     coreFiles: newCoreFiles,
     coreDependencies: fileMerge.coreDependencies,
     coreScripts: fileMerge.coreScripts,
@@ -1925,11 +1989,11 @@ ${getConfetti(randomFn)}
 
 // src/hooks.ts
 import { existsSync as existsSync3 } from "fs";
-import path20 from "path";
+import path21 from "path";
 import { pathToFileURL } from "url";
 import envPaths2 from "env-paths";
 function getPostScaffoldHookPath(configDir = envPaths2("clispark", { suffix: "" }).config) {
-  return path20.join(configDir, "hooks", "post-scaffold.mjs");
+  return path21.join(configDir, "hooks", "post-scaffold.mjs");
 }
 var defaultDeps2 = {
   fileExists: existsSync3,
@@ -1972,7 +2036,7 @@ function resolvePack(language) {
 program.action(
   (options) => withLogging("scaffold", async (logger) => {
     const answers = await runWizard();
-    const targetDir = path21.join(process.cwd(), answers.projectName);
+    const targetDir = path22.join(process.cwd(), answers.projectName);
     const pack = resolvePack(answers.language);
     logger.info({ projectName: answers.projectName, targetDir, language: pack.id }, "scaffold started");
     await scaffoldProject(
@@ -1981,7 +2045,8 @@ program.action(
         targetDir,
         registryUrl: answers.registryUrl,
         publishIntent: answers.publishIntent,
-        lintEnabled: answers.lintEnabled
+        lintEnabled: answers.lintEnabled,
+        autocompleteEnabled: answers.autocompleteEnabled
       },
       pack
     );