codeslop 0.1.0

package/bin/wasted.js

@@ -0,0 +1,323 @@
+#!/usr/bin/env node
+
+import { loadConfig, saveConfig } from '../lib/config.js';
+import { CATEGORIES } from '../lib/categories.js';
+import { addEvent, todayStats, allTimeStats, getSessions, startSession, getDailySummary } from '../lib/store.js';
+import { syncDaily, syncEvent } from '../lib/sync.js';
+import { wasteCost } from '../lib/cost.js';
+import { randomUUID } from 'crypto';
+import { existsSync, statSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const args = process.argv.slice(2);
+const cmd = args[0] || 'help';
+const R='\x1b[31m',G='\x1b[32m',Y='\x1b[33m',D='\x1b[2m',B='\x1b[1m',X='\x1b[0m',BG_R='\x1b[41m',BG_G='\x1b[42m';
+const fmt = n => n.toLocaleString('en-US');
+const bar = (v, max, w=20) => { const f=Math.round((v/Math.max(max,1))*w); return `${R}${'█'.repeat(f)}${D}${'░'.repeat(w-f)}${X}`; };
+
+const CMDS = {
+  init, log: quickLog, report, today, me, stats, sessions,
+  sync, stream, watch, scan, lb: leaderboard, leaderboard,
+  cats: showCats, categories: showCats,
+};
+
+async function main() { return (CMDS[cmd] || help)(); }
+
+function help() {
+  console.log(`
+${R}${B} codeslop ${X}${D}— tracking every dollar your AI agent lights on fire${X}
+
+ ${B}setup${X}
+  ${G}codeslop init${X} [name]        create your profile
+  ${G}codeslop stream${X} off|daily|live  set sync mode (default: daily)
+
+ ${B}record${X}
+  ${G}codeslop log${X}                 log waste interactively
+  ${G}codeslop report${X} CAT TOK [M]  quick report
+
+ ${B}view${X}
+  ${G}codeslop today${X}               today's local stats
+  ${G}codeslop sessions${X}            recent sessions
+  ${G}codeslop me${X}                  all-time local stats
+
+ ${B}global${X}
+  ${G}codeslop sync${X}                push summary to codeslop.org
+  ${G}codeslop stats${X}               global waste stats
+  ${G}codeslop watch${X}               live global feed
+  ${G}codeslop lb${X}                  wall of shame
+
+ ${B}other${X}
+  ${G}codeslop scan${X}                detect installed AI clients
+  ${G}codeslop cats${X}                list categories
+
+ ${D}data stored locally at ~/.wasted/
+ only aggregated summaries leave your machine (stream: daily)
+ no prompts, no file paths, no descriptions are ever sent.
+ codeslop.org${X}
+`);
+}
+
+async function init() {
+  const config = loadConfig();
+  if (config.user_id) {
+    console.log(`\n  already set up as ${B}${config.nickname}${X} ${D}(${config.user_id})${X}`);
+    console.log(`  stream: ${config.stream}  country: ${config.country || 'not set'}\n`);
+    return;
+  }
+  const user_id = randomUUID().slice(0, 12);
+  const nickname = args[1] || process.env.USER || 'anon';
+  config.user_id = user_id;
+  config.nickname = nickname;
+  saveConfig(config);
+  try {
+    await fetch(config.api_url+'/api/users',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({user_id,nickname})});
+  } catch {}
+  console.log(`
+  ${G}${B}✓${X} ${B}${nickname}${X} ${D}${user_id}${X}
+
+  ${D}stream mode:${X} ${Y}daily${X} ${D}(aggregated summaries only)${X}
+  ${D}local db:${X}    ~/.wasted/wasted.db
+  ${D}config:${X}      ~/.wasted/config.json
+
+  ${G}codeslop log${X}    → record waste
+  ${G}codeslop today${X}  → see today's stats
+  ${G}codeslop scan${X}   → detect AI clients
+`);
+}
+
+function requireUser() {
+  const c = loadConfig();
+  if (!c.user_id) { console.log(`\n  ${R}run ${G}codeslop init${R} first${X}\n`); return null; }
+  return c;
+}
+
+async function quickLog() {
+  if (!requireUser()) return;
+  const config = loadConfig();
+  const catKeys = Object.keys(CATEGORIES);
+  console.log(`\n  ${B}category:${X}\n`);
+  catKeys.forEach((k,i) => console.log(`  ${D}${String(i+1).padStart(2)}${X} ${CATEGORIES[k].icon} ${B}${CATEGORIES[k].name}${X}`));
+
+  const rl = (await import('readline')).createInterface({input:process.stdin,output:process.stdout});
+  const ask = q => new Promise(r => rl.question(q, r));
+
+  const ci = parseInt(await ask(`\n  ${B}#${X} `)) - 1;
+  if (ci<0||ci>=catKeys.length) { rl.close(); return; }
+  const tokens = parseInt(await ask(`  ${B}tokens:${X} `)) || 500;
+  const model = await ask(`  ${B}model:${X} `) || 'unknown';
+  const client = await ask(`  ${B}client:${X} `) || 'unknown';
+  const note = await ask(`  ${B}note (local only):${X} `) || null;
+  rl.close();
+
+  const category = catKeys[ci];
+  const cost = wasteCost(model, category, tokens);
+
+  addEvent(category, tokens, { model, client, note, cost });
+
+  // Live sync if enabled
+  if (config.stream === 'live') {
+    await syncEvent({ category, model, client, tokens, cost });
+  }
+
+  console.log(`\n  ${CATEGORIES[category].icon} ${R}${B}${fmt(tokens)}${X} tokens → ${B}${CATEGORIES[category].name}${X} ${D}(stored locally)${X}\n`);
+}
+
+async function report() {
+  const config = requireUser();
+  if (!config) return;
+  const [, category, tokStr, model, client] = args;
+  if (!category || !CATEGORIES[category]) {
+    console.log(`\n  ${D}usage: codeslop report <category> <tokens> [model] [client]${X}`);
+    console.log(`  ${D}cats: ${Object.keys(CATEGORIES).join(', ')}${X}\n`);
+    return;
+  }
+  const tokens = parseInt(tokStr) || 500;
+  const cost = wasteCost(model, category, tokens);
+  addEvent(category, tokens, { model: model||'unknown', client: client||'unknown', cost });
+  if (config.stream === 'live') await syncEvent({ category, model: model||'unknown', client: client||'unknown', tokens, cost });
+  console.log(`\n  ${CATEGORIES[category].icon} ${R}${fmt(tokens)}${X} → ${B}${CATEGORIES[category].name}${X}\n`);
+}
+
+function today() {
+  const s = todayStats();
+  const t = s.totals;
+  console.log(`\n  ${R}${B}today${X} — ${R}$${t.cost.toFixed(2)}${X} — ${fmt(t.tokens)} tokens — ${t.events} events\n`);
+  if (s.by_category.length) {
+    const max = s.by_category[0]?.v || 1;
+    console.log(`  ${D}categories${X}`);
+    s.by_category.forEach(c => {
+      const m = CATEGORIES[c.k] || {icon:'?',name:c.k};
+      console.log(`  ${m.icon} ${m.name.padEnd(18)} ${bar(c.v,max)} ${D}${fmt(c.v)}${X}`);
+    });
+  }
+  if (s.by_client.length) {
+    const max = s.by_client[0]?.v || 1;
+    console.log(`\n  ${D}clients${X}`);
+    s.by_client.forEach(c => console.log(`  ${c.k.padEnd(20)} ${bar(c.v,max,15)} ${D}${fmt(c.v)}${X}`));
+  }
+  if (s.by_model.length) {
+    const max = s.by_model[0]?.v || 1;
+    console.log(`\n  ${D}models${X}`);
+    s.by_model.forEach(c => console.log(`  ${c.k.padEnd(20)} ${bar(c.v,max,15)} ${D}${fmt(c.v)}${X}`));
+  }
+  if (s.sessions.length) {
+    console.log(`\n  ${D}sessions${X}`);
+    s.sessions.forEach(ss => console.log(`  ${D}${ss.id}${X} ${ss.client.padEnd(14)} ${R}${fmt(ss.total_tokens)}${X} tok`));
+  }
+  console.log();
+}
+
+function me() {
+  const s = allTimeStats();
+  const t = s.totals;
+  const config = loadConfig();
+  console.log(`\n  ${R}${B}${config.nickname || 'you'}${X} — ${R}$${t.cost.toFixed(2)}${X} — ${fmt(t.tokens)} tokens — ${Y}${Math.floor(t.cost/12)} burritos${X}\n`);
+  if (s.by_category.length) {
+    const max = s.by_category[0]?.v || 1;
+    s.by_category.forEach(c => {
+      const m = CATEGORIES[c.k] || {icon:'?',name:c.k};
+      console.log(`  ${m.icon} ${m.name.padEnd(18)} ${bar(c.v,max)} ${D}${fmt(c.v)}${X}`);
+    });
+  }
+  console.log();
+}
+
+function sessions() {
+  const ss = getSessions(20);
+  if (!ss.length) { console.log(`\n  ${D}no sessions yet${X}\n`); return; }
+  console.log(`\n  ${B}recent sessions${X}\n`);
+  ss.forEach(s => {
+    const dur = s.ended_at ? `${D}ended${X}` : `${G}active${X}`;
+    console.log(`  ${D}${s.id}${X}  ${s.client.padEnd(14)} ${s.model||'—'.padEnd(12)} ${R}${fmt(s.total_tokens).padStart(8)}${X} tok  ${dur}`);
+  });
+  console.log();
+}
+
+async function sync() {
+  const config = requireUser();
+  if (!config) return;
+  if (config.stream === 'off') { console.log(`\n  ${D}stream is off. run ${G}codeslop stream daily${D} to enable.${X}\n`); return; }
+
+  console.log(`\n  ${D}syncing...${X}`);
+  const summary = getDailySummary();
+  if (!summary.length) { console.log(`  ${D}nothing to sync${X}\n`); return; }
+
+  console.log(`  ${D}${summary.length} aggregated rows (no descriptions sent)${X}`);
+  const result = await syncDaily();
+  if (result.synced) {
+    console.log(`  ${G}✓${X} synced ${result.synced} summaries\n`);
+  } else {
+    console.log(`  ${R}couldn't reach API${X}\n`);
+  }
+}
+
+function stream() {
+  const mode = args[1];
+  const config = loadConfig();
+  if (!mode) {
+    console.log(`\n  stream mode: ${B}${config.stream}${X}`);
+    console.log(`\n  ${D}off${X}   — nothing leaves your machine`);
+    console.log(`  ${D}daily${X} — aggregated summary, no descriptions`);
+    console.log(`  ${D}live${X}  — events streamed (still no raw content)\n`);
+    console.log(`  ${D}usage: codeslop stream off|daily|live${X}\n`);
+    return;
+  }
+  if (!['off','daily','live'].includes(mode)) { console.log(`\n  ${R}must be off, daily, or live${X}\n`); return; }
+  config.stream = mode;
+  saveConfig(config);
+  const labels = { off:`${R}off${X} — local only`, daily:`${Y}daily${X} — aggregated summaries`, live:`${G}live${X} — real-time` };
+  console.log(`\n  stream: ${labels[mode]}\n`);
+}
+
+async function watch() {
+  const config = loadConfig();
+  console.log(`\n  ${R}${B}live feed${X}  ${D}ctrl+c to stop${X}\n`);
+  try {
+    const res = await fetch(config.api_url+'/api/live',{headers:{Accept:'text/event-stream'}});
+    const reader = res.body.getReader();
+    const dec = new TextDecoder();
+    let buf = '';
+    while (true) {
+      const {done,value} = await reader.read();
+      if (done) break;
+      buf += dec.decode(value,{stream:true});
+      const lines = buf.split('\n'); buf = lines.pop();
+      for (const l of lines) {
+        if (!l.startsWith('data: ')) continue;
+        try {
+          const d = JSON.parse(l.slice(6));
+          if (d.type==='init') console.log(`  ${G}●${X} connected — ${d.watching} watching — $${d.today.cost.toFixed(2)} today\n`);
+          else if (d.type==='event'&&d.ev) {
+            const e=d.ev, m=CATEGORIES[e.category]||{icon:'🗑️',name:e.category};
+            const t=new Date().toLocaleTimeString('en-US',{hour12:false,hour:'2-digit',minute:'2-digit',second:'2-digit'});
+            console.log(`  ${D}${t}${X} ${m.icon} ${m.name.padEnd(16)} ${R}${fmt(e.tokens).padStart(7)}${X} ${D}${e.client}/${e.model}${X}`);
+          }
+        } catch{}
+      }
+    }
+  } catch { console.log(`  ${R}can't connect${X}\n`); }
+}
+
+async function stats() {
+  const config = loadConfig();
+  try {
+    const d = await (await fetch(config.api_url+'/api/stats')).json();
+    console.log(`\n  ${R}${B}global${X} — ${R}$${d.today.cost.toFixed(2)}${X} today — ${fmt(d.today.tokens)} tokens — ${d.users} users\n`);
+    if (d.by_category.length) {
+      const max = d.by_category[0]?.v||1;
+      d.by_category.forEach(c => {
+        const m = CATEGORIES[c.k]||{icon:'?',name:c.k};
+        console.log(`  ${m.icon} ${m.name.padEnd(18)} ${bar(c.v,max)} ${D}${fmt(c.v)}${X}`);
+      });
+    }
+    if (d.by_client.length) {
+      console.log();
+      const max = d.by_client[0]?.v||1;
+      d.by_client.forEach(c => console.log(`  ${(c.k||'?').padEnd(20)} ${bar(c.v,max,15)} ${D}${fmt(c.v)}${X}`));
+    }
+    console.log();
+  } catch { console.log(`\n  ${R}can't reach API${X}\n`); }
+}
+
+async function leaderboard() {
+  const config = loadConfig();
+  try {
+    const d = await (await fetch(config.api_url+'/api/leaderboard')).json();
+    console.log(`\n  ${R}${B}wall of shame${X}\n`);
+    if (!d.length) { console.log(`  ${D}empty${X}\n`); return; }
+    d.forEach((u,i) => {
+      const medal = i===0?'👑':i===1?'🥈':i===2?'🥉':'  ';
+      console.log(`  ${medal} ${D}#${i+1}${X} ${B}${(u.nickname||u.id).padEnd(16)}${X} ${R}$${u.total_cost.toFixed(2).padStart(10)}${X} ${D}${fmt(u.total_tokens)} tok${X}`);
+    });
+    console.log();
+  } catch { console.log(`\n  ${R}can't reach API${X}\n`); }
+}
+
+function showCats() {
+  console.log(`\n  ${B}waste categories${X}\n`);
+  Object.entries(CATEGORIES).forEach(([k,c]) => console.log(`  ${c.icon} ${B}${c.name.padEnd(18)}${X} ${D}${k}${X}`));
+  console.log();
+}
+
+function scan() {
+  console.log(`\n  ${B}scanning...${X}\n`);
+  const home = homedir();
+  const checks = [
+    {name:'Claude Code', paths:[join(home,'.claude')]},
+    {name:'Cursor',      paths:[join(home,'.cursor'), join(home,'Library','Application Support','Cursor')]},
+    {name:'Windsurf',    paths:[join(home,'.windsurf'), join(home,'Library','Application Support','Windsurf')]},
+    {name:'Copilot',     paths:[join(home,'.copilot')]},
+    {name:'Aider',       paths:[join(home,'.aider.chat.history.md')]},
+    {name:'OpenCode',    paths:[join(home,'.opencode')]},
+  ];
+  let found = 0;
+  for (const c of checks) {
+    const exists = c.paths.some(p => existsSync(p));
+    if (exists) { console.log(`  ${G}●${X} ${B}${c.name}${X}`); found++; }
+    else { console.log(`  ${D}○ ${c.name}${X}`); }
+  }
+  console.log(`\n  ${found} client(s) detected\n`);
+}
+
+main().catch(e => { console.error(e); process.exit(1); });

package/lib/api.js

@@ -0,0 +1,23 @@
+import { loadConfig } from './config.js';
+
+async function request(method, path, body) {
+  const config = loadConfig();
+  const url = config.api_url + path;
+  const opts = {
+    method,
+    headers: { 'Content-Type': 'application/json' },
+  };
+  if (body) opts.body = JSON.stringify(body);
+  const res = await fetch(url, opts);
+  return res.json();
+}
+
+export const api = {
+  reportWaste: (data) => request('POST', '/api/report', data),
+  reportBatch: (data) => request('POST', '/api/report/batch', data),
+  getStats: () => request('GET', '/api/stats'),
+  getUserStats: (id) => request('GET', `/api/users/${id}`),
+  getLeaderboard: () => request('GET', '/api/leaderboard'),
+  getRecent: (n = 30) => request('GET', `/api/recent?n=${n}`),
+  register: (user_id, nickname) => request('POST', '/api/users', { user_id, nickname }),
+};

package/lib/categories.js

@@ -0,0 +1,12 @@
+export const CATEGORIES = {
+  yapping:            { icon: '🦜', name: 'Yapping',            desc: 'Model monologued. Nobody asked.' },
+  groundhog_day:      { icon: '🔄', name: 'Groundhog Day',      desc: 'Same action retried 3+ times.' },
+  ghost_agent:        { icon: '👻', name: 'Ghost Agent',        desc: 'Sub-agent spawned. Did nothing.' },
+  prompt_salad:       { icon: '🥗', name: 'Prompt Salad',       desc: 'Vague prompt. Model guessed.' },
+  tool_spam:          { icon: '🔨', name: 'Tool Spam',          desc: 'Tool calls that went nowhere.' },
+  context_stuffing:   { icon: '🧸', name: 'Context Stuffing',   desc: 'Huge context. Never referenced.' },
+  hallucination_trip: { icon: '🍄', name: 'Hallucination Trip', desc: 'Confidently wrong. Redo.' },
+  ping_pong:          { icon: '🏓', name: 'Ping Pong',          desc: '3+ turns. Zero progress.' },
+  skill_issue:        { icon: '💀', name: 'Skill Issue',        desc: 'Skill misfired completely.' },
+  overthink:          { icon: '🧠', name: 'Overthink',          desc: '200 lines. Needed 10.' },
+};

package/lib/config.js

@@ -0,0 +1,24 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const DIR = join(homedir(), '.wasted');
+const FILE = join(DIR, 'config.json');
+
+const DEFAULTS = {
+  user_id: null,
+  nickname: null,
+  api_url: process.env.WASTED_API_URL || 'https://codeslop.org',
+  stream: 'daily',    // off | daily | live
+  country: null,       // opt-in, e.g. "US" or "IN"
+};
+
+export function loadConfig() {
+  try { return { ...DEFAULTS, ...JSON.parse(readFileSync(FILE, 'utf8')) }; }
+  catch { return { ...DEFAULTS }; }
+}
+
+export function saveConfig(config) {
+  mkdirSync(DIR, { recursive: true });
+  writeFileSync(FILE, JSON.stringify(config, null, 2) + '\n');
+}

package/lib/cost.js

@@ -0,0 +1,2 @@
+// Re-export from shared pricing module.
+export { wasteCost } from '../../shared/pricing.js';

package/lib/store.js

@@ -0,0 +1,113 @@
+import Database from 'better-sqlite3';
+import { mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { randomUUID } from 'crypto';
+import { wasteCost } from '../../shared/pricing.js';
+
+const DIR = join(homedir(), '.wasted');
+const DB_PATH = join(DIR, 'wasted.db');
+
+let _db;
+function db() {
+  if (_db) return _db;
+  mkdirSync(DIR, { recursive: true });
+  _db = new Database(DB_PATH);
+  _db.pragma('journal_mode = WAL');
+  _db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      client TEXT NOT NULL,
+      model TEXT,
+      started_at TEXT DEFAULT (datetime('now')),
+      ended_at TEXT,
+      total_tokens INTEGER DEFAULT 0,
+      total_cost REAL DEFAULT 0
+    );
+    CREATE TABLE IF NOT EXISTS events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      category TEXT NOT NULL,
+      model TEXT NOT NULL DEFAULT 'unknown',
+      client TEXT NOT NULL DEFAULT 'unknown',
+      tokens INTEGER NOT NULL,
+      cost REAL NOT NULL,
+      note TEXT,
+      synced INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY(session_id) REFERENCES sessions(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_ev_sync ON events(synced);
+    CREATE INDEX IF NOT EXISTS idx_ev_date ON events(created_at);
+    CREATE INDEX IF NOT EXISTS idx_sess_date ON sessions(started_at);
+  `);
+  return _db;
+}
+
+// Sessions
+export function startSession(client, model) {
+  const id = randomUUID().slice(0, 8);
+  db().prepare('INSERT INTO sessions(id,client,model) VALUES(?,?,?)').run(id, client, model || null);
+  return id;
+}
+
+export function endSession(id) {
+  db().prepare('UPDATE sessions SET ended_at=datetime("now") WHERE id=?').run(id);
+}
+
+export function getSessions(limit = 20) {
+  return db().prepare('SELECT * FROM sessions ORDER BY started_at DESC LIMIT ?').all(limit);
+}
+
+// Events
+export function addEvent(category, tokens, opts = {}) {
+  // Cost should be pre-calculated by the caller using wasteCost()
+  const cost = opts.cost || wasteCost(opts.model || 'unknown', category, tokens);
+  db().prepare('INSERT INTO events(session_id,category,model,client,tokens,cost,note) VALUES(?,?,?,?,?,?,?)').run(
+    opts.session_id || null, category, opts.model || 'unknown', opts.client || 'unknown', tokens, cost, opts.note || null
+  );
+  if (opts.session_id) {
+    db().prepare('UPDATE sessions SET total_tokens=total_tokens+?, total_cost=total_cost+? WHERE id=?').run(tokens, cost, opts.session_id);
+  }
+}
+
+// Stats
+export function todayStats() {
+  return {
+    totals: db().prepare(`SELECT COALESCE(SUM(cost),0) as cost, COALESCE(SUM(tokens),0) as tokens, COUNT(*) as events FROM events WHERE date(created_at)=date('now')`).get(),
+    by_category: db().prepare(`SELECT category as k, SUM(tokens) as v, COUNT(*) as n FROM events WHERE date(created_at)=date('now') GROUP BY category ORDER BY v DESC`).all(),
+    by_client: db().prepare(`SELECT client as k, SUM(tokens) as v, COUNT(*) as n FROM events WHERE date(created_at)=date('now') GROUP BY client ORDER BY v DESC`).all(),
+    by_model: db().prepare(`SELECT model as k, SUM(tokens) as v, COUNT(*) as n FROM events WHERE date(created_at)=date('now') GROUP BY model ORDER BY v DESC`).all(),
+    sessions: db().prepare(`SELECT * FROM sessions WHERE date(started_at)=date('now') ORDER BY started_at DESC`).all(),
+  };
+}
+
+export function allTimeStats() {
+  return {
+    totals: db().prepare(`SELECT COALESCE(SUM(cost),0) as cost, COALESCE(SUM(tokens),0) as tokens, COUNT(*) as events FROM events`).get(),
+    by_category: db().prepare(`SELECT category as k, SUM(tokens) as v, COUNT(*) as n FROM events GROUP BY category ORDER BY v DESC`).all(),
+  };
+}
+
+// Sync: get unsynced events, mark them synced
+export function getUnsyncedEvents() {
+  return db().prepare('SELECT * FROM events WHERE synced=0 ORDER BY created_at ASC LIMIT 500').all();
+}
+
+export function markSynced(ids) {
+  const placeholders = ids.map(() => '?').join(',');
+  db().prepare(`UPDATE events SET synced=1 WHERE id IN (${placeholders})`).run(...ids);
+}
+
+// Summary for daily sync (aggregated, no notes/descriptions — privacy safe)
+export function getDailySummary() {
+  return db().prepare(`
+    SELECT category, model, client, SUM(tokens) as tokens, SUM(cost) as cost, COUNT(*) as n
+    FROM events WHERE synced=0
+    GROUP BY category, model, client
+  `).all();
+}
+
+export function markAllSynced() {
+  db().prepare('UPDATE events SET synced=1 WHERE synced=0').run();
+}

package/lib/sync.js

@@ -0,0 +1,72 @@
+import { createHash } from 'crypto';
+import { loadConfig } from './config.js';
+import { getDailySummary, markAllSynced } from './store.js';
+
+// Generate a dedup key so the server can ignore duplicate syncs
+function idempKey(userId, row) {
+  const date = new Date().toISOString().slice(0, 10);
+  return createHash('sha256').update(`${userId}:${row.category}:${row.model}:${row.client}:${row.tokens}:${date}`).digest('hex').slice(0, 16);
+}
+
+// Sync modes:
+//   off   — nothing leaves your machine
+//   daily — aggregated summary, no descriptions, no notes
+//   live  — each event sent as it happens (still no raw descriptions)
+
+export async function syncDaily() {
+  const config = loadConfig();
+  if (!config.user_id || config.stream === 'off') return { synced: 0 };
+
+  const summary = getDailySummary();
+  if (!summary.length) return { synced: 0 };
+
+  // Convert summary rows into batch events (aggregated = privacy safe)
+  const events = summary.map(row => ({
+    category: row.category,
+    model: row.model,
+    client: row.client,
+    tokens: row.tokens,
+    cost: row.cost,
+    idempotency_key: idempKey(config.user_id, row),
+  }));
+
+  try {
+    const res = await fetch(config.api_url + '/api/report/batch', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        user_id: config.user_id,
+        events,
+        country: config.country || null,
+      }),
+    });
+    const data = await res.json();
+    if (data.ok) {
+      markAllSynced();
+      return { synced: events.length };
+    }
+  } catch {}
+  return { synced: 0 };
+}
+
+export async function syncEvent(event) {
+  const config = loadConfig();
+  if (!config.user_id || config.stream !== 'live') return false;
+
+  try {
+    await fetch(config.api_url + '/api/report', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        user_id: config.user_id,
+        category: event.category,
+        model: event.model,
+        client: event.client,
+        tokens: event.tokens,
+        cost: event.cost,
+        country: config.country || null,
+      }),
+    });
+    return true;
+  } catch { return false; }
+}

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "codeslop",
+  "version": "0.1.0",
+  "description": "Track every dollar your AI agent lights on fire. Works with Claude Code, Cursor, Windsurf, Copilot, Aider, OpenCode. codeslop.org",
+  "bin": {
+    "codeslop": "./bin/wasted.js"
+  },
+  "type": "module",
+  "keywords": ["ai", "tokens", "waste", "slop", "codeslop", "llm", "claude", "cursor", "copilot", "windsurf", "opencode", "aider"],
+  "license": "MIT",
+  "files": ["bin/", "lib/"],
+  "dependencies": {
+    "better-sqlite3": "^11.6.0"
+  }
+}