@juancr11/sibu 0.16.0 → 0.17.1

package/bin/modules/workflow-configuration-manager/stop-managing-file/handler.js

@@ -0,0 +1,221 @@
+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 } from '../../workflow-state-ledger/state-path.js';
+import { resolveSelectableSkillById } from '../../template-catalog/index.js';
+import { readFileHashIfPresent, sha256 } from '../../../shared/hash.js';
+import { getProjectContext } from '../../../shared/paths.js';
+import { renderIntro } from '../../../support/interactive-guidance/index.js';
+import { cloneState, readStateForDoctor, writeStateFile } from '../../workflow-state-ledger/index.js';
+import { getTemplateVersion, readTemplateManifest } from '../../template-catalog/index.js';
+import { renderTemplateForSync } from '../../template-catalog/index.js';
+import { removeUndefinedFields } from '../../../shared/object.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, getSkillTargetsForAgents, } from '../../template-catalog/index.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;
+        case 'database':
+            return state.selectedDatabaseSkills?.includes(resolved.skill.id) ?? false;
+        case 'workflow':
+            return state.selectedWorkflowSkills?.includes(resolved.skill.id) ?? false;
+    }
+}
+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;
+        case 'database':
+            state.selectedDatabaseSkills = (state.selectedDatabaseSkills ?? []).filter((skillId) => skillId !== resolved.skill.id);
+            return;
+        case 'workflow':
+            state.selectedWorkflowSkills = (state.selectedWorkflowSkills ?? []).filter((skillId) => skillId !== resolved.skill.id);
+            return;
+    }
+}
+function getSkillManagedPaths(rootPath, state, resolved) {
+    const relativePaths = new Set(getSkillTargetsForAgents(resolved.skill, getSelectedAgentsFromState(state)).map((target) => target.targetRelativePath));
+    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),
+            selectedWorkflowSkills: getSelectedWorkflowSkillsFromState(state),
+            selectedDatabaseSkills: getSelectedDatabaseSkillsFromState(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/modules/workflow-configuration-manager/stop-mcp-server/command.js

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

package/bin/modules/workflow-configuration-manager/stop-mcp-server/handler.js

@@ -0,0 +1,198 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { cancel, isCancel, log, select } from '@clack/prompts';
+import { STATE_RELATIVE_PATH } from '../../workflow-state-ledger/state-path.js';
+import { readFileHashIfPresent, sha256 } from '../../../shared/hash.js';
+import { removeUndefinedFields } from '../../../shared/object.js';
+import { getProjectContext } from '../../../shared/paths.js';
+import { renderMissingWorkflowFiles, resolveSelectableMcpServerById } from '../../template-catalog/index.js';
+import { getWorkflowMutationReadiness } from '../../sync-review-orchestrator/index.js';
+import { getTemplateVersion, readTemplateManifest } from '../../template-catalog/index.js';
+import { cloneState, writeStateFile } from '../../workflow-state-ledger/index.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from '../../template-catalog/index.js';
+export async function handleStopMcpServer(command) {
+    const { rootPath, statePath } = getProjectContext();
+    const readiness = getWorkflowMutationReadiness({ rootPath, statePath });
+    if (!readiness.ok) {
+        log.error(readiness.message);
+        log.info(readiness.hint);
+        for (const preview of readiness.actionablePreviews?.slice(0, 3) ?? []) {
+            log.info(`${preview.relativePath}: ${preview.status}`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const result = stopSelectedMcpServer({ rootPath, state: readiness.state, serverId: command.serverId });
+    switch (result.status) {
+        case 'blocked':
+            log.error(result.message);
+            if (result.hint) {
+                log.info(result.hint);
+            }
+            process.exitCode = 1;
+            return;
+        case 'noop':
+            log.success(result.message);
+            log.info('No files changed.');
+            return;
+        case 'stopped':
+            writeStateFile(statePath, result.state);
+            log.success(`Updated ${STATE_RELATIVE_PATH}`);
+            log.success(`Stopped ${result.serverName}.`);
+            for (const [index, stoppedPath] of result.stoppedPaths.entries()) {
+                await askToDeleteStoppedMcpFile(stoppedPath, result.stoppedFiles[index]);
+            }
+            return;
+    }
+}
+export function getNextStoppedMcpSelection(state, serverId) {
+    const resolution = resolveSelectableMcpServerById(serverId);
+    if (!resolution.ok) {
+        return { status: 'blocked', message: resolution.message };
+    }
+    const selectedMcpServerIds = [...(state.selectedMcpServers ?? [])];
+    if (!selectedMcpServerIds.includes(resolution.resolved.server.id)) {
+        return { status: 'noop', message: `${resolution.resolved.server.name} is not selected.` };
+    }
+    return {
+        status: 'selected',
+        serverName: resolution.resolved.server.name,
+        remainingMcpServers: selectedMcpServerIds.filter((selectedServerId) => selectedServerId !== resolution.resolved.server.id).map(getMcpServerById),
+    };
+}
+export function stopSelectedMcpServer({ rootPath, state, serverId }) {
+    const selectionResult = getNextStoppedMcpSelection(state, serverId);
+    if (selectionResult.status !== 'selected') {
+        return selectionResult;
+    }
+    const selectedAgents = getSelectedAgentsFromState(state);
+    const selectedLanguageSkills = getSelectedLanguageSkillsFromState(state);
+    const selectedFrameworkSkills = getSelectedFrameworkSkillsFromState(state);
+    const selectedArchitectureSkill = getSelectedArchitectureSkillFromState(state);
+    const selectedWorkflowSkills = getSelectedWorkflowSkillsFromState(state);
+    const selectedDatabaseSkills = getSelectedDatabaseSkillsFromState(state);
+    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, getSelectedMcpServersFromState(state));
+    const nextTargets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectionResult.remainingMcpServers);
+    const manifest = readTemplateManifest();
+    const nextState = cloneState(state);
+    const nextTargetsByPath = new Map(nextTargets.map((target) => [target.targetPath, target]));
+    const stoppedPaths = [];
+    const stoppedFiles = [];
+    nextState.selectedMcpServers = selectionResult.remainingMcpServers.map((server) => server.id);
+    if (serverId === 'notion' && nextState.mcpServerConfigs?.notion) {
+        const { notion: _notion, ...remainingMcpServerConfigs } = nextState.mcpServerConfigs;
+        nextState.mcpServerConfigs = Object.keys(remainingMcpServerConfigs).length > 0 ? remainingMcpServerConfigs : undefined;
+    }
+    nextState.templateVersion = manifest.templateVersion;
+    nextState.updatedAt = new Date().toISOString();
+    for (const previousTarget of previousTargets.filter((target) => target.mcpConfigAgentId)) {
+        const relativePath = path.relative(rootPath, previousTarget.targetPath);
+        const managedFile = nextState.managedFiles[relativePath];
+        if (!managedFile) {
+            return {
+                status: 'blocked',
+                message: `${relativePath} is not recorded in ${STATE_RELATIVE_PATH}.`,
+                hint: 'Run `sibu sync` to review workflow state before stopping this MCP server.',
+            };
+        }
+        const nextTarget = nextTargetsByPath.get(previousTarget.targetPath);
+        if (nextTarget) {
+            const [file] = renderMissingWorkflowFiles({
+                missingTargets: [nextTarget],
+                selectedLanguageSkills,
+                selectedFrameworkSkills,
+                selectedArchitectureSkill,
+                selectedWorkflowSkills,
+                selectedDatabaseSkills,
+                selectedMcpServers: selectionResult.remainingMcpServers,
+            });
+            fs.mkdirSync(path.dirname(file.targetPath), { recursive: true });
+            fs.writeFileSync(file.targetPath, file.contents, 'utf8');
+            nextState.managedFiles[relativePath] = removeUndefinedFields({
+                ...managedFile,
+                templateVersion: getTemplateVersion(manifest, managedFile.template),
+                sha256: sha256(file.contents),
+                status: managedFile.status ?? 'managed',
+            });
+            continue;
+        }
+        const stoppedFile = removeUndefinedFields({
+            ...managedFile,
+            templateVersion: getTemplateVersion(manifest, managedFile.template),
+            sha256: readFileHashIfPresent(previousTarget.targetPath) ?? managedFile.sha256,
+            status: 'unmanaged',
+            reason: 'Stopped by `sibu mcp stop`.',
+        });
+        nextState.managedFiles[relativePath] = stoppedFile;
+        stoppedPaths.push({ relativePath, absolutePath: previousTarget.targetPath });
+        stoppedFiles.push(stoppedFile);
+    }
+    return { status: 'stopped', state: nextState, stoppedPaths, stoppedFiles, serverName: selectionResult.serverName };
+}
+export async function askToDeleteStoppedMcpFile(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 MCP config 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);
+    }
+    const confirmDelete = deleteAction === 'delete' && hasLocalEdits(managedPath.absolutePath, managedFile) ? await askToConfirmEditedDelete(managedPath) : undefined;
+    applyStoppedMcpFileDeleteDecision({ managedPath, managedFile, deleteAction, confirmDelete });
+}
+export function applyStoppedMcpFileDeleteDecision({ managedPath, managedFile, deleteAction, confirmDelete, }) {
+    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;
+    }
+    if (deleteAction === 'keep') {
+        log.info(`Kept ${managedPath.relativePath}.`);
+        return;
+    }
+    if (hasLocalEdits(managedPath.absolutePath, managedFile) && confirmDelete !== 'delete') {
+        log.info(`Kept ${managedPath.relativePath}.`);
+        return;
+    }
+    fs.unlinkSync(managedPath.absolutePath);
+    log.success(`Deleted ${managedPath.relativePath}.`);
+}
+async function askToConfirmEditedDelete(managedPath) {
+    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);
+    }
+    return confirmDelete;
+}
+function hasLocalEdits(filePath, managedFile) {
+    return readFileHashIfPresent(filePath) !== managedFile.sha256;
+}
+function getMcpServerById(serverId) {
+    const resolution = resolveSelectableMcpServerById(serverId);
+    if (!resolution.ok) {
+        throw new Error(`Unsupported MCP server in state: ${serverId}`);
+    }
+    return resolution.resolved.server;
+}

package/bin/modules/workflow-configuration-manager/use-mcp-server/command.js

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

package/bin/modules/workflow-configuration-manager/use-mcp-server/handler.js

@@ -0,0 +1,193 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { writeSibuState } from '../../workflow-state-ledger/index.js';
+import { log } from '@clack/prompts';
+import { STATE_RELATIVE_PATH } from '../../workflow-state-ledger/state-path.js';
+import { sha256 } from '../../../shared/hash.js';
+import { getProjectContext } from '../../../shared/paths.js';
+import { askForNotionDocsParentPage } from '../../../support/interactive-guidance/index.js';
+import { renderTemplateForSync } from '../../template-catalog/index.js';
+import { getWorkflowMutationReadiness } from '../../sync-review-orchestrator/index.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowSkillsImpliedByMcpServers, getWorkflowTargets, renderMissingWorkflowFiles, resolveSelectableMcpServerById, } from '../../template-catalog/index.js';
+const defaultDependencies = {
+    askForNotionDocsParentPage,
+};
+export async function handleUseMcpServer(command, dependencies = defaultDependencies) {
+    const { rootPath, statePath } = getProjectContext();
+    const readiness = getWorkflowMutationReadiness({ rootPath, statePath });
+    if (!readiness.ok) {
+        log.error(readiness.message);
+        log.info(readiness.hint);
+        for (const preview of readiness.actionablePreviews?.slice(0, 3) ?? []) {
+            log.info(`${preview.relativePath}: ${preview.status}`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const selectionResult = getNextMcpSelection(readiness.state, command.serverId);
+    switch (selectionResult.status) {
+        case 'noop':
+            log.success(selectionResult.message);
+            log.info('No files changed.');
+            return;
+        case 'blocked':
+            log.error(selectionResult.message);
+            if (selectionResult.hint) {
+                log.info(selectionResult.hint);
+            }
+            process.exitCode = 1;
+            return;
+        case 'selected': {
+            const mcpServerConfigs = await getNextMcpServerConfigs({ state: readiness.state, selectionResult, dependencies });
+            applySelectedMcpServer({ rootPath, statePath, state: readiness.state, selectionResult, mcpServerConfigs });
+            return;
+        }
+    }
+}
+export function getNextMcpSelection(state, serverId) {
+    const resolution = resolveSelectableMcpServerById(serverId);
+    if (!resolution.ok) {
+        return { status: 'blocked', message: resolution.message };
+    }
+    const selectedMcpServerIds = [...(state.selectedMcpServers ?? [])];
+    if (selectedMcpServerIds.includes(resolution.resolved.server.id)) {
+        return { status: 'noop', message: `${resolution.resolved.server.name} is already selected.` };
+    }
+    return {
+        status: 'selected',
+        serverName: resolution.resolved.server.name,
+        selectedMcpServers: [...selectedMcpServerIds, resolution.resolved.server.id].map(getMcpServerById),
+    };
+}
+async function getNextMcpServerConfigs({ state, selectionResult, dependencies, }) {
+    if (!selectionResult.selectedMcpServers.some((server) => server.id === 'notion') || state.selectedMcpServers?.includes('notion')) {
+        return state.mcpServerConfigs;
+    }
+    const docsParentPage = await dependencies.askForNotionDocsParentPage();
+    return {
+        ...state.mcpServerConfigs,
+        notion: { docsParentPage },
+    };
+}
+function applySelectedMcpServer({ rootPath, statePath, state, selectionResult, mcpServerConfigs, }) {
+    const selectedAgents = getSelectedAgentsFromState(state);
+    const selectedLanguageSkills = getSelectedLanguageSkillsFromState(state);
+    const selectedFrameworkSkills = getSelectedFrameworkSkillsFromState(state);
+    const selectedArchitectureSkill = getSelectedArchitectureSkillFromState(state);
+    const currentWorkflowSkills = getSelectedWorkflowSkillsFromState(state);
+    const impliedWorkflowSkills = getWorkflowSkillsImpliedByMcpServers(selectionResult.selectedMcpServers.map((server) => server.id));
+    const selectedWorkflowSkills = mergeWorkflowSkills(currentWorkflowSkills, impliedWorkflowSkills);
+    const selectedDatabaseSkills = getSelectedDatabaseSkillsFromState(state);
+    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, currentWorkflowSkills, selectedDatabaseSkills, getSelectedMcpServersFromState(state));
+    const targets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectionResult.selectedMcpServers);
+    const affectedTargets = getAffectedTargets(previousTargets, targets);
+    const preflightError = getMcpUsePreflightError({ rootPath, state, affectedTargets, previousTargets });
+    if (preflightError) {
+        log.error(preflightError);
+        log.info('Run `sibu sync` to review workflow state before selecting an MCP server.');
+        process.exitCode = 1;
+        return;
+    }
+    const agentsTarget = targets.find((target) => target.label === 'AGENTS.md');
+    if (!agentsTarget) {
+        throw new Error('AGENTS.md target is missing from workflow targets.');
+    }
+    const nonAgentTargets = affectedTargets.filter((target) => target.label !== 'AGENTS.md');
+    const files = renderMissingWorkflowFiles({
+        missingTargets: nonAgentTargets,
+        selectedLanguageSkills,
+        selectedFrameworkSkills,
+        selectedArchitectureSkill,
+        selectedWorkflowSkills,
+        selectedDatabaseSkills,
+        selectedMcpServers: selectionResult.selectedMcpServers,
+    });
+    for (const file of files) {
+        const fileAlreadyExists = fs.existsSync(file.targetPath);
+        fs.mkdirSync(path.dirname(file.targetPath), { recursive: true });
+        fs.writeFileSync(file.targetPath, file.contents, fileAlreadyExists ? 'utf8' : { encoding: 'utf8', flag: 'wx' });
+        log.success(`${fileAlreadyExists ? 'Updated' : 'Created'} ${file.label}`);
+    }
+    if (affectedTargets.some((target) => target.label === 'AGENTS.md')) {
+        const agentsContents = renderTemplateForSync({
+            templateRelativePath: agentsTarget.templateRelativePath,
+            currentPath: agentsTarget.targetPath,
+            selectedLanguageSkills,
+            selectedFrameworkSkills,
+            selectedArchitectureSkill,
+            selectedWorkflowSkills,
+            selectedDatabaseSkills,
+            selectedMcpServers: selectionResult.selectedMcpServers,
+        });
+        fs.writeFileSync(agentsTarget.targetPath, agentsContents, 'utf8');
+        log.success('Updated AGENTS.md skill routing');
+    }
+    writeSibuState({
+        rootPath,
+        statePath,
+        selectedAgents,
+        selectedLanguageSkills,
+        selectedFrameworkSkills,
+        selectedArchitectureSkill,
+        selectedWorkflowSkills,
+        selectedDatabaseSkills,
+        selectedMcpServers: selectionResult.selectedMcpServers,
+        mcpServerConfigs,
+        targets,
+    });
+    log.success(`Updated ${STATE_RELATIVE_PATH}`);
+    log.success(`Added ${selectionResult.serverName}.`);
+    for (const skill of impliedWorkflowSkills.filter((skill) => !currentWorkflowSkills.some((currentSkill) => currentSkill.id === skill.id))) {
+        log.success(`Added ${skill.name}.`);
+    }
+    log.info('Sibu configured MCP files only; prerequisites, credentials, and provider authentication remain user-owned.');
+}
+function getAffectedTargets(previousTargets, targets) {
+    const previousTargetPaths = new Set(previousTargets.map((target) => target.targetPath));
+    const newTargets = targets.filter((target) => !previousTargetPaths.has(target.targetPath) && (target.targetKind === 'skill' || target.targetKind === 'mcp-config'));
+    const mcpConfigTargets = targets.filter((target) => target.mcpConfigAgentId);
+    const agentsTarget = targets.find((target) => target.label === 'AGENTS.md');
+    const affectedTargets = new Map();
+    for (const target of [...mcpConfigTargets, ...newTargets, ...(newTargets.some((target) => target.targetKind === 'skill') && agentsTarget ? [agentsTarget] : [])]) {
+        affectedTargets.set(target.targetPath, target);
+    }
+    return [...affectedTargets.values()];
+}
+function mergeWorkflowSkills(...skillGroups) {
+    const skillsById = new Map();
+    for (const skill of skillGroups.flat()) {
+        skillsById.set(skill.id, skill);
+    }
+    return [...skillsById.values()];
+}
+function getMcpUsePreflightError({ rootPath, state, affectedTargets, previousTargets, }) {
+    const previousTargetPaths = new Set(previousTargets.map((target) => target.targetPath));
+    for (const target of affectedTargets) {
+        const relativePath = path.relative(rootPath, target.targetPath);
+        if (previousTargetPaths.has(target.targetPath)) {
+            const managedFile = state.managedFiles[relativePath];
+            if (!managedFile) {
+                return `${relativePath} is not recorded in ${STATE_RELATIVE_PATH}.`;
+            }
+            if (!fs.existsSync(target.targetPath)) {
+                return `${relativePath} is missing.`;
+            }
+            const currentHash = sha256(fs.readFileSync(target.targetPath, 'utf8'));
+            if (currentHash !== managedFile.sha256) {
+                return `${relativePath} has changed since Sibu last recorded it.`;
+            }
+            continue;
+        }
+        if (fs.existsSync(target.targetPath)) {
+            return `${relativePath} already exists but is not recorded for this MCP selection.`;
+        }
+    }
+    return undefined;
+}
+function getMcpServerById(serverId) {
+    const resolution = resolveSelectableMcpServerById(serverId);
+    if (!resolution.ok) {
+        throw new Error(`Unsupported MCP server in state: ${serverId}`);
+    }
+    return resolution.resolved.server;
+}

package/bin/modules/workflow-configuration-manager/use-skill/command.js

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