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

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

@@ -0,0 +1,66 @@
+---
+name: moai-lang-dart
+description: Dart best practices with flutter test, dart analyze, and Flutter widget
+  patterns
+allowed-tools:
+- Read
+- Bash
+---
+
+# Dart Expert
+
+## What it does
+
+Provides Dart-specific expertise for TDD development, including flutter test framework, dart analyze linting, and Flutter widget patterns for cross-platform app development.
+
+## When to use
+
+- "Dart 테스트 작성", "Flutter 위젯 패턴", "flutter test 사용법"
+- Automatically invoked when working with Dart/Flutter projects
+- Dart SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **flutter test**: Built-in test framework
+- **mockito**: Mocking library for Dart
+- **Widget testing**: Test Flutter widgets
+- Test coverage with `flutter test --coverage`
+
+**Code Quality**:
+- **dart analyze**: Static analysis tool
+- **dart format**: Code formatting
+- **very_good_analysis**: Strict lint rules
+
+**Package Management**:
+- **pub**: Package manager (pub.dev)
+- **pubspec.yaml**: Dependency configuration
+- Flutter SDK version management
+
+**Flutter Patterns**:
+- **StatelessWidget/StatefulWidget**: UI components
+- **Provider/Riverpod**: State management
+- **BLoC**: Business logic separation
+- **Navigator**: Routing and navigation
+
+**Best Practices**:
+- File ≤300 LOC, function ≤50 LOC
+- Prefer `const` constructors for immutable widgets
+- Use `final` for immutable fields
+- Widget composition over inheritance
+
+## Examples
+
+### Example 1: TDD with flutter test
+User: "/alfred:2-build UI-001"
+Claude: (creates RED widget test, GREEN implementation, REFACTOR with const)
+
+### Example 2: Static analysis
+User: "dart analyze 실행"
+Claude: (runs dart analyze and reports issues)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (Dart-specific review)
+- mobile-app-expert (Flutter app development)

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

@@ -0,0 +1,66 @@
+---
+name: moai-lang-elixir
+description: Elixir best practices with ExUnit, Mix, and OTP patterns
+allowed-tools:
+- Read
+- Bash
+---
+
+# Elixir Expert
+
+## What it does
+
+Provides Elixir-specific expertise for TDD development, including ExUnit testing, Mix build tool, and OTP (Open Telecom Platform) patterns for concurrent systems.
+
+## When to use
+
+- "Elixir 테스트 작성", "ExUnit 사용법", "OTP 패턴"
+- Automatically invoked when working with Elixir/Phoenix projects
+- Elixir SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **ExUnit**: Built-in test framework
+- **Mox**: Mocking library
+- **StreamData**: Property-based testing
+- Test coverage with `mix test --cover`
+
+**Build Tools**:
+- **Mix**: Build tool and project manager
+- **mix.exs**: Project configuration
+- **Hex**: Package manager
+
+**Code Quality**:
+- **Credo**: Static code analysis
+- **Dialyzer**: Type checking
+- **mix format**: Code formatting
+
+**OTP Patterns**:
+- **GenServer**: Generic server behavior
+- **Supervisor**: Process supervision
+- **Application**: Application behavior
+- **Task**: Async/await operations
+
+**Best Practices**:
+- File ≤300 LOC, function ≤50 LOC
+- Pattern matching over conditionals
+- Pipe operator (|>) for data transformations
+- Immutable data structures
+- "Let it crash" philosophy with supervisors
+
+## Examples
+
+### Example 1: TDD with ExUnit
+User: "/alfred:2-build SERVER-001"
+Claude: (creates RED test with ExUnit, GREEN GenServer implementation, REFACTOR)
+
+### Example 2: Credo analysis
+User: "Credo 분석 실행"
+Claude: (runs mix credo --strict and reports issues)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (Elixir-specific review)
+- web-api-expert (Phoenix API development)

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

@@ -0,0 +1,67 @@
+---
+name: moai-lang-go
+description: Go best practices with go test, golint, gofmt, and standard library utilization
+allowed-tools:
+- Read
+- Bash
+---
+
+# Go Expert
+
+## What it does
+
+Provides Go-specific expertise for TDD development, including go test framework, golint/staticcheck, gofmt formatting, and effective standard library usage.
+
+## When to use
+
+- "Go 테스트 작성", "go test 사용법", "Go 표준 라이브러리"
+- Automatically invoked when working with Go projects
+- Go SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **go test**: Built-in testing framework
+- **Table-driven tests**: Structured test cases
+- **testify/assert**: Optional assertion library
+- Test coverage ≥85% with `go test -cover`
+
+**Code Quality**:
+- **gofmt**: Automatic code formatting
+- **golint**: Go linter (deprecated, use staticcheck)
+- **staticcheck**: Advanced static analysis
+- **go vet**: Built-in error detection
+
+**Standard Library**:
+- Use standard library first before external dependencies
+- **net/http**: HTTP server/client
+- **encoding/json**: JSON marshaling
+- **context**: Context propagation
+
+**Go Patterns**:
+- Interfaces for abstraction (small interfaces)
+- Error handling with explicit returns
+- Defer for cleanup
+- Goroutines and channels for concurrency
+
+**Best Practices**:
+- File ≤300 LOC, function ≤50 LOC
+- Exported names start with capital letters
+- Error handling: `if err != nil { return err }`
+- Avoid naked returns in large functions
+
+## Examples
+
+### Example 1: TDD with table-driven tests
+User: "/alfred:2-build PARSE-001"
+Claude: (creates RED test with table-driven approach, GREEN implementation, REFACTOR)
+
+### Example 2: Coverage check
+User: "go test 커버리지 확인"
+Claude: (runs go test -cover ./... and reports coverage)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (Go-specific review)
+- alfred-performance-optimizer (Go profiling)

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

@@ -0,0 +1,67 @@
+---
+name: moai-lang-haskell
+description: Haskell best practices with HUnit, Stack/Cabal, and pure functional programming
+allowed-tools:
+- Read
+- Bash
+---
+
+# Haskell Expert
+
+## What it does
+
+Provides Haskell-specific expertise for TDD development, including HUnit testing, Stack/Cabal build tools, and pure functional programming with strong type safety.
+
+## When to use
+
+- "Haskell 테스트 작성", "HUnit 사용법", "순수 함수형 프로그래밍"
+- Automatically invoked when working with Haskell projects
+- Haskell SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **HUnit**: Unit testing framework
+- **QuickCheck**: Property-based testing
+- **Hspec**: BDD-style testing
+- Test coverage with hpc
+
+**Build Tools**:
+- **Stack**: Reproducible builds, dependency resolution
+- **Cabal**: Haskell package system
+- **hpack**: Alternative package description
+
+**Code Quality**:
+- **hlint**: Haskell linter
+- **stylish-haskell**: Code formatting
+- **GHC warnings**: Compiler-level checks
+
+**Functional Programming**:
+- **Pure functions**: No side effects
+- **Monads**: IO, Maybe, Either, State
+- **Functors/Applicatives**: Abstraction patterns
+- **Type classes**: Polymorphism
+- **Lazy evaluation**: Infinite data structures
+
+**Best Practices**:
+- File ≤300 LOC, function ≤50 LOC
+- Prefer total functions (avoid partial)
+- Type-driven development
+- Point-free style (when readable)
+- Avoid do-notation overuse
+
+## Examples
+
+### Example 1: TDD with HUnit
+User: "/alfred:2-build PARSE-001"
+Claude: (creates RED test with HUnit, GREEN implementation with pure functions, REFACTOR)
+
+### Example 2: Property testing
+User: "QuickCheck 속성 테스트"
+Claude: (creates property-based tests for invariants)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (Haskell-specific review)
+- alfred-refactoring-coach (functional refactoring)

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

@@ -0,0 +1,66 @@
+---
+name: moai-lang-java
+description: Java best practices with JUnit, Maven/Gradle, Checkstyle, and Spring
+  Boot patterns
+allowed-tools:
+- Read
+- Bash
+---
+
+# Java Expert
+
+## What it does
+
+Provides Java-specific expertise for TDD development, including JUnit testing, Maven/Gradle build tools, Checkstyle linting, and Spring Boot patterns.
+
+## When to use
+
+- "Java 테스트 작성", "JUnit 사용법", "Spring Boot 패턴"
+- Automatically invoked when working with Java projects
+- Java SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **JUnit 5**: Unit testing with annotations (@Test, @BeforeEach)
+- **Mockito**: Mocking framework for dependencies
+- **AssertJ**: Fluent assertion library
+- Test coverage ≥85% with JaCoCo
+
+**Build Tools**:
+- **Maven**: pom.xml, dependency management
+- **Gradle**: build.gradle, Kotlin DSL support
+- Multi-module project structures
+
+**Code Quality**:
+- **Checkstyle**: Java style checker (Google/Sun conventions)
+- **PMD**: Static code analysis
+- **SpotBugs**: Bug detection
+
+**Spring Boot Patterns**:
+- Dependency Injection (@Autowired, @Component)
+- REST controllers (@RestController, @RequestMapping)
+- Service layer separation (@Service, @Repository)
+- Configuration properties (@ConfigurationProperties)
+
+**Best Practices**:
+- File ≤300 LOC, method ≤50 LOC
+- Interfaces for abstraction
+- Builder pattern for complex objects
+- Exception handling with custom exceptions
+
+## Examples
+
+### Example 1: TDD with JUnit
+User: "/alfred:2-build SERVICE-001"
+Claude: (creates RED test with JUnit 5, GREEN implementation, REFACTOR with interfaces)
+
+### Example 2: Build execution
+User: "Maven 빌드 실행"
+Claude: (runs mvn clean test and reports results)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (Java-specific review)
+- database-expert (JPA/Hibernate patterns)

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

@@ -0,0 +1,64 @@
+---
+name: moai-lang-javascript
+description: JavaScript best practices with Jest, ESLint, Prettier, and npm package
+  management
+allowed-tools:
+- Read
+- Bash
+---
+
+# JavaScript Expert
+
+## What it does
+
+Provides JavaScript-specific expertise for TDD development, including Jest testing, ESLint linting, Prettier formatting, and npm package management.
+
+## When to use
+
+- "JavaScript 테스트 작성", "Jest 사용법", "ES6+ 문법"
+- Automatically invoked when working with JavaScript projects
+- JavaScript SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **Jest**: Unit testing with mocking, snapshots
+- **@testing-library**: DOM/React testing
+- Test coverage ≥85% enforcement
+
+**Code Quality**:
+- **ESLint**: JavaScript linting with recommended rules
+- **Prettier**: Code formatting (opinionated)
+- **JSDoc**: Type hints via comments (for type safety)
+
+**Package Management**:
+- **npm**: Standard package manager
+- **package.json** for dependencies and scripts
+- Semantic versioning
+
+**Modern JavaScript**:
+- ES6+ features (arrow functions, destructuring, spread/rest)
+- Async/await over callbacks
+- Module imports (ESM) over CommonJS
+
+**Best Practices**:
+- File ≤300 LOC, function ≤50 LOC
+- Prefer `const` over `let`, avoid `var`
+- Guard clauses for early returns
+- Meaningful names, avoid abbreviations
+
+## Examples
+
+### Example 1: TDD with Jest
+User: "/alfred:2-build API-001"
+Claude: (creates RED test with Jest, GREEN implementation, REFACTOR with JSDoc)
+
+### Example 2: Linting
+User: "ESLint 실행"
+Claude: (runs eslint . and reports linting errors)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (JavaScript-specific review)
+- alfred-debugger-pro (JavaScript debugging)

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

@@ -0,0 +1,66 @@
+---
+name: moai-lang-julia
+description: Julia best practices with Test stdlib, Pkg manager, and scientific computing
+  patterns
+allowed-tools:
+- Read
+- Bash
+---
+
+# Julia Expert
+
+## What it does
+
+Provides Julia-specific expertise for TDD development, including Test standard library, Pkg package manager, and high-performance scientific computing patterns.
+
+## When to use
+
+- "Julia 테스트 작성", "Test stdlib 사용법", "과학 컴퓨팅"
+- Automatically invoked when working with Julia projects
+- Julia SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **Test**: Built-in testing library (@test, @testset)
+- **Coverage.jl**: Test coverage analysis
+- **BenchmarkTools.jl**: Performance benchmarking
+
+**Package Management**:
+- **Pkg**: Built-in package manager
+- **Project.toml**: Package configuration
+- **Manifest.toml**: Dependency lock file
+
+**Code Quality**:
+- **JuliaFormatter.jl**: Code formatting
+- **Lint.jl**: Static analysis
+- **JET.jl**: Type inference analysis
+
+**Scientific Computing**:
+- **Multiple dispatch**: Method specialization on argument types
+- **Type stability**: Performance optimization
+- **Broadcasting**: Element-wise operations (. syntax)
+- **Linear algebra**: Built-in BLAS/LAPACK
+
+**Best Practices**:
+- File ≤300 LOC, function ≤50 LOC
+- Type annotations for performance-critical code
+- Prefer abstract types for function arguments
+- Use @inbounds for performance (after bounds checking)
+- Profile before optimizing
+
+## Examples
+
+### Example 1: TDD with Test stdlib
+User: "/alfred:2-build COMPUTE-001"
+Claude: (creates RED test with @testset, GREEN implementation with type stability, REFACTOR)
+
+### Example 2: Performance optimization
+User: "Julia 성능 최적화"
+Claude: (profiles code and suggests type-stable refactoring)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (Julia-specific review)
+- alfred-performance-optimizer (Julia profiling)

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

@@ -0,0 +1,67 @@
+---
+name: moai-lang-kotlin
+description: Kotlin best practices with JUnit, Gradle, ktlint, coroutines, and extension
+  functions
+allowed-tools:
+- Read
+- Bash
+---
+
+# Kotlin Expert
+
+## What it does
+
+Provides Kotlin-specific expertise for TDD development, including JUnit testing, Gradle build system, ktlint linting, coroutines for concurrency, and extension functions.
+
+## When to use
+
+- "Kotlin 테스트 작성", "코루틴 사용법", "Android 패턴"
+- Automatically invoked when working with Kotlin/Android projects
+- Kotlin SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **JUnit 5**: Unit testing with Kotlin extensions
+- **MockK**: Kotlin-friendly mocking library
+- **Kotest**: Kotlin-native testing framework
+- Test coverage ≥85% with JaCoCo
+
+**Build Tools**:
+- **Gradle**: build.gradle.kts with Kotlin DSL
+- **Maven**: pom.xml alternative
+- Multi-platform support (JVM, Native, JS)
+
+**Code Quality**:
+- **ktlint**: Kotlin linter with formatting
+- **detekt**: Static code analysis
+- **Android Lint**: Android-specific checks
+
+**Kotlin Features**:
+- **Coroutines**: Async programming with suspend functions
+- **Extension functions**: Add methods to existing classes
+- **Data classes**: Automatic equals/hashCode/toString
+- **Null safety**: Non-nullable types by default
+- **Smart casts**: Automatic type casting after checks
+
+**Android Patterns**:
+- **Jetpack Compose**: Declarative UI
+- **ViewModel**: UI state management
+- **Room**: Database abstraction
+- **Retrofit**: Network requests
+
+## Examples
+
+### Example 1: TDD with coroutines
+User: "/alfred:2-build API-001"
+Claude: (creates RED test with runTest, GREEN implementation with suspend functions, REFACTOR)
+
+### Example 2: ktlint check
+User: "ktlint 실행"
+Claude: (runs ktlint and reports style violations)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (Kotlin-specific review)
+- mobile-app-expert (Android app development)

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

@@ -0,0 +1,65 @@
+---
+name: moai-lang-lua
+description: Lua best practices with busted, luacheck, and embedded scripting patterns
+allowed-tools:
+- Read
+- Bash
+---
+
+# Lua Expert
+
+## What it does
+
+Provides Lua-specific expertise for TDD development, including busted testing framework, luacheck linting, and embedded scripting patterns for game development and system configuration.
+
+## When to use
+
+- "Lua 테스트 작성", "busted 사용법", "임베디드 스크립팅"
+- Automatically invoked when working with Lua projects
+- Lua SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **busted**: Elegant Lua testing framework
+- **luassert**: Assertion library
+- **lua-coveralls**: Coverage reporting
+- BDD-style test writing
+
+**Code Quality**:
+- **luacheck**: Lua linter and static analyzer
+- **StyLua**: Code formatting
+- **luadoc**: Documentation generation
+
+**Package Management**:
+- **LuaRocks**: Package manager
+- **rockspec**: Package specification
+
+**Lua Patterns**:
+- **Tables**: Versatile data structure
+- **Metatables**: Operator overloading
+- **Closures**: Function factories
+- **Coroutines**: Cooperative multitasking
+
+**Best Practices**:
+- File ≤300 LOC, function ≤50 LOC
+- Use `local` for all variables
+- Prefer tables over multiple return values
+- Document public APIs
+- Avoid global variables
+
+## Examples
+
+### Example 1: TDD with busted
+User: "/alfred:2-build CONFIG-001"
+Claude: (creates RED test with busted, GREEN implementation, REFACTOR with metatables)
+
+### Example 2: Linting check
+User: "luacheck 실행"
+Claude: (runs luacheck and reports style violations)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (Lua-specific review)
+- cli-tool-expert (Lua scripting utilities)

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

@@ -0,0 +1,65 @@
+---
+name: moai-lang-php
+description: PHP best practices with PHPUnit, Composer, and PSR standards
+allowed-tools:
+- Read
+- Bash
+---
+
+# PHP Expert
+
+## What it does
+
+Provides PHP-specific expertise for TDD development, including PHPUnit testing, Composer package management, and PSR (PHP Standards Recommendations) compliance.
+
+## When to use
+
+- "PHP 테스트 작성", "PHPUnit 사용법", "PSR 표준"
+- Automatically invoked when working with PHP projects
+- PHP SPEC implementation (`/alfred:2-build`)
+
+## How it works
+
+**TDD Framework**:
+- **PHPUnit**: PHP testing framework
+- **Mockery**: Mocking library
+- **PHPSpec**: BDD-style testing (alternative)
+- Test coverage with `phpunit --coverage-html`
+
+**Code Quality**:
+- **PHP_CodeSniffer**: PSR compliance checker
+- **PHPStan**: Static analysis tool
+- **PHP CS Fixer**: Code formatting
+
+**Package Management**:
+- **Composer**: Dependency management
+- **composer.json**: Package configuration
+- **Packagist**: Public package registry
+
+**PSR Standards**:
+- **PSR-1**: Basic coding standard
+- **PSR-2/PSR-12**: Coding style guide
+- **PSR-4**: Autoloading standard
+- **PSR-7**: HTTP message interfaces
+
+**Best Practices**:
+- File ≤300 LOC, method ≤50 LOC
+- Type declarations (PHP 7.4+)
+- Namespaces for organization
+- Dependency injection over global state
+
+## Examples
+
+### Example 1: TDD with PHPUnit
+User: "/alfred:2-build SERVICE-001"
+Claude: (creates RED test with PHPUnit, GREEN implementation, REFACTOR with types)
+
+### Example 2: PSR compliance
+User: "PSR 표준 확인"
+Claude: (runs phpcs --standard=PSR12 and reports violations)
+
+## Works well with
+
+- alfred-trust-validation (coverage verification)
+- alfred-code-reviewer (PHP-specific review)
+- web-api-expert (Laravel/Symfony API development)