@juancr11/sibu 0.5.3 → 0.7.0

package/bin/admin/changelog.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import { createInterface } from 'node:readline/promises';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { handleGenerateChangelogWrite } from '../modules/maintainer-release-support/generate-changelog/handler.js';
+const USAGE = `Usage: pnpm admin:changelog -- [--from <ref>] [--to <ref>] [--version <version>] [--date <yyyy-mm-dd>] [--yes]
+
+Options:
+  --from <ref>          Git ref to start from. Defaults to the latest reachable tag.
+  --to <ref>            Git ref to end at. Defaults to HEAD.
+  --version <version>   Release version. Accepts MAJOR.MINOR.PATCH with optional leading v.
+  --date <yyyy-mm-dd>   Release date for a versioned changelog section.
+  --yes                 Print the preview and write without prompting.
+  --help                Show this help message.
+`;
+export function parseChangelogArgs(args) {
+    const command = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        switch (arg) {
+            case '--':
+                break;
+            case '--help':
+            case '-h':
+                return { status: 'help', usage: USAGE };
+            case '--yes':
+                command.assumeYes = true;
+                break;
+            case '--from': {
+                const value = readFlagValue(args, index, arg);
+                if (value.status === 'error') {
+                    return value.result;
+                }
+                command.fromRef = value.value;
+                index += 1;
+                break;
+            }
+            case '--to': {
+                const value = readFlagValue(args, index, arg);
+                if (value.status === 'error') {
+                    return value.result;
+                }
+                command.toRef = value.value;
+                index += 1;
+                break;
+            }
+            case '--version': {
+                const value = readFlagValue(args, index, arg);
+                if (value.status === 'error') {
+                    return value.result;
+                }
+                command.version = value.value;
+                index += 1;
+                break;
+            }
+            case '--date': {
+                const value = readFlagValue(args, index, arg);
+                if (value.status === 'error') {
+                    return value.result;
+                }
+                command.date = value.value;
+                index += 1;
+                break;
+            }
+            default:
+                if (arg?.startsWith('--')) {
+                    return error(`Unknown option \`${arg}\`.`);
+                }
+                return error(`Unexpected argument \`${arg ?? ''}\`.`);
+        }
+    }
+    return { status: 'ok', command };
+}
+export async function runChangelogCli(args = process.argv.slice(2), cwd = process.cwd()) {
+    const parsedArgs = parseChangelogArgs(args);
+    if (parsedArgs.status === 'help') {
+        process.stdout.write(parsedArgs.usage);
+        return 0;
+    }
+    if (parsedArgs.status === 'error') {
+        process.stderr.write(`${parsedArgs.message}\n\n${parsedArgs.usage}`);
+        return 1;
+    }
+    const result = await handleGenerateChangelogWrite(parsedArgs.command, createTerminalPorts(), cwd);
+    switch (result.status) {
+        case 'written':
+            process.stdout.write(`\nWrote ${result.changelogPath}\n`);
+            return 0;
+        case 'declined':
+            process.stdout.write('\nNo changes written.\n');
+            return 0;
+        case 'blocked':
+            process.stderr.write(`\nChangelog generation blocked: ${result.message}\n`);
+            return 1;
+    }
+}
+function readFlagValue(args, index, flag) {
+    const value = args[index + 1];
+    if (!value || value.startsWith('--')) {
+        return {
+            status: 'error',
+            result: error(`Option \`${flag}\` requires a value.`),
+        };
+    }
+    return { status: 'ok', value };
+}
+function error(message) {
+    return {
+        status: 'error',
+        message,
+        usage: USAGE,
+    };
+}
+function createTerminalPorts() {
+    return {
+        readFile(path) {
+            if (!fs.existsSync(path)) {
+                return undefined;
+            }
+            return fs.readFileSync(path, 'utf8');
+        },
+        writeFile(path, content) {
+            fs.writeFileSync(path, content, 'utf8');
+        },
+        async confirmWrite() {
+            const readline = createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            try {
+                const answer = await readline.question('\nWrite CHANGELOG.md with these changes? [y/N] ');
+                return /^(y|yes)$/i.test(answer.trim());
+            }
+            finally {
+                readline.close();
+            }
+        },
+        showPreview(preview) {
+            process.stdout.write(preview);
+        },
+    };
+}
+async function main() {
+    try {
+        process.exitCode = await runChangelogCli();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`\nChangelog generation failed: ${message}\n`);
+        process.exitCode = 1;
+    }
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    await main();
+}

package/bin/admin/release.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+import { createInterface } from 'node:readline/promises';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { previewAndConfirmMaintainerRelease } from '../modules/maintainer-release-support/release-workflow/handler.js';
+const USAGE = `Usage: pnpm admin:release -- [--from <ref>] [--to <ref>] [--version <version>] [--date <yyyy-mm-dd>] [--otp <code>] [--yes] [--dry-run]
+
+Options:
+  --from <ref>          Git ref to start from. Defaults to the latest reachable SemVer-like tag.
+  --to <ref>            Git ref to end at. Defaults to HEAD.
+  --version <version>   Release version override. Accepts MAJOR.MINOR.PATCH with optional leading v.
+  --date <yyyy-mm-dd>   Release date for the versioned changelog section.
+  --otp <code>          npm one-time password for accounts that require 2FA for publishing.
+  --yes                 Print the preview and continue without prompting.
+  --dry-run             Print the release plan and perform no writes or side effects.
+  --help                Show this help message.
+`;
+export function parseReleaseArgs(args) {
+    const command = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        switch (arg) {
+            case '--':
+                break;
+            case '--help':
+            case '-h':
+                return { status: 'help', usage: USAGE };
+            case '--yes':
+                command.assumeYes = true;
+                break;
+            case '--dry-run':
+                command.dryRun = true;
+                break;
+            case '--from': {
+                const value = readFlagValue(args, index, arg);
+                if (value.status === 'error') {
+                    return value.result;
+                }
+                command.fromRef = value.value;
+                index += 1;
+                break;
+            }
+            case '--to': {
+                const value = readFlagValue(args, index, arg);
+                if (value.status === 'error') {
+                    return value.result;
+                }
+                command.toRef = value.value;
+                index += 1;
+                break;
+            }
+            case '--version': {
+                const value = readFlagValue(args, index, arg);
+                if (value.status === 'error') {
+                    return value.result;
+                }
+                command.version = value.value;
+                index += 1;
+                break;
+            }
+            case '--date': {
+                const value = readFlagValue(args, index, arg);
+                if (value.status === 'error') {
+                    return value.result;
+                }
+                command.date = value.value;
+                index += 1;
+                break;
+            }
+            case '--otp': {
+                const value = readFlagValue(args, index, arg);
+                if (value.status === 'error') {
+                    return value.result;
+                }
+                command.otp = value.value;
+                index += 1;
+                break;
+            }
+            default:
+                if (arg?.startsWith('--')) {
+                    return error(`Unknown option \`${arg}\`.`);
+                }
+                return error(`Unexpected argument \`${arg ?? ''}\`.`);
+        }
+    }
+    return { status: 'ok', command };
+}
+export async function runReleaseCli(args = process.argv.slice(2), ports = createTerminalPorts(), cwd = process.cwd()) {
+    const parsedArgs = parseReleaseArgs(args);
+    if (parsedArgs.status === 'help') {
+        ports.print(parsedArgs.usage);
+        return 0;
+    }
+    if (parsedArgs.status === 'error') {
+        process.stderr.write(`${parsedArgs.message}\n\n${parsedArgs.usage}`);
+        return 1;
+    }
+    const result = await previewAndConfirmMaintainerRelease(parsedArgs.command, ports, cwd);
+    switch (result.status) {
+        case 'confirmed':
+            printExecutionResult(result.execution, ports);
+            return result.execution.status === 'executed' ? 0 : 1;
+        case 'dry-run':
+            ports.print('\nDry run complete. No changes written.\n');
+            return 0;
+        case 'declined':
+            ports.print('\nRelease declined. No changes written.\n');
+            return 0;
+        case 'blocked':
+            process.stderr.write(`\nRelease planning blocked: ${result.message}\n`);
+            return 1;
+    }
+}
+function readFlagValue(args, index, flag) {
+    const value = args[index + 1];
+    if (!value || value.startsWith('--')) {
+        return {
+            status: 'error',
+            result: error(`Option \`${flag}\` requires a value.`),
+        };
+    }
+    return { status: 'ok', value };
+}
+function error(message) {
+    return {
+        status: 'error',
+        message,
+        usage: USAGE,
+    };
+}
+function createTerminalPorts() {
+    return {
+        print(message) {
+            process.stdout.write(message);
+        },
+        async confirmRelease(plan) {
+            const readline = createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            try {
+                const answer = await readline.question(`\nRelease ${plan.targetVersion}? [y/N] `);
+                return /^(y|yes)$/i.test(answer.trim());
+            }
+            finally {
+                readline.close();
+            }
+        },
+        writeFile(path, contents) {
+            fs.writeFileSync(path, contents, 'utf8');
+        },
+        run(command, args) {
+            try {
+                const stdout = execFileSync(command, args, {
+                    encoding: 'utf8',
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                return {
+                    exitCode: 0,
+                    stdout,
+                    stderr: '',
+                };
+            }
+            catch (error) {
+                return commandFailure(error);
+            }
+        },
+    };
+}
+function printExecutionResult(result, ports) {
+    ports.print('\nRelease execution results:\n');
+    for (const completedStep of result.completedSteps) {
+        ports.print(`- ${completedStep.message}\n`);
+    }
+    if (result.status === 'failed') {
+        ports.print(`\nRelease failed at ${result.failedStep.name}: ${result.failedStep.message}\n`);
+        ports.print(`Recovery: ${result.failedStep.recoveryGuidance}\n`);
+        return;
+    }
+    ports.print('\nRelease completed successfully.\n');
+}
+function commandFailure(error) {
+    if (isExecFileError(error)) {
+        return {
+            exitCode: typeof error.status === 'number' ? error.status : 1,
+            stdout: bufferToString(error.stdout),
+            stderr: bufferToString(error.stderr),
+        };
+    }
+    return {
+        exitCode: 1,
+        stderr: error instanceof Error ? error.message : String(error),
+    };
+}
+function isExecFileError(error) {
+    return typeof error === 'object' && error !== null;
+}
+function bufferToString(value) {
+    if (Buffer.isBuffer(value)) {
+        return value.toString('utf8');
+    }
+    return value ?? '';
+}
+async function main() {
+    try {
+        process.exitCode = await runReleaseCli();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`\nRelease workflow failed: ${message}\n`);
+        process.exitCode = 1;
+    }
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    await main();
+}

package/bin/entrypoints/cli/create-program.js

@@ -1,5 +1,5 @@
 import { Command as CommanderCommand } from 'commander';
-import { SIBU_VERSION } from '../../shared/catalog.js';
+import { SIBU_VERSION } from '../../modules/version-advisory/index.js';
 import { executeCliCommand } from './execute-command.js';
 export function createProgram() {
     const cli = new CommanderCommand();

package/bin/entrypoints/cli/execute-command.js

@@ -1,9 +1,9 @@
-import { handleDoctorProject } from '../../features/doctor-project/handler.js';
-import { handleInitProject } from '../../features/init-project/handler.js';
-import { handleListSkills } from '../../features/list-skills/handler.js';
-import { handleStopManagingFile } from '../../features/stop-managing-file/handler.js';
-import { handleSyncProject } from '../../features/sync-project/handler.js';
-import { handleUseSkill } from '../../features/use-skill/handler.js';
+import { handleDoctorProject } from '../../modules/workflow-health-diagnosis/index.js';
+import { handleInitProject } from '../../modules/project-adoption/index.js';
+import { handleListSkills } from '../../modules/skill-selection-management/index.js';
+import { handleStopManagingFile } from '../../modules/skill-selection-management/index.js';
+import { handleSyncProject } from '../../modules/sync-review/index.js';
+import { handleUseSkill } from '../../modules/skill-selection-management/index.js';
 export async function executeCliCommand(command) {
     switch (command.type) {
         case 'init':

package/bin/modules/interactive-guidance/index.js

@@ -0,0 +1 @@
+export { askForArchitectureSkill, askForFrameworkSkills, askForLanguageSkills, askForMissingFrameworkSkills, askForNewArchitectureSkill, askForNewLanguageSkills, askForProjectOverview, askForSupportedAgents, askForWorkflowSkills, renderIntro, shouldAskForNewLanguageSkills, } from './prompts.js';

package/bin/{shared → modules/interactive-guidance}/prompts.js

@@ -3,7 +3,7 @@ import { cancel, isCancel, multiselect, select, text } from '@clack/prompts';
 import gradient from 'gradient-string';
 import { Box, Text, render, useApp } from 'ink';
 import { useEffect } from 'react';
-import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS } from './catalog.js';
+import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS } from '../workflow-target-planning/index.js';
 const NONE_OPTION_ID = 'none';
 export async function renderIntro() {
     console.log(gradient(['#39ff14', '#00e5ff', '#9b5de5']).multiline('⧖  S I B U  ⧖'));

package/bin/modules/maintainer-release-support/generate-changelog/changelog-format.js

@@ -0,0 +1,213 @@
+export const CHANGELOG_CATEGORIES = ['Added', 'Changed', 'Deprecated', 'Removed', 'Fixed', 'Security'];
+export function createEmptyEntriesByCategory() {
+    return {
+        Added: [],
+        Changed: [],
+        Deprecated: [],
+        Removed: [],
+        Fixed: [],
+        Security: [],
+    };
+}
+export function buildChangelogProposal(input) {
+    const entriesByCategory = createEmptyEntriesByCategory();
+    const warnings = [...(input.warnings ?? [])];
+    for (const commit of input.commits) {
+        const result = classifyCommit(commit);
+        entriesByCategory[result.entry.category].push(result.entry);
+        warnings.push(...result.warnings);
+    }
+    return {
+        sourceRange: input.sourceRange,
+        targetSection: input.targetSection ?? { type: 'unreleased' },
+        semverGuidance: {
+            suggestedBump: suggestSemverBump(entriesByCategory),
+        },
+        commitCount: input.commits.length,
+        entriesByCategory,
+        warnings,
+    };
+}
+export function retargetChangelogProposal(proposal, targetSection) {
+    return {
+        ...proposal,
+        targetSection,
+    };
+}
+export function suggestSemverBump(entriesByCategory) {
+    const entries = Object.values(entriesByCategory).flat();
+    if (entries.some((entry) => entry.breakingChange)) {
+        return 'major';
+    }
+    if (entriesByCategory.Added.some((entry) => entry.source === 'conventional-commit')) {
+        return 'minor';
+    }
+    return 'patch';
+}
+export function renderChangelogSection(proposal) {
+    const lines = [renderTargetSectionHeading(proposal.targetSection), ...renderEntriesByCategory(proposal.entriesByCategory)];
+    return `${lines.join('\n')}\n`;
+}
+export function renderChangelogPreview(proposal, targetPath) {
+    const lines = [
+        'Changelog preview',
+        '',
+        `Git range: ${formatSourceRange(proposal.sourceRange)}`,
+        `Commits inspected: ${proposal.commitCount}`,
+        `Target path: ${targetPath}`,
+        `Target section: ${formatTargetSection(proposal.targetSection)}`,
+        `Suggested SemVer bump: ${proposal.semverGuidance.suggestedBump}`,
+        '',
+        'Entries:',
+        ...renderPreviewEntries(proposal.entriesByCategory),
+    ];
+    if (proposal.warnings.length > 0) {
+        lines.push('', 'Warnings:', ...proposal.warnings.map(formatWarning));
+    }
+    return `${lines.join('\n')}\n`;
+}
+function renderTargetSectionHeading(targetSection) {
+    if (targetSection.type === 'unreleased') {
+        return '## Unreleased';
+    }
+    return `## ${targetSection.version} - ${targetSection.date}`;
+}
+function renderEntriesByCategory(entriesByCategory) {
+    return CHANGELOG_CATEGORIES.flatMap((category) => {
+        const entries = entriesByCategory[category];
+        if (entries.length === 0) {
+            return [];
+        }
+        return ['', `### ${category}`, ...entries.map((entry) => `- ${entry.text}`)];
+    });
+}
+function renderPreviewEntries(entriesByCategory) {
+    const lines = renderEntriesByCategory(entriesByCategory);
+    if (lines.length === 0) {
+        return ['- No generated entries.'];
+    }
+    return lines;
+}
+function formatSourceRange(sourceRange) {
+    if (sourceRange.fromRef) {
+        return `${sourceRange.fromRef}..${sourceRange.toRef}`;
+    }
+    return sourceRange.toRef;
+}
+function formatTargetSection(targetSection) {
+    if (targetSection.type === 'unreleased') {
+        return 'Unreleased';
+    }
+    return `${targetSection.version} - ${targetSection.date}`;
+}
+function formatWarning(warning) {
+    const commitSuffix = warning.commitHash ? ` (${warning.commitHash})` : '';
+    return `- [${warning.code}] ${warning.message}${commitSuffix}`;
+}
+export function classifyCommit(commit) {
+    const conventionalCommit = parseConventionalCommit(commit.subject);
+    if (!conventionalCommit) {
+        const entry = buildEntry({
+            category: classifyFromText(commit.subject),
+            text: commit.subject.trim(),
+            commit,
+            source: 'commit-message',
+            breakingChange: hasBreakingChangeMarker(commit),
+            reviewNeeded: true,
+        });
+        return {
+            entry,
+            warnings: buildReviewWarnings(entry, 'Commit message is not a Conventional Commit. Review the generated changelog entry.'),
+        };
+    }
+    const breakingChange = conventionalCommit.breakingChange || hasBreakingChangeMarker(commit);
+    const entry = buildEntry({
+        category: classifyConventionalCommit(conventionalCommit.type, conventionalCommit.description),
+        text: conventionalCommit.description,
+        commit,
+        source: 'conventional-commit',
+        breakingChange,
+        reviewNeeded: breakingChange,
+    });
+    return {
+        entry,
+        warnings: breakingChange ? buildReviewWarnings(entry, 'Breaking change detected. Review the generated changelog entry.') : [],
+    };
+}
+function parseConventionalCommit(subject) {
+    const match = /^(?<type>[a-z]+)(?:\([^)]+\))?(?<breaking>!)?:\s+(?<description>.+)$/.exec(subject.trim());
+    if (!match?.groups) {
+        return undefined;
+    }
+    return {
+        type: match.groups.type,
+        description: match.groups.description.trim(),
+        breakingChange: match.groups.breaking === '!',
+    };
+}
+function classifyConventionalCommit(type, description) {
+    const textCategory = classifyFromText(`${type} ${description}`);
+    if (textCategory !== 'Changed') {
+        return textCategory;
+    }
+    switch (type) {
+        case 'feat':
+            return 'Added';
+        case 'fix':
+            return 'Fixed';
+        case 'perf':
+        case 'refactor':
+        case 'style':
+        case 'docs':
+        case 'test':
+        case 'build':
+        case 'ci':
+        case 'chore':
+            return 'Changed';
+        default:
+            return 'Changed';
+    }
+}
+function classifyFromText(text) {
+    const normalizedText = text.toLowerCase();
+    if (/\b(security|secure|vulnerability|cve|exploit)\b/.test(normalizedText)) {
+        return 'Security';
+    }
+    if (/\b(deprecat(?:e|ed|es|ing|ion))\b/.test(normalizedText)) {
+        return 'Deprecated';
+    }
+    if (/\b(remove|removed|removes|removing|delete|deleted|deletes|deleting)\b/.test(normalizedText)) {
+        return 'Removed';
+    }
+    return 'Changed';
+}
+function hasBreakingChangeMarker(commit) {
+    return /^BREAKING[ -]CHANGE:/im.test(commit.body);
+}
+function buildEntry(input) {
+    return {
+        category: input.category,
+        text: input.text,
+        commitHash: input.commit.hash,
+        reviewNeeded: input.reviewNeeded,
+        breakingChange: input.breakingChange,
+        source: input.source,
+    };
+}
+function buildReviewWarnings(entry, message) {
+    const warnings = [
+        {
+            code: 'review-needed',
+            message,
+            commitHash: entry.commitHash,
+        },
+    ];
+    if (entry.breakingChange) {
+        warnings.push({
+            code: 'breaking-change',
+            message: 'Breaking change detected. Confirm release notes and SemVer impact before publishing.',
+            commitHash: entry.commitHash,
+        });
+    }
+    return warnings;
+}