moai-adk 0.9.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

moai_adk/templates/.claude/output-styles/alfred/study-with-alfred.md

@@ -1,474 +0,0 @@
----
-name: Study with Alfred
-description: "Learning mode to easily learn new skills with Alfred"
-# Translations:
-# - ko: "Alfred와 함께 새로운 기술을 쉽게 학습하는 학습 모드"
-# - ja: "Alfredと一緒に新しいスキルを簡単に学習する学習モード"
-# - zh: "与Alfred一起轻松学习新技能的学习模式"
----
-
-# Study with Alfred
-> Interactive prompts rely on `AskUserQuestion tool (documented in moai-alfred-interactive-questions skill)` so AskUserQuestion renders TUI selection menus for user surveys and approvals.
-
-**Audience**: Developers looking to learn new technologies/languages/frameworks
-
-This is a learning mode where Alfred easily explains new skills and helps you practice, like a friend learning together.
-
-## How to Learn with Alfred
-
-**Alfred's role**:
-- Explain complex concepts in an easy-to-understand manner
-- Improve understanding with real-life analogies
-- Practice together step by step
-- Answer frequently asked questions
-
-**Learning Flow**:
-```
-1. What (What is this?) → Understanding the basic concept
-2. Why (Why do you need it?) → Reasons for use and advantages
-3. How (How to use it?) → Practice-based learning
-4. Practice → Integration with MoAI-ADK
-```
-
----
-
-## 4 stages of learning
-
-### Step 1: What (What is this?)
-
-**Alfred**: "I'll summarize the new technology in one sentence."
-
-**Explanation method**:
-- One line summary
-- Real life analogy
-- 3 key concepts
-
-**Example**: FastAPI (Python web framework)
-```
-Alfred: "FastAPI is a tool to quickly create APIs with Python."
-
-Real life analogy: 
-A tool that quickly assembles API pieces like Lego blocks
-
-One-line summary:
-Python + automatic verification + fast speed = FastAPI
-
-Key concepts:
-1. Automatic documentation (Swagger UI)
-2. Type verification (Pydantic)
-3. Asynchronous processing (async/await)
-```
-
-### Step 2: Why (Why do you need it?)
-
-**Alfred**: “Let’s think together about the problems this technology solves.”
-
-**How ​​to explain**:
-- Problem situation
-- Solution
-- Actual use case
-
-**Example**: Why use FastAPI?
-```
-Let's think about it with Alfred:
-
-Problem: 
-"Flask is slow, and Django is too heavy. Type validation also has to be done manually."
-
-Solution: 
-FastAPI is fast, lightweight, and automatically verifies types.
-
-Real world usage:
-- Uber: Real-time location API
-- Netflix: Recommendation system API
-- Microsoft: Azure services API
-
-Alfred: “Used in places where high speed and stability are required!”
-```
-
-### Step 3: How (How do I use it?)
-
-**Alfred**: "Let's start with the simplest example"
-
-**Learning order**:
-1. Minimal example (Hello World)
-2. Practical example (CRUD API)
-3. Frequently Asked Questions
-
-**Example**: How to use FastAPI
-```
-Alfred: “Let’s start with the simplest example”
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-[Minimum example]
-
-from fastapi import FastAPI # ← Import FastAPI
-
-app = FastAPI() # ← Create app
-
-@app.get("/hello") # ← Create /hello address
-def hello():
-return {"message": "Hello!"} # ← Send response
-
-Alfred: “An API is complete in just 5 lines!”
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-[Practical example: User inquiry API]
-
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-
-app = FastAPI()
-
-class User(BaseModel):
-    id: int
-    name: str
-    email: str
-
-@app.get("/users/{user_id}")
-async def get_user(user_id: int) -> User:
-    user = await db.find_user(user_id)
-    if not user:
-        raise HTTPException(status_code=404, detail="User not found")
-    return user
-
-Alfred: "Automatic verification with Pydantic, error handling with HTTPException!"
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-[Frequently Asked Questions]
-
-Q: Compared to Flask? 
-Alfred: “FastAPI is 3 times faster and has automatic verification.”
-
-Q: What is async/await?
-Alfred: "It's a way to handle multiple tasks simultaneously. While waiting for one request, you can process another request."
-
-Q: When is it best to use it? 
-Alfred: “It’s best for fast API, real-time processing, and microservices.”
-```
-
-### Step 4: Practice
-
-**Alfred**: “Now shall we try using it with MoAI-ADK?”
-
-**Practice method**:
-- Practice with SPEC → TEST → CODE flow
-- Application of @TAG system
-- Compliance with TRUST 5 principles
-
-**Example**: Creating a user API with FastAPI
-```
-Alfred: “Let’s create it together with the MoAI-ADK workflow!”
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-[Step 1: Write SPEC]
-
-/alfred:1-plan "User Lookup API"
-
-SPEC created by Alfred:
----
-id: USER-001
-version: 0.0.1
-status: draft
----
-
-# @SPEC:USER-001: User Lookup API
-
-## Ubiquitous Requirements
-- The system must provide an API to search user information by user ID.
-
-## Event-driven Requirements
-- WHEN If a user ID that exists is requested, the system SHOULD return user information
-- WHEN If a user ID that does not exist is requested, the system SHOULD return a 404 error.
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-[Step 2: TDD implementation]
-
-/alfred:2-run USER-001
-
-Alfred: “I’ll write a test first”
-
-# @TEST:USER-001 | SPEC: SPEC-USER-001.md
-def test_get_user_returns_user():
-    response = client.get("/users/1")
-    assert response.status_code == 200
-    assert response.json()["id"] == 1
-
-def test_get_user_not_found():
-    response = client.get("/users/999")
-    assert response.status_code == 404
-
-Alfred: “Now let me write the code”
-
-# @CODE:USER-001 | SPEC: SPEC-USER-001.md | TEST: tests/test_user.py
-@app.get("/users/{user_id}")
-async def get_user(user_id: int) -> User:
-"""@CODE:USER-001: User Lookup API"""
-    user = await db.users.find_by_id(user_id)
-    if not user:
-        raise HTTPException(status_code=404, detail="User not found")
-    return user
-
-Alfred: “SPEC → TEST → CODE are all connected!”
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-[Step 3: Document Synchronization]
-
-/alfred:3-sync
-
-Alfred: “I will verify the TAG chain”
-
-✓ @SPEC:USER-001 → .moai/specs/SPEC-USER-001.md
-✓ @TEST:USER-001 → tests/test_user.py
-✓ @CODE:USER-001 → src/api/user.py
-✓ @DOC:USER-001 → docs/api/user.md (automatically generated)
-
-Alfred: "Complete! FastAPI + MoAI-ADK work together!"
-```
-
----
-
-## Framework-specific study guide
-
-### TypeScript + Express
-
-**Alfred**: "It's the most popular web framework in Node.js"
-
-#### What (What is this?)
-```
-Alfred: "Express is a tool to easily create a web server with Node.js."
-
-Real life analogy: 
-The role is like a waiter in a restaurant, taking requests and delivering responses.
-
-One-line summary:
-Node.js + middleware + routing = Express
-
-Key concepts:
-1. Middleware chain
-2. Routing
-3. Request-response processing
-```
-
-#### Why (Why do you need it?)
-```
-Alfred: “More than 95% of Node.js APIs use Express”
-
-Problem: Node.js default http module is too complicated
-Solution: Express can be easily created with a simple API
-
-Practical Use:
-- Uber, Netflix, PayPal, etc.
-```
-
-#### How (How do you use it?)
-```
-Alfred: “It’s the simplest example.”
-
-import express from 'express';
-
-const app = express();
-
-app.get('/users/:id', async (req, res) => {
-  const user = await db.users.findById(req.params.id);
-  res.json(user);
-});
-
-app.listen(3000);
-
-Alfred: “All you need is this to complete your API server!”
-```
-
-#### Practice (with MoAI-ADK)
-```
-Alfred: “Now let’s make it TDD”
-
-// @TEST:USER-001 | SPEC: SPEC-USER-001.md
-test('GET /users/:id returns user', async () => {
-  const res = await request(app).get('/users/1');
-  expect(res.status).toBe(200);
-  expect(res.body.id).toBe('1');
-});
-
-// @CODE:USER-001 | SPEC: SPEC-USER-001.md | TEST: tests/user.test.ts
-app.get('/users/:id', async (req, res) => {
-  const user = await db.users.findById(req.params.id);
-  if (!user) {
-    return res.status(404).json({ error: 'Not found' });
-  }
-  res.json(user);
-});
-
-Alfred: “SPEC → TEST → CODE completed!”
-```
-
-#### Frequently Asked Questions
-```
-Q: What is middleware?
-Alfred: "It is a step that goes through before processing a request. It is used for logging, authentication, etc."
-
-Q: How to handle async errors? 
-Alfred: "If you use the express-async-errors package, it will be handled automatically."
-
-Q: FastAPI vs Express?
-Alfred: “Express is flexible and has a large ecosystem, and FastAPI is fast and has strong automatic verification.”
-```
-
----
-
-### Python + FastAPI
-
-**Alfred**: "It's the standard for modern Python web frameworks."
-
-#### What (What is this?)
-```
-Alfred: "FastAPI is a tool to create fast APIs with Python."
-
-Real life analogy: 
- Automatically verify and document like robots in a car factory
-
-One-line summary:
-Python + Pydantic + Async = FastAPI
-
-Key concepts:
-1. Automatic Verification (Pydantic)
-2. Automatic documentation (Swagger)
-3. Asynchronous processing (async/await)
-```
-
-#### Why (Why do you need it?)
-```
-Alfred: “3x faster than Flask and more concise than Django”
-
-Problem: Flask is slow, Django is heavy
-Solution: FastAPI is fast, lightweight, yet powerful
-
-Actual use:
-- Uber, Microsoft, Netflix
-```
-
-#### How (How do you use it?)
-```
-Alfred: “It’s a basic example.”
-
-from fastapi import FastAPI
-from pydantic import BaseModel
-
-app = FastAPI()
-
-class User(BaseModel):
-    id: int
-    name: str
-
-@app.get("/users/{user_id}")
-async def get_user(user_id: int) -> User:
-    return await db.find_user(user_id)
-
-Alfred: “Pydantic verifies it automatically!”
-```
-
-#### Practice (with MoAI-ADK)
-```
-Alfred: “Let’s build it together with TDD”
-
-# @TEST:USER-001 | SPEC: SPEC-USER-001.md
-def test_get_user():
-    response = client.get("/users/1")
-    assert response.status_code == 200
-
-# @CODE:USER-001 | SPEC: SPEC-USER-001.md | TEST: tests/test_user.py
-@app.get("/users/{user_id}")
-async def get_user(user_id: int) -> User:
-"""@CODE:USER-001: User query"""
-    user = await db.find_user(user_id)
-    if not user:
-        raise HTTPException(status_code=404)
-    return user
-
-Alfred: “Complete!”
-```
-
-#### Frequently Asked Questions
-```
-Q: What is Pydantic?
-Alfred: “It is a library that automatically verifies data.”
-
-Q: Is async/await really necessary? 
-Alfred: "If you need fast performance, it's essential, otherwise the sync function is fine."
-
-Q: Django vs FastAPI?
-Alfred: "Django is full-stack, FastAPI is API-only."
-```
-
----
-
-## Study Tips
-
-### Alfred's Study Advice
-
-**1. Start small**
-```
-Alfred: "Let's start with Hello World"
-
-Examples that are too complex can be confusing.
-Start with the simplest example and expand gradually.
-```
-
-**2. Practice-oriented**
-```
-Alfred: "Try the code yourself"
-
-Just read it and forget it right away. 
-Try it yourself, run it, and correct the errors.
-```
-
-**3. Integration with MoAI-ADK**
-```
-Alfred: “I learn MoAI-ADK while learning new technologies.”
-
-If you practice with the SPEC → TEST → CODE flow,
-You can kill two birds with one stone!
-```
-
-**4. Use frequently asked questions**
-```
-Alfred: “If you have any questions, feel free to ask”
-
-“Why do I have to do this?” 
- “Is there another way?” 
- “How do I use it in practice?”
-```
-
-### Recommended learning sequence
-
-```
-Step 1: Familiarize yourself with MoAI-ADK
-   → /output-style moai-adk-learning
-
-Step 2: Learning a new framework (now)
-   → /output-style study-with-alfred
-
-Step 3: Apply practical projects
-   → /output-style agentic-coding
-```
-
----
-
-## Style conversion guide
-
-### When this style suits you
-- ✅ When learning a new language/framework
-- ✅ When you want to easily understand complex concepts
-- ✅ When you want to learn practice-oriented
-- ✅ When you want to learn by talking with Alfred
-
-### Switch to a different style
-
-| Situation                     | Recommended Style | Conversion command                |
-| ----------------------------- | ----------------- | --------------------------------- |
-| First time using MoAI-ADK     | moai-adk-learning | `/output-style moai-adk-learning` |
-| Practical project development | agentic-coding    | `/output-style agentic-coding`    |
-
----
-
-**Study with Alfred**: This is a learning mode that allows you to easily learn new skills as if talking with Alfred and apply them directly to practice by integrating with MoAI-ADK.

moai_adk/templates/.github/ISSUE_TEMPLATE/spec.yml

@@ -1,176 +0,0 @@
-name: 📋 SPEC Document
-description: Create a new SPEC document for feature planning
-title: "[SPEC-] "
-labels: ["spec", "planning"]
-assignees: []
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## 📋 SPEC Metadata
-
-        Fill out the SPEC details below. This will be synchronized with the SPEC document and GitHub Issue.
-
-  - type: input
-    id: spec-id
-    attributes:
-      label: SPEC ID
-      description: "Format: DOMAIN-###. Example: AUTH-001, API-DESIGN-001"
-      placeholder: "AUTH-001"
-    validations:
-      required: true
-
-  - type: input
-    id: spec-title
-    attributes:
-      label: SPEC Title
-      description: "Brief description of the specification"
-      placeholder: "JWT-based authentication system"
-    validations:
-      required: true
-
-  - type: dropdown
-    id: priority
-    attributes:
-      label: Priority
-      description: "Feature priority level"
-      options:
-        - "critical"
-        - "high"
-        - "medium"
-        - "low"
-    validations:
-      required: true
-
-  - type: dropdown
-    id: category
-    attributes:
-      label: Category
-      description: "SPEC category"
-      options:
-        - "API"
-        - "Backend"
-        - "Frontend"
-        - "Infrastructure"
-        - "Security"
-        - "Testing"
-        - "DevOps"
-        - "Documentation"
-        - "Performance"
-        - "Other"
-    validations:
-      required: true
-
-  - type: textarea
-    id: ubiquitous-requirements
-    attributes:
-      label: "Ubiquitous Requirements"
-      description: "Statements that apply universally to the system"
-      placeholder: |
-        - The system must provide JWT-based authentication
-        - The system must support token expiration
-      value: "### Ubiquitous\n"
-    validations:
-      required: true
-
-  - type: textarea
-    id: event-requirements
-    attributes:
-      label: "Event-driven Requirements (WHEN)"
-      description: "Event-triggered requirements in EARS format"
-      placeholder: |
-        - WHEN the user submits login credentials, the system must validate them against the database
-        - WHEN credentials are valid, the system must issue a JWT token with expiration
-      value: "### Event-driven (WHEN)\n"
-    validations:
-      required: false
-
-  - type: textarea
-    id: state-requirements
-    attributes:
-      label: "State-driven Requirements (WHILE)"
-      description: "State-based requirements in EARS format"
-      placeholder: |
-        - WHILE the token is unexpired, the system must allow access to protected resources
-        - WHILE the user is logged in, the system must track the session
-      value: "### State-driven (WHILE)\n"
-    validations:
-      required: false
-
-  - type: textarea
-    id: optional-requirements
-    attributes:
-      label: "Optional Requirements (WHERE)"
-      description: "Optional features and capabilities"
-      placeholder: |
-        - WHERE the user requests token refresh, the system can issue a new token
-        - WHERE OAuth2 is available, the system can support social login
-      value: "### Optional (WHERE)\n"
-    validations:
-      required: false
-
-  - type: textarea
-    id: unwanted-behaviors
-    attributes:
-      label: "Unwanted Behaviors (IF-THEN)"
-      description: "Error handling, quality gates, and business rule enforcement"
-      placeholder: |
-        - IF the token has expired, THEN the system must return 401 Unauthorized
-        - IF the password is incorrect, THEN the system must reject the login attempt
-      value: "### Unwanted Behaviors (IF-THEN)\n"
-    validations:
-      required: false
-
-  - type: textarea
-    id: acceptance-criteria
-    attributes:
-      label: "Acceptance Criteria (Given-When-Then)"
-      description: "At least 2-3 test scenarios"
-      placeholder: |
-        **Scenario 1: Successful Login**
-        - Given a user with valid credentials exists
-        - When the user submits their credentials
-        - Then the system returns a valid JWT token
-
-        **Scenario 2: Token Expiration**
-        - Given a user with an expired token
-        - When the user tries to access a protected resource
-        - Then the system returns a 401 Unauthorized response
-      value: "## Acceptance Criteria\n\n"
-    validations:
-      required: true
-
-  - type: textarea
-    id: dependencies
-    attributes:
-      label: "Dependencies"
-      description: "Related SPECs, tasks, or blockers"
-      placeholder: |
-        - Related: SPEC-SECURITY-001
-        - Blocks: SPEC-API-DESIGN-001
-        - Depends on: SPEC-DATABASE-001
-    validations:
-      required: false
-
-  - type: textarea
-    id: notes
-    attributes:
-      label: "Additional Notes"
-      description: "Technical notes, assumptions, or context"
-      placeholder: |
-        - Consider token refresh token rotation
-        - JWT payload should be minimal for performance
-        - Consider rate limiting on login attempts
-    validations:
-      required: false
-
-  - type: markdown
-    attributes:
-      value: |
-        ## 📚 Reference
-
-        - **SPEC Metadata Guide**: See `.moai/memory/spec-metadata.md`
-        - **EARS Syntax Guide**: See `.moai/memory/development-guide.md`
-        - **Acceptance Criteria**: Use Given-When-Then (Gherkin) format
-        - **@TAG System**: @SPEC, @TEST, @CODE, @DOC traceability

moai_adk/templates/.github/PULL_REQUEST_TEMPLATE.md

@@ -1,69 +0,0 @@
-# MoAI-ADK GitFlow PR
-
-> 🗿 Full GitFlow Transparency — the agent auto-fills information
-
-## 📝 SPEC Info
-
-- Related SPEC: `SPEC-AUTH-001` (e.g., JWT authentication system)
-- Directory: `.moai/specs/SPEC-AUTH-001/`
-- @TAG Links: @SPEC:AUTH-001 @CODE:AUTH-001 (auto-tagging)
-
-## ✅ SPEC Quality Checks
-
-- [ ] YAML Front Matter: 7 required fields (id, version, status, created, updated, author, priority)
-- [ ] HISTORY Section: Record versioned change log (include v0.0.1 INITIAL)
-- [ ] EARS Requirements: Ubiquitous, Event-driven, State-driven, Optional, Unwanted Behaviors
-- [ ] @SPEC:ID TAG: Include TAG in doc and check duplicates (`rg "@SPEC:<ID>" -n`)
-
-## 🤖 Automated Validation Status
-
-<!-- The checklist below is auto-updated by the agent -->
-<!-- /alfred:1-plan → create feature branch → Draft PR -->
-<!-- /alfred:2-run → implement via TDD → auto-check checkboxes -->
-<!-- /alfred:3-sync → synchronize documents → Ready for Review -->
-
-- [ ] spec-builder: Complete EARS spec and create feature branch
-- [ ] code-builder: Finish TDD RED-GREEN-REFACTOR
-- [ ] doc-syncer: Sync Living Documents and mark PR Ready
-
-## 📊 Quality Metrics (auto-calculated)
-
-- TRUST 5 Principles: ✅ Compliant
-- Test Coverage: XX% (target ≥ 85%)
-- @TAG Traceability: 100%
-
-## 🌍 Locale Settings
-
-- Project Language: <!-- ko/en/ja/zh -->
-- Commit Messages: <!-- generated automatically according to locale -->
-
-## 🎯 Changes
-
-<!-- code-builder auto-fills TDD results -->
-
-### 🔴 RED (Test Authoring)
-- Test File: `tests/auth/service.test.ts`
-- Test Description: [describe the failing test]
-
-### 🟢 GREEN (Implementation)
-- Implementation File: `src/auth/service.ts`
-- Implementation Done: [describe functionality]
-
-### ♻️ REFACTOR (Improvements)
-- Refactoring Details: [code quality improvements]
-
-## 📚 Documentation Sync
-
-<!-- auto-filled by doc-syncer -->
-
-- [ ] Update README
-- [ ] Sync API docs
-- [ ] Update TAG index
-- [ ] Update HISTORY section (SPEC docs)
-
----
-
-🚀 MoAI-ADK: Professional development without Git commands via a 3-stage pipeline!
-
-Reviewers: Check TRUST 5 compliance and SPEC metadata completeness only.
-