@changesmith/cli 1.4.0

package/dist/index.js

@@ -0,0 +1,1258 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command8 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/config.ts
+import Conf from "conf";
+import { readFile, writeFile, access } from "fs/promises";
+import { join } from "path";
+var CONFIG_FILE = ".changesmith.json";
+var userConfig = new Conf({
+  projectName: "changesmith",
+  schema: {
+    token: { type: "string" },
+    userId: { type: "string" },
+    apiUrl: { type: "string" }
+  }
+});
+function getApiUrl() {
+  return getEnvApiUrl() ?? userConfig.get("apiUrl") ?? "https://api.changesmith.dev";
+}
+function setApiUrl(url) {
+  userConfig.set("apiUrl", url);
+}
+var MIN_TOKEN_LENGTH = 50;
+var MAX_TOKEN_LENGTH = 4096;
+function getEnvToken() {
+  const raw = process.env.CHANGESMITH_TOKEN?.trim();
+  return raw || void 0;
+}
+function getEnvApiUrl() {
+  const raw = process.env.CHANGESMITH_API_URL?.trim();
+  if (!raw) return void 0;
+  if (!envApiUrlWarned) {
+    try {
+      new URL(raw);
+    } catch {
+      envApiUrlWarned = true;
+      console.error(
+        `Warning: CHANGESMITH_API_URL is not a valid URL ("${raw}") \u2014 API calls may fail.`
+      );
+    }
+  }
+  return raw;
+}
+var envTokenWarned = false;
+var envApiUrlWarned = false;
+function warnIfEnvTokenSuspicious() {
+  const envToken = getEnvToken();
+  if (!envToken || envTokenWarned) return;
+  if (envToken.length < MIN_TOKEN_LENGTH) {
+    envTokenWarned = true;
+    console.error("Warning: CHANGESMITH_TOKEN looks too short \u2014 API calls may fail.");
+  } else if (envToken.length > MAX_TOKEN_LENGTH) {
+    envTokenWarned = true;
+    console.error("Warning: CHANGESMITH_TOKEN is unusually long \u2014 this may not be a valid token.");
+  }
+}
+function getAuthToken() {
+  return getEnvToken() ?? userConfig.get("token");
+}
+function setAuthToken(token) {
+  userConfig.set("token", token);
+}
+function getUserId() {
+  return userConfig.get("userId");
+}
+function setUserId(id) {
+  userConfig.set("userId", id);
+}
+function clearAuth() {
+  userConfig.delete("token");
+  userConfig.delete("userId");
+}
+function isLoggedIn() {
+  return !!getAuthToken();
+}
+function isEnvAuth() {
+  return !!getEnvToken();
+}
+function isEnvApiUrl() {
+  return !!getEnvApiUrl();
+}
+function hasStoredToken() {
+  return !!userConfig.get("token");
+}
+function getProjectConfigPath(cwd = process.cwd()) {
+  return join(cwd, CONFIG_FILE);
+}
+async function projectConfigExists(cwd = process.cwd()) {
+  try {
+    await access(getProjectConfigPath(cwd));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readProjectConfig(cwd = process.cwd()) {
+  try {
+    const content = await readFile(getProjectConfigPath(cwd), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function writeProjectConfig(config, cwd = process.cwd()) {
+  await writeFile(getProjectConfigPath(cwd), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function getDefaultProjectConfig() {
+  return {
+    version: 1,
+    excludeTypes: ["chore", "style", "ci"]
+  };
+}
+
+// src/git.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { access as access2 } from "fs/promises";
+import { join as join2 } from "path";
+var execAsync = promisify(exec);
+var SAFE_GIT_REF = /^[\w./@^~{}\-]+$/;
+function assertSafeRef(ref) {
+  if (!SAFE_GIT_REF.test(ref)) {
+    throw new Error(`Invalid git ref: "${ref}"`);
+  }
+}
+async function git(args, cwd = process.cwd()) {
+  const { stdout } = await execAsync(`git ${args}`, { cwd, maxBuffer: 10 * 1024 * 1024 });
+  return stdout.trim();
+}
+async function isGitRepo(cwd = process.cwd()) {
+  try {
+    await access2(join2(cwd, ".git"));
+    return true;
+  } catch {
+    try {
+      await git("rev-parse --git-dir", cwd);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+async function getDefaultBranch(cwd = process.cwd()) {
+  try {
+    const remoteBranch = await git("symbolic-ref refs/remotes/origin/HEAD --short", cwd);
+    return remoteBranch.replace("origin/", "");
+  } catch {
+    try {
+      await git("show-ref --verify refs/heads/main", cwd);
+      return "main";
+    } catch {
+      return "master";
+    }
+  }
+}
+async function getRemoteUrl(cwd = process.cwd()) {
+  try {
+    const url = await git("remote get-url origin", cwd);
+    return url;
+  } catch {
+    return null;
+  }
+}
+function parseRepoFromUrl(url) {
+  const sshMatch = url.match(/git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return { owner: sshMatch[1], repo: sshMatch[2] };
+  }
+  const httpsMatch = url.match(/https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    return { owner: httpsMatch[1], repo: httpsMatch[2] };
+  }
+  return null;
+}
+async function getTags(cwd = process.cwd()) {
+  try {
+    const output = await git("tag --sort=-version:refname", cwd);
+    if (!output) return [];
+    return output.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function getLatestTag(cwd = process.cwd()) {
+  try {
+    return await git("describe --tags --abbrev=0", cwd);
+  } catch {
+    return null;
+  }
+}
+async function getPreviousTag(tag, cwd = process.cwd()) {
+  assertSafeRef(tag);
+  try {
+    return await git(`describe --tags --abbrev=0 ${tag}^`, cwd);
+  } catch {
+    return null;
+  }
+}
+async function getGitRoot(cwd = process.cwd()) {
+  return git("rev-parse --show-toplevel", cwd);
+}
+async function isShallowClone(cwd = process.cwd()) {
+  try {
+    const result = await git("rev-parse --is-shallow-repository", cwd);
+    return result === "true";
+  } catch {
+    return false;
+  }
+}
+async function getCommitsBetween(from, to, cwd = process.cwd()) {
+  assertSafeRef(from);
+  assertSafeRef(to);
+  const format = "%x00%x01%H%x00%an%x00%aI%x00%B";
+  const output = await git(`log ${from}..${to} --format="${format}" --no-merges`, cwd);
+  if (!output) return [];
+  const commits = [];
+  const rawCommits = output.split("\0
").filter(Boolean);
+  for (const raw of rawCommits) {
+    const parts = raw.split("\0");
+    if (parts.length < 4) continue;
+    const sha = parts[0].trim();
+    const author = parts[1].trim();
+    const date = parts[2].trim();
+    const message = parts.slice(3).join("\0").trim();
+    if (sha) {
+      commits.push({ sha, message, author, date });
+    }
+  }
+  return commits;
+}
+async function getCommitDiff(sha, cwd = process.cwd()) {
+  assertSafeRef(sha);
+  const output = await git(`show ${sha} --numstat -p --format=""`, cwd);
+  const patchStart = output.search(/^diff --git /m);
+  const numstatSection = patchStart !== -1 ? output.slice(0, patchStart) : output;
+  const patchSection = patchStart !== -1 ? output.slice(patchStart) : "";
+  const fileStats = /* @__PURE__ */ new Map();
+  for (const line of numstatSection.split("\n").filter(Boolean)) {
+    const match2 = line.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+    if (match2) {
+      const additions = match2[1] === "-" ? 0 : parseInt(match2[1], 10);
+      const deletions = match2[2] === "-" ? 0 : parseInt(match2[2], 10);
+      const filename = match2[3];
+      if (match2[1] !== "-" || match2[2] !== "-") {
+        fileStats.set(filename, { additions, deletions });
+      }
+    }
+  }
+  const files = [];
+  const filePatchRegex = /^diff --git a\/(.+?) b\/(.+?)$/gm;
+  const patchParts = [];
+  let match;
+  while ((match = filePatchRegex.exec(patchSection)) !== null) {
+    patchParts.push({ filename: match[2], startIndex: match.index });
+  }
+  for (let i = 0; i < patchParts.length; i++) {
+    const part = patchParts[i];
+    const endIndex = i + 1 < patchParts.length ? patchParts[i + 1].startIndex : patchSection.length;
+    const filePatch = patchSection.substring(part.startIndex, endIndex).trim();
+    const stats = fileStats.get(part.filename);
+    if (!stats) continue;
+    let status = "modified";
+    if (filePatch.includes("new file mode")) {
+      status = "added";
+    } else if (filePatch.includes("deleted file mode")) {
+      status = "deleted";
+    } else if (filePatch.includes("rename from")) {
+      status = "renamed";
+    }
+    files.push({
+      filename: part.filename,
+      status,
+      additions: stats.additions,
+      deletions: stats.deletions,
+      patch: filePatch
+    });
+  }
+  return { sha, files };
+}
+async function deriveRepoName(cwd = process.cwd()) {
+  const remoteUrl = await getRemoteUrl(cwd);
+  if (remoteUrl) {
+    const ghInfo = parseRepoFromUrl(remoteUrl);
+    if (ghInfo) {
+      return `${ghInfo.owner}/${ghInfo.repo}`;
+    }
+    const genericMatch = remoteUrl.match(/[/:]([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (genericMatch) {
+      return genericMatch[1];
+    }
+  }
+  const { basename } = await import("path");
+  return basename(cwd);
+}
+
+// src/commands/init.ts
+var initCommand = new Command("init").description("Initialize Changesmith in the current repository").option("-f, --force", "Overwrite existing config").action(async (options) => {
+  const spinner = ora("Detecting git repository...").start();
+  if (!await isGitRepo()) {
+    spinner.fail("Not a git repository");
+    console.log(chalk.gray("Run this command from the root of a git repository."));
+    process.exit(1);
+  }
+  spinner.succeed("Git repository detected");
+  if (await projectConfigExists()) {
+    if (!options.force) {
+      console.log(chalk.yellow("Changesmith is already initialized in this repository."));
+      console.log(chalk.gray(`Config file: ${getProjectConfigPath()}`));
+      console.log(chalk.gray("Use --force to overwrite the existing config."));
+      process.exit(0);
+    }
+  }
+  const defaultBranch = await getDefaultBranch();
+  const remoteUrl = await getRemoteUrl();
+  const repoInfo = remoteUrl ? parseRepoFromUrl(remoteUrl) : null;
+  const config = {
+    ...getDefaultProjectConfig(),
+    defaultBranch
+  };
+  const writeSpinner = ora("Creating config file...").start();
+  await writeProjectConfig(config);
+  writeSpinner.succeed("Created .changesmith.json");
+  console.log("");
+  console.log(chalk.green("Changesmith initialized successfully!"));
+  console.log("");
+  if (repoInfo) {
+    console.log(chalk.gray(`Repository: ${repoInfo.owner}/${repoInfo.repo}`));
+  }
+  console.log(chalk.gray(`Default branch: ${defaultBranch}`));
+  console.log("");
+  console.log("Next steps:");
+  console.log(chalk.cyan("  1. ") + "Log in to Changesmith:");
+  console.log(chalk.gray("     changesmith login"));
+  console.log("");
+  console.log(chalk.cyan("  2. ") + "Generate a changelog:");
+  console.log(chalk.gray("     changesmith generate v1.0.0"));
+  console.log("");
+  console.log(chalk.gray(`Edit ${getProjectConfigPath()} to customize changelog generation.`));
+});
+
+// src/commands/generate.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { writeFile as writeFile3 } from "fs/promises";
+
+// src/api.ts
+var ApiError = class extends Error {
+  constructor(status, message, code) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+    this.code = code;
+  }
+  /** Structured error code from the API response JSON (e.g. 'expired_token', 'authorization_pending') */
+  code;
+};
+async function request(path, options = {}, tokenOverride) {
+  const apiUrl = getApiUrl();
+  warnIfEnvTokenSuspicious();
+  const token = tokenOverride ?? getAuthToken();
+  const headers = {
+    ...options.headers || {}
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (options.body && !headers["Content-Type"]) {
+    headers["Content-Type"] = "application/json";
+  }
+  const response = await fetch(`${apiUrl}${path}`, {
+    ...options,
+    headers
+  });
+  if (!response.ok) {
+    switch (response.status) {
+      case 401: {
+        let message;
+        if (tokenOverride) {
+          message = "Not authenticated. The provided token may be invalid or expired.";
+        } else if (isEnvAuth()) {
+          message = "Not authenticated. CHANGESMITH_TOKEN may be invalid or expired.";
+        } else {
+          message = "Not authenticated. Run `changesmith login` to log in.";
+        }
+        throw new ApiError(401, message);
+      }
+      case 402:
+        throw new ApiError(402, "Usage limit reached. Upgrade your plan at changesmith.dev.");
+      case 403: {
+        let msg = "CLI access requires a Business plan. Upgrade at changesmith.dev/dashboard/settings";
+        try {
+          const json = await response.json();
+          if (typeof json.message === "string" && json.message.length > 0) {
+            msg = json.message;
+          }
+        } catch {
+        }
+        throw new ApiError(403, msg);
+      }
+      case 404:
+        throw new ApiError(404, "Not found.");
+      default: {
+        const text = await response.text().catch(() => response.statusText);
+        let code;
+        let displayText = text;
+        try {
+          const json = JSON.parse(text);
+          if (typeof json === "object" && json !== null) {
+            if (typeof json.error === "string" && json.error.length > 0) {
+              code = json.error;
+            } else if (typeof json.code === "string" && json.code.length > 0) {
+              code = json.code;
+            }
+            displayText = typeof json.message === "string" && json.message || typeof json.error === "string" && json.error || text;
+          }
+        } catch {
+        }
+        if (displayText.length > 200) {
+          displayText = displayText.substring(0, 200) + "...";
+        }
+        displayText = displayText.replace(/at [^\s]+\.(ts|js|mjs|cjs):\d+/g, "[internal]");
+        throw new ApiError(response.status, `API error (${response.status}): ${displayText}`, code);
+      }
+    }
+  }
+  return response.json();
+}
+function getMe(token) {
+  return request("/auth/me", {}, token);
+}
+function getRepoByName(owner, repo) {
+  return request(
+    `/api/repos/by-name/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`
+  );
+}
+function startGeneration(repoId, body) {
+  return request(`/api/repos/${repoId}/generate`, {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+}
+function getChangelog(changelogId) {
+  return request(`/api/changelogs/${changelogId}`);
+}
+function deviceAuthStart() {
+  return request("/auth/device/start", {
+    method: "POST"
+  });
+}
+function deviceAuthPoll(deviceCode) {
+  return request("/auth/device/poll", {
+    method: "POST",
+    body: JSON.stringify({ deviceCode })
+  });
+}
+function startLocalGeneration(body) {
+  return request("/api/generate/local", {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+}
+function getLocalGenerationResult(jobId) {
+  return request(
+    `/api/generate/local/${encodeURIComponent(jobId)}`
+  );
+}
+
+// src/changelog.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { resolve } from "path";
+import { prependReleaseSection } from "@changesmith/core";
+async function prependToChangelog(content, version, rootDir) {
+  const changelogPath = resolve(rootDir || process.cwd(), "CHANGELOG.md");
+  let existing;
+  try {
+    existing = await readFile2(changelogPath, "utf-8");
+  } catch {
+  }
+  if (existing) {
+    const updated = prependReleaseSection(existing, content, version);
+    await writeFile2(changelogPath, updated, "utf-8");
+  } else {
+    await writeFile2(changelogPath, `# Changelog
+
+${content}
+`, "utf-8");
+  }
+}
+
+// src/commands/generate.ts
+var POLL_INTERVAL_MS = 5e3;
+var POLL_TIMEOUT_MS = 10 * 60 * 1e3;
+var githubCommand = new Command2("github").description("Generate a changelog via GitHub App (requires installation)").argument("[version]", "Version tag to generate changelog for (e.g., v1.0.0)").option("--from <tag>", "Starting tag/commit (defaults to previous tag)").option("--to <ref>", "Ending ref (defaults to the version tag)").option("-o, --output <file>", "Output file (defaults to stdout)").option("-w, --write", "Prepend to CHANGELOG.md").action(async (version, options) => {
+  if (!isLoggedIn()) {
+    console.error(chalk2.red("Error: Not logged in"));
+    console.log(chalk2.gray("Run `changesmith login` to authenticate."));
+    process.exit(1);
+  }
+  if (!await isGitRepo()) {
+    console.error(chalk2.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  let targetVersion = version;
+  if (!targetVersion) {
+    const latestTag = await getLatestTag();
+    if (latestTag) {
+      targetVersion = latestTag;
+      console.log(chalk2.gray(`Using latest tag: ${targetVersion}`));
+    } else {
+      console.error(chalk2.red("Error: No version specified and no tags found"));
+      console.log(chalk2.gray("Usage: changesmith github v1.0.0 [-w] [-o file]"));
+      process.exit(1);
+    }
+  }
+  const remoteUrl = await getRemoteUrl();
+  const repoInfo = remoteUrl ? parseRepoFromUrl(remoteUrl) : null;
+  if (!repoInfo) {
+    console.error(chalk2.red("Error: Could not determine repository from git remote"));
+    console.log(chalk2.gray("Make sure your repository has a GitHub remote configured."));
+    process.exit(1);
+  }
+  const repoSpinner = ora2("Looking up repository...").start();
+  let repoId;
+  try {
+    const repo = await getRepoByName(repoInfo.owner, repoInfo.repo);
+    repoId = repo.id;
+    repoSpinner.succeed(`Repository: ${chalk2.cyan(repo.fullName)}`);
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 404) {
+      repoSpinner.fail("Repository not connected to Changesmith");
+      const appUrl = deriveWebUrl(getApiUrl());
+      console.log("");
+      console.log("To connect this repository:");
+      console.log(chalk2.cyan("  1. ") + `Visit ${chalk2.underline(`${appUrl}/dashboard/repos`)}`);
+      console.log(chalk2.cyan("  2. ") + 'Click "Add Repository" and install the GitHub App');
+      console.log(chalk2.cyan("  3. ") + "Select this repository for access");
+      process.exit(1);
+    }
+    repoSpinner.fail("Failed to look up repository");
+    console.error(chalk2.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+  const genSpinner = ora2("Starting changelog generation...").start();
+  let changelogId;
+  try {
+    const result = await startGeneration(repoId, {
+      version: targetVersion,
+      fromTag: options.from,
+      toTag: options.to
+    });
+    changelogId = result.changelogId;
+    genSpinner.succeed(`Generation queued (${result.fromTag} \u2192 ${targetVersion})`);
+  } catch (error) {
+    genSpinner.fail("Failed to start generation");
+    console.error(chalk2.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+  const gitRoot = await getGitRoot();
+  const pollSpinner = ora2("Generating changelog...").start();
+  const startTime = Date.now();
+  try {
+    while (Date.now() - startTime < POLL_TIMEOUT_MS) {
+      const elapsed = Math.floor((Date.now() - startTime) / 1e3);
+      pollSpinner.text = `Generating changelog... (${elapsed}s)`;
+      await sleep(POLL_INTERVAL_MS);
+      const changelog = await getChangelog(changelogId);
+      if (changelog.status === "draft" || changelog.status === "approved") {
+        pollSpinner.succeed("Changelog generated");
+        if (options.write) {
+          await prependToChangelog(changelog.content, targetVersion, gitRoot);
+          console.log(chalk2.green("CHANGELOG.md updated"));
+        } else if (options.output) {
+          await writeFile3(options.output, changelog.content + "\n", "utf-8");
+          console.log(chalk2.green(`Changelog written to ${options.output}`));
+        } else {
+          console.log("");
+          console.log(chalk2.cyan("\u2500".repeat(60)));
+          console.log(changelog.content);
+          console.log(chalk2.cyan("\u2500".repeat(60)));
+        }
+        return;
+      }
+      if (changelog.status === "failed") {
+        const errorMsg = changelog.metadata?.errorMessage || "Unknown error";
+        pollSpinner.fail("Changelog generation failed");
+        console.error(chalk2.red(String(errorMsg)));
+        process.exit(1);
+      }
+      if (changelog.status === "published") {
+        pollSpinner.succeed("Changelog already published");
+        console.log(changelog.content);
+        return;
+      }
+    }
+    pollSpinner.fail("Generation timed out");
+    console.error(chalk2.red("Changelog generation did not complete within 10 minutes."));
+    console.log(chalk2.gray("Check the dashboard for status."));
+    process.exit(1);
+  } catch (error) {
+    pollSpinner.fail("Error while waiting for generation");
+    console.error(chalk2.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+});
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function deriveWebUrl(apiUrlString) {
+  try {
+    const apiUrl = new URL(apiUrlString);
+    if (apiUrl.hostname.startsWith("api.")) {
+      return `${apiUrl.protocol}//${apiUrl.hostname.slice(4)}`;
+    }
+    return apiUrl.origin;
+  } catch {
+    return apiUrlString;
+  }
+}
+
+// src/commands/local.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora3 from "ora";
+import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+var POLL_INTERVAL_MS2 = 3e3;
+var POLL_TIMEOUT_MS2 = 10 * 60 * 1e3;
+var MAX_TOTAL_DIFF_BYTES = 3 * 1024 * 1024;
+var MAX_COMMITS = 500;
+var localCommand = new Command3("local").description("Generate a changelog from local git commits (no GitHub App required)").argument("[version]", "Version tag to generate changelog for (e.g., v1.0.0)").option("--from <ref>", "Starting ref (defaults to the tag before version)").option("--to <ref>", "Ending ref (defaults to HEAD or the version tag)").option("-o, --output <file>", "Write output to a specific file").option("-w, --write", "Prepend to CHANGELOG.md").action(async (version, options) => {
+  if (!isLoggedIn()) {
+    console.error(chalk3.red("Error: Not logged in"));
+    console.log(chalk3.gray("Run `changesmith login` to authenticate."));
+    process.exit(1);
+  }
+  if (!await isGitRepo()) {
+    console.error(chalk3.red("Error: Not a git repository"));
+    process.exit(1);
+  }
+  if (await isShallowClone()) {
+    console.error(chalk3.yellow("Warning: This is a shallow clone. Commit history may be incomplete."));
+    console.log(chalk3.gray("For full history, run: git fetch --unshallow"));
+  }
+  let targetVersion = version;
+  if (!targetVersion) {
+    const latestTag = await getLatestTag();
+    if (latestTag) {
+      targetVersion = latestTag;
+      console.log(chalk3.gray(`Using latest tag: ${targetVersion}`));
+    } else {
+      console.error(chalk3.red("Error: No version specified and no tags found"));
+      console.log(chalk3.gray("Usage: changesmith local v1.0.0"));
+      console.log(chalk3.gray("  or:  changesmith local v1.0.0 --from HEAD~50"));
+      process.exit(1);
+    }
+  }
+  const toRef = options.to || targetVersion;
+  let fromRef = options.from;
+  if (!fromRef) {
+    const prevTag = await getPreviousTag(targetVersion);
+    if (prevTag) {
+      fromRef = prevTag;
+      console.log(chalk3.gray(`Using previous tag as start: ${fromRef}`));
+    } else {
+      console.error(chalk3.red("Error: No previous tag found."));
+      console.log(
+        chalk3.gray("Specify a starting ref with --from:")
+      );
+      console.log(chalk3.gray(`  changesmith local ${targetVersion} --from HEAD~50`));
+      console.log(chalk3.gray(`  changesmith local ${targetVersion} --from abc1234`));
+      process.exit(1);
+    }
+  }
+  const commitSpinner = ora3("Collecting commits...").start();
+  let commits;
+  try {
+    commits = await getCommitsBetween(fromRef, toRef);
+  } catch (error) {
+    commitSpinner.fail("Failed to collect commits");
+    console.error(chalk3.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+  if (commits.length === 0) {
+    commitSpinner.fail("No commits found in the specified range");
+    console.log(chalk3.gray(`Range: ${fromRef}..${toRef}`));
+    process.exit(1);
+  }
+  if (commits.length > MAX_COMMITS) {
+    commitSpinner.text = `Found ${commits.length} commits, using first ${MAX_COMMITS}`;
+    commits = commits.slice(0, MAX_COMMITS);
+  }
+  commitSpinner.succeed(`Found ${commits.length} commits (${fromRef}..${toRef})`);
+  const diffSpinner = ora3("Collecting diffs...").start();
+  const diffs = [];
+  let totalDiffBytes = 0;
+  let skippedDiffs = 0;
+  for (let i = 0; i < commits.length; i++) {
+    const commit = commits[i];
+    diffSpinner.text = `Collecting diffs... (${i + 1}/${commits.length})`;
+    if (totalDiffBytes >= MAX_TOTAL_DIFF_BYTES) {
+      skippedDiffs = commits.length - i;
+      break;
+    }
+    try {
+      const diff = await getCommitDiff(commit.sha);
+      const diffSize = JSON.stringify(diff).length;
+      if (totalDiffBytes + diffSize > MAX_TOTAL_DIFF_BYTES) {
+        skippedDiffs = commits.length - i;
+        break;
+      }
+      diffs.push(diff);
+      totalDiffBytes += diffSize;
+    } catch {
+    }
+  }
+  if (skippedDiffs > 0) {
+    diffSpinner.succeed(
+      `Collected diffs for ${diffs.length} commits (${skippedDiffs} skipped \u2014 3MB limit)`
+    );
+  } else {
+    diffSpinner.succeed(`Collected diffs for ${diffs.length} commits`);
+  }
+  const gitRoot = await getGitRoot();
+  let existingChangelog;
+  try {
+    existingChangelog = await readFile3(resolve2(gitRoot, "CHANGELOG.md"), "utf-8");
+  } catch {
+  }
+  const projectConfig = await readProjectConfig();
+  const customInstructions = projectConfig?.customPrompt;
+  const repoName = await deriveRepoName();
+  const genSpinner = ora3("Starting changelog generation...").start();
+  let jobId;
+  try {
+    const result = await startLocalGeneration({
+      version: targetVersion,
+      repoName,
+      commits,
+      diffs,
+      existingChangelog,
+      customInstructions
+    });
+    jobId = result.jobId;
+    genSpinner.succeed("Generation queued");
+  } catch (error) {
+    genSpinner.fail("Failed to start generation");
+    if (error instanceof ApiError && error.status === 413) {
+      console.error(chalk3.red("Payload too large. Try a smaller commit range."));
+    } else {
+      console.error(chalk3.red(error instanceof Error ? error.message : String(error)));
+    }
+    process.exit(1);
+  }
+  const pollSpinner = ora3("Generating changelog...").start();
+  const startTime = Date.now();
+  try {
+    while (Date.now() - startTime < POLL_TIMEOUT_MS2) {
+      const elapsed = Math.floor((Date.now() - startTime) / 1e3);
+      pollSpinner.text = `Generating changelog... (${elapsed}s)`;
+      await sleep2(POLL_INTERVAL_MS2);
+      const result = await getLocalGenerationResult(jobId);
+      if (result.status === "completed" && result.content) {
+        pollSpinner.succeed("Changelog generated");
+        if (options.write) {
+          await prependToChangelog(result.content, targetVersion, gitRoot);
+          console.log(chalk3.green("CHANGELOG.md updated"));
+        } else if (options.output) {
+          await writeFile4(options.output, result.content + "\n", "utf-8");
+          console.log(chalk3.green(`Changelog written to ${options.output}`));
+        } else {
+          console.log("");
+          console.log(chalk3.cyan("\u2500".repeat(60)));
+          console.log(result.content);
+          console.log(chalk3.cyan("\u2500".repeat(60)));
+        }
+        return;
+      }
+      if (result.status === "error") {
+        pollSpinner.fail("Changelog generation failed");
+        console.error(chalk3.red(result.error || "Unknown error"));
+        process.exit(1);
+      }
+    }
+    pollSpinner.fail("Generation timed out");
+    console.error(chalk3.red("Changelog generation did not complete within 10 minutes."));
+    process.exit(1);
+  } catch (error) {
+    pollSpinner.fail("Error while waiting for generation");
+    console.error(chalk3.red(error instanceof Error ? error.message : String(error)));
+    process.exit(1);
+  }
+});
+function sleep2(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// src/commands/login.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import ora4 from "ora";
+var MIN_POLL_INTERVAL_MS = 5e3;
+var MAX_POLL_INTERVAL_MS = 6e4;
+var loginCommand = new Command4("login").description("Log in to Changesmith").option("--token <token>", "Use a pre-generated auth token (for CI/automation)").action(async (options) => {
+  if (options.token) {
+    await validateAndSaveToken(options.token, { showEnvWarning: isEnvAuth() });
+    return;
+  }
+  if (isEnvAuth()) {
+    console.log(chalk4.yellow("Already authenticated via CHANGESMITH_TOKEN environment variable."));
+    console.log(chalk4.gray("Unset CHANGESMITH_TOKEN to use stored credentials instead."));
+    return;
+  }
+  if (isLoggedIn()) {
+    console.log(chalk4.yellow("You are already logged in."));
+    console.log(chalk4.gray("Run `changesmith logout` to log out first."));
+    return;
+  }
+  await deviceAuthFlow();
+});
+async function validateAndSaveToken(token, opts = {}) {
+  const spinner = ora4("Validating token...").start();
+  try {
+    if (token.length < MIN_TOKEN_LENGTH || token.length > MAX_TOKEN_LENGTH) {
+      throw new Error("Invalid token format.");
+    }
+    const user = await getMe(token);
+    setAuthToken(token);
+    setUserId(user.id);
+    if (opts.showEnvWarning) {
+      spinner.succeed(
+        `Token saved for ${chalk4.cyan(user.githubLogin)}` + chalk4.yellow(" (CHANGESMITH_TOKEN currently takes precedence)")
+      );
+      console.log(chalk4.gray("Unset CHANGESMITH_TOKEN to use stored credentials."));
+    } else {
+      spinner.succeed(`Logged in as ${chalk4.cyan(user.githubLogin)}`);
+    }
+  } catch (error) {
+    spinner.fail("Token validation failed");
+    if (error instanceof ApiError) {
+      console.error(chalk4.red(error.message));
+    } else if (error instanceof TypeError && error.message.includes("fetch")) {
+      console.error(chalk4.red("Unable to connect to API server. Check your network connection."));
+    } else if (error instanceof Error && error.name === "AbortError") {
+      console.error(chalk4.red("Request timed out. The API server is not responding."));
+    } else if (error instanceof Error && error.message === "Invalid token format.") {
+      console.error(chalk4.red(error.message));
+    } else {
+      console.error(chalk4.red("Token validation failed. Please try again."));
+    }
+    process.exit(1);
+  }
+}
+async function deviceAuthFlow() {
+  const apiUrl = getApiUrl();
+  console.log(chalk4.cyan("Changesmith Login"));
+  console.log("");
+  const spinner = ora4("Starting authentication...").start();
+  try {
+    const data = await deviceAuthStart();
+    spinner.stop();
+    console.log("To authenticate, visit:");
+    console.log("");
+    console.log(chalk4.cyan(`  ${data.verificationUri}`));
+    console.log("");
+    console.log("And enter this code:");
+    console.log("");
+    console.log(chalk4.bold.green(`  ${data.userCode}`));
+    console.log("");
+    const pollSpinner = ora4("Waiting for authentication...").start();
+    const token = await pollForToken(data.deviceCode, data.interval, data.expiresIn);
+    if (!token) {
+      pollSpinner.fail("Authentication timed out");
+      process.exit(1);
+    }
+    try {
+      const user = await getMe(token);
+      setAuthToken(token);
+      setUserId(user.id);
+      pollSpinner.succeed(`Logged in as ${chalk4.cyan(user.githubLogin)}`);
+    } catch {
+      setAuthToken(token);
+      pollSpinner.succeed("Logged in");
+      console.log(
+        chalk4.yellow(
+          "Warning: Could not verify token. If commands fail, try `changesmith logout` and log in again."
+        )
+      );
+    }
+    console.log("");
+    console.log("You can now generate changelogs:");
+    console.log(chalk4.gray("  changesmith generate v1.0.0"));
+  } catch (error) {
+    spinner.fail("Authentication failed");
+    const appUrl = apiUrl.replace("/api", "").replace("api.", "");
+    console.log("");
+    console.log("To log in manually:");
+    console.log(chalk4.cyan("  1. ") + `Visit ${appUrl}/dashboard/settings`);
+    console.log(chalk4.cyan("  2. ") + "Generate an API token");
+    console.log(chalk4.cyan("  3. ") + "Run: changesmith login --token YOUR_TOKEN");
+  }
+}
+async function pollForToken(deviceCode, interval, expiresIn) {
+  const pollInterval = Math.max(
+    Math.min(interval * 1e3, MAX_POLL_INTERVAL_MS),
+    MIN_POLL_INTERVAL_MS
+  );
+  const safeExpiresIn = Math.max(60, Math.min(expiresIn, 3600));
+  const maxAttempts = Math.floor(safeExpiresIn * 1e3 / pollInterval);
+  const startTime = Date.now();
+  const absoluteTimeoutMs = safeExpiresIn * 1e3;
+  for (let i = 0; i < maxAttempts; i++) {
+    if (Date.now() - startTime >= absoluteTimeoutMs) {
+      return null;
+    }
+    await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+    try {
+      const data = await deviceAuthPoll(deviceCode);
+      return data.token;
+    } catch (error) {
+      if (error instanceof ApiError) {
+        if (error.code === "ERR_DEVICE_002") {
+          continue;
+        }
+        return null;
+      }
+      continue;
+    }
+  }
+  return null;
+}
+
+// src/commands/logout.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+var logoutCommand = new Command5("logout").description("Log out from Changesmith cloud").option("--clear-stored", "Remove stored credentials (useful when CHANGESMITH_TOKEN is set)").action(async (options) => {
+  if (options.clearStored) {
+    if (hasStoredToken()) {
+      clearAuth();
+      console.log(chalk5.green("Stored credentials cleared."));
+    } else {
+      console.log(chalk5.gray("No stored credentials to clear."));
+    }
+    if (isEnvAuth()) {
+      console.log(chalk5.gray("Still authenticated via CHANGESMITH_TOKEN."));
+    }
+    return;
+  }
+  if (isEnvAuth()) {
+    console.log(chalk5.yellow("Using CHANGESMITH_TOKEN environment variable."));
+    console.log(chalk5.gray("Unset the environment variable to log out:"));
+    console.log(chalk5.gray("  unset CHANGESMITH_TOKEN"));
+    if (hasStoredToken()) {
+      console.log("");
+      console.log(
+        chalk5.gray("Note: Stored credentials are preserved. Use --clear-stored to remove them.")
+      );
+    }
+    return;
+  }
+  if (!isLoggedIn()) {
+    console.log(chalk5.gray("You are not logged in."));
+    return;
+  }
+  clearAuth();
+  console.log(chalk5.green("Logged out successfully."));
+});
+
+// src/commands/status.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+var statusCommand = new Command6("status").description("Show Changesmith status for the current repository").action(async () => {
+  console.log(chalk6.cyan("Changesmith Status"));
+  console.log("");
+  const isRepo = await isGitRepo();
+  console.log(`Git repository: ${isRepo ? chalk6.green("Yes") : chalk6.red("No")}`);
+  if (isRepo) {
+    const remoteUrl = await getRemoteUrl();
+    const repoInfo = remoteUrl ? parseRepoFromUrl(remoteUrl) : null;
+    if (repoInfo) {
+      console.log(`Repository:     ${chalk6.white(`${repoInfo.owner}/${repoInfo.repo}`)}`);
+    }
+    const latestTag = await getLatestTag();
+    const tags = await getTags();
+    console.log(`Latest tag:     ${latestTag ? chalk6.white(latestTag) : chalk6.gray("none")}`);
+    console.log(`Total tags:     ${chalk6.white(tags.length.toString())}`);
+  }
+  console.log("");
+  const hasConfig = await projectConfigExists();
+  console.log(
+    `Project config: ${hasConfig ? chalk6.green(".changesmith.json") : chalk6.gray("not initialized")}`
+  );
+  if (hasConfig) {
+    const config = await readProjectConfig();
+    if (config) {
+      if (config.excludeTypes?.length) {
+        console.log(`Excluded types: ${chalk6.gray(config.excludeTypes.join(", "))}`);
+      }
+      if (config.customPrompt) {
+        console.log(`Custom prompt:  ${chalk6.green("configured")}`);
+      }
+    }
+  }
+  console.log("");
+  const loggedIn = isLoggedIn();
+  const envAuth = isEnvAuth();
+  if (envAuth) {
+    console.log(`Logged in:      ${chalk6.green("yes")} ${chalk6.gray("(via CHANGESMITH_TOKEN)")}`);
+  } else {
+    console.log(`Logged in:      ${loggedIn ? chalk6.green("yes") : chalk6.gray("no")}`);
+  }
+  if (loggedIn) {
+    try {
+      const user = await getMe();
+      console.log(`User:           ${chalk6.white(user.githubLogin)}`);
+      console.log(`Plan:           ${chalk6.white(user.plan)}`);
+    } catch {
+    }
+  }
+  console.log("");
+  if (!hasConfig) {
+    console.log(chalk6.gray("Run `changesmith init` to initialize this repository."));
+  } else if (!loggedIn) {
+    console.log(chalk6.gray("Run `changesmith login` to authenticate."));
+  } else {
+    console.log(chalk6.gray("Run `changesmith generate` to create a changelog."));
+  }
+});
+
+// src/commands/config.ts
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+var configCommand = new Command7("config").description("View or modify configuration").addCommand(
+  new Command7("show").description("Show current configuration").option("--project", "Show project config only").option("--user", "Show user config only").action(async (options) => {
+    if (!options.user) {
+      await showProjectConfig();
+    }
+    if (!options.project) {
+      showUserConfig();
+    }
+  })
+).addCommand(
+  new Command7("set").description("Set a configuration value").argument("<key>", "Config key to set").argument("<value>", "Value to set").option("--global", "Set in user config (default is project config)").action(async (key, value, options) => {
+    if (options.global) {
+      setUserConfigValue(key, value);
+    } else {
+      await setProjectConfigValue(key, value);
+    }
+  })
+).addCommand(
+  new Command7("get").description("Get a configuration value").argument("<key>", "Config key to get").option("--global", "Get from user config (default is project config)").action(async (key, options) => {
+    if (options.global) {
+      getUserConfigValue(key);
+    } else {
+      await getProjectConfigValue(key);
+    }
+  })
+).addCommand(
+  new Command7("reset").description("Reset project config to defaults").option("-f, --force", "Skip confirmation").action(async (options) => {
+    if (!await projectConfigExists()) {
+      console.log(chalk7.yellow("No project config found."));
+      console.log(chalk7.gray("Run `changesmith init` first."));
+      return;
+    }
+    if (!options.force) {
+      console.log(chalk7.yellow("This will reset .changesmith.json to defaults."));
+      console.log(chalk7.gray("Use --force to confirm."));
+      return;
+    }
+    await writeProjectConfig(getDefaultProjectConfig());
+    console.log(chalk7.green("Project config reset to defaults."));
+  })
+);
+async function showProjectConfig() {
+  console.log(chalk7.cyan("Project Configuration"));
+  console.log(chalk7.gray(`  File: ${getProjectConfigPath()}`));
+  console.log("");
+  if (!await projectConfigExists()) {
+    console.log(chalk7.gray("  No project config found."));
+    console.log(chalk7.gray("  Run `changesmith init` to create one."));
+    console.log("");
+    return;
+  }
+  const config = await readProjectConfig();
+  if (!config) {
+    console.log(chalk7.red("  Error reading config file."));
+    console.log("");
+    return;
+  }
+  console.log(chalk7.white("  version:        ") + config.version);
+  if (config.defaultBranch) {
+    console.log(chalk7.white("  defaultBranch:  ") + config.defaultBranch);
+  }
+  if (config.excludeTypes?.length) {
+    console.log(chalk7.white("  excludeTypes:   ") + config.excludeTypes.join(", "));
+  }
+  if (config.includeScopes?.length) {
+    console.log(chalk7.white("  includeScopes:  ") + config.includeScopes.join(", "));
+  }
+  if (config.excludeScopes?.length) {
+    console.log(chalk7.white("  excludeScopes:  ") + config.excludeScopes.join(", "));
+  }
+  if (config.styleGuide) {
+    console.log(chalk7.white("  styleGuide:     ") + config.styleGuide);
+  }
+  if (config.customPrompt) {
+    console.log(chalk7.white("  customPrompt:   ") + chalk7.green("(configured)"));
+  }
+  console.log("");
+}
+function showUserConfig() {
+  console.log(chalk7.cyan("User Configuration"));
+  console.log("");
+  if (isEnvApiUrl()) {
+    console.log(chalk7.white("  apiUrl:         ") + getApiUrl() + chalk7.gray(" (via env)"));
+  } else {
+    console.log(chalk7.white("  apiUrl:         ") + getApiUrl());
+  }
+  const loggedIn = isLoggedIn();
+  const envAuth = isEnvAuth();
+  if (envAuth) {
+    console.log(chalk7.white("  loggedIn:       ") + chalk7.green("yes") + chalk7.gray(" (via env)"));
+  } else {
+    console.log(
+      chalk7.white("  loggedIn:       ") + (loggedIn ? chalk7.green("yes") : chalk7.gray("no"))
+    );
+  }
+  if (!envAuth && isLoggedIn()) {
+    const userId = getUserId();
+    if (userId) {
+      console.log(chalk7.white("  userId:         ") + userId);
+    }
+  }
+  console.log("");
+}
+function setUserConfigValue(key, value) {
+  switch (key) {
+    case "apiUrl":
+      try {
+        new URL(value);
+      } catch {
+        console.log(chalk7.red(`Invalid URL: ${value}`));
+        process.exit(1);
+      }
+      setApiUrl(value);
+      console.log(chalk7.green(`Set apiUrl to: ${value}`));
+      break;
+    default:
+      console.log(chalk7.red(`Unknown user config key: ${key}`));
+      console.log(chalk7.gray("Available keys: apiUrl"));
+      process.exit(1);
+  }
+}
+function getUserConfigValue(key) {
+  switch (key) {
+    case "apiUrl":
+      console.log(getApiUrl());
+      break;
+    default:
+      console.log(chalk7.red(`Unknown user config key: ${key}`));
+      console.log(chalk7.gray("Available keys: apiUrl"));
+      process.exit(1);
+  }
+}
+async function setProjectConfigValue(key, value) {
+  if (!await projectConfigExists()) {
+    console.log(chalk7.red("No project config found."));
+    console.log(chalk7.gray("Run `changesmith init` first."));
+    process.exit(1);
+  }
+  const config = await readProjectConfig();
+  if (!config) {
+    console.log(chalk7.red("Error reading config file."));
+    process.exit(1);
+  }
+  const validKeys = [
+    "defaultBranch",
+    "excludeTypes",
+    "includeScopes",
+    "excludeScopes",
+    "styleGuide",
+    "customPrompt"
+  ];
+  if (!validKeys.includes(key)) {
+    console.log(chalk7.red(`Unknown project config key: ${key}`));
+    console.log(chalk7.gray(`Available keys: ${validKeys.join(", ")}`));
+    process.exit(1);
+  }
+  const arrayKeys = ["excludeTypes", "includeScopes", "excludeScopes"];
+  if (arrayKeys.includes(key)) {
+    const arrayValue = value.split(",").map((s) => s.trim()).filter(Boolean);
+    const updatedConfig = { ...config, [key]: arrayValue };
+    await writeProjectConfig(updatedConfig);
+    console.log(chalk7.green(`Set ${key} to: [${arrayValue.join(", ")}]`));
+  } else {
+    const updatedConfig = { ...config, [key]: value };
+    await writeProjectConfig(updatedConfig);
+    console.log(chalk7.green(`Set ${key} to: ${value}`));
+  }
+}
+async function getProjectConfigValue(key) {
+  const validKeys = [
+    "version",
+    "defaultBranch",
+    "excludeTypes",
+    "includeScopes",
+    "excludeScopes",
+    "styleGuide",
+    "customPrompt"
+  ];
+  if (!validKeys.includes(key)) {
+    console.log(chalk7.red(`Unknown project config key: ${key}`));
+    console.log(chalk7.gray(`Available keys: ${validKeys.join(", ")}`));
+    process.exit(1);
+  }
+  if (!await projectConfigExists()) {
+    console.log(chalk7.red("No project config found."));
+    process.exit(1);
+  }
+  const config = await readProjectConfig();
+  if (!config) {
+    console.log(chalk7.red("Error reading config file."));
+    process.exit(1);
+  }
+  const configRecord = config;
+  const value = configRecord[key];
+  if (value === void 0) {
+    console.log(chalk7.gray("(not set)"));
+  } else if (Array.isArray(value)) {
+    console.log(value.join(", "));
+  } else {
+    console.log(String(value));
+  }
+}
+
+// src/index.ts
+var program = new Command8();
+program.name("changesmith").description("Generate beautiful changelogs from your git history").version("1.4.0");
+program.addCommand(initCommand);
+program.addCommand(localCommand);
+program.addCommand(githubCommand);
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(statusCommand);
+program.addCommand(configCommand);
+var generateAlias = new Command8("generate").description('Alias for "github" command').allowUnknownOption(true).allowExcessArguments(true).helpOption(false).action(async function() {
+  await githubCommand.parseAsync(["node", "github", ...generateAlias.args]);
+});
+program.addCommand(generateAlias, { hidden: true });
+program.parse();
+//# sourceMappingURL=index.js.map