@juancr11/sibu 0.17.0 → 0.18.0

package/bin/support/expected-workflow-targets.js

@@ -0,0 +1,131 @@
+import path from 'node:path';
+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));
+}
+export function getSelectedFrameworkSkillsFromState(state) {
+    return SELECTABLE_FRAMEWORK_SKILLS.filter((skill) => state.selectedFrameworkSkills?.includes(skill.id));
+}
+export function getSelectedArchitectureSkillFromState(state) {
+    return SELECTABLE_ARCHITECTURE_SKILLS.find((skill) => skill.id === state.selectedArchitectureSkill);
+}
+export function getSelectedWorkflowSkillsFromState(state) {
+    return SELECTABLE_WORKFLOW_SKILLS.filter((skill) => state.selectedWorkflowSkills?.includes(skill.id));
+}
+export function getSelectedDatabaseSkillsFromState(state) {
+    return SELECTABLE_DATABASE_SKILLS.filter((skill) => state.selectedDatabaseSkills?.includes(skill.id));
+}
+export function getSelectedMcpServersFromState(state) {
+    return SELECTABLE_MCP_SERVERS.filter((server) => state.selectedMcpServers?.includes(server.id));
+}
+export function getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = []) {
+    const skillTargets = new Map();
+    const selectedSkills = [
+        ...MANDATORY_SKILLS,
+        ...selectedLanguageSkills,
+        ...selectedFrameworkSkills,
+        ...selectedDatabaseSkills,
+        ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []),
+        ...selectedWorkflowSkills,
+    ];
+    for (const agent of selectedAgents) {
+        for (const skill of selectedSkills) {
+            for (const skillTarget of getSkillTargetsForAgent(skill, agent.id)) {
+                skillTargets.set(skillTarget.targetRelativePath, skillTarget);
+            }
+        }
+    }
+    return [...skillTargets.values()];
+}
+export function getSkillTargetsForAgents(skill, selectedAgents) {
+    const skillTargets = new Map();
+    for (const agent of selectedAgents) {
+        for (const skillTarget of getSkillTargetsForAgent(skill, agent.id)) {
+            skillTargets.set(skillTarget.targetRelativePath, skillTarget);
+        }
+    }
+    return [...skillTargets.values()];
+}
+function getSkillTargetsForAgent(skill, agentId) {
+    const targets = [];
+    const targetRelativePath = skill.targetRelativePathsByAgent[agentId];
+    if (targetRelativePath) {
+        targets.push({
+            targetRelativePath,
+            templateRelativePath: skill.templateRelativePath,
+        });
+    }
+    for (const supplementalTarget of skill.supplementalTargetsByAgent?.[agentId] ?? []) {
+        targets.push(supplementalTarget);
+    }
+    return targets;
+}
+function getSessionStartHookTargetsForAgents(selectedAgents) {
+    const selectedAgentIds = new Set(selectedAgents.map((agent) => agent.id));
+    return SESSION_START_HOOKS.filter((hookTemplate) => selectedAgentIds.has(hookTemplate.agentId)).map((hookTemplate) => ({
+        targetRelativePath: hookTemplate.targetRelativePath,
+        templateRelativePath: hookTemplate.templateRelativePath,
+    }));
+}
+export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills = [], selectedFrameworkSkills = [], selectedArchitectureSkill, selectedWorkflowSkills = [], selectedDatabaseSkills = [], selectedMcpServers = []) {
+    const targets = [
+        {
+            label: 'AGENTS.md',
+            targetPath: path.join(rootPath, 'AGENTS.md'),
+            templateRelativePath: 'AGENTS.md',
+            requiresProjectOverview: true,
+            targetKind: 'agent-support',
+        },
+        ...selectedAgents.flatMap((agent) => {
+            if (!agent.targetRelativePath || !agent.templateRelativePath) {
+                return [];
+            }
+            return [
+                {
+                    label: agent.targetRelativePath,
+                    targetPath: path.join(rootPath, agent.targetRelativePath),
+                    templateRelativePath: agent.templateRelativePath,
+                    requiresProjectOverview: false,
+                    targetKind: 'agent-support',
+                },
+            ];
+        }),
+        ...getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills, selectedDatabaseSkills).map((skillTarget) => ({
+            label: skillTarget.targetRelativePath,
+            targetPath: path.join(rootPath, skillTarget.targetRelativePath),
+            templateRelativePath: skillTarget.templateRelativePath,
+            requiresProjectOverview: false,
+            targetKind: 'skill',
+        })),
+        ...getSessionStartHookTargetsForAgents(selectedAgents).map((hookTarget) => ({
+            label: hookTarget.targetRelativePath,
+            targetPath: path.join(rootPath, hookTarget.targetRelativePath),
+            templateRelativePath: hookTarget.templateRelativePath,
+            requiresProjectOverview: false,
+            targetKind: 'agent-support',
+        })),
+    ];
+    for (const mcpTarget of getMcpConfigTargetsForAgents(selectedAgents, selectedMcpServers)) {
+        const targetPath = path.join(rootPath, mcpTarget.targetRelativePath);
+        const existingTarget = targets.find((target) => target.targetPath === targetPath);
+        if (existingTarget) {
+            existingTarget.selectedMcpServers = selectedMcpServers;
+            existingTarget.mcpConfigAgentId = mcpTarget.agentId;
+            continue;
+        }
+        targets.push({
+            label: mcpTarget.targetRelativePath,
+            targetPath,
+            templateRelativePath: mcpTarget.templateRelativePath,
+            requiresProjectOverview: false,
+            targetKind: 'mcp-config',
+            mcpConfigAgentId: mcpTarget.agentId,
+            selectedMcpServers,
+        });
+    }
+    return targets;
+}
+export function getSelectedAgentsFromState(state) {
+    return SUPPORTED_AGENTS.filter((agent) => state.selectedAgents.includes(agent.id));
+}

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

@@ -0,0 +1 @@
+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/support/interactive-guidance/prompts.js

@@ -0,0 +1,275 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cancel, isCancel, multiselect, select, text } from '@clack/prompts';
+import gradient from 'gradient-string';
+import { Box, Text, render, useApp } from 'ink';
+import { useEffect } from 'react';
+import { SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_DATABASE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_MCP_SERVERS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS, } from '../../modules/template-catalog/index.js';
+const NONE_OPTION_ID = 'none';
+export const MCP_SERVER_SELECTION_MESSAGE = 'Select optional MCP servers to configure. Sibu writes config files only; you own prerequisites and authentication.';
+export async function renderIntro() {
+    console.log(gradient(['#39ff14', '#00e5ff', '#9b5de5']).multiline('⧖  S I B U  ⧖'));
+    const app = render(_jsx(IntroPanel, {}));
+    await app.waitUntilExit();
+}
+function IntroPanel() {
+    const { exit } = useApp();
+    useEffect(() => {
+        const timer = setTimeout(exit, 650);
+        return () => clearTimeout(timer);
+    }, [exit]);
+    return (_jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 2, paddingY: 1, flexDirection: "column", children: [_jsx(Text, { color: "cyanBright", children: "Sibu is ready" }), _jsx(Text, { color: "greenBright", children: "Build. Test. Rewind. Improve." })] }));
+}
+export async function askForSupportedAgents() {
+    const selectedAgentIds = await multiselect({
+        message: 'Select the agents this project should support.',
+        required: true,
+        options: SUPPORTED_AGENTS.map((agent) => ({
+            value: agent.id,
+            label: agent.name,
+            hint: agent.description,
+        })),
+    });
+    if (isCancel(selectedAgentIds)) {
+        cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    return SUPPORTED_AGENTS.filter((agent) => selectedAgentIds.includes(agent.id));
+}
+export async function askForLanguageSkills() {
+    const selectedLanguageSkillIds = await multiselect({
+        message: 'Select the languages this project should support.',
+        required: false,
+        options: SELECTABLE_LANGUAGE_SKILLS.map((skill) => ({
+            value: skill.id,
+            label: skill.name,
+            hint: skill.description,
+        })),
+    });
+    if (isCancel(selectedLanguageSkillIds)) {
+        cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    return SELECTABLE_LANGUAGE_SKILLS.filter((skill) => selectedLanguageSkillIds.includes(skill.id));
+}
+export async function askForFrameworkSkills() {
+    return askForFrameworkSkillSelection({
+        message: 'Select the frameworks this project should support.',
+        cancelMessage: 'Initialization cancelled.',
+    });
+}
+export async function askForDatabaseSkills() {
+    const selectedDatabaseSkillIds = await multiselect({
+        message: 'Select the database skills this project should support.',
+        required: false,
+        options: SELECTABLE_DATABASE_SKILLS.map((skill) => ({
+            value: skill.id,
+            label: skill.name,
+            hint: skill.description,
+        })),
+    });
+    if (isCancel(selectedDatabaseSkillIds)) {
+        cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    return SELECTABLE_DATABASE_SKILLS.filter((skill) => selectedDatabaseSkillIds.includes(skill.id));
+}
+export async function askForMcpServers() {
+    const selectedMcpServerIds = await multiselect({
+        message: MCP_SERVER_SELECTION_MESSAGE,
+        required: false,
+        options: SELECTABLE_MCP_SERVERS.map((server) => ({
+            value: server.id,
+            label: server.name,
+            hint: server.description,
+        })),
+    });
+    if (isCancel(selectedMcpServerIds)) {
+        cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    return SELECTABLE_MCP_SERVERS.filter((server) => selectedMcpServerIds.includes(server.id));
+}
+export async function askForNotionDocsParentPage() {
+    const parentPage = await text({
+        message: 'Enter the Notion docs destination parent page URL or page ID.',
+        placeholder: 'https://www.notion.so/workspace/Sibu-Docs-...',
+        validate(value) {
+            if (!value?.trim()) {
+                return 'Enter a Notion parent page that your Notion MCP connection can access.';
+            }
+        },
+    });
+    if (isCancel(parentPage)) {
+        cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    return parentPage.trim();
+}
+async function askForFrameworkSkillSelection({ message, cancelMessage, }) {
+    const selectedFrameworkSkillIds = await multiselect({
+        message,
+        required: false,
+        options: [
+            { value: NONE_OPTION_ID, label: 'None', hint: 'Do not install framework-specific guidance.' },
+            ...SELECTABLE_FRAMEWORK_SKILLS.map((skill) => ({
+                value: skill.id,
+                label: skill.name,
+                hint: skill.description,
+            })),
+        ],
+    });
+    if (isCancel(selectedFrameworkSkillIds)) {
+        cancel(cancelMessage);
+        process.exit(0);
+    }
+    if (selectedFrameworkSkillIds.includes(NONE_OPTION_ID)) {
+        return [];
+    }
+    return SELECTABLE_FRAMEWORK_SKILLS.filter((skill) => selectedFrameworkSkillIds.includes(skill.id));
+}
+export async function askForArchitectureSkill() {
+    const selectedArchitectureSkillId = await select({
+        message: 'Select an architecture style for this project.',
+        options: [
+            { value: 'none', label: 'None', hint: 'Do not install opinionated architecture guidance.' },
+            ...SELECTABLE_ARCHITECTURE_SKILLS.map((skill) => ({
+                value: skill.id,
+                label: skill.name,
+                hint: skill.description,
+            })),
+        ],
+    });
+    if (isCancel(selectedArchitectureSkillId)) {
+        cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    if (selectedArchitectureSkillId === 'none') {
+        return undefined;
+    }
+    return SELECTABLE_ARCHITECTURE_SKILLS.find((skill) => skill.id === selectedArchitectureSkillId);
+}
+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: promptableWorkflowSkills.map((skill) => ({
+            value: skill.id,
+            label: skill.name,
+            hint: skill.description,
+        })),
+    });
+    if (isCancel(selectedWorkflowSkillIds)) {
+        cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    return promptableWorkflowSkills.filter((skill) => selectedWorkflowSkillIds.includes(skill.id));
+}
+export function shouldAskForNewLanguageSkills(state) {
+    return (state.selectedLanguageSkills?.length ?? 0) === 0;
+}
+export async function askForNewLanguageSkills(state) {
+    if (!shouldAskForNewLanguageSkills(state)) {
+        return { state, changedState: false };
+    }
+    const selectedLanguageSkillIds = new Set(state.selectedLanguageSkills ?? []);
+    const unselectedLanguageSkills = SELECTABLE_LANGUAGE_SKILLS.filter((skill) => !selectedLanguageSkillIds.has(skill.id));
+    if (unselectedLanguageSkills.length === 0) {
+        return { state, changedState: false };
+    }
+    const selectedNewLanguageSkillIds = await multiselect({
+        message: 'Select any new languages this project should support.',
+        required: false,
+        options: unselectedLanguageSkills.map((skill) => ({
+            value: skill.id,
+            label: skill.name,
+            hint: skill.description,
+        })),
+    });
+    if (isCancel(selectedNewLanguageSkillIds)) {
+        cancel('Sync cancelled.');
+        process.exit(0);
+    }
+    for (const selectedSkillId of selectedNewLanguageSkillIds) {
+        selectedLanguageSkillIds.add(selectedSkillId);
+    }
+    if (selectedNewLanguageSkillIds.length === 0) {
+        return { state, changedState: false };
+    }
+    return {
+        state: {
+            ...state,
+            selectedLanguageSkills: [...selectedLanguageSkillIds],
+            updatedAt: new Date().toISOString(),
+        },
+        changedState: true,
+    };
+}
+export async function askForMissingFrameworkSkills(state) {
+    if (state.selectedFrameworkSkills !== undefined) {
+        return { state, changedState: false };
+    }
+    const selectedFrameworkSkills = await askForFrameworkSkillSelection({
+        message: 'Select the frameworks this project should support.',
+        cancelMessage: 'Sync cancelled.',
+    });
+    return {
+        state: {
+            ...state,
+            selectedFrameworkSkills: selectedFrameworkSkills.map((skill) => skill.id),
+            updatedAt: new Date().toISOString(),
+        },
+        changedState: true,
+    };
+}
+export async function askForNewArchitectureSkill(state) {
+    if (state.selectedArchitectureSkill) {
+        return { state, changedState: false };
+    }
+    const selectedArchitectureSkillId = await select({
+        message: 'Select an architecture style for this project.',
+        options: [
+            { value: 'none', label: 'None', hint: 'Do not install opinionated architecture guidance.' },
+            ...SELECTABLE_ARCHITECTURE_SKILLS.map((skill) => ({
+                value: skill.id,
+                label: skill.name,
+                hint: skill.description,
+            })),
+        ],
+    });
+    if (isCancel(selectedArchitectureSkillId)) {
+        cancel('Sync cancelled.');
+        process.exit(0);
+    }
+    return {
+        state: selectedArchitectureSkillId === 'none'
+            ? state
+            : {
+                ...state,
+                selectedArchitectureSkill: selectedArchitectureSkillId,
+                updatedAt: new Date().toISOString(),
+            },
+        changedState: selectedArchitectureSkillId !== 'none',
+    };
+}
+export async function askForProjectOverview() {
+    const overview = await text({
+        message: 'Tell me what this project is about.',
+        placeholder: 'A local-first notes app for software teams.',
+        validate(value) {
+            if (!value?.trim()) {
+                return 'Please enter a short project overview so I can create AGENTS.md.';
+            }
+            return undefined;
+        },
+    });
+    if (isCancel(overview)) {
+        cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    return overview;
+}

package/bin/support/version-advisory/index.js

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

package/bin/support/version-advisory/npm-version.js

@@ -0,0 +1,205 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const SIBU_PACKAGE_NAME = '@juancr11/sibu';
+export const SIBU_VERSION = readPackageVersion();
+export const NPM_VERSION_LOOKUP_MODE_ENV = 'SIBU_NPM_LOOKUP_MODE';
+export const NPM_VERSION_OVERRIDE_ENV = 'SIBU_NPM_LATEST_VERSION';
+export const SIBU_CACHE_HOME_ENV = 'SIBU_CACHE_HOME';
+export const SUPPORTED_NPM_LOOKUP_MODES = ['live', 'offline'];
+const NPM_VERSION_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
+const NPM_REGISTRY_URL = 'https://registry.npmjs.org';
+export async function checkForLatestSibuVersion(options = {}) {
+    const now = options.now ?? new Date();
+    const overrideResult = readOverrideResult(now);
+    if (overrideResult) {
+        return overrideResult;
+    }
+    const cachedRecord = readCachedNpmVersionResult();
+    if (cachedRecord.ok && isFreshCacheRecord(cachedRecord.record, now)) {
+        return {
+            ...cachedRecord.record,
+            source: 'cache',
+        };
+    }
+    const liveOutcome = await fetchLatestVersionOutcome({
+        fetchImpl: options.fetchImpl ?? fetch,
+        now,
+    });
+    writeCachedNpmVersionResult(liveOutcome);
+    return liveOutcome;
+}
+async function fetchLatestVersionOutcome({ fetchImpl, now }) {
+    try {
+        const response = await fetchImpl(`${NPM_REGISTRY_URL}/${encodeURIComponent(SIBU_PACKAGE_NAME)}/latest`, {
+            headers: { accept: 'application/json' },
+        });
+        if (!response.ok) {
+            return buildUnavailableOutcome({ checkedAt: now.toISOString(), reason: 'network-error' });
+        }
+        const payload = (await response.json());
+        const latestVersion = getLatestVersionFromPayload(payload);
+        if (!latestVersion) {
+            return buildUnavailableOutcome({ checkedAt: now.toISOString(), reason: 'invalid-response' });
+        }
+        return buildVersionedOutcome({
+            checkedAt: now.toISOString(),
+            latestVersion,
+            source: 'live',
+            status: compareVersions(latestVersion, SIBU_VERSION) > 0 ? 'update-available' : 'up-to-date',
+        });
+    }
+    catch {
+        return buildUnavailableOutcome({ checkedAt: now.toISOString(), reason: 'network-error' });
+    }
+}
+function readOverrideResult(now) {
+    const overrideMode = readLookupModeOverride();
+    if (overrideMode === 'offline') {
+        return buildUnavailableOutcome({
+            checkedAt: now.toISOString(),
+            reason: 'override',
+            source: 'override',
+        });
+    }
+    const overrideVersion = process.env[NPM_VERSION_OVERRIDE_ENV]?.trim();
+    if (!overrideVersion) {
+        return undefined;
+    }
+    return buildVersionedOutcome({
+        checkedAt: now.toISOString(),
+        latestVersion: overrideVersion,
+        source: 'override',
+        status: compareVersions(overrideVersion, SIBU_VERSION) > 0 ? 'update-available' : 'up-to-date',
+    });
+}
+function readLookupModeOverride() {
+    const value = process.env[NPM_VERSION_LOOKUP_MODE_ENV]?.trim().toLowerCase();
+    if (!value) {
+        return undefined;
+    }
+    return SUPPORTED_NPM_LOOKUP_MODES.find((mode) => mode === value);
+}
+function readCachedNpmVersionResult() {
+    const cachePath = getNpmVersionCachePath();
+    if (!fs.existsSync(cachePath)) {
+        return { ok: false, reason: 'missing' };
+    }
+    try {
+        const payload = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+        if (!isNpmVersionCacheRecord(payload)) {
+            return { ok: false, reason: 'invalid' };
+        }
+        return { ok: true, record: payload };
+    }
+    catch {
+        return { ok: false, reason: 'invalid' };
+    }
+}
+function writeCachedNpmVersionResult(result) {
+    const cachePath = getNpmVersionCachePath();
+    fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+    fs.writeFileSync(cachePath, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
+}
+function isFreshCacheRecord(record, now) {
+    const checkedAt = Date.parse(record.checkedAt);
+    if (Number.isNaN(checkedAt)) {
+        return false;
+    }
+    return now.getTime() - checkedAt < NPM_VERSION_CACHE_TTL_MS;
+}
+function getLatestVersionFromPayload(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return undefined;
+    }
+    const version = payload.version;
+    return typeof version === 'string' && version.trim() ? version.trim() : undefined;
+}
+function buildVersionedOutcome({ checkedAt, latestVersion, source, status, }) {
+    return {
+        checkedAt,
+        currentVersion: SIBU_VERSION,
+        latestVersion,
+        packageName: SIBU_PACKAGE_NAME,
+        source,
+        status,
+    };
+}
+function buildUnavailableOutcome({ checkedAt, reason, source = 'live', }) {
+    return {
+        checkedAt,
+        packageName: SIBU_PACKAGE_NAME,
+        reason,
+        source,
+        status: 'unavailable',
+    };
+}
+function compareVersions(left, right) {
+    const leftParts = splitVersion(left);
+    const rightParts = splitVersion(right);
+    const maxLength = Math.max(leftParts.core.length, rightParts.core.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftValue = leftParts.core[index] ?? 0;
+        const rightValue = rightParts.core[index] ?? 0;
+        if (leftValue !== rightValue) {
+            return leftValue > rightValue ? 1 : -1;
+        }
+    }
+    if (leftParts.prerelease === rightParts.prerelease) {
+        return 0;
+    }
+    if (!leftParts.prerelease) {
+        return 1;
+    }
+    if (!rightParts.prerelease) {
+        return -1;
+    }
+    return leftParts.prerelease.localeCompare(rightParts.prerelease);
+}
+function splitVersion(version) {
+    const [core, prerelease] = version.trim().split('-', 2);
+    return {
+        core: core.split('.').map((part) => Number.parseInt(part, 10) || 0),
+        prerelease,
+    };
+}
+function isNpmVersionCacheRecord(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const record = value;
+    if (record.status === 'unavailable') {
+        return (typeof record.checkedAt === 'string' &&
+            typeof record.packageName === 'string' &&
+            typeof record.reason === 'string' &&
+            typeof record.source === 'string');
+    }
+    return ((record.status === 'up-to-date' || record.status === 'update-available') &&
+        typeof record.checkedAt === 'string' &&
+        typeof record.currentVersion === 'string' &&
+        typeof record.latestVersion === 'string' &&
+        typeof record.packageName === 'string' &&
+        typeof record.source === 'string');
+}
+function getNpmVersionCachePath() {
+    return path.join(getSibuCacheRoot(), 'cache', 'npm-version.json');
+}
+function getSibuCacheRoot() {
+    const override = process.env[SIBU_CACHE_HOME_ENV]?.trim();
+    if (override) {
+        return path.resolve(override);
+    }
+    return path.join(os.homedir(), '.sibu');
+}
+function readPackageVersion() {
+    const packageJsonPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    if (!isPackageJsonWithVersion(packageJson)) {
+        throw new Error(`Could not read Sibu version from ${packageJsonPath}.`);
+    }
+    return packageJson.version;
+}
+function isPackageJsonWithVersion(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.version === 'string');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juancr11/sibu",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "CLI for setting up a local AI-augmented development workflow.",
   "repository": {
     "type": "git",
@@ -19,6 +19,7 @@
     "bin/admin/",
     "bin/modules/",
     "bin/shared/",
+    "bin/support/",
     "!bin/shared/state.js",
     "!bin/**/*.test.js",
     "!bin/echo.js",

package/templates/AGENTS.md

@@ -35,6 +35,14 @@ Keep responses concise by default, but spend the context needed for correctness,
 - Ask focused questions when needed; otherwise make reasonable assumptions and proceed.
 - If the user wants more detail, they can ask follow-up questions.
 
+## Judgment and honesty
+
+- Be direct and respectful. Avoid patronizing praise, performative agreement, and over-reassurance.
+- Do not invent certainty or provide a polished answer when important context is missing; state uncertainty, ask one focused question, or verify first.
+- Make low-risk assumptions only when they are clearly labeled.
+- Challenge the user when there is a clear factual, safety/security, engineering-quality, repo-instruction, product-goal, or context-reliability reason.
+- When challenging, give a short reason and a better alternative. Do not argue preferences or nitpick style; preserve user control after material tradeoffs are acknowledged unless safety or project rules require refusal.
+
 ## Skill routing
 
 For planned product/feature work, use this pipeline: product vision -> business domain model -> capabilities map -> deep module map / feature brief -> technical design -> optional UX -> epics/stories -> AI executor. Business Domain Model work sits after Product Vision and before the Capabilities Map. Deep Module Map and Feature Brief work are sibling downstream artifacts from Product Vision, Business Domain Model, and Capabilities Map. Technical Design remains downstream of both Feature Brief and Deep Module Map, with Scrum planning and AI executor flows after Technical Design. Narrow code fixes and small local changes do not require the full pipeline unless product scope, module ownership, or architecture direction is unclear.

package/templates/manifest.json

@@ -1,12 +1,13 @@
 {
-  "templateVersion": "132",
+  "templateVersion": "133",
   "templates": {
     "AGENTS.md": {
-      "version": "33",
+      "version": "34",
       "description": "Project-level agent instructions and Sibu maintenance guidance.",
       "changes": [
-        "Adds the Capabilities Map as a formal pipeline stage before sibling Deep Module Map and Feature Brief work.",
-        "Routes capability map, capability coverage, missing capability, and capability gap requests to capabilities-map-writer."
+        "Adds judgment and honesty guidance for direct, non-condescending collaboration.",
+        "Clarifies that agents should state uncertainty, ask focused questions, or verify instead of inventing certainty.",
+        "Defines when agents should challenge users for clear factual, safety, quality, instruction, product, or context-reliability reasons."
       ]
     },
     ".codex/config.toml": {

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

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

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

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

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

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