@juancr11/sibu 0.7.0 → 0.8.0

package/bin/modules/interactive-guidance/index.js

@@ -1 +1 @@
-export { askForArchitectureSkill, askForFrameworkSkills, askForLanguageSkills, askForMissingFrameworkSkills, askForNewArchitectureSkill, askForNewLanguageSkills, askForProjectOverview, askForSupportedAgents, askForWorkflowSkills, renderIntro, shouldAskForNewLanguageSkills, } from './prompts.js';
+export { askForArchitectureSkill, askForDatabaseSkills, askForFrameworkSkills, askForLanguageSkills, askForMissingFrameworkSkills, askForNewArchitectureSkill, askForNewLanguageSkills, askForProjectOverview, askForSupportedAgents, askForWorkflowSkills, renderIntro, shouldAskForNewLanguageSkills, } from './prompts.js';

package/bin/modules/interactive-guidance/prompts.js

@@ -3,7 +3,7 @@ import { cancel, isCancel, multiselect, select, text } from '@clack/prompts';
 import gradient from 'gradient-string';
 import { Box, Text, render, useApp } from 'ink';
 import { useEffect } from 'react';
-import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS } from '../workflow-target-planning/index.js';
+import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS } from '../workflow-target-planning/index.js';
 const NONE_OPTION_ID = 'none';
 export async function renderIntro() {
     console.log(gradient(['#39ff14', '#00e5ff', '#9b5de5']).multiline('⧖  S I B U  ⧖'));
@@ -56,6 +56,22 @@ export async function askForFrameworkSkills() {
         cancelMessage: 'Initialization cancelled.',
     });
 }
+export async function askForDatabaseSkills() {
+    const selectedDatabaseSkillIds = await multiselect({
+        message: 'Select the database skills this project should support.',
+        required: false,
+        options: SELECTABLE_DATABASE_SKILLS.map((skill) => ({
+            value: skill.id,
+            label: skill.name,
+            hint: skill.description,
+        })),
+    });
+    if (isCancel(selectedDatabaseSkillIds)) {
+        cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    return SELECTABLE_DATABASE_SKILLS.filter((skill) => selectedDatabaseSkillIds.includes(skill.id));
+}
 async function askForFrameworkSkillSelection({ message, cancelMessage, }) {
     const selectedFrameworkSkillIds = await multiselect({
         message,

package/bin/modules/project-adoption/handler.js

@@ -4,7 +4,7 @@ import { intro, log, outro } from '@clack/prompts';
 import chalk from 'chalk';
 import { STATE_RELATIVE_PATH } from '../../shared/catalog.js';
 import { getProjectContext } from '../../shared/paths.js';
-import { askForArchitectureSkill, askForFrameworkSkills, askForLanguageSkills, askForProjectOverview, askForSupportedAgents, askForWorkflowSkills, renderIntro } from '../interactive-guidance/index.js';
+import { askForArchitectureSkill, askForDatabaseSkills, askForFrameworkSkills, askForLanguageSkills, askForProjectOverview, askForSupportedAgents, askForWorkflowSkills, renderIntro } from '../interactive-guidance/index.js';
 import { readStateForDoctor } from '../workflow-state-registry/index.js';
 import { getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../workflow-target-planning/index.js';
 export async function handleInitProject(_command) {
@@ -30,9 +30,10 @@ export async function handleInitProject(_command) {
     const selectedAgents = await askForSupportedAgents();
     const selectedLanguageSkills = await askForLanguageSkills();
     const selectedFrameworkSkills = await askForFrameworkSkills();
+    const selectedDatabaseSkills = await askForDatabaseSkills();
     const selectedArchitectureSkill = await askForArchitectureSkill();
     const selectedWorkflowSkills = await askForWorkflowSkills();
-    const targets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills);
+    const targets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
     const missingTargets = targets.filter((target) => !fs.existsSync(target.targetPath));
     log.message('I will create this project’s initial AI workflow files.');
     for (const target of targets) {
@@ -53,13 +54,14 @@ export async function handleInitProject(_command) {
         selectedFrameworkSkills,
         selectedArchitectureSkill,
         selectedWorkflowSkills,
+        selectedDatabaseSkills,
     });
     for (const file of files) {
         fs.mkdirSync(path.dirname(file.targetPath), { recursive: true });
         fs.writeFileSync(file.targetPath, file.contents, { encoding: 'utf8', flag: 'wx' });
         log.success(`Created ${file.label}`);
     }
-    writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, targets });
+    writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, targets });
     log.success(`Created ${STATE_RELATIVE_PATH}`);
     outro(chalk.green('Setup complete.'));
 }

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, 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,7 @@ export function applySyncAction({ rootPath, state, manifest, preview, action, })
                 selectedFrameworkSkills: getSelectedFrameworkSkillsFromState(nextState),
                 selectedArchitectureSkill: getSelectedArchitectureSkillFromState(nextState),
                 selectedWorkflowSkills: getSelectedWorkflowSkillsFromState(nextState),
+                selectedDatabaseSkills: getSelectedDatabaseSkillsFromState(nextState),
             });
             fs.mkdirSync(path.dirname(targetPath), { recursive: true });
             fs.writeFileSync(targetPath, contents, 'utf8');
@@ -56,6 +57,7 @@ export function applySyncAction({ rootPath, state, manifest, preview, action, })
                 selectedFrameworkSkills: getSelectedFrameworkSkillsFromState(state),
                 selectedArchitectureSkill: getSelectedArchitectureSkillFromState(state),
                 selectedWorkflowSkills: getSelectedWorkflowSkillsFromState(state),
+                selectedDatabaseSkills: getSelectedDatabaseSkillsFromState(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, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from '../workflow-target-planning/index.js';
 const ACTIONABLE_SYNC_PREVIEW_STATUSES = new Set([
     'new-template',
     'missing',
@@ -30,6 +30,7 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
     const selectedFrameworkSkills = getSelectedFrameworkSkillsFromState(state);
     const selectedArchitectureSkill = getSelectedArchitectureSkillFromState(state);
     const selectedWorkflowSkills = getSelectedWorkflowSkillsFromState(state);
+    const selectedDatabaseSkills = getSelectedDatabaseSkillsFromState(state);
     const previews = Object.entries(state.managedFiles).map(([relativePath, managedFile]) => getManagedFileSyncPreview({
         rootPath,
         manifest,
@@ -39,8 +40,9 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
         selectedFrameworkSkills,
         selectedArchitectureSkill,
         selectedWorkflowSkills,
+        selectedDatabaseSkills,
     }));
-    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills);
+    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
     for (const target of expectedTargets) {
         const relativePath = path.relative(rootPath, target.targetPath);
         if (state.managedFiles[relativePath]) {
@@ -77,7 +79,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, }) {
     if (managedFile.status === 'unmanaged') {
         return { relativePath, managedFile, status: 'unmanaged', recordedTemplateVersion: managedFile.templateVersion, changes: [] };
     }
@@ -97,6 +99,7 @@ function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFi
         selectedFrameworkSkills,
         selectedArchitectureSkill,
         selectedWorkflowSkills,
+        selectedDatabaseSkills,
     });
     const hasUpdate = hasTemplateUpdate || hasSelectionUpdate;
     const changes = hasTemplateUpdate ? template.changes : ['Refreshes generated skill routing for the current selected skills.'];
@@ -154,7 +157,7 @@ function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFi
         hasLocalFile,
     };
 }
-function hasRenderedSelectionUpdate({ relativePath, currentPath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, }) {
+function hasRenderedSelectionUpdate({ relativePath, currentPath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, }) {
     if (relativePath !== 'AGENTS.md') {
         return false;
     }
@@ -165,6 +168,7 @@ function hasRenderedSelectionUpdate({ relativePath, currentPath, managedFile, se
         selectedFrameworkSkills,
         selectedArchitectureSkill,
         selectedWorkflowSkills,
+        selectedDatabaseSkills,
     });
     return sha256(renderedContents) !== managedFile.sha256;
 }

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

@@ -18,18 +18,18 @@ 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 = [], }) {
     let contents = readTemplate(templateRelativePath);
     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);

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, 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, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from '../workflow-target-planning/index.js';
 export async function handleDoctorProject(_command) {
     await renderIntro();
     intro(chalk.cyan('Checking workflow state'));
@@ -117,6 +117,11 @@ 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 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 +130,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));
     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,8 @@ 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.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',
@@ -221,6 +236,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_WORKFLOW_SKILLS, SUPPORTED_AGENTS, resolveSelectableSkillById, } from './catalog.js';
+export { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedSkillTargetsForAgents, getSelectedWorkflowSkillsFromState, getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState, } from './workflow-targets.js';

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

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { SIBU_VERSION } from '../version-advisory/index.js';
-import { MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS, } from './index.js';
+import { MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS, } from './index.js';
 import { sha256 } from '../../shared/hash.js';
 import { removeUndefinedFields } from '../../shared/object.js';
 import { readExistingState } from '../workflow-state-registry/index.js';
@@ -18,12 +18,16 @@ export function getSelectedArchitectureSkillFromState(state) {
 export function getSelectedWorkflowSkillsFromState(state) {
     return SELECTABLE_WORKFLOW_SKILLS.filter((skill) => state.selectedWorkflowSkills?.includes(skill.id));
 }
-export function getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = []) {
+export function getSelectedDatabaseSkillsFromState(state) {
+    return SELECTABLE_DATABASE_SKILLS.filter((skill) => state.selectedDatabaseSkills?.includes(skill.id));
+}
+export function getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = []) {
     const skillTargets = new Map();
     const selectedSkills = [
         ...MANDATORY_SKILLS,
         ...selectedLanguageSkills,
         ...selectedFrameworkSkills,
+        ...selectedDatabaseSkills,
         ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []),
         ...selectedWorkflowSkills,
     ];
@@ -41,7 +45,7 @@ export function getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguag
     }
     return [...skillTargets.values()];
 }
-export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills = [], selectedFrameworkSkills = [], selectedArchitectureSkill, selectedWorkflowSkills = []) {
+export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills = [], selectedFrameworkSkills = [], selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = []) {
     return [
         {
             label: 'AGENTS.md',
@@ -62,7 +66,7 @@ export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSki
                 },
             ];
         }),
-        ...getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills).map((skillTarget) => ({
+        ...getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills).map((skillTarget) => ({
             label: skillTarget.targetRelativePath,
             targetPath: path.join(rootPath, skillTarget.targetRelativePath),
             templateRelativePath: skillTarget.templateRelativePath,
@@ -70,7 +74,7 @@ export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSki
         })),
     ];
 }
-export function renderMissingWorkflowFiles({ missingTargets, overview, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], }) {
+export function renderMissingWorkflowFiles({ missingTargets, overview, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], }) {
     return missingTargets.map((target) => {
         let contents = readTemplate(target.templateRelativePath);
         if (target.requiresProjectOverview) {
@@ -79,7 +83,7 @@ export function renderMissingWorkflowFiles({ missingTargets, overview, selectedL
             }
             contents = contents.replace('{{PROJECT_OVERVIEW}}', overview.trim());
         }
-        contents = renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills);
+        contents = renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
         return {
             label: target.label,
             targetPath: target.targetPath,
@@ -87,7 +91,7 @@ export function renderMissingWorkflowFiles({ missingTargets, overview, selectedL
         };
     });
 }
-export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], targets, }) {
+export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], targets, }) {
     const previousState = readExistingState(statePath);
     const now = new Date().toISOString();
     const manifest = readTemplateManifest();
@@ -101,6 +105,7 @@ export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLa
         selectedFrameworkSkills: selectedFrameworkSkills.map((skill) => skill.id),
         selectedArchitectureSkill: selectedArchitectureSkill?.id,
         selectedWorkflowSkills: selectedWorkflowSkills.map((skill) => skill.id),
+        selectedDatabaseSkills: selectedDatabaseSkills.map((skill) => skill.id),
         managedFiles: Object.fromEntries(targets
             .filter((target) => fs.existsSync(target.targetPath))
             .map((target) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juancr11/sibu",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "CLI for setting up a local AI-augmented development workflow.",
   "repository": {
     "type": "git",

package/templates/manifest.json

@@ -1,5 +1,5 @@
 {
-  "templateVersion": "69",
+  "templateVersion": "70",
   "templates": {
     "AGENTS.md": {
       "version": "25",
@@ -80,6 +80,13 @@
         "Adds an optional Go skill with concise, Effective Go\u2013style guidance for .go files, package APIs, interfaces, errors, receivers, concurrency, and tests."
       ]
     },
+    "skills/postgresql-expert/SKILL.md": {
+      "version": "1",
+      "description": "Selectable PostgreSQL Expert skill for practical database schema design and PostgreSQL-specific tradeoff guidance.",
+      "changes": [
+        "Adds an optional PostgreSQL Expert database skill focused on simple schema design, data integrity, migrations, access patterns, and purposeful indexing."
+      ]
+    },
     "skills/architecture/ddd-hexagonal/SKILL.md": {
       "version": "4",
       "description": "Selectable back-end architecture skill for DDD and Hexagonal Architecture.",

package/templates/skills/postgresql-expert/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: postgresql-expert
+description: Use this skill for PostgreSQL schema design, migrations, constraints, queries, indexing, and database tradeoffs when practical database judgment is needed.
+---
+
+# PostgreSQL Expert
+
+Use this skill when working with PostgreSQL database design or database-facing application changes.
+
+Apply this skill together with `clean-code`. Keep the guidance practical: prefer the simplest database design that protects data integrity and supports the application's real access patterns.
+
+## Use this skill for
+
+- designing or reviewing PostgreSQL schemas
+- planning migrations and safe schema evolution
+- choosing keys, constraints, relationships, and transactions
+- reasoning about queries, access patterns, and indexes
+- deciding whether PostgreSQL-specific features are worth using
+- reviewing database-related tradeoffs in application code
+
+## Core principles
+
+### 1. Start with the product model
+- Model the real domain concepts, not speculative future reporting or scaling needs.
+- Prefer clear table and column names that match product language.
+- Keep schemas boring until the product needs something more specialized.
+- Do not add tables, abstractions, or generic metadata columns just in case.
+
+### 2. Protect data integrity in the database
+- Use primary keys, foreign keys, `NOT NULL`, `UNIQUE`, and `CHECK` constraints when they express real invariants.
+- Prefer database-enforced integrity over relying only on application checks for durable rules.
+- Make deletion behavior explicit with appropriate foreign-key actions.
+- Use transactions when a change must succeed or fail as one unit.
+
+### 3. Evolve schemas safely
+- Treat migrations as production changes that need clear rollback or recovery thinking.
+- Prefer small, reversible migration steps for risky changes.
+- Avoid destructive changes until data has been backfilled, verified, and callers have moved over.
+- Consider lock behavior and table size before changing large production tables.
+
+### 4. Design from access patterns, not guesses
+- Understand the queries the application actually needs before optimizing.
+- Keep common reads and writes straightforward before introducing denormalization.
+- Use normalization for clarity and integrity; denormalize only for a measured or well-understood reason.
+- Explain tradeoffs when choosing between simpler schema shape and query convenience.
+
+### 5. Add indexes only when justified
+- Do not add indexes just because a column is used, foreign-keyed, or might be queried someday.
+- Add an index when there is a clear query, filtering, joining, sorting, uniqueness, or constraint need.
+- Remember that indexes speed some reads but add write cost, storage cost, and maintenance overhead.
+- Prefer a small number of purposeful indexes over broad defensive indexing.
+
+### 6. Use PostgreSQL features with restraint
+- Consider PostgreSQL capabilities such as JSONB, arrays, partial indexes, generated columns, enums, extensions, and full-text search when they simplify a real requirement.
+- Do not use PostgreSQL-specific features to appear sophisticated when standard relational modeling is clearer.
+- Be explicit about portability tradeoffs when choosing PostgreSQL-specific behavior.
+- Prefer built-in PostgreSQL capabilities before adding extra infrastructure.
+
+### 7. Keep database advice actionable
+- Tie recommendations to the schema, query, migration, or invariant at hand.
+- Say what evidence would change the recommendation, such as query plans, row counts, write volume, or latency targets.
+- When context is missing, ask for the relevant schema, migration, query, or access pattern instead of guessing.
+- Avoid broad DBA checklists unless the task is explicitly about operations or performance investigation.
+
+## Decision rule
+
+When unsure, prefer:
+1. simple schema design that matches current product needs
+2. explicit database constraints for real invariants
+3. safe, incremental migrations
+4. query-aware design over speculative optimization
+5. purposeful indexes over blanket indexing