@wipal/agent-team 1.0.3 → 1.1.0

package/templates/skills/memory/recall.md

@@ -0,0 +1,160 @@
+---
+name: recall
+description: Search and retrieve memories from long-term storage using semantic search
+invocable: true
+---
+
+# Recall Skill
+
+Search and retrieve memories from SimpleMem long-term memory system.
+
+## When to Use
+
+Use this skill when:
+- Starting a new task - check relevant history first
+- Encountering a bug - check similar past issues
+- Making a decision - review past decisions
+- Implementing a feature - look for existing patterns
+- User asks about project history or decisions
+- You need context on why something was done a certain way
+
+## How to Use
+
+### Option 1: Basic Search
+
+Call the `memory_search` MCP tool:
+
+```
+memory_search(
+  tenant_id="<agent-name>",
+  query="<what to search for>",
+  k=10
+)
+```
+
+### Option 2: Get Context by Intent
+
+Call the `memory_get_context` MCP tool:
+
+```
+memory_get_context(
+  tenant_id="<agent-name>",
+  intent="<current task or intent>",
+  limit=20
+)
+```
+
+### Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `tenant_id` | Yes | Your agent name (for memory isolation) |
+| `query` | Yes (search) | Natural language search query |
+| `intent` | Yes (context) | Current task intent for relevant context |
+| `k` / `limit` | No | Number of results (default: 10) |
+
+## Examples
+
+### Searching for Decisions
+
+```
+memory_search(
+  tenant_id="dev-fe",
+  query="why did we choose react query over swr",
+  k=5
+)
+```
+
+### Searching for Bug Fixes
+
+```
+memory_search(
+  tenant_id="dev-be",
+  query="websocket memory leak fix",
+  k=5
+)
+```
+
+### Getting Context for a Task
+
+```
+memory_get_context(
+  tenant_id="dev-fe",
+  intent="implementing user authentication with JWT",
+  limit=10
+)
+```
+
+### Searching for Patterns
+
+```
+memory_search(
+  tenant_id="dev-fe",
+  query="form validation pattern",
+  k=5
+)
+```
+
+## Search Tips
+
+1. **Use Natural Language**: The search is semantic, so describe what you're looking for naturally
+2. **Include Context**: "why did we..." or "how to..." works well
+3. **Use Multiple Terms**: "authentication JWT token refresh" finds more specific results
+4. **Try Different Phrasings**: If no results, rephrase the query
+
+## Interpreting Results
+
+Results are returned as JSON:
+
+```json
+{
+  "success": true,
+  "results": [
+    {
+      "entry_id": "uuid",
+      "content": "The stored memory content...",
+      "metadata": {
+        "type": "decision",
+        "importance": 8,
+        "tags": ["react", "data-fetching"]
+      },
+      "timestamp": "2025-01-15T10:30:00",
+      "score": 0.85  // Similarity score (higher = better match)
+    }
+  ]
+}
+```
+
+- **score**: Similarity score (0-1, higher = better match)
+- **content**: The stored information
+- **metadata**: Type, importance, tags
+- **timestamp**: When it was stored
+
+## Workflow Integration
+
+### Before Starting a Task
+
+```
+1. Call memory_get_context with your task intent
+2. Review relevant past decisions and patterns
+3. Check for any related bug fixes or learnings
+4. Proceed with context-aware implementation
+```
+
+### When Encountering an Issue
+
+```
+1. Call memory_search with the error or issue description
+2. Look for similar past problems and solutions
+3. Apply learnings or escalate if new issue
+4. Store the new fix with /remember
+```
+
+### When Making Decisions
+
+```
+1. Search for related past decisions
+2. Review rationale and trade-offs
+3. Make new decision with historical context
+4. Store new decision with /remember
+```

package/templates/skills/memory/reflect.md

@@ -0,0 +1,168 @@
+---
+name: reflect
+description: Consolidate memories, detect patterns, and synthesize learnings from recent work
+invocable: true
+---
+
+# Reflect Skill
+
+Consolidate memories, detect patterns, and synthesize learnings from your recent work.
+
+## When to Use
+
+Use this skill when:
+- End of a significant work session
+- After completing a feature or task
+- Weekly/monthly reflection
+- Before starting a major new phase
+- When you feel you've accumulated learnings to consolidate
+- User asks for a summary of recent work
+
+## How to Use
+
+### Option 1: Full Consolidation
+
+Call the `memory_consolidate` MCP tool:
+
+```
+memory_consolidate(
+  tenant_id="<agent-name>"
+)
+```
+
+This will:
+1. Analyze recent memories
+2. Detect patterns and themes
+3. Create synthesized summary entries
+4. Link related memories
+5. Archive redundant entries
+
+### Option 2: Get Summary
+
+Call `memory_get_context` with reflection intent:
+
+```
+memory_get_context(
+  tenant_id="<agent-name>",
+  intent="reflection summary patterns recent work",
+  limit=30
+)
+```
+
+## What Consolidation Does
+
+### Pattern Detection
+
+Identifies recurring themes across memories:
+- Frequently used patterns
+- Repeated decisions or choices
+- Common bug types or issues
+- Emerging conventions
+
+### Theme Synthesis
+
+Creates high-level summaries:
+- "Authentication patterns used: JWT with refresh tokens, stored in httpOnly cookies"
+- "Testing approach: Vitest for unit, Playwright for E2E, MSW for API mocking"
+- "State management preference: Zustand for global, React Query for server state"
+
+### Memory Linking
+
+Connects related entries:
+- Bug fix → Root cause entry
+- Decision → Implementation entry
+- Pattern → Usage examples
+
+### Cleanup
+
+Archives redundant or obsolete entries:
+- Superseded decisions
+- Duplicate entries
+- Temporary notes that are no longer relevant
+
+## Example Workflow
+
+### End of Session Reflection
+
+```
+1. Store any final memories with /remember
+2. Call memory_consolidate to synthesize
+3. Review the consolidated patterns
+4. Update knowledge.md if significant new patterns
+```
+
+### Weekly Review
+
+```
+1. Recall recent work: /recall "past week work summary"
+2. Reflect and consolidate: /reflect
+3. Identify patterns and learnings
+4. Update project documentation
+```
+
+## Output Format
+
+Consolidation returns:
+
+```json
+{
+  "success": true,
+  "summary": {
+    "memories_analyzed": 45,
+    "patterns_detected": [
+      {
+        "pattern": "Prefer composition over inheritance for React components",
+        "frequency": 8,
+        "examples": ["Button variants", "Form fields", "Card layouts"]
+      }
+    ],
+    "themes": [
+      "Performance optimization focus",
+      "Accessibility improvements",
+      "Test coverage expansion"
+    ],
+    "recommendations": [
+      "Consider extracting common component patterns to shared library",
+      "Document performance optimization checklist"
+    ]
+  }
+}
+```
+
+## Best Practices
+
+1. **Regular Reflection**: Consolidate at end of each work session
+2. **Review Before Big Changes**: Check patterns before major refactors
+3. **Update Documentation**: Move consolidated patterns to knowledge.md
+4. **Share with Team**: Important patterns should be shared with other agents
+
+## Integration with knowledge.md
+
+After consolidation:
+
+1. **High-Value Patterns** → Add to knowledge.md
+2. **Conventions** → Update project rules
+3. **Decisions** → Update ADR (Architecture Decision Records)
+4. **Learnings** → Add to lessons.md
+
+## Example Consolidation Session
+
+```
+# End of session
+
+/remember "Implemented lazy loading for images using IntersectionObserver"
+
+/remember "Added error boundary wrapper for all route components"
+
+/remember "Fixed layout shift issue by reserving space with aspect-ratio"
+
+# Now consolidate
+/reflect
+
+# Output:
+# - Pattern detected: Performance optimization focus
+# - Theme: Core Web Vitals improvements
+# - Recommendation: Create performance checklist
+
+# Update knowledge.md with new patterns
+```

package/templates/skills/memory/remember.md

@@ -0,0 +1,105 @@
+---
+name: remember
+description: Store important information to long-term memory for later retrieval
+invocable: true
+---
+
+# Remember Skill
+
+Store important information to SimpleMem long-term memory system.
+
+## When to Use
+
+Use this skill when:
+- User makes an important decision
+- You complete a significant task or feature
+- You learn a new pattern or best practice
+- You fix a bug and want to remember the solution
+- User shares project-specific knowledge
+- You establish conventions or architecture decisions
+
+## How to Use
+
+Call the `memory_add` MCP tool:
+
+```
+memory_add(
+  tenant_id="<agent-name>",
+  content="<what to remember>",
+  metadata={
+    "type": "decision|pattern|bugfix|learning|convention|architecture",
+    "importance": 1-10,
+    "tags": ["relevant", "tags"]
+  }
+)
+```
+
+### Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `tenant_id` | Yes | Your agent name (for memory isolation) |
+| `content` | Yes | The information to remember (be specific and detailed) |
+| `metadata.type` | No | Category: decision, pattern, bugfix, learning, convention, architecture |
+| `metadata.importance` | No | Priority 1-10 (default: 5) |
+| `metadata.tags` | No | Array of relevant tags for filtering |
+
+## Examples
+
+### Storing a Decision
+
+```
+memory_add(
+  tenant_id="dev-fe",
+  content="Decided to use React Query instead of SWR for data fetching. Rationale: Better caching control, more comprehensive documentation, wider community support. Date: 2025-01-15. Discussed with: tech-lead",
+  metadata={
+    "type": "decision",
+    "importance": 8,
+    "tags": ["react", "data-fetching", "architecture"]
+  }
+)
+```
+
+### Storing a Bug Fix
+
+```
+memory_add(
+  tenant_id="dev-be",
+  content="Fixed memory leak in WebSocket connection handler. Root cause: Event listeners not cleaned up on disconnect. Solution: Added cleanup in useEffect return and component unmount. File: src/services/websocket.ts",
+  metadata={
+    "type": "bugfix",
+    "importance": 7,
+    "tags": ["websocket", "memory-leak", "bugfix"]
+  }
+)
+```
+
+### Storing a Pattern
+
+```
+memory_add(
+  tenant_id="dev-fe",
+  content="Pattern: For form handling, use react-hook-form with Zod schema validation. Structure: Define schema → infer type → use useForm with zodResolver. Example: schemas/user.ts has UserSchema, components/UserForm.tsx uses it.",
+  metadata={
+    "type": "pattern",
+    "importance": 6,
+    "tags": ["forms", "react-hook-form", "zod", "validation"]
+  }
+)
+```
+
+## Best Practices
+
+1. **Be Specific**: Include file paths, function names, dates, and rationale
+2. **Use Tags**: Add relevant tags for easier retrieval
+3. **Rate Importance**: Higher importance (8-10) for critical decisions
+4. **Include Context**: Why was this decision made? Who was involved?
+5. **Link to Code**: Mention specific files or functions when relevant
+
+## Tips for Good Memory Entries
+
+- Start with WHAT, then WHY, then HOW
+- Include the date or reference to when it happened
+- Name the people/agents involved in decisions
+- Reference related decisions or patterns
+- Note any trade-offs considered

package/templates/tasks/lessons.md.tmpl

@@ -0,0 +1,77 @@
+# Lessons Learned
+
+> Self-improvement log based on Boris Cherny's approach
+> Updated after EVERY correction to prevent repeat mistakes
+
+---
+
+## Format
+
+### YYYY-MM-DD: [Lesson Title]
+**What happened:** [Description of the situation]
+**Context:** [When/where this occurred]
+**Lesson:** [What we learned]
+**Rule added:** [Rule to prevent same mistake]
+**Code example:** (if applicable)
+
+```typescript
+// ✅ Good
+good_code_here();
+
+// ❌ Bad
+bad_code_here();
+```
+
+---
+
+## Pattern Promotion
+
+| Stage | Condition | Location |
+|-------|-----------|----------|
+| **Lesson** | New finding | lessons.md |
+| **Pattern** | Used 3+ times successfully | knowledge.md |
+| **Skill** | High confidence, reusable | SKILL.md |
+| **Rule** | Proven reliable | rules/ |
+
+---
+
+## Recent Lessons
+
+### {{DATE}}: [First Lesson Title]
+**What happened:**
+**Context:**
+**Lesson:**
+**Rule added:**
+
+---
+
+## Common Pitfalls to Avoid
+
+### General
+- ❌ Committing without verification
+- ❌ Over-engineering simple solutions
+- ❌ Not handling edge cases
+- ❌ Ignoring user corrections
+
+### {{ROLE_NAME}} Specific
+- ❌ [Role-specific pitfall 1]
+- ❌ [Role-specific pitfall 2]
+
+---
+
+## Corrections Received
+
+### [Date]: [Correction Description]
+**From:** User/Reviewer
+**What was wrong:**
+**What I did:**
+**Pattern identified:**
+
+---
+
+## Statistics
+
+- Total lessons: 0
+- This week: 0
+- This month: 0
+- Most common category: N/A

package/templates/tasks/todo.md.tmpl

@@ -0,0 +1,53 @@
+# Task: {{TASK_NAME}}
+
+## Overview
+**Description:** {{TASK_DESCRIPTION}}
+**Created:** {{CREATED_AT}}
+**Status:** In Progress
+
+---
+
+## Plan
+
+### Steps
+- [ ] Step 1: [Description]
+- [ ] Step 2: [Description]
+- [ ] Step 3: [Description]
+
+### Files to Modify
+- [ ] `path/to/file1` - [Change description]
+- [ ] `path/to/file2` - [Change description]
+
+---
+
+## Progress
+
+### Completed
+- [x] [Completed item]
+
+### In Progress
+- [ ] [Current item]
+
+### Blocked
+- [ ] [Blocked item] - **Reason:** [Why blocked]
+
+---
+
+## Review
+
+### Summary
+[High-level summary of changes made]
+
+### Verification
+- [ ] Code runs without errors
+- [ ] Tests pass
+- [ ] Changes verified manually
+- [ ] No unintended side effects
+
+### Lessons Learned
+[Add lessons for tasks/lessons.md]
+
+---
+
+## Notes
+[Any additional notes]

package/src/commands/switch.js

@@ -1,53 +0,0 @@
-/**
- * Switch command - Show instructions to switch to an agent
- */
-
-import chalk from 'chalk';
-import { isInitialized, agentExists, getAgentDir } from '../utils/file-utils.js';
-
-/**
- * Switch to an agent
- */
-export async function switchCommand(name) {
-  const projectRoot = process.cwd();
-
-  // Check if initialized
-  if (!(await isInitialized(projectRoot))) {
-    console.log(chalk.red('❌ Project not initialized'));
-    console.log(chalk.gray('   Run `npx @wipal/agent-team init` first'));
-    return;
-  }
-
-  // Check if agent exists
-  if (!(await agentExists(name, projectRoot))) {
-    console.log(chalk.red(`❌ Agent '${name}' not found`));
-    console.log('');
-    console.log(chalk.gray('List available agents:'));
-    console.log(chalk.cyan('   npx @wipal/agent-team list'));
-    return;
-  }
-
-  const agentDir = getAgentDir(name, projectRoot);
-  const claudeMdPath = `${agentDir}/CLAUDE.md`;
-
-  console.log(chalk.green(`✓ Switching to agent: ${name}`));
-  console.log('');
-  console.log(chalk.blue('Agent configuration:'));
-  console.log(chalk.gray(`   ${claudeMdPath}`));
-  console.log('');
-  console.log(chalk.blue('How to use in Claude Code:'));
-  console.log('');
-  console.log(chalk.white('Option 1: Use the agent\'s CLAUDE.md directly'));
-  console.log(chalk.gray('   Claude Code will read instructions from:'));
-  console.log(chalk.cyan(`   ${claudeMdPath}`));
-  console.log('');
-  console.log(chalk.white('Option 2: Copy content to project root CLAUDE.md'));
-  console.log(chalk.gray('   If you want this agent to be the default:'));
-  console.log(chalk.cyan(`   cp ${claudeMdPath} .claude/CLAUDE.md`));
-  console.log('');
-  console.log(chalk.white('Option 3: Use /switch command (if available)'));
-  console.log(chalk.cyan(`   /switch ${name}`));
-  console.log('');
-  console.log(chalk.gray('The agent has the following skills available:'));
-  console.log(chalk.gray(`   ${agentDir}/skills/`));
-}