clispark 1.14.0 → 1.16.0

package/dist/cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path9 from "path";
+import path14 from "path";
 import { Command } from "commander";
 
 // src/wizard.ts
 import { intro, outro, text, select, log, isCancel, cancel } from "@clack/prompts";
 
 // src/languages/packs/node-oclif.ts
-import path4 from "path";
+import path5 from "path";
 
 // src/package-root.ts
 import { existsSync, readFileSync } from "fs";
@@ -212,9 +212,135 @@ async function applyPrivateIntent(targetDir) {
   pkg.private = true;
   await writeFile2(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
 }
+async function applyRegistryUrl(targetDir, registryUrl) {
+  await writeFile2(path3.join(targetDir, ".npmrc"), `registry=${registryUrl}
+`);
+}
 var npmRegistryChecker = {
   checkNameAvailability,
-  applyPrivateIntent
+  applyPrivateIntent,
+  applyRegistryUrl
+};
+
+// src/languages/command-generators/node-oclif.ts
+import { mkdir, readdir, writeFile as writeFile3 } from "fs/promises";
+import path4 from "path";
+
+// src/languages/command-generator.ts
+function buildCommandTree(paths2) {
+  const nodesByPath = /* @__PURE__ */ new Map();
+  const roots = [];
+  function getOrCreateNode(nodePath) {
+    let node = nodesByPath.get(nodePath);
+    if (!node) {
+      const segments = nodePath.split(" ");
+      node = { path: nodePath, displayLabel: segments.join(" > "), children: [] };
+      nodesByPath.set(nodePath, node);
+      if (segments.length === 1) {
+        roots.push(node);
+      } else {
+        const parent = getOrCreateNode(segments.slice(0, -1).join(" "));
+        parent.children.push(node);
+      }
+    }
+    return node;
+  }
+  for (const p of paths2) {
+    getOrCreateNode(p);
+  }
+  return roots;
+}
+
+// src/languages/command-generators/node-oclif.ts
+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);
+    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));
+    }
+  }
+  return files;
+}
+function toCommandPath(relativeFilePath) {
+  return relativeFilePath.replace(/\.ts$/, "").split(path4.sep).join(" ");
+}
+async function listExistingCommands(targetDir) {
+  const commandsDir = path4.join(targetDir, "src", "commands");
+  const files = await collectCommandFiles(commandsDir);
+  return buildCommandTree(files.map(toCommandPath));
+}
+function toClassName(pathSegments) {
+  return pathSegments.map((seg) => seg[0].toUpperCase() + seg.slice(1)).join("");
+}
+function argFor(param) {
+  const opts = [`required: ${param.required}`, `description: '${param.name}'`];
+  if (param.type === "enum") {
+    opts.push(`options: [${(param.allowedValues ?? []).map((v) => `'${v}'`).join(", ")}]`);
+  }
+  const argsMethod = param.type === "enum" ? "string" : param.type;
+  return `Args.${argsMethod}({ ${opts.join(", ")} })`;
+}
+function generateCommandFileContent(spec) {
+  const className = toClassName(spec.pathSegments);
+  const argsLines = spec.parameters.map((p) => `    ${p.name}: ${argFor(p)},`).join("\n");
+  const logExpr = spec.parameters.map((p) => `${p.name}=\${args.${p.name}}`).join(" ");
+  const depth = spec.pathSegments.length;
+  const baseCommandImportPath = "../".repeat(depth) + "base-command";
+  return `import { Args } from '@oclif/core';
+import { BaseCommand } from '${baseCommandImportPath}';
+
+export default class ${className} extends BaseCommand {
+  static description = '${spec.pathSegments[spec.pathSegments.length - 1]} command';
+  static args = {
+${argsLines}
+  };
+  static flags = {};
+
+  async run(): Promise<void> {
+    const { args } = await this.parse(${className});
+    this.log(\`${logExpr}\`);
+  }
+}
+`;
+}
+function sampleArgValue(param) {
+  if (param.type === "enum") return param.allowedValues?.[0] ?? "";
+  if (param.type === "integer") return "1";
+  if (param.type === "boolean") return "true";
+  return "value";
+}
+function generateTestFileContent(spec) {
+  const commandInvocation = spec.pathSegments.join(" ");
+  const sampleArgs = spec.parameters.map(sampleArgValue).join(" ");
+  const fullInvocation = sampleArgs ? `${commandInvocation} ${sampleArgs}` : commandInvocation;
+  return `import { describe, it, expect } from 'vitest';
+import { runCommand } from '@oclif/test';
+
+describe('${commandInvocation}', () => {
+  it('runs successfully', async () => {
+    const { error } = await runCommand('${fullInvocation}');
+    expect(error).toBeUndefined();
+  });
+});
+`;
+}
+async function generateCommand(targetDir, spec) {
+  const relDir = path4.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));
+  return { commandFile: commandRelPath, testFile: testRelPath };
+}
+var nodeOclifCommandGenerator = {
+  listExistingCommands,
+  generateCommand
 };
 
 // src/languages/packs/node-oclif.ts
@@ -228,7 +354,7 @@ function validateProjectName(value) {
 var nodeOclifPack = {
   id: "node",
   displayName: "Node.js / TypeScript (oclif)",
-  templateDir: path4.join(findPackageRoot(), "templates", "node"),
+  templateDir: path5.join(findPackageRoot(), "templates", "node"),
   scaffoldCommands: [
     { command: "npm", args: ["install"] },
     { command: "npm", args: ["run", "build"] }
@@ -239,13 +365,339 @@ var nodeOclifPack = {
     defaultUrl: NPM_DEFAULT_REGISTRY_URL,
     promptLabel: "Custom npm registry URL (leave empty for npmjs.org)",
     checkNameAvailability: npmRegistryChecker.checkNameAvailability,
-    applyPrivateIntent: npmRegistryChecker.applyPrivateIntent
+    applyPrivateIntent: npmRegistryChecker.applyPrivateIntent,
+    applyRegistryUrl: npmRegistryChecker.applyRegistryUrl
+  },
+  commandGenerator: nodeOclifCommandGenerator
+};
+
+// src/languages/packs/dotnet.ts
+import path9 from "path";
+
+// src/update/adapters/dotnet.ts
+import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
+import path6 from "path";
+var CORE_FILE_PATHS2 = [
+  "Cli.slnx",
+  "src/Program.cs",
+  "src/ICliCommand.cs",
+  "src/CommandPathAttribute.cs",
+  "src/CommandDiscovery.cs",
+  "src/CliUserException.cs",
+  "src/Logging/CliLoggerFactory.cs",
+  "src/Logging/SensitivePropertyEnricher.cs",
+  "tests/Cli.Tests.csproj",
+  "ARCHITECTURE.md",
+  ".gitignore"
+];
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractTag(content, tag) {
+  const match = content.match(new RegExp(`<${tag}>([^<]*)</${tag}>`));
+  if (!match) throw new Error(`.csproj is missing a <${tag}> tag`);
+  return match[1];
+}
+function extractPackageReferences(content) {
+  const refs = {};
+  const re = /<PackageReference\s+Include="([^"]+)"\s+Version="([^"]+)"\s*\/>/g;
+  let m;
+  while (m = re.exec(content)) {
+    refs[m[1]] = m[2];
+  }
+  return refs;
+}
+function setTag(content, tag, value) {
+  const escapedTag = escapeRegExp(tag);
+  return content.replace(new RegExp(`(<${escapedTag}>)[^<]*(</${escapedTag}>)`), `$1${value}$2`);
+}
+function setPackageReferenceVersion(content, name, version) {
+  const re = new RegExp(`(<PackageReference\\s+Include="${escapeRegExp(name)}"\\s+Version=")[^"]+(")`);
+  return content.replace(re, `$1${version}$2`);
+}
+function addPackageReference(content, name, version) {
+  const re = /^([ \t]*)<PackageReference[^\n]*\/>\n(?=[ \t]*<\/ItemGroup>)/m;
+  return content.replace(re, (match, indent) => `${match}${indent}<PackageReference Include="${name}" Version="${version}" />
+`);
+}
+function parseManifestFile(rawContent) {
+  return {
+    raw: rawContent,
+    version: extractTag(rawContent, "Version"),
+    targetFramework: extractTag(rawContent, "TargetFramework"),
+    packageId: extractTag(rawContent, "PackageId"),
+    toolCommandName: extractTag(rawContent, "ToolCommandName"),
+    packageReferences: extractPackageReferences(rawContent)
+  };
+}
+function extractCoreFields2(manifestFile) {
+  return {
+    coreDependencies: manifestFile.packageReferences,
+    coreScripts: {},
+    coreFields: { TargetFramework: manifestFile.targetFramework }
+  };
+}
+function mergeManifestFile(current, oldManifest, newTemplate) {
+  let raw = current.raw;
+  let changed = false;
+  const dependencies = [];
+  const coreDependencies = {};
+  for (const name of Object.keys(newTemplate.packageReferences)) {
+    const newValue = newTemplate.packageReferences[name];
+    const currentValue = current.packageReferences[name];
+    const oldValue = oldManifest.coreDependencies[name];
+    const result = reconcileEntry(currentValue, oldValue, newValue, stringEquals);
+    dependencies.push({ key: name, outcome: result.outcome });
+    coreDependencies[name] = result.value;
+    if (result.outcome === "added") {
+      changed = true;
+      raw = addPackageReference(raw, name, result.value);
+    } else if (result.outcome !== "skipped" && result.value !== currentValue) {
+      changed = true;
+      raw = setPackageReferenceVersion(raw, name, result.value);
+    }
+  }
+  const oldCoreFields = oldManifest.coreFields;
+  const fields = [];
+  const targetFrameworkResult = reconcileEntry(
+    current.targetFramework,
+    oldCoreFields.TargetFramework,
+    newTemplate.targetFramework,
+    stringEquals
+  );
+  fields.push({ key: "TargetFramework", outcome: targetFrameworkResult.outcome });
+  if (targetFrameworkResult.outcome !== "skipped" && targetFrameworkResult.value !== current.targetFramework) {
+    changed = true;
+    raw = setTag(raw, "TargetFramework", targetFrameworkResult.value);
+  }
+  return {
+    updatedFile: { ...current, raw },
+    changed,
+    dependencies,
+    scripts: [],
+    fields,
+    coreDependencies,
+    coreScripts: {},
+    coreFields: { TargetFramework: targetFrameworkResult.value }
+  };
+}
+var dotnetAdapter = {
+  coreFilePaths: 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");
+    return parseManifestFile(content);
+  },
+  async writeManifestFile(dir, content) {
+    await writeFile4(path6.join(dir, "src", "Cli.csproj"), content.raw);
+  },
+  parseManifestFile,
+  readProjectName(manifestFile) {
+    return manifestFile.packageId;
+  },
+  extractCoreFields(manifestFile) {
+    return extractCoreFields2(manifestFile);
+  },
+  mergeManifestFile(current, oldManifest, newTemplate) {
+    return mergeManifestFile(current, oldManifest, newTemplate);
+  }
+};
+
+// src/languages/registry-checkers/nuget.ts
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
+import path7 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;
+async function checkNameAvailability2(name) {
+  const url = `${NUGET_FLATCONTAINER_BASE}/${encodeURIComponent(name.toLowerCase())}/index.json`;
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS2) });
+    if (response.status === 404) return "available";
+    if (response.status === 200) return "taken";
+    return "unverified";
+  } catch {
+    return "unverified";
+  }
+}
+async function applyPrivateIntent2(targetDir) {
+  const csprojPath = path7.join(targetDir, "src", "Cli.csproj");
+  const content = await readFile4(csprojPath, "utf8");
+  const updated = content.replace(
+    /(<PropertyGroup>\s*\n)/,
+    "$1    <IsPackable>false</IsPackable>\n"
+  );
+  await writeFile5(csprojPath, updated);
+}
+async function applyRegistryUrl2(targetDir, registryUrl) {
+  const config = [
+    '<?xml version="1.0" encoding="utf-8"?>',
+    "<configuration>",
+    "  <packageSources>",
+    "    <clear />",
+    `    <add key="custom" value="${registryUrl}" />`,
+    "  </packageSources>",
+    "</configuration>",
+    ""
+  ].join("\n");
+  await mkdir2(targetDir, { recursive: true });
+  await writeFile5(path7.join(targetDir, "NuGet.config"), config);
+}
+var nugetRegistryChecker = {
+  checkNameAvailability: checkNameAvailability2,
+  applyPrivateIntent: applyPrivateIntent2,
+  applyRegistryUrl: applyRegistryUrl2
+};
+
+// 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";
+async function listExistingCommands2(targetDir) {
+  const commandsDir = path8.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 match = content.match(/\[CommandPath\("([^"]+)"\)\]/);
+    if (match) paths2.push(match[1]);
+  }
+  return buildCommandTree(paths2);
+}
+function toClassName2(pathSegments) {
+  return pathSegments.map((seg) => seg[0].toUpperCase() + seg.slice(1)).join("") + "Command";
+}
+function csharpDeclType(param) {
+  const baseType = param.type === "integer" ? "int" : param.type === "boolean" ? "bool" : "string";
+  if (param.required) return baseType;
+  return `${baseType}?`;
+}
+function argumentDeclaration(param) {
+  const varName = `${param.name}Argument`;
+  const declType = csharpDeclType(param);
+  const arityLine = param.required ? "" : "\n            Arity = ArgumentArity.ZeroOrOne,";
+  const lines = [
+    `        var ${varName} = new Argument<${declType}>("${param.name}")`,
+    `        {`,
+    `            Description = "${param.name}",${arityLine}`,
+    `        };`
+  ];
+  if (param.type === "enum") {
+    lines.push(`        ${varName}.AcceptOnlyFromAmong(${(param.allowedValues ?? []).map((v) => `"${v}"`).join(", ")});`);
+  }
+  return lines.join("\n");
+}
+function generateCommandFileContent2(spec) {
+  const className = toClassName2(spec.pathSegments);
+  const commandPath = spec.pathSegments.join(" ");
+  const lastSegment = spec.pathSegments[spec.pathSegments.length - 1];
+  const argDecls = spec.parameters.map(argumentDeclaration).join("\n\n");
+  const addLines = spec.parameters.map((p) => `        command.Arguments.Add(${p.name}Argument);`).join("\n");
+  const getValueLines = spec.parameters.map((p) => `            var ${p.name} = parseResult.GetValue(${p.name}Argument);`).join("\n");
+  const interpolated = spec.parameters.map((p) => `${p.name}={${p.name}}`).join(" ");
+  return `using System.CommandLine;
+
+namespace Cli.Commands;
+
+[CommandPath("${commandPath}")]
+public sealed class ${className} : ICliCommand
+{
+    public Command Build()
+    {
+${argDecls}
+
+        var command = new Command("${lastSegment}", "${lastSegment} command");
+${addLines}
+        command.SetAction(parseResult =>
+        {
+${getValueLines}
+            Console.WriteLine($"${interpolated}");
+        });
+
+        return command;
+    }
+}
+`;
+}
+function sampleArgValue2(param) {
+  if (param.type === "enum") return param.allowedValues?.[0] ?? "";
+  if (param.type === "integer") return "1";
+  if (param.type === "boolean") return "true";
+  return "value";
+}
+function generateTestFileContent2(spec) {
+  const className = toClassName2(spec.pathSegments);
+  const sampleArgs = spec.parameters.map(sampleArgValue2);
+  return `using System.CommandLine;
+using Cli.Commands;
+
+namespace Cli.Tests;
+
+public class ${className}Tests
+{
+    [Fact]
+    public void RunsSuccessfully()
+    {
+        var command = new ${className}().Build();
+        var parseResult = command.Parse([${sampleArgs.map((a) => `"${a}"`).join(", ")}]);
+
+        var exitCode = parseResult.Invoke();
+
+        Assert.Equal(0, exitCode);
+    }
+}
+`;
+}
+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));
+  return { commandFile: commandRelPath, testFile: testRelPath };
+}
+var dotnetCommandGenerator = {
+  listExistingCommands: listExistingCommands2,
+  generateCommand: generateCommand2
+};
+
+// src/languages/packs/dotnet.ts
+function validateProjectName2(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 dotnetPack = {
+  id: "dotnet",
+  displayName: ".NET / C# (System.CommandLine)",
+  templateDir: path9.join(findPackageRoot(), "templates", "dotnet"),
+  scaffoldCommands: [
+    { command: "dotnet", args: ["restore"] },
+    { command: "dotnet", args: ["build"] }
+  ],
+  validateProjectName: validateProjectName2,
+  updateAdapter: dotnetAdapter,
+  registry: {
+    defaultUrl: NUGET_DEFAULT_REGISTRY_URL,
+    promptLabel: "Custom NuGet feed URL (leave empty for nuget.org)",
+    checkNameAvailability: nugetRegistryChecker.checkNameAvailability,
+    applyPrivateIntent: nugetRegistryChecker.applyPrivateIntent,
+    applyRegistryUrl: nugetRegistryChecker.applyRegistryUrl
+  },
+  commandGenerator: dotnetCommandGenerator
 };
 
 // src/languages/index.ts
 var LANGUAGE_PACKS = {
-  [nodeOclifPack.id]: nodeOclifPack
+  [nodeOclifPack.id]: nodeOclifPack,
+  [dotnetPack.id]: dotnetPack
 };
 
 // src/wizard.ts
@@ -324,15 +776,15 @@ async function runWizard(deps = defaultDeps) {
 }
 
 // src/scaffold.ts
-import { cp, readdir, readFile as readFile4, rename, writeFile as writeFile4 } from "fs/promises";
-import path6 from "path";
+import { cp, readdir as readdir3, readFile as readFile7, rename, writeFile as writeFile8 } from "fs/promises";
+import path11 from "path";
 import spawn from "cross-spawn";
 
 // src/update/manifest.ts
 import { createHash } from "crypto";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { mkdir, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import path5 from "path";
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile7 } from "fs/promises";
+import path10 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/errors.ts
@@ -350,7 +802,7 @@ function hashContent(content) {
 async function hashCoreFiles(dir, adapter) {
   const entries = await Promise.all(
     adapter.coreFilePaths.map(async (relativePath) => {
-      const content = await readFile3(path5.join(dir, relativePath), "utf8");
+      const content = await readFile6(path10.join(dir, relativePath), "utf8");
       return [relativePath, hashContent(content)];
     })
   );
@@ -362,15 +814,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 = path5.join(".clispark", "manifest.json");
+var MANIFEST_RELATIVE_PATH = path10.join(".clispark", "manifest.json");
 async function writeManifest(targetDir, manifest) {
-  const manifestPath = path5.join(targetDir, MANIFEST_RELATIVE_PATH);
-  await mkdir(path5.dirname(manifestPath), { recursive: true });
-  await writeFile3(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  const manifestPath = path10.join(targetDir, MANIFEST_RELATIVE_PATH);
+  await mkdir4(path10.dirname(manifestPath), { recursive: true });
+  await writeFile7(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
 }
 async function readManifest(targetDir) {
   try {
-    const content = await readFile3(path5.join(targetDir, MANIFEST_RELATIVE_PATH), "utf8");
+    const content = await readFile6(path10.join(targetDir, MANIFEST_RELATIVE_PATH), "utf8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -386,14 +838,14 @@ async function requireManifest(targetDir) {
   return manifest;
 }
 function getGeneratorVersion() {
-  let dir = path5.dirname(fileURLToPath2(import.meta.url));
+  let dir = path10.dirname(fileURLToPath2(import.meta.url));
   while (true) {
-    const pkgPath = path5.join(dir, "package.json");
+    const pkgPath = path10.join(dir, "package.json");
     if (existsSync2(pkgPath)) {
       const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
       if (pkg.name === "clispark") return pkg.version;
     }
-    const parentDir = path5.dirname(dir);
+    const parentDir = path10.dirname(dir);
     if (parentDir === dir) {
       throw new Error("Could not locate clispark's own package.json.");
     }
@@ -405,7 +857,7 @@ function getGeneratorVersion() {
 async function assertTargetDirIsUsable(targetDir) {
   let entries;
   try {
-    entries = await readdir(targetDir);
+    entries = await readdir3(targetDir);
   } catch {
     return;
   }
@@ -417,10 +869,10 @@ function applyPlaceholders(content, projectName) {
   return content.replaceAll("{{projectName}}", projectName);
 }
 async function collectFiles(dir) {
-  const entries = await readdir(dir, { withFileTypes: true });
+  const entries = await readdir3(dir, { withFileTypes: true });
   const files = await Promise.all(
     entries.map((entry) => {
-      const fullPath = path6.join(dir, entry.name);
+      const fullPath = path11.join(dir, entry.name);
       return entry.isDirectory() ? collectFiles(fullPath) : Promise.resolve([fullPath]);
     })
   );
@@ -430,9 +882,9 @@ async function replacePlaceholdersInTree(targetDir, projectName) {
   const files = await collectFiles(targetDir);
   await Promise.all(
     files.map(async (filePath) => {
-      const content = await readFile4(filePath, "utf8");
+      const content = await readFile7(filePath, "utf8");
       if (content.includes("{{projectName}}")) {
-        await writeFile4(filePath, applyPlaceholders(content, projectName));
+        await writeFile8(filePath, applyPlaceholders(content, projectName));
       }
     })
   );
@@ -441,14 +893,13 @@ async function copyTemplate(options, pack) {
   const { projectName, targetDir, registryUrl, publishIntent } = options;
   await assertTargetDirIsUsable(targetDir);
   await cp(pack.templateDir, targetDir, { recursive: true });
-  await rename(path6.join(targetDir, "gitignore"), path6.join(targetDir, ".gitignore"));
+  await rename(path11.join(targetDir, "gitignore"), path11.join(targetDir, ".gitignore"));
   await replacePlaceholdersInTree(targetDir, projectName);
   if (publishIntent === false) {
     await pack.registry.applyPrivateIntent(targetDir);
   }
   if (registryUrl && registryUrl !== pack.registry.defaultUrl) {
-    await writeFile4(path6.join(targetDir, ".npmrc"), `registry=${registryUrl}
-`);
+    await pack.registry.applyRegistryUrl(targetDir, registryUrl);
   }
 }
 async function defaultRunCommand(command, args, cwd) {
@@ -481,7 +932,7 @@ async function scaffoldProject(options, pack, deps = defaultScaffoldDeps) {
 // src/logger.ts
 import { randomBytes } from "crypto";
 import { mkdirSync, readdirSync, statSync, unlinkSync, writeFileSync } from "fs";
-import path7 from "path";
+import path12 from "path";
 import envPaths from "env-paths";
 import pino from "pino";
 var paths = envPaths("clispark", { suffix: "" });
@@ -517,7 +968,7 @@ var SWEEP_MARKER_FILE = ".last-sweep";
 var SWEEP_THROTTLE_MS = 24 * 60 * 60 * 1e3;
 function sweepOldLogs(logDir) {
   safely(() => {
-    const markerPath = path7.join(logDir, SWEEP_MARKER_FILE);
+    const markerPath = path12.join(logDir, SWEEP_MARKER_FILE);
     let shouldSweep = true;
     try {
       shouldSweep = Date.now() - statSync(markerPath).mtimeMs >= SWEEP_THROTTLE_MS;
@@ -527,7 +978,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 = path7.join(logDir, file);
+      const filePath = path12.join(logDir, file);
       if (statSync(filePath).mtimeMs < cutoffMs) {
         unlinkSync(filePath);
       }
@@ -538,7 +989,7 @@ function sweepOldLogs(logDir) {
 function createLogger(commandName, logDir = paths.log) {
   mkdirSync(logDir, { recursive: true });
   sweepOldLogs(logDir);
-  const logFilePath = path7.join(logDir, buildLogFileName(commandName));
+  const logFilePath = path12.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);
@@ -576,8 +1027,8 @@ function withLogging(commandName, action, logDir = paths.log, loggerFactory = cr
 }
 
 // src/update/update.ts
-import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import path8 from "path";
+import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
+import path13 from "path";
 import spawn2 from "cross-spawn";
 
 // src/update/releasenotes.ts
@@ -595,7 +1046,7 @@ function compareVersions(a, b) {
   return 0;
 }
 var RELEASES_URL = "https://api.github.com/repos/martinwichner/clispark/releases";
-var FETCH_TIMEOUT_MS2 = 5e3;
+var FETCH_TIMEOUT_MS3 = 5e3;
 async function fetchReleaseNotes(targetDir, fetchFn = fetch) {
   const manifest = await requireManifest(targetDir);
   const fromVersion = manifest.generatorVersion;
@@ -603,7 +1054,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_MS2) });
+  const response = await fetchFn(RELEASES_URL, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS3) });
   if (!response.ok) {
     throw new Error(`Failed to fetch release notes: GitHub API responded with ${response.status}`);
   }
@@ -663,7 +1114,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 readFile5(path8.join(templateDir, adapter.manifestFileName), "utf8"),
+    await readFile8(path13.join(templateDir, adapter.manifestFileName), "utf8"),
     projectName
   );
   const newTemplateManifestFile = adapter.parseManifestFile(newTemplateRaw);
@@ -673,13 +1124,13 @@ async function updateProject(targetDir, adapter, templateDir, language, deps = d
   const perFileResults = await Promise.all(
     adapter.coreFilePaths.map(async (relativePath) => {
       const newContent = applyPlaceholders(
-        await readFile5(path8.join(templateDir, adapter.templateSourcePath(relativePath)), "utf8"),
+        await readFile8(path13.join(templateDir, adapter.templateSourcePath(relativePath)), "utf8"),
         projectName
       );
       const newHash = hashContent(newContent);
       let currentHash;
       try {
-        currentHash = hashContent(await readFile5(path8.join(targetDir, relativePath), "utf8"));
+        currentHash = hashContent(await readFile8(path13.join(targetDir, relativePath), "utf8"));
       } catch {
         currentHash = void 0;
       }
@@ -691,13 +1142,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: path8.join(targetDir, relativePath), content: newContent });
+      fileWrites.push({ targetPath: path13.join(targetDir, relativePath), content: newContent });
     }
   }
   for (const relativePath of Object.keys(oldManifest.coreFiles)) {
     if (adapter.coreFilePaths.includes(relativePath)) continue;
     try {
-      await readFile5(path8.join(targetDir, relativePath), "utf8");
+      await readFile8(path13.join(targetDir, relativePath), "utf8");
       files.push({ path: relativePath, outcome: "no-longer-core" });
     } catch {
     }
@@ -719,8 +1170,8 @@ async function updateProject(targetDir, adapter, templateDir, language, deps = d
     };
   }
   for (const write of fileWrites) {
-    await mkdir2(path8.dirname(write.targetPath), { recursive: true });
-    await writeFile5(write.targetPath, write.content);
+    await mkdir5(path13.dirname(write.targetPath), { recursive: true });
+    await writeFile9(write.targetPath, write.content);
   }
   if (fileMerge.changed) {
     await adapter.writeManifestFile(targetDir, fileMerge.updatedFile);
@@ -782,10 +1233,157 @@ function formatUpdateSummary(result) {
   return lines.join("\n");
 }
 
+// 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.");
+    process.exit(1);
+  }
+}
+var NEW_TOP_LEVEL = "__new_top_level__";
+var HERE = "__here__";
+function flattenForMenu(nodes) {
+  const result = [];
+  for (const node of nodes) {
+    result.push({ value: node.path, label: node.displayLabel });
+    result.push(...flattenForMenu(node.children));
+  }
+  return result;
+}
+function findNode(nodes, targetPath) {
+  for (const node of nodes) {
+    if (node.path === targetPath) return node;
+    const found = findNode(node.children, targetPath);
+    if (found) return found;
+  }
+  return void 0;
+}
+async function selectWithinNode(node) {
+  if (node.children.length === 0) {
+    return node.path.split(" ");
+  }
+  const options = [
+    { 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);
+  if (choice === HERE) {
+    return node.path.split(" ");
+  }
+  const childNode = node.children.find((c) => c.path === choice);
+  return selectWithinNode(childNode);
+}
+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);
+  if (choice === NEW_TOP_LEVEL) {
+    return [];
+  }
+  const node = findNode(existing, choice);
+  return selectWithinNode(node);
+}
+function flattenPaths(nodes) {
+  return nodes.flatMap((node) => [node.path, ...flattenPaths(node.children)]);
+}
+async function collectParameters() {
+  const parameters = [];
+  let hasOptional = false;
+  for (; ; ) {
+    const addMore = await confirm({
+      message: parameters.length === 0 ? "Add a parameter?" : "Add another parameter?"
+    });
+    exitIfCancelled2(addMore);
+    if (!addMore) break;
+    const nameValue = await text2({
+      message: "Parameter name",
+      validate: (value) => {
+        if (!/^[a-z][a-zA-Z0-9]*$/.test(value)) return "Use a single word starting with a lowercase letter.";
+        if (parameters.some((p) => p.name === value)) return "A parameter with this name already exists.";
+        return void 0;
+      }
+    });
+    exitIfCancelled2(nameValue);
+    const name = nameValue;
+    const typeValue = await select2({
+      message: "Parameter type",
+      options: [
+        { value: "string", label: "String" },
+        { value: "integer", label: "Integer" },
+        { value: "boolean", label: "Boolean" },
+        { value: "enum", label: "String with allowed values" }
+      ]
+    });
+    exitIfCancelled2(typeValue);
+    const type = typeValue;
+    let required = false;
+    if (type !== "boolean") {
+      const options = hasOptional ? [{ value: false, label: "Optional" }] : [
+        { value: true, label: "Required" },
+        { value: false, label: "Optional" }
+      ];
+      const requiredValue = await select2({ message: "Required or optional?", options });
+      exitIfCancelled2(requiredValue);
+      required = requiredValue;
+    }
+    if (!required) hasOptional = true;
+    let allowedValues;
+    if (type === "enum") {
+      const valuesInput = await text2({
+        message: "Allowed values (comma-separated)",
+        validate: (value) => {
+          const values = value.split(",").map((v) => v.trim()).filter(Boolean);
+          if (values.length < 2) return "Enter at least two comma-separated values.";
+          for (const v of values) {
+            if (!/^[A-Za-z0-9_-]+$/.test(v)) {
+              return `Invalid value "${v}": use only letters, numbers, hyphens, and underscores.`;
+            }
+          }
+          return void 0;
+        }
+      });
+      exitIfCancelled2(valuesInput);
+      allowedValues = valuesInput.split(",").map((v) => v.trim()).filter(Boolean);
+    }
+    parameters.push({ name, type, required, allowedValues });
+  }
+  return parameters;
+}
+async function runAddWizard(targetDir, deps) {
+  intro2("clispark add \u2014 add a new command");
+  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];
+  const parameters = await collectParameters();
+  log2.info(`About to create "${fullPathSegments.join(" ")}" with ${parameters.length} parameter(s).`);
+  const proceed = await confirm({ message: "Proceed?" });
+  exitIfCancelled2(proceed);
+  if (!proceed) {
+    cancel2("Cancelled.");
+    process.exit(1);
+  }
+  const spec = { pathSegments: fullPathSegments, parameters };
+  const result = await deps.commandGenerator.generateCommand(targetDir, spec);
+  outro2(`Created ${result.commandFile} and ${result.testFile}.`);
+}
+
 // src/whoami.ts
 import os from "os";
 var JOKE_API_URL = "https://v2.jokeapi.dev/joke/Programming,Miscellaneous";
-var FETCH_TIMEOUT_MS3 = 3e3;
+var FETCH_TIMEOUT_MS4 = 3e3;
 var SUPPORTED_JOKE_LANGUAGES = ["cs", "de", "en", "es", "fr", "pt"];
 var LOGO = String.raw`
       ⚡ clispark
@@ -843,7 +1441,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_MS3) });
+    const response = await fetchFn(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS4) });
     if (!response.ok) return void 0;
     const data = await response.json();
     if (data.error) return void 0;
@@ -896,7 +1494,7 @@ function resolvePack(language) {
 program.action(
   (options) => withLogging("scaffold", async (logger) => {
     const answers = await runWizard();
-    const targetDir = path9.join(process.cwd(), answers.projectName);
+    const targetDir = path14.join(process.cwd(), answers.projectName);
     const pack = resolvePack(answers.language);
     logger.info({ projectName: answers.projectName, targetDir, language: pack.id }, "scaffold started");
     await scaffoldProject(
@@ -937,6 +1535,17 @@ program.command("releasenotes").description("Show what changed between this proj
     console.log(formatReleaseNotes(result));
   })
 );
+program.command("add").description("Add a new command to an already-scaffolded project").action(
+  withLogging("add", async (logger) => {
+    const targetDir = process.cwd();
+    const manifest = await requireManifest(targetDir);
+    const language = manifest.language ?? "node";
+    const pack = resolvePack(language);
+    logger.info({ targetDir, language }, "add started");
+    await runAddWizard(targetDir, { commandGenerator: pack.commandGenerator });
+    logger.info({}, "add completed");
+  })
+);
 function resolveWhoamiMode(options) {
   if (options.joke && options.fact) {
     throw new UserError("Use either --joke or --fact, not both.");