omgkit 2.9.0 → 2.10.0

package/README.md

@@ -7,7 +7,7 @@
 [![License](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
 
 > **AI Team System for Claude Code**
-> 23 Agents • 58 Commands • 88 Skills • 10 Modes
+> 23 Agents • 58 Commands • 29 Workflows • 88 Skills • 10 Modes
 > *"Think Omega. Build Omega. Be Omega."*
 
 OMGKIT transforms Claude Code into an autonomous AI development team with sprint management, specialized agents, and Omega-level thinking for 10x-1000x productivity improvements.
@@ -18,6 +18,7 @@ OMGKIT transforms Claude Code into an autonomous AI development team with sprint
 |-----------|-------|-------------|
 | **Agents** | 23 | Specialized AI team members |
 | **Commands** | 58 | Slash commands for every task |
+| **Workflows** | 29 | Complete development processes |
 | **Skills** | 88 | Domain expertise modules |
 | **Modes** | 10 | Behavioral configurations |
 | **Sprint Management** | ✅ | Vision, backlog, team autonomy |
@@ -163,6 +164,52 @@ After installation, use these commands in Claude Code:
 /team:status        # Show team activity
 ```
 
+## 📋 Workflows (29)
+
+Workflows are orchestrated sequences of agents, commands, and skills that guide complete development processes.
+
+### Development
+| Workflow | Description |
+|----------|-------------|
+| `feature` | Complete feature development from planning to PR |
+| `bug-fix` | Systematic debugging and resolution |
+| `refactor` | Code improvement and restructuring |
+| `code-review` | Comprehensive code review |
+
+### AI Engineering
+| Workflow | Description |
+|----------|-------------|
+| `rag-development` | Build complete RAG systems |
+| `model-evaluation` | AI model evaluation pipeline |
+| `prompt-engineering` | Systematic prompt optimization |
+| `agent-development` | Build AI agents |
+| `fine-tuning` | Model fine-tuning workflow |
+
+### Omega ⭐
+| Workflow | Description |
+|----------|-------------|
+| `10x-improvement` | Tactical enhancements |
+| `100x-architecture` | System redesign |
+| `1000x-innovation` | Industry transformation |
+
+### Sprint Management
+| Workflow | Description |
+|----------|-------------|
+| `sprint-setup` | Initialize and plan sprints |
+| `sprint-execution` | Execute sprint tasks |
+| `sprint-retrospective` | Review and improve |
+
+### Other Categories
+- **Security**: `security-audit`, `penetration-testing`
+- **Database**: `schema-design`, `migration`, `optimization`
+- **API**: `api-design`, `api-testing`
+- **Full Stack**: `full-feature`, `authentication`
+- **Content**: `technical-docs`, `marketing`
+- **Research**: `technology-research`, `best-practices`
+- **Quality**: `performance-optimization`
+
+Use workflows with: `/workflow:<name> "description"`
+
 ## 🎭 Modes (10)
 
 | Mode | Description |

package/lib/cli.js

@@ -389,6 +389,7 @@ export function initProject(options = {}) {
   const templates = [
     { src: 'config.yaml', dest: '.omgkit/config.yaml' },
     { src: 'OMEGA.md', dest: 'OMEGA.md' },
+    { src: 'CLAUDE.md', dest: 'CLAUDE.md' },
     { src: 'vision.yaml', dest: '.omgkit/sprints/vision.yaml' },
     { src: 'backlog.yaml', dest: '.omgkit/sprints/backlog.yaml' },
     { src: 'settings.json', dest: '.omgkit/settings.json' },
@@ -578,7 +579,8 @@ export function doctor(options = {}) {
     const files = [
       '.omgkit/config.yaml',
       '.omgkit/sprints/vision.yaml',
-      'OMEGA.md'
+      'OMEGA.md',
+      'CLAUDE.md'
     ];
 
     files.forEach(f => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omgkit",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "description": "Omega-Level Development Kit - AI Team System for Claude Code. 23 agents, 58 commands, 88 skills, sprint management.",
   "keywords": [
     "claude-code",

package/plugin/workflows/ai-engineering/agent-development.md

@@ -0,0 +1,240 @@
+---
+name: agent-development
+description: Build autonomous AI agents with tools
+category: ai-engineering
+complexity: very-high
+estimated-time: 8-24 hours
+agents:
+  - researcher
+  - planner
+  - architect
+  - fullstack-developer
+  - tester
+  - security-auditor
+skills:
+  - ai-agents
+  - ai-architecture
+  - guardrails-safety
+commands:
+  - /planning:research
+  - /planning:plan-detailed
+  - /dev:feature
+  - /dev:test
+  - /quality:security-scan
+prerequisites:
+  - Agent use case defined
+  - Tool requirements known
+  - LLM API access
+---
+
+# Agent Development Workflow
+
+## Overview
+
+The Agent Development workflow guides you through building autonomous AI agents capable of planning, tool use, and multi-step task execution. It covers architecture, implementation, testing, and safety measures.
+
+## When to Use
+
+- Building autonomous assistants
+- Creating tool-using AI systems
+- Implementing multi-step workflows
+- Building AI copilots
+- Creating agentic applications
+
+## Steps
+
+### Step 1: Research
+**Agent:** researcher
+**Command:** `/planning:research "agent architectures"`
+**Duration:** 1-2 hours
+
+Research phase:
+- Study agent architectures (ReAct, Plan-Execute)
+- Review tool use patterns
+- Analyze memory systems
+- Evaluate safety approaches
+
+**Output:** Research findings
+
+### Step 2: Architecture Design
+**Agent:** architect
+**Command:** `/planning:plan-detailed "agent architecture"`
+**Duration:** 1-2 hours
+
+Design architecture:
+- Define agent capabilities
+- Design tool interface
+- Plan memory system
+- Specify safety boundaries
+
+**Output:** Architecture document
+
+### Step 3: Tool Implementation
+**Agent:** fullstack-developer
+**Duration:** 2-4 hours
+
+Build tools:
+- Define tool schemas
+- Implement tool functions
+- Add input validation
+- Create error handling
+
+**Output:** Tool implementations
+
+### Step 4: Planning System
+**Agent:** fullstack-developer
+**Duration:** 2-4 hours
+
+Implement planning:
+- Task decomposition
+- Step sequencing
+- Dependency handling
+- Progress tracking
+
+**Output:** Planning system
+
+### Step 5: Execution Loop
+**Agent:** fullstack-developer
+**Duration:** 2-4 hours
+
+Build execution:
+- Action selection
+- Tool invocation
+- Result processing
+- Loop control
+
+**Output:** Execution loop
+
+### Step 6: Memory System
+**Agent:** fullstack-developer
+**Duration:** 1-2 hours
+
+Implement memory:
+- Short-term context
+- Long-term storage
+- Memory retrieval
+- Context management
+
+**Output:** Memory system
+
+### Step 7: Safety Implementation
+**Agent:** security-auditor
+**Duration:** 1-2 hours
+
+Add safety:
+- Input validation
+- Output filtering
+- Action limits
+- Guardrails
+
+**Output:** Safety layer
+
+### Step 8: Testing
+**Agent:** tester
+**Command:** `/dev:test`
+**Duration:** 2-4 hours
+
+Test agent:
+- Unit tests for tools
+- Integration tests
+- Behavior tests
+- Safety tests
+
+**Output:** Test suite
+
+### Step 9: Security Review
+**Agent:** security-auditor
+**Command:** `/quality:security-scan`
+**Duration:** 1-2 hours
+
+Security review:
+- Prompt injection prevention
+- Tool abuse prevention
+- Data leak prevention
+- Access control
+
+**Output:** Security report
+
+## Quality Gates
+
+- [ ] Architecture documented and approved
+- [ ] All tools implemented and tested
+- [ ] Planning system working
+- [ ] Execution loop reliable
+- [ ] Memory system functional
+- [ ] Safety measures in place
+- [ ] Security review passed
+- [ ] All tests passing
+
+## Agent Architecture
+
+```
+AI Agent Architecture
+=====================
+
+┌─────────────────────────────────────────┐
+│                 AGENT                    │
+│  ┌─────────────────────────────────┐    │
+│  │          PLANNER                │    │
+│  │   Task → Steps → Actions        │    │
+│  └─────────────────────────────────┘    │
+│                  ↓                       │
+│  ┌─────────────────────────────────┐    │
+│  │         EXECUTOR                │    │
+│  │   Select → Execute → Observe    │    │
+│  └─────────────────────────────────┘    │
+│                  ↓                       │
+│  ┌─────────────────────────────────┐    │
+│  │          TOOLS                  │    │
+│  │   [Search] [Code] [API] [DB]    │    │
+│  └─────────────────────────────────┘    │
+│                  ↓                       │
+│  ┌─────────────────────────────────┐    │
+│  │          MEMORY                 │    │
+│  │   Short-term │ Long-term        │    │
+│  └─────────────────────────────────┘    │
+└─────────────────────────────────────────┘
+```
+
+## Safety Considerations
+
+```
+Agent Safety Checklist
+======================
+[ ] Rate limiting implemented
+[ ] Action scope restricted
+[ ] Sensitive data protected
+[ ] Prompt injection mitigated
+[ ] Human-in-the-loop for risky actions
+[ ] Audit logging enabled
+[ ] Rollback capability
+[ ] Kill switch available
+```
+
+## Tips
+
+- Start with limited tools
+- Add comprehensive logging
+- Implement human approval for risky actions
+- Test extensively with edge cases
+- Monitor agent behavior in production
+- Version control agent prompts
+
+## Example Usage
+
+```bash
+# Build code assistant agent
+/workflow:agent-development "code review agent with git, search, and code tools"
+
+# Build data analysis agent
+/workflow:agent-development "data analyst with SQL, Python, and visualization tools"
+
+# Build customer service agent
+/workflow:agent-development "support agent with knowledge base and ticketing tools"
+```
+
+## Related Workflows
+
+- `rag-development` - For knowledge-augmented agents
+- `prompt-engineering` - For agent prompts
+- `security-audit` - For agent security

package/plugin/workflows/ai-engineering/fine-tuning.md

@@ -0,0 +1,212 @@
+---
+name: fine-tuning
+description: Fine-tune foundation models for specific tasks
+category: ai-engineering
+complexity: high
+estimated-time: 4-16 hours
+agents:
+  - researcher
+  - planner
+  - fullstack-developer
+  - tester
+skills:
+  - finetuning
+  - dataset-engineering
+  - evaluation-methodology
+commands:
+  - /planning:plan
+  - /dev:feature
+  - /dev:test
+prerequisites:
+  - Training data available
+  - Compute resources allocated
+  - Base model selected
+---
+
+# Fine-tuning Workflow
+
+## Overview
+
+The Fine-tuning workflow guides you through fine-tuning foundation models for specific domains or tasks. It covers data preparation, training configuration, execution, evaluation, and deployment.
+
+## When to Use
+
+- Adapting models to domains
+- Improving task-specific performance
+- Reducing inference costs
+- Creating specialized assistants
+- Achieving better quality/latency
+
+## Steps
+
+### Step 1: Strategy Planning
+**Agent:** planner
+**Command:** `/planning:plan "fine-tuning strategy"`
+**Duration:** 30-60 minutes
+
+Define strategy:
+- Identify fine-tuning goals
+- Select base model
+- Choose technique (LoRA, QLoRA, full)
+- Estimate resources
+
+**Output:** Fine-tuning strategy
+
+### Step 2: Data Preparation
+**Agent:** fullstack-developer
+**Duration:** 2-6 hours
+
+Prepare data:
+- Collect training examples
+- Format for fine-tuning
+- Quality filtering
+- Train/val/test split
+
+**Output:** Training dataset
+
+### Step 3: Configuration
+**Agent:** fullstack-developer
+**Duration:** 30-60 minutes
+
+Configure training:
+- Set hyperparameters
+- Configure LoRA/QLoRA settings
+- Setup logging
+- Define checkpoints
+
+**Output:** Training configuration
+
+### Step 4: Training
+**Agent:** fullstack-developer
+**Duration:** 1-8 hours
+
+Run training:
+- Execute training job
+- Monitor metrics
+- Save checkpoints
+- Handle errors
+
+**Output:** Trained model
+
+### Step 5: Evaluation
+**Agent:** tester
+**Command:** `/dev:test`
+**Duration:** 1-2 hours
+
+Evaluate model:
+- Run evaluation suite
+- Compare to baseline
+- Analyze improvements
+- Check for regressions
+
+**Output:** Evaluation report
+
+### Step 6: Deployment
+**Agent:** fullstack-developer
+**Duration:** 1-2 hours
+
+Deploy model:
+- Export model
+- Setup inference
+- Configure serving
+- Validate deployment
+
+**Output:** Deployed model
+
+## Quality Gates
+
+- [ ] Strategy approved
+- [ ] Dataset quality verified
+- [ ] Training completed
+- [ ] Evaluation targets met
+- [ ] No harmful behaviors
+- [ ] Deployment successful
+
+## Fine-tuning Techniques
+
+```
+Fine-tuning Techniques Comparison
+=================================
+
+FULL FINE-TUNING:
+- Updates all parameters
+- Highest quality potential
+- Most compute/memory
+- Best for small models
+
+LoRA (Low-Rank Adaptation):
+- Updates small adapters
+- Good quality/efficiency
+- Lower memory needs
+- Works with large models
+
+QLoRA (Quantized LoRA):
+- LoRA + 4-bit quantization
+- Very memory efficient
+- Good for consumer GPUs
+- Slight quality tradeoff
+
+PROMPT TUNING:
+- Only tunes prompt embeddings
+- Very parameter efficient
+- Limited adaptation
+- Fast training
+```
+
+## Data Format
+
+```json
+// Chat fine-tuning format
+{
+  "messages": [
+    {"role": "system", "content": "You are..."},
+    {"role": "user", "content": "Question..."},
+    {"role": "assistant", "content": "Answer..."}
+  ]
+}
+
+// Instruction fine-tuning format
+{
+  "instruction": "Task description",
+  "input": "Input data",
+  "output": "Expected output"
+}
+```
+
+## Hyperparameters
+
+| Parameter | Typical Range | Notes |
+|-----------|---------------|-------|
+| Learning Rate | 1e-5 to 5e-4 | Lower for larger models |
+| Batch Size | 4-32 | Depends on memory |
+| Epochs | 1-5 | Watch for overfitting |
+| LoRA Rank | 8-64 | Higher = more capacity |
+| LoRA Alpha | 16-128 | Usually 2x rank |
+
+## Tips
+
+- Start with small dataset
+- Use validation set
+- Monitor for overfitting
+- Save checkpoints frequently
+- Compare to baseline early
+- Document everything
+
+## Example Usage
+
+```bash
+# Fine-tune for customer support
+/workflow:fine-tuning "customer support model with company FAQ and tone"
+
+# Fine-tune for code generation
+/workflow:fine-tuning "code completion model for Python with company patterns"
+
+# Fine-tune for domain adaptation
+/workflow:fine-tuning "legal document analyzer with contract examples"
+```
+
+## Related Workflows
+
+- `dataset-engineering` - For data preparation
+- `model-evaluation` - For comprehensive evaluation
+- `prompt-engineering` - Alternative to fine-tuning