@defai.digital/cli 13.4.3 → 13.4.5

package/bundled/workflows/std/documentation.yaml

@@ -0,0 +1,180 @@
+workflowId: std/documentation
+version: "1.0.0"
+name: Standard Documentation
+description: |
+  Documentation workflow for creating clear, useful documentation.
+  Covers technical docs, API docs, and user guides.
+
+metadata:
+  category: documentation
+  tags:
+    - documentation
+    - writing
+    - technical-writing
+  estimatedDuration: 90000
+
+steps:
+  - stepId: analyze
+    name: Analyze Documentation Needs
+    type: prompt
+    config:
+      prompt: |
+        You are creating documentation. First, understand what needs to be documented.
+
+        ## Subject
+        ${input.targetPath}
+
+        ## Audience
+        ${input.audience}
+
+        ## Documentation Type
+        ${input.docType}
+
+        ## Context
+        ${input.context}
+
+        Analyze:
+
+        1. **Subject Matter**
+           - What is being documented?
+           - Key concepts to explain
+           - Complexity level
+
+        2. **Audience Analysis**
+           - Who will read this?
+           - What do they already know?
+           - What do they need to accomplish?
+
+        3. **Documentation Scope**
+           - What to include
+           - What to exclude
+           - Related documentation to reference
+
+        4. **Existing Documentation**
+           - What already exists?
+           - What needs updating?
+           - Gaps to fill
+
+        5. **Format Requirements**
+           - Markdown/HTML/other
+           - Code examples needed
+           - Diagrams/visuals needed
+    timeoutMs: 45000
+
+  - stepId: outline
+    name: Create Outline
+    type: prompt
+    dependencies:
+      - analyze
+    config:
+      prompt: |
+        Based on your analysis:
+        ${previousOutputs.analyze}
+
+        Create a documentation outline:
+
+        ## Document Structure
+
+        ### Title
+        Clear, descriptive title for the documentation.
+
+        ### Overview
+        - Purpose (1-2 sentences)
+        - Who this is for
+        - Prerequisites
+
+        ### Main Sections
+        1. **[Section 1 Title]**
+           - Key points to cover
+           - Examples needed
+           - Estimated length
+
+        2. **[Section 2 Title]**
+           - Key points to cover
+           - Examples needed
+           - Estimated length
+
+        (Continue for all sections...)
+
+        ### Code Examples
+        List code examples to include:
+        - Example 1: [Description]
+        - Example 2: [Description]
+
+        ### Diagrams/Visuals
+        - Diagram 1: [What it shows]
+        - Screenshot: [What to capture]
+
+        ### Cross-References
+        - Related docs to link
+        - External resources
+
+        ### FAQ/Troubleshooting
+        Common questions or issues to address.
+    timeoutMs: 45000
+
+  - stepId: write
+    name: Write Documentation
+    type: prompt
+    dependencies:
+      - outline
+    config:
+      prompt: |
+        Based on your outline:
+        ${previousOutputs.outline}
+
+        Write the complete documentation:
+
+        Follow these guidelines:
+        - Use clear, concise language
+        - Include practical examples
+        - Use proper formatting (headings, lists, code blocks)
+        - Anticipate reader questions
+        - Provide context before details
+
+        Write the full documentation content following the outline structure.
+        Include all code examples, explanations, and cross-references.
+
+        Make sure to:
+        - Start with the most important information
+        - Use consistent terminology
+        - Include copy-paste ready code
+        - Explain the "why" not just the "what"
+    timeoutMs: 90000
+
+  - stepId: summary
+    name: Create Summary
+    type: prompt
+    dependencies:
+      - write
+    config:
+      prompt: |
+        Provide a summary of the documentation created:
+        ${previousOutputs.write}
+
+        ## Documentation Summary
+        - Document title
+        - Target audience
+        - Main topics covered
+
+        ## Sections Created
+        1. [Section name] - [brief description]
+        2. [Section name] - [brief description]
+
+        ## Code Examples Included
+        - Example 1: [description]
+        - Example 2: [description]
+
+        ## Suggested File Location
+        Where this documentation should be saved.
+
+        ## Related Documentation
+        - Links to add from other docs
+        - Links to add to other docs
+
+        ## Review Checklist
+        - [ ] Technical accuracy
+        - [ ] Code examples tested
+        - [ ] Links verified
+        - [ ] Spelling/grammar checked
+    timeoutMs: 30000

package/bundled/workflows/std/implementation.yaml

@@ -0,0 +1,197 @@
+workflowId: std/implementation
+version: "1.0.0"
+name: Standard Implementation
+description: |
+  Structured workflow for implementing new features or functionality.
+  Covers requirements analysis, design, implementation, and testing.
+
+metadata:
+  category: implementation
+  tags:
+    - implementation
+    - feature
+    - development
+  estimatedDuration: 180000
+
+steps:
+  - stepId: analyze
+    name: Analyze Requirements
+    type: prompt
+    config:
+      prompt: |
+        You are implementing a new feature. First, analyze the requirements thoroughly.
+
+        ## Feature Specification
+        ${input.spec}
+
+        ## Acceptance Criteria
+        ${input.acceptanceCriteria}
+
+        ## Context
+        ${input.context}
+
+        Analyze and clarify:
+
+        1. **Functional Requirements**
+           - What must the feature do?
+           - User stories or use cases
+           - Input/output expectations
+
+        2. **Non-Functional Requirements**
+           - Performance expectations
+           - Security considerations
+           - Scalability needs
+           - Accessibility requirements
+
+        3. **Constraints**
+           - Technical constraints
+           - Time/resource constraints
+           - Dependencies on other features
+
+        4. **Open Questions**
+           - Ambiguities in requirements
+           - Decisions needed
+           - Assumptions being made
+
+        5. **Out of Scope**
+           - What this feature explicitly does NOT include
+           - Future enhancements to consider later
+    timeoutMs: 60000
+
+  - stepId: design
+    name: Design Solution
+    type: prompt
+    dependencies:
+      - analyze
+    config:
+      prompt: |
+        Based on your requirements analysis:
+        ${previousOutputs.analyze}
+
+        Design the implementation:
+
+        ## Architecture Overview
+        High-level description of how the feature fits into the system.
+
+        ## Component Design
+
+        ### New Components
+        For each new component/module:
+        - Name and purpose
+        - Responsibilities
+        - Public interface
+        - Dependencies
+
+        ### Modified Components
+        For each existing component to modify:
+        - What changes needed
+        - Why these changes
+        - Impact on existing functionality
+
+        ## Data Model
+        - New data structures/schemas
+        - Database changes (if any)
+        - Data flow description
+
+        ## API Design (if applicable)
+        - Endpoints/methods
+        - Request/response formats
+        - Error handling
+
+        ## Integration Points
+        - How this connects to existing code
+        - External service integrations
+        - Event/message flows
+
+        ## Design Decisions
+        Key decisions made and alternatives considered.
+    timeoutMs: 90000
+
+  - stepId: implement
+    name: Implementation Plan
+    type: prompt
+    dependencies:
+      - design
+    config:
+      prompt: |
+        Based on your design:
+        ${previousOutputs.design}
+
+        Create an implementation plan:
+
+        ## Implementation Steps
+        Break down into small, mergeable increments:
+
+        ### Phase 1: Foundation
+        - Step 1.1: [Description]
+        - Step 1.2: [Description]
+
+        ### Phase 2: Core Logic
+        - Step 2.1: [Description]
+        - Step 2.2: [Description]
+
+        ### Phase 3: Integration
+        - Step 3.1: [Description]
+        - Step 3.2: [Description]
+
+        ## Code Structure
+        - Files to create
+        - Files to modify
+        - Suggested directory structure
+
+        ## Testing Plan
+        - Unit tests to write
+        - Integration tests needed
+        - Manual testing scenarios
+
+        ## Dependencies
+        - External packages needed
+        - Internal dependencies
+        - Order of implementation
+
+        ## Risk Mitigation
+        - Potential issues and how to address them
+        - Feature flags if needed
+        - Rollback strategy
+    timeoutMs: 60000
+
+  - stepId: summary
+    name: Create Summary
+    type: prompt
+    dependencies:
+      - implement
+    config:
+      prompt: |
+        Summarize the implementation plan:
+        ${previousOutputs.implement}
+
+        ## Feature Summary
+        One paragraph describing the feature and approach.
+
+        ## Deliverables
+        - [ ] Component 1
+        - [ ] Component 2
+        - [ ] Tests
+        - [ ] Documentation
+
+        ## Files to Create/Modify
+        List of files with brief description of changes.
+
+        ## Dependencies
+        - External packages: [list]
+        - Internal modules: [list]
+
+        ## Testing Checklist
+        - [ ] Unit tests for [component]
+        - [ ] Integration test for [flow]
+        - [ ] Manual testing of [scenario]
+
+        ## Definition of Done
+        - [ ] All acceptance criteria met
+        - [ ] Tests passing
+        - [ ] Code reviewed
+        - [ ] Documentation updated
+
+        ## Estimated Effort
+        Simple/Medium/Complex and brief justification.
+    timeoutMs: 30000

package/bundled/workflows/std/refactoring.yaml

@@ -0,0 +1,180 @@
+workflowId: std/refactoring
+version: "1.0.0"
+name: Standard Refactoring
+description: |
+  Systematic refactoring workflow for improving code structure.
+  Focuses on maintainability, readability, and design improvements.
+
+metadata:
+  category: refactoring
+  tags:
+    - refactoring
+    - clean-code
+    - maintenance
+  estimatedDuration: 150000
+
+steps:
+  - stepId: assess
+    name: Assess Current State
+    type: prompt
+    config:
+      prompt: |
+        You are planning a refactoring effort. First, assess the current state of the code.
+
+        ## Target Code/Area
+        ${input.targetPath}
+
+        ## Refactoring Goals
+        ${input.goals}
+
+        ## Context
+        ${input.context}
+
+        Analyze and document:
+
+        1. **Current Code Structure**
+           - How is the code organized?
+           - What patterns/abstractions are used?
+           - What are the main components/modules?
+
+        2. **Code Smells Identified**
+           - Duplication
+           - Long methods/classes
+           - Poor naming
+           - Tight coupling
+           - Missing abstractions
+           - Other issues
+
+        3. **Dependencies**
+           - What does this code depend on?
+           - What depends on this code?
+           - External integrations
+
+        4. **Test Coverage**
+           - Are there existing tests?
+           - What's the coverage level?
+           - Are tests reliable?
+
+        5. **Risk Assessment**
+           - How critical is this code?
+           - What could break?
+           - How easy to rollback?
+    timeoutMs: 60000
+
+  - stepId: plan
+    name: Create Refactoring Plan
+    type: prompt
+    dependencies:
+      - assess
+    config:
+      prompt: |
+        Based on your assessment:
+        ${previousOutputs.assess}
+
+        Create a detailed refactoring plan:
+
+        ## Refactoring Strategy
+        Overall approach and guiding principles for this refactoring.
+
+        ## Changes in Priority Order
+        List each change as a discrete, safe step:
+
+        ### Step 1: [Name]
+        - What: Specific change to make
+        - Why: Benefit of this change
+        - How: Brief implementation approach
+        - Risk: Low/Medium/High
+        - Tests: Tests to add/update
+
+        ### Step 2: [Name]
+        (Continue for each step...)
+
+        ## Suggested Order
+        Why this order? (dependencies, risk mitigation, etc.)
+
+        ## What NOT to Change
+        Areas to leave alone and why.
+
+        ## Success Criteria
+        How do we know the refactoring is successful?
+        - Metrics to track
+        - Quality gates
+    timeoutMs: 90000
+
+  - stepId: implement
+    name: Implementation Guidance
+    type: prompt
+    dependencies:
+      - plan
+    config:
+      prompt: |
+        Based on your refactoring plan:
+        ${previousOutputs.plan}
+
+        Provide specific implementation guidance:
+
+        ## Code Changes
+
+        For each step in the plan, provide:
+
+        ### [Step Name]
+
+        **Before (Current Code Pattern):**
+        Show the problematic pattern to change.
+
+        **After (Refactored Pattern):**
+        Show the improved pattern to implement.
+
+        **Key Points:**
+        - Specific things to watch for
+        - Common mistakes to avoid
+        - Edge cases to handle
+
+        ## Testing Strategy
+        - Tests to write BEFORE refactoring (safety net)
+        - Tests to add AFTER refactoring
+        - How to verify behavior unchanged
+
+        ## Rollback Plan
+        If something goes wrong:
+        - How to detect problems
+        - How to revert safely
+        - Data migration considerations (if any)
+    timeoutMs: 60000
+
+  - stepId: summary
+    name: Create Summary
+    type: prompt
+    dependencies:
+      - implement
+    config:
+      prompt: |
+        Summarize the refactoring plan:
+        ${previousOutputs.implement}
+
+        ## Refactoring Summary
+        One paragraph describing what this refactoring achieves.
+
+        ## Scope
+        - Files to modify: [list]
+        - Estimated changes: [lines/functions/classes]
+
+        ## Key Improvements
+        1. [Improvement 1]
+        2. [Improvement 2]
+        3. [Improvement 3]
+
+        ## Prerequisites
+        - [ ] Existing tests pass
+        - [ ] Code reviewed
+        - [ ] Other prerequisites
+
+        ## Checklist
+        - [ ] Step 1: [name]
+        - [ ] Step 2: [name]
+        - [ ] All tests pass
+        - [ ] Code review complete
+
+        ## Estimated Effort
+        Simple/Medium/Complex and brief justification.
+    timeoutMs: 30000