npm - aiwf - Versions diffs - 0.3.23 → 0.4.0 - Mend

aiwf 0.3.23 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (321) hide show

package/docs/guides/independent-sprint-guide-ko.md DELETED Viewed

@@ -1,321 +0,0 @@
-# 독립 스프린트 가이드
-[Read in English](independent-sprint-guide.md)
-## 개요
-독립 스프린트는 AIWF v0.3.12+의 핵심 기능으로, 마일스톤 관리의 오버헤드 없이 빠른 YOLO 실행을 가능하게 합니다. 다음과 같은 작업에 적합합니다:
-- 빠른 프로토타입
-- 독립적인 기능
-- 버그 수정 묶음
-- README TODO 구현
-- GitHub 이슈 해결
-## 주요 이점
-### 🚀 속도
-- 마일스톤 계획 불필요
-- README에서 TODO 직접 추출
-- 즉시 YOLO 실행 가능
-- 최소한의 설정 오버헤드
-### 🛡️ 오버엔지니어링 방지
-- 내장된 엔지니어링 레벨 제어
-- 포커스 규칙 강제
-- 복잡도 제한
-- 기본적으로 YAGNI 원칙 적용
-### 💾 복구
-- 자동 체크포인트 생성
-- 안전한 중단 처리
-- 진행 상황 보존
-- Git 상태 추적
-## 독립 스프린트 생성
-### README TODO에서 생성
-```bash
-aiwf sprint independent --from-readme
-```
-이 명령어는:
-1. README.md에서 TODO 항목, 체크박스, 기능 목록을 스캔
-2. 이를 태스크로 추출
-3. 최소 엔지니어링 레벨로 스프린트 생성
-4. 즉시 YOLO 실행 준비
-README 형식 예시:
-```markdown
-## TODO
-- [ ] 사용자 인증 추가
-- [ ] API 엔드포인트 구현
-- [ ] 대시보드 UI 생성
-```
-### GitHub 이슈에서 생성
-```bash
-aiwf sprint independent --from-issue 123
-```
-이 명령어는:
-1. `gh` CLI를 사용하여 GitHub에서 이슈 #123 가져오기
-2. 제목과 체크리스트 항목 추출
-3. 이슈 내용에서 태스크 생성
-4. 원본 이슈로 다시 링크
-### 대화형 생성
-```bash
-aiwf sprint independent "빠른 기능 구현"
-```
-다음을 프롬프트합니다:
-- 스프린트 이름
-- 주요 목표
-- 엔지니어링 레벨 선호
-### 엔지니어링 레벨과 함께
-```bash
-# Minimal - 빠른 프로토타입, 필수 요소만
-aiwf sprint independent "MVP 기능" --minimal
-# Balanced - 합리적인 속도로 좋은 품질
-aiwf sprint independent "API 기능" --balanced
-# Complete - 모든 기능을 갖춘 완전한 구현
-aiwf sprint independent "핵심 시스템" --complete
-```
-## 엔지니어링 레벨 설명
-### Minimal 레벨
-- **목표**: 최대한 빨리 작동하는 프로토타입
-- **포커스**: 핵심 기능만
-- **테스트**: 기본적인 스모크 테스트
-- **문서화**: 인라인 주석만
-- **리팩토링**: 문제가 있을 때만
-- **사용 시기**: POC, 데모, 실험
-### Balanced 레벨
-- **목표**: 좋은 관행을 따르는 프로덕션 준비 코드
-- **포커스**: 깨끗하고 유지보수 가능한 코드
-- **테스트**: 중요한 경로에 대한 단위 테스트
-- **문서화**: README + 주요 함수
-- **리팩토링**: 명확성을 위해 필요시
-- **사용 시기**: 일반 기능, API
-### Complete 레벨
-- **목표**: 엔터프라이즈급 구현
-- **포커스**: 확장성과 확장 가능성
-- **테스트**: 포괄적인 테스트 커버리지
-- **문서화**: 전체 API 문서 + 가이드
-- **리팩토링**: 사전 최적화
-- **사용 시기**: 핵심 시스템, 라이브러리
-## 독립 스프린트로 YOLO 실행
-### 기본 실행
-스프린트 생성 후 다음으로 실행:
-```
-/project:aiwf:yolo S03
-```
-### 설정과 함께
-1. YOLO 설정 생성:
-```bash
-aiwf yolo-config wizard
-```
-2. 스프린트의 엔지니어링 레벨과 일치하는 옵션 선택
-3. 오버엔지니어링이 방지된다는 확신으로 실행
-### 체크포인트 복구
-실행이 중단된 경우:
-```bash
-# 상태 확인
-aiwf checkpoint status
-# 사용 가능한 체크포인트 목록
-aiwf checkpoint list
-# 복원 및 계속
-aiwf checkpoint restore cp_1234567890
-```
-## 모범 사례
-### 1. 작게 시작하기
-- 초기 구현에는 `--minimal` 사용
-- 후속 스프린트에서 엔지니어링 레벨 업그레이드
-- 조기 최적화 피하기
-### 2. 요구사항에 집중
-- README TODO가 개발을 주도하도록 허용
-- "있으면 좋은" 기능 추가 저항
-- YAGNI 원칙 엄격히 따르기
-### 3. 체크포인트를 현명하게 사용
-- 위험한 변경 전에 수동 체크포인트 생성
-- 오래된 체크포인트 정기적으로 정리
-- 일반적인 흐름에서는 자동 체크포인트 신뢰
-### 4. 목적에 맞는 레벨 매칭
-- 프로토타입 → Minimal
-- 사용자 대면 기능 → Balanced
-- 핵심 인프라 → Complete
-## 일반적인 워크플로우
-### README에서 빠른 기능
-```bash
-# 1. 기능 목록으로 README 업데이트
-echo "- [ ] 검색 기능 추가" >> README.md
-# 2. README에서 스프린트 생성
-aiwf sprint independent --from-readme --minimal
-# 3. YOLO로 실행
-# Claude Code에서: /project:aiwf:yolo S01
-```
-### 이슈 중심 개발
-```bash
-# 1. 이슈에서 스프린트 생성
-aiwf sprint independent --from-issue 456 --balanced
-# 2. 생성된 태스크 검토
-aiwf-sprint status S01
-# 3. 모니터링과 함께 실행
-# Claude Code에서: /project:aiwf:yolo S01
-```
-### 프로토타입에서 프로덕션으로
-```bash
-# 1. 최소 프로토타입으로 시작
-aiwf sprint independent "사용자 인증" --minimal
-# 실행: /project:aiwf:yolo S01
-# 2. 균형잡힌 구현으로 향상
-aiwf sprint independent "사용자 인증 향상" --balanced
-# 실행: /project:aiwf:yolo S02
-# 3. 전체 기능으로 완성
-aiwf sprint independent "사용자 인증 완성" --complete
-# 실행: /project:aiwf:yolo S03
-```
-## 문제 해결
-### 스프린트 생성 실패
-**문제**: .aiwf 디렉토리를 찾을 수 없음
-**해결**: AIWF가 설치된 프로젝트 루트에서 실행
-**문제**: README에서 TODO를 찾을 수 없음
-**해결**: 체크박스 형식으로 TODO 섹션 추가
-### YOLO 실행 문제
-**문제**: 오버엔지니어링 감지됨
-**해결**: 엔지니어링 레벨을 minimal로 조정
-**문제**: 테스트 실패
-**해결**: YOLO 설정 테스트 임계값 설정 확인
-### 체크포인트 문제
-**문제**: 체크포인트를 복원할 수 없음
-**해결**: Git 상태가 체크포인트와 일치하는지 확인
-**문제**: 체크포인트가 너무 많음
-**해결**: `aiwf checkpoint clean --keep 10` 실행
-## 고급 사용법
-### 사용자 정의 태스크 추출
-`.aiwf/todo-patterns.json` 생성:
-```json
-{
-  "patterns": [
-    "TODO:",
-    "FIXME:",
-    "- [ ]",
-    "기능:"
-  ]
-}
-```
-### 스프린트 템플릿
-`.aiwf/sprint-templates/` 생성:
-```yaml
-# api-sprint.yaml
-name_prefix: "API 기능"
-engineering_level: balanced
-default_tasks:
-  - "API 엔드포인트 설계"
-  - "컨트롤러 구현"
-  - "테스트 추가"
-  - "문서 업데이트"
-```
-### 자동화 스크립트
-```bash
-#!/bin/bash
-# create-weekly-sprint.sh
-# 이번 주 이슈 추출
-ISSUES=$(gh issue list --label "이번-주" --json number -q '.[].number')
-# 이슈에서 스프린트 생성
-for issue in $ISSUES; do
-  aiwf sprint independent --from-issue $issue --minimal
-done
-```
-## CI/CD와의 통합
-### GitHub Actions 예시
-```yaml
-name: 이슈에서 스프린트 생성
-on:
-  issues:
-    types: [labeled]
-jobs:
-  create-sprint:
-    if: github.event.label.name == 'ready-for-sprint'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: AIWF 설치
-        run: npm install -g aiwf
-      - name: 스프린트 생성
-        run: |
-          aiwf sprint independent \
-            --from-issue ${{ github.event.issue.number }} \
-            --minimal
-```
-## 요약
-독립 스프린트는 빠르고 집중된 개발을 향한 AIWF의 진화를 나타냅니다. 마일스톤 관리의 오버헤드를 제거하고 오버엔지니어링 방지를 통합함으로써, 개발자가 최소한의 마찰로 아이디어에서 구현으로 이동할 수 있게 합니다.
-기억하세요: **YOLO는 무모한 것이 아닙니다 - 안전 장치가 있는 집중된 실행입니다.**

package/docs/guides/independent-sprint-guide.md DELETED Viewed

@@ -1,321 +0,0 @@
-# Independent Sprint Guide
-[한국어로 보기](independent-sprint-guide-ko.md)
-## Overview
-Independent Sprints are a core feature of AIWF v0.3.12+, designed to enable rapid YOLO execution without the overhead of milestone management. They are perfect for:
-- Quick prototypes
-- Standalone features
-- Bug fix batches
-- README TODO implementations
-- GitHub issue resolutions
-## Key Benefits
-### 🚀 Speed
-- No milestone planning required
-- Direct TODO extraction from README
-- Immediate YOLO execution capability
-- Minimal setup overhead
-### 🛡️ Overengineering Prevention
-- Built-in engineering level controls
-- Focus rules enforcement
-- Complexity limits
-- YAGNI principle by default
-### 💾 Recovery
-- Automatic checkpoint creation
-- Safe interruption handling
-- Progress preservation
-- Git state tracking
-## Creating Independent Sprints
-### From README TODOs
-```bash
-aiwf sprint independent --from-readme
-```
-This command:
-1. Scans README.md for TODO items, checkboxes, or feature lists
-2. Extracts them as tasks
-3. Creates a sprint with minimal engineering level
-4. Prepares for immediate YOLO execution
-Example README format:
-```markdown
-## TODO
-- [ ] Add user authentication
-- [ ] Implement API endpoints
-- [ ] Create dashboard UI
-```
-### From GitHub Issues
-```bash
-aiwf sprint independent --from-issue 123
-```
-This command:
-1. Fetches issue #123 from GitHub using `gh` CLI
-2. Extracts title and checklist items
-3. Creates tasks from the issue content
-4. Links back to the original issue
-### Interactive Creation
-```bash
-aiwf sprint independent "Quick Feature Implementation"
-```
-This prompts for:
-- Sprint name
-- Main goal
-- Engineering level preference
-### With Engineering Levels
-```bash
-# Minimal - Fast prototype, bare essentials only
-aiwf sprint independent "MVP Feature" --minimal
-# Balanced - Good quality with reasonable speed
-aiwf sprint independent "API Feature" --balanced
-# Complete - Full implementation with all bells and whistles
-aiwf sprint independent "Core System" --complete
-```
-## Engineering Levels Explained
-### Minimal Level
-- **Goal**: Working prototype ASAP
-- **Focus**: Core functionality only
-- **Testing**: Basic smoke tests
-- **Documentation**: Inline comments only
-- **Refactoring**: None unless broken
-- **Use When**: POCs, demos, experiments
-### Balanced Level
-- **Goal**: Production-ready with good practices
-- **Focus**: Clean, maintainable code
-- **Testing**: Unit tests for critical paths
-- **Documentation**: README + key functions
-- **Refactoring**: As needed for clarity
-- **Use When**: Regular features, APIs
-### Complete Level
-- **Goal**: Enterprise-grade implementation
-- **Focus**: Scalability and extensibility
-- **Testing**: Comprehensive test coverage
-- **Documentation**: Full API docs + guides
-- **Refactoring**: Proactive optimization
-- **Use When**: Core systems, libraries
-## YOLO Execution with Independent Sprints
-### Basic Execution
-After creating a sprint, execute it with:
-```
-/project:aiwf:yolo S03
-```
-### With Configuration
-1. Create YOLO config:
-```bash
-aiwf yolo-config wizard
-```
-2. Select options matching your sprint's engineering level
-3. Execute with confidence that overengineering is prevented
-### Checkpoint Recovery
-If execution is interrupted:
-```bash
-# Check status
-aiwf checkpoint status
-# List available checkpoints
-aiwf checkpoint list
-# Restore and continue
-aiwf checkpoint restore cp_1234567890
-```
-## Best Practices
-### 1. Start Small
-- Use `--minimal` for initial implementations
-- Upgrade engineering level in subsequent sprints
-- Avoid premature optimization
-### 2. Focus on Requirements
-- Let README TODOs drive development
-- Resist adding "nice to have" features
-- Follow YAGNI principle strictly
-### 3. Use Checkpoints Wisely
-- Create manual checkpoints before risky changes
-- Clean old checkpoints regularly
-- Trust automatic checkpointing for normal flow
-### 4. Match Level to Purpose
-- Prototypes → Minimal
-- User-facing features → Balanced
-- Core infrastructure → Complete
-## Common Workflows
-### Quick Feature from README
-```bash
-# 1. Update README with feature list
-echo "- [ ] Add search functionality" >> README.md
-# 2. Create sprint from README
-aiwf sprint independent --from-readme --minimal
-# 3. Execute with YOLO
-# In Claude Code: /project:aiwf:yolo S01
-```
-### Issue-Driven Development
-```bash
-# 1. Create sprint from issue
-aiwf sprint independent --from-issue 456 --balanced
-# 2. Review generated tasks
-aiwf-sprint status S01
-# 3. Execute with monitoring
-# In Claude Code: /project:aiwf:yolo S01
-```
-### Prototype to Production
-```bash
-# 1. Start with minimal prototype
-aiwf sprint independent "User Auth" --minimal
-# Execute: /project:aiwf:yolo S01
-# 2. Enhance with balanced implementation
-aiwf sprint independent "User Auth Enhanced" --balanced
-# Execute: /project:aiwf:yolo S02
-# 3. Complete with full features
-aiwf sprint independent "User Auth Complete" --complete
-# Execute: /project:aiwf:yolo S03
-```
-## Troubleshooting
-### Sprint Creation Fails
-**Issue**: Can't find .aiwf directory
-**Solution**: Run from project root with AIWF installed
-**Issue**: No TODOs found in README
-**Solution**: Add TODO section with checkbox format
-### YOLO Execution Issues
-**Issue**: Overengineering detected
-**Solution**: Adjust engineering level to minimal
-**Issue**: Tests failing
-**Solution**: Check YOLO config test threshold settings
-### Checkpoint Problems
-**Issue**: Can't restore checkpoint
-**Solution**: Ensure Git state matches checkpoint
-**Issue**: Too many checkpoints
-**Solution**: Run `aiwf checkpoint clean --keep 10`
-## Advanced Usage
-### Custom Task Extraction
-Create a `.aiwf/todo-patterns.json`:
-```json
-{
-  "patterns": [
-    "TODO:",
-    "FIXME:",
-    "- [ ]",
-    "Feature:"
-  ]
-}
-```
-### Sprint Templates
-Create `.aiwf/sprint-templates/`:
-```yaml
-# api-sprint.yaml
-name_prefix: "API Feature"
-engineering_level: balanced
-default_tasks:
-  - "Design API endpoints"
-  - "Implement controllers"
-  - "Add tests"
-  - "Update documentation"
-```
-### Automation Scripts
-```bash
-#!/bin/bash
-# create-weekly-sprint.sh
-# Extract this week's issues
-ISSUES=$(gh issue list --label "this-week" --json number -q '.[].number')
-# Create sprint from issues
-for issue in $ISSUES; do
-  aiwf sprint independent --from-issue $issue --minimal
-done
-```
-## Integration with CI/CD
-### GitHub Actions Example
-```yaml
-name: Create Sprint from Issues
-on:
-  issues:
-    types: [labeled]
-jobs:
-  create-sprint:
-    if: github.event.label.name == 'ready-for-sprint'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install AIWF
-        run: npm install -g aiwf
-      - name: Create Sprint
-        run: |
-          aiwf sprint independent \
-            --from-issue ${{ github.event.issue.number }} \
-            --minimal
-```
-## Summary
-Independent Sprints represent the evolution of AIWF towards rapid, focused development. By removing the overhead of milestone management and integrating overengineering prevention, they enable developers to move from idea to implementation with minimal friction.
-Remember: **YOLO is not reckless - it's focused execution with safety rails.**

package/rules/global/aiwf-code-style-guide.md DELETED Viewed

@@ -1,30 +0,0 @@
-# Code Style Guide
-Detailed code style rules for naming and TypeScript usage.
-## Naming Conventions
-**Do:**
-- Use descriptive names with auxiliary verbs for booleans (e.g., `isLoading`, `hasError`).
-- Prefix event handlers with "handle" (e.g., `handleClick`, `handleSubmit`).
-- Use lowercase and dashes for directory names (kebab-case) (e.g., `components/todo-list`).
-- Prefer named exports for components and modules.
-**Don't:**
-- Don't use ambiguous or single-letter variable names unless their scope is very small and clear (e.g., loop counters).
-- Don't use `snake_case` or `PascalCase` for file or directory names.
-## TypeScript Usage
-**Do:**
-- Prefer `interface` over `type` for defining object shapes, but use `type` for unions, intersections, or primitives.
-- Use `const` assertions or simple objects instead of `enum`.
-- Use the `satisfies` operator for type validation without changing the underlying type.
-**Don't:**
-- Don't use the `any` type unless absolutely necessary and its usage is well-justified.
-- Don't ignore type errors or suppress them with `// @ts-ignore` without a clear explanation.

package/rules/global/aiwf-coding-principles.md DELETED Viewed

@@ -1,33 +0,0 @@
-# Coding Principles Guide
-High-level architectural principles for the project.
-## Architecture Principles
-**Do:**
-- Apply Clean Architecture principles to create decoupled, testable, and maintainable systems.
-- Follow SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion).
-- Explicitly define architectural boundaries and module responsibilities.
-- Use dependency inversion to decouple high-level and low-level modules.
-**Don't:**
-- Don't create tightly coupled modules that are hard to change or test independently.
-- Don't violate core architectural boundaries or mix unrelated concerns.
-- Don't ignore the separation of business logic and infrastructure.
-## 2. General Coding Philosophy
-**Do:**
-- Write concise, highly readable TypeScript code.
-- Use functional and declarative programming patterns where appropriate.
-- Apply the DRY (Don't Repeat Yourself) principle to avoid code duplication.
-- Use early return statements to improve readability and reduce nesting.
-- Organize components logically: exports, subcomponents, helpers, types.
-**Don't:**
-- Don't write overly complex or deeply nested logic.
-- Don't sacrifice clarity for cleverness.