r2pde-ai 0.1.0

package/dist/commands/reset.js

@@ -0,0 +1,33 @@
+import { Command } from 'commander';
+import { getPaths } from '../core/paths.js';
+import { logWarn, logSuccess, logInfo } from '../core/logger.js';
+import fs from 'fs-extra';
+import { confirm } from '@inquirer/prompts';
+import path from 'path';
+export const resetCommand = new Command('reset')
+    .description('Clear the prompts folder')
+    .action(async () => {
+    const cwd = process.cwd();
+    const paths = getPaths(cwd);
+    if (!fs.existsSync(paths.root)) {
+        logWarn('r2pde-ai not initialized. Run r2pde-ai init first.');
+        return;
+    }
+    logWarn('This will delete all files in .r2pde-ai/prompts/. This action cannot be undone.');
+    logInfo('This will permanently delete all generated prompts. Artifacts (manifestos, contracts, requirements) are NOT affected.');
+    const doReset = await confirm({ message: 'Reset prompts folder?', default: false });
+    if (!doReset) {
+        logInfo('Operation cancelled.');
+        return;
+    }
+    const promptDir = paths.prompts;
+    if (fs.existsSync(promptDir)) {
+        for (const file of fs.readdirSync(promptDir)) {
+            fs.unlinkSync(path.join(promptDir, file));
+        }
+    }
+    const logPath = path.join(paths.logs, 'pde.log.md');
+    fs.ensureFileSync(logPath);
+    fs.appendFileSync(logPath, `- ${new Date().toISOString()} | reset | prompts | cleared\n`, { encoding: 'utf8' });
+    logSuccess('Prompts folder cleared.');
+});

package/dist/commands/score-config.js

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+import { loadConfig, saveConfig } from '../core/config.js';
+import { logInfo, logSuccess, logError } from '../core/logger.js';
+import { input } from '@inquirer/prompts';
+export const scoreConfigCommand = new Command('score:config')
+    .description('Configure quality score thresholds')
+    .action(async () => {
+    const cwd = process.cwd();
+    const config = loadConfig(cwd);
+    logInfo(`Current thresholds:`);
+    logInfo(`  Green max % issues: ${config.score.green.max}`);
+    logInfo(`  Yellow max % issues: ${config.score.yellow.max}`);
+    logInfo('Maximum percentage of issues allowed for a GREEN score. Below this = healthy project.');
+    const green = Number(await input({ message: 'Green threshold max % of issues:', default: String(config.score.green.max), validate: (v) => {
+            const n = Number(v);
+            return n >= 1 && n < 100 ? true : 'Enter a value between 1 and 99';
+        } }));
+    logInfo('Maximum percentage of issues allowed for a YELLOW score. Above this = RED.');
+    const yellow = Number(await input({ message: 'Yellow threshold max % of issues:', default: String(config.score.yellow.max), validate: (v) => {
+            const n = Number(v);
+            return n > green && n < 100 ? true : 'Yellow must be greater than green and less than 100';
+        } }));
+    if (green >= yellow) {
+        logError('Green threshold must be less than yellow threshold.');
+        return;
+    }
+    config.score.green.max = green;
+    config.score.yellow.max = yellow;
+    saveConfig(cwd, config);
+    logSuccess(`Updated thresholds: green.max=${green}, yellow.max=${yellow}`);
+});

package/dist/commands/score.js

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { scoreProject } from '../core/scorer.js';
+import { getPaths } from '../core/paths.js';
+import { logError, logWarn, logInfo } from '../core/logger.js';
+import { loadConfig } from '../core/config.js';
+import fs from 'fs-extra';
+import path from 'path';
+export const scoreCommand = new Command('score')
+    .description('Evaluate quality score from current or specified context')
+    .option('--from <folder>', 'Evaluate from this folder (manifestos | contracts | requirements)')
+    .action(async (opts) => {
+    const cwd = process.cwd();
+    const paths = getPaths(cwd);
+    if (!fs.existsSync(paths.root)) {
+        logError('r2pde-ai not initialized. Run r2pde-ai init first.');
+        return;
+    }
+    const config = loadConfig(cwd);
+    const result = scoreProject(cwd, opts.from);
+    for (const warn of result.warnings) {
+        if (warn.severity === 'error')
+            logError(`[${warn.file}] ${warn.issue}`);
+        else
+            logWarn(`[${warn.file}] ${warn.issue}`);
+    }
+    logInfo(`\nChecks: ${result.passed}/${result.total} passed, ${result.failed} failed`);
+    logInfo(`Score: ${result.percentage}%`);
+    let emoji = '🟢', msg = 'Score is GREEN — environment is consistent, proceed.';
+    if (result.level === 'yellow') {
+        emoji = '🟡';
+        msg = 'Score is YELLOW — gaps detected, proceed with awareness.';
+    }
+    else if (result.level === 'red') {
+        emoji = '🔴';
+        msg = 'Score is RED — critical issues found, resolve before proceeding.';
+    }
+    logInfo(`${emoji} ${msg}`);
+    // Log
+    const logPath = path.join(paths.logs, 'pde.log.md');
+    const logLine = `- ${new Date().toISOString()} | score | [${result.level}] | [${result.percentage}%] | [${result.passed}/${result.total}] checks passed\n`;
+    fs.ensureFileSync(logPath);
+    fs.appendFileSync(logPath, logLine, { encoding: 'utf8' });
+});

package/dist/commands/wave-prompt.js

@@ -0,0 +1,130 @@
+import { Command } from 'commander';
+import { getPaths } from '../core/paths.js';
+import { logError, logWarn, logInfo, logSuccess } from '../core/logger.js';
+import { scoreProject } from '../core/scorer.js';
+import { select, confirm } from '@inquirer/prompts';
+import fs from 'fs-extra';
+import path from 'path';
+import { createAiAdapter } from '../core/ai/adapter-factory.js';
+function logScore(level, msg) {
+    let emoji = '🟢';
+    if (level === 'yellow')
+        emoji = '🟡';
+    if (level === 'red')
+        emoji = '🔴';
+    logInfo(`${emoji} ${msg}`);
+}
+export const wavePromptCommand = new Command('wave:prompt')
+    .description('Generate consolidated prompt for current wave')
+    .action(async () => {
+    const cwd = process.cwd();
+    const paths = getPaths(cwd);
+    if (!fs.existsSync(paths.root)) {
+        logError('r2pde-ai not initialized. Run r2pde-ai init first.');
+        return;
+    }
+    // Step 2 — Score check
+    const score = scoreProject(cwd);
+    if (score.level === 'red') {
+        logScore('red', 'Score is RED. Generating prompt with critical issues may produce poor results.');
+        logInfo('Prompt generation with RED score may produce poor results.');
+        const doContinue = await confirm({ message: 'Score is RED. Generating prompt with critical issues may produce poor results. Continue?', default: false });
+        if (!doContinue) {
+            logInfo('Operation cancelled.');
+            return;
+        }
+    }
+    else if (score.level === 'yellow') {
+        logScore('yellow', 'Score is YELLOW. Proceeding with warnings.');
+        logWarn('Proceeding with warnings.');
+    }
+    else {
+        logScore('green', 'Score is healthy.');
+    }
+    // Step 3 — Ask wave
+    logInfo('The implementation wave to generate a prompt for. Each wave covers a specific layer of the project.');
+    const wave = await select({
+        message: 'Select a wave:',
+        choices: [
+            { name: 'Framework', value: 'framework' },
+            { name: 'Architecture', value: 'architecture' },
+            { name: 'Core (errors, logs, security)', value: 'core' },
+            { name: 'Authentication', value: 'authentication' },
+            { name: 'Users', value: 'users' },
+            { name: 'UI/UX', value: 'ui-ux' },
+            { name: 'Tests', value: 'tests' },
+            { name: 'Documentation', value: 'documentation' }
+        ]
+    });
+    // Step 4 — Load artifacts
+    function readOrPlaceholder(file) {
+        return fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '[No artifacts defined]';
+    }
+    function readAllOrPlaceholder(dir) {
+        if (!fs.existsSync(dir))
+            return '[No artifacts defined]';
+        const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+        if (files.length === 0)
+            return '[No artifacts defined]';
+        return files.map(f => fs.readFileSync(path.join(dir, f), 'utf8')).join('\n---\n');
+    }
+    const indexContent = readOrPlaceholder(path.join(paths.root, 'pde.index.md'));
+    const manifestosContent = readAllOrPlaceholder(paths.manifestos);
+    const contractsContent = readAllOrPlaceholder(paths.contracts);
+    const requirementsContent = readAllOrPlaceholder(paths.requirements);
+    // Step 5 — Generate prompt
+    const now = new Date();
+    const tsFmt = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${String(now.getDate()).padStart(2, '0')}-${String(now.getHours()).padStart(2, '0')}${String(now.getMinutes()).padStart(2, '0')}${String(now.getSeconds()).padStart(2, '0')}`;
+    const filename = `${wave}-${tsFmt}.md`;
+    const prompt = `# r2pde-ai — Wave Prompt: ${wave}\nGenerated: ${now.toISOString()}\nScore: ${score.level === 'green' ? '🟢' : score.level === 'yellow' ? '🟡' : '🔴'} ${score.percentage}%\n\n---\n\n## Project Context\n${indexContent}\n\n---\n\n## Manifestos\n${manifestosContent}\n\n---\n\n## Contracts\n${contractsContent}\n\n---\n\n## Requirements\n${requirementsContent}\n\n---\n\n## Wave Objective\nYou are an AI coding assistant working on the ${wave} wave of this project.\nYour task is to implement everything required for this wave following ALL manifestos, contracts, and requirements defined above.\nDo not deviate from the defined architecture, naming conventions, or code patterns.\nGenerate production-ready TypeScript code only.\nAsk no questions — implement based on the context provided.\n\n## Wave: ${wave}\nImplement the ${wave} layer of the project as defined by the artifacts above.\nFollow all contracts strictly. Apply all manifesto principles. Satisfy all requirements.\n`;
+    // Step 5.1 — AI Adapter
+    const configPath = path.join(paths.root, 'pde.config.json');
+    const config = fs.existsSync(configPath) ? fs.readJsonSync(configPath) : {};
+    const adapter = createAiAdapter(config);
+    if (adapter.isReal()) {
+        logInfo('AI API configured — sending prompt to AI...');
+    }
+    else {
+        logInfo('No AI API configured — running in offline mode.');
+    }
+    const ora = (await import('ora')).default;
+    const spinner = ora('Generating response...').start();
+    let outputPrompt;
+    let isApi = adapter.isReal();
+    try {
+        if (isApi) {
+            const metaInstruction = `You are an expert software architect and prompt engineer.\nYour task is to analyze the project context below and generate an optimized, precise prompt for GitHub Copilot.\nThe prompt you generate will be pasted directly into GitHub Copilot to implement the \"${wave}\" wave of this project.\nMake the prompt:\n- Specific and unambiguous\n- Aligned with the defined architecture, patterns, and conventions\n- Structured so Copilot understands exactly what to implement and how\n- Include all relevant constraints from manifestos and contracts\n- Reference acceptance criteria from requirements\nDo not generate code yourself. Generate only the optimized Copilot prompt.\n\n## Project Context\n${prompt}\n\nNow generate the optimized GitHub Copilot prompt for the \"${wave}\" wave:`;
+            outputPrompt = await adapter.generate(metaInstruction);
+        }
+        else {
+            outputPrompt = await adapter.generate(prompt);
+        }
+        spinner.succeed('Response received.');
+    }
+    catch (err) {
+        spinner.fail('AI API call failed.');
+        logError(err instanceof Error ? err.message : 'Unknown error');
+        logInfo('Falling back to offline mode — saving prompt for copy/paste.');
+        outputPrompt = prompt;
+        isApi = false;
+    }
+    // Step 6 — Save outputPrompt
+    const promptsDir = path.join(paths.root, 'prompts');
+    fs.ensureDirSync(promptsDir);
+    const filePath = path.join(promptsDir, filename);
+    fs.writeFileSync(filePath, outputPrompt, { encoding: 'utf8' });
+    // Step 7 — Log entry
+    const logPath = path.join(paths.logs, 'pde.log.md');
+    const logLine = `- ${now.toISOString()} | wave:prompt | ${wave} | ${filename} | generated\n`;
+    fs.ensureFileSync(logPath);
+    fs.appendFileSync(logPath, logLine, { encoding: 'utf8' });
+    // Step 8 — Output
+    if (isApi) {
+        logSuccess(`Optimized prompt generated by AI and saved to .r2pde-ai/prompts/${filename}`);
+        logInfo('This prompt was optimized by AI. Copy and paste it into GitHub Copilot.');
+    }
+    else {
+        logSuccess(`Prompt generated: .r2pde-ai/prompts/${filename}`);
+        logInfo('Copy the content of this file and paste it into GitHub Copilot.');
+    }
+});

package/dist/core/ai/adapter-factory.js

@@ -0,0 +1,9 @@
+import { MockAdapter } from './mock-adapter.js';
+import { ApiAdapter } from './api-adapter.js';
+export function createAiAdapter(config) {
+    const { apiUrl, apiKey } = config.ai;
+    if (apiUrl && apiUrl.trim() !== '' && apiKey && apiKey.trim() !== '') {
+        return new ApiAdapter({ apiUrl, apiKey, model: config.ai.model });
+    }
+    return new MockAdapter();
+}

package/dist/core/ai/ai-adapter.js

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

package/dist/core/ai/api-adapter.js

@@ -0,0 +1,38 @@
+export class ApiAdapter {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    isReal() {
+        return true;
+    }
+    async generate(prompt) {
+        const response = await fetch(`${this.config.apiUrl}/v1/messages`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.config.apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify({
+                model: this.config.model || 'claude-sonnet-4-20250514',
+                max_tokens: 8096,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`AI API error: ${response.status} — ${error}`);
+        }
+        const data = await response.json();
+        return data.content
+            .filter(block => block.type === 'text')
+            .map(block => block.text)
+            .join('\n');
+    }
+}

package/dist/core/ai/mock-adapter.js

@@ -0,0 +1,28 @@
+export class MockAdapter {
+    isReal() {
+        return false;
+    }
+    async generate(prompt) {
+        return [
+            '# GitHub Copilot Prompt — Generated by r2pde-ai (Mock Mode)',
+            '',
+            '> ⚠ This prompt was generated in offline mode (no AI API configured).',
+            '> Configure ai.apiUrl and ai.apiKey for AI-optimized prompts.',
+            '> To configure: r2pde-ai config:set ai.apiUrl <url>',
+            '> To configure: r2pde-ai config:set ai.apiKey <key>',
+            '',
+            '---',
+            '',
+            '## Instructions for GitHub Copilot',
+            '',
+            'Read the full context below and implement the requested wave.',
+            'Follow all manifestos, contracts, and requirements strictly.',
+            'Generate production-ready TypeScript code only.',
+            'Do not ask questions — implement based on the context provided.',
+            '',
+            '---',
+            '',
+            prompt,
+        ].join('\n');
+    }
+}

package/dist/core/config.js

@@ -0,0 +1,61 @@
+import fs from 'fs-extra';
+import path from 'path';
+export const DEFAULT_CONFIG = {
+    version: '0.1.0',
+    language: 'en',
+    artifactsLanguage: 'en',
+    git: {
+        autoCommit: false,
+        commitMessagePrefix: 'pde:',
+    },
+    score: {
+        green: { max: 30 },
+        yellow: { max: 70 },
+        red: { max: 100 },
+    },
+    ai: {
+        apiUrl: '',
+        apiKey: '',
+        model: '',
+    },
+    project: {
+        type: '',
+        architecture: '',
+        maturity: '',
+        hasAuth: false,
+        hasPayment: false,
+        hasIntegrations: false,
+        audience: '',
+        stack: '',
+    },
+};
+export function loadConfig(projectRoot) {
+    const configPath = path.resolve(projectRoot, '.r2pde-ai', 'pde.config.json');
+    if (!fs.existsSync(configPath)) {
+        return DEFAULT_CONFIG;
+    }
+    try {
+        const fileConfig = fs.readJsonSync(configPath);
+        return {
+            ...DEFAULT_CONFIG,
+            ...fileConfig,
+            git: { ...DEFAULT_CONFIG.git, ...fileConfig.git },
+            score: {
+                green: { ...DEFAULT_CONFIG.score.green, ...(fileConfig.score?.green || {}) },
+                yellow: { ...DEFAULT_CONFIG.score.yellow, ...(fileConfig.score?.yellow || {}) },
+                red: { ...DEFAULT_CONFIG.score.red, ...(fileConfig.score?.red || {}) },
+            },
+            ai: { ...DEFAULT_CONFIG.ai, ...fileConfig.ai },
+            project: { ...DEFAULT_CONFIG.project, ...fileConfig.project },
+        };
+    }
+    catch {
+        return DEFAULT_CONFIG;
+    }
+}
+export function saveConfig(projectRoot, config) {
+    const dir = path.resolve(projectRoot, '.r2pde-ai');
+    const configPath = path.resolve(dir, 'pde.config.json');
+    fs.ensureDirSync(dir);
+    fs.writeJsonSync(configPath, config, { spaces: 2 });
+}

package/dist/core/git.js

@@ -0,0 +1,20 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { execSync } from 'child_process';
+import { logWarn } from './logger.js';
+export function isGitRepo(projectRoot) {
+    return fs.existsSync(path.resolve(projectRoot, '.git'));
+}
+export function gitAddAndCommit(projectRoot, message, config) {
+    if (!config.git.autoCommit)
+        return;
+    if (!isGitRepo(projectRoot))
+        return;
+    try {
+        execSync('git add .r2pde-ai/', { cwd: projectRoot, stdio: 'ignore' });
+        execSync(`git commit -m "${config.git.commitMessagePrefix} ${message}"`, { cwd: projectRoot, stdio: 'ignore' });
+    }
+    catch {
+        logWarn('Git commit failed (ignored).');
+    }
+}

package/dist/core/logger.js

@@ -0,0 +1,22 @@
+import chalk from 'chalk';
+export function logSuccess(message) {
+    console.log(chalk.green('✔'), message);
+}
+export function logInfo(message) {
+    console.log(chalk.blue('ℹ'), message);
+}
+export function logWarn(message) {
+    console.log(chalk.yellow('⚠'), message);
+}
+export function logError(message) {
+    console.log(chalk.red('✖'), message);
+}
+export function logScore(level, message) {
+    const emoji = level === 'green' ? '🟢' : level === 'yellow' ? '🟡' : '🔴';
+    let colorFn = chalk.green;
+    if (level === 'yellow')
+        colorFn = chalk.yellow;
+    if (level === 'red')
+        colorFn = chalk.red;
+    console.log(colorFn(emoji), message);
+}

package/dist/core/paths.js

@@ -0,0 +1,17 @@
+import path from 'path';
+export function getPaths(projectRoot) {
+    const resolve = (...segments) => path.resolve(projectRoot, ...segments);
+    return {
+        root: resolve('.r2pde-ai'),
+        config: resolve('.r2pde-ai', 'pde.config.json'),
+        index: resolve('.r2pde-ai', 'pde.index.md'),
+        guide: resolve('.r2pde-ai', 'GUIDE.md'),
+        templates: resolve('.r2pde-ai', 'templates'),
+        manifestos: resolve('.r2pde-ai', 'manifestos'),
+        contracts: resolve('.r2pde-ai', 'contracts'),
+        requirements: resolve('.r2pde-ai', 'requirements'),
+        waves: resolve('.r2pde-ai', 'waves'),
+        prompts: resolve('.r2pde-ai', 'prompts'),
+        logs: resolve('.r2pde-ai', 'logs'),
+    };
+}

package/dist/core/scorer.js

@@ -0,0 +1,135 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { loadConfig } from './config.js';
+import { getPaths } from './paths.js';
+function isKebabCase(filename) {
+    return /^[a-z0-9\-]+\.md$/.test(filename);
+}
+function parseMetadata(content) {
+    if (!content.startsWith('---'))
+        return null;
+    const end = content.indexOf('---', 3);
+    if (end === -1)
+        return null;
+    const meta = content.slice(3, end).trim();
+    const lines = meta.split(/\r?\n/);
+    const obj = {};
+    for (const line of lines) {
+        const [k, ...rest] = line.split(':');
+        if (k && rest.length)
+            obj[k.trim()] = rest.join(':').trim();
+    }
+    return obj;
+}
+export function scoreProject(projectRoot, fromPath) {
+    const pdePaths = getPaths(projectRoot);
+    const paths = {
+        manifestos: pdePaths.manifestos,
+        contracts: pdePaths.contracts,
+        requirements: pdePaths.requirements,
+    };
+    const folders = ['manifestos', 'contracts', 'requirements'];
+    const foldersToProcess = fromPath && folders.includes(fromPath)
+        ? [fromPath]
+        : folders;
+    let total = 0, passed = 0, failed = 0;
+    const warnings = [];
+    const found = { manifestos: false, contracts: false, requirements: false };
+    for (const folder of folders) {
+        const dir = paths[folder];
+        if (fs.existsSync(dir)) {
+            const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+            if (files.length > 0)
+                found[folder] = true;
+        }
+    }
+    for (const folder of foldersToProcess) {
+        const dir = paths[folder];
+        if (!fs.existsSync(dir))
+            continue;
+        const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+        for (const file of files) {
+            const filePath = path.join(dir, file);
+            const content = fs.readFileSync(filePath, 'utf8');
+            // Always use POSIX-style for warnings
+            const relativePath = `${folder}/${file}`.replace(/\\/g, '/');
+            ++total;
+            if (content.trim().startsWith('---')) {
+                ++passed;
+            }
+            else {
+                ++failed;
+                warnings.push({ file: relativePath, issue: 'Missing metadata header', severity: 'warning' });
+            }
+            const meta = parseMetadata(content);
+            const endOfMeta = content.indexOf('---', 3);
+            ++total;
+            if (meta && meta.name) {
+                ++passed;
+            }
+            else {
+                ++failed;
+                warnings.push({ file: relativePath, issue: 'Missing name field in metadata', severity: 'warning' });
+            }
+            ++total;
+            if (meta && meta.description) {
+                ++passed;
+            }
+            else {
+                ++failed;
+                warnings.push({ file: relativePath, issue: 'Missing description field', severity: 'warning' });
+            }
+            ++total;
+            if (endOfMeta !== -1 && content.slice(endOfMeta + 3).trim().length > 0) {
+                ++passed;
+            }
+            else {
+                ++failed;
+                warnings.push({ file: relativePath, issue: 'File has no content beyond metadata', severity: 'warning' });
+            }
+            ++total;
+            if (isKebabCase(file)) {
+                ++passed;
+            }
+            else {
+                ++failed;
+                warnings.push({ file: relativePath, issue: 'Filename is not kebab-case', severity: 'warning' });
+            }
+        }
+    }
+    if (!fromPath) {
+        ++total;
+        if (found.manifestos) {
+            ++passed;
+        }
+        else {
+            ++failed;
+            warnings.push({ file: 'manifestos/', issue: 'No manifestos defined', severity: 'error' });
+        }
+        ++total;
+        if (found.contracts) {
+            ++passed;
+        }
+        else {
+            ++failed;
+            warnings.push({ file: 'contracts/', issue: 'No contracts defined', severity: 'error' });
+        }
+        ++total;
+        if (found.requirements) {
+            ++passed;
+        }
+        else {
+            ++failed;
+            warnings.push({ file: 'requirements/', issue: 'No requirements defined', severity: 'error' });
+        }
+    }
+    const percentage = total > 0 ? Math.round((passed / total) * 1000) / 10 : 100;
+    const issuePercentage = total > 0 ? (failed / total) * 100 : 0;
+    const config = loadConfig(projectRoot);
+    let level = 'red';
+    if (issuePercentage <= config.score.green.max)
+        level = 'green';
+    else if (issuePercentage <= config.score.yellow.max)
+        level = 'yellow';
+    return { total, passed, failed, warnings, percentage, level };
+}

package/dist/index.js

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

package/dist/templates/contract.template.md

@@ -0,0 +1,14 @@
+# Contract: [Name]
+
+## Purpose
+Describe what this contract enforces.
+
+## Rules
+- Rule one (mandatory)
+- Rule two (mandatory)
+
+## Violations
+Describe what constitutes a violation of this contract.
+
+## Exceptions
+Define known exceptions if any.

package/dist/templates/manifesto.template.md

@@ -0,0 +1,15 @@
+# Manifesto: [Name]
+
+## Purpose
+Describe the guiding principle this manifesto establishes.
+
+## Principles
+- Principle one
+- Principle two
+- Principle three
+
+## Scope
+Define what areas of the project this manifesto applies to.
+
+## Exceptions
+Define known exceptions if any.

package/dist/templates/requirement.template.md

@@ -0,0 +1,17 @@
+# Requirement: [Name]
+
+## Type
+[ ] Functional  [ ] Non-functional  [ ] Business Rule
+
+## Description
+Describe the requirement clearly and objectively.
+
+## Acceptance Criteria
+- Criterion one
+- Criterion two
+
+## Dependencies
+List any requirements or contracts this depends on.
+
+## Notes
+Additional context if needed.