omgkit 2.5.2 → 2.7.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 • 76 Skills • 10 Modes
+> 23 Agents • 58 Commands • 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,7 +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 |
-| **Skills** | 76 | Domain expertise modules |
+| **Skills** | 88 | Domain expertise modules |
 | **Modes** | 10 | Behavioral configurations |
 | **Sprint Management** | ✅ | Vision, backlog, team autonomy |
 | **Omega Thinking** | ✅ | 7 modes for 10x-1000x solutions |
@@ -204,6 +204,25 @@ Switch modes with: `/mode <name>`
 | 🕸️ Systemic | Interconnections and emergence |
 | ⚛️ Quantum | Multiple possibilities |
 
+## 🧠 AI Engineering Skills (12)
+
+Based on Chip Huyen's "AI Engineering" book, OMGKIT includes comprehensive skills for building production AI applications:
+
+| Skill | Description |
+|-------|-------------|
+| `foundation-models` | Model architecture, sampling, structured outputs |
+| `evaluation-methodology` | AI-as-judge, semantic similarity, ELO ranking |
+| `ai-system-evaluation` | Benchmarks, model selection, cost analysis |
+| `prompt-engineering` | Few-shot, chain-of-thought, injection defense |
+| `rag-systems` | Chunking, embedding, hybrid retrieval, reranking |
+| `ai-agents` | Tool use, ReAct, Plan-and-Execute, memory |
+| `finetuning` | LoRA, QLoRA, PEFT, model merging |
+| `dataset-engineering` | Curation, deduplication, synthesis |
+| `inference-optimization` | Quantization, batching, caching, vLLM |
+| `ai-architecture` | Gateway, routing, observability |
+| `guardrails-safety` | Input/output guards, PII protection |
+| `user-feedback` | Explicit/implicit signals, A/B testing |
+
 ## 🛠️ CLI Commands
 
 ```bash

package/lib/cli.js

@@ -58,7 +58,7 @@ ${COLORS.magenta}╔════════════════════
 `;
 
 /**
- * Get the plugin installation directory
+ * Get the plugin backup directory (for reference/updates)
  * @param {string} [homeDir] - Optional home directory override for testing
  * @returns {string} Plugin directory path
  */
@@ -67,6 +67,160 @@ export function getPluginDir(homeDir) {
   return join(home, '.claude', 'plugins', 'omgkit');
 }
 
+/**
+ * Get the Claude Code commands directory
+ * @param {string} [homeDir] - Optional home directory override for testing
+ * @returns {string} Commands directory path
+ */
+export function getCommandsDir(homeDir) {
+  const home = homeDir || process.env.HOME || process.env.USERPROFILE;
+  return join(home, '.claude', 'commands');
+}
+
+/**
+ * Get the Claude Code skills directory
+ * @param {string} [homeDir] - Optional home directory override for testing
+ * @returns {string} Skills directory path
+ */
+export function getSkillsDir(homeDir) {
+  const home = homeDir || process.env.HOME || process.env.USERPROFILE;
+  return join(home, '.claude', 'skills');
+}
+
+/**
+ * Get the Claude Code agents directory
+ * @param {string} [homeDir] - Optional home directory override for testing
+ * @returns {string} Agents directory path
+ */
+export function getAgentsDir(homeDir) {
+  const home = homeDir || process.env.HOME || process.env.USERPROFILE;
+  return join(home, '.claude', 'agents');
+}
+
+/**
+ * Copy commands from plugin to Claude Code commands directory
+ * Commands are flattened with category prefix (e.g., dev/fix.md -> dev-fix.md)
+ * @param {string} pluginSrc - Source plugin directory
+ * @param {string} commandsDest - Destination commands directory
+ * @returns {number} Number of commands copied
+ */
+function copyCommands(pluginSrc, commandsDest) {
+  const commandsSrc = join(pluginSrc, 'commands');
+  if (!existsSync(commandsSrc)) return 0;
+
+  mkdirSync(commandsDest, { recursive: true });
+  let count = 0;
+
+  // Get all category directories
+  const categories = readdirSync(commandsSrc).filter(f =>
+    statSync(join(commandsSrc, f)).isDirectory()
+  );
+
+  for (const category of categories) {
+    const categoryPath = join(commandsSrc, category);
+    const files = readdirSync(categoryPath).filter(f => f.endsWith('.md'));
+
+    for (const file of files) {
+      const srcPath = join(categoryPath, file);
+      // Use category prefix for clarity (e.g., dev-fix.md)
+      const destName = `${category}-${file}`;
+      const destPath = join(commandsDest, destName);
+      cpSync(srcPath, destPath);
+      count++;
+    }
+  }
+
+  return count;
+}
+
+/**
+ * Copy skills from plugin to Claude Code skills directory
+ * Preserves the skill directory structure (category/skill-name/SKILL.md)
+ * @param {string} pluginSrc - Source plugin directory
+ * @param {string} skillsDest - Destination skills directory
+ * @returns {number} Number of skills copied
+ */
+function copySkills(pluginSrc, skillsDest) {
+  const skillsSrc = join(pluginSrc, 'skills');
+  if (!existsSync(skillsSrc)) return 0;
+
+  mkdirSync(skillsDest, { recursive: true });
+  let count = 0;
+
+  // Get all category directories
+  const categories = readdirSync(skillsSrc).filter(f =>
+    statSync(join(skillsSrc, f)).isDirectory()
+  );
+
+  for (const category of categories) {
+    const categoryPath = join(skillsSrc, category);
+    const skills = readdirSync(categoryPath).filter(f =>
+      statSync(join(categoryPath, f)).isDirectory()
+    );
+
+    for (const skill of skills) {
+      const skillSrcPath = join(categoryPath, skill);
+      // Use flat structure with unique name: category-skill-name
+      const skillDestPath = join(skillsDest, `${category}-${skill}`);
+      cpSync(skillSrcPath, skillDestPath, { recursive: true });
+      count++;
+    }
+  }
+
+  return count;
+}
+
+/**
+ * Copy agents from plugin to Claude Code agents directory
+ * @param {string} pluginSrc - Source plugin directory
+ * @param {string} agentsDest - Destination agents directory
+ * @returns {number} Number of agents copied
+ */
+function copyAgents(pluginSrc, agentsDest) {
+  const agentsSrc = join(pluginSrc, 'agents');
+  if (!existsSync(agentsSrc)) return 0;
+
+  mkdirSync(agentsDest, { recursive: true });
+  let count = 0;
+
+  const files = readdirSync(agentsSrc).filter(f => f.endsWith('.md'));
+
+  for (const file of files) {
+    const srcPath = join(agentsSrc, file);
+    const destPath = join(agentsDest, file);
+    cpSync(srcPath, destPath);
+    count++;
+  }
+
+  return count;
+}
+
+/**
+ * Copy modes as special commands
+ * @param {string} pluginSrc - Source plugin directory
+ * @param {string} commandsDest - Destination commands directory
+ * @returns {number} Number of modes copied
+ */
+function copyModes(pluginSrc, commandsDest) {
+  const modesSrc = join(pluginSrc, 'modes');
+  if (!existsSync(modesSrc)) return 0;
+
+  mkdirSync(commandsDest, { recursive: true });
+  let count = 0;
+
+  const files = readdirSync(modesSrc).filter(f => f.endsWith('.md'));
+
+  for (const file of files) {
+    const srcPath = join(modesSrc, file);
+    // Prefix modes with 'mode-' for clarity
+    const destPath = join(commandsDest, `mode-${file}`);
+    cpSync(srcPath, destPath);
+    count++;
+  }
+
+  return count;
+}
+
 /**
  * Get package version from package.json
  * @returns {string} Version string
@@ -112,15 +266,44 @@ export function installPlugin(options = {}) {
 
   const pluginSrc = join(getPackageRoot(), 'plugin');
   const pluginDest = getPluginDir(homeDir);
+  const commandsDest = getCommandsDir(homeDir);
+  const skillsDest = getSkillsDir(homeDir);
+  const agentsDest = getAgentsDir(homeDir);
 
   if (!existsSync(pluginSrc)) {
     if (!silent) log.error('Plugin source not found. Package may be corrupted.');
     return { success: false, error: 'SOURCE_NOT_FOUND' };
   }
 
+  const stats = {
+    commands: 0,
+    skills: 0,
+    agents: 0,
+    modes: 0
+  };
+
   try {
+    // Step 1: Copy full plugin to backup location for reference
+    if (!silent) log.info('Copying plugin to backup location...');
     mkdirSync(pluginDest, { recursive: true });
     cpSync(pluginSrc, pluginDest, { recursive: true });
+
+    // Step 2: Install commands to ~/.claude/commands/
+    if (!silent) log.info('Installing commands...');
+    stats.commands = copyCommands(pluginSrc, commandsDest);
+
+    // Step 3: Install skills to ~/.claude/skills/
+    if (!silent) log.info('Installing skills...');
+    stats.skills = copySkills(pluginSrc, skillsDest);
+
+    // Step 4: Install agents to ~/.claude/agents/
+    if (!silent) log.info('Installing agents...');
+    stats.agents = copyAgents(pluginSrc, agentsDest);
+
+    // Step 5: Install modes as commands
+    if (!silent) log.info('Installing modes...');
+    stats.modes = copyModes(pluginSrc, commandsDest);
+
   } catch (err) {
     if (!silent) log.error(`Installation failed: ${err.message}`);
     return { success: false, error: err.message };
@@ -128,24 +311,39 @@ export function installPlugin(options = {}) {
 
   if (!silent) {
     log.success('Plugin installed successfully!');
-    log.info(`Location: ${pluginDest}`);
     console.log(`
-${COLORS.bright}Installed:${COLORS.reset}
-  📦 23 Agents
-  ⚡ 54 Commands
-  🧠 43 Skills
-  🎭 9 Modes
+${COLORS.bright}Installed to Claude Code:${COLORS.reset}
+  ${COLORS.cyan}Commands:${COLORS.reset} ${commandsDest} (${stats.commands} commands + ${stats.modes} modes)
+  ${COLORS.cyan}Skills:${COLORS.reset}   ${skillsDest} (${stats.skills} skills)
+  ${COLORS.cyan}Agents:${COLORS.reset}   ${agentsDest} (${stats.agents} agents)
+  ${COLORS.cyan}Backup:${COLORS.reset}   ${pluginDest}
+
+${COLORS.bright}Summary:${COLORS.reset}
+  📦 ${stats.agents} Agents
+  ⚡ ${stats.commands} Commands
+  🧠 ${stats.skills} Skills
+  🎭 ${stats.modes} Modes
 
 ${COLORS.bright}Next steps:${COLORS.reset}
-  1. cd your-project
-  2. omgkit init
-  3. Open Claude Code and type /help
+  1. Restart Claude Code to load new commands
+  2. Type /help to see available commands
+  3. Try /dev-fix, /git-commit, /planning-plan, etc.
 
 ${COLORS.magenta}🔮 Think Omega. Build Omega. Be Omega.${COLORS.reset}
 `);
   }
 
-  return { success: true, path: pluginDest };
+  return {
+    success: true,
+    path: pluginDest,
+    stats,
+    locations: {
+      commands: commandsDest,
+      skills: skillsDest,
+      agents: agentsDest,
+      backup: pluginDest
+    }
+  };
 }
 
 /**
@@ -248,18 +446,23 @@ export function doctor(options = {}) {
   }
 
   const pluginDir = getPluginDir(homeDir);
+  const commandsDir = getCommandsDir(homeDir);
+  const skillsDir = getSkillsDir(homeDir);
+  const agentsDir = getAgentsDir(homeDir);
+
   const result = {
     plugin: { installed: false, components: {} },
+    claudeCode: { commands: 0, skills: 0, agents: 0 },
     project: { initialized: false, files: {} }
   };
 
-  // Check plugin
-  if (!silent) console.log(`${COLORS.bright}Plugin Status${COLORS.reset}`);
+  // Check backup plugin location
+  if (!silent) console.log(`${COLORS.bright}Backup Plugin Location${COLORS.reset}`);
 
   if (existsSync(pluginDir)) {
     result.plugin.installed = true;
     result.plugin.path = pluginDir;
-    if (!silent) log.success(`Installed at ${pluginDir}`);
+    if (!silent) log.success(`Backup at ${pluginDir}`);
 
     const components = [
       { path: 'commands', name: 'Commands' },
@@ -282,7 +485,84 @@ export function doctor(options = {}) {
     });
   } else {
     if (!silent) {
-      log.error('Not installed');
+      log.warn('Backup not found (optional)');
+    }
+  }
+
+  // Check Claude Code directories (the important ones)
+  if (!silent) console.log(`\n${COLORS.bright}Claude Code Integration${COLORS.reset}`);
+
+  // Count commands
+  if (existsSync(commandsDir)) {
+    const commandPrefixes = ['dev-', 'git-', 'planning-', 'quality-', 'context-', 'design-', 'omega-', 'sprint-', 'mode-'];
+    const files = readdirSync(commandsDir).filter(f =>
+      f.endsWith('.md') && commandPrefixes.some(p => f.startsWith(p))
+    );
+    result.claudeCode.commands = files.length;
+    if (!silent) {
+      if (files.length > 0) {
+        log.success(`Commands: ${files.length} installed at ${commandsDir}`);
+      } else {
+        log.warn(`Commands: None found at ${commandsDir}`);
+      }
+    }
+  } else {
+    if (!silent) log.warn(`Commands: Directory not found (${commandsDir})`);
+  }
+
+  // Count skills
+  if (existsSync(skillsDir)) {
+    const skillPrefixes = ['databases-', 'devops-', 'tools-', 'languages-', 'frameworks-', 'frontend-', 'backend-', 'mobile-', 'integrations-', 'security-', 'testing-', 'methodology-', 'ai-engineering-', 'omega-'];
+    const dirs = readdirSync(skillsDir).filter(f => {
+      const fullPath = join(skillsDir, f);
+      return statSync(fullPath).isDirectory() && skillPrefixes.some(p => f.startsWith(p));
+    });
+    result.claudeCode.skills = dirs.length;
+    if (!silent) {
+      if (dirs.length > 0) {
+        log.success(`Skills: ${dirs.length} installed at ${skillsDir}`);
+      } else {
+        log.warn(`Skills: None found at ${skillsDir}`);
+      }
+    }
+  } else {
+    if (!silent) log.warn(`Skills: Directory not found (${skillsDir})`);
+  }
+
+  // Count agents
+  if (existsSync(agentsDir)) {
+    const agentFiles = [
+      'code-reviewer.md', 'architect.md', 'debugger.md', 'api-designer.md',
+      'database-admin.md', 'cicd-manager.md', 'oracle.md', 'researcher.md',
+      'project-manager.md', 'copywriter.md', 'vulnerability-scanner.md',
+      'security-auditor.md', 'journal-writer.md', 'sprint-master.md',
+      'tester.md', 'fullstack-developer.md', 'planner.md', 'docs-manager.md',
+      'git-manager.md', 'ui-ux-designer.md', 'scout.md', 'brainstormer.md',
+      'pipeline-architect.md'
+    ];
+    const installed = agentFiles.filter(f => existsSync(join(agentsDir, f)));
+    result.claudeCode.agents = installed.length;
+    if (!silent) {
+      if (installed.length > 0) {
+        log.success(`Agents: ${installed.length} installed at ${agentsDir}`);
+      } else {
+        log.warn(`Agents: None found at ${agentsDir}`);
+      }
+    }
+  } else {
+    if (!silent) log.warn(`Agents: Directory not found (${agentsDir})`);
+  }
+
+  // Overall status
+  const isInstalled = result.claudeCode.commands > 0 ||
+                      result.claudeCode.skills > 0 ||
+                      result.claudeCode.agents > 0;
+
+  if (!silent) {
+    if (isInstalled) {
+      console.log(`\n${COLORS.green}✓ OMGKIT is properly installed in Claude Code${COLORS.reset}`);
+    } else {
+      console.log(`\n${COLORS.red}✗ OMGKIT is not installed in Claude Code${COLORS.reset}`);
       log.info('Run: omgkit install');
     }
   }
@@ -322,6 +602,34 @@ export function doctor(options = {}) {
   return result;
 }
 
+/**
+ * Remove OMGKIT files from a directory based on naming patterns
+ * @param {string} dir - Directory to clean
+ * @param {string[]} prefixes - File prefixes to remove (e.g., ['dev-', 'git-'])
+ * @returns {number} Number of files removed
+ */
+function cleanOmgkitFiles(dir, prefixes) {
+  if (!existsSync(dir)) return 0;
+
+  let count = 0;
+  const items = readdirSync(dir);
+
+  for (const item of items) {
+    const itemPath = join(dir, item);
+    const stat = statSync(itemPath);
+
+    // Check if item matches any prefix
+    const matchesPrefix = prefixes.some(p => item.startsWith(p));
+
+    if (matchesPrefix) {
+      rmSync(itemPath, { recursive: true, force: true });
+      count++;
+    }
+  }
+
+  return count;
+}
+
 /**
  * Uninstall the plugin
  * @param {Object} options - Options
@@ -338,15 +646,86 @@ export function uninstallPlugin(options = {}) {
   }
 
   const pluginDir = getPluginDir(homeDir);
+  const commandsDir = getCommandsDir(homeDir);
+  const skillsDir = getSkillsDir(homeDir);
+  const agentsDir = getAgentsDir(homeDir);
+
+  const removed = {
+    backup: false,
+    commands: 0,
+    skills: 0,
+    agents: 0
+  };
+
+  // Command prefixes from our categories
+  const commandPrefixes = [
+    'dev-', 'git-', 'planning-', 'quality-', 'context-',
+    'design-', 'omega-', 'sprint-', 'mode-'
+  ];
+
+  // Skill prefixes from our categories
+  const skillPrefixes = [
+    'databases-', 'devops-', 'tools-', 'languages-', 'frameworks-',
+    'frontend-', 'backend-', 'mobile-', 'integrations-', 'security-',
+    'testing-', 'methodology-', 'ai-engineering-', 'omega-'
+  ];
+
+  // Agent files we installed
+  const agentFiles = [
+    'code-reviewer.md', 'architect.md', 'debugger.md', 'api-designer.md',
+    'database-admin.md', 'cicd-manager.md', 'oracle.md', 'researcher.md',
+    'project-manager.md', 'copywriter.md', 'vulnerability-scanner.md',
+    'security-auditor.md', 'journal-writer.md', 'sprint-master.md',
+    'tester.md', 'fullstack-developer.md', 'planner.md', 'docs-manager.md',
+    'git-manager.md', 'ui-ux-designer.md', 'scout.md', 'brainstormer.md',
+    'pipeline-architect.md'
+  ];
 
+  // Remove backup location
   if (existsSync(pluginDir)) {
     rmSync(pluginDir, { recursive: true, force: true });
-    if (!silent) log.success('Plugin uninstalled!');
-    return { success: true, removed: true };
-  } else {
-    if (!silent) log.warn('Plugin not found.');
-    return { success: true, removed: false };
+    removed.backup = true;
+    if (!silent) log.success('Removed backup plugin directory');
   }
+
+  // Remove commands
+  removed.commands = cleanOmgkitFiles(commandsDir, commandPrefixes);
+  if (!silent && removed.commands > 0) {
+    log.success(`Removed ${removed.commands} commands`);
+  }
+
+  // Remove skills
+  removed.skills = cleanOmgkitFiles(skillsDir, skillPrefixes);
+  if (!silent && removed.skills > 0) {
+    log.success(`Removed ${removed.skills} skills`);
+  }
+
+  // Remove agents
+  if (existsSync(agentsDir)) {
+    for (const agentFile of agentFiles) {
+      const agentPath = join(agentsDir, agentFile);
+      if (existsSync(agentPath)) {
+        rmSync(agentPath, { force: true });
+        removed.agents++;
+      }
+    }
+    if (!silent && removed.agents > 0) {
+      log.success(`Removed ${removed.agents} agents`);
+    }
+  }
+
+  const anyRemoved = removed.backup || removed.commands > 0 ||
+                     removed.skills > 0 || removed.agents > 0;
+
+  if (!silent) {
+    if (anyRemoved) {
+      log.success('OMGKIT uninstalled successfully!');
+    } else {
+      log.warn('OMGKIT was not installed.');
+    }
+  }
+
+  return { success: true, removed };
 }
 
 /**

package/package.json

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

package/plugin/skills/ai-engineering/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: ai-engineering
+description: Building production AI applications with Foundation Models. Covers prompt engineering, RAG, agents, finetuning, evaluation, and deployment. Use when working with LLMs, building AI features, or architecting AI systems.
+---
+
+# AI Engineering Skills
+
+Comprehensive skills for building AI applications with Foundation Models.
+
+## AI Engineering Stack
+
+```
+┌─────────────────────────────────────────────────────┐
+│  APPLICATION LAYER                                   │
+│  Prompt Engineering, RAG, Agents, Guardrails        │
+├─────────────────────────────────────────────────────┤
+│  MODEL LAYER                                         │
+│  Model Selection, Finetuning, Evaluation            │
+├─────────────────────────────────────────────────────┤
+│  INFRASTRUCTURE LAYER                                │
+│  Inference Optimization, Caching, Orchestration     │
+└─────────────────────────────────────────────────────┘
+```
+
+## 12 Core Skills
+
+| Skill | Description | Guide |
+|-------|-------------|-------|
+| Foundation Models | Model architecture, sampling, structured outputs | [foundation-models/](foundation-models/SKILL.md) |
+| Evaluation Methodology | Metrics, AI-as-judge, comparative evaluation | [evaluation-methodology/](evaluation-methodology/SKILL.md) |
+| AI System Evaluation | End-to-end evaluation, benchmarks, model selection | [ai-system-evaluation/](ai-system-evaluation/SKILL.md) |
+| Prompt Engineering | System prompts, few-shot, chain-of-thought, defense | [prompt-engineering/](prompt-engineering/SKILL.md) |
+| RAG Systems | Chunking, embedding, retrieval, reranking | [rag-systems/](rag-systems/SKILL.md) |
+| AI Agents | Tool use, planning strategies, memory systems | [ai-agents/](ai-agents/SKILL.md) |
+| Finetuning | LoRA, QLoRA, PEFT, model merging | [finetuning/](finetuning/SKILL.md) |
+| Dataset Engineering | Data quality, curation, synthesis, annotation | [dataset-engineering/](dataset-engineering/SKILL.md) |
+| Inference Optimization | Quantization, batching, caching, speculative decoding | [inference-optimization/](inference-optimization/SKILL.md) |
+| AI Architecture | Gateway, routing, observability, deployment | [ai-architecture/](ai-architecture/SKILL.md) |
+| Guardrails & Safety | Input/output guards, PII protection, injection defense | [guardrails-safety/](guardrails-safety/SKILL.md) |
+| User Feedback | Explicit/implicit signals, feedback loops, A/B testing | [user-feedback/](user-feedback/SKILL.md) |
+
+## Development Process
+
+```
+1. Use Case Evaluation → 2. Model Selection → 3. Evaluation Pipeline
+                                                      ↓
+4. Prompt Engineering → 5. Context (RAG/Agents) → 6. Finetuning (if needed)
+                                                      ↓
+7. Inference Optimization → 8. Deployment → 9. Monitoring & Feedback
+```
+
+## Quick Decision Guide
+
+| Need | Start With |
+|------|------------|
+| Improve output quality | prompt-engineering |
+| Add external knowledge | rag-systems |
+| Multi-step reasoning | ai-agents |
+| Reduce latency/cost | inference-optimization |
+| Measure quality | evaluation-methodology |
+| Protect system | guardrails-safety |
+
+## Reference
+
+Based on "AI Engineering" by Chip Huyen (O'Reilly, 2025).