aiwf 0.1.0 → 0.3.1

package/claude-code/aiwf/en/.aiwf/98_PROMPTS/github_integration.md

@@ -0,0 +1,130 @@
+# GitHub Integration with AIWF Framework
+
+This document provides guidance on integrating GitHub issues and pull requests with the AIWF task management system.
+
+## Overview
+
+The AIWF framework now supports seamless integration with GitHub issues and pull requests, enabling better tracking and collaboration through the `gh` CLI tool.
+
+## Key Features
+
+### 1. Task-Issue Linking
+
+- Each task can be linked to a GitHub issue via the `github_issue` field in frontmatter
+- Automatic status synchronization between tasks and issues
+- Bidirectional updates ensure consistency
+
+### 2. Automated Workflows
+
+- Create GitHub issues from tasks: `/project:aiwf:issue_create {task_id}`
+- Generate pull requests with issue linking: `/project:aiwf:pr_create {task_id}`
+- Commit messages automatically include issue references
+
+### 3. Status Management
+
+- Task status changes trigger GitHub issue updates
+- Issues are labeled based on task status (in-progress, completed, etc.)
+- Comments are added to issues for transparency
+
+## Commands Reference
+
+### Issue Creation
+
+```bash
+/project:aiwf:issue_create {task_id}
+```
+
+Creates a GitHub issue from a task file with:
+
+- Title including task ID
+- Description from task content
+- Appropriate labels
+- Automatic assignment
+
+### Pull Request Creation
+
+```bash
+/project:aiwf:pr_create {task_id}
+```
+
+Creates a pull request that:
+
+- Links to the associated issue
+- Includes commit history
+- Auto-closes issue on merge
+- Assigns reviewers
+
+### Manual GitHub Commands
+
+Update issue status:
+
+```bash
+gh issue comment {issue_number} --body "Status update message"
+gh issue edit {issue_number} --add-label "label-name"
+```
+
+Create issue manually:
+
+```bash
+gh issue create \
+  --title "Task: Description" \
+  --body "Detailed description" \
+  --label "task,sprint-01"
+```
+
+## Best Practices
+
+### 1. Issue Creation Timing
+
+- Create issues when starting a sprint
+- Link issues immediately after creation
+- Update frontmatter with issue number
+
+### 2. Commit Messages
+
+- Use `fixes #123` for bug fixes
+- Use `relates to #123` for partial work
+- Include task ID in commit message
+
+### 3. Pull Request Workflow
+
+- Create PR after task completion
+- Ensure all tests pass
+- Link to original issue
+- Request appropriate reviewers
+
+## Integration Points
+
+### Task Files
+
+Add to frontmatter:
+
+```yaml
+github_issue: #123
+```
+
+### Sprint Planning
+
+- Create issues for all tasks at sprint start
+- Use labels to group by sprint
+- Track progress via GitHub Projects
+
+### YOLO Mode
+
+- Automatically creates issues if enabled
+- Creates PRs after successful commits
+- Maintains full automation flow
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Missing gh CLI**: Install GitHub CLI first
+2. **Authentication**: Run `gh auth login`
+3. **Permissions**: Ensure repo access rights
+
+### Error Handling
+
+- Check task file for valid issue number
+- Verify GitHub API limits
+- Ensure branch protection rules allow automation

package/claude-code/aiwf/en/.aiwf/98_PROMPTS/useful-prompts.md

@@ -0,0 +1,31 @@
+# 유용한 프롬프트
+
+## 프로젝트 분석
+
+[Ask, sonnet4 그리고 o3 연속으로..]
+
+```
+이 프로젝트 구조를 자세히 파악해줘
+코드 컨벤션 스타일 디자인 규칙을 모두 분석해서 자세히 설명해줘
+```
+
+## 커서 Rule 생성
+
+[Agent, sonnet4]
+
+```
+/Generate Cursor Rules
+위의 분석한 내용을 기반으로 rule 만들어줘
+내용은 영어로 작성해.
+대표적인 프롬프트 엔지니어링 기법을 적용해서 최적화해줘.
+반드시 지켜야할 규칙, 반드시 하지말아야할 것들을 특히 강조해서 적어줘.
+```
+
+[Agent, sonnet4]
+
+```
+/Generate Cursor Rules
+지금까지 너는 실수를 했지이 실수의 원인을 자세히 분석하고, 로 작성해.
+대표적인 프롬프트 엔지니어링 기법을 적용해서 최적화해줘.
+반드시 지켜야할 규칙, 반드시 하지말아야할 것들을 특히 강조해서 적어줘.
+```

package/claude-code/aiwf/en/.aiwf/98_PROMPTS/vibe-front-prompts.md

@@ -0,0 +1,89 @@
+# VIBE 코딩 프론트엔드 프롬프트
+
+https://github.com/roboco-io/handson-vibecoding-demo
+
+## STEP1
+
+지금부터 간단한 앱을 만드는 것을 데모로 보여주려 고해. TODO앱을 웹 앱으로 만들려고해. 우선 docs 폴더 아래에 요건 정의를 문서화 해 줘. 요건정의를 위해서 필요한 질문들을 포함해줘.
+
+- requirements.md 리뷰
+- .windsurfrules 생성
+
+@requirements.md 참고해서 설계문서 작성을 진행해줘
+
+- design.dm 리뷰
+  mermaid -> svg 로 설계문서를 작성
+
+@design.md 에서 아키텍처 다이어그램은 SVG를 사용해서 정확하고 상서하게 그려줘.
+
+리퀘스트 처리 부분에 대해서 시퀀스 다이어 그램을 추가해줘. 시퀀스 다이어그램은 mermaid 로 그려줘
+
+UI 설계에서 모바일뷰와 데스크톱 뷰의 와이어프레임도 SVG로 생성해줘
+
+카드뷰 보다는 리스트로 표시해줘
+
+@design.md 문서에 기반해서 앞으로 수행해 야 할 작업들을 순서대로 체크리스트로 만들어 줘. UI/UX를 제외한 코어 비즈니스 로직은 TDD 에 기반해서 작업해야해. 작업이 확인 가능한 단 위별로 커밋 포인트도 체크리스트에 표시해줘.
+
+## STEP2
+
+나는 좀 더 간편한 UI Kit을 사용해서 프론트를 구현하고 싶어. 어떤 UI Kit이 좋을까?
+
+Mantine 을 사용해서 UI를 구현하도록 요건과 설계문서를 업데이트 해줘
+
+@implementation-checklist.md 의 이름을 checklist.md 로 바꿔줘
+
+업데이트된 @design.md 내용에 맞춰서 @checklist.md 를 업데이트 해줘
+
+Windsurf rules 수정 :
+
+- 커뮤니케이션은 한국어로 해줘
+- 프론트엔드 UI 구현시에는 실행 코드를 먼저 작성한다. 코어 비즈니스 로직 구현 시에만 TDD로 진행 할 것.
+- 백엔드는 TDD로 구현할 것
+- 커밋 전에 docs/checklist.md에 진행상황을 업데이트 한다.
+- 설계 변경시에는 requirements.md 와 design.md 를 수정한다.
+
+업데이트 된 계획들을 커밋해줘
+
+이제 체크리스트 항목을 시작해줘
+
+프로젝트 설명을 위한 README 를 root 폴더에 만들어줘
+
+[자동화]
+Rules 파일은 자동화에 큰 역할을 담당한다
+Awesome cursor rules 를 참고해서 업데이트 해야한다
+
+@web https://github.com/PatrickJS/awesome-cursorrules/blob/main/rules/nextjs15-react19-vercelai-tailwind-cursorrules-prompt-file/.cursorrules 참고해서 이 프로젝트의 아키텍처와 요구사항 edesign.md, erequirements.nd 을 반영한 규칙 파일을 edocs 에 windsurfruels.md 에 만들어줘
+
+git hook을 이용해서 커밋시에 Iint fix, build, test가 자동으로 수행되도록 하고싶어. 실행 코드에 변경시에만 작동되어야 해.
+우선은 프론트에 대해서 적용해줘
+
+체크리스트에 방금 작업한 내용을 반영해줘. 설계문서와 README 에도 반영해줘
+
+변경사항을 커밋해줘
+
+@pre-commit 을 수정해서 좀 더 디테일한 로그를 남겨서 디버깅을 용이하게 해줘
+
+## STEP3
+
+[P] 나는 프른트 개발을 독립적으로 완료하고 그 다음 백엔드에 연결하는 방식으로 개발을 하고 싶어.
+
+- 관련 체크리스트 조정됨
+
+[P] 체크리스트에 따라서 다음 작업을 진행해줘
+
+- lint 작성확인
+- npm run lint
+
+[P] 이제부터 mantain v7 으로 UI를 구현해줘. 최신버전의 사용법은 @web https://mantine.dev 를 참고해서 구현해줘
+(시안 이미지 복붙후)
+이미지를 참고해서 모바일과 데스크톱 모두 대응되는 반응형 디자인으로 작성해줘.
+이미지는 와이어프레임 이므로 배치만 참고해줘
+
+- 공식문서 파일들을 rules에 업데이트 하자
+- 관련 MCP도 업데이트 되고 있으니 참고하자
+
+@checklist.md 에 데모로서 불필요한 부분을 삭제했어. 삭제된 내용을 @requirements.md, @design.md 에 반영해줘.
+
+@checklist.md 를 보고 다음 구현을 진행해줘. 우선 브라우저 전체 너비를 사용 하도록 레이아웃을 조정해줘. 현재 코드는 고정폭을 사용하고 있어. 수정 하기 전에 관련 코드를 먼저 꼼꼼히 살펴보고 수정을 계획을 세운다음 나에게 확인을 받고 진행 해.
+
+- 중간에 헤맬때는 조사를 하라고 시키면 좋다

package/claude-code/{simone/.simone → aiwf/en/.aiwf}/99_TEMPLATES/task_template.md

@@ -4,6 +4,7 @@ sprint_sequence_id: S<ID> # e.g., S01 (If part of a sprint, otherwise null or ab
 status: open # open | in_progress | pending_review | done | failed | blocked
 complexity: Medium # Low | Medium | High
 last_updated: YYYY-MM-DDTHH:MM:SSZ
+github_issue: # Optional: GitHub issue number (e.g., #123)
 ---
 
 # Task: (Filename serves as the descriptive title)

package/claude-code/{simone/.simone/CLAUDE.MD → aiwf/en/.aiwf/CLAUDE.md}

@@ -1,30 +1,36 @@
-# CLAUDE.md - Simone Framework Structure Guide
+# CLAUDE.md - AIWF Framework Structure Guide
 
 ## Overview
-This is the root directory of the Simone framework structure. It contains all project documentation, requirements, sprints, and organizational files.
+
+This is the root directory of the AIWF framework structure. It contains all project documentation, requirements, sprints, and organizational files.
 
 ## Critical Files
 
 ### Project Manifest
+
 **IMPORTANT**: The project manifest file MUST be named:
+
 ```
 00_PROJECT_MANIFEST.md
 ```
 
 **NOT**:
+
 - ❌ `MANIFEST.md`
 - ❌ `PROJECT_MANIFEST.md`
 - ❌ `project_manifest.md`
 
 The manifest is the central reference file that tracks:
+
 - Project name and status
 - Current milestone and sprint
 - Project metadata
 - Last updated timestamp
 
 ## Directory Structure
+
 ```
-.simone/
+.AIWF/
 ├── 00_PROJECT_MANIFEST.md          # Central project reference (CORRECT NAME)
 ├── 01_PROJECT_DOCS/                # General project documentation
 ├── 02_REQUIREMENTS/                # Milestone-based requirements
@@ -38,6 +44,7 @@ The manifest is the central reference file that tracks:
 ## Naming Conventions Summary
 
 ### Files
+
 - **Project Manifest**: `00_PROJECT_MANIFEST.md`
 - **Milestone Meta**: `M##_milestone_meta.md`
 - **Sprint Meta**: `S##_M##_sprint_meta.md`
@@ -45,6 +52,7 @@ The manifest is the central reference file that tracks:
 - **ADR Files**: `ADR_###_*.md`
 
 ### Folders
+
 - **Milestones**: `M##_Milestone_Name/`
 - **Sprints**: `S##_M##_Sprint_Name/`
 - **State Snapshots**: `YYYY-MM-DD_HH-MM_snapshot/`
@@ -58,8 +66,9 @@ The manifest is the central reference file that tracks:
 5. **Use underscores** for spaces in folder and file names
 
 ## Common Initialization Mistakes
+
 - Creating `MANIFEST.md` instead of `00_PROJECT_MANIFEST.md`
 - Missing the leading zeros in numbered prefixes
 - Using hyphens instead of underscores
 - Creating files without using templates
-- Not updating the manifest after structural changes
+- Not updating the manifest after structural changes

package/claude-code/{simone/.simone → aiwf/en/.aiwf}/README.md

@@ -1,12 +1,12 @@
-# Simone Framework
+# AIWF Framework
 
-Simone is a project management system designed to work with Claude Code's strengths and limitations. It provides structure for breaking down software projects into manageable, context-aware tasks.
+AIWF is a project management system designed to work with Claude Code's strengths and limitations. It provides structure for breaking down software projects into manageable, context-aware tasks.
 
 ## Core Concept
 
-The fundamental challenge: AI context windows are limited and we can't control what information stays or leaves during long sessions. Simone solves this by starting fresh for each task while providing rich, relevant context.
+The fundamental challenge: AI context windows are limited and we can't control what information stays or leaves during long sessions. AIWF solves this by starting fresh for each task while providing rich, relevant context.
 
-## How Simone Works
+## How AIWF Works
 
 ### 1. Requirements First
 
@@ -49,7 +49,7 @@ Each task follows a strict workflow:
 
 ### 4. Context Management
 
-For each task, Simone provides:
+For each task, AIWF provides:
 
 - The specific task description and criteria
 - Relevant sprint and milestone context
@@ -79,7 +79,7 @@ Built-in review processes maintain standards:
 
 ## Commands Overview
 
-Simone commands (`/project:simone:command`) automate the workflow:
+AIWF commands (`/project:AIWF:command`) automate the workflow:
 
 - Planning: `plan_milestone`, `create_sprint`
 - Execution: `create_task`, `do_task`, `code_review`

package/claude-code/aiwf/en/.claude/CLAUDE_BE.md

@@ -0,0 +1,276 @@
+# CLAUDE.md
+
+IMPORTANT: These are my development preferences and guidelines. YOU MUST follow them when working on my projects.
+site: https://github.com/wcygan/dotfiles
+
+## Code Style & Workflow
+
+### Testing
+
+- **ALWAYS** write clear, descriptive test names for better readability
+- **ALWAYS** prefer running single tests over the whole test suite for performance
+- Use `deno test --filter="test name"` or framework-specific single test runners
+
+### Language & Framework Preferences
+
+#### Backend Programming
+
+IMPORTANT: I am primarily a backend developer and prefer these languages and frameworks:
+
+- **Go**: Use [ConnectRPC](https://github.com/connectrpc/connect-go) for RPC services
+- **Rust**: Use [axum](https://github.com/tokio-rs/axum) for web services
+- **Java**: Use [Spring Boot](https://spring.io/projects/spring-boot) with [Quarkus](https://quarkus.io/)
+
+#### Scripting & Automation
+
+**YOU MUST** use Deno for all scripting tasks instead of Bash or Python:
+
+- Create `deno.json` in project root with tasks for common operations
+- Use JSR imports: `import { walk } from "@std/fs";` NOT `https://deno.land/...`
+- Use [Dax](https://github.com/dsherret/dax) for cross-platform shell operations
+- Example deno.json imports: `"@std/fs": "jsr:@std/fs@^1.0.17"`
+
+#### Web Development
+
+Use [Deno Fresh](https://fresh.deno.dev/) with these practices:
+
+- Built-in test runner: `Deno.test()`
+- Organize tests: `/tests/unit/`, `/tests/component/`, `/tests/e2e/`
+- Mock external dependencies for fast, reliable tests
+- Use fresh-testing-library for component/handler testing
+
+## Infrastructure Choices
+
+IMPORTANT: I run a Talos Linux Kubernetes Cluster. Use these modern alternatives:
+
+- **Database**: Postgres (NOT MySQL)
+- **Cache**: DragonflyDB (NOT Redis)
+- **Streaming**: RedPanda (NOT Kafka)
+- **NoSQL**: ScyllaDB (NOT Cassandra)
+
+## Modern Development Tools
+
+### Preferred Command-Line Tools
+
+**ALWAYS** prefer these modern, fast alternatives:
+
+- **ripgrep (rg)**: Use instead of grep for searching code
+- **fd**: Use instead of find for finding files
+- **fzf**: Use for interactive fuzzy finding
+- **bat**: Use instead of cat for syntax-highlighted file viewing
+- **exa/eza**: Use instead of ls for better file listings
+- **delta**: Use for better git diffs
+- **zoxide**: Use instead of cd for smarter directory navigation
+- **duf**: Use instead of df for disk usage
+- **htop/btop**: Use instead of top for process monitoring
+- **jq**: Use for JSON processing and manipulation
+- **yq**: Use for YAML processing and manipulation
+- **hexyl**: Use for hex viewing of binary files
+
+### Output Format Preferences
+
+**ALWAYS** prefer JSON output for parsing when available:
+
+- Use `-o json` or `--json` flags when available (e.g., `kubectl get nodes -o json`)
+- Parse structured JSON output instead of text formats for reliability
+- Use `jq` for JSON processing in scripts
+- Examples:
+  - `kubectl get pods -o json | jq '.items[].metadata.name'`
+  - `docker inspect container-name | jq '.[0].State.Status'`
+  - `aws ec2 describe-instances --output json | jq '.Reservations[].Instances[]'`
+
+### Common Commands
+
+```bash
+# Modern tool usage
+rg "pattern" --type rust        # Search Rust files
+fd ".rs$" src/                   # Find all Rust files
+bat src/main.rs                  # View file with syntax highlighting
+eza -la --git                    # List files with git status
+delta                            # Better git diff viewer
+
+# Deno development
+deno task dev          # Start development server
+deno task test         # Run all tests
+deno test --filter="specific test"  # Run single test
+deno task build        # Build project
+deno check            # Type check
+deno fmt              # Format code
+deno lint             # Lint code
+
+# Project setup
+deno task init        # Initialize / configure the project for a new environment
+deno task deps        # Update dependencies
+
+# Git worktree (for multi-agent workflows)
+git worktree add ../project-feature feature-branch
+git worktree list
+git worktree remove ../project-feature
+```
+
+## Development Workflow
+
+1. **ALWAYS** run type checking/linting after code changes (e.g., `deno check`, `go vet`, `cargo check`)
+2. **ALWAYS** format code before committing using project's formatter
+3. **ALWAYS** run relevant tests before pushing changes
+4. **NEVER** commit without running pre-commit checks
+5. **ALWAYS** use semantic commit messages (feat:, fix:, docs:, refactor:, test:, chore:)
+
+### AI-Assisted Development Pattern
+
+1. **WRITE** failing tests first (test-driven development)
+2. **GENERATE** implementation with AI assistance
+3. **VERIFY** code meets requirements and security standards
+4. **REFACTOR** at appropriate checkpoints, not continuously
+5. **LOG** extensively for debugging AI-generated code
+
+### Context Management
+
+- **PROVIDE** clear, specific requirements to minimize context gaps
+- **INCLUDE** relevant project context in prompts
+- **DOCUMENT** assumptions and decisions in code comments
+
+## Security & Code Verification
+
+### AI-Generated Code Review
+
+- **ALWAYS** review and understand AI-generated code before accepting
+- **NEVER** commit code you don't fully understand
+- **RUN** security scanning on all generated code
+- **VERIFY** all third-party dependencies suggested by AI
+- **TEST** edge cases and error handling thoroughly
+
+### Sensitive Data Protection
+
+- **NEVER** share API keys, credentials, or proprietary code with AI
+- **USE** environment variables or secret management tools
+- **SANITIZE** logs and debug output before sharing
+
+## Project Planning & Coordination
+
+### PLAN.md Adherence
+
+When a `PLAN.md` file exists in the project root, **YOU MUST**:
+
+1. **READ** the PLAN.md file at the start of each session to understand current tasks and priorities
+2. **FOLLOW** the task breakdown and execution strategy defined in the plan
+3. **RESPECT** task dependencies and join points for multi-agent coordination
+4. **UPDATE** task status in the plan as work progresses
+5. **COORDINATE** with other agents at defined synchronization points
+6. **USE** the TodoWrite tool to track individual tasks from the plan
+
+### Multi-Agent Workflow
+
+When working as part of a multi-agent team:
+
+- **CHECK** `/tmp/{project-name}/project-status.md` or coordination files for shared state
+- **WORK** only on assigned tasks to avoid conflicts
+- **COMMUNICATE** progress through PR comments or status files
+- **WAIT** at join points until all parallel work is complete
+- **MERGE** work carefully following the plan's integration strategy
+- **USE** git worktrees to work on separate branches without conflicts
+- **CREATE** status files in `/tmp/{project-name}/claude-scratch/` for inter-agent communication
+- **COORDINATE** using shared JSON status files for structured updates in project-specific directories
+
+## Performance & Optimization
+
+### Token Efficiency
+
+- **OPTIMIZE** prompts for clarity and brevity
+- **BATCH** related operations in single requests
+- **USE** structured outputs (JSON) for parsing efficiency
+- **CACHE** common patterns and solutions locally
+
+### Parallel Development
+
+- **USE** Docker containers for isolated AI agent environments
+- **IMPLEMENT** clear synchronization points for multi-agent work
+- **MAINTAIN** shared state files in `/tmp/{project-name}/`
+
+## Task Management
+
+Use the task management system for tracking work items:
+
+- **Location**: Tasks are stored in `/tasks/` directory with `status.json` index
+- **Commands**: Use `/task-create`, `/task-update`, `/task-list`, `/task-show`, `/task-log`, `/task-search`, `/task-archive`
+- **Format**: Tasks are markdown files with structured metadata
+- **Integration**: Active tasks sync with TodoWrite for session tracking
+
+## File Organization
+
+- `/src/` - Source code
+- `/tests/` - Test files organized by type
+- `/scripts/` - Deno automation scripts
+- `/tasks/` - Task management files (markdown + status.json)
+- `deno.json` - Project configuration and tasks
+- `import_map.json` - Import mappings (if needed)
+
+## Documentation Style
+
+### README Files
+
+**KEEP README FILES CONCISE AND SCANNABLE:**
+
+- **Maximum 50 lines** for most projects
+- **No excessive emojis** or decorative elements
+- **Essential sections only**: Purpose, Quick Start, Key Commands
+- **No verbose explanations** - let code and comments speak
+- **Single quick start command** when possible
+- **Brief feature lists** without detailed descriptions
+- **Minimal project structure** - only if complex
+- **Essential links only** - avoid resource dumps
+
+**Example concise README:**
+
+````markdown
+# Project Name
+
+Brief one-line description of what it does.
+
+## Quick Start
+
+```bash
+deno task init && deno task dev
+```
+````
+
+## Key Commands
+
+- `deno task test` - Run tests
+- `deno task build` - Build project
+
+## Features
+
+- Core feature 1
+- Core feature 2
+- Core feature 3
+
+```
+**Avoid:**
+- Long feature descriptions
+- Extensive project structure diagrams
+- Multiple installation methods
+- Verbose technical explanations
+- Marketing-style language
+- Detailed configuration options in main README
+
+## Claude Code Features
+
+### Thinking Modes
+- `think` - Standard mode (4,000 tokens)
+- `think hard` - Enhanced analysis
+- `think harder` - Deep computation
+- `ultrathink` - Maximum analysis (31,999 tokens)
+
+### Effective Usage
+- **USE** thinking modes for complex architectural decisions
+- **AVOID** over-thinking simple tasks
+- **BALANCE** computation time with task complexity
+
+## IMPORTANT Notes
+
+- **YOU MUST** follow these guidelines exactly as written
+- **ALWAYS** ask for clarification if requirements conflict
+- **NEVER** use deprecated patterns or old import styles
+- **ALWAYS** prioritize performance and type safety
+```