@juancr11/sibu 0.1.0

package/README.md

@@ -0,0 +1,198 @@
+# ai-augmented-workflow
+
+A local workspace for developing and refining an AI-augmented software development workflow.
+
+## Install Sibu
+
+The official way to install and update Sibu is with npm:
+
+```sh
+npm install -g @juancr11/sibu
+```
+
+After installing, the normal user flow is:
+
+1. run `sibu init` in your project
+2. run `sibu doctor` to check workflow health
+3. if `sibu doctor` says a newer npm version exists, run `npm install -g @juancr11/sibu`
+4. rerun `sibu doctor`
+5. if drift is reported, decide whether to run `sibu sync`
+
+Updating Sibu alone does not change project files. It only changes what `sibu doctor` can detect against the newer installed templates.
+
+## CLI
+
+Sibu helps projects adopt and maintain AI workflow support files safely.
+
+From a project directory, run:
+
+```sh
+sibu init
+```
+
+`sibu init` is idempotent: it opens a polished interactive flow, lets you select supported agents with the keyboard, creates missing workflow files for that selection, keeps existing files unchanged, and reports when no changes are needed. When `AGENTS.md` is missing, the CLI asks for a project overview and writes the file based on the template in this repository. It can also create Codex, Gemini, and Claude support files when selected. Sibu records the generated workflow state in `.sibu/state.json` so `sibu doctor` can detect drift safely.
+
+Use `sibu doctor` to run a read-only health check. It reports missing managed files, local modifications, malformed state metadata, and template version drift without changing files.
+
+If `sibu doctor` tells you that a newer npm version exists, update with `npm install -g @juancr11/sibu`, rerun `sibu doctor`, and only then decide whether to run `sibu sync`. Updating Sibu alone changes what doctor can detect; it does not change project files.
+
+Use `sibu sync` to review template updates interactively. It explains human-readable template changes, protects local edits from automatic overwrites, and lets you apply safe updates, mark customized files as reviewed, write side templates, stop managing a file, or skip for later. Sibu records each file as `managed`, `customized`, or `unmanaged` in `.sibu/state.json`.
+
+Use `sibu skills list` to list available workflow skills and see which selectable skills are currently enabled for the project.
+
+Use `sibu skills stop <file>` to stop managing an Sibu-tracked workflow file. The file is marked as `unmanaged` in `.sibu/state.json`, removed from the selected skill state when applicable, and the CLI asks whether to keep or delete the local file.
+
+## Release notes and changelog
+
+For every Sibu release, update both release-note locations:
+
+- `CHANGELOG.md` is the canonical source in the repo
+- the matching GitHub Release is the public release surface
+
+When preparing a release, write or update the `CHANGELOG.md` entry first, then publish the matching GitHub Release using that same summary.
+
+This keeps one source of truth in the repo while still giving users a public release page they can browse from GitHub.
+
+## Maintainer release workflow
+
+If you are preparing a new Sibu npm release, use [`docs/releasing.md`](docs/releasing.md). That guide covers version bumping, `CHANGELOG.md`, tarball-based validation, npm publish, GitHub Release creation, and post-publish verification.
+
+## Contributor development
+
+The rest of this README section is for contributors working on Sibu itself, not for end users installing the CLI.
+
+The CLI entrypoint lives in `src/entrypoints/cli/`, command handlers live in `src/features/`, shared workflow utilities live in `src/shared/`, and everything compiles to `bin/sibu.js`. The `bin/` directory is generated by `pnpm build` and should not be edited directly.
+
+```sh
+pnpm install
+pnpm verify
+```
+
+## Contributor local testing
+
+Use `pnpm link --global` to make the local `sibu` command available from any directory while developing.
+
+This linked workflow is useful for day-to-day contributor development, but it is **not** a supported end-user install path and it is **not** the release-readiness check for npm publishing. For release readiness, prefer tarball-based validation with `npm pack` so you verify the exact package contents users will install.
+
+From this repository:
+
+```sh
+pnpm dev:link
+```
+
+Then test it in a new project directory:
+
+```sh
+mkdir /tmp/test-sibu-project
+cd /tmp/test-sibu-project
+git init
+sibu init
+sibu doctor
+sibu sync
+sibu skills list
+find . -maxdepth 2 -type f | sort
+```
+
+After editing CLI source files under `src/`, rebuild before testing again:
+
+```sh
+cd /home/juanca/code/ai-augmented-workflow
+pnpm build
+```
+
+When you are done testing the linked CLI, remove the global link:
+
+```sh
+pnpm dev:unlink
+```
+
+## Validate the npm package
+
+Before treating a build as ready to publish, validate the packaged artifact instead of relying only on `pnpm link`.
+
+### 1. Inspect the tarball contents
+
+```sh
+pnpm verify
+mkdir -p /tmp/sibu-pack
+npm pack --json --pack-destination /tmp/sibu-pack
+tar -tzf /tmp/sibu-pack/juancr11-sibu-*.tgz | sort
+```
+
+Use the tarball listing to confirm the packed artifact includes the expected runtime files:
+
+- `bin/sibu.js`
+- runtime code under `bin/entrypoints/`, `bin/features/`, and `bin/shared/`
+- `templates/`
+- `README.md`
+
+This check proves the package contents are correct, but it does **not** prove the installed CLI runs correctly after npm global install.
+
+### 2. Smoke test the installed tarball runtime
+
+```sh
+pnpm run validate:packed-runtime
+```
+
+This command:
+
+- runs `npm pack` in an isolated temporary workspace
+- installs the produced tarball into an isolated npm prefix
+- verifies `sibu --help` runs from the installed binary
+- creates a temporary fixture project outside this repo
+- runs `sibu doctor` in that fixture project to prove the installed CLI can read bundled runtime assets such as templates
+
+If this command fails, treat it as an installed-package runtime problem rather than a normal local-development issue.
+
+Treat tarball inspection plus `pnpm run validate:packed-runtime` as the release-readiness path for npm packaging changes. Use `pnpm dev:link` only for interactive local development.
+
+## Validate the doctor npm update advisory
+
+Use the deterministic override hooks to verify both advisory scenarios without depending on a real npm publish cycle:
+
+```sh
+pnpm run validate:doctor-version-advisory
+```
+
+This validation proves both of these cases locally:
+
+- a newer npm version is available and `sibu doctor` suggests `npm install -g @juancr11/sibu`
+- npm lookup is unavailable and `sibu doctor` still completes the local health check without failing
+
+For one-off manual checks, you can also run:
+
+```sh
+SIBU_NPM_LATEST_VERSION=9.9.9 node ./bin/sibu.js doctor
+SIBU_NPM_LOOKUP_MODE=offline node ./bin/sibu.js doctor
+```
+
+## Validate post-update drift after upgrading Sibu
+
+Use the local two-tarball validation flow to prove that upgrading Sibu can surface new drift without changing project files automatically:
+
+```sh
+pnpm run validate:post-update-doctor-drift
+```
+
+This validation proves the full explicit flow locally:
+
+- install an older local tarball
+- run `sibu doctor` and see the npm update advisory
+- update to a newer local tarball
+- rerun `sibu doctor` and see drift reported
+- confirm no files change until `sibu sync` is explicitly run
+
+## Changing templates
+
+Templates are versioned product artifacts. When changing any file under `templates/`, use the local template-change skill if available and update `templates/manifest.json` in the same change.
+
+Template change checklist:
+
+- Bump the global `templateVersion` when any template changes.
+- Bump each changed template's own `version`.
+- Add user-facing change notes that explain what changed and why it matters.
+- Avoid renaming template paths unless migration or backwards compatibility is handled.
+- Run `pnpm verify`.
+- Test `sibu init`, `sibu doctor`, and `sibu sync` in a temporary project when practical.
+
+The `changes` entries in `templates/manifest.json` are shown by `sibu sync`, so write them for users rather than as code-level diff notes. If using an AI coding agent, explicitly ask it to use the local template-change skill before editing templates.

package/bin/entrypoints/cli/command.js

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

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

@@ -0,0 +1,33 @@
+import { Command as CommanderCommand } from 'commander';
+import { SIBU_VERSION } from '../../shared/catalog.js';
+import { executeCliCommand } from './execute-command.js';
+export function createProgram() {
+    const cli = new CommanderCommand();
+    cli.name('sibu').description('Set up a local AI-augmented development workflow.').version(SIBU_VERSION);
+    cli
+        .command('init')
+        .description('Initialize Sibu workflow files once for a project')
+        .action(() => executeCliCommand({ type: 'init' }));
+    cli
+        .command('doctor')
+        .description('Read-only health check for Sibu-managed workflow files')
+        .action(() => executeCliCommand({ type: 'doctor' }));
+    cli
+        .command('sync')
+        .description('Interactively review and apply Sibu template updates')
+        .action(() => executeCliCommand({ type: 'sync' }));
+    const skills = cli.command('skills').description('Manage Sibu workflow skills');
+    skills
+        .command('list')
+        .description('List available Sibu skills')
+        .action(() => executeCliCommand({ type: 'skills:list' }));
+    skills
+        .command('use <skill_name>')
+        .description('Add one available selectable skill to a clean Sibu workflow')
+        .action((skillName) => executeCliCommand({ type: 'skills:use', skillName }));
+    skills
+        .command('stop <skill_name>')
+        .description('Stop managing one selected Sibu skill')
+        .action((skillName) => executeCliCommand({ type: 'skills:stop', skillName }));
+    return cli;
+}

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

@@ -0,0 +1,28 @@
+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';
+export async function executeCliCommand(command) {
+    switch (command.type) {
+        case 'init':
+            await handleInitProject(command);
+            return;
+        case 'doctor':
+            await handleDoctorProject(command);
+            return;
+        case 'sync':
+            await handleSyncProject(command);
+            return;
+        case 'skills:list':
+            await handleListSkills(command);
+            return;
+        case 'skills:stop':
+            await handleStopManagingFile(command);
+            return;
+        case 'skills:use':
+            await handleUseSkill(command);
+            return;
+    }
+}

package/bin/entrypoints/cli/main.js

@@ -0,0 +1,5 @@
+import { createProgram } from './create-program.js';
+export async function runCli(argv = process.argv) {
+    const program = createProgram();
+    await program.parseAsync(argv);
+}

package/bin/features/doctor-project/command.js

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

package/bin/features/doctor-project/handler.js

@@ -0,0 +1,194 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { intro, log, outro } from '@clack/prompts';
+import chalk from 'chalk';
+import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, STATE_RELATIVE_PATH, SUPPORTED_AGENTS } from '../../shared/catalog.js';
+import { sha256 } from '../../shared/hash.js';
+import { checkForLatestSibuVersion } from '../../shared/npm-version.js';
+import { getProjectContext } from '../../shared/paths.js';
+import { renderIntro } from '../../shared/prompts.js';
+import { hasReviewedTemplateVersion, readStateForDoctor } from '../../shared/state.js';
+import { getTemplateVersion, readTemplateManifest } from '../../shared/templates.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getWorkflowTargets, } from '../../shared/workflow-targets.js';
+export async function handleDoctorProject(_command) {
+    await renderIntro();
+    intro(chalk.cyan('Checking workflow state'));
+    const { rootPath, statePath } = getProjectContext();
+    const stateResult = readStateForDoctor(statePath);
+    if (!stateResult.ok) {
+        log.error(stateResult.message);
+        log.info('Run `sibu init` once to create Sibu workflow metadata.');
+        outro(chalk.yellow('Setup needs attention.'));
+        process.exitCode = 1;
+        return;
+    }
+    const state = stateResult.state;
+    const issues = diagnoseState({ rootPath, state });
+    const npmVersionResult = await checkForLatestSibuVersion();
+    if (issues.length === 0) {
+        log.success('Workflow is healthy. No drift detected.');
+        log.info(`Sibu version: ${state.sibuVersion}`);
+        log.info(`Template version: ${state.templateVersion}`);
+        log.info(`Managed workflow files: ${Object.keys(state.managedFiles).length}`);
+        log.info(`File statuses: ${formatManagedFileStatusCounts(state)}`);
+        logNpmVersionAdvisory(npmVersionResult);
+        outro(chalk.green('Check complete.'));
+        return;
+    }
+    log.warn('Found workflow changes that need review.');
+    for (const issue of issues) {
+        if (issue.severity === 'error') {
+            log.error(issue.message);
+        }
+        else {
+            log.warn(issue.message);
+        }
+        if (issue.hint) {
+            log.info(issue.hint);
+        }
+    }
+    logNpmVersionAdvisory(npmVersionResult);
+    logSyncNextStep();
+    outro(chalk.yellow('Review needed.'));
+    process.exitCode = 1;
+}
+export function getNpmVersionAdvisoryLines(result) {
+    if (result.status !== 'update-available') {
+        return [];
+    }
+    return [
+        `A newer Sibu version is available: ${result.latestVersion} (${result.currentVersion} installed).`,
+        'Update with `npm install -g @juancr11/sibu`.',
+    ];
+}
+export function getDoctorSyncNextStepLines() {
+    return [
+        'Run `sibu sync` to review these workflow changes and choose whether to apply them.',
+        'Sibu will not change project files until you explicitly run `sibu sync`.',
+    ];
+}
+function logNpmVersionAdvisory(result) {
+    for (const line of getNpmVersionAdvisoryLines(result)) {
+        log.info(line);
+    }
+}
+function logSyncNextStep() {
+    for (const line of getDoctorSyncNextStepLines()) {
+        log.info(line);
+    }
+}
+function diagnoseState({ rootPath, state }) {
+    const issues = [];
+    const manifest = readTemplateManifest();
+    if (state.templateVersion !== manifest.templateVersion) {
+        issues.push({
+            severity: 'warning',
+            message: `State was generated from template version ${state.templateVersion}; current template version is ${manifest.templateVersion}.`,
+            hint: 'Run `sibu sync` to review and apply or dismiss template updates.',
+        });
+    }
+    addUnsupportedSelectionIssues(state, issues);
+    const reportedMissingPaths = addExpectedTargetIssues(rootPath, state, issues);
+    addManagedFileIssues(rootPath, state, issues, reportedMissingPaths);
+    return issues;
+}
+function addUnsupportedSelectionIssues(state, issues) {
+    for (const selectedAgent of state.selectedAgents) {
+        if (!SUPPORTED_AGENTS.some((agent) => agent.id === selectedAgent)) {
+            issues.push({ severity: 'warning', message: `State references unsupported agent: ${selectedAgent}.` });
+        }
+    }
+    for (const selectedLanguageSkill of state.selectedLanguageSkills ?? []) {
+        if (!SELECTABLE_LANGUAGE_SKILLS.some((skill) => skill.id === selectedLanguageSkill)) {
+            issues.push({ severity: 'warning', message: `State references unsupported language skill: ${selectedLanguageSkill}.` });
+        }
+    }
+    for (const reviewedLanguageSkill of state.reviewedLanguageSkills ?? []) {
+        if (!SELECTABLE_LANGUAGE_SKILLS.some((skill) => skill.id === reviewedLanguageSkill)) {
+            issues.push({ severity: 'warning', message: `State references unsupported reviewed language skill: ${reviewedLanguageSkill}.` });
+        }
+    }
+    for (const selectedFrameworkSkill of state.selectedFrameworkSkills ?? []) {
+        if (!SELECTABLE_FRAMEWORK_SKILLS.some((skill) => skill.id === selectedFrameworkSkill)) {
+            issues.push({ severity: 'warning', message: `State references unsupported framework skill: ${selectedFrameworkSkill}.` });
+        }
+    }
+    if (state.selectedArchitectureSkill && !SELECTABLE_ARCHITECTURE_SKILLS.some((skill) => skill.id === state.selectedArchitectureSkill)) {
+        issues.push({ severity: 'warning', message: `State references unsupported architecture skill: ${state.selectedArchitectureSkill}.` });
+    }
+    for (const reviewedArchitectureSkill of state.reviewedArchitectureSkills ?? []) {
+        if (!SELECTABLE_ARCHITECTURE_SKILLS.some((skill) => skill.id === reviewedArchitectureSkill)) {
+            issues.push({ severity: 'warning', message: `State references unsupported reviewed architecture skill: ${reviewedArchitectureSkill}.` });
+        }
+    }
+}
+function addExpectedTargetIssues(rootPath, state, issues) {
+    const reportedMissingPaths = new Set();
+    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), getSelectedLanguageSkillsFromState(state), getSelectedFrameworkSkillsFromState(state), getSelectedArchitectureSkillFromState(state));
+    for (const target of expectedTargets) {
+        const relativePath = path.relative(rootPath, target.targetPath);
+        const managedFile = state.managedFiles[relativePath];
+        if (managedFile?.status === 'unmanaged') {
+            continue;
+        }
+        if (!fs.existsSync(target.targetPath)) {
+            reportedMissingPaths.add(relativePath);
+            issues.push({
+                severity: 'error',
+                message: `${relativePath} is missing.`,
+                hint: 'Run `sibu sync` to recreate missing managed workflow files.',
+            });
+            continue;
+        }
+        if (!managedFile) {
+            issues.push({
+                severity: 'warning',
+                message: `${relativePath} exists but is not recorded in ${STATE_RELATIVE_PATH}.`,
+                hint: 'Run `sibu sync` to review and record this workflow file.',
+            });
+        }
+    }
+    return reportedMissingPaths;
+}
+function addManagedFileIssues(rootPath, state, issues, reportedMissingPaths) {
+    const manifest = readTemplateManifest();
+    for (const [relativePath, managedFile] of Object.entries(state.managedFiles)) {
+        if (managedFile.status === 'unmanaged') {
+            continue;
+        }
+        const targetPath = path.join(rootPath, relativePath);
+        if (!fs.existsSync(targetPath)) {
+            if (!reportedMissingPaths.has(relativePath)) {
+                issues.push({
+                    severity: 'error',
+                    message: `${relativePath} is recorded in ${STATE_RELATIVE_PATH} but is missing.`,
+                    hint: 'Run `sibu sync` to recreate missing managed workflow files.',
+                });
+            }
+            continue;
+        }
+        const currentHash = sha256(fs.readFileSync(targetPath, 'utf8'));
+        if (currentHash !== managedFile.sha256) {
+            issues.push({
+                severity: 'warning',
+                message: `${relativePath} has changed since Sibu last recorded it.`,
+                hint: 'If this was intentional, keep it. `sibu sync` will not overwrite local edits automatically.',
+            });
+        }
+        const currentTemplateVersion = getTemplateVersion(manifest, managedFile.template);
+        if (managedFile.templateVersion !== currentTemplateVersion && !hasReviewedTemplateVersion(managedFile, currentTemplateVersion)) {
+            issues.push({
+                severity: 'warning',
+                message: `${relativePath} was generated from template version ${managedFile.templateVersion}; current template version is ${currentTemplateVersion}.`,
+                hint: 'Run `sibu sync` to review and apply or dismiss this template update.',
+            });
+        }
+    }
+}
+function formatManagedFileStatusCounts(state) {
+    const counts = Object.values(state.managedFiles).reduce((accumulator, managedFile) => {
+        accumulator[managedFile.status ?? 'managed'] += 1;
+        return accumulator;
+    }, { managed: 0, customized: 0, unmanaged: 0 });
+    return `managed=${counts.managed}, customized=${counts.customized}, unmanaged=${counts.unmanaged}`;
+}

package/bin/features/init-project/command.js

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

package/bin/features/init-project/handler.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+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, renderIntro } from '../../shared/prompts.js';
+import { readStateForDoctor } from '../../shared/state.js';
+import { getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../../shared/workflow-targets.js';
+export async function handleInitProject(_command) {
+    await renderIntro();
+    intro(chalk.cyan('Setting up Sibu'));
+    const { rootPath, statePath } = getProjectContext();
+    if (fs.existsSync(statePath)) {
+        const stateResult = readStateForDoctor(statePath);
+        if (stateResult.ok) {
+            log.success('This project is already initialized with Sibu.');
+            log.info('Run `sibu doctor` for a read-only health check.');
+            log.info('Run `sibu sync` to review template updates, missing files, or workflow changes.');
+            outro(chalk.green('Setup already complete.'));
+            return;
+        }
+        log.error(stateResult.message);
+        log.info(`${STATE_RELATIVE_PATH} already exists, so I will not overwrite it from init.`);
+        log.info('Fix or restore the state file before running `sibu doctor` or `sibu sync`.');
+        outro(chalk.yellow('Setup needs attention.'));
+        process.exitCode = 1;
+        return;
+    }
+    const selectedAgents = await askForSupportedAgents();
+    const selectedLanguageSkills = await askForLanguageSkills();
+    const selectedFrameworkSkills = await askForFrameworkSkills();
+    const selectedArchitectureSkill = await askForArchitectureSkill();
+    const targets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill);
+    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) {
+        if (fs.existsSync(target.targetPath)) {
+            log.info(`${target.label} already exists. I will keep it unchanged and record it in ${STATE_RELATIVE_PATH}.`);
+        }
+        else {
+            log.info(`${target.label} is missing. I will create it.`);
+        }
+    }
+    log.info(`${STATE_RELATIVE_PATH} is missing. I will create it.`);
+    const shouldAskForOverview = missingTargets.some((target) => target.requiresProjectOverview);
+    const overview = shouldAskForOverview ? await askForProjectOverview() : undefined;
+    const files = renderMissingWorkflowFiles({
+        missingTargets,
+        overview,
+        selectedLanguageSkills,
+        selectedFrameworkSkills,
+        selectedArchitectureSkill,
+    });
+    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, targets });
+    log.success(`Created ${STATE_RELATIVE_PATH}`);
+    outro(chalk.green('Setup complete.'));
+}

package/bin/features/list-skills/command.js

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

package/bin/features/list-skills/handler.js

@@ -0,0 +1,55 @@
+import { intro, log, outro } from '@clack/prompts';
+import chalk from 'chalk';
+import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS } from '../../shared/catalog.js';
+import { getProjectContext } from '../../shared/paths.js';
+import { renderIntro } from '../../shared/prompts.js';
+import { readStateForDoctor } from '../../shared/state.js';
+export async function handleListSkills(_command) {
+    await renderIntro();
+    intro(chalk.cyan('Available workflow skills'));
+    const { statePath } = getProjectContext();
+    const stateResult = readStateForDoctor(statePath);
+    const state = stateResult.ok ? stateResult.state : undefined;
+    if (!stateResult.ok) {
+        log.warn(`${stateResult.message} Showing available skills without project state.`);
+        log.info('Run `sibu init` before selecting project skills.');
+    }
+    logSkillGroup('Languages', getLanguageSkillItems(state));
+    logSkillGroup('Frameworks', getFrameworkSkillItems(state));
+    logSkillGroup('Architecture', getArchitectureSkillItems(state));
+    outro(chalk.green('Skill list ready.'));
+}
+function getLanguageSkillItems(state) {
+    const selectedSkillIds = new Set(state?.selectedLanguageSkills ?? []);
+    return SELECTABLE_LANGUAGE_SKILLS.map((skill) => ({
+        name: skill.name,
+        id: skill.id,
+        description: skill.description,
+        selected: selectedSkillIds.has(skill.id),
+    }));
+}
+function getFrameworkSkillItems(state) {
+    const selectedSkillIds = new Set(state?.selectedFrameworkSkills ?? []);
+    return SELECTABLE_FRAMEWORK_SKILLS.map((skill) => ({
+        name: skill.name,
+        id: skill.id,
+        description: skill.description,
+        selected: selectedSkillIds.has(skill.id),
+    }));
+}
+function getArchitectureSkillItems(state) {
+    return SELECTABLE_ARCHITECTURE_SKILLS.map((skill) => ({
+        name: skill.name,
+        id: skill.id,
+        description: skill.description,
+        selected: state?.selectedArchitectureSkill === skill.id,
+    }));
+}
+function logSkillGroup(label, skills) {
+    log.message(chalk.bold(label));
+    for (const skill of skills) {
+        const marker = skill.selected ? chalk.green('● selected') : chalk.dim('○ available');
+        console.log(`  ${marker} ${chalk.bold(skill.name)} ${chalk.dim(`(${skill.id})`)}`);
+        console.log(`    ${chalk.dim(skill.description)}`);
+    }
+}

package/bin/features/stop-managing-file/command.js

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