clispark 1.14.0 → 1.15.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path9 from "path";
+import path12 from "path";
 import { Command } from "commander";
 
 // src/wizard.ts
@@ -212,9 +212,14 @@ 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/packs/node-oclif.ts
@@ -239,13 +244,223 @@ 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
+  }
+};
+
+// src/languages/packs/dotnet.ts
+import path7 from "path";
+
+// src/update/adapters/dotnet.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import path5 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(path5.join(dir, "src", "Cli.csproj"), "utf8");
+    return parseManifestFile(content);
+  },
+  async writeManifestFile(dir, content) {
+    await writeFile3(path5.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, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import path6 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 = path6.join(targetDir, "src", "Cli.csproj");
+  const content = await readFile4(csprojPath, "utf8");
+  const updated = content.replace(
+    /(<PropertyGroup>\s*\n)/,
+    "$1    <IsPackable>false</IsPackable>\n"
+  );
+  await writeFile4(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 mkdir(targetDir, { recursive: true });
+  await writeFile4(path6.join(targetDir, "NuGet.config"), config);
+}
+var nugetRegistryChecker = {
+  checkNameAvailability: checkNameAvailability2,
+  applyPrivateIntent: applyPrivateIntent2,
+  applyRegistryUrl: applyRegistryUrl2
+};
+
+// 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: path7.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
   }
 };
 
 // src/languages/index.ts
 var LANGUAGE_PACKS = {
-  [nodeOclifPack.id]: nodeOclifPack
+  [nodeOclifPack.id]: nodeOclifPack,
+  [dotnetPack.id]: dotnetPack
 };
 
 // src/wizard.ts
@@ -324,15 +539,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, readFile as readFile6, rename, writeFile as writeFile6 } from "fs/promises";
+import path9 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 mkdir2, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/errors.ts
@@ -350,7 +565,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 readFile5(path8.join(dir, relativePath), "utf8");
       return [relativePath, hashContent(content)];
     })
   );
@@ -362,15 +577,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 = path8.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 = path8.join(targetDir, MANIFEST_RELATIVE_PATH);
+  await mkdir2(path8.dirname(manifestPath), { recursive: true });
+  await writeFile5(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 readFile5(path8.join(targetDir, MANIFEST_RELATIVE_PATH), "utf8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -386,14 +601,14 @@ async function requireManifest(targetDir) {
   return manifest;
 }
 function getGeneratorVersion() {
-  let dir = path5.dirname(fileURLToPath2(import.meta.url));
+  let dir = path8.dirname(fileURLToPath2(import.meta.url));
   while (true) {
-    const pkgPath = path5.join(dir, "package.json");
+    const pkgPath = path8.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 = path8.dirname(dir);
     if (parentDir === dir) {
       throw new Error("Could not locate clispark's own package.json.");
     }
@@ -420,7 +635,7 @@ async function collectFiles(dir) {
   const entries = await readdir(dir, { withFileTypes: true });
   const files = await Promise.all(
     entries.map((entry) => {
-      const fullPath = path6.join(dir, entry.name);
+      const fullPath = path9.join(dir, entry.name);
       return entry.isDirectory() ? collectFiles(fullPath) : Promise.resolve([fullPath]);
     })
   );
@@ -430,9 +645,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 readFile6(filePath, "utf8");
       if (content.includes("{{projectName}}")) {
-        await writeFile4(filePath, applyPlaceholders(content, projectName));
+        await writeFile6(filePath, applyPlaceholders(content, projectName));
       }
     })
   );
@@ -441,14 +656,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(path9.join(targetDir, "gitignore"), path9.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 +695,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 path10 from "path";
 import envPaths from "env-paths";
 import pino from "pino";
 var paths = envPaths("clispark", { suffix: "" });
@@ -517,7 +731,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 = path10.join(logDir, SWEEP_MARKER_FILE);
     let shouldSweep = true;
     try {
       shouldSweep = Date.now() - statSync(markerPath).mtimeMs >= SWEEP_THROTTLE_MS;
@@ -527,7 +741,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 = path10.join(logDir, file);
       if (statSync(filePath).mtimeMs < cutoffMs) {
         unlinkSync(filePath);
       }
@@ -538,7 +752,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 = path10.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 +790,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 mkdir3, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
+import path11 from "path";
 import spawn2 from "cross-spawn";
 
 // src/update/releasenotes.ts
@@ -595,7 +809,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 +817,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 +877,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 readFile7(path11.join(templateDir, adapter.manifestFileName), "utf8"),
     projectName
   );
   const newTemplateManifestFile = adapter.parseManifestFile(newTemplateRaw);
@@ -673,13 +887,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 readFile7(path11.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 readFile7(path11.join(targetDir, relativePath), "utf8"));
       } catch {
         currentHash = void 0;
       }
@@ -691,13 +905,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: path11.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 readFile7(path11.join(targetDir, relativePath), "utf8");
       files.push({ path: relativePath, outcome: "no-longer-core" });
     } catch {
     }
@@ -719,8 +933,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 mkdir3(path11.dirname(write.targetPath), { recursive: true });
+    await writeFile7(write.targetPath, write.content);
   }
   if (fileMerge.changed) {
     await adapter.writeManifestFile(targetDir, fileMerge.updatedFile);
@@ -785,7 +999,7 @@ function formatUpdateSummary(result) {
 // 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 +1057,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 +1110,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 = path12.join(process.cwd(), answers.projectName);
     const pack = resolvePack(answers.language);
     logger.info({ projectName: answers.projectName, targetDir, language: pack.id }, "scaffold started");
     await scaffoldProject(