appiq-solution 1.2.0 → 1.3.1

package/SuperClaude/.claude/commands/shared/task-system.yml

@@ -0,0 +1,380 @@
+# Task Management & Todo Integration System
+
+## Legend
+| Symbol | Meaning | | Abbrev | Meaning |
+|--------|---------|---|--------|---------|
+| 📋 | task/project | | req | requirement |
+| ✅ | completed | | impl | implementation |
+| 🔄 | in progress | | ctx | context |
+| ⏸ | paused | | rec | recovery |
+
+## Two-Tier Architecture
+
+```yaml
+Hierarchy:
+  Level_1_Tasks: "High-level features (./claudedocs/tasks/ folders)"
+    Purpose: "Session persistence, git branching, requirement tracking"
+    Scope: "Features spanning multiple sessions"
+    Examples: ["build auth system", "implement dashboard", "create API"]
+    
+  Level_2_Todos: "Immediate actionable steps (TodoWrite/TodoRead)"
+    Purpose: "Context switching, progress tracking, focus management"
+    Scope: "Small chunks within current session"
+    Examples: ["create user model", "add login endpoint", "write tests"]
+
+Integration_Principle:
+  - Tasks provide persistence across sessions
+  - Todos provide focus within sessions
+  - Both work together seamlessly
+  - No duplication, clear boundaries
+  - Automatic synchronization between layers
+```
+
+## Automatic Task Detection
+
+```yaml
+Complexity_Analysis_Engine:
+  Keyword_Extraction:
+    Trigger_Verbs: ["build", "create", "implement", "develop", "design", "add", "integrate"]
+    Scope_Nouns: ["system", "feature", "functionality", "component", "service", "application"]
+    Complexity_Flags: ["authentication", "database", "API", "full-stack", "architecture", "integration"]
+    
+  Scoring_System:
+    Base_Score: 0
+    Trigger_Verb: "+2 points each"
+    Scope_Noun: "+2 points each"
+    Complexity_Flag: "+3 points each"
+    Multi_Step_Indicator: "+3 points"
+    File_Estimate: "files * 1 point"
+    
+  Complexity_Thresholds:
+    Auto_Create_Task: "≥8 points"
+    Brief_Notification: "5-7 points"
+    Proceed_Normal: "<5 points"
+
+Pattern_Detection:
+  High_Complexity_Patterns:
+    - "build a * system"
+    - "create * authentication"
+    - "implement * database"
+    - "develop * application"
+    - "full-stack *"
+    - "end-to-end *"
+    
+  Multi_Session_Indicators:
+    - "complete *", "entire *", "comprehensive *"
+    - Multiple technology mentions
+    - Frontend + backend combination
+    - Database + API requirements
+    - Architecture + implementation scope
+
+Time_Estimation:
+  High_Complexity: ">2 hours, likely multiple sessions"
+  Medium_Complexity: "1-2 hours, possible session break"
+  Low_Complexity: "<1 hour, single session"
+  
+File_Impact_Assessment:
+  High: ">5 estimated files affected"
+  Medium: "3-5 files affected"
+  Low: "1-2 files affected"
+```
+
+## Seamless Auto-Creation Flow
+
+```yaml
+Execution_Process:
+  Silent_Analysis:
+    - Parse requirement in background
+    - Calculate complexity score
+    - Estimate file impact and time
+    - No user interruption during analysis
+    
+  Instant_Decision:
+    Score_8_Plus: "Auto-create immediately, start work"
+    Score_5_7: "Brief notification, then create and proceed"
+    Score_Under_5: "Use TodoWrite only, no task needed"
+    
+  Background_Setup:
+    - Generate unique task ID (YYYYMMDD-HHMMSS format)
+    - Create task file from requirement
+    - Setup git branch (task/{id}-{slug})
+    - Move to in-progress folder
+    - Convert to TodoWrite steps
+    - Begin implementation immediately
+
+User_Notification:
+  High_Complexity: "[Task created: {id}] {brief_description}"
+  Medium_Complexity: "[Multi-step work detected - creating task] {brief_description}"
+  Format: "Single line notification only"
+  Timing: "After creation, before work begins"
+  
+No_Interruption_Policy:
+  - Never ask "should I create a task?"
+  - Never wait for confirmation
+  - Never pause workflow for task setup
+  - Seamless background operation
+  - User only sees brief notification
+```
+
+## Workflow Integration
+
+```yaml
+Complex_Requirement_Flow:
+  1_Auto_Detect: "Complexity ≥8 → create task automatically"
+  2_Breakdown: "Task phases → TodoWrite immediate steps"
+  3_Execute: "Work on todos → update task progress"
+  4_Session_Break: "Preserve both task and todo state"
+  5_Resume: "Restore task context + todos on startup"
+  
+Simple_Requirement_Flow:
+  1_Detect: "Complexity <5 → TodoWrite only"
+  2_Execute: "Work on todos directly"
+  3_Complete: "Mark todos done, no task tracking"
+  
+Medium_Requirement_Flow:
+  1_Detect: "Complexity 5-7 → brief task creation"
+  2_Immediate: "Convert to TodoWrite steps"
+  3_Execute: "Work on todos with light task tracking"
+
+Task_To_Todos_Conversion:
+  When_Task_Starts:
+    - Parse task breakdown sections
+    - Extract actionable steps
+    - Convert to TodoWrite format
+    - Preserve task context and ID linkage
+    
+  Step_Extraction:
+    Analysis_Phase: "→ pending todos"
+    Implementation_Phase: "→ pending todos"
+    Testing_Phase: "→ pending todos"
+    Completion_Phase: "→ pending todos"
+    
+  Todo_Format:
+    id: "Auto-generated unique ID"
+    content: "Actionable step from task"
+    status: "pending"
+    priority: "Inherit from parent task"
+    task_id: "Link back to parent task"
+```
+
+## Task Status Management
+
+```yaml
+Status_Transitions:
+  pending → in_progress: "/task:start {id} + TodoWrite breakdown"
+  in_progress → completed: "All todos complete + /task:complete {id}"
+  in_progress → paused: "/task:pause {id} + preserve todos"
+  any → cancelled: "/task:cancel {id} + clear todos"
+  
+Folder_Mapping:
+  Pending: "./claudedocs/tasks/pending/"
+  In_Progress: "./claudedocs/tasks/in-progress/ + active TodoWrite"
+  Completed: "./claudedocs/tasks/completed/ + archived todos"
+  Cancelled: "./claudedocs/tasks/cancelled/"
+
+Task_File_Structure:
+  Naming: "{type}-{id}-{slug}.md"
+  Types: ["feature", "bugfix", "refactor", "docs", "test"]
+  ID_Format: "YYYYMMDD-HHMMSS"
+  Slug: "kebab-case description"
+  
+Metadata_Required:
+  - id, title, status, priority
+  - created, updated timestamps
+  - git branch information
+  - complexity score
+  - estimated completion time
+  
+Content_Sections:
+  - requirement description
+  - step-by-step breakdown
+  - affected files list
+  - context preservation
+  - checkpoint history
+  - todo integration state
+```
+
+## Context Preservation & Recovery
+
+```yaml
+Session_State_Tracking:
+  Task_Context:
+    - Active task ID and current phase
+    - Architectural decisions made
+    - Git branch and commit info
+    - File paths and key variables
+    
+  Todo_Context:
+    - Current todo list state
+    - In-progress item details
+    - Completed items log
+    - Blocking issues identified
+    
+  Combined_State:
+    - Task progress percentage
+    - Todo completion ratio
+    - Session focus area
+    - Next recommended action
+
+Auto_Save_Triggers:
+  Context_Threshold: ">70% context capacity full"
+  Session_Timeout: ">30min inactive"
+  Error_Recovery: "On significant failures"
+  Manual_Break: "User requests pause/break"
+  
+Recovery_On_Startup:
+  1_Scan_Tasks: "Check ./claudedocs/tasks/in-progress/"
+  2_Restore_Todos: "Rebuild TodoWrite from task state"
+  3_Identify_Focus: "Determine current todo and context"
+  4_Resume_Message: "Resuming {task} - working on {current_todo}"
+
+Context_Corruption_Handling:
+  Task_Exists_No_Todos:
+    - Regenerate todos from task breakdown
+    - Resume from last known position
+    
+  Todos_Exist_No_Task:
+    - Continue with todos only
+    - Warn about missing task context
+    
+  Both_Missing:
+    - Start fresh workflow
+    - No recovery needed
+    
+  Corruption_Recovery:
+    - Fallback to task file data
+    - Regenerate todos if possible
+    - Manual recovery prompts when needed
+```
+
+## Smart Synchronization
+
+```yaml
+Todo_Completion_Updates_Task:
+  On_Todo_Complete:
+    - Calculate overall task progress
+    - Update task file with progress
+    - Move to next logical step
+    - Create checkpoint if milestone reached
+    
+  Progress_Calculation:
+    Total_Steps: "Count all todos derived from task"
+    Completed_Steps: "Count completed todos"
+    Percentage: "completed / total * 100"
+    
+Task_Completion_Clears_Todos:
+  On_Task_Complete:
+    - Mark all remaining todos complete
+    - Clear TodoWrite state
+    - Archive task to completed/ folder
+    - Create final git checkpoint/merge
+    
+Bidirectional_Sync:
+  Todo → Task: "Todo completion updates task progress"
+  Task → Todo: "Task status changes affect todo priorities"
+  Context: "Both systems share context seamlessly"
+```
+
+## Git Integration
+
+```yaml
+Branch_Strategy:
+  Naming: "task/{id}-{slug}"
+  Creation: "Automatic on task start"
+  Protection: "Prevent force push, require PR for completion"
+  
+Commit_Discipline:
+  Format: "[{task_id}] {phase}: {description}"
+  Atomic: "One logical change per commit"
+  Phase_Examples:
+    - "[{id}] Analysis: Requirements documented"
+    - "[{id}] Impl: {component} implemented"
+    - "[{id}] Test: {test_type} tests added"
+    - "[{id}] Complete: Task finished"
+  
+Checkpoints:
+  Automatic:
+    - Phase transitions
+    - Before risky operations
+    - Session timeout (>30min)
+    - Todo milestone completion
+  Manual:
+    - /task:pause command
+    - /user:git --checkpoint
+    
+Cleanup_Workflow:
+  On_Complete:
+    - Squash merge to main
+    - Delete feature branch
+    - Archive task to completed/
+    - Update project documentation
+  Retention:
+    - Keep completed tasks 30 days
+    - Archive older tasks monthly
+    - Prune stale branches weekly
+```
+
+## Command Integration
+
+```yaml
+Task_Commands:
+  create: "/task:create {title} --type {type} --priority {priority}"
+  list: "/task:list --status {status}"
+  start: "/task:start {id}"
+  pause: "/task:pause {id}"
+  complete: "/task:complete {id}"
+  resume: "/task:resume {id}"
+  cancel: "/task:cancel {id}"
+  
+Auto_Detection_Commands:
+  /user:build → "Analyze complexity → create task if needed → proceed"
+  /user:implement → "Always create task → breakdown → execute"
+  /user:create → "Analyze scope → task if multi-step → proceed"
+  
+Plan_Mode_Integration:
+  exit_plan_mode:
+    - Analyze plan complexity automatically
+    - Count steps, files, technologies involved
+    - If complexity ≥8: Create task with plan content
+    - Track plan execution through task system
+    
+Persona_Activation_Triggers:
+  architect: "High complexity system design"
+  frontend: "UI/component development requests"
+  backend: "API/database implementation work"
+  security: "Authentication/authorization features"
+```
+
+## User Experience Examples
+
+```yaml
+Example_1_Complex_Auto_Creation:
+  User_Input: "Build user authentication system"
+  System_Analysis: "Score: 11 (build+system+authentication)"
+  System_Response: "[Task created: auth-20250623-143052] Starting implementation..."
+  Generated_Todos: ["Create user model", "Add registration endpoint", "Implement JWT", "Add tests"]
+  User_Experience: "Seamless transition to implementation with task tracking"
+  
+Example_2_Simple_No_Task:
+  User_Input: "Fix login button styling"
+  System_Analysis: "Score: 2 (low complexity)"
+  System_Response: "No task created"
+  Generated_Todos: ["Update button CSS", "Test responsive design"]
+  User_Experience: "Direct todo completion without task overhead"
+  
+Example_3_Session_Recovery:
+  Before_Break: "Working on 'Add registration endpoint' (todo 2/8)"
+  After_Resume: "Resuming auth system - continuing with registration endpoint"
+  State_Restored: "Task context + todo position + git branch + architectural decisions"
+  User_Experience: "Seamless continuation as if never interrupted"
+  
+Example_4_Medium_Complexity:
+  User_Input: "Create product catalog component"
+  System_Analysis: "Score: 6 (create+component)"
+  System_Response: "[Multi-step work detected - creating task] Product catalog implementation"
+  Generated_Todos: ["Design component interface", "Implement product list", "Add filtering", "Write tests"]
+  User_Experience: "Brief notification, then immediate work start"
+```
+
+---
+*Task System v1.0 - Seamless integration of persistent tasks with dynamic todos for SuperClaude*

package/SuperClaude/.claude/commands/shared/task-ultracompressed.yml

@@ -0,0 +1,88 @@
+# Task UltraCompressed Format Configuration
+
+## Format Rules
+```yaml
+activation:
+  automatic: true for all task operations
+  exceptions: none - always use compressed format
+  
+compression_rules:
+  remove_words:
+    - the, a, an, is, are, was, were
+    - in, on, at, to, for, of, with
+    - that, which, this, these
+  
+  abbreviations:
+    status: S | priority: P | implementation: impl
+    configuration: cfg | documentation: docs
+    authentication: auth | database: db
+    architecture: arch | development: dev
+    production: prod | dependencies: deps
+    
+  symbols:
+    →: leads to / results in
+    &: and / with
+    w/: with / including
+    w/o: without
+    ✓: completed
+    □: pending
+    ⚠: blocked
+    
+structure:
+  title_line: "T: {title}"
+  metadata_line: "ID: {id} | S: {status} | P: {priority}"
+  branch_line: "Branch: {branch}"
+  phases: bullet list with symbols
+  context: key:value pairs
+  progress: percentage and todo count
+```
+
+## Task File Template
+```yaml
+header: |
+  # Legend: → leads to | & and | w/ with | S: status | P: priority | ✓ done | □ pending
+  
+  T: {title}
+  ID: {id} | S: {status} | P: {priority}
+  Branch: {branch}
+
+phases: |
+  ## Phases
+  {phase_list}
+
+context: |
+  ## Context
+  Dec: {decisions}
+  Block: {blockers}
+  Files: {files}
+  Next: {next_step}
+
+progress: |
+  ## Progress
+  Todos: {active}/{total}
+  Complete: {percentage}%
+```
+
+## Conversion Examples
+```yaml
+verbose_to_compressed:
+  before: "Create user authentication system with JWT tokens"
+  after: "T: User auth system w/ JWT"
+  
+  before: "Status: in-progress, Priority: high"
+  after: "S: in-progress | P: high"
+  
+  before: "Implementation phase is currently blocked by CORS configuration"
+  after: "Impl phase blocked: CORS cfg"
+  
+  before: "Decision made: Use PostgreSQL for database"
+  after: "Dec: PostgreSQL for db"
+```
+
+## Benefits
+```yaml
+token_savings: ~70% reduction
+readability: maintained through legend
+consistency: enforced format across all tasks
+scanning: easier to find key information
+```

package/SuperClaude/.claude/commands/shared/templates/feature-template.md

@@ -0,0 +1,59 @@
+# Task: {TASK_NAME}
+
+## Metadata
+```yaml
+id: {TASK_ID}
+title: {TASK_TITLE}
+status: pending
+priority: medium
+created: {TIMESTAMP}
+updated: {TIMESTAMP}
+assignee: Claude
+branch: feature/{TASK_ID}
+```
+
+## Requirement
+{REQUIREMENT_DESCRIPTION}
+
+## Breakdown
+### Analysis Phase
+- [ ] Understand requirements
+- [ ] Identify affected files
+- [ ] Plan architecture changes
+- [ ] Create git branch
+
+### Implementation Phase
+- [ ] {STEP_1}
+- [ ] {STEP_2}
+- [ ] {STEP_3}
+
+### Testing Phase
+- [ ] Write tests
+- [ ] Run test suite
+- [ ] Manual testing
+
+### Completion Phase
+- [ ] Code review
+- [ ] Documentation update
+- [ ] Merge to main
+
+## Files Affected
+```yaml
+new: []
+modified: []
+deleted: []
+```
+
+## Context Preservation
+```yaml
+key_decisions: []
+blockers: []
+notes: []
+session_state: {}
+```
+
+## Checkpoints
+```yaml
+commits: []
+branches: []
+```

package/SuperClaude/.claude/commands/shared/templates/task-ultracompressed.md

@@ -0,0 +1,26 @@
+# Legend: → leads to | & and | w/ with | S: status | P: priority | ✓ done | □ pending
+
+T: {TASK_TITLE}
+ID: {TASK_ID} | S: {STATUS} | P: {PRIORITY}
+Branch: {BRANCH}
+
+## Phases
+□ Analysis: Requirements & design
+□ Impl: Core functionality
+□ Test: Unit & integration
+□ Deploy: Staging & prod
+
+## Context
+Dec: {KEY_DECISIONS}
+Block: {BLOCKERS}
+Files: {AFFECTED_FILES}
+Next: {NEXT_STEP}
+
+## Progress
+Todos: {ACTIVE}/{TOTAL}
+Complete: {PERCENTAGE}%
+Session: {SESSION_TIME}
+
+## Git
+Commits: {COMMIT_COUNT}
+Last: {LAST_COMMIT}

package/SuperClaude/.claude/commands/shared/thinking-modes.yml

@@ -0,0 +1,61 @@
+# Thinking Mode Config
+
+## Thinking Mode Flags
+```yaml
+Command_Flags:
+  --think: "Standard thinking mode - Multi-file analysis (4K tokens)"
+  --think-hard: "Deep analysis mode - Arch level (10K tokens)"
+  --ultrathink: "Critical analysis mode - System redesign (32K tokens)"
+  
+Default_Behavior:
+  No_flag: "Basic mode - Single file, simple tasks"
+  
+Flag_Combinations:
+  With_planning: "--plan --think" # Plan w/ deeper analysis
+  With_other_flags: Compatible w/ all command-specific flags
+  
+Usage_Examples:
+  - /user:analyze --code --think         # Standard code analysis
+  - /user:design --api --think-hard      # Deep architectural design
+  - /user:troubleshoot --ultrathink      # Critical debugging session
+  - /user:improve --perf --think   # Perf analysis w/ context
+```
+
+## Mode Characteristics
+```yaml
+Basic (no flag):
+  Scope: Single file, <10 lines
+  Use_case: Quick fixes, simple edits, direct answers
+  Token_usage: Minimal
+  
+Standard (--think):
+  Scope: Multi-file coordination
+  Use_case: Feature implementation, moderate complexity
+  Token_usage: ~4K tokens
+  
+Deep (--think-hard):  
+  Scope: System architecture, complex patterns
+  Use_case: Design decisions, optimization strategies
+  Token_usage: ~10K tokens
+  
+Critical (--ultrathink):
+  Scope: Complete system analysis
+  Use_case: Redesigns, security audits, critical issues
+  Token_usage: ~32K tokens
+```
+
+## Auto-Activation Rules
+```yaml
+Command_Triggers:
+  design + --api: Suggest --think-hard for architecture
+  troubleshoot + production: Suggest --ultrathink for critical issues
+  analyze + --security: Auto-apply --think for comprehensive review
+  
+Complexity_Detection:
+  Multi-file_reference: Upgrade to --think
+  Architecture_keywords: Suggest --think-hard
+  Critical_terms: Recommend --ultrathink
+```
+
+---
+*Thinking modes: Control analysis depth through command flags*