@savvy-web/changesets 0.1.0

package/bin/savvy-changesets.js

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+import { Args, Command, Options } from "@effect/cli";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { execSync } from "node:child_process";
+import { findProjectRoot, getWorkspaceInfos } from "workspace-tools";
+import { readFileSync, ChangelogTransformer, ChangesetLinter, existsSync, resolve, mkdirSync, writeFileSync, join } from "../273.js";
+import { Data, Effect } from "../245.js";
+const dirArg = Args.directory({
+    name: "dir"
+}).pipe(Args.withDefault(".changeset"));
+function runCheck(dir) {
+    return Effect.gen(function*() {
+        const resolved = resolve(dir);
+        const messages = yield* Effect["try"](()=>ChangesetLinter.validate(resolved));
+        const byFile = new Map();
+        for (const msg of messages){
+            const existing = byFile.get(msg.file);
+            if (existing) existing.push(msg);
+            else byFile.set(msg.file, [
+                msg
+            ]);
+        }
+        for (const [file, fileMessages] of byFile){
+            yield* Effect.log(`\n${file}`);
+            for (const msg of fileMessages)yield* Effect.log(`  ${msg.line}:${msg.column}  ${msg.rule}  ${msg.message}`);
+        }
+        const errorCount = messages.length;
+        const filesWithErrors = byFile.size;
+        if (errorCount > 0) {
+            yield* Effect.log(`\n${filesWithErrors} file(s) with errors, ${errorCount} error(s) found`);
+            process.exitCode = 1;
+        } else yield* Effect.log("All changeset files passed validation.");
+    });
+}
+const checkCommand = Command.make("check", {
+    dir: dirArg
+}, ({ dir })=>runCheck(dir)).pipe(Command.withDescription("Full changeset validation with summary"));
+const CUSTOM_RULES_ENTRY = "@savvy-web/changesets/markdownlint";
+const CHANGELOG_ENTRY = "@savvy-web/changesets/changelog";
+const BASE_CONFIG_PATH = "lib/configs/.markdownlint-cli2.jsonc";
+const RULE_NAMES = [
+    "changeset-heading-hierarchy",
+    "changeset-required-sections",
+    "changeset-content-structure"
+];
+const DEFAULT_CONFIG = {
+    $schema: "https://unpkg.com/@changesets/config@3.1.1/schema.json",
+    changelog: [
+        CHANGELOG_ENTRY,
+        {
+            repo: "owner/repo"
+        }
+    ],
+    commit: false,
+    access: "restricted",
+    baseBranch: "main",
+    updateInternalDependencies: "patch",
+    ignore: [],
+    privatePackages: {
+        tag: true,
+        version: true
+    }
+};
+const InitErrorBase = Data.TaggedError("InitError");
+class InitError extends InitErrorBase {
+    get message() {
+        return `Init failed at ${this.step}: ${this.reason}`;
+    }
+}
+const forceOption = Options.boolean("force").pipe(Options.withAlias("f"), Options.withDescription("Overwrite existing config files"), Options.withDefault(false));
+const quietOption = Options.boolean("quiet").pipe(Options.withAlias("q"), Options.withDescription("Silence warnings, always exit 0"), Options.withDefault(false));
+const markdownlintOption = Options.boolean("markdownlint").pipe(Options.withDescription("Register rules in base markdownlint config"), Options.withDefault(true));
+function detectGitHubRepo(cwd) {
+    try {
+        const url = execSync("git remote get-url origin", {
+            cwd,
+            encoding: "utf-8"
+        }).trim();
+        const https = url.match(/github\.com\/([^/]+)\/([^/.]+)/);
+        if (https) return `${https[1]}/${https[2]}`;
+        const ssh = url.match(/github\.com:([^/]+)\/([^/.]+)/);
+        if (ssh) return `${ssh[1]}/${ssh[2]}`;
+    } catch  {}
+    return null;
+}
+function stripJsoncComments(text) {
+    return text.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function resolveWorkspaceRoot(cwd) {
+    return findProjectRoot(cwd) ?? cwd;
+}
+function ensureChangesetDir(root) {
+    return Effect["try"]({
+        try: ()=>{
+            const dir = join(root, ".changeset");
+            mkdirSync(dir, {
+                recursive: true
+            });
+            return dir;
+        },
+        catch: (error)=>new InitError({
+                step: ".changeset directory",
+                reason: error instanceof Error ? error.message : String(error)
+            })
+    });
+}
+function handleConfig(changesetDir, repoSlug, force) {
+    return Effect["try"]({
+        try: ()=>{
+            const configPath = join(changesetDir, "config.json");
+            if (force || !existsSync(configPath)) {
+                const config = {
+                    ...DEFAULT_CONFIG,
+                    changelog: [
+                        CHANGELOG_ENTRY,
+                        {
+                            repo: repoSlug
+                        }
+                    ]
+                };
+                writeFileSync(configPath, `${JSON.stringify(config, null, "\t")}\n`);
+                return force ? "Overwrote .changeset/config.json" : "Created .changeset/config.json";
+            }
+            const existing = JSON.parse(readFileSync(configPath, "utf-8"));
+            existing.changelog = [
+                CHANGELOG_ENTRY,
+                {
+                    repo: repoSlug
+                }
+            ];
+            writeFileSync(configPath, `${JSON.stringify(existing, null, "\t")}\n`);
+            return "Patched changelog in .changeset/config.json";
+        },
+        catch: (error)=>new InitError({
+                step: ".changeset/config.json",
+                reason: error instanceof Error ? error.message : String(error)
+            })
+    });
+}
+function handleBaseMarkdownlint(root) {
+    return Effect["try"]({
+        try: ()=>{
+            const baseConfigPath = join(root, BASE_CONFIG_PATH);
+            if (!existsSync(baseConfigPath)) return null;
+            const raw = readFileSync(baseConfigPath, "utf-8");
+            const parsed = JSON.parse(stripJsoncComments(raw));
+            if (!Array.isArray(parsed.customRules)) parsed.customRules = [];
+            if (!parsed.customRules.includes(CUSTOM_RULES_ENTRY)) parsed.customRules.push(CUSTOM_RULES_ENTRY);
+            if ("object" != typeof parsed.config || null === parsed.config) parsed.config = {};
+            for (const rule of RULE_NAMES)if (!(rule in parsed.config)) parsed.config[rule] = false;
+            writeFileSync(baseConfigPath, `${JSON.stringify(parsed, null, "\t")}\n`);
+            return "Updated lib/configs/.markdownlint-cli2.jsonc";
+        },
+        catch: (error)=>new InitError({
+                step: "lib/configs/.markdownlint-cli2.jsonc",
+                reason: error instanceof Error ? error.message : String(error)
+            })
+    });
+}
+function handleChangesetMarkdownlint(changesetDir, root, force) {
+    return Effect["try"]({
+        try: ()=>{
+            const mdlintPath = join(changesetDir, ".markdownlint.json");
+            const hasBaseConfig = existsSync(join(root, BASE_CONFIG_PATH));
+            if (force || !existsSync(mdlintPath)) {
+                const mdlintConfig = {};
+                if (hasBaseConfig) mdlintConfig.extends = `../${BASE_CONFIG_PATH}`;
+                mdlintConfig.default = false;
+                mdlintConfig.MD041 = false;
+                for (const rule of RULE_NAMES)mdlintConfig[rule] = true;
+                writeFileSync(mdlintPath, `${JSON.stringify(mdlintConfig, null, "\t")}\n`);
+                return force ? "Overwrote .changeset/.markdownlint.json" : "Created .changeset/.markdownlint.json";
+            }
+            const existing = JSON.parse(readFileSync(mdlintPath, "utf-8"));
+            for (const rule of RULE_NAMES)existing[rule] = true;
+            writeFileSync(mdlintPath, `${JSON.stringify(existing, null, "\t")}\n`);
+            return "Patched rules in .changeset/.markdownlint.json";
+        },
+        catch: (error)=>new InitError({
+                step: ".changeset/.markdownlint.json",
+                reason: error instanceof Error ? error.message : String(error)
+            })
+    });
+}
+const initCommand = Command.make("init", {
+    force: forceOption,
+    quiet: quietOption,
+    markdownlint: markdownlintOption
+}, ({ force, quiet, markdownlint })=>Effect.gen(function*() {
+        const root = resolveWorkspaceRoot(process.cwd());
+        const repo = detectGitHubRepo(root);
+        if (!repo && !quiet) yield* Effect.log("Warning: could not detect GitHub repo from git remote, using placeholder");
+        const repoSlug = repo ?? "owner/repo";
+        const changesetDir = yield* ensureChangesetDir(root);
+        yield* Effect.log("Ensured .changeset/ directory");
+        const errors = [];
+        const configResult = yield* handleConfig(changesetDir, repoSlug, force).pipe(Effect.either);
+        if ("Right" === configResult._tag) yield* Effect.log(configResult.right);
+        else errors.push(configResult.left);
+        if (markdownlint) {
+            const baseResult = yield* handleBaseMarkdownlint(root).pipe(Effect.either);
+            if ("Right" === baseResult._tag) {
+                if (baseResult.right) yield* Effect.log(baseResult.right);
+            } else errors.push(baseResult.left);
+        }
+        const mdlintResult = yield* handleChangesetMarkdownlint(changesetDir, root, force).pipe(Effect.either);
+        if ("Right" === mdlintResult._tag) yield* Effect.log(mdlintResult.right);
+        else errors.push(mdlintResult.left);
+        if (errors.length > 0) {
+            for (const err of errors)yield* Effect.logError(err.message);
+            if (!quiet) process.exitCode = 1;
+            return;
+        }
+        yield* Effect.log("Init complete.");
+    }).pipe(Effect.catchAll((error)=>Effect.gen(function*() {
+            if (!quiet) {
+                yield* Effect.logError(error instanceof InitError ? error.message : `Init failed: ${String(error)}`);
+                process.exitCode = 1;
+            }
+        })))).pipe(Command.withDescription("Bootstrap a repo for @savvy-web/changesets"));
+const lint_dirArg = Args.directory({
+    name: "dir"
+}).pipe(Args.withDefault(".changeset"));
+const lint_quietOption = Options.boolean("quiet").pipe(Options.withAlias("q"), Options.withDescription("Only output errors, no summary"), Options.withDefault(false));
+function runLint(dir, quiet) {
+    return Effect.gen(function*() {
+        const resolved = resolve(dir);
+        const messages = yield* Effect["try"](()=>ChangesetLinter.validate(resolved));
+        for (const msg of messages)yield* Effect.log(`${msg.file}:${msg.line}:${msg.column} ${msg.rule} ${msg.message}`);
+        if (!quiet && 0 === messages.length) yield* Effect.log("No lint errors found.");
+        if (messages.length > 0) process.exitCode = 1;
+    });
+}
+const lintCommand = Command.make("lint", {
+    dir: lint_dirArg,
+    quiet: lint_quietOption
+}, ({ dir, quiet })=>runLint(dir, quiet)).pipe(Command.withDescription("Validate changeset files"));
+const fileArg = Args.file({
+    name: "file"
+}).pipe(Args.withDefault("CHANGELOG.md"));
+const dryRunOption = Options.boolean("dry-run").pipe(Options.withAlias("n"), Options.withDescription("Print transformed output instead of writing"), Options.withDefault(false));
+const checkOption = Options.boolean("check").pipe(Options.withAlias("c"), Options.withDescription("Exit 1 if file would change (for CI)"), Options.withDefault(false));
+function runTransform(file, dryRun, check) {
+    return Effect.gen(function*() {
+        const resolved = resolve(file);
+        const content = yield* Effect["try"](()=>readFileSync(resolved, "utf-8"));
+        const result = ChangelogTransformer.transformContent(content);
+        if (dryRun) return void (yield* Effect.log(result));
+        if (check) {
+            if (result !== content) {
+                yield* Effect.log(`${resolved} would be modified by transform.`);
+                process.exitCode = 1;
+            } else yield* Effect.log(`${resolved} is already formatted.`);
+            return;
+        }
+        yield* Effect["try"](()=>writeFileSync(resolved, result, "utf-8"));
+        yield* Effect.log(`Transformed ${resolved}`);
+    });
+}
+const transformCommand = Command.make("transform", {
+    file: fileArg,
+    dryRun: dryRunOption,
+    check: checkOption
+}, ({ file, dryRun, check })=>runTransform(file, dryRun, check)).pipe(Command.withDescription("Post-process CHANGELOG.md"));
+class Workspace {
+    static detectPackageManager(cwd = process.cwd()) {
+        const packageJsonPath = join(cwd, "package.json");
+        if (!existsSync(packageJsonPath)) return "npm";
+        try {
+            const content = readFileSync(packageJsonPath, "utf-8");
+            const pkg = JSON.parse(content);
+            if (pkg.packageManager) {
+                const match = pkg.packageManager.match(/^(npm|pnpm|yarn|bun)@/);
+                if (match) return match[1];
+            }
+        } catch  {}
+        return "npm";
+    }
+    static getChangesetVersionCommand(pm) {
+        switch(pm){
+            case "pnpm":
+                return "pnpm exec changeset version";
+            case "yarn":
+                return "yarn exec changeset version";
+            case "bun":
+                return "bun x changeset version";
+            default:
+                return "npx changeset version";
+        }
+    }
+    static discoverChangelogs(cwd = process.cwd()) {
+        const resolvedCwd = resolve(cwd);
+        const results = [];
+        const seen = new Set();
+        try {
+            const workspaces = getWorkspaceInfos(resolvedCwd) ?? [];
+            for (const ws of workspaces){
+                const changelogPath = join(ws.path, "CHANGELOG.md");
+                if (existsSync(changelogPath) && !seen.has(ws.path)) {
+                    seen.add(ws.path);
+                    results.push({
+                        name: ws.name,
+                        path: ws.path,
+                        changelogPath
+                    });
+                }
+            }
+        } catch  {}
+        if (!seen.has(resolvedCwd)) {
+            const rootChangelog = join(resolvedCwd, "CHANGELOG.md");
+            if (existsSync(rootChangelog)) {
+                let rootName = "root";
+                try {
+                    const pkg = JSON.parse(readFileSync(join(resolvedCwd, "package.json"), "utf-8"));
+                    if (pkg.name) rootName = pkg.name;
+                } catch  {}
+                results.push({
+                    name: rootName,
+                    path: resolvedCwd,
+                    changelogPath: rootChangelog
+                });
+            }
+        }
+        return results;
+    }
+}
+const version_dryRunOption = Options.boolean("dry-run").pipe(Options.withAlias("n"), Options.withDescription("Skip changeset version, only transform existing CHANGELOGs"), Options.withDefault(false));
+function runVersion(dryRun) {
+    return Effect.gen(function*() {
+        const cwd = process.cwd();
+        const pm = Workspace.detectPackageManager(cwd);
+        yield* Effect.log(`Detected package manager: ${pm}`);
+        if (dryRun) yield* Effect.log("Dry run: skipping changeset version");
+        else {
+            const cmd = Workspace.getChangesetVersionCommand(pm);
+            yield* Effect.log(`Running: ${cmd}`);
+            yield* Effect["try"]({
+                try: ()=>execSync(cmd, {
+                        cwd,
+                        stdio: "inherit"
+                    }),
+                catch: (error)=>new Error(`changeset version failed: ${error instanceof Error ? error.message : String(error)}`)
+            });
+        }
+        const changelogs = Workspace.discoverChangelogs(cwd);
+        if (0 === changelogs.length) return void (yield* Effect.log("No CHANGELOG.md files found."));
+        yield* Effect.log(`Found ${changelogs.length} CHANGELOG.md file(s)`);
+        for (const entry of changelogs){
+            yield* Effect["try"]({
+                try: ()=>ChangelogTransformer.transformFile(entry.changelogPath),
+                catch: (error)=>new Error(`Failed to transform ${entry.changelogPath}: ${error instanceof Error ? error.message : String(error)}`)
+            });
+            yield* Effect.log(`Transformed ${entry.name} → ${entry.changelogPath}`);
+        }
+    });
+}
+const versionCommand = Command.make("version", {
+    dryRun: version_dryRunOption
+}, ({ dryRun })=>runVersion(dryRun)).pipe(Command.withDescription("Run changeset version and transform all CHANGELOGs"));
+const rootCommand = Command.make("savvy-changesets").pipe(Command.withSubcommands([
+    initCommand,
+    lintCommand,
+    transformCommand,
+    checkCommand,
+    versionCommand
+]));
+const cli = Command.run(rootCommand, {
+    name: "savvy-changesets",
+    version: "0.1.0"
+});
+function runCli() {
+    const main = Effect.suspend(()=>cli(process.argv)).pipe(Effect.provide(NodeContext.layer));
+    NodeRuntime.runMain(main);
+}
+runCli();

package/changelog.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Changesets API changelog formatter.
+ *
+ * This module exports the `ChangelogFunctions` required by the Changesets API.
+ * Configure in `.changeset/config.json`:
+ *
+ * ```json
+ * {
+ *   "changelog": ["\@savvy-web/changesets/changelog", { "repo": "savvy-web/package-name" }]
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+import { ChangelogFunctions } from '@changesets/types';
+
+declare const changelogFunctions: ChangelogFunctions;
+export default changelogFunctions;
+
+export { }

package/changelog.js

@@ -0,0 +1 @@
+export { default } from "./160.js";