@agentrhq/webcmd 0.1.1 → 0.2.0

package/dist/src/registry-api.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Public API for webcmd plugins.
+ *
+ * TS plugins should import from '@agentrhq/webcmd/registry' which resolves to
+ * this file. It re-exports ONLY the core registration API — no serialization,
+ * no transitive side-effects — to avoid circular dependency deadlocks when
+ * plugins are dynamically imported during discoverPlugins().
+ */
+export { cli, Strategy, getRegistry, fullName, registerCommand } from './registry.js';
+export type { CliCommand, Arg, CliOptions, CommandArgs, SiteSessionMode } from './registry.js';
+export type { IPage } from './types.js';
+export { onStartup, onBeforeExecute, onAfterExecute } from './hooks.js';
+export type { HookFn, HookContext, HookName } from './hooks.js';

package/dist/src/registry-api.js

@@ -0,0 +1,10 @@
+/**
+ * Public API for webcmd plugins.
+ *
+ * TS plugins should import from '@agentrhq/webcmd/registry' which resolves to
+ * this file. It re-exports ONLY the core registration API — no serialization,
+ * no transitive side-effects — to avoid circular dependency deadlocks when
+ * plugins are dynamically imported during discoverPlugins().
+ */
+export { cli, Strategy, getRegistry, fullName, registerCommand } from './registry.js';
+export { onStartup, onBeforeExecute, onAfterExecute } from './hooks.js';

package/dist/src/registry.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Core registry: Strategy enum, Arg/CliCommand interfaces, cli() registration.
+ */
+import type { IPage } from './types.js';
+export declare enum Strategy {
+    PUBLIC = "public",
+    LOCAL = "local",
+    COOKIE = "cookie",
+    INTERCEPT = "intercept",
+    UI = "ui"
+}
+export interface Arg {
+    name: string;
+    type?: string;
+    default?: unknown;
+    required?: boolean;
+    valueRequired?: boolean;
+    positional?: boolean;
+    help?: string;
+    choices?: string[];
+}
+export type CommandArgs = Record<string, any>;
+export type BrowserCommandFunc = (page: IPage, kwargs: CommandArgs, debug?: boolean) => Promise<unknown>;
+export type NonBrowserCommandFunc = (kwargs: CommandArgs, debug?: boolean) => Promise<unknown>;
+export type CommandAccess = 'read' | 'write';
+export type SiteSessionMode = 'ephemeral' | 'persistent';
+export interface AuthStatusMetadata {
+    quickCheck?: BrowserCommandFunc;
+    refresh?: BrowserCommandFunc;
+}
+interface BaseCliCommand {
+    site: string;
+    name: string;
+    aliases?: string[];
+    description: string;
+    access: CommandAccess;
+    /** Canonical invocation shown in agent-facing help. Generated when omitted. */
+    example?: string;
+    domain?: string;
+    strategy?: Strategy;
+    args: Arg[];
+    columns?: string[];
+    pipeline?: Record<string, unknown>[];
+    /** Origin of this command: 'yaml', 'ts', or plugin name. */
+    source?: string;
+    footerExtra?: (kwargs: CommandArgs) => string | undefined;
+    validateArgs?: (kwargs: CommandArgs) => void;
+    /**
+     * Control pre-navigation and browser-session requirement.
+     *
+     * After normalizeCommand() expands strategy, this field carries the
+     * resolved runtime intent:
+     *
+     * - `undefined`: no pre-navigation, browser session decided by pipeline steps
+     * - `false`: explicitly skip pre-navigation (adapter handles its own navigation)
+     * - `true`: needs authenticated browser context but no specific pre-nav URL
+     *   (e.g. INTERCEPT/UI adapters, or COOKIE without domain)
+     * - `string`: pre-navigate to this URL before running the adapter
+     *   (e.g. `'https://x.com'` for COOKIE strategy with domain)
+     *
+     * Adapter authors can set this explicitly to override the strategy-based default.
+     */
+    navigateBefore?: boolean | string;
+    /** Site session lifecycle for adapter commands. */
+    siteSession?: SiteSessionMode;
+    /** Default browser window mode for commands whose UX requires visibility. */
+    defaultWindowMode?: 'foreground' | 'background';
+    /** Override the default CLI output format when the user does not pass -f/--format. */
+    defaultFormat?: 'table' | 'plain' | 'json' | 'yaml' | 'yml' | 'md' | 'markdown' | 'csv';
+    /** Optional auth-status metadata attached by shared auth adapters. */
+    authStatus?: AuthStatusMetadata;
+}
+export interface BrowserCliCommand extends BaseCliCommand {
+    /** Browser commands receive an IPage. Omitted means true after normalization. */
+    browser?: true;
+    func?: BrowserCommandFunc;
+}
+export interface NonBrowserCliCommand extends BaseCliCommand {
+    /** Non-browser commands do not receive a page argument. */
+    browser: false;
+    func?: NonBrowserCommandFunc;
+}
+export type CliCommand = BrowserCliCommand | NonBrowserCliCommand;
+type RawCliCommand = BaseCliCommand & {
+    browser?: boolean;
+    func?: BrowserCommandFunc | NonBrowserCommandFunc;
+};
+/** Internal extension for lazy-loaded TS modules (not exposed in public API) */
+export type InternalCliCommand = CliCommand & {
+    _lazy?: boolean;
+    _modulePath?: string;
+};
+type RequiredCliOptions = {
+    site: string;
+    name: string;
+    access: CommandAccess;
+    description?: string;
+    args?: Arg[];
+};
+type BrowserStrategy = Exclude<Strategy, Strategy.PUBLIC | Strategy.LOCAL>;
+type BrowserCliOptions = Partial<Omit<BrowserCliCommand, 'args' | 'description' | 'browser' | 'strategy'>> & RequiredCliOptions & ({
+    browser: true;
+    strategy?: Strategy;
+} | {
+    browser?: true;
+    strategy?: BrowserStrategy;
+});
+type NonBrowserCliOptions = Partial<Omit<NonBrowserCliCommand, 'args' | 'description'>> & RequiredCliOptions & ({
+    browser: false;
+} | {
+    strategy: Strategy.PUBLIC | Strategy.LOCAL;
+    browser?: false;
+});
+export type CliOptions = BrowserCliOptions | NonBrowserCliOptions;
+declare global {
+    var __webcmd_registry__: Map<string, CliCommand> | undefined;
+}
+export declare function cli(opts: CliOptions): CliCommand;
+export declare function getRegistry(): Map<string, CliCommand>;
+export declare function fullName(cmd: Pick<BaseCliCommand, 'site' | 'name'>): string;
+export declare function strategyLabel(cmd: CliCommand): string;
+export declare function registerCommand(cmd: RawCliCommand): void;
+export {};

package/dist/src/registry.js

@@ -0,0 +1,125 @@
+/**
+ * Core registry: Strategy enum, Arg/CliCommand interfaces, cli() registration.
+ */
+export var Strategy;
+(function (Strategy) {
+    Strategy["PUBLIC"] = "public";
+    Strategy["LOCAL"] = "local";
+    Strategy["COOKIE"] = "cookie";
+    Strategy["INTERCEPT"] = "intercept";
+    Strategy["UI"] = "ui";
+})(Strategy || (Strategy = {}));
+const _registry = globalThis.__webcmd_registry__ ??= new Map();
+export function cli(opts) {
+    const cmd = {
+        site: opts.site,
+        name: opts.name,
+        aliases: opts.aliases,
+        description: opts.description ?? '',
+        access: opts.access,
+        example: opts.example,
+        domain: opts.domain,
+        strategy: opts.strategy,
+        browser: opts.browser,
+        args: opts.args ?? [],
+        columns: opts.columns,
+        func: opts.func,
+        pipeline: opts.pipeline,
+        footerExtra: opts.footerExtra,
+        validateArgs: opts.validateArgs,
+        navigateBefore: opts.navigateBefore,
+        siteSession: opts.siteSession,
+        defaultWindowMode: opts.defaultWindowMode,
+        defaultFormat: opts.defaultFormat,
+        authStatus: opts.authStatus,
+    };
+    registerCommand(cmd);
+    return _registry.get(fullName(cmd));
+}
+export function getRegistry() {
+    return _registry;
+}
+export function fullName(cmd) {
+    return `${cmd.site}/${cmd.name}`;
+}
+export function strategyLabel(cmd) {
+    return cmd.strategy ?? Strategy.PUBLIC;
+}
+/**
+ * Normalize a command's runtime fields. This is the single place where
+ * `strategy` is decoded into the concrete fields that the execution path
+ * reads (`browser`, `navigateBefore`). After normalization, execution code
+ * (resolvePreNav, shouldUseBrowserSession) never reads `cmd.strategy`.
+ *
+ * `strategy` itself is preserved as metadata for `webcmd list`, cascade
+ * probe, adapter generation, and human documentation.
+ *
+ * Override priority (highest wins):
+ *   1. Explicit field on the command (`browser: false`, `navigateBefore: false`)
+ *   2. Derived from strategy + domain (the defaults below)
+ */
+function normalizeCommand(cmd) {
+    assertCommandAccess(cmd);
+    assertSiteSession(cmd);
+    const strategy = cmd.strategy ?? (cmd.browser === false ? Strategy.PUBLIC : Strategy.COOKIE);
+    const browser = cmd.browser ?? (strategy !== Strategy.PUBLIC && strategy !== Strategy.LOCAL);
+    let navigateBefore = cmd.navigateBefore;
+    if (navigateBefore === undefined) {
+        if (strategy === Strategy.COOKIE && cmd.domain) {
+            navigateBefore = `https://${cmd.domain}`;
+        }
+        else if (strategy !== Strategy.PUBLIC && strategy !== Strategy.LOCAL) {
+            // Non-PUBLIC without domain: needs authenticated browser context
+            // but no specific pre-navigation URL. `true` signals this to
+            // shouldUseBrowserSession without triggering resolvePreNav.
+            navigateBefore = true;
+        }
+    }
+    return browser
+        ? { ...cmd, strategy, browser: true, navigateBefore }
+        : { ...cmd, strategy, browser: false, navigateBefore };
+}
+function assertCommandAccess(cmd) {
+    if (cmd.access === 'read' || cmd.access === 'write')
+        return;
+    const key = `${cmd.site}/${cmd.name}`;
+    throw new Error(`Command ${key} must declare access: 'read' | 'write'`);
+}
+function assertSiteSession(cmd) {
+    if (cmd.siteSession === undefined)
+        return;
+    const key = `${cmd.site}/${cmd.name}`;
+    if (cmd.siteSession !== 'ephemeral' && cmd.siteSession !== 'persistent') {
+        throw new Error(`Command ${key} siteSession must be one of: ephemeral, persistent`);
+    }
+}
+export function registerCommand(cmd) {
+    const normalized = normalizeCommand(cmd);
+    const canonicalKey = fullName(normalized);
+    const existing = _registry.get(canonicalKey);
+    if (existing?.aliases) {
+        for (const alias of existing.aliases) {
+            _registry.delete(`${existing.site}/${alias}`);
+        }
+    }
+    const aliases = normalizeAliases(normalized.aliases, normalized.name);
+    normalized.aliases = aliases.length > 0 ? aliases : undefined;
+    _registry.set(canonicalKey, normalized);
+    for (const alias of aliases) {
+        _registry.set(`${normalized.site}/${alias}`, normalized);
+    }
+}
+function normalizeAliases(aliases, commandName) {
+    if (!Array.isArray(aliases) || aliases.length === 0)
+        return [];
+    const seen = new Set();
+    const normalized = [];
+    for (const alias of aliases) {
+        const value = typeof alias === 'string' ? alias.trim() : '';
+        if (!value || value === commandName || seen.has(value))
+            continue;
+        seen.add(value);
+        normalized.push(value);
+    }
+    return normalized;
+}

package/dist/src/registry.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for registry.ts: Strategy enum, cli() registration, helpers.
+ */
+export {};

package/dist/src/registry.test.js

@@ -0,0 +1,209 @@
+/**
+ * Tests for registry.ts: Strategy enum, cli() registration, helpers.
+ */
+import { describe, it, expect } from 'vitest';
+import { cli, getRegistry, fullName, strategyLabel, registerCommand, Strategy } from './registry.js';
+describe('cli() registration', () => {
+    it('registers a command and returns it', () => {
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'hello', access: 'read',
+            description: 'A test command',
+            strategy: Strategy.PUBLIC,
+            browser: false,
+        });
+        expect(cmd.site).toBe('test-registry');
+        expect(cmd.name).toBe('hello');
+        expect(cmd.access).toBe('read');
+        expect(cmd.strategy).toBe(Strategy.PUBLIC);
+        expect(cmd.browser).toBe(false);
+        expect(cmd.args).toEqual([]);
+    });
+    it('puts registered command in the registry', () => {
+        cli({
+            site: 'test-registry',
+            name: 'registered', access: 'read',
+            description: 'test',
+        });
+        const registry = getRegistry();
+        expect(registry.has('test-registry/registered')).toBe(true);
+    });
+    it('defaults strategy to COOKIE when browser is true', () => {
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'default-strategy', access: 'read',
+        });
+        expect(cmd.strategy).toBe(Strategy.COOKIE);
+        expect(cmd.browser).toBe(true);
+    });
+    it('defaults strategy to PUBLIC when browser is false', () => {
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'no-browser', access: 'read',
+            browser: false,
+        });
+        expect(cmd.strategy).toBe(Strategy.PUBLIC);
+    });
+    it('preserves LOCAL strategy on registration', () => {
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'local-strategy', access: 'read',
+            description: 'reads local credentials',
+            strategy: Strategy.LOCAL,
+            browser: false,
+        });
+        expect(cmd.strategy).toBe(Strategy.LOCAL);
+        expect(cmd.browser).toBe(false);
+    });
+    it('overwrites existing command on re-registration', () => {
+        cli({ site: 'test-registry', name: 'overwrite', access: 'read', description: 'v1' });
+        cli({ site: 'test-registry', name: 'overwrite', access: 'read', description: 'v2' });
+        const reg = getRegistry();
+        expect(reg.get('test-registry/overwrite')?.description).toBe('v2');
+    });
+    it('registers aliases as alternate registry keys for the same command', () => {
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'canonical', access: 'read',
+            description: 'test aliases',
+            aliases: ['compat', 'legacy-name'],
+        });
+        const registry = getRegistry();
+        expect(cmd.aliases).toEqual(['compat', 'legacy-name']);
+        expect(registry.get('test-registry/canonical')).toBe(cmd);
+        expect(registry.get('test-registry/compat')).toBe(cmd);
+        expect(registry.get('test-registry/legacy-name')).toBe(cmd);
+    });
+    it('preserves defaultFormat on the registered command', () => {
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'plain-default', access: 'read',
+            description: 'prefers plain output',
+            defaultFormat: 'plain',
+        });
+        expect(cmd.defaultFormat).toBe('plain');
+        expect(getRegistry().get('test-registry/plain-default')?.defaultFormat).toBe('plain');
+    });
+    it('preserves validateArgs on the registered command', () => {
+        const validateArgs = () => undefined;
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'validated', access: 'read',
+            description: 'validates args before execution',
+            validateArgs,
+        });
+        expect(cmd.validateArgs).toBe(validateArgs);
+        expect(getRegistry().get('test-registry/validated')?.validateArgs).toBe(validateArgs);
+    });
+    it('rejects commands without explicit access metadata', () => {
+        expect(() => cli({
+            site: 'test-registry',
+            name: 'missing-access',
+        })).toThrow("Command test-registry/missing-access must declare access: 'read' | 'write'");
+    });
+});
+describe('fullName', () => {
+    it('returns site/name', () => {
+        const cmd = {
+            site: 'youtube', name: 'search', access: 'read', description: '', args: [],
+        };
+        expect(fullName(cmd)).toBe('youtube/search');
+    });
+});
+describe('strategyLabel', () => {
+    it('returns strategy string', () => {
+        const cmd = {
+            site: 'test', name: 'test', access: 'read', description: '', args: [],
+            strategy: Strategy.INTERCEPT,
+        };
+        expect(strategyLabel(cmd)).toBe('intercept');
+    });
+    it('returns public when no strategy set', () => {
+        const cmd = {
+            site: 'test', name: 'test', access: 'read', description: '', args: [],
+        };
+        expect(strategyLabel(cmd)).toBe('public');
+    });
+});
+describe('registerCommand', () => {
+    it('registers a pre-built command', () => {
+        const cmd = {
+            site: 'test-registry',
+            name: 'direct-reg', access: 'read',
+            description: 'directly registered',
+            args: [],
+            strategy: Strategy.COOKIE,
+            browser: true,
+        };
+        registerCommand(cmd);
+        const reg = getRegistry();
+        expect(reg.get('test-registry/direct-reg')?.strategy).toBe(Strategy.COOKIE);
+    });
+});
+describe('normalizeCommand (via registerCommand)', () => {
+    it('COOKIE + domain → navigateBefore is the domain URL', () => {
+        registerCommand({
+            site: 'test-norm', name: 'cookie-domain', access: 'read', description: '', args: [],
+            strategy: Strategy.COOKIE, domain: 'x.com',
+        });
+        const cmd = getRegistry().get('test-norm/cookie-domain');
+        expect(cmd.browser).toBe(true);
+        expect(cmd.navigateBefore).toBe('https://x.com');
+    });
+    it('COOKIE without domain → navigateBefore is true (auth context, no URL)', () => {
+        registerCommand({
+            site: 'test-norm', name: 'cookie-nodomain', access: 'read', description: '', args: [],
+            strategy: Strategy.COOKIE,
+        });
+        const cmd = getRegistry().get('test-norm/cookie-nodomain');
+        expect(cmd.browser).toBe(true);
+        expect(cmd.navigateBefore).toBe(true);
+    });
+    it('INTERCEPT → navigateBefore is true (auth context)', () => {
+        registerCommand({
+            site: 'test-norm', name: 'intercept', access: 'read', description: '', args: [],
+            strategy: Strategy.INTERCEPT, domain: 'example.com',
+        });
+        const cmd = getRegistry().get('test-norm/intercept');
+        expect(cmd.browser).toBe(true);
+        expect(cmd.navigateBefore).toBe(true);
+    });
+    it('PUBLIC → browser false, navigateBefore undefined', () => {
+        registerCommand({
+            site: 'test-norm', name: 'public', access: 'read', description: '', args: [],
+            strategy: Strategy.PUBLIC,
+        });
+        const cmd = getRegistry().get('test-norm/public');
+        expect(cmd.browser).toBe(false);
+        expect(cmd.navigateBefore).toBeUndefined();
+    });
+    it('LOCAL → browser false, navigateBefore undefined', () => {
+        registerCommand({
+            site: 'test-norm', name: 'local', access: 'read', description: '', args: [],
+            strategy: Strategy.LOCAL,
+        });
+        const cmd = getRegistry().get('test-norm/local');
+        expect(cmd.strategy).toBe(Strategy.LOCAL);
+        expect(strategyLabel(cmd)).toBe('local');
+        expect(cmd.browser).toBe(false);
+        expect(cmd.navigateBefore).toBeUndefined();
+    });
+    it('explicit navigateBefore: false overrides COOKIE + domain', () => {
+        registerCommand({
+            site: 'test-norm', name: 'cookie-override', access: 'read', description: '', args: [],
+            strategy: Strategy.COOKIE, domain: 'amazon.com', navigateBefore: false,
+        });
+        const cmd = getRegistry().get('test-norm/cookie-override');
+        expect(cmd.browser).toBe(true);
+        expect(cmd.navigateBefore).toBe(false);
+    });
+    it('explicit navigateBefore URL overrides strategy default', () => {
+        registerCommand({
+            site: 'test-norm', name: 'explicit-url', access: 'read', description: '', args: [],
+            strategy: Strategy.COOKIE, domain: 'x.com',
+            navigateBefore: 'https://x.com/explore',
+        });
+        const cmd = getRegistry().get('test-norm/explicit-url');
+        expect(cmd.navigateBefore).toBe('https://x.com/explore');
+    });
+});

package/dist/src/release-notes.d.ts

@@ -0,0 +1,38 @@
+export declare const RELEASE_NOTE_SECTIONS: readonly ["Highlights", "Improvements", "Fixes", "Contributors", "Reverts"];
+export type ReleaseNoteSection = typeof RELEASE_NOTE_SECTIONS[number];
+export interface PullRequestLabel {
+    name: string;
+}
+export interface PullRequestFile {
+    path: string;
+}
+export interface PullRequestAuthor {
+    login: string;
+}
+export interface PullRequestDetails {
+    number: number;
+    title: string;
+    body?: string | null;
+    author?: PullRequestAuthor | null;
+    labels: PullRequestLabel[];
+    files: PullRequestFile[];
+    diff?: string;
+    url: string;
+    mergedAt?: string | null;
+}
+export interface ReleaseContext {
+    tag: string;
+    previousTag: string;
+    currentRef: string;
+    pullRequests: PullRequestDetails[];
+}
+export interface CompareCommit {
+    sha: string;
+    message: string;
+    author?: string | null;
+}
+export type GitRunner = (args: readonly string[]) => Promise<string>;
+export declare function extractPullRequestNumber(message: string): number | null;
+export declare function filterReleasePullRequests(prs: PullRequestDetails[]): PullRequestDetails[];
+export declare function normalizeReleaseNotes(raw: string, contributors: string[]): string;
+export declare function buildReleaseNotesPrompt(context: ReleaseContext): string;

package/dist/src/release-notes.js

@@ -0,0 +1,99 @@
+export const RELEASE_NOTE_SECTIONS = ['Highlights', 'Improvements', 'Fixes', 'Contributors', 'Reverts'];
+const SQUASH_MERGE_PR_NUMBER_PATTERN = /\(#(?<number>\d+)\)\s*$/;
+const MERGE_COMMIT_PR_NUMBER_PATTERN = /^Merge pull request #(?<number>\d+) /;
+const RELEASE_PLEASE_TITLE_PATTERN = /^chore(?:\([^)]+\))?: release(?:\s|$)/;
+function normalizeHandle(handle) {
+    const trimmed = handle.trim();
+    return trimmed.startsWith('@') ? trimmed.slice(1) : trimmed;
+}
+function uniqueSortedHandles(handles) {
+    return [...new Set(handles.map(normalizeHandle).filter(Boolean))].sort((left, right) => left.localeCompare(right));
+}
+function formatSectionContent(content) {
+    const trimmed = content?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : 'None.';
+}
+export function extractPullRequestNumber(message) {
+    const firstLine = message.split(/\r?\n/, 1)[0] ?? message;
+    const squashMatch = firstLine.match(SQUASH_MERGE_PR_NUMBER_PATTERN);
+    if (squashMatch?.groups?.number) {
+        return Number(squashMatch.groups.number);
+    }
+    const mergeMatch = firstLine.match(MERGE_COMMIT_PR_NUMBER_PATTERN);
+    if (mergeMatch?.groups?.number) {
+        return Number(mergeMatch.groups.number);
+    }
+    return null;
+}
+export function filterReleasePullRequests(prs) {
+    return prs.filter((pr) => {
+        const title = pr.title.trim().toLowerCase();
+        if (title.startsWith('release:'))
+            return false;
+        if (RELEASE_PLEASE_TITLE_PATTERN.test(title))
+            return false;
+        return !pr.labels.some((label) => {
+            const name = label.name.trim().toLowerCase();
+            return name === 'release' || name === 'skip-changelog';
+        });
+    });
+}
+function parseReleaseNoteSections(raw) {
+    const sections = {};
+    let currentSection = null;
+    for (const line of raw.split(/\r?\n/)) {
+        const headingMatch = line.match(/^##\s+(.+?)\s*$/);
+        if (headingMatch) {
+            const section = RELEASE_NOTE_SECTIONS.find((candidate) => candidate.toLowerCase() === headingMatch[1].toLowerCase()) ?? null;
+            currentSection = section;
+            if (currentSection)
+                sections[currentSection] = sections[currentSection] ?? [];
+            continue;
+        }
+        if (currentSection) {
+            sections[currentSection] ??= [];
+            sections[currentSection].push(line);
+        }
+    }
+    return sections;
+}
+export function normalizeReleaseNotes(raw, contributors) {
+    const sections = parseReleaseNoteSections(raw);
+    const normalizedContributors = uniqueSortedHandles(contributors).map((handle) => `- @${handle}`);
+    return RELEASE_NOTE_SECTIONS.map((section) => {
+        if (section === 'Contributors') {
+            const content = normalizedContributors.length > 0 ? normalizedContributors.join('\n') : 'None.';
+            return `## ${section}\n${content}`;
+        }
+        const content = formatSectionContent(sections[section]?.join('\n'));
+        return `## ${section}\n${content}`;
+    }).join('\n\n');
+}
+function formatPullRequest(pr) {
+    const author = pr.author?.login ?? 'unknown';
+    const labels = pr.labels.length > 0 ? pr.labels.map((label) => label.name).join(', ') : 'None';
+    const files = pr.files.length > 0 ? pr.files.map((file) => file.path).join('\n') : 'None';
+    const body = pr.body?.trim() ? pr.body.trim() : 'None';
+    const diff = pr.diff?.trim() ? pr.diff.trim() : 'None';
+    return [
+        `PR #${pr.number}: ${pr.title}`,
+        `Author: @${author}`,
+        `Labels: ${labels}`,
+        `Files:\n${files}`,
+        `Body:\n${body}`,
+        `Diff:\n${diff}`,
+    ].join('\n');
+}
+export function buildReleaseNotesPrompt(context) {
+    const prSummaries = context.pullRequests.map(formatPullRequest).join('\n\n');
+    return [
+        `Write user-facing release notes for ${context.tag}.`,
+        `Release range: ${context.previousTag}...${context.currentRef}.`,
+        'Use only the supplied pull requests below. Do not invent changes or pull in information from elsewhere.',
+        `Required sections: ${RELEASE_NOTE_SECTIONS.map((section) => `## ${section}`).join(', ')}.`,
+        'Each section must be present in the final notes.',
+        '',
+        `Pull requests included for this release:`,
+        prSummaries,
+    ].join('\n');
+}

package/dist/src/release-notes.test.d.ts

@@ -0,0 +1 @@
+export {};