@jens_astrup/release-manager 0.1.0-alpha.2

package/dist/src/lib/git.js

@@ -0,0 +1,94 @@
+import { execa } from 'execa';
+/**
+ * Run a git command in the given project directory, returning trimmed stdout.
+ */
+async function git(args, opts) {
+    const { stdout } = await execa('git', args, { cwd: opts.cwd });
+    return stdout.trim();
+}
+export async function ensureCleanWorkingDir(opts) {
+    const status = await git(['status', '--porcelain', '-uno'], opts);
+    if (status.length > 0) {
+        throw new Error('Working directory is not clean. Please commit or stash changes.');
+    }
+}
+export async function fetchAndCheckout(branch, opts) {
+    await git(['fetch', 'origin', branch], opts);
+    await git(['checkout', branch], opts);
+    await git(['pull', 'origin', branch], opts);
+}
+export async function deleteLocalBranch(branch, opts) {
+    try {
+        await git(['branch', '-D', branch], opts);
+    }
+    catch {
+        // not present locally
+    }
+}
+export async function deleteRemoteBranchIfExists(branch, opts) {
+    try {
+        const refs = await git(['ls-remote', '--heads', 'origin', branch], opts);
+        if (refs.length > 0) {
+            await git(['push', 'origin', '--delete', branch], opts);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+export async function createBranchAndPush(branch, commitMessage, filesToAdd, opts) {
+    await git(['checkout', '-b', branch], opts);
+    if (filesToAdd.length > 0) {
+        await git(['add', ...filesToAdd], opts);
+    }
+    await git(['commit', '-m', commitMessage], opts);
+    await git(['push', 'origin', branch], opts);
+}
+export async function getCommitsBetween(base, head, opts) {
+    await git(['fetch', 'origin', base], opts);
+    let raw = '';
+    try {
+        raw = await git(['log', `${base}..${head}`, '--pretty=format:%H|%s'], opts);
+    }
+    catch {
+        return [];
+    }
+    if (!raw)
+        return [];
+    return raw
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => {
+        const [sha, ...rest] = line.split('|');
+        return { sha: sha ?? 'unknown', message: rest.join('|') || 'No commit message' };
+    });
+}
+export function extractLinearIssueId(commitMessage) {
+    const m = commitMessage.match(/([A-Z][A-Z0-9]+-\d+)/);
+    return m ? m[1] : undefined;
+}
+export async function isGitRepo(opts) {
+    try {
+        await git(['rev-parse', '--is-inside-work-tree'], opts);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Returns "owner/repo" inferred from the origin remote URL, if possible.
+ */
+export async function inferGithubRepo(opts) {
+    try {
+        const url = await git(['remote', 'get-url', 'origin'], opts);
+        // Supports both git@github.com:owner/repo.git and https://github.com/owner/repo.git
+        const m = url.match(/github\.com[:/]([^/]+)\/([^/.]+)(?:\.git)?$/i);
+        if (!m)
+            return null;
+        return { owner: m[1] ?? '', repo: m[2] ?? '' };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/lib/github.js

@@ -0,0 +1,46 @@
+import { Octokit } from 'octokit';
+import { requireEnv } from './env.js';
+function octokit() {
+    return new Octokit({ auth: requireEnv('GITHUB_TOKEN') });
+}
+export async function createPullRequest(args) {
+    const client = octokit();
+    const { data } = await client.rest.pulls.create(args);
+    return data.html_url;
+}
+/**
+ * Fetch closed issues for the given repo, optionally filtered by label and milestone.
+ * Used when issueSource === 'github'.
+ */
+export async function getClosedIssues(args) {
+    const client = octokit();
+    // Resolve milestone title to number if provided
+    let milestoneNumber;
+    if (args.milestone) {
+        const { data: milestones } = await client.rest.issues.listMilestones({
+            owner: args.owner,
+            repo: args.repo,
+            state: 'all',
+            per_page: 100
+        });
+        const found = milestones.find((m) => m.title === args.milestone);
+        if (found)
+            milestoneNumber = found.number;
+    }
+    const { data: issues } = await client.rest.issues.listForRepo({
+        owner: args.owner,
+        repo: args.repo,
+        state: 'closed',
+        labels: args.label,
+        milestone: milestoneNumber !== undefined ? String(milestoneNumber) : undefined,
+        per_page: 100
+    });
+    return issues
+        .filter((i) => !i.pull_request)
+        .map((i) => ({
+        title: i.title,
+        description: i.body ?? undefined,
+        url: i.html_url,
+        identifier: `#${i.number}`
+    }));
+}

package/dist/src/lib/linear.js

@@ -0,0 +1,40 @@
+import { LinearClient } from '@linear/sdk';
+import { requireEnv } from './env.js';
+function linear() {
+    // Support both env var names used historically in the source scripts.
+    const apiKey = process.env.LINEAR_API_KEY ?? process.env.LINEAR_API_TOKEN;
+    if (!apiKey) {
+        throw new Error('LINEAR_API_KEY environment variable is not set');
+    }
+    return new LinearClient({ apiKey });
+}
+export async function getReadyForDeployIssues(stateId) {
+    if (!stateId) {
+        throw new Error('Linear "ready-for-deploy" workflow state ID is not configured. Set it in Settings.');
+    }
+    const client = linear();
+    const state = await client.workflowState(stateId);
+    const issues = await state.issues();
+    return issues.nodes.map((i) => ({
+        title: i.title,
+        description: i.description ?? undefined,
+        url: i.url,
+        identifier: i.identifier
+    }));
+}
+export async function getIssueDescription(issueId) {
+    try {
+        const client = linear();
+        const issue = await client.issue(issueId);
+        return issue.description || issue.title;
+    }
+    catch {
+        return 'Failed to fetch issue description';
+    }
+}
+/** Used to pre-validate that the API key is at least readable. */
+export async function pingLinear() {
+    requireEnv('LINEAR_API_KEY');
+    const client = linear();
+    await client.viewer;
+}

package/dist/src/lib/openai.js

@@ -0,0 +1,100 @@
+import OpenAI from 'openai';
+import { z } from 'zod';
+import { requireEnv } from './env.js';
+const RELEASE_NOTES_SYSTEM = `
+You write the release notes for new versions of a software product.
+
+You are given a list of issues that have been closed in the current release, with the title, description, and URL.
+
+You should take the title and description of each issue and write a concise summary of the changes made.
+
+The release notes should be in the following format:
+
+## v1.0.0
+- [Issue Description] (Closes [ISSUE-ID](Issue URL))
+`;
+function client() {
+    return new OpenAI({ apiKey: requireEnv('OPENAI_API_KEY') });
+}
+function formatIssueNotes(issues) {
+    return issues
+        .map((i) => `---\n${i.title}\n${i.description ?? ''}\n${i.url}\n---`)
+        .join('\n');
+}
+/**
+ * Generate release notes from a set of issues. Reports streaming progress
+ * (0..1) so the UI can render a determinate progress bar.
+ */
+export async function generateReleaseNotes(args, onProgress) {
+    const openai = client();
+    const userMessage = `New version: ${args.version}\n\n------\n\n${formatIssueNotes(args.issues)}`;
+    // Use streaming so we can drive a progress bar by tokens received.
+    // We don't know total tokens in advance, so we estimate against an
+    // expectation of ~600 output tokens and cap at 0.95 until done.
+    const EXPECTED_TOKENS = 600;
+    let tokenCount = 0;
+    const stream = await openai.chat.completions.create({
+        model: args.model,
+        stream: true,
+        messages: [
+            { role: 'system', content: RELEASE_NOTES_SYSTEM },
+            { role: 'user', content: userMessage }
+        ]
+    });
+    let full = '';
+    for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta?.content ?? '';
+        if (delta) {
+            full += delta;
+            tokenCount += Math.max(1, Math.ceil(delta.length / 4));
+            if (onProgress) {
+                const ratio = 1 - Math.exp(-tokenCount / EXPECTED_TOKENS);
+                onProgress(Math.min(0.95, ratio));
+            }
+        }
+    }
+    if (onProgress)
+        onProgress(1);
+    if (!full.trim()) {
+        throw new Error('No release notes returned from OpenAI');
+    }
+    return full;
+}
+const versionResponseSchema = z.object({
+    type: z.enum(['major', 'minor', 'patch'])
+});
+/**
+ * Suggest a version bump (major/minor/patch) from a list of commits, using OpenAI.
+ * Falls back to "patch" on any error.
+ */
+export async function suggestBumpType(commits, model) {
+    if (commits.length === 0)
+        return 'patch';
+    const openai = client();
+    const descriptions = commits.map((c) => `- ${c.description}`).join('\n');
+    const systemMessage = `You analyze commit changes and determine the appropriate version bump type (major, minor, or patch) following semantic versioning.
+- Major version bump (breaking change): incompatible API changes or substantial user-facing changes.
+- Minor version bump: backward compatible new functionality.
+- Patch version bump: backward compatible bug fixes.
+Respond with a JSON object: {"type":"major"|"minor"|"patch"}.`;
+    const userMessage = `Based on the following changes, determine if this should be a major, minor, or patch version bump:\n\n${descriptions}`;
+    try {
+        const response = await openai.chat.completions.create({
+            model,
+            temperature: 0.2,
+            response_format: { type: 'json_object' },
+            messages: [
+                { role: 'system', content: systemMessage },
+                { role: 'user', content: userMessage }
+            ]
+        });
+        const raw = response.choices[0]?.message?.content ?? '{}';
+        const parsed = versionResponseSchema.safeParse(JSON.parse(raw));
+        if (parsed.success)
+            return parsed.data.type;
+        return 'patch';
+    }
+    catch {
+        return 'patch';
+    }
+}

package/dist/src/lib/version.js

@@ -0,0 +1,69 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import semver from 'semver';
+/**
+ * Read the current version from package.json in the project directory.
+ */
+export async function getCurrentVersion(projectDir) {
+    const pkgPath = join(projectDir, 'package.json');
+    const raw = await readFile(pkgPath, 'utf-8');
+    const pkg = JSON.parse(raw);
+    if (!pkg.version) {
+        throw new Error('No "version" field found in package.json');
+    }
+    return pkg.version;
+}
+/**
+ * Compute the next version given a bump type. For alpha/beta we use
+ * semver's prerelease behavior, which auto-increments existing tagged versions:
+ *   1.2.3       + alpha => 1.2.4-alpha.0
+ *   1.2.4-alpha.0 + alpha => 1.2.4-alpha.1
+ *   1.2.3       + beta  => 1.2.4-beta.0
+ *
+ * For "explicit", the caller must pass `explicitVersion`.
+ */
+export function computeNextVersion(current, type, explicitVersion) {
+    if (type === 'explicit') {
+        if (!explicitVersion) {
+            throw new Error('An explicit version is required when bump type is "explicit"');
+        }
+        const cleaned = semver.clean(explicitVersion) ?? explicitVersion.replace(/^v/, '');
+        if (!semver.valid(cleaned)) {
+            throw new Error(`"${explicitVersion}" is not a valid semver version`);
+        }
+        return cleaned;
+    }
+    if (type === 'alpha' || type === 'beta') {
+        const next = semver.inc(current, 'prerelease', type);
+        if (!next)
+            throw new Error(`Failed to compute prerelease bump from ${current}`);
+        return next;
+    }
+    const next = semver.inc(current, type);
+    if (!next)
+        throw new Error(`Failed to compute ${type} bump from ${current}`);
+    return next;
+}
+/**
+ * Update package.json with the new version, preserving formatting as best as possible.
+ */
+export async function writeVersion(projectDir, version) {
+    const pkgPath = join(projectDir, 'package.json');
+    const raw = await readFile(pkgPath, 'utf-8');
+    const pkg = JSON.parse(raw);
+    pkg.version = version;
+    // preserve trailing newline if present
+    const trailingNewline = raw.endsWith('\n') ? '\n' : '';
+    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + trailingNewline, 'utf-8');
+}
+/**
+ * Validate a user-supplied explicit version string.
+ */
+export function isValidExplicitVersion(input) {
+    const cleaned = semver.clean(input) ?? input.replace(/^v/, '');
+    return semver.valid(cleaned) !== null;
+}
+export function isPrerelease(version) {
+    const parsed = semver.parse(version);
+    return Boolean(parsed && parsed.prerelease.length > 0);
+}

package/dist/src/lib/workflows.js

@@ -0,0 +1,127 @@
+import { runBuildCheck } from './build.js';
+import { createBranchAndPush, deleteLocalBranch, deleteRemoteBranchIfExists, ensureCleanWorkingDir, extractLinearIssueId, fetchAndCheckout, getCommitsBetween } from './git.js';
+import { createPullRequest, getClosedIssues } from './github.js';
+import { getIssueDescription, getReadyForDeployIssues } from './linear.js';
+import { generateReleaseNotes, suggestBumpType as openaiSuggestBumpType } from './openai.js';
+import { computeNextVersion, getCurrentVersion, writeVersion } from './version.js';
+/**
+ * Full version-bump flow: clean check -> fetch develop -> build -> bump
+ * package.json -> push branch -> open PR.
+ */
+export async function prepareVersionFlow(args) {
+    const { config, bumpType, explicitVersion, skipBuild, onUpdate } = args;
+    const cwd = config.projectDir;
+    const developBranch = config.github.developBranch;
+    // Step: check working dir
+    onUpdate('clean', { status: 'running' });
+    await ensureCleanWorkingDir({ cwd });
+    onUpdate('clean', { status: 'done' });
+    // Step: refresh develop
+    onUpdate('fetch', { status: 'running' });
+    await fetchAndCheckout(developBranch, { cwd });
+    onUpdate('fetch', { status: 'done' });
+    // Step: build check
+    if (skipBuild || !config.buildCheckEnabled) {
+        onUpdate('build', { status: 'skipped' });
+    }
+    else {
+        onUpdate('build', { status: 'running', progress: 0 });
+        await runBuildCheck(config.buildCommand, cwd, (p) => onUpdate('build', { progress: p.progress, detail: p.line }));
+        onUpdate('build', { status: 'done', progress: 1 });
+    }
+    // Step: compute and write version
+    onUpdate('bump', { status: 'running' });
+    const current = await getCurrentVersion(cwd);
+    const nextVersion = computeNextVersion(current, bumpType, explicitVersion);
+    await writeVersion(cwd, nextVersion);
+    const versionBranch = `v${nextVersion}`;
+    onUpdate('bump', { status: 'done', detail: `${current} -> ${nextVersion}` });
+    // Step: clean up old branches with same name
+    onUpdate('cleanup', { status: 'running' });
+    await deleteLocalBranch(versionBranch, { cwd });
+    await deleteRemoteBranchIfExists(versionBranch, { cwd });
+    onUpdate('cleanup', { status: 'done' });
+    // Step: branch + push
+    onUpdate('push', { status: 'running' });
+    await createBranchAndPush(versionBranch, `chore: bump version to ${nextVersion}`, ['package.json'], { cwd });
+    onUpdate('push', { status: 'done' });
+    // Step: open PR
+    onUpdate('pr', { status: 'running' });
+    const pullRequestUrl = await createPullRequest({
+        owner: config.github.owner,
+        repo: config.github.repo,
+        title: `Bump version to ${nextVersion}`,
+        body: `Version bump to ${nextVersion}`,
+        head: versionBranch,
+        base: developBranch
+    });
+    onUpdate('pr', { status: 'done', detail: pullRequestUrl });
+    return { version: nextVersion, pullRequestUrl };
+}
+/**
+ * Create a release: pull issues from configured source -> AI notes ->
+ * develop -> main PR.
+ */
+export async function createReleaseFlow(args) {
+    const { config, onUpdate } = args;
+    const cwd = config.projectDir;
+    // Step: refresh develop
+    onUpdate('fetch', { status: 'running' });
+    await fetchAndCheckout(config.github.developBranch, { cwd });
+    onUpdate('fetch', { status: 'done' });
+    // Step: gather issues from configured source
+    onUpdate('issues', { status: 'running' });
+    let issues = [];
+    if (config.issueSource === 'linear') {
+        issues = await getReadyForDeployIssues(config.linear?.readyForDeployStateId ?? '');
+    }
+    else {
+        issues = await getClosedIssues({
+            owner: config.github.owner,
+            repo: config.github.repo,
+            label: config.github.issueLabel,
+            milestone: config.github.milestone
+        });
+    }
+    onUpdate('issues', {
+        status: 'done',
+        detail: `${issues.length} issue${issues.length === 1 ? '' : 's'}`
+    });
+    // Step: AI notes
+    onUpdate('notes', { status: 'running', progress: 0 });
+    const version = await getCurrentVersion(cwd);
+    const notes = await generateReleaseNotes({ version, issues, model: config.openaiModel }, (p) => onUpdate('notes', { progress: p }));
+    onUpdate('notes', { status: 'done', progress: 1 });
+    // Step: PR
+    onUpdate('pr', { status: 'running' });
+    const url = await createPullRequest({
+        owner: config.github.owner,
+        repo: config.github.repo,
+        title: `v${version}`,
+        body: notes,
+        head: config.github.developBranch,
+        base: config.github.mainBranch
+    });
+    onUpdate('pr', { status: 'done', detail: url });
+    return { pullRequestUrl: url };
+}
+/**
+ * Build CommitInfo[] from develop..main and resolve Linear descriptions.
+ */
+export async function gatherCommitsForSuggestion(config) {
+    const commits = await getCommitsBetween(config.github.mainBranch, config.github.developBranch, { cwd: config.projectDir });
+    const enriched = await Promise.all(commits.map(async (c) => {
+        const linearIssueId = extractLinearIssueId(c.message);
+        let description = c.message;
+        if (config.issueSource === 'linear' && linearIssueId) {
+            description = await getIssueDescription(linearIssueId);
+        }
+        return { ...c, linearIssueId, description };
+    }));
+    return enriched;
+}
+export async function suggestBump(config) {
+    const commits = await gatherCommitsForSuggestion(config);
+    const bumpType = await openaiSuggestBumpType(commits, config.openaiModel);
+    return { bumpType, commitCount: commits.length };
+}