@juancr11/sibu 0.13.2 → 0.15.1

package/bin/shared/templates.js

@@ -1,60 +0,0 @@
-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, selectedWorkflowSkills = [], }) {
-    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, selectedWorkflowSkills);
-}
-export function renderSkillRouting(contents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = []) {
-    if (!contents.includes('{{OPTIONAL_SKILL_ROUTING}}')) {
-        return contents;
-    }
-    const optionalRouting = [...selectedLanguageSkills, ...selectedFrameworkSkills, ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []), ...selectedWorkflowSkills]
-        .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/workflow-targets.js

@@ -1,125 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { SIBU_VERSION } from './catalog.js';
-import { MANDATORY_SKILLS, SELECTABLE_ARCHITECTURE_SKILLS, SELECTABLE_FRAMEWORK_SKILLS, SELECTABLE_LANGUAGE_SKILLS, SELECTABLE_WORKFLOW_SKILLS, SUPPORTED_AGENTS, } from '../modules/workflow-target-planning/index.js';
-import { sha256 } from './hash.js';
-import { removeUndefinedFields } from './object.js';
-import { readExistingState } from './state.js';
-import { getTemplateVersion, readTemplate, readTemplateManifest, renderSkillRouting } from '../modules/template-catalog-rendering/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 getSelectedSkillTargetsForAgents(selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = []) {
-    const skillTargets = new Map();
-    const selectedSkills = [
-        ...MANDATORY_SKILLS,
-        ...selectedLanguageSkills,
-        ...selectedFrameworkSkills,
-        ...(selectedArchitectureSkill ? [selectedArchitectureSkill] : []),
-        ...selectedWorkflowSkills,
-    ];
-    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, selectedWorkflowSkills = []) {
-    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, selectedWorkflowSkills).map((skillTarget) => ({
-            label: skillTarget.targetRelativePath,
-            targetPath: path.join(rootPath, skillTarget.targetRelativePath),
-            templateRelativePath: skillTarget.templateRelativePath,
-            requiresProjectOverview: false,
-        })),
-    ];
-}
-export function renderMissingWorkflowFiles({ missingTargets, overview, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], }) {
-    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, selectedWorkflowSkills);
-        return {
-            label: target.label,
-            targetPath: target.targetPath,
-            contents,
-        };
-    });
-}
-export function writeSibuState({ rootPath, statePath, selectedAgents, selectedLanguageSkills, selectedFrameworkSkills, selectedArchitectureSkill, selectedWorkflowSkills = [], targets, }) {
-    const previousState = readExistingState(statePath);
-    const now = new Date().toISOString();
-    const manifest = readTemplateManifest();
-    const state = {
-        sibuVersion: SIBU_VERSION,
-        templateVersion: manifest.templateVersion,
-        generatedAt: previousState?.generatedAt ?? now,
-        updatedAt: now,
-        selectedAgents: selectedAgents.map((agent) => agent.id),
-        selectedLanguageSkills: selectedLanguageSkills.map((skill) => skill.id),
-        selectedFrameworkSkills: selectedFrameworkSkills.map((skill) => skill.id),
-        selectedArchitectureSkill: selectedArchitectureSkill?.id,
-        selectedWorkflowSkills: selectedWorkflowSkills.map((skill) => skill.id),
-        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));
-}