agentic-code 0.5.1

package/.agents/context-maps/task-rule-matrix.yaml

@@ -0,0 +1,248 @@
+# Task-Rule Mapping Matrix
+# Maps tasks to relevant rules based on metadata and tags
+# Used by task-analysis.md to recommend appropriate rules for each task type
+
+rules:
+  # Core Rules
+  core/metacognition:
+    path: ".agents/rules/core/metacognition.md"
+    tags: [self-assessment, reflection, decision-checkpoint, quality-control]
+    when_to_load:
+      - "Task type changes (e.g., from design to implementation)"
+      - "Unexpected errors occur repeatedly"
+      - "Completing a meaningful unit of work"
+      - "Before starting new implementation"
+    typical_tasks: [all]
+    size: small
+    priority: always
+    description: "Self-assessment and reflection protocols for maintaining quality"
+
+  core/ai-development-guide:
+    path: ".agents/rules/core/ai-development-guide.md"
+    tags: [anti-patterns, debugging, best-practices, rule-of-three, technical-debt, impact-analysis, unused-code, code-deletion, implementation-completeness]
+    when_to_load:
+      - "Starting new implementation"
+      - "Code review and refactoring"
+      - "Debugging complex issues"
+      - "Technical decision making"
+      - "Impact analysis before changes"
+    typical_tasks: [implementation, debugging, refactoring]
+    size: medium
+    priority: high
+    description: "Anti-patterns, debugging techniques, development best practices, and implementation completeness assurance"
+
+  core/documentation-criteria:
+    path: ".agents/rules/core/documentation-criteria.md"
+    tags: [documentation, adr, design-doc, decision-matrix, scale-assessment]
+    when_to_load:
+      - "Task scale assessment (Small/Medium/Large)"
+      - "Architecture decisions needed"
+      - "Creating technical documentation"
+      - "New feature planning"
+    typical_tasks: [design, documentation, planning]
+    size: medium
+    priority: medium
+    description: "Criteria for when and how to create documentation"
+
+  core/testing-strategy:
+    path: ".agents/rules/core/testing-strategy.md"
+    tags: [testing, roi-calculation, test-selection, budget-enforcement, behavior-first]
+    when_to_load:
+      - "Generating acceptance tests from design documents"
+      - "Test prioritization and selection"
+      - "ROI-based test strategy decisions"
+      - "Preventing test over-generation"
+    typical_tasks: [test_generation]
+    size: large
+    priority: high
+    description: "ROI-based test selection framework with behavior-first filtering and budget enforcement"
+
+  core/integration-e2e-testing:
+    path: ".agents/rules/core/integration-e2e-testing.md"
+    tags: [testing, integration-test, e2e-test, behavior-first, mock-boundary, test-review]
+    when_to_load:
+      - "Generating integration/E2E test skeletons"
+      - "Implementing integration/E2E tests"
+      - "Reviewing test implementation quality"
+    typical_tasks: [test_generation, test_review]
+    size: small
+    priority: high
+    description: "Integration and E2E test design, implementation rules, and review criteria"
+
+  # Language Rules (currently TypeScript, but concepts are universal)
+  language/rules:
+    path: ".agents/rules/language/rules.md"
+    tags: [implementation, coding-style, type-safety, error-handling, refactoring, clean-code, solid-principles]
+    when_to_load:
+      - "Writing or modifying code"
+      - "Code review"
+      - "Refactoring existing code"
+      - "Implementing new features"
+    typical_tasks: [implementation, refactoring]
+    size: large
+    priority: high
+    description: "Language-specific coding standards and best practices"
+    universal_concepts:
+      - "YAGNI principle"
+      - "DRY principle"
+      - "Error handling patterns"
+      - "Dependency injection"
+      - "Clean code principles"
+      - "Type/static safety (for typed languages)"
+      - "Async/concurrent programming patterns"
+      - "Function composition over classes"
+
+  language/testing:
+    path: ".agents/rules/language/testing.md"
+    tags: [testing, tdd, quality-assurance, coverage, unit-tests, integration-tests, verify-phase, test-skeleton]
+    when_to_load:
+      - "Writing tests"
+      - "Bug fixing (test-first)"
+      - "Quality checks"
+      - "Refactoring (ensuring safety)"
+      - "VERIFY phase execution (mandatory)"
+      - "Test skeleton generation from acceptance criteria"
+    typical_tasks: [implementation, debugging, quality-check, test_generation]
+    size: medium
+    priority: always
+    description: "Testing standards, TDD practices, and mandatory quality checks"
+    universal_concepts:
+      - "Red-Green-Refactor cycle"
+      - "Test independence"
+      - "AAA pattern (Arrange-Act-Assert)"
+      - "Coverage requirements (70%+)"
+      - "Mock/stub patterns"
+      - "Unit vs Integration testing"
+      - "Test-first development"
+
+  contextual/architecture/implementation-approach:
+    path: ".agents/rules/contextual/architecture/implementation-approach.md"
+    tags: [strategy-selection, task-decomposition, verification-levels, integration-points]
+    when_to_load:
+      - "Medium/Large scale tasks (3+ files)"
+      - "Implementation strategy selection"
+      - "Task breakdown and planning"
+      - "Choosing between vertical/horizontal slicing"
+    typical_tasks: [planning, design, implementation]
+    size: medium
+    priority: conditional
+    description: "Strategy selection for implementation approaches (vertical/horizontal slicing)"
+
+
+# Task Type to Rule Mapping
+task_mappings:
+  prd_creation:
+    required:
+      - "core/documentation-criteria"
+    recommended:
+      - "core/metacognition"
+
+  implementation:
+    required:
+      - "language/rules"
+      - "language/testing"  # TDD is mandatory
+      - "core/ai-development-guide"
+    recommended:
+      - "core/metacognition"
+    conditional:
+      - "contextual/architecture/implementation-approach"  # For Medium/Large scale
+
+  debugging:
+    required:
+      - "core/ai-development-guide"
+      - "language/testing"
+    recommended:
+      - "language/rules"
+      - "core/metacognition"
+
+  design:
+    required:
+      - "core/documentation-criteria"
+    conditional:
+      - "contextual/architecture/implementation-approach"  # Required for Medium/Large scale (3+ files)
+
+  documentation:
+    required:
+      - "core/documentation-criteria"
+
+  refactoring:
+    required:
+      - "language/rules"
+      - "language/testing"
+      - "core/ai-development-guide"
+    recommended:
+      - "core/metacognition"
+
+  research:
+    recommended:
+      - "core/metacognition"
+
+  test_generation:
+    required:
+      - "language/testing"  # Test framework patterns and conventions
+      - "core/documentation-criteria"  # Design document analysis
+      - "core/testing-strategy"  # ROI-based test selection
+      - "core/integration-e2e-testing"  # Integration/E2E test design rules
+    recommended:
+      - "core/metacognition"
+
+  integration_test_review:
+    required:
+      - "language/testing"
+      - "core/integration-e2e-testing"
+    recommended:
+      - "core/metacognition"
+    description: "Review integration and E2E test implementations"
+
+  code_review:
+    required:
+      - "language/rules"
+      - "core/ai-development-guide"
+    recommended:
+      - "core/metacognition"
+    description: "Review implementation against Design Doc compliance"
+
+  technical_document_review:
+    required:
+      - "core/documentation-criteria"
+    conditional:
+      - "core/testing-strategy"
+      - "language/rules"
+    recommended:
+      - "core/metacognition"
+    description: "Review technical documents (Design Docs, ADRs)"
+
+# Scale-based Rule Loading
+scale_mappings:
+  small:  # 1-2 files
+    load_immediately:
+      - "language/rules"
+    load_on_demand: []
+
+  medium:  # 3-5 files
+    load_immediately:
+      - "language/rules"
+      - "language/testing"  # TDD is mandatory
+      - "core/documentation-criteria"
+      - "contextual/architecture/implementation-approach"  # Required for approach selection
+    load_on_demand:
+      - "core/ai-development-guide"
+
+  large:  # 6+ files
+    load_immediately:
+      - "core/documentation-criteria"
+      - "contextual/architecture/implementation-approach"
+    load_on_demand:
+      - "language/rules"
+      - "language/testing"
+      - "core/ai-development-guide"
+
+# Metadata for rule selection algorithm
+selection_rules:
+  - "Always load core/metacognition at session start"
+  - "Load language/rules when any code modification is involved"
+  - "Load language/testing for ALL implementation tasks (TDD mandatory)"
+  - "Load implementation-approach for Medium/Large scale (3+ files)"
+  - "Execute ALL quality check commands in VERIFY phase with 0 errors"
+  - "Progressive loading: start with minimum, add as needed"
+  - "Unload task-specific rules after task completion"

package/.agents/rules/contextual/architecture/implementation-approach.md

@@ -0,0 +1,202 @@
+# Implementation Strategy Selection Framework (Meta-cognitive Approach)
+
+An implementation strategy selection framework based on meta-cognitive thinking. Derives optimal implementation approaches through a systematic decision process from understanding existing implementations to constraint compatibility.
+
+## Meta-cognitive Strategy Selection Process
+
+### Step 1: Comprehensive Current State Analysis
+
+**Core Question**: "What does the existing implementation look like?"
+
+#### Analysis Framework
+```yaml
+Architecture Analysis:
+  - Current responsibility separation and improvement potential
+  - Data flow identification and evaluation
+  - Dependency visualization and impact scope
+  - Technical debt quantification
+
+Implementation Quality Assessment:
+  - Code quality and maintainability
+  - Test coverage and reliability
+  - Performance characteristics
+  - Security considerations
+
+Historical Context Understanding:
+  - Why did it become the current form?
+  - Validity check of past decisions
+  - Changes in technical constraints
+  - Evolution of business requirements
+```
+
+#### Meta-cognitive Question List
+- What is the true responsibility of this implementation?
+- Which parts are business essence and which derive from technical constraints?
+- What dependencies or implicit preconditions are unclear from the code?
+- What benefits and constraints does the current design bring?
+
+### Step 2: Strategy Exploration and Creation
+
+**Core Question**: "When determining before → after, what implementation patterns or strategies should be referenced?"
+
+#### Strategy Discovery Process
+```yaml
+Research and Exploration:
+  - Implementation examples and patterns from similar tech stacks (research online)
+  - Approach collection from projects handling similar challenges
+  - Open source implementation references
+  - Technical literature and blog research
+
+Creative Thinking:
+  - Sequential/parallel application of multiple strategies
+  - Design based on project time/human/technical constraints
+  - Phase division and milestone setting
+  - Pre-design of necessary extension points
+```
+
+#### Reference Strategy Patterns (Creative Combinations Encouraged)
+
+**Legacy Handling Strategies**:
+- Strangler Pattern: Gradual migration through phased replacement
+- Facade Pattern: Complexity hiding through unified interface
+- Adapter Pattern: Bridge with existing systems
+
+**New Development Strategies**:
+- Feature-driven Development: Vertical implementation prioritizing user value
+- Foundation-driven Development: Foundation-first construction prioritizing stability
+- Risk-driven Development: Prioritize addressing maximum risk elements
+
+**Integration/Migration Strategies**:
+- Proxy Pattern: Transparent feature extension
+- Decorator Pattern: Phased enhancement of existing features
+- Bridge Pattern: Flexibility through abstraction
+
+**Important**: The optimal solution is discovered through creative thinking according to each project's context.
+
+### Step 3: Risk Assessment and Control
+
+**Core Question**: "What risks arise when applying this to existing implementation, and what's the best way to control them?"
+
+#### Risk Analysis Matrix
+```yaml
+Technical Risks:
+  - Impact on existing systems
+  - Data consistency assurance
+  - Performance degradation possibility
+  - Integration complexity
+
+Operational Risks:
+  - Service availability impact
+  - Deployment downtime
+  - Monitoring/operation process changes
+  - Failure rollback procedures
+
+Project Risks:
+  - Schedule delay possibility
+  - Technology learning costs
+  - Quality requirement achievement
+  - Cross-team coordination complexity
+```
+
+#### Risk Control Strategies
+```yaml
+Preventive Measures:
+  - Phased migration to new system without service disruption
+  - Verification through parallel operation of old and new systems
+  - Addition of integration and regression tests for new features
+  - Pre-implementation setup of performance and error monitoring
+
+Incident Response:
+  - Clarify rollback procedures and conditions to old system
+  - Prepare log analysis and metrics dashboards
+  - Define communication system and role assignments for failures
+  - Document partial service continuation procedures
+```
+
+### Step 4: Constraint Compatibility Verification
+
+**Core Question**: "What are this project's constraints?"
+
+#### Constraint Checklist
+```yaml
+Technical Constraints:
+  - Compatibility with existing libraries/frameworks
+  - Server resource, network, database capacity limits
+  - Mandatory requirements like data protection, access control, audit logging
+  - Numerical targets like response time <5 seconds, 99.9% uptime
+
+Temporal Constraints:
+  - Project deadlines and priorities
+  - Dependencies with other projects
+  - Milestone/release plans
+  - Learning/acquisition period considerations
+
+Resource Constraints:
+  - Team size, new technology learning time, existing skill sets
+  - Developer work hours, server resources, operational system allocation
+  - Project budget ceiling, running cost ceiling
+  - External vendor support deadlines, SLAs, contract terms
+
+Business Constraints:
+  - Market launch timing requirements
+  - Customer impact minimization requirements
+  - Regulatory/industry standard compliance
+```
+
+### Step 5: Implementation Approach Decision
+
+Select optimal solution from basic implementation approaches (creative combinations encouraged):
+
+#### Vertical Slice (Feature-driven)
+**Characteristics**: Vertical implementation across all layers by feature unit
+**Application Conditions**: Low inter-feature dependencies, output in user-usable form, changes needed across all architecture layers
+**Verification Method**: End-user value delivery at each feature completion
+
+#### Horizontal Slice (Foundation-driven)
+**Characteristics**: Phased construction by architecture layer
+**Application Conditions**: Foundation system stability important, multiple features depend on common foundation, layer-by-layer verification effective
+**Verification Method**: Integrated operation verification when all foundation layers complete
+
+#### Hybrid (Creative Combination)
+**Characteristics**: Flexible combination according to project characteristics
+**Application Conditions**: Unclear requirements, need to change approach per phase, transition from prototyping to full implementation
+**Verification Method**: Verify at appropriate L1/L2/L3 levels according to each phase's goals
+
+### Step 6: Decision Rationale Documentation
+
+**Design Doc Documentation**: Clearly specify implementation strategy selection reasons and rationale.
+
+## Verification Level Definitions
+
+Priority for completion verification of each task:
+
+- **L1: Functional Operation Verification** - Operates as end-user feature (e.g., search executable)
+- **L2: Test Operation Verification** - New tests added and passing (e.g., type definition tests)
+- **L3: Build Success Verification** - No compile errors (e.g., interface definitions)
+
+**Priority**: L1 > L2 > L3 in order of verifiability importance
+
+## Integration Point Definitions
+
+Define integration points according to selected strategy:
+- **Strangler-based**: When switching between old and new systems for each feature
+- **Feature-driven**: When users can actually use the feature
+- **Foundation-driven**: When all architecture layers are ready and E2E tests pass
+- **Hybrid**: When individual goals defined for each phase are achieved
+
+## Anti-patterns
+
+- **Pattern Fixation**: Selecting only from listed strategies without considering unique combinations
+- **Insufficient Analysis**: Skipping Step 1 analysis framework before strategy selection
+- **Risk Neglect**: Starting implementation without Step 3 risk analysis matrix
+- **Constraint Ignorance**: Deciding strategy without checking Step 4 constraint checklist
+- **Rationale Omission**: Selecting strategy without using Step 6 documentation template
+
+## Guidelines for Meta-cognitive Execution
+
+1. **Leverage Known Patterns**: Use as starting point, explore creative combinations
+2. **Active Web Research**: Research implementation examples from similar tech stacks
+3. **Apply 5 Whys**: Pursue root causes to grasp essence
+4. **Multi-perspective Evaluation**: Comprehensively evaluate from each Step 1-4 perspective
+5. **Creative Thinking**: Consider sequential application of multiple strategies and designs leveraging project-specific constraints
+6. **Clarify Decision Rationale**: Make strategy selection rationale explicit in design documents