clispark 1.17.1 → 1.19.0

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path14 from "path";
+import path19 from "path";
 import { Command } from "commander";
 
 // src/wizard.ts
-import { intro, outro, text, select, log, isCancel, cancel } from "@clack/prompts";
+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";
@@ -694,57 +694,385 @@ var dotnetPack = {
   commandGenerator: dotnetCommandGenerator
 };
 
+// src/languages/packs/powershell.ts
+import path13 from "path";
+
+// src/update/adapters/powershell.ts
+import { readFile as readFile6, writeFile as writeFile7 } from "fs/promises";
+import path10 from "path";
+import spawn from "cross-spawn";
+var CORE_FILE_PATHS3 = [
+  "Module.psm1",
+  "Logging/Initialize-Logging.ps1",
+  "ARCHITECTURE.md",
+  ".gitignore"
+];
+function arrayEquals(a, b) {
+  return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+function escapeSingleQuotedPowerShellString(value) {
+  return value.replace(/'/g, "''");
+}
+function readManifestViaPwsh(manifestPath) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      "pwsh",
+      [
+        "-NoProfile",
+        "-Command",
+        `(Import-PowerShellDataFile -Path '${escapeSingleQuotedPowerShellString(manifestPath)}') | ConvertTo-Json -Depth 5 -Compress`
+      ],
+      { stdio: ["ignore", "pipe", "pipe"] }
+    );
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => stdout += chunk);
+    child.stderr?.on("data", (chunk) => stderr += chunk);
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`pwsh exited with code ${code} reading ${manifestPath}: ${stderr}`));
+        return;
+      }
+      try {
+        resolve(JSON.parse(stdout));
+      } catch (err) {
+        reject(new Error(`Could not parse pwsh JSON output for ${manifestPath}: ${String(err)}
+Output: ${stdout}`));
+      }
+    });
+  });
+}
+function parseManifestFile2(rawContent) {
+  const versionMatch = rawContent.match(/ModuleVersion\s*=\s*'([^']*)'/);
+  if (!versionMatch) throw new Error("Module.psd1 is missing a ModuleVersion field");
+  const requiredModulesMatch = rawContent.match(/RequiredModules\s*=\s*@\(([^)]*)\)/);
+  const requiredModules = requiredModulesMatch ? requiredModulesMatch[1].split(",").map((s) => s.trim().replace(/^'|'$/g, "")).filter(Boolean) : [];
+  return { raw: rawContent, version: versionMatch[1], requiredModules };
+}
+function setModuleVersion(content, version) {
+  return content.replace(/(ModuleVersion\s*=\s*')[^']*(')/, `$1${version}$2`);
+}
+function setRequiredModules(content, modules) {
+  const formatted = modules.map((m) => `'${m}'`).join(", ");
+  return content.replace(/(RequiredModules\s*=\s*@\()[^)]*(\))/, `$1${formatted}$2`);
+}
+function extractCoreFields3(manifestFile) {
+  const coreDependencies = {};
+  for (const name of manifestFile.requiredModules) coreDependencies[name] = "*";
+  return {
+    coreDependencies,
+    coreScripts: {},
+    coreFields: { RequiredModulesCount: manifestFile.requiredModules.length, ModuleVersion: manifestFile.version }
+  };
+}
+function mergeManifestFile2(current, oldManifest, newTemplate) {
+  let raw = current.raw;
+  let changed = false;
+  const dependencies = [];
+  const coreDependencies = {};
+  const mergedModules = [];
+  for (const name of newTemplate.requiredModules) {
+    const currentHasIt = current.requiredModules.includes(name);
+    const oldHadIt = Object.prototype.hasOwnProperty.call(oldManifest.coreDependencies, name);
+    const result = reconcileEntry(
+      currentHasIt ? name : void 0,
+      oldHadIt ? name : void 0,
+      name,
+      (a, b) => a === b
+    );
+    dependencies.push({ key: name, outcome: result.outcome });
+    if (result.value) {
+      coreDependencies[name] = "*";
+      mergedModules.push(result.value);
+    }
+  }
+  for (const name of current.requiredModules) {
+    if (!mergedModules.includes(name)) mergedModules.push(name);
+  }
+  if (!arrayEquals(mergedModules, current.requiredModules)) {
+    changed = true;
+    raw = setRequiredModules(raw, mergedModules);
+  }
+  const oldCoreFields = oldManifest.coreFields;
+  const versionResult = reconcileEntry(current.version, oldCoreFields.ModuleVersion, newTemplate.version, (a, b) => a === b);
+  if (versionResult.value !== current.version) {
+    changed = true;
+    raw = setModuleVersion(raw, versionResult.value);
+  }
+  return {
+    updatedFile: { ...current, raw, requiredModules: mergedModules },
+    changed,
+    dependencies,
+    scripts: [],
+    fields: [],
+    coreDependencies,
+    coreScripts: {},
+    coreFields: { RequiredModulesCount: mergedModules.length, ModuleVersion: versionResult.value }
+  };
+}
+var powershellAdapter = {
+  coreFilePaths: 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 parsedViaPwsh = await readManifestViaPwsh(manifestPath);
+    return {
+      raw,
+      version: parsedViaPwsh.ModuleVersion,
+      requiredModules: parsedViaPwsh.RequiredModules ?? []
+    };
+  },
+  async writeManifestFile(dir, content) {
+    await writeFile7(path10.join(dir, "Module.psd1"), content.raw);
+  },
+  parseManifestFile: parseManifestFile2,
+  readProjectName() {
+    return "__scaffolded-from-targetDir__";
+  },
+  extractCoreFields(manifestFile) {
+    return extractCoreFields3(manifestFile);
+  },
+  mergeManifestFile(current, oldManifest, newTemplate) {
+    return mergeManifestFile2(current, oldManifest, newTemplate);
+  }
+};
+
+// src/languages/registry-checkers/powershell-gallery.ts
+import { mkdir as mkdir4, writeFile as writeFile8 } from "fs/promises";
+import path11 from "path";
+var POWERSHELL_GALLERY_DEFAULT_URL = "https://www.powershellgallery.com/api/v2";
+var FETCH_TIMEOUT_MS3 = 5e3;
+async function checkNameAvailability3(name, registryUrl) {
+  const url = `${registryUrl}/FindPackagesById()?id='${encodeURIComponent(name)}'`;
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS3) });
+    if (response.status !== 200) return "unverified";
+    const body = await response.text();
+    return body.includes("<entry>") ? "taken" : "available";
+  } catch {
+    return "unverified";
+  }
+}
+async function applyPrivateIntent3() {
+}
+async function applyRegistryUrl3(targetDir, registryUrl) {
+  const content = [
+    "# This file documents the private PSResourceGet repository configured for this project.",
+    "# Register it once per machine before publishing or installing dependencies from it:",
+    `#   Register-PSResourceRepository -Name "custom" -Uri "${registryUrl}" -Trusted`,
+    "",
+    registryUrl,
+    ""
+  ].join("\n");
+  await mkdir4(targetDir, { recursive: true });
+  await writeFile8(path11.join(targetDir, ".psresource-repository"), content);
+}
+var powershellGalleryRegistryChecker = {
+  checkNameAvailability: checkNameAvailability3,
+  applyPrivateIntent: applyPrivateIntent3,
+  applyRegistryUrl: applyRegistryUrl3
+};
+
+// src/languages/command-generators/powershell.ts
+import { mkdir as mkdir5, readdir as readdir3, writeFile as writeFile9 } from "fs/promises";
+import path12 from "path";
+import { select, text, isCancel, cancel } from "@clack/prompts";
+var APPROVED_VERBS = [
+  "Get",
+  "Set",
+  "New",
+  "Remove",
+  "Add",
+  "Clear",
+  "Invoke",
+  "Start",
+  "Stop",
+  "Test",
+  "Update",
+  "Export",
+  "Import"
+];
+function exitIfCancelled(value) {
+  if (isCancel(value)) {
+    cancel("Operation cancelled.");
+    process.exit(1);
+  }
+}
+async function listExistingCommands3(targetDir) {
+  const publicDir = path12.join(targetDir, "Public");
+  const files = await readdir3(publicDir);
+  const paths2 = files.filter((f) => f.endsWith(".ps1")).map((f) => f.replace(/\.ps1$/, ""));
+  return buildCommandTree(paths2);
+}
+function powershellParamType(param) {
+  if (param.type === "integer") return "[int]";
+  if (param.type === "boolean") return "[switch]";
+  return "[string]";
+}
+function parameterDeclaration(param) {
+  const lines = [];
+  if (param.type === "enum") {
+    lines.push(`    [ValidateSet(${(param.allowedValues ?? []).map((v) => `'${v}'`).join(", ")})]`);
+  }
+  if (param.required && param.type !== "boolean") {
+    lines.push("    [Parameter(Mandatory)]");
+  }
+  lines.push(`    ${powershellParamType(param)}$${param.name}`);
+  return lines.join("\n");
+}
+function generateCommandFileContent3(spec) {
+  const funcName = spec.pathSegments[spec.pathSegments.length - 1];
+  const paramLines = spec.parameters.map(parameterDeclaration).join(",\n\n");
+  const paramBlock = spec.parameters.length > 0 ? `
+${paramLines}
+` : "";
+  const echoLines = spec.parameters.length > 0 ? spec.parameters.map((p) => `        Write-Output "${p.name}=$${p.name}"`).join("\n") : `        Write-Output '${funcName} ran'`;
+  return `function ${funcName} {
+    [CmdletBinding()]
+    param(${paramBlock})
+    process {
+${echoLines}
+    }
+}
+`;
+}
+function sampleParamValue(param) {
+  if (param.type === "enum") return param.allowedValues?.[0] ?? "";
+  if (param.type === "integer") return "1";
+  return "value";
+}
+function generateTestFileContent3(spec) {
+  const funcName = spec.pathSegments[spec.pathSegments.length - 1];
+  const mandatoryArgs = spec.parameters.filter((p) => p.required && p.type !== "boolean").map((p) => `-${p.name} '${sampleParamValue(p)}'`).join(" ");
+  const invocation = mandatoryArgs ? `${funcName} ${mandatoryArgs}` : funcName;
+  return `Describe '${funcName}' {
+    It 'runs without error' {
+        { ${invocation} } | Should -Not -Throw
+    }
+}
+`;
+}
+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));
+  return { commandFile: commandRelPath.replace(/\\/g, "/"), testFile: testRelPath.replace(/\\/g, "/") };
+}
+async function promptCommandIdentity(_pathSegments, existingPaths) {
+  const verbValue = await select({
+    message: "Verb (from PowerShell\u2019s approved-verb list)",
+    options: APPROVED_VERBS.map((v) => ({ value: v, label: v }))
+  });
+  exitIfCancelled(verbValue);
+  const nounValue = await text({
+    message: "Noun",
+    validate: (value) => {
+      if (!/^[A-Z][A-Za-z0-9]*$/.test(value)) return "Use PascalCase, starting with an uppercase letter (e.g. TaskList).";
+      const fullName = `${verbValue}-${value}`;
+      if (existingPaths.has(fullName)) return `"${fullName}" already exists.`;
+      return void 0;
+    }
+  });
+  exitIfCancelled(nounValue);
+  return [`${verbValue}-${nounValue}`];
+}
+var powershellCommandGenerator = {
+  listExistingCommands: listExistingCommands3,
+  generateCommand: generateCommand3,
+  promptCommandIdentity
+};
+
+// src/languages/packs/powershell.ts
+function validateProjectName3(value) {
+  if (!value || value.trim().length === 0) return "Project name is required.";
+  if (!/^[A-Z][A-Za-z0-9]*$/.test(value)) {
+    return "Use PascalCase, starting with an uppercase letter (e.g. MyTool).";
+  }
+  return void 0;
+}
+var powershellPack = {
+  id: "powershell",
+  displayName: "PowerShell (7.4+)",
+  templateDir: path13.join(findPackageRoot(), "templates", "powershell"),
+  scaffoldCommands: [
+    {
+      command: "pwsh",
+      args: ["-NoProfile", "-Command", "Install-Module -Name PSFramework,Pester,Microsoft.PowerShell.PSResourceGet -Scope CurrentUser -Force -AllowClobber"]
+    }
+  ],
+  validateProjectName: validateProjectName3,
+  updateAdapter: powershellAdapter,
+  registry: {
+    defaultUrl: POWERSHELL_GALLERY_DEFAULT_URL,
+    promptLabel: "Custom PowerShell repository URL (leave empty for the PowerShell Gallery)",
+    checkNameAvailability: powershellGalleryRegistryChecker.checkNameAvailability,
+    applyPrivateIntent: powershellGalleryRegistryChecker.applyPrivateIntent,
+    applyRegistryUrl: powershellGalleryRegistryChecker.applyRegistryUrl
+  },
+  commandGenerator: powershellCommandGenerator
+};
+
 // src/languages/index.ts
 var LANGUAGE_PACKS = {
   [nodeOclifPack.id]: nodeOclifPack,
-  [dotnetPack.id]: dotnetPack
+  [dotnetPack.id]: dotnetPack,
+  [powershellPack.id]: powershellPack
 };
 
 // src/wizard.ts
 var defaultDeps = {
   languagePacks: LANGUAGE_PACKS
 };
-function exitIfCancelled(value) {
-  if (isCancel(value)) {
-    cancel("Operation cancelled.");
+function exitIfCancelled2(value) {
+  if (isCancel2(value)) {
+    cancel2("Operation cancelled.");
     process.exit(1);
   }
 }
 async function runWizard(deps = defaultDeps) {
   intro("clispark \u2014 scaffold a new CLI project");
   const packs = Object.values(deps.languagePacks);
-  const languageValue = await select({
+  const languageValue = await select2({
     message: "Which language?",
     options: packs.map((pack2) => ({ value: pack2.id, label: pack2.displayName }))
   });
-  exitIfCancelled(languageValue);
+  exitIfCancelled2(languageValue);
   const pack = deps.languagePacks[languageValue];
-  const nameValue = await text({
+  const nameValue = await text2({
     message: "Project name",
     validate: pack.validateProjectName
   });
-  exitIfCancelled(nameValue);
+  exitIfCancelled2(nameValue);
   let projectName = nameValue;
-  const profileValue = await select({
+  const profileValue = await select2({
     message: "Is this a work or private project?",
     options: [
       { value: "private", label: "Private" },
       { value: "work", label: "Work" }
     ]
   });
-  exitIfCancelled(profileValue);
+  exitIfCancelled2(profileValue);
   const profile = profileValue;
   let registryUrl = pack.registry.defaultUrl;
   if (profile === "work") {
-    const registryValue = await text({
+    const registryValue = await text2({
       message: pack.registry.promptLabel,
       placeholder: pack.registry.defaultUrl,
       defaultValue: pack.registry.defaultUrl
     });
-    exitIfCancelled(registryValue);
+    exitIfCancelled2(registryValue);
     registryUrl = registryValue || pack.registry.defaultUrl;
   }
-  const publishIntentValue = await select({
+  const publishIntentValue = await select2({
     message: "Do you plan to publish this?",
     options: [
       { value: false, label: "No" },
@@ -752,18 +1080,18 @@ async function runWizard(deps = defaultDeps) {
     ],
     initialValue: false
   });
-  exitIfCancelled(publishIntentValue);
+  exitIfCancelled2(publishIntentValue);
   const publishIntent = publishIntentValue;
   let nameAvailability = "skipped";
   if (publishIntent) {
     nameAvailability = await pack.registry.checkNameAvailability(projectName, registryUrl);
     while (nameAvailability === "taken") {
       log.warn(`"${projectName}" is already taken on ${registryUrl}. Please choose a different name.`);
-      const retryValue = await text({
+      const retryValue = await text2({
         message: "Project name",
         validate: pack.validateProjectName
       });
-      exitIfCancelled(retryValue);
+      exitIfCancelled2(retryValue);
       projectName = retryValue;
       nameAvailability = await pack.registry.checkNameAvailability(projectName, registryUrl);
     }
@@ -776,15 +1104,15 @@ async function runWizard(deps = defaultDeps) {
 }
 
 // src/scaffold.ts
-import { cp, readdir as readdir3, readFile as readFile7, rename, writeFile as writeFile8 } from "fs/promises";
-import path11 from "path";
-import spawn from "cross-spawn";
+import { cp, readdir as readdir4, readFile as readFile8, rename, writeFile as writeFile11 } from "fs/promises";
+import path15 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 mkdir4, readFile as readFile6, writeFile as writeFile7 } from "fs/promises";
-import path10 from "path";
+import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile10 } from "fs/promises";
+import path14 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/errors.ts
@@ -802,7 +1130,7 @@ function hashContent(content) {
 async function hashCoreFiles(dir, adapter) {
   const entries = await Promise.all(
     adapter.coreFilePaths.map(async (relativePath) => {
-      const content = await readFile6(path10.join(dir, relativePath), "utf8");
+      const content = await readFile7(path14.join(dir, relativePath), "utf8");
       return [relativePath, hashContent(content)];
     })
   );
@@ -814,15 +1142,15 @@ async function buildManifest(targetDir, generatorVersion, language, adapter) {
   const { coreDependencies, coreScripts, coreFields } = adapter.extractCoreFields(manifestFile);
   return { generatorVersion, language, coreFiles, coreDependencies, coreScripts, coreFields };
 }
-var MANIFEST_RELATIVE_PATH = path10.join(".clispark", "manifest.json");
+var MANIFEST_RELATIVE_PATH = path14.join(".clispark", "manifest.json");
 async function writeManifest(targetDir, manifest) {
-  const manifestPath = path10.join(targetDir, MANIFEST_RELATIVE_PATH);
-  await mkdir4(path10.dirname(manifestPath), { recursive: true });
-  await writeFile7(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  const manifestPath = path14.join(targetDir, MANIFEST_RELATIVE_PATH);
+  await mkdir6(path14.dirname(manifestPath), { recursive: true });
+  await writeFile10(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
 }
 async function readManifest(targetDir) {
   try {
-    const content = await readFile6(path10.join(targetDir, MANIFEST_RELATIVE_PATH), "utf8");
+    const content = await readFile7(path14.join(targetDir, MANIFEST_RELATIVE_PATH), "utf8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -838,14 +1166,14 @@ async function requireManifest(targetDir) {
   return manifest;
 }
 function getGeneratorVersion() {
-  let dir = path10.dirname(fileURLToPath2(import.meta.url));
+  let dir = path14.dirname(fileURLToPath2(import.meta.url));
   while (true) {
-    const pkgPath = path10.join(dir, "package.json");
+    const pkgPath = path14.join(dir, "package.json");
     if (existsSync2(pkgPath)) {
       const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
       if (pkg.name === "clispark") return pkg.version;
     }
-    const parentDir = path10.dirname(dir);
+    const parentDir = path14.dirname(dir);
     if (parentDir === dir) {
       throw new Error("Could not locate clispark's own package.json.");
     }
@@ -857,7 +1185,7 @@ function getGeneratorVersion() {
 async function assertTargetDirIsUsable(targetDir) {
   let entries;
   try {
-    entries = await readdir3(targetDir);
+    entries = await readdir4(targetDir);
   } catch {
     return;
   }
@@ -869,10 +1197,10 @@ function applyPlaceholders(content, projectName) {
   return content.replaceAll("{{projectName}}", projectName);
 }
 async function collectFiles(dir) {
-  const entries = await readdir3(dir, { withFileTypes: true });
+  const entries = await readdir4(dir, { withFileTypes: true });
   const files = await Promise.all(
     entries.map((entry) => {
-      const fullPath = path11.join(dir, entry.name);
+      const fullPath = path15.join(dir, entry.name);
       return entry.isDirectory() ? collectFiles(fullPath) : Promise.resolve([fullPath]);
     })
   );
@@ -882,9 +1210,9 @@ async function replacePlaceholdersInTree(targetDir, projectName) {
   const files = await collectFiles(targetDir);
   await Promise.all(
     files.map(async (filePath) => {
-      const content = await readFile7(filePath, "utf8");
+      const content = await readFile8(filePath, "utf8");
       if (content.includes("{{projectName}}")) {
-        await writeFile8(filePath, applyPlaceholders(content, projectName));
+        await writeFile11(filePath, applyPlaceholders(content, projectName));
       }
     })
   );
@@ -893,7 +1221,7 @@ async function copyTemplate(options, pack) {
   const { projectName, targetDir, registryUrl, publishIntent } = options;
   await assertTargetDirIsUsable(targetDir);
   await cp(pack.templateDir, targetDir, { recursive: true });
-  await rename(path11.join(targetDir, "gitignore"), path11.join(targetDir, ".gitignore"));
+  await rename(path15.join(targetDir, "gitignore"), path15.join(targetDir, ".gitignore"));
   await replacePlaceholdersInTree(targetDir, projectName);
   if (publishIntent === false) {
     await pack.registry.applyPrivateIntent(targetDir);
@@ -904,7 +1232,7 @@ async function copyTemplate(options, pack) {
 }
 async function defaultRunCommand(command, args, cwd) {
   await new Promise((resolve, reject) => {
-    const child = spawn(command, args, { cwd, stdio: "inherit" });
+    const child = spawn2(command, args, { cwd, stdio: "inherit" });
     child.on("error", reject);
     child.on("close", (code) => {
       if (code === 0) {
@@ -932,7 +1260,7 @@ async function scaffoldProject(options, pack, deps = defaultScaffoldDeps) {
 // src/logger.ts
 import { randomBytes } from "crypto";
 import { mkdirSync, readdirSync, statSync, unlinkSync, writeFileSync } from "fs";
-import path12 from "path";
+import path16 from "path";
 import envPaths from "env-paths";
 import pino from "pino";
 var paths = envPaths("clispark", { suffix: "" });
@@ -968,7 +1296,7 @@ var SWEEP_MARKER_FILE = ".last-sweep";
 var SWEEP_THROTTLE_MS = 24 * 60 * 60 * 1e3;
 function sweepOldLogs(logDir) {
   safely(() => {
-    const markerPath = path12.join(logDir, SWEEP_MARKER_FILE);
+    const markerPath = path16.join(logDir, SWEEP_MARKER_FILE);
     let shouldSweep = true;
     try {
       shouldSweep = Date.now() - statSync(markerPath).mtimeMs >= SWEEP_THROTTLE_MS;
@@ -978,7 +1306,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 = path12.join(logDir, file);
+      const filePath = path16.join(logDir, file);
       if (statSync(filePath).mtimeMs < cutoffMs) {
         unlinkSync(filePath);
       }
@@ -989,7 +1317,7 @@ function sweepOldLogs(logDir) {
 function createLogger(commandName, logDir = paths.log) {
   mkdirSync(logDir, { recursive: true });
   sweepOldLogs(logDir);
-  const logFilePath = path12.join(logDir, buildLogFileName(commandName));
+  const logFilePath = path16.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);
@@ -1027,9 +1355,9 @@ function withLogging(commandName, action, logDir = paths.log, loggerFactory = cr
 }
 
 // src/update/update.ts
-import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
-import path13 from "path";
-import spawn2 from "cross-spawn";
+import { mkdir as mkdir7, readFile as readFile9, writeFile as writeFile12 } from "fs/promises";
+import path17 from "path";
+import spawn3 from "cross-spawn";
 
 // src/update/releasenotes.ts
 function stripV(version) {
@@ -1046,7 +1374,7 @@ function compareVersions(a, b) {
   return 0;
 }
 var RELEASES_URL = "https://api.github.com/repos/martinwichner/clispark/releases";
-var FETCH_TIMEOUT_MS3 = 5e3;
+var FETCH_TIMEOUT_MS4 = 5e3;
 async function fetchReleaseNotes(targetDir, fetchFn = fetch) {
   const manifest = await requireManifest(targetDir);
   const fromVersion = manifest.generatorVersion;
@@ -1054,7 +1382,7 @@ async function fetchReleaseNotes(targetDir, fetchFn = fetch) {
   if (compareVersions(fromVersion, toVersion) >= 0) {
     return { status: "up-to-date", fromVersion, toVersion, releases: [] };
   }
-  const response = await fetchFn(RELEASES_URL, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS3) });
+  const response = await fetchFn(RELEASES_URL, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS4) });
   if (!response.ok) {
     throw new Error(`Failed to fetch release notes: GitHub API responded with ${response.status}`);
   }
@@ -1077,7 +1405,7 @@ ${r.body}`).join("\n\n");
 // src/update/update.ts
 async function defaultRunCommand2(command, args, cwd) {
   await new Promise((resolve, reject) => {
-    const child = spawn2(command, args, { cwd, stdio: "inherit" });
+    const child = spawn3(command, args, { cwd, stdio: "inherit" });
     child.on("error", reject);
     child.on("close", (code) => {
       if (code === 0) resolve();
@@ -1087,7 +1415,7 @@ async function defaultRunCommand2(command, args, cwd) {
 }
 async function defaultCaptureCommand(command, args, cwd) {
   return new Promise((resolve, reject) => {
-    const child = spawn2(command, args, { cwd });
+    const child = spawn3(command, args, { cwd });
     let stdout = "";
     child.stdout?.on("data", (chunk) => {
       stdout += chunk.toString();
@@ -1114,7 +1442,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 readFile8(path13.join(templateDir, adapter.manifestFileName), "utf8"),
+    await readFile9(path17.join(templateDir, adapter.manifestFileName), "utf8"),
     projectName
   );
   const newTemplateManifestFile = adapter.parseManifestFile(newTemplateRaw);
@@ -1124,13 +1452,13 @@ async function updateProject(targetDir, adapter, templateDir, language, deps = d
   const perFileResults = await Promise.all(
     adapter.coreFilePaths.map(async (relativePath) => {
       const newContent = applyPlaceholders(
-        await readFile8(path13.join(templateDir, adapter.templateSourcePath(relativePath)), "utf8"),
+        await readFile9(path17.join(templateDir, adapter.templateSourcePath(relativePath)), "utf8"),
         projectName
       );
       const newHash = hashContent(newContent);
       let currentHash;
       try {
-        currentHash = hashContent(await readFile8(path13.join(targetDir, relativePath), "utf8"));
+        currentHash = hashContent(await readFile9(path17.join(targetDir, relativePath), "utf8"));
       } catch {
         currentHash = void 0;
       }
@@ -1142,13 +1470,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: path13.join(targetDir, relativePath), content: newContent });
+      fileWrites.push({ targetPath: path17.join(targetDir, relativePath), content: newContent });
     }
   }
   for (const relativePath of Object.keys(oldManifest.coreFiles)) {
     if (adapter.coreFilePaths.includes(relativePath)) continue;
     try {
-      await readFile8(path13.join(targetDir, relativePath), "utf8");
+      await readFile9(path17.join(targetDir, relativePath), "utf8");
       files.push({ path: relativePath, outcome: "no-longer-core" });
     } catch {
     }
@@ -1170,8 +1498,8 @@ async function updateProject(targetDir, adapter, templateDir, language, deps = d
     };
   }
   for (const write of fileWrites) {
-    await mkdir5(path13.dirname(write.targetPath), { recursive: true });
-    await writeFile9(write.targetPath, write.content);
+    await mkdir7(path17.dirname(write.targetPath), { recursive: true });
+    await writeFile12(write.targetPath, write.content);
   }
   if (fileMerge.changed) {
     await adapter.writeManifestFile(targetDir, fileMerge.updatedFile);
@@ -1234,10 +1562,10 @@ function formatUpdateSummary(result) {
 }
 
 // src/add-wizard.ts
-import { intro as intro2, outro as outro2, select as select2, text as text2, confirm, isCancel as isCancel2, cancel as cancel2, log as log2 } from "@clack/prompts";
-function exitIfCancelled2(value) {
-  if (isCancel2(value)) {
-    cancel2("Operation cancelled.");
+import { intro as intro2, outro as outro2, select as select3, text as text3, confirm, isCancel as isCancel3, cancel as cancel3, log as log2 } from "@clack/prompts";
+function exitIfCancelled3(value) {
+  if (isCancel3(value)) {
+    cancel3("Operation cancelled.");
     process.exit(1);
   }
 }
@@ -1267,8 +1595,8 @@ async function selectWithinNode(node) {
     { value: HERE, label: `Direct subcommand of "${node.path}"` },
     ...node.children.map((child) => ({ value: child.path, label: `Under "${child.path}"` }))
   ];
-  const choice = await select2({ message: `Where under "${node.path}"?`, options });
-  exitIfCancelled2(choice);
+  const choice = await select3({ message: `Where under "${node.path}"?`, options });
+  exitIfCancelled3(choice);
   if (choice === HERE) {
     return node.path.split(" ");
   }
@@ -1277,8 +1605,8 @@ async function selectWithinNode(node) {
 }
 async function selectPath(existing) {
   const options = [{ value: NEW_TOP_LEVEL, label: "New top-level command" }, ...flattenForMenu(existing)];
-  const choice = await select2({ message: "Where should the new command go?", options });
-  exitIfCancelled2(choice);
+  const choice = await select3({ message: "Where should the new command go?", options });
+  exitIfCancelled3(choice);
   if (choice === NEW_TOP_LEVEL) {
     return [];
   }
@@ -1295,9 +1623,9 @@ async function collectParameters() {
     const addMore = await confirm({
       message: parameters.length === 0 ? "Add a parameter?" : "Add another parameter?"
     });
-    exitIfCancelled2(addMore);
+    exitIfCancelled3(addMore);
     if (!addMore) break;
-    const nameValue = await text2({
+    const nameValue = await text3({
       message: "Parameter name",
       validate: (value) => {
         if (!/^[a-z][a-zA-Z0-9]*$/.test(value)) return "Use a single word starting with a lowercase letter.";
@@ -1305,9 +1633,9 @@ async function collectParameters() {
         return void 0;
       }
     });
-    exitIfCancelled2(nameValue);
+    exitIfCancelled3(nameValue);
     const name = nameValue;
-    const typeValue = await select2({
+    const typeValue = await select3({
       message: "Parameter type",
       options: [
         { value: "string", label: "String" },
@@ -1316,7 +1644,7 @@ async function collectParameters() {
         { value: "enum", label: "String with allowed values" }
       ]
     });
-    exitIfCancelled2(typeValue);
+    exitIfCancelled3(typeValue);
     const type = typeValue;
     let required = false;
     if (type !== "boolean") {
@@ -1324,14 +1652,14 @@ async function collectParameters() {
         { value: true, label: "Required" },
         { value: false, label: "Optional" }
       ];
-      const requiredValue = await select2({ message: "Required or optional?", options });
-      exitIfCancelled2(requiredValue);
+      const requiredValue = await select3({ message: "Required or optional?", options });
+      exitIfCancelled3(requiredValue);
       required = requiredValue;
     }
     if (!required) hasOptional = true;
     let allowedValues;
     if (type === "enum") {
-      const valuesInput = await text2({
+      const valuesInput = await text3({
         message: "Allowed values (comma-separated)",
         validate: (value) => {
           const values = value.split(",").map((v) => v.trim()).filter(Boolean);
@@ -1344,7 +1672,7 @@ async function collectParameters() {
           return void 0;
         }
       });
-      exitIfCancelled2(valuesInput);
+      exitIfCancelled3(valuesInput);
       allowedValues = valuesInput.split(",").map((v) => v.trim()).filter(Boolean);
     }
     parameters.push({ name, type, required, allowedValues });
@@ -1356,23 +1684,28 @@ async function runAddWizard(targetDir, deps) {
   const existing = await deps.commandGenerator.listExistingCommands(targetDir);
   const pathSegments = await selectPath(existing);
   const existingPaths = new Set(flattenPaths(existing));
-  const nameValue = await text2({
-    message: "Command name",
-    validate: (value) => {
-      if (!/^[a-z][a-zA-Z0-9]*$/.test(value)) return "Use a single word starting with a lowercase letter.";
-      const fullPath = [...pathSegments, value].join(" ");
-      if (existingPaths.has(fullPath)) return `"${fullPath}" already exists.`;
-      return void 0;
-    }
-  });
-  exitIfCancelled2(nameValue);
-  const fullPathSegments = [...pathSegments, nameValue];
+  let fullPathSegments;
+  if (deps.commandGenerator.promptCommandIdentity) {
+    fullPathSegments = await deps.commandGenerator.promptCommandIdentity(pathSegments, existingPaths);
+  } else {
+    const nameValue = await text3({
+      message: "Command name",
+      validate: (value) => {
+        if (!/^[a-z][a-zA-Z0-9]*$/.test(value)) return "Use a single word starting with a lowercase letter.";
+        const fullPath = [...pathSegments, value].join(" ");
+        if (existingPaths.has(fullPath)) return `"${fullPath}" already exists.`;
+        return void 0;
+      }
+    });
+    exitIfCancelled3(nameValue);
+    fullPathSegments = [...pathSegments, nameValue];
+  }
   const parameters = await collectParameters();
   log2.info(`About to create "${fullPathSegments.join(" ")}" with ${parameters.length} parameter(s).`);
   const proceed = await confirm({ message: "Proceed?" });
-  exitIfCancelled2(proceed);
+  exitIfCancelled3(proceed);
   if (!proceed) {
-    cancel2("Cancelled.");
+    cancel3("Cancelled.");
     process.exit(1);
   }
   const spec = { pathSegments: fullPathSegments, parameters };
@@ -1383,7 +1716,7 @@ async function runAddWizard(targetDir, deps) {
 // src/whoami.ts
 import os from "os";
 var JOKE_API_URL = "https://v2.jokeapi.dev/joke/Programming,Miscellaneous";
-var FETCH_TIMEOUT_MS4 = 3e3;
+var FETCH_TIMEOUT_MS5 = 3e3;
 var SUPPORTED_JOKE_LANGUAGES = ["cs", "de", "en", "es", "fr", "pt"];
 var LOGO = String.raw`
       ⚡ clispark
@@ -1441,7 +1774,7 @@ function getRandomFunFact(osFacts = defaultOsFacts, randomFn = Math.random) {
 async function fetchJoke(language, fetchFn) {
   try {
     const url = `${JOKE_API_URL}?lang=${language}&safe-mode`;
-    const response = await fetchFn(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS4) });
+    const response = await fetchFn(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS5) });
     if (!response.ok) return void 0;
     const data = await response.json();
     if (data.error) return void 0;
@@ -1481,9 +1814,45 @@ ${getConfetti(randomFn)}
 `);
 }
 
+// src/hooks.ts
+import { existsSync as existsSync3 } from "fs";
+import path18 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");
+}
+var defaultDeps2 = {
+  fileExists: existsSync3,
+  importHookModule: (fileUrl) => import(fileUrl),
+  warn: (message) => console.warn(message)
+};
+function warnHookFailed(deps, detail) {
+  deps.warn(
+    `\u26A0 Post-scaffold hook failed: ${detail}
+  Your project was still created successfully \u2014 this only affects the optional hook.`
+  );
+}
+async function runPostScaffoldHook(context, hookPath = getPostScaffoldHookPath(), deps = defaultDeps2) {
+  if (!deps.fileExists(hookPath)) {
+    return;
+  }
+  try {
+    const mod = await deps.importHookModule(pathToFileURL(hookPath).href);
+    if (typeof mod.default !== "function") {
+      throw new Error("post-scaffold.mjs must have a default export that is a function");
+    }
+    await mod.default(context);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    warnHookFailed(deps, detail);
+  }
+}
+
 // src/cli.ts
+import { existsSync as existsSync4 } from "fs";
 var program = new Command();
-program.name("clispark").description("Interactive scaffolding tool for new CLI projects").option("--no-confetti", "Skip the confetti after a successful run").configureHelp({ showGlobalOptions: true }).version(getGeneratorVersion());
+program.name("clispark").description("Interactive scaffolding tool for new CLI projects").option("--no-confetti", "Skip the confetti after a successful run").option("--no-hook", "Skip the post-scaffold hook, even if one is configured").configureHelp({ showGlobalOptions: true }).version(getGeneratorVersion());
 function resolvePack(language) {
   const pack = LANGUAGE_PACKS[language];
   if (!pack) {
@@ -1494,7 +1863,7 @@ function resolvePack(language) {
 program.action(
   (options) => withLogging("scaffold", async (logger) => {
     const answers = await runWizard();
-    const targetDir = path14.join(process.cwd(), answers.projectName);
+    const targetDir = path19.join(process.cwd(), answers.projectName);
     const pack = resolvePack(answers.language);
     logger.info({ projectName: answers.projectName, targetDir, language: pack.id }, "scaffold started");
     await scaffoldProject(
@@ -1509,6 +1878,15 @@ program.action(
     logger.info({ projectName: answers.projectName }, "scaffold completed");
     console.log(`
 Done! Your new CLI project is ready at ${targetDir}`);
+    if (options.hook !== false) {
+      await runPostScaffoldHook({
+        projectName: answers.projectName,
+        targetDir,
+        language: pack.id,
+        registryUrl: answers.registryUrl,
+        publishIntent: answers.publishIntent
+      });
+    }
     if (options.confetti !== false) printConfetti();
   })()
 );
@@ -1562,6 +1940,23 @@ program.command("whoami").description("A little something extra").option("--joke
     logger.info({}, "whoami completed");
   })()
 );
+program.command("hook").description("Show the post-scaffold hook file location and whether one is configured").action(
+  () => withLogging("hook", async (logger) => {
+    const hookPath = getPostScaffoldHookPath();
+    const exists = existsSync4(hookPath);
+    logger.info({ hookPath, exists }, "hook status checked");
+    console.log("\nPost-scaffold hook\n");
+    console.log(`Location: ${hookPath}`);
+    if (exists) {
+      console.log("Status:   found \u2014 will run after the next scaffold");
+    } else {
+      console.log("Status:   not found \u2014 no hook will run after the next scaffold");
+      console.log(
+        "\nTo add one, create that file as an ES module exporting a default function:\n\n  export default async function postScaffold({ projectName, targetDir, language, registryUrl, publishIntent }) {\n    // your code here\n  }\n\nIt runs once, right after a new project finishes scaffolding."
+      );
+    }
+  })()
+);
 program.parseAsync(process.argv).catch((error) => {
   console.error(error);
   process.exit(1);