oh-my-hi 0.4.0 → 0.4.2

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "oh-my-hi",
       "description": "Visual dashboard for Claude Code harness — usage/token analysis of skills, agents, plugins, hooks, memory, MCP servers, rules, and principles",
-      "version": "0.4.0",
+      "version": "0.4.2",
       "author": {
         "name": "Jae Sung Park",
         "email": "alberto.park@gmail.com"

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.4.2] - 2026-04-03
+
+### Changed
+- Progress output improved: step-numbered messages (`[1/3]`, `[1/4]`) replace generic lines; first-run vs normal-run messaging differentiated
+- In-place progress bar (`█░` style) rendered during file collection
+- `collectAllScopes` accepts `progress` flag to enable/disable bar rendering
+- Update check now queries **GitHub tags** first (primary distribution channel), with npm registry as fallback
+
+### Fixed
+- Progress bar newline flushed after collection completes (no broken terminal output)
+- Update check now compares versions numerically; pre-publish local versions no longer trigger spurious "downgrade" attempts
+- `--update` now runs `git fetch --tags` on the marketplace cache before calling `claude plugin update`, so stale local caches no longer report "already at latest" when a newer version exists on GitHub
+- Test: replaced flaky mtime comparison with output-based assertion (macOS APFS sub-ms timestamp precision artifact)
+
 ## [0.4.0] - 2026-04-02
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-hi",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Claude Code harness insights dashboard",
   "repository": {
     "type": "git",

package/scripts/generate-dashboard.mjs

@@ -64,43 +64,82 @@ async function runUpdate() {
   const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'));
   console.log(`oh-my-hi: current version v${pkg.version}`);
   console.log('oh-my-hi: checking for updates...');
+
+  // Detect marketplace name and cache dir
+  const pluginCacheDir = path.join(CLAUDE_CONFIG_DIR, 'plugins', 'cache');
+  let marketplace = 'oh-my-hi';
+  if (fs.existsSync(pluginCacheDir)) {
+    for (const entry of fs.readdirSync(pluginCacheDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith('temp_')) continue;
+      if (fs.existsSync(path.join(pluginCacheDir, entry.name, pkg.name))) {
+        marketplace = entry.name;
+        break;
+      }
+    }
+  }
+
+  // Refresh marketplace cache so claude plugin update sees latest tags
+  const marketplaceCacheDir = path.join(CLAUDE_CONFIG_DIR, 'plugins', 'marketplaces', marketplace);
+  if (fs.existsSync(marketplaceCacheDir)) {
+    try {
+      execSync('git fetch --tags --quiet', { cwd: marketplaceCacheDir, stdio: 'pipe', timeout: 10000 });
+    } catch { /* best effort — offline or not a git repo */ }
+  }
+
   try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 5000);
-    const res = await fetch(`https://registry.npmjs.org/${pkg.name}/latest`, {
-      signal: controller.signal, headers: { 'Accept': 'application/json' },
-    });
-    clearTimeout(timeout);
-    if (!res.ok) throw new Error('registry request failed');
-    const data = await res.json();
+    // Check latest version via GitHub tags API (git-based distribution)
+    const repoUrl = pkg.repository?.url || '';
+    const ghMatch = repoUrl.match(/github\.com[/:]([^/]+\/[^/.]+)/);
+    let latest = null;
+
+    if (ghMatch) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+      const res = await fetch(`https://api.github.com/repos/${ghMatch[1]}/tags`, {
+        signal: controller.signal, headers: { 'Accept': 'application/vnd.github+json' },
+      });
+      clearTimeout(timeout);
+      if (res.ok) {
+        const tags = await res.json();
+        // Find highest semver tag
+        for (const tag of tags) {
+          const v = tag.name.replace(/^v/, '');
+          if (/^\d+\.\d+\.\d+$/.test(v) && (!latest || semverGt(v, latest))) latest = v;
+        }
+      }
+    }
+
+    // Fallback to npm registry if GitHub API unavailable
+    if (!latest) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+      const res = await fetch(`https://registry.npmjs.org/${pkg.name}/latest`, {
+        signal: controller.signal, headers: { 'Accept': 'application/json' },
+      });
+      clearTimeout(timeout);
+      if (res.ok) {
+        const data = await res.json();
+        latest = data.version;
+      }
+    }
+
+    if (!latest) throw new Error('could not determine latest version');
 
     // Cache check result
     const UPDATE_CHECK_FILE = path.join(OUTPUT, 'cache', '.update-check');
     try {
       fs.mkdirSync(path.dirname(UPDATE_CHECK_FILE), { recursive: true });
-      fs.writeFileSync(UPDATE_CHECK_FILE, JSON.stringify({ timestamp: Date.now(), current: pkg.version, latest: data.version }), 'utf8');
+      fs.writeFileSync(UPDATE_CHECK_FILE, JSON.stringify({ timestamp: Date.now(), current: pkg.version, latest }), 'utf8');
     } catch { /* best effort */ }
 
-    if (data.version === pkg.version) {
+    if (!semverGt(latest, pkg.version)) {
       console.log('oh-my-hi: ✅ already up to date');
       return;
     }
-    console.log(`oh-my-hi: v${data.version} available`);
-    // Detect marketplace name from plugin cache path
-    const pluginCacheDir = path.join(CLAUDE_CONFIG_DIR, 'plugins', 'cache');
-    let marketplace = 'oh-my-hi';
-    if (fs.existsSync(pluginCacheDir)) {
-      for (const entry of fs.readdirSync(pluginCacheDir, { withFileTypes: true })) {
-        if (!entry.isDirectory() || entry.name.startsWith('temp_')) continue;
-        if (fs.existsSync(path.join(pluginCacheDir, entry.name, pkg.name))) {
-          marketplace = entry.name;
-          break;
-        }
-      }
-    }
-    console.log(`oh-my-hi: updating v${pkg.version} → v${data.version}...`);
+    console.log(`oh-my-hi: v${latest} available`);
+    console.log(`oh-my-hi: updating v${pkg.version} → v${latest}...`);
     execSync(`claude plugin update ${pkg.name}@${marketplace}`, { stdio: 'inherit' });
-    console.log(`oh-my-hi: ✅ updated to v${data.version}`);
+    console.log(`oh-my-hi: ✅ updated to v${latest}`);
   } catch (e) {
     if (e.name === 'AbortError') console.log('oh-my-hi: ❌ network timeout');
     else console.log('oh-my-hi: ❌ update failed —', e.message);
@@ -112,6 +151,17 @@ async function runUpdate() {
 const SETTINGS_PATH = path.join(CLAUDE_CONFIG_DIR, 'settings.json');
 const AUTO_HOOK_CMD = `node "${path.join(ROOT, 'scripts', 'generate-dashboard.mjs')}" --data-only`;
 
+/** Returns true if version a is greater than version b (semver, numeric comparison) */
+function semverGt(a, b) {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return true;
+    if ((pa[i] || 0) < (pb[i] || 0)) return false;
+  }
+  return false;
+}
+
 function readSettings() {
   if (!fs.existsSync(SETTINGS_PATH)) return {};
   try { return JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf-8')); } catch { return {}; }
@@ -267,11 +317,7 @@ async function main() {
   }
 
   // ── Full mode (user-initiated /omh) ──
-  console.log('oh-my-hi: collecting data...');
-
   const scopes = detectScopes(CLAUDE_CONFIG_DIR, extraPaths);
-  console.log(`  scopes: ${scopes.length} detected`);
-
   const systemLocale = detectSystemLocale();
 
   // Check cache state to decide progressive mode
@@ -285,30 +331,37 @@ async function main() {
   }
 
   if (!cacheExists && !pendingExists) {
-    // Progressive mode: no cache at all
-    console.log('oh-my-hi: progressive mode — quick preview first...');
+    // Progressive mode: no cache at all (first run)
+    console.log('oh-my-hi: first run — generating dashboard from scratch...');
+    console.log(`  [1/4] scanning ${scopes.length} workspace(s)...`);
 
     const cache = {};
-    const phase1ScopeData = await collectAllScopes(scopes, { days: 7, cache });
+    console.log('  [2/4] building 7-day preview...');
+    const phase1ScopeData = await collectAllScopes(scopes, { days: 7, cache, progress: true });
     const phase1Data = buildDataObject(scopes, phase1ScopeData, systemLocale, { _partial: true });
     writeDataJs(phase1Data, dataPath);
+
+    console.log('  [3/4] opening browser with preview...');
     openOrRefreshBrowser(indexPath);
-    console.log('oh-my-hi: preview ready — loading full data in background...');
 
-    const phase2ScopeData = await collectAllScopes(scopes, { days: 0, cache, cachePath: CACHE_PATH });
+    console.log('  [4/4] loading full history (this may take a moment)...');
+    const phase2ScopeData = await collectAllScopes(scopes, { days: 0, cache, cachePath: CACHE_PATH, progress: true });
     const phase2Data = buildDataObject(scopes, phase2ScopeData, systemLocale);
     writeDataJs(phase2Data, dataPath);
     openOrRefreshBrowser(indexPath);
-    console.log('oh-my-hi: full data loaded — browser refreshed');
   } else {
     // Normal mode: load cache + merge pending + full data
-    const scopeData = await collectAllScopes(scopes, { days: 0, cachePath: CACHE_PATH });
+    console.log('oh-my-hi: collecting data...');
+    console.log(`  [1/3] scanning ${scopes.length} workspace(s)...`);
+    const scopeData = await collectAllScopes(scopes, { days: 0, cachePath: CACHE_PATH, progress: true });
+    console.log('  [2/3] building dashboard...');
     const data = buildDataObject(scopes, scopeData, systemLocale);
     writeDataJs(data, dataPath);
+    console.log('  [3/3] opening browser...');
     openOrRefreshBrowser(indexPath);
   }
 
-  console.log('oh-my-hi: done');
+  console.log('oh-my-hi: ✅ done');
 
   // Auto-refresh status notice
   const settings = readSettings();
@@ -323,7 +376,7 @@ async function main() {
   await checkForUpdate();
 }
 
-/** Check npm registry for newer version (non-blocking, cached for 24h) */
+/** Check GitHub tags for newer version (non-blocking, cached for 24h) */
 async function checkForUpdate() {
   const UPDATE_CHECK_FILE = path.join(OUTPUT, 'cache', '.update-check');
   try {
@@ -331,7 +384,7 @@ async function checkForUpdate() {
     if (fs.existsSync(UPDATE_CHECK_FILE)) {
       const lastCheck = JSON.parse(fs.readFileSync(UPDATE_CHECK_FILE, 'utf8'));
       if (Date.now() - lastCheck.timestamp < 24 * 60 * 60 * 1000) {
-        if (lastCheck.latest && lastCheck.latest !== lastCheck.current) {
+        if (lastCheck.latest && semverGt(lastCheck.latest, lastCheck.current)) {
           console.log(`\noh-my-hi: ✨ v${lastCheck.latest} available (current: v${lastCheck.current})`);
           console.log('  → Update: /omh --update');
         }
@@ -341,25 +394,48 @@ async function checkForUpdate() {
 
     const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'));
     const current = pkg.version;
+    let latest = null;
+
+    // Check GitHub tags first (primary distribution channel)
+    const repoUrl = pkg.repository?.url || '';
+    const ghMatch = repoUrl.match(/github\.com[/:]([^/]+\/[^/.]+)/);
+    if (ghMatch) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 3000);
+      const res = await fetch(`https://api.github.com/repos/${ghMatch[1]}/tags`, {
+        signal: controller.signal, headers: { 'Accept': 'application/vnd.github+json' },
+      });
+      clearTimeout(timeout);
+      if (res.ok) {
+        const tags = await res.json();
+        for (const tag of tags) {
+          const v = tag.name.replace(/^v/, '');
+          if (/^\d+\.\d+\.\d+$/.test(v) && (!latest || semverGt(v, latest))) latest = v;
+        }
+      }
+    }
 
-    // Fetch latest version from npm (with 3s timeout)
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 3000);
-    const res = await fetch(`https://registry.npmjs.org/${pkg.name}/latest`, {
-      signal: controller.signal,
-      headers: { 'Accept': 'application/json' },
-    });
-    clearTimeout(timeout);
+    // Fallback to npm registry
+    if (!latest) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 3000);
+      const res = await fetch(`https://registry.npmjs.org/${pkg.name}/latest`, {
+        signal: controller.signal, headers: { 'Accept': 'application/json' },
+      });
+      clearTimeout(timeout);
+      if (res.ok) {
+        const data = await res.json();
+        latest = data.version;
+      }
+    }
 
-    if (!res.ok) return;
-    const data = await res.json();
-    const latest = data.version;
+    if (!latest) return;
 
     // Cache the result
     fs.mkdirSync(path.dirname(UPDATE_CHECK_FILE), { recursive: true });
     fs.writeFileSync(UPDATE_CHECK_FILE, JSON.stringify({ timestamp: Date.now(), current, latest }), 'utf8');
 
-    if (latest && latest !== current) {
+    if (semverGt(latest, current)) {
       console.log(`\noh-my-hi: ✨ v${latest} available (current: v${current})`);
       console.log('  → Update: /omh --update');
     }
@@ -385,8 +461,18 @@ function detectSystemLocale() {
   return systemLocale;
 }
 
+/** Render an in-place progress bar to stdout */
+function renderProgressBar(processed, total) {
+  if (!total) return;
+  const pct = Math.round((processed / total) * 100);
+  const width = 25;
+  const filled = Math.round((processed / total) * width);
+  const bar = '█'.repeat(filled) + '░'.repeat(width - filled);
+  process.stdout.write(`\r  [${bar}] ${pct}% (${processed}/${total} files)`);
+}
+
 /** Collect all scopes (global + projects) with given options */
-async function collectAllScopes(scopes, { days = 0, cache, cachePath } = {}) {
+async function collectAllScopes(scopes, { days = 0, cache, cachePath, progress = false } = {}) {
   const projectScopes = scopes.filter(s => s.type !== 'global');
   // Load or reuse cache; reset parse counter for this collection round
   const sharedCache = cache || (cachePath ? loadTranscriptCache(cachePath) : {});
@@ -398,6 +484,12 @@ async function collectAllScopes(scopes, { days = 0, cache, cachePath } = {}) {
   }
 
   sharedCache._parsed = 0;
+  sharedCache._processed = 0;
+  sharedCache._total = 0;
+  sharedCache._onProgress = progress
+    ? () => renderProgressBar(sharedCache._processed, sharedCache._total)
+    : undefined;
+
   const usageOpts = { days, cache: sharedCache, cachePath };
 
   const [globalData, ...projectResults] = await Promise.all([
@@ -416,6 +508,8 @@ async function collectAllScopes(scopes, { days = 0, cache, cachePath } = {}) {
   // Update mtime index for lightweight mode
   if (cachePath) saveMtimeIndex(cachePath, sharedCache);
 
+  if (progress) process.stdout.write('\n');
+
   const totalFiles = Object.keys(sharedCache).filter(k => !k.startsWith('_')).length;
   const parsed = Math.min(sharedCache._parsed || 0, totalFiles);
   console.log(`  transcripts: ${totalFiles} files (${parsed} parsed, ${totalFiles - parsed} cached)`);
@@ -441,7 +535,9 @@ function buildDataObject(scopes, scopeData, systemLocale, extra = {}) {
     }
   }
   const taskCategories = buildTaskCategories(cleanScopeData);
-  const isDevBuild = fs.existsSync(path.join(ROOT, '.git'));
+  // 스크립트가 ~/.claude 하위(플러그인)에서 실행되면 배포본, 그 외는 dev
+  const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+  const isDevBuild = !scriptDir.startsWith(CLAUDE_CONFIG_DIR);
   return {
     scopes,
     scopeData: cleanScopeData,

package/scripts/parsers/usage.mjs

@@ -405,19 +405,24 @@ export function saveMtimeIndex(cachePath, cache) {
  * Always parses without cutoff (full data) so cache is reusable across time ranges.
  */
 async function cachedParseTranscriptFile(fp, cache) {
-  let stat;
-  try { stat = fs.statSync(fp); } catch { return null; }
-  const cached = cache[fp];
-  if (cached && cached.mtimeMs === stat.mtimeMs) {
-    // Full cache hit (has result) or mtime-only stub (skip — already processed)
-    if (cached.size === stat.size) return cached.result;
-    // Mtime match but size=0 means mtime-only stub from lightweight mode — skip
-    if (cached.size === 0) return null;
+  try {
+    let stat;
+    try { stat = fs.statSync(fp); } catch { return null; }
+    const cached = cache[fp];
+    if (cached && cached.mtimeMs === stat.mtimeMs) {
+      // Full cache hit (has result) or mtime-only stub (skip — already processed)
+      if (cached.size === stat.size) return cached.result;
+      // Mtime match but size=0 means mtime-only stub from lightweight mode — skip
+      if (cached.size === 0) return null;
+    }
+    const result = await parseTranscriptFile(fp, 0);
+    cache[fp] = { mtimeMs: stat.mtimeMs, size: stat.size, result, _new: true };
+    cache._parsed = (cache._parsed || 0) + 1;
+    return result;
+  } finally {
+    cache._processed = (cache._processed || 0) + 1;
+    cache._onProgress?.();
   }
-  const result = await parseTranscriptFile(fp, 0);
-  cache[fp] = { mtimeMs: stat.mtimeMs, size: stat.size, result, _new: true };
-  cache._parsed = (cache._parsed || 0) + 1;
-  return result;
 }
 
 /**
@@ -671,6 +676,7 @@ async function parseTranscripts(configDir, cutoffMs, cache = {}) {
   }
 
   // Phase 2: Parse all files in parallel (with cache)
+  cache._total = (cache._total || 0) + filePaths.length;
   const results = await parallelMap(filePaths, fp => cachedParseTranscriptFile(fp, cache));
 
   return applyCutoff(mergeTranscriptResults(results.filter(Boolean)), cutoffMs);
@@ -784,6 +790,7 @@ async function parseProjectTranscripts(projDirPath, cutoffMs, cache = {}) {
   }
 
   // Phase 2: Parse all files in parallel (with cache)
+  cache._total = (cache._total || 0) + filePaths.length;
   const results = await parallelMap(filePaths, fp => cachedParseTranscriptFile(fp, cache));
 
   return applyCutoff(mergeTranscriptResults(results.filter(Boolean)), cutoffMs);

package/test/cache.test.mjs

@@ -208,13 +208,11 @@ describe('Conditional HTML Rebuild', () => {
   });
 
   it('should not rebuild index.html when version matches', () => {
-    // Get current mtime
-    const statBefore = fs.statSync(path.join(OUTPUT, 'index.html'));
-    // Wait 1s to ensure mtime would differ
-    execSync('sleep 1');
-    run('--data-only');
-    const statAfter = fs.statSync(path.join(OUTPUT, 'index.html'));
-    assert.equal(statBefore.mtimeMs, statAfter.mtimeMs, 'index.html should not be rewritten');
+    // Check output rather than mtime: mtime comparison is unreliable on macOS APFS
+    // due to sub-millisecond timestamp precision artifacts.
+    const output = run('--data-only');
+    assert.ok(!output.includes('rebuilding'), 'should not print rebuilding message');
+    assert.ok(!output.includes('data structure changed'), 'should not trigger migration rebuild');
   });
 });
 
@@ -323,6 +321,97 @@ describe('Progressive Loading', () => {
   });
 });
 
+// ── Progress Tracking ──
+
+describe('Progress Tracking', () => {
+  it('_onProgress is called for every file (cache hit and miss)', async () => {
+    const tmpDir = fs.mkdtempSync('/tmp/omh-progress-');
+    try {
+      // Write two minimal JSONL transcript files
+      fs.writeFileSync(path.join(tmpDir, 'a.jsonl'), '');
+      fs.writeFileSync(path.join(tmpDir, 'b.jsonl'), '');
+
+      const cache = {};
+      let callCount = 0;
+      cache._onProgress = () => { callCount++; };
+
+      await parseUsage(CLAUDE_CONFIG_DIR, 0, tmpDir, { cache });
+      assert.ok(callCount >= 2, `_onProgress should be called at least once per file, got ${callCount}`);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true });
+    }
+  });
+
+  it('_processed equals number of files processed', async () => {
+    const tmpDir = fs.mkdtempSync('/tmp/omh-progress-');
+    try {
+      fs.writeFileSync(path.join(tmpDir, 'a.jsonl'), '');
+      fs.writeFileSync(path.join(tmpDir, 'b.jsonl'), '');
+      fs.writeFileSync(path.join(tmpDir, 'c.jsonl'), '');
+
+      const cache = {};
+      cache._onProgress = () => {};
+      await parseUsage(CLAUDE_CONFIG_DIR, 0, tmpDir, { cache });
+
+      assert.equal(cache._processed, 3, '_processed should equal file count');
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true });
+    }
+  });
+
+  it('_total is set before files are processed', async () => {
+    const tmpDir = fs.mkdtempSync('/tmp/omh-progress-');
+    try {
+      fs.writeFileSync(path.join(tmpDir, 'a.jsonl'), '');
+      fs.writeFileSync(path.join(tmpDir, 'b.jsonl'), '');
+
+      const cache = {};
+      let totalAtFirstCall = null;
+      cache._onProgress = () => {
+        if (totalAtFirstCall === null) totalAtFirstCall = cache._total;
+      };
+
+      await parseUsage(CLAUDE_CONFIG_DIR, 0, tmpDir, { cache });
+      assert.ok(totalAtFirstCall >= 2, `_total should be set before first _onProgress, got ${totalAtFirstCall}`);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true });
+    }
+  });
+
+  it('_processed increments for cache hits too', async () => {
+    const tmpDir = fs.mkdtempSync('/tmp/omh-progress-');
+    try {
+      fs.writeFileSync(path.join(tmpDir, 'a.jsonl'), '');
+
+      // First run — cache miss
+      const cache = {};
+      cache._onProgress = () => {};
+      await parseUsage(CLAUDE_CONFIG_DIR, 0, tmpDir, { cache });
+      const parsedFirst = cache._parsed;
+
+      // Second run — cache hit
+      cache._processed = 0;
+      cache._parsed = 0;
+      cache._onProgress = () => {};
+      await parseUsage(CLAUDE_CONFIG_DIR, 0, tmpDir, { cache });
+
+      assert.equal(cache._processed, 1, '_processed should increment even on cache hit');
+      assert.equal(cache._parsed, 0, '_parsed should not increment on cache hit');
+      assert.equal(parsedFirst, 1, 'first run should have parsed the file');
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true });
+    }
+  });
+
+  it('normal mode output contains progress bar characters', () => {
+    // Progress bar is only shown in full (non --data-only) mode
+    // Use captured stdout which includes \r-separated progress updates
+    const output = run();
+    const hasProgressBar = output.includes('[') && output.includes('%') && output.includes('files)');
+    assert.ok(hasProgressBar, 'output should contain progress bar ([ ... % ... files))');
+  });
+});
+
 // ── findSkillFiles Exclusions ──
 
 describe('findSkillFiles exclusions', () => {