Initial commit

commands/task.md

@@ -0,0 +1,223 @@
+## Task
+
+Launches a smart agent to handle complex searches and investigations. Great for large-scale work without eating up context.
+
+### Usage
+
+```bash
+# Request Task from Claude
+"Investigate [task] using Task"
+```
+
+### What Task Does
+
+**Works Independently**
+
+- Combines multiple tools automatically
+- Gathers and analyzes step by step
+- Puts results together in clear reports
+
+**Saves Context**
+
+- Uses less memory than manual searching
+- Searches lots of files efficiently
+- Pulls data from outside sources
+
+**Ensures Quality**
+
+- Checks if sources are reliable
+- Verifies from different angles
+- Fills in missing pieces
+
+### Basic Examples
+
+```bash
+# Complex codebase investigation
+"Investigate which files implement this feature using Task"
+
+# Large-scale file search
+"Identify configuration file inconsistencies using Task"
+
+# External information collection
+"Investigate the latest AI technology trends using Task"
+```
+
+### Collaboration with Claude
+
+```bash
+# Complex problem analysis
+"Analyze the cause of memory leaks using Task, including profiling results and logs"
+
+# Dependency investigation
+"Investigate vulnerabilities of this npm package using Task"
+
+# Competitor analysis
+"Investigate API specifications of competing services using Task"
+
+# Architecture analysis
+"Analyze dependencies of this microservice using Task"
+```
+
+### Task vs Other Commands
+
+#### When to Use What
+
+| Command             | Main Use Case                   | Execution Method      | Information Collection     |
+| ------------------- | ------------------------------- | --------------------- | -------------------------- |
+| **Task**            | Investigation, analysis, search | Autonomous execution  | Multiple sources           |
+| ultrathink          | Deep thinking, judgment         | Structured thinking   | Existing knowledge-focused |
+| sequential-thinking | Problem-solving, design         | Step-by-step thinking | As needed                  |
+| plan                | Implementation planning         | Approval process      | Requirement analysis       |
+
+#### Quick Decision Guide
+
+```text
+Need to gather info?
+├─ Yes → From many places or lots of files?
+│          ├─ Yes → **Use Task**
+│          └─ No → Just ask normally
+└─ No → Need deep thinking?
+          ├─ Yes → Use ultrathink/sequential-thinking
+          └─ No → Just ask normally
+```
+
+### When Task Works Best
+
+**Great For**
+
+- Exploring complex codebases (dependencies, architecture)
+- Searching many files (patterns, configs)
+- Gathering external info (tech trends, libraries)
+- Combining data from multiple places (logs, metrics)
+- Repetitive investigations (audits, debt checks)
+- Big searches that would eat too much context
+
+**Not Great For**
+
+- Simple questions I already know
+- Quick one-time tasks
+- Things needing back-and-forth discussion
+- Design decisions (use plan or thinking commands instead)
+
+### Detailed Examples by Category
+
+#### System Analysis and Investigation
+
+```bash
+# Complex system analysis
+"Identify bottlenecks in the EC site using Task, investigating database, API, and frontend"
+
+# Architecture analysis
+"Analyze dependencies of this microservice using Task, including API communication and data flow"
+
+# Technical debt investigation
+"Analyze technical debt in legacy code using Task, including refactoring priorities"
+```
+
+#### Security and Compliance
+
+```bash
+# Security audit
+"Investigate vulnerabilities in this application using Task, based on OWASP Top 10"
+
+# License investigation
+"Investigate license issues in project dependencies using Task"
+
+# Configuration file audit
+"Identify security configuration inconsistencies using Task, including environment differences"
+```
+
+#### Performance and Optimization
+
+```bash
+# Performance analysis
+"Identify heavy queries in the application using Task, including execution plans and optimization proposals"
+
+# Resource usage investigation
+"Investigate causes of memory leaks using Task, including profiling results and code analysis"
+
+# Bundle size analysis
+"Investigate frontend bundle size issues using Task, including optimization suggestions"
+```
+
+#### External Information Collection
+
+```bash
+# Technology trend investigation
+"Investigate 2024 JavaScript framework trends using Task"
+
+# Competitor analysis
+"Investigate API specifications of competing services using Task, including feature comparison table"
+
+# Library evaluation
+"Compare state management libraries using Task, including performance and learning costs"
+```
+
+### Execution Flow and Quality Assurance
+
+#### Task Execution Flow
+
+```text
+1. Initial Analysis
+   ├─ Decomposition of task and identification of investigation scope
+   ├─ Selection of necessary tools and information sources
+   └─ Development of execution plan
+
+2. Information Collection
+   ├─ File search and code analysis
+   ├─ Collection of external information
+   └─ Data structuring
+
+3. Analysis and Integration
+   ├─ Relevance analysis of collected information
+   ├─ Identification of patterns and issues
+   └─ Verification of hypotheses
+
+4. Reporting and Proposal
+   ├─ Structuring of results
+   ├─ Creation of improvement proposals
+   └─ Presentation of next actions
+```
+
+#### Quality Assurance
+
+- **Reliability check of information sources**: Fact confirmation from multiple sources
+- **Completeness check**: Verification of no gaps in investigation targets
+- **Consistency verification**: Confirmation of consistency in conflicting information
+- **Practicality evaluation**: Assessment of feasibility and effectiveness of proposals
+
+### Error Handling and Constraints
+
+#### Common Constraints
+
+- **External API usage limits**: Rate limits and authentication errors
+- **Large file processing limits**: Memory and timeout constraints
+- **Access permission issues**: Restrictions on file and directory access
+
+#### Error Handling
+
+- **Partial result reporting**: Analysis with only obtainable information
+- **Alternative proposals**: Suggestion of alternative investigation methods under constraints
+- **Stepwise execution**: Division of large-scale tasks for execution
+
+### Notes
+
+- Task is optimal for complex, autonomous investigation and analysis tasks
+- For simple questions or when immediate answers are needed, use normal question format
+- Treat investigation results as reference information and always verify important decisions
+- When collecting external information, pay attention to the freshness and accuracy of information
+
+### Execution Example
+
+```bash
+# Usage example
+"Investigate issues in GraphQL schema using Task"
+
+# Expected behavior
+# 1. Dedicated agent starts
+# 2. Search for GraphQL-related files
+# 3. Analyze schema definitions
+# 4. Compare with best practices
+# 5. Identify issues and propose improvements
+# 6. Create structured report
+```