r2pde-ai 0.1.0

package/dist/commands/contract-delete.js

@@ -0,0 +1,45 @@
+import { select, confirm } from '@inquirer/prompts';
+import fs from 'fs-extra';
+import path from 'path';
+import { getPaths } from '../core/paths.js';
+import { logError, logWarn, logInfo, logSuccess } from '../core/logger.js';
+import { gitAddAndCommit } from '../core/git.js';
+import { loadConfig } from '../core/config.js';
+export async function contractDeleteCommand() {
+    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 files = fs.readdirSync(paths.contracts).filter(f => f.endsWith('.md'));
+    if (files.length === 0) {
+        logInfo('No contracts found.');
+        return;
+    }
+    logInfo('Select the artifact to permanently delete. This action cannot be undone and will remove the file from disk.');
+    const selected = await select({
+        message: 'Select a contract to delete:',
+        choices: files.map(f => ({ name: f.replace('.md', ''), value: f })),
+    });
+    const name = selected.replace(/\.md$/, '').replace(/-/g, ' ');
+    logWarn('This action cannot be undone.');
+    logInfo('Select Yes to confirm deletion.');
+    const doDelete = await confirm({ message: `Delete contract '${name}'?`, default: false });
+    if (!doDelete) {
+        logInfo('Operation cancelled.');
+        return;
+    }
+    const filePath = path.join(paths.contracts, selected);
+    fs.unlinkSync(filePath);
+    // Step 5 — Log entry
+    const logPath = path.join(paths.logs, 'pde.log.md');
+    const logLine = `- ${new Date().toISOString()} | contract:delete | ${selected} | deleted\n`;
+    fs.ensureFileSync(logPath);
+    fs.appendFileSync(logPath, logLine, { encoding: 'utf8' });
+    // Step 6 — Git commit if enabled
+    const config = loadConfig(cwd);
+    gitAddAndCommit(cwd, `feat(contract): remove ${name}`, config);
+    // Step 7 — Final output
+    logSuccess(`Contract '${name}' deleted.`);
+}

package/dist/commands/doctor.js

@@ -0,0 +1,112 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { getPaths } from '../core/paths.js';
+import { loadConfig } from '../core/config.js';
+import { logSuccess, logWarn, logError, logInfo } from '../core/logger.js';
+import { isGitRepo } from '../core/git.js';
+export async function doctorCommand() {
+    const cwd = process.cwd();
+    const paths = getPaths(cwd);
+    let hasError = false;
+    let hasWarn = false;
+    // Check 1 — r2pde-ai initialized
+    if (!fs.existsSync(paths.root)) {
+        logError('r2pde-ai not initialized. Run r2pde-ai init first.');
+        hasError = true;
+        return printSummary(hasError, hasWarn);
+    }
+    else {
+        logSuccess('r2pde-ai folder found');
+    }
+    // Check 2 — pde.config.json exists and is valid
+    if (!fs.existsSync(paths.config)) {
+        logError('pde.config.json not found. Run r2pde-ai init to generate.');
+        hasError = true;
+        return printSummary(hasError, hasWarn);
+    }
+    else {
+        try {
+            loadConfig(cwd);
+            logSuccess('pde.config.json found and valid');
+        }
+        catch (e) {
+            logError('pde.config.json is invalid JSON.');
+            hasError = true;
+            return printSummary(hasError, hasWarn);
+        }
+    }
+    // Check 3 — pde.index.md exists
+    if (fs.existsSync(paths.index)) {
+        logSuccess('pde.index.md found');
+    }
+    else {
+        logWarn('pde.index.md not found. Run r2pde-ai init to regenerate.');
+        hasWarn = true;
+    }
+    // Check 4 — All required folders exist
+    const requiredFolders = [
+        paths.manifestos,
+        paths.contracts,
+        paths.requirements,
+        paths.waves,
+        paths.prompts,
+        paths.logs,
+        paths.templates,
+    ];
+    let missingFolders = [];
+    for (const folder of requiredFolders) {
+        if (!fs.existsSync(folder)) {
+            missingFolders.push(path.basename(folder));
+            logWarn(`${path.basename(folder)} folder not found`);
+            hasWarn = true;
+        }
+    }
+    if (missingFolders.length === 0) {
+        logSuccess('All required folders found');
+    }
+    // Check 5 — Templates present
+    const templateFiles = [
+        'manifesto.template.md',
+        'contract.template.md',
+        'requirement.template.md',
+    ];
+    let missingTemplates = [];
+    for (const file of templateFiles) {
+        if (!fs.existsSync(path.join(paths.templates, file))) {
+            missingTemplates.push(file);
+            logWarn(`${file} not found in templates`);
+            hasWarn = true;
+        }
+    }
+    if (missingTemplates.length === 0) {
+        logSuccess('All templates found');
+    }
+    // Check 6 — Git repository
+    if (isGitRepo(cwd)) {
+        logSuccess('Git repository detected');
+    }
+    else {
+        logWarn('No git repository detected. Strongly recommended.');
+        hasWarn = true;
+    }
+    // Check 7 — AI API configured
+    const config = loadConfig(cwd);
+    if (config.ai.apiUrl && config.ai.apiKey) {
+        logSuccess('AI API configured — prompts will be optimized by AI before Copilot use.');
+    }
+    else {
+        logInfo('AI API not configured — prompts will be generated in offline mode for manual copy/paste into Copilot.');
+    }
+    printSummary(hasError, hasWarn);
+}
+function printSummary(hasError, hasWarn) {
+    if (hasError) {
+        logError('Environment has critical issues. Fix before proceeding.');
+    }
+    else if (hasWarn) {
+        logWarn('Environment has warnings. Review above.');
+    }
+    else {
+        logSuccess('All checks passed. Environment is healthy.');
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,190 @@
+// Removed legacy inquirer import
+import { input, select, confirm } from '@inquirer/prompts';
+import fs from 'fs-extra';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { getPaths } from '../core/paths.js';
+import { saveConfig, DEFAULT_CONFIG } from '../core/config.js';
+import { logWarn, logInfo, logSuccess } from '../core/logger.js';
+import { isGitRepo, gitAddAndCommit } from '../core/git.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export async function initCommand() {
+    const cwd = process.cwd();
+    const paths = getPaths(cwd);
+    // Step 1 — Validate environment FIRST
+    const alreadyInitialized = fs.existsSync(paths.root);
+    if (alreadyInitialized) {
+        logWarn('r2pde-ai is already initialized in this project.');
+        logInfo('Reinitialize will overwrite existing configuration.');
+        const reinit = await confirm({
+            message: 'r2pde-ai is already initialized. Reinitialize?',
+            default: false
+        });
+        if (!reinit) {
+            logInfo('Initialization cancelled.');
+            return;
+        }
+    }
+    if (!isGitRepo(cwd)) {
+        logWarn('No git repository detected. It is strongly recommended to initialize git before proceeding.');
+    }
+    // Step 2 — Create folders AFTER validation
+    fs.ensureDirSync(paths.root);
+    fs.ensureDirSync(paths.templates);
+    fs.ensureDirSync(paths.manifestos);
+    fs.ensureDirSync(paths.contracts);
+    fs.ensureDirSync(paths.requirements);
+    fs.ensureDirSync(paths.waves);
+    fs.ensureDirSync(paths.prompts);
+    fs.ensureDirSync(paths.logs);
+    // Step 3 — Interactive project setup
+    const folderName = path.basename(cwd);
+    logInfo('The name of your project. Used in generated files and git commits.');
+    const projectName = await input({ message: 'Project name:', default: folderName });
+    logInfo('The type of product you are building. Affects which contracts and waves are prioritized.');
+    const projectType = await select({ message: 'Project type:', choices: [
+            { name: 'Micro SaaS', value: 'micro-saas' },
+            { name: 'Landing Page', value: 'landing-page' },
+            { name: 'API', value: 'api' },
+            { name: 'Dashboard', value: 'dashboard' },
+            { name: 'E-commerce', value: 'e-commerce' },
+            { name: 'Other', value: 'other' }
+        ] });
+    logInfo('The structural pattern of your codebase. Impacts folder structure and separation of concerns.');
+    const architecture = await select({ message: 'Architecture:', choices: [
+            { name: 'Monolith', value: 'monolith' },
+            { name: 'Microservices', value: 'microservices' },
+            { name: 'Monorepo', value: 'monorepo' },
+            { name: 'Serverless', value: 'serverless' }
+        ] });
+    logInfo('The coding philosophy to follow. Guides naming, structure, and complexity decisions.');
+    const codePattern = await select({ message: 'Code pattern:', choices: [
+            { name: 'Clean Code', value: 'clean-code' },
+            { name: 'DDD', value: 'ddd' },
+            { name: 'SOLID', value: 'solid' },
+            { name: 'Pragmatic', value: 'pragmatic' }
+        ] });
+    logInfo('The current stage of the project. MVP relaxes some contracts; production enforces all.');
+    const maturity = await select({ message: 'Maturity:', choices: [
+            { name: 'MVP', value: 'mvp' },
+            { name: 'Production', value: 'production' }
+        ] });
+    logInfo('The primary protocol between services or client and server.');
+    const communication = await select({ message: 'Communication:', choices: [
+            { name: 'HTTP REST', value: 'http-rest' },
+            { name: 'GraphQL', value: 'graphql' },
+            { name: 'gRPC', value: 'grpc' },
+            { name: 'WebSockets', value: 'websockets' },
+            { name: 'Other', value: 'other' }
+        ] });
+    logInfo('The type of data storage your project will use.');
+    const persistence = await select({ message: 'Persistence:', choices: [
+            { name: 'SQL', value: 'sql' },
+            { name: 'NoSQL', value: 'nosql' },
+            { name: 'In-memory', value: 'in-memory' },
+            { name: 'Other', value: 'other' }
+        ] });
+    logInfo('Whether the project requires user login and session management.');
+    const hasAuth = await confirm({ message: 'Has authentication?', default: true });
+    logInfo('Whether the project handles billing, subscriptions, or transactions.');
+    const hasPayment = await confirm({ message: 'Has payment?', default: false });
+    logInfo('Whether the project connects to third-party APIs or services.');
+    const hasIntegrations = await confirm({ message: 'Has external integrations?', default: false });
+    logInfo('Who will use this product. Affects UX contracts and compliance requirements.');
+    const audience = await select({
+        message: 'Target audience:',
+        choices: [
+            { name: 'B2B (Business to Business)', value: 'b2b' },
+            { name: 'B2C (Business to Consumer)', value: 'b2c' },
+            { name: 'Internal', value: 'internal' },
+        ],
+    });
+    logInfo('The main technology stack. Used to generate stack-specific prompts for your AI copilot.');
+    const stack = await input({
+        message: 'Primary stack:',
+        default: 'Node.js / TypeScript',
+    });
+    logInfo('The language used in CLI output messages.');
+    const language = await select({ message: 'Language for messages:', choices: [
+            { name: 'English', value: 'en' },
+            { name: 'Português', value: 'pt' }
+        ] });
+    logInfo('The language used in generated markdown artifact files.');
+    const artifactsLanguage = await select({ message: 'Language for artifacts:', choices: [
+            { name: 'English', value: 'en' },
+            { name: 'Português', value: 'pt' }
+        ] });
+    // Compose config object from prompt results
+    const config = {
+        ...DEFAULT_CONFIG,
+        version: '0.1.0',
+        language,
+        artifactsLanguage,
+        git: { ...DEFAULT_CONFIG.git },
+        score: { ...DEFAULT_CONFIG.score },
+        ai: { ...DEFAULT_CONFIG.ai },
+        project: {
+            type: projectType,
+            architecture,
+            maturity,
+            hasAuth,
+            hasPayment,
+            hasIntegrations,
+            audience,
+            stack,
+        },
+    };
+    // Step 4 — Save config file
+    saveConfig(cwd, config);
+    // Step 5 — Generate pde.index.md
+    const indexContent = `# PDE Index — ${projectName}
+
+> Always paste this file into your AI copilot before any prompt.
+
+## Project Profile
+- **Type**: ${projectType}
+- **Architecture**: ${architecture}
+- **Code Pattern**: ${codePattern}
+- **Maturity**: ${maturity}
+- **Communication**: ${communication}
+- **Persistence**: ${persistence}
+- **Authentication**: ${hasAuth ? 'yes' : 'no'}
+- **Payment**: ${hasPayment ? 'yes' : 'no'}
+- **Integrations**: ${hasIntegrations ? 'yes' : 'no'}
+- **Audience**: ${audience}
+- **Stack**: ${stack}
+
+## Artifact Map
+- Manifestos: .r2pde-ai/manifestos/
+- Contracts: .r2pde-ai/contracts/
+- Requirements: .r2pde-ai/requirements/
+- Waves: .r2pde-ai/waves/
+- Prompts: .r2pde-ai/prompts/
+- Logs: .r2pde-ai/logs/
+
+## Framework Version
+- r2pde-ai: 0.1.0
+`;
+    fs.writeFileSync(paths.index, indexContent, { encoding: 'utf8' });
+    // Step 6 — Copy templates
+    const templateFiles = [
+        { src: path.resolve(__dirname, '../templates/manifesto.template.md'), dest: path.resolve(paths.templates, 'manifesto.template.md') },
+        { src: path.resolve(__dirname, '../templates/contract.template.md'), dest: path.resolve(paths.templates, 'contract.template.md') },
+        { src: path.resolve(__dirname, '../templates/requirement.template.md'), dest: path.resolve(paths.templates, 'requirement.template.md') },
+    ];
+    const runtimeTemplateDir = path.resolve(__dirname, '../templates');
+    for (const { dest } of templateFiles) {
+        const src = path.resolve(runtimeTemplateDir, path.basename(dest));
+        fs.copyFileSync(src, dest);
+    }
+    // Step 7 — Generate GUIDE.md
+    const guideContent = `# r2pde-ai GUIDE\n\n## What is a Manifesto?\nA Manifesto defines guiding principles for your project. Create one when you want to establish a core value or philosophy.\n\n**Structure:**\n- Purpose\n- Principles\n- Scope\n- Exceptions\n\n## What is a Contract?\nA Contract enforces rules or agreements in your project. Create one to formalize expectations.\n\n**Structure:**\n- Purpose\n- Rules\n- Violations\n- Exceptions\n\n## What is a Requirement?\nA Requirement describes a functional, non-functional, or business rule. Create one for every need or constraint.\n\n**Structure:**\n- Type\n- Description\n- Acceptance Criteria\n- Dependencies\n- Notes\n\n## What are Waves?\nWaves are iterative cycles of delivery. Each wave advances the project with new artifacts.\n\n**How to advance:**\n- Complete all requirements and contracts for the current wave.\n- Review quality score.\n- Start the next wave.\n\n## What is the Quality Score?\nThe Quality Score measures project health:\n- 🟢 Green: 0-30\n- 🟡 Yellow: 31-70\n- 🔴 Red: 71-100\n\n## How to use pde.index.md\nPaste .r2pde-ai/pde.index.md into your AI copilot before any prompt to provide full project context.\n\n## Prompt Generation (wave:prompt)\n\n- **Offline mode:** Generates a structured prompt for copy/paste into GitHub Copilot.\n- **API mode:** Generates an AI-optimized prompt for copy/paste into GitHub Copilot.\n- **Copilot always generates the code** — the AI API only improves the prompt quality.\n\n## CLI Commands Reference\n- init: Initialize r2pde-ai in the current project\n- doctor: Diagnose project health\n`;
+    fs.writeFileSync(paths.guide, guideContent, { encoding: 'utf8' });
+    // Step 8 — Git commit if enabled
+    gitAddAndCommit(cwd, 'init: project initialized', config);
+    // Step 9 — Final output
+    logSuccess('r2pde-ai initialized successfully.');
+    logInfo('Start by reading .r2pde-ai/GUIDE.md');
+    logInfo('Then paste .r2pde-ai/pde.index.md into your AI copilot before any prompt.');
+}

package/dist/commands/logs.js

@@ -0,0 +1,35 @@
+import { Command } from 'commander';
+import { getPaths } from '../core/paths.js';
+import { logInfo, logSuccess, logWarn } from '../core/logger.js';
+import fs from 'fs-extra';
+import { confirm } from '@inquirer/prompts';
+import path from 'path';
+export const logsCommand = new Command('logs')
+    .description('View the audit log')
+    .option('--clear', 'Clear all logs')
+    .action(async (opts) => {
+    const cwd = process.cwd();
+    const paths = getPaths(cwd);
+    if (!fs.existsSync(paths.root)) {
+        logWarn('r2pde-ai not initialized. Run r2pde-ai init first.');
+        return;
+    }
+    const logPath = path.join(paths.logs, 'pde.log.md');
+    if (opts.clear) {
+        logInfo('This will permanently delete all audit log entries. This action cannot be undone.');
+        const doClear = await confirm({ message: 'Clear all logs? This cannot be undone.', default: false });
+        if (!doClear) {
+            logInfo('Operation cancelled.');
+            return;
+        }
+        fs.writeFileSync(logPath, '', { encoding: 'utf8' });
+        logSuccess('Logs cleared.');
+        return;
+    }
+    if (!fs.existsSync(logPath)) {
+        logInfo('No logs found.');
+        return;
+    }
+    const content = fs.readFileSync(logPath, 'utf8');
+    logInfo('\n' + content);
+});

package/dist/commands/manifesto-create.js

@@ -0,0 +1,93 @@
+import { input, select, confirm } from '@inquirer/prompts';
+import fs from 'fs-extra';
+import path from 'path';
+import { getPaths } from '../core/paths.js';
+import { logError, logWarn, logInfo, logSuccess } from '../core/logger.js';
+import { gitAddAndCommit } from '../core/git.js';
+import { loadConfig } from '../core/config.js';
+function toKebabCase(str) {
+    return str
+        .normalize('NFD')
+        .replace(/[^\w\s-]/g, '')
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-');
+}
+export async function manifestoCreateCommand() {
+    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 — Interactive prompts
+    logInfo('The name of this manifesto. Should reflect the principle it establishes (e.g. UI Principles, Code Philosophy).');
+    const name = await input({ message: 'Manifesto name:', validate: (inputVal) => inputVal.trim() !== '' || 'Name is required' });
+    logInfo('The area of the project this manifesto governs.');
+    const scope = await select({ message: 'Scope:', choices: [
+            { name: 'UI', value: 'ui' },
+            { name: 'UX', value: 'ux' },
+            { name: 'Code Philosophy', value: 'code-philosophy' },
+            { name: 'Development Culture', value: 'development-culture' },
+            { name: 'Other', value: 'other' }
+        ] });
+    logInfo('A brief summary of what this manifesto enforces and why it exists.');
+    const description = await input({ message: 'Brief description:', validate: (inputVal) => inputVal.trim() !== '' || 'Description is required' });
+    const kebabName = toKebabCase(name);
+    const filename = `${kebabName}.md`;
+    const filePath = path.join(paths.manifestos, filename);
+    // Step 3 — Check for duplicates
+    if (fs.existsSync(filePath)) {
+        logWarn('Manifesto already exists.');
+        logInfo('Select Yes to overwrite the existing manifesto file.');
+        const overwrite = await confirm({ message: 'Manifesto already exists. Overwrite?', default: false });
+        if (!overwrite) {
+            logInfo('Operation cancelled.');
+            return;
+        }
+    }
+    // Step 4 — Generate manifesto file
+    const templatePath = path.join(paths.templates, 'manifesto.template.md');
+    if (!fs.existsSync(templatePath)) {
+        logError('Manifesto template not found.');
+        return;
+    }
+    let template = fs.readFileSync(templatePath, 'utf8');
+    template = template.replace('[Name]', name);
+    const meta = `---\nname: ${name}\nscope: ${scope}\ndescription: ${description}\ncreatedAt: ${new Date().toISOString()}\n---\n\n`;
+    const content = meta + template;
+    fs.writeFileSync(filePath, content, { encoding: 'utf8' });
+    // Step 5 — Update pde.index.md
+    if (fs.existsSync(paths.index)) {
+        let indexContent = fs.readFileSync(paths.index, { encoding: 'utf8' });
+        const manifestosSection = '- Manifestos: .r2pde-ai/manifestos/';
+        const newLine = `  - ${name}: .r2pde-ai/manifestos/${filename}`;
+        if (indexContent.includes(manifestosSection)) {
+            const lines = indexContent.split('\n');
+            const idx = lines.findIndex(l => l.trim() === manifestosSection);
+            if (idx !== -1) {
+                // Insert after Manifestos: section, but before next section or end
+                let insertAt = idx + 1;
+                while (insertAt < lines.length && (lines[insertAt].startsWith('  - ') || lines[insertAt].trim() === ''))
+                    insertAt++;
+                lines.splice(insertAt, 0, newLine);
+                indexContent = lines.join('\n');
+                fs.writeFileSync(paths.index, indexContent, { encoding: 'utf8' });
+            }
+        }
+    }
+    else {
+        logWarn('pde.index.md not found. Skipping index update.');
+    }
+    // Step 6 — Log entry
+    const logPath = path.join(paths.logs, 'pde.log.md');
+    const logLine = `- ${new Date().toISOString()} | manifesto:create | ${filename} | created\n`;
+    fs.ensureFileSync(logPath);
+    fs.appendFileSync(logPath, logLine, { encoding: 'utf8' });
+    // Step 7 — Git commit if enabled
+    const config = loadConfig(cwd);
+    gitAddAndCommit(cwd, `feat(manifesto): add ${name}`, config);
+    // Step 8 — Final output
+    logSuccess(`Manifesto '${name}' created at .r2pde-ai/manifestos/${filename}`);
+}

package/dist/commands/manifesto-delete.js

@@ -0,0 +1,45 @@
+import { select, confirm } from '@inquirer/prompts';
+import fs from 'fs-extra';
+import path from 'path';
+import { getPaths } from '../core/paths.js';
+import { logError, logWarn, logInfo, logSuccess } from '../core/logger.js';
+import { gitAddAndCommit } from '../core/git.js';
+import { loadConfig } from '../core/config.js';
+export async function manifestoDeleteCommand() {
+    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 files = fs.readdirSync(paths.manifestos).filter(f => f.endsWith('.md'));
+    if (files.length === 0) {
+        logInfo('No manifestos found.');
+        return;
+    }
+    logInfo('Select the artifact to permanently delete. This action cannot be undone and will remove the file from disk.');
+    const selected = await select({
+        message: 'Select a manifesto to delete:',
+        choices: files.map(f => ({ name: f.replace('.md', ''), value: f })),
+    });
+    const name = selected.replace(/\.md$/, '').replace(/-/g, ' ');
+    logWarn('This action cannot be undone.');
+    logInfo('Select Yes to confirm deletion.');
+    const doDelete = await confirm({ message: `Delete manifesto '${name}'?`, default: false });
+    if (!doDelete) {
+        logInfo('Operation cancelled.');
+        return;
+    }
+    const filePath = path.join(paths.manifestos, selected);
+    fs.unlinkSync(filePath);
+    // Step 5 — Log entry
+    const logPath = path.join(paths.logs, 'pde.log.md');
+    const logLine = `- ${new Date().toISOString()} | manifesto:delete | ${selected} | deleted\n`;
+    fs.ensureFileSync(logPath);
+    fs.appendFileSync(logPath, logLine, { encoding: 'utf8' });
+    // Step 6 — Git commit if enabled
+    const config = loadConfig(cwd);
+    gitAddAndCommit(cwd, `feat(manifesto): remove ${name}`, config);
+    // Step 7 — Final output
+    logSuccess(`Manifesto '${name}' deleted.`);
+}

package/dist/commands/requirement-create.js

@@ -0,0 +1,100 @@
+import { input, select, confirm } from '@inquirer/prompts';
+import fs from 'fs-extra';
+import path from 'path';
+import { getPaths } from '../core/paths.js';
+import { logError, logWarn, logInfo, logSuccess } from '../core/logger.js';
+import { gitAddAndCommit } from '../core/git.js';
+import { loadConfig } from '../core/config.js';
+function toKebabCase(str) {
+    return str
+        .normalize('NFD')
+        .replace(/[^\w\s-]/g, '')
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-');
+}
+export async function requirementCreateCommand() {
+    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 — Interactive prompts
+    logInfo('The name of this requirement. Should be clear and specific (e.g. User Registration, Password Reset).');
+    const name = await input({ message: 'Requirement name:', validate: (inputVal) => inputVal.trim() !== '' || 'Name is required' });
+    logInfo('Functional requirements describe behavior. Non-functional describe quality. Business rules describe constraints.');
+    const type = await select({ message: 'Type:', choices: [
+            { name: 'Functional', value: 'functional' },
+            { name: 'Non-functional', value: 'non-functional' },
+            { name: 'Business rule', value: 'business-rule' }
+        ] });
+    logInfo('High priority requirements are evaluated first in the quality score.');
+    const priority = await select({ message: 'Priority:', choices: [
+            { name: 'High', value: 'high' },
+            { name: 'Medium', value: 'medium' },
+            { name: 'Low', value: 'low' }
+        ] });
+    logInfo('A clear, objective description of what this requirement specifies.');
+    const description = await input({ message: 'Brief description:', validate: (inputVal) => inputVal.trim() !== '' || 'Description is required' });
+    logInfo('The conditions that must be true for this requirement to be considered complete. Comma-separated.');
+    const criteria = await input({ message: 'Acceptance criteria (comma-separated):', validate: (inputVal) => inputVal.trim() !== '' || 'Acceptance criteria required' });
+    const kebabName = toKebabCase(name);
+    const filename = `${kebabName}.md`;
+    const filePath = path.join(paths.requirements, filename);
+    // Step 3 — Check for duplicates
+    if (fs.existsSync(filePath)) {
+        logWarn('Requirement already exists.');
+        logInfo('Select Yes to overwrite the existing requirement file.');
+        const overwrite = await confirm({ message: 'Requirement already exists. Overwrite?', default: false });
+        if (!overwrite) {
+            logInfo('Operation cancelled.');
+            return;
+        }
+    }
+    // Step 4 — Generate requirement file
+    const templatePath = path.join(paths.templates, 'requirement.template.md');
+    if (!fs.existsSync(templatePath)) {
+        logError('Requirement template not found.');
+        return;
+    }
+    let template = fs.readFileSync(templatePath, { encoding: 'utf8' });
+    template = template.replace('[Name]', name);
+    const meta = `---\nname: ${name}\ntype: ${type}\npriority: ${priority}\ndescription: ${description}\ncreatedAt: ${new Date().toISOString()}\n---\n\n`;
+    const criteriaLines = criteria.split(',').map((c) => `- ${c.trim()}`).join('\n');
+    const criteriaSection = `## Acceptance Criteria\n${criteriaLines}\n\n`;
+    const content = meta + criteriaSection + template;
+    fs.writeFileSync(filePath, content, { encoding: 'utf8' });
+    // Step 5 — Update pde.index.md
+    if (fs.existsSync(paths.index)) {
+        let indexContent = fs.readFileSync(paths.index, { encoding: 'utf8' });
+        const requirementsSection = '- Requirements: .r2pde-ai/requirements/';
+        const newLine = `  - ${name}: .r2pde-ai/requirements/${filename}`;
+        if (indexContent.includes(requirementsSection)) {
+            const lines = indexContent.split('\n');
+            const idx = lines.findIndex(l => l.trim() === requirementsSection);
+            if (idx !== -1) {
+                let insertAt = idx + 1;
+                while (insertAt < lines.length && (lines[insertAt].startsWith('  - ') || lines[insertAt].trim() === ''))
+                    insertAt++;
+                lines.splice(insertAt, 0, newLine);
+                indexContent = lines.join('\n');
+                fs.writeFileSync(paths.index, indexContent, { encoding: 'utf8' });
+            }
+        }
+    }
+    else {
+        logWarn('pde.index.md not found. Skipping index update.');
+    }
+    // Step 6 — Log entry
+    const logPath = path.join(paths.logs, 'pde.log.md');
+    const logLine = `- ${new Date().toISOString()} | requirement:create | ${filename} | created\n`;
+    fs.ensureFileSync(logPath);
+    fs.appendFileSync(logPath, logLine, { encoding: 'utf8' });
+    // Step 7 — Git commit if enabled
+    const config = loadConfig(cwd);
+    gitAddAndCommit(cwd, `feat(requirement): add ${name}`, config);
+    // Step 8 — Final output
+    logSuccess(`Requirement '${name}' created at .r2pde-ai/requirements/${filename}`);
+}

package/dist/commands/requirement-delete.js

@@ -0,0 +1,46 @@
+import { select, confirm } from '@inquirer/prompts';
+import fs from 'fs-extra';
+import path from 'path';
+import { getPaths } from '../core/paths.js';
+import { logError, logWarn, logInfo, logSuccess } from '../core/logger.js';
+import { gitAddAndCommit } from '../core/git.js';
+import { loadConfig } from '../core/config.js';
+export async function requirementDeleteCommand() {
+    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 files = fs.readdirSync(paths.requirements).filter(f => f.endsWith('.md'));
+    if (files.length === 0) {
+        logInfo('No requirements found.');
+        return;
+    }
+    logInfo('Select the artifact to permanently delete. This action cannot be undone and will remove the file from disk.');
+    const selectedName = await select({
+        message: 'Select a requirement to delete:',
+        choices: files.map(f => ({ name: f.replace('.md', ''), value: f.replace('.md', '') })),
+    });
+    const selected = `${selectedName}.md`;
+    const name = selected.replace(/\.md$/, '').replace(/-/g, ' ');
+    logWarn('This action cannot be undone.');
+    logInfo('Select Yes to confirm deletion.');
+    const doDelete = await confirm({ message: `Delete requirement '${name}'?`, default: false });
+    if (!doDelete) {
+        logInfo('Operation cancelled.');
+        return;
+    }
+    const filePath = path.join(paths.requirements, selected);
+    fs.unlinkSync(filePath);
+    // Step 5 — Log entry
+    const logPath = path.join(paths.logs, 'pde.log.md');
+    const logLine = `- ${new Date().toISOString()} | requirement:delete | ${selected} | deleted\n`;
+    fs.ensureFileSync(logPath);
+    fs.appendFileSync(logPath, logLine, { encoding: 'utf8' });
+    // Step 6 — Git commit if enabled
+    const config = loadConfig(cwd);
+    gitAddAndCommit(cwd, `feat(requirement): remove ${name}`, config);
+    // Step 7 — Final output
+    logSuccess(`Requirement '${name}' deleted.`);
+}