claudecode-omc 4.8.3 → 4.9.3

package/scripts/release.ts

@@ -0,0 +1,511 @@
+#!/usr/bin/env tsx
+/**
+ * Release Automation Script
+ *
+ * Automates version bumping, changelog generation, and release notes creation.
+ * Uses conventional commits to categorize changes automatically.
+ *
+ * Usage:
+ *   npm run release -- patch              # Bump patch version
+ *   npm run release -- minor              # Bump minor version
+ *   npm run release -- major              # Bump major version
+ *   npm run release -- 4.9.0              # Set explicit version
+ *   npm run release -- patch --dry-run    # Preview without writing
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join, resolve } from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ROOT = resolve(__dirname, '..');
+
+// ── Colors ──────────────────────────────────────────────────────────────────
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[2m',
+};
+
+function clr(text: string, code: string): string {
+  return `${code}${text}${c.reset}`;
+}
+
+// ── Types ───────────────────────────────────────────────────────────────────
+
+interface ParsedCommit {
+  hash: string;
+  type: string;
+  scope: string;
+  description: string;
+  prNumber: string | null;
+  raw: string;
+}
+
+interface ChangelogSection {
+  title: string;
+  entries: string[];
+}
+
+// ── Version helpers ─────────────────────────────────────────────────────────
+
+function getCurrentVersion(): string {
+  const pkg = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf-8'));
+  return pkg.version;
+}
+
+function getLatestTag(): string {
+  try {
+    return execSync('git describe --tags --abbrev=0', { cwd: ROOT, encoding: 'utf-8' }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function bumpVersion(current: string, bump: string): string {
+  if (/^\d+\.\d+\.\d+$/.test(bump)) return bump;
+
+  const [major, minor, patch] = current.split('.').map(Number);
+  switch (bump) {
+    case 'major': return `${major + 1}.0.0`;
+    case 'minor': return `${major}.${minor + 1}.0`;
+    case 'patch': return `${major}.${minor}.${patch + 1}`;
+    default: throw new Error(`Invalid bump type: ${bump}. Use patch, minor, major, or X.Y.Z`);
+  }
+}
+
+// ── Git helpers ─────────────────────────────────────────────────────────────
+
+function getCommitsSinceTag(tag: string): string[] {
+  const range = tag ? `${tag}..HEAD` : 'HEAD';
+  const raw = execSync(
+    `git log ${range} --format="%H|%s" --no-merges`,
+    { cwd: ROOT, encoding: 'utf-8' }
+  ).trim();
+  return raw ? raw.split('\n') : [];
+}
+
+function getMergeCommitsSinceTag(tag: string): string[] {
+  const range = tag ? `${tag}..HEAD` : 'HEAD';
+  const raw = execSync(
+    `git log ${range} --format="%s" --merges`,
+    { cwd: ROOT, encoding: 'utf-8' }
+  ).trim();
+  return raw ? raw.split('\n') : [];
+}
+
+function getContributors(tag: string): string[] {
+  const merges = getMergeCommitsSinceTag(tag);
+  const contributors = new Set<string>();
+
+  for (const msg of merges) {
+    const match = msg.match(/from\s+([^/]+)\//);
+    if (match && match[1]) {
+      const user = match[1].trim();
+      if (user && !user.startsWith('#')) {
+        contributors.add(user);
+      }
+    }
+  }
+
+  return [...contributors].sort();
+}
+
+function getPRCount(tag: string): number {
+  const merges = getMergeCommitsSinceTag(tag);
+  return merges.filter(m => m.startsWith('Merge pull request')).length;
+}
+
+// ── Commit parsing ──────────────────────────────────────────────────────────
+
+const CONVENTIONAL_RE = /^(?<type>[a-z]+)(?:\((?<scope>[^)]*)\))?:\s*(?<desc>.+)$/;
+
+function parseCommit(line: string): ParsedCommit | null {
+  const [hash, ...rest] = line.split('|');
+  const raw = rest.join('|');
+
+  if (!raw) return null;
+
+  // Skip merge commits, chore(release) version bumps
+  if (raw.startsWith('Merge ')) return null;
+  if (raw.match(/^chore\(release\)/i)) return null;
+
+  const match = raw.match(CONVENTIONAL_RE);
+  if (!match?.groups) return null;
+
+  const prMatch = raw.match(/\(#(\d+)\)/);
+
+  return {
+    hash: hash.trim(),
+    type: match.groups.type,
+    scope: match.groups.scope || '',
+    description: match.groups.desc.replace(/\s*\(#\d+\)$/, '').trim(),
+    prNumber: prMatch ? prMatch[1] : null,
+    raw,
+  };
+}
+
+// ── Categorization ──────────────────────────────────────────────────────────
+
+function categorize(commits: ParsedCommit[]): Map<string, ParsedCommit[]> {
+  const categories = new Map<string, ParsedCommit[]>();
+
+  for (const commit of commits) {
+    let category: string;
+
+    if (commit.type === 'feat') {
+      category = 'features';
+    } else if (commit.type === 'fix' && /^(security|deps)$/.test(commit.scope)) {
+      category = 'security';
+    } else if (commit.type === 'fix') {
+      category = 'fixes';
+    } else if (commit.type === 'refactor') {
+      category = 'refactoring';
+    } else if (commit.type === 'docs') {
+      category = 'docs';
+    } else if (commit.type === 'chore' && commit.scope === 'deps') {
+      category = 'security';
+    } else if (commit.type === 'perf') {
+      category = 'features';
+    } else {
+      // skip test, chore, ci, build, style
+      continue;
+    }
+
+    if (!categories.has(category)) categories.set(category, []);
+    categories.get(category)!.push(commit);
+  }
+
+  return categories;
+}
+
+// ── Changelog generation ────────────────────────────────────────────────────
+
+function formatEntry(commit: ParsedCommit): string {
+  const scope = commit.scope ? `(${commit.scope})` : '';
+  const pr = commit.prNumber ? ` (#${commit.prNumber})` : '';
+  return `- **${commit.type}${scope}: ${commit.description}**${pr}`;
+}
+
+function generateTitle(categories: Map<string, ParsedCommit[]>): string {
+  const parts: string[] = [];
+
+  if (categories.has('features')) {
+    // Pick the most notable feature keywords
+    const feats = categories.get('features')!;
+    const keywords = feats
+      .slice(0, 3)
+      .map(f => {
+        // Extract key noun from description
+        const words = f.description.split(/\s+/);
+        return words.slice(0, 3).join(' ');
+      });
+    parts.push(...keywords);
+  }
+  if (categories.has('security')) parts.push('Security Hardening');
+  if (categories.has('fixes') && !parts.length) parts.push('Bug Fixes');
+
+  if (parts.length === 0) return 'Maintenance Release';
+  if (parts.length <= 3) return parts.join(', ');
+  return parts.slice(0, 3).join(', ');
+}
+
+function generateSummary(categories: Map<string, ParsedCommit[]>, prCount: number): string {
+  const parts: string[] = [];
+  if (categories.has('features')) parts.push(`**${categories.get('features')!.length} new features**`);
+  if (categories.has('security')) parts.push(`**security hardening**`);
+  if (categories.has('fixes')) parts.push(`**${categories.get('fixes')!.length} bug fixes**`);
+
+  if (parts.length === 0) return 'Maintenance release with internal improvements.';
+  return `Release with ${parts.join(', ')} across ${prCount}+ merged PRs.`;
+}
+
+function generateChangelog(
+  version: string,
+  categories: Map<string, ParsedCommit[]>,
+  prCount: number,
+): string {
+  const title = generateTitle(categories);
+  const summary = generateSummary(categories, prCount);
+
+  const sections: ChangelogSection[] = [];
+
+  // Highlights: top features + security
+  const highlights: string[] = [];
+  if (categories.has('features')) {
+    for (const f of categories.get('features')!.slice(0, 5)) {
+      highlights.push(formatEntry(f));
+    }
+  }
+  if (categories.has('security')) {
+    for (const s of categories.get('security')!.slice(0, 3)) {
+      highlights.push(formatEntry(s));
+    }
+  }
+  if (highlights.length) sections.push({ title: 'Highlights', entries: highlights });
+
+  // New Features
+  if (categories.has('features')) {
+    sections.push({ title: 'New Features', entries: categories.get('features')!.map(formatEntry) });
+  }
+
+  // Security & Hardening
+  if (categories.has('security')) {
+    sections.push({ title: 'Security & Hardening', entries: categories.get('security')!.map(formatEntry) });
+  }
+
+  // Bug Fixes
+  if (categories.has('fixes')) {
+    sections.push({ title: 'Bug Fixes', entries: categories.get('fixes')!.map(formatEntry) });
+  }
+
+  // Refactoring
+  if (categories.has('refactoring')) {
+    sections.push({ title: 'Refactoring', entries: categories.get('refactoring')!.map(formatEntry) });
+  }
+
+  // Documentation
+  if (categories.has('docs')) {
+    sections.push({ title: 'Documentation', entries: categories.get('docs')!.map(formatEntry) });
+  }
+
+  // Stats
+  const featCount = categories.get('features')?.length ?? 0;
+  const fixCount = categories.get('fixes')?.length ?? 0;
+  const secCount = categories.get('security')?.length ?? 0;
+  const statsLine = `- **${prCount}+ PRs merged** | **${featCount} new features** | **${fixCount} bug fixes** | **${secCount} security/hardening improvements**`;
+
+  // Assemble
+  let md = `# oh-my-claudecode v${version}: ${title}\n\n`;
+  md += `## Release Notes\n\n${summary}\n`;
+
+  for (const section of sections) {
+    md += `\n### ${section.title}\n\n`;
+    md += section.entries.join('\n') + '\n';
+  }
+
+  md += `\n### Stats\n\n${statsLine}\n`;
+
+  return md;
+}
+
+function generateReleaseBody(
+  version: string,
+  changelog: string,
+  contributors: string[],
+  prevTag: string,
+): string {
+  let body = changelog;
+
+  body += `\n### Install / Update\n\n`;
+  body += '```bash\n';
+  body += `npm install -g oh-my-claude-sisyphus@${version}\n`;
+  body += '```\n\n';
+  body += 'Or reinstall the plugin:\n```bash\nclaude /install-plugin oh-my-claudecode\n```\n';
+
+  if (prevTag) {
+    body += `\n**Full Changelog**: https://github.com/Yeachan-Heo/oh-my-claudecode/compare/${prevTag}...v${version}\n`;
+  }
+
+  if (contributors.length > 0) {
+    body += `\n## Contributors\n\nThank you to all contributors who made this release possible!\n\n`;
+    body += contributors.map(u => `@${u}`).join(' ') + '\n';
+  }
+
+  return body;
+}
+
+// ── Version file bumping ────────────────────────────────────────────────────
+
+function bumpVersionFiles(newVersion: string, dryRun: boolean): string[] {
+  const changes: string[] = [];
+
+  // 1. package.json
+  const pkgPath = join(ROOT, 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+  if (pkg.version !== newVersion) {
+    pkg.version = newVersion;
+    if (!dryRun) writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+    changes.push(`package.json: ${pkg.version} → ${newVersion}`);
+  }
+
+  // 2. .claude-plugin/plugin.json
+  const pluginPath = join(ROOT, '.claude-plugin/plugin.json');
+  if (existsSync(pluginPath)) {
+    const content = readFileSync(pluginPath, 'utf-8');
+    const updated = content.replace(/"version":\s*"[^"]*"/, `"version": "${newVersion}"`);
+    if (content !== updated) {
+      if (!dryRun) writeFileSync(pluginPath, updated, 'utf-8');
+      changes.push(`plugin.json: bumped to ${newVersion}`);
+    }
+  }
+
+  // 3. .claude-plugin/marketplace.json (has 2 version fields)
+  const marketPath = join(ROOT, '.claude-plugin/marketplace.json');
+  if (existsSync(marketPath)) {
+    const content = readFileSync(marketPath, 'utf-8');
+    const updated = content.replace(/"version":\s*"[^"]*"/g, `"version": "${newVersion}"`);
+    if (content !== updated) {
+      if (!dryRun) writeFileSync(marketPath, updated, 'utf-8');
+      changes.push(`marketplace.json: bumped to ${newVersion}`);
+    }
+  }
+
+  // 4. docs/CLAUDE.md version marker
+  const claudeMdPath = join(ROOT, 'docs/CLAUDE.md');
+  if (existsSync(claudeMdPath)) {
+    const content = readFileSync(claudeMdPath, 'utf-8');
+    const updated = content.replace(/<!-- OMC:VERSION:[^\s]*? -->/, `<!-- OMC:VERSION:${newVersion} -->`);
+    if (content !== updated) {
+      if (!dryRun) writeFileSync(claudeMdPath, updated, 'utf-8');
+      changes.push(`docs/CLAUDE.md: version marker → ${newVersion}`);
+    }
+  }
+
+  // 5. package-lock.json (via npm)
+  if (!dryRun) {
+    try {
+      execSync('npm install --package-lock-only --ignore-scripts 2>/dev/null', { cwd: ROOT });
+      changes.push('package-lock.json: regenerated');
+    } catch {
+      changes.push('package-lock.json: FAILED to regenerate');
+    }
+  } else {
+    changes.push('package-lock.json: would regenerate');
+  }
+
+  return changes;
+}
+
+// ── Main ────────────────────────────────────────────────────────────────────
+
+function main(): void {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes('--dry-run');
+  const help = args.includes('--help') || args.includes('-h');
+  const bumpArg = args.find(a => !a.startsWith('-'));
+
+  if (help || !bumpArg) {
+    console.log(`
+${clr('Release Automation', c.bold)}
+
+${clr('Usage:', c.cyan)}
+  npm run release -- <patch|minor|major|X.Y.Z> [--dry-run]
+
+${clr('Examples:', c.cyan)}
+  npm run release -- patch              # 4.8.1 → 4.8.2
+  npm run release -- minor              # 4.8.1 → 4.9.0
+  npm run release -- 5.0.0              # Set explicit version
+  npm run release -- patch --dry-run    # Preview without writing
+
+${clr('What it does:', c.cyan)}
+  1. Bumps version in all 5 files (package.json, plugin.json, marketplace.json, docs/CLAUDE.md, lockfile)
+  2. Generates CHANGELOG.md from conventional commits
+  3. Generates .github/release-body.md with contributor @mentions
+  4. Runs sync-metadata to update doc badges
+
+${clr('After running:', c.cyan)}
+  git add -A && git commit -m "chore(release): bump version to vX.Y.Z"
+  git push origin dev
+  # Wait for CI green, then:
+  git checkout main && git merge dev && git push origin main
+  git tag -a vX.Y.Z -m "vX.Y.Z" && git push origin vX.Y.Z
+  # release.yml handles npm publish + GitHub release
+`);
+    return;
+  }
+
+  const currentVersion = getCurrentVersion();
+  const newVersion = bumpVersion(currentVersion, bumpArg);
+  const prevTag = getLatestTag();
+
+  console.log(clr('\n🚀 Release Automation', c.bold));
+  console.log(clr('═══════════════════════\n', c.dim));
+  console.log(`  Current version: ${clr(currentVersion, c.yellow)}`);
+  console.log(`  New version:     ${clr(newVersion, c.green)}`);
+  console.log(`  Previous tag:    ${clr(prevTag || '(none)', c.dim)}`);
+  if (dryRun) console.log(clr('\n  DRY RUN — no files will be modified\n', c.yellow));
+
+  // 1. Parse commits
+  const rawCommits = getCommitsSinceTag(prevTag);
+  const parsed = rawCommits.map(parseCommit).filter((c): c is ParsedCommit => c !== null);
+  const categories = categorize(parsed);
+  const prCount = getPRCount(prevTag);
+  const contributors = getContributors(prevTag);
+
+  console.log(clr('\n📊 Commit Analysis', c.cyan));
+  console.log(`  Total commits: ${rawCommits.length}`);
+  console.log(`  Parsed conventional: ${parsed.length}`);
+  console.log(`  PRs merged: ${prCount}`);
+  console.log(`  Contributors: ${contributors.join(', ') || '(none)'}`);
+
+  for (const [cat, commits] of categories) {
+    console.log(`  ${cat}: ${commits.length}`);
+  }
+
+  // 2. Bump version files
+  console.log(clr('\n📦 Version Bump', c.cyan));
+  const versionChanges = bumpVersionFiles(newVersion, dryRun);
+  for (const change of versionChanges) {
+    console.log(`  ${clr('✓', c.green)} ${change}`);
+  }
+
+  // 3. Generate CHANGELOG
+  console.log(clr('\n📝 Changelog', c.cyan));
+  const changelog = generateChangelog(newVersion, categories, prCount);
+  if (!dryRun) {
+    writeFileSync(join(ROOT, 'CHANGELOG.md'), changelog, 'utf-8');
+    console.log(`  ${clr('✓', c.green)} Written to CHANGELOG.md`);
+  } else {
+    console.log(`  ${clr('→', c.yellow)} Would write CHANGELOG.md`);
+    console.log(clr('\n--- CHANGELOG Preview ---\n', c.dim));
+    console.log(changelog);
+    console.log(clr('--- End Preview ---\n', c.dim));
+  }
+
+  // 4. Generate release body
+  console.log(clr('\n📋 Release Body', c.cyan));
+  const releaseBody = generateReleaseBody(newVersion, changelog, contributors, prevTag);
+  const releaseBodyPath = join(ROOT, '.github/release-body.md');
+  if (!dryRun) {
+    writeFileSync(releaseBodyPath, releaseBody, 'utf-8');
+    console.log(`  ${clr('✓', c.green)} Written to .github/release-body.md`);
+  } else {
+    console.log(`  ${clr('→', c.yellow)} Would write .github/release-body.md`);
+  }
+
+  // 5. Run sync-metadata
+  console.log(clr('\n🔄 Sync Metadata', c.cyan));
+  if (!dryRun) {
+    try {
+      execSync('npx tsx scripts/sync-metadata.ts', { cwd: ROOT, stdio: 'inherit' });
+    } catch {
+      console.log(`  ${clr('⚠', c.yellow)} sync-metadata had warnings (non-fatal)`);
+    }
+  } else {
+    console.log(`  ${clr('→', c.yellow)} Would run sync-metadata`);
+  }
+
+  // 6. Next steps
+  console.log(clr('\n✅ Done!', c.green));
+  if (!dryRun) {
+    console.log(clr('\nNext steps:', c.bold));
+    console.log(`  1. ${clr(`git add -A && git commit -m "chore(release): bump version to v${newVersion}"`, c.cyan)}`);
+    console.log(`  2. ${clr(`git push origin dev`, c.cyan)}`);
+    console.log(`  3. Wait for CI green`);
+    console.log(`  4. ${clr(`git checkout main && git merge dev && git push origin main`, c.cyan)}`);
+    console.log(`  5. ${clr(`git tag -a v${newVersion} -m "v${newVersion}" && git push origin v${newVersion}`, c.cyan)}`);
+    console.log(`  6. release.yml handles npm publish + GitHub release automatically`);
+  }
+}
+
+main();

package/scripts/run-provider-advisor.js

@@ -17,16 +17,20 @@ const SHOULD_USE_WINDOWS_SHELL = process.platform === 'win32';
  * - codex: `codex exec --dangerously-bypass-approvals-and-sandbox <prompt>`
  * - gemini: `gemini -p <prompt> --yolo`
  */
-function buildProviderArgs(provider, prompt) {
+function buildProviderArgs(provider, prompt, { pipePromptViaStdin = false } = {}) {
   if (provider === 'codex') {
-    return ['exec', '--dangerously-bypass-approvals-and-sandbox', prompt];
+    return ['exec', '--dangerously-bypass-approvals-and-sandbox', pipePromptViaStdin ? '-' : prompt];
   }
   if (provider === 'gemini') {
-    return ['-p', prompt, '--yolo'];
+    return pipePromptViaStdin ? ['--yolo'] : ['-p', prompt, '--yolo'];
   }
   return ['-p', prompt];
 }
 
+function shouldPipePromptViaStdin(provider) {
+  return SHOULD_USE_WINDOWS_SHELL && (provider === 'codex' || provider === 'gemini');
+}
+
 const ASK_ORIGINAL_TASK_ENV = 'OMC_ASK_ORIGINAL_TASK';
 const ASK_ORIGINAL_TASK_ENV_ALIAS = 'OMX_ASK_ORIGINAL_TASK';
 
@@ -209,12 +213,14 @@ async function main() {
 
   ensureBinary(provider, binary);
 
-  const providerArgs = buildProviderArgs(provider, prompt);
+  const pipePromptViaStdin = shouldPipePromptViaStdin(provider);
+  const providerArgs = buildProviderArgs(provider, prompt, { pipePromptViaStdin });
   const run = spawnSync(binary, providerArgs, {
     encoding: 'utf8',
     maxBuffer: 10 * 1024 * 1024,
     env: buildProviderEnv(provider),
     shell: SHOULD_USE_WINDOWS_SHELL,
+    ...(pipePromptViaStdin ? { input: prompt } : {}),
   });
 
   const stdout = run.stdout || '';

package/scripts/session-end.mjs

@@ -4,8 +4,9 @@ const require = createRequire(import.meta.url);
 import { readStdin } from './lib/stdin.mjs';
 
 async function main() {
-  // Read stdin (timeout-protected, see issue #240/#459)
-  const input = await readStdin();
+  // Read stdin with reduced timeout for SessionEnd — the input payload is small
+  // and doesn't need the default 5s wait. This saves ~4s toward the hook timeout (#1700).
+  const input = await readStdin(1000);
 
   try {
     const data = JSON.parse(input);