vibeglish 0.1.0

package/src/hooks/capture.sh

@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+# VibeGlish capture hook — silently captures Claude Code prompts
+# Must complete in < 50ms. No network requests. Silent on failure.
+
+set -euo pipefail
+trap 'exit 0' ERR
+
+VIBEGLISH_DIR="${HOME}/.vibeglish"
+RAW_DIR="${VIBEGLISH_DIR}/raw"
+ERROR_LOG="${VIBEGLISH_DIR}/error.log"
+
+# Read stdin
+INPUT=$(cat 2>/dev/null) || exit 0
+
+# Validate JSON and extract fields
+if ! command -v jq &>/dev/null; then
+  echo "$(date -Iseconds) jq not installed" >> "${ERROR_LOG}" 2>/dev/null
+  exit 0
+fi
+
+PROMPT=$(echo "$INPUT" | jq -r '.prompt // empty' 2>/dev/null) || exit 0
+[ -z "$PROMPT" ] && exit 0
+
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // "unknown"' 2>/dev/null) || true
+CWD=$(echo "$INPUT" | jq -r '.cwd // ""' 2>/dev/null) || true
+PROJECT=$(basename "$CWD" 2>/dev/null) || PROJECT="unknown"
+
+# --- Filtering ---
+
+# Skip slash commands
+[[ "$PROMPT" == /* ]] && exit 0
+
+# Skip pure file paths
+if [[ "$PROMPT" =~ ^[/~][a-zA-Z0-9_./-]+$ ]]; then
+  exit 0
+fi
+
+# Skip if no ASCII letters (pure Chinese / symbols)
+if ! echo "$PROMPT" | grep -q '[a-zA-Z]'; then
+  exit 0
+fi
+
+# Word count check (< 4 words = skip)
+WORD_COUNT=$(echo "$PROMPT" | wc -w | tr -d ' ')
+[ "$WORD_COUNT" -lt 4 ] && exit 0
+
+# Skip if code blocks dominate (> 70%)
+TOTAL_LINES=$(echo "$PROMPT" | wc -l | tr -d ' ')
+if [ "$TOTAL_LINES" -gt 0 ]; then
+  CODE_LINES=$(echo "$PROMPT" | awk '
+    /^```/ { in_code = !in_code; next }
+    in_code { count++ }
+    /^    / && !in_code { count++ }
+    END { print count+0 }
+  ')
+  if [ "$TOTAL_LINES" -gt 2 ]; then
+    RATIO=$((CODE_LINES * 100 / TOTAL_LINES))
+    [ "$RATIO" -gt 70 ] && exit 0
+  fi
+fi
+
+# Skip duplicate (same session, same prompt hash)
+PROMPT_HASH=$(echo -n "$PROMPT" | md5sum 2>/dev/null | cut -d' ' -f1 || echo -n "$PROMPT" | md5 2>/dev/null)
+LAST_FILE="/tmp/.vibeglish-last-${SESSION_ID}"
+if [ -f "$LAST_FILE" ]; then
+  LAST_HASH=$(cat "$LAST_FILE" 2>/dev/null) || true
+  [ "$PROMPT_HASH" = "$LAST_HASH" ] && exit 0
+fi
+echo -n "$PROMPT_HASH" > "$LAST_FILE" 2>/dev/null || true
+
+# --- Sanitization ---
+
+# Redact obvious secrets
+PROMPT=$(echo "$PROMPT" | sed -E \
+  -e 's/sk-[a-zA-Z0-9]{20,}/[REDACTED]/g' \
+  -e 's/ghp_[a-zA-Z0-9]{20,}/[REDACTED]/g' \
+  -e 's/gho_[a-zA-Z0-9]{20,}/[REDACTED]/g' \
+  -e 's/AKIA[A-Z0-9]{16}/[REDACTED]/g' \
+  -e 's/xoxb-[a-zA-Z0-9-]{20,}/[REDACTED]/g' \
+)
+
+# --- Write ---
+
+CHAR_COUNT=${#PROMPT}
+DATE=$(date +%Y-%m-%d)
+TS=$(date -Iseconds 2>/dev/null || date +%Y-%m-%dT%H:%M:%S%z)
+TARGET="${RAW_DIR}/${DATE}.jsonl"
+
+mkdir -p "$RAW_DIR" 2>/dev/null || exit 0
+
+JSON_LINE=$(jq -cn \
+  --arg ts "$TS" \
+  --arg sid "$SESSION_ID" \
+  --arg proj "$PROJECT" \
+  --arg prompt "$PROMPT" \
+  --argjson cc "$CHAR_COUNT" \
+  --argjson wc "$WORD_COUNT" \
+  '{ts:$ts, session_id:$sid, project:$proj, prompt:$prompt, char_count:$cc, word_count:$wc}' \
+2>/dev/null) || exit 0
+
+# Atomic append with lock (use mkdir as cross-platform lock)
+LOCKDIR="/tmp/.vibeglish-raw.lock"
+if mkdir "$LOCKDIR" 2>/dev/null; then
+  echo "$JSON_LINE" >> "$TARGET" 2>/dev/null || true
+  rmdir "$LOCKDIR" 2>/dev/null || true
+else
+  # Lock held by another process, try without lock (append is mostly atomic for small writes)
+  echo "$JSON_LINE" >> "$TARGET" 2>/dev/null || true
+fi
+
+exit 0

package/src/review/engine.mjs

@@ -0,0 +1,185 @@
+import { execFile } from 'node:child_process';
+import { REVIEW_SYSTEM_PROMPT } from '../constants.mjs';
+import { readJSON } from '../utils.mjs';
+import { CONFIG_PATH, DEFAULT_CONFIG } from '../constants.mjs';
+
+export async function reviewBatch(entries, config = {}) {
+  const cfg = { ...DEFAULT_CONFIG, ...readJSON(CONFIG_PATH), ...config };
+
+  // Prepare entries with IDs
+  const prepared = entries.map((e) => {
+    const ts = e.ts || new Date().toISOString();
+    const timePart = ts.replace(/[-:T]/g, '').slice(8, 14);
+    const rand = Math.random().toString(16).slice(2, 6);
+    return {
+      ...e,
+      id: e.id || `${ts.slice(0, 10).replace(/-/g, '')}-${timePart}-${rand}`,
+    };
+  });
+
+  // Truncate long prompts
+  for (const entry of prepared) {
+    if (entry.prompt.length > 2000) {
+      const words = entry.prompt.split(/\s+/).slice(0, 500);
+      entry.prompt = words.join(' ');
+      entry.truncated = true;
+    }
+  }
+
+  // Split into batches
+  const batchSize = cfg.batch_size || 20;
+  const batches = [];
+  for (let i = 0; i < prepared.length; i += batchSize) {
+    batches.push(prepared.slice(i, i + batchSize));
+  }
+
+  // Process batches sequentially (claude CLI has subscription rate limits)
+  const results = [];
+  for (let i = 0; i < batches.length; i++) {
+    process.stdout.write(`  Reviewing batch ${i + 1}/${batches.length}...\r`);
+    const batchResult = await callClaude(batches[i]);
+    results.push(batchResult);
+  }
+
+  // Flatten and merge results
+  const allResults = [];
+  for (let i = 0; i < batches.length; i++) {
+    const batch = batches[i];
+    const batchResults = results[i] || [];
+
+    for (let j = 0; j < batch.length; j++) {
+      const entry = batch[j];
+      const result = batchResults[j] || { skip: true, review_status: 'failed' };
+
+      if (result.skip) {
+        allResults.push({
+          id: entry.id,
+          ts: entry.ts,
+          project: entry.project,
+          original: entry.prompt,
+          skipped: true,
+          ...(entry.truncated ? { truncated: true } : {}),
+          ...(result.review_status ? { review_status: result.review_status } : {}),
+        });
+      } else {
+        allResults.push({
+          id: entry.id,
+          ts: entry.ts,
+          project: entry.project,
+          original: entry.prompt,
+          corrected: result.corrected || entry.prompt,
+          score: result.score ?? 0,
+          is_clean: result.is_clean ?? false,
+          issues: result.issues || [],
+          ...(entry.truncated ? { truncated: true } : {}),
+        });
+      }
+    }
+  }
+
+  return allResults;
+}
+
+async function callClaude(batch, retries = 3) {
+  const payload = batch.map(e => ({ id: e.id, prompt: e.prompt }));
+  const userMessage = JSON.stringify(payload);
+
+  for (let attempt = 0; attempt < retries; attempt++) {
+    try {
+      const text = await execClaude(REVIEW_SYSTEM_PROMPT, userMessage);
+      return parseResponse(text, batch.length);
+    } catch (err) {
+      if (attempt < retries - 1) {
+        const delay = Math.pow(2, attempt) * 1000;
+        await new Promise(r => setTimeout(r, delay));
+        continue;
+      }
+      console.error(`\n  claude call failed after ${retries} retries: ${err.message}`);
+      return batch.map(() => ({ skip: true, review_status: 'failed' }));
+    }
+  }
+}
+
+function execClaude(systemPrompt, userMessage) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      '-p', userMessage,
+      '--system-prompt', systemPrompt,
+      '--output-format', 'text',
+    ];
+
+    const child = execFile('claude', args, {
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: 120_000,
+    }, (err, stdout, stderr) => {
+      if (err) {
+        reject(new Error(`claude CLI error: ${err.message}${stderr ? `\n${stderr}` : ''}`));
+        return;
+      }
+      resolve(stdout);
+    });
+  });
+}
+
+function parseResponse(text, expectedLength) {
+  // Try parsing as-is
+  let parsed = tryParse(text);
+  if (parsed) return validateLength(parsed, expectedLength);
+
+  // Strip markdown fences
+  const stripped = text.replace(/^```(?:json)?\s*\n?/m, '').replace(/\n?```\s*$/m, '');
+  parsed = tryParse(stripped);
+  if (parsed) return validateLength(parsed, expectedLength);
+
+  // Try fixing truncated JSON by closing brackets
+  const fixed = stripped + (stripped.includes('[') && !stripped.endsWith(']') ? ']' : '');
+  parsed = tryParse(fixed);
+  if (parsed) return validateLength(parsed, expectedLength);
+
+  console.error('  Failed to parse response from claude');
+  return Array.from({ length: expectedLength }, () => ({ skip: true, review_status: 'parse_failed' }));
+}
+
+function tryParse(text) {
+  try {
+    const result = JSON.parse(text);
+    return Array.isArray(result) ? result : null;
+  } catch {
+    return null;
+  }
+}
+
+function validateLength(parsed, expectedLength) {
+  if (parsed.length === expectedLength) return parsed;
+  if (parsed.length < expectedLength) {
+    while (parsed.length < expectedLength) {
+      parsed.push({ skip: true, review_status: 'mismatch' });
+    }
+  }
+  return parsed.slice(0, expectedLength);
+}
+
+export function computeStats(entries) {
+  const reviewed = entries.filter(e => !e.skipped);
+  const skipped = entries.filter(e => e.skipped);
+
+  const issueBreakdown = { grammar: 0, vocabulary: 0, spelling: 0, punctuation: 0, style: 0, word_order: 0 };
+  let totalScore = 0;
+
+  for (const entry of reviewed) {
+    totalScore += entry.score || 0;
+    for (const issue of entry.issues || []) {
+      if (issueBreakdown[issue.type] !== undefined) {
+        issueBreakdown[issue.type]++;
+      }
+    }
+  }
+
+  return {
+    total_captured: entries.length,
+    total_reviewed: reviewed.length,
+    skipped: skipped.length,
+    avg_score: reviewed.length > 0 ? Math.round((totalScore / reviewed.length) * 10) / 10 : 0,
+    issue_breakdown: issueBreakdown,
+  };
+}

package/src/utils.mjs

@@ -0,0 +1,64 @@
+import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, readdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+export function readJSON(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export function writeJSON(path, data) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
+}
+
+export function readJSONL(path) {
+  try {
+    const lines = readFileSync(path, 'utf-8').trim().split('\n').filter(Boolean);
+    return lines.map(line => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
+export function appendJSONL(path, obj) {
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, JSON.stringify(obj) + '\n');
+}
+
+export function listFiles(dir, ext) {
+  try {
+    return readdirSync(dir).filter(f => f.endsWith(ext)).sort();
+  } catch {
+    return [];
+  }
+}
+
+export function formatDate(date = new Date()) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, '0');
+  const d = String(date.getDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+}
+
+export function parseDate(str) {
+  const [y, m, d] = str.split('-').map(Number);
+  return new Date(y, m - 1, d);
+}
+
+export function dateRange(from, to) {
+  const dates = [];
+  const current = parseDate(from);
+  const end = parseDate(to);
+  while (current <= end) {
+    dates.push(formatDate(current));
+    current.setDate(current.getDate() + 1);
+  }
+  return dates;
+}
+
+export function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+}

package/test/achievements.test.mjs

@@ -0,0 +1,116 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { checkAchievements } from '../src/achievements.mjs';
+
+function makeDay(date, entries = [], overrides = {}) {
+  const reviewed = entries.filter(e => !e.skipped);
+  const issueBreakdown = { grammar: 0, vocabulary: 0, spelling: 0, punctuation: 0, style: 0, word_order: 0 };
+  for (const e of reviewed) {
+    for (const i of e.issues || []) {
+      if (issueBreakdown[i.type] !== undefined) issueBreakdown[i.type]++;
+    }
+  }
+  return {
+    date,
+    stats: {
+      total_captured: entries.length,
+      total_reviewed: reviewed.length,
+      skipped: entries.length - reviewed.length,
+      avg_score: reviewed.length > 0 ? reviewed.reduce((s, e) => s + (e.score || 0), 0) / reviewed.length : 0,
+      issue_breakdown: issueBreakdown,
+      ...overrides,
+    },
+    entries: reviewed,
+  };
+}
+
+function makeEntry(score, issues = [], opts = {}) {
+  return {
+    id: Math.random().toString(36).slice(2),
+    ts: opts.ts || '2026-04-01T10:00:00+08:00',
+    project: opts.project || 'test',
+    original: 'test prompt',
+    corrected: 'test prompt.',
+    score,
+    is_clean: score >= 95,
+    issues,
+  };
+}
+
+describe('achievements', () => {
+  it('unlocks First Blood with one reviewed day', () => {
+    const data = [makeDay('2026-04-01', [makeEntry(70)])];
+    const results = checkAchievements(data);
+    const fb = results.find(a => a.id === 'first_blood');
+    assert.ok(fb.unlocked);
+  });
+
+  it('does not unlock First Blood with no data', () => {
+    const data = [makeDay('2026-04-01', [])];
+    const results = checkAchievements(data);
+    const fb = results.find(a => a.id === 'first_blood');
+    assert.ok(!fb.unlocked);
+  });
+
+  it('unlocks Century Club at 100 entries', () => {
+    const entries = Array.from({ length: 100 }, () => makeEntry(60));
+    const data = [makeDay('2026-04-01', entries)];
+    const results = checkAchievements(data);
+    const cc = results.find(a => a.id === 'century_club');
+    assert.ok(cc.unlocked);
+  });
+
+  it('unlocks Clean Coder when >50% clean', () => {
+    const entries = [
+      makeEntry(96), makeEntry(97), makeEntry(98), // 3 clean
+      makeEntry(60), makeEntry(50), // 2 not clean
+    ];
+    const data = [makeDay('2026-04-01', entries)];
+    const results = checkAchievements(data);
+    const cc = results.find(a => a.id === 'clean_coder');
+    assert.ok(cc.unlocked);
+  });
+
+  it('unlocks Perfect Day when all scores >= 90', () => {
+    const entries = [makeEntry(92), makeEntry(95), makeEntry(90)];
+    const data = [makeDay('2026-04-01', entries)];
+    const results = checkAchievements(data);
+    const pd = results.find(a => a.id === 'perfect_day');
+    assert.ok(pd.unlocked);
+  });
+
+  it('does not unlock Perfect Day with one low score', () => {
+    const entries = [makeEntry(92), makeEntry(50), makeEntry(90)];
+    const data = [makeDay('2026-04-01', entries)];
+    const results = checkAchievements(data);
+    const pd = results.find(a => a.id === 'perfect_day');
+    assert.ok(!pd.unlocked);
+  });
+
+  it('unlocks Night Owl for late night prompts', () => {
+    const entries = [makeEntry(70, [], { ts: '2026-04-01T02:30:00+08:00' })];
+    const data = [makeDay('2026-04-01', entries)];
+    const results = checkAchievements(data);
+    const no = results.find(a => a.id === 'night_owl');
+    assert.ok(no.unlocked);
+  });
+
+  it('unlocks Streak Master x7 with 7 consecutive days', () => {
+    const data = [];
+    for (let i = 0; i < 7; i++) {
+      const d = `2026-04-${String(i + 1).padStart(2, '0')}`;
+      data.push(makeDay(d, [makeEntry(60)]));
+    }
+    const results = checkAchievements(data);
+    const sm = results.find(a => a.id === 'streak_7');
+    assert.ok(sm.unlocked);
+  });
+
+  it('does not unlock Streak 7 with gap', () => {
+    const dates = ['2026-04-01', '2026-04-02', '2026-04-03', '2026-04-05', '2026-04-06', '2026-04-07', '2026-04-08'];
+    const data = dates.map(d => makeDay(d, [makeEntry(60)]));
+    const results = checkAchievements(data);
+    const sm = results.find(a => a.id === 'streak_7');
+    assert.ok(!sm.unlocked);
+  });
+});

package/test/capture.test.mjs

@@ -0,0 +1,108 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { execSync } from 'node:child_process';
+import { mkdirSync, readFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const CAPTURE_SCRIPT = join(import.meta.dirname, '../src/hooks/capture.sh');
+const RAW_DIR = join(homedir(), '.vibeglish', 'raw');
+
+function capture(input) {
+  const json = JSON.stringify(input);
+  try {
+    execSync(`echo '${json.replace(/'/g, "'\\''")}' | bash "${CAPTURE_SCRIPT}"`, {
+      timeout: 5000,
+      stdio: 'pipe',
+    });
+  } catch (err) {
+    // capture.sh should never throw
+    return err;
+  }
+  return null;
+}
+
+function todayFile() {
+  const d = new Date();
+  const date = `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,'0')}-${String(d.getDate()).padStart(2,'0')}`;
+  return join(RAW_DIR, `${date}.jsonl`);
+}
+
+function lineCount() {
+  const f = todayFile();
+  if (!existsSync(f)) return 0;
+  return readFileSync(f, 'utf-8').trim().split('\n').filter(Boolean).length;
+}
+
+describe('capture.sh', () => {
+  it('captures a valid prompt', () => {
+    const before = lineCount();
+    capture({
+      session_id: 'test-capture-valid',
+      prompt: 'This is a valid test prompt for capture testing',
+      cwd: '/tmp/test-project',
+    });
+    assert.equal(lineCount(), before + 1);
+  });
+
+  it('filters slash commands', () => {
+    const before = lineCount();
+    capture({ session_id: 'test-slash', prompt: '/help', cwd: '/tmp' });
+    assert.equal(lineCount(), before);
+  });
+
+  it('filters short prompts (< 4 words)', () => {
+    const before = lineCount();
+    capture({ session_id: 'test-short', prompt: 'yes ok', cwd: '/tmp' });
+    assert.equal(lineCount(), before);
+  });
+
+  it('filters pure Chinese prompts', () => {
+    const before = lineCount();
+    capture({ session_id: 'test-chinese', prompt: '这是纯中文消息', cwd: '/tmp' });
+    assert.equal(lineCount(), before);
+  });
+
+  it('filters file paths', () => {
+    const before = lineCount();
+    capture({ session_id: 'test-path', prompt: '/Users/test/project/file.ts', cwd: '/tmp' });
+    assert.equal(lineCount(), before);
+  });
+
+  it('filters duplicate prompts in same session', () => {
+    const before = lineCount();
+    capture({ session_id: 'test-dup-session', prompt: 'this is a duplicate test prompt for checking', cwd: '/tmp' });
+    const after1 = lineCount();
+    assert.equal(after1, before + 1);
+    capture({ session_id: 'test-dup-session', prompt: 'this is a duplicate test prompt for checking', cwd: '/tmp' });
+    assert.equal(lineCount(), after1); // no change
+  });
+
+  it('redacts API keys', () => {
+    capture({
+      session_id: 'test-redact',
+      prompt: 'use this key sk-abcdefghijklmnopqrstuvwxyz to access the api',
+      cwd: '/tmp/redact-test',
+    });
+    const f = todayFile();
+    const last = readFileSync(f, 'utf-8').trim().split('\n').pop();
+    const data = JSON.parse(last);
+    assert.ok(data.prompt.includes('[REDACTED]'));
+    assert.ok(!data.prompt.includes('sk-abcdef'));
+  });
+
+  it('exits 0 on invalid JSON input', () => {
+    const err = execSync(`echo 'not json' | bash "${CAPTURE_SCRIPT}" 2>&1; echo $?`, { encoding: 'utf-8' });
+    assert.ok(err.trim().endsWith('0'));
+  });
+
+  it('keeps mixed Chinese-English prompts', () => {
+    const before = lineCount();
+    capture({
+      session_id: 'test-mixed',
+      prompt: '帮我 fix this bug in the authentication module',
+      cwd: '/tmp/mixed',
+    });
+    assert.equal(lineCount(), before + 1);
+  });
+});

package/test/engine.test.mjs

@@ -0,0 +1,56 @@
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { computeStats } from '../src/review/engine.mjs';
+
+describe('computeStats', () => {
+  it('computes correct stats for mixed entries', () => {
+    const entries = [
+      {
+        id: '1', original: 'test', corrected: 'test!', score: 80, is_clean: false,
+        issues: [{ type: 'grammar', original: 'a', corrected: 'b', rule: 'test' }],
+      },
+      {
+        id: '2', original: 'good', corrected: 'good', score: 95, is_clean: true,
+        issues: [],
+      },
+      {
+        id: '3', original: 'code', skipped: true,
+      },
+      {
+        id: '4', original: 'bad', corrected: 'well', score: 50, is_clean: false,
+        issues: [
+          { type: 'grammar', original: 'x', corrected: 'y', rule: 'r1' },
+          { type: 'vocabulary', original: 'a', corrected: 'b', rule: 'r2' },
+        ],
+      },
+    ];
+
+    const stats = computeStats(entries);
+    assert.equal(stats.total_captured, 4);
+    assert.equal(stats.total_reviewed, 3);
+    assert.equal(stats.skipped, 1);
+    assert.equal(stats.avg_score, 75); // (80+95+50)/3 = 75
+    assert.equal(stats.issue_breakdown.grammar, 2);
+    assert.equal(stats.issue_breakdown.vocabulary, 1);
+    assert.equal(stats.issue_breakdown.spelling, 0);
+  });
+
+  it('handles empty entries', () => {
+    const stats = computeStats([]);
+    assert.equal(stats.total_captured, 0);
+    assert.equal(stats.total_reviewed, 0);
+    assert.equal(stats.avg_score, 0);
+  });
+
+  it('handles all skipped entries', () => {
+    const entries = [
+      { id: '1', original: 'code', skipped: true },
+      { id: '2', original: 'path', skipped: true },
+    ];
+    const stats = computeStats(entries);
+    assert.equal(stats.total_captured, 2);
+    assert.equal(stats.total_reviewed, 0);
+    assert.equal(stats.skipped, 2);
+    assert.equal(stats.avg_score, 0);
+  });
+});