moai-adk 0.3.12__py3-none-any.whl → 0.4.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-essentials-review/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: moai-essentials-review
+description: Automated code review with SOLID principles, code smells, and language-specific
+  best practices
+allowed-tools:
+- Read
+- Bash
+- Write
+- Edit
+- TodoWrite
+---
+
+# Alfred Code Reviewer
+
+## What it does
+
+Automated code review with language-specific best practices, SOLID principles verification, and code smell detection.
+
+## When to use
+
+- "코드 리뷰해줘", "이 코드 개선점은?", "코드 품질 확인"
+- Optionally invoked after `/alfred:3-sync`
+- Before merging PR
+
+## How it works
+
+**Code Constraints Check**:
+- File ≤300 LOC
+- Function ≤50 LOC
+- Parameters ≤5
+- Cyclomatic complexity ≤10
+
+**SOLID Principles**:
+- Single Responsibility
+- Open/Closed
+- Liskov Substitution
+- Interface Segregation
+- Dependency Inversion
+
+**Code Smell Detection**:
+- Long Method
+- Large Class
+- Duplicate Code
+- Dead Code
+- Magic Numbers
+
+**Language-specific Best Practices**:
+- Python: List comprehension, type hints, PEP 8
+- TypeScript: Strict typing, async/await, error handling
+- Java: Streams API, Optional, Design patterns
+
+**Review Report**:
+```markdown
+## Code Review Report
+
+### 🔴 Critical Issues (3)
+1. **src/auth/service.py:45** - Function too long (85 > 50 LOC)
+2. **src/api/handler.ts:120** - Missing error handling
+3. **src/db/repository.java:200** - Magic number
+
+### ⚠️ Warnings (5)
+1. **src/utils/helper.py:30** - Unused import
+
+### ✅ Good Practices Found
+- Test coverage: 92%
+- Consistent naming
+```
+
+## Examples
+
+User: "이 코드 리뷰해줘"
+Claude: (analyzes code, detects issues, provides improvement suggestions)
+## Works well with
+
+- moai-foundation-specs
+- moai-essentials-refactor

moai_adk/templates/.claude/skills/moai-foundation-ears/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: moai-foundation-ears
+description: EARS requirement authoring guide (Ubiquitous/Event/State/Optional/Constraints)
+allowed-tools:
+- Read
+- Bash
+- Write
+- Edit
+- TodoWrite
+---
+
+# Alfred EARS Authoring Guide
+
+## What it does
+
+EARS (Easy Approach to Requirements Syntax) authoring guide for writing clear, testable requirements using 5 statement patterns.
+
+## When to use
+
+- "SPEC 작성", "요구사항 정리", "EARS 구문"
+- Automatically invoked by `/alfred:1-plan`
+- When writing or refining SPEC documents
+
+## How it works
+
+EARS provides 5 statement patterns for structured requirements:
+
+### 1. Ubiquitous (기본 요구사항)
+**Format**: 시스템은 [기능]을 제공해야 한다
+**Example**: 시스템은 사용자 인증 기능을 제공해야 한다
+
+### 2. Event-driven (이벤트 기반)
+**Format**: WHEN [조건]이면, 시스템은 [동작]해야 한다
+**Example**: WHEN 사용자가 로그인하면, 시스템은 JWT 토큰을 발급해야 한다
+
+### 3. State-driven (상태 기반)
+**Format**: WHILE [상태]일 때, 시스템은 [동작]해야 한다
+**Example**: WHILE 사용자가 인증된 상태일 때, 시스템은 보호된 리소스 접근을 허용해야 한다
+
+### 4. Optional (선택적 기능)
+**Format**: WHERE [조건]이면, 시스템은 [동작]할 수 있다
+**Example**: WHERE 리프레시 토큰이 제공되면, 시스템은 새로운 액세스 토큰을 발급할 수 있다
+
+### 5. Constraints (제약사항)
+**Format**: IF [조건]이면, 시스템은 [제약]해야 한다
+**Example**: IF 잘못된 토큰이 제공되면, 시스템은 접근을 거부해야 한다
+
+## Writing Tips
+
+✅ Be specific and measurable
+✅ Avoid vague terms ("적절한", "충분한", "빠른")
+✅ One requirement per statement
+✅ Make it testable
+
+## Examples
+
+User: "JWT 인증 SPEC 작성해줘"
+Claude: (applies EARS patterns to structure authentication requirements)
+## Works well with
+
+- moai-foundation-specs

moai_adk/templates/.claude/skills/moai-foundation-git/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: moai-foundation-git
+description: Git workflow automation (branching, TDD commits, PR management)
+allowed-tools:
+- Read
+- Bash
+- Write
+- Edit
+- TodoWrite
+---
+
+# Alfred Git Workflow
+
+## What it does
+
+Automates Git operations following MoAI-ADK conventions: branch creation, locale-based TDD commits, Draft PR creation, and PR Ready transition.
+
+## When to use
+
+- "브랜치 생성", "PR 만들어줘", "커밋 생성"
+- Automatically invoked by `/alfred:1-plan`, `/alfred:2-run`, `/alfred:3-sync`
+- Git workflow automation needed
+
+## How it works
+
+**1. Branch Creation**:
+```bash
+git checkout develop
+git checkout -b feature/SPEC-AUTH-001
+```
+
+**2. Locale-based TDD Commits**:
+- **Korean (ko)**: 🔴 RED: [테스트 설명]
+- **English (en)**: 🔴 RED: [Test description]
+- **Japanese (ja)**: 🔴 RED: [テスト説明]
+- **Chinese (zh)**: 🔴 RED: [测试说明]
+
+Configured via `.moai/config.json`:
+```json
+{"project": {"locale": "ko"}}
+```
+
+**3. Draft PR Creation**:
+Creates Draft PR with SPEC reference and test checklist.
+
+**4. PR Ready Transition** (via `/alfred:3-sync`):
+- Updates PR from Draft → Ready
+- Adds quality gate checklist
+- Verifies TRUST 5-principles
+
+## Examples
+
+### Example 1: Create feature branch
+User: "/alfred:1-plan JWT 인증"
+Claude: (creates `feature/SPEC-AUTH-001` branch and Draft PR)
+
+### Example 2: TDD commit
+User: "/alfred:2-run AUTH-001"
+Claude: (commits with locale-specific format: 🔴 RED, 🟢 GREEN, ♻️ REFACTOR)
+
+### Example 3: Finalize PR
+User: "/alfred:3-sync"
+Claude: (transitions PR to Ready state with quality report)

moai_adk/templates/.claude/skills/moai-foundation-langs/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: moai-foundation-langs
+description: Auto-detects project language and framework (package.json, pyproject.toml,
+  etc)
+allowed-tools:
+- Read
+- Bash
+- Write
+- Edit
+- TodoWrite
+---
+
+# Alfred Language Detection
+
+## What it does
+
+Automatically detects project's primary language and framework by scanning configuration files, then recommends appropriate testing tools and linters.
+
+## When to use
+
+- "언어 감지", "프로젝트 언어 확인", "테스트 도구 추천"
+- Automatically invoked by `/alfred:0-project`, `/alfred:2-run`
+- Setting up new project
+
+## How it works
+
+**Configuration File Scanning**:
+- `package.json` → TypeScript/JavaScript (Jest/Vitest, ESLint/Biome)
+- `pyproject.toml` → Python (pytest, ruff, black)
+- `Cargo.toml` → Rust (cargo test, clippy, rustfmt)
+- `go.mod` → Go (go test, golint, gofmt)
+- `Gemfile` → Ruby (RSpec, RuboCop)
+- `pubspec.yaml` → Dart/Flutter (flutter test, dart analyze)
+- `build.gradle` → Java/Kotlin (JUnit, Checkstyle)
+- `Package.swift` → Swift (XCTest, SwiftLint)
+
+**Toolchain Recommendation**:
+```json
+{
+  "language": "Python",
+  "test_framework": "pytest",
+  "linter": "ruff",
+  "formatter": "black",
+  "type_checker": "mypy",
+  "package_manager": "uv"
+}
+```
+
+**Framework Detection**:
+- **Python**: FastAPI, Django, Flask
+- **TypeScript**: React, Next.js, Vue
+- **Java**: Spring Boot, Quarkus
+
+**Supported Languages**: Python, TypeScript, Java, Go, Rust, Ruby, Dart, Swift, Kotlin, PHP, C#, C++, Elixir, Scala, Clojure (20+ languages)
+
+## Examples
+
+### Example 1: Auto-detect project language
+User: "/alfred:0-project"
+Claude: (scans config files, detects Python, recommends pytest + ruff + black)
+
+### Example 2: Manual detection
+User: "이 프로젝트는 무슨 언어?"
+Claude: (analyzes config files and reports language + framework)

moai_adk/templates/.claude/skills/moai-foundation-specs/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: moai-foundation-specs
+description: Validates SPEC YAML frontmatter (7 required fields) and HISTORY section
+allowed-tools:
+- Read
+- Bash
+- Write
+- Edit
+- TodoWrite
+---
+
+# Alfred SPEC Metadata Validation
+
+## What it does
+
+Validates SPEC document structure including YAML frontmatter (7 required fields) and HISTORY section compliance.
+
+## When to use
+
+- "SPEC 검증", "메타데이터 확인", "SPEC 구조 체크"
+- Automatically invoked by `/alfred:1-plan`
+- Before creating SPEC document
+
+## How it works
+
+**YAML Frontmatter Validation (7 required fields)**:
+- `id`: SPEC ID (e.g., AUTH-001)
+- `version`: Semantic Version (e.g., 0.0.1)
+- `status`: draft|active|completed|deprecated
+- `created`: YYYY-MM-DD format
+- `updated`: YYYY-MM-DD format
+- `author`: @{GitHub ID} format
+- `priority`: low|medium|high|critical
+
+**HISTORY Section Validation**:
+- Checks existence of HISTORY section
+- Verifies version history (INITIAL/ADDED/CHANGED/FIXED tags)
+- Validates author and date consistency
+
+**Format Validation**:
+```bash
+# Check required fields
+rg "^(id|version|status|created|updated|author|priority):" .moai/specs/SPEC-*/spec.md
+
+# Verify HISTORY section
+rg "^## HISTORY" .moai/specs/SPEC-*/spec.md
+```
+
+## Examples
+
+### Example 1: Validate SPEC structure
+User: "SPEC-AUTH-001 메타데이터 확인해줘"
+Claude: (validates YAML frontmatter and HISTORY section, reports issues)
+
+### Example 2: Batch validation
+User: "모든 SPEC 메타데이터 검증"
+Claude: (validates all SPEC documents and generates report)
+## Works well with
+
+- moai-foundation-ears
+- moai-foundation-tags

moai_adk/templates/.claude/skills/moai-foundation-tags/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: moai-foundation-tags
+description: Scans @TAG markers directly from code and generates inventory (CODE-FIRST)
+allowed-tools:
+- Read
+- Bash
+- Write
+- Edit
+- TodoWrite
+---
+
+# Alfred TAG Scanning
+
+## What it does
+
+Scans all @TAG markers (SPEC/TEST/CODE/DOC) directly from codebase and generates TAG inventory without intermediate caching (CODE-FIRST principle).
+
+## When to use
+
+- "TAG 스캔", "TAG 목록", "TAG 인벤토리"
+- Automatically invoked by `/alfred:3-sync`
+- "고아 TAG 찾아줘", "TAG 체인 확인"
+
+## How it works
+
+**CODE-FIRST Scanning**:
+```bash
+# Direct code scan without intermediate cache
+rg '@(SPEC|TEST|CODE|DOC):' -n .moai/specs/ tests/ src/ docs/
+```
+
+**TAG Inventory Generation**:
+- Lists all TAGs with file locations
+- Detects orphaned TAGs (no corresponding SPEC/TEST/CODE)
+- Identifies broken links in TAG chain
+- Reports duplicate IDs
+
+**TAG Chain Verification**:
+- @SPEC → @TEST → @CODE → @DOC connection check
+- Ensures traceability across all artifacts
+
+## Examples
+
+### Example 1: Full TAG scan
+User: "TAG 전체 스캔해줘"
+Claude: (scans all files and generates TAG inventory report)
+
+### Example 2: Find orphaned TAGs
+User: "고아 TAG 찾아줘"
+Claude: (identifies TAGs without complete chain)
+## Works well with
+
+- moai-foundation-trust
+- moai-foundation-specs

moai_adk/templates/.claude/skills/moai-foundation-trust/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: moai-foundation-trust
+description: Validates TRUST 5-principles (Test 85%+, Readable, Unified, Secured,
+  Trackable)
+allowed-tools:
+- Read
+- Write
+- Edit
+- Bash
+- TodoWrite
+---
+
+# Foundation: TRUST Validation
+
+## What it does
+
+Validates MoAI-ADK's TRUST 5-principles compliance to ensure code quality, testability, security, and traceability.
+
+## When to use
+
+- "TRUST 원칙 확인", "품질 검증", "코드 품질 체크"
+- Automatically invoked by `/alfred:3-sync`
+- Before merging PR or releasing
+
+## How it works
+
+**T - Test First**:
+- Checks test coverage ≥85% (pytest, vitest, go test, cargo test, etc.)
+- Verifies TDD cycle compliance (RED → GREEN → REFACTOR)
+
+**R - Readable**:
+- File ≤300 LOC, Function ≤50 LOC, Parameters ≤5, Complexity ≤10
+
+**U - Unified**:
+- SPEC-driven architecture consistency, Clear module boundaries
+
+**S - Secured**:
+- Input validation, No hardcoded secrets, Access control
+
+**T - Trackable**:
+- TAG chain integrity (@SPEC → @TEST → @CODE → @DOC)
+
+## Works well with
+
+- moai-foundation-tags (TAG traceability)
+- moai-foundation-specs (SPEC validation)

moai_adk/templates/.claude/skills/moai-lang-c/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: moai-lang-c
+description: C best practices with Unity test framework, cppcheck, and Make build
+  system
+allowed-tools:
+- Read
+- Bash
+---
+
+# C Expert
+
+## What it does
+
+Provides C-specific expertise for TDD development, including Unity test framework, cppcheck static analysis, and Make build system for system programming.
+
+## When to use
+
+- "C 테스트 작성", "Unity 테스트 프레임워크", "임베디드 C"
+- Automatically invoked when working with C projects
+- C SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **Unity**: Lightweight C test framework
+- **CMock**: Mocking framework for C
+- **Ceedling**: Build automation for C
+- Test coverage with gcov
+
+**Build Tools**:
+- **Make**: Standard build automation
+- **CMake**: Modern build system
+- **GCC/Clang**: C compilers
+
+**Code Quality**:
+- **cppcheck**: Static code analysis
+- **Valgrind**: Memory leak detection
+- **splint**: Secure programming lint
+
+**C Patterns**:
+- **Opaque pointers**: Information hiding
+- **Function pointers**: Callback mechanisms
+- **Error codes**: Integer return values
+- **Manual memory management**: malloc/free discipline
+
+**Best Practices**:
+- File ≤300 LOC, function ≤50 LOC
+- Always check malloc return values
+- Free every malloc
+- Avoid buffer overflows (use strncpy, snprintf)
+- Use const for read-only parameters
+- Initialize all variables
+
+## Examples
+
+### Example 1: TDD with Unity
+User: "/alfred:2-build DRIVER-001"
+Claude: (creates RED test with Unity, GREEN implementation, REFACTOR with error handling)
+
+### Example 2: Memory leak check
+User: "Valgrind 메모리 체크"
+Claude: (runs valgrind --leak-check=full and reports leaks)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (C-specific review)
+- alfred-debugger-pro (C debugging)

moai_adk/templates/.claude/skills/moai-lang-clojure/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: moai-lang-clojure
+description: Clojure best practices with clojure.test, Leiningen, and immutable data
+  structures
+allowed-tools:
+- Read
+- Bash
+---
+
+# Clojure Expert
+
+## What it does
+
+Provides Clojure-specific expertise for TDD development, including clojure.test framework, Leiningen build tool, and immutable data structures with functional programming.
+
+## When to use
+
+- "Clojure 테스트 작성", "clojure.test 사용법", "불변 데이터 구조"
+- Automatically invoked when working with Clojure projects
+- Clojure SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **clojure.test**: Built-in testing library
+- **midje**: BDD-style testing
+- **test.check**: Property-based testing
+- Test coverage with cloverage
+
+**Build Tools**:
+- **Leiningen**: Project automation, dependency management
+- **deps.edn**: Official dependency tool
+- **Boot**: Alternative build tool
+
+**Code Quality**:
+- **clj-kondo**: Linter for Clojure
+- **cljfmt**: Code formatting
+- **eastwood**: Additional linting
+
+**Clojure Patterns**:
+- **Immutable data structures**: Persistent collections
+- **Pure functions**: Functional core, imperative shell
+- **Threading macros**: -> and ->> for readability
+- **Lazy sequences**: Infinite data processing
+- **Transducers**: Composable transformations
+
+**Best Practices**:
+- File ≤300 LOC, function ≤50 LOC
+- Prefer let bindings over def
+- Use namespaces for organization
+- Destructuring for data access
+- Avoid mutable state
+
+## Examples
+
+### Example 1: TDD with clojure.test
+User: "/alfred:2-build TRANSFORM-001"
+Claude: (creates RED test with clojure.test, GREEN implementation with threading macros, REFACTOR)
+
+### Example 2: Property testing
+User: "test.check 속성 테스트"
+Claude: (creates generative tests with test.check)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (Clojure-specific review)
+- alfred-refactoring-coach (functional refactoring)

moai_adk/templates/.claude/skills/moai-lang-cpp/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: moai-lang-cpp
+description: C++ best practices with Google Test, clang-format, and modern C++ (C++17/20)
+allowed-tools:
+- Read
+- Bash
+---
+
+# C++ Expert
+
+## What it does
+
+Provides C++-specific expertise for TDD development, including Google Test framework, clang-format formatting, and modern C++ (C++17/20) features.
+
+## When to use
+
+- "C++ 테스트 작성", "Google Test 사용법", "모던 C++"
+- Automatically invoked when working with C++ projects
+- C++ SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **Google Test (gtest)**: Unit testing framework
+- **Google Mock (gmock)**: Mocking framework
+- **Catch2**: Alternative testing framework
+- Test coverage with gcov/lcov
+
+**Build Tools**:
+- **CMake**: Cross-platform build system
+- **Make**: Traditional build tool
+- **Conan/vcpkg**: Package managers
+
+**Code Quality**:
+- **clang-format**: Code formatting
+- **clang-tidy**: Static analysis
+- **cppcheck**: Additional static analysis
+
+**Modern C++ Features**:
+- **Smart pointers**: unique_ptr, shared_ptr, weak_ptr
+- **Move semantics**: std::move, rvalue references
+- **Lambda expressions**: Inline functions
+- **auto keyword**: Type inference
+- **constexpr**: Compile-time evaluation
+- **std::optional**: Nullable types (C++17)
+- **Concepts**: Type constraints (C++20)
+
+**Best Practices**:
+- File ≤300 LOC, function ≤50 LOC
+- RAII (Resource Acquisition Is Initialization)
+- Rule of Five (destructor, copy/move constructors/assignments)
+- Prefer stack allocation over heap
+- Const correctness
+
+## Examples
+
+### Example 1: TDD with Google Test
+User: "/alfred:2-build CACHE-001"
+Claude: (creates RED test with gtest, GREEN implementation with smart pointers, REFACTOR)
+
+### Example 2: Modern C++ refactoring
+User: "C++17 기능으로 리팩토링"
+Claude: (refactors code to use std::optional, structured bindings)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (C++-specific review)
+- alfred-performance-optimizer (C++ profiling)

moai_adk/templates/.claude/skills/moai-lang-csharp/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: moai-lang-csharp
+description: C# best practices with xUnit, .NET tooling, LINQ, and async/await patterns
+allowed-tools:
+- Read
+- Bash
+---
+
+# C# Expert
+
+## What it does
+
+Provides C#-specific expertise for TDD development, including xUnit testing, .NET CLI tooling, LINQ query expressions, and async/await patterns.
+
+## When to use
+
+- "C# 테스트 작성", "xUnit 사용법", "LINQ 쿼리"
+- Automatically invoked when working with .NET projects
+- C# SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **xUnit**: Modern .NET testing framework
+- **Moq**: Mocking library for interfaces
+- **FluentAssertions**: Expressive assertions
+- Test coverage ≥85% with Coverlet
+
+**Build Tools**:
+- **.NET CLI**: dotnet build, test, run
+- **NuGet**: Package management
+- **MSBuild**: Build system
+
+**Code Quality**:
+- **StyleCop**: C# style checker
+- **SonarAnalyzer**: Static code analysis
+- **EditorConfig**: Code formatting rules
+
+**C# Patterns**:
+- **LINQ**: Query expressions for collections
+- **Async/await**: Asynchronous programming
+- **Properties**: Get/set accessors
+- **Extension methods**: Add methods to existing types
+- **Nullable reference types**: Null safety (C# 8+)
+
+**Best Practices**:
+- File ≤300 LOC, method ≤50 LOC
+- Use PascalCase for public members
+- Prefer `var` for local variables when type is obvious
+- Async methods should end with "Async" suffix
+- Use string interpolation ($"") over concatenation
+
+## Examples
+
+### Example 1: TDD with xUnit
+User: "/alfred:2-build SERVICE-001"
+Claude: (creates RED test with xUnit, GREEN implementation with async/await, REFACTOR)
+
+### Example 2: LINQ query optimization
+User: "LINQ 쿼리 최적화"
+Claude: (analyzes LINQ queries and suggests IEnumerable vs IQueryable optimizations)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (C#-specific review)
+- web-api-expert (ASP.NET Core API development)