r2pde-ai 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](https://semver.org).
+
+
+## [0.1.1] - 2026-05-14
+
+### Changed
+- Refactored `wave:prompt` to clarify that the AI API only generates optimized prompts for Copilot, never code.
+- Updated all documentation (README, GUIDE, doctor, CLI help) to explain the new prompt optimization flow and Copilot's role.
+
+### Added
+- `init` command — interactive project initialization with full .r2pde-ai structure
+- `doctor` command — environment health check
+- `manifesto:create` / `manifesto:delete` — manifesto artifact management
+- `contract:create` / `contract:delete` — contract artifact management
+- `requirement:create` / `requirement:delete` — requirement artifact management
+- `score` / `score:config` — quality score engine with traffic light system
+- `wave:prompt` — consolidated AI copilot prompt generation per wave
+- `config:set` / `config:lang` — configuration management
+- `reset` — prompts folder cleanup
+- `logs` / `logs --clear` — audit log management
+- Automated tests with Vitest (14 tests, 100% pass)
+- Enhanced --help with examples and documentation

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 r2pde-ai contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,373 @@
+# r2pde-ai
+
+> **Pilot Driven Engineering** — A CLI framework that bridges the gap between architectural intent and AI-generated code.
+
+[![npm version](https://img.shields.io/npm/v/r2pde-ai.svg)](https://www.npmjs.com/package/r2pde-ai)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen)](https://nodejs.org)
+
+---
+
+## What is r2pde-ai?
+
+`r2pde-ai` is a CLI framework for solo developers working with AI copilots (GitHub Copilot, Claude, etc.) inside VS Code. It structures your project's architectural decisions — manifestos, contracts, and specifications — into versioned markdown artifacts that guide the AI with precision, reducing ambiguity, token waste, and code drift.
+
+The result: less programming, more engineering. Less guessing, more intent.
+
+---
+
+## How it works
+
+```
+Developer defines → CLI structures → AI receives context → AI delivers code
+```
+
+1. Install the package globally
+2. Run `r2pde-ai init` inside your project folder
+3. Use CLI commands to generate manifestos, contracts, and specifications
+4. Use the generated prompts with your AI copilot
+5. Everything is versioned, logged, and git-tracked
+
+---
+
+## Installation
+
+```bash
+npm install -g r2pde-ai
+```
+
+**Requirements**
+- Node.js >= 20.0.0 (LTS)
+- npm >= 10
+- Git initialized in your project
+
+---
+
+## Quick Start
+
+```bash
+# Create and navigate to your project folder
+mkdir my-project && cd my-project
+
+# Initialize git
+git init
+
+# Initialize r2pde-ai
+r2pde-ai init
+
+# Check environment health
+r2pde-ai doctor
+
+# Read the user guide to understand artifacts
+# See .r2pde-ai/GUIDE.md
+
+# Create your first manifesto
+r2pde-ai manifesto:create
+
+# Evaluate quality score
+r2pde-ai score
+```
+
+---
+
+## Project Structure
+
+After `init`, the following structure is created inside your project:
+
+```
+.r2pde-ai/
+├── pde.index.md                  # Master index — always paste this into your AI copilot first
+├── pde.config.json               # Central configuration file
+├── GUIDE.md                      # Human-readable guide — artifact types, structure, examples
+├── templates/
+│   ├── manifesto.template.md     # Template used by CLI when generating manifestos
+│   ├── contract.template.md      # Template used by CLI when generating contracts
+│   └── requirement.template.md   # Template used by CLI when generating requirements
+├── manifestos/                   # Guiding principles (UI, UX, code philosophy)
+├── contracts/                    # Rigid rules (architecture, TDD, DDD, security, routes)
+├── requirements/                 # Application specification (goals, flows, domains)
+├── waves/                        # Implementation waves and progress tracking
+├── prompts/                      # Generated prompts for AI copilot (manually deletable)
+└── logs/                         # Audit log of all CLI commands executed
+```
+
+### About Templates
+
+Templates live in `.r2pde-ai/templates/` and serve two purposes:
+
+- **For the CLI** — used as the base structure when generating new artifacts via commands
+- **For the developer** — reference models showing what each artifact should contain and how it should be structured
+
+Templates can be customized. Once edited, the CLI will use your version as the base for all future artifact generation in that project — making every artifact consistent with your project's specific style and conventions.
+
+### About GUIDE.md
+
+`GUIDE.md` is generated by `init` and serves as the human-readable reference for the framework. It explains each artifact type, its purpose, its structure, and includes annotated examples. Consult it whenever you need to understand what to put in a manifesto, contract, or requirement.
+
+---
+
+## Core Concepts
+
+### Manifestos
+Flexible guiding principles covering UI, UX, code philosophy, and development culture.
+
+### Contracts
+Rigid, non-negotiable rules covering architecture, TDD, DDD, security, permissions, routing, tests, and commit conventions.
+
+### Requirements
+Full application specification: objectives, functional and non-functional requirements, business rules, use cases, flows, domains, and acceptance criteria.
+
+### Waves
+Incremental implementation phases:
+1. Framework → 2. Architecture → 3. Conceptual environment → 4. Core (errors, logs, security) → 5. Authentication → 6. Users → 7. UI/UX → 8. Tests → 9. Documentation
+
+### Quality Score
+Before generating any prompt, the CLI evaluates all artifacts from the current wave forward and returns a traffic-light score:
+- 🟢 **Green** — consistent, proceed
+- 🟡 **Yellow** — gaps or ambiguities detected, proceed with awareness
+- 🔴 **Red** — critical conflicts or broken dependencies, strongly advised to resolve first
+
+The score is contextual — it evaluates from the current wave forward, not the entire project. Thresholds are configurable.
+
+---
+
+## CLI Commands
+
+| Command | Description |
+|---|---|
+| `r2pde-ai init` | Initialize framework in current directory |
+| `r2pde-ai doctor` | Check environment health |
+| `r2pde-ai manifesto:create` | Create a new manifesto |
+| `r2pde-ai manifesto:delete` | Delete a manifesto |
+| `r2pde-ai contract:create` | Create a new contract |
+| `r2pde-ai contract:delete` | Delete a contract |
+| `r2pde-ai requirement:create` | Create a new requirement |
+| `r2pde-ai requirement:delete` | Delete a requirement |
+| `r2pde-ai score` | Evaluate quality score from current context |
+| `r2pde-ai score:config` | Configure score thresholds |
+| `r2pde-ai wave:prompt` | Generate consolidated prompt for current wave |
+| `r2pde-ai config:set` | Update configuration values |
+| `r2pde-ai config:lang` | Set language for messages and artifacts |
+| `r2pde-ai reset` | Reset prompts folder (with confirmation) |
+| `r2pde-ai logs` | View audit log |
+
+---
+
+## Configuration
+
+The `pde.config.json` file controls all framework behavior. Every setting has a sensible default and can be changed via commands.
+
+```json
+{
+  "version": "1.0.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": ""
+  }
+}
+```
+
+### Core Design Principle
+
+> *Every behavior has a default. Every default is configurable. Every configuration has a command.*
+
+---
+
+
+## AI API Integration (Advanced Mode)
+
+r2pde-ai works in two modes:
+
+**Offline mode (default)** — The CLI generates structured prompts that you copy and paste into GitHub Copilot. No external AI required.
+
+**API mode** — When an external AI API is configured, the CLI sends your project context to the AI, which generates an optimized, more precise prompt for GitHub Copilot. You still copy and paste into Copilot — but the prompt is significantly better.
+
+**Important:** The AI API never generates code directly. It generates better prompts for Copilot. Copilot is always responsible for generating the code.
+
+To enable API mode:
+```bash
+r2pde-ai config:set ai.apiUrl https://api.anthropic.com
+r2pde-ai config:set ai.apiKey your-api-key
+r2pde-ai config:set ai.model claude-sonnet-4-20250514
+```
+
+Supported: any API following the Anthropic messages format. OpenAI-compatible APIs may require adapter configuration in future versions.
+
+---
+
+## Git Integration
+
+`r2pde-ai` is designed to live inside a git repository. Every artifact is a markdown file — versionable, diffable, and auditable.
+
+Auto-commit (optional):
+```bash
+r2pde-ai config:set git.autoCommit true
+```
+
+When enabled, every CLI command that creates or modifies an artifact automatically stages and commits the change with a standardized message.
+
+---
+
+## Internationalization
+
+Default language is English for both CLI messages and artifact structure. To change:
+
+```bash
+r2pde-ai config:lang --messages pt
+r2pde-ai config:lang --artifacts pt
+```
+
+---
+
+## Contributing
+
+We welcome contributions of all kinds — bug reports, feature requests, documentation improvements, and code.
+
+### Before You Start
+
+1. Read this README fully
+2. Check [open issues](../../issues) — your idea may already be in progress
+3. For significant changes, open an issue first to discuss the approach
+4. Keep changes focused — one concern per pull request
+
+### Development Setup
+
+```bash
+# Fork and clone the repository
+git clone https://github.com/your-username/r2pde-ai.git
+cd r2pde-ai
+
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Link locally for testing
+npm link
+
+# Run tests
+npm test
+```
+
+### Branching Convention
+
+| Branch | Purpose |
+|---|---|
+| `main` | Stable, released code |
+| `dev` | Active development |
+| `feature/short-description` | New features |
+| `fix/short-description` | Bug fixes |
+| `docs/short-description` | Documentation only |
+
+All pull requests target `dev`. Never submit directly to `main`.
+
+### Commit Convention
+
+We follow [Conventional Commits](https://www.conventionalcommits.org):
+
+```
+feat: add score:config command
+fix: resolve wave detection on nested folders
+docs: update contributing guide
+chore: bump dependencies
+refactor: simplify artifact loader
+test: add score threshold validation
+```
+
+### Pull Request Process
+
+1. Branch from `dev`
+2. Write or update tests for your change
+3. Ensure `npm test` passes with no failures
+4. Update documentation if the change affects behavior or commands
+5. Open a PR against `dev` with a clear title and description
+6. Reference any related issue with `Closes #number`
+7. Wait for review — we aim to respond within 72 hours
+
+### Code Standards
+
+- TypeScript strict mode — no `any`
+- All public functions documented with JSDoc
+- File names in `kebab-case`
+- Classes and components in `PascalCase`
+- Methods and properties in `camelCase`
+- Constants in `UPPER_SNAKE_CASE`
+- Custom errors in `PascalCase` + `Error` suffix
+
+### Reporting Bugs
+
+Open an issue with:
+- Node.js version (`node --version`)
+- r2pde-ai version (`r2pde-ai --version`)
+- Operating system
+- Command that triggered the issue
+- Expected vs actual behavior
+- Minimal reproduction steps
+
+### Requesting Features
+
+Open an issue with:
+- Problem you are trying to solve
+- How you currently work around it
+- Proposed solution or command
+- Any alternative approaches considered
+
+### Code of Conduct
+
+Be direct, be respectful, be constructive. We value clarity over ceremony. Discussions should focus on ideas, not individuals. Maintainers reserve the right to close unconstructive threads.
+
+---
+
+## Versioning
+
+This project follows [Semantic Versioning](https://semver.org):
+
+- `MAJOR` — breaking changes to CLI commands or artifact structure
+- `MINOR` — new commands or backward-compatible features
+- `PATCH` — bug fixes and internal improvements
+
+Changelogs are maintained in [CHANGELOG.md](./CHANGELOG.md).
+
+---
+
+## License
+
+MIT © r2pde-ai contributors
+
+See [LICENSE](./LICENSE) for full terms.
+
+---
+
+## Roadmap
+
+- [ ] `init` interactive mode with project type and architecture selection
+- [ ] Template customization per project
+- [ ] API mode with full AI integration
+- [ ] Quality score engine
+- [ ] Wave prompt consolidation
+- [ ] VS Code extension for inline command execution
+- [ ] Multi-language artifact support
+- [ ] Plugin system for custom contracts and manifestos

package/dist/cli.js

@@ -0,0 +1,97 @@
+import { resetCommand } from './commands/reset.js';
+import { logsCommand } from './commands/logs.js';
+import { requirementCreateCommand } from './commands/requirement-create.js';
+import { requirementDeleteCommand } from './commands/requirement-delete.js';
+import { scoreCommand } from './commands/score.js';
+import { scoreConfigCommand } from './commands/score-config.js';
+import { wavePromptCommand } from './commands/wave-prompt.js';
+import { configSetCommand } from './commands/config-set.js';
+import { configLangCommand } from './commands/config-lang.js';
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { doctorCommand } from './commands/doctor.js';
+import { manifestoCreateCommand } from './commands/manifesto-create.js';
+import { manifestoDeleteCommand } from './commands/manifesto-delete.js';
+import { contractCreateCommand } from './commands/contract-create.js';
+import { contractDeleteCommand } from './commands/contract-delete.js';
+const program = new Command();
+program.addHelpText('after', `
+Examples:
+  $ r2pde-ai init
+  $ r2pde-ai doctor
+  $ r2pde-ai manifesto:create
+  $ r2pde-ai contract:create
+  $ r2pde-ai requirement:create
+  $ r2pde-ai score
+  $ r2pde-ai score --from contracts
+  $ r2pde-ai wave:prompt
+  $ r2pde-ai config:set git.autoCommit true
+  $ r2pde-ai config:lang
+  $ r2pde-ai logs
+  $ r2pde-ai logs --clear
+  $ r2pde-ai reset
+
+Documentation:
+  After init, read .r2pde-ai/GUIDE.md for full artifact reference.
+  Always paste .r2pde-ai/pde.index.md into your AI copilot before any prompt.
+`);
+program.addCommand(resetCommand);
+program.addCommand(logsCommand);
+program
+    .command('requirement:create')
+    .description('Create a new requirement')
+    .action(() => {
+    void requirementCreateCommand();
+});
+program
+    .command('requirement:delete')
+    .description('Delete an existing requirement')
+    .action(() => {
+    void requirementDeleteCommand();
+});
+program
+    .command('contract:create')
+    .description('Create a new contract')
+    .action(() => {
+    void contractCreateCommand();
+});
+program
+    .command('contract:delete')
+    .description('Delete an existing contract')
+    .action(() => {
+    void contractDeleteCommand();
+});
+program
+    .command('manifesto:create')
+    .description('Create a new manifesto')
+    .action(() => {
+    void manifestoCreateCommand();
+});
+program
+    .command('manifesto:delete')
+    .description('Delete an existing manifesto')
+    .action(() => {
+    void manifestoDeleteCommand();
+});
+program.addCommand(scoreCommand);
+program.addCommand(scoreConfigCommand);
+program.addCommand(wavePromptCommand);
+program.addCommand(configSetCommand);
+program.addCommand(configLangCommand);
+program
+    .name('r2pde-ai')
+    .description('Pilot Driven Engineering A CLI framework that bridges the gap between architectural intent and AI-generated code.')
+    .version('0.1.0');
+program
+    .command('init')
+    .description('Initialize r2pde-ai in the current project')
+    .action(() => {
+    void initCommand();
+});
+program
+    .command('doctor')
+    .description('Check the health of the r2pde-ai environment')
+    .action(() => {
+    void doctorCommand();
+});
+program.parse();

package/dist/commands/config-lang.js

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import { select } from '@inquirer/prompts';
+import { loadConfig, saveConfig } from '../core/config.js';
+import { logInfo, logSuccess } from '../core/logger.js';
+export const configLangCommand = new Command('config:lang')
+    .description('Set language for messages and artifacts')
+    .action(async () => {
+    const cwd = process.cwd();
+    const config = loadConfig(cwd);
+    logInfo('The language for all CLI output messages.');
+    const language = await select({
+        message: 'Language for CLI messages:',
+        choices: [
+            { name: 'English', value: 'en' },
+            { name: 'Português', value: 'pt' }
+        ],
+        default: config.language || 'en',
+    });
+    logInfo('The language used when generating markdown artifact files.');
+    const artifactsLanguage = await select({
+        message: 'Language for artifacts:',
+        choices: [
+            { name: 'English', value: 'en' },
+            { name: 'Português', value: 'pt' }
+        ],
+        default: config.artifactsLanguage || 'en',
+    });
+    config.language = language;
+    config.artifactsLanguage = artifactsLanguage;
+    saveConfig(cwd, config);
+    logSuccess('Language settings updated.');
+});

package/dist/commands/config-set.js

@@ -0,0 +1,38 @@
+import { Command } from 'commander';
+import { loadConfig, saveConfig } from '../core/config.js';
+import { logSuccess, logWarn } from '../core/logger.js';
+function setByDot(obj, path, value) {
+    const keys = path.split('.');
+    let cur = obj;
+    for (let i = 0; i < keys.length - 1; ++i) {
+        if (!(keys[i] in cur))
+            return false;
+        cur = cur[keys[i]];
+    }
+    const last = keys[keys.length - 1];
+    if (!(last in cur))
+        return false;
+    cur[last] = value;
+    return true;
+}
+export const configSetCommand = new Command('config:set')
+    .description('Set a configuration value')
+    .argument('<key>', 'Config key (dot notation)')
+    .argument('<value>', 'Value to set')
+    .action((key, value) => {
+    const cwd = process.cwd();
+    const config = loadConfig(cwd);
+    let v = value;
+    if (value === 'true')
+        v = true;
+    else if (value === 'false')
+        v = false;
+    else if (!isNaN(Number(value)))
+        v = Number(value);
+    const ok = setByDot(config, key, v);
+    if (!ok) {
+        logWarn(`Key does not exist in config: ${key}`);
+    }
+    saveConfig(cwd, config);
+    logSuccess(`Config updated: ${key} = ${v}`);
+});

package/dist/commands/contract-create.js

@@ -0,0 +1,101 @@
+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 contractCreateCommand() {
+    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 contract. Should reflect what rule it enforces (e.g. API Security, Commit Convention).');
+    const name = await input({ message: 'Contract name:', validate: (inputVal) => inputVal.trim() !== '' || 'Name is required' });
+    logInfo('The category this contract belongs to. Used for organization and score evaluation.');
+    const type = await select({ message: 'Type:', choices: [
+            { name: 'Architecture', value: 'architecture' },
+            { name: 'TDD', value: 'tdd' },
+            { name: 'DDD', value: 'ddd' },
+            { name: 'Security', value: 'security' },
+            { name: 'Permissions', value: 'permissions' },
+            { name: 'Routing', value: 'routing' },
+            { name: 'Tests', value: 'tests' },
+            { name: 'Commits', value: 'commits' },
+            { name: 'Other', value: 'other' }
+        ] });
+    logInfo('Mandatory contracts are evaluated strictly. Recommended contracts generate warnings only.');
+    const enforcement = await select({ message: 'Enforcement level:', choices: [
+            { name: 'Mandatory', value: 'mandatory' },
+            { name: 'Recommended', value: 'recommended' }
+        ] });
+    logInfo('A brief summary of what this contract enforces and the consequences of violation.');
+    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.contracts, filename);
+    // Step 3 — Check for duplicates
+    if (fs.existsSync(filePath)) {
+        logWarn('Contract already exists.');
+        logInfo('Select Yes to overwrite the existing contract file.');
+        const overwrite = await confirm({ message: 'Contract already exists. Overwrite?', default: false });
+        if (!overwrite) {
+            logInfo('Operation cancelled.');
+            return;
+        }
+    }
+    // Step 4 — Generate contract file
+    const templatePath = path.join(paths.templates, 'contract.template.md');
+    if (!fs.existsSync(templatePath)) {
+        logError('Contract template not found.');
+        return;
+    }
+    let template = fs.readFileSync(templatePath, { encoding: 'utf8' });
+    template = template.replace('[Name]', name);
+    const meta = `---\nname: ${name}\ntype: ${type}\nenforcement: ${enforcement}\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 contractsSection = '- Contracts: .r2pde-ai/contracts/';
+        const newLine = `  - ${name}: .r2pde-ai/contracts/${filename}`;
+        if (indexContent.includes(contractsSection)) {
+            const lines = indexContent.split('\n');
+            const idx = lines.findIndex(l => l.trim() === contractsSection);
+            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()} | contract: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(contract): add ${name}`, config);
+    // Step 8 — Final output
+    logSuccess(`Contract '${name}' created at .r2pde-ai/contracts/${filename}`);
+}