@sumant.pathak/devjar 1.0.0

package/src/providers/openai.js

@@ -0,0 +1,37 @@
+// Provider: OpenAI — gpt-4o-mini (cheap, fast)
+// Requires: API key from https://platform.openai.com
+
+export const name = 'openai';
+export const defaultModel = 'gpt-4o-mini';
+
+export async function normalize(userPrompt, systemPrompt, config = {}) {
+  const apiKey = config.apiKey || process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      'OpenAI API key required.\n' +
+      '  Get key:  https://platform.openai.com/api-keys\n' +
+      '  Set it:   devjar config --provider openai --key sk-...'
+    );
+  }
+
+  const res = await fetch('https://api.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify({
+      model: config.model || defaultModel,
+      max_tokens: 500,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userPrompt },
+      ],
+    }),
+  });
+
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(`OpenAI error ${res.status}: ${err?.error?.message || res.statusText}`);
+  }
+
+  const data = await res.json();
+  return data.choices?.[0]?.message?.content?.trim() || '';
+}

package/src/stats.js

@@ -0,0 +1,173 @@
+// devjar stats — token usage tracker
+// Reads ~/.devjar/history.json, shows savings estimates
+// --json flag for raw output
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+
+const HISTORY_FILE = path.join(os.homedir(), '.devjar', 'history.json');
+const AVG_STARC_TOKENS = 200; // avg tokens in a structured STAR-C output
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function loadHistory() {
+  try {
+    if (!fs.existsSync(HISTORY_FILE)) return [];
+    return JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf8'));
+  } catch { return []; }
+}
+
+function estimateTokensSaved(entry) {
+  const rawChars = (entry.original || '').length;
+  // Formula: (original_chars - 200) × 0.25
+  // Negative = vague prompt was already short, minimal saving
+  return Math.max(0, Math.round((rawChars - 200) * 0.25));
+}
+
+function toDateStr(iso) {
+  return iso ? iso.slice(0, 10) : '';
+}
+
+function todayStr() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function calcStreak(history) {
+  if (!history.length) return 0;
+  const days = [...new Set(history.map(e => toDateStr(e.timestamp)))].sort().reverse();
+  let streak = 0;
+  let expected = todayStr();
+  for (const day of days) {
+    if (day === expected) {
+      streak++;
+      const d = new Date(expected);
+      d.setDate(d.getDate() - 1);
+      expected = d.toISOString().slice(0, 10);
+    } else break;
+  }
+  return streak;
+}
+
+function avg(arr) {
+  if (!arr.length) return 0;
+  return Math.round(arr.reduce((s, v) => s + v, 0) / arr.length);
+}
+
+function bar(value, max, width = 20) {
+  const filled = max > 0 ? Math.round((value / max) * width) : 0;
+  return chalk.cyan('█'.repeat(filled)) + chalk.gray('░'.repeat(width - filled));
+}
+
+// ── Main Export ────────────────────────────────────────────────────────────
+
+export async function stats(options = {}) {
+  if (options.reset) {
+    try {
+      fs.writeFileSync(HISTORY_FILE, '[]', 'utf8');
+      console.log(chalk.green('✓ History reset.'));
+    } catch (e) {
+      console.log(chalk.red('✗ Could not reset: ' + e.message));
+    }
+    return;
+  }
+
+  const history = loadHistory();
+
+  if (!history.length) {
+    console.log(chalk.yellow('No history yet.') + chalk.gray(' Run `devjar prompt` to start tracking.'));
+    return;
+  }
+
+  // ── Compute today ──
+  const today = history.filter(e => toDateStr(e.timestamp) === todayStr());
+  const todayTokens = today.reduce((s, e) => s + estimateTokensSaved(e), 0);
+  const todayOrigLens = today.map(e => (e.original || '').length);
+  const todayStructLens = today.map(e => (e.structured || '').length);
+
+  // ── Compute all-time ──
+  const totalTokens = history.reduce((s, e) => s + estimateTokensSaved(e), 0);
+  const streak = calcStreak(history);
+
+  // Most active project
+  const projectCounts = {};
+  for (const e of history) {
+    projectCounts[e.project || 'unknown'] = (projectCounts[e.project || 'unknown'] || 0) + 1;
+  }
+  const topProject = Object.entries(projectCounts).sort((a, b) => b[1] - a[1])[0];
+
+  // Per-project breakdown (top 5)
+  const projectList = Object.entries(projectCounts)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 5);
+
+  const maxCount = projectList[0]?.[1] || 1;
+
+  if (options.json) {
+    console.log(JSON.stringify({
+      today: {
+        prompts: today.length,
+        avgOriginalLen: avg(todayOrigLens),
+        avgStructuredLen: avg(todayStructLens),
+        estimatedTokensSaved: todayTokens,
+      },
+      allTime: {
+        totalPrompts: history.length,
+        totalEstimatedTokensSaved: totalTokens,
+        mostActiveProject: topProject?.[0],
+        streakDays: streak,
+        projects: Object.fromEntries(projectList),
+      },
+    }, null, 2));
+    return;
+  }
+
+  // ── Render ──
+  console.log(chalk.bold.blue('⬡ devjar') + chalk.gray(' stats'));
+  console.log(chalk.gray('─'.repeat(52)));
+
+  // Today
+  console.log(chalk.bold.white('Today') + chalk.gray(`  (${todayStr()})`));
+  if (today.length === 0) {
+    console.log(chalk.gray('  No prompts yet today.'));
+  } else {
+    console.log(
+      chalk.gray('  Prompts normalized:   ') + chalk.cyan(today.length)
+    );
+    console.log(
+      chalk.gray('  Avg original length:  ') + chalk.white(avg(todayOrigLens) + ' chars')
+    );
+    console.log(
+      chalk.gray('  Avg structured length:') + chalk.white(avg(todayStructLens) + ' chars')
+    );
+    console.log(
+      chalk.gray('  Estimated tokens saved:') + chalk.green(` ~${todayTokens}`)
+    );
+  }
+
+  console.log();
+  console.log(chalk.bold.white('All Time'));
+  console.log(chalk.gray('  Total prompts:         ') + chalk.cyan(history.length));
+  console.log(chalk.gray('  Total tokens saved:    ') + chalk.green(`~${totalTokens.toLocaleString()}`));
+  console.log(chalk.gray('  Most active project:   ') + chalk.white(topProject?.[0] || '—') + chalk.gray(` (${topProject?.[1] || 0} prompts)`));
+  console.log(
+    chalk.gray('  Streak:                ') +
+    (streak > 0 ? chalk.yellow('🔥 ' + streak + ' day' + (streak > 1 ? 's' : '')) : chalk.gray('0 days'))
+  );
+
+  if (projectList.length > 1) {
+    console.log();
+    console.log(chalk.bold.white('Projects'));
+    for (const [name, count] of projectList) {
+      console.log(
+        `  ${bar(count, maxCount, 16)} ` +
+        chalk.white(name.padEnd(20)) +
+        chalk.gray(` ${count} prompt${count > 1 ? 's' : ''}`)
+      );
+    }
+  }
+
+  console.log(chalk.gray('─'.repeat(52)));
+  console.log(chalk.gray(`  History: ${HISTORY_FILE}`));
+}

package/src/update.js

@@ -0,0 +1,235 @@
+// devjar update — regenerate or live-watch CLAUDE.md
+// One-time: full 3-phase re-scan (same as init but overwrites)
+// --watch: chokidar file watcher, Phase 1 on every change,
+//          Phase 2 (Haiku) every 10 changes
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import chokidar from 'chokidar';
+import {
+  init,
+  walkDir,
+  buildFileTree,
+  readJsonSafe,
+  detectStack,
+  pickKeyFiles,
+  extractPatterns,
+} from './init.js';
+
+const IGNORE_WATCH = [
+  'node_modules', '.git', 'dist', '.next', 'out', 'build',
+  'CLAUDE.md', '*.lock', '.env*',
+];
+
+const IGNORE_DIRS_WATCH = new Set([
+  'node_modules', '.git', 'dist', '.next', 'out', 'build', '.cache', 'coverage', 'public',
+]);
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function findClaudeMd(baseDir) {
+  return path.join(baseDir, 'CLAUDE.md');
+}
+
+function countExistingFiles(claudeMdPath) {
+  try {
+    const content = fs.readFileSync(claudeMdPath, 'utf8');
+    return (content.match(/📄/g) || []).length;
+  } catch { return 0; }
+}
+
+function patchFileTreeSection(claudeMdPath, newTree) {
+  try {
+    let content = fs.readFileSync(claudeMdPath, 'utf8');
+    // Replace between ## Project Map and the next ##
+    content = content.replace(
+      /(## Project Map\n)([\s\S]*?)(\n## )/,
+      `$1${newTree}\n$3`
+    );
+    fs.writeFileSync(claudeMdPath, content, 'utf8');
+    return true;
+  } catch { return false; }
+}
+
+function patchRulesSection(claudeMdPath, rules) {
+  try {
+    let content = fs.readFileSync(claudeMdPath, 'utf8');
+    const rulesText = rules.map((r, i) => `${i + 1}. ${r}`).join('\n');
+    content = content.replace(
+      /(## Unbreakable Rules\n)([\s\S]*?)(\n---)/,
+      `$1${rulesText}\n$3`
+    );
+    fs.writeFileSync(claudeMdPath, content, 'utf8');
+    return true;
+  } catch { return false; }
+}
+
+function timestamp() {
+  return chalk.gray(`[${new Date().toLocaleTimeString()}]`);
+}
+
+// ── Phase 1 only: update file tree ────────────────────────────────────────
+
+function runPhase1(baseDir) {
+  const BINARY_EXTS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg', '.webp',
+    '.woff', '.woff2', '.ttf', '.eot', '.mp4', '.mp3', '.pdf',
+    '.zip', '.exe', '.dll', '.bin', '.map',
+  ]);
+  const SKIP_FILES = new Set([
+    'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lockb',
+    '.env', '.env.local', '.env.production', '.DS_Store',
+  ]);
+
+  function walk(dir, depth = 0) {
+    const entries = [];
+    if (depth > 2) return entries;
+    let items;
+    try { items = fs.readdirSync(dir, { withFileTypes: true }); } catch { return entries; }
+    for (const item of items) {
+      if (item.name.startsWith('.') && item.name !== '.env.example') continue;
+      if (IGNORE_DIRS_WATCH.has(item.name)) continue;
+      const fullPath = path.join(dir, item.name);
+      const relPath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
+      if (item.isDirectory()) {
+        entries.push({ type: 'dir', path: relPath, name: item.name });
+        entries.push(...walk(fullPath, depth + 1));
+      } else if (item.isFile()) {
+        const ext = path.extname(item.name).toLowerCase();
+        if (BINARY_EXTS.has(ext) || SKIP_FILES.has(item.name)) continue;
+        const size = fs.statSync(fullPath).size;
+        entries.push({ type: 'file', path: relPath, name: item.name, size });
+      }
+    }
+    return entries;
+  }
+
+  const entries = walk(baseDir);
+  return { entries, tree: buildFileTree(entries), fileCount: entries.filter(e => e.type === 'file').length };
+}
+
+// ── Watch mode ─────────────────────────────────────────────────────────────
+
+async function runWatch(baseDir, mapFile, options) {
+  const projectName = readJsonSafe(path.join(baseDir, 'package.json'))?.name || path.basename(baseDir);
+
+  console.log(chalk.bold.blue('⬡ devjar') + chalk.gray(` watching ${chalk.white(projectName)}...`));
+  console.log(chalk.gray(`  CLAUDE.md: ${mapFile}`));
+  console.log(chalk.gray('  Ctrl+C to stop\n'));
+
+  let changeCount = 0;
+  let haikusFired = 0;
+  let debounceTimer = null;
+
+  const watcher = chokidar.watch(baseDir, {
+    ignored: [
+      /(^|[/\\])\../, // dotfiles
+      /node_modules/,
+      /\.git/,
+      /dist/,
+      /\.next/,
+      /CLAUDE\.md/,
+      /.*\.lock$/,
+    ],
+    persistent: true,
+    ignoreInitial: true,
+    depth: 3,
+  });
+
+  async function handleChange(eventType, filePath) {
+    const relPath = path.relative(baseDir, filePath).replace(/\\/g, '/');
+    changeCount++;
+
+    const icon = eventType === 'add' ? chalk.green('+') :
+                 eventType === 'unlink' ? chalk.red('-') :
+                 chalk.yellow('~');
+
+    process.stdout.write(
+      `${timestamp()} ${icon} ${chalk.white(relPath)}\n`
+    );
+
+    // Debounce Phase 1 updates
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      const { tree, fileCount } = runPhase1(baseDir);
+      const ok = patchFileTreeSection(mapFile, tree);
+      if (ok) {
+        process.stdout.write(
+          `${timestamp()} ${chalk.green('↑')} CLAUDE.md updated — ` +
+          chalk.white(`${fileCount} files`) +
+          (eventType === 'add' ? chalk.gray(` — added ${relPath}`) : '') +
+          '\n'
+        );
+      }
+
+      // Every 10 changes: trigger full Haiku re-analysis
+      if (changeCount % 10 === 0 && process.env.ANTHROPIC_API_KEY) {
+        haikusFired++;
+        process.stdout.write(
+          `${timestamp()} ${chalk.cyan('⟳')} ${chalk.yellow('10 changes reached — re-analyzing rules via Haiku...')}\n`
+        );
+        try {
+          const { entries } = runPhase1(baseDir);
+          const { contents } = pickKeyFiles(baseDir, entries);
+          const patterns = await extractPatterns(contents);
+          if (patterns?.rules) {
+            patchRulesSection(mapFile, patterns.rules);
+            process.stdout.write(
+              `${timestamp()} ${chalk.green('✓')} Rules updated — ` +
+              chalk.white(`${patterns.rules.length} rules extracted\n`)
+            );
+          }
+        } catch (e) {
+          process.stdout.write(chalk.yellow(`${timestamp()} ⚠ Haiku re-analysis failed: ${e.message}\n`));
+        }
+      }
+    }, parseInt(options.debounce || '500', 10));
+  }
+
+  watcher.on('add',    (p) => handleChange('add', p));
+  watcher.on('change', (p) => handleChange('change', p));
+  watcher.on('unlink', (p) => handleChange('unlink', p));
+  watcher.on('error',  (e) => console.error(chalk.red('Watcher error:'), e));
+
+  // Keep process alive
+  process.on('SIGINT', () => {
+    console.log(chalk.gray(`\n\n  Stopped after ${changeCount} changes, ${haikusFired} Haiku calls.`));
+    watcher.close();
+    process.exit(0);
+  });
+}
+
+// ── Main Export ────────────────────────────────────────────────────────────
+
+export async function update(dir = '.', options = {}) {
+  const baseDir = path.resolve(dir);
+  const mapFile = findClaudeMd(baseDir);
+
+  if (!fs.existsSync(mapFile)) {
+    console.log(chalk.red('✗ No CLAUDE.md found.') + chalk.gray(' Run ') + chalk.cyan('devjar init') + chalk.gray(' first.'));
+    process.exit(1);
+  }
+
+  // ── Watch mode ──
+  if (options.watch) {
+    return runWatch(baseDir, mapFile, options);
+  }
+
+  // ── One-time regenerate ──
+  console.log(chalk.bold.blue('⬡ devjar') + chalk.gray(' update'));
+  console.log(chalk.gray('─'.repeat(52)));
+
+  const prevFileCount = countExistingFiles(mapFile);
+
+  // Delegate to init (overwrites CLAUDE.md)
+  await init(dir, { output: mapFile, depth: options.depth || '2' });
+
+  const { fileCount: newFileCount } = runPhase1(baseDir);
+  const diff = newFileCount - prevFileCount;
+  const diffStr = diff > 0 ? chalk.green(`+${diff} new files`) :
+                  diff < 0 ? chalk.red(`${diff} files removed`) :
+                  chalk.gray('no file changes');
+
+  console.log(chalk.gray(`  ${diffStr}`));
+}