From 7413eb631c47d58929a609de81e9f5aa3766ff36 Mon Sep 17 00:00:00 2001 From: NomenAK <39598727+NomenAK@users.noreply.github.com> Date: Tue, 24 Jun 2025 11:29:02 +0200 Subject: [PATCH] Enhanced Task Management System - Adaptation of PR #5 (#7) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Add comprehensive task management system with hybrid todo integration - Automatic task detection based on complexity scoring (8+ points) - Seamless .tasks/ folder structure (pending/in-progress/completed) - Two-tier architecture: Tasks for persistence, TodoWrite for focus - Auto-conversion of task breakdowns to TodoWrite steps - Session recovery with context preservation - Git integration with automatic branching - Zero-interruption workflow for complex requirements 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude * Enhance task management system with SuperClaude integration - Update all .tasks/ paths to ./claudedocs/tasks/ for consistency - Add plan mode integration for intelligent task suggestions - Implement UltraCompressed format (~70% token reduction) - Enhance git workflow with clean branch strategy and atomic commits - Add task-ultracompressed.yml configuration - Update install.sh to reflect new file counts - Integrate with exit_plan_mode for complex work detection This adapts PR #5's excellent task tracking functionality to fit SuperClaude's architecture while adding valuable enhancements. --------- Co-authored-by: Mohammad Aziz Co-authored-by: Claude --- .claude/commands/shared/auto-task-trigger.yml | 127 +++++++++++ .claude/commands/shared/session-recovery.yml | 144 ++++++++++++ .claude/commands/shared/task-management.yml | 205 ++++++++++++++++++ .../commands/shared/task-ultracompressed.yml | 88 ++++++++ .../shared/templates/feature-template.md | 59 +++++ .../shared/templates/task-ultracompressed.md | 26 +++ .../commands/shared/todo-task-integration.yml | 153 +++++++++++++ .claude/commands/task.md | 110 ++++++++++ .gitignore | 3 + CLAUDE.md | 13 +- install.sh | 6 +- 11 files changed, 930 insertions(+), 4 deletions(-) create mode 100644 .claude/commands/shared/auto-task-trigger.yml create mode 100644 .claude/commands/shared/session-recovery.yml create mode 100644 .claude/commands/shared/task-management.yml create mode 100644 .claude/commands/shared/task-ultracompressed.yml create mode 100644 .claude/commands/shared/templates/feature-template.md create mode 100644 .claude/commands/shared/templates/task-ultracompressed.md create mode 100644 .claude/commands/shared/todo-task-integration.yml create mode 100644 .claude/commands/task.md diff --git a/.claude/commands/shared/auto-task-trigger.yml b/.claude/commands/shared/auto-task-trigger.yml new file mode 100644 index 0000000..b2fe487 --- /dev/null +++ b/.claude/commands/shared/auto-task-trigger.yml @@ -0,0 +1,127 @@ +# auto-task-trigger.yml - Seamless Automatic Task Mode + +## Complexity Analysis Engine +```yaml +requirement_parser: + extract_keywords: + 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 + scope_noun: +2 points + complexity_flag: +3 points + multi_step_indicator: +3 points + file_estimate: files * 1 point + + thresholds: + auto_create: ≥8 points + suggest_create: 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 *" + - mentions of multiple technologies + - frontend + backend mentions + - database + API mentions +``` + +## Seamless Auto-Creation +```yaml +execution_flow: + 1_silent_analysis: + - parse requirement in background + - calculate complexity score + - no user interruption + + 2_instant_decision: + score ≥8: auto_create_immediately + score 5-7: brief_notification_then_create + score <5: proceed_without_task + + 3_background_setup: + - generate task ID + - create task file + - setup git branch + - move to in-progress + - begin implementation + +user_notification: + high_complexity: "[Task created: {id}] {brief_description}" + medium_complexity: "[Multi-step work detected - creating task] {brief_description}" + format: single_line_notification + timing: after_creation_before_work + +no_interruption_policy: + - never ask "should I create a task?" + - never wait for confirmation + - never pause workflow + - seamless background operation +``` + +## Context Preservation +```yaml +auto_save_triggers: + context_threshold: >70% full + session_timeout: >30min inactive + error_recovery: on failures + manual_break: user requests pause + +seamless_recovery: + startup_scan: check ./claudedocs/tasks/in-progress/ + auto_resume: highest priority active task + context_restore: previous session state + notification: "Resuming: {task_title}" + +session_continuity: + preserve_state: file paths, variables, decisions + track_progress: completed steps, current focus + handle_blockers: previous issues & solutions + maintain_context: architectural decisions +``` + +## Integration Patterns +```yaml +command_integration: + /user:build → auto-detect 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 + - count steps, files, technologies + - if complexity ≥8: "Create task to track this plan? (y/n)" + - if yes: create task with plan content + - track plan execution through task + + planning_triggers: + - --plan flag detected + - risky operations (deploy, migrate) + - multi-phase work identified + - cross-cutting concerns + +persona_activation: + architect: high complexity systems + frontend: UI/component requests + backend: API/database work + security: authentication/authorization + +workflow_chains: + detect → create → breakdown → branch → implement → test → complete + requirement → task → steps → code → validation → merge + plan → analyze → suggest task → create → track → complete +``` \ No newline at end of file diff --git a/.claude/commands/shared/session-recovery.yml b/.claude/commands/shared/session-recovery.yml new file mode 100644 index 0000000..6651b2a --- /dev/null +++ b/.claude/commands/shared/session-recovery.yml @@ -0,0 +1,144 @@ +# session-recovery.yml - Session Recovery & Context Preservation + +## Startup Detection +```yaml +scan_on_startup: + locations: + - ./claudedocs/tasks/in-progress/*.md + - ./claudedocs/tasks/pending/*.md (overdue) + + parse_tasks: + - extract metadata + - check git branch status + - identify next steps + - restore context variables + + recovery_prompt: + found_tasks: "Found {count} active tasks. Resume work?" + no_tasks: "No active tasks found. Ready for new work." + overdue: "Task {id} overdue. Continue or reschedule?" +``` + +## Context Preservation +```yaml +session_state: + file_paths: currently modified files + variables: important data & settings + decisions: architectural choices made + blockers: issues & solutions attempted + +auto_save_triggers: + - major code changes + - before risky operations + - session timeout warnings + - manual /task:pause + +context_format: + ```yaml + session_state: + current_files: [path1, path2] + key_variables: + api_endpoint: "https://api.example.com" + database_name: "myapp_prod" + decisions: + - "Used React over Vue for better team familiarity" + - "Chose PostgreSQL for ACID compliance" + blockers: + - issue: "CORS error on API calls" + attempted: ["added headers", "proxy setup"] + solution: "needed server-side CORS config" + ``` +``` + +## Hybrid Recovery Process +```yaml +step_1_identify: + - scan ./claudedocs/tasks/in-progress/ + - parse task metadata + - check git branch status + - validate file existence + - restore previous TodoWrite state + +step_2_restore_both_systems: + task_context: + - load session context + - summarize previous work + - identify blocking issues + todo_context: + - regenerate TodoWrite from task breakdown + - identify last completed todo + - set current focus todo + - preserve todo progress + +step_3_seamless_resume: + no_prompts: true + auto_continue: true + template: | + Resuming {task_title} - working on: {current_todo} + Progress: {completed_todos}/{total_todos} todos, {task_progress}% complete + +hybrid_state_restoration: + both_systems_sync: + - task provides persistence + - todos provide immediate focus + - progress tracked in both + - no duplication of effort +``` + +## Git Integration +```yaml +branch_tracking: + - verify branch exists + - check for uncommitted changes + - identify merge conflicts + - track remote status + +checkpoint_restoration: + - list available checkpoints + - show diff since last checkpoint + - offer rollback options + - suggest merge strategies +``` + +## Session Break Handling +```yaml +graceful_pause: + auto_triggers: + - context >90% full + - long inactivity + - error thresholds + + pause_actions: + - save current context + - create git checkpoint + - update progress status + - log session summary + + resume_preparation: + - validate environment + - check dependencies + - restore file states + - prepare tools +``` + +## Multi-Task Management +```yaml +concurrent_tasks: + max_active: 3 + priority_rules: + - high priority blocks others + - related tasks can be parallel + - different areas can overlap + +task_switching: + - auto-save current context + - create checkpoint + - switch git branch + - restore new context + +conflict_resolution: + - file modification conflicts + - git merge requirements + - dependency overlaps + - resource constraints +``` \ No newline at end of file diff --git a/.claude/commands/shared/task-management.yml b/.claude/commands/shared/task-management.yml new file mode 100644 index 0000000..e58c218 --- /dev/null +++ b/.claude/commands/shared/task-management.yml @@ -0,0 +1,205 @@ +# task-management.yml - Task Management & Session Recovery + +## Automatic Task Detection +```yaml +complexity_indicators: + high_complexity: + - mentions: ["system", "architecture", "integration", "authentication", "database"] + - scope: ["full-stack", "end-to-end", "complete", "entire"] + - actions: ["build", "create", "implement", "develop", "add feature"] + - files: >5 estimated files + - time: >2 hours estimated + - sessions: likely >1 session + + medium_complexity: + - mentions: ["component", "module", "service", "API"] + - scope: ["frontend", "backend", "single area"] + - files: 3-5 estimated files + - time: 1-2 hours estimated + + low_complexity: + - mentions: ["fix", "update", "modify", "adjust"] + - scope: ["single file", "small change"] + - files: 1-2 files + - time: <1 hour + +auto_task_thresholds: + always_create: high_complexity + suggest_create: medium_complexity + multi_step + never_create: low_complexity + +detection_keywords: + trigger_words: ["build", "create", "implement", "develop", "add", "design", "system"] + scope_words: ["feature", "functionality", "component", "service", "integration"] + complexity_words: ["authentication", "database", "API", "architecture", "full-stack"] +``` + +## Hybrid Todo + Task System +```yaml +two_tier_approach: + task_level: high-level features (./claudedocs/tasks/ folders) + todo_level: immediate steps (TodoWrite/TodoRead) + +integration_flow: + 1. Complex requirement → auto-create Task + 2. Task breakdown → TodoWrite for immediate steps + 3. Work on todos → update task progress + 4. Session break → preserve both systems + 5. Resume → restore task + active todos + +seamless_operation: + task_creates_todos: task breakdown → TodoWrite steps + todos_update_task: completed todos → task progress + context_preserves_both: session state includes task + todos + recovery_restores_both: startup → resume task + todos + +## Task Status Flow +```yaml +status_transitions: + pending → in-progress: /task:start {id} + TodoWrite breakdown + in-progress → completed: all todos complete + /task:complete {id} + in-progress → pending: /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 +``` + +## Session Recovery +```yaml +startup_check: + - scan ./claudedocs/tasks/in-progress/ + - identify active tasks + - restore context from task files + - suggest next steps + +context_preservation: + key_decisions: important architectural choices + blockers: issues preventing progress + session_state: variables, file paths, current focus + +recovery_prompts: + - "Resuming task: {title}" + - "Last context: {context}" + - "Next steps: {next_steps}" +``` + +## Task File Structure +```yaml +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 + +content_sections: + - requirement description + - step-by-step breakdown + - affected files list + - context preservation + - checkpoint history +``` + +## Git Integration +```yaml +branch_strategy: + naming: task/{id}-{slug} + creation: automatic on task start + protection: prevent force push + +commit_discipline: + format: "[{task_id}] {phase}: {description}" + atomic: one logical change per commit + phases: + - "[{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) + manual: + - /task:pause command + - /user:git --checkpoint + +cleanup_workflow: + on_complete: + - squash merge to main + - delete feature branch + - archive task to completed/ + retention: + - keep completed tasks 30 days + - archive older tasks + - prune stale branches weekly + +git_hooks: + pre_commit: validate task state + post_merge: update task status + branch_protection: task/* branches +``` + +## Automatic Task Creation Flow +```yaml +detection_process: + step_1_analyze: + - parse user requirement + - count complexity indicators + - estimate files affected + - assess time/session requirements + + step_2_decide: + high_complexity: auto_create_task + medium_complexity: brief_confirmation + low_complexity: proceed_normally + + step_3_execute: + auto_create: + - generate task ID + - create task file from requirement + - move to pending folder + - create git branch + - breakdown into TodoWrite steps + - start immediately with active todos + brief_confirm: + - "Creating task for multi-step work. Proceeding..." + - auto-create without waiting + - convert steps to TodoWrite + +seamless_activation: + no_interruption: true + minimal_prompts: true + auto_start: true + background_setup: true + +user_experience: + before: "I need to build user authentication" + after: "[Auto-creating task: user-auth-20250623-143052] Starting implementation..." + flow: requirement → auto-detect → create → start → implement +``` + +## Commands 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: + - scan for ./claudedocs/tasks/ on startup + - auto-create for complex requirements (no prompts) + - auto-pause tasks on context limits + - auto-resume on session start +``` \ No newline at end of file diff --git a/.claude/commands/shared/task-ultracompressed.yml b/.claude/commands/shared/task-ultracompressed.yml new file mode 100644 index 0000000..fb8c040 --- /dev/null +++ b/.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 +``` \ No newline at end of file diff --git a/.claude/commands/shared/templates/feature-template.md b/.claude/commands/shared/templates/feature-template.md new file mode 100644 index 0000000..4a13fa1 --- /dev/null +++ b/.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: [] +``` \ No newline at end of file diff --git a/.claude/commands/shared/templates/task-ultracompressed.md b/.claude/commands/shared/templates/task-ultracompressed.md new file mode 100644 index 0000000..a7f6b23 --- /dev/null +++ b/.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} \ No newline at end of file diff --git a/.claude/commands/shared/todo-task-integration.yml b/.claude/commands/shared/todo-task-integration.yml new file mode 100644 index 0000000..ba64f29 --- /dev/null +++ b/.claude/commands/shared/todo-task-integration.yml @@ -0,0 +1,153 @@ +# todo-task-integration.yml - Seamless Todo + Task System + +## 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 +``` + +## Workflow Integration +```yaml +complex_requirement_flow: + 1_auto_detect: complexity ≥8 → create task + 2_breakdown: task phases → TodoWrite immediate steps + 3_execute: work on todos → update task progress + 4_session_break: preserve both systems + 5_resume: restore task + todos state + +simple_requirement_flow: + 1_detect: complexity <5 → TodoWrite only + 2_execute: work on todos directly + 3_complete: mark todos done + +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 +``` + +## Automatic Breakdown Logic +```yaml +task_to_todos_conversion: + when_task_starts: + - parse task breakdown sections + - extract actionable steps + - convert to TodoWrite format + - preserve task context + + step_extraction: + analysis_phase: → pending todos + implementation_phase: → pending todos + testing_phase: → pending todos + completion_phase: → pending todos + + todo_format: + - id: auto-generated + - content: actionable step from task + - status: pending + - priority: inherit from task + - task_id: link back to parent task + +## Context Preservation +```yaml +session_state_tracking: + task_context: + - active task ID + - current phase + - architectural decisions + - git branch info + + todo_context: + - current todo list + - in_progress item + - completed items + - blocking issues + + combined_state: + - task progress percentage + - todos completion ratio + - session focus area + - next recommended action + +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 + 4_resume_message: "Resuming {task} - working on {current_todo}" +``` + +## Smart Synchronization +```yaml +todo_completion_updates_task: + on_todo_complete: + - calculate task progress + - update task file + - move to next logical step + - create checkpoint if needed + + progress_calculation: + total_steps: count all todos from task + completed_steps: count completed todos + percentage: completed / total * 100 + +task_completion_clears_todos: + on_task_complete: + - mark all todos complete + - clear TodoWrite state + - archive task to completed/ + - create final git checkpoint + +## Error Recovery +```yaml +state_mismatch_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 + +context_corruption: + - fallback to task file data + - regenerate todos if possible + - manual recovery prompts +``` + +## User Experience Examples +```yaml +example_1_complex: + user: "Build user authentication system" + system: "[Task created: auth-20250623-143052]" + todos: ["Create user model", "Add registration endpoint", "Implement JWT"] + work: Focus on current todo with task context preserved + +example_2_simple: + user: "Fix login button styling" + system: No task created + todos: ["Update button CSS", "Test responsive design"] + work: Direct todo completion + +example_3_session_break: + before_break: Working on "Add registration endpoint" (todo 2/8) + after_resume: "Resuming auth system - continuing with registration endpoint" + state: Task context + todo position fully restored +``` \ No newline at end of file diff --git a/.claude/commands/task.md b/.claude/commands/task.md new file mode 100644 index 0000000..9b27781 --- /dev/null +++ b/.claude/commands/task.md @@ -0,0 +1,110 @@ +# /task: - Task Management & Session Recovery + +@task-management.yml + +## Purpose +Manage complex features & requirements across sessions with automatic breakdown, context preservation & recovery. + +## Syntax +```bash +/task:create [--type feature|bugfix|refactor|docs|test] [--priority high|medium|low] +/task:list [--status pending|in-progress|completed] [--priority high|medium|low] +/task:start <id> +/task:pause <id> +/task:complete <id> +/task:resume <id> +/task:cancel <id> +/task:show <id> +/task:update <id> --status <status> --priority <priority> +``` + +## Workflow +```yaml +Creation: + 1. Analyze requirement complexity + 2. Generate unique task ID (YYYYMMDD-HHMMSS) + 3. Break down into phases & steps + 4. Create task file from template + 5. Create git branch + 6. Move to pending folder + +Execution: + 1. Move to in-progress folder + 2. Create git checkpoint + 3. Execute steps sequentially + 4. Update progress & context + 5. Handle session breaks gracefully + +Completion: + 1. Verify all steps completed + 2. Run final tests + 3. Create completion checkpoint + 4. Move to completed folder + 5. Merge git branch +``` + +## Auto-Detection +```yaml +Triggers: + - "build feature X" + - "implement functionality Y" + - "add component Z" + - Requirements >3 files + - Complex multi-step work + +Response: + "This looks like a multi-step task. Should I create a task breakdown?" + Options: [Yes - create task] [No - proceed directly] +``` + +## Session Recovery +```yaml +Startup: + 1. Scan .tasks/in-progress/ + 2. Identify active tasks + 3. Restore context from task files + 4. Suggest resumption steps + +Context: + - Key architectural decisions + - Current implementation state + - Known blockers & solutions + - File modification history +``` + +## Examples +```bash +# Create new feature task +/task:create "User authentication system" --type feature --priority high + +# List all pending tasks +/task:list --status pending + +# Start working on a task +/task:start 20250623-143052 + +# Pause current work (auto-saves context) +/task:pause 20250623-143052 + +# Resume after session break +/task:resume 20250623-143052 + +# Mark task complete +/task:complete 20250623-143052 +``` + +## Integration +- **Git**: Automatic branching & checkpoints +- **TodoWrite**: Sync with current todo system +- **Personas**: Task-specific persona activation +- **MCP**: Context preservation across tools +- **Commands**: Chain with other /user: commands + +## File Structure +``` +./claudedocs/tasks/ +├── pending/feature-20250623-143052-user-auth.md +├── in-progress/bugfix-20250623-144022-login-error.md +├── completed/refactor-20250623-142033-api-cleanup.md +└── templates/feature-template.md +``` \ No newline at end of file diff --git a/.gitignore b/.gitignore index f7ba095..0b33bb3 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,9 @@ logs/ # Claude operations documentation .claudedocs/ +# Task management (project-specific) +./claudedocs/tasks/ + # System files .DS_Store Thumbs.db diff --git a/CLAUDE.md b/CLAUDE.md index ed7ea40..3ba5c48 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -18,7 +18,7 @@ Philosophy: Code>docs | Simple→complex | Security first Communication: Concise format | Symbols: →|&:» | Bullets>prose Workflow: TodoRead()→TodoWrite(3+)→Execute | Update immediate Stack: React|TS|Vite + Node|Express|PostgreSQL + Git|ESLint|Jest -Commands: /user:<command> [flags] | Ex: /user:build --init +Commands: /user:<command> [flags] | /task:<action> | Ex: /user:build --init ``` ## Thinking Modes @@ -72,6 +72,17 @@ Efficiency: Min tokens | Cache results | Batch ops Files: *.tsx→frontend | *.sql→data | Docker→devops | *.test→qa Keywords: bug|error→debugger | optimize→performance | secure→security Context: TypeError→trace | Module error→deps | Permission→security +Tasks: Auto-detect complexity→seamless task creation | ./claudedocs/tasks/in-progress→auto-resume +``` + +## Task Management + +```yaml +Mode: Automatic | No user prompts | Seamless activation +Detection: ≥8 complexity points→auto-create | 5-7→brief notify | <5→normal +Triggers: "build|create|implement" + "system|feature" + complexity flags +Flow: requirement→analyze→create→breakdown→implement | Background operation +Recovery: Auto-resume active tasks | Context preservation | Git integration ``` ## Performance diff --git a/install.sh b/install.sh index 2a41fb6..c988cb7 100755 --- a/install.sh +++ b/install.sh @@ -133,11 +133,11 @@ command_files=$(ls -1 "$INSTALL_DIR/commands/"*.md 2>/dev/null | wc -l) shared_files=$(ls -1 "$INSTALL_DIR/commands/shared/"*.yml 2>/dev/null | wc -l) echo -e "Main config files: ${GREEN}$main_files${NC} (expected: 4)" -echo -e "Command files: ${GREEN}$command_files${NC} (expected: 18)" -echo -e "Shared resources: ${GREEN}$shared_files${NC} (expected: 26)" +echo -e "Command files: ${GREEN}$command_files${NC} (expected: 19)" +echo -e "Shared resources: ${GREEN}$shared_files${NC} (expected: 31)" # Check if installation was successful -if [ "$main_files" -ge 4 ] && [ "$command_files" -ge 18 ] && [ "$shared_files" -ge 26 ]; then +if [ "$main_files" -ge 4 ] && [ "$command_files" -ge 19 ] && [ "$shared_files" -ge 31 ]; then echo "" echo -e "${GREEN}✓ SuperClaude installed successfully!${NC}" echo ""