vibeglish 0.1.0

package/src/cli/commands/report.mjs

@@ -0,0 +1,141 @@
+import { join } from 'node:path';
+import { REVIEWED_DIR } from '../../constants.mjs';
+import { readJSON, listFiles, formatDate, parseDate } from '../../utils.mjs';
+import { checkAchievements } from '../../achievements.mjs';
+
+export default async function report(args) {
+  const daysArg = args.indexOf('--days');
+  const days = daysArg !== -1 && args[daysArg + 1] ? parseInt(args[daysArg + 1]) : 7;
+
+  const today = parseDate(formatDate());
+  const startDate = new Date(today);
+  startDate.setDate(startDate.getDate() - days + 1);
+
+  const allFiles = listFiles(REVIEWED_DIR, '.json');
+  if (allFiles.length === 0) {
+    console.log('No reviewed data yet. Run "vibeglish review" first.');
+    return;
+  }
+
+  // Load all reviewed data
+  const allData = [];
+  const periodData = [];
+  const startStr = formatDate(startDate);
+
+  for (const f of allFiles) {
+    const data = readJSON(join(REVIEWED_DIR, f));
+    if (!data) continue;
+    allData.push(data);
+    if (data.date >= startStr) {
+      periodData.push(data);
+    }
+  }
+
+  if (periodData.length === 0) {
+    console.log(`No data in the last ${days} days.`);
+    return;
+  }
+
+  // Compute stats
+  const totalCaptures = periodData.reduce((s, d) => s + d.stats.total_captured, 0);
+  const totalReviewed = periodData.reduce((s, d) => s + d.stats.total_reviewed, 0);
+  const totalSkipped = periodData.reduce((s, d) => s + d.stats.skipped, 0);
+  const avgScore = periodData.reduce((s, d) => s + d.stats.avg_score, 0) / periodData.length;
+
+  // Previous period for comparison
+  const prevStart = new Date(startDate);
+  prevStart.setDate(prevStart.getDate() - days);
+  const prevStartStr = formatDate(prevStart);
+  const prevData = allData.filter(d => d.date >= prevStartStr && d.date < startStr);
+  const prevAvg = prevData.length > 0
+    ? prevData.reduce((s, d) => s + d.stats.avg_score, 0) / prevData.length
+    : null;
+  const scoreDiff = prevAvg !== null ? avgScore - prevAvg : null;
+
+  // Issue breakdown
+  const issueMap = {};
+  for (const day of periodData) {
+    for (const entry of day.entries) {
+      for (const issue of entry.issues || []) {
+        const key = issue.rule || issue.type;
+        issueMap[key] = (issueMap[key] || 0) + 1;
+      }
+    }
+  }
+  const topIssues = Object.entries(issueMap)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 3);
+
+  // Daily scores
+  const dailyScores = periodData
+    .sort((a, b) => a.date.localeCompare(b.date))
+    .map(d => ({ date: d.date, score: d.stats.avg_score }));
+
+  // Clean prompts
+  const cleanCount = periodData.reduce((s, d) =>
+    s + d.entries.filter(e => e.is_clean).length, 0);
+
+  // Achievements
+  const achievements = checkAchievements(allData);
+  const recentUnlocked = achievements.filter(a => {
+    if (!a.unlockedAt) return false;
+    return a.unlockedAt >= startStr;
+  });
+
+  // Format dates
+  const from = periodData[0].date.slice(5);
+  const to = periodData[periodData.length - 1].date.slice(5);
+
+  // Output
+  const cols = process.stdout.columns || 50;
+  const barWidth = Math.min(10, Math.floor(cols / 6));
+
+  console.log(`
+\u{1F4CA} VibeGlish Report (${from} ~ ${to})
+${'━'.repeat(Math.min(cols - 2, 45))}
+
+  Prompts captured:  ${totalCaptures}
+  Prompts reviewed:  ${totalReviewed}  (${totalSkipped} skipped)
+  Average score:     ${avgScore.toFixed(1)}${scoreDiff !== null ? `  ${scoreDiff >= 0 ? '\u25B2' : '\u25BC'} ${scoreDiff >= 0 ? '+' : ''}${scoreDiff.toFixed(1)} vs prev` : ''}`);
+
+  if (topIssues.length > 0) {
+    console.log(`
+  \u{1F525} Top ${topIssues.length} recurring mistakes:
+  ${'┌' + '─'.repeat(42) + '┐'}`);
+    const maxCount = topIssues[0][1];
+    for (let i = 0; i < topIssues.length; i++) {
+      const [rule, count] = topIssues[i];
+      const filled = Math.round((count / maxCount) * barWidth);
+      const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(barWidth - filled);
+      const label = rule.length > 20 ? rule.slice(0, 20) + '...' : rule.padEnd(23);
+      console.log(`  │ ${i + 1}. ${label} ${String(count).padStart(3)} 次  ${bar} │`);
+    }
+    console.log(`  ${'└' + '─'.repeat(42) + '┘'}`);
+  }
+
+  console.log(`
+  \u{1F48E} Clean prompts (score >= 95):  ${cleanCount} / ${totalReviewed} (${totalReviewed > 0 ? ((cleanCount / totalReviewed) * 100).toFixed(1) : 0}%)`);
+
+  if (dailyScores.length > 0) {
+    console.log(`\n  \u{1F4C8} Score trend:`);
+    const dayNames = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+    const maxScore = Math.max(...dailyScores.map(d => d.score), 1);
+    const bestDay = dailyScores.reduce((best, d) => d.score > best.score ? d : best, dailyScores[0]);
+    for (const ds of dailyScores) {
+      const dayName = dayNames[parseDate(ds.date).getDay()];
+      const filled = Math.round((ds.score / 100) * barWidth);
+      const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(barWidth - filled);
+      const marker = ds.date === bestDay.date ? ' \u2190 best!' : '';
+      console.log(`  ${dayName}  ${bar}  ${ds.score.toFixed(0)}${marker}`);
+    }
+  }
+
+  if (recentUnlocked.length > 0) {
+    console.log(`\n  \u{1F3C6} Achievements unlocked:`);
+    for (const ach of recentUnlocked) {
+      console.log(`     "${ach.name}" — ${ach.description}`);
+    }
+  }
+
+  console.log('');
+}

package/src/cli/commands/review.mjs

@@ -0,0 +1,90 @@
+import { join } from 'node:path';
+import { existsSync, copyFileSync } from 'node:fs';
+import { RAW_DIR, REVIEWED_DIR } from '../../constants.mjs';
+import { readJSONL, readJSON, writeJSON, listFiles, formatDate, dateRange, ensureDir } from '../../utils.mjs';
+import { reviewBatch, computeStats } from '../../review/engine.mjs';
+
+export default async function review(args) {
+  const force = args.includes('--force');
+  let dates = [];
+
+  const dateIdx = args.indexOf('--date');
+  const fromIdx = args.indexOf('--from');
+  const toIdx = args.indexOf('--to');
+
+  if (dateIdx !== -1 && args[dateIdx + 1]) {
+    dates = [args[dateIdx + 1]];
+  } else if (fromIdx !== -1 && toIdx !== -1 && args[fromIdx + 1] && args[toIdx + 1]) {
+    dates = dateRange(args[fromIdx + 1], args[toIdx + 1]);
+  } else {
+    // Default: all unreviewed dates
+    const rawFiles = listFiles(RAW_DIR, '.jsonl');
+    const reviewedFiles = new Set(listFiles(REVIEWED_DIR, '.json').map(f => f.replace('.json', '')));
+
+    dates = rawFiles
+      .map(f => f.replace('.jsonl', ''))
+      .filter(d => force || !reviewedFiles.has(d));
+
+    if (dates.length === 0) {
+      console.log('No pending prompts to review. Capture some prompts first!');
+      return;
+    }
+  }
+
+  console.log(`Reviewing ${dates.length} day(s)...`);
+
+  for (const date of dates) {
+    const rawFile = join(RAW_DIR, `${date}.jsonl`);
+    const reviewedFile = join(REVIEWED_DIR, `${date}.json`);
+
+    if (!existsSync(rawFile)) {
+      console.log(`  ${date}: no raw data, skipping`);
+      continue;
+    }
+
+    if (existsSync(reviewedFile) && !force) {
+      console.log(`  ${date}: already reviewed, skipping (use --force to re-review)`);
+      continue;
+    }
+
+    // Copy raw file to avoid read/write conflict
+    const tmpFile = join(RAW_DIR, `${date}.jsonl.tmp`);
+    copyFileSync(rawFile, tmpFile);
+
+    const entries = readJSONL(tmpFile);
+    if (entries.length === 0) {
+      console.log(`  ${date}: empty file, skipping`);
+      continue;
+    }
+
+    console.log(`  ${date}: ${entries.length} prompts`);
+
+    try {
+      const results = await reviewBatch(entries);
+      const stats = computeStats(results);
+
+      const output = {
+        date,
+        reviewed_at: new Date().toISOString(),
+        model: 'claude-sonnet-4-20250514',
+        stats,
+        entries: results.filter(e => !e.skipped),
+      };
+
+      ensureDir(REVIEWED_DIR);
+      writeJSON(reviewedFile, output);
+
+      console.log(`  ${date}: done (avg score: ${stats.avg_score}, reviewed: ${stats.total_reviewed}, skipped: ${stats.skipped})`);
+    } catch (err) {
+      console.error(`  ${date}: failed — ${err.message}`);
+    }
+
+    // Clean up temp file
+    try {
+      const { unlinkSync } = await import('node:fs');
+      unlinkSync(tmpFile);
+    } catch { /* ignore */ }
+  }
+
+  console.log('\nReview complete! Run "vibeglish serve" to view results.');
+}

package/src/cli/commands/serve.mjs

@@ -0,0 +1,102 @@
+import { createServer } from 'node:http';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { REVIEWED_DIR, DASHBOARD_DIR, CONFIG_PATH, DEFAULT_CONFIG } from '../../constants.mjs';
+import { readJSON, listFiles } from '../../utils.mjs';
+import { checkAchievements } from '../../achievements.mjs';
+
+export default async function serve(args) {
+  const portIdx = args.indexOf('--port');
+  const config = readJSON(CONFIG_PATH) || DEFAULT_CONFIG;
+  let port = portIdx !== -1 && args[portIdx + 1] ? parseInt(args[portIdx + 1]) : config.dashboard_port || 6188;
+
+  const dashboardFile = join(DASHBOARD_DIR, 'index.html');
+  if (!existsSync(dashboardFile)) {
+    console.error('Dashboard not found. Run "vibeglish init" first.');
+    process.exit(1);
+  }
+
+  const server = createServer((req, res) => {
+    const url = new URL(req.url, `http://localhost:${port}`);
+
+    if (url.pathname === '/api/data') {
+      handleDataAPI(url, res);
+    } else {
+      // Serve dashboard
+      try {
+        const html = readFileSync(dashboardFile, 'utf-8');
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(html);
+      } catch (err) {
+        res.writeHead(500);
+        res.end('Failed to load dashboard');
+      }
+    }
+  });
+
+  // Try port, increment if busy
+  let attempts = 0;
+  const tryListen = () => {
+    server.listen(port, '127.0.0.1', () => {
+      console.log(`VibeGlish Dashboard running at http://localhost:${port}`);
+      console.log('Press Ctrl+C to stop.\n');
+
+      // Try to open browser
+      import('node:child_process').then(({ exec }) => {
+        const cmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
+        exec(`${cmd} http://localhost:${port}`, () => {});
+      });
+    });
+
+    server.on('error', (err) => {
+      if (err.code === 'EADDRINUSE' && attempts < 10) {
+        attempts++;
+        port++;
+        tryListen();
+      } else {
+        console.error(`Cannot start server: ${err.message}`);
+        process.exit(1);
+      }
+    });
+  };
+
+  tryListen();
+}
+
+function handleDataAPI(url, res) {
+  try {
+    const dateParam = url.searchParams.get('date');
+    const fromParam = url.searchParams.get('from');
+    const toParam = url.searchParams.get('to');
+
+    const files = listFiles(REVIEWED_DIR, '.json');
+    let data = [];
+
+    for (const f of files) {
+      const date = f.replace('.json', '');
+      if (dateParam && date !== dateParam) continue;
+      if (fromParam && date < fromParam) continue;
+      if (toParam && date > toParam) continue;
+
+      const d = readJSON(join(REVIEWED_DIR, f));
+      if (d) data.push(d);
+    }
+
+    data.sort((a, b) => a.date.localeCompare(b.date));
+
+    // Check achievements
+    const allData = files.map(f => readJSON(join(REVIEWED_DIR, f))).filter(Boolean);
+    const achievements = checkAchievements(allData);
+
+    const result = { days: data, achievements };
+
+    res.writeHead(200, {
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': '*',
+    });
+    res.end(JSON.stringify(result));
+  } catch (err) {
+    res.writeHead(500);
+    res.end(JSON.stringify({ error: err.message }));
+  }
+}

package/src/cli/commands/status.mjs

@@ -0,0 +1,53 @@
+import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { RAW_DIR, REVIEWED_DIR } from '../../constants.mjs';
+import { listFiles, formatDate } from '../../utils.mjs';
+
+export default async function status() {
+  const today = formatDate();
+  const rawFiles = listFiles(RAW_DIR, '.jsonl');
+  const reviewedFiles = listFiles(REVIEWED_DIR, '.json');
+  const reviewedDates = new Set(reviewedFiles.map(f => f.replace('.json', '')));
+
+  // Today's captures
+  let todayCount = 0;
+  const todayFile = join(RAW_DIR, `${today}.jsonl`);
+  try {
+    todayCount = readFileSync(todayFile, 'utf-8').trim().split('\n').filter(Boolean).length;
+  } catch { /* no file */ }
+
+  // Total captures
+  let totalCaptures = 0;
+  for (const f of rawFiles) {
+    try {
+      totalCaptures += readFileSync(join(RAW_DIR, f), 'utf-8').trim().split('\n').filter(Boolean).length;
+    } catch { /* skip */ }
+  }
+
+  // Pending review
+  const pendingDates = rawFiles
+    .map(f => f.replace('.jsonl', ''))
+    .filter(d => !reviewedDates.has(d));
+
+  // Total reviewed
+  let totalReviewed = 0;
+  for (const f of reviewedFiles) {
+    try {
+      const data = JSON.parse(readFileSync(join(REVIEWED_DIR, f), 'utf-8'));
+      totalReviewed += data.stats?.total_reviewed || 0;
+    } catch { /* skip */ }
+  }
+
+  console.log(`
+VibeGlish Status
+────────────────────────────────
+  Today (${today}):     ${todayCount} prompts captured
+  Total captured:      ${totalCaptures}
+  Total reviewed:      ${totalReviewed}
+  Pending review:      ${pendingDates.length} day(s)
+${pendingDates.length > 0 ? `                       ${pendingDates.join(', ')}` : ''}
+────────────────────────────────
+  Raw data:   ${RAW_DIR}
+  Reviewed:   ${REVIEWED_DIR}
+`);
+}

package/src/cli/commands/uninstall.mjs

@@ -0,0 +1,43 @@
+import { existsSync } from 'node:fs';
+import { CLAUDE_SETTINGS_PATH, VIBEGLISH_DIR } from '../../constants.mjs';
+import { readJSON, writeJSON } from '../../utils.mjs';
+
+export default async function uninstall() {
+  if (!existsSync(CLAUDE_SETTINGS_PATH)) {
+    console.log('No Claude settings file found — nothing to uninstall.');
+    return;
+  }
+
+  const settings = readJSON(CLAUDE_SETTINGS_PATH);
+  if (!settings?.hooks?.UserPromptSubmit) {
+    console.log('No UserPromptSubmit hook found — nothing to uninstall.');
+    return;
+  }
+
+  const before = settings.hooks.UserPromptSubmit.length;
+  settings.hooks.UserPromptSubmit = settings.hooks.UserPromptSubmit.filter(entry =>
+    !entry.hooks?.some(h => h.command?.includes('vibeglish') || h.command?.includes('capture.sh'))
+  );
+  const after = settings.hooks.UserPromptSubmit.length;
+
+  if (before === after) {
+    console.log('VibeGlish hook not found in settings — nothing to uninstall.');
+    return;
+  }
+
+  // Clean up empty arrays
+  if (settings.hooks.UserPromptSubmit.length === 0) {
+    delete settings.hooks.UserPromptSubmit;
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  writeJSON(CLAUDE_SETTINGS_PATH, settings);
+
+  console.log(`VibeGlish hook removed from Claude Code settings.
+
+  Your data is preserved in: ${VIBEGLISH_DIR}
+  To delete all data: rm -rf ${VIBEGLISH_DIR}
+`);
+}

package/src/cli/index.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+const [command, ...args] = process.argv.slice(2);
+
+const commands = {
+  init: () => import('./commands/init.mjs'),
+  status: () => import('./commands/status.mjs'),
+  review: () => import('./commands/review.mjs'),
+  report: () => import('./commands/report.mjs'),
+  serve: () => import('./commands/serve.mjs'),
+  export: () => import('./commands/export.mjs'),
+  'hook-test': () => import('./commands/hook-test.mjs'),
+  uninstall: () => import('./commands/uninstall.mjs'),
+};
+
+function printHelp() {
+  console.log(`
+vibeglish — Learn English naturally while vibe coding
+
+Usage: vibeglish <command> [options]
+
+Commands:
+  init          Initialize VibeGlish and install the Claude Code hook
+  status        Show capture/review statistics
+  review        Run AI correction on captured prompts
+  report        Print a weekly summary report in the terminal
+  serve         Start the local Web Dashboard
+  export        Export all reviewed data as JSON or CSV
+  hook-test     Test if the capture hook is working
+  uninstall     Remove the hook (keeps your data)
+
+Options:
+  --help, -h    Show this help message
+  --version     Show version
+`);
+}
+
+if (!command || command === '--help' || command === '-h') {
+  printHelp();
+  process.exit(0);
+}
+
+if (command === '--version') {
+  const { readFileSync } = await import('node:fs');
+  const { fileURLToPath } = await import('node:url');
+  const { join, dirname } = await import('node:path');
+  const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '../../package.json'), 'utf-8'));
+  console.log(`vibeglish v${pkg.version}`);
+  process.exit(0);
+}
+
+if (!commands[command]) {
+  console.error(`Unknown command: ${command}\nRun "vibeglish --help" for usage.`);
+  process.exit(1);
+}
+
+try {
+  const mod = await commands[command]();
+  await mod.default(args);
+} catch (err) {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+}

package/src/constants.mjs

@@ -0,0 +1,52 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const HOME = homedir();
+
+export const VIBEGLISH_DIR = join(HOME, '.vibeglish');
+export const RAW_DIR = join(VIBEGLISH_DIR, 'raw');
+export const REVIEWED_DIR = join(VIBEGLISH_DIR, 'reviewed');
+export const HOOKS_DIR = join(VIBEGLISH_DIR, 'hooks');
+export const DASHBOARD_DIR = join(VIBEGLISH_DIR, 'dashboard');
+export const CONFIG_PATH = join(VIBEGLISH_DIR, 'config.json');
+export const ERROR_LOG = join(VIBEGLISH_DIR, 'error.log');
+export const ACHIEVEMENTS_PATH = join(VIBEGLISH_DIR, 'achievements.json');
+export const CLAUDE_SETTINGS_PATH = join(HOME, '.claude', 'settings.json');
+
+export const DEFAULT_CONFIG = {
+  locale: 'zh-CN',
+  min_word_count: 4,
+  max_code_ratio: 0.7,
+  batch_size: 20,
+  dashboard_port: 6188,
+  auto_review_cron: null,
+  score_explanation_language: 'zh-CN',
+};
+
+export const REVIEW_SYSTEM_PROMPT = `You are an English writing coach for non-native developers. You will receive
+a batch of prompts that a Chinese developer wrote to an AI coding assistant.
+
+For each prompt, provide:
+1. "corrected": The natural, idiomatic English version. Preserve technical
+   terms exactly. If the original mixes Chinese and English, only correct
+   the English parts and leave Chinese as-is.
+2. "issues": An array of specific corrections, each with:
+   - "type": one of "grammar", "vocabulary", "spelling", "punctuation",
+     "style", "word_order"
+   - "original": the problematic fragment (quote from original)
+   - "corrected": the fixed fragment
+   - "rule": a concise explanation in CHINESE (学习者的母语) so the
+     developer actually absorbs it. Use grammatical terminology sparingly.
+3. "score": 0-100 fluency score for the original. 100 = native-level.
+   Scoring rubric:
+   - 90-100: Minor style issues only
+   - 70-89: Understandable but has noticeable errors
+   - 50-69: Meaning is clear but grammar is systematically broken
+   - 30-49: Requires effort to understand
+   - 0-29: Largely incomprehensible
+4. "is_clean": boolean, true if no corrections needed (score >= 95)
+
+If a prompt is just a code snippet, a file path, or not meaningfully English,
+return {"skip": true} for that entry.
+
+Respond with a JSON array matching the input order. No markdown fences.`;