@juancr11/sibu 0.17.0 → 0.17.1

package/bin/modules/{template-catalog-rendering → template-catalog}/templates.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { getTemplatesPath } from '../../shared/paths.js';
+import { renderMcpConfig, resolveMcpConfigAgentId } from '../agent-tool-configuration/index.js';
 export function readTemplate(relativePath) {
     return fs.readFileSync(path.join(getTemplatesPath(), relativePath), 'utf8');
 }
@@ -18,9 +19,24 @@ export function getTemplateVersion(manifest, templateRelativePath) {
     }
     return template.version;
 }
+function isTemplateManifest(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const manifest = value;
+    return (typeof manifest.templateVersion === 'string' &&
+        !!manifest.templates &&
+        typeof manifest.templates === 'object' &&
+        Object.values(manifest.templates).every((template) => !!template &&
+            typeof template === 'object' &&
+            typeof template.version === 'string' &&
+            typeof template.description === 'string' &&
+            Array.isArray(template.changes) &&
+            template.changes.every((change) => typeof change === 'string')));
+}
 export function renderTemplateForSync({ templateRelativePath, currentPath, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], selectedMcpServers = [], }) {
     let contents = readTemplate(templateRelativePath);
-    const mcpConfigAgentId = getMcpConfigAgentId(templateRelativePath);
+    const mcpConfigAgentId = resolveMcpConfigAgentId(templateRelativePath);
     if (mcpConfigAgentId) {
         return renderMcpConfig({ agentId: mcpConfigAgentId, baseContents: contents, selectedMcpServers });
     }
@@ -31,6 +47,31 @@ export function renderTemplateForSync({ templateRelativePath, currentPath, selec
     contents = renderWorkerToolboxRoutingPlaceholders(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
     return contents;
 }
+export function renderMissingWorkflowFiles({ missingTargets, overview, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], selectedMcpServers = [], }) {
+    return missingTargets.map((target) => {
+        let contents = readTemplate(target.templateRelativePath);
+        if (target.mcpConfigAgentId && (target.selectedMcpServers?.length || selectedMcpServers.length)) {
+            contents = renderMcpConfig({
+                agentId: target.mcpConfigAgentId,
+                baseContents: contents,
+                selectedMcpServers: target.selectedMcpServers ?? selectedMcpServers,
+            });
+        }
+        if (target.requiresProjectOverview) {
+            if (!overview?.trim()) {
+                throw new Error('Project overview is required to create AGENTS.md.');
+            }
+            contents = contents.replace('{{PROJECT_OVERVIEW}}', overview.trim());
+        }
+        contents = renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
+        contents = renderWorkerToolboxRoutingPlaceholders(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
+        return {
+            label: target.label,
+            targetPath: target.targetPath,
+            contents,
+        };
+    });
+}
 export function renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = []) {
     if (!contents.includes('{{OPTIONAL_SKILL_ROUTING}}')) {
         return contents;
@@ -85,15 +126,6 @@ export function renderWorkerToolboxRoutingPlaceholders(contents, selectedLanguag
     }
     return renderedContents;
 }
-export function renderMcpConfig({ agentId, baseContents, selectedMcpServers, }) {
-    if (selectedMcpServers.length === 0) {
-        return baseContents ?? renderJsonMcpConfig({});
-    }
-    if (agentId === 'codex') {
-        return renderCodexMcpConfig(baseContents ?? '', selectedMcpServers);
-    }
-    return renderJsonMcpConfig(buildJsonMcpServerConfigs(agentId, selectedMcpServers), baseContents);
-}
 function collectWorkerRelevantSkills({ selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, }) {
     const implementationRelevantWorkflowSkills = selectedWorkflowSkills.filter((skill) => skill.id === 'ai-prompt-engineer-master' || skill.id === 'ux-expert');
     return [
@@ -120,108 +152,3 @@ export function extractProjectOverview(filePath) {
     const overview = match?.[1]?.trim();
     return overview || undefined;
 }
-function renderCodexMcpConfig(baseContents, selectedMcpServers) {
-    const trimmedBaseContents = baseContents.trimEnd();
-    const serverConfigs = selectedMcpServers.map((server) => buildCodexMcpServerConfig(server)).filter((config) => config.length > 0);
-    if (serverConfigs.length === 0) {
-        return baseContents;
-    }
-    const separator = trimmedBaseContents ? '\n\n' : '';
-    return `${trimmedBaseContents}${separator}${serverConfigs.join('\n\n')}\n`;
-}
-function buildCodexMcpServerConfig(server) {
-    if (server.id === 'github') {
-        return `[mcp_servers.github]
-url = "https://api.githubcopilot.com/mcp/"
-bearer_token_env_var = "GITHUB_PERSONAL_ACCESS_TOKEN"
-
-[mcp_servers.github.tools.issue_write]
-approval_mode = "approve"
-
-[mcp_servers.github.tools.sub_issue_write]
-approval_mode = "approve"`;
-    }
-    if (server.id === 'notion') {
-        return `[mcp_servers.notion]
-url = "https://mcp.notion.com/mcp"`;
-    }
-    return '';
-}
-function getMcpConfigAgentId(templateRelativePath) {
-    if (templateRelativePath === '.codex/config.toml') {
-        return 'codex';
-    }
-    if (templateRelativePath === 'mcp/claude/.mcp.json') {
-        return 'claude';
-    }
-    if (templateRelativePath === 'mcp/gemini/settings.json') {
-        return 'gemini';
-    }
-    if (templateRelativePath === '.gemini/settings.json') {
-        return 'gemini';
-    }
-    return undefined;
-}
-function buildJsonMcpServerConfigs(agentId, selectedMcpServers) {
-    const mcpServers = {};
-    for (const server of selectedMcpServers) {
-        if (server.id === 'github') {
-            mcpServers.github = buildGithubMcpServerConfig(agentId);
-        }
-        if (server.id === 'notion') {
-            mcpServers.notion = buildNotionMcpServerConfig();
-        }
-    }
-    return mcpServers;
-}
-function buildGithubMcpServerConfig(agentId) {
-    const headers = {
-        Authorization: 'Bearer ${GITHUB_PERSONAL_ACCESS_TOKEN}',
-    };
-    if (agentId === 'gemini') {
-        return {
-            httpUrl: 'https://api.githubcopilot.com/mcp/',
-            headers,
-        };
-    }
-    return {
-        type: 'http',
-        url: 'https://api.githubcopilot.com/mcp/',
-        headers,
-    };
-}
-function buildNotionMcpServerConfig() {
-    return {
-        url: 'https://mcp.notion.com/mcp',
-    };
-}
-function renderJsonMcpConfig(mcpServers, baseContents) {
-    const baseConfig = parseJsonObject(baseContents);
-    baseConfig.mcpServers = mcpServers;
-    return `${JSON.stringify(baseConfig, null, 2)}\n`;
-}
-function parseJsonObject(contents) {
-    if (!contents?.trim()) {
-        return {};
-    }
-    const parsed = JSON.parse(contents);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error('Expected JSON template to contain an object.');
-    }
-    return parsed;
-}
-function isTemplateManifest(value) {
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    const manifest = value;
-    return (typeof manifest.templateVersion === 'string' &&
-        !!manifest.templates &&
-        typeof manifest.templates === 'object' &&
-        Object.values(manifest.templates).every((template) => !!template &&
-            typeof template === 'object' &&
-            typeof template.version === 'string' &&
-            typeof template.description === 'string' &&
-            Array.isArray(template.changes) &&
-            template.changes.every((change) => typeof change === 'string')));
-}

package/bin/modules/workflow-configuration-manager/index.js

@@ -0,0 +1,6 @@
+export { handleListSkills } from './list-skills/handler.js';
+export { getNextSkillSelection, handleUseSkill } from './use-skill/handler.js';
+export { handleStopManagingFile, stopSelectedSkill } from './stop-managing-file/handler.js';
+export { getMcpServerListItems, handleListMcpServers } from './list-mcp-servers/handler.js';
+export { getNextMcpSelection, handleUseMcpServer } from './use-mcp-server/handler.js';
+export { applyStoppedMcpFileDeleteDecision, getNextStoppedMcpSelection, handleStopMcpServer, stopSelectedMcpServer } from './stop-mcp-server/handler.js';

package/bin/modules/workflow-configuration-manager/list-mcp-servers/handler.js

@@ -0,0 +1,46 @@
+import { intro, log, outro } from '@clack/prompts';
+import chalk from 'chalk';
+import { SELECTABLE_MCP_SERVERS } from '../../template-catalog/index.js';
+import { getProjectContext } from '../../../shared/paths.js';
+import { renderIntro } from '../../../support/interactive-guidance/index.js';
+import { readStateForDoctor } from '../../workflow-state-ledger/index.js';
+const defaultDependencies = {
+    renderIntro,
+    intro,
+    logMessage: log.message,
+    logWarn: log.warn,
+    logInfo: log.info,
+    outro,
+    getStatePath: () => getProjectContext().statePath,
+    readState: readStateForDoctor,
+};
+export async function handleListMcpServers(_command, dependencies = defaultDependencies) {
+    await dependencies.renderIntro();
+    dependencies.intro(chalk.cyan('Available MCP servers'));
+    const statePath = dependencies.getStatePath();
+    const stateResult = dependencies.readState(statePath);
+    const state = stateResult.ok ? stateResult.state : undefined;
+    if (!stateResult.ok) {
+        dependencies.logWarn(`${stateResult.message} Showing available MCP servers without project state.`);
+        dependencies.logInfo('Run `sibu init` before selecting project MCP servers.');
+    }
+    dependencies.logInfo('Sibu configures MCP files only; prerequisites, credentials, and provider authentication remain user-owned.');
+    dependencies.logMessage(chalk.bold('MCP servers'));
+    for (const server of getMcpServerListItems(state)) {
+        const marker = server.selected ? chalk.green('● selected') : chalk.dim('○ available');
+        console.log(`  ${marker} ${chalk.bold(server.name)} ${chalk.dim(`(${server.id})`)}`);
+        console.log(`    ${chalk.dim(server.description)}`);
+        console.log(`    ${chalk.dim(`Source: ${server.source}`)}`);
+    }
+    dependencies.outro(chalk.green('MCP server list ready.'));
+}
+export function getMcpServerListItems(state) {
+    const selectedServerIds = new Set(state?.selectedMcpServers ?? []);
+    return SELECTABLE_MCP_SERVERS.map((server) => ({
+        name: server.name,
+        id: server.id,
+        description: server.description,
+        source: server.source,
+        selected: selectedServerIds.has(server.id),
+    }));
+}

package/bin/modules/workflow-configuration-manager/list-skills/command.js

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

package/bin/modules/workflow-configuration-manager/list-skills/handler.js

@@ -0,0 +1,75 @@
+import { intro, log, outro } from '@clack/prompts';
+import chalk from 'chalk';
+import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS } from '../../template-catalog/index.js';
+import { getProjectContext } from '../../../shared/paths.js';
+import { renderIntro } from '../../../support/interactive-guidance/index.js';
+import { readStateForDoctor } from '../../workflow-state-ledger/index.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('Databases', getDatabaseSkillItems(state));
+    logSkillGroup('Architecture', getArchitectureSkillItems(state));
+    logSkillGroup('Workflow', getWorkflowSkillItems(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 getDatabaseSkillItems(state) {
+    const selectedSkillIds = new Set(state?.selectedDatabaseSkills ?? []);
+    return SELECTABLE_DATABASE_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 getWorkflowSkillItems(state) {
+    const selectedSkillIds = new Set(state?.selectedWorkflowSkills ?? []);
+    return SELECTABLE_WORKFLOW_SKILLS.map((skill) => ({
+        name: skill.name,
+        id: skill.id,
+        description: skill.description,
+        selected: selectedSkillIds.has(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/modules/workflow-configuration-manager/stop-managing-file/command.js

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

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 {};