@juancr11/sibu 0.1.0

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

@@ -0,0 +1,213 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { cancel, intro, isCancel, log, outro, select } from '@clack/prompts';
+import chalk from 'chalk';
+import { STATE_RELATIVE_PATH, resolveSelectableSkillById } from '../../shared/catalog.js';
+import { readFileHashIfPresent, sha256 } from '../../shared/hash.js';
+import { getProjectContext } from '../../shared/paths.js';
+import { renderIntro } from '../../shared/prompts.js';
+import { cloneState, readStateForDoctor, writeStateFile } from '../../shared/state.js';
+import { getTemplateVersion, readTemplateManifest, renderTemplateForSync } from '../../shared/templates.js';
+import { removeUndefinedFields } from '../../shared/object.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, } from '../../shared/workflow-targets.js';
+export async function handleStopManagingFile({ skillName }) {
+    await renderIntro();
+    intro(chalk.cyan('Updating skill management'));
+    const { rootPath, statePath } = getProjectContext();
+    const stateResult = readStateForDoctor(statePath);
+    if (!stateResult.ok) {
+        log.error(stateResult.message);
+        log.info('Run `sibu init` before managing workflow skill state.');
+        outro(chalk.yellow('Skill update unavailable.'));
+        process.exitCode = 1;
+        return;
+    }
+    const result = stopSelectedSkill({ rootPath, state: stateResult.state, skillName });
+    switch (result.status) {
+        case 'blocked':
+            log.error(result.message);
+            if (result.hint) {
+                log.info(result.hint);
+            }
+            outro(chalk.yellow('Nothing changed.'));
+            process.exitCode = 1;
+            return;
+        case 'noop':
+            log.success(result.message);
+            log.info('No files changed.');
+            outro(chalk.green('Skill selection is already up to date.'));
+            return;
+        case 'stopped':
+            writeStateFile(statePath, result.state);
+            for (const stoppedPath of result.stoppedPaths) {
+                log.success(`Stopped managing ${stoppedPath.relativePath}.`);
+            }
+            log.success('Updated AGENTS.md skill routing.');
+            log.success(`Updated ${STATE_RELATIVE_PATH}.`);
+            for (const [index, stoppedPath] of result.stoppedPaths.entries()) {
+                await askToDeleteStoppedFile(stoppedPath, result.stoppedFiles[index]);
+            }
+            outro(chalk.green(`Updated ${result.skillName}.`));
+            return;
+    }
+}
+export function stopSelectedSkill({ rootPath, state, skillName }) {
+    const resolution = resolveSelectableSkillById(skillName);
+    if (!resolution.ok) {
+        return { status: 'blocked', message: resolution.message, hint: 'Use `sibu skills stop <skill_name>` with a selectable skill id from `sibu skills list`.' };
+    }
+    if (!isSkillSelected(state, resolution.resolved)) {
+        return { status: 'noop', message: `${resolution.resolved.skill.name} is not selected.` };
+    }
+    const stoppedPaths = getSkillManagedPaths(rootPath, state, resolution.resolved);
+    if (stoppedPaths.length === 0) {
+        return { status: 'blocked', message: `${resolution.resolved.skill.name} does not have a managed target for the selected agents.` };
+    }
+    const nextState = cloneState(state);
+    const stoppedFiles = [];
+    for (const stoppedPath of stoppedPaths) {
+        const managedFile = nextState.managedFiles[stoppedPath.relativePath];
+        if (!managedFile) {
+            return {
+                status: 'blocked',
+                message: `${stoppedPath.relativePath} is not recorded in ${STATE_RELATIVE_PATH}.`,
+                hint: 'Run `sibu sync` to review workflow state before stopping this skill.',
+            };
+        }
+        const currentHash = readFileHashIfPresent(stoppedPath.absolutePath);
+        const stoppedFile = removeUndefinedFields({
+            ...managedFile,
+            sha256: currentHash ?? managedFile.sha256,
+            status: 'unmanaged',
+            reason: 'Stopped by `sibu skills stop`.',
+        });
+        nextState.managedFiles[stoppedPath.relativePath] = stoppedFile;
+        stoppedFiles.push(stoppedFile);
+    }
+    removeSelectedSkill(nextState, resolution.resolved);
+    const agentsUpdate = getAgentsUpdate(rootPath, nextState);
+    if (!agentsUpdate.ok) {
+        return { status: 'blocked', message: agentsUpdate.message, hint: 'Run `sibu sync` to review workflow state before stopping this skill.' };
+    }
+    fs.writeFileSync(agentsUpdate.path, agentsUpdate.contents, 'utf8');
+    const manifest = readTemplateManifest();
+    nextState.templateVersion = manifest.templateVersion;
+    nextState.updatedAt = new Date().toISOString();
+    nextState.managedFiles['AGENTS.md'] = removeUndefinedFields({
+        ...agentsUpdate.managedFile,
+        templateVersion: getTemplateVersion(manifest, agentsUpdate.managedFile.template),
+        sha256: sha256(agentsUpdate.contents),
+        status: agentsUpdate.managedFile.status ?? 'managed',
+    });
+    return { status: 'stopped', state: nextState, stoppedPaths, stoppedFiles, skillName: resolution.resolved.skill.name };
+}
+function isSkillSelected(state, resolved) {
+    switch (resolved.kind) {
+        case 'language':
+            return state.selectedLanguageSkills?.includes(resolved.skill.id) ?? false;
+        case 'framework':
+            return state.selectedFrameworkSkills?.includes(resolved.skill.id) ?? false;
+        case 'architecture':
+            return state.selectedArchitectureSkill === resolved.skill.id;
+    }
+}
+function removeSelectedSkill(state, resolved) {
+    switch (resolved.kind) {
+        case 'language':
+            state.selectedLanguageSkills = (state.selectedLanguageSkills ?? []).filter((skillId) => skillId !== resolved.skill.id);
+            return;
+        case 'framework':
+            state.selectedFrameworkSkills = (state.selectedFrameworkSkills ?? []).filter((skillId) => skillId !== resolved.skill.id);
+            return;
+        case 'architecture':
+            delete state.selectedArchitectureSkill;
+            return;
+    }
+}
+function getSkillManagedPaths(rootPath, state, resolved) {
+    const relativePaths = new Set();
+    for (const agent of getSelectedAgentsFromState(state)) {
+        const relativePath = resolved.skill.targetRelativePathsByAgent[agent.id];
+        if (relativePath) {
+            relativePaths.add(relativePath);
+        }
+    }
+    return [...relativePaths].map((relativePath) => ({
+        relativePath,
+        absolutePath: path.join(rootPath, relativePath),
+    }));
+}
+function getAgentsUpdate(rootPath, state) {
+    const agentsRelativePath = 'AGENTS.md';
+    const agentsPath = path.join(rootPath, agentsRelativePath);
+    const managedFile = state.managedFiles[agentsRelativePath];
+    if (!managedFile) {
+        return { ok: false, message: 'AGENTS.md is not recorded in `.sibu/state.json`.' };
+    }
+    if (!fs.existsSync(agentsPath)) {
+        return { ok: false, message: 'AGENTS.md is missing.' };
+    }
+    const currentHash = sha256(fs.readFileSync(agentsPath, 'utf8'));
+    if (currentHash !== managedFile.sha256) {
+        return { ok: false, message: 'AGENTS.md has changed since Sibu last recorded it.' };
+    }
+    return {
+        ok: true,
+        path: agentsPath,
+        managedFile,
+        contents: renderTemplateForSync({
+            templateRelativePath: managedFile.template,
+            currentPath: agentsPath,
+            selectedLanguageSkills: getSelectedLanguageSkillsFromState(state),
+            selectedFrameworkSkills: getSelectedFrameworkSkillsFromState(state),
+            selectedArchitectureSkill: getSelectedArchitectureSkillFromState(state),
+        }),
+    };
+}
+async function askToDeleteStoppedFile(managedPath, managedFile) {
+    if (!fs.existsSync(managedPath.absolutePath)) {
+        log.info(`${managedPath.relativePath} does not exist locally, so there is nothing to delete.`);
+        return;
+    }
+    if (!fs.lstatSync(managedPath.absolutePath).isFile()) {
+        log.warn(`${managedPath.relativePath} is not a regular file. I will not delete it.`);
+        return;
+    }
+    const deleteAction = await select({
+        message: `Do you also want to delete ${managedPath.relativePath} for good?`,
+        options: [
+            { value: 'keep', label: 'Keep file', hint: 'Recommended. Leave the local file unchanged.' },
+            { value: 'delete', label: 'Delete file', hint: 'Permanently remove this file from the project.' },
+        ],
+    });
+    if (isCancel(deleteAction)) {
+        cancel('Delete prompt cancelled. The file is no longer managed, but it was not deleted.');
+        process.exit(0);
+    }
+    if (deleteAction === 'keep') {
+        log.info(`Kept ${managedPath.relativePath}.`);
+        return;
+    }
+    if (hasLocalEdits(managedPath.absolutePath, managedFile)) {
+        const confirmDelete = await select({
+            message: `${managedPath.relativePath} differs from the last Sibu-recorded hash. Delete it anyway?`,
+            options: [
+                { value: 'keep', label: 'Keep file', hint: 'Recommended. Preserve local edits.' },
+                { value: 'delete', label: 'Delete anyway', hint: 'Permanently remove the edited file.' },
+            ],
+        });
+        if (isCancel(confirmDelete)) {
+            cancel('Delete prompt cancelled. The file is no longer managed, but it was not deleted.');
+            process.exit(0);
+        }
+        if (confirmDelete === 'keep') {
+            log.info(`Kept ${managedPath.relativePath}.`);
+            return;
+        }
+    }
+    fs.unlinkSync(managedPath.absolutePath);
+    log.success(`Deleted ${managedPath.relativePath}.`);
+}
+function hasLocalEdits(filePath, managedFile) {
+    return readFileHashIfPresent(filePath) !== managedFile.sha256;
+}

package/bin/features/sync-project/action-prompt.js

@@ -0,0 +1,65 @@
+import { cancel, isCancel, select } from '@clack/prompts';
+export async function askForSyncAction(preview) {
+    if (preview.status === 'update-available') {
+        const action = await select({
+            message: `What should I do with ${preview.relativePath}?`,
+            options: [
+                { value: 'apply-update', label: 'Apply update', hint: 'Safe because no local edits were detected.' },
+                { value: 'skip', label: 'Skip for now' },
+            ],
+        });
+        return handleSyncActionCancel(action);
+    }
+    if (preview.status === 'missing') {
+        const action = await select({
+            message: `What should I do with ${preview.relativePath}?`,
+            options: [
+                { value: 'apply-update', label: 'Recreate file', hint: 'Write the latest template and update Sibu state.' },
+                { value: 'stop-managing', label: 'Stop managing this file', hint: 'Opt this file out of Sibu missing-file warnings.' },
+                { value: 'skip', label: 'Skip for now' },
+            ],
+        });
+        return handleSyncActionCancel(action);
+    }
+    if (preview.status === 'new-template') {
+        const options = preview.hasLocalFile
+            ? [
+                { value: 'mark-reviewed', label: 'Start managing existing file', hint: 'Keep the file unchanged and record it in Sibu state.' },
+                { value: 'write-side-template', label: 'Write latest template beside my file', hint: 'Create a reference copy under .sibu/sync/.' },
+                { value: 'skip', label: 'Skip for now' },
+            ]
+            : [
+                { value: 'apply-update', label: 'Create file', hint: 'Write the latest template and record it in Sibu state.' },
+                { value: 'skip', label: 'Skip for now' },
+            ];
+        const action = await select({
+            message: `What should I do with ${preview.relativePath}?`,
+            options,
+        });
+        return handleSyncActionCancel(action);
+    }
+    const options = [
+        { value: 'mark-reviewed', label: 'Mark as reviewed', hint: 'Keep my file and stop warning about this template version.' },
+        { value: 'stop-managing', label: 'Stop managing this file', hint: 'Opt this file out of Sibu template drift warnings.' },
+        { value: 'skip', label: 'Skip for now' },
+    ];
+    if (preview.status === 'modified-with-update') {
+        options.splice(1, 0, {
+            value: 'write-side-template',
+            label: 'Write latest template beside my file',
+            hint: 'Create a reference copy under .sibu/sync/.',
+        });
+    }
+    const action = await select({
+        message: `What should I do with ${preview.relativePath}?`,
+        options,
+    });
+    return handleSyncActionCancel(action);
+}
+function handleSyncActionCancel(action) {
+    if (isCancel(action)) {
+        cancel('Sync cancelled.');
+        process.exit(0);
+    }
+    return action;
+}

package/bin/features/sync-project/apply-action.js

@@ -0,0 +1,81 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { log } from '@clack/prompts';
+import { sha256 } from '../../shared/hash.js';
+import { getSideTemplatePath } from '../../shared/paths.js';
+import { cloneState } from '../../shared/state.js';
+import { getTemplateVersion, renderTemplateForSync } from '../../shared/templates.js';
+import { getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState } from '../../shared/workflow-targets.js';
+export function applySyncAction({ rootPath, state, manifest, preview, action, }) {
+    const nextState = cloneState(state);
+    const managedFile = nextState.managedFiles[preview.relativePath] ?? preview.managedFile;
+    const targetPath = path.join(rootPath, preview.relativePath);
+    const currentTemplateVersion = preview.currentTemplateVersion ?? getTemplateVersion(manifest, managedFile.template);
+    switch (action) {
+        case 'apply-update': {
+            const contents = renderTemplateForSync({
+                templateRelativePath: managedFile.template,
+                currentPath: targetPath,
+                selectedLanguageSkills: getSelectedLanguageSkillsFromState(nextState),
+                selectedFrameworkSkills: getSelectedFrameworkSkillsFromState(nextState),
+                selectedArchitectureSkill: getSelectedArchitectureSkillFromState(nextState),
+            });
+            fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+            fs.writeFileSync(targetPath, contents, 'utf8');
+            nextState.templateVersion = manifest.templateVersion;
+            nextState.updatedAt = new Date().toISOString();
+            nextState.managedFiles[preview.relativePath] = {
+                template: managedFile.template,
+                templateVersion: currentTemplateVersion,
+                sha256: sha256(contents),
+                status: 'managed',
+            };
+            log.success(`Applied latest template to ${preview.relativePath}`);
+            return { state: nextState, changedFiles: true, changedState: true };
+        }
+        case 'mark-reviewed': {
+            const contents = fs.readFileSync(targetPath, 'utf8');
+            nextState.templateVersion = manifest.templateVersion;
+            nextState.updatedAt = new Date().toISOString();
+            nextState.managedFiles[preview.relativePath] = {
+                ...managedFile,
+                sha256: sha256(contents),
+                status: 'customized',
+                lastReviewedTemplateVersion: currentTemplateVersion,
+            };
+            log.success(`Marked ${preview.relativePath} as reviewed.`);
+            return { state: nextState, changedFiles: false, changedState: true };
+        }
+        case 'write-side-template': {
+            const sideTemplatePath = getSideTemplatePath(rootPath, preview.relativePath, currentTemplateVersion);
+            const contents = renderTemplateForSync({
+                templateRelativePath: managedFile.template,
+                currentPath: targetPath,
+                selectedLanguageSkills: getSelectedLanguageSkillsFromState(state),
+                selectedFrameworkSkills: getSelectedFrameworkSkillsFromState(state),
+                selectedArchitectureSkill: getSelectedArchitectureSkillFromState(state),
+            });
+            fs.mkdirSync(path.dirname(sideTemplatePath), { recursive: true });
+            fs.writeFileSync(sideTemplatePath, contents, 'utf8');
+            log.success(`Wrote latest template to ${path.relative(rootPath, sideTemplatePath)}`);
+            log.info('Review it and copy over anything you want.');
+            return { state, changedFiles: true, changedState: false };
+        }
+        case 'stop-managing': {
+            const contents = fs.existsSync(targetPath) ? fs.readFileSync(targetPath, 'utf8') : '';
+            nextState.templateVersion = manifest.templateVersion;
+            nextState.updatedAt = new Date().toISOString();
+            nextState.managedFiles[preview.relativePath] = {
+                ...managedFile,
+                sha256: sha256(contents),
+                status: 'unmanaged',
+                lastReviewedTemplateVersion: currentTemplateVersion,
+                reason: 'user opted out',
+            };
+            log.success(`Stopped managing ${preview.relativePath}.`);
+            return { state: nextState, changedFiles: false, changedState: true };
+        }
+        case 'skip':
+            return { state, changedFiles: false, changedState: false };
+    }
+}

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

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

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

@@ -0,0 +1,77 @@
+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 { askForMissingFrameworkSkills, askForNewArchitectureSkill, askForNewLanguageSkills, renderIntro } from '../../shared/prompts.js';
+import { readStateForDoctor, writeStateFile } from '../../shared/state.js';
+import { readTemplateManifest } from '../../shared/templates.js';
+import { askForSyncAction } from './action-prompt.js';
+import { applySyncAction } from './apply-action.js';
+import { logSyncPreview } from './log-preview.js';
+import { getSyncPreviews, isActionableSyncPreview, shouldAskForSyncAction } from './preview.js';
+export async function handleSyncProject(_command) {
+    await renderIntro();
+    intro(chalk.cyan('Reviewing workflow updates'));
+    const { rootPath, statePath } = getProjectContext();
+    const stateResult = readStateForDoctor(statePath);
+    if (!stateResult.ok) {
+        log.error(stateResult.message);
+        log.info('Run `sibu init` before syncing so I know which files are managed.');
+        outro(chalk.yellow('Sync unavailable.'));
+        process.exitCode = 1;
+        return;
+    }
+    const languageSkillSelection = await askForNewLanguageSkills(stateResult.state);
+    const frameworkSkillSelection = await askForMissingFrameworkSkills(languageSkillSelection.state);
+    const architectureSkillSelection = await askForNewArchitectureSkill(frameworkSkillSelection.state);
+    let state = architectureSkillSelection.state;
+    const manifest = readTemplateManifest();
+    const previews = getSyncPreviews({ rootPath, state, manifest });
+    const actionablePreviews = previews.filter(isActionableSyncPreview);
+    if (actionablePreviews.length === 0) {
+        log.success('No template updates or local changes need review.');
+        if (state.templateVersion !== manifest.templateVersion ||
+            languageSkillSelection.changedState ||
+            frameworkSkillSelection.changedState ||
+            architectureSkillSelection.changedState) {
+            state = {
+                ...state,
+                templateVersion: manifest.templateVersion,
+                updatedAt: new Date().toISOString(),
+            };
+            writeStateFile(statePath, state);
+            log.success(`Updated ${STATE_RELATIVE_PATH}`);
+        }
+        else {
+            log.info('No files changed.');
+        }
+        outro(chalk.green('Everything is already in sync.'));
+        return;
+    }
+    log.warn('Found workflow updates to review.');
+    let changedState = languageSkillSelection.changedState || frameworkSkillSelection.changedState || architectureSkillSelection.changedState;
+    let changedFiles = false;
+    for (const preview of previews) {
+        logSyncPreview(preview);
+        if (!shouldAskForSyncAction(preview)) {
+            continue;
+        }
+        const action = await askForSyncAction(preview);
+        if (action === 'skip') {
+            log.info(`Skipped ${preview.relativePath}.`);
+            continue;
+        }
+        const result = applySyncAction({ rootPath, state, manifest, preview, action });
+        state = result.state;
+        changedState = changedState || result.changedState;
+        changedFiles = changedFiles || result.changedFiles;
+    }
+    if (changedState) {
+        writeStateFile(statePath, state);
+        log.success(`Updated ${STATE_RELATIVE_PATH}`);
+    }
+    if (!changedFiles && !changedState) {
+        log.info('No files changed.');
+    }
+    outro(chalk.green('Sync complete.'));
+}

package/bin/features/sync-project/log-preview.js

@@ -0,0 +1,62 @@
+import { log } from '@clack/prompts';
+import { STATE_RELATIVE_PATH } from '../../shared/catalog.js';
+export function logSyncPreview(preview) {
+    switch (preview.status) {
+        case 'up-to-date':
+            log.success(`${preview.relativePath} is up to date.`);
+            return;
+        case 'new-template':
+            if (preview.hasLocalFile) {
+                log.warn(`${preview.relativePath} is expected but is not recorded in ${STATE_RELATIVE_PATH}.`);
+                log.info('I will not overwrite it automatically. You can start managing it or write the latest template beside it.');
+            }
+            else {
+                log.warn(`${preview.relativePath} should now be part of this workflow.`);
+            }
+            logTemplateChanges(preview);
+            return;
+        case 'missing':
+            log.error(`${preview.relativePath} is missing.`);
+            log.info('You can recreate it from the latest template during this sync.');
+            return;
+        case 'modified':
+            log.warn(`${preview.relativePath} has local edits.`);
+            log.info('I will not overwrite it automatically. There are no newer template changes for it right now.');
+            return;
+        case 'update-available':
+            if (preview.recordedTemplateVersion === preview.currentTemplateVersion) {
+                log.warn(`${preview.relativePath} needs generated content updates from your current project selections.`);
+            }
+            else {
+                log.warn(`${preview.relativePath} has a newer template available (${preview.recordedTemplateVersion} → ${preview.currentTemplateVersion}).`);
+            }
+            logTemplateChanges(preview);
+            return;
+        case 'modified-with-update':
+            if (preview.recordedTemplateVersion === preview.currentTemplateVersion) {
+                log.warn(`${preview.relativePath} has local edits and also needs generated content updates from your current project selections.`);
+            }
+            else {
+                log.warn(`${preview.relativePath} has local edits and a newer template is available (${preview.recordedTemplateVersion} → ${preview.currentTemplateVersion}).`);
+            }
+            log.info('I will not overwrite it automatically. Review the template changes below and decide what to adopt.');
+            logTemplateChanges(preview);
+            return;
+        case 'unknown-template':
+            log.warn(`${preview.relativePath} references a template that is not in templates/manifest.json.`);
+            return;
+        case 'unmanaged':
+            log.info(`${preview.relativePath} is unmanaged. I will leave it alone.`);
+            return;
+    }
+}
+function logTemplateChanges(preview) {
+    if (preview.changes.length === 0) {
+        log.info('No human-readable template changes were recorded for this template.');
+        return;
+    }
+    log.info('New template changes:');
+    for (const change of preview.changes) {
+        log.info(`- ${change}`);
+    }
+}

package/bin/features/sync-project/preview.js

@@ -0,0 +1 @@
+export { getSyncPreviews, isActionableSyncPreview, shouldAskForSyncAction } from '../../shared/sync-preview.js';

package/bin/features/use-skill/command.js

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