geeto 0.3.9 → 0.4.1

package/lib/workflows/release.js

@@ -12,6 +12,33 @@ import { chooseModelForProvider, generateReleaseNotesWithProvider, getAIProvider
 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)
@@ -223,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) {
@@ -366,10 +831,6 @@ export const handleRelease = async () => {
             copilotModel = savedState.copilotModel;
             openrouterModel = savedState.openrouterModel;
             geminiModel = savedState.geminiModel;
-            const modelDisplay = getModelValue(copilotModel ?? openrouterModel ?? geminiModel ?? '');
-            log.info(`Using saved AI config: ${getAIProviderShortName(aiProvider)}` +
-                (modelDisplay ? ` (${modelDisplay})` : ''));
-            console.log('');
         }
         else {
             // No saved config — ask user to pick provider + model
@@ -541,7 +1002,9 @@ export const handleRelease = async () => {
                 month: 'long',
                 day: 'numeric',
             });
-            newEntry = [`## v${newVersion} — ${date}`, '', aiReleaseNotes, '', '---', ''].join('\n');
+            const normalizedNotes = normalizeReleaseMarkdown(aiReleaseNotes);
+            newEntry =
+                [`## v${newVersion} — ${date}`, '', normalizedNotes, '', '---', ''].join('\n') + '\n';
         }
         else {
             newEntry = generateReleaseMd(newVersion, commits, currentVersion);
@@ -631,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') {
@@ -645,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);
@@ -660,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}`);
@@ -669,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