@juancr11/sibu 0.7.0 → 0.9.0

package/bin/modules/skill-selection-management/list-skills/handler.js

@@ -1,6 +1,6 @@
 import { intro, log, outro } from '@clack/prompts';
 import chalk from 'chalk';
-import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS } from '../../workflow-target-planning/index.js';
+import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS } from '../../workflow-target-planning/index.js';
 import { getProjectContext } from '../../../shared/paths.js';
 import { renderIntro } from '../../interactive-guidance/index.js';
 import { readStateForDoctor } from '../../workflow-state-registry/index.js';
@@ -16,6 +16,7 @@ export async function handleListSkills(_command) {
     }
     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.'));
@@ -38,6 +39,15 @@ function getFrameworkSkillItems(state) {
         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,

package/bin/modules/skill-selection-management/stop-managing-file/handler.js

@@ -10,7 +10,7 @@ import { renderIntro } from '../../interactive-guidance/index.js';
 import { cloneState, readStateForDoctor, writeStateFile } from '../../workflow-state-registry/index.js';
 import { getTemplateVersion, readTemplateManifest, renderTemplateForSync } from '../../template-catalog-rendering/index.js';
 import { removeUndefinedFields } from '../../../shared/object.js';
-import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, } from '../../workflow-target-planning/index.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, } from '../../workflow-target-planning/index.js';
 export async function handleStopManagingFile({ skillName }) {
     await renderIntro();
     intro(chalk.cyan('Updating skill management'));
@@ -110,6 +110,8 @@ function isSkillSelected(state, resolved) {
             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;
     }
@@ -125,6 +127,9 @@ function removeSelectedSkill(state, resolved) {
         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;
@@ -168,6 +173,7 @@ function getAgentsUpdate(rootPath, state) {
             selectedFrameworkSkills: getSelectedFrameworkSkillsFromState(state),
             selectedArchitectureSkill: getSelectedArchitectureSkillFromState(state),
             selectedWorkflowSkills: getSelectedWorkflowSkillsFromState(state),
+            selectedDatabaseSkills: getSelectedDatabaseSkillsFromState(state),
         }),
     };
 }

package/bin/modules/skill-selection-management/use-skill/handler.js

@@ -46,6 +46,7 @@ export function getNextSkillSelection(state, skillName) {
     const selectedLanguageSkills = [...(state.selectedLanguageSkills ?? [])];
     const selectedFrameworkSkills = [...(state.selectedFrameworkSkills ?? [])];
     const selectedWorkflowSkills = [...(state.selectedWorkflowSkills ?? [])];
+    const selectedDatabaseSkills = [...(state.selectedDatabaseSkills ?? [])];
     switch (resolution.resolved.kind) {
         case 'language':
             if (selectedLanguageSkills.includes(resolution.resolved.skill.id)) {
@@ -59,6 +60,7 @@ export function getNextSkillSelection(state, skillName) {
                     selectedFrameworkSkills: selectedFrameworkSkills.map(getFrameworkSkillById),
                     selectedArchitectureSkill: getArchitectureSkillById(state.selectedArchitectureSkill),
                     selectedWorkflowSkills: selectedWorkflowSkills.map(getWorkflowSkillById),
+                    selectedDatabaseSkills: selectedDatabaseSkills.map(getDatabaseSkillById),
                 },
             };
         case 'framework':
@@ -73,6 +75,7 @@ export function getNextSkillSelection(state, skillName) {
                     selectedFrameworkSkills: [...selectedFrameworkSkills, resolution.resolved.skill.id].map(getFrameworkSkillById),
                     selectedArchitectureSkill: getArchitectureSkillById(state.selectedArchitectureSkill),
                     selectedWorkflowSkills: selectedWorkflowSkills.map(getWorkflowSkillById),
+                    selectedDatabaseSkills: selectedDatabaseSkills.map(getDatabaseSkillById),
                 },
             };
         case 'architecture':
@@ -94,6 +97,22 @@ export function getNextSkillSelection(state, skillName) {
                     selectedFrameworkSkills: selectedFrameworkSkills.map(getFrameworkSkillById),
                     selectedArchitectureSkill: resolution.resolved.skill,
                     selectedWorkflowSkills: selectedWorkflowSkills.map(getWorkflowSkillById),
+                    selectedDatabaseSkills: selectedDatabaseSkills.map(getDatabaseSkillById),
+                },
+            };
+        case 'database':
+            if (selectedDatabaseSkills.includes(resolution.resolved.skill.id)) {
+                return { status: 'noop', message: `${resolution.resolved.skill.name} is already selected.` };
+            }
+            return {
+                status: 'selected',
+                skillName: resolution.resolved.skill.name,
+                selection: {
+                    selectedLanguageSkills: selectedLanguageSkills.map(getLanguageSkillById),
+                    selectedFrameworkSkills: selectedFrameworkSkills.map(getFrameworkSkillById),
+                    selectedArchitectureSkill: getArchitectureSkillById(state.selectedArchitectureSkill),
+                    selectedWorkflowSkills: selectedWorkflowSkills.map(getWorkflowSkillById),
+                    selectedDatabaseSkills: [...selectedDatabaseSkills, resolution.resolved.skill.id].map(getDatabaseSkillById),
                 },
             };
         case 'workflow':
@@ -108,6 +127,7 @@ export function getNextSkillSelection(state, skillName) {
                     selectedFrameworkSkills: selectedFrameworkSkills.map(getFrameworkSkillById),
                     selectedArchitectureSkill: getArchitectureSkillById(state.selectedArchitectureSkill),
                     selectedWorkflowSkills: [...selectedWorkflowSkills, resolution.resolved.skill.id].map(getWorkflowSkillById),
+                    selectedDatabaseSkills: selectedDatabaseSkills.map(getDatabaseSkillById),
                 },
             };
     }
@@ -128,12 +148,14 @@ function applySelectedSkill({ rootPath, statePath, state, selectionResult, }) {
         selectedFrameworkSkills: selectionResult.selection.selectedFrameworkSkills,
         selectedArchitectureSkill: selectionResult.selection.selectedArchitectureSkill,
         selectedWorkflowSkills: selectionResult.selection.selectedWorkflowSkills,
+        selectedDatabaseSkills: selectionResult.selection.selectedDatabaseSkills,
     });
     const [newSkillFile] = renderMissingWorkflowFiles({
         missingTargets: [plan.newSkillTarget],
         selectedLanguageSkills: selectionResult.selection.selectedLanguageSkills,
         selectedFrameworkSkills: selectionResult.selection.selectedFrameworkSkills,
         selectedArchitectureSkill: selectionResult.selection.selectedArchitectureSkill,
+        selectedDatabaseSkills: selectionResult.selection.selectedDatabaseSkills,
     });
     fs.mkdirSync(path.dirname(newSkillFile.targetPath), { recursive: true });
     fs.writeFileSync(newSkillFile.targetPath, newSkillFile.contents, { encoding: 'utf8', flag: 'wx' });
@@ -148,6 +170,7 @@ function applySelectedSkill({ rootPath, statePath, state, selectionResult, }) {
         selectedFrameworkSkills: selectionResult.selection.selectedFrameworkSkills,
         selectedArchitectureSkill: selectionResult.selection.selectedArchitectureSkill,
         selectedWorkflowSkills: selectionResult.selection.selectedWorkflowSkills,
+        selectedDatabaseSkills: selectionResult.selection.selectedDatabaseSkills,
         targets: plan.targets,
     });
     log.success(`Updated ${STATE_RELATIVE_PATH}`);
@@ -155,8 +178,8 @@ function applySelectedSkill({ rootPath, statePath, state, selectionResult, }) {
 }
 function buildSkillApplicationPlan({ rootPath, state, selectionResult, }) {
     const selectedAgents = getSelectedAgentsFromState(state);
-    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, getSelectedLanguageSkillsFromState(state), getSelectedFrameworkSkillsFromState(state), getArchitectureSkillById(state.selectedArchitectureSkill), getSelectedWorkflowSkillsFromState(state));
-    const targets = getWorkflowTargets(rootPath, selectedAgents, selectionResult.selection.selectedLanguageSkills, selectionResult.selection.selectedFrameworkSkills, selectionResult.selection.selectedArchitectureSkill, selectionResult.selection.selectedWorkflowSkills);
+    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, getSelectedLanguageSkillsFromState(state), getSelectedFrameworkSkillsFromState(state), getArchitectureSkillById(state.selectedArchitectureSkill), getSelectedWorkflowSkillsFromState(state), getSelectedDatabaseSkillsFromState(state));
+    const targets = getWorkflowTargets(rootPath, selectedAgents, selectionResult.selection.selectedLanguageSkills, selectionResult.selection.selectedFrameworkSkills, selectionResult.selection.selectedArchitectureSkill, selectionResult.selection.selectedWorkflowSkills, selectionResult.selection.selectedDatabaseSkills);
     const previousTargetPaths = new Set(previousTargets.map((target) => target.targetPath));
     const newSkillTarget = targets.find((target) => !previousTargetPaths.has(target.targetPath));
     const agentsTarget = targets.find((target) => target.label === 'AGENTS.md');
@@ -195,6 +218,9 @@ function getSelectedFrameworkSkillsFromState(state) {
 function getSelectedWorkflowSkillsFromState(state) {
     return (state.selectedWorkflowSkills ?? []).map(getWorkflowSkillById);
 }
+function getSelectedDatabaseSkillsFromState(state) {
+    return (state.selectedDatabaseSkills ?? []).map(getDatabaseSkillById);
+}
 function getLanguageSkillById(skillId) {
     const resolution = resolveSelectableSkillById(skillId);
     if (!resolution.ok || resolution.resolved.kind !== 'language') {
@@ -226,3 +252,10 @@ function getWorkflowSkillById(skillId) {
     }
     return resolution.resolved.skill;
 }
+function getDatabaseSkillById(skillId) {
+    const resolution = resolveSelectableSkillById(skillId);
+    if (!resolution.ok || resolution.resolved.kind !== 'database') {
+        throw new Error(`Unsupported database skill in state: ${skillId}`);
+    }
+    return resolution.resolved.skill;
+}

package/bin/modules/sync-review/apply-action.js

@@ -5,7 +5,7 @@ import { sha256 } from '../../shared/hash.js';
 import { getSideTemplatePath } from '../../shared/paths.js';
 import { cloneState } from '../workflow-state-registry/index.js';
 import { getTemplateVersion, renderTemplateForSync } from '../template-catalog-rendering/index.js';
-import { getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, } from '../workflow-target-planning/index.js';
+import { getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, } from '../workflow-target-planning/index.js';
 export function applySyncAction({ rootPath, state, manifest, preview, action, }) {
     const nextState = cloneState(state);
     const managedFile = nextState.managedFiles[preview.relativePath] ?? preview.managedFile;
@@ -20,6 +20,8 @@ export function applySyncAction({ rootPath, state, manifest, preview, action, })
                 selectedFrameworkSkills: getSelectedFrameworkSkillsFromState(nextState),
                 selectedArchitectureSkill: getSelectedArchitectureSkillFromState(nextState),
                 selectedWorkflowSkills: getSelectedWorkflowSkillsFromState(nextState),
+                selectedDatabaseSkills: getSelectedDatabaseSkillsFromState(nextState),
+                selectedMcpServers: getSelectedMcpServersFromState(nextState),
             });
             fs.mkdirSync(path.dirname(targetPath), { recursive: true });
             fs.writeFileSync(targetPath, contents, 'utf8');
@@ -56,6 +58,8 @@ export function applySyncAction({ rootPath, state, manifest, preview, action, })
                 selectedFrameworkSkills: getSelectedFrameworkSkillsFromState(state),
                 selectedArchitectureSkill: getSelectedArchitectureSkillFromState(state),
                 selectedWorkflowSkills: getSelectedWorkflowSkillsFromState(state),
+                selectedDatabaseSkills: getSelectedDatabaseSkillsFromState(state),
+                selectedMcpServers: getSelectedMcpServersFromState(state),
             });
             fs.mkdirSync(path.dirname(sideTemplatePath), { recursive: true });
             fs.writeFileSync(sideTemplatePath, contents, 'utf8');

package/bin/modules/sync-review/sync-preview.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { sha256 } from '../../shared/hash.js';
 import { hasReviewedTemplateVersion } from '../workflow-state-registry/index.js';
 import { renderTemplateForSync } from '../template-catalog-rendering/index.js';
-import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from '../workflow-target-planning/index.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from '../workflow-target-planning/index.js';
 const ACTIONABLE_SYNC_PREVIEW_STATUSES = new Set([
     'new-template',
     'missing',
@@ -30,6 +30,8 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
     const selectedFrameworkSkills = getSelectedFrameworkSkillsFromState(state);
     const selectedArchitectureSkill = getSelectedArchitectureSkillFromState(state);
     const selectedWorkflowSkills = getSelectedWorkflowSkillsFromState(state);
+    const selectedDatabaseSkills = getSelectedDatabaseSkillsFromState(state);
+    const selectedMcpServers = getSelectedMcpServersFromState(state);
     const previews = Object.entries(state.managedFiles).map(([relativePath, managedFile]) => getManagedFileSyncPreview({
         rootPath,
         manifest,
@@ -39,8 +41,10 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
         selectedFrameworkSkills,
         selectedArchitectureSkill,
         selectedWorkflowSkills,
+        selectedDatabaseSkills,
+        selectedMcpServers,
     }));
-    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills);
+    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectedMcpServers);
     for (const target of expectedTargets) {
         const relativePath = path.relative(rootPath, target.targetPath);
         if (state.managedFiles[relativePath]) {
@@ -77,7 +81,7 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
     }
     return previews;
 }
-function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, }) {
+function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectedMcpServers, }) {
     if (managedFile.status === 'unmanaged') {
         return { relativePath, managedFile, status: 'unmanaged', recordedTemplateVersion: managedFile.templateVersion, changes: [] };
     }
@@ -97,9 +101,11 @@ function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFi
         selectedFrameworkSkills,
         selectedArchitectureSkill,
         selectedWorkflowSkills,
+        selectedDatabaseSkills,
+        selectedMcpServers,
     });
     const hasUpdate = hasTemplateUpdate || hasSelectionUpdate;
-    const changes = hasTemplateUpdate ? template.changes : ['Refreshes generated skill routing for the current selected skills.'];
+    const changes = hasTemplateUpdate ? template.changes : [getSelectionRefreshChange(managedFile.template)];
     if (!hasLocalFile) {
         return {
             relativePath,
@@ -154,8 +160,14 @@ function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFi
         hasLocalFile,
     };
 }
-function hasRenderedSelectionUpdate({ relativePath, currentPath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, }) {
-    if (relativePath !== 'AGENTS.md') {
+function getSelectionRefreshChange(templateRelativePath) {
+    if (templateRelativePath === '.codex/config.toml' || templateRelativePath === 'mcp/claude/.mcp.json' || templateRelativePath === 'mcp/gemini/settings.json') {
+        return 'Refreshes generated MCP configuration for the current selected MCP servers.';
+    }
+    return 'Refreshes generated skill routing for the current selected skills.';
+}
+function hasRenderedSelectionUpdate({ relativePath, currentPath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectedMcpServers, }) {
+    if (relativePath !== 'AGENTS.md' && selectedMcpServers.length === 0) {
         return false;
     }
     const renderedContents = renderTemplateForSync({
@@ -165,6 +177,8 @@ function hasRenderedSelectionUpdate({ relativePath, currentPath, managedFile, se
         selectedFrameworkSkills,
         selectedArchitectureSkill,
         selectedWorkflowSkills,
+        selectedDatabaseSkills,
+        selectedMcpServers,
     });
     return sha256(renderedContents) !== managedFile.sha256;
 }

package/bin/modules/template-catalog-rendering/index.js

@@ -1 +1 @@
-export { extractProjectOverview, getTemplateVersion, readTemplate, readTemplateManifest, renderSkillRouting, renderTemplateForSync, } from './templates.js';
+export { extractProjectOverview, getTemplateVersion, readTemplate, readTemplateManifest, renderMcpConfig, renderSkillRouting, renderTemplateForSync, } from './templates.js';

package/bin/modules/template-catalog-rendering/templates.js

@@ -18,22 +18,38 @@ export function getTemplateVersion(manifest, templateRelativePath) {
     }
     return template.version;
 }
-export function renderTemplateForSync({ templateRelativePath, currentPath, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], }) {
+export function renderTemplateForSync({ templateRelativePath, currentPath, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], selectedMcpServers = [], }) {
     let contents = readTemplate(templateRelativePath);
+    const mcpConfigAgentId = getMcpConfigAgentId(templateRelativePath);
+    if (mcpConfigAgentId) {
+        return renderMcpConfig({ agentId: mcpConfigAgentId, baseContents: contents, selectedMcpServers });
+    }
     if (contents.includes('{{PROJECT_OVERVIEW}}')) {
         contents = contents.replace('{{PROJECT_OVERVIEW}}', extractProjectOverview(currentPath) ?? 'Describe this project.');
     }
-    return renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills);
+    return renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
 }
-export function renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = []) {
+export function renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = []) {
     if (!contents.includes('{{OPTIONAL_SKILL_ROUTING}}')) {
         return contents;
     }
-    const optionalRouting = [...selectedLanguageSkills, ...selectedFrameworkSkills, ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []), ...selectedWorkflowSkills]
+    const optionalRouting = [...selectedLanguageSkills, ...selectedFrameworkSkills, ...selectedDatabaseSkills, ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []), ...selectedWorkflowSkills]
         .map((skill) => `- ${skill.routingInstruction}`)
         .join('\n');
     return contents.replace('{{OPTIONAL_SKILL_ROUTING}}', optionalRouting);
 }
+export function renderMcpConfig({ agentId, baseContents, selectedMcpServers, }) {
+    const githubServer = selectedMcpServers.find((server) => server.id === 'github');
+    if (!githubServer) {
+        return baseContents ?? renderJsonMcpConfig({});
+    }
+    if (agentId === 'codex') {
+        return renderCodexGithubMcpConfig(baseContents ?? '');
+    }
+    return renderJsonMcpConfig({
+        github: buildGithubMcpServerConfig(agentId),
+    });
+}
 export function extractProjectOverview(filePath) {
     if (!fs.existsSync(filePath)) {
         return undefined;
@@ -43,6 +59,45 @@ export function extractProjectOverview(filePath) {
     const overview = match?.[1]?.trim();
     return overview || undefined;
 }
+function renderCodexGithubMcpConfig(baseContents) {
+    const trimmedBaseContents = baseContents.trimEnd();
+    const separator = trimmedBaseContents ? '\n\n' : '';
+    return `${trimmedBaseContents}${separator}[mcp_servers.github]
+url = "https://api.githubcopilot.com/mcp/"
+bearer_token_env_var = "GITHUB_PERSONAL_ACCESS_TOKEN"
+`;
+}
+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';
+    }
+    return undefined;
+}
+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 renderJsonMcpConfig(mcpServers) {
+    return `${JSON.stringify({ mcpServers }, null, 2)}\n`;
+}
 function isTemplateManifest(value) {
     if (!value || typeof value !== 'object') {
         return false;

package/bin/modules/workflow-health-diagnosis/handler.js

@@ -3,14 +3,14 @@ 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 { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SUPPORTED_AGENTS } from '../workflow-target-planning/index.js';
+import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_MCP_SERVERS, SUPPORTED_AGENTS } from '../workflow-target-planning/index.js';
 import { sha256 } from '../../shared/hash.js';
 import { checkForLatestSibuVersion } from '../version-advisory/index.js';
 import { getProjectContext } from '../../shared/paths.js';
 import { renderIntro } from '../interactive-guidance/index.js';
 import { hasReviewedTemplateVersion, readStateForDoctor } from '../workflow-state-registry/index.js';
 import { getTemplateVersion, readTemplateManifest } from '../template-catalog-rendering/index.js';
-import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getWorkflowTargets, } from '../workflow-target-planning/index.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from '../workflow-target-planning/index.js';
 export async function handleDoctorProject(_command) {
     await renderIntro();
     intro(chalk.cyan('Checking workflow state'));
@@ -117,6 +117,16 @@ function addUnsupportedSelectionIssues(state, issues) {
     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 selectedDatabaseSkill of state.selectedDatabaseSkills ?? []) {
+        if (!SELECTABLE_DATABASE_SKILLS.some((skill) => skill.id === selectedDatabaseSkill)) {
+            issues.push({ severity: 'warning', message: `State references unsupported database skill: ${selectedDatabaseSkill}.` });
+        }
+    }
+    for (const selectedMcpServer of state.selectedMcpServers ?? []) {
+        if (!SELECTABLE_MCP_SERVERS.some((server) => server.id === selectedMcpServer)) {
+            issues.push({ severity: 'warning', message: `State references unsupported MCP server: ${selectedMcpServer}.` });
+        }
+    }
     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}.` });
@@ -125,7 +135,7 @@ function addUnsupportedSelectionIssues(state, issues) {
 }
 function addExpectedTargetIssues(rootPath, state, issues) {
     const reportedMissingPaths = new Set();
-    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), getSelectedLanguageSkillsFromState(state), getSelectedFrameworkSkillsFromState(state), getSelectedArchitectureSkillFromState(state));
+    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), getSelectedLanguageSkillsFromState(state), getSelectedFrameworkSkillsFromState(state), getSelectedArchitectureSkillFromState(state), getSelectedWorkflowSkillsFromState(state), getSelectedDatabaseSkillsFromState(state), getSelectedMcpServersFromState(state));
     for (const target of expectedTargets) {
         const relativePath = path.relative(rootPath, target.targetPath);
         const managedFile = state.managedFiles[relativePath];

package/bin/modules/workflow-state-registry/state.js

@@ -57,6 +57,10 @@ function isSibuState(value) {
         (state.selectedArchitectureSkill === undefined || typeof state.selectedArchitectureSkill === 'string') &&
         (state.selectedWorkflowSkills === undefined ||
             (Array.isArray(state.selectedWorkflowSkills) && state.selectedWorkflowSkills.every((skill) => typeof skill === 'string'))) &&
+        (state.selectedDatabaseSkills === undefined ||
+            (Array.isArray(state.selectedDatabaseSkills) && state.selectedDatabaseSkills.every((skill) => typeof skill === 'string'))) &&
+        (state.selectedMcpServers === undefined ||
+            (Array.isArray(state.selectedMcpServers) && state.selectedMcpServers.every((server) => typeof server === 'string'))) &&
         (state.reviewedArchitectureSkills === undefined ||
             (Array.isArray(state.reviewedArchitectureSkills) && state.reviewedArchitectureSkills.every((skill) => typeof skill === 'string'))) &&
         !!state.managedFiles &&

package/bin/modules/workflow-target-planning/catalog.js

@@ -100,6 +100,21 @@ export const SELECTABLE_LANGUAGE_SKILLS = [
         },
     },
 ];
+export const SELECTABLE_DATABASE_SKILLS = [
+    {
+        id: 'postgresql-expert',
+        name: 'PostgreSQL Expert',
+        description: 'Install practical guidance for PostgreSQL schema design, migrations, constraints, queries, indexing, and database tradeoffs',
+        routingInstruction: 'For PostgreSQL schema design, migrations, constraints, queries, indexing, or database tradeoffs, use `postgresql-expert`.',
+        templateRelativePath: 'skills/postgresql-expert/SKILL.md',
+        targetRelativePathsByAgent: {
+            codex: '.agents/skills/postgresql-expert/SKILL.md',
+            gemini: '.agents/skills/postgresql-expert/SKILL.md',
+            claude: '.agents/skills/postgresql-expert/SKILL.md',
+            windsurf: '.agents/skills/postgresql-expert/SKILL.md',
+        },
+    },
+];
 export const SELECTABLE_FRAMEWORK_SKILLS = [
     {
         id: 'react',
@@ -184,6 +199,14 @@ export const SELECTABLE_WORKFLOW_SKILLS = [
         },
     },
 ];
+export const SELECTABLE_MCP_SERVERS = [
+    {
+        id: 'github',
+        name: 'GitHub MCP Server',
+        description: "Configure GitHub's official MCP server; Sibu writes config only, while prerequisites, runtime availability, credentials, and authentication remain user-owned",
+        source: 'github/github-mcp-server',
+    },
+];
 export const SUPPORTED_AGENTS = [
     {
         id: 'codex',
@@ -212,6 +235,13 @@ export const SUPPORTED_AGENTS = [
         description: 'Use root AGENTS.md and shared .agents/skills/ discovery',
     },
 ];
+export function resolveSelectableMcpServerById(serverId) {
+    const server = SELECTABLE_MCP_SERVERS.find((selectableServer) => selectableServer.id === serverId);
+    if (server) {
+        return { ok: true, resolved: { server } };
+    }
+    return { ok: false, message: `Unknown MCP server \`${serverId}\`. Run \`sibu mcp list\` to see available MCP servers.` };
+}
 export function resolveSelectableSkillById(skillId) {
     const languageSkill = SELECTABLE_LANGUAGE_SKILLS.find((skill) => skill.id === skillId);
     if (languageSkill) {
@@ -221,6 +251,10 @@ export function resolveSelectableSkillById(skillId) {
     if (frameworkSkill) {
         return { ok: true, resolved: { kind: 'framework', skill: frameworkSkill } };
     }
+    const databaseSkill = SELECTABLE_DATABASE_SKILLS.find((skill) => skill.id === skillId);
+    if (databaseSkill) {
+        return { ok: true, resolved: { kind: 'database', skill: databaseSkill } };
+    }
     const architectureSkill = SELECTABLE_ARCHITECTURE_SKILLS.find((skill) => skill.id === skillId);
     if (architectureSkill) {
         return { ok: true, resolved: { kind: 'architecture', skill: architectureSkill } };

package/bin/modules/workflow-target-planning/index.js

@@ -1,2 +1,2 @@
-export { MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS, resolveSelectableSkillById, } from './catalog.js';
-export { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedSkillTargetsForAgents, getSelectedWorkflowSkillsFromState, getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState, } from './workflow-targets.js';
+export { MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_MCP_SERVERS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS, resolveSelectableMcpServerById, resolveSelectableSkillById, } from './catalog.js';
+export { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedMcpTargetsForAgents, getSelectedSkillTargetsForAgents, getSelectedWorkflowSkillsFromState, getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState, } from './workflow-targets.js';