@juancr11/sibu 0.6.0 → 0.8.0

package/bin/modules/skill-selection-management/index.js

@@ -0,0 +1,3 @@
+export { handleListSkills } from './list-skills/handler.js';
+export { getNextSkillSelection, handleUseSkill } from './use-skill/handler.js';
+export { handleStopManagingFile, stopSelectedSkill } from './stop-managing-file/handler.js';

package/bin/{features → modules/skill-selection-management}/list-skills/handler.js

@@ -1,9 +1,9 @@
 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 '../../shared/catalog.js';
-import { getProjectContext } from '../../shared/paths.js';
-import { renderIntro } from '../../shared/prompts.js';
-import { readStateForDoctor } from '../../shared/state.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';
 export async function handleListSkills(_command) {
     await renderIntro();
     intro(chalk.cyan('Available workflow skills'));
@@ -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/{features → modules/skill-selection-management}/stop-managing-file/handler.js

@@ -2,14 +2,15 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { cancel, intro, isCancel, log, outro, select } from '@clack/prompts';
 import chalk from 'chalk';
-import { STATE_RELATIVE_PATH, resolveSelectableSkillById } from '../../shared/catalog.js';
-import { readFileHashIfPresent, sha256 } from '../../shared/hash.js';
-import { getProjectContext } from '../../shared/paths.js';
-import { renderIntro } from '../../shared/prompts.js';
-import { cloneState, readStateForDoctor, writeStateFile } from '../../shared/state.js';
-import { getTemplateVersion, readTemplateManifest, renderTemplateForSync } from '../../shared/templates.js';
-import { removeUndefinedFields } from '../../shared/object.js';
-import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, } from '../../shared/workflow-targets.js';
+import { STATE_RELATIVE_PATH } from '../../../shared/catalog.js';
+import { resolveSelectableSkillById } from '../../workflow-target-planning/index.js';
+import { readFileHashIfPresent, sha256 } from '../../../shared/hash.js';
+import { getProjectContext } from '../../../shared/paths.js';
+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, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, } from '../../workflow-target-planning/index.js';
 export async function handleStopManagingFile({ skillName }) {
     await renderIntro();
     intro(chalk.cyan('Updating skill management'));
@@ -109,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;
     }
@@ -124,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;
@@ -167,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/command.js

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

package/bin/{features → modules/skill-selection-management}/use-skill/handler.js

@@ -1,12 +1,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { log } from '@clack/prompts';
-import { STATE_RELATIVE_PATH, resolveSelectableSkillById } from '../../shared/catalog.js';
-import { sha256 } from '../../shared/hash.js';
-import { getProjectContext } from '../../shared/paths.js';
-import { renderTemplateForSync } from '../../shared/templates.js';
-import { getWorkflowMutationReadiness } from '../../shared/workflow-mutation-readiness.js';
-import { getSelectedAgentsFromState, getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../../shared/workflow-targets.js';
+import { STATE_RELATIVE_PATH } from '../../../shared/catalog.js';
+import { resolveSelectableSkillById } from '../../workflow-target-planning/index.js';
+import { sha256 } from '../../../shared/hash.js';
+import { getProjectContext } from '../../../shared/paths.js';
+import { renderTemplateForSync } from '../../template-catalog-rendering/index.js';
+import { getWorkflowMutationReadiness } from '../../workflow-mutation-readiness/index.js';
+import { getSelectedAgentsFromState, getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../../workflow-target-planning/index.js';
 export async function handleUseSkill(command) {
     const { rootPath, statePath } = getProjectContext();
     const readiness = getWorkflowMutationReadiness({ rootPath, statePath });
@@ -45,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)) {
@@ -58,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':
@@ -72,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':
@@ -93,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':
@@ -107,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),
                 },
             };
     }
@@ -127,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' });
@@ -147,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}`);
@@ -154,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');
@@ -194,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') {
@@ -225,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/{features/sync-project → modules/sync-review}/apply-action.js

@@ -3,9 +3,9 @@ import path from 'node:path';
 import { log } from '@clack/prompts';
 import { sha256 } from '../../shared/hash.js';
 import { getSideTemplatePath } from '../../shared/paths.js';
-import { cloneState } from '../../shared/state.js';
-import { getTemplateVersion, renderTemplateForSync } from '../../shared/templates.js';
-import { getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, } from '../../shared/workflow-targets.js';
+import { cloneState } from '../workflow-state-registry/index.js';
+import { getTemplateVersion, renderTemplateForSync } from '../template-catalog-rendering/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/command.js

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

package/bin/{features/sync-project → modules/sync-review}/handler.js

@@ -2,13 +2,13 @@ import { intro, log, outro } from '@clack/prompts';
 import chalk from 'chalk';
 import { STATE_RELATIVE_PATH } from '../../shared/catalog.js';
 import { getProjectContext } from '../../shared/paths.js';
-import { askForMissingFrameworkSkills, askForNewArchitectureSkill, askForNewLanguageSkills, renderIntro } from '../../shared/prompts.js';
-import { readStateForDoctor, writeStateFile } from '../../shared/state.js';
-import { readTemplateManifest } from '../../shared/templates.js';
+import { askForMissingFrameworkSkills, askForNewArchitectureSkill, askForNewLanguageSkills, renderIntro } from '../interactive-guidance/index.js';
+import { readStateForDoctor, writeStateFile } from '../workflow-state-registry/index.js';
+import { readTemplateManifest } from '../template-catalog-rendering/index.js';
 import { askForSyncAction } from './action-prompt.js';
 import { applySyncAction } from './apply-action.js';
 import { logSyncPreview } from './log-preview.js';
-import { getSyncPreviews, isActionableSyncPreview, shouldAskForSyncAction } from './preview.js';
+import { getSyncPreviews, isActionableSyncPreview, shouldAskForSyncAction } from './sync-preview.js';
 export async function handleSyncProject(_command) {
     await renderIntro();
     intro(chalk.cyan('Reviewing workflow updates'));

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

@@ -0,0 +1,5 @@
+export { askForSyncAction } from './action-prompt.js';
+export { applySyncAction } from './apply-action.js';
+export { handleSyncProject } from './handler.js';
+export { logSyncPreview } from './log-preview.js';
+export { getSyncPreviews, isActionableSyncPreview, shouldAskForSyncAction } from './sync-preview.js';

package/bin/{shared → modules/sync-review}/sync-preview.js

@@ -1,9 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { sha256 } from './hash.js';
-import { hasReviewedTemplateVersion } from './state.js';
-import { renderTemplateForSync } from './templates.js';
-import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from './workflow-targets.js';
+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, 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/index.js

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

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

@@ -0,0 +1,60 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getTemplatesPath } from '../../shared/paths.js';
+export function readTemplate(relativePath) {
+    return fs.readFileSync(path.join(getTemplatesPath(), relativePath), 'utf8');
+}
+export function readTemplateManifest() {
+    const manifest = JSON.parse(fs.readFileSync(path.join(getTemplatesPath(), 'manifest.json'), 'utf8'));
+    if (!isTemplateManifest(manifest)) {
+        throw new Error('templates/manifest.json is not a valid template manifest.');
+    }
+    return manifest;
+}
+export function getTemplateVersion(manifest, templateRelativePath) {
+    const template = manifest.templates[templateRelativePath];
+    if (!template) {
+        throw new Error(`Template ${templateRelativePath} is missing from templates/manifest.json.`);
+    }
+    return template.version;
+}
+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, selectedDatabaseSkills);
+}
+export function renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = []) {
+    if (!contents.includes('{{OPTIONAL_SKILL_ROUTING}}')) {
+        return contents;
+    }
+    const optionalRouting = [...selectedLanguageSkills, ...selectedFrameworkSkills, ...selectedDatabaseSkills, ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []), ...selectedWorkflowSkills]
+        .map((skill) => `- ${skill.routingInstruction}`)
+        .join('\n');
+    return contents.replace('{{OPTIONAL_SKILL_ROUTING}}', optionalRouting);
+}
+export function extractProjectOverview(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return undefined;
+    }
+    const contents = fs.readFileSync(filePath, 'utf8');
+    const match = contents.match(/## Project overview\s+([\s\S]*?)(?=\n## |$)/);
+    const overview = match?.[1]?.trim();
+    return overview || undefined;
+}
+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/version-advisory/index.js

@@ -0,0 +1 @@
+export { checkForLatestSibuVersion, SIBU_CACHE_HOME_ENV, SIBU_PACKAGE_NAME, SIBU_VERSION } from './npm-version.js';

package/bin/{shared → modules/version-advisory}/npm-version.js

@@ -1,7 +1,13 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
-import { NPM_VERSION_LOOKUP_MODE_ENV, NPM_VERSION_OVERRIDE_ENV, SIBU_PACKAGE_NAME, SIBU_VERSION, SUPPORTED_NPM_LOOKUP_MODES } from './catalog.js';
-import { getNpmVersionCachePath } from './paths.js';
+import { fileURLToPath } from 'node:url';
+export const SIBU_PACKAGE_NAME = '@juancr11/sibu';
+export const SIBU_VERSION = readPackageVersion();
+export const NPM_VERSION_LOOKUP_MODE_ENV = 'SIBU_NPM_LOOKUP_MODE';
+export const NPM_VERSION_OVERRIDE_ENV = 'SIBU_NPM_LATEST_VERSION';
+export const SIBU_CACHE_HOME_ENV = 'SIBU_CACHE_HOME';
+export const SUPPORTED_NPM_LOOKUP_MODES = ['live', 'offline'];
 const NPM_VERSION_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
 const NPM_REGISTRY_URL = 'https://registry.npmjs.org';
 export async function checkForLatestSibuVersion(options = {}) {
@@ -176,3 +182,24 @@ function isNpmVersionCacheRecord(value) {
         typeof record.packageName === 'string' &&
         typeof record.source === 'string');
 }
+function getNpmVersionCachePath() {
+    return path.join(getSibuCacheRoot(), 'cache', 'npm-version.json');
+}
+function getSibuCacheRoot() {
+    const override = process.env[SIBU_CACHE_HOME_ENV]?.trim();
+    if (override) {
+        return path.resolve(override);
+    }
+    return path.join(os.homedir(), '.sibu');
+}
+function readPackageVersion() {
+    const packageJsonPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    if (!isPackageJsonWithVersion(packageJson)) {
+        throw new Error(`Could not read Sibu version from ${packageJsonPath}.`);
+    }
+    return packageJson.version;
+}
+function isPackageJsonWithVersion(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.version === 'string');
+}

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

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

package/bin/{features/doctor-project → modules/workflow-health-diagnosis}/handler.js

@@ -2,14 +2,15 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { intro, log, outro } from '@clack/prompts';
 import chalk from 'chalk';
-import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, STATE_RELATIVE_PATH, SUPPORTED_AGENTS } from '../../shared/catalog.js';
+import { STATE_RELATIVE_PATH } from '../../shared/catalog.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 '../../shared/npm-version.js';
+import { checkForLatestSibuVersion } from '../version-advisory/index.js';
 import { getProjectContext } from '../../shared/paths.js';
-import { renderIntro } from '../../shared/prompts.js';
-import { hasReviewedTemplateVersion, readStateForDoctor } from '../../shared/state.js';
-import { getTemplateVersion, readTemplateManifest } from '../../shared/templates.js';
-import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getWorkflowTargets, } from '../../shared/workflow-targets.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, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from '../workflow-target-planning/index.js';
 export async function handleDoctorProject(_command) {
     await renderIntro();
     intro(chalk.cyan('Checking workflow state'));
@@ -116,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}.` });
@@ -124,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-health-diagnosis/index.js

@@ -0,0 +1 @@
+export { diagnoseState, getDoctorSyncNextStepLines, getNpmVersionAdvisoryLines, handleDoctorProject } from './handler.js';

package/bin/modules/workflow-mutation-readiness/index.js

@@ -0,0 +1 @@
+export { getWorkflowMutationReadiness } from './workflow-mutation-readiness.js';

package/bin/{shared → modules/workflow-mutation-readiness}/workflow-mutation-readiness.js

@@ -1,6 +1,6 @@
-import { readStateForDoctor } from './state.js';
-import { getSyncPreviews, isActionableSyncPreview } from './sync-preview.js';
-import { readTemplateManifest } from './templates.js';
+import { readStateForDoctor } from '../workflow-state-registry/index.js';
+import { getSyncPreviews, isActionableSyncPreview } from '../sync-review/index.js';
+import { readTemplateManifest } from '../template-catalog-rendering/index.js';
 export function getWorkflowMutationReadiness({ rootPath, statePath }) {
     const stateResult = readStateForDoctor(statePath);
     if (!stateResult.ok) {

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

@@ -0,0 +1 @@
+export { cloneState, hasReviewedTemplateVersion, readExistingState, readStateForDoctor, writeStateFile } from './state.js';

package/bin/{shared → modules/workflow-state-registry}/state.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { STATE_RELATIVE_PATH } from './catalog.js';
+import { STATE_RELATIVE_PATH } from '../../shared/catalog.js';
 export function readStateForDoctor(statePath) {
     if (!fs.existsSync(statePath)) {
         return { ok: false, message: `${STATE_RELATIVE_PATH} is missing.` };
@@ -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 &&