@juancr11/sibu 0.15.1 → 0.17.0

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

@@ -10,7 +10,7 @@ import { renderIntro } from '../../interactive-guidance/index.js';
 import { cloneState, readStateForDoctor, writeStateFile } from '../../workflow-state-registry/index.js';
 import { getTemplateVersion, readTemplateManifest, renderTemplateForSync } from '../../template-catalog-rendering/index.js';
 import { removeUndefinedFields } from '../../../shared/object.js';
-import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, } from '../../workflow-target-planning/index.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedWorkflowSkillsFromState, getSkillTargetsForAgents, } from '../../workflow-target-planning/index.js';
 export async function handleStopManagingFile({ skillName }) {
     await renderIntro();
     intro(chalk.cyan('Updating skill management'));
@@ -136,13 +136,7 @@ function removeSelectedSkill(state, resolved) {
     }
 }
 function getSkillManagedPaths(rootPath, state, resolved) {
-    const relativePaths = new Set();
-    for (const agent of getSelectedAgentsFromState(state)) {
-        const relativePath = resolved.skill.targetRelativePathsByAgent[agent.id];
-        if (relativePath) {
-            relativePaths.add(relativePath);
-        }
-    }
+    const relativePaths = new Set(getSkillTargetsForAgents(resolved.skill, getSelectedAgentsFromState(state)).map((target) => target.targetRelativePath));
     return [...relativePaths].map((relativePath) => ({
         relativePath,
         absolutePath: path.join(rootPath, relativePath),

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

@@ -1,4 +1,4 @@
-import { cancel, isCancel, select } from '@clack/prompts';
+import { cancel, confirm, isCancel, select } from '@clack/prompts';
 export async function askForSyncAction(preview) {
     if (preview.status === 'update-available') {
         const action = await select({
@@ -56,6 +56,19 @@ export async function askForSyncAction(preview) {
     });
     return handleSyncActionCancel(action);
 }
+export async function askForUnsupportedAgentCleanup(plan) {
+    const shouldCleanUp = await confirm({
+        message: plan.removesSibuState
+            ? 'Remove unsupported agent state and all Sibu-managed workflow files?'
+            : 'Remove unsupported agent selections and obsolete Sibu-managed files?',
+        initialValue: true,
+    });
+    if (isCancel(shouldCleanUp)) {
+        cancel('Sync cancelled.');
+        process.exit(0);
+    }
+    return shouldCleanUp;
+}
 function handleSyncActionCancel(action) {
     if (isCancel(action)) {
         cancel('Sync cancelled.');

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

@@ -5,12 +5,22 @@ import { getProjectContext } from '../../shared/paths.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 { askForSyncAction, askForUnsupportedAgentCleanup } from './action-prompt.js';
 import { applySyncAction } from './apply-action.js';
 import { logSyncPreview } from './log-preview.js';
 import { getSyncPreviews, isActionableSyncPreview, shouldAskForSyncAction } from './sync-preview.js';
-export async function handleSyncProject(_command) {
-    await renderIntro();
+import { applyUnsupportedAgentCleanup, getUnsupportedAgentCleanupPlan } from './unsupported-agent-cleanup.js';
+const defaultSyncProjectDependencies = {
+    renderIntro,
+    askForUnsupportedAgentCleanup,
+    askForNewLanguageSkills,
+    askForMissingFrameworkSkills,
+    askForNewArchitectureSkill,
+    askForSyncAction,
+};
+export async function handleSyncProject(_command, dependencies = {}) {
+    const syncDependencies = { ...defaultSyncProjectDependencies, ...dependencies };
+    await syncDependencies.renderIntro();
     intro(chalk.cyan('Reviewing workflow updates'));
     const { rootPath, statePath } = getProjectContext();
     const stateResult = readStateForDoctor(statePath);
@@ -21,9 +31,46 @@ export async function handleSyncProject(_command) {
         process.exitCode = 1;
         return;
     }
-    const languageSkillSelection = await askForNewLanguageSkills(stateResult.state);
-    const frameworkSkillSelection = await askForMissingFrameworkSkills(languageSkillSelection.state);
-    const architectureSkillSelection = await askForNewArchitectureSkill(frameworkSkillSelection.state);
+    const cleanupPlan = getUnsupportedAgentCleanupPlan({ rootPath, state: stateResult.state });
+    if (cleanupPlan) {
+        log.warn('This project has agent selections that are no longer supported by Sibu.');
+        log.info(`Unsupported selections: ${cleanupPlan.unsupportedAgentIds.join(', ')}`);
+        if (cleanupPlan.filePathsToDelete.length > 0) {
+            log.info('Sibu-managed files to remove:');
+            for (const relativePath of cleanupPlan.filePathsToDelete) {
+                log.info(`- ${relativePath}`);
+            }
+        }
+        else {
+            log.info('No Sibu-managed files need to be deleted for this cleanup.');
+        }
+        if (cleanupPlan.removesSibuState) {
+            log.warn(`No supported agents will remain, so ${STATE_RELATIVE_PATH} will be removed after cleanup.`);
+        }
+        const shouldCleanUp = await syncDependencies.askForUnsupportedAgentCleanup(cleanupPlan);
+        if (!shouldCleanUp) {
+            log.warn('Unsupported agent cleanup was skipped.');
+            log.info('Run `sibu sync` again and accept cleanup before reviewing other workflow updates.');
+            outro(chalk.yellow('Sync stopped.'));
+            process.exitCode = 1;
+            return;
+        }
+        const cleanupResult = applyUnsupportedAgentCleanup({ rootPath, statePath, state: stateResult.state, plan: cleanupPlan });
+        for (const relativePath of cleanupResult.removedFiles) {
+            log.success(`Removed ${relativePath}`);
+        }
+        if (cleanupResult.removedStateFile) {
+            log.success(`Removed ${STATE_RELATIVE_PATH}`);
+            outro(chalk.green('Unsupported agent cleanup complete.'));
+            return;
+        }
+        writeStateFile(statePath, cleanupResult.state);
+        log.success(`Updated ${STATE_RELATIVE_PATH}`);
+        stateResult.state = cleanupResult.state;
+    }
+    const languageSkillSelection = await syncDependencies.askForNewLanguageSkills(stateResult.state);
+    const frameworkSkillSelection = await syncDependencies.askForMissingFrameworkSkills(languageSkillSelection.state);
+    const architectureSkillSelection = await syncDependencies.askForNewArchitectureSkill(frameworkSkillSelection.state);
     let state = architectureSkillSelection.state;
     const manifest = readTemplateManifest();
     const previews = getSyncPreviews({ rootPath, state, manifest });
@@ -56,7 +103,7 @@ export async function handleSyncProject(_command) {
         if (!shouldAskForSyncAction(preview)) {
             continue;
         }
-        const action = await askForSyncAction(preview);
+        const action = await syncDependencies.askForSyncAction(preview);
         if (action === 'skip') {
             log.info(`Skipped ${preview.relativePath}.`);
             continue;

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

@@ -3,3 +3,4 @@ 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';
+export { applyUnsupportedAgentCleanup, getUnsupportedAgentCleanupPlan } from './unsupported-agent-cleanup.js';

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, getWorkflowSkillsImpliedByMcpServers, getWorkflowTargets, } from '../workflow-target-planning/index.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getSkillTargetsForAgents, getWorkflowSkillsImpliedByMcpServers, getWorkflowTargets, } from '../workflow-target-planning/index.js';
 const ACTIONABLE_SYNC_PREVIEW_STATUSES = new Set([
     'new-template',
     'missing',
@@ -39,7 +39,7 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
     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 })) {
+        for (const preview of getNewExpectedTargetPreviews({ rootPath, manifest, state, expectedTargets, selectedAgents: getSelectedAgentsFromState(state), workflowSkill: skill })) {
             previews.push(preview);
             alreadyPreviewedPaths.add(preview.relativePath);
         }
@@ -65,8 +65,8 @@ export function getSyncPreviews({ rootPath, state, manifest }) {
     }
     return previews;
 }
-function getNewExpectedTargetPreviews({ rootPath, manifest, state, expectedTargets, workflowSkill, }) {
-    const workflowSkillTargetPaths = new Set(Object.values(workflowSkill.targetRelativePathsByAgent));
+function getNewExpectedTargetPreviews({ rootPath, manifest, state, expectedTargets, selectedAgents, workflowSkill, }) {
+    const workflowSkillTargetPaths = new Set(getSkillTargetsForAgents(workflowSkill, selectedAgents).map((target) => target.targetRelativePath));
     return expectedTargets
         .filter((target) => workflowSkillTargetPaths.has(path.relative(rootPath, target.targetPath)))
         .filter((target) => !state.managedFiles[path.relative(rootPath, target.targetPath)])

package/bin/modules/sync-review/unsupported-agent-cleanup.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedDatabaseSkillsFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getSelectedMcpServersFromState, getSelectedWorkflowSkillsFromState, getWorkflowTargets, SUPPORTED_AGENTS, } from '../workflow-target-planning/index.js';
+import { cloneState } from '../workflow-state-registry/index.js';
+export function getUnsupportedAgentCleanupPlan({ rootPath, state }) {
+    const supportedAgentIds = new Set(SUPPORTED_AGENTS.map((agent) => agent.id));
+    const unsupportedAgentIds = state.selectedAgents.filter((agentId) => !supportedAgentIds.has(agentId));
+    if (unsupportedAgentIds.length === 0) {
+        return undefined;
+    }
+    const remainingSupportedAgents = getSelectedAgentsFromState(state);
+    const obsoleteManagedFilePaths = getObsoleteManagedFilePaths({ rootPath, state, remainingSupportedAgents });
+    const filePathsToDelete = obsoleteManagedFilePaths.filter((relativePath) => state.managedFiles[relativePath]?.status !== 'unmanaged');
+    return {
+        unsupportedAgentIds,
+        remainingSupportedAgents,
+        obsoleteManagedFilePaths,
+        filePathsToDelete,
+        removesSibuState: remainingSupportedAgents.length === 0,
+    };
+}
+export function applyUnsupportedAgentCleanup({ rootPath, statePath, state, plan, }) {
+    const removedFiles = [];
+    for (const relativePath of plan.filePathsToDelete) {
+        const targetPath = path.join(rootPath, relativePath);
+        if (!fs.existsSync(targetPath)) {
+            continue;
+        }
+        fs.rmSync(targetPath, { recursive: true, force: true });
+        removedFiles.push(relativePath);
+    }
+    if (plan.removesSibuState) {
+        fs.rmSync(statePath, { force: true });
+        return { removedStateFile: true, removedFiles };
+    }
+    const unsupportedAgentIds = new Set(plan.unsupportedAgentIds);
+    const obsoleteManagedFilePaths = new Set(plan.obsoleteManagedFilePaths);
+    const nextState = cloneState(state);
+    nextState.selectedAgents = nextState.selectedAgents.filter((agentId) => !unsupportedAgentIds.has(agentId));
+    nextState.updatedAt = new Date().toISOString();
+    for (const relativePath of obsoleteManagedFilePaths) {
+        delete nextState.managedFiles[relativePath];
+    }
+    return {
+        removedStateFile: false,
+        removedFiles,
+        state: nextState,
+    };
+}
+function getObsoleteManagedFilePaths({ rootPath, state, remainingSupportedAgents, }) {
+    if (remainingSupportedAgents.length === 0) {
+        return Object.keys(state.managedFiles);
+    }
+    const expectedTargets = getWorkflowTargets(rootPath, remainingSupportedAgents, getSelectedLanguageSkillsFromState(state), getSelectedFrameworkSkillsFromState(state), getSelectedArchitectureSkillFromState(state), getSelectedWorkflowSkillsFromState(state), getSelectedDatabaseSkillsFromState(state), getSelectedMcpServersFromState(state));
+    const expectedManagedFilePaths = new Set(expectedTargets.map((target) => path.relative(rootPath, target.targetPath)));
+    return Object.keys(state.managedFiles).filter((relativePath) => !expectedManagedFilePaths.has(relativePath));
+}

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

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

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

@@ -27,7 +27,9 @@ export function renderTemplateForSync({ templateRelativePath, currentPath, selec
     if (contents.includes('{{PROJECT_OVERVIEW}}')) {
         contents = contents.replace('{{PROJECT_OVERVIEW}}', extractProjectOverview(currentPath) ?? 'Describe this project.');
     }
-    return renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
+    contents = renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
+    contents = renderWorkerToolboxRoutingPlaceholders(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills);
+    return contents;
 }
 export function renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = []) {
     if (!contents.includes('{{OPTIONAL_SKILL_ROUTING}}')) {
@@ -38,6 +40,51 @@ export function renderSkillRouting(contents, selectedLanguageSkills, selectedFra
         .join('\n');
     return contents.replace('{{OPTIONAL_SKILL_ROUTING}}', optionalRouting);
 }
+export function renderWorkerToolboxRouting({ profile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], }) {
+    const selectedSkills = collectWorkerRelevantSkills({
+        selectedLanguageSkills,
+        selectedFrameworkSkills,
+        selectedArchitectureSkill,
+        selectedWorkflowSkills,
+        selectedDatabaseSkills,
+    });
+    const selectedSkillLines = selectedSkills.map((skill) => `- ${skill.name}: read \`${getSharedSkillTargetPath(skill)}\` when relevant. ${skill.routingInstruction}`);
+    const selectedSkillsSection = selectedSkillLines.length > 0
+        ? selectedSkillLines.join('\n')
+        : '- No optional implementation-relevant Sibu skills are selected for this project. Use source artifacts and flag unmapped patterns as risks instead of guessing silently.';
+    return `## Focused ${profile} worker routing
+
+- Always read and apply \`.agents/skills/clean-code/SKILL.md\` before ${profile === 'planner' ? 'writing implementation plan steps' : 'editing code or running story execution'}.
+- Read the worker toolbox skill path provided in the main-agent packet before doing work.
+- Read every required skill path listed in the packet. If a required skill path is missing, stop and report the blocker to the main agent.
+- Read optional installed skill paths only when they are relevant to the story, touched files, source artifacts, or validation work.
+- Treat distilled skill constraints from the packet as binding task constraints.
+- If an optional relevant skill is not installed and you encounter an unmapped language, framework, database, or architecture pattern, do not guess silently; continue only when safe and flag the gap as a ${profile === 'planner' ? 'plan risk' : 'Review Gate risk'}.
+
+### Optional installed skills relevant to ${profile} work
+${selectedSkillsSection}`;
+}
+export function renderWorkerToolboxRoutingPlaceholders(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = []) {
+    const placeholderProfiles = [
+        { placeholder: '{{PLANNER_WORKER_ROUTING}}', profile: 'planner' },
+        { placeholder: '{{EXECUTOR_WORKER_ROUTING}}', profile: 'executor' },
+    ];
+    let renderedContents = contents;
+    for (const { placeholder, profile } of placeholderProfiles) {
+        if (!renderedContents.includes(placeholder)) {
+            continue;
+        }
+        renderedContents = renderedContents.replace(placeholder, renderWorkerToolboxRouting({
+            profile,
+            selectedLanguageSkills,
+            selectedFrameworkSkills,
+            selectedArchitectureSkill,
+            selectedWorkflowSkills,
+            selectedDatabaseSkills,
+        }));
+    }
+    return renderedContents;
+}
 export function renderMcpConfig({ agentId, baseContents, selectedMcpServers, }) {
     if (selectedMcpServers.length === 0) {
         return baseContents ?? renderJsonMcpConfig({});
@@ -45,7 +92,24 @@ export function renderMcpConfig({ agentId, baseContents, selectedMcpServers, })
     if (agentId === 'codex') {
         return renderCodexMcpConfig(baseContents ?? '', selectedMcpServers);
     }
-    return renderJsonMcpConfig(buildJsonMcpServerConfigs(agentId, selectedMcpServers));
+    return renderJsonMcpConfig(buildJsonMcpServerConfigs(agentId, selectedMcpServers), baseContents);
+}
+function collectWorkerRelevantSkills({ selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills, }) {
+    const implementationRelevantWorkflowSkills = selectedWorkflowSkills.filter((skill) => skill.id === 'ai-prompt-engineer-master' || skill.id === 'ux-expert');
+    return [
+        ...selectedLanguageSkills,
+        ...selectedFrameworkSkills,
+        ...selectedDatabaseSkills,
+        ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []),
+        ...implementationRelevantWorkflowSkills,
+    ];
+}
+function getSharedSkillTargetPath(skill) {
+    const sharedTargetPath = Object.values(skill.targetRelativePathsByAgent).find((targetPath) => targetPath !== undefined);
+    if (!sharedTargetPath) {
+        throw new Error(`Selectable skill ${skill.id} has no target path.`);
+    }
+    return sharedTargetPath;
 }
 export function extractProjectOverview(filePath) {
     if (!fs.existsSync(filePath)) {
@@ -93,6 +157,9 @@ function getMcpConfigAgentId(templateRelativePath) {
     if (templateRelativePath === 'mcp/gemini/settings.json') {
         return 'gemini';
     }
+    if (templateRelativePath === '.gemini/settings.json') {
+        return 'gemini';
+    }
     return undefined;
 }
 function buildJsonMcpServerConfigs(agentId, selectedMcpServers) {
@@ -128,8 +195,20 @@ function buildNotionMcpServerConfig() {
         url: 'https://mcp.notion.com/mcp',
     };
 }
-function renderJsonMcpConfig(mcpServers) {
-    return `${JSON.stringify({ mcpServers }, null, 2)}\n`;
+function renderJsonMcpConfig(mcpServers, baseContents) {
+    const baseConfig = parseJsonObject(baseContents);
+    baseConfig.mcpServers = mcpServers;
+    return `${JSON.stringify(baseConfig, null, 2)}\n`;
+}
+function parseJsonObject(contents) {
+    if (!contents?.trim()) {
+        return {};
+    }
+    const parsed = JSON.parse(contents);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('Expected JSON template to contain an object.');
+    }
+    return parsed;
 }
 function isTemplateManifest(value) {
     if (!value || typeof value !== 'object') {

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

@@ -1,5 +1,6 @@
 import { readStateForDoctor } from '../workflow-state-registry/index.js';
 import { getSyncPreviews, isActionableSyncPreview } from '../sync-review/index.js';
+import { getUnsupportedAgentCleanupPlan } from '../sync-review/unsupported-agent-cleanup.js';
 import { readTemplateManifest } from '../template-catalog-rendering/index.js';
 export function getWorkflowMutationReadiness({ rootPath, statePath }) {
     const stateResult = readStateForDoctor(statePath);
@@ -11,6 +12,14 @@ export function getWorkflowMutationReadiness({ rootPath, statePath }) {
         };
     }
     const manifest = readTemplateManifest();
+    const unsupportedAgentCleanupPlan = getUnsupportedAgentCleanupPlan({ rootPath, state: stateResult.state });
+    if (unsupportedAgentCleanupPlan) {
+        return {
+            ok: false,
+            message: 'Workflow state is not clean enough to select a skill safely.',
+            hint: 'Run `sibu sync` to review workflow state before selecting a skill.',
+        };
+    }
     const previews = getSyncPreviews({ rootPath, state: stateResult.state, manifest });
     const actionablePreviews = previews.filter(isActionableSyncPreview);
     if (actionablePreviews.length > 0) {