@dragonflymcp/plugin 1.0.0

package/templates/commands/profile.md.template

@@ -0,0 +1,142 @@
+# /profile Command
+
+Generate or view project profile with auto-detected characteristics.
+
+## Usage
+
+```
+/profile                    # Generate/refresh project profile
+/profile recommend <task>   # Get recommendations for a task
+/profile view               # View current profile
+```
+
+## Purpose
+
+This command invokes the project-profile concept to:
+- Auto-detect languages and frameworks
+- Identify architectural patterns
+- Measure codebase metrics
+- Enable technology-specific skills
+- Optimize workflow behavior
+
+## Process
+
+When you run `/profile`:
+
+1. **Scan File Extensions**
+   - Count files by extension
+   - Determine primary/secondary languages
+
+2. **Analyze Package Files**
+   - Read package.json, requirements.txt, Cargo.toml, etc.
+   - Detect frameworks and their versions
+
+3. **Use AST Index**
+   - Get code metrics (files, lines, symbols)
+   - Detect patterns (repository, DI, MVC, etc.)
+
+4. **Identify Conventions**
+   - Linting/formatting configuration
+   - Naming conventions
+   - Directory structure style
+
+5. **Generate Optimizations**
+   - Enable relevant skills
+   - Suggest workflow adjustments
+   - Override sync rules for this project
+
+## Output Format
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Project Profile
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Languages:
+  Primary:   TypeScript (65%)
+  Secondary: Python (25%), YAML (10%)
+
+Frameworks:
+  Frontend:  React 18.2, TailwindCSS
+  Backend:   Express 4.18
+  Database:  PostgreSQL + Prisma 5.0
+  Testing:   Jest 29.0
+
+Architecture:
+  Style:     Layered (feature-based directories)
+  Patterns:  repository-pattern, dependency-injection
+
+Metrics:
+  Files:     234 total (189 source, 45 test)
+  Lines:     45,000
+  Coverage:  24% (by file count)
+
+Quality:
+  Linting:   ESLint (strict)
+  Formatter: Prettier
+  Types:     TypeScript (strict mode)
+
+Enabled Skills:
+  ✓ typescript-patterns
+  ✓ react-best-practices
+  ✓ prisma-patterns
+
+Workflow Optimizations:
+  • Skip architecture for low-complexity tasks (established patterns)
+  • Enable React-specific quality checks for .tsx files
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Profile saved to: koan/profile.yaml
+```
+
+## Recommendations
+
+With `/profile recommend <task>`:
+
+```
+/profile recommend "Add user authentication"
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Recommendations for: Add user authentication
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Skills to Enable:
+  • typescript-patterns (project uses strict TypeScript)
+  • prisma-patterns (user model likely uses Prisma)
+
+Relevant Patterns:
+  • repository-pattern
+    Example: src/repositories/user.repository.ts
+    Apply to: AuthRepository
+
+Files to Reference:
+  • src/features/users/user.service.ts
+  • src/shared/errors/app-error.ts
+  • prisma/schema.prisma
+
+Workflow Suggestions:
+  1. Use existing UserRepository pattern for AuthRepository
+  2. Follow established error handling in src/shared/errors
+  3. Add Prisma migration for auth tables
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Storage
+
+Profile stored at: `koan/profile.yaml`
+
+## Integration
+
+Profile auto-triggers on first Zen install if not exists.
+Profile informs:
+- Task classification weights
+- Architecture phase behavior
+- Quality review focus areas
+
+## WYSIWID Principle
+
+All detection rules and optimizations are visible in:
+- `.claude/concepts/project-profile.md`
+- `koan/profile.yaml` (actual detected values)

package/templates/commands/reasoning.md.template

@@ -0,0 +1,228 @@
+View and analyze reasoning chains from architecture decisions.
+
+This command provides visibility into the Chain-of-Thought reasoning process
+used by the architecture concept.
+
+## Usage
+
+```
+/reasoning <arch-id>           - View reasoning chain for an architecture
+/reasoning compare <id1> <id2> - Compare reasoning between two architectures
+/reasoning stats               - Show reasoning mode usage statistics
+/reasoning modes               - Display available reasoning modes
+```
+
+## Examples
+
+### View Reasoning Chain
+
+```
+/reasoning arch-001
+```
+
+Output:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Reasoning Chain: arch-001
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Mode: standard (5 steps)
+Method: linear
+Model: sonnet
+Confidence: 0.95
+
+Step 1: Understand Requirements (450 tokens, 1.2s)
+├─ Requirements: User authentication, Social login
+└─ Constraints: Must integrate with existing session
+
+Step 2: Explore Approaches (800 tokens, 2.1s)
+├─ Approach 1: OAuth2 with Passport.js
+├─ Approach 2: Custom OAuth2 implementation
+└─ Approach 3: SAML with passport-saml
+
+Step 3: Evaluate Trade-offs (600 tokens, 1.5s)
+├─ OAuth2 + Passport: 8.5/10 (selected)
+├─ Custom OAuth2: 3.2/10
+└─ SAML: 5.1/10
+
+Step 4: Decide (350 tokens, 0.9s)
+├─ Selected: OAuth2 with Passport.js
+├─ Confidence: 0.95
+└─ Rationale: Battle-tested, team familiarity
+
+Step 5: Design (500 tokens, 1.3s)
+├─ Components: 3
+├─ Interfaces: 2
+└─ Data flow steps: 8
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Total: 2,700 tokens | 7.0s | $0.005
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### View Deep Tree-of-Thought
+
+```
+/reasoning arch-cot-001
+```
+
+Output:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Reasoning Chain: arch-cot-001
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Mode: deep (10 steps)
+Method: tree_of_thought
+Model: opus
+Confidence: 0.92
+
+Phase 1: Deep Understanding (3 steps)
+├─ Step 1: Decompose → 4 sub-problems identified
+├─ Step 2: Requirements → analyzed
+└─ Step 3: Constraints → mapped
+
+Phase 2: Tree-of-Thought Exploration (3 steps)
+│
+├─ Branch 1: Structured Output (score: 8.0)
+│   ├─ b1.1: Single-call variant (8.5) ✓ SELECTED
+│   └─ b1.2: Multi-call variant (7.2) ✗ pruned
+│
+├─ Branch 2: Step-by-Step (score: 3.0) ✗ pruned
+│   └─ Reason: 5-20x cost increase
+│
+└─ Branches pruned: 3 | Final depth: 3
+
+Phase 3: Decision (2 steps)
+├─ Risk analysis completed
+└─ Final: Dual-Mode Reasoning (confidence: 0.92)
+
+Phase 4: Design (2 steps)
+├─ Architecture, Integration points
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Total: 6,500 tokens | 20.0s | $0.015
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Compare Architectures
+
+```
+/reasoning compare arch-001 arch-002
+```
+
+Output:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Reasoning Comparison
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+                    arch-001        arch-002
+Mode:               standard        deep
+Steps:              5               10
+Model:              sonnet          opus
+Tokens:             2,700           6,500
+Duration:           7.0s            18.5s
+Cost:               $0.005          $0.015
+Confidence:         0.95            0.97
+Approaches:         3               5
+
+Key Differences:
+- arch-002 explored 2 more approaches
+- arch-002 used Opus for deeper trade-off analysis
+- arch-002 has higher confidence (+0.02)
+- arch-002 cost 3x more but may prevent rework
+```
+
+### View Statistics
+
+```
+/reasoning stats
+```
+
+Output:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Reasoning Mode Statistics
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Mode Usage (last 30 days):
+├─ quick:      12 (25%)  avg: $0.003, 3.2s
+├─ standard:   28 (58%)  avg: $0.005, 7.8s
+└─ deep:        8 (17%)  avg: $0.015, 19.2s
+
+Total architectures: 48
+Average confidence: 0.93
+Total cost: $0.31
+
+Auto-Mode Selection Accuracy:
+├─ Correct mode selected: 45/50 (90%)
+├─ Under-estimated: 3 (resulted in rework)
+└─ Over-estimated: 2 (higher cost than needed)
+
+Recommendations:
+- Consider using 'deep' for authentication features
+- 'quick' mode worked well for UI-only changes
+```
+
+### Display Available Modes
+
+```
+/reasoning modes
+```
+
+Output:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Available Reasoning Modes
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Mode          Steps   Model    Method          Cost      Use Case
+──────────────────────────────────────────────────────────────────
+quick         3       sonnet   linear          ~$0.003   Simple features, quick fixes
+standard      5       sonnet   linear          ~$0.005   Typical features (default)
+deep          10      opus     tree_of_thought ~$0.015   Complex features, critical decisions
+
+Mode Selection:
+1. Explicit prefix: /workflow deep "..."
+2. Story tags: critical, security → deep
+3. Keywords: distributed, migration → deep
+4. Default: standard
+
+Configuration: .claude/config/reasoning-modes.yaml
+```
+
+## Implementation
+
+When invoked, this command:
+
+1. **View reasoning chain**:
+   - Read `koan/architecture/arch-{id}.yaml`
+   - Extract `reasoning_chain` section
+   - Format as hierarchical tree view
+   - Show tokens/timing per step
+   - For deep mode: render tree-of-thought exploration with pruning
+
+2. **Compare architectures**:
+   - Read both architecture files
+   - Compare mode, steps, tokens, cost, confidence
+   - Identify key differences in reasoning approach
+   - Suggest which mode was more appropriate
+
+3. **Show statistics**:
+   - Scan all `koan/architecture/arch-*.yaml` files
+   - Aggregate by reasoning mode
+   - Calculate averages and distributions
+   - Analyze auto-mode selection accuracy
+   - Generate recommendations
+
+4. **Display modes**:
+   - Read `.claude/config/reasoning-modes.yaml`
+   - Format mode table with costs
+   - Show selection priority rules
+
+## Related Commands
+
+- `/workflow` - Execute workflow with reasoning mode
+- `/trace` - View full provenance chain
+- `/costs` - Cost analysis including reasoning costs

package/templates/commands/recall.md.template

@@ -0,0 +1,197 @@
+---
+name: recall
+description: "Retrieve memories from semantic storage"
+---
+
+# /recall Command
+
+Search and retrieve stored memories from semantic memory.
+
+## Usage
+
+```
+/recall <query>                 # Search by keyword
+/recall --category <cat>        # Filter by category
+/recall --tags tag1,tag2        # Filter by tags
+/recall --recent [n]            # Show n most recent (default: 10)
+/recall --all                   # Show all memories
+```
+
+## Parameters
+
+| Parameter | Description | Default |
+|-----------|-------------|---------|
+| query | Keyword to search in memory content | - |
+| --category | Filter: architecture, conventions, patterns, workflows, debugging | all |
+| --tags | Comma-separated tags to match | - |
+| --recent | Show most recent n memories | 10 |
+| --all | Show all memories (paginated) | false |
+
+## What to Do
+
+### 1. Read Memory Index
+
+```bash
+cat koan/memory/index.yaml
+```
+
+### 2. Search Memories
+
+Based on query type:
+- **Keyword**: Search content fields
+- **Tags**: Match tag arrays
+- **Category**: Filter by category
+- **Recent**: Sort by created_at
+
+### 3. Read Matching Memory Files
+
+```bash
+# Read relevant category files
+cat koan/memory/semantic/architecture.yaml
+cat koan/memory/semantic/conventions.yaml
+# etc.
+```
+
+### 4. Format Results
+
+```
+Found {n} memories matching "{query}":
+
+1. [mem-001] {category} | {confidence}
+   "{content}"
+   Tags: [{tags}]
+   Stored: {date}
+
+2. [mem-002] {category} | {confidence}
+   "{content}"
+   Tags: [{tags}]
+   Stored: {date}
+
+... more results
+```
+
+## Examples
+
+### Keyword Search
+```
+/recall auth
+
+Found 4 memories matching "auth":
+
+1. [mem-015] architecture | high
+   "Authentication uses JWT with RS256 signing"
+   Tags: [auth, jwt, security]
+   Stored: 2025-01-05
+
+2. [mem-023] architecture | high
+   "OAuth tokens expire after 1 hour"
+   Tags: [auth, oauth, tokens]
+   Stored: 2025-01-05
+
+3. [mem-031] workflows | medium
+   "To test auth: use test user credentials in .env.test"
+   Tags: [auth, testing, credentials]
+   Stored: 2025-01-06
+
+4. [mem-048] debugging | high
+   "Auth failures: check token expiry first"
+   Tags: [auth, debugging, tokens]
+   Stored: 2025-01-06
+```
+
+### Category Filter
+```
+/recall --category conventions
+
+Found 8 memories in category "conventions":
+
+1. [mem-002] high
+   "All API endpoints return { data, error, meta } shape"
+   Tags: [api, conventions]
+
+2. [mem-007] high
+   "Use kebab-case for file names"
+   Tags: [naming, files]
+
+3. [mem-012] high
+   "Always use async/await, never callbacks"
+   Tags: [async, style]
+
+... 5 more
+```
+
+### Tag Search
+```
+/recall --tags security
+
+Found 3 memories with tag "security":
+
+1. [mem-015] architecture | high
+   "Authentication uses JWT with RS256 signing"
+
+2. [mem-019] architecture | medium
+   "API keys stored in environment variables only"
+
+3. [mem-027] conventions | high
+   "Never log sensitive data - use [REDACTED]"
+```
+
+### Recent Memories
+```
+/recall --recent 5
+
+5 most recent memories:
+
+1. [mem-048] debugging | high (today)
+   "Auth failures: check token expiry first"
+
+2. [mem-047] patterns | medium (today)
+   "Rate limiting uses token bucket algorithm"
+
+3. [mem-046] workflows | high (yesterday)
+   "Deploy to staging: npm run deploy:staging"
+
+4. [mem-045] architecture | medium (yesterday)
+   "Cache TTL is 5 minutes for user data"
+
+5. [mem-044] conventions | high (2 days ago)
+   "Error messages should be user-friendly"
+```
+
+## No Results
+
+When no memories match:
+```
+/recall kubernetes
+
+No memories found matching "kubernetes".
+
+Suggestions:
+- Try broader search terms
+- Check available categories: /recall --categories
+- Store new knowledge: /remember "..."
+```
+
+## Memory Context for Tasks
+
+When working on a task, proactively recall relevant memories:
+
+```
+User: Let's work on the API error handling
+
+Claude: Before we start, let me check relevant memories...
+
+/recall --tags api,error
+
+Found 2 relevant memories:
+1. "All API endpoints return { data, error, meta } shape"
+2. "Error messages should be user-friendly"
+
+I'll keep these conventions in mind as we work.
+```
+
+## Related Commands
+
+- `/remember` - Store new memory
+- `/forget` - Remove a memory
+- `/health` - Check context health

package/templates/commands/remember.md.template

@@ -0,0 +1,148 @@
+---
+name: remember
+description: "Store a fact or knowledge in semantic memory for future sessions"
+---
+
+# /remember Command
+
+Store persistent memories that survive across sessions and context compressions.
+
+## Usage
+
+```
+/remember "fact or knowledge to store"
+/remember --category <cat> "content"
+/remember --tags tag1,tag2 "content"
+/remember --confidence high|medium|low "content"
+```
+
+## Parameters
+
+| Parameter | Description | Default |
+|-----------|-------------|---------|
+| content | The fact/knowledge to remember | required |
+| --category | Category: architecture, conventions, patterns, workflows, debugging | inferred |
+| --tags | Comma-separated tags for retrieval | auto-generated |
+| --confidence | Confidence level | high (if user stated) |
+
+## What to Do
+
+### 1. Parse the Memory Content
+
+Extract:
+- The core fact being stored
+- Any implicit category
+- Relevant tags
+
+### 2. Generate Memory Entry
+
+```yaml
+# koan/memory/semantic/{category}.yaml
+- id: "mem-{timestamp}"
+  type: semantic
+  category: "{category}"
+  content: "{user's content}"
+  confidence: "{level}"
+  source: "User stated in session {date}"
+  tags: [{generated tags}]
+  created_at: "{timestamp}"
+  session_id: "{current session}"
+```
+
+### 3. Update Memory Index
+
+Add entry to `koan/memory/index.yaml`:
+- Increment total count
+- Add to tag index
+- Add to recent additions
+
+### 4. Confirm Storage
+
+```
+✅ Memory stored:
+
+ID: mem-{id}
+Type: semantic
+Category: {category}
+Content: "{content}"
+Confidence: {level}
+Tags: [{tags}]
+
+This will be recalled in future sessions.
+```
+
+## Examples
+
+### Basic Usage
+```
+/remember "API rate limit is 100 requests per minute"
+
+✅ Memory stored:
+ID: mem-20250106-143052
+Category: architecture
+Content: "API rate limit is 100 requests per minute"
+Tags: [api, rate-limit, constraints]
+```
+
+### With Category
+```
+/remember --category conventions "Use kebab-case for file names"
+
+✅ Memory stored:
+ID: mem-20250106-143055
+Category: conventions
+Content: "Use kebab-case for file names"
+Tags: [conventions, naming, files]
+```
+
+### With Tags
+```
+/remember --tags auth,security "OAuth tokens expire after 1 hour"
+
+✅ Memory stored:
+ID: mem-20250106-143100
+Category: architecture
+Content: "OAuth tokens expire after 1 hour"
+Tags: [auth, security, tokens, oauth]
+```
+
+## Auto-Remember Triggers
+
+Claude should proactively suggest remembering when:
+
+1. **User explicitly states a rule**
+   > "Always use async/await, never callbacks"
+
+   Suggest: `/remember "Always use async/await, never callbacks"`
+
+2. **Important decision is made**
+   > "Let's go with PostgreSQL for the database"
+
+   Suggest: `/remember --category architecture "Using PostgreSQL as primary database"`
+
+3. **Debugging insight discovered**
+   > "Ah, the issue was the missing CORS header"
+
+   Suggest: `/remember --category debugging "CORS issues: check for missing headers"`
+
+4. **User preference revealed**
+   > "I prefer smaller, focused commits"
+
+   Suggest: `/remember --tags preferences,git "User prefers smaller, focused commits"`
+
+## Memory Categories
+
+| Category | Use For |
+|----------|---------|
+| architecture | System design, tech choices, constraints |
+| conventions | Coding style, naming, formatting |
+| patterns | Common code patterns in the project |
+| workflows | How to do common tasks |
+| debugging | Known issues and solutions |
+| preferences | User's stated preferences |
+
+## Related Commands
+
+- `/recall` - Retrieve stored memories
+- `/forget` - Remove a memory
+- `/checkpoint` - Save session state