fraim-framework 1.0.0

package/docs/guides/getting-started.md

@@ -0,0 +1,175 @@
+# 🚀 Getting Started with FRAIM
+
+**Framework for Rigor-based AI Management**
+
+Welcome to FRAIM! This guide will transform you from a developer into an AI manager in under 30 seconds.
+
+## 🚀 Quick Start (30 seconds)
+
+### 1. Navigate to Your Repository
+```bash
+cd your-project
+```
+
+### 2. Setup FRAIM
+```bash
+npx @fraim/framework init
+```
+
+### 3. Create Your First AI-Managed Issue
+```bash
+gh issue create --title "Add user authentication" --label "phase:design,ai-agent:claude"
+```
+
+### 4. Watch the Magic Happen! 🎉
+
+GitHub automatically:
+- 🔄 Creates branch: `feature/1-add-user-authentication`
+- 🔄 Creates draft PR
+- 🔄 Sets status: `status:wip`
+- 🤖 Claude starts working on RFC
+
+## 🤖 AI Agent Coordination
+
+FRAIM coordinates three types of AI agents, each with specific roles:
+
+### Cursor (IDE Development)
+- **Role**: Implementation and testing
+- **Strengths**: Code generation, testing, IDE integration
+- **Best For**: `phase:impl` tasks
+
+### Claude (Conversational AI)
+- **Role**: Design and RFC creation
+- **Strengths**: Natural language, documentation, architecture
+- **Best For**: `phase:design` tasks
+
+### Windsurf (Code Understanding)
+- **Role**: Performance and integration
+- **Strengths**: Code analysis, optimization, system integration
+- **Best For**: `phase:tests` and optimization tasks
+
+## 📋 Workflow Phases
+
+### Phase 1: Design (`phase:design`)
+1. **Create Issue**: Describe the feature or bug
+2. **Add Labels**: `phase:design` + `ai-agent:claude`
+3. **AI Action**: Claude creates RFC and architecture docs
+4. **Review**: Stakeholders review and approve design
+5. **Transition**: Change to `phase:impl` + `ai-agent:cursor`
+
+### Phase 2: Implementation (`phase:impl`)
+1. **AI Action**: Cursor implements the feature
+2. **Testing**: Comprehensive test coverage
+3. **Documentation**: Code comments and updates
+4. **Review**: Code review and validation
+5. **Transition**: Change to `phase:tests` + `ai-agent:windsurf`
+
+### Phase 3: Testing (`phase:tests`)
+1. **AI Action**: Windsurf validates implementation
+2. **Performance**: Performance testing and optimization
+3. **Integration**: System integration testing
+4. **Validation**: Final validation against requirements
+5. **Completion**: Mark as `status:complete`
+
+## 🏷️ Label System
+
+### Phase Labels
+- `phase:design` - Design and RFC creation
+- `phase:impl` - Implementation and development
+- `phase:tests` - Testing and validation
+
+### Status Labels
+- `status:wip` - Work in progress
+- `status:needs-review` - Ready for review
+- `status:complete` - Work completed
+
+### Agent Labels
+- `ai-agent:cursor` - Assigned to Cursor
+- `ai-agent:claude` - Assigned to Claude
+- `ai-agent:windsurf` - Assigned to Windsurf
+
+### Priority Labels (Optional)
+- `priority:critical` - Critical priority
+- `priority:high` - High priority
+- `priority:medium` - Medium priority
+- `priority:low` - Low priority
+
+## 🔧 Advanced Setup
+
+### Interactive Wizard
+```bash
+npx @fraim/framework wizard
+```
+
+The wizard will ask you:
+- Which AI agents to enable
+- Whether to enable deployment workflows
+- Whether to run in dry-run mode first
+
+### Custom Configuration
+```bash
+npx @fraim/framework setup owner/repository --config custom-config.json
+```
+
+### Partial Setup
+```bash
+# Only create labels
+npx @fraim/framework setup owner/repository --labels-only
+
+# Only setup workflows
+npx @fraim/framework setup owner/repository --workflows-only
+```
+
+## 📚 Next Steps
+
+### 1. Explore Documentation
+- [🧠 RIGOR Methodology](../../README.md#-the-rigor-methodology)
+- [🤖 AI Agent Rules](../../agents/)
+- [🏗️ Framework Overview](../../README.md#-framework-structure)
+
+### 2. Try Different Workflows
+- Create issues with different phase/agent combinations
+- Experiment with the label system
+- Practice phase transitions
+
+### 3. Customize for Your Team
+- Adjust agent assignments based on team strengths
+- Customize workflows for your development process
+- Add team-specific labels and processes
+
+### 4. Scale Up
+- Apply FRAIM to multiple repositories
+- Train your team on the methodology
+- Integrate with existing CI/CD pipelines
+
+## 🎯 Success Metrics
+
+### Individual Level
+- **Setup Time**: < 30 seconds to get started
+- **Issue Resolution**: Faster development cycles
+- **Code Quality**: Higher quality through AI coordination
+- **Learning**: Better understanding of AI capabilities
+
+### Team Level
+- **Coordination**: Seamless AI agent collaboration
+- **Consistency**: Standardized development processes
+- **Visibility**: Clear progress tracking and status
+- **Efficiency**: Reduced manual coordination overhead
+
+### Organization Level
+- **Scalability**: Framework grows with your organization
+- **Compliance**: Audit trails and process documentation
+- **Innovation**: Faster adoption of new AI capabilities
+- **Competitive Advantage**: Professional AI management capabilities
+
+## 🚀 Ready to Become an AI Manager?
+
+```bash
+npx @fraim/framework init
+```
+
+**FRAIM: Where humans become AI managers through rigorous methodology**
+
+---
+
+*Need help? Check the [main README](../../README.md) or [contact the team](https://github.com/mathursrus/Ashley-Calendar-AI/issues).*

package/getting-started.md

@@ -0,0 +1,143 @@
+# 🚀 Getting Started with FRAIM
+
+**Framework for Rigor-based AI Management**
+
+Welcome to FRAIM! This guide will transform you from a developer into an AI manager in under 30 seconds.
+
+## 🎯 What is FRAIM?
+
+FRAIM is a framework that empowers human developers to coordinate AI agents using the  **RIGOR methodology**: Reviews • Isolation • GitOps • Observability • Retrospectives.
+
+Instead of manually managing AI tools, FRAIM gives you the structure and automation to orchestrate AI agents like a professional team manager.
+
+## 🚀 Quick Start (30 seconds)
+
+### 1. Navigate to Your Repository
+```bash
+cd your-project
+```
+
+### 2. Setup FRAIM
+```bash
+npx @fraim/setup init
+```
+
+### 3. Create Your Issue List in your Git Repo
+```bash
+gh issue create --title "Add user authentication" 
+```
+
+### 4. Let your AI Agents do the Magic! 🎉
+Cursor: @design 1
+Windsurf: /start-design 1
+Claude: @design 1
+
+AI Agent automatically:
+- 🔄 Labels the Git issue with phase:design
+
+GitHub automatically:
+- 🔄 Creates branch: `feature/1-add-user-authentication`
+- 🔄 Creates draft PR
+- 🔄 Sets status: `status:wip`
+
+AI Agent automatically:
+- 🔄 Checks out the new branch
+- 🔄 Researches codebase, architecture, issue and writes a PRD/RFC
+- 🔄 Commits, Syncs the branch and Labels the Git issue with status:needs-review for you to PR
+
+You:
+- Watch the magic happen
+- Review the PR like you normally would, and add comments
+- Let the AI Agent know if you want it to iterate, or proceed to @implement (Claude, Cursor), or /start-impl (Windsurf)
+
+
+## 🧠 Understanding the RIGOR Methodology
+
+FRAIM is built on five core principles that ensure reliable, scalable, continuously improving AI coordination:
+
+- **R**eviews: Structured feedback and approval processes
+- **I**solation: Agents don't interfere with each others' work *unless* you explicitly ask them to
+- **G**itOps: Git as the single source of truth and the glue between you and your agents
+- **O**bservability: Complete visibility into AI activities
+- **R**etrospectives: Continuous learning from mistakes and positive experiences
+
+
+## 📋 Workflow Phases
+
+### Phase 1: Design (`phase:design`)
+1. **You**: Tell the agent to move into this phase and give it the issue number
+2. **AI Action**: Labels issue `phase:design`, moves to branch, creates RFC/UX/test-plan, commits and sends out PR, labels issue `status:needs-review`
+3. **Review**: Stakeholders review and approve design
+4. **Issue, PR State**: Git automatically changes status between wip, complete
+
+### Phase 2: Implementation (`phase:impl`)
+1. **You**: Tell the agent to move into this phase
+2. **AI Action**: Labels issue `phase:impl`, moves to branch, consults issue/code/rfcs, implements code and tests, runs tests, commits and sends out PR
+3. **Review**: Stakeholders review and approve implementation
+4. **Issue, PR State**: Git automatically changes status between wip, complete
+
+### Phase 3: Resolve 
+1. **You**: Tell the agent to move into this phase once totally satisfied with the implementation and tests
+2. **AI Action**: Pulls from master, deals with merge issues (with your help if needed), confirms everything still works, pushes to master, deletes remote and local branches, cleans up local copy of the branch
+3. **Git**: Runs CI and prevents merging if failed
+
+## 🏷️ Label System
+
+### Phase Labels
+- `phase:design` - Design and RFC creation
+- `phase:impl` - Implementation and development
+- `phase:tests` - Testing and validation (if needed, I ask AI Agents to write tests as part of implementation)
+
+### Status Labels
+- `status:wip` - Work in progress
+- `status:needs-review` - Ready for review
+- `status:complete` - Work completed
+
+### Agent Labels (for future, I don't use these yet)
+- `ai-agent:cursor` - Assigned to Cursor
+- `ai-agent:claude` - Assigned to Claude
+- `ai-agent:windsurf` - Assigned to Windsurf
+
+## 🔧 Advanced Setup
+
+### Interactive Wizard
+```bash
+npx @fraim/setup wizard
+```
+
+The wizard will ask you:
+- Which AI agents to enable
+- Whether to enable deployment workflows
+- Whether to run in dry-run mode first
+
+### Custom Configuration
+```bash
+npx @fraim/setup setup owner/repository --config custom-config.json
+```
+
+### Partial Setup
+```bash
+# Only create labels
+npx @fraim/setup setup owner/repository --labels-only
+
+# Only setup workflows
+npx @fraim/setup setup owner/repository --workflows-only
+```
+
+## 🎯 Success Metrics - I hope these happen for you
+
+- **Setup Time**: < 30 seconds to get started
+- **Issue Resolution**: Faster development cycles
+- **Code Quality**: Higher quality through AI coordination
+- **Learning**: Better understanding of AI capabilities
+
+## 🚀 Ready to Become an AI Manager?
+
+```bash
+npx @fraim/setup init
+```
+
+**FRAIM: Where humans become AI managers through rigorous methodology**
+
+---
+

package/index.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+/**
+ * FRAIM Framework - Main Entry Point
+ * Framework for Rigor-based AI Management
+ * Where humans become AI managers through rigorous methodology
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// Import the CLI
+const { main } = require('./bin/fraim.js');
+
+// Export the main function for programmatic use
+module.exports = { main };
+
+// If this file is run directly, execute the CLI
+if (require.main === module) {
+    main();
+}
+
+// Framework information
+module.exports.FRAIM_INFO = {
+    name: 'FRAIM',
+    fullName: 'Framework for Rigor-based AI Management',
+    version: '1.0.0',
+    description: 'Where humans become AI managers through rigorous methodology',
+    methodology: 'RIGOR',
+    principles: [
+        'Reviews: Structured feedback and approval processes',
+        'Isolation: Agents don\'t interfere with each others\' work *unless* you explicitly ask them to',
+        'GitOps: Git as the single source of truth and the glue between you and your agents',
+        'Observability: Complete visibility into AI activities',
+        'Retrospectives: Continuous learning from mistakes and positive experiences'
+    ],
+    supportedAgents: ['cursor', 'claude', 'windsurf'],
+    repository: 'https://github.com/mathursrus/Ashley-Calendar-AI/tree/master/FRAIM',
+    note: 'All rules and workflows have been tested and proven in real project environments'
+};

package/install.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+
+# FRAIM One-Line Installer
+# Framework for Rigor-based AI Management
+# Where humans become AI managers through rigorous methodology
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Banner
+echo -e "${BLUE}"
+cat << 'EOF'
+╔══════════════════════════════════════════════════════════════╗
+║  🚀 FRAIM                                                  ║
+║  Framework for Rigor-based AI Management                    ║
+║  Where humans become AI managers                            ║
+╚══════════════════════════════════════════════════════════════╝
+EOF
+echo -e "${NC}"
+
+echo -e "${GREEN}🤖 Welcome to FRAIM!${NC}"
+echo -e "${GREEN}Where humans become AI managers through rigorous methodology${NC}\n"
+
+# Check if we're in a git repository
+if [ ! -d ".git" ]; then
+    echo -e "${RED}❌ Error: Not in a git repository${NC}"
+    echo "Please run this script from within a git repository."
+    exit 1
+fi
+
+# Check if FRAIM is already installed
+if [ -d "FRAIM" ]; then
+    echo -e "${YELLOW}⚠️  FRAIM appears to already be installed in this repository${NC}"
+    echo "If you want to reinstall, please remove the existing FRAIM folder first."
+    exit 1
+fi
+
+echo -e "${BLUE}📥 Installing FRAIM framework...${NC}"
+
+# Download FRAIM from GitHub
+echo "Downloading FRAIM framework..."
+curl -sSL https://raw.githubusercontent.com/mathursrus/Ashley-Calendar-AI/master/FRAIM/install.sh | bash -s -- --repo $(git remote get-url origin | sed 's/.*github.com[:/]\([^/]*\/[^/]*\).*/\1/' | sed 's/\.git$//')
+
+echo -e "\n${GREEN}✅ FRAIM installation complete!${NC}"
+echo -e "\n${BLUE}🚀 Next steps:${NC}"
+echo "1. Review the FRAIM folder that was created"
+echo "2. Run: npx @fraim/framework init"
+echo "3. Start managing your AI agents with RIGOR methodology!"
+echo -e "\n${BLUE}📚 Learn more:${NC}"
+echo "Documentation: https://github.com/mathursrus/Ashley-Calendar-AI/tree/master/FRAIM"
+echo -e "\n${GREEN}🎯 Ready to become an AI manager?${NC}"
+echo "The FRAIM framework is now installed and ready to use!"

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "fraim-framework",
+  "version": "1.0.0",
+  "description": "FRAIM: Framework for Rigor-based AI Management - Where humans become AI managers through rigorous methodology",
+  "main": "index.js",
+  "bin": {
+    "fraim": "./bin/fraim.js",
+    "fraim-setup": "./bin/fraim.js"
+  },
+  "scripts": {
+    "setup": "node setup.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "postinstall": "echo '🚀 FRAIM installed! Run: npx fraim-framework --help'"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mathursrus/Ashley-Calendar-AI.git",
+    "directory": "FRAIM"
+  },
+  "keywords": [
+    "fraim",
+    "ai-management",
+    "ai-coordination",
+    "ai-agents",
+    "multi-agent",
+    "github",
+    "workflow",
+    "automation",
+    "gitops",
+    "cursor",
+    "claude",
+    "windsurf",
+    "rigor",
+    "enterprise",
+    "framework",
+    "ai-managers"
+  ],
+  "author": "Sid Mathur <sid.mathur@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mathursrus/Ashley-Calendar-AI/issues"
+  },
+  "homepage": "https://github.com/mathursrus/Ashley-Calendar-AI/tree/master/FRAIM#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/__init__.py

@@ -0,0 +1,10 @@
+"""
+FRAIM Python Package
+Framework for Rigor-based AI Management
+Where humans become AI managers through rigorous methodology
+"""
+
+from .cli import main
+
+__version__ = "1.0.0"
+__all__ = ["main"]

package/scripts/cli.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""
+FRAIM Python CLI
+Framework for Rigor-based AI Management
+Where humans become AI managers through rigorous methodology
+"""
+
+import sys
+import argparse
+
+def show_banner():
+    """Display FRAIM banner"""
+    banner = """
+╔══════════════════════════════════════════════════════════════╗
+║  🚀 FRAIM                                                  ║
+║  Framework for Rigor-based AI Management                    ║
+║  Where humans become AI managers                            ║
+╚══════════════════════════════════════════════════════════════╝
+"""
+    print(banner)
+
+def show_help():
+    """Display help information"""
+    show_banner()
+    print("🤖 Welcome to FRAIM!")
+    print("Where humans become AI managers through rigorous methodology\n")
+
+    print("🚀 Quick commands:")
+    print("  pip install fraim-framework")
+    print("  fraim init     # Setup current repository")
+    print("  fraim rigor    # Learn RIGOR methodology")
+    print("  fraim --help   # Full documentation\n")
+
+    print("🧠 The RIGOR Methodology:")
+    print("  R - Reviews: Structured feedback and approval processes")
+    print("  I - Idempotency: Safe, repeatable operations")
+    print("  G - GitOps: Git as the single source of truth")
+    print("  O - Observability: Complete visibility into AI activities")
+    print("  R - Rollback: Safe recovery from any state\n")
+
+    print("📚 Documentation: https://github.com/mathursrus/Ashley-Calendar-AI/tree/master/FRAIM")
+    print("🎯 Ready to become an AI manager? Run: fraim init")
+
+def show_rigor():
+    """Display RIGOR methodology information"""
+    show_banner()
+    print("🧠 The RIGOR Methodology for AI Management\n")
+
+    print("R - Reviews:")
+    print("  • Structured feedback and approval processes")
+    print("  • Code review workflows with AI agents")
+    print("  • Automated quality gates and checks")
+    print("  • Human oversight of AI decisions\n")
+
+    print("I - Idempotency:")
+    print("  • Safe, repeatable operations")
+    print("  • No side effects from multiple runs")
+    print("  • Consistent results every time")
+    print("  • Rollback-friendly changes\n")
+
+    print("G - GitOps:")
+    print("  • Git as the single source of truth")
+    print("  • Declarative infrastructure and workflows")
+    print("  • Automated deployments from Git changes")
+    print("  • Version-controlled AI agent configurations\n")
+
+    print("O - Observability:")
+    print("  • Complete visibility into AI activities")
+    print("  • Metrics, logs, and tracing")
+    print("  • Performance monitoring and alerting")
+    print("  • Audit trails for compliance\n")
+
+    print("R - Rollback:")
+    print("  • Safe recovery from any state")
+    print("  • Automated rollback mechanisms")
+    print("  • Point-in-time recovery")
+    print("  • Zero-downtime deployments\n")
+
+    print("🎯 This methodology transforms you from a developer into an AI manager!")
+
+def main():
+    """Main CLI entry point"""
+    parser = argparse.ArgumentParser(
+        description="FRAIM: Framework for Rigor-based AI Management",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  fraim init     # Setup FRAIM in current repository
+  fraim rigor    # Learn about RIGOR methodology
+  fraim --help   # Show this help message
+        """
+    )
+    
+    parser.add_argument(
+        "command",
+        nargs="?",
+        choices=["init", "rigor", "setup", "wizard"],
+        help="Command to execute"
+    )
+    
+    parser.add_argument(
+        "--version",
+        action="version",
+        version="FRAIM 1.0.0"
+    )
+    
+    args = parser.parse_args()
+    
+    if not args.command or args.command == "help":
+        show_help()
+        return
+    
+    if args.command == "rigor":
+        show_rigor()
+        return
+    
+    if args.command in ["init", "setup"]:
+        show_banner()
+        print("🚀 Setting up FRAIM in current repository...\n")
+        print("📋 This will:")
+        print("  • Create GitHub labels for AI management")
+        print("  • Set up automated workflows")
+        print("  • Configure AI agent rules")
+        print("  • Initialize documentation\n")
+        print("💡 Run: fraim init  # For full setup")
+        print("🔧 Or run: fraim wizard  # For interactive setup")
+        return
+    
+    if args.command == "wizard":
+        show_banner()
+        print("🔮 FRAIM Interactive Setup Wizard\n")
+        print("This wizard will guide you through:")
+        print("  1. Repository configuration")
+        print("  2. AI agent setup")
+        print("  3. Workflow customization")
+        print("  4. Team member onboarding\n")
+        print("💡 Run: fraim wizard  # To start the wizard")
+        return
+
+if __name__ == "__main__":
+    main()