@juancr11/sibu 0.13.1 → 0.14.0

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

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

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

@@ -148,11 +148,16 @@ export async function askForArchitectureSkill() {
     }
     return SELECTABLE_ARCHITECTURE_SKILLS.find((skill) => skill.id === selectedArchitectureSkillId);
 }
-export async function askForWorkflowSkills() {
+export function getPromptableWorkflowSkills(excludedWorkflowSkillIds = []) {
+    const excludedIds = new Set(excludedWorkflowSkillIds);
+    return SELECTABLE_WORKFLOW_SKILLS.filter((skill) => !excludedIds.has(skill.id));
+}
+export async function askForWorkflowSkills(excludedWorkflowSkillIds = []) {
+    const promptableWorkflowSkills = getPromptableWorkflowSkills(excludedWorkflowSkillIds);
     const selectedWorkflowSkillIds = await multiselect({
         message: 'Select optional workflow skills for this project.',
         required: false,
-        options: SELECTABLE_WORKFLOW_SKILLS.map((skill) => ({
+        options: promptableWorkflowSkills.map((skill) => ({
             value: skill.id,
             label: skill.name,
             hint: skill.description,
@@ -162,7 +167,7 @@ export async function askForWorkflowSkills() {
         cancel('Initialization cancelled.');
         process.exit(0);
     }
-    return SELECTABLE_WORKFLOW_SKILLS.filter((skill) => selectedWorkflowSkillIds.includes(skill.id));
+    return promptableWorkflowSkills.filter((skill) => selectedWorkflowSkillIds.includes(skill.id));
 }
 export function shouldAskForNewLanguageSkills(state) {
     return (state.selectedLanguageSkills?.length ?? 0) === 0;

package/bin/modules/mcp-server-selection-management/use-mcp-server/handler.js

@@ -2,10 +2,12 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { log } from '@clack/prompts';
 import { STATE_RELATIVE_PATH } from '../../../shared/catalog.js';
+import { sha256 } from '../../../shared/hash.js';
 import { getProjectContext } from '../../../shared/paths.js';
 import { askForNotionDocsParentPage } from '../../interactive-guidance/index.js';
+import { renderTemplateForSync } from '../../template-catalog-rendering/index.js';
 import { getWorkflowMutationReadiness } from '../../workflow-mutation-readiness/index.js';
-import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, renderMissingWorkflowFiles, resolveSelectableMcpServerById, writeSibuState, } from '../../workflow-target-planning/index.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowSkillsImpliedByMcpServers, getWorkflowTargets, renderMissingWorkflowFiles, resolveSelectableMcpServerById, writeSibuState, } from '../../workflow-target-planning/index.js';
 const defaultDependencies = {
     askForNotionDocsParentPage,
 };
@@ -71,11 +73,13 @@ function applySelectedMcpServer({ rootPath, statePath, state, selectionResult, m
     const selectedLanguageSkills = getSelectedLanguageSkillsFromState(state);
     const selectedFrameworkSkills = getSelectedFrameworkSkillsFromState(state);
     const selectedArchitectureSkill = getSelectedArchitectureSkillFromState(state);
-    const selectedWorkflowSkills = getSelectedWorkflowSkillsFromState(state);
+    const currentWorkflowSkills = getSelectedWorkflowSkillsFromState(state);
+    const impliedWorkflowSkills = getWorkflowSkillsImpliedByMcpServers(selectionResult.selectedMcpServers.map((server) => server.id));
+    const selectedWorkflowSkills = mergeWorkflowSkills(currentWorkflowSkills, impliedWorkflowSkills);
     const selectedDatabaseSkills = getSelectedDatabaseSkillsFromState(state);
-    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, getSelectedMcpServersFromState(state));
+    const previousTargets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, currentWorkflowSkills, selectedDatabaseSkills, getSelectedMcpServersFromState(state));
     const targets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectionResult.selectedMcpServers);
-    const affectedTargets = getAffectedMcpTargets(previousTargets, targets);
+    const affectedTargets = getAffectedTargets(previousTargets, targets);
     const preflightError = getMcpUsePreflightError({ rootPath, state, affectedTargets, previousTargets });
     if (preflightError) {
         log.error(preflightError);
@@ -83,8 +87,13 @@ function applySelectedMcpServer({ rootPath, statePath, state, selectionResult, m
         process.exitCode = 1;
         return;
     }
+    const agentsTarget = targets.find((target) => target.label === 'AGENTS.md');
+    if (!agentsTarget) {
+        throw new Error('AGENTS.md target is missing from workflow targets.');
+    }
+    const nonAgentTargets = affectedTargets.filter((target) => target.label !== 'AGENTS.md');
     const files = renderMissingWorkflowFiles({
-        missingTargets: affectedTargets,
+        missingTargets: nonAgentTargets,
         selectedLanguageSkills,
         selectedFrameworkSkills,
         selectedArchitectureSkill,
@@ -95,9 +104,23 @@ function applySelectedMcpServer({ rootPath, statePath, state, selectionResult, m
     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, 'utf8');
+        fs.writeFileSync(file.targetPath, file.contents, fileAlreadyExists ? 'utf8' : { encoding: 'utf8', flag: 'wx' });
         log.success(`${fileAlreadyExists ? 'Updated' : 'Created'} ${file.label}`);
     }
+    if (affectedTargets.some((target) => target.label === 'AGENTS.md')) {
+        const agentsContents = renderTemplateForSync({
+            templateRelativePath: agentsTarget.templateRelativePath,
+            currentPath: agentsTarget.targetPath,
+            selectedLanguageSkills,
+            selectedFrameworkSkills,
+            selectedArchitectureSkill,
+            selectedWorkflowSkills,
+            selectedDatabaseSkills,
+            selectedMcpServers: selectionResult.selectedMcpServers,
+        });
+        fs.writeFileSync(agentsTarget.targetPath, agentsContents, 'utf8');
+        log.success('Updated AGENTS.md skill routing');
+    }
     writeSibuState({
         rootPath,
         statePath,
@@ -113,20 +136,45 @@ function applySelectedMcpServer({ rootPath, statePath, state, selectionResult, m
     });
     log.success(`Updated ${STATE_RELATIVE_PATH}`);
     log.success(`Added ${selectionResult.serverName}.`);
+    for (const skill of impliedWorkflowSkills.filter((skill) => !currentWorkflowSkills.some((currentSkill) => currentSkill.id === skill.id))) {
+        log.success(`Added ${skill.name}.`);
+    }
     log.info('Sibu configured MCP files only; prerequisites, credentials, and provider authentication remain user-owned.');
 }
-function getAffectedMcpTargets(previousTargets, targets) {
+function getAffectedTargets(previousTargets, targets) {
     const previousTargetPaths = new Set(previousTargets.map((target) => target.targetPath));
-    return targets.filter((target) => target.mcpConfigAgentId || (!previousTargetPaths.has(target.targetPath) && target.targetKind === 'mcp-config'));
+    const newTargets = targets.filter((target) => !previousTargetPaths.has(target.targetPath) && (target.targetKind === 'skill' || target.targetKind === 'mcp-config'));
+    const mcpConfigTargets = targets.filter((target) => target.mcpConfigAgentId);
+    const agentsTarget = targets.find((target) => target.label === 'AGENTS.md');
+    const affectedTargets = new Map();
+    for (const target of [...mcpConfigTargets, ...newTargets, ...(newTargets.some((target) => target.targetKind === 'skill') && agentsTarget ? [agentsTarget] : [])]) {
+        affectedTargets.set(target.targetPath, target);
+    }
+    return [...affectedTargets.values()];
+}
+function mergeWorkflowSkills(...skillGroups) {
+    const skillsById = new Map();
+    for (const skill of skillGroups.flat()) {
+        skillsById.set(skill.id, skill);
+    }
+    return [...skillsById.values()];
 }
 function getMcpUsePreflightError({ rootPath, state, affectedTargets, previousTargets, }) {
     const previousTargetPaths = new Set(previousTargets.map((target) => target.targetPath));
     for (const target of affectedTargets) {
         const relativePath = path.relative(rootPath, target.targetPath);
         if (previousTargetPaths.has(target.targetPath)) {
-            if (!state.managedFiles[relativePath]) {
+            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.`;
+            }
             continue;
         }
         if (fs.existsSync(target.targetPath)) {

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

@@ -6,7 +6,14 @@ import { STATE_RELATIVE_PATH } from '../../shared/catalog.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 { getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../workflow-target-planning/index.js';
+import { getWorkflowSkillsImpliedByMcpServers, getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../workflow-target-planning/index.js';
+function mergeWorkflowSkills(...skillGroups) {
+    const skillsById = new Map();
+    for (const skill of skillGroups.flat()) {
+        skillsById.set(skill.id, skill);
+    }
+    return [...skillsById.values()];
+}
 const defaultDependencies = {
     renderIntro,
     askForSupportedAgents,
@@ -41,12 +48,16 @@ export async function handleInitProject(_command, dependencies = defaultDependen
     }
     const selectedAgents = await dependencies.askForSupportedAgents();
     const selectedMcpServers = await dependencies.askForMcpServers();
+    const impliedWorkflowSkills = getWorkflowSkillsImpliedByMcpServers(selectedMcpServers.map((server) => server.id));
+    for (const skill of impliedWorkflowSkills) {
+        log.info(`${skill.name} will be included because its matching MCP server was selected.`);
+    }
     const notionDocsParentPage = selectedMcpServers.some((server) => server.id === 'notion') ? await dependencies.askForNotionDocsParentPage() : undefined;
     const selectedLanguageSkills = await dependencies.askForLanguageSkills();
     const selectedFrameworkSkills = await dependencies.askForFrameworkSkills();
     const selectedDatabaseSkills = await dependencies.askForDatabaseSkills();
     const selectedArchitectureSkill = await dependencies.askForArchitectureSkill();
-    const selectedWorkflowSkills = await dependencies.askForWorkflowSkills();
+    const selectedWorkflowSkills = mergeWorkflowSkills(impliedWorkflowSkills, await dependencies.askForWorkflowSkills(impliedWorkflowSkills.map((skill) => skill.id)));
     const targets = getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectedMcpServers);
     const missingTargets = targets.filter((target) => !fs.existsSync(target.targetPath));
     log.message('I will create this project’s initial AI workflow files.');

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

@@ -2,13 +2,17 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { log } from '@clack/prompts';
 import { STATE_RELATIVE_PATH } from '../../../shared/catalog.js';
-import { resolveSelectableSkillById } from '../../workflow-target-planning/index.js';
+import { askForNotionDocsParentPage } from '../../interactive-guidance/index.js';
+import { getMcpServersRequiredByWorkflowSkills, 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) {
+import { getSelectedAgentsFromState, getSelectedMcpServersFromState, getWorkflowTargets, renderMissingWorkflowFiles, writeSibuState } from '../../workflow-target-planning/index.js';
+const defaultDependencies = {
+    askForNotionDocsParentPage,
+};
+export async function handleUseSkill(command, dependencies = defaultDependencies) {
     const { rootPath, statePath } = getProjectContext();
     const readiness = getWorkflowMutationReadiness({ rootPath, statePath });
     if (!readiness.ok) {
@@ -34,7 +38,7 @@ export async function handleUseSkill(command) {
             process.exitCode = 1;
             return;
         case 'selected':
-            applySelectedSkill({ rootPath, statePath, state: readiness.state, selectionResult });
+            await applySelectedSkill({ rootPath, statePath, state: readiness.state, selectionResult, dependencies });
             return;
     }
 }
@@ -132,7 +136,7 @@ export function getNextSkillSelection(state, skillName) {
             };
     }
 }
-function applySelectedSkill({ rootPath, statePath, state, selectionResult, }) {
+async function applySelectedSkill({ rootPath, statePath, state, selectionResult, dependencies, }) {
     const plan = buildSkillApplicationPlan({ rootPath, state, selectionResult });
     const preflightError = getSkillApplicationPreflightError({ rootPath, state, plan });
     if (preflightError) {
@@ -141,25 +145,37 @@ function applySelectedSkill({ rootPath, statePath, state, selectionResult, }) {
         process.exitCode = 1;
         return;
     }
-    const agentsContents = renderTemplateForSync({
-        templateRelativePath: plan.agentsTarget.templateRelativePath,
-        currentPath: plan.agentsTarget.targetPath,
+    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,
     });
-    const [newSkillFile] = renderMissingWorkflowFiles({
-        missingTargets: [plan.newSkillTarget],
+    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.mkdirSync(path.dirname(newSkillFile.targetPath), { recursive: true });
-    fs.writeFileSync(newSkillFile.targetPath, newSkillFile.contents, { encoding: 'utf8', flag: 'wx' });
-    log.success(`Created ${newSkillFile.label}`);
     fs.writeFileSync(plan.agentsTarget.targetPath, agentsContents, 'utf8');
     log.success('Updated AGENTS.md skill routing');
     writeSibuState({
@@ -171,43 +187,79 @@ function applySelectedSkill({ rootPath, statePath, state, selectionResult, }) {
         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 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 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 newSkillTarget = targets.find((target) => !previousTargetPaths.has(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 (!newSkillTarget) {
+    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.');
     }
-    return { agentsTarget, newSkillTarget, targets, selectedAgents };
+    const affectedTargets = dedupeTargets([...newTargets, ...mcpConfigTargets, agentsTarget]);
+    return { agentsTarget, newTargets, affectedTargets, targets, selectedAgents, selectedMcpServers };
 }
 function getSkillApplicationPreflightError({ rootPath, state, plan }) {
-    if (fs.existsSync(plan.newSkillTarget.targetPath)) {
-        return `${path.relative(rootPath, plan.newSkillTarget.targetPath)} already exists but is not recorded for this selection.`;
+    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.`;
+        }
     }
-    const agentsRelativePath = path.relative(rootPath, plan.agentsTarget.targetPath);
-    const agentsManagedFile = state.managedFiles[agentsRelativePath];
-    if (!agentsManagedFile) {
-        return 'AGENTS.md is not recorded in `.sibu/state.json`.';
+    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.`;
+        }
     }
-    if (!fs.existsSync(plan.agentsTarget.targetPath)) {
-        return 'AGENTS.md is missing.';
+    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);
     }
-    const agentsCurrentHash = sha256(fs.readFileSync(plan.agentsTarget.targetPath, 'utf8'));
-    if (agentsCurrentHash !== agentsManagedFile.sha256) {
-        return 'AGENTS.md has changed since Sibu last recorded it.';
+    return [...serversById.values()];
+}
+async function getNextMcpServerConfigs({ state, selectedMcpServers, dependencies, }) {
+    if (!selectedMcpServers.some((server) => server.id === 'notion') || state.selectedMcpServers?.includes('notion')) {
+        return state.mcpServerConfigs;
     }
-    return undefined;
+    const docsParentPage = await dependencies.askForNotionDocsParentPage();
+    return {
+        ...state.mcpServerConfigs,
+        notion: { docsParentPage },
+    };
 }
 function getSelectedLanguageSkillsFromState(state) {
     return (state.selectedLanguageSkills ?? []).map(getLanguageSkillById);

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

@@ -13,6 +13,7 @@ export function applySyncAction({ rootPath, state, manifest, preview, action, })
     const currentTemplateVersion = preview.currentTemplateVersion ?? getTemplateVersion(manifest, managedFile.template);
     switch (action) {
         case 'apply-update': {
+            recordImpliedWorkflowSkill(nextState, preview);
             const contents = renderTemplateForSync({
                 templateRelativePath: managedFile.template,
                 currentPath: targetPath,
@@ -37,6 +38,7 @@ export function applySyncAction({ rootPath, state, manifest, preview, action, })
             return { state: nextState, changedFiles: true, changedState: true };
         }
         case 'mark-reviewed': {
+            recordImpliedWorkflowSkill(nextState, preview);
             const contents = fs.readFileSync(targetPath, 'utf8');
             nextState.templateVersion = manifest.templateVersion;
             nextState.updatedAt = new Date().toISOString();
@@ -85,3 +87,12 @@ export function applySyncAction({ rootPath, state, manifest, preview, action, })
             return { state, changedFiles: false, changedState: false };
     }
 }
+function recordImpliedWorkflowSkill(state, preview) {
+    if (!preview.impliedWorkflowSkillId) {
+        return;
+    }
+    if (state.selectedWorkflowSkills?.includes(preview.impliedWorkflowSkillId)) {
+        return;
+    }
+    state.selectedWorkflowSkills = [...(state.selectedWorkflowSkills ?? []), preview.impliedWorkflowSkillId];
+}

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, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, } from '../workflow-target-planning/index.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowSkillsImpliedByMcpServers, getWorkflowTargets, } from '../workflow-target-planning/index.js';
 const ACTIONABLE_SYNC_PREVIEW_STATUSES = new Set([
     'new-template',
     'missing',
@@ -32,7 +32,19 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
     const selectedWorkflowSkills = getSelectedWorkflowSkillsFromState(state);
     const selectedDatabaseSkills = getSelectedDatabaseSkillsFromState(state);
     const selectedMcpServers = getSelectedMcpServersFromState(state);
-    const previews = Object.entries(state.managedFiles).map(([relativePath, managedFile]) => getManagedFileSyncPreview({
+    const impliedWorkflowSkills = getWorkflowSkillsImpliedByMcpServers(selectedMcpServers.map((server) => server.id));
+    const plannedWorkflowSkills = mergeWorkflowSkills(selectedWorkflowSkills, impliedWorkflowSkills);
+    const missingImpliedWorkflowSkills = impliedWorkflowSkills.filter((skill) => !selectedWorkflowSkills.some((selectedSkill) => selectedSkill.id === skill.id));
+    const previews = [];
+    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, plannedWorkflowSkills, selectedDatabaseSkills, selectedMcpServers);
+    const alreadyPreviewedPaths = new Set();
+    for (const skill of missingImpliedWorkflowSkills) {
+        for (const preview of getNewExpectedTargetPreviews({ rootPath, manifest, state, expectedTargets, workflowSkill: skill })) {
+            previews.push(preview);
+            alreadyPreviewedPaths.add(preview.relativePath);
+        }
+    }
+    previews.push(...Object.entries(state.managedFiles).map(([relativePath, managedFile]) => getManagedFileSyncPreview({
         rootPath,
         manifest,
         relativePath,
@@ -40,46 +52,65 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
         selectedLanguageSkills,
         selectedFrameworkSkills,
         selectedArchitectureSkill,
-        selectedWorkflowSkills,
+        selectedWorkflowSkills: plannedWorkflowSkills,
         selectedDatabaseSkills,
         selectedMcpServers,
-    }));
-    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectedMcpServers);
+    })));
     for (const target of expectedTargets) {
         const relativePath = path.relative(rootPath, target.targetPath);
-        if (state.managedFiles[relativePath]) {
-            continue;
-        }
-        const template = manifest.templates[target.templateRelativePath];
-        if (!template) {
-            previews.push({
-                relativePath,
-                managedFile: {
-                    template: target.templateRelativePath,
-                    templateVersion: 'unknown',
-                    sha256: '',
-                },
-                status: 'unknown-template',
-                changes: [],
-                hasLocalFile: fs.existsSync(target.targetPath),
-            });
+        if (state.managedFiles[relativePath] || alreadyPreviewedPaths.has(relativePath)) {
             continue;
         }
-        previews.push({
+        previews.push(getNewExpectedTargetPreview({ rootPath, manifest, target }));
+    }
+    return previews;
+}
+function getNewExpectedTargetPreviews({ rootPath, manifest, state, expectedTargets, workflowSkill, }) {
+    const workflowSkillTargetPaths = new Set(Object.values(workflowSkill.targetRelativePathsByAgent));
+    return expectedTargets
+        .filter((target) => workflowSkillTargetPaths.has(path.relative(rootPath, target.targetPath)))
+        .filter((target) => !state.managedFiles[path.relative(rootPath, target.targetPath)])
+        .map((target) => ({
+        ...getNewExpectedTargetPreview({ rootPath, manifest, target }),
+        impliedWorkflowSkillId: workflowSkill.id,
+    }));
+}
+function getNewExpectedTargetPreview({ rootPath, manifest, target }) {
+    const relativePath = path.relative(rootPath, target.targetPath);
+    const template = manifest.templates[target.templateRelativePath];
+    if (!template) {
+        return {
             relativePath,
             managedFile: {
                 template: target.templateRelativePath,
-                templateVersion: template.version,
+                templateVersion: 'unknown',
                 sha256: '',
-                status: 'managed',
             },
-            status: 'new-template',
-            currentTemplateVersion: template.version,
-            changes: template.changes,
+            status: 'unknown-template',
+            changes: [],
             hasLocalFile: fs.existsSync(target.targetPath),
-        });
+        };
     }
-    return previews;
+    return {
+        relativePath,
+        managedFile: {
+            template: target.templateRelativePath,
+            templateVersion: template.version,
+            sha256: '',
+            status: 'managed',
+        },
+        status: 'new-template',
+        currentTemplateVersion: template.version,
+        changes: template.changes,
+        hasLocalFile: fs.existsSync(target.targetPath),
+    };
+}
+function mergeWorkflowSkills(...skillGroups) {
+    const skillsById = new Map();
+    for (const skill of skillGroups.flat()) {
+        skillsById.set(skill.id, skill);
+    }
+    return [...skillsById.values()];
 }
 function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, selectedMcpServers, }) {
     if (managedFile.status === 'unmanaged') {

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

@@ -71,6 +71,15 @@ export const MANDATORY_SKILLS = [
             windsurf: '.agents/skills/ai-implementation-plan-executor/SKILL.md',
         },
     },
+    {
+        templateRelativePath: 'skills/feature-idea-capture/SKILL.md',
+        targetRelativePathsByAgent: {
+            codex: '.agents/skills/feature-idea-capture/SKILL.md',
+            gemini: '.agents/skills/feature-idea-capture/SKILL.md',
+            claude: '.agents/skills/feature-idea-capture/SKILL.md',
+            windsurf: '.agents/skills/feature-idea-capture/SKILL.md',
+        },
+    },
 ];
 export const SELECTABLE_LANGUAGE_SKILLS = [
     {
@@ -211,7 +220,60 @@ export const SELECTABLE_WORKFLOW_SKILLS = [
             windsurf: '.agents/skills/ux-expert/SKILL.md',
         },
     },
+    {
+        id: 'export-to-github',
+        name: 'Export to GitHub',
+        description: "Install guidance for exporting a named feature's Epics and User Stories to GitHub using the configured GitHub MCP server",
+        routingInstruction: "For exporting a feature's Epics and User Stories to GitHub issues or sub-issues, use `export-to-github`.",
+        templateRelativePath: 'skills/export-to-github/SKILL.md',
+        targetRelativePathsByAgent: {
+            codex: '.agents/skills/export-to-github/SKILL.md',
+            gemini: '.agents/skills/export-to-github/SKILL.md',
+            claude: '.agents/skills/export-to-github/SKILL.md',
+            windsurf: '.agents/skills/export-to-github/SKILL.md',
+        },
+    },
+    {
+        id: 'export-to-notion',
+        name: 'Export to Notion',
+        description: "Install guidance for exporting a named feature's feature brief, UX design, and technical design to Notion using the configured Notion MCP server",
+        routingInstruction: "For exporting a feature's feature brief, UX design, or technical design to Notion, use `export-to-notion`.",
+        templateRelativePath: 'skills/export-to-notion/SKILL.md',
+        targetRelativePathsByAgent: {
+            codex: '.agents/skills/export-to-notion/SKILL.md',
+            gemini: '.agents/skills/export-to-notion/SKILL.md',
+            claude: '.agents/skills/export-to-notion/SKILL.md',
+            windsurf: '.agents/skills/export-to-notion/SKILL.md',
+        },
+    },
 ];
+const EXPORT_WORKFLOW_SKILL_MCP_REQUIREMENTS = {
+    'export-to-github': 'github',
+    'export-to-notion': 'notion',
+};
+export function getMcpServersRequiredByWorkflowSkills(workflowSkillIds) {
+    const requiredServerIds = new Set();
+    for (const workflowSkillId of workflowSkillIds) {
+        const requiredServerId = getRequiredMcpServerIdForWorkflowSkill(workflowSkillId);
+        if (requiredServerId) {
+            requiredServerIds.add(requiredServerId);
+        }
+    }
+    return SELECTABLE_MCP_SERVERS.filter((server) => requiredServerIds.has(server.id));
+}
+export function getWorkflowSkillsImpliedByMcpServers(mcpServerIds) {
+    const selectedServerIds = new Set(mcpServerIds);
+    const impliedSkillIds = Object.entries(EXPORT_WORKFLOW_SKILL_MCP_REQUIREMENTS)
+        .filter(([, requiredServerId]) => selectedServerIds.has(requiredServerId))
+        .map(([workflowSkillId]) => workflowSkillId);
+    return SELECTABLE_WORKFLOW_SKILLS.filter((skill) => impliedSkillIds.includes(skill.id));
+}
+function getRequiredMcpServerIdForWorkflowSkill(workflowSkillId) {
+    if (workflowSkillId === 'export-to-github' || workflowSkillId === 'export-to-notion') {
+        return EXPORT_WORKFLOW_SKILL_MCP_REQUIREMENTS[workflowSkillId];
+    }
+    return undefined;
+}
 export const SELECTABLE_MCP_SERVERS = [
     {
         id: 'github',

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

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

package/package.json

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

package/templates/AGENTS.md

@@ -47,6 +47,7 @@ For planned product/feature work, use this pipeline: product vision -> deep modu
 - For requests to create Epics, User Stories, Scrum planning artifacts, backlog slices, or delivery plans from an approved feature brief and technical design, use `scrum-master-planner`.
 - For explicit planning-only requests to turn a specific User Story into an implementation checklist, coding plan, step-by-step execution plan, or baby-step plan without implementation, use `ai-implementation-planner` and stop after writing the plan. Treat a request as planning-only only when the user explicitly says planning-only, "do not implement," or asks to create the plan without execution.
 - For requests to plan, implement, execute, continue, or work through a specific User Story under `docs/features/<feature-slug>/epics/<epic-slug>/stories/<order>-<story-slug>.md`, an Epic, or an existing story implementation plan under `docs/features/<feature-slug>/epics/<epic-slug>/stories/<order>-<story-slug>.impl_plan/`, use `ai-implementation-plan-executor`; when the story plan is missing, the executor must create it with `ai-implementation-planner` and immediately continue into implementation without a separate plan approval gate.
+- For requests to capture, save, jot down, or add rough future feature ideas, use `feature-idea-capture`.
 {{OPTIONAL_SKILL_ROUTING}}
 
 ## Sibu maintenance