@juancr11/sibu 0.17.0 → 0.18.0

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

@@ -0,0 +1,314 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { writeSibuState } from '../../workflow-state-ledger/index.js';
+import { log } from '@clack/prompts';
+import { STATE_RELATIVE_PATH } from '../../workflow-state-ledger/state-path.js';
+import { askForNotionDocsParentPage } from '../../../support/interactive-guidance/index.js';
+import { getMcpServersRequiredByWorkflowSkills, resolveSelectableSkillById } from '../../template-catalog/index.js';
+import { sha256 } from '../../../shared/hash.js';
+import { getProjectContext } from '../../../shared/paths.js';
+import { renderTemplateForSync } from '../../template-catalog/index.js';
+import { getWorkflowMutationReadiness } from '../../sync-review-orchestrator/index.js';
+import { getSelectedAgentsFromState, getSelectedMcpServersFromState, getWorkflowTargets, renderMissingWorkflowFiles, } from '../../template-catalog/index.js';
+const defaultDependencies = {
+    askForNotionDocsParentPage,
+};
+export async function handleUseSkill(command, dependencies = defaultDependencies) {
+    const { rootPath, statePath } = getProjectContext();
+    const readiness = getWorkflowMutationReadiness({ rootPath, statePath });
+    if (!readiness.ok) {
+        log.error(readiness.message);
+        log.info(readiness.hint);
+        for (const preview of readiness.actionablePreviews?.slice(0, 3) ?? []) {
+            log.info(`${preview.relativePath}: ${preview.status}`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const selectionResult = getNextSkillSelection(readiness.state, command.skillName);
+    switch (selectionResult.status) {
+        case 'noop':
+            log.success(selectionResult.message);
+            log.info('No files changed.');
+            return;
+        case 'blocked':
+            log.error(selectionResult.message);
+            if (selectionResult.hint) {
+                log.info(selectionResult.hint);
+            }
+            process.exitCode = 1;
+            return;
+        case 'selected':
+            await applySelectedSkill({ rootPath, statePath, state: readiness.state, selectionResult, dependencies });
+            return;
+    }
+}
+export function getNextSkillSelection(state, skillName) {
+    const resolution = resolveSelectableSkillById(skillName);
+    if (!resolution.ok) {
+        return { status: 'blocked', message: resolution.message };
+    }
+    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)) {
+                return { status: 'noop', message: `${resolution.resolved.skill.name} is already selected.` };
+            }
+            return {
+                status: 'selected',
+                skillName: resolution.resolved.skill.name,
+                selection: {
+                    selectedLanguageSkills: [...selectedLanguageSkills, resolution.resolved.skill.id].map(getLanguageSkillById),
+                    selectedFrameworkSkills: selectedFrameworkSkills.map(getFrameworkSkillById),
+                    selectedArchitectureSkill: getArchitectureSkillById(state.selectedArchitectureSkill),
+                    selectedWorkflowSkills: selectedWorkflowSkills.map(getWorkflowSkillById),
+                    selectedDatabaseSkills: selectedDatabaseSkills.map(getDatabaseSkillById),
+                },
+            };
+        case 'framework':
+            if (selectedFrameworkSkills.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, resolution.resolved.skill.id].map(getFrameworkSkillById),
+                    selectedArchitectureSkill: getArchitectureSkillById(state.selectedArchitectureSkill),
+                    selectedWorkflowSkills: selectedWorkflowSkills.map(getWorkflowSkillById),
+                    selectedDatabaseSkills: selectedDatabaseSkills.map(getDatabaseSkillById),
+                },
+            };
+        case 'architecture':
+            if (state.selectedArchitectureSkill === resolution.resolved.skill.id) {
+                return { status: 'noop', message: `${resolution.resolved.skill.name} is already selected.` };
+            }
+            if (state.selectedArchitectureSkill) {
+                return {
+                    status: 'blocked',
+                    message: `Cannot select ${resolution.resolved.skill.name} because another architecture skill is already selected.`,
+                    hint: 'Architecture skill replacement is not supported yet. Keep the existing architecture skill or stop managing it first.',
+                };
+            }
+            return {
+                status: 'selected',
+                skillName: resolution.resolved.skill.name,
+                selection: {
+                    selectedLanguageSkills: selectedLanguageSkills.map(getLanguageSkillById),
+                    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':
+            if (selectedWorkflowSkills.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, resolution.resolved.skill.id].map(getWorkflowSkillById),
+                    selectedDatabaseSkills: selectedDatabaseSkills.map(getDatabaseSkillById),
+                },
+            };
+    }
+}
+async function applySelectedSkill({ rootPath, statePath, state, selectionResult, dependencies, }) {
+    const plan = buildSkillApplicationPlan({ rootPath, state, selectionResult });
+    const preflightError = getSkillApplicationPreflightError({ rootPath, state, plan });
+    if (preflightError) {
+        log.error(preflightError);
+        log.info('Run `sibu sync` to review workflow state before selecting a skill.');
+        process.exitCode = 1;
+        return;
+    }
+    const mcpServerConfigs = await getNextMcpServerConfigs({ state, selectedMcpServers: plan.selectedMcpServers, dependencies });
+    const dependencyMcpServers = plan.selectedMcpServers.filter((server) => !(state.selectedMcpServers ?? []).includes(server.id));
+    for (const server of dependencyMcpServers) {
+        log.info(`${selectionResult.skillName} requires ${server.name}. I will add them together.`);
+    }
+    const nonAgentTargets = plan.affectedTargets.filter((target) => target.label !== 'AGENTS.md');
+    const files = renderMissingWorkflowFiles({
+        missingTargets: nonAgentTargets,
+        selectedLanguageSkills: selectionResult.selection.selectedLanguageSkills,
+        selectedFrameworkSkills: selectionResult.selection.selectedFrameworkSkills,
+        selectedArchitectureSkill: selectionResult.selection.selectedArchitectureSkill,
+        selectedWorkflowSkills: selectionResult.selection.selectedWorkflowSkills,
+        selectedDatabaseSkills: selectionResult.selection.selectedDatabaseSkills,
+        selectedMcpServers: plan.selectedMcpServers,
+    });
+    for (const file of files) {
+        const fileAlreadyExists = fs.existsSync(file.targetPath);
+        fs.mkdirSync(path.dirname(file.targetPath), { recursive: true });
+        fs.writeFileSync(file.targetPath, file.contents, fileAlreadyExists ? 'utf8' : { encoding: 'utf8', flag: 'wx' });
+        log.success(`${fileAlreadyExists ? 'Updated' : 'Created'} ${file.label}`);
+    }
+    const agentsContents = renderTemplateForSync({
+        templateRelativePath: plan.agentsTarget.templateRelativePath,
+        currentPath: plan.agentsTarget.targetPath,
+        selectedLanguageSkills: selectionResult.selection.selectedLanguageSkills,
+        selectedFrameworkSkills: selectionResult.selection.selectedFrameworkSkills,
+        selectedArchitectureSkill: selectionResult.selection.selectedArchitectureSkill,
+        selectedWorkflowSkills: selectionResult.selection.selectedWorkflowSkills,
+        selectedDatabaseSkills: selectionResult.selection.selectedDatabaseSkills,
+        selectedMcpServers: plan.selectedMcpServers,
+    });
+    fs.writeFileSync(plan.agentsTarget.targetPath, agentsContents, 'utf8');
+    log.success('Updated AGENTS.md skill routing');
+    writeSibuState({
+        rootPath,
+        statePath,
+        selectedAgents: plan.selectedAgents,
+        selectedLanguageSkills: selectionResult.selection.selectedLanguageSkills,
+        selectedFrameworkSkills: selectionResult.selection.selectedFrameworkSkills,
+        selectedArchitectureSkill: selectionResult.selection.selectedArchitectureSkill,
+        selectedWorkflowSkills: selectionResult.selection.selectedWorkflowSkills,
+        selectedDatabaseSkills: selectionResult.selection.selectedDatabaseSkills,
+        selectedMcpServers: plan.selectedMcpServers,
+        mcpServerConfigs,
+        targets: plan.targets,
+    });
+    log.success(`Updated ${STATE_RELATIVE_PATH}`);
+    log.success(`Added ${selectionResult.skillName}.`);
+    for (const server of dependencyMcpServers) {
+        log.success(`Added ${server.name}.`);
+    }
+}
+function buildSkillApplicationPlan({ rootPath, state, selectionResult, }) {
+    const selectedAgents = getSelectedAgentsFromState(state);
+    const currentMcpServers = getSelectedMcpServersFromState(state);
+    const requiredMcpServers = getMcpServersRequiredByWorkflowSkills(selectionResult.selection.selectedWorkflowSkills.map((skill) => skill.id));
+    const selectedMcpServers = mergeMcpServers(currentMcpServers, requiredMcpServers);
+    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, getSelectedLanguageSkillsFromState(state), getSelectedFrameworkSkillsFromState(state), getArchitectureSkillById(state.selectedArchitectureSkill), getSelectedWorkflowSkillsFromState(state), getSelectedDatabaseSkillsFromState(state), currentMcpServers);
+    const targets = getWorkflowTargets(rootPath, selectedAgents, selectionResult.selection.selectedLanguageSkills, selectionResult.selection.selectedFrameworkSkills, selectionResult.selection.selectedArchitectureSkill, selectionResult.selection.selectedWorkflowSkills, selectionResult.selection.selectedDatabaseSkills, selectedMcpServers);
+    const previousTargetPaths = new Set(previousTargets.map((target) => target.targetPath));
+    const newTargets = targets.filter((target) => !previousTargetPaths.has(target.targetPath) && (target.targetKind === 'skill' || target.targetKind === 'mcp-config'));
+    const mcpConfigTargets = targets.filter((target) => target.mcpConfigAgentId && selectedMcpServers.length > currentMcpServers.length);
+    const agentsTarget = targets.find((target) => target.label === 'AGENTS.md');
+    if (newTargets.length === 0) {
+        throw new Error(`No new workflow target found for ${selectionResult.skillName}.`);
+    }
+    if (!agentsTarget) {
+        throw new Error('AGENTS.md target is missing from workflow targets.');
+    }
+    const affectedTargets = dedupeTargets([...newTargets, ...mcpConfigTargets, agentsTarget]);
+    return { agentsTarget, newTargets, affectedTargets, targets, selectedAgents, selectedMcpServers };
+}
+function getSkillApplicationPreflightError({ rootPath, state, plan }) {
+    const existingRecordedTargets = plan.affectedTargets.filter((target) => state.managedFiles[path.relative(rootPath, target.targetPath)]);
+    const newTargets = plan.affectedTargets.filter((target) => !state.managedFiles[path.relative(rootPath, target.targetPath)]);
+    for (const target of newTargets) {
+        if (fs.existsSync(target.targetPath)) {
+            return `${path.relative(rootPath, target.targetPath)} already exists but is not recorded for this selection.`;
+        }
+    }
+    for (const target of existingRecordedTargets) {
+        const relativePath = path.relative(rootPath, target.targetPath);
+        const managedFile = state.managedFiles[relativePath];
+        if (!managedFile) {
+            return `${relativePath} is not recorded in ${STATE_RELATIVE_PATH}.`;
+        }
+        if (!fs.existsSync(target.targetPath)) {
+            return `${relativePath} is missing.`;
+        }
+        const currentHash = sha256(fs.readFileSync(target.targetPath, 'utf8'));
+        if (currentHash !== managedFile.sha256) {
+            return `${relativePath} has changed since Sibu last recorded it.`;
+        }
+    }
+    return undefined;
+}
+function dedupeTargets(targets) {
+    return [...new Map(targets.map((target) => [target.targetPath, target])).values()];
+}
+function mergeMcpServers(...serverGroups) {
+    const serversById = new Map();
+    for (const server of serverGroups.flat()) {
+        serversById.set(server.id, server);
+    }
+    return [...serversById.values()];
+}
+async function getNextMcpServerConfigs({ state, selectedMcpServers, dependencies, }) {
+    if (!selectedMcpServers.some((server) => server.id === 'notion') || state.selectedMcpServers?.includes('notion')) {
+        return state.mcpServerConfigs;
+    }
+    const docsParentPage = await dependencies.askForNotionDocsParentPage();
+    return {
+        ...state.mcpServerConfigs,
+        notion: { docsParentPage },
+    };
+}
+function getSelectedLanguageSkillsFromState(state) {
+    return (state.selectedLanguageSkills ?? []).map(getLanguageSkillById);
+}
+function getSelectedFrameworkSkillsFromState(state) {
+    return (state.selectedFrameworkSkills ?? []).map(getFrameworkSkillById);
+}
+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') {
+        throw new Error(`Unsupported language skill in state: ${skillId}`);
+    }
+    return resolution.resolved.skill;
+}
+function getFrameworkSkillById(skillId) {
+    const resolution = resolveSelectableSkillById(skillId);
+    if (!resolution.ok || resolution.resolved.kind !== 'framework') {
+        throw new Error(`Unsupported framework skill in state: ${skillId}`);
+    }
+    return resolution.resolved.skill;
+}
+function getArchitectureSkillById(skillId) {
+    if (!skillId) {
+        return undefined;
+    }
+    const resolution = resolveSelectableSkillById(skillId);
+    if (!resolution.ok || resolution.resolved.kind !== 'architecture') {
+        throw new Error(`Unsupported architecture skill in state: ${skillId}`);
+    }
+    return resolution.resolved.skill;
+}
+function getWorkflowSkillById(skillId) {
+    const resolution = resolveSelectableSkillById(skillId);
+    if (!resolution.ok || resolution.resolved.kind !== 'workflow') {
+        throw new Error(`Unsupported workflow skill in state: ${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/workflow-health-inspector/command.js

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

package/bin/modules/{workflow-health-diagnosis → workflow-health-inspector}/handler.js

@@ -2,15 +2,15 @@ import fs from 'node:fs';
 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_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_MCP_SERVERS, SUPPORTED_AGENTS } from '../workflow-target-planning/index.js';
+import { STATE_RELATIVE_PATH } from '../workflow-state-ledger/state-path.js';
+import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_MCP_SERVERS, SUPPORTED_AGENTS } from '../template-catalog/index.js';
 import { sha256 } from '../../shared/hash.js';
-import { checkForLatestSibuVersion } from '../version-advisory/index.js';
+import { checkForLatestSibuVersion } from '../../support/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, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from '../workflow-target-planning/index.js';
+import { renderIntro } from '../../support/interactive-guidance/index.js';
+import { hasReviewedTemplateVersion, readStateForDoctor } from '../workflow-state-ledger/index.js';
+import { getTemplateVersion, readTemplateManifest } from '../template-catalog/index.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from '../template-catalog/index.js';
 export async function handleDoctorProject(_command) {
     await renderIntro();
     intro(chalk.cyan('Checking workflow state'));

package/bin/modules/workflow-installer/command.js

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

package/bin/modules/{project-adoption → workflow-installer}/handler.js

@@ -1,12 +1,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { writeSibuState } from '../workflow-state-ledger/index.js';
 import { intro, log, outro } from '@clack/prompts';
 import chalk from 'chalk';
-import { STATE_RELATIVE_PATH } from '../../shared/catalog.js';
+import { STATE_RELATIVE_PATH } from '../workflow-state-ledger/state-path.js';
 import { getProjectContext } from '../../shared/paths.js';
-import { askForArchitectureSkill, askForDatabaseSkills, askForFrameworkSkills, askForLanguageSkills, askForMcpServers, askForNotionDocsParentPage, askForProjectOverview, askForSupportedAgents, askForWorkflowSkills, renderIntro, } from '../interactive-guidance/index.js';
-import { readStateForDoctor } from '../workflow-state-registry/index.js';
-import { getWorkflowSkillsImpliedByMcpServers, getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../workflow-target-planning/index.js';
+import { askForArchitectureSkill, askForDatabaseSkills, askForFrameworkSkills, askForLanguageSkills, askForMcpServers, askForNotionDocsParentPage, askForProjectOverview, askForSupportedAgents, askForWorkflowSkills, renderIntro, } from '../../support/interactive-guidance/index.js';
+import { readStateForDoctor } from '../workflow-state-ledger/index.js';
+import { getWorkflowSkillsImpliedByMcpServers, getWorkflowTargets, renderMissingWorkflowFiles } from '../template-catalog/index.js';
 function mergeWorkflowSkills(...skillGroups) {
     const skillsById = new Map();
     for (const skill of skillGroups.flat()) {

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

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

package/bin/modules/workflow-state-ledger/state-path.js

@@ -0,0 +1 @@
+export const STATE_RELATIVE_PATH = '.sibu/state.json';

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

@@ -1,6 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { STATE_RELATIVE_PATH } from '../../shared/catalog.js';
+import { STATE_RELATIVE_PATH } from './state-path.js';
+import { sha256 } from '../../shared/hash.js';
+import { removeUndefinedFields } from '../../shared/object.js';
+import { getTemplateVersion, readTemplateManifest } from '../template-catalog/index.js';
+import { SIBU_VERSION } from '../../support/version-advisory/index.js';
 export function readStateForDoctor(statePath) {
     if (!fs.existsSync(statePath)) {
         return { ok: false, message: `${STATE_RELATIVE_PATH} is missing.` };
@@ -37,6 +41,41 @@ export function cloneState(state) {
 export function hasReviewedTemplateVersion(managedFile, templateVersion) {
     return managedFile.lastReviewedTemplateVersion === templateVersion;
 }
+export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], selectedMcpServers, mcpServerConfigs, targets, }) {
+    const previousState = readExistingState(statePath);
+    const now = new Date().toISOString();
+    const manifest = readTemplateManifest();
+    const state = {
+        sibuVersion: SIBU_VERSION,
+        templateVersion: manifest.templateVersion,
+        generatedAt: previousState?.generatedAt ?? now,
+        updatedAt: now,
+        selectedAgents: selectedAgents.map((agent) => agent.id),
+        selectedLanguageSkills: selectedLanguageSkills.map((skill) => skill.id),
+        selectedFrameworkSkills: selectedFrameworkSkills.map((skill) => skill.id),
+        selectedArchitectureSkill: selectedArchitectureSkill?.id,
+        selectedWorkflowSkills: selectedWorkflowSkills.map((skill) => skill.id),
+        selectedDatabaseSkills: selectedDatabaseSkills.map((skill) => skill.id),
+        ...(selectedMcpServers !== undefined ? { selectedMcpServers: selectedMcpServers.map((server) => server.id) } : {}),
+        ...(mcpServerConfigs ?? previousState?.mcpServerConfigs ? { mcpServerConfigs: mcpServerConfigs ?? previousState?.mcpServerConfigs } : {}),
+        managedFiles: Object.fromEntries(targets
+            .filter((target) => fs.existsSync(target.targetPath))
+            .map((target) => {
+            const relativePath = path.relative(rootPath, target.targetPath);
+            const previousManagedFile = previousState?.managedFiles[relativePath];
+            const nextManagedFile = {
+                template: target.templateRelativePath,
+                templateVersion: getTemplateVersion(manifest, target.templateRelativePath),
+                sha256: sha256(fs.readFileSync(target.targetPath, 'utf8')),
+                status: previousManagedFile?.status ?? 'managed',
+                lastReviewedTemplateVersion: previousManagedFile?.lastReviewedTemplateVersion,
+                reason: previousManagedFile?.reason,
+            };
+            return [relativePath, removeUndefinedFields(nextManagedFile)];
+        })),
+    };
+    writeStateFile(statePath, state);
+}
 function isSibuState(value) {
     if (!value || typeof value !== 'object') {
         return false;

package/bin/{modules/workflow-target-planning/workflow-targets.js → shared/expected-workflow-targets.js}

@@ -1,11 +1,6 @@
-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_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_MCP_SERVERS, SELECTABLE_WORKFLOW_SKILLS, SESSION_START_HOOKS, 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';
-import { getTemplateVersion, readTemplate, readTemplateManifest, renderMcpConfig, renderSkillRouting, renderWorkerToolboxRoutingPlaceholders } from '../template-catalog-rendering/index.js';
+import { MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_MCP_SERVERS, SELECTABLE_WORKFLOW_SKILLS, SESSION_START_HOOKS, SUPPORTED_AGENTS, } from '../modules/template-catalog/catalog.js';
+import { getMcpConfigTargetsForAgents } from '../modules/agent-tool-configuration/index.js';
 export function getSelectedLanguageSkillsFromState(state) {
     return SELECTABLE_LANGUAGE_SKILLS.filter((skill) => state.selectedLanguageSkills?.includes(skill.id));
 }
@@ -66,41 +61,6 @@ function getSkillTargetsForAgent(skill, agentId) {
     }
     return targets;
 }
-export function getSelectedMcpTargetsForAgents(selectedAgents, selectedMcpServers) {
-    if (selectedMcpServers.length === 0) {
-        return [];
-    }
-    return selectedAgents.flatMap((agent) => {
-        if (agent.id === 'codex') {
-            return [
-                {
-                    targetRelativePath: '.codex/config.toml',
-                    templateRelativePath: '.codex/config.toml',
-                    agentId: 'codex',
-                },
-            ];
-        }
-        if (agent.id === 'claude') {
-            return [
-                {
-                    targetRelativePath: '.mcp.json',
-                    templateRelativePath: 'mcp/claude/.mcp.json',
-                    agentId: 'claude',
-                },
-            ];
-        }
-        if (agent.id === 'gemini') {
-            return [
-                {
-                    targetRelativePath: '.gemini/settings.json',
-                    templateRelativePath: 'mcp/gemini/settings.json',
-                    agentId: 'gemini',
-                },
-            ];
-        }
-        return [];
-    });
-}
 function getSessionStartHookTargetsForAgents(selectedAgents) {
     const selectedAgentIds = new Set(selectedAgents.map((agent) => agent.id));
     return SESSION_START_HOOKS.filter((hookTemplate) => selectedAgentIds.has(hookTemplate.agentId)).map((hookTemplate) => ({
@@ -146,7 +106,7 @@ export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSki
             targetKind: 'agent-support',
         })),
     ];
-    for (const mcpTarget of getSelectedMcpTargetsForAgents(selectedAgents, selectedMcpServers)) {
+    for (const mcpTarget of getMcpConfigTargetsForAgents(selectedAgents, selectedMcpServers)) {
         const targetPath = path.join(rootPath, mcpTarget.targetRelativePath);
         const existingTarget = targets.find((target) => target.targetPath === targetPath);
         if (existingTarget) {
@@ -166,67 +126,6 @@ export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSki
     }
     return targets;
 }
-export function renderMissingWorkflowFiles({ missingTargets, overview, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], selectedMcpServers = [], }) {
-    return missingTargets.map((target) => {
-        let contents = readTemplate(target.templateRelativePath);
-        if (target.mcpConfigAgentId && (target.selectedMcpServers?.length || selectedMcpServers.length)) {
-            contents = renderMcpConfig({
-                agentId: target.mcpConfigAgentId,
-                baseContents: contents,
-                selectedMcpServers: target.selectedMcpServers ?? selectedMcpServers,
-            });
-        }
-        if (target.requiresProjectOverview) {
-            if (!overview?.trim()) {
-                throw new Error('Project overview is required to create AGENTS.md.');
-            }
-            contents = contents.replace('{{PROJECT_OVERVIEW}}', overview.trim());
-        }
-        contents = renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
-        contents = renderWorkerToolboxRoutingPlaceholders(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
-        return {
-            label: target.label,
-            targetPath: target.targetPath,
-            contents,
-        };
-    });
-}
-export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], selectedMcpServers, mcpServerConfigs, targets, }) {
-    const previousState = readExistingState(statePath);
-    const now = new Date().toISOString();
-    const manifest = readTemplateManifest();
-    const state = {
-        sibuVersion: SIBU_VERSION,
-        templateVersion: manifest.templateVersion,
-        generatedAt: previousState?.generatedAt ?? now,
-        updatedAt: now,
-        selectedAgents: selectedAgents.map((agent) => agent.id),
-        selectedLanguageSkills: selectedLanguageSkills.map((skill) => skill.id),
-        selectedFrameworkSkills: selectedFrameworkSkills.map((skill) => skill.id),
-        selectedArchitectureSkill: selectedArchitectureSkill?.id,
-        selectedWorkflowSkills: selectedWorkflowSkills.map((skill) => skill.id),
-        selectedDatabaseSkills: selectedDatabaseSkills.map((skill) => skill.id),
-        ...(selectedMcpServers !== undefined ? { selectedMcpServers: selectedMcpServers.map((server) => server.id) } : {}),
-        ...(mcpServerConfigs ?? previousState?.mcpServerConfigs ? { mcpServerConfigs: mcpServerConfigs ?? previousState?.mcpServerConfigs } : {}),
-        managedFiles: Object.fromEntries(targets
-            .filter((target) => fs.existsSync(target.targetPath))
-            .map((target) => {
-            const relativePath = path.relative(rootPath, target.targetPath);
-            const previousManagedFile = previousState?.managedFiles[relativePath];
-            const nextManagedFile = {
-                template: target.templateRelativePath,
-                templateVersion: getTemplateVersion(manifest, target.templateRelativePath),
-                sha256: sha256(fs.readFileSync(target.targetPath, 'utf8')),
-                status: previousManagedFile?.status ?? 'managed',
-                lastReviewedTemplateVersion: previousManagedFile?.lastReviewedTemplateVersion,
-                reason: previousManagedFile?.reason,
-            };
-            return [relativePath, removeUndefinedFields(nextManagedFile)];
-        })),
-    };
-    fs.mkdirSync(path.dirname(statePath), { recursive: true });
-    fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
-}
 export function getSelectedAgentsFromState(state) {
     return SUPPORTED_AGENTS.filter((agent) => state.selectedAgents.includes(agent.id));
 }

package/bin/shared/paths.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { STATE_RELATIVE_PATH } from './catalog.js';
+const STATE_RELATIVE_PATH = '.sibu/state.json';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export function getProjectContext() {