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

x_ipe/resources/skills/x-ipe-skill-creator-v3/references/2. reference-section-order.md

@@ -0,0 +1,127 @@
+# Section Order Reference
+
+BLOCKING: Section order follows agent cognitive flow aligned with Anthropic's Progressive Disclosure principle.
+
+```yaml
+# ═══════════════════════════════════════════════════════════════════════════════
+# UNIVERSAL SECTION ORDER PRINCIPLE (Anthropic Agent Skills Best Practice)
+# ═══════════════════════════════════════════════════════════════════════════════
+#
+# Progressive Disclosure (3 Levels):
+#   Level 1: METADATA   - name + description in frontmatter (~100 tokens)
+#   Level 2: BODY       - Main SKILL.md content (<5000 tokens recommended)
+#   Level 3: RESOURCES  - scripts/, references/, assets/ (loaded on demand)
+#
+# Cognitive Flow for SKILL.md Body:
+#   1. CONTEXT    - What is this? When to use? (Early exit if not applicable)
+#   2. DECISION   - Can I proceed? What inputs needed? (Gate check)
+#   3. ACTION     - How to execute? (Core procedure)
+#   4. VERIFY     - How to confirm success? (Completion criteria)
+#   5. REFERENCE  - Where to find details? (Deep dive on demand)
+#
+# Key Constraints (from agentskills.io spec):
+#   - SKILL.md < 500 lines (move details to references/)
+#   - name: lowercase, hyphens, 1-64 chars
+#   - description: 1-1024 chars, include trigger keywords
+# ═══════════════════════════════════════════════════════════════════════════════
+
+x-ipe-task-based:
+  section_order:
+    # CONTEXT
+    1: Purpose
+    2: Important Notes
+    # DECISION
+    3: Input Parameters
+    4: Definition of Ready (DoR)
+    # ACTION
+    5: Execution Flow Summary (DAG/Sub-agent)
+    6: Execution Procedure (Steps)
+    # VERIFY
+    7: Output Result
+    8: Definition of Done (DoD)
+    # REFERENCE
+    9: Patterns & Anti-Patterns
+    10: Examples
+
+x-ipe-tool:
+  # Utility functions and tool integrations
+  section_order:
+    # CONTEXT
+    1: Purpose
+    2: Important Notes
+    3: About (Domain Concepts)
+    4: When to Use
+    # DECISION
+    5: Input Parameters
+    6: Definition of Ready (DoR)
+    # ACTION
+    7: Operations
+    # VERIFY
+    8: Output Result
+    9: Definition of Done (DoD)
+    # REFERENCE
+    10: Error Handling
+    11: Templates
+    12: Examples
+
+x-ipe-task-category:
+  # Orchestration skill called when all related task-based skills in a category finish
+  section_order:
+    # CONTEXT
+    1: Purpose
+    2: Important Notes
+    3: About (Domain Concepts)
+    4: When to Use
+    # DECISION
+    5: Input Parameters
+    6: Definition of Ready (DoR)
+    # ACTION
+    7: Operations
+    # VERIFY
+    8: Output Result
+    9: Definition of Done (DoD)
+    # REFERENCE
+    10: Error Handling
+    11: Templates
+    12: Examples
+
+x-ipe-workflow-orchestration:
+  section_order:
+    # CONTEXT
+    1: Purpose
+    2: Important Notes
+    # DECISION
+    3: Input Parameters
+    4: Definition of Ready (DoR)
+    # ACTION
+    5: Execution Flow Summary (DAG/Sub-agent)
+    6: Execution Procedure (Steps)
+    # VERIFY
+    7: Output Result
+    8: Definition of Done (DoD)
+    # REFERENCE
+    9: Registry (Task Types / Skill Mapping)
+    10: Error Handling
+    11: Templates
+    12: Examples
+
+x-ipe-meta:
+  # Skills for creating/managing other skills (x-ipe-meta-skill-creator-v3)
+  section_order:
+    # CONTEXT
+    1: Purpose
+    2: About (Domain Concepts)
+    3: Important Notes
+    # DECISION
+    4: Input Parameters
+    5: Definition of Ready (DoR)
+    # ACTION
+    6: Execution Flow Summary (DAG/Sub-agent)
+    7: Execution Procedure (Steps)
+    # VERIFY
+    8: Output Result
+    9: Definition of Done (DoD)
+    # REFERENCE
+    10: Templates
+    11: Examples
+```

x_ipe/resources/skills/x-ipe-skill-creator-v3/references/3. example-step-based-code-review.md

@@ -0,0 +1,84 @@
+# Example: Code Review Procedure (Pattern 1 - Step-Based Workflow)
+
+Demonstrates Pattern 1 (Step-Based Workflow) with distinct constraints, outputs, and success criteria per step.
+
+```xml
+<procedure name="Code Review">
+  <!-- CRITICAL: Both DoR/DoD check elements below are MANDATORY -->
+  <execute_dor_checks_before_starting/>
+  <schedule_dod_checks_with_sub_agent_before_starting/>
+  
+  <step_1>
+    <name>Gather Context</name>
+    <action>
+      1. Read the pull request description
+      2. Identify the feature/bug being addressed
+      3. Review linked issues or requirements
+    </action>
+    <constraints>
+      - BLOCKING: Do not start review without understanding the intent
+      - CRITICAL: Check if there are related PRs that should be reviewed together
+    </constraints>
+    <success_criteria>
+      - Intent of change is understood
+      - Scope of change is identified
+      - Related context is loaded
+    </success_criteria>
+    <output>Review context document with intent + scope</output>
+  </step_1>
+
+  <step_2>
+    <name>Analyze Diff</name>
+    <requires>Review context from step_1</requires>
+    <action>
+      1. Review each changed file
+      2. Check for logic errors, security issues, performance problems
+      3. Verify coding standards compliance
+      4. Check test coverage for changes
+    </action>
+    <constraints>
+      - BLOCKING: Security vulnerabilities must be flagged
+      - CRITICAL: Do not approve if tests are missing for new logic
+      - MANDATORY: Check for breaking changes in public APIs
+    </constraints>
+    <success_criteria>
+      - All files reviewed
+      - Issues categorized by severity
+      - No blocking issues remain unaddressed
+    </success_criteria>
+    <output>List of review comments with severity levels</output>
+  </step_2>
+
+  <step_3>
+    <name>Provide Feedback</name>
+    <requires>Review comments from step_2</requires>
+    <action>
+      1. Group comments by file
+      2. Prioritize blocking issues first
+      3. Suggest specific fixes where possible
+      4. Acknowledge good patterns
+    </action>
+    <constraints>
+      - CRITICAL: Be constructive, not dismissive
+      - MANDATORY: Explain why, not just what
+    </constraints>
+    <success_criteria>
+      - All issues communicated clearly
+      - Actionable suggestions provided
+      - Overall assessment given (approve/request changes)
+    </success_criteria>
+    <output>Review submitted with decision</output>
+  </step_3>
+
+  <sub-agent-planning>
+    <sub_agent_1>
+      <sub_agent_definition>
+        <role>Security Reviewer</role>
+        <prompt>Review the code changes for security vulnerabilities including SQL injection, XSS, authentication bypasses, and data exposure risks. Return list of security issues with severity.</prompt>
+      </sub_agent_definition>
+      <workflow_step_reference>step_2</workflow_step_reference>
+    </sub_agent_1>
+  </sub-agent-planning>
+
+</procedure>
+```

x_ipe/resources/skills/x-ipe-skill-creator-v3/references/4. example-step-based-feature-implementation.md

@@ -0,0 +1,113 @@
+# Example: Feature Implementation Procedure (Pattern 1 - Step-Based Workflow)
+
+Demonstrates Pattern 1 (Step-Based Workflow) for TDD-based feature implementation with sub-agent support.
+
+```xml
+<procedure name="Feature Implementation">
+  <!-- CRITICAL: Both DoR/DoD check elements below are MANDATORY -->
+  <execute_dor_checks_before_starting/>
+  <schedule_dod_checks_with_sub_agent_before_starting/>
+  
+  <step_1>
+    <name>Read Technical Design</name>
+    <action>
+      1. Load technical design document from {feature_folder}/technical-design.md
+      2. Identify components to implement
+      3. Note dependencies and integration points
+    </action>
+    <constraints>
+      - BLOCKING: Do not start coding without reading design
+      - CRITICAL: Verify design is approved (status == approved)
+    </constraints>
+    <success_criteria>
+      - All components identified
+      - Dependencies mapped
+      - Implementation order determined
+    </success_criteria>
+    <output>Implementation plan with component list</output>
+  </step_1>
+
+  <step_2>
+    <name>Write Tests First</name>
+    <requires>Implementation plan from step_1</requires>
+    <action>
+      1. Create test file at tests/test_{feature_name}.py
+      2. Write failing tests for each acceptance criterion
+      3. Run tests to confirm they fail
+    </action>
+    <constraints>
+      - BLOCKING: Tests must fail before implementation
+      - MANDATORY: Cover all acceptance criteria
+      - CRITICAL: Include edge cases
+    </constraints>
+    <success_criteria>
+      - Test file created
+      - All acceptance criteria have tests
+      - Tests run and fail as expected
+    </success_criteria>
+    <output>Test file with failing tests</output>
+  </step_2>
+
+  <step_3>
+    <name>Implement Code</name>
+    <requires>Failing tests from step_2</requires>
+    <action>
+      1. Implement minimum code to pass tests
+      2. Follow KISS/YAGNI principles
+      3. Add inline comments only where necessary
+    </action>
+    <constraints>
+      - BLOCKING: Do not add unrequested features
+      - CRITICAL: Follow existing code patterns
+      - MANDATORY: Handle error cases
+    </constraints>
+    <success_criteria>
+      - All tests pass
+      - No linting errors
+      - Code follows project conventions
+    </success_criteria>
+    <output>Implementation code with passing tests</output>
+  </step_3>
+
+  <step_4>
+    <name>Verify Integration</name>
+    <requires>Implementation from step_3</requires>
+    <action>
+      1. Run full test suite
+      2. Check for regression
+      3. Verify integration with dependent components
+    </action>
+    <constraints>
+      - BLOCKING: Full test suite must pass
+      - CRITICAL: No regression in existing functionality
+    </constraints>
+    <success_criteria>
+      - All tests pass (new + existing)
+      - No console errors or warnings
+      - Feature works end-to-end
+    </success_criteria>
+    <output>Verified implementation ready for review</output>
+  </step_4>
+
+  <sub-agent-planning>
+    <sub_agent_1>
+      <sub_agent_definition>
+        <role>Test Validator</role>
+        <prompt>Review the test file to ensure all acceptance criteria from technical design are covered with appropriate test cases. Check for edge cases and error handling tests. Return coverage report.</prompt>
+      </sub_agent_definition>
+      <workflow_step_reference>step_2</workflow_step_reference>
+    </sub_agent_1>
+    <sub_agent_2>
+      <sub_agent_definition>
+        <role>Code Quality Reviewer</role>
+        <prompt>Review implemented code for adherence to SOLID principles, KISS, YAGNI. Check for code smells, unused code, and verify it follows existing project patterns. Return quality assessment.</prompt>
+      </sub_agent_definition>
+      <workflow_step_reference>step_3</workflow_step_reference>
+      <starting_condition>
+        - "START after sub_agent_1 completes"
+      </starting_condition>
+    </sub_agent_2>
+  </sub-agent-planning>
+
+</procedure>
+```

x_ipe/resources/skills/x-ipe-skill-creator-v3/references/5. example-function-based-validation.md

@@ -0,0 +1,73 @@
+# Example: Validation Utilities (Pattern 2 - Function-Based Workflow)
+
+Demonstrates Pattern 2 (Function-Based Workflow) providing a library of validation functions that callers invoke as needed.
+
+```xml
+<functions>
+  <!-- CRITICAL: Both DoR/DoD check elements below are MANDATORY -->
+  <execute_dor_checks_before_starting/>
+  <schedule_dod_checks_with_sub_agent_before_starting/>
+  
+  <function name="validate_yaml_syntax">
+    <purpose>Check if a YAML file has valid syntax</purpose>
+    <when_to_use>Before processing any YAML configuration or data file</when_to_use>
+    <inputs>
+      - file_path: Path to the YAML file to validate
+    </inputs>
+    <action>
+      1. Read file content
+      2. Parse using YAML parser
+      3. Capture any syntax errors with line numbers
+    </action>
+    <constraints>
+      - BLOCKING: Return error immediately if file not found
+    </constraints>
+    <outputs>
+      - is_valid: boolean indicating syntax validity
+      - errors: list of syntax errors with line numbers (empty if valid)
+    </outputs>
+  </function>
+
+  <function name="validate_schema_compliance">
+    <purpose>Check if data conforms to expected schema structure</purpose>
+    <when_to_use>After syntax validation passes, before using data</when_to_use>
+    <inputs>
+      - data: Parsed data object to validate
+      - schema_path: Path to schema definition file
+    </inputs>
+    <action>
+      1. Load schema definition
+      2. Traverse data structure
+      3. Check each field against schema requirements
+      4. Collect all violations
+    </action>
+    <constraints>
+      - CRITICAL: Check required fields first
+      - MANDATORY: Validate nested structures recursively
+    </constraints>
+    <outputs>
+      - is_compliant: boolean indicating schema compliance
+      - violations: list of schema violations with field paths
+    </outputs>
+  </function>
+
+  <function name="validate_cross_references">
+    <purpose>Verify that references between files are valid</purpose>
+    <when_to_use>When validating documents that reference other documents</when_to_use>
+    <inputs>
+      - source_file: File containing references
+      - reference_pattern: Regex pattern to find references
+    </inputs>
+    <action>
+      1. Extract all references from source file
+      2. For each reference, check if target exists
+      3. Report broken references
+    </action>
+    <outputs>
+      - all_valid: boolean indicating all references valid
+      - broken_refs: list of broken references with locations
+    </outputs>
+  </function>
+
+</functions>
+```

x_ipe/resources/skills/x-ipe-skill-creator-v3/references/6. example-function-based-analysis.md

@@ -0,0 +1,94 @@
+# Example: Code Analysis Toolkit (Pattern 2 - Function-Based Workflow)
+
+Demonstrates Pattern 2 (Function-Based Workflow) providing a toolkit of analysis functions for code inspection.
+
+```xml
+<functions>
+  <!-- CRITICAL: Both DoR/DoD check elements below are MANDATORY -->
+  <execute_dor_checks_before_starting/>
+  <schedule_dod_checks_with_sub_agent_before_starting/>
+  
+  <function name="analyze_dependencies">
+    <purpose>Extract and categorize project dependencies</purpose>
+    <when_to_use>When understanding project structure or checking for outdated packages</when_to_use>
+    <inputs>
+      - project_root: Root directory of the project
+      - package_file: Name of package manifest (e.g., pyproject.toml, package.json)
+    </inputs>
+    <action>
+      1. Locate package manifest file
+      2. Parse dependencies section
+      3. Categorize as direct vs dev dependencies
+      4. Check for version constraints
+    </action>
+    <outputs>
+      - dependencies: list of {name, version, category, constraint_type}
+      - dependency_count: total number of dependencies
+    </outputs>
+  </function>
+
+  <function name="analyze_imports">
+    <purpose>Map import relationships within codebase</purpose>
+    <when_to_use>When understanding module coupling or planning refactoring</when_to_use>
+    <inputs>
+      - source_files: List of source files to analyze
+      - include_stdlib: Whether to include standard library imports
+    </inputs>
+    <action>
+      1. Parse each source file for import statements
+      2. Resolve relative imports to absolute paths
+      3. Build import graph
+      4. Identify circular dependencies
+    </action>
+    <constraints>
+      - CRITICAL: Flag circular dependencies
+    </constraints>
+    <outputs>
+      - import_graph: mapping of file to its imports
+      - circular_deps: list of circular dependency chains
+      - external_deps: list of external package imports
+    </outputs>
+  </function>
+
+  <function name="analyze_complexity">
+    <purpose>Calculate code complexity metrics</purpose>
+    <when_to_use>When evaluating code quality or identifying refactoring candidates</when_to_use>
+    <inputs>
+      - file_path: Source file to analyze
+      - threshold: Complexity threshold for flagging
+    </inputs>
+    <action>
+      1. Parse source file AST
+      2. Calculate cyclomatic complexity per function
+      3. Calculate cognitive complexity per function
+      4. Flag functions exceeding threshold
+    </action>
+    <outputs>
+      - functions: list of {name, cyclomatic, cognitive, loc}
+      - high_complexity: list of functions exceeding threshold
+      - file_average: average complexity across all functions
+    </outputs>
+  </function>
+
+  <function name="analyze_test_coverage">
+    <purpose>Identify untested code paths</purpose>
+    <when_to_use>When improving test coverage or identifying testing gaps</when_to_use>
+    <inputs>
+      - source_dir: Directory containing source code
+      - test_dir: Directory containing test files
+    </inputs>
+    <action>
+      1. Map test files to source files by naming convention
+      2. Parse test files for test functions
+      3. Identify source files without corresponding tests
+      4. Identify public functions without test coverage
+    </action>
+    <outputs>
+      - coverage_map: mapping of source files to test files
+      - untested_files: list of source files without tests
+      - untested_functions: list of public functions without tests
+    </outputs>
+  </function>
+
+</functions>
+```

x_ipe/resources/skills/x-ipe-skill-creator-v3/references/7. example-task-io-code-implementation.md

@@ -0,0 +1,36 @@
+# Example: Task Input/Output (Code Implementation)
+
+Demonstrates Task Input and Task Completion Output patterns for Code Implementation task type.
+
+## Task Input
+
+```yaml
+task_input:
+  task_id: "TASK-042"
+  task_type: "Code Implementation"
+  
+  # Context
+  feature_id: "F-003"
+  feature_folder: "x-ipe-docs/features/F-003-user-auth/"
+  technical_design: "x-ipe-docs/features/F-003-user-auth/technical-design.md"
+  
+  # From previous task (Test Generation)
+  test_file: "tests/test_user_auth.py"
+  acceptance_criteria_count: 5
+```
+
+## Task Completion Output
+
+```yaml
+task_completion_output:
+  category: "feature-stage"
+  status: "completed"
+  next_task_type: "Feature Acceptance Test"
+  require_human_review: "no"
+  task_output_links:
+    - "src/auth/user_auth.py"
+    - "src/auth/validators.py"
+  # Dynamic attributes
+  tests_passed: 12
+  coverage: "87%"
+```

x_ipe/resources/skills/x-ipe-skill-creator-v3/references/8. example-structured-summary.md

@@ -0,0 +1,43 @@
+# Example: Structured Summary
+
+Demonstrates markdown table format for summarizing multiple items with consistent attributes.
+
+## Feature Summary
+
+```markdown
+| Feature ID | Name | Priority | Status |
+|------------|------|----------|--------|
+| F-001 | User Authentication | Must-have | Pending |
+| F-002 | Dashboard | Must-have | In Progress |
+| F-003 | Export Reports | Nice-to-have | Pending |
+```
+
+## Dependency Summary
+
+```markdown
+| Component | Depends On | Type | Risk |
+|-----------|------------|------|------|
+| AuthService | Database | Hard | Low |
+| Dashboard | AuthService, API | Hard | Medium |
+| Reports | Dashboard | Soft | Low |
+```
+
+## Requirement Summary
+
+```markdown
+| Req ID | Description | Priority | Complexity | Status |
+|--------|-------------|----------|------------|--------|
+| R-001 | User login with email/password | Must-have | Medium | Approved |
+| R-002 | Password reset via email | Must-have | Low | Approved |
+| R-003 | OAuth integration | Nice-to-have | High | Pending |
+```
+
+## Test Coverage Summary
+
+```markdown
+| Module | Lines | Covered | Coverage | Status |
+|--------|-------|---------|----------|--------|
+| auth | 245 | 220 | 89.8% | ✅ Pass |
+| api | 180 | 144 | 80.0% | ✅ Pass |
+| utils | 95 | 70 | 73.7% | ⚠️ Below threshold |
+```

x_ipe/resources/skills/x-ipe-skill-creator-v3/references/9. example-dor-dod.md

@@ -0,0 +1,77 @@
+# Example: DoR/DoD (Code Implementation)
+
+Demonstrates Definition of Ready and Definition of Done patterns using XML format.
+
+## Definition of Ready
+
+```xml
+<definition_of_ready>
+  <checkpoint required="true">
+    <name>Technical Design Approved</name>
+    <verification>technical-design.md exists with status: approved</verification>
+  </checkpoint>
+  <checkpoint required="true">
+    <name>Test Cases Generated</name>
+    <verification>Test file exists with failing tests</verification>
+  </checkpoint>
+  <checkpoint required="recommended">
+    <name>Dependencies Available</name>
+    <verification>All referenced components are implemented</verification>
+  </checkpoint>
+</definition_of_ready>
+```
+
+## Definition of Done
+
+```xml
+<definition_of_done>
+  <checkpoint required="true">
+    <name>All Tests Pass</name>
+    <verification>Run test suite, 100% pass rate</verification>
+  </checkpoint>
+  <checkpoint required="true">
+    <name>Code Reviewed</name>
+    <verification>PR approved or self-review documented</verification>
+  </checkpoint>
+  <checkpoint required="true">
+    <name>No Linting Errors</name>
+    <verification>Linter returns 0 errors</verification>
+  </checkpoint>
+</definition_of_done>
+```
+
+---
+
+## Additional Examples
+
+### Feature Refinement DoR/DoD
+
+```xml
+<definition_of_ready>
+  <checkpoint required="true">
+    <name>Feature exists on board</name>
+    <verification>Feature ID found in feature-board.md</verification>
+  </checkpoint>
+  <checkpoint required="true">
+    <name>Requirement summary available</name>
+    <verification>requirement-summary.md exists in requirement folder</verification>
+  </checkpoint>
+</definition_of_ready>
+```
+
+```xml
+<definition_of_done>
+  <checkpoint required="true">
+    <name>Specification document created</name>
+    <verification>feature-specification.md exists in feature folder</verification>
+  </checkpoint>
+  <checkpoint required="true">
+    <name>Acceptance criteria defined</name>
+    <verification>At least 2 acceptance criteria per feature</verification>
+  </checkpoint>
+  <checkpoint required="true">
+    <name>Human review complete</name>
+    <verification>User approved specification</verification>
+  </checkpoint>
+</definition_of_done>
+```