@kienha/anti-chaotic 1.0.2 → 1.0.5

package/.agent/skills/rules-workflows/references/workflows-guide.md

@@ -8,27 +8,9 @@
 
 ## Workflow File Template
 
-```markdown
----
-description: [Brief description for workflow discovery]
----
-
-# Workflow Title
-
-[Optional overview of what this workflow accomplishes]
-
-## Step 1: [Action Name]
-
-[Detailed instructions for this step]
-
-## Step 2: [Action Name]
+A basic workflow template is available in `../assets/workflow-basic.md`.
 
-[Detailed instructions for this step]
-
-## Step 3: [Action Name]
-
-[Detailed instructions for this step]
-```
+This template serves as a comprehensive guide for structuring workflows, including tool usage, step definitions, and referencing other skills.
 
 ## Calling Other Workflows
 
@@ -46,6 +28,16 @@ After performing a task manually, ask agent to formalize it:
 
 > "Create a workflow from our conversation about deploying to production"
 
+## Workflow Design Principles
+
+When creating new workflows, strictly follow **"Workflow = Process"**:
+
+1.  **Sequence over Standards**: Define _what_ to do and _when_, but delegate _how_ to Skills.
+2.  **Refer to roles**: Use "As [Role]" or "Call [Skill]" instead of hardcoding instructions.
+3.  **Dynamic References**:
+    - ❌ `Ensure indentation is 2 spaces.` (Hardcoded knowledge)
+    - ✅ `Format code according to project standards defined in [frontend-developer] skill.` (Dynamic reference)
+
 ## Best Practices
 
 1. **Clear step names** - Describe the action in step title

package/.agent/skills/skill-creator/SKILL.md

@@ -60,10 +60,24 @@ Markdown instructions for the agent. Keep under **5000 tokens** for optimal cont
 
 Include:
 
-- Step-by-step workflows
+- **Tool Usage Standards**: Standard patterns for using Antigravity tools (`run_command`, `read_file`) within this domain.
+- Step-by-step workflows (Procedures, not Lifecycle Workflows)
 - Code examples
 - Edge cases and troubleshooting
 
+## Skill Design Principles
+
+**Strict Separation of Concerns**:
+
+- **Skill = Knowledge**: Capabilities, Standards, Best Practices, Reference Data.
+- **Workflow = Process**: Steps, Sequences, Lifecycles, Timelines.
+
+> [!WARNING]
+> **Do NOT embed Workflows in Skills.**
+>
+> - ❌ Bad: A `backend-developer` skill defining a "Feature Implementation" lifecycle.
+> - ✅ Good: A `backend-developer` skill defining "API Design Standards" and asking the user to use a generic Workflow to execute it.
+
 ## Progressive Disclosure
 
 Skills use three-level loading to manage context efficiently:
@@ -88,29 +102,12 @@ Skills use three-level loading to manage context efficiently:
 Use available tools to understand the full picture:
 
 1. **Search tools**: Use `search_web`, `read_url_content` to research official documentation
-2. **MCP servers**: Query relevant MCP servers (e.g., `context7` for library docs) if available
-3. **Codebase analysis**: Use `grep_search`, `find_by_name` to understand existing patterns
-
-**Use MCP Sequential Thinking for complex analysis:**
-
-For complex problems, use `mcp_sequential-thinking_sequentialthinking` to:
-
-- Break down problems into reasoning steps
-- Consider multiple angles, revise if needed
-- Generate hypotheses and verify step-by-step
-- Ensure no edge cases are missed
-
-```
-Thought 1: Identify core requirements
-Thought 2: Analyze dependencies
-Thought 3: Consider edge cases
-...
-Final: Synthesize conclusions
-```
+2. **Codebase analysis**: Use `grep_search`, `find_by_name` to understand existing patterns
 
 **Analyze step-by-step:**
 
 - What are the core capabilities needed?
+- **What standard Antigravity tools are most relevant?** (e.g., read_file for docs, run_command for CLI)
 - What are common use cases and edge cases?
 - What scripts or references would be reusable?
 
@@ -196,6 +193,7 @@ Instead of generic "What constraints?", ask specific questions like:
 
 - What is the specific domain? (frontend, backend, devops, AI, etc.)
 - What tech stack or frameworks are involved?
+- **What standard tool patterns apply?** (e.g., File system ops vs Command line ops)
 - What constraints must be followed? (time, resources, team size)
 
 ### Phase 3: Scope (Define Boundaries)

package/.agent/skills/skill-creator/assets/skill-questionnaire.md

@@ -73,6 +73,14 @@
 
 <!-- Options: junior, senior, expert (20+ years) -->
 
+### Design Principle: Separation of Concerns
+
+<!-- Reminder:
+- Skill = Knowledge (Capabilities, Standards, Best Practices)
+- Workflow = Process (Steps, Sequences, Lifecycles)
+Do NOT ask for "Process" definitions here. Focus on "Knowledge".
+-->
+
 ### Which best practices must be followed?
 
 <!-- Example: "Follow Testing Trophy pattern, AAA structure for tests" -->

package/.agent/workflows/docs-from-codebase.md

@@ -0,0 +1,104 @@
+---
+description: Generate comprehensive documentation from existing codebase (Architecture, API, Specs).
+---
+
+# Generate Documentation from Codebase
+
+Automatically generates structured documentation from an existing codebase.
+
+> [!IMPORTANT]
+> **MANDATORY**: Apply `.agent/rules/documentation.md` for all document creation.
+
+---
+
+## MCP Usage Guidelines
+
+| MCP Tool                                     | When to Use                                    |
+| -------------------------------------------- | ---------------------------------------------- |
+| `mcp_sequential-thinking_sequentialthinking` | Analyze complex architecture, design decisions |
+| `mcp_context7_query-docs`                    | Research framework patterns, diagram syntax    |
+
+---
+
+## Step 1: Codebase Discovery
+
+// turbo
+
+> 💡 **MCP**: Use `sequential-thinking` to analyze unfamiliar project structures
+
+1. **Invoke `[lead-architect]` skill** to analyze codebase structure
+2. Identify: tech stack, entry points, API routes, DB schemas
+3. **WAIT** for user to confirm understanding
+
+---
+
+## Step 2: Determine Scope
+
+// turbo
+
+Ask user which documentation to generate:
+
+- System Architecture
+- API Documentation
+- Database Schema
+- Component Reference
+
+**Default**: Generate all if not specified.
+
+---
+
+## Step 3: Generate Architecture Documentation
+
+// turbo
+
+> 💡 **MCP**: Use `sequential-thinking` + `context7` with `/mermaid-js/mermaid` for C4 diagrams
+
+1. **Invoke `[lead-architect]` skill** to create:
+   - System Context (C4 Context Diagram)
+   - Component View (C4 Component Diagram)
+   - Data Flow documentation
+
+---
+
+## Step 4: Generate API Documentation
+
+// turbo
+
+> 💡 **MCP**: Use `context7` for framework-specific API patterns
+
+1. **Invoke `[backend-developer]` skill** to:
+   - Scan and document API routes
+   - Create endpoint specifications
+
+---
+
+## Step 5: Generate Database Schema Documentation
+
+// turbo
+
+> 💡 **MCP**: Use `context7` with `/drizzle-team/*` or `/prisma/*` + `/mermaid-js/mermaid` for ERD
+
+1. **Invoke `[backend-developer]` skill** to:
+   - Document entities and relationships
+   - Generate ERD diagram
+
+---
+
+## Step 6: Finalize
+
+// turbo
+
+1. Create/update MOC files
+2. Validate wiki-links and frontmatter
+3. Present summary and suggest next steps
+
+---
+
+## Quick Reference
+
+| Step | Skill             | Output            |
+| ---- | ----------------- | ----------------- |
+| 1    | lead-architect    | Codebase analysis |
+| 3    | lead-architect    | Architecture docs |
+| 4    | backend-developer | API docs          |
+| 5    | backend-developer | Schema docs       |

package/.agent/workflows/implement-feature.md

@@ -0,0 +1,148 @@
+---
+description: End-to-end feature implementation workflow (Spec → Design → Code → Test → Deploy)
+---
+
+# Feature Implementation Workflow
+
+Orchestrates feature implementation from specification to deployment.
+
+> [!IMPORTANT]
+> **MANDATORY**: Read `.agent/rules/documentation.md` before creating any document.
+
+---
+
+## MCP Usage Guidelines
+
+| MCP Tool                                     | When to Use                                       | Example Query                  |
+| -------------------------------------------- | ------------------------------------------------- | ------------------------------ |
+| `mcp_sequential-thinking_sequentialthinking` | Complex decisions, debugging, architecture design | Break down feature into tasks  |
+| `mcp_context7_resolve-library-id`            | Find library ID before querying docs              | "react hook form"              |
+| `mcp_context7_query-docs`                    | Research library patterns, APIs, best practices   | "How to setup auth in Next.js" |
+
+---
+
+## Step 0: Quick Specification (Optional)
+
+**Skip if**: User Stories or specs already exist in `docs/`.
+
+> 💡 **MCP**: Use `sequential-thinking` to analyze ambiguous requirements
+
+1. **Invoke `[product-manager]` skill** to clarify requirements
+2. Create `feature-spec.md` artifact with: Goal, User, Acceptance Criteria
+3. **WAIT** for user confirmation
+
+---
+
+## Step 1: Locate Existing Artifacts
+
+// turbo
+
+> 💡 **MCP**: Use `context7` to research unfamiliar tech in existing codebase
+
+1. Search `docs/` for related: User Stories, SDD, Designs
+2. **Invoke `[lead-architect]` skill** to identify scope and dependencies
+3. List files to create/modify
+4. **WAIT** for user to confirm scope
+
+---
+
+## Step 2: Implementation Plan
+
+// turbo
+
+> 💡 **MCP**: **MUST** use `sequential-thinking` to break down complex features into atomic tasks
+
+1. **Invoke `[lead-architect]` skill** to create task breakdown
+2. Create `implementation-plan.md` artifact with phased tasks
+3. Save to `docs/050-Tasks/Task-{FeatureName}.md` after approval
+4. **WAIT** for user approval
+
+---
+
+## Step 3: Design Review (If UI Feature)
+
+// turbo
+
+**Skip if**: Feature is purely backend/API.
+
+> 💡 **MCP**: Use `context7` with `/radix-ui/*` or `/shadcn/*` for component patterns
+
+1. Check `docs/040-Design/` for existing designs
+2. **Invoke `[designer]` skill** for new component specifications
+3. **WAIT** for user confirmation
+
+---
+
+## Step 4: Backend Implementation
+
+// turbo
+
+> 💡 **MCP**:
+>
+> - Use `context7` with `/supabase/supabase`, `/prisma/prisma` for DB patterns
+> - Use `sequential-thinking` for complex business logic
+
+1. **Invoke `[backend-developer]` skill** for:
+   - Data models/migrations
+   - API endpoints/server functions
+   - Unit tests (TDD approach)
+2. Run tests and verify
+3. **WAIT** for user checkpoint
+
+---
+
+## Step 5: Frontend Implementation
+
+// turbo
+
+> 💡 **MCP**: Use `context7` with `/vercel/next.js`, `/tanstack/react-query`, `/react-hook-form/*` for patterns
+
+1. **Invoke `[frontend-developer]` skill** for:
+   - Components following design specs
+   - State management
+   - Component tests
+2. **WAIT** for user checkpoint
+
+---
+
+## Step 6: Integration & QA
+
+// turbo
+
+> 💡 **MCP**:
+>
+> - Use `context7` with `/vitest-dev/vitest`, `/playwright/*` for testing patterns
+> - Use `sequential-thinking` to analyze test failures
+
+1. **Invoke `[qa-tester]` skill** for:
+   - E2E test execution
+   - Acceptance criteria verification
+   - Edge case testing
+2. Create `qa-report.md` artifact
+3. **WAIT** for user to confirm ready
+
+---
+
+## Step 7: Finalize
+
+// turbo
+
+1. **Invoke `[lead-architect]` skill** to:
+   - Update MOC files
+   - Move task to `docs/050-Tasks/Completed/`
+   - Update API/changelog if applicable
+2. Present completion summary with next steps
+
+---
+
+## Quick Reference
+
+| Step | Skill              | Output                 |
+| ---- | ------------------ | ---------------------- |
+| 0    | product-manager    | feature-spec.md        |
+| 1-2  | lead-architect     | implementation-plan.md |
+| 3    | designer           | Component specs        |
+| 4    | backend-developer  | API, Models, Tests     |
+| 5    | frontend-developer | Components, Tests      |
+| 6    | qa-tester          | qa-report.md           |
+| 7    | lead-architect     | Updated docs           |