clispark 1.19.0 → 1.20.0

package/dist/cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path19 from "path";
+import path21 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 path5 from "path";
+import path6 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, writeFile } from "fs/promises";
-import path2 from "path";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
 
 // src/update/reconcile.ts
 function reconcileEntry(currentLiveValue, oldManifestValue, newTemplateValue, isEqual) {
@@ -51,6 +51,28 @@ function deepEquals(a, b) {
   return JSON.stringify(a) === JSON.stringify(b);
 }
 
+// src/languages/lint-support/node.ts
+import { readFile, rm, writeFile } from "fs/promises";
+import path2 from "path";
+var LINT_SCRIPT_NAMES = ["lint", "format"];
+var LINT_DEPENDENCY_NAMES = [
+  "eslint",
+  "@eslint/js",
+  "typescript-eslint",
+  "prettier",
+  "eslint-config-prettier"
+];
+async function stripLintTooling(targetDir) {
+  await rm(path2.join(targetDir, "eslint.config.js"), { force: true });
+  await rm(path2.join(targetDir, ".prettierrc"), { force: true });
+  await rm(path2.join(targetDir, ".prettierignore"), { force: true });
+  const pkgPath = path2.join(targetDir, "package.json");
+  const pkg = JSON.parse(await readFile(pkgPath, "utf8"));
+  for (const name of LINT_SCRIPT_NAMES) delete pkg.scripts?.[name];
+  for (const name of LINT_DEPENDENCY_NAMES) delete pkg.devDependencies?.[name];
+  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+
 // src/update/adapters/node-oclif.ts
 var CORE_FILE_PATHS = [
   "bin/run.ts",
@@ -71,10 +93,11 @@ function currentDependencyValue(pkg, name) {
   }
   return void 0;
 }
-function extractCoreFields(pkg) {
+function extractCoreFields(pkg, flags) {
   const coreDependencies = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  const scriptNames = flags.lintEnabled ? [...CORE_SCRIPT_NAMES, ...LINT_SCRIPT_NAMES] : CORE_SCRIPT_NAMES;
   const coreScripts = {};
-  for (const name of CORE_SCRIPT_NAMES) {
+  for (const name of scriptNames) {
     const value = pkg.scripts?.[name];
     if (value !== void 0) coreScripts[name] = value;
   }
@@ -92,10 +115,11 @@ function mergePackageJson(currentPkg, oldManifest, newTemplatePkg) {
   let changed = false;
   const dependencies = [];
   const coreDependencies = {};
-  const dependencyNames = /* @__PURE__ */ new Set([
-    ...Object.keys(newTemplatePkg.dependencies ?? {}),
-    ...Object.keys(newTemplatePkg.devDependencies ?? {})
-  ]);
+  const dependencyNames = new Set(
+    [...Object.keys(newTemplatePkg.dependencies ?? {}), ...Object.keys(newTemplatePkg.devDependencies ?? {})].filter(
+      (name) => oldManifest.lintEnabled || !LINT_DEPENDENCY_NAMES.includes(name)
+    )
+  );
   for (const name of dependencyNames) {
     const inNewDependencies = newTemplatePkg.dependencies?.[name] !== void 0;
     const newValue = (inNewDependencies ? newTemplatePkg.dependencies : newTemplatePkg.devDependencies)[name];
@@ -112,7 +136,8 @@ function mergePackageJson(currentPkg, oldManifest, newTemplatePkg) {
   }
   const scripts = [];
   const coreScripts = {};
-  for (const name of CORE_SCRIPT_NAMES) {
+  const scriptNames = oldManifest.lintEnabled ? [...CORE_SCRIPT_NAMES, ...LINT_SCRIPT_NAMES] : CORE_SCRIPT_NAMES;
+  for (const name of scriptNames) {
     const newValue = newTemplatePkg.scripts?.[name];
     if (newValue === void 0) continue;
     const currentValue = currentPkg.scripts?.[name];
@@ -164,17 +189,19 @@ function mergePackageJson(currentPkg, oldManifest, newTemplatePkg) {
   };
 }
 var nodeOclifAdapter = {
-  coreFilePaths: CORE_FILE_PATHS,
+  coreFilePaths(flags) {
+    return flags.lintEnabled ? [...CORE_FILE_PATHS, "eslint.config.js", ".prettierrc", ".prettierignore"] : CORE_FILE_PATHS;
+  },
   templateSourcePath(relativePath) {
     return relativePath === ".gitignore" ? "gitignore" : relativePath;
   },
   manifestFileName: "package.json",
   async readManifestFile(dir) {
-    const content = await readFile(path2.join(dir, "package.json"), "utf8");
+    const content = await readFile2(path3.join(dir, "package.json"), "utf8");
     return JSON.parse(content);
   },
   async writeManifestFile(dir, content) {
-    await writeFile(path2.join(dir, "package.json"), JSON.stringify(content, null, 2) + "\n");
+    await writeFile2(path3.join(dir, "package.json"), JSON.stringify(content, null, 2) + "\n");
   },
   parseManifestFile(rawContent) {
     return JSON.parse(rawContent);
@@ -182,8 +209,8 @@ var nodeOclifAdapter = {
   readProjectName(manifestFile) {
     return manifestFile.name;
   },
-  extractCoreFields(manifestFile) {
-    return extractCoreFields(manifestFile);
+  extractCoreFields(manifestFile, flags) {
+    return extractCoreFields(manifestFile, flags);
   },
   mergeManifestFile(current, oldManifest, newTemplate) {
     return mergePackageJson(current, oldManifest, newTemplate);
@@ -191,8 +218,8 @@ var nodeOclifAdapter = {
 };
 
 // src/languages/registry-checkers/npm.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";
 var NPM_DEFAULT_REGISTRY_URL = "https://registry.npmjs.org";
 var FETCH_TIMEOUT_MS = 5e3;
 async function checkNameAvailability(name, registryUrl) {
@@ -207,13 +234,13 @@ async function checkNameAvailability(name, registryUrl) {
   }
 }
 async function applyPrivateIntent(targetDir) {
-  const packageJsonPath = path3.join(targetDir, "package.json");
-  const pkg = JSON.parse(await readFile2(packageJsonPath, "utf8"));
+  const packageJsonPath = path4.join(targetDir, "package.json");
+  const pkg = JSON.parse(await readFile3(packageJsonPath, "utf8"));
   pkg.private = true;
-  await writeFile2(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+  await writeFile3(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
 }
 async function applyRegistryUrl(targetDir, registryUrl) {
-  await writeFile2(path3.join(targetDir, ".npmrc"), `registry=${registryUrl}
+  await writeFile3(path4.join(targetDir, ".npmrc"), `registry=${registryUrl}
 `);
 }
 var npmRegistryChecker = {
@@ -223,8 +250,8 @@ var npmRegistryChecker = {
 };
 
 // src/languages/command-generators/node-oclif.ts
-import { mkdir, readdir, writeFile as writeFile3 } from "fs/promises";
-import path4 from "path";
+import { mkdir, readdir, writeFile as writeFile4 } from "fs/promises";
+import path5 from "path";
 
 // src/languages/command-generator.ts
 function buildCommandTree(paths2) {
@@ -256,20 +283,20 @@ async function collectCommandFiles(dir, baseDir = dir) {
   const entries = await readdir(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = path4.join(dir, entry.name);
+    const fullPath = path5.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(path4.relative(baseDir, fullPath));
+      files.push(path5.relative(baseDir, fullPath));
     }
   }
   return files;
 }
 function toCommandPath(relativeFilePath) {
-  return relativeFilePath.replace(/\.ts$/, "").split(path4.sep).join(" ");
+  return relativeFilePath.replace(/\.ts$/, "").split(path5.sep).join(" ");
 }
 async function listExistingCommands(targetDir) {
-  const commandsDir = path4.join(targetDir, "src", "commands");
+  const commandsDir = path5.join(targetDir, "src", "commands");
   const files = await collectCommandFiles(commandsDir);
   return buildCommandTree(files.map(toCommandPath));
 }
@@ -329,13 +356,13 @@ describe('${commandInvocation}', () => {
 `;
 }
 async function generateCommand(targetDir, spec) {
-  const relDir = path4.join("src", "commands", ...spec.pathSegments.slice(0, -1));
+  const relDir = path5.join("src", "commands", ...spec.pathSegments.slice(0, -1));
   const fileName = spec.pathSegments[spec.pathSegments.length - 1];
-  const commandRelPath = path4.join(relDir, `${fileName}.ts`);
-  const testRelPath = path4.join(relDir, `${fileName}.test.ts`);
-  await mkdir(path4.join(targetDir, relDir), { recursive: true });
-  await writeFile3(path4.join(targetDir, commandRelPath), generateCommandFileContent(spec));
-  await writeFile3(path4.join(targetDir, testRelPath), generateTestFileContent(spec));
+  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));
   return { commandFile: commandRelPath, testFile: testRelPath };
 }
 var nodeOclifCommandGenerator = {
@@ -354,7 +381,7 @@ function validateProjectName(value) {
 var nodeOclifPack = {
   id: "node",
   displayName: "Node.js / TypeScript (oclif)",
-  templateDir: path5.join(findPackageRoot(), "templates", "node"),
+  templateDir: path6.join(findPackageRoot(), "templates", "node"),
   scaffoldCommands: [
     { command: "npm", args: ["install"] },
     { command: "npm", args: ["run", "build"] }
@@ -368,15 +395,16 @@ var nodeOclifPack = {
     applyPrivateIntent: npmRegistryChecker.applyPrivateIntent,
     applyRegistryUrl: npmRegistryChecker.applyRegistryUrl
   },
-  commandGenerator: nodeOclifCommandGenerator
+  commandGenerator: nodeOclifCommandGenerator,
+  stripLintTooling
 };
 
 // src/languages/packs/dotnet.ts
-import path9 from "path";
+import path11 from "path";
 
 // src/update/adapters/dotnet.ts
-import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
-import path6 from "path";
+import { readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
+import path7 from "path";
 var CORE_FILE_PATHS2 = [
   "Cli.slnx",
   "src/Program.cs",
@@ -398,6 +426,16 @@ function extractTag(content, tag) {
   if (!match) throw new Error(`.csproj is missing a <${tag}> tag`);
   return match[1];
 }
+function extractOptionalTag(content, tag) {
+  const match = content.match(new RegExp(`<${tag}>([^<]*)</${tag}>`));
+  return match?.[1];
+}
+var ANALYZER_PROPERTY_NAMES = [
+  "EnableNETAnalyzers",
+  "AnalysisLevel",
+  "AnalysisMode",
+  "EnforceCodeStyleInBuild"
+];
 function extractPackageReferences(content) {
   const refs = {};
   const re = /<PackageReference\s+Include="([^"]+)"\s+Version="([^"]+)"\s*\/>/g;
@@ -420,6 +458,14 @@ function addPackageReference(content, name, version) {
   return content.replace(re, (match, indent) => `${match}${indent}<PackageReference Include="${name}" Version="${version}" />
 `);
 }
+function extractAnalyzerProperties(content) {
+  const properties = {};
+  for (const name of ANALYZER_PROPERTY_NAMES) {
+    const value = extractOptionalTag(content, name);
+    if (value !== void 0) properties[name] = value;
+  }
+  return properties;
+}
 function parseManifestFile(rawContent) {
   return {
     raw: rawContent,
@@ -427,14 +473,22 @@ function parseManifestFile(rawContent) {
     targetFramework: extractTag(rawContent, "TargetFramework"),
     packageId: extractTag(rawContent, "PackageId"),
     toolCommandName: extractTag(rawContent, "ToolCommandName"),
-    packageReferences: extractPackageReferences(rawContent)
+    packageReferences: extractPackageReferences(rawContent),
+    analyzerProperties: extractAnalyzerProperties(rawContent)
   };
 }
-function extractCoreFields2(manifestFile) {
+function extractCoreFields2(manifestFile, flags) {
+  const coreFields = { TargetFramework: manifestFile.targetFramework };
+  if (flags.lintEnabled) {
+    for (const name of ANALYZER_PROPERTY_NAMES) {
+      const value = manifestFile.analyzerProperties[name];
+      if (value !== void 0) coreFields[name] = value;
+    }
+  }
   return {
     coreDependencies: manifestFile.packageReferences,
     coreScripts: {},
-    coreFields: { TargetFramework: manifestFile.targetFramework }
+    coreFields
   };
 }
 function mergeManifestFile(current, oldManifest, newTemplate) {
@@ -470,6 +524,26 @@ function mergeManifestFile(current, oldManifest, newTemplate) {
     changed = true;
     raw = setTag(raw, "TargetFramework", targetFrameworkResult.value);
   }
+  const coreFields = { TargetFramework: targetFrameworkResult.value };
+  if (oldManifest.lintEnabled) {
+    for (const name of ANALYZER_PROPERTY_NAMES) {
+      const newValue = newTemplate.analyzerProperties[name];
+      if (newValue === void 0) continue;
+      const currentValue = current.analyzerProperties[name];
+      if (currentValue === void 0) {
+        fields.push({ key: name, outcome: "skipped" });
+        continue;
+      }
+      const oldValue = oldCoreFields[name];
+      const result = reconcileEntry(currentValue, oldValue, newValue, stringEquals);
+      fields.push({ key: name, outcome: result.outcome });
+      coreFields[name] = result.value;
+      if (result.outcome !== "skipped" && result.value !== currentValue) {
+        changed = true;
+        raw = setTag(raw, name, result.value);
+      }
+    }
+  }
   return {
     updatedFile: { ...current, raw },
     changed,
@@ -478,28 +552,30 @@ function mergeManifestFile(current, oldManifest, newTemplate) {
     fields,
     coreDependencies,
     coreScripts: {},
-    coreFields: { TargetFramework: targetFrameworkResult.value }
+    coreFields
   };
 }
 var dotnetAdapter = {
-  coreFilePaths: CORE_FILE_PATHS2,
+  coreFilePaths() {
+    return CORE_FILE_PATHS2;
+  },
   templateSourcePath(relativePath) {
     return relativePath === ".gitignore" ? "gitignore" : relativePath;
   },
   manifestFileName: "src/Cli.csproj",
   async readManifestFile(dir) {
-    const content = await readFile3(path6.join(dir, "src", "Cli.csproj"), "utf8");
+    const content = await readFile4(path7.join(dir, "src", "Cli.csproj"), "utf8");
     return parseManifestFile(content);
   },
   async writeManifestFile(dir, content) {
-    await writeFile4(path6.join(dir, "src", "Cli.csproj"), content.raw);
+    await writeFile5(path7.join(dir, "src", "Cli.csproj"), content.raw);
   },
   parseManifestFile,
   readProjectName(manifestFile) {
     return manifestFile.packageId;
   },
-  extractCoreFields(manifestFile) {
-    return extractCoreFields2(manifestFile);
+  extractCoreFields(manifestFile, flags) {
+    return extractCoreFields2(manifestFile, flags);
   },
   mergeManifestFile(current, oldManifest, newTemplate) {
     return mergeManifestFile(current, oldManifest, newTemplate);
@@ -507,8 +583,8 @@ var dotnetAdapter = {
 };
 
 // src/languages/registry-checkers/nuget.ts
-import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import path7 from "path";
+import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
+import path8 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;
@@ -524,13 +600,13 @@ async function checkNameAvailability2(name) {
   }
 }
 async function applyPrivateIntent2(targetDir) {
-  const csprojPath = path7.join(targetDir, "src", "Cli.csproj");
-  const content = await readFile4(csprojPath, "utf8");
+  const csprojPath = path8.join(targetDir, "src", "Cli.csproj");
+  const content = await readFile5(csprojPath, "utf8");
   const updated = content.replace(
     /(<PropertyGroup>\s*\n)/,
     "$1    <IsPackable>false</IsPackable>\n"
   );
-  await writeFile5(csprojPath, updated);
+  await writeFile6(csprojPath, updated);
 }
 async function applyRegistryUrl2(targetDir, registryUrl) {
   const config = [
@@ -544,7 +620,7 @@ async function applyRegistryUrl2(targetDir, registryUrl) {
     ""
   ].join("\n");
   await mkdir2(targetDir, { recursive: true });
-  await writeFile5(path7.join(targetDir, "NuGet.config"), config);
+  await writeFile6(path8.join(targetDir, "NuGet.config"), config);
 }
 var nugetRegistryChecker = {
   checkNameAvailability: checkNameAvailability2,
@@ -553,15 +629,15 @@ var nugetRegistryChecker = {
 };
 
 // src/languages/command-generators/dotnet.ts
-import { mkdir as mkdir3, readFile as readFile5, readdir as readdir2, writeFile as writeFile6 } from "fs/promises";
-import path8 from "path";
+import { mkdir as mkdir3, readFile as readFile6, readdir as readdir2, writeFile as writeFile7 } from "fs/promises";
+import path9 from "path";
 async function listExistingCommands2(targetDir) {
-  const commandsDir = path8.join(targetDir, "src", "Commands");
+  const commandsDir = path9.join(targetDir, "src", "Commands");
   const files = await readdir2(commandsDir);
   const paths2 = [];
   for (const file of files) {
     if (!file.endsWith(".cs")) continue;
-    const content = await readFile5(path8.join(commandsDir, file), "utf8");
+    const content = await readFile6(path9.join(commandsDir, file), "utf8");
     const match = content.match(/\[CommandPath\("([^"]+)"\)\]/);
     if (match) paths2.push(match[1]);
   }
@@ -653,12 +729,12 @@ public class ${className}Tests
 }
 async function generateCommand2(targetDir, spec) {
   const className = toClassName2(spec.pathSegments);
-  const commandRelPath = path8.join("src", "Commands", `${className}.cs`);
-  const testRelPath = path8.join("tests", `${className}Tests.cs`);
-  await mkdir3(path8.join(targetDir, "src", "Commands"), { recursive: true });
-  await mkdir3(path8.join(targetDir, "tests"), { recursive: true });
-  await writeFile6(path8.join(targetDir, commandRelPath), generateCommandFileContent2(spec));
-  await writeFile6(path8.join(targetDir, testRelPath), generateTestFileContent2(spec));
+  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));
   return { commandFile: commandRelPath, testFile: testRelPath };
 }
 var dotnetCommandGenerator = {
@@ -666,6 +742,19 @@ var dotnetCommandGenerator = {
   generateCommand: generateCommand2
 };
 
+// src/languages/lint-support/dotnet.ts
+import { readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
+import path10 from "path";
+async function stripLintTooling2(targetDir) {
+  const csprojPath = path10.join(targetDir, "src", "Cli.csproj");
+  const content = await readFile7(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);
+}
+
 // src/languages/packs/dotnet.ts
 function validateProjectName2(value) {
   if (!value || value.trim().length === 0) return "Project name is required.";
@@ -677,7 +766,7 @@ function validateProjectName2(value) {
 var dotnetPack = {
   id: "dotnet",
   displayName: ".NET / C# (System.CommandLine)",
-  templateDir: path9.join(findPackageRoot(), "templates", "dotnet"),
+  templateDir: path11.join(findPackageRoot(), "templates", "dotnet"),
   scaffoldCommands: [
     { command: "dotnet", args: ["restore"] },
     { command: "dotnet", args: ["build"] }
@@ -691,15 +780,16 @@ var dotnetPack = {
     applyPrivateIntent: nugetRegistryChecker.applyPrivateIntent,
     applyRegistryUrl: nugetRegistryChecker.applyRegistryUrl
   },
-  commandGenerator: dotnetCommandGenerator
+  commandGenerator: dotnetCommandGenerator,
+  stripLintTooling: stripLintTooling2
 };
 
 // src/languages/packs/powershell.ts
-import path13 from "path";
+import path15 from "path";
 
 // src/update/adapters/powershell.ts
-import { readFile as readFile6, writeFile as writeFile7 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
+import path12 from "path";
 import spawn from "cross-spawn";
 var CORE_FILE_PATHS3 = [
   "Module.psm1",
@@ -812,14 +902,16 @@ function mergeManifestFile2(current, oldManifest, newTemplate) {
   };
 }
 var powershellAdapter = {
-  coreFilePaths: CORE_FILE_PATHS3,
+  coreFilePaths() {
+    return CORE_FILE_PATHS3;
+  },
   templateSourcePath(relativePath) {
     return relativePath === ".gitignore" ? "gitignore" : relativePath;
   },
   manifestFileName: "Module.psd1",
   async readManifestFile(dir) {
-    const manifestPath = path10.join(dir, "Module.psd1");
-    const raw = await readFile6(manifestPath, "utf8");
+    const manifestPath = path12.join(dir, "Module.psd1");
+    const raw = await readFile8(manifestPath, "utf8");
     const parsedViaPwsh = await readManifestViaPwsh(manifestPath);
     return {
       raw,
@@ -828,7 +920,7 @@ var powershellAdapter = {
     };
   },
   async writeManifestFile(dir, content) {
-    await writeFile7(path10.join(dir, "Module.psd1"), content.raw);
+    await writeFile9(path12.join(dir, "Module.psd1"), content.raw);
   },
   parseManifestFile: parseManifestFile2,
   readProjectName() {
@@ -843,8 +935,8 @@ var powershellAdapter = {
 };
 
 // src/languages/registry-checkers/powershell-gallery.ts
-import { mkdir as mkdir4, writeFile as writeFile8 } from "fs/promises";
-import path11 from "path";
+import { mkdir as mkdir4, writeFile as writeFile10 } from "fs/promises";
+import path13 from "path";
 var POWERSHELL_GALLERY_DEFAULT_URL = "https://www.powershellgallery.com/api/v2";
 var FETCH_TIMEOUT_MS3 = 5e3;
 async function checkNameAvailability3(name, registryUrl) {
@@ -870,7 +962,7 @@ async function applyRegistryUrl3(targetDir, registryUrl) {
     ""
   ].join("\n");
   await mkdir4(targetDir, { recursive: true });
-  await writeFile8(path11.join(targetDir, ".psresource-repository"), content);
+  await writeFile10(path13.join(targetDir, ".psresource-repository"), content);
 }
 var powershellGalleryRegistryChecker = {
   checkNameAvailability: checkNameAvailability3,
@@ -879,8 +971,8 @@ var powershellGalleryRegistryChecker = {
 };
 
 // src/languages/command-generators/powershell.ts
-import { mkdir as mkdir5, readdir as readdir3, writeFile as writeFile9 } from "fs/promises";
-import path12 from "path";
+import { mkdir as mkdir5, readdir as readdir3, writeFile as writeFile11 } from "fs/promises";
+import path14 from "path";
 import { select, text, isCancel, cancel } from "@clack/prompts";
 var APPROVED_VERBS = [
   "Get",
@@ -904,7 +996,7 @@ function exitIfCancelled(value) {
   }
 }
 async function listExistingCommands3(targetDir) {
-  const publicDir = path12.join(targetDir, "Public");
+  const publicDir = path14.join(targetDir, "Public");
   const files = await readdir3(publicDir);
   const paths2 = files.filter((f) => f.endsWith(".ps1")).map((f) => f.replace(/\.ps1$/, ""));
   return buildCommandTree(paths2);
@@ -959,12 +1051,12 @@ function generateTestFileContent3(spec) {
 }
 async function generateCommand3(targetDir, spec) {
   const funcName = spec.pathSegments[spec.pathSegments.length - 1];
-  const commandRelPath = path12.join("Public", `${funcName}.ps1`);
-  const testRelPath = path12.join("tests", `${funcName}.Tests.ps1`);
-  await mkdir5(path12.join(targetDir, "Public"), { recursive: true });
-  await mkdir5(path12.join(targetDir, "tests"), { recursive: true });
-  await writeFile9(path12.join(targetDir, commandRelPath), generateCommandFileContent3(spec));
-  await writeFile9(path12.join(targetDir, testRelPath), generateTestFileContent3(spec));
+  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));
   return { commandFile: commandRelPath.replace(/\\/g, "/"), testFile: testRelPath.replace(/\\/g, "/") };
 }
 async function promptCommandIdentity(_pathSegments, existingPaths) {
@@ -1002,7 +1094,7 @@ function validateProjectName3(value) {
 var powershellPack = {
   id: "powershell",
   displayName: "PowerShell (7.4+)",
-  templateDir: path13.join(findPackageRoot(), "templates", "powershell"),
+  templateDir: path15.join(findPackageRoot(), "templates", "powershell"),
   scaffoldCommands: [
     {
       command: "pwsh",
@@ -1018,7 +1110,9 @@ var powershellPack = {
     applyPrivateIntent: powershellGalleryRegistryChecker.applyPrivateIntent,
     applyRegistryUrl: powershellGalleryRegistryChecker.applyRegistryUrl
   },
-  commandGenerator: powershellCommandGenerator
+  commandGenerator: powershellCommandGenerator,
+  stripLintTooling: async () => {
+  }
 };
 
 // src/languages/index.ts
@@ -1082,6 +1176,16 @@ async function runWizard(deps = defaultDeps) {
   });
   exitIfCancelled2(publishIntentValue);
   const publishIntent = publishIntentValue;
+  const lintEnabledValue = await select2({
+    message: "Set up lint tooling?",
+    options: [
+      { value: false, label: "No" },
+      { value: true, label: "Yes" }
+    ],
+    initialValue: false
+  });
+  exitIfCancelled2(lintEnabledValue);
+  const lintEnabled = lintEnabledValue;
   let nameAvailability = "skipped";
   if (publishIntent) {
     nameAvailability = await pack.registry.checkNameAvailability(projectName, registryUrl);
@@ -1100,19 +1204,19 @@ async function runWizard(deps = defaultDeps) {
     }
   }
   outro(`Ready to scaffold "${projectName}".`);
-  return { language: pack.id, projectName, profile, registryUrl, publishIntent, nameAvailability };
+  return { language: pack.id, projectName, profile, registryUrl, publishIntent, nameAvailability, lintEnabled };
 }
 
 // src/scaffold.ts
-import { cp, readdir as readdir4, readFile as readFile8, rename, writeFile as writeFile11 } from "fs/promises";
-import path15 from "path";
+import { cp, readdir as readdir4, readFile as readFile10, rename, writeFile as writeFile13 } from "fs/promises";
+import path17 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 readFile7, writeFile as writeFile10 } from "fs/promises";
-import path14 from "path";
+import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile12 } from "fs/promises";
+import path16 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/errors.ts
@@ -1127,30 +1231,30 @@ var UserError = class extends Error {
 function hashContent(content) {
   return createHash("sha256").update(content).digest("hex");
 }
-async function hashCoreFiles(dir, adapter) {
+async function hashCoreFiles(dir, adapter, flags) {
   const entries = await Promise.all(
-    adapter.coreFilePaths.map(async (relativePath) => {
-      const content = await readFile7(path14.join(dir, relativePath), "utf8");
+    adapter.coreFilePaths(flags).map(async (relativePath) => {
+      const content = await readFile9(path16.join(dir, relativePath), "utf8");
       return [relativePath, hashContent(content)];
     })
   );
   return Object.fromEntries(entries);
 }
-async function buildManifest(targetDir, generatorVersion, language, adapter) {
-  const coreFiles = await hashCoreFiles(targetDir, adapter);
+async function buildManifest(targetDir, generatorVersion, language, adapter, lintEnabled) {
+  const coreFiles = await hashCoreFiles(targetDir, adapter, { lintEnabled });
   const manifestFile = await adapter.readManifestFile(targetDir);
-  const { coreDependencies, coreScripts, coreFields } = adapter.extractCoreFields(manifestFile);
-  return { generatorVersion, language, coreFiles, coreDependencies, coreScripts, coreFields };
+  const { coreDependencies, coreScripts, coreFields } = adapter.extractCoreFields(manifestFile, { lintEnabled });
+  return { generatorVersion, language, lintEnabled, coreFiles, coreDependencies, coreScripts, coreFields };
 }
-var MANIFEST_RELATIVE_PATH = path14.join(".clispark", "manifest.json");
+var MANIFEST_RELATIVE_PATH = path16.join(".clispark", "manifest.json");
 async function writeManifest(targetDir, manifest) {
-  const manifestPath = path14.join(targetDir, MANIFEST_RELATIVE_PATH);
-  await mkdir6(path14.dirname(manifestPath), { recursive: true });
-  await writeFile10(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  const manifestPath = path16.join(targetDir, MANIFEST_RELATIVE_PATH);
+  await mkdir6(path16.dirname(manifestPath), { recursive: true });
+  await writeFile12(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
 }
 async function readManifest(targetDir) {
   try {
-    const content = await readFile7(path14.join(targetDir, MANIFEST_RELATIVE_PATH), "utf8");
+    const content = await readFile9(path16.join(targetDir, MANIFEST_RELATIVE_PATH), "utf8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -1166,14 +1270,14 @@ async function requireManifest(targetDir) {
   return manifest;
 }
 function getGeneratorVersion() {
-  let dir = path14.dirname(fileURLToPath2(import.meta.url));
+  let dir = path16.dirname(fileURLToPath2(import.meta.url));
   while (true) {
-    const pkgPath = path14.join(dir, "package.json");
+    const pkgPath = path16.join(dir, "package.json");
     if (existsSync2(pkgPath)) {
       const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
       if (pkg.name === "clispark") return pkg.version;
     }
-    const parentDir = path14.dirname(dir);
+    const parentDir = path16.dirname(dir);
     if (parentDir === dir) {
       throw new Error("Could not locate clispark's own package.json.");
     }
@@ -1200,7 +1304,7 @@ async function collectFiles(dir) {
   const entries = await readdir4(dir, { withFileTypes: true });
   const files = await Promise.all(
     entries.map((entry) => {
-      const fullPath = path15.join(dir, entry.name);
+      const fullPath = path17.join(dir, entry.name);
       return entry.isDirectory() ? collectFiles(fullPath) : Promise.resolve([fullPath]);
     })
   );
@@ -1210,9 +1314,9 @@ async function replacePlaceholdersInTree(targetDir, projectName) {
   const files = await collectFiles(targetDir);
   await Promise.all(
     files.map(async (filePath) => {
-      const content = await readFile8(filePath, "utf8");
+      const content = await readFile10(filePath, "utf8");
       if (content.includes("{{projectName}}")) {
-        await writeFile11(filePath, applyPlaceholders(content, projectName));
+        await writeFile13(filePath, applyPlaceholders(content, projectName));
       }
     })
   );
@@ -1221,7 +1325,7 @@ async function copyTemplate(options, pack) {
   const { projectName, targetDir, registryUrl, publishIntent } = options;
   await assertTargetDirIsUsable(targetDir);
   await cp(pack.templateDir, targetDir, { recursive: true });
-  await rename(path15.join(targetDir, "gitignore"), path15.join(targetDir, ".gitignore"));
+  await rename(path17.join(targetDir, "gitignore"), path17.join(targetDir, ".gitignore"));
   await replacePlaceholdersInTree(targetDir, projectName);
   if (publishIntent === false) {
     await pack.registry.applyPrivateIntent(targetDir);
@@ -1247,7 +1351,11 @@ var defaultScaffoldDeps = { runCommand: defaultRunCommand };
 async function scaffoldProject(options, pack, deps = defaultScaffoldDeps) {
   await copyTemplate(options, pack);
   const { targetDir } = options;
-  const manifest = await buildManifest(targetDir, getGeneratorVersion(), pack.id, pack.updateAdapter);
+  const lintEnabled = options.lintEnabled ?? false;
+  if (!lintEnabled) {
+    await pack.stripLintTooling(targetDir);
+  }
+  const manifest = await buildManifest(targetDir, getGeneratorVersion(), pack.id, pack.updateAdapter, lintEnabled);
   await writeManifest(targetDir, manifest);
   await deps.runCommand("git", ["init"], targetDir);
   await deps.runCommand("git", ["add", "-A"], targetDir);
@@ -1260,7 +1368,7 @@ async function scaffoldProject(options, pack, deps = defaultScaffoldDeps) {
 // src/logger.ts
 import { randomBytes } from "crypto";
 import { mkdirSync, readdirSync, statSync, unlinkSync, writeFileSync } from "fs";
-import path16 from "path";
+import path18 from "path";
 import envPaths from "env-paths";
 import pino from "pino";
 var paths = envPaths("clispark", { suffix: "" });
@@ -1296,7 +1404,7 @@ var SWEEP_MARKER_FILE = ".last-sweep";
 var SWEEP_THROTTLE_MS = 24 * 60 * 60 * 1e3;
 function sweepOldLogs(logDir) {
   safely(() => {
-    const markerPath = path16.join(logDir, SWEEP_MARKER_FILE);
+    const markerPath = path18.join(logDir, SWEEP_MARKER_FILE);
     let shouldSweep = true;
     try {
       shouldSweep = Date.now() - statSync(markerPath).mtimeMs >= SWEEP_THROTTLE_MS;
@@ -1306,7 +1414,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 = path16.join(logDir, file);
+      const filePath = path18.join(logDir, file);
       if (statSync(filePath).mtimeMs < cutoffMs) {
         unlinkSync(filePath);
       }
@@ -1317,7 +1425,7 @@ function sweepOldLogs(logDir) {
 function createLogger(commandName, logDir = paths.log) {
   mkdirSync(logDir, { recursive: true });
   sweepOldLogs(logDir);
-  const logFilePath = path16.join(logDir, buildLogFileName(commandName));
+  const logFilePath = path18.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);
@@ -1355,8 +1463,8 @@ function withLogging(commandName, action, logDir = paths.log, loggerFactory = cr
 }
 
 // src/update/update.ts
-import { mkdir as mkdir7, readFile as readFile9, writeFile as writeFile12 } from "fs/promises";
-import path17 from "path";
+import { mkdir as mkdir7, readFile as readFile11, writeFile as writeFile14 } from "fs/promises";
+import path19 from "path";
 import spawn3 from "cross-spawn";
 
 // src/update/releasenotes.ts
@@ -1442,7 +1550,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 readFile9(path17.join(templateDir, adapter.manifestFileName), "utf8"),
+    await readFile11(path19.join(templateDir, adapter.manifestFileName), "utf8"),
     projectName
   );
   const newTemplateManifestFile = adapter.parseManifestFile(newTemplateRaw);
@@ -1450,15 +1558,15 @@ async function updateProject(targetDir, adapter, templateDir, language, deps = d
   const newCoreFiles = {};
   const fileWrites = [];
   const perFileResults = await Promise.all(
-    adapter.coreFilePaths.map(async (relativePath) => {
+    adapter.coreFilePaths(oldManifest).map(async (relativePath) => {
       const newContent = applyPlaceholders(
-        await readFile9(path17.join(templateDir, adapter.templateSourcePath(relativePath)), "utf8"),
+        await readFile11(path19.join(templateDir, adapter.templateSourcePath(relativePath)), "utf8"),
         projectName
       );
       const newHash = hashContent(newContent);
       let currentHash;
       try {
-        currentHash = hashContent(await readFile9(path17.join(targetDir, relativePath), "utf8"));
+        currentHash = hashContent(await readFile11(path19.join(targetDir, relativePath), "utf8"));
       } catch {
         currentHash = void 0;
       }
@@ -1470,13 +1578,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: path17.join(targetDir, relativePath), content: newContent });
+      fileWrites.push({ targetPath: path19.join(targetDir, relativePath), content: newContent });
     }
   }
   for (const relativePath of Object.keys(oldManifest.coreFiles)) {
-    if (adapter.coreFilePaths.includes(relativePath)) continue;
+    if (adapter.coreFilePaths(oldManifest).includes(relativePath)) continue;
     try {
-      await readFile9(path17.join(targetDir, relativePath), "utf8");
+      await readFile11(path19.join(targetDir, relativePath), "utf8");
       files.push({ path: relativePath, outcome: "no-longer-core" });
     } catch {
     }
@@ -1498,8 +1606,8 @@ async function updateProject(targetDir, adapter, templateDir, language, deps = d
     };
   }
   for (const write of fileWrites) {
-    await mkdir7(path17.dirname(write.targetPath), { recursive: true });
-    await writeFile12(write.targetPath, write.content);
+    await mkdir7(path19.dirname(write.targetPath), { recursive: true });
+    await writeFile14(write.targetPath, write.content);
   }
   if (fileMerge.changed) {
     await adapter.writeManifestFile(targetDir, fileMerge.updatedFile);
@@ -1507,6 +1615,7 @@ async function updateProject(targetDir, adapter, templateDir, language, deps = d
   const newManifest = {
     generatorVersion: toVersion,
     language,
+    lintEnabled: oldManifest.lintEnabled ?? false,
     coreFiles: newCoreFiles,
     coreDependencies: fileMerge.coreDependencies,
     coreScripts: fileMerge.coreScripts,
@@ -1816,11 +1925,11 @@ ${getConfetti(randomFn)}
 
 // src/hooks.ts
 import { existsSync as existsSync3 } from "fs";
-import path18 from "path";
+import path20 from "path";
 import { pathToFileURL } from "url";
 import envPaths2 from "env-paths";
 function getPostScaffoldHookPath(configDir = envPaths2("clispark", { suffix: "" }).config) {
-  return path18.join(configDir, "hooks", "post-scaffold.mjs");
+  return path20.join(configDir, "hooks", "post-scaffold.mjs");
 }
 var defaultDeps2 = {
   fileExists: existsSync3,
@@ -1863,7 +1972,7 @@ function resolvePack(language) {
 program.action(
   (options) => withLogging("scaffold", async (logger) => {
     const answers = await runWizard();
-    const targetDir = path19.join(process.cwd(), answers.projectName);
+    const targetDir = path21.join(process.cwd(), answers.projectName);
     const pack = resolvePack(answers.language);
     logger.info({ projectName: answers.projectName, targetDir, language: pack.id }, "scaffold started");
     await scaffoldProject(
@@ -1871,7 +1980,8 @@ program.action(
         projectName: answers.projectName,
         targetDir,
         registryUrl: answers.registryUrl,
-        publishIntent: answers.publishIntent
+        publishIntent: answers.publishIntent,
+        lintEnabled: answers.lintEnabled
       },
       pack
     );