aiwf 0.3.1 → 0.3.3

package/claude-code/aiwf/ko/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/claude-code/aiwf/ko/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
+  }
+}

package/claude-code/aiwf/ko/ai-tools/github-copilot/template/.github/copilot-instructions.md

@@ -0,0 +1,202 @@
+# GitHub Copilot Instructions for AIWF Project
+
+## Project Context
+
+This project uses the AI Workflow Framework (AIWF) for structured AI-assisted development. Copilot should understand and work with AIWF conventions.
+
+## AIWF Structure
+
+```
+.aiwf/
+├── feature-ledger/      # Feature tracking system
+├── personas/            # AI persona definitions
+├── 03_SPRINTS/         # Sprint organization
+└── 99_TEMPLATES/       # Project templates
+```
+
+## Coding Guidelines
+
+### 1. Feature References
+
+Always reference Feature Ledger IDs in:
+- Function documentation
+- Commit messages  
+- TODO comments
+
+Example:
+```javascript
+/**
+ * Implements user authentication
+ * @feature FL001 - User Authentication System
+ */
+function authenticateUser(credentials) {
+  // Implementation
+}
+```
+
+### 2. Sprint Task Integration
+
+When implementing sprint tasks:
+- Reference task ID in comments
+- Update task status after completion
+- Follow task acceptance criteria
+
+Example:
+```javascript
+// Task: T13_S03 - AI Tool Integration
+// Implementing Claude Code template configuration
+```
+
+### 3. AI Persona Patterns
+
+Use persona-specific patterns:
+
+**Architect Persona**:
+- Focus on system design patterns
+- Emphasize scalability and maintainability
+- Document architectural decisions
+
+**Developer Persona**:
+- Implement clean, efficient code
+- Follow SOLID principles
+- Add comprehensive error handling
+
+**Reviewer Persona**:
+- Check for security vulnerabilities
+- Verify performance implications
+- Ensure code quality standards
+
+### 4. Code Generation Rules
+
+1. **Always check Feature Ledger first**
+   - Don't duplicate existing features
+   - Reference related features in comments
+
+2. **Follow AIWF conventions**
+   - Use standardized file naming
+   - Maintain consistent structure
+   - Update relevant documentation
+
+3. **Include AIWF metadata**
+   ```javascript
+   // AIWF Metadata
+   // Feature: FL001
+   // Sprint: S03
+   // Task: T13_S03
+   // Persona: developer
+   ```
+
+### 5. Snippets and Shortcuts
+
+**Feature Ledger Check**:
+```javascript
+// TODO: Check Feature Ledger for existing implementation
+// aiwf ledger search <feature-name>
+```
+
+**Task Status Update**:
+```javascript
+// Task completed: Update status
+// aiwf task complete <task-id>
+```
+
+**Persona Activation**:
+```javascript
+// Switching to architect persona for design
+// aiwf persona use architect
+```
+
+## Best Practices
+
+1. **Feature-First Development**
+   - Always start by checking the Feature Ledger
+   - Create new ledger entries for new features
+   - Update feature status as you progress
+
+2. **Sprint Alignment**
+   - Keep code aligned with current sprint goals
+   - Reference sprint tasks in implementations
+   - Update task logs regularly
+
+3. **Documentation Standards**
+   - Include AIWF references in all documentation
+   - Link to relevant ADRs
+   - Maintain feature traceability
+
+4. **Testing Integration**
+   - Test features according to ledger specifications
+   - Verify persona-specific requirements
+   - Ensure sprint acceptance criteria are met
+
+## Common Patterns
+
+### Feature Implementation Pattern
+```javascript
+// Feature: FL-[ID] - [Name]
+// Sprint: S[XX]
+// Task: T[XX]_S[XX]
+
+import { FeatureLedger } from '@aiwf/core';
+
+export class NewFeature {
+  constructor() {
+    this.featureId = 'FL-[ID]';
+    this.validateAgainstLedger();
+  }
+  
+  validateAgainstLedger() {
+    const ledger = new FeatureLedger();
+    return ledger.validateFeature(this.featureId);
+  }
+}
+```
+
+### Sprint Task Pattern
+```javascript
+// Sprint Task: T[XX]_S[XX]
+// Status: in_progress
+// Started: [timestamp]
+
+async function implementTask() {
+  // Update task status
+  await aiwf.task.updateStatus('T[XX]_S[XX]', 'in_progress');
+  
+  // Implementation
+  
+  // Complete task
+  await aiwf.task.updateStatus('T[XX]_S[XX]', 'completed');
+}
+```
+
+## Integration Commands
+
+Quick reference for AIWF commands to use in comments:
+
+```bash
+# Feature Ledger
+aiwf ledger list
+aiwf ledger show <id>
+aiwf ledger add
+
+# Sprint Management  
+aiwf sprint current
+aiwf sprint tasks
+aiwf task start <id>
+aiwf task complete <id>
+
+# AI Personas
+aiwf persona list
+aiwf persona use <name>
+```
+
+## Copilot Behavior Customization
+
+1. **Prioritize AIWF patterns** in suggestions
+2. **Include feature references** in generated code
+3. **Follow sprint structure** for task implementations
+4. **Apply persona-specific** coding styles
+5. **Maintain traceability** through comments and documentation
+
+---
+
+*This instruction set is part of AIWF's GitHub Copilot integration. Version: 1.0.0*