x-ipe 1.0.23__py3-none-any.whl → 1.0.25__py3-none-any.whl

x_ipe/resources/skills/project-quality-board-management/references/evaluation-principles.md

@@ -0,0 +1,213 @@
+# Evaluation Principles Reference
+
+This document contains all evaluation principles and thresholds used by the project-quality-board-management skill.
+
+---
+
+## Requirements Evaluation Principles
+
+| Principle | Threshold | Description |
+|-----------|-----------|-------------|
+| Completeness | 100% | Every implemented feature must have documented requirements |
+| Traceability | Required | Requirements should trace to features and code |
+| Clarity | No ambiguity | Requirements should be specific and testable |
+| Currency | < 30 days | Requirements updated within 30 days of code changes |
+
+---
+
+## Specification Evaluation Principles
+
+| Principle | Threshold | Description |
+|-----------|-----------|-------------|
+| API Documentation | Required | All public APIs must be documented |
+| Behavior Specification | Required | Expected behaviors clearly defined |
+| Edge Cases | Documented | Error handling and edge cases specified |
+| Version Alignment | Match | Spec version should match implementation version |
+
+---
+
+## Test Coverage Evaluation Principles
+
+| Principle | Threshold | Description |
+|-----------|-----------|-------------|
+| Line Coverage | ≥ 80% | Minimum line coverage for production code |
+| Branch Coverage | ≥ 70% | Minimum branch/decision coverage |
+| Critical Path Coverage | 100% | Core business logic must be fully tested |
+| Error Handler Coverage | ≥ 90% | Exception and error paths tested |
+| Test Isolation | Required | Tests should not depend on external services |
+| Mock External APIs | Required | External API calls must be mocked in tests |
+
+---
+
+## Code Alignment Evaluation Principles
+
+| Principle | Threshold | Description |
+|-----------|-----------|-------------|
+| **File Size** | ≤ 800 lines | Single file should not exceed 800 lines |
+| **Function Size** | ≤ 50 lines | Single function should not exceed 50 lines |
+| **Class Size** | ≤ 500 lines | Single class should not exceed 500 lines |
+| **Cyclomatic Complexity** | ≤ 10 | Function complexity should be manageable |
+| **SRP** | 1 reason to change | Each module/class has one responsibility |
+| **OCP** | Extensible | Open for extension, closed for modification |
+| **LSP** | Substitutable | Subtypes must be substitutable for base types |
+| **ISP** | Focused | Clients shouldn't depend on unused interfaces |
+| **DIP** | Abstracted | Depend on abstractions, not concretions |
+| **DRY** | No duplication | Avoid code duplication across modules |
+| **KISS** | Simple solutions | Prefer simple over complex implementations |
+| **YAGNI** | No unused code | Don't implement features until needed |
+| **Modular Design** | Cohesive modules | Code organized into focused, reusable modules |
+| **Naming Conventions** | Consistent | Follow language-specific naming conventions |
+| **Import Organization** | Grouped | Imports organized by type (stdlib, external, internal) |
+
+---
+
+## Tracing Coverage Principles
+
+| Principle | Threshold | Description |
+|-----------|-----------|-------------|
+| Decorator Coverage | ≥ 90% | Public functions must have @x_ipe_tracing decorator |
+| Sensitive Param Redaction | Required | password, token, secret, key params must use redact=[] |
+| Logging Levels | Correct | API=INFO, Business logic=INFO, Utilities=DEBUG |
+
+---
+
+## Security Evaluation Principles
+
+| Principle | Threshold | Description |
+|-----------|-----------|-------------|
+| Input Validation | Required | All user-facing endpoints must validate input |
+| No Hardcoded Secrets | Required | No secrets, tokens, or credentials in code |
+| Auth/Authz | Required | Protected routes must have proper authentication/authorization |
+| Injection Prevention | Required | SQL injection and XSS prevention measures in place |
+| Sensitive Data Handling | Required | Encryption/hashing for sensitive data |
+
+---
+
+## KISS Principle Assessment
+
+| Check | Threshold | Description |
+|-------|-----------|-------------|
+| Avoid Over-Engineering | No unnecessary abstractions | Don't add layers without clear benefit |
+| Straightforward Logic | Linear flow preferred | Avoid convoluted control flow |
+| Minimal Dependencies | Only necessary imports | Don't import unused libraries |
+| Clear Intent | Self-documenting code | Code should express intent without excessive comments |
+| Simple Data Structures | Use built-in types | Avoid custom types when built-ins suffice |
+
+---
+
+## Modular Design Assessment
+
+| Check | Threshold | Description |
+|-------|-----------|-------------|
+| **Module Cohesion** | High cohesion | Related functions grouped in same module |
+| **Module Coupling** | Loose coupling | Modules minimize dependencies on each other |
+| **Single Entry Point** | One public API | Each module has clear public interface |
+| **Folder Structure** | Logical grouping | Files organized by feature or layer |
+| **Reusability** | Portable modules | Modules can be reused in different contexts |
+| **Testability** | Independently testable | Each module can be tested in isolation |
+
+**Modular Design Patterns:**
+
+| Pattern | When to Apply | Example |
+|---------|---------------|---------|
+| Feature Modules | Large files > 800 lines | Split `app.py` → `routes/api.py`, `routes/views.py` |
+| Service Layer | Business logic mixed with routes | Extract to `services/` folder |
+| Component Split | UI file > 500 lines | Split into sub-components |
+| Utility Extraction | Repeated helper functions | Create `utils/` or `lib/` folder |
+
+---
+
+## Code Smell Detection
+
+| Smell | Detection Rule | Severity |
+|-------|----------------|----------|
+| God Class | Class > 500 lines OR > 20 methods | High |
+| Long Method | Function > 50 lines | Medium |
+| Large File | File > 800 lines | Medium |
+| Deep Nesting | > 4 levels of indentation | Medium |
+| Too Many Parameters | Function > 5 parameters | Low |
+| Magic Numbers | Hardcoded values without constants | Low |
+| Dead Code | Unused functions/variables | Low |
+| Duplicate Code | Similar code blocks > 10 lines | Medium |
+
+---
+
+## Score Calculation
+
+### Dimension Score (1-10 Grid)
+
+Each dimension (Requirements, Specification, Test, Code, Tracing, Security) is scored 1-10 based on:
+
+1. **Principle Violations:** Count violations in that dimension
+2. **Principle Importance:** Weight violations by importance (critical=3, high=2, medium=1, low=0.5)
+
+```
+dimension_score = 10 - SUM(violation_weight * importance_weight)
+dimension_score = MAX(1, MIN(10, dimension_score))  # Clamp to 1-10
+```
+
+**Importance Weights by Principle:**
+
+| Category | Principle | Importance | Weight |
+|----------|-----------|------------|--------|
+| Code | File Size >800 lines | Critical | 3 |
+| Code | Function Size >50 lines | High | 2 |
+| Code | SRP Violation | Critical | 3 |
+| Code | OCP Violation | High | 2 |
+| Code | LSP Violation | Medium | 1 |
+| Code | ISP Violation | Medium | 1 |
+| Code | DIP Violation | High | 2 |
+| Code | DRY Violation | High | 2 |
+| Code | KISS Violation | High | 2 |
+| Code | Modular Design Violation | High | 2 |
+| Test | Line Coverage <80% | High | 2 |
+| Test | No Tests | Critical | 3 |
+| Test | Critical Path Untested | Critical | 3 |
+| Req | Undocumented Feature | Medium | 1 |
+| Req | Unimplemented Requirement | High | 2 |
+| Req | Deviated Implementation | High | 2 |
+| Spec | Missing Specification | Medium | 1 |
+| Spec | Outdated Specification | Medium | 1 |
+| Tracing | Untraced Function | Medium | 1 |
+| Tracing | Unredacted Sensitive Param | High | 2 |
+| Security | Hardcoded Secret | Critical | 3 |
+| Security | Missing Input Validation | High | 2 |
+| Security | Missing Auth/Authz | Critical | 3 |
+
+### Dimension Status from Score
+
+| Score Range | Status | Icon |
+|-------------|--------|------|
+| 8-10 | ✅ aligned | Green |
+| 6-7 | ⚠️ needs_attention | Yellow |
+| 1-5 | ❌ critical | Red |
+| N/A | 📋 planned | Gray |
+
+### Feature Score (1-10)
+
+```
+feature_score = weighted_average(
+  requirements_alignment: weight=0.20,
+  specification_alignment: weight=0.20,
+  test_coverage: weight=0.20,
+  code_alignment: weight=0.20,
+  tracing_coverage: weight=0.10,
+  security: weight=0.10
+)
+```
+
+**Note:** Features with "planned" status are excluded from scoring.
+
+### Overall Score (1-10)
+
+```
+overall_score = average(all feature_scores WHERE status != "planned")
+```
+
+### Health Status
+
+```
+IF overall_score >= 8: healthy
+ELSE IF overall_score >= 5: attention_needed
+ELSE: critical
+```

x_ipe/resources/skills/project-quality-board-management/references/evaluation-procedures.md

@@ -0,0 +1,214 @@
+# Evaluation Procedures Reference
+
+This document contains detailed evaluation procedures for each perspective.
+
+---
+
+## Procedure: Evaluate Requirements Alignment
+
+```
+1. LOCATE requirement docs:
+   - x-ipe-docs/requirements/requirement-summary.md
+   - x-ipe-docs/requirements/requirement-details.md
+   - Any docs referencing feature
+
+2. FOR EACH requirement related to feature:
+   a. CHECK if requirement is documented
+   b. CHECK if requirement is implemented in code
+   c. IDENTIFY deviations between doc and implementation
+
+3. CLASSIFY gaps:
+   - undocumented: Implemented but not in requirements
+   - unimplemented: In requirements but not implemented
+   - deviated: Implementation differs from requirement
+
+4. ASSIGN severity:
+   - high: Core functionality affected
+   - medium: Secondary functionality affected
+   - low: Minor/edge cases
+```
+
+---
+
+## Procedure: Evaluate Specification Alignment
+
+```
+1. LOCATE specification:
+   - x-ipe-docs/requirements/FEATURE-XXX/specification.md
+
+2. IF specification exists:
+   a. EXTRACT expected behaviors
+   b. COMPARE with actual implementation
+   c. IDENTIFY gaps (missing | outdated | incorrect)
+   
+3. IF specification missing (empty feature folder):
+   a. CHECK if any related implementation exists in codebase
+   b. IF no implementation found:
+      - status: planned
+      - NOT a gap - just indicates future work needed
+      - Do NOT count as critical or high priority gap
+   c. IF implementation exists without specification:
+      - status: not_found
+      - Add gap: "Implementation exists but specification missing"
+      - severity: medium (documentation debt)
+```
+
+---
+
+## Procedure: Evaluate Test Coverage
+
+```
+1. IDENTIFY test files for feature:
+   - tests/**/test_*{feature_name}*
+   - tests/**/*{feature_name}*_test.*
+
+2. RUN coverage analysis:
+   - Python: pytest --cov
+   - Node.js: npm test -- --coverage
+   - Go: go test -cover
+
+3. EXTRACT metrics:
+   - Line coverage %
+   - Branch coverage %
+   - Untested functions/areas
+
+4. IDENTIFY critical untested areas:
+   - Business logic paths
+   - Error handlers
+   - Edge cases
+
+5. DETERMINE status:
+   - sufficient: ≥80% line coverage, no critical gaps
+   - insufficient: <80% or has critical gaps
+   - no_tests: No test files found
+```
+
+---
+
+## Procedure: Evaluate Code Alignment
+
+```
+1. LOCATE technical design:
+   - x-ipe-docs/requirements/FEATURE-XXX/technical-design.md
+
+2. IF technical design exists:
+   a. EXTRACT expected:
+      - File structure
+      - Component interfaces
+      - Data models
+   b. COMPARE with actual implementation
+   c. IDENTIFY gaps:
+      - structure: File/folder organization differs
+      - behavior: Logic differs from design
+      - interface: API/interface differs
+
+3. DETERMINE status:
+   - aligned: No significant gaps
+   - drifted: Minor gaps exist
+   - major_drift: Critical gaps exist
+```
+
+---
+
+## Procedure: Evaluate Tracing Coverage
+
+```
+1. SCAN code files for @x_ipe_tracing decorator usage:
+   - grep -r "@x_ipe_tracing" src/
+   - Count decorated vs total public functions
+
+2. FOR EACH file in scope:
+   - List public functions (def/async def at module level, class methods)
+   - Check if decorated with @x_ipe_tracing
+   - Flag missing decorators
+
+3. CHECK sensitive parameter redaction:
+   - Search for password, token, secret, key, auth parameters
+   - Verify redact=[] is specified for these
+
+4. COMPILE tracing_coverage: {
+     status: passed|warning|failed,
+     coverage_percentage: X%,
+     untraced_functions: [],
+     unredacted_params: []
+   }
+```
+
+---
+
+## Procedure: Evaluate Security
+
+```
+1. SCAN for hardcoded secrets:
+   - grep for password=, secret=, token=, api_key=
+   - Check for base64-encoded strings that look like keys
+
+2. CHECK input validation:
+   - Identify user-facing endpoints
+   - Verify input validation exists
+
+3. CHECK authentication/authorization:
+   - Protected routes have auth decorators
+   - Role-based access control where needed
+
+4. CHECK injection prevention:
+   - Parameterized queries (no string concatenation for SQL)
+   - XSS prevention (output encoding)
+
+5. COMPILE security_evaluation: {
+     status: passed|warning|failed,
+     violations: []
+   }
+```
+
+---
+
+## Procedure: Generate Refactoring Suggestions
+
+**Integrates with:** `task-type-refactoring-analysis` skill
+
+```
+1. ANALYZE gaps from all perspectives:
+   - Collect all gaps with severity high/medium
+   - Group gaps by feature
+
+2. FOR EACH feature with gaps:
+   a. IDENTIFY applicable principles:
+      - Large files/classes → SRP, SOLID
+      - Duplicated code → DRY
+      - Complex logic → KISS
+      - Unused code → YAGNI
+      - Mixed concerns → SoC
+   
+   b. FORMULATE goals based on gaps:
+      - requirements gaps → Suggest documentation sync or code alignment
+      - specification gaps → Suggest spec update or implementation fix
+      - test coverage gaps → Suggest test-first approach
+      - code alignment gaps → Suggest structural refactoring
+   
+   c. DEFINE target structure:
+      - Describe desired code organization after fixes
+      - Note key structural changes needed
+   
+   d. IDENTIFY constraints:
+      - Backward compatibility requirements
+      - API stability requirements
+      - Dependencies to preserve
+
+3. COMPILE refactoring_suggestion for feature:
+   summary: "<derived from gap analysis>"
+   goals:
+     - goal: "<specific goal from gap>"
+       priority: <based on gap severity>
+       rationale: "<from gap description>"
+   target_structure: "<desired end state>"
+   
+   principles:
+     primary: [<principles with applications>]
+     secondary: [<supporting principles>]
+     constraints: [<identified constraints>]
+
+4. IF no gaps found for feature:
+   - Set has_suggestions: false for that feature
+   - Skip suggestion generation
+```

x_ipe/resources/skills/project-quality-board-management/templates/quality-report.md

@@ -53,11 +53,15 @@
 
 ### Overview Table
 
-| Feature ID | Feature Name | Status | Score | Req | Spec | Test | Code | Gaps |
-|------------|--------------|--------|-------|-----|------|------|------|------|
-| {feature_id} | {feature_name} | {status_icon} | {score}/10 | {req_icon} | {spec_icon} | {test_icon} | {code_icon} | {gap_count} |
+| Feature ID | Feature Name | Score | Status | Req | Spec | Test | Code | Tracing | Security | Gaps |
+|------------|--------------|-------|--------|-----|------|------|------|---------|----------|------|
+| {feature_id} | {feature_name} | {score}/10 | {status_icon} | {req_score}/10 | {spec_score}/10 | {test_score}/10 | {code_score}/10 | {tracing_score}/10 | {security_score}/10 | {gap_count} |
 
-**Status Icons:** ✅ aligned | ⚠️ needs_attention | ❌ critical | 📋 planned
+**Score-to-Status Mapping:**
+- 8-10: ✅ aligned (green)
+- 6-7: ⚠️ needs_attention (yellow)
+- 1-5: ❌ critical (red)
+- N/A: 📋 planned (gray)
 
 ---
 
@@ -99,6 +103,22 @@
 
 *No violations* (if none)
 
+#### Tracing Coverage Violations
+
+| Violation | Severity | Details |
+|-----------|----------|---------|
+| {violation_type} | {severity} | {details} |
+
+*No violations* (if none)
+
+#### Security Violations
+
+| Violation | Severity | Details |
+|-----------|----------|---------|
+| {violation_type} | {severity} | {details} |
+
+*No violations* (if none)
+
 ---
 
 <!-- Repeat "### {feature_id}" section for each feature with violations -->
@@ -149,9 +169,14 @@
 
 ### Coverage by Feature
 
-| Feature | Requirements | Specification | Test Coverage | Code Alignment | Overall |
-|---------|--------------|---------------|---------------|----------------|---------|
-| {feature_id} | {req_score} | {spec_score} | {test_score} | {code_score} | {overall} |
+| Feature | Requirements | Specification | Test Coverage | Code Alignment | Tracing | Security | Overall |
+|---------|--------------|---------------|---------------|----------------|---------|----------|---------|
+| {feature_id} | {req_score}/10 | {spec_score}/10 | {test_score}/10 | {code_score}/10 | {tracing_score}/10 | {security_score}/10 | {overall}/10 |
+
+**Score-to-Status Mapping:**
+- 8-10: ✅ aligned
+- 6-7: ⚠️ needs_attention
+- 1-5: ❌ critical
 
 ### Gap Distribution by Feature
 
@@ -245,21 +270,48 @@
 | Too Many Parameters | Function > 5 parameters | Low |
 | Duplicate Code | Similar code blocks > 10 lines | Medium |
 
+### Tracing Coverage Evaluation
+
+| Principle | Threshold | Description |
+|-----------|-----------|-------------|
+| Decorator Coverage | ≥ 90% | Public functions must have @x_ipe_tracing decorator |
+| Sensitive Param Redaction | Required | password, token, secret, key params must use redact=[] |
+| Logging Levels | Correct | API=INFO, Business logic=INFO, Utilities=DEBUG |
+
+### Security Evaluation
+
+| Principle | Threshold | Description |
+|-----------|-----------|-------------|
+| Input Validation | Required | All user-facing endpoints must validate input |
+| No Hardcoded Secrets | Required | No secrets, tokens, or credentials in code |
+| Auth/Authz | Required | Protected routes must have proper authentication/authorization |
+| Injection Prevention | Required | SQL injection and XSS prevention measures in place |
+| Sensitive Data Handling | Required | Encryption/hashing for sensitive data |
+
 ---
 
 ## Status Legend
 
-| Status | Description |
-|--------|-------------|
-| aligned | Fully aligned with documentation |
-| planned | Future feature - empty folder with no implementation (not a gap) |
-| needs_update | Minor updates needed |
-| needs_attention | Significant gaps exist |
-| not_found | Documentation missing but implementation exists |
-| critical | Major issues requiring immediate action |
-| sufficient | Test coverage ≥80% |
-| insufficient | Test coverage <80% |
-| no_tests | No tests found |
+| Score Range | Status | Description |
+|-------------|--------|-------------|
+| 8-10 | ✅ aligned | Fully aligned, meets quality standards |
+| 6-7 | ⚠️ needs_attention | Minor gaps exist, should be addressed |
+| 1-5 | ❌ critical | Major issues requiring immediate action |
+| N/A | 📋 planned | Future feature - not yet implemented |
+
+### Dimension Score Calculation
+
+Each dimension (Requirements, Specification, Test, Code, Tracing, Security) is scored 1-10 based on:
+
+```
+dimension_score = 10 - SUM(violation_count × importance_weight)
+```
+
+**Importance Weights:**
+- Critical violations: ×3 (e.g., no tests, hardcoded secrets)
+- High violations: ×2 (e.g., missing coverage, SRP violations)
+- Medium violations: ×1 (e.g., outdated specs, missing docs)
+- Low violations: ×0.5 (e.g., minor style issues)
 
 ## Health Status Definitions
 

x_ipe/resources/skills/task-execution-guideline/SKILL.md

@@ -63,7 +63,7 @@ Task:
 | Task Type | Category |
 |-----------|----------|
 | `task-type-feature-refinement`, `task-type-technical-design`, `task-type-test-generation`, `task-type-code-implementation`, `task-type-feature-acceptance-test`, `task-type-feature-closing` | feature-stage |
-| `task-type-ideation`, `task-type-idea-mockup`, `task-type-idea-to-architecture` | ideation-stage |
+| `x-ipe-task-based-ideation`, `task-type-idea-mockup`, `task-type-idea-to-architecture` | ideation-stage |
 | `task-type-requirement-gathering`, `task-type-feature-breakdown` | requirement-stage |
 | `task-type-bug-fix`, `task-type-change-request`, `task-type-project-init`, `task-type-dev-environment`, `task-type-user-manual`, `task-type-human-playground`, `task-type-share-idea`, `task-type-feature-acceptance-test` | Standalone |
 | `task-type-refactoring-analysis`, `task-type-improve-code-quality-before-refactoring`, `task-type-code-refactor-v2` | code-refactoring-stage |
@@ -351,7 +351,7 @@ ELSE:
 
 | Task Type | Skill | Category | Next Task | Human Review (default) |
 |-----------|-------|----------|-----------|------------------------|
-| Ideation | `task-type-ideation` | ideation-stage | Idea Mockup OR Idea to Architecture | No |
+| Ideation | `x-ipe-task-based-ideation` | ideation-stage | Idea Mockup OR Idea to Architecture | No |
 | Idea Mockup | `task-type-idea-mockup` | ideation-stage | Requirement Gathering | No |
 | Idea to Architecture | `task-type-idea-to-architecture` | ideation-stage | Requirement Gathering | No |
 | Share Idea | `task-type-share-idea` | Standalone | - | Yes |

x_ipe/resources/skills/task-execution-guideline/templates/task-record.yaml

@@ -9,7 +9,7 @@ task_id: TASK-XXX                    # Unique identifier (format: TASK-001, TASK
 task_type: ""                        # From Task Types Registry in SKILL.md
 category: ""                         # Derived from task type:
                                      # - feature-stage (task-type-feature-*, task-type-human-playground, task-type-technical-design)
-                                     # - requirement-stage (task-type-ideation, task-type-requirement-gathering, task-type-feature-breakdown)
+                                     # - requirement-stage (x-ipe-task-based-ideation, task-type-requirement-gathering, task-type-feature-breakdown)
                                      # - Standalone (no category)
 role_assigned: ""                    # Who performs the work (e.g., Nova, Claude, Human)
 status: pending                      # Task status: pending | in_progress | blocked | deferred | completed | cancelled