@juancr11/sibu 0.1.0

package/bin/shared/prompts.js

@@ -0,0 +1,205 @@
+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_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SUPPORTED_AGENTS } from './catalog.js';
+const NONE_OPTION_ID = 'none';
+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.',
+    });
+}
+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 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/shared/state.js

@@ -0,0 +1,76 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { STATE_RELATIVE_PATH } from './catalog.js';
+export function readStateForDoctor(statePath) {
+    if (!fs.existsSync(statePath)) {
+        return { ok: false, message: `${STATE_RELATIVE_PATH} is missing.` };
+    }
+    try {
+        const parsedState = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        if (!isSibuState(parsedState)) {
+            return { ok: false, message: `${STATE_RELATIVE_PATH} is not a valid Sibu state file.` };
+        }
+        return { ok: true, state: parsedState };
+    }
+    catch {
+        return { ok: false, message: `${STATE_RELATIVE_PATH} could not be parsed.` };
+    }
+}
+export function readExistingState(statePath) {
+    if (!fs.existsSync(statePath)) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeStateFile(statePath, state) {
+    fs.mkdirSync(path.dirname(statePath), { recursive: true });
+    fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+export function cloneState(state) {
+    return JSON.parse(JSON.stringify(state));
+}
+export function hasReviewedTemplateVersion(managedFile, templateVersion) {
+    return managedFile.lastReviewedTemplateVersion === templateVersion;
+}
+function isSibuState(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const state = value;
+    return (typeof state.sibuVersion === 'string' &&
+        typeof state.templateVersion === 'string' &&
+        typeof state.generatedAt === 'string' &&
+        typeof state.updatedAt === 'string' &&
+        Array.isArray(state.selectedAgents) &&
+        state.selectedAgents.every((agent) => typeof agent === 'string') &&
+        (state.selectedLanguageSkills === undefined ||
+            (Array.isArray(state.selectedLanguageSkills) && state.selectedLanguageSkills.every((skill) => typeof skill === 'string'))) &&
+        (state.reviewedLanguageSkills === undefined ||
+            (Array.isArray(state.reviewedLanguageSkills) && state.reviewedLanguageSkills.every((skill) => typeof skill === 'string'))) &&
+        (state.selectedFrameworkSkills === undefined ||
+            (Array.isArray(state.selectedFrameworkSkills) && state.selectedFrameworkSkills.every((skill) => typeof skill === 'string'))) &&
+        (state.selectedArchitectureSkill === undefined || typeof state.selectedArchitectureSkill === 'string') &&
+        (state.reviewedArchitectureSkills === undefined ||
+            (Array.isArray(state.reviewedArchitectureSkills) && state.reviewedArchitectureSkills.every((skill) => typeof skill === 'string'))) &&
+        !!state.managedFiles &&
+        typeof state.managedFiles === 'object' &&
+        Object.values(state.managedFiles).every(isManagedFileState));
+}
+function isManagedFileState(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const managedFile = value;
+    const validStatuses = ['managed', 'customized', 'unmanaged'];
+    return (typeof managedFile.template === 'string' &&
+        typeof managedFile.templateVersion === 'string' &&
+        typeof managedFile.sha256 === 'string' &&
+        (managedFile.status === undefined || validStatuses.includes(managedFile.status)) &&
+        (managedFile.lastReviewedTemplateVersion === undefined || typeof managedFile.lastReviewedTemplateVersion === 'string') &&
+        (managedFile.reason === undefined || typeof managedFile.reason === 'string'));
+}

package/bin/shared/sync-preview.js

@@ -0,0 +1,166 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { sha256 } from './hash.js';
+import { hasReviewedTemplateVersion } from './state.js';
+import { renderTemplateForSync } from './templates.js';
+import { getSelectedAgentsFromState, getSelectedArchitectureSkillFromState, getSelectedFrameworkSkillsFromState, getSelectedLanguageSkillsFromState, getWorkflowTargets, } from './workflow-targets.js';
+const ACTIONABLE_SYNC_PREVIEW_STATUSES = new Set([
+    'new-template',
+    'missing',
+    'modified',
+    'update-available',
+    'modified-with-update',
+    'unknown-template',
+]);
+const PROMPTABLE_SYNC_PREVIEW_STATUSES = new Set([
+    'new-template',
+    'missing',
+    'modified',
+    'update-available',
+    'modified-with-update',
+]);
+export function isActionableSyncPreview(preview) {
+    return ACTIONABLE_SYNC_PREVIEW_STATUSES.has(preview.status);
+}
+export function shouldAskForSyncAction(preview) {
+    return PROMPTABLE_SYNC_PREVIEW_STATUSES.has(preview.status);
+}
+export function getSyncPreviews({ rootPath, state, manifest }) {
+    const selectedLanguageSkills = getSelectedLanguageSkillsFromState(state);
+    const selectedFrameworkSkills = getSelectedFrameworkSkillsFromState(state);
+    const selectedArchitectureSkill = getSelectedArchitectureSkillFromState(state);
+    const previews = Object.entries(state.managedFiles).map(([relativePath, managedFile]) => getManagedFileSyncPreview({
+        rootPath,
+        manifest,
+        relativePath,
+        managedFile,
+        selectedLanguageSkills,
+        selectedFrameworkSkills,
+        selectedArchitectureSkill,
+    }));
+    const expectedTargets = getWorkflowTargets(rootPath, getSelectedAgentsFromState(state), selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill);
+    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),
+            });
+            continue;
+        }
+        previews.push({
+            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),
+        });
+    }
+    return previews;
+}
+function getManagedFileSyncPreview({ rootPath, manifest, relativePath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, }) {
+    if (managedFile.status === 'unmanaged') {
+        return { relativePath, managedFile, status: 'unmanaged', recordedTemplateVersion: managedFile.templateVersion, changes: [] };
+    }
+    const template = manifest.templates[managedFile.template];
+    if (!template) {
+        return { relativePath, managedFile, status: 'unknown-template', recordedTemplateVersion: managedFile.templateVersion, changes: [] };
+    }
+    const targetPath = path.join(rootPath, relativePath);
+    const hasLocalFile = fs.existsSync(targetPath);
+    const hasLocalEdits = hasLocalFile ? sha256(fs.readFileSync(targetPath, 'utf8')) !== managedFile.sha256 : false;
+    const hasTemplateUpdate = managedFile.templateVersion !== template.version && !hasReviewedTemplateVersion(managedFile, template.version);
+    const hasSelectionUpdate = hasRenderedSelectionUpdate({
+        relativePath,
+        currentPath: targetPath,
+        managedFile,
+        selectedLanguageSkills,
+        selectedFrameworkSkills,
+        selectedArchitectureSkill,
+    });
+    const hasUpdate = hasTemplateUpdate || hasSelectionUpdate;
+    const changes = hasTemplateUpdate ? template.changes : ['Refreshes generated skill routing for the current selected skills.'];
+    if (!hasLocalFile) {
+        return {
+            relativePath,
+            managedFile,
+            status: 'missing',
+            recordedTemplateVersion: managedFile.templateVersion,
+            currentTemplateVersion: template.version,
+            changes: template.changes,
+            hasLocalFile,
+        };
+    }
+    if (hasLocalEdits && hasUpdate) {
+        return {
+            relativePath,
+            managedFile,
+            status: 'modified-with-update',
+            recordedTemplateVersion: managedFile.templateVersion,
+            currentTemplateVersion: template.version,
+            changes,
+            hasLocalFile,
+        };
+    }
+    if (hasLocalEdits) {
+        return {
+            relativePath,
+            managedFile,
+            status: 'modified',
+            recordedTemplateVersion: managedFile.templateVersion,
+            currentTemplateVersion: template.version,
+            changes: [],
+            hasLocalFile,
+        };
+    }
+    if (hasUpdate) {
+        return {
+            relativePath,
+            managedFile,
+            status: 'update-available',
+            recordedTemplateVersion: managedFile.templateVersion,
+            currentTemplateVersion: template.version,
+            changes,
+            hasLocalFile,
+        };
+    }
+    return {
+        relativePath,
+        managedFile,
+        status: 'up-to-date',
+        recordedTemplateVersion: managedFile.templateVersion,
+        currentTemplateVersion: template.version,
+        changes: [],
+        hasLocalFile,
+    };
+}
+function hasRenderedSelectionUpdate({ relativePath, currentPath, managedFile, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, }) {
+    if (relativePath !== 'AGENTS.md') {
+        return false;
+    }
+    const renderedContents = renderTemplateForSync({
+        templateRelativePath: managedFile.template,
+        currentPath,
+        selectedLanguageSkills,
+        selectedFrameworkSkills,
+        selectedArchitectureSkill,
+    });
+    return sha256(renderedContents) !== managedFile.sha256;
+}

package/bin/shared/templates.js

@@ -0,0 +1,60 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getTemplatesPath } from './paths.js';
+export function readTemplate(relativePath) {
+    return fs.readFileSync(path.join(getTemplatesPath(), relativePath), 'utf8');
+}
+export function readTemplateManifest() {
+    const manifest = JSON.parse(fs.readFileSync(path.join(getTemplatesPath(), 'manifest.json'), 'utf8'));
+    if (!isTemplateManifest(manifest)) {
+        throw new Error('templates/manifest.json is not a valid template manifest.');
+    }
+    return manifest;
+}
+export function getTemplateVersion(manifest, templateRelativePath) {
+    const template = manifest.templates[templateRelativePath];
+    if (!template) {
+        throw new Error(`Template ${templateRelativePath} is missing from templates/manifest.json.`);
+    }
+    return template.version;
+}
+export function renderTemplateForSync({ templateRelativePath, currentPath, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, }) {
+    let contents = readTemplate(templateRelativePath);
+    if (contents.includes('{{PROJECT_OVERVIEW}}')) {
+        contents = contents.replace('{{PROJECT_OVERVIEW}}', extractProjectOverview(currentPath) ?? 'Describe this project.');
+    }
+    return renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill);
+}
+export function renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill) {
+    if (!contents.includes('{{OPTIONAL_SKILL_ROUTING}}')) {
+        return contents;
+    }
+    const optionalRouting = [...selectedLanguageSkills, ...selectedFrameworkSkills, ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : [])]
+        .map((skill) => `- ${skill.routingInstruction}`)
+        .join('\n');
+    return contents.replace('{{OPTIONAL_SKILL_ROUTING}}', optionalRouting);
+}
+export function extractProjectOverview(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return undefined;
+    }
+    const contents = fs.readFileSync(filePath, 'utf8');
+    const match = contents.match(/## Project overview\s+([\s\S]*?)(?=\n## |$)/);
+    const overview = match?.[1]?.trim();
+    return overview || undefined;
+}
+function isTemplateManifest(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const manifest = value;
+    return (typeof manifest.templateVersion === 'string' &&
+        !!manifest.templates &&
+        typeof manifest.templates === 'object' &&
+        Object.values(manifest.templates).every((template) => !!template &&
+            typeof template === 'object' &&
+            typeof template.version === 'string' &&
+            typeof template.description === 'string' &&
+            Array.isArray(template.changes) &&
+            template.changes.every((change) => typeof change === 'string')));
+}

package/bin/shared/types.js

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

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

@@ -0,0 +1,30 @@
+import { readStateForDoctor } from './state.js';
+import { getSyncPreviews, isActionableSyncPreview } from './sync-preview.js';
+import { readTemplateManifest } from './templates.js';
+export function getWorkflowMutationReadiness({ rootPath, statePath }) {
+    const stateResult = readStateForDoctor(statePath);
+    if (!stateResult.ok) {
+        return {
+            ok: false,
+            message: stateResult.message,
+            hint: 'Run `sibu init` before selecting project skills.',
+        };
+    }
+    const manifest = readTemplateManifest();
+    const previews = getSyncPreviews({ rootPath, state: stateResult.state, manifest });
+    const actionablePreviews = previews.filter(isActionableSyncPreview);
+    if (actionablePreviews.length > 0) {
+        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.',
+            actionablePreviews,
+        };
+    }
+    return {
+        ok: true,
+        state: stateResult.state,
+        manifest,
+        previews,
+    };
+}

package/bin/shared/workflow-targets.js

@@ -0,0 +1,119 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { SIBU_VERSION, MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SUPPORTED_AGENTS } from './catalog.js';
+import { sha256 } from './hash.js';
+import { removeUndefinedFields } from './object.js';
+import { readExistingState } from './state.js';
+import { getTemplateVersion, readTemplate, readTemplateManifest, renderSkillRouting } from './templates.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 getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill) {
+    const skillTargets = new Map();
+    const selectedSkills = [
+        ...MANDATORY_SKILLS,
+        ...selectedLanguageSkills,
+        ...selectedFrameworkSkills,
+        ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []),
+    ];
+    for (const agent of selectedAgents) {
+        for (const skill of selectedSkills) {
+            const targetRelativePath = skill.targetRelativePathsByAgent[agent.id];
+            if (!targetRelativePath) {
+                continue;
+            }
+            skillTargets.set(targetRelativePath, {
+                targetRelativePath,
+                templateRelativePath: skill.templateRelativePath,
+            });
+        }
+    }
+    return [...skillTargets.values()];
+}
+export function getWorkflowTargets(rootPath, selectedAgents, selectedLanguageSkills = [], selectedFrameworkSkills = [], selectedArchitectureSkill) {
+    return [
+        {
+            label: 'AGENTS.md',
+            targetPath: path.join(rootPath, 'AGENTS.md'),
+            templateRelativePath: 'AGENTS.md',
+            requiresProjectOverview: true,
+        },
+        ...selectedAgents.flatMap((agent) => {
+            if (!agent.targetRelativePath || !agent.templateRelativePath) {
+                return [];
+            }
+            return [
+                {
+                    label: agent.targetRelativePath,
+                    targetPath: path.join(rootPath, agent.targetRelativePath),
+                    templateRelativePath: agent.templateRelativePath,
+                    requiresProjectOverview: false,
+                },
+            ];
+        }),
+        ...getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill).map((skillTarget) => ({
+            label: skillTarget.targetRelativePath,
+            targetPath: path.join(rootPath, skillTarget.targetRelativePath),
+            templateRelativePath: skillTarget.templateRelativePath,
+            requiresProjectOverview: false,
+        })),
+    ];
+}
+export function renderMissingWorkflowFiles({ missingTargets, overview, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, }) {
+    return missingTargets.map((target) => {
+        let contents = readTemplate(target.templateRelativePath);
+        if (target.requiresProjectOverview) {
+            if (!overview?.trim()) {
+                throw new Error('Project overview is required to create AGENTS.md.');
+            }
+            contents = contents.replace('{{PROJECT_OVERVIEW}}', overview.trim());
+        }
+        contents = renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill);
+        return {
+            label: target.label,
+            targetPath: target.targetPath,
+            contents,
+        };
+    });
+}
+export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, targets, }) {
+    const previousState = readExistingState(statePath);
+    const now = new Date().toISOString();
+    const manifest = readTemplateManifest();
+    const state = {
+        sibuVersion: SIBU_VERSION,
+        templateVersion: manifest.templateVersion,
+        generatedAt: previousState?.generatedAt ?? now,
+        updatedAt: now,
+        selectedAgents: selectedAgents.map((agent) => agent.id),
+        selectedLanguageSkills: selectedLanguageSkills.map((skill) => skill.id),
+        selectedFrameworkSkills: selectedFrameworkSkills.map((skill) => skill.id),
+        selectedArchitectureSkill: selectedArchitectureSkill?.id,
+        managedFiles: Object.fromEntries(targets
+            .filter((target) => fs.existsSync(target.targetPath))
+            .map((target) => {
+            const relativePath = path.relative(rootPath, target.targetPath);
+            const previousManagedFile = previousState?.managedFiles[relativePath];
+            const nextManagedFile = {
+                template: target.templateRelativePath,
+                templateVersion: getTemplateVersion(manifest, target.templateRelativePath),
+                sha256: sha256(fs.readFileSync(target.targetPath, 'utf8')),
+                status: previousManagedFile?.status ?? 'managed',
+                lastReviewedTemplateVersion: previousManagedFile?.lastReviewedTemplateVersion,
+                reason: previousManagedFile?.reason,
+            };
+            return [relativePath, removeUndefinedFields(nextManagedFile)];
+        })),
+    };
+    fs.mkdirSync(path.dirname(statePath), { recursive: true });
+    fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+export function getSelectedAgentsFromState(state) {
+    return SUPPORTED_AGENTS.filter((agent) => state.selectedAgents.includes(agent.id));
+}

package/bin/sibu.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { runCli } from './entrypoints/cli/main.js';
+runCli().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});