aiwf 0.3.0 → 0.3.2

package/.aiwf/ai-tools/cursor/template/.cursorrules

@@ -0,0 +1,362 @@
+# Cursor AI Rules for AIWF Projects
+
+## Project Context
+This project uses the AI Workflow Framework (AIWF) for structured development with AI assistance. Follow these rules to ensure Cursor provides AIWF-aware suggestions.
+
+## Core Principles
+
+### 1. Feature-Driven Development
+- Always check Feature Ledger before implementing new features
+- Reference Feature IDs (FL###) in all related code
+- Maintain feature traceability throughout the codebase
+
+### 2. Sprint-Aligned Coding
+- Reference current sprint tasks in implementations
+- Update task status as work progresses
+- Follow sprint acceptance criteria strictly
+
+### 3. Persona-Based Development
+- Apply appropriate coding style based on active persona
+- Switch personas for different types of work
+- Document persona usage in code comments
+
+## AIWF Integration Rules
+
+### Feature References
+```javascript
+/**
+ * @feature FL001 - User Authentication System
+ * @task TX01_S01 - Implement login functionality
+ * @persona developer
+ */
+```
+
+### Sprint Context
+```javascript
+// Sprint: S01_M02 - Authentication Foundation
+// Task: TX01_S01
+// Status: in_progress
+// Acceptance Criteria:
+// - [ ] User can log in with email/password
+// - [ ] Sessions are managed securely
+// - [ ] Rate limiting is implemented
+```
+
+### Error Handling with Context
+```javascript
+class FeatureError extends Error {
+  constructor(message, context) {
+    super(`[${context.featureId}/${context.taskId}] ${message}`);
+    this.feature = context.featureId;
+    this.task = context.taskId;
+    this.timestamp = new Date().toISOString();
+  }
+}
+```
+
+## Code Generation Guidelines
+
+### 1. Documentation Standards
+Every function/class must include:
+- Feature ID reference
+- Task ID (if applicable)
+- Active persona
+- Brief description
+- Example usage
+
+### 2. Naming Conventions
+- Features: `FL###_FeatureName`
+- Tasks: `TX##_S##_TaskName`
+- Sprints: `S##_M##_SprintName`
+- Files: `feature-id_component-name.ext`
+
+### 3. Import Organization
+```javascript
+// External dependencies
+import express from 'express';
+import jwt from 'jsonwebtoken';
+
+// AIWF core imports
+import { FeatureLedger } from '@aiwf/core';
+import { TaskManager } from '@aiwf/tasks';
+
+// Project imports
+import { AuthService } from './services/auth.service';
+
+// Feature-specific imports
+import { FL001_UserAuth } from './features/FL001_user_auth';
+```
+
+## Persona-Specific Patterns
+
+### Architect Persona
+Focus on:
+- System design patterns
+- Architecture documentation
+- Technology decisions
+- Scalability considerations
+
+```javascript
+// Architect persona active
+interface IAuthenticationStrategy {
+  authenticate(credentials: ICredentials): Promise<IAuthResult>;
+  refresh(token: string): Promise<IAuthResult>;
+  revoke(token: string): Promise<void>;
+}
+
+// Suggest factory patterns, dependency injection, etc.
+```
+
+### Security Persona
+Focus on:
+- Input validation
+- Security best practices
+- Vulnerability prevention
+- Audit logging
+
+```javascript
+// Security persona active
+class SecureAuthService {
+  async authenticate(credentials) {
+    // Input sanitization
+    this.validator.sanitize(credentials);
+    
+    // Rate limiting check
+    await this.rateLimiter.check(credentials.email);
+    
+    // Secure password comparison
+    const isValid = await bcrypt.compare(
+      credentials.password,
+      hashedPassword
+    );
+    
+    // Audit log
+    this.auditLogger.log('auth_attempt', {
+      email: credentials.email,
+      success: isValid,
+      ip: request.ip,
+      timestamp: new Date()
+    });
+  }
+}
+```
+
+### Developer Persona
+Focus on:
+- Clean implementation
+- Error handling
+- Testing
+- Performance
+
+```javascript
+// Developer persona active
+class UserController {
+  constructor(
+    private authService: AuthService,
+    private logger: Logger
+  ) {}
+
+  async login(req: Request, res: Response) {
+    try {
+      const result = await this.authService.authenticate(req.body);
+      
+      res.json({
+        success: true,
+        data: result
+      });
+      
+      this.logger.info('User logged in', { userId: result.user.id });
+    } catch (error) {
+      this.logger.error('Login failed', error);
+      
+      res.status(401).json({
+        success: false,
+        error: 'Authentication failed'
+      });
+    }
+  }
+}
+```
+
+## Testing Guidelines
+
+### Test Structure
+```javascript
+describe('Feature FL001: User Authentication', () => {
+  describe('Task TX01_S01: Login Implementation', () => {
+    describe('Acceptance Criteria', () => {
+      it('should authenticate valid credentials', async () => {
+        // Test implementation
+      });
+      
+      it('should reject invalid credentials', async () => {
+        // Test implementation
+      });
+      
+      it('should enforce rate limiting', async () => {
+        // Test implementation
+      });
+    });
+  });
+});
+```
+
+### Test Documentation
+```javascript
+/**
+ * Test Suite: User Authentication
+ * @feature FL001
+ * @sprint S01_M02
+ * @coverage Unit, Integration
+ */
+```
+
+## Git Integration
+
+### Commit Message Format
+```
+<type>(<feature-id>): <description>
+
+<body>
+
+Task: <task-id>
+Sprint: <sprint-id>
+Persona: <active-persona>
+```
+
+Example:
+```
+feat(FL001): implement JWT authentication
+
+- Add token generation service
+- Implement refresh token logic
+- Add token validation middleware
+
+Task: TX01_S01
+Sprint: S01_M02
+Persona: developer
+```
+
+### Branch Naming
+```
+feature/FL###-short-description
+task/TX##-S##-task-name
+bugfix/FL###-issue-description
+```
+
+## Code Review Checklist
+
+When reviewing code, ensure:
+- [ ] Feature ID is referenced
+- [ ] Task requirements are met
+- [ ] Appropriate persona patterns are used
+- [ ] AIWF conventions are followed
+- [ ] Documentation is complete
+- [ ] Tests cover acceptance criteria
+- [ ] Security considerations are addressed
+- [ ] Performance impact is acceptable
+
+## Quick Commands
+
+Include these in comments for quick actions:
+```javascript
+// @aiwf-check-feature - Verify feature exists in ledger
+// @aiwf-update-task - Update task progress
+// @aiwf-switch-persona - Change active persona
+// @aiwf-link-sprint - Link to current sprint
+```
+
+## AI Behavior Modifiers
+
+### Context-Aware Suggestions
+- Prioritize AIWF patterns
+- Include feature/task references
+- Apply persona-specific styles
+- Maintain project consistency
+
+### Auto-Complete Preferences
+1. AIWF-specific imports first
+2. Feature-based function names
+3. Task-aligned variable names
+4. Persona-appropriate patterns
+
+## Integration Points
+
+### Feature Ledger
+```javascript
+// Always validate against Feature Ledger
+const ledger = new FeatureLedger();
+const feature = await ledger.getFeature('FL001');
+
+if (feature.status !== 'active') {
+  throw new FeatureError('Feature not active', {
+    featureId: 'FL001',
+    status: feature.status
+  });
+}
+```
+
+### Task Management
+```javascript
+// Update task progress
+const taskManager = new TaskManager();
+await taskManager.updateProgress('TX01_S01', {
+  percentage: 75,
+  notes: 'Authentication implemented, testing remaining'
+});
+```
+
+### Sprint Tracking
+```javascript
+// Get current sprint context
+const sprint = await aiwf.getCurrentSprint();
+console.log(`Working on: ${sprint.name} (${sprint.id})`);
+```
+
+## Performance Considerations
+
+### Feature-Specific Optimization
+```javascript
+// Include performance metrics per feature
+/**
+ * @feature FL001
+ * @performance Target: <100ms response time
+ * @performance Current: 85ms average
+ */
+```
+
+### Caching Strategy
+```javascript
+// Feature-aware caching
+const cacheKey = `feature:${featureId}:${userId}`;
+const cached = await cache.get(cacheKey);
+```
+
+## Security Patterns
+
+### Feature-Level Security
+```javascript
+// Apply security based on feature requirements
+@FeatureSecurity('FL001', ['auth:read', 'auth:write'])
+class AuthenticationEndpoint {
+  // Implementation
+}
+```
+
+### Audit Logging
+```javascript
+// Include feature context in audit logs
+auditLogger.log({
+  action: 'user.login',
+  feature: 'FL001',
+  task: 'TX01_S01',
+  user: userId,
+  timestamp: new Date(),
+  result: 'success'
+});
+```
+
+---
+
+*Cursor AI Rules for AIWF Integration v1.0.0*
+*These rules ensure Cursor provides AIWF-aware code suggestions and maintains project consistency*

package/.aiwf/ai-tools/github-copilot/README.md

@@ -0,0 +1,195 @@
+# GitHub Copilot AIWF Integration Template
+
+## Overview
+
+This template configures GitHub Copilot to work seamlessly with the AI Workflow Framework (AIWF), ensuring code suggestions align with AIWF patterns and conventions.
+
+## Features
+
+- **Feature Ledger Awareness**: Copilot suggestions reference existing features
+- **Sprint Task Integration**: Code generation aligned with current sprint tasks
+- **AI Persona Patterns**: Different coding styles based on active persona
+- **AIWF Snippets**: Quick access to common AIWF commands and patterns
+- **Automatic Documentation**: Feature and task references in generated code
+
+## Installation
+
+```bash
+# Install GitHub Copilot template
+aiwf ai-tool install github-copilot
+
+# Or manually copy template files
+cp -r .aiwf/ai-tools/github-copilot/template/.github .
+```
+
+## Configuration
+
+The template includes:
+
+1. **copilot-instructions.md**: Main configuration for Copilot behavior
+   - AIWF structure documentation
+   - Coding guidelines
+   - Pattern examples
+   - Integration commands
+
+## Usage
+
+### 1. Feature-Aware Suggestions
+
+Copilot will automatically:
+- Check Feature Ledger before suggesting new implementations
+- Include feature IDs in documentation
+- Reference related features in comments
+
+```javascript
+// Copilot will suggest:
+/**
+ * Implements user profile management
+ * @feature FL002 - User Profile System
+ * @related FL001 - User Authentication System
+ */
+```
+
+### 2. Sprint Task Context
+
+When working on sprint tasks:
+
+```javascript
+// Type: "Implement task T13_S03"
+// Copilot will generate task-aware code:
+
+// Task: T13_S03 - AI Tool Integration
+// Status: in_progress
+// Acceptance Criteria: Create tool templates
+
+async function createToolTemplate(toolName) {
+  // Implementation following task requirements
+}
+```
+
+### 3. Persona-Based Patterns
+
+Activate different coding styles:
+
+```javascript
+// Comment: "Using architect persona"
+// Copilot suggests design patterns and architecture
+
+// Comment: "Using developer persona"  
+// Copilot suggests implementation details
+
+// Comment: "Using reviewer persona"
+// Copilot suggests validation and security checks
+```
+
+### 4. AIWF Command Snippets
+
+Type AIWF commands in comments for quick suggestions:
+
+```javascript
+// aiwf ledger -> Suggests feature ledger operations
+// aiwf sprint -> Suggests sprint management code
+// aiwf task -> Suggests task update patterns
+```
+
+## Best Practices
+
+1. **Start with Comments**: Begin files with AIWF metadata comments
+2. **Use Feature Tags**: Include @feature tags in function documentation
+3. **Reference Tasks**: Add task IDs when implementing sprint work
+4. **Update Status**: Include task status updates in your workflow
+5. **Maintain Traceability**: Keep clear links between code and AIWF elements
+
+## Customization
+
+### Project-Specific Instructions
+
+Add to `.github/copilot-instructions.md`:
+
+```markdown
+## Project-Specific Rules
+
+- Use TypeScript for all new files
+- Follow REST API conventions
+- Implement comprehensive logging
+```
+
+### Custom Snippets
+
+Define project-specific patterns:
+
+```markdown
+### Custom Patterns
+
+**Service Implementation**:
+```javascript
+// Pattern: AIWF Service
+// Feature: FL-[ID]
+export class ${ServiceName}Service {
+  constructor(private ledger: FeatureLedger) {}
+}
+```
+
+## Tips for Effective Use
+
+1. **Comment-Driven Development**
+   - Start with descriptive comments
+   - Include AIWF references
+   - Let Copilot expand on your intent
+
+2. **Feature Checking**
+   - Always verify against Feature Ledger
+   - Avoid duplicating existing features
+   - Link related implementations
+
+3. **Task Alignment**
+   - Keep implementations focused on current task
+   - Reference acceptance criteria
+   - Update task status regularly
+
+4. **Persona Switching**
+   - Use appropriate personas for different tasks
+   - Architect for design decisions
+   - Developer for implementation
+   - Reviewer for quality checks
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Copilot not recognizing AIWF patterns**
+   - Ensure copilot-instructions.md is in .github/
+   - Restart your IDE
+   - Check file permissions
+
+2. **Incorrect feature references**
+   - Update Feature Ledger cache: `aiwf ledger sync`
+   - Verify feature IDs in comments
+
+3. **Missing sprint context**
+   - Run `aiwf sprint current` to verify active sprint
+   - Include sprint ID in file headers
+
+## Integration with Other Tools
+
+- **VS Code**: Works automatically with Copilot extension
+- **JetBrains IDEs**: Configure in Copilot settings
+- **Neovim**: Use copilot.vim with AIWF paths
+
+## Updates
+
+Keep your template updated:
+
+```bash
+aiwf ai-tool update github-copilot
+```
+
+## Resources
+
+- [GitHub Copilot Docs](https://docs.github.com/copilot)
+- [AIWF Documentation](https://aiwf.dev/docs)
+- [Integration Examples](https://github.com/aiwf/examples)
+
+---
+
+*GitHub Copilot Integration Template v1.0.0*

package/.aiwf/ai-tools/github-copilot/config.json

@@ -0,0 +1,24 @@
+{
+  "name": "github-copilot",
+  "version": "1.0.0",
+  "description": "GitHub Copilot integration template for AIWF",
+  "compatible_aiwf_version": ">=0.1.0",
+  "features": {
+    "feature_ledger": true,
+    "ai_persona": true,
+    "context_compression": false,
+    "offline_cache": true
+  },
+  "setup_commands": [],
+  "files_to_copy": [
+    {
+      "source": "template/.github",
+      "destination": ".github"
+    }
+  ],
+  "settings": {
+    "auto_feature_reference": true,
+    "inline_documentation": true,
+    "aiwf_snippets": true
+  }
+}