oh-my-claude-sisyphus 3.4.0 → 3.4.1

package/scripts/sync-metadata.ts

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+/**
+ * Metadata Sync System
+ *
+ * Synchronizes version and metadata from package.json to all documentation files.
+ * Prevents version drift and ensures consistency across the project.
+ *
+ * Usage:
+ *   npm run sync-metadata              # Sync all files
+ *   npm run sync-metadata -- --dry-run # Preview changes
+ *   npm run sync-metadata -- --verify  # Check if files are in sync
+ */
+
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'fs';
+import { join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Color utilities for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+};
+
+function color(text: string, colorCode: string): string {
+  return `${colorCode}${text}${colors.reset}`;
+}
+
+// Metadata interface
+interface Metadata {
+  version: string;
+  description: string;
+  keywords: string[];
+  repository: string;
+  homepage: string;
+  npmPackage: string;
+}
+
+// File sync configuration
+interface FileSync {
+  path: string;
+  replacements: Array<{
+    pattern: RegExp;
+    replacement: (metadata: Metadata) => string;
+    description: string;
+  }>;
+}
+
+// Load metadata from package.json
+function loadMetadata(): Metadata {
+  const projectRoot = resolve(__dirname, '..');
+  const packageJsonPath = join(projectRoot, 'package.json');
+
+  if (!existsSync(packageJsonPath)) {
+    throw new Error(`package.json not found at ${packageJsonPath}`);
+  }
+
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+
+  return {
+    version: packageJson.version,
+    description: packageJson.description || '',
+    keywords: packageJson.keywords || [],
+    repository: packageJson.repository?.url?.replace(/^git\+/, '').replace(/\.git$/, '') || '',
+    homepage: packageJson.homepage || '',
+    npmPackage: packageJson.name || 'oh-my-claude-sisyphus',
+  };
+}
+
+// Get count of agents from agents directory
+function getAgentCount(): number {
+  const projectRoot = resolve(__dirname, '..');
+  const agentsDir = join(projectRoot, 'agents');
+
+  if (!existsSync(agentsDir)) {
+    return 0;
+  }
+
+  const files = readdirSync(agentsDir);
+  return files.filter((f: string) => f.endsWith('.md')).length;
+}
+
+// Get count of skills from skills directory (directories, not files)
+function getSkillCount(): number {
+  const projectRoot = resolve(__dirname, '..');
+  const skillsDir = join(projectRoot, 'skills');
+
+  if (!existsSync(skillsDir)) {
+    return 0;
+  }
+
+  const entries = readdirSync(skillsDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).length;
+}
+
+// Define file sync configurations
+function getFileSyncConfigs(): FileSync[] {
+  const agentCount = getAgentCount();
+  const skillCount = getSkillCount();
+
+  return [
+    {
+      path: 'README.md',
+      replacements: [
+        {
+          pattern: /\[!\[npm version\]\(https:\/\/img\.shields\.io\/npm\/v\/[^)]+\)/g,
+          replacement: (m) => `[![npm version](https://img.shields.io/npm/v/${m.npmPackage}?color=cb3837)`,
+          description: 'npm version badge',
+        },
+        {
+          pattern: /\[!\[npm downloads\]\(https:\/\/img\.shields\.io\/npm\/dm\/[^)]+\)/g,
+          replacement: (m) => `[![npm downloads](https://img.shields.io/npm/dm/${m.npmPackage}?color=blue)`,
+          description: 'npm downloads badge',
+        },
+      ],
+    },
+    {
+      path: 'docs/FULL-README.md',
+      replacements: [
+        {
+          pattern: /\[!\[Version\]\(https:\/\/img\.shields\.io\/badge\/version-[^-]+-[^)]+\)/g,
+          replacement: (m) => `[![Version](https://img.shields.io/badge/version-${m.version}-ff6b6b)`,
+          description: 'Version badge',
+        },
+        {
+          pattern: /\[!\[npm version\]\(https:\/\/img\.shields\.io\/npm\/v\/[^?]+[^)]*\)/g,
+          replacement: (m) => `[![npm version](https://img.shields.io/npm/v/${m.npmPackage}?color=cb3837)`,
+          description: 'npm version badge',
+        },
+        {
+          pattern: /## NEW in \d+\.\d+\.\d+:/g,
+          replacement: (m) => `## NEW in ${m.version}:`,
+          description: 'Version header',
+        },
+        {
+          pattern: /## ⚡ NEW in \d+\.\d+:/g,
+          replacement: (m) => {
+            const [major, minor] = m.version.split('.');
+            return `## ⚡ NEW in ${major}.${minor}:`;
+          },
+          description: 'Major.minor version header',
+        },
+      ],
+    },
+    {
+      path: '.github/CLAUDE.md',
+      replacements: [
+        {
+          pattern: /\*\*\d+ specialized agents\*\*/g,
+          replacement: () => `**${agentCount} specialized agents**`,
+          description: 'Agent count',
+        },
+        {
+          pattern: /\*\*\d+ slash commands\*\*/g,
+          replacement: () => `**${skillCount} slash commands**`,
+          description: 'Slash command count',
+        },
+      ],
+    },
+    {
+      path: 'docs/ARCHITECTURE.md',
+      replacements: [
+        {
+          pattern: /version \d+\.\d+\.\d+/gi,
+          replacement: (m) => `version ${m.version}`,
+          description: 'Architecture version references',
+        },
+      ],
+    },
+    {
+      path: 'CHANGELOG.md',
+      replacements: [
+        // CHANGELOG is manually maintained, only verify latest version exists
+        {
+          pattern: /^## \[\d+\.\d+\.\d+\]/m,
+          replacement: (m) => `## [${m.version}]`,
+          description: 'Latest version header (verify only)',
+        },
+      ],
+    },
+  ];
+}
+
+// Sync a single file
+function syncFile(
+  config: FileSync,
+  metadata: Metadata,
+  dryRun: boolean,
+  projectRoot: string
+): { changed: boolean; changes: string[] } {
+  const filePath = join(projectRoot, config.path);
+
+  if (!existsSync(filePath)) {
+    console.log(color(`⚠ File not found: ${config.path}`, colors.yellow));
+    return { changed: false, changes: [] };
+  }
+
+  let content = readFileSync(filePath, 'utf-8');
+  const originalContent = content;
+  const changes: string[] = [];
+
+  for (const replacement of config.replacements) {
+    const matches = content.match(replacement.pattern);
+    if (matches) {
+      const newContent = content.replace(
+        replacement.pattern,
+        replacement.replacement(metadata)
+      );
+
+      if (newContent !== content) {
+        changes.push(replacement.description);
+        content = newContent;
+      }
+    }
+  }
+
+  const changed = content !== originalContent;
+
+  if (changed && !dryRun) {
+    writeFileSync(filePath, content, 'utf-8');
+  }
+
+  return { changed, changes };
+}
+
+// Verify all files are in sync
+function verifySync(metadata: Metadata, projectRoot: string): boolean {
+  console.log(color('\n🔍 Verifying metadata sync...', colors.cyan));
+
+  const configs = getFileSyncConfigs();
+  let allInSync = true;
+
+  for (const config of configs) {
+    const result = syncFile(config, metadata, true, projectRoot);
+
+    if (result.changed) {
+      allInSync = false;
+      console.log(color(`✗ ${config.path}`, colors.red));
+      result.changes.forEach(change => {
+        console.log(color(`  - ${change} needs update`, colors.yellow));
+      });
+    } else {
+      console.log(color(`✓ ${config.path}`, colors.green));
+    }
+  }
+
+  return allInSync;
+}
+
+// Main sync operation
+function syncAll(dryRun: boolean): void {
+  const projectRoot = resolve(__dirname, '..');
+  const metadata = loadMetadata();
+
+  console.log(color('\n📦 Metadata Sync System', colors.bright));
+  console.log(color('========================\n', colors.bright));
+  console.log(`Version: ${color(metadata.version, colors.green)}`);
+  console.log(`Package: ${color(metadata.npmPackage, colors.cyan)}`);
+  console.log(`Agents: ${color(String(getAgentCount()), colors.blue)}`);
+  console.log(`Skills: ${color(String(getSkillCount()), colors.blue)}`);
+
+  if (dryRun) {
+    console.log(color('\n🔍 DRY RUN MODE - No files will be modified\n', colors.yellow));
+  }
+
+  const configs = getFileSyncConfigs();
+  let totalChanges = 0;
+
+  for (const config of configs) {
+    const result = syncFile(config, metadata, dryRun, projectRoot);
+
+    if (result.changed) {
+      totalChanges++;
+      const status = dryRun ? '📝' : '✓';
+      console.log(color(`\n${status} ${config.path}`, colors.cyan));
+      result.changes.forEach(change => {
+        console.log(color(`  - ${change}`, colors.blue));
+      });
+    }
+  }
+
+  if (totalChanges === 0) {
+    console.log(color('\n✅ All files are already in sync!', colors.green));
+  } else if (dryRun) {
+    console.log(color(`\n📊 ${totalChanges} file(s) would be updated`, colors.yellow));
+    console.log(color('Run without --dry-run to apply changes', colors.cyan));
+  } else {
+    console.log(color(`\n✅ Successfully synced ${totalChanges} file(s)!`, colors.green));
+  }
+}
+
+// CLI
+function main(): void {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes('--dry-run');
+  const verify = args.includes('--verify');
+  const help = args.includes('--help') || args.includes('-h');
+
+  if (help) {
+    console.log(`
+${color('Metadata Sync System', colors.bright)}
+
+${color('Usage:', colors.cyan)}
+  npm run sync-metadata              Sync all files
+  npm run sync-metadata -- --dry-run Preview changes without writing
+  npm run sync-metadata -- --verify  Check if files are in sync
+
+${color('Description:', colors.cyan)}
+  Synchronizes version and metadata from package.json to documentation files.
+  Prevents version drift and ensures consistency across the project.
+
+${color('Files Synced:', colors.cyan)}
+  - README.md (npm badges)
+  - docs/FULL-README.md (version badges and headers)
+  - .github/CLAUDE.md (agent/skill counts)
+  - docs/ARCHITECTURE.md (version references)
+  - CHANGELOG.md (version header verification)
+
+${color('Examples:', colors.cyan)}
+  npm run sync-metadata              # Apply all updates
+  npm run sync-metadata -- --dry-run # See what would change
+  npm run sync-metadata -- --verify  # CI/CD verification
+`);
+    return;
+  }
+
+  try {
+    if (verify) {
+      const projectRoot = resolve(__dirname, '..');
+      const metadata = loadMetadata();
+      const inSync = verifySync(metadata, projectRoot);
+
+      if (!inSync) {
+        console.log(color('\n❌ Files are out of sync!', colors.red));
+        console.log(color('Run: npm run sync-metadata', colors.cyan));
+        process.exit(1);
+      } else {
+        console.log(color('\n✅ All files are in sync!', colors.green));
+      }
+    } else {
+      syncAll(dryRun);
+    }
+  } catch (error) {
+    console.error(color('\n❌ Error:', colors.red), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+
+// Export for testing
+export { loadMetadata, syncFile, verifySync, getAgentCount, getSkillCount };

package/skills/build-fix/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: build-fix
+description: Fix build and TypeScript errors with minimal changes
+---
+
+# Build Fix Skill
+
+Fix build and TypeScript errors quickly with minimal code changes. Get the build green without refactoring.
+
+## When to Use
+
+This skill activates when:
+- User says "fix the build", "build is broken"
+- TypeScript compilation fails
+- `npm run build` or `tsc` reports errors
+- User requests "minimal fixes" for errors
+
+## What It Does
+
+Delegates to the `build-fixer` agent (Sonnet model) to:
+
+1. **Collect Errors**
+   - Run `npx tsc --noEmit` to get all TypeScript errors
+   - Or run `npm run build` to get build failures
+   - Categorize errors by type and severity
+
+2. **Fix Strategically**
+   - Add type annotations where missing
+   - Add null checks where needed
+   - Fix import/export statements
+   - Resolve module resolution issues
+   - Fix linter errors blocking build
+
+3. **Minimal Diff Strategy**
+   - NO refactoring of unrelated code
+   - NO architectural changes
+   - NO performance optimizations
+   - ONLY what's needed to make build pass
+
+4. **Verify**
+   - Run `npx tsc --noEmit` after each fix
+   - Ensure no new errors introduced
+   - Stop when build passes
+
+## Agent Delegation
+
+```
+Task(
+  subagent_type="oh-my-claudecode:build-fixer",
+  model="sonnet",
+  prompt="BUILD FIX TASK
+
+Fix all build and TypeScript errors with minimal changes.
+
+Requirements:
+- Run tsc/build to collect errors
+- Fix errors one at a time
+- Verify each fix doesn't introduce new errors
+- NO refactoring, NO architectural changes
+- Stop when build passes
+
+Output: Build error resolution report with:
+- List of errors fixed
+- Lines changed per fix
+- Final build status"
+)
+```
+
+## Stop Conditions
+
+The build-fixer agent stops when:
+- `npx tsc --noEmit` exits with code 0
+- `npm run build` completes successfully
+- No new errors introduced
+
+## Output Format
+
+```
+BUILD FIX REPORT
+================
+
+Errors Fixed: 12
+Files Modified: 8
+Lines Changed: 47
+
+Fixes Applied:
+1. src/utils/validation.ts:15 - Added return type annotation
+2. src/components/Header.tsx:42 - Added null check for props.user
+3. src/api/client.ts:89 - Fixed import path for axios
+...
+
+Final Build Status: ✓ PASSING
+Verification: npx tsc --noEmit (exit code 0)
+```
+
+## Best Practices
+
+- **One fix at a time** - Easier to verify and debug
+- **Minimal changes** - Don't refactor while fixing
+- **Document why** - Comment non-obvious fixes
+- **Test after** - Ensure tests still pass
+
+## Use with Other Skills
+
+Combine with other skills for comprehensive fixing:
+
+**With Ultrawork:**
+```
+/ultrawork fix all build errors
+```
+Spawns multiple build-fixer agents in parallel for different files.
+
+**With Ralph:**
+```
+/ralph fix the build
+```
+Keeps trying until build passes, even if it takes multiple iterations.
+
+**With Pipeline:**
+```
+/pipeline debug "build is failing"
+```
+Uses: explore → architect → build-fixer workflow.

package/skills/code-review/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: code-review
+description: Run a comprehensive code review
+---
+
+# Code Review Skill
+
+Conduct a thorough code review for quality, security, and maintainability with severity-rated feedback.
+
+## When to Use
+
+This skill activates when:
+- User requests "review this code", "code review"
+- Before merging a pull request
+- After implementing a major feature
+- User wants quality assessment
+
+## What It Does
+
+Delegates to the `code-reviewer` agent (Opus model) for deep analysis:
+
+1. **Identify Changes**
+   - Run `git diff` to find changed files
+   - Determine scope of review (specific files or entire PR)
+
+2. **Review Categories**
+   - **Security** - Hardcoded secrets, injection risks, XSS, CSRF
+   - **Code Quality** - Function size, complexity, nesting depth
+   - **Performance** - Algorithm efficiency, N+1 queries, caching
+   - **Best Practices** - Naming, documentation, error handling
+   - **Maintainability** - Duplication, coupling, testability
+
+3. **Severity Rating**
+   - **CRITICAL** - Security vulnerability (must fix before merge)
+   - **HIGH** - Bug or major code smell (should fix before merge)
+   - **MEDIUM** - Minor issue (fix when possible)
+   - **LOW** - Style/suggestion (consider fixing)
+
+4. **Specific Recommendations**
+   - File:line locations for each issue
+   - Concrete fix suggestions
+   - Code examples where applicable
+
+## Agent Delegation
+
+```
+Task(
+  subagent_type="oh-my-claudecode:code-reviewer",
+  model="opus",
+  prompt="CODE REVIEW TASK
+
+Review code changes for quality, security, and maintainability.
+
+Scope: [git diff or specific files]
+
+Review Checklist:
+- Security vulnerabilities (OWASP Top 10)
+- Code quality (complexity, duplication)
+- Performance issues (N+1, inefficient algorithms)
+- Best practices (naming, documentation, error handling)
+- Maintainability (coupling, testability)
+
+Output: Code review report with:
+- Files reviewed count
+- Issues by severity (CRITICAL, HIGH, MEDIUM, LOW)
+- Specific file:line locations
+- Fix recommendations
+- Approval recommendation (APPROVE / REQUEST CHANGES / COMMENT)"
+)
+```
+
+## Output Format
+
+```
+CODE REVIEW REPORT
+==================
+
+Files Reviewed: 8
+Total Issues: 15
+
+CRITICAL (0)
+-----------
+(none)
+
+HIGH (3)
+--------
+1. src/api/auth.ts:42
+   Issue: User input not sanitized before SQL query
+   Risk: SQL injection vulnerability
+   Fix: Use parameterized queries or ORM
+
+2. src/components/UserProfile.tsx:89
+   Issue: Password displayed in plain text in logs
+   Risk: Credential exposure
+   Fix: Remove password from log statements
+
+3. src/utils/validation.ts:15
+   Issue: Email regex allows invalid formats
+   Risk: Accepts malformed emails
+   Fix: Use proven email validation library
+
+MEDIUM (7)
+----------
+...
+
+LOW (5)
+-------
+...
+
+RECOMMENDATION: REQUEST CHANGES
+
+Critical security issues must be addressed before merge.
+```
+
+## Review Checklist
+
+The code-reviewer agent checks:
+
+### Security
+- [ ] No hardcoded secrets (API keys, passwords, tokens)
+- [ ] All user inputs sanitized
+- [ ] SQL/NoSQL injection prevention
+- [ ] XSS prevention (escaped outputs)
+- [ ] CSRF protection on state-changing operations
+- [ ] Authentication/authorization properly enforced
+
+### Code Quality
+- [ ] Functions < 50 lines (guideline)
+- [ ] Cyclomatic complexity < 10
+- [ ] No deeply nested code (> 4 levels)
+- [ ] No duplicate logic (DRY principle)
+- [ ] Clear, descriptive naming
+
+### Performance
+- [ ] No N+1 query patterns
+- [ ] Appropriate caching where applicable
+- [ ] Efficient algorithms (avoid O(n²) when O(n) possible)
+- [ ] No unnecessary re-renders (React/Vue)
+
+### Best Practices
+- [ ] Error handling present and appropriate
+- [ ] Logging at appropriate levels
+- [ ] Documentation for public APIs
+- [ ] Tests for critical paths
+- [ ] No commented-out code
+
+## Approval Criteria
+
+**APPROVE** - No CRITICAL or HIGH issues, minor improvements only
+**REQUEST CHANGES** - CRITICAL or HIGH issues present
+**COMMENT** - Only LOW/MEDIUM issues, no blocking concerns
+
+## Use with Other Skills
+
+**With Pipeline:**
+```
+/pipeline review "implement user authentication"
+```
+Includes code review as part of implementation workflow.
+
+**With Ralph:**
+```
+/ralph code-review then fix all issues
+```
+Review code, get feedback, fix until approved.
+
+**With Ultrawork:**
+```
+/ultrawork review all files in src/
+```
+Parallel code review across multiple files.
+
+## Best Practices
+
+- **Review early** - Catch issues before they compound
+- **Review often** - Small, frequent reviews better than huge ones
+- **Address CRITICAL/HIGH first** - Fix security and bugs immediately
+- **Consider context** - Some "issues" may be intentional trade-offs
+- **Learn from reviews** - Use feedback to improve coding practices