geeto 0.3.6 → 0.4.1

package/lib/workflows/release.js

@@ -4,12 +4,41 @@
  * RELEASE.MD (user-friendly) and CHANGELOG.md (developer-facing)
  */
 import { readFileSync, writeFileSync } from 'node:fs';
-import { askQuestion, confirm, ProgressBar } from '../cli/input.js';
+import { askQuestion, confirm, editInline, ProgressBar } from '../cli/input.js';
 import { select } from '../cli/menu.js';
 import { colors } from '../utils/colors.js';
 import { exec, execAsync, execSilent } from '../utils/exec.js';
+import { chooseModelForProvider, generateReleaseNotesWithProvider, getAIProviderShortName, getModelValue, } from '../utils/git-ai.js';
 import { log } from '../utils/logging.js';
+import { loadState } from '../utils/state.js';
 // ─── Helpers ───
+/**
+ * Normalize markdown spacing for consistent markdownlint-friendly output.
+ * Ensures: one blank line after ### and #### headings, one blank line between sections,
+ * no double blank lines, trailing newline.
+ */
+const normalizeReleaseMarkdown = (md) => {
+    const lines = md.split('\n');
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        const nextLine = lines[i + 1] ?? '';
+        result.push(line);
+        // After a heading (### or ####), ensure exactly one blank line before content
+        if ((line.startsWith('###') || line.startsWith('####')) && nextLine.trim() !== '') {
+            result.push('');
+        }
+        // After a bullet line, if next line is a heading, ensure blank line
+        if (line.startsWith('-') && (nextLine.startsWith('###') || nextLine.startsWith('####'))) {
+            result.push('');
+        }
+    }
+    // Collapse multiple blank lines into one
+    return result
+        .join('\n')
+        .replaceAll(/\n{3,}/g, '\n\n')
+        .trim();
+};
 const parseSemver = (version) => {
     const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
     if (!match)
@@ -31,7 +60,9 @@ const getCurrentVersion = () => {
 };
 const getExistingTags = () => {
     try {
-        const output = execSilent('git tag --list --sort=-v:refname').trim();
+        // Sort by creation date (newest first), NOT version number.
+        // Version sort breaks when older dummy/test tags have higher semver (e.g. v2.0.0 before v0.3.x).
+        const output = execSilent('git tag --list --sort=-creatordate').trim();
         return output ? output.split('\n').filter(Boolean) : [];
     }
     catch {
@@ -102,6 +133,14 @@ const updatePackageVersion = (newVersion) => {
     const pkg = JSON.parse(content);
     pkg.version = newVersion;
     writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+    // Also update the compiled-binary-safe version constant
+    try {
+        const versionTs = readFileSync('src/version.ts', 'utf8');
+        writeFileSync('src/version.ts', versionTs.replace(/VERSION = '[^']*'/, `VERSION = '${newVersion}'`), 'utf8');
+    }
+    catch {
+        /* version.ts update is best-effort */
+    }
 };
 // ─── stripConventional helpers ───
 const stripFeatPrefix = (s) => {
@@ -137,24 +176,24 @@ const generateReleaseMd = (version, commits, prevVersion) => {
         day: 'numeric',
     });
     const cat = categorizeCommits(commits);
+    // Each version is a ## section so multiple versions stack in a single file
     const header = [
-        `# Release v${version}`,
+        `## v${version} — ${date}`,
         '',
-        `**Release date:** ${date}`,
-        `**Previous version:** v${prevVersion}`,
+        `> Previous version: v${prevVersion}`,
         '',
-        "## What's New?",
+        "### What's New?",
         '',
     ];
     const featureSection = cat.features.length > 0
-        ? ['### New Features', '', ...cat.features.map((f) => `- ${stripFeatPrefix(f.subject)}`), '']
+        ? ['#### New Features', '', ...cat.features.map((f) => `- ${stripFeatPrefix(f.subject)}`), '']
         : [];
     const fixSection = cat.fixes.length > 0
-        ? ['### Bug Fixes', '', ...cat.fixes.map((f) => `- ${stripFixPrefix(f.subject)}`), '']
+        ? ['#### Bug Fixes', '', ...cat.fixes.map((f) => `- ${stripFixPrefix(f.subject)}`), '']
         : [];
     const breakingSection = cat.breaking.length > 0
         ? [
-            '### Important Changes',
+            '#### Important Changes',
             '',
             '> Note: Some changes in this version may require adjustments.',
             '',
@@ -164,19 +203,13 @@ const generateReleaseMd = (version, commits, prevVersion) => {
         : [];
     const otherSection = cat.other.length > 0
         ? [
-            '### Other Improvements',
+            '#### Other Improvements',
             '',
             ...cat.other.map((o) => `- ${stripConventionalPrefix(o.subject)}`),
             '',
         ]
         : [];
     const empty = commits.length === 0 ? ['No significant changes in this version.', ''] : [];
-    const footer = [
-        '---',
-        '',
-        '*This document was automatically generated by [Geeto CLI](https://github.com/rust142/geeto)*',
-        '',
-    ];
     return [
         ...header,
         ...featureSection,
@@ -184,7 +217,8 @@ const generateReleaseMd = (version, commits, prevVersion) => {
         ...breakingSection,
         ...otherSection,
         ...empty,
-        ...footer,
+        '---',
+        '',
     ].join('\n');
 };
 // ─── CHANGELOG.md generator (developer-facing, per-commit) ───
@@ -216,10 +250,448 @@ const generateChangelogEntry = (version, commits, prevVersion) => {
         : [];
     return [...header, ...breakingSection, ...featureSection, ...fixSection, ...otherSection].join('\n');
 };
+// ─── Sync GitHub Releases for existing tags ───
+const getExistingGithubReleases = () => {
+    try {
+        const output = execSilent('gh release list --limit 100 --json tagName --jq ".[].tagName"').trim();
+        return output ? output.split('\n').filter(Boolean) : [];
+    }
+    catch {
+        return [];
+    }
+};
+const handleSyncReleases = async () => {
+    const line = '─'.repeat(56);
+    // Check if gh CLI is available
+    try {
+        execSilent('gh --version');
+    }
+    catch {
+        log.error('GitHub CLI (gh) is not installed. Install it: https://cli.github.com');
+        return;
+    }
+    console.log('');
+    const spinner = log.spinner();
+    spinner.start('Checking GitHub releases...');
+    const localTags = getExistingTags();
+    const ghReleases = getExistingGithubReleases();
+    const missingTags = localTags.filter((t) => !ghReleases.includes(t));
+    spinner.succeed(`Found ${localTags.length} tags, ${ghReleases.length} GitHub releases`);
+    if (missingTags.length === 0) {
+        console.log('');
+        log.success('All tags have GitHub Releases! Nothing to sync.');
+        return;
+    }
+    console.log('');
+    log.info(`${colors.bright}${missingTags.length}${colors.reset} tags missing GitHub Releases:`);
+    for (const tag of missingTags) {
+        console.log(`  ${colors.yellow}${tag}${colors.reset}`);
+    }
+    console.log('');
+    const action = await select('What do you want to do?', [
+        { label: 'Create releases for all missing tags', value: 'all' },
+        { label: 'Select which tags to release', value: 'select' },
+        { label: 'Cancel', value: 'cancel' },
+    ]);
+    if (action === 'cancel')
+        return;
+    let tagsToRelease = missingTags;
+    if (action === 'select') {
+        const { multiSelect } = await import('../cli/menu.js');
+        const choices = missingTags.map((t) => ({ label: t, value: t }));
+        const selected = await multiSelect('Select tags to create releases for:', choices);
+        if (selected.length === 0) {
+            log.info('No tags selected.');
+            return;
+        }
+        tagsToRelease = selected;
+    }
+    // Choose release notes mode: AI or template
+    console.log('');
+    const notesMode = await select('How should release notes be generated?', [
+        { label: 'AI-generated (recommended)', value: 'ai' },
+        { label: 'Auto-generate (template-based)', value: 'auto' },
+    ]);
+    // AI setup if needed
+    let useAI = notesMode === 'ai';
+    let language = 'en';
+    let aiProvider = 'copilot';
+    let copilotModel;
+    let openrouterModel;
+    let geminiModel;
+    if (useAI) {
+        language = (await select('Release notes language:', [
+            { label: 'English', value: 'en' },
+            { label: 'Indonesian (Bahasa Indonesia)', value: 'id' },
+        ]));
+        // Check saved config
+        const savedState = loadState();
+        if (savedState?.aiProvider &&
+            savedState.aiProvider !== 'manual' &&
+            (savedState.copilotModel || savedState.openrouterModel || savedState.geminiModel)) {
+            aiProvider = savedState.aiProvider;
+            copilotModel = savedState.copilotModel;
+            openrouterModel = savedState.openrouterModel;
+            geminiModel = savedState.geminiModel;
+        }
+        else {
+            let providerChosen = false;
+            while (!providerChosen) {
+                aiProvider = (await select('Choose AI Provider:', [
+                    { label: 'GitHub Copilot (Recommended)', value: 'copilot' },
+                    { label: 'Gemini', value: 'gemini' },
+                    { label: 'OpenRouter', value: 'openrouter' },
+                ]));
+                const chosen = await chooseModelForProvider(aiProvider, undefined, 'Back to AI provider menu');
+                if (!chosen || chosen === 'back')
+                    continue;
+                switch (aiProvider) {
+                    case 'gemini': {
+                        geminiModel = chosen;
+                        break;
+                    }
+                    case 'copilot': {
+                        copilotModel = chosen;
+                        break;
+                    }
+                    case 'openrouter': {
+                        openrouterModel = chosen;
+                        break;
+                    }
+                }
+                providerChosen = true;
+            }
+        }
+    }
+    // Preview and confirm
+    console.log('');
+    console.log(`${colors.cyan}┌${line}┐${colors.reset}`);
+    console.log(`${colors.cyan}│${colors.reset} ${colors.bright}Sync Plan${colors.reset}`);
+    console.log(`${colors.cyan}├${line}┤${colors.reset}`);
+    for (const tag of tagsToRelease) {
+        const ver = tag.replace(/^v/, '');
+        console.log(`${colors.cyan}│${colors.reset}  ${colors.green}+${colors.reset} Create release for ${colors.yellow}${ver}${colors.reset}`);
+    }
+    console.log(`${colors.cyan}│${colors.reset}  ${colors.gray}Mode: ${useAI ? 'AI-generated' : 'Template-based'}${colors.reset}`);
+    console.log(`${colors.cyan}└${line}┘${colors.reset}`);
+    console.log('');
+    const proceed = confirm(`Create ${tagsToRelease.length} GitHub Releases?`);
+    if (!proceed)
+        return;
+    // Create releases one by one
+    const allTags = getExistingTags();
+    let successCount = 0;
+    for (const tag of tagsToRelease) {
+        const ver = tag.replace(/^v/, '');
+        const tagIdx = allTags.indexOf(tag);
+        const prevTag = allTags[tagIdx + 1];
+        const commits = getCommitsSinceTag(prevTag);
+        const commitList = commits.map((c) => c.subject).join('\n');
+        let releaseBody;
+        if (useAI && commits.length > 0) {
+            console.log('');
+            const aiSpinner = log.spinner();
+            const modelDisplay = getModelValue(copilotModel ?? openrouterModel ?? geminiModel ?? '');
+            aiSpinner.start(`Generating notes for ${tag} with ${getAIProviderShortName(aiProvider)}` +
+                (modelDisplay ? ` (${modelDisplay})` : '') +
+                '...');
+            const aiResult = await generateReleaseNotesWithProvider(aiProvider, commitList, language, undefined, copilotModel, openrouterModel, geminiModel);
+            if (aiResult) {
+                aiSpinner.succeed(`Notes generated for ${tag}`);
+                releaseBody = normalizeReleaseMarkdown(aiResult);
+                // Preview notes for user review
+                console.log('');
+                console.log(`${colors.cyan}┌${'─'.repeat(56)}┐${colors.reset}`);
+                console.log(`${colors.cyan}│${colors.reset} ${colors.bright}Release Notes — ${tag}${colors.reset}`);
+                console.log(`${colors.cyan}├${'─'.repeat(56)}┤${colors.reset}`);
+                for (const noteLine of releaseBody.split('\n')) {
+                    console.log(`${colors.cyan}│${colors.reset} ${noteLine}`);
+                }
+                console.log(`${colors.cyan}└${'─'.repeat(56)}┘${colors.reset}`);
+                console.log('');
+                const reviewAction = await select(`Publish release for ${tag}?`, [
+                    { label: 'Yes, publish', value: 'accept' },
+                    { label: 'Skip this tag', value: 'skip' },
+                ]);
+                if (reviewAction === 'skip')
+                    continue;
+            }
+            else {
+                aiSpinner.fail(`AI failed for ${tag}, using template`);
+                useAI = false;
+                releaseBody = generateReleaseMd(ver, commits, prevTag?.replace(/^v/, '') ?? '0.0.0')
+                    .replace(/^## .*\n+/, '')
+                    .replace(/\n---\n*$/, '')
+                    .trim();
+            }
+        }
+        else {
+            releaseBody = generateReleaseMd(ver, commits, prevTag?.replace(/^v/, '') ?? '0.0.0')
+                .replace(/^## .*\n+/, '')
+                .replace(/\n---\n*$/, '')
+                .trim();
+        }
+        console.log('');
+        const releaseSpinner = log.spinner();
+        // Ensure tag exists on remote before creating GitHub Release
+        releaseSpinner.start(`Pushing tag ${colors.yellow}${tag}${colors.reset} to remote...`);
+        try {
+            await execAsync(`git push origin ${tag} --no-verify`, true);
+            releaseSpinner.succeed(`Tag ${tag} pushed to remote`);
+        }
+        catch {
+            // Tag might already exist on remote — that's fine, continue
+        }
+        console.log('');
+        const createSpinner = log.spinner();
+        createSpinner.start(`Creating release ${colors.yellow}${tag}${colors.reset}...`);
+        const os = await import('node:os');
+        const tempFile = `${os.tmpdir()}/geeto-sync-${Date.now()}.md`;
+        writeFileSync(tempFile, releaseBody, 'utf8');
+        try {
+            await execAsync(`gh release create ${tag} --title "${tag}" --notes-file "${tempFile}"`, true);
+            createSpinner.succeed(`Release ${tag} created`);
+            successCount++;
+        }
+        catch (error) {
+            const stderr = error.stderr?.trim();
+            createSpinner.fail(`Failed to create release for ${tag}`);
+            if (stderr)
+                log.error(`  ${stderr.split('\n')[0]}`);
+        }
+        // Cleanup temp file
+        try {
+            const { unlinkSync } = await import('node:fs');
+            unlinkSync(tempFile);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    console.log('');
+    if (successCount === tagsToRelease.length) {
+        log.success(`All ${successCount} GitHub Releases created!`);
+    }
+    else {
+        log.warn(`${successCount}/${tagsToRelease.length} releases created`);
+    }
+};
+// ─── Delete GitHub Releases ───
+const handleDeleteReleases = async () => {
+    // Check if gh CLI is available
+    try {
+        execSilent('gh --version');
+    }
+    catch {
+        log.error('GitHub CLI (gh) is not installed. Install it: https://cli.github.com');
+        return;
+    }
+    console.log('');
+    const spinner = log.spinner();
+    spinner.start('Fetching GitHub releases...');
+    const ghReleases = getExistingGithubReleases();
+    spinner.succeed(`Found ${ghReleases.length} GitHub releases`);
+    if (ghReleases.length === 0) {
+        console.log('');
+        log.info('No GitHub Releases to delete.');
+        return;
+    }
+    console.log('');
+    const { multiSelect } = await import('../cli/menu.js');
+    const choices = ghReleases.map((t) => ({ label: t, value: t }));
+    const selected = await multiSelect('Select releases to delete:', choices);
+    if (selected.length === 0) {
+        log.info('No releases selected.');
+        return;
+    }
+    console.log('');
+    const alsoDeleteTag = confirm('Also delete the associated git tags?');
+    console.log('');
+    const proceed = confirm(`Delete ${selected.length} GitHub Release(s)${alsoDeleteTag ? ' + tags' : ''}?`);
+    if (!proceed)
+        return;
+    let successCount = 0;
+    for (const release of selected) {
+        console.log('');
+        const releaseSpinner = log.spinner();
+        releaseSpinner.start(`Deleting release ${colors.yellow}${release}${colors.reset}...`);
+        try {
+            await execAsync(`gh release delete ${release} --yes`, true);
+            if (alsoDeleteTag) {
+                try {
+                    await execAsync(`git tag -d ${release}`, true);
+                    await execAsync(`git push origin --delete ${release} --no-verify`, true);
+                }
+                catch {
+                    /* Tag deletion is best-effort */
+                }
+            }
+            releaseSpinner.succeed(`Release ${release} deleted${alsoDeleteTag ? ' + tag' : ''}`);
+            successCount++;
+        }
+        catch (error) {
+            const stderr = error.stderr?.trim();
+            releaseSpinner.fail(`Failed to delete ${release}`);
+            if (stderr)
+                log.error(`  ${stderr.split('\n')[0]}`);
+        }
+    }
+    console.log('');
+    if (successCount === selected.length) {
+        log.success(`All ${successCount} releases deleted!`);
+    }
+    else {
+        log.warn(`${successCount}/${selected.length} releases deleted`);
+    }
+};
+// ─── Recover missing tags ───
+const handleRecoverTags = async () => {
+    const line = '─'.repeat(56);
+    console.log('');
+    const spinner = log.spinner();
+    spinner.start('Scanning release commits...');
+    // Find all release commits: "chore(release): vX.Y.Z"
+    let gitLog;
+    try {
+        gitLog = exec('git log --all --oneline --grep="^chore(release): v" --format="%H %s"', true);
+    }
+    catch {
+        spinner.fail('Failed to scan git log');
+        return;
+    }
+    const releasePattern = /^([a-f0-9]+) chore\(release\): v(.+)$/;
+    const releaseCommits = [];
+    for (const logLine of gitLog.split('\n').filter(Boolean)) {
+        const match = logLine.match(releasePattern);
+        if (match?.[1] && match[2]) {
+            releaseCommits.push({
+                hash: match[1],
+                version: match[2],
+                tag: `v${match[2]}`,
+            });
+        }
+    }
+    if (releaseCommits.length === 0) {
+        spinner.fail('No release commits found');
+        return;
+    }
+    // Compare with existing tags
+    const existingTags = new Set(getExistingTags());
+    const missingTags = releaseCommits.filter((rc) => !existingTags.has(rc.tag));
+    spinner.succeed(`Found ${releaseCommits.length} release commits, ${existingTags.size} tags`);
+    if (missingTags.length === 0) {
+        console.log('');
+        log.success('All release commits have matching tags! Nothing to recover.');
+        return;
+    }
+    // Show missing tags
+    console.log('');
+    log.info(`${colors.bright}${missingTags.length}${colors.reset} tags missing (release commit exists but no tag):`);
+    for (const mt of missingTags) {
+        console.log(`  ${colors.yellow}${mt.tag}${colors.reset} ${colors.gray}← ${mt.hash.slice(0, 7)}${colors.reset}`);
+    }
+    console.log('');
+    const action = await select('What do you want to do?', [
+        { label: 'Recover all missing tags', value: 'all' },
+        { label: 'Select which tags to recover', value: 'select' },
+        { label: 'Cancel', value: 'cancel' },
+    ]);
+    if (action === 'cancel')
+        return;
+    let tagsToRecover = missingTags;
+    if (action === 'select') {
+        const { multiSelect } = await import('../cli/menu.js');
+        const choices = missingTags.map((mt) => ({
+            label: `${mt.tag} (${mt.hash.slice(0, 7)})`,
+            value: mt.tag,
+        }));
+        const selected = await multiSelect('Select tags to recover:', choices);
+        if (selected.length === 0) {
+            log.info('No tags selected.');
+            return;
+        }
+        tagsToRecover = missingTags.filter((mt) => selected.includes(mt.tag));
+    }
+    // Preview
+    console.log('');
+    console.log(`${colors.cyan}┌${line}┐${colors.reset}`);
+    console.log(`${colors.cyan}│${colors.reset} ${colors.bright}Recovery Plan${colors.reset}`);
+    console.log(`${colors.cyan}├${line}┤${colors.reset}`);
+    for (const mt of tagsToRecover) {
+        console.log(`${colors.cyan}│${colors.reset}  ${colors.green}+${colors.reset} ${colors.yellow}${mt.tag}${colors.reset} → commit ${colors.gray}${mt.hash.slice(0, 7)}${colors.reset}`);
+    }
+    console.log(`${colors.cyan}└${line}┘${colors.reset}`);
+    console.log('');
+    const proceed = confirm(`Create ${tagsToRecover.length} tags?`);
+    if (!proceed)
+        return;
+    let successCount = 0;
+    for (const mt of tagsToRecover) {
+        console.log('');
+        const tagSpinner = log.spinner();
+        tagSpinner.start(`Creating tag ${colors.yellow}${mt.tag}${colors.reset}...`);
+        try {
+            exec(`git tag -a ${mt.tag} ${mt.hash} -m "Release ${mt.tag}"`, true);
+            tagSpinner.succeed(`Tag ${mt.tag} created`);
+            successCount++;
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            tagSpinner.fail(`Failed to create ${mt.tag}`);
+            log.error(`  ${errMsg.split('\n')[0]}`);
+        }
+    }
+    console.log('');
+    if (successCount === tagsToRecover.length) {
+        log.success(`All ${successCount} tags recovered!`);
+    }
+    else {
+        log.warn(`${successCount}/${tagsToRecover.length} tags recovered`);
+    }
+    // Offer to push tags to remote
+    if (successCount > 0) {
+        console.log('');
+        const pushTags = confirm('Push recovered tags to remote?');
+        if (pushTags) {
+            console.log('');
+            const pushSpinner = log.spinner();
+            pushSpinner.start('Pushing tags to remote...');
+            try {
+                await execAsync('git push --tags --no-verify', true);
+                pushSpinner.succeed('Tags pushed to remote');
+            }
+            catch (error) {
+                const stderr = error.stderr?.trim();
+                pushSpinner.fail('Failed to push tags');
+                if (stderr)
+                    log.error(`  ${stderr.split('\n')[0]}`);
+            }
+        }
+    }
+};
 // ─── Main handler ───
 export const handleRelease = async () => {
     log.banner();
     log.step(`${colors.cyan}Release / Tag Manager${colors.reset}\n`);
+    // Main menu: create new release, sync, or manage releases
+    const mode = await select('What do you want to do?', [
+        { label: 'Create a new release', value: 'create' },
+        { label: 'Sync GitHub Releases for existing tags', value: 'sync' },
+        { label: 'Recover missing tags from release commits', value: 'recover' },
+        { label: 'Delete GitHub Releases', value: 'delete' },
+    ]);
+    if (mode === 'sync') {
+        await handleSyncReleases();
+        return;
+    }
+    if (mode === 'recover') {
+        await handleRecoverTags();
+        return;
+    }
+    if (mode === 'delete') {
+        await handleDeleteReleases();
+        return;
+    }
     const currentVersion = getCurrentVersion();
     const semver = parseSemver(currentVersion);
     if (!semver) {
@@ -330,6 +802,182 @@ export const handleRelease = async () => {
         log.info('Cancelled.');
         return;
     }
+    // ─── AI Release Notes Generation ───
+    // Ask how to generate release notes for RELEASE.MD
+    const commitList = commits.map((c) => c.subject).join('\n');
+    console.log('');
+    const releaseNotesMode = await select('How do you want to generate RELEASE.MD?', [
+        { label: 'AI-generated (recommended)', value: 'ai' },
+        { label: 'Auto-generate (template-based)', value: 'auto' },
+    ]);
+    let aiReleaseNotes = null;
+    if (releaseNotesMode === 'ai' && commits.length > 0) {
+        // Choose language
+        const language = (await select('Release notes language:', [
+            { label: 'English', value: 'en' },
+            { label: 'Indonesian (Bahasa Indonesia)', value: 'id' },
+        ]));
+        // Read saved AI config from state
+        const savedState = loadState();
+        let aiProvider = 'copilot';
+        let copilotModel;
+        let openrouterModel;
+        let geminiModel;
+        // Use saved provider/model if available, otherwise ask user
+        if (savedState?.aiProvider &&
+            savedState.aiProvider !== 'manual' &&
+            (savedState.copilotModel || savedState.openrouterModel || savedState.geminiModel)) {
+            aiProvider = savedState.aiProvider;
+            copilotModel = savedState.copilotModel;
+            openrouterModel = savedState.openrouterModel;
+            geminiModel = savedState.geminiModel;
+        }
+        else {
+            // No saved config — ask user to pick provider + model
+            let providerChosen = false;
+            while (!providerChosen) {
+                aiProvider = (await select('Choose AI Provider:', [
+                    { label: 'GitHub Copilot (Recommended)', value: 'copilot' },
+                    { label: 'Gemini', value: 'gemini' },
+                    { label: 'OpenRouter', value: 'openrouter' },
+                ]));
+                const chosen = await chooseModelForProvider(aiProvider, undefined, 'Back to AI provider menu');
+                if (!chosen || chosen === 'back')
+                    continue;
+                switch (aiProvider) {
+                    case 'gemini': {
+                        geminiModel = chosen;
+                        break;
+                    }
+                    case 'copilot': {
+                        copilotModel = chosen;
+                        break;
+                    }
+                    case 'openrouter': {
+                        openrouterModel = chosen;
+                        break;
+                    }
+                }
+                providerChosen = true;
+            }
+        }
+        // Generate/regenerate loop (similar to commit flow)
+        let correction;
+        let accepted = false;
+        while (!accepted) {
+            const spinner = log.spinner();
+            const modelDisplay = getModelValue(copilotModel ?? openrouterModel ?? geminiModel ?? '');
+            spinner.start(`Generating release notes with ${getAIProviderShortName(aiProvider)}` +
+                (modelDisplay ? ` (${modelDisplay})` : '') +
+                '...');
+            const result = await generateReleaseNotesWithProvider(aiProvider, commitList, language, correction, copilotModel, openrouterModel, geminiModel);
+            spinner.succeed('Release notes generated');
+            console.log('');
+            if (!result) {
+                log.warn('AI returned no result. Falling back to template-based generation.');
+                break;
+            }
+            aiReleaseNotes = result;
+            // Preview
+            console.log(`${colors.cyan}┌${'─'.repeat(56)}┐${colors.reset}`);
+            console.log(`${colors.cyan}│${colors.reset} ${colors.bright}Release Notes Preview${colors.reset}`);
+            console.log(`${colors.cyan}├${'─'.repeat(56)}┤${colors.reset}`);
+            for (const line of aiReleaseNotes.split('\n')) {
+                console.log(`${colors.cyan}│${colors.reset} ${line}`);
+            }
+            console.log(`${colors.cyan}└${'─'.repeat(56)}┘${colors.reset}`);
+            console.log('');
+            const action = await select('Accept these release notes?', [
+                { label: 'Yes, use it', value: 'accept' },
+                { label: 'Regenerate', value: 'regenerate' },
+                { label: 'Edit inline', value: 'edit' },
+                { label: 'Correct AI (give feedback)', value: 'correct' },
+                { label: 'Change model', value: 'change-model' },
+                { label: 'Change AI provider', value: 'change-provider' },
+                { label: 'Use template instead', value: 'template' },
+            ]);
+            switch (action) {
+                case 'accept': {
+                    accepted = true;
+                    break;
+                }
+                case 'regenerate': {
+                    correction = undefined;
+                    continue;
+                }
+                case 'edit': {
+                    const edited = await editInline(aiReleaseNotes, 'Release Notes', '.md');
+                    aiReleaseNotes = edited;
+                    accepted = true;
+                    break;
+                }
+                case 'correct': {
+                    if (process.stdin.isTTY)
+                        process.stdin.setRawMode(false);
+                    const feedback = askQuestion('Feedback for AI: ').trim();
+                    if (feedback)
+                        correction = feedback;
+                    continue;
+                }
+                case 'change-model': {
+                    const newModel = await chooseModelForProvider(aiProvider, undefined, 'Back');
+                    if (newModel && newModel !== 'back') {
+                        switch (aiProvider) {
+                            case 'gemini': {
+                                geminiModel = newModel;
+                                break;
+                            }
+                            case 'copilot': {
+                                copilotModel = newModel;
+                                break;
+                            }
+                            case 'openrouter': {
+                                openrouterModel = newModel;
+                                break;
+                            }
+                        }
+                    }
+                    correction = undefined;
+                    continue;
+                }
+                case 'change-provider': {
+                    const prov = (await select('Choose AI provider:', [
+                        { label: 'GitHub Copilot', value: 'copilot' },
+                        { label: 'Gemini', value: 'gemini' },
+                        { label: 'OpenRouter', value: 'openrouter' },
+                    ]));
+                    aiProvider = prov;
+                    copilotModel = undefined;
+                    openrouterModel = undefined;
+                    geminiModel = undefined;
+                    const newModel = await chooseModelForProvider(aiProvider, undefined, 'Back');
+                    if (newModel && newModel !== 'back') {
+                        switch (aiProvider) {
+                            case 'gemini': {
+                                geminiModel = newModel;
+                                break;
+                            }
+                            case 'copilot': {
+                                copilotModel = newModel;
+                                break;
+                            }
+                            case 'openrouter': {
+                                openrouterModel = newModel;
+                                break;
+                            }
+                        }
+                    }
+                    correction = undefined;
+                    continue;
+                }
+                case 'template': {
+                    aiReleaseNotes = null;
+                    accepted = true;
+                    break;
+                }
+            }
+        }
+    }
     // Execute release steps
     const spinner = log.spinner();
     // 1. Update package.json
@@ -342,14 +990,58 @@ export const handleRelease = async () => {
         spinner.fail('Failed to update package.json');
         return;
     }
-    // 2. Generate RELEASE.MD
-    spinner.start('Generating RELEASE.MD...');
+    // 2. Update RELEASE.MD (prepend new version, keep old ones)
+    spinner.start('Updating RELEASE.MD...');
     try {
-        writeFileSync('RELEASE.MD', generateReleaseMd(newVersion, commits, currentVersion), 'utf8');
-        spinner.succeed('RELEASE.MD generated');
+        // Use AI-generated notes if available, otherwise fallback to template
+        let newEntry;
+        if (aiReleaseNotes) {
+            const now = new Date();
+            const date = now.toLocaleDateString('en-US', {
+                year: 'numeric',
+                month: 'long',
+                day: 'numeric',
+            });
+            const normalizedNotes = normalizeReleaseMarkdown(aiReleaseNotes);
+            newEntry =
+                [`## v${newVersion} — ${date}`, '', normalizedNotes, '', '---', ''].join('\n') + '\n';
+        }
+        else {
+            newEntry = generateReleaseMd(newVersion, commits, currentVersion);
+        }
+        let existing = '';
+        try {
+            existing = readFileSync('RELEASE.MD', 'utf8');
+        }
+        catch {
+            // File doesn't exist yet
+        }
+        const header = '# Releases\n\n';
+        const footer = '\n*This document was automatically generated by [Geeto CLI](https://github.com/rust142/geeto)*\n';
+        let releaseMd;
+        if (existing.startsWith('# Releases')) {
+            // Strip old header and footer, prepend new entry after header
+            const headerEnd = existing.indexOf('\n\n') + 2;
+            let body = existing.slice(headerEnd);
+            // Remove trailing auto-generated footer if present
+            const footerIdx = body.lastIndexOf('*This document was automatically generated by [Geeto CLI]');
+            if (footerIdx !== -1) {
+                body = body.slice(0, footerIdx).trimEnd() + '\n\n';
+            }
+            releaseMd = header + newEntry + body + footer;
+        }
+        else if (existing) {
+            // Old format without "# Releases" header — keep existing below new entry
+            releaseMd = header + newEntry + existing + '\n' + footer;
+        }
+        else {
+            releaseMd = header + newEntry + footer;
+        }
+        writeFileSync('RELEASE.MD', releaseMd, 'utf8');
+        spinner.succeed('RELEASE.MD updated');
     }
     catch {
-        spinner.fail('Failed to generate RELEASE.MD');
+        spinner.fail('Failed to update RELEASE.MD');
     }
     // 3. Update CHANGELOG.md
     spinner.start('Updating CHANGELOG.md...');
@@ -382,7 +1074,7 @@ export const handleRelease = async () => {
     // 4. Stage, commit, tag
     spinner.start('Creating release commit...');
     try {
-        exec('git add package.json RELEASE.MD CHANGELOG.md', true);
+        exec('git add package.json src/version.ts RELEASE.MD CHANGELOG.md', true);
         exec(`git commit --no-verify -m "chore(release): v${newVersion}"`, true);
         spinner.succeed('Release commit created');
     }
@@ -402,8 +1094,8 @@ export const handleRelease = async () => {
     // 5. Push
     console.log('');
     const pushChoice = await select('Push to remote?', [
-        { label: 'Push commit + tag', value: 'both' },
-        { label: 'Push commit only', value: 'commit' },
+        { label: 'Push release + tag', value: 'both' },
+        { label: 'Push release only', value: 'commit' },
         { label: 'Skip pushing', value: 'skip' },
     ]);
     if (pushChoice === 'both' || pushChoice === 'commit') {
@@ -416,13 +1108,13 @@ export const handleRelease = async () => {
         try {
             await execAsync(`git push`, true);
             if (pushChoice === 'both') {
-                await execAsync(`git push origin v${newVersion}`, true);
+                await execAsync(`git push origin v${newVersion} --no-verify`, true);
             }
             clearInterval(interval);
             progressBar.update(100);
             progressBar.complete();
             console.log('');
-            log.success(pushChoice === 'both' ? 'Pushed commit + tag' : 'Pushed commit');
+            log.success(pushChoice === 'both' ? 'Pushed release + tag' : 'Pushed release');
         }
         catch {
             clearInterval(interval);
@@ -431,6 +1123,49 @@ export const handleRelease = async () => {
             log.error('Failed to push');
         }
     }
+    // 6. Create GitHub Release (if tag was pushed and gh CLI is available)
+    let ghReleaseCreated = false;
+    if (pushChoice === 'both') {
+        try {
+            execSilent('gh --version');
+            // gh CLI is available — create a GitHub Release
+            // Build release body from AI notes or template
+            const releaseBody = aiReleaseNotes
+                ? normalizeReleaseMarkdown(aiReleaseNotes)
+                : generateReleaseMd(newVersion, commits, currentVersion)
+                    .replace(/^## .*\n+/, '')
+                    .replace(/\n---\n*$/, '')
+                    .trim();
+            // Write to temp file to avoid shell quoting issues
+            const os = await import('node:os');
+            const tempFile = `${os.tmpdir()}/geeto-release-${Date.now()}.md`;
+            writeFileSync(tempFile, releaseBody, 'utf8');
+            const releaseSpinner = log.spinner();
+            releaseSpinner.start('Creating GitHub Release...');
+            try {
+                await execAsync(`gh release create v${newVersion} --title "v${newVersion}" --notes-file "${tempFile}"`, true);
+                releaseSpinner.succeed('GitHub Release created');
+                ghReleaseCreated = true;
+            }
+            catch (error) {
+                const stderr = error.stderr?.trim();
+                releaseSpinner.fail('Failed to create GitHub Release');
+                if (stderr)
+                    log.error(`  ${stderr.split('\n')[0]}`);
+            }
+            // Cleanup temp file
+            try {
+                const { unlinkSync } = await import('node:fs');
+                unlinkSync(tempFile);
+            }
+            catch {
+                /* ignore cleanup errors */
+            }
+        }
+        catch {
+            // gh CLI not available — skip silently
+        }
+    }
     // Summary
     console.log('');
     console.log(`${colors.cyan}┌${line}┐${colors.reset}`);
@@ -440,6 +1175,9 @@ export const handleRelease = async () => {
     console.log(`${colors.cyan}│${colors.reset}  ${colors.green}✓${colors.reset} RELEASE.MD generated ${colors.gray}(user-facing)${colors.reset}`);
     console.log(`${colors.cyan}│${colors.reset}  ${colors.green}✓${colors.reset} CHANGELOG.md updated ${colors.gray}(developer-facing)${colors.reset}`);
     console.log(`${colors.cyan}│${colors.reset}  ${colors.green}✓${colors.reset} Tag v${newVersion} created`);
+    if (ghReleaseCreated) {
+        console.log(`${colors.cyan}│${colors.reset}  ${colors.green}✓${colors.reset} GitHub Release published`);
+    }
     console.log(`${colors.cyan}└${line}┘${colors.reset}`);
 };
 //# sourceMappingURL=release.js.map