fraim-framework 1.0.12 → 2.0.2

package/setup.js

@@ -1,482 +1,831 @@
 #!/usr/bin/env node
 
+/**
+ * FRAIM Framework Setup Script
+ * 
+ * This script sets up the FRAIM framework in a repository.
+ * It creates the necessary directory structure, configuration files,
+ * and templates for AI agent management.
+ */
+
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 const readline = require('readline');
 
-// Colors for console output
+// ANSI color codes for terminal output
 const colors = {
     reset: '\x1b[0m',
     bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    underscore: '\x1b[4m',
+    blink: '\x1b[5m',
+    reverse: '\x1b[7m',
+    hidden: '\x1b[8m',
+    
+    black: '\x1b[30m',
     red: '\x1b[31m',
     green: '\x1b[32m',
     yellow: '\x1b[33m',
     blue: '\x1b[34m',
     magenta: '\x1b[35m',
-    cyan: '\x1b[36m'
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    
+    bgBlack: '\x1b[40m',
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue: '\x1b[44m',
+    bgMagenta: '\x1b[45m',
+    bgCyan: '\x1b[46m',
+    bgWhite: '\x1b[47m'
 };
 
-function log(message, color = 'reset') {
-    console.log(`${colors[color]}${message}${colors.reset}`);
+// Logging functions
+function log(message) {
+    console.log(message);
+}
+
+function logHeader(message) {
+    console.log('\n' + colors.bright + colors.cyan + '='.repeat(60) + colors.reset);
+    console.log(colors.bright + colors.cyan + ' ' + message + colors.reset);
+    console.log(colors.bright + colors.cyan + '='.repeat(60) + colors.reset + '\n');
+}
+
+function logStep(message) {
+    console.log('\n' + colors.bright + colors.blue + '➤ ' + message + colors.reset);
 }
 
 function logSuccess(message) {
-    log(`✅ ${message}`, 'green');
+    console.log(colors.green + '✓ ' + message + colors.reset);
 }
 
 function logInfo(message) {
-    log(`ℹ️  ${message}`, 'blue');
+    console.log(colors.cyan + 'ℹ ' + message + colors.reset);
 }
 
 function logWarning(message) {
-    log(`⚠️  ${message}`, 'yellow');
+    console.log(colors.yellow + '⚠ ' + message + colors.reset);
 }
 
 function logError(message) {
-    log(`❌ ${message}`, 'red');
-}
-
-function logHeader(message) {
-    log(`\n${colors.bright}${colors.cyan}${message}${colors.reset}`);
-    log('─'.repeat(message.length));
+    console.error(colors.red + '✗ ' + message + colors.reset);
 }
 
-function logStep(message) {
-    log(`\n${colors.bright}${colors.magenta}${message}${colors.reset}`);
+// Helper functions
+function ensureDirectory(dir) {
+    const fullPath = path.resolve(process.cwd(), dir);
+    if (!fs.existsSync(fullPath)) {
+        fs.mkdirSync(fullPath, { recursive: true });
+        return true;
+    }
+    return false;
 }
 
-function ensureDirectory(dirPath) {
-    if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-        logSuccess(`Created directory: ${dirPath}`);
+function writeFile(filePath, content) {
+    const fullPath = path.resolve(process.cwd(), filePath);
+    const dir = path.dirname(fullPath);
+    
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
     }
+    
+    fs.writeFileSync(fullPath, content);
 }
 
-function writeFile(filePath, content) {
-    ensureDirectory(path.dirname(filePath));
-    fs.writeFileSync(filePath, content);
-    logSuccess(`Created file: ${filePath}`);
+function copyFile(src, dest) {
+    const srcPath = path.resolve(process.cwd(), src);
+    const destPath = path.resolve(process.cwd(), dest);
+    
+    if (fs.existsSync(srcPath)) {
+        const destDir = path.dirname(destPath);
+        if (!fs.existsSync(destDir)) {
+            fs.mkdirSync(destDir, { recursive: true });
+        }
+        
+        fs.copyFileSync(srcPath, destPath);
+        return true;
+    }
+    
+    return false;
 }
 
 function copyDirectory(src, dest) {
-    if (!fs.existsSync(dest)) {
-        fs.mkdirSync(dest, { recursive: true });
+    const srcPath = path.resolve(process.cwd(), src);
+    const destPath = path.resolve(process.cwd(), dest);
+    
+    if (!fs.existsSync(srcPath)) {
+        return false;
     }
     
-    const items = fs.readdirSync(src);
-    for (const item of items) {
-        const srcPath = path.join(src, item);
-        const destPath = path.join(dest, item);
+    if (!fs.existsSync(destPath)) {
+        fs.mkdirSync(destPath, { recursive: true });
+    }
+    
+    const files = fs.readdirSync(srcPath);
+    
+    for (const file of files) {
+        const srcFile = path.join(srcPath, file);
+        const destFile = path.join(destPath, file);
         
-        if (fs.statSync(srcPath).isDirectory()) {
-            copyDirectory(srcPath, destPath);
+        if (fs.statSync(srcFile).isDirectory()) {
+            copyDirectory(srcFile, destFile);
         } else {
-            fs.copyFileSync(srcPath, destPath);
-            logSuccess(`Copied: ${destPath}`);
+            fs.copyFileSync(srcFile, destFile);
         }
     }
+    
+    return true;
 }
 
-function askQuestion(question, defaultValue = 'y') {
-    return new Promise((resolve) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-        
-        const defaultText = defaultValue ? ` (${defaultValue})` : '';
-        rl.question(`${question}${defaultText}: `, (answer) => {
+function isGitRepository() {
+    try {
+        execSync('git rev-parse --is-inside-work-tree', { stdio: 'ignore' });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+// Interactive prompt
+function createReadlineInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+}
+
+async function askQuestion(question) {
+    const rl = createReadlineInterface();
+    
+    return new Promise(resolve => {
+        rl.question(colors.yellow + '? ' + question + ' (y/n) ' + colors.reset, answer => {
             rl.close();
-            const finalAnswer = answer.trim() || defaultValue;
-            resolve(finalAnswer.toLowerCase());
+            resolve(answer.toLowerCase());
         });
     });
 }
 
-function createProjectStructure() {
-    // Create retrospectives folder
-    ensureDirectory('retrospectives');
-    logSuccess('Created retrospectives folder');
-    
-    // Create docs/rfcs folder
-    ensureDirectory('docs/rfcs');
-    logSuccess('Created docs/rfcs folder');
+async function askInput(question, defaultValue = '') {
+    const rl = createReadlineInterface();
     
-    // Create BUGFIX template
-    const bugfixTemplate = `Issue: #<issue>  
+    return new Promise(resolve => {
+        rl.question(colors.yellow + '? ' + question + (defaultValue ? ` (${defaultValue})` : '') + ': ' + colors.reset, answer => {
+            rl.close();
+            resolve(answer || defaultValue);
+        });
+    });
+}
 
-## Impact of the Bug
+// Create rule files
+function createRuleFiles() {
+    // Create integrity-and-test-ethics.md
+    const integrityContent = `# Integrity and Test Ethics
 
-## Repro Steps
+THIS IS THE MOST CRITICAL RULE. Be ethical, truthful, honest above all.
 
-## Root Cause
+## Core Principles
 
-## Fix
+1. **Honesty in Testing**: Never fake test results or evidence. If a test fails, report it accurately.
+2. **Transparency**: Always disclose limitations, edge cases, and potential issues.
+3. **Ethical Code Generation**: Generate code that respects privacy, security, and user consent.
+4. **Accurate Representation**: Never claim functionality that doesn't exist or isn't implemented.
+5. **Intellectual Property Respect**: Properly attribute sources and respect licensing terms.
 
-## Tests
-- Could be existing tests that are failing and need to be fixed
-- Could be new tests that need to be added into an existing test suite
-- Could be a new test suite
-`;
-    writeFile('docs/rfcs/BUGFIX-TEMPLATE.md', bugfixTemplate);
-    logSuccess('Created BUGFIX-TEMPLATE.md');
-    
-    // Create RFC template
-    const rfcTemplate = `# RFC: <Title>
+## Test Ethics Guidelines
 
-Issue: #<issue>  
-Owner: <agent>
+- **No Fabrication**: Never fabricate test results or evidence
+- **Complete Reporting**: Report all test failures, not just successes
+- **Reproducible Tests**: Ensure tests are reproducible and deterministic
+- **Edge Case Honesty**: Explicitly document edge cases that aren't handled
+- **Performance Transparency**: Be honest about performance limitations
 
-## Customer 
+## Implementation Ethics
 
-## Customer Outcome
+- **Security First**: Never suggest insecure implementations for convenience
+- **Privacy Respect**: Handle user data with appropriate protections
+- **Accessibility**: Consider accessibility implications in all designs
+- **Documentation**: Document known limitations and issues
+- **Attribution**: Properly attribute external code sources and inspirations`;
+    writeFile('rules/integrity-and-test-ethics.md', integrityContent);
+    logSuccess('Created integrity-and-test-ethics.md');
 
-## Customer Problem being solved
+    // Create simplicity.md
+    const simplicityContent = `# Simplicity
 
-## Solution
+Keep solutions simple and focused, avoid over-engineering.
 
-## Alternatives
+## Core Principles
 
-## Design Details
-- User Experience changes (incl. all modalities currently supported: see codebase to know which ones)
-- API surface (OpenAPI) changes
-- Data model / schema changes
-- Failure modes & timeouts
-- Telemetry & analytics
+1. **Focus on the Current Issue**: When fixing an issue, focus only on that issue.
+2. **Avoid Premature Optimization**: Don't optimize code until there's a demonstrated need.
+3. **Minimize Dependencies**: Add new dependencies only when absolutely necessary.
+4. **Readable Over Clever**: Prefer readable code over clever solutions.
+5. **Incremental Changes**: Make small, focused changes rather than large rewrites.
 
-## Test Matrix
-- Unit: modules & edge cases
-- Integration: API <-> DB <-> external
-- E2E: user flows (happy/sad)
+## Guidelines
 
-## Risks & Mitigations
+- **Single Responsibility**: Each function, class, or module should have a single responsibility
+- **Explicit Over Implicit**: Favor explicit code over implicit behavior
+- **Standard Patterns**: Use standard patterns and idioms when possible
+- **Minimal API Surface**: Keep public APIs minimal and focused
+- **Avoid Premature Abstraction**: Don't abstract until you see repeated patterns
 
-## Observability (logs, metrics, alerts)
+## When Fixing Issues
 
-## Phased Delivery Plan
-- Do not incude timelines
-- Do include the following for each phase:
-  - Deliverable
-  - Value delivered by deliverable
-  - What will be tested
-`;
-    writeFile('docs/rfcs/RFC-TEMPLATE.md', rfcTemplate);
-    logSuccess('Created RFC-TEMPLATE.md');
-    
-    logSuccess('Project structure created');
-}
+- Focus only on the specific issue at hand
+- Avoid making unrelated changes
+- File separate issues for other problems you discover
+- Keep the scope narrow and well-defined`;
+    writeFile('rules/simplicity.md', simplicityContent);
+    logSuccess('Created simplicity.md');
 
-async function setupGitHubCLI() {
-    logStep('GitHub CLI Setup');
-    logInfo('To create GitHub labels automatically, you need GitHub CLI installed and authenticated.');
-    
-    // Check if gh is installed
-    try {
-        execSync('gh --version', { stdio: 'pipe' });
-        logSuccess('GitHub CLI is already installed');
-    } catch (error) {
-        logWarning('GitHub CLI is not installed');
-        logInfo('Installing GitHub CLI...');
-        logInfo('📥 Download from: https://cli.github.com/');
-        logInfo('💻 Or use package manager:');
-        logInfo('   Windows: winget install GitHub.cli');
-        logInfo('   macOS: brew install gh');
-        logInfo('   Ubuntu/Debian: sudo apt install gh');
-        logInfo('   CentOS/RHEL: sudo yum install gh');
-        
-        const waitForInstall = await askQuestion('Press Enter after installing GitHub CLI, or type "skip" to continue without it');
-        if (waitForInstall === 'skip') {
-            return false;
-        }
-        
-        // Check again
-        try {
-            execSync('gh --version', { stdio: 'pipe' });
-            logSuccess('GitHub CLI is now available');
-        } catch (error) {
-            logWarning('GitHub CLI still not available, continuing without it');
-            return false;
-        }
-    }
-    
-    // Check if authenticated
-    try {
-        execSync('gh auth status', { stdio: 'pipe' });
-        logSuccess('GitHub CLI is already authenticated');
-        return true;
-    } catch (error) {
-        logWarning('GitHub CLI is not authenticated');
-        logInfo('You need to authenticate with GitHub to create labels automatically.');
-        logInfo('🔐 Run: gh auth login');
-        logInfo('   This will open a browser for OAuth authentication');
-        
-        const waitForAuth = await askQuestion('Press Enter after authenticating, or type "skip" to continue without authentication');
-        if (waitForAuth === 'skip') {
-            return false;
-        }
-        
-        // Check authentication again
-        try {
-            execSync('gh auth status', { stdio: 'pipe' });
-            logSuccess('GitHub CLI is now authenticated');
-            return true;
-        } catch (error) {
-            logWarning('GitHub CLI authentication failed, continuing without it');
-            return false;
-        }
-    }
-}
+    // Create architecture.md
+    const architectureContent = `# Architecture
 
-function createGitHubLabels() {
-    const labels = [
-        { name: 'phase:design', color: '0e8a16', description: 'Design phase - RFC creation and review' },
-        { name: 'phase:impl', color: '1d76db', description: 'Implementation phase - coding and testing' },
-        { name: 'phase:tests', color: 'fef2c0', description: 'Testing phase - validation and QA' },
-        { name: 'status:wip', color: 'fbca04', description: 'Work in progress' },
-        { name: 'status:needs-review', color: 'd93f0b', description: 'Ready for review' },
-        { name: 'status:complete', color: '0e8a16', description: 'Completed and approved' },
-        { name: 'status:changes-requested', color: 'd93f0b', description: 'Changes requested in review' },
-        { name: 'ai-agent:cursor', color: '5319e7', description: 'Assigned to Cursor AI agent' },
-        { name: 'ai-agent:claude', color: 'c2e0c6', description: 'Assigned to Claude AI agent' },
-        { name: 'ai-agent:windsurf', color: 'bfdadc', description: 'Assigned to Windsurf AI agent' }
-    ];
-
-    logInfo('Creating GitHub labels...');
-    
-    for (const label of labels) {
-        try {
-            const command = `gh label create "${label.name}" --color "${label.color}" --description "${label.description}"`;
-            execSync(command, { stdio: 'pipe' });
-            logSuccess(`Created label: ${label.name}`);
-        } catch (error) {
-            if (error.message.includes('already exists')) {
-                logInfo(`Label already exists: ${label.name}`);
-            } else {
-                logWarning(`Failed to create label ${label.name}: ${error.message}`);
-            }
-        }
-    }
-    
-    logSuccess('GitHub labels created');
-}
+Maintain clean architectural boundaries by using appropriate technologies for each task.
 
-function createLabelsConfigFile() {
-    const labels = [
-        { name: 'phase:design', color: '0e8a16', description: 'Design phase - RFC creation and review' },
-        { name: 'phase:impl', color: '1d76db', description: 'Implementation phase - coding and testing' },
-        { name: 'phase:tests', color: 'fef2c0', description: 'Testing phase - validation and QA' },
-        { name: 'status:wip', color: 'fbca04', description: 'Work in progress' },
-        { name: 'status:needs-review', color: 'd93f0b', description: 'Ready for review' },
-        { name: 'status:complete', color: '0e8a16', description: 'Completed and approved' },
-        { name: 'status:changes-requested', color: 'd93f0b', description: 'Changes requested in review' },
-        { name: 'ai-agent:cursor', color: '5319e7', description: 'Assigned to Cursor AI agent' },
-        { name: 'ai-agent:claude', color: 'c2e0c6', description: 'Assigned to Claude AI agent' },
-        { name: 'ai-agent:windsurf', color: 'bfdadc', description: 'Assigned to Windsurf AI agent' }
-    ];
-
-    const labelsContent = JSON.stringify(labels, null, 2);
-    writeFile('.github/labels.json', labelsContent);
-    
-    logSuccess('GitHub labels configuration file created');
-    logInfo('You can import these labels using:');
-    logInfo('1. GitHub web interface: Settings > Labels > Import labels');
-    logInfo('2. Or manually create each label with the provided colors and descriptions');
-}
+## Core Principles
 
-function createGitHubWorkflows() {
-    // Get the directory where this script is located (FRAIM package directory)
-    const fraimDir = __dirname;
-    
-    // Copy actual workflow files from FRAIM/github folder
-    const workflowsSrc = path.join(fraimDir, 'github');
-    if (fs.existsSync(workflowsSrc)) {
-        copyDirectory(workflowsSrc, '.github/workflows');
-        logSuccess('GitHub workflows copied from FRAIM/github folder');
-    } else {
-        logWarning(`github folder not found at ${workflowsSrc}, skipping workflow creation`);
-    }
-}
+1. **Separation of Concerns**: Keep different parts of the system focused on their specific responsibilities.
+2. **Clean Interfaces**: Define clear interfaces between components.
+3. **Appropriate Technologies**: Use the right tool for each job.
+4. **Testability**: Design components to be easily testable.
+5. **Scalability**: Consider how the architecture will scale with increased load or complexity.
 
-function createAgentFolders() {
-    // Get the directory where this script is located (FRAIM package directory)
-    const fraimDir = __dirname;
-    
-    // Create .cursor folder at top level with all contents
-    const cursorSrc = path.join(fraimDir, 'agents', 'cursor');
-    if (fs.existsSync(cursorSrc)) {
-        copyDirectory(cursorSrc, '.cursor');
-        logSuccess('Created .cursor folder with all contents');
-    } else {
-        logWarning(`agents/cursor directory not found at ${cursorSrc}, skipping .cursor creation`);
-    }
+## Guidelines
 
-    // Create .windsurf folder at top level with all contents
-    const windsurfSrc = path.join(fraimDir, 'agents', 'windsurf');
-    if (fs.existsSync(windsurfSrc)) {
-        copyDirectory(windsurfSrc, '.windsurf');
-        logSuccess('Created .windsurf folder with all contents');
-    } else {
-        logWarning(`agents/windsurf directory not found at ${windsurfSrc}, skipping .windsurf creation`);
-    }
+- **Domain-Driven Design**: Model the system around the business domain
+- **Layered Architecture**: Maintain clear separation between layers
+- **Dependency Injection**: Use dependency injection for flexible component composition
+- **Interface-First Design**: Define interfaces before implementations
+- **Consistent Patterns**: Apply consistent patterns throughout the codebase
 
-    // Create CLAUDE.md at top level
-    const claudeSrc = path.join(fraimDir, 'agents', 'claude', 'CLAUDE.md');
-    if (fs.existsSync(claudeSrc)) {
-        const claudeContent = fs.readFileSync(claudeSrc, 'utf8');
-        writeFile('CLAUDE.md', claudeContent);
-        logSuccess('Created CLAUDE.md at top level');
-    } else {
-        logWarning(`agents/claude/CLAUDE.md not found at ${claudeSrc}, skipping CLAUDE.md creation`);
-    }
-}
+## Technology Selection
 
-async function runWizard() {
-    logHeader('🔮 FRAIM Interactive Setup Wizard');
-    log('Welcome to the FRAIM setup wizard! I\'ll guide you through each step.\n');
+- Use natural language processing technologies for language understanding tasks
+- Use deterministic code for business logic and data processing
+- Select appropriate data storage technologies based on access patterns
+- Choose UI frameworks based on application requirements and team expertise`;
+    writeFile('rules/architecture.md', architectureContent);
+    logSuccess('Created architecture.md');
 
-    try {
-        // Check prerequisites
-        logStep('Step 1: Checking Prerequisites');
-        
-        // Check if we're in a git repository
-        try {
-            execSync('git rev-parse --git-dir', { stdio: 'pipe' });
-            logSuccess('Running in a git repository');
-        } catch (error) {
-            logError('Not in a git repository');
-            logInfo('Please run this command from within a git repository');
-            return;
-        }
+    // Create continuous-learning.md
+    const continuousLearningContent = `# Continuous Learning
 
-        // Step 2: Project Structure
-        logStep('Step 2: Project Structure');
-        const setupStructure = await askQuestion('Would you like to create project structure (retrospectives, docs/rfcs with templates)?', 'y');
-        
-        if (setupStructure === 'y' || setupStructure === 'yes') {
-            createProjectStructure();
-        } else {
-            logInfo('Skipping project structure setup');
-        }
+Prevent repeating past mistakes by systematically learning from retrospectives, RFCs, and historical issue patterns.
 
-        // Step 3: AI Agent Setup
-        logStep('Step 3: AI Agent Configuration');
-        const setupAgents = await askQuestion('Would you like to set up AI agent configurations (.cursor, .windsurf, CLAUDE.md)?', 'y');
-        
-        if (setupAgents === 'y' || setupAgents === 'yes') {
-            createAgentFolders();
-        } else {
-            logInfo('Skipping AI agent setup');
-        }
+## Core Principles
 
-        // Step 4: GitHub Workflows
-        logStep('Step 4: GitHub Workflows');
-        const setupWorkflows = await askQuestion('Would you like to set up GitHub workflows for automation?', 'y');
-        
-        if (setupWorkflows === 'y' || setupWorkflows === 'yes') {
-            ensureDirectory('.github/workflows');
-            createGitHubWorkflows();
-        } else {
-            logInfo('Skipping GitHub workflow setup');
-        }
+1. **Learn from History**: Review past issues and solutions before starting similar work.
+2. **Document Learnings**: Capture insights in retrospectives and knowledge bases.
+3. **Share Knowledge**: Ensure learnings are accessible to all team members.
+4. **Evolve Practices**: Continuously refine processes based on experience.
+5. **Anticipate Issues**: Use historical patterns to predict and prevent problems.
 
-        // Step 5: GitHub Labels
-        logStep('Step 5: GitHub Labels');
-        const setupLabels = await askQuestion('Would you like to create GitHub labels for FRAIM?', 'y');
-        
-        if (setupLabels === 'y' || setupLabels === 'yes') {
-            const ghAvailable = await setupGitHubCLI();
-            if (ghAvailable) {
-                createGitHubLabels();
-            } else {
-                logInfo('GitHub CLI not available - creating labels configuration file instead');
-                createLabelsConfigFile();
-            }
-        } else {
-            logInfo('Skipping GitHub label setup');
-        }
+## Guidelines
 
-        // Step 6: Summary
-        logStep('Step 6: Setup Summary');
-        logHeader('🎉 Setup Complete!');
-        logSuccess('FRAIM has been successfully set up in your repository!');
-        logInfo('Next steps:');
-        logInfo('1. Commit and push these files to GitHub');
-        logInfo('2. Import GitHub labels from .github/labels.json using the web interface');
-        logInfo('3. Create your first issue with phase labels');
-        logInfo('4. Start coordinating your AI agents!');
-        
-        logInfo('\n📚 Learn more about FRAIM:');
-        logInfo('https://github.com/mathursrus/Ashley-Calendar-AI/tree/master/FRAIM');
-        
-        logInfo('\n🧠 Learn the RIGOR methodology:');
-        logInfo('npx fraim-framework rigor');
+- **Review Retrospectives**: Always review relevant retrospectives before starting work
+- **RFC Analysis**: Study RFCs for design decisions and rationales
+- **Pattern Recognition**: Identify recurring issues and their root causes
+- **Knowledge Base**: Contribute to and utilize the team's knowledge base
+- **Feedback Loops**: Create tight feedback loops for rapid learning
 
-    } catch (error) {
-        logError(`Wizard failed: ${error.message}`);
-        process.exit(1);
-    }
+## Implementation
+
+- Before starting work on an issue, search for similar past issues
+- Review retrospectives from related features or components
+- Check knowledge base for relevant patterns and anti-patterns
+- Document new learnings after completing work
+- Share insights with the team through appropriate channels`;
+    writeFile('rules/continuous-learning.md', continuousLearningContent);
+    logSuccess('Created continuous-learning.md');
+
+    // Create successful-debugging-patterns.md
+    const debuggingContent = `# Successful Debugging Patterns
+
+Debug issues systematically and convert learnings into test cases.
+
+## Core Principles
+
+1. **Systematic Approach**: Follow a structured debugging methodology.
+2. **Evidence-Based**: Base conclusions on evidence, not assumptions.
+3. **Root Cause Analysis**: Identify the root cause, not just symptoms.
+4. **Test Case Creation**: Create tests that verify the fix and prevent regression.
+5. **Knowledge Sharing**: Document findings for future reference.
+
+## Debugging Methodology
+
+1. **Reproduce**: Create a reliable reproduction of the issue
+2. **Isolate**: Narrow down the scope to the smallest possible area
+3. **Hypothesize**: Form testable hypotheses about the cause
+4. **Test**: Verify or disprove each hypothesis systematically
+5. **Fix**: Address the root cause, not just symptoms
+6. **Verify**: Confirm the fix resolves the issue
+7. **Prevent**: Add tests to prevent regression
+
+## Best Practices
+
+- Use logging strategically to gather information
+- Leverage debugging tools appropriate for the technology
+- Break complex issues into smaller, testable components
+- Document the debugging process and findings
+- Create regression tests that would have caught the issue`;
+    writeFile('rules/successful-debugging-patterns.md', debuggingContent);
+    logSuccess('Created successful-debugging-patterns.md');
 }
 
-async function runSetup() {
-    logHeader('🚀 FRAIM Quick Setup');
-    log('Setting up FRAIM in current repository...\n');
+// Create workflow templates
+function createWorkflowTemplates() {
+    // Create design.md
+    const designContent = `# Design Phase Workflow
+
+## Overview
+This workflow guides the design phase for new features or significant changes.
+
+## Steps
+
+### 1. Understand Requirements
+- Review the issue description thoroughly
+- Clarify any ambiguities with stakeholders
+- Identify acceptance criteria and constraints
+
+### 2. Research
+- Review similar features in the codebase
+- Check retrospectives for related work
+- Research industry best practices
+- Identify potential technical approaches
+
+### 3. Create RFC Document
+- Create a new RFC document in docs/rfcs/
+- Follow the RFC template structure
+- Include:
+  - Problem statement
+  - Proposed solution
+  - Alternative approaches considered
+  - Implementation plan
+  - Testing strategy
+  - Rollout plan
+
+### 4. Design Review
+- Submit RFC for review
+- Address feedback and iterate
+- Get final approval from stakeholders
+
+### 5. Transition to Implementation
+- Update issue with design decisions
+- Add implementation tasks
+- Apply "status:ready-for-implementation" label
+
+## Deliverables
+- Comprehensive RFC document
+- Updated issue with implementation tasks
+- Design approval from stakeholders`;
+    writeFile('workflows/design.md', designContent);
+    logSuccess('Created design.md workflow');
+
+    // Create implement.md
+    const implementContent = `# Implementation Phase Workflow
+
+## Overview
+This workflow guides the implementation phase after design approval.
+
+## Steps
+
+### 1. Prepare Development Environment
+- Create a feature branch from master
+- Set up local development environment
+- Verify test environment is working
+
+### 2. Implementation Planning
+- Break down work into manageable tasks
+- Prioritize tasks in logical order
+- Create a test plan for the implementation
+
+### 3. Iterative Development
+- Implement features in small, testable increments
+- Write tests alongside code
+- Commit frequently with descriptive messages
+- Keep changes focused on the current issue
+
+### 4. Testing
+- Run existing tests to ensure no regressions
+- Add new tests for added functionality
+- Test edge cases and error conditions
+- Document test evidence
+
+### 5. Code Review Preparation
+- Self-review code for quality and standards
+- Ensure all tests are passing
+- Update documentation as needed
+- Prepare PR description with implementation details
+
+### 6. Submit Pull Request
+- Create PR with comprehensive description
+- Link to the original issue
+- Include test evidence
+- Request review from appropriate reviewers
+
+## Deliverables
+- Working implementation of the feature
+- Comprehensive test coverage
+- Updated documentation
+- Pull request ready for review`;
+    writeFile('workflows/implement.md', implementContent);
+    logSuccess('Created implement.md workflow');
+
+    // Create test.md
+    const testContent = `# Testing Phase Workflow
+
+## Overview
+This workflow guides the testing phase to ensure quality and reliability.
+
+## Steps
+
+### 1. Test Planning
+- Review requirements and acceptance criteria
+- Identify test scenarios and edge cases
+- Create a test plan document
+- Define test data requirements
+
+### 2. Test Implementation
+- Implement unit tests for individual components
+- Create integration tests for component interactions
+- Develop end-to-end tests for user flows
+- Write performance tests if applicable
+
+### 3. Test Execution
+- Run all tests in development environment
+- Document test results and evidence
+- Investigate and fix any test failures
+- Verify fixes with additional test runs
+
+### 4. Edge Case and Error Testing
+- Test boundary conditions
+- Verify error handling and recovery
+- Test with invalid or unexpected inputs
+- Verify security constraints
+
+### 5. Documentation
+- Document test coverage
+- Record test evidence (screenshots, logs)
+- Update test documentation
+- Document any known limitations
+
+### 6. Test Review
+- Review test results with stakeholders
+- Address any feedback or concerns
+- Get approval for test completion
+- Apply "status:approved" label when tests pass
+
+## Deliverables
+- Comprehensive test suite
+- Test evidence documentation
+- Test coverage report
+- Stakeholder approval of test results`;
+    writeFile('workflows/test.md', testContent);
+    logSuccess('Created test.md workflow');
+
+    // Create resolve.md
+    const resolveContent = `# Issue Resolution Workflow
+
+## Overview
+This workflow guides the process of resolving issues and bugs.
+
+## Steps
+
+### 1. Issue Triage
+- Verify the issue can be reproduced
+- Assess severity and priority
+- Identify affected components
+- Determine if it's a regression
+
+### 2. Investigation
+- Reproduce the issue consistently
+- Identify the root cause through debugging
+- Document findings and affected code paths
+- Create a minimal reproduction if possible
+
+### 3. Solution Design
+- Design a fix that addresses the root cause
+- Consider potential side effects
+- Ensure backward compatibility if needed
+- Document the proposed solution
+
+### 4. Implementation
+- Create a fix branch from master
+- Implement the solution
+- Add tests that would have caught the issue
+- Verify the fix resolves the issue
+
+### 5. Testing
+- Run existing tests to ensure no regressions
+- Test the specific fix thoroughly
+- Document test evidence
+- Verify edge cases are handled
+
+### 6. Code Review and Merge
+- Submit PR with detailed description
+- Include reproduction steps and fix explanation
+- Request review from appropriate reviewers
+- Address feedback and iterate as needed
+
+### 7. Verification
+- Verify fix in production or staging
+- Document verification evidence
+- Close the issue with reference to the fix
+
+## Deliverables
+- Root cause analysis
+- Fixed implementation
+- Tests that prevent regression
+- Documentation of the resolution`;
+    writeFile('workflows/resolve.md', resolveContent);
+    logSuccess('Created resolve.md workflow');
+
+    // Create retrospect.md
+    const retrospectContent = `# Retrospective Workflow
+
+## Overview
+This workflow guides the process of conducting retrospectives after completing significant work.
+
+## Steps
+
+### 1. Preparation
+- Schedule retrospective meeting
+- Gather metrics and data about the work
+- Review issue history and PRs
+- Identify key events and milestones
+
+### 2. Retrospective Meeting
+- Review what went well
+- Identify what could be improved
+- Discuss unexpected challenges
+- Recognize team and individual contributions
+
+### 3. Root Cause Analysis
+- Analyze issues and challenges
+- Identify root causes, not just symptoms
+- Look for patterns across multiple issues
+- Consider process and technical factors
+
+### 4. Action Items
+- Create specific, actionable improvements
+- Assign owners to action items
+- Set deadlines for implementation
+- Create issues for tracking action items
+
+### 5. Documentation
+- Document retrospective findings
+- Create retrospective document in /retrospectives/
+- Include metrics, learnings, and action items
+- Share with the team and stakeholders
+
+### 6. Follow-up
+- Track progress on action items
+- Implement process improvements
+- Update documentation and guidelines
+- Reference learnings in future work
+
+## Deliverables
+- Retrospective document with findings
+- Action items with owners and deadlines
+- Updated processes and guidelines
+- Knowledge sharing with the team`;
+    writeFile('workflows/retrospect.md', retrospectContent);
+    logSuccess('Created retrospect.md workflow');
+}
 
-    try {
-        // Check prerequisites
-        try {
-            execSync('git rev-parse --git-dir', { stdio: 'pipe' });
-        } catch (error) {
-            logError('Not in a git repository');
-            logInfo('Please run this command from within a git repository');
-            process.exit(1);
-        }
+// Create project structure
+function createProjectStructure() {
+    // Create directories
+    ensureDirectory('retrospectives');
+    ensureDirectory('docs/rfcs');
+    ensureDirectory('rules');
+    ensureDirectory('templates/evidence');
+    ensureDirectory('templates/retrospective');
+    ensureDirectory('templates/specs');
+    ensureDirectory('templates/help');
+    ensureDirectory('workflows');
+    ensureDirectory('.github/workflows');
+    ensureDirectory('agents/cursor');
+    ensureDirectory('agents/claude');
+    ensureDirectory('agents/windsurf');
+    ensureDirectory('scripts');
+    
+    logSuccess('Created directory structure');
 
-        // Create everything at once
-        createProjectStructure();
-        ensureDirectory('.github/workflows');
-        createAgentFolders();
-        createGitHubWorkflows();
-        
-        // Check GitHub CLI availability for labels
-        try {
-            execSync('gh --version', { stdio: 'pipe' });
-            try {
-                execSync('gh auth status', { stdio: 'pipe' });
-                logInfo('GitHub CLI available and authenticated - creating labels automatically');
-                createGitHubLabels();
-            } catch (error) {
-                logWarning('GitHub CLI not authenticated - creating labels configuration file instead');
-                createLabelsConfigFile();
-            }
-        } catch (error) {
-            logInfo('GitHub CLI not available - creating labels configuration file instead');
-            createLabelsConfigFile();
-        }
+    // Create BUGFIX template
+    const bugfixTemplate = `Issue: #<issue>
 
-        logHeader('🎉 Setup Complete!');
-        logSuccess('FRAIM has been successfully set up in your repository!');
-        logInfo('Next steps:');
-        logInfo('1. Commit and push these files to GitHub');
-        logInfo('2. Import GitHub labels from .github/labels.json using the web interface');
-        logInfo('3. Create your first issue with phase labels');
-        logInfo('4. Start coordinating your AI agents!');
-        
-        logInfo('\n📚 Learn more about FRAIM:');
-        logInfo('https://github.com/mathursrus/Ashley-Calendar-AI/tree/master/FRAIM');
-        
-        logInfo('\n🧠 Learn the RIGOR methodology:');
-        logInfo('npx fraim-framework rigor');
+## Tests
+- Could be existing tests that are failing and need to be fixed
+- Could be new tests that need to be added into an existing test suite
+- Could be a new test suite
+`;
+    writeFile('docs/rfcs/BUGFIX-TEMPLATE.md', bugfixTemplate);
+    logSuccess('Created BUGFIX-TEMPLATE.md');
 
+    // Create RFC template
+    const rfcTemplate = `# RFC: <Title>
+
+Issue: #<issue>  
+Owner: <agent>
+
+## Design Details
+- User Experience changes (incl. all modalities currently supported: see codebase to know which ones)
+- API surface (OpenAPI) changes
+- Data model / schema changes
+- Failure modes & timeouts
+- Telemetry & analytics
+
+## Test Matrix
+- Unit: modules & edge cases
+- Integration: API <-> DB <-> external
+- E2E: user flows (happy/sad)`;
+    writeFile('docs/rfcs/RFC-TEMPLATE.md', rfcTemplate);
+    logSuccess('Created RFC-TEMPLATE.md');
+
+    // Create basic rule files
+    createRuleFiles();
+    logSuccess('Created rule files');
+
+    // Create workflow templates
+    createWorkflowTemplates();
+    logSuccess('Created workflow templates');
+
+    // Create basic CODEOWNERS file
+    const codeownersContent = `# This file defines the code owners for the repository
+# Code owners are automatically requested for review when someone opens a PR that modifies code they own
+# See: https://docs.github.com/en/repositories/managing-your-codebase-in-github/about-code-owners
+
+# Default owners for everything in the repo
+*       @${process.env.USER || 'repo-owner'}
+
+# Specific ownership for different parts of the codebase
+/rules/          @${process.env.USER || 'repo-owner'}
+/workflows/      @${process.env.USER || 'repo-owner'}
+/templates/      @${process.env.USER || 'repo-owner'}
+/scripts/        @${process.env.USER || 'repo-owner'}
+/.github/        @${process.env.USER || 'repo-owner'}
+
+# Documentation
+/docs/           @${process.env.USER || 'repo-owner'}
+*.md             @${process.env.USER || 'repo-owner'}`;
+    writeFile('CODEOWNERS', codeownersContent);
+    logSuccess('Created CODEOWNERS file');
+
+    // Create basic PR template
+    const prTemplateContent = `# Pull Request
+
+## Description
+<!-- Provide a brief description of the changes in this PR -->
+
+## Related Issue
+<!-- Link to the issue this PR addresses (use format: Closes #123, Fixes #123) -->
+
+## Type of Change
+<!-- Mark the appropriate option with an [x] -->
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Documentation update
+- [ ] Code refactoring
+- [ ] Performance improvement
+- [ ] Tests
+- [ ] Build/CI changes
+- [ ] Other (please describe):
+
+## Implementation Details
+<!-- Provide a detailed description of the implementation -->
+
+## Testing
+<!-- Describe the testing you've done -->
+- [ ] Added unit tests
+- [ ] Added integration tests
+- [ ] Manually tested
+- [ ] Test exempt (explain why)
+
+## Evidence
+<!-- Provide evidence of testing (screenshots, logs, etc.) -->
+
+## Checklist
+<!-- Mark items with [x] once completed -->
+- [ ] Code follows project style guidelines
+- [ ] Documentation has been updated
+- [ ] All tests are passing
+- [ ] PR has been reviewed by at least one team member
+- [ ] Changes have been tested in a development environment
+
+## Additional Notes
+<!-- Any additional information that might be helpful for reviewers -->`;
+    writeFile('.github/pull_request_template.md', prTemplateContent);
+    logSuccess('Created PR template');
+
+    // Create labels.json
+    const labelsContent = `[
+  {
+    "name": "aiagents",
+    "color": "0e8a16",
+    "description": "Issue prepared for AI agent collaboration"
+  },
+  {
+    "name": "status:ready-for-design",
+    "color": "0075ca",
+    "description": "Issue is ready for design phase"
+  },
+  {
+    "name": "status:in-design",
+    "color": "0075ca",
+    "description": "Issue is currently in design phase"
+  },
+  {
+    "name": "status:ready-for-implementation",
+    "color": "7057ff",
+    "description": "Issue is ready for implementation phase"
+  },
+  {
+    "name": "status:in-implementation",
+    "color": "7057ff",
+    "description": "Issue is currently in implementation phase"
+  },
+  {
+    "name": "status:ready-for-testing",
+    "color": "008672",
+    "description": "Issue is ready for testing phase"
+  },
+  {
+    "name": "status:in-testing",
+    "color": "008672",
+    "description": "Issue is currently in testing phase"
+  },
+  {
+    "name": "status:test-exempt",
+    "color": "c5def5",
+    "description": "Implementation is exempt from test requirements"
+  },
+  {
+    "name": "status:blocked",
+    "color": "d73a4a",
+    "description": "Issue is blocked by another issue or external factor"
+  },
+  {
+    "name": "status:needs-review",
+    "color": "fbca04",
+    "description": "Issue or PR needs review"
+  },
+  {
+    "name": "status:approved",
+    "color": "0e8a16",
+    "description": "Issue or PR has been approved"
+  },
+  {
+    "name": "status:needs-revision",
+    "color": "d93f0b",
+    "description": "Issue or PR needs revision based on feedback"
+  },
+  {
+    "name": "priority:high",
+    "color": "d93f0b",
+    "description": "High priority issue"
+  },
+  {
+    "name": "priority:medium",
+    "color": "fbca04",
+    "description": "Medium priority issue"
+  },
+  {
+    "name": "priority:low",
+    "color": "c5def5",
+    "description": "Low priority issue"
+  }
+]`;
+    writeFile('labels.json', labelsContent);
+    logSuccess('Created labels.json');
+}
+
+// Export the main setup function
+function runSetup() {
+    console.log('🚀 Setting up FRAIM in current repository...\n');
+    
+    try {
+        createProjectStructure();
+        console.log('\n✅ FRAIM setup complete!');
+        console.log('🎯 Your repository is now ready for AI agent management.');
+        console.log('📚 Next steps:');
+        console.log('   1. Customize .ai-agents/rules/architecture.md for your project');
+        console.log('   2. Update .ai-agents/scripts/cleanup-branch.ts with your cleanup logic');
+        console.log('   3. Copy scripts from sample_package.json to your package.json');
+        console.log('   4. Start creating issues with phase labels!');
     } catch (error) {
-        logError(`Setup failed: ${error.message}`);
-        process.exit(1);
+        console.error('❌ Setup failed:', error.message);
+        throw error;
     }
 }
 
-// Run setup if this script is executed directly
+// If this file is run directly, execute setup
 if (require.main === module) {
     runSetup();
 }
 
-module.exports = { runSetup, runWizard, createProjectStructure };
+module.exports = { runSetup };