@versionsmith/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,647 @@
+#!/usr/bin/env node
+
+// src/commands/init.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { input, confirm } from "@inquirer/prompts";
+
+// src/utils/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var DEFAULT_CONFIG = {
+  changelog: "CHANGELOG.md",
+  header: `# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).`
+};
+var VERSIONSMITH_DIR = ".versionsmith";
+var CONFIG_FILE = "config.json";
+function getVersionsmithDir(cwd = process.cwd()) {
+  return join(cwd, VERSIONSMITH_DIR);
+}
+function getConfigPath(cwd = process.cwd()) {
+  return join(cwd, VERSIONSMITH_DIR, CONFIG_FILE);
+}
+function readConfig(cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { ...DEFAULT_CONFIG, ...parsed };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function writeConfig(config, cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function isInitialized(cwd = process.cwd()) {
+  return existsSync(getConfigPath(cwd));
+}
+
+// src/commands/init.ts
+async function init(cwd = process.cwd()) {
+  const dir = getVersionsmithDir(cwd);
+  const configPath = getConfigPath(cwd);
+  if (isInitialized(cwd)) {
+    console.log(
+      `versionsmith is already initialized (found ${configPath.replace(cwd + "/", "")})`
+    );
+    const proceed = await confirm({
+      message: "Re-initialize and overwrite config?",
+      default: false
+    });
+    if (!proceed) {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  console.log("\nWelcome to versionsmith!\n");
+  console.log(
+    "This tool helps you manage changelogs following the Keep a Changelog format."
+  );
+  console.log("https://keepachangelog.com/en/1.1.0/\n");
+  const changelogFile = await input({
+    message: "Changelog file path:",
+    default: DEFAULT_CONFIG.changelog,
+    validate: (v) => v.trim().length > 0 ? true : "Cannot be empty"
+  });
+  console.log(
+    "\nCustomize your changelog header (the text before any release sections)."
+  );
+  console.log(`Default:
+${DEFAULT_CONFIG.header}
+`);
+  const useDefault = await confirm({
+    message: "Use the default header?",
+    default: true
+  });
+  let header = DEFAULT_CONFIG.header;
+  if (!useDefault) {
+    header = await input({
+      message: "Enter your changelog header (use \\n for newlines):",
+      default: DEFAULT_CONFIG.header.replace(/\n/g, "\\n"),
+      validate: (v) => v.trim().length > 0 ? true : "Cannot be empty"
+    });
+    header = header.replace(/\\n/g, "\n");
+  }
+  const config = {
+    changelog: changelogFile.trim(),
+    header
+  };
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeConfig(config, cwd);
+  const gitkeepPath = join2(dir, ".gitkeep");
+  if (!existsSync2(gitkeepPath)) {
+    writeFileSync2(gitkeepPath, "", "utf-8");
+  }
+  const changelogPath = join2(cwd, config.changelog);
+  if (!existsSync2(changelogPath)) {
+    const initialContent = config.header + "\n\n## [Unreleased]\n";
+    writeFileSync2(changelogPath, initialContent, "utf-8");
+    console.log(`
+Created ${config.changelog}`);
+  } else {
+    console.log(`
+${config.changelog} already exists, skipping creation.`);
+  }
+  console.log(`Created .versionsmith/config.json`);
+  console.log(`
+versionsmith initialized successfully!
+`);
+  console.log("Next steps:");
+  console.log("  npx @versionsmith/cli          - Create a new changelog entry");
+  console.log(
+    "  npx @versionsmith/cli release  - Merge entries into your changelog"
+  );
+  console.log(
+    "  npx @versionsmith/cli release --version 1.0.0  - Release a specific version"
+  );
+}
+
+// src/commands/add.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+import { checkbox, input as input2, confirm as confirm2 } from "@inquirer/prompts";
+
+// src/utils/changelog.ts
+var CHANGE_TYPES = [
+  "Added",
+  "Changed",
+  "Deprecated",
+  "Removed",
+  "Fixed",
+  "Security"
+];
+function parseChangeset(content) {
+  const entries = {};
+  let currentType = null;
+  for (const line of content.split("\n")) {
+    const typeMatch = line.match(/^###\s+(Added|Changed|Deprecated|Removed|Fixed|Security)\s*$/);
+    if (typeMatch) {
+      currentType = typeMatch[1];
+      if (!entries[currentType]) entries[currentType] = [];
+      continue;
+    }
+    if (currentType && line.startsWith("- ")) {
+      entries[currentType].push(line.slice(2).trim());
+    }
+  }
+  return { entries };
+}
+function renderEntries(entries) {
+  const parts = [];
+  for (const type of CHANGE_TYPES) {
+    const items = entries[type];
+    if (!items || items.length === 0) continue;
+    parts.push(`### ${type}
+`);
+    for (const item of items) {
+      parts.push(`- ${item}`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function mergeChangesets(changesets) {
+  const merged = {};
+  for (const cs of changesets) {
+    for (const type of CHANGE_TYPES) {
+      const items = cs.entries[type];
+      if (!items || items.length === 0) continue;
+      if (!merged[type]) merged[type] = [];
+      merged[type].push(...items);
+    }
+  }
+  return merged;
+}
+function parseChangelog(content) {
+  const lines = content.split("\n");
+  let headerLines = [];
+  let releases = [];
+  let currentRelease = null;
+  let currentType = null;
+  let foundFirstRelease = false;
+  for (const line of lines) {
+    const releaseMatch = line.match(
+      /^##\s+\[([^\]]+)\](?:\s+-\s+(\d{4}-\d{2}-\d{2}))?\s*$/
+    );
+    if (releaseMatch) {
+      if (currentRelease) {
+        releases.push(currentRelease);
+      }
+      foundFirstRelease = true;
+      currentType = null;
+      currentRelease = {
+        version: releaseMatch[1],
+        date: releaseMatch[2],
+        entries: {}
+      };
+      continue;
+    }
+    if (!foundFirstRelease) {
+      headerLines.push(line);
+      continue;
+    }
+    if (currentRelease) {
+      const typeMatch = line.match(
+        /^###\s+(Added|Changed|Deprecated|Removed|Fixed|Security)\s*$/
+      );
+      if (typeMatch) {
+        currentType = typeMatch[1];
+        if (!currentRelease.entries[currentType]) {
+          currentRelease.entries[currentType] = [];
+        }
+        continue;
+      }
+      if (currentType && line.startsWith("- ")) {
+        currentRelease.entries[currentType].push(line.slice(2).trim());
+        continue;
+      }
+      if (currentType && line.match(/^\s{2,}/) && currentRelease.entries[currentType].length > 0) {
+        const arr = currentRelease.entries[currentType];
+        arr[arr.length - 1] += "\n" + line;
+        continue;
+      }
+    }
+  }
+  if (currentRelease) {
+    releases.push(currentRelease);
+  }
+  while (headerLines.length > 0 && headerLines[headerLines.length - 1].trim() === "") {
+    headerLines.pop();
+  }
+  return { header: headerLines.join("\n"), releases };
+}
+function renderChangelog(header, releases) {
+  const parts = [header, ""];
+  for (const release2 of releases) {
+    const heading = release2.version === "Unreleased" ? "## [Unreleased]" : `## [${release2.version}] - ${release2.date}`;
+    parts.push(heading);
+    parts.push("");
+    const body = renderEntries(release2.entries);
+    if (body) {
+      parts.push(body);
+    }
+  }
+  const result = parts.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+  return result + "\n";
+}
+function insertUnreleased(parsed, newEntries) {
+  const releases = [...parsed.releases];
+  const unreleasedIdx = releases.findIndex((r) => r.version === "Unreleased");
+  if (unreleasedIdx === -1) {
+    releases.unshift({ version: "Unreleased", entries: newEntries });
+  } else {
+    const existing = releases[unreleasedIdx];
+    const merged = {};
+    for (const type of CHANGE_TYPES) {
+      const existingItems = existing.entries[type] ?? [];
+      const newItems = newEntries[type] ?? [];
+      if (existingItems.length > 0 || newItems.length > 0) {
+        merged[type] = [...existingItems, ...newItems];
+      }
+    }
+    releases[unreleasedIdx] = { ...existing, entries: merged };
+  }
+  return { ...parsed, releases };
+}
+function promoteToRelease(parsed, version, date, newEntries) {
+  const releases = [...parsed.releases];
+  const unreleasedIdx = releases.findIndex((r) => r.version === "Unreleased");
+  const existingUnreleased = unreleasedIdx !== -1 ? releases[unreleasedIdx].entries : {};
+  const mergedEntries = {};
+  for (const type of CHANGE_TYPES) {
+    const a = existingUnreleased[type] ?? [];
+    const b = newEntries[type] ?? [];
+    if (a.length > 0 || b.length > 0) {
+      mergedEntries[type] = [...a, ...b];
+    }
+  }
+  const newRelease = { version, date, entries: mergedEntries };
+  if (unreleasedIdx !== -1) {
+    releases.splice(unreleasedIdx, 1);
+  }
+  releases.unshift(newRelease);
+  releases.unshift({ version: "Unreleased", entries: {} });
+  return { ...parsed, releases };
+}
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+
+// src/utils/names.ts
+import { existsSync as existsSync3, readdirSync } from "fs";
+import { join as join3 } from "path";
+var ADJECTIVES = [
+  "ancient",
+  "brave",
+  "calm",
+  "dark",
+  "eager",
+  "fair",
+  "gentle",
+  "happy",
+  "idle",
+  "jolly",
+  "keen",
+  "lively",
+  "merry",
+  "noble",
+  "odd",
+  "plain",
+  "quiet",
+  "rapid",
+  "swift",
+  "tidy",
+  "ultra",
+  "vivid",
+  "warm",
+  "exact",
+  "young",
+  "amber",
+  "blunt",
+  "crisp",
+  "dull",
+  "early",
+  "faint",
+  "grand",
+  "harsh",
+  "icy",
+  "jazzy",
+  "kind",
+  "large",
+  "mild",
+  "neat",
+  "open",
+  "pale",
+  "quick",
+  "rare",
+  "slim",
+  "tall",
+  "urban",
+  "vast",
+  "wild",
+  "xeric",
+  "zesty"
+];
+var NOUNS = [
+  "anchor",
+  "bridge",
+  "castle",
+  "delta",
+  "ember",
+  "fjord",
+  "glacier",
+  "harbor",
+  "island",
+  "jungle",
+  "knoll",
+  "lagoon",
+  "meadow",
+  "nexus",
+  "ocean",
+  "peak",
+  "quarry",
+  "river",
+  "summit",
+  "tundra",
+  "uplift",
+  "valley",
+  "wetland",
+  "xenon",
+  "zenith",
+  "arrow",
+  "basin",
+  "canyon",
+  "dune",
+  "estuary",
+  "forest",
+  "gorge",
+  "heath",
+  "inlet",
+  "jetty",
+  "kelp",
+  "ledge",
+  "marsh",
+  "nova",
+  "orbit",
+  "pine",
+  "quartz",
+  "ridge",
+  "shore",
+  "trail",
+  "umbra",
+  "vortex",
+  "wave",
+  "xylem",
+  "yard"
+];
+function generateName(dir) {
+  const adjective = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)];
+  const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)];
+  const base = `${adjective}-${noun}`;
+  if (!existsSync3(dir)) {
+    return base;
+  }
+  const existing = new Set(
+    readdirSync(dir).map((f) => f.replace(/\.md$/, ""))
+  );
+  if (!existing.has(base)) {
+    return base;
+  }
+  let counter = 2;
+  while (existing.has(`${base}-${counter}`)) {
+    counter++;
+  }
+  return `${base}-${counter}`;
+}
+function changesetPath(dir, name) {
+  return join3(dir, `${name}.md`);
+}
+
+// src/commands/add.ts
+async function add(cwd = process.cwd()) {
+  if (!isInitialized(cwd)) {
+    console.error(
+      "versionsmith is not initialized. Run `npx @versionsmith/cli init` first."
+    );
+    process.exit(1);
+  }
+  const dir = getVersionsmithDir(cwd);
+  console.log("\nCreate a new changelog entry\n");
+  const selectedTypes = await checkbox({
+    message: "Select the type(s) of change (space to select, enter to confirm):",
+    choices: CHANGE_TYPES.map((t) => ({
+      name: t,
+      value: t,
+      description: typeDescription(t)
+    })),
+    validate: (v) => v.length > 0 ? true : "Select at least one change type."
+  });
+  const entries = {};
+  for (const type of selectedTypes) {
+    console.log(`
+  ${type} \u2014 ${typeDescription(type)}`);
+    const items = [];
+    let addAnother = true;
+    while (addAnother) {
+      const description = await input2({
+        message: `  Describe the ${type.toLowerCase()} change:`,
+        validate: (v) => v.trim().length > 0 ? true : "Description cannot be empty."
+      });
+      items.push(description.trim());
+      addAnother = await confirm2({
+        message: `  Add another ${type.toLowerCase()} entry?`,
+        default: false
+      });
+    }
+    entries[type] = items;
+  }
+  console.log("\n--- Preview ---");
+  console.log(renderEntries(entries));
+  console.log("---------------\n");
+  const confirmed = await confirm2({
+    message: "Save this changelog entry?",
+    default: true
+  });
+  if (!confirmed) {
+    console.log("Aborted. No file written.");
+    return;
+  }
+  const name = generateName(dir);
+  const filePath = changesetPath(dir, name);
+  const content = renderEntries(entries);
+  writeFileSync3(filePath, content, "utf-8");
+  console.log(`
+Saved: .versionsmith/${name}.md`);
+  console.log(
+    "\nCommit this file alongside your changes. When ready to release, run:"
+  );
+  console.log("  npx @versionsmith/cli release");
+}
+function typeDescription(type) {
+  switch (type) {
+    case "Added":
+      return "New features";
+    case "Changed":
+      return "Changes in existing functionality";
+    case "Deprecated":
+      return "Soon-to-be removed features";
+    case "Removed":
+      return "Now removed features";
+    case "Fixed":
+      return "Bug fixes";
+    case "Security":
+      return "Vulnerability fixes";
+  }
+}
+
+// src/commands/release.ts
+import {
+  existsSync as existsSync4,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync4,
+  unlinkSync
+} from "fs";
+import { join as join4 } from "path";
+async function release(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  if (!isInitialized(cwd)) {
+    console.error(
+      "versionsmith is not initialized. Run `npx @versionsmith/cli init` first."
+    );
+    process.exit(1);
+  }
+  const config = readConfig(cwd);
+  const dir = getVersionsmithDir(cwd);
+  const changelogPath = join4(cwd, config.changelog);
+  const files = existsSync4(dir) ? readdirSync2(dir).filter(
+    (f) => f.endsWith(".md") && f !== ".gitkeep"
+  ) : [];
+  if (files.length === 0 && !options.version) {
+    console.log("No changelog entries found in .versionsmith/");
+    console.log("Run `npx @versionsmith/cli` to create one.");
+    return;
+  }
+  const changesets = files.map((f) => {
+    const content = readFileSync2(join4(dir, f), "utf-8");
+    return parseChangeset(content);
+  });
+  const merged = mergeChangesets(changesets);
+  let parsed = { header: config.header, releases: [] };
+  if (existsSync4(changelogPath)) {
+    const existing = readFileSync2(changelogPath, "utf-8");
+    parsed = parseChangelog(existing);
+    if (!parsed.header.trim()) {
+      parsed = { ...parsed, header: config.header };
+    }
+  }
+  const dateStr = options.date ?? today();
+  let updated;
+  if (options.version) {
+    updated = promoteToRelease(parsed, options.version, dateStr, merged);
+    console.log(`
+Releasing version ${options.version} (${dateStr})
+`);
+  } else {
+    updated = insertUnreleased(parsed, merged);
+    console.log(`
+Merging entries into [Unreleased]
+`);
+  }
+  const rendered = renderChangelog(updated.header, updated.releases);
+  writeFileSync4(changelogPath, rendered, "utf-8");
+  for (const f of files) {
+    unlinkSync(join4(dir, f));
+  }
+  console.log(`Updated ${config.changelog}`);
+  if (files.length > 0) {
+    console.log(`Removed ${files.length} changeset file(s):
+`);
+    for (const f of files) {
+      console.log(`  - .versionsmith/${f}`);
+    }
+  }
+  console.log("\nDone! Review your changelog and commit the changes.");
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+function parseVersion(args2) {
+  const idx = args2.indexOf("--version");
+  if (idx !== -1 && args2[idx + 1]) {
+    return args2[idx + 1];
+  }
+  const flag = args2.find((a) => a.startsWith("--version="));
+  if (flag) {
+    return flag.split("=")[1];
+  }
+  return void 0;
+}
+function showHelp() {
+  console.log(`
+versionsmith \u2014 conflict-free changelog management
+
+USAGE
+  npx @versionsmith/cli [command] [options]
+
+COMMANDS
+  (no command)         Create a new changelog entry interactively
+  add                  Alias for the default command
+  init                 Initialize versionsmith in the current directory
+  release              Merge changeset entries into CHANGELOG.md
+
+OPTIONS
+  --version <version>  (release only) Create a versioned release entry
+  --help, -h           Show this help message
+
+EXAMPLES
+  npx @versionsmith/cli init
+  npx @versionsmith/cli
+  npx @versionsmith/cli add
+  npx @versionsmith/cli release
+  npx @versionsmith/cli release --version 1.2.0
+`);
+}
+async function main() {
+  if (args.includes("--help") || args.includes("-h")) {
+    showHelp();
+    return;
+  }
+  switch (command) {
+    case "init":
+      await init();
+      break;
+    case "release": {
+      const version = parseVersion(args.slice(1));
+      await release({ version });
+      break;
+    }
+    case "add":
+    case void 0:
+      await add();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      showHelp();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  if (err instanceof Error && (err.message.includes("force closed") || err.name === "ExitPromptError")) {
+    console.log("\nAborted.");
+    process.exit(0);
+  }
+  console.error("Error:", err instanceof Error ? err.message : err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@versionsmith/cli",
+  "version": "0.0.1",
+  "description": "A simple, conflict-free changelog management tool following Keep a Changelog",
+  "type": "module",
+  "bin": {
+    "versionsmith": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "node --test --experimental-strip-types src/__tests__/*.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}