claudecode-omc 4.8.3 → 4.9.3

package/scripts/session-start.mjs

@@ -48,6 +48,89 @@ function readJsonFile(path) {
   }
 }
 
+function getRuntimeBaseDir() {
+  return process.env.CLAUDE_PLUGIN_ROOT || join(__dirname, '..');
+}
+
+async function loadProjectMemoryModules() {
+  try {
+    const runtimeBase = getRuntimeBaseDir();
+    const [
+      projectMemoryStorage,
+      projectMemoryDetector,
+      projectMemoryFormatter,
+      rulesFinder,
+    ] = await Promise.all([
+      import(pathToFileURL(join(runtimeBase, 'dist', 'hooks', 'project-memory', 'storage.js')).href),
+      import(pathToFileURL(join(runtimeBase, 'dist', 'hooks', 'project-memory', 'detector.js')).href),
+      import(pathToFileURL(join(runtimeBase, 'dist', 'hooks', 'project-memory', 'formatter.js')).href),
+      import(pathToFileURL(join(runtimeBase, 'dist', 'hooks', 'rules-injector', 'finder.js')).href),
+    ]);
+
+    return {
+      loadProjectMemory: projectMemoryStorage.loadProjectMemory,
+      saveProjectMemory: projectMemoryStorage.saveProjectMemory,
+      shouldRescan: projectMemoryStorage.shouldRescan,
+      detectProjectEnvironment: projectMemoryDetector.detectProjectEnvironment,
+      formatContextSummary: projectMemoryFormatter.formatContextSummary,
+      findProjectRoot: rulesFinder.findProjectRoot,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function hasProjectMemoryContent(memory) {
+  return Boolean(
+    memory &&
+    (
+      memory.userDirectives?.length ||
+      memory.customNotes?.length ||
+      memory.hotPaths?.length ||
+      memory.techStack?.languages?.length ||
+      memory.techStack?.frameworks?.length ||
+      memory.build?.buildCommand ||
+      memory.build?.testCommand
+    )
+  );
+}
+
+async function resolveProjectMemorySummary(directory, projectMemoryModules) {
+  const {
+    detectProjectEnvironment,
+    findProjectRoot,
+    formatContextSummary,
+    loadProjectMemory,
+    saveProjectMemory,
+    shouldRescan,
+  } = projectMemoryModules;
+
+  const projectRoot = findProjectRoot?.(directory);
+  if (!projectRoot) {
+    return '';
+  }
+
+  let memory = await loadProjectMemory?.(projectRoot);
+
+  if ((!memory || shouldRescan?.(memory)) && detectProjectEnvironment && saveProjectMemory) {
+    const existing = memory;
+    memory = await detectProjectEnvironment(projectRoot);
+
+    if (existing) {
+      memory.customNotes = existing.customNotes;
+      memory.userDirectives = existing.userDirectives;
+    }
+
+    await saveProjectMemory(projectRoot, memory);
+  }
+
+  if (!hasProjectMemoryContent(memory)) {
+    return '';
+  }
+
+  return formatContextSummary(memory)?.trim() || '';
+}
+
 // Semantic version comparison (for cache cleanup sorting)
 function semverCompare(a, b) {
   const pa = a.replace(/^v/, '').split('.').map(s => parseInt(s, 10) || 0);
@@ -174,13 +257,12 @@ async function checkNpmUpdate(currentVersion) {
   } catch {}
 
   // Fetch from npm registry with 2s timeout
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 2000);
   try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 2000);
     const response = await fetch(`https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`, {
       signal: controller.signal
     });
-    clearTimeout(timeoutId);
     if (!response.ok) return null;
 
     const data = await response.json();
@@ -201,7 +283,7 @@ async function checkNpmUpdate(currentVersion) {
     } catch {}
 
     return updateAvailable ? { currentVersion, latestVersion } : null;
-  } catch { return null; }
+  } catch { return null; } finally { clearTimeout(timeoutId); }
 }
 
 // Check if HUD is properly installed (with retry for race conditions)
@@ -298,6 +380,7 @@ async function main() {
     const directory = data.cwd || data.directory || process.cwd();
     const sessionId = data.session_id || data.sessionId || '';
     const messages = [];
+    const projectMemoryModules = await loadProjectMemoryModules();
 
     // Check for version drift between components
     const driftInfo = detectVersionDrift();
@@ -322,6 +405,17 @@ async function main() {
       }
     } catch {}
 
+    // Warn if silentAutoUpdate is enabled but running in plugin mode (#1773)
+    if (process.env.CLAUDE_PLUGIN_ROOT) {
+      try {
+        const omcConfigPath = join(configDir, '.omc-config.json');
+        const omcConfig = readJsonFile(omcConfigPath);
+        if (omcConfig?.silentAutoUpdate) {
+          messages.push(`<session-restore>\n\n[OMC] silentAutoUpdate is enabled in .omc-config.json but has no effect in plugin mode.\nTo update, use: /plugin marketplace update omc && /omc-setup\nOr run manually: omc update\n\n</session-restore>\n\n---\n`);
+        }
+      } catch {}
+    }
+
     // Check HUD installation (one-time setup guidance)
     const hudCheck = await checkHudInstallation();
     if (!hudCheck.installed) {
@@ -428,6 +522,26 @@ Treat this as prior-session context only. Prioritize the user's newest request,
 `);
     }
 
+    if (projectMemoryModules) {
+      try {
+        const summary = await resolveProjectMemorySummary(directory, projectMemoryModules);
+        if (summary) {
+          messages.push(`<project-memory-context>
+
+[PROJECT MEMORY]
+
+${summary}
+
+</project-memory-context>
+
+---
+`);
+        }
+      } catch {
+        // Project memory is additive only; never break session start.
+      }
+    }
+
     // Check for notepad Priority Context
     const notepadPath = join(directory, '.omc', 'notepad.md');
     if (existsSync(notepadPath)) {

package/scripts/session-summary.mjs

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+/**
+ * Session Summary Generator
+ *
+ * Standalone script that generates a brief (<20 char) summary of the current
+ * Claude Code session using `claude -p`.
+ *
+ * Usage:
+ *   node session-summary.mjs <transcript_path> <state_dir> <session_id> [--verbose]
+ *
+ * The script:
+ * 1. Counts user message turns from the transcript JSONL
+ * 2. Checks cached summary in <state_dir>/session-summary.json
+ * 3. If turns >= 10 and (no cache or turns - lastTurnCount >= 10), generates
+ *    a new summary via `claude -p`
+ * 4. Writes the result to the state file
+ *
+ * Exit codes:
+ *   0 - success (summary generated or cache is fresh)
+ *   1 - error
+ *   2 - not enough turns yet
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, createReadStream } from 'fs';
+import { join } from 'path';
+import { execFileSync } from 'child_process';
+import { createInterface } from 'readline';
+
+const TURN_THRESHOLD = 10;
+const verbose = process.argv.includes('--verbose') || process.argv.includes('-v');
+
+function log(...args) {
+  if (verbose) {
+    console.error('[session-summary]', ...args);
+  }
+}
+
+/**
+ * Count user message turns from a transcript JSONL file.
+ * A "turn" is a message with role === 'user'.
+ */
+async function countUserTurns(transcriptPath) {
+  if (!existsSync(transcriptPath)) {
+    return 0;
+  }
+
+  let turns = 0;
+  const stream = createReadStream(transcriptPath);
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.message?.role === 'user' || entry.type === 'human') {
+        turns++;
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  return turns;
+}
+
+/**
+ * Extract recent conversation context for summarization.
+ * Returns the last N user messages as context.
+ */
+async function extractConversationContext(transcriptPath, maxMessages = 20) {
+  if (!existsSync(transcriptPath)) {
+    return '';
+  }
+
+  const messages = [];
+  const stream = createReadStream(transcriptPath);
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      const role = entry.message?.role ?? (entry.type === 'human' ? 'user' : null);
+      if (!role) continue;
+
+      const content = entry.message?.content;
+      if (!content) continue;
+
+      let text = '';
+      if (typeof content === 'string') {
+        text = content;
+      } else if (Array.isArray(content)) {
+        text = content
+          .filter(b => b.type === 'text' && b.text)
+          .map(b => b.text)
+          .join(' ');
+      }
+
+      if (text.trim()) {
+        messages.push({ role, text: text.slice(0, 200) });
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  // Take last N messages for context
+  const recent = messages.slice(-maxMessages);
+  return recent.map(m => `${m.role}: ${m.text}`).join('\n');
+}
+
+/**
+ * Read cached summary state (scoped by sessionId).
+ */
+function readSummaryState(stateDir, sessionId) {
+  const statePath = join(stateDir, `session-summary-${sessionId}.json`);
+  if (!existsSync(statePath)) return null;
+  try {
+    return JSON.parse(readFileSync(statePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write summary state to disk (scoped by sessionId).
+ */
+function writeSummaryState(stateDir, sessionId, state) {
+  mkdirSync(stateDir, { recursive: true });
+  const statePath = join(stateDir, `session-summary-${sessionId}.json`);
+  writeFileSync(statePath, JSON.stringify(state, null, 2));
+}
+
+/**
+ * Generate summary using `claude -p`.
+ */
+function generateSummary(conversationContext) {
+  const prompt = `You are a session labeler. Given the conversation below, produce a SHORT label (under 20 characters, in the same language as the conversation) that summarizes what the user is working on. Output ONLY the label text, nothing else. No quotes, no explanation.
+
+Examples of good labels:
+- "auth bug fix"
+- "API 테스트 추가"
+- "리팩토링 utils"
+- "deploy pipeline"
+- "DB migration"
+
+Conversation:
+${conversationContext}
+
+Label:`;
+
+  try {
+    const result = execFileSync('claude', ['-p', prompt], {
+      encoding: 'utf-8',
+      timeout: 30_000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, CLAUDE_CODE_ENTRYPOINT: 'session-summary' },
+    });
+    const summary = result.trim().slice(0, 19); // Enforce <20 chars
+    return summary || null;
+  } catch (error) {
+    log('claude -p failed:', error.message);
+    return null;
+  }
+}
+
+async function main() {
+  const transcriptPath = process.argv[2];
+  const stateDir = process.argv[3];
+  const sessionId = process.argv[4];
+
+  if (!transcriptPath || !stateDir || !sessionId) {
+    console.error('Usage: session-summary.mjs <transcript_path> <state_dir> <session_id> [--verbose]');
+    process.exit(1);
+  }
+
+  // Validate sessionId to prevent path traversal
+  const SESSION_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,255}$/;
+  if (!SESSION_ID_PATTERN.test(sessionId)) {
+    console.error('[session-summary] invalid sessionId');
+    process.exit(1);
+  }
+
+  log('transcript:', transcriptPath);
+  log('stateDir:', stateDir);
+  log('sessionId:', sessionId);
+
+  // 1. Count user turns
+  const turnCount = await countUserTurns(transcriptPath);
+  log('user turns:', turnCount);
+
+  if (turnCount < TURN_THRESHOLD) {
+    log('not enough turns yet');
+    process.exit(2);
+  }
+
+  // 2. Check cached state (scoped by sessionId)
+  const cached = readSummaryState(stateDir, sessionId);
+  log('cached state:', cached);
+
+  if (cached?.summary && cached?.turnCount != null) {
+    const turnsSinceLastGeneration = turnCount - cached.turnCount;
+    if (turnsSinceLastGeneration < TURN_THRESHOLD) {
+      log('cache is fresh, skipping generation');
+      process.exit(0);
+    }
+  }
+
+  // 3. Extract conversation context
+  const context = await extractConversationContext(transcriptPath);
+  if (!context) {
+    log('no conversation context found');
+    process.exit(1);
+  }
+
+  // 4. Generate summary via claude -p
+  log('generating summary...');
+  const summary = generateSummary(context);
+
+  if (!summary) {
+    log('failed to generate summary');
+    process.exit(1);
+  }
+
+  log('generated summary:', summary);
+
+  // 5. Write state (scoped by sessionId)
+  writeSummaryState(stateDir, sessionId, {
+    summary,
+    turnCount,
+    generatedAt: new Date().toISOString(),
+  });
+
+  log('done');
+  process.exit(0);
+}
+
+main().catch(error => {
+  console.error('[session-summary] fatal error:', error.message);
+  process.exit(1);
+});

package/scripts/setup-claude-md.sh

@@ -9,18 +9,127 @@ set -euo pipefail
 
 MODE="${1:?Usage: setup-claude-md.sh <local|global>}"
 DOWNLOAD_URL="https://raw.githubusercontent.com/Yeachan-Heo/oh-my-claudecode/main/docs/CLAUDE.md"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SCRIPT_PLUGIN_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+# Resolve active plugin root from installed_plugins.json.
+# Handles stale CLAUDE_PLUGIN_ROOT when a session was started before a plugin
+# update (e.g. 4.8.2 session invoking setup after updating to 4.9.0).
+# Same pattern as run.cjs resolveTarget() fallback.
+resolve_active_plugin_root() {
+  local config_dir="${CLAUDE_CONFIG_DIR:-$HOME/.claude}"
+  local installed_plugins="${config_dir}/plugins/installed_plugins.json"
+
+  if [ -f "$installed_plugins" ] && command -v jq >/dev/null 2>&1; then
+    local active_path
+    active_path=$(jq -r '
+      (.plugins // .)
+      | to_entries[]
+      | select(.key | startswith("oh-my-claudecode"))
+      | .value[0].installPath // empty
+    ' "$installed_plugins" 2>/dev/null)
+
+    if [ -n "$active_path" ] && [ -d "$active_path" ]; then
+      echo "$active_path"
+      return 0
+    fi
+  fi
+
+  # Fallback: scan sibling version directories for the latest (mirrors run.cjs)
+  local cache_base
+  cache_base="$(dirname "$SCRIPT_PLUGIN_ROOT")"
+  if [ -d "$cache_base" ]; then
+    local latest
+    latest=$(ls -1 "$cache_base" | grep -E '^[0-9]+\.[0-9]+\.[0-9]+' | sort -t. -k1,1nr -k2,2nr -k3,3nr | head -1)
+    if [ -n "$latest" ] && [ -d "${cache_base}/${latest}" ]; then
+      echo "${cache_base}/${latest}"
+      return 0
+    fi
+  fi
+
+  echo "$SCRIPT_PLUGIN_ROOT"
+}
+
+ACTIVE_PLUGIN_ROOT="$(resolve_active_plugin_root)"
+CANONICAL_CLAUDE_MD="${ACTIVE_PLUGIN_ROOT}/docs/CLAUDE.md"
+CANONICAL_OMC_REFERENCE_SKILL="${ACTIVE_PLUGIN_ROOT}/skills/omc-reference/SKILL.md"
+
+ensure_local_omc_git_exclude() {
+  local exclude_path
+
+  if ! exclude_path=$(git rev-parse --git-path info/exclude 2>/dev/null); then
+    echo "Skipped OMC git exclude setup (not a git repository)"
+    return 0
+  fi
+
+  mkdir -p "$(dirname "$exclude_path")"
+
+  local block_start="# BEGIN OMC local artifacts"
+
+  if [ -f "$exclude_path" ] && grep -Fq "$block_start" "$exclude_path"; then
+    echo "OMC git exclude already configured"
+    return 0
+  fi
+
+  if [ -f "$exclude_path" ] && [ -s "$exclude_path" ]; then
+    printf '\n' >> "$exclude_path"
+  fi
+
+  cat >> "$exclude_path" <<'EOF'
+# BEGIN OMC local artifacts
+.omc/*
+!.omc/skills/
+!.omc/skills/**
+# END OMC local artifacts
+EOF
+
+  echo "Configured git exclude for local .omc artifacts (preserving .omc/skills/)"
+}
 
 # Determine target path
 if [ "$MODE" = "local" ]; then
-  mkdir -p .claude
+  mkdir -p .claude/skills/omc-reference
   TARGET_PATH=".claude/CLAUDE.md"
+  SKILL_TARGET_PATH=".claude/skills/omc-reference/SKILL.md"
 elif [ "$MODE" = "global" ]; then
+  mkdir -p "$HOME/.claude/skills/omc-reference"
   TARGET_PATH="$HOME/.claude/CLAUDE.md"
+  SKILL_TARGET_PATH="$HOME/.claude/skills/omc-reference/SKILL.md"
 else
   echo "ERROR: Invalid mode '$MODE'. Use 'local' or 'global'." >&2
   exit 1
 fi
 
+
+install_omc_reference_skill() {
+  local source_label=""
+  local temp_skill
+  temp_skill=$(mktemp /tmp/omc-reference-skill-XXXXXX.md)
+
+  if [ -f "$CANONICAL_OMC_REFERENCE_SKILL" ]; then
+    cp "$CANONICAL_OMC_REFERENCE_SKILL" "$temp_skill"
+    source_label="$CANONICAL_OMC_REFERENCE_SKILL"
+  elif [ -n "${CLAUDE_PLUGIN_ROOT:-}" ] && [ -f "${CLAUDE_PLUGIN_ROOT}/skills/omc-reference/SKILL.md" ]; then
+    cp "${CLAUDE_PLUGIN_ROOT}/skills/omc-reference/SKILL.md" "$temp_skill"
+    source_label="${CLAUDE_PLUGIN_ROOT}/skills/omc-reference/SKILL.md"
+  else
+    rm -f "$temp_skill"
+    echo "Skipped omc-reference skill install (canonical skill source unavailable)"
+    return 0
+  fi
+
+  if [ ! -s "$temp_skill" ]; then
+    rm -f "$temp_skill"
+    echo "Skipped omc-reference skill install (empty canonical skill source: $source_label)"
+    return 0
+  fi
+
+  mkdir -p "$(dirname "$SKILL_TARGET_PATH")"
+  cp "$temp_skill" "$SKILL_TARGET_PATH"
+  rm -f "$temp_skill"
+  echo "Installed omc-reference skill to $SKILL_TARGET_PATH"
+}
+
 # Extract old version before download
 OLD_VERSION=$(grep -m1 'OMC:VERSION:' "$TARGET_PATH" 2>/dev/null | sed -E 's/.*OMC:VERSION:([^ ]+).*/\1/' || true)
 if [ -z "$OLD_VERSION" ]; then
@@ -38,10 +147,21 @@ if [ -f "$TARGET_PATH" ]; then
   echo "Backed up existing CLAUDE.md to $BACKUP_PATH"
 fi
 
-# Download fresh OMC content to temp file
+# Load canonical OMC content to temp file
 TEMP_OMC=$(mktemp /tmp/omc-claude-XXXXXX.md)
 trap 'rm -f "$TEMP_OMC"' EXIT
-curl -fsSL "$DOWNLOAD_URL" -o "$TEMP_OMC"
+
+SOURCE_LABEL=""
+if [ -f "$CANONICAL_CLAUDE_MD" ]; then
+  cp "$CANONICAL_CLAUDE_MD" "$TEMP_OMC"
+  SOURCE_LABEL="$CANONICAL_CLAUDE_MD"
+elif [ -n "${CLAUDE_PLUGIN_ROOT:-}" ] && [ -f "${CLAUDE_PLUGIN_ROOT}/docs/CLAUDE.md" ]; then
+  cp "${CLAUDE_PLUGIN_ROOT}/docs/CLAUDE.md" "$TEMP_OMC"
+  SOURCE_LABEL="${CLAUDE_PLUGIN_ROOT}/docs/CLAUDE.md"
+else
+  curl -fsSL "$DOWNLOAD_URL" -o "$TEMP_OMC"
+  SOURCE_LABEL="$DOWNLOAD_URL"
+fi
 
 if [ ! -s "$TEMP_OMC" ]; then
   echo "ERROR: Failed to download CLAUDE.md. Aborting."
@@ -50,6 +170,12 @@ if [ ! -s "$TEMP_OMC" ]; then
   exit 1
 fi
 
+if ! grep -q '<!-- OMC:START -->' "$TEMP_OMC" || ! grep -q '<!-- OMC:END -->' "$TEMP_OMC"; then
+  echo "ERROR: Canonical CLAUDE.md source is missing required OMC markers: $SOURCE_LABEL" >&2
+  echo "Refusing to install a summarized or malformed CLAUDE.md." >&2
+  exit 1
+fi
+
 # Strip existing markers from downloaded content (idempotency)
 # Use awk for cross-platform compatibility (GNU/BSD)
 if grep -q '<!-- OMC:START -->' "$TEMP_OMC"; then
@@ -119,6 +245,17 @@ else
   rm -f "$TEMP_OMC"
 fi
 
+if ! grep -q '<!-- OMC:START -->' "$TARGET_PATH" || ! grep -q '<!-- OMC:END -->' "$TARGET_PATH"; then
+  echo "ERROR: Installed CLAUDE.md is missing required OMC markers: $TARGET_PATH" >&2
+  exit 1
+fi
+
+install_omc_reference_skill
+
+if [ "$MODE" = "local" ]; then
+  ensure_local_omc_git_exclude
+fi
+
 # Extract new version and report
 NEW_VERSION=$(grep -m1 'OMC:VERSION:' "$TARGET_PATH" 2>/dev/null | sed -E 's/.*OMC:VERSION:([^ ]+).*/\1/' || true)
 if [ -z "$NEW_VERSION" ]; then

package/scripts/skill-injector.mjs

@@ -130,8 +130,9 @@ function findMatchingSkillsFallback(prompt, directory, sessionId) {
   const candidates = findSkillFilesFallback(directory);
   const matches = [];
 
-  // Get or create session cache
+  // Get or create session cache (cap size to prevent unbounded growth)
   if (!injectedCacheFallback.has(sessionId)) {
+    if (injectedCacheFallback.size > 500) injectedCacheFallback.clear();
     injectedCacheFallback.set(sessionId, new Set());
   }
   const alreadyInjected = injectedCacheFallback.get(sessionId);