@uoyo/mvtt 2.0.0-beta.0

package/sources/knowledge/patterns/frontend-react/review-checklist.md

@@ -0,0 +1,78 @@
+# React Code Review Checklist
+
+## Component Structure
+
+- [ ] Component has single responsibility
+- [ ] Component is properly typed (TypeScript)
+- [ ] Props interface is defined and documented
+- [ ] Default values provided where appropriate
+- [ ] Component handles loading states
+- [ ] Component handles error states
+
+## React Best Practices
+
+- [ ] Keys are used correctly in lists (not index)
+- [ ] useEffect dependencies are complete
+- [ ] Cleanup functions provided in effects
+- [ ] State updates are immutable
+- [ ] useCallback/useMemo used appropriately (not prematurely)
+- [ ] No direct DOM manipulation
+
+## Performance
+
+- [ ] No unnecessary re-renders
+- [ ] Large lists are virtualized if needed
+- [ ] Images are optimized
+- [ ] Code splitting applied for large features
+- [ ] Lazy loading used where appropriate
+
+## State Management
+
+- [ ] State is as local as possible
+- [ ] Derived state is computed, not stored
+- [ ] Context is not overused
+- [ ] Server state uses proper solution (React Query/SWR)
+
+## Hooks
+
+- [ ] Custom hooks follow naming convention (use*)
+- [ ] Hooks are at top level of component
+- [ ] Custom hooks return stable references
+- [ ] Hook dependencies are correct
+
+## Accessibility
+
+- [ ] Semantic HTML elements used
+- [ ] ARIA attributes where needed
+- [ ] Focus management considered
+- [ ] Keyboard navigation works
+- [ ] Screen reader tested
+
+## Error Handling
+
+- [ ] Error boundaries used appropriately
+- [ ] API errors are handled
+- [ ] User sees meaningful error messages
+- [ ] Errors are logged appropriately
+
+## Code Quality
+
+- [ ] No console.log in production code
+- [ ] No commented out code
+- [ ] Consistent formatting
+- [ ] Meaningful variable names
+- [ ] No magic numbers/strings
+
+## Testing
+
+- [ ] Critical paths are tested
+- [ ] User interactions tested
+- [ ] Edge cases covered
+- [ ] Accessibility tested
+
+## Security
+
+- [ ] No XSS vulnerabilities (dangerouslySetInnerHTML avoided)
+- [ ] User input is sanitized
+- [ ] Sensitive data not in client bundle
+- [ ] Environment variables used correctly

package/sources/knowledge/patterns/manifest.yaml

@@ -0,0 +1,113 @@
+patterns:
+  id: patterns
+  name: Architecture Patterns
+  version: "1.0"
+  description: Collection of architecture patterns for software design
+
+loading:
+  priority: 2
+  auto_load: false
+  load_rule: "Load patterns/{active}/* based on config.yaml pattern.active"
+
+available:
+  - id: ddd
+    name: Domain-Driven Design
+    path: ddd/
+    manifest: ddd/manifest.yaml
+    description: Tactical and strategic patterns for complex domain modeling
+    suitable_for:
+      - complex-domain
+      - enterprise-application
+      - bounded-contexts
+    files:
+      - tactical-patterns.md
+      - review-checklist.md
+
+  - id: clean-architecture
+    name: Clean Architecture
+    path: clean-architecture/
+    manifest: clean-architecture/manifest.yaml
+    description: Dependency inversion and layer separation patterns
+    suitable_for:
+      - enterprise-application
+      - long-term-project
+      - multi-interface-system
+    files:
+      - review-checklist.md
+
+  - id: frontend-react
+    name: Frontend (React)
+    path: frontend-react/
+    manifest: frontend-react/manifest.yaml
+    description: Modern React frontend application patterns
+    suitable_for:
+      - web-app
+      - spa
+      - pwa
+      - next.js
+    frameworks:
+      - react
+      - next.js
+      - remix
+    files:
+      - overview.md
+      - component-patterns.md
+      - review-checklist.md
+
+# Custom patterns will be added here during #init analyze
+# Example:
+# custom:
+#   - id: my-custom-pattern
+#     name: My Custom Pattern
+#     path: my-custom-pattern/
+#     generated: true
+#     generated_at: "2026-03-08T12:00:00Z"
+
+custom: []
+
+discovery:
+  description: |
+    To discover available patterns:
+    1. List subdirectories of knowledge/patterns/
+    2. Each subdirectory is a pattern pack
+    3. Read {pattern}/manifest.yaml for pattern details
+
+  to_add_pattern: |
+    1. Create knowledge/patterns/{pattern}/ directory
+    2. Add manifest.yaml with pattern metadata
+    3. Add pattern documentation files
+    4. Register in config.yaml under pattern.available
+    5. Add to this file's available or custom list
+
+pattern_selection_guide:
+  description: |
+    During #init, analyze project and suggest appropriate pattern:
+
+  decision_tree: |
+    1. Is this a frontend web application?
+       → If React/Next.js/Remix: suggest frontend-react
+       → If Vue/Svelte: suggest generic (or add more patterns)
+
+    2. Is this a CLI tool, library, or simple service?
+       → Suggest generic
+
+    3. Does the domain have complex business rules?
+       → Suggest DDD
+
+    4. Is this a long-term enterprise application?
+       → Suggest Clean Architecture or DDD
+
+    5. Uncertain or unique architecture?
+       → Offer "analyze" option to create custom pattern
+
+  user_options:
+    - id: yes
+      description: Accept recommended pattern
+    - id: "{pattern_id}"
+      description: Select specific pattern by ID
+    - id: analyze
+      description: Analyze project and create custom pattern
+    - id: generic
+      description: Use generic pattern
+    - id: none
+      description: Proceed without architecture pattern

package/sources/sections/activation-load-config.md

@@ -0,0 +1,5 @@
+### Step 2: Load Config & Apply Preferences (Config Foundation)
+Read `.ai-agents/config.yaml` and enforce the following throughout this entire session:
+- `preferences.language` → Use this language for ALL output (responses, artifact content, comments)
+- `preferences.output.no_emojis` → If true, never use emojis
+- `preferences.output.data_format` → Use this format for data sections in artifacts

package/sources/sections/activation-load-context.md

@@ -0,0 +1,11 @@
+## Activation Protocol
+
+### Step 1: Load Context (Context Foundation)
+Load the following files as foundational context:
+- `.ai-agents/workspace/session.yaml` -- Current workflow state
+- `.ai-agents/workspace/project-context.yaml` -- Project domain data
+
+Extended context for this skill:
+{{#extended_context}}
+- {{.}}
+{{/extended_context}}

package/sources/sections/activation-preflight.md

@@ -0,0 +1,4 @@
+### Step 3: Pre-flight Checks
+{{#checks}}
+{{order}}. If `{{field}}` is empty → {{level}}: "{{message}}"
+{{/checks}}

package/sources/sections/footer-next-steps.md

@@ -0,0 +1,9 @@
+## Suggested Next Steps
+After completion, suggest:
+- `/{{next_primary}}` -- {{next_primary_desc}}
+{{#next_alternatives}}
+- `/{{skill}}` -- {{when}}
+{{/next_alternatives}}
+{{#always_show}}
+- `/{{skill}}` -- {{desc}}
+{{/always_show}}

package/sources/sections/role-header.md

@@ -0,0 +1,13 @@
+## Role
+
+You are the **{{role}}** -- {{role_desc}}.
+
+### Decision Rules
+{{#decision_rules}}
+- {{rule}}
+{{/decision_rules}}
+
+### Boundaries
+{{#boundaries}}
+- Do NOT {{scope}} -> Suggest `{{skill}}`
+{{/boundaries}}

package/sources/skills/mvt-add-context/business.md

@@ -0,0 +1,47 @@
+## Execution Flow
+
+### Step 1: Assess Current State
+- Read project-context.yaml and evaluate completeness:
+  - Project name empty -> Mark as "not initialized"
+  - Requirements empty -> Mark as "no requirements"
+  - Architecture empty -> Mark as "no architecture"
+- Read config.yaml:
+  - Check `pattern.active`
+- Calculate and display context completeness percentage
+
+### Step 2: Guided Information Collection
+Based on what is missing, guide the user through relevant sections:
+
+**If not initialized** (project basics):
+- Project name, type, description
+- Tech stack (language, framework, build tool, test framework)
+- Suggest running `/mvt-init` for automatic detection
+
+**If no requirements** (requirements & background):
+- Main features and goals
+- User roles and use cases
+- Known constraints and limitations
+
+**If no architecture** (architecture info):
+- Architecture pattern (DDD / Clean Architecture / etc.)
+- Module structure
+- Key technical decisions
+
+**Supplementary information** (always available):
+- Project-specific coding standards
+- Team conventions
+- Third-party integration details
+
+### Step 3: Write Context
+Based on information collected:
+1. Update `.ai-agents/workspace/project-context.yaml` (matching fields)
+2. Update `.ai-agents/workspace/session.yaml` (if initialization changed)
+3. If coding standards provided -> Write to `.ai-agents/knowledge/principle/`
+4. If project knowledge provided -> Write to `.ai-agents/knowledge/project/`
+5. Update `config.yaml` `pattern.active` if user confirmed architecture pattern
+
+### Step 4: Verification Report
+- Show updated context summary
+- Display completeness change (before vs after)
+- If context is large -> Suggest running `/mvt-check-context`
+- Suggest next steps

package/sources/skills/mvt-add-context/manifest.yaml

@@ -0,0 +1,83 @@
+name: mvt-add-context
+output: .claude/skills/mvt-add-context/SKILL.md
+
+frontmatter:
+  name: mvt-add-context
+  description: "Interactively add or update project context information to the MVTT workspace. Use when user wants to manually add project details, requirements, architecture info, coding standards, or team conventions."
+
+sections:
+  - type: inline
+    content: |
+      # MVT Context Add
+
+      ## Purpose
+
+      Guide users through adding or updating project context information in the MVTT workspace. This is a user-driven, interactive process complementary to `/mvt-sync-context` (which is code-driven and automatic).
+
+  - type: shared
+    source: sections/role-header.md
+    params:
+      role: Conductor
+      role_desc: "a Workflow Coordinator"
+      decision_rules:
+        - rule: "Project not initialized -> Suggest `/mvt-init` first, but allow manual context entry"
+        - rule: "Missing project basics -> Guide through project info collection"
+        - rule: "Missing requirements -> Guide through requirements entry"
+        - rule: "Missing architecture -> Guide through architecture info"
+        - rule: "User provides coding standards -> Write to knowledge/principle/"
+        - rule: "User provides project knowledge -> Write to knowledge/project/"
+      boundaries:
+        - scope: "analyze code automatically"
+          skill: "/mvt-sync-context or /mvt-analyze-code"
+        - scope: "make architecture decisions"
+          skill: "/mvt-design"
+        - scope: "write implementation code"
+          skill: "/mvt-implement"
+
+  - type: shared
+    source: sections/activation-load-context.md
+
+  - type: shared
+    source: sections/activation-load-config.md
+
+  - type: inline
+    content: |
+      ### Step 3: Pre-flight Checks
+      - No blocking checks required.
+
+      ### Step 4: Execute
+      Proceed to Execution Flow below.
+
+  - type: file
+    source: ./business.md
+
+  - type: inline
+    content: |
+      ## Output Format
+
+      No external template -- output is inline:
+
+      ```markdown
+      ## Context Updated
+
+      ### Completeness
+      - **Before**: {pct_before}%
+      - **After**: {pct_after}%
+
+      ### Changes Made
+      | Section | Status | Details |
+      |---------|--------|---------|
+      | Project Info | {Updated/Unchanged} | {summary} |
+      | Requirements | {Updated/Unchanged} | {summary} |
+      | Architecture | {Updated/Unchanged} | {summary} |
+      | Knowledge | {Updated/Unchanged} | {summary} |
+
+      ### Files Modified
+      - {list of modified files}
+
+      ---
+      **Suggested Next Steps**:
+      - `/mvt-check-context` -- Analyze context load if context is large
+      - `/mvt-analyze` -- Start requirements analysis
+      - `/mvt-status` -- View current project status
+      ```

package/sources/skills/mvt-analyze/business.md

@@ -0,0 +1,33 @@
+## Execution Flow
+
+### Step 1: Load Requirements
+- If file path provided as argument -> Read that file
+- If requirements exist in `.ai-agents/workspace/requirements/` -> List files, ask user to select
+- Otherwise -> Use requirements text from user message
+
+### Step 2: Extract Information
+- Identify features and functionality
+- Identify actors and stakeholders
+- Extract business rules and constraints
+- Note assumptions made
+
+### Step 3: Detect Ambiguities
+- Check for unclear requirements
+- Check for missing information
+- Check for conflicting requirements
+
+### Step 4: Generate Clarification Questions
+- If ambiguities found -> List each with specific question, prioritized by impact
+- If no ambiguities -> Skip this step
+
+### Step 5: Update Workspace
+1. Generate change-id: `{YYYYMMDD}-{slug}` format (e.g., `20260425-user-authentication`)
+2. Update `.ai-agents/workspace/session.yaml`:
+   - Set `active_change.id` and `active_change.title`
+   - Set `active_change.created_at`
+   - Set `progress.analyze: done`
+   - Set `session.last_command: "/mvt-analyze"`
+   - Append one-line summary to `recent_actions` (keep max 3)
+3. Update `.ai-agents/workspace/project-context.yaml`:
+   - Write to `requirements` section (features, actors, business_rules, clarifications)
+4. Write artifact: `.ai-agents/workspace/artifacts/{change-id}/analysis.md`

package/sources/skills/mvt-analyze/manifest.yaml

@@ -0,0 +1,89 @@
+name: mvt-analyze
+output: .claude/skills/mvt-analyze/SKILL.md
+
+frontmatter:
+  name: mvt-analyze
+  description: "Analyze requirements documents and extract domain concepts. Use when user wants to analyze requirements, extract features, or start the analysis phase of development workflow."
+
+sections:
+  - type: inline
+    content: |
+      # MVT Analyze
+
+      ## Purpose
+
+      Analyze requirements and extract domain concepts as the foundation for architecture design and implementation. This is the first phase in the full workflow: analyze -> design -> implement -> review -> test.
+
+  - type: shared
+    source: sections/role-header.md
+    params:
+      role: Analyst
+      role_desc: "a Requirements Analysis Expert"
+      decision_rules:
+        - rule: "Clear requirements -> Proceed with structured analysis"
+        - rule: "Ambiguities found -> Stop and ask clarification first"
+        - rule: "Multiple interpretations -> List all, ask user to choose"
+        - rule: "Conflicts detected -> Highlight explicitly, ask for resolution"
+        - rule: "Vague requirements -> Request specific examples"
+      boundaries:
+        - scope: "make architecture decisions"
+          skill: "/mvt-design"
+        - scope: "recommend technologies"
+          skill: "/mvt-design"
+        - scope: "write implementation code"
+          skill: "/mvt-implement"
+
+  - type: shared
+    source: sections/activation-load-context.md
+    params:
+      extended_context:
+        - ".ai-agents/workspace/requirements/ -- Existing requirements files (if exists)"
+
+  - type: shared
+    source: sections/activation-load-config.md
+
+  - type: shared
+    source: sections/activation-preflight.md
+    params:
+      checks:
+        - order: "1"
+          field: "session.initialized_at"
+          level: "WARN"
+          message: 'Session not initialized. Run `/mvt-init` first.'
+        - order: "2"
+          field: "project.name"
+          level: "WARN"
+          message: 'Project not initialized. Run `/mvt-init` first.'
+        - order: "3"
+          field: "pattern.active"
+          level: "Continue"
+          message: "analysis does not require pattern, but add warning and suggest `/mvt-init`."
+
+  - type: inline
+    content: |
+      ### Step 4: Execute
+      Proceed to Execution Flow below.
+
+  - type: file
+    source: ./business.md
+
+  - type: inline
+    content: |
+      ## Output Format
+
+      Read and use the output template from: `.ai-agents/skills/_templates/analyze-output.md`
+
+      If a custom version exists at `.ai-agents/skills/_templates/custom/analyze-output.md`, use the custom version instead.
+
+      Fill the template placeholders with the analysis results.
+
+      Every response MUST end with a Suggested Next Steps section.
+
+  - type: shared
+    source: sections/footer-next-steps.md
+    params:
+      next_primary: mvt-design
+      next_primary_desc: "Create architecture design based on this analysis"
+      always_show:
+        - skill: mvt-status
+          desc: "Check current workflow progress"

package/sources/skills/mvt-analyze-code/business.md

@@ -0,0 +1,35 @@
+## Execution Flow
+
+### Step 1: Scan Codebase
+- Scan source directories (src/, lib/, app/, etc.)
+- Identify entry points
+- Map module/directory structure
+
+### Step 2: Extract Entities
+- Find domain entities and models
+- Identify value objects
+- Map relationships between entities
+
+### Step 3: Extract Services
+- Find service classes and modules
+- Identify API endpoints
+- Map dependency graph between services
+
+### Step 4: Analyze Architecture
+- Detect architecture pattern (DDD, Clean Architecture, MVC, etc.)
+- Assess confidence level
+- Identify layer boundaries
+
+### Step 5: Infer Requirements
+- Generate feature list from code functionality
+- Identify business rules from logic
+- Document inferred requirements with confidence levels
+
+### Step 6: Update Workspace
+1. Update `.ai-agents/workspace/project-context.yaml`:
+   - Write detected architecture to `architecture` section
+   - Write discovered modules, entities, services
+2. Write artifact: `.ai-agents/workspace/artifacts/code-analysis/{timestamp}-analysis.md`
+3. Update `.ai-agents/workspace/session.yaml`:
+   - Set `session.last_command: "/mvt-analyze-code"`
+   - Append one-line summary to `recent_actions` (keep max 3)

package/sources/skills/mvt-analyze-code/manifest.yaml

@@ -0,0 +1,88 @@
+name: mvt-analyze-code
+output: .claude/skills/mvt-analyze-code/SKILL.md
+
+frontmatter:
+  name: mvt-analyze-code
+  description: "Reverse-analyze existing code to generate context and infer requirements. Use when user wants to understand an existing codebase, generate documentation for legacy code, or onboard to a new project."
+
+sections:
+  - type: inline
+    content: |
+      # MVT Analyze Code
+
+      ## Purpose
+
+      Reverse-analyze existing code to generate context, discover architecture, and infer requirements. Unlike `/mvt-analyze` which works from requirements documents, this skill works from source code. This is an independent operation that does not create a change-id.
+
+  - type: shared
+    source: sections/role-header.md
+    params:
+      role: Analyst
+      role_desc: "a Requirements Analysis Expert"
+      decision_rules:
+        - rule: "Source code exists -> Proceed with codebase scanning"
+        - rule: "No source code found -> Warn user and suggest checking project path"
+        - rule: "Ambiguous architecture -> Present detected pattern with confidence level"
+        - rule: "Multiple frameworks detected -> List all and ask user to confirm primary"
+      boundaries:
+        - scope: "make architecture decisions"
+          skill: "/mvt-design"
+        - scope: "recommend technologies"
+          skill: "/mvt-design"
+        - scope: "write implementation code"
+          skill: "/mvt-implement"
+
+  - type: shared
+    source: sections/activation-load-context.md
+    params:
+      extended_context:
+        - "Scan project source directories for analysis"
+
+  - type: shared
+    source: sections/activation-load-config.md
+
+  - type: shared
+    source: sections/activation-preflight.md
+    params:
+      checks:
+        - order: "1"
+          field: "session.initialized_at"
+          level: "WARN"
+          message: 'Session not initialized. Run `/mvt-init` first.'
+
+  - type: inline
+    content: |
+      ### Independent Operation Rules
+      - This is an independent operation -- no workflow prerequisites required
+      - Does NOT create a change-id
+      - Artifacts stored under `.ai-agents/workspace/artifacts/code-analysis/` instead of a change-id directory
+
+      ### Step 4: Execute
+      Proceed to Execution Flow below.
+
+  - type: file
+    source: ./business.md
+
+  - type: inline
+    content: |
+      ## Output Format
+
+      Read and use the output template from: `.ai-agents/skills/_templates/analyze-code-output.md`
+
+      If a custom version exists at `.ai-agents/skills/_templates/custom/analyze-code-output.md`, use the custom version instead.
+
+      Fill the template placeholders with the analysis results.
+
+      Every response MUST end with a Suggested Next Steps section.
+
+  - type: shared
+    source: sections/footer-next-steps.md
+    params:
+      next_primary: mvt-analyze
+      next_primary_desc: "Add requirements on top of discovered structure"
+      next_alternatives:
+        - skill: mvt-design
+          when: "Design new features for existing architecture"
+      always_show:
+        - skill: mvt-status
+          desc: "Check current project state"

package/sources/skills/mvt-check-context/business.md

@@ -0,0 +1,42 @@
+## Execution Flow
+
+### Step 1: Scan Context Files
+Scan all files that MVTT may load during operation:
+
+**Core files** (always loaded):
+- `.ai-agents/workspace/session.yaml`
+- `.ai-agents/workspace/project-context.yaml`
+- `.ai-agents/config.yaml`
+
+**Knowledge files** (loaded per config):
+- `.ai-agents/knowledge/core/`
+- `.ai-agents/knowledge/patterns/{active}/`
+- `.ai-agents/knowledge/principle/`
+- `.ai-agents/knowledge/project/`
+
+**Artifact files**:
+- `.ai-agents/workspace/artifacts/` (all subdirectories)
+
+**Skill files**:
+- `.claude/skills/mvt-*/SKILL.md` (all skill definitions)
+
+### Step 2: Estimate Token Consumption
+- Calculate approximate tokens for each file: `characters / 4`
+- Group by category:
+  - Core (session + context + config)
+  - Knowledge (knowledge/)
+  - Artifacts (artifacts/)
+  - Skills (skills/)
+- Sum totals per category and overall
+
+### Step 3: Assess and Recommend
+- Determine health status based on total tokens
+- Identify Top 5 largest files
+- Generate optimization recommendations:
+  - Oversized project-context.yaml -> Suggest trimming
+  - Too many old artifacts -> Suggest `/mvt-cleanup`
+  - Unused knowledge files -> Suggest removal or lazy_load
+  - Redundant information -> Suggest consolidation
+- Each recommendation should be specific and actionable
+
+### Step 4: Generate Report