@tailor-platform/erp-kit 0.0.1 → 0.1.0

package/skills/2-module-feature-breakdown/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: 2-module-feature-breakdown
+description: Use when breaking down a feature spec into model and command documentation. Triggers on feature implementation planning, creating model docs, creating command docs, or when user references model.yml/command.yml schemas.
+---
+
+# Feature Breakdown to Model/Command Docs
+
+Convert feature specifications into structured model and command documentation following framework schemas.
+
+## When to Use
+
+- User has a feature spec (e.g., `docs/features/*.md`) and wants implementation docs
+- User asks to create model or command documentation
+- User references `model.yml` or `command.yml` schemas
+
+## Workflow
+
+```
+ANALYZE → SCAFFOLD → POPULATE → VALIDATE
+```
+
+### 1. Analyze
+
+Read the feature spec and identify:
+
+- **Models**: Entities with state, fields, relationships
+- **Commands**: Operations that change state (look for verbs in state diagrams)
+
+### 2. Scaffold
+
+For each model and command, scaffold the documentation files using `erp-kit` CLI:
+
+```bash
+erp-kit scaffold --modules-root modules model <module-name> <model-name>
+erp-kit scaffold --modules-root modules command <module-name> <command-name>
+```
+
+### 3. Populate
+
+Fill in the scaffolded docs with details analyzed from Step 1.
+
+### 4. Validate
+
+Run `pnpm run module:doc:check` and fix any violations.
+
+## Schema Quick Reference
+
+Schemas are bundled in `@tailor-platform/erp-kit` (model.yml, command.yml).
+
+## Common Patterns
+
+| Feature Element       | Documentation Type               |
+| --------------------- | -------------------------------- |
+| Entity with fields    | Model doc                        |
+| State machine         | Model doc with State Transitions |
+| Verb in state diagram | Command doc                      |
+| CRUD operation        | Command doc                      |
+| Validation logic      | Command doc Business Rules       |
+
+## Validation
+
+Always run before completing:
+
+```bash
+pnpm run module:doc:check
+```

package/skills/3-module-doc-review/SKILL.md

@@ -0,0 +1,230 @@
+---
+name: 3-module-review
+description: Review feature parity between feature documentation and command/model documentation. Use when validating that all feature scenarios are covered by command docs, and that all required models exist.
+---
+
+# Feature Parity Review Workflow
+
+Review **documentation consistency** between feature specs and command/model docs.
+
+## Purpose
+
+Verify that feature documentation (high-level business requirements) is properly covered by command documentation (command specifications) and model documentation (data structures).
+
+```
+Feature Docs (What)  →  Command Docs (How)  →  Model Docs (With What)
+     ↓                        ↓                       ↓
+  Scenarios              Business Rules          Data Structures
+  Process Flows          Error Scenarios         Relationships
+  Test Cases             Process Flows           Constraints
+```
+
+## When to Use
+
+- After writing feature documentation, check for gaps in command/model documentation
+- After writing command/model documentation, verify consistency with features
+- Quality check during documentation review
+
+## Workflow
+
+```
+FEATURE DOCS → COMMAND DOCS → MODEL DOCS → COMPARE → REPORT
+```
+
+## Step-by-Step
+
+### 1. Read Feature Documentation
+
+Read ALL feature docs:
+
+```
+modules/<module-name>/docs/features/*.md
+```
+
+### 2. Read Command Documentation
+
+Read ALL command docs:
+
+```
+modules/<module-name>/docs/commands/*.md
+```
+
+### 3. Read Model Documentation
+
+Read ALL model docs:
+
+```
+modules/<module-name>/docs/models/*.md
+```
+
+### 4. Feature → Command Parity Check
+
+For each feature's scenarios and test cases:
+
+| Check Item             | Question                                                                   |
+| ---------------------- | -------------------------------------------------------------------------- |
+| Command existence      | Does a command doc exist to implement the scenario?                        |
+| Business rule coverage | Are feature test cases covered by command business rules?                  |
+| Error handling         | Are expected error cases from feature included in command error scenarios? |
+| Process flow alignment | Does feature process flow match command process flow?                      |
+
+#### How to Check
+
+1. List all scenario patterns from feature
+2. Identify required operations (verbs) for each scenario: "Add", "Update", "Delete", "Set default", etc.
+3. Verify corresponding command doc exists
+4. Map feature test cases to command business rules / error scenarios
+
+### 5. Feature → Model Parity Check
+
+For each entity mentioned in feature:
+
+| Check Item       | Question                                                           |
+| ---------------- | ------------------------------------------------------------------ |
+| Model existence  | Does a model doc exist for entities mentioned in feature?          |
+| State management | Do feature state transitions match model state transitions?        |
+| Relationships    | Are relationships shown in feature defined in model relationships? |
+
+### 6. Command → Model Consistency Check
+
+For each command doc:
+
+| Check Item                 | Question                                                       |
+| -------------------------- | -------------------------------------------------------------- |
+| Target model               | Does a model doc exist for the model that command operates on? |
+| State transition alignment | Do state changes by command match model state transitions?     |
+
+### 7. Report Findings
+
+```markdown
+## Feature Parity Review Report
+
+**Module:** <module-name>
+
+---
+
+### 1. Feature → Command Coverage
+
+| Feature     | Scenarios   | Required Commands                  | Documented Commands       | Gap                |
+| ----------- | ----------- | ---------------------------------- | ------------------------- | ------------------ |
+| <feature-1> | N scenarios | <cmd-a>, <cmd-b>, <cmd-c>, <cmd-d> | <cmd-a>, <cmd-b>, <cmd-c> | ❌ <cmd-d> missing |
+| <feature-2> | N scenarios | <cmd-e>, <cmd-f>, <cmd-g>          | -                         | ❌ No command docs |
+
+---
+
+### 2. Feature → Model Coverage
+
+| Feature     | Required Models      | Documented Models    | Gap |
+| ----------- | -------------------- | -------------------- | --- |
+| <feature-1> | <Model-A>            | <Model-A>            | ✅  |
+| <feature-2> | <Model-B>, <Model-A> | <Model-B>, <Model-A> | ✅  |
+| <feature-3> | <Model-C>, <Model-A> | <Model-C>, <Model-A> | ✅  |
+
+---
+
+### 3. Test Case → Business Rule Mapping
+
+| Feature     | Test Case                                  | Covered by Command      | Status            |
+| ----------- | ------------------------------------------ | ----------------------- | ----------------- |
+| <feature-1> | "<test case description from feature doc>" | <cmd-a> (business rule) | ✅                |
+| <feature-1> | "<test case description from feature doc>" | <cmd-c> (business rule) | ✅                |
+| <feature-2> | "<test case description from feature doc>" | -                       | ❌ No command doc |
+
+---
+
+### 4. Missing Documentation
+
+#### Missing Command Docs
+
+| Feature     | Expected Command | Purpose               |
+| ----------- | ---------------- | --------------------- |
+| <feature-2> | <cmd-e>          | <purpose description> |
+| <feature-2> | <cmd-f>          | <purpose description> |
+| <feature-2> | <cmd-g>          | <purpose description> |
+
+#### Missing Model Docs
+
+(none found)
+
+---
+
+### 5. Inconsistencies
+
+| Type                      | Location                               | Issue                                                             |
+| ------------------------- | -------------------------------------- | ----------------------------------------------------------------- |
+| State transition mismatch | <feature-1> feature vs <Model-A> model | Feature shows "<cmd-x>" but no command doc exists                 |
+| Missing error scenario    | <feature-2> feature                    | "<error case from test cases>" has no corresponding command error |
+
+---
+
+### 6. Summary
+
+| Aspect                     | Status | Details                                     |
+| -------------------------- | ------ | ------------------------------------------- |
+| Feature → Command Coverage | ⚠️     | X/Y features have complete command coverage |
+| Feature → Model Coverage   | ✅     | All required models documented              |
+| Test Case Coverage         | ⚠️     | X/Y test cases mapped to business rules     |
+| Documentation Consistency  | ⚠️     | N inconsistencies found                     |
+
+### 7. Recommendations
+
+1. **Create missing command docs:**
+   - List all missing commands grouped by feature
+
+2. **Add missing business rules to existing command docs:**
+   - Feature test cases not yet mapped to command business rules
+3. **Resolve inconsistencies:**
+   - Align state transitions between feature and model docs
+```
+
+## Common Gaps
+
+### Feature → Command
+
+- **Orphaned scenarios**: Feature describes operation but no command doc exists
+- **Missing CRUD**: Feature implies create/update/delete but only some are documented
+- **Implicit commands**: Feature scenario requires helper command not documented
+- **Default handling**: Feature mentions "default" selection but no setDefault command
+
+### Feature → Model
+
+- **Missing models**: Feature references entity with no model doc
+- **State mismatch**: Feature shows states not in model's state diagram
+- **Relationship gaps**: Feature implies relationship not in model doc
+
+### Test Case → Business Rule
+
+- **Uncovered test cases**: Feature test case has no corresponding business rule
+- **Missing error scenarios**: Feature error case not in command's error scenarios
+- **Validation gaps**: Feature constraint not enforced by any command
+
+## Quick Reference: Extraction Patterns
+
+### From Feature Docs
+
+```markdown
+## Scenario Patterns
+
+- **Add <entity>**: ... → Command: add<Entity> / create<Entity>
+- **Change default <entity>**: ... → Command: setDefault<Entity>
+
+## Test Cases
+
+- Adding a <entity> with valid data creates it in active status
+  → Business rule in add<Entity>
+- Only one <entity> can be default per <parent> at a time
+  → Business rule in setDefault<Entity>
+```
+
+### Expected Command Docs for Feature
+
+| Feature Operation | Expected Command Doc |
+| ----------------- | -------------------- |
+| "Add X"           | addX / createX       |
+| "Update X"        | updateX              |
+| "Delete X"        | deleteX              |
+| "Set default X"   | setDefaultX          |
+| "Activate X"      | activateX            |
+| "Deactivate X"    | deactivateX          |
+| "Assign X to Y"   | assignXToY           |
+| "Remove X from Y" | removeXFromY         |

package/skills/4-module-tdd-implementation/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: 4-module-tdd-implementation
+description: Use when implementing features in any module under modules/. Triggers on TDD workflow, domain command implementation, adding new database models, creating test fixtures, or implementing business logic commands.
+---
+
+# TDD Implementation for Module Development
+
+Guide for implementing features in modules using Test-Driven Development.
+
+## When to Use
+
+- Implementing new domain commands in any module
+- Adding database models with `@tailor-platform/sdk`
+- Creating tests with `@tailor-platform/erp-kit` testing utilities
+- Implementing business logic (CRUD, state transitions, relationships)
+
+## Workflow
+
+```
+MODELS → ERRORS → FIXTURES → TESTS → IMPLEMENT → EXPORT → VERIFY
+```
+
+## Step-by-Step
+
+### 1. Database Models (`src/db/`)
+
+See: `.agents/rules/module-development/models.md`
+
+### 2. Error Classes (`src/lib/errors.ts`)
+
+See: `.agents/rules/module-development/errors.md`
+
+### 3. Test Fixtures (`src/testing/fixtures.ts`)
+
+See: `.agents/rules/module-development/testing.md`
+
+### 4. Write Tests First (`src/command/*.test.ts`)
+
+See: `.agents/rules/module-development/testing.md`
+
+### 5. Implement Commands (`src/command/*.ts`)
+
+See: `.agents/rules/module-development/commands.md`
+
+### 6. Export (`src/index.ts`)
+
+See: `.agents/rules/module-development/exports.md`
+
+### 7. Verify
+
+```bash
+pnpm generate   # Regenerate types if models changed
+pnpm lint       # Check code style
+pnpm typecheck  # Verify TypeScript types
+pnpm test       # Run all tests
+```