@savvy-web/changesets 0.1.0

package/160.js

@@ -0,0 +1,404 @@
+import { getInfo } from "@changesets/get-github-info";
+import { Layer, unified, Schema, remark_stringify, Data, Effect, remark_gfm, remark_parse, Context } from "./245.js";
+import { external_mdast_util_to_string_toString } from "./689.js";
+import { resolveCommitType, fromHeading } from "./60.js";
+const ChangesetValidationErrorBase = Data.TaggedError("ChangesetValidationError");
+class ChangesetValidationError extends ChangesetValidationErrorBase {
+    get message() {
+        const prefix = this.file ? `${this.file}: ` : "";
+        const detail = this.issues.map((i)=>`  - ${i.path}: ${i.message}`).join("\n");
+        return `${prefix}Changeset validation failed:\n${detail}`;
+    }
+}
+const GitHubApiErrorBase = Data.TaggedError("GitHubApiError");
+class GitHubApiError extends GitHubApiErrorBase {
+    get message() {
+        const status = this.statusCode ? ` (${this.statusCode})` : "";
+        return `GitHub API error during ${this.operation}${status}: ${this.reason}`;
+    }
+    get isRateLimited() {
+        return 403 === this.statusCode || 429 === this.statusCode;
+    }
+    get isRetryable() {
+        return void 0 !== this.statusCode && (this.statusCode >= 500 || this.isRateLimited);
+    }
+}
+const MarkdownParseErrorBase = Data.TaggedError("MarkdownParseError");
+class MarkdownParseError extends MarkdownParseErrorBase {
+    get message() {
+        const loc = this.line ? `:${this.line}${this.column ? `:${this.column}` : ""}` : "";
+        const src = this.source ? `${this.source}${loc}: ` : "";
+        return `${src}Markdown parse error: ${this.reason}`;
+    }
+}
+const ConfigurationErrorBase = Data.TaggedError("ConfigurationError");
+class ConfigurationError extends ConfigurationErrorBase {
+    get message() {
+        return `Configuration error (${this.field}): ${this.reason}`;
+    }
+}
+const REPO_PATTERN = /^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/;
+const RepoSchema = Schema.String.pipe(Schema.pattern(REPO_PATTERN, {
+    message: ()=>'Repository must be in format "owner/repository" (e.g., "microsoft/vscode")'
+}));
+const ChangesetOptionsSchema = Schema.Struct({
+    repo: RepoSchema,
+    commitLinks: Schema.optional(Schema.Boolean),
+    prLinks: Schema.optional(Schema.Boolean),
+    issueLinks: Schema.optional(Schema.Boolean),
+    issuePrefixes: Schema.optional(Schema.Array(Schema.String))
+});
+function validateChangesetOptions(input) {
+    if (null == input) return Effect.fail(new ConfigurationError({
+        field: "options",
+        reason: 'Configuration is required. Add options to your changesets config:\n"changelog": ["@savvy-web/changesets", { "repo": "owner/repository" }]'
+    }));
+    if ("object" != typeof input) return Effect.fail(new ConfigurationError({
+        field: "options",
+        reason: "Configuration must be an object"
+    }));
+    const obj = input;
+    if (!("repo" in obj) || void 0 === obj.repo) return Effect.fail(new ConfigurationError({
+        field: "repo",
+        reason: 'Repository name is required. Add the "repo" option to your changesets config:\n"changelog": ["@savvy-web/changesets", { "repo": "owner/repository" }]'
+    }));
+    if ("string" == typeof obj.repo && !REPO_PATTERN.test(obj.repo)) return Effect.fail(new ConfigurationError({
+        field: "repo",
+        reason: `Invalid repository format: "${obj.repo}". Expected format is "owner/repository" (e.g., "microsoft/vscode")`
+    }));
+    return Schema.decodeUnknown(ChangesetOptionsSchema)(input).pipe(Effect.mapError((parseError)=>new ConfigurationError({
+            field: "options",
+            reason: String(parseError)
+        })));
+}
+function getGitHubInfo(params) {
+    return Effect.tryPromise({
+        try: ()=>getInfo({
+                commit: params.commit,
+                repo: params.repo
+            }),
+        catch: (error)=>new GitHubApiError({
+                operation: "getInfo",
+                reason: error instanceof Error ? error.message : String(error)
+            })
+    });
+}
+const _tag = Context.Tag("GitHubService");
+const GitHubServiceBase = _tag();
+class GitHubService extends GitHubServiceBase {
+}
+const GitHubLive = Layer.succeed(GitHubService, {
+    getInfo: getGitHubInfo
+});
+function makeGitHubTest(responses) {
+    return Layer.succeed(GitHubService, {
+        getInfo: (params)=>{
+            const info = responses.get(params.commit);
+            if (info) return Effect.succeed(info);
+            return Effect.fail(new GitHubApiError({
+                operation: "getInfo",
+                reason: `No mock response for commit ${params.commit}`
+            }));
+        }
+    });
+}
+function createRemarkProcessor() {
+    return unified().use(remark_parse).use(remark_gfm).use(remark_stringify);
+}
+function parseMarkdown(content) {
+    const processor = createRemarkProcessor();
+    return processor.parse(content);
+}
+function stringifyMarkdown(tree) {
+    const processor = createRemarkProcessor();
+    return processor.stringify(tree);
+}
+const markdown_tag = Context.Tag("MarkdownService");
+const MarkdownServiceBase = markdown_tag();
+class MarkdownService extends MarkdownServiceBase {
+}
+const MarkdownLive = Layer.succeed(MarkdownService, {
+    parse: (content)=>Effect.sync(()=>parseMarkdown(content)),
+    stringify: (tree)=>Effect.sync(()=>stringifyMarkdown(tree))
+});
+function logWarning(message, ...args) {
+    if ("u" > typeof process && "true" === process.env.GITHUB_ACTIONS) {
+        const text = args.length > 0 ? `${message} ${args.join(" ")}` : message;
+        console.warn(`::warning::${text}`);
+    } else console.warn(message, ...args);
+}
+function getDependencyReleaseLine(changesets, dependenciesUpdated, options) {
+    return Effect.gen(function*() {
+        if (0 === dependenciesUpdated.length) return "";
+        const github = yield* GitHubService;
+        let apiFailures = 0;
+        const totalWithCommit = changesets.filter((cs)=>cs.commit).length;
+        const commitLinks = yield* Effect.forEach(changesets, (cs)=>{
+            const commit = cs.commit;
+            if (!commit) return Effect.succeed(null);
+            return github.getInfo({
+                commit,
+                repo: options.repo
+            }).pipe(Effect.map((info)=>info.links.commit), Effect.catchAll((error)=>{
+                apiFailures++;
+                logWarning(`Failed to fetch GitHub info for commit ${commit}:`, String(error));
+                return Effect.succeed(`[\`${commit.substring(0, 7)}\`](https://github.com/${options.repo}/commit/${commit})`);
+            }));
+        }, {
+            concurrency: 10
+        });
+        if (apiFailures > 0) {
+            const successRate = ((totalWithCommit - apiFailures) / totalWithCommit * 100).toFixed(1);
+            logWarning(`GitHub API calls completed with ${apiFailures}/${totalWithCommit} failures (${successRate}% success rate)`);
+        }
+        const validLinks = commitLinks.filter(Boolean);
+        const changesetLink = validLinks.length > 0 ? `- Updated dependencies [${validLinks.join(", ")}]:` : "- Updated dependencies:";
+        const updatedDependenciesList = dependenciesUpdated.map((dep)=>`  - ${dep.name}@${dep.newVersion}`);
+        return [
+            changesetLink,
+            ...updatedDependenciesList
+        ].join("\n");
+    });
+}
+const MARKDOWN_LINK_PATTERN = /\[([^\]]+)\]\(([^)]+)\)/;
+function extractUrlFromMarkdown(linkOrUrl) {
+    const match = MARKDOWN_LINK_PATTERN.exec(linkOrUrl);
+    return match ? match[2] : linkOrUrl;
+}
+const NonEmptyString = Schema.String.pipe(Schema.minLength(1));
+const PositiveInteger = Schema.Number.pipe(Schema.int(), Schema.positive());
+function isValidUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+const UsernameSchema = Schema.String.pipe(Schema.pattern(/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/, {
+    message: ()=>"Invalid GitHub username format"
+}));
+const IssueNumberSchema = PositiveInteger.annotations({
+    title: "IssueNumber",
+    description: "GitHub issue or pull request number"
+});
+const UrlOrMarkdownLinkSchema = Schema.String.pipe(Schema.filter((value)=>{
+    if (isValidUrl(value)) return true;
+    const match = MARKDOWN_LINK_PATTERN.exec(value);
+    return match?.[2] ? isValidUrl(match[2]) : false;
+}, {
+    message: ()=>"Invalid URL or markdown link format"
+}));
+const GitHubInfoSchema = Schema.Struct({
+    user: Schema.optional(UsernameSchema),
+    pull: Schema.optional(IssueNumberSchema),
+    links: Schema.Struct({
+        commit: UrlOrMarkdownLinkSchema,
+        pull: Schema.optional(UrlOrMarkdownLinkSchema),
+        user: Schema.optional(UrlOrMarkdownLinkSchema)
+    })
+});
+const CONVENTIONAL_COMMIT_PATTERN = /^(\w+)(?:\(([^)]+)\))?(!)?\s*:\s*(.+)/;
+function parseCommitMessage(message) {
+    const match = CONVENTIONAL_COMMIT_PATTERN.exec(message);
+    if (match) {
+        const [, type, scope, bang, description] = match;
+        const lines = message.split("\n");
+        const body = lines.slice(1).join("\n").trim();
+        const result = {
+            type,
+            description: description.trim()
+        };
+        if (scope) result.scope = scope;
+        if ("!" === bang) result.breaking = true;
+        if (body) result.body = body;
+        return result;
+    }
+    return {
+        description: message
+    };
+}
+const CLOSES_ISSUE_PATTERN = /closes?:?\s*#?(\d+(?:, *#?\d+)*)/i;
+const FIXES_ISSUE_PATTERN = /fix(?:es)?:?\s*#?(\d+(?:, *#?\d+)*)/i;
+const REFS_ISSUE_PATTERN = /refs?:?\s*#?(\d+(?:, *#?\d+)*)/i;
+const ISSUE_NUMBER_SPLIT_PATTERN = /, */;
+function extractIssueNumbers(pattern, message) {
+    const safeMessage = message.slice(0, 10000);
+    const match = pattern.exec(safeMessage);
+    if (!match?.[1]) return [];
+    return match[1].split(ISSUE_NUMBER_SPLIT_PATTERN).map((num)=>num.replace("#", "").trim());
+}
+function parseIssueReferences(commitMessage) {
+    return {
+        closes: extractIssueNumbers(CLOSES_ISSUE_PATTERN, commitMessage),
+        fixes: extractIssueNumbers(FIXES_ISSUE_PATTERN, commitMessage),
+        refs: extractIssueNumbers(REFS_ISSUE_PATTERN, commitMessage)
+    };
+}
+function parseChangesetSections(summary) {
+    const tree = parseMarkdown(summary);
+    const h2Indices = [];
+    for(let i = 0; i < tree.children.length; i++){
+        const node = tree.children[i];
+        if ("heading" === node.type && 2 === node.depth) h2Indices.push(i);
+    }
+    if (0 === h2Indices.length) return {
+        preamble: summary.trim(),
+        sections: []
+    };
+    const result = {
+        sections: []
+    };
+    if (h2Indices[0] > 0) {
+        const preambleNodes = tree.children.slice(0, h2Indices[0]);
+        result.preamble = stringifyAstSlice(preambleNodes);
+    }
+    for(let i = 0; i < h2Indices.length; i++){
+        const headingIndex = h2Indices[i];
+        const headingNode = tree.children[headingIndex];
+        const headingText = external_mdast_util_to_string_toString(headingNode);
+        const nextIndex = i + 1 < h2Indices.length ? h2Indices[i + 1] : tree.children.length;
+        const contentNodes = tree.children.slice(headingIndex + 1, nextIndex);
+        const content = stringifyAstSlice(contentNodes);
+        const category = fromHeading(headingText);
+        if (category) result.sections.push({
+            category,
+            heading: headingText,
+            content
+        });
+    }
+    return result;
+}
+function stringifyAstSlice(nodes) {
+    if (0 === nodes.length) return "";
+    const root = {
+        type: "root",
+        children: nodes
+    };
+    return stringifyMarkdown(root).trim();
+}
+const ISSUE_CATEGORIES = [
+    {
+        key: "closes",
+        label: "Closes"
+    },
+    {
+        key: "fixes",
+        label: "Fixes"
+    },
+    {
+        key: "refs",
+        label: "Refs"
+    }
+];
+function formatChangelogEntry(entry, options) {
+    const parts = [];
+    if (entry.commit) {
+        const shortHash = entry.commit.substring(0, 7);
+        parts.push(`[\`${shortHash}\`](https://github.com/${options.repo}/commit/${entry.commit})`);
+    }
+    parts.push(entry.summary.trim());
+    const issueLinks = [];
+    for (const { key, label } of ISSUE_CATEGORIES){
+        const numbers = entry.issues[key];
+        if (numbers.length > 0) {
+            const links = numbers.map((num)=>`[#${num}](https://github.com/${options.repo}/issues/${num})`);
+            issueLinks.push(`${label}: ${links.join(", ")}`);
+        }
+    }
+    if (issueLinks.length > 0) parts.push(`\n\n${issueLinks.join(". ")}`);
+    return parts.join(" ");
+}
+function formatPRAndUserAttribution(pr, user, links) {
+    let prReference = "";
+    if (pr) if (links?.pull) {
+        const pullUrl = extractUrlFromMarkdown(links.pull);
+        prReference = ` [#${String(pr)}](${pullUrl})`;
+    } else prReference = ` (#${String(pr)})`;
+    if (user) {
+        if (links?.user) {
+            const userUrl = extractUrlFromMarkdown(links.user);
+            return `${prReference} Thanks [@${user}](${userUrl})!`;
+        }
+        return `${prReference} Thanks @${user}!`;
+    }
+    return prReference;
+}
+function getReleaseLine(changeset, versionType, options) {
+    return Effect.gen(function*() {
+        let commitInfo = null;
+        if (changeset.commit) {
+            const github = yield* GitHubService;
+            commitInfo = yield* github.getInfo({
+                commit: changeset.commit,
+                repo: options.repo
+            }).pipe(Effect.flatMap((raw)=>Schema.decodeUnknown(GitHubInfoSchema)(raw).pipe(Effect.map(()=>raw), Effect.catchAll(()=>Effect.succeed(raw)))), Effect.catchAll((error)=>{
+                logWarning("Could not fetch GitHub info for commit:", changeset.commit ?? "", String(error));
+                return Effect.succeed(null);
+            }));
+        }
+        const parsed = parseChangesetSections(changeset.summary);
+        const firstLine = changeset.summary.split("\n")[0];
+        const commitMsg = parseCommitMessage(firstLine);
+        const bodyText = changeset.summary.split("\n").slice(1).join("\n");
+        const issueRefs = parseIssueReferences(bodyText);
+        const attribution = commitInfo ? formatPRAndUserAttribution(commitInfo.pull ?? void 0, commitInfo.user ?? void 0, commitInfo.links) : "";
+        if (parsed.sections.length > 0) {
+            const lines = [];
+            if (parsed.preamble) {
+                lines.push(parsed.preamble);
+                lines.push("");
+            }
+            for (const section of parsed.sections){
+                lines.push(`### ${section.category.heading}`);
+                lines.push("");
+                const commitPrefix = changeset.commit ? `[\`${changeset.commit.substring(0, 7)}\`](https://github.com/${options.repo}/commit/${changeset.commit}) ` : "";
+                if (section.content) {
+                    const contentLines = section.content.split("\n");
+                    const firstContentLine = contentLines[0];
+                    if (firstContentLine.startsWith("- ") || firstContentLine.startsWith("* ")) {
+                        lines.push(`${firstContentLine.substring(0, 2)}${commitPrefix}${firstContentLine.substring(2)}`);
+                        lines.push(...contentLines.slice(1));
+                    } else lines.push(`- ${commitPrefix}${section.content}`);
+                }
+                lines.push("");
+            }
+            const result = lines.join("\n").trimEnd();
+            return `${result}${attribution}`;
+        }
+        const commitType = commitMsg.type ?? versionType;
+        const category = resolveCommitType(commitType, commitMsg.scope, commitMsg.breaking);
+        const entryInput = {
+            type: category.heading,
+            summary: changeset.summary,
+            issues: issueRefs,
+            ...changeset.commit ? {
+                commit: changeset.commit
+            } : {}
+        };
+        const entry = formatChangelogEntry(entryInput, {
+            repo: options.repo
+        });
+        return `- ${entry}${attribution}`;
+    });
+}
+const MainLayer = Layer.mergeAll(GitHubLive, MarkdownLive);
+const changelogFunctions = {
+    getReleaseLine: async (changeset, versionType, options)=>{
+        const program = Effect.gen(function*() {
+            const opts = yield* validateChangesetOptions(options);
+            return yield* getReleaseLine(changeset, versionType, opts);
+        });
+        return Effect.runPromise(program.pipe(Effect.provide(MainLayer)));
+    },
+    getDependencyReleaseLine: async (changesets, dependenciesUpdated, options)=>{
+        const program = Effect.gen(function*() {
+            const opts = yield* validateChangesetOptions(options);
+            return yield* getDependencyReleaseLine(changesets, dependenciesUpdated, opts);
+        });
+        return Effect.runPromise(program.pipe(Effect.provide(MainLayer)));
+    }
+};
+const changelog = changelogFunctions;
+export default changelog;
+export { ChangesetOptionsSchema, ChangesetValidationError, ChangesetValidationErrorBase, ConfigurationError, ConfigurationErrorBase, GitHubApiError, GitHubApiErrorBase, GitHubInfoSchema, GitHubLive, GitHubService, GitHubServiceBase, IssueNumberSchema, MarkdownLive, MarkdownParseError, MarkdownParseErrorBase, MarkdownService, MarkdownServiceBase, NonEmptyString, PositiveInteger, RepoSchema, UrlOrMarkdownLinkSchema, UsernameSchema, makeGitHubTest };