@juancr11/sibu 0.6.0 → 0.8.0

package/bin/modules/maintainer-release-support/release-workflow/handler.js

@@ -0,0 +1,369 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildChangelogProposal, retargetChangelogProposal } from '../generate-changelog/changelog-format.js';
+import { planChangelogUpdate } from '../generate-changelog/changelog-writer.js';
+import { readGitHistory } from '../generate-changelog/git-history.js';
+import { parseSemverVersion } from '../generate-changelog/semver.js';
+import { checkReleaseTagAvailable, resolveReleaseRange } from './git-release.js';
+import { planPackageJsonVersionUpdate } from './package-json.js';
+import { buildReleaseMetadataPlan, deriveSuggestedBumpFromChangelogProposal, formatReleaseTagName, incrementSemverVersion, renderReleasePlanPreview, extractReleaseChangelogSection, } from './release-plan.js';
+export function planMaintainerRelease(command, cwd = process.cwd()) {
+    const releaseRange = resolveReleaseRange(command, cwd);
+    if (releaseRange.status === 'blocked') {
+        return releaseRange;
+    }
+    const gitHistory = readGitHistory({
+        fromRef: releaseRange.range.fromRef,
+        toRef: releaseRange.range.toRef,
+    }, cwd);
+    if (gitHistory.status === 'blocked') {
+        return {
+            status: 'blocked',
+            message: gitHistory.message,
+            warnings: gitHistory.warnings.map((warning) => ({ code: warning.code, message: warning.message })),
+        };
+    }
+    const commitDerivedChangelogProposal = buildChangelogProposal({
+        commits: gitHistory.commits,
+        sourceRange: gitHistory.sourceRange,
+        warnings: gitHistory.warnings,
+    });
+    const suggestedBump = deriveSuggestedBumpFromChangelogProposal(commitDerivedChangelogProposal);
+    const targetVersion = resolveTargetVersion({ fromRef: releaseRange.range.fromRef, requestedVersion: command.version, suggestedBump });
+    if (targetVersion.status === 'blocked') {
+        return targetVersion;
+    }
+    const targetDate = command.date ?? new Date().toISOString().slice(0, 10);
+    const changelogProposal = retargetChangelogProposal(commitDerivedChangelogProposal, {
+        type: 'version',
+        version: targetVersion.version,
+        date: targetDate,
+    });
+    const tagName = formatReleaseTagName(targetVersion.version);
+    const tagAvailability = checkReleaseTagAvailable(tagName, cwd);
+    if (tagAvailability.status === 'blocked') {
+        return tagAvailability;
+    }
+    const changelogUpdatePlan = planChangelogUpdate(readFileIfExists(path.join(cwd, 'CHANGELOG.md')), changelogProposal);
+    if (changelogUpdatePlan.status === 'blocked') {
+        return {
+            status: 'blocked',
+            message: changelogUpdatePlan.message,
+            warnings: changelogUpdatePlan.warnings.map((warning) => ({ code: warning.code, message: warning.message })),
+        };
+    }
+    const packageJsonUpdatePlan = planPackageJsonVersionUpdate(readFileIfExists(path.join(cwd, 'package.json')), targetVersion.version);
+    if (packageJsonUpdatePlan.status === 'blocked') {
+        return packageJsonUpdatePlan;
+    }
+    const existingChangelogSection = extractReleaseChangelogSection(readFileIfExists(path.join(cwd, 'CHANGELOG.md')) ?? '', targetVersion.version);
+    const metadataAlreadyPrepared = packageJsonUpdatePlan.plan.currentVersion === targetVersion.version && existingChangelogSection !== undefined && tagAvailability.existingTagAtHead;
+    return {
+        status: 'planned',
+        plan: {
+            range: releaseRange.range,
+            targetVersion: targetVersion.version,
+            tagName,
+            suggestedBump,
+            commitCount: gitHistory.commits.length,
+            otp: command.otp,
+            hasOtp: command.otp !== undefined,
+            metadataAlreadyPrepared,
+            existingTagAtHead: tagAvailability.existingTagAtHead,
+            metadata: buildReleaseMetadataPlan({
+                changelog: {
+                    path: 'CHANGELOG.md',
+                    targetVersion: targetVersion.version,
+                    targetDate,
+                    replacingExistingSection: changelogUpdatePlan.replacingExistingSection,
+                    nextContent: changelogUpdatePlan.content,
+                },
+                packageJson: packageJsonUpdatePlan.plan,
+            }),
+            warnings: changelogProposal.warnings.map((warning) => ({ code: warning.code, message: warning.message })),
+        },
+    };
+}
+export async function previewAndConfirmMaintainerRelease(command, ports, cwd = process.cwd()) {
+    ports.print('Starting maintainer release planning...\n');
+    const planningResult = planMaintainerRelease(command, cwd);
+    if (planningResult.status === 'blocked') {
+        ports.print(`Release planning blocked: ${planningResult.message}\n`);
+        printWarnings(planningResult.warnings, ports);
+        return planningResult;
+    }
+    ports.print(`Release plan ready for ${planningResult.plan.targetVersion} from ${planningResult.plan.range.fromRef} to ${planningResult.plan.range.toRef}.\n\n`);
+    const preview = renderReleasePlanPreview(planningResult.plan);
+    ports.print(preview);
+    if (command.dryRun) {
+        ports.print('Dry run requested; no files, commands, tags, publishes, pushes, or GitHub Releases will be created.\n');
+        return {
+            status: 'dry-run',
+            plan: planningResult.plan,
+            preview,
+        };
+    }
+    if (!command.assumeYes) {
+        ports.print('Waiting for maintainer confirmation before making changes...\n');
+        const confirmed = await ports.confirmRelease(planningResult.plan);
+        if (!confirmed) {
+            ports.print('Release confirmation declined; no changes were written.\n');
+            return {
+                status: 'declined',
+                plan: planningResult.plan,
+                preview,
+            };
+        }
+    }
+    else {
+        ports.print('--yes provided; continuing after preview without prompting.\n');
+    }
+    ports.print('Release confirmed; starting execution.\n');
+    return {
+        status: 'confirmed',
+        plan: planningResult.plan,
+        preview,
+        execution: await executeConfirmedRelease(planningResult.plan, ports),
+    };
+}
+export async function executeConfirmedRelease(plan, ports) {
+    const completedSteps = [];
+    if (!plan.metadata) {
+        return failExecution(completedSteps, 'write-changelog', 'Release plan does not include metadata updates.');
+    }
+    const npmAuth = await runStep(ports, completedSteps, 'check-npm-auth', 'Checking npm authentication: npm whoami...', 'npm', ['whoami'], 'npm authentication check passed.');
+    if (npmAuth.status === 'failed') {
+        return npmAuth;
+    }
+    const githubAuth = await runStep(ports, completedSteps, 'check-github-auth', 'Checking GitHub authentication: gh auth status...', 'gh', ['auth', 'status'], 'GitHub authentication check passed.');
+    if (githubAuth.status === 'failed') {
+        return githubAuth;
+    }
+    const build = await runStep(ports, completedSteps, 'build-release', 'Building release artifacts: pnpm build...', 'pnpm', ['build'], 'Release build passed.');
+    if (build.status === 'failed') {
+        return build;
+    }
+    if (plan.metadataAlreadyPrepared) {
+        completedSteps.push({ name: 'write-changelog', message: `${plan.metadata.changelog.path} already prepared for ${plan.targetVersion}; skipped write.` });
+        completedSteps.push({ name: 'write-package-json', message: `${plan.metadata.packageJson.path} already prepared for ${plan.targetVersion}; skipped write.` });
+        printExecutionProgress(ports, `Metadata already prepared for ${plan.targetVersion}; skipping changelog and package.json writes.`);
+    }
+    else {
+        printExecutionProgress(ports, `Writing changelog update to ${plan.metadata.changelog.path}...`);
+        ports.writeFile(plan.metadata.changelog.path, plan.metadata.changelog.nextContent);
+        completedSteps.push({ name: 'write-changelog', message: `Wrote ${plan.metadata.changelog.path}.` });
+        printExecutionProgress(ports, `Done: wrote ${plan.metadata.changelog.path}.`);
+        printExecutionProgress(ports, `Writing package version ${plan.metadata.packageJson.targetVersion} to ${plan.metadata.packageJson.path}...`);
+        ports.writeFile(plan.metadata.packageJson.path, plan.metadata.packageJson.nextContent);
+        completedSteps.push({ name: 'write-package-json', message: `Wrote ${plan.metadata.packageJson.path}.` });
+        printExecutionProgress(ports, `Done: wrote ${plan.metadata.packageJson.path}.`);
+    }
+    printExecutionProgress(ports, 'Running release validation: pnpm run validate:release-publish...');
+    const validation = await ports.run('pnpm', ['run', 'validate:release-publish']);
+    if (validation.exitCode !== 0) {
+        const failure = failExecution(completedSteps, 'validate-release', 'Release validation failed.', validation);
+        printExecutionFailure(ports, failure);
+        return failure;
+    }
+    completedSteps.push({ name: 'validate-release', message: 'Release validation passed.' });
+    printExecutionProgress(ports, 'Done: release validation passed.');
+    const releaseCommitMessage = `chore(release): ${plan.targetVersion}`;
+    if (plan.metadataAlreadyPrepared) {
+        completedSteps.push({ name: 'create-release-commit', message: `Release commit already exists at HEAD for ${plan.targetVersion}; skipped commit.` });
+        printExecutionProgress(ports, `Release commit already exists at HEAD for ${plan.targetVersion}; skipping commit.`);
+    }
+    else {
+        printExecutionProgress(ports, 'Staging release metadata: git add CHANGELOG.md package.json...');
+        const gitAdd = await ports.run('git', ['add', 'CHANGELOG.md', 'package.json']);
+        if (gitAdd.exitCode !== 0) {
+            const failure = failExecution(completedSteps, 'create-release-commit', 'Staging release metadata failed.', gitAdd);
+            printExecutionFailure(ports, failure);
+            return failure;
+        }
+        printExecutionProgress(ports, `Creating release commit: ${releaseCommitMessage}...`);
+        const gitCommit = await ports.run('git', ['commit', '-m', releaseCommitMessage]);
+        if (gitCommit.exitCode !== 0) {
+            const failure = failExecution(completedSteps, 'create-release-commit', 'Creating the release commit failed.', gitCommit);
+            printExecutionFailure(ports, failure);
+            return failure;
+        }
+        completedSteps.push({ name: 'create-release-commit', message: `Created release commit: ${releaseCommitMessage}.` });
+        printExecutionProgress(ports, `Done: created release commit ${releaseCommitMessage}.`);
+    }
+    if (plan.existingTagAtHead) {
+        completedSteps.push({ name: 'create-release-tag', message: `Release tag ${plan.tagName} already points at HEAD; skipped tag creation.` });
+        printExecutionProgress(ports, `Release tag ${plan.tagName} already points at HEAD; skipping tag creation.`);
+    }
+    else {
+        printExecutionProgress(ports, `Creating release tag: ${plan.tagName}...`);
+        const gitTag = await ports.run('git', ['tag', plan.tagName]);
+        if (gitTag.exitCode !== 0) {
+            const failure = failExecution(completedSteps, 'create-release-tag', `Creating release tag ${plan.tagName} failed.`, gitTag);
+            printExecutionFailure(ports, failure);
+            return failure;
+        }
+        completedSteps.push({ name: 'create-release-tag', message: `Created release tag: ${plan.tagName}.` });
+        printExecutionProgress(ports, `Done: created release tag ${plan.tagName}.`);
+    }
+    const npmPublishArgs = buildNpmPublishArgs(plan);
+    const npmPublishLog = plan.hasOtp ? 'npm publish --access public --otp ******' : 'npm publish --access public';
+    printExecutionProgress(ports, `Publishing package to npm: ${npmPublishLog}...`);
+    const npmPublish = await ports.run('npm', npmPublishArgs);
+    if (npmPublish.exitCode !== 0) {
+        const failure = failExecution(completedSteps, 'publish-npm', 'Publishing to npm failed.', npmPublish);
+        printExecutionFailure(ports, failure);
+        return failure;
+    }
+    completedSteps.push({ name: 'publish-npm', message: 'Published package to npm.' });
+    printExecutionProgress(ports, 'Done: published package to npm.');
+    printExecutionProgress(ports, 'Pushing release commit: git push origin HEAD...');
+    const pushCommit = await ports.run('git', ['push', 'origin', 'HEAD']);
+    if (pushCommit.exitCode !== 0) {
+        const failure = failExecution(completedSteps, 'push-commit', 'Pushing the release commit failed.', pushCommit);
+        printExecutionFailure(ports, failure);
+        return failure;
+    }
+    completedSteps.push({ name: 'push-commit', message: 'Pushed release commit to origin.' });
+    printExecutionProgress(ports, 'Done: pushed release commit to origin.');
+    printExecutionProgress(ports, `Pushing release tag: git push origin ${plan.tagName}...`);
+    const pushTag = await ports.run('git', ['push', 'origin', plan.tagName]);
+    if (pushTag.exitCode !== 0) {
+        const failure = failExecution(completedSteps, 'push-tag', `Pushing release tag ${plan.tagName} failed.`, pushTag);
+        printExecutionFailure(ports, failure);
+        return failure;
+    }
+    completedSteps.push({ name: 'push-tag', message: `Pushed release tag ${plan.tagName} to origin.` });
+    printExecutionProgress(ports, `Done: pushed release tag ${plan.tagName} to origin.`);
+    const releaseBody = extractReleaseBody(plan);
+    printExecutionProgress(ports, `Creating GitHub Release: gh release create ${plan.tagName}...`);
+    const githubRelease = await ports.run('gh', ['release', 'create', plan.tagName, '--title', plan.tagName, '--notes', releaseBody]);
+    if (githubRelease.exitCode !== 0) {
+        const failure = failExecution(completedSteps, 'create-github-release', 'Creating the GitHub Release failed.', githubRelease);
+        printExecutionFailure(ports, failure);
+        return failure;
+    }
+    completedSteps.push({ name: 'create-github-release', message: `Created GitHub Release ${plan.tagName}.` });
+    printExecutionProgress(ports, `Done: created GitHub Release ${plan.tagName}.`);
+    return {
+        status: 'executed',
+        completedSteps,
+    };
+}
+function printWarnings(warnings, ports) {
+    if (warnings.length === 0) {
+        return;
+    }
+    ports.print('Warnings:\n');
+    for (const warning of warnings) {
+        ports.print(`- [${warning.code}] ${warning.message}\n`);
+    }
+}
+function printExecutionProgress(ports, message) {
+    ports.print?.(`${message}\n`);
+}
+function printExecutionFailure(ports, failure) {
+    ports.print?.(`Failed: ${failure.failedStep.message}\n`);
+    ports.print?.(`Recovery: ${failure.failedStep.recoveryGuidance}\n`);
+}
+function buildNpmPublishArgs(plan) {
+    const args = ['publish', '--access', 'public'];
+    if (plan.otp) {
+        args.push('--otp', plan.otp);
+    }
+    return args;
+}
+async function runStep(ports, completedSteps, stepName, startMessage, command, args, completedMessage) {
+    printExecutionProgress(ports, startMessage);
+    const result = await ports.run(command, args);
+    if (result.exitCode !== 0) {
+        const failure = failExecution(completedSteps, stepName, `${completedMessage.replace(/\.$/, '')} failed.`, result);
+        printExecutionFailure(ports, failure);
+        return failure;
+    }
+    completedSteps.push({ name: stepName, message: completedMessage });
+    printExecutionProgress(ports, `Done: ${completedMessage}`);
+    return { status: 'ok' };
+}
+function resolveTargetVersion(input) {
+    if (input.requestedVersion) {
+        const requestedVersion = parseSemverVersion(input.requestedVersion);
+        if (requestedVersion.status === 'invalid') {
+            return blockedTargetVersion('invalid-version', requestedVersion.message);
+        }
+        return { status: 'ok', version: requestedVersion.version.version };
+    }
+    const previousVersion = parseSemverVersion(input.fromRef);
+    if (previousVersion.status === 'invalid') {
+        return blockedTargetVersion('invalid-version', `Release baseline \`${input.fromRef}\` must be SemVer-like when --version is omitted.`);
+    }
+    return {
+        status: 'ok',
+        version: incrementSemverVersion(previousVersion.version, input.suggestedBump).version,
+    };
+}
+function blocked(code, message) {
+    return {
+        status: 'blocked',
+        message,
+        warnings: [{ code, message }],
+    };
+}
+function blockedTargetVersion(code, message) {
+    return {
+        status: 'blocked',
+        message,
+        warnings: [{ code, message }],
+    };
+}
+function readFileIfExists(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return undefined;
+    }
+    return fs.readFileSync(filePath, 'utf8');
+}
+function failExecution(completedSteps, name, message, commandResult) {
+    const stderr = commandResult?.stderr?.trim();
+    const commandContext = stderr ? ` ${stderr}` : '';
+    return {
+        status: 'failed',
+        completedSteps,
+        failedStep: {
+            name,
+            message: `${message}${commandContext}`,
+            recoveryGuidance: buildRecoveryGuidance(name),
+        },
+    };
+}
+function buildRecoveryGuidance(name) {
+    switch (name) {
+        case 'validate-release':
+            return 'Fix validation failures, restore or review local release metadata changes, then rerun the release workflow.';
+        case 'check-npm-auth':
+            return 'Run `npm login` with an account that can publish this package, then rerun the release workflow.';
+        case 'check-github-auth':
+            return 'Run `gh auth login` or fix GitHub CLI authentication, then rerun the release workflow.';
+        case 'build-release':
+            return 'Fix the build failure, then rerun the release workflow.';
+        case 'create-release-commit':
+            return 'Review local release metadata changes, resolve git commit issues, then rerun or complete the release manually.';
+        case 'create-release-tag':
+            return 'Review the release commit and tag state, then create the tag manually or rerun after cleanup.';
+        case 'publish-npm':
+            return 'Review npm authentication/package state. If the package was not published, rerun after fixing npm publish. The workflow publishes with `npm publish --access public`.';
+        case 'write-changelog':
+        case 'write-package-json':
+            return 'Review local file permissions and release metadata, then rerun the release workflow.';
+        case 'push-commit':
+            return 'npm publish may have completed. Push the release commit manually after resolving git remote issues.';
+        case 'push-tag':
+            return 'npm publish and the release commit push may have completed. Push the release tag manually after resolving git remote issues.';
+        case 'create-github-release':
+            return 'npm publish and git push may have completed. Create the GitHub Release manually with the finalized CHANGELOG.md section.';
+    }
+}
+function extractReleaseBody(plan) {
+    if (!plan.metadata) {
+        return `Release ${plan.targetVersion}`;
+    }
+    return extractReleaseChangelogSection(plan.metadata.changelog.nextContent, plan.targetVersion) ?? `Release ${plan.targetVersion}`;
+}

package/bin/modules/maintainer-release-support/release-workflow/package-json.js

@@ -0,0 +1,181 @@
+export function planPackageJsonVersionUpdate(existingContent, targetVersion) {
+    if (existingContent === undefined) {
+        return malformedPackageJson('Root package.json could not be read.');
+    }
+    const parsedPackageJson = parsePackageJson(existingContent);
+    if (parsedPackageJson.status === 'blocked') {
+        return parsedPackageJson;
+    }
+    const currentVersion = parsedPackageJson.value.version;
+    if (typeof currentVersion !== 'string') {
+        return malformedPackageJson('Root package.json must contain a string version field.');
+    }
+    const versionValueRange = findRootStringPropertyValueRange(existingContent, 'version');
+    if (!versionValueRange) {
+        return malformedPackageJson('Root package.json version field could not be located safely.');
+    }
+    return {
+        status: 'ok',
+        plan: {
+            path: 'package.json',
+            currentVersion,
+            targetVersion,
+            nextContent: replaceRange(existingContent, versionValueRange.start, versionValueRange.end, JSON.stringify(targetVersion)),
+        },
+    };
+}
+function parsePackageJson(content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (!isRecord(parsed)) {
+            return malformedPackageJson('Root package.json must contain a JSON object.');
+        }
+        return {
+            status: 'ok',
+            value: parsed,
+        };
+    }
+    catch {
+        return malformedPackageJson('Root package.json could not be parsed as JSON.');
+    }
+}
+function findRootStringPropertyValueRange(content, propertyName) {
+    let index = skipWhitespace(content, 0);
+    if (content[index] !== '{') {
+        return undefined;
+    }
+    index += 1;
+    while (index < content.length) {
+        index = skipWhitespaceAndComma(content, index);
+        if (content[index] === '}') {
+            return undefined;
+        }
+        if (content[index] !== '"') {
+            return undefined;
+        }
+        const keyEnd = findStringLiteralEnd(content, index);
+        if (keyEnd === undefined) {
+            return undefined;
+        }
+        const key = parseStringLiteral(content.slice(index, keyEnd));
+        index = skipWhitespace(content, keyEnd);
+        if (content[index] !== ':') {
+            return undefined;
+        }
+        index = skipWhitespace(content, index + 1);
+        const valueStart = index;
+        const valueEnd = findJsonValueEnd(content, valueStart);
+        if (valueEnd === undefined) {
+            return undefined;
+        }
+        if (key === propertyName) {
+            if (content[valueStart] !== '"') {
+                return undefined;
+            }
+            return {
+                start: valueStart,
+                end: valueEnd,
+            };
+        }
+        index = valueEnd;
+    }
+    return undefined;
+}
+function findJsonValueEnd(content, start) {
+    const firstCharacter = content[start];
+    if (firstCharacter === '"') {
+        return findStringLiteralEnd(content, start);
+    }
+    if (firstCharacter === '{' || firstCharacter === '[') {
+        return findContainerEnd(content, start);
+    }
+    const match = /^[^,\]}]+/.exec(content.slice(start));
+    return match ? start + match[0].trimEnd().length : undefined;
+}
+function findContainerEnd(content, start) {
+    const openingCharacter = content[start];
+    const closingCharacter = openingCharacter === '{' ? '}' : ']';
+    let depth = 0;
+    let index = start;
+    while (index < content.length) {
+        const character = content[index];
+        if (character === '"') {
+            const stringEnd = findStringLiteralEnd(content, index);
+            if (stringEnd === undefined) {
+                return undefined;
+            }
+            index = stringEnd;
+            continue;
+        }
+        if (character === openingCharacter) {
+            depth += 1;
+        }
+        if (character === closingCharacter) {
+            depth -= 1;
+            if (depth === 0) {
+                return index + 1;
+            }
+        }
+        index += 1;
+    }
+    return undefined;
+}
+function findStringLiteralEnd(content, start) {
+    let escaped = false;
+    for (let index = start + 1; index < content.length; index += 1) {
+        const character = content[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (character === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (character === '"') {
+            return index + 1;
+        }
+    }
+    return undefined;
+}
+function parseStringLiteral(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return typeof parsed === 'string' ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function skipWhitespace(content, start) {
+    let index = start;
+    while (/\s/.test(content[index] ?? '')) {
+        index += 1;
+    }
+    return index;
+}
+function skipWhitespaceAndComma(content, start) {
+    let index = skipWhitespace(content, start);
+    if (content[index] === ',') {
+        index = skipWhitespace(content, index + 1);
+    }
+    return index;
+}
+function replaceRange(content, start, end, replacement) {
+    return `${content.slice(0, start)}${replacement}${content.slice(end)}`;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function malformedPackageJson(message) {
+    return {
+        status: 'blocked',
+        message,
+        warnings: [
+            {
+                code: 'malformed-package-json',
+                message,
+            },
+        ],
+    };
+}

package/bin/modules/maintainer-release-support/release-workflow/release-plan.js

@@ -0,0 +1,87 @@
+export function incrementSemverVersion(version, bump) {
+    switch (bump) {
+        case 'major':
+            return buildParsedVersion(version.major + 1, 0, 0);
+        case 'minor':
+            return buildParsedVersion(version.major, version.minor + 1, 0);
+        case 'patch':
+            return buildParsedVersion(version.major, version.minor, version.patch + 1);
+    }
+}
+export function formatReleaseTagName(version) {
+    return `v${version}`;
+}
+export function buildReleaseMetadataPlan(metadata) {
+    return metadata;
+}
+export function deriveSuggestedBumpFromChangelogProposal(proposal) {
+    return proposal.semverGuidance.suggestedBump;
+}
+export function renderReleasePlanPreview(plan) {
+    const lines = [
+        'Release plan preview',
+        '',
+        `Git range: ${plan.range.fromRef}..${plan.range.toRef}`,
+        `Proposed version: ${plan.targetVersion}`,
+        `Suggested SemVer bump: ${plan.suggestedBump}`,
+        `Commits inspected: ${plan.commitCount}`,
+        '',
+        'Planned local metadata updates:',
+        ...renderMetadataPreview(plan),
+        '',
+        'Planned release actions after confirmation:',
+        '- Check npm authentication: npm whoami',
+        '- Check GitHub authentication: gh auth status',
+        '- Build release artifacts: pnpm build',
+        `- Run validation: pnpm run validate:release-publish`,
+        `- Create release commit: chore(release): ${plan.targetVersion}`,
+        `- Create git tag: ${plan.tagName}`,
+        `- Publish package: npm publish --access public${plan.hasOtp ? ' --otp ******' : ''}`,
+        `- Push release commit: git push origin HEAD`,
+        `- Push release tag: git push origin ${plan.tagName}`,
+        `- Create GitHub Release: gh release create ${plan.tagName}`,
+    ];
+    if (plan.warnings.length > 0) {
+        lines.push('', 'Warnings:', ...plan.warnings.map(formatReleaseWarning));
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function extractReleaseChangelogSection(changelogContent, targetVersion) {
+    const sectionStart = changelogContent.indexOf(`## ${targetVersion} - `);
+    if (sectionStart < 0) {
+        return undefined;
+    }
+    const nextSectionStart = changelogContent.indexOf('\n## ', sectionStart + 1);
+    const sectionEnd = nextSectionStart >= 0 ? nextSectionStart : changelogContent.length;
+    return changelogContent.slice(sectionStart, sectionEnd).trim();
+}
+function buildParsedVersion(major, minor, patch) {
+    return {
+        version: `${major}.${minor}.${patch}`,
+        major,
+        minor,
+        patch,
+    };
+}
+function renderMetadataPreview(plan) {
+    if (!plan.metadata) {
+        return ['- No local metadata updates planned.'];
+    }
+    const changelogAction = plan.metadata.changelog.replacingExistingSection ? 'Replace' : 'Create';
+    return [
+        `- ${changelogAction} CHANGELOG.md section: ${plan.metadata.changelog.targetVersion} - ${plan.metadata.changelog.targetDate}`,
+        ...renderChangelogSectionPreview(plan.metadata.changelog.nextContent, plan.metadata.changelog.targetVersion),
+        `- Update package.json version: ${plan.metadata.packageJson.currentVersion} -> ${plan.metadata.packageJson.targetVersion}`,
+    ];
+}
+function renderChangelogSectionPreview(changelogContent, targetVersion) {
+    const section = extractChangelogVersionSection(changelogContent, targetVersion);
+    const previewLines = section.split('\n').slice(0, 20);
+    return ['  Changelog preview:', ...previewLines.map((line) => `  ${line}`)];
+}
+function extractChangelogVersionSection(changelogContent, targetVersion) {
+    return extractReleaseChangelogSection(changelogContent, targetVersion) ?? '(target changelog section not found in planned content)';
+}
+function formatReleaseWarning(warning) {
+    return `- [${warning.code}] ${warning.message}`;
+}

package/bin/{features/init-project → modules/project-adoption}/handler.js

@@ -4,9 +4,9 @@ import { intro, log, outro } from '@clack/prompts';
 import chalk from 'chalk';
 import { STATE_RELATIVE_PATH } from '../../shared/catalog.js';
 import { getProjectContext } from '../../shared/paths.js';
-import { askForArchitectureSkill, askForFrameworkSkills, askForLanguageSkills, askForProjectOverview, askForSupportedAgents, askForWorkflowSkills, renderIntro } from '../../shared/prompts.js';
-import { readStateForDoctor } from '../../shared/state.js';
-import { getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../../shared/workflow-targets.js';
+import { askForArchitectureSkill, askForDatabaseSkills, askForFrameworkSkills, askForLanguageSkills, askForProjectOverview, askForSupportedAgents, askForWorkflowSkills, renderIntro } from '../interactive-guidance/index.js';
+import { readStateForDoctor } from '../workflow-state-registry/index.js';
+import { getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../workflow-target-planning/index.js';
 export async function handleInitProject(_command) {
     await renderIntro();
     intro(chalk.cyan('Setting up Sibu'));
@@ -30,9 +30,10 @@ export async function handleInitProject(_command) {
     const selectedAgents = await askForSupportedAgents();
     const selectedLanguageSkills = await askForLanguageSkills();
     const selectedFrameworkSkills = await askForFrameworkSkills();
+    const selectedDatabaseSkills = await askForDatabaseSkills();
     const selectedArchitectureSkill = await askForArchitectureSkill();
     const selectedWorkflowSkills = await askForWorkflowSkills();
-    const targets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills);
+    const targets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
     const missingTargets = targets.filter((target) => !fs.existsSync(target.targetPath));
     log.message('I will create this project’s initial AI workflow files.');
     for (const target of targets) {
@@ -53,13 +54,14 @@ export async function handleInitProject(_command) {
         selectedFrameworkSkills,
         selectedArchitectureSkill,
         selectedWorkflowSkills,
+        selectedDatabaseSkills,
     });
     for (const file of files) {
         fs.mkdirSync(path.dirname(file.targetPath), { recursive: true });
         fs.writeFileSync(file.targetPath, file.contents, { encoding: 'utf8', flag: 'wx' });
         log.success(`Created ${file.label}`);
     }
-    writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, targets });
+    writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, targets });
     log.success(`Created ${STATE_RELATIVE_PATH}`);
     outro(chalk.green('Setup complete.'));
 }

package/bin/modules/project-adoption/index.js

@@ -0,0 +1 @@
+export { handleInitProject } from './handler.js';