vibeusage 0.2.15 → 0.2.16

package/README.md

@@ -1,5 +1,7 @@
 <div align="center">
 
+<img src="dashboard/public/icon-192.png" width="96" alt="VibeUsage Icon" />
+
 # 🟢 VIBEUSAGE
 
 **QUANTIFY YOUR AI OUTPUT**  

package/README.zh-CN.md

@@ -1,5 +1,7 @@
 <div align="center">
 
+<img src="dashboard/public/icon-192.png" width="96" alt="VibeUsage 图标" />
+
 # 🟢 VIBEUSAGE
 
 **量化你的 AI 产出**  

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibeusage",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "description": "Codex CLI token usage tracker (macOS-first, notify-driven).",
   "license": "MIT",
   "publishConfig": {
@@ -17,13 +17,16 @@
     "dashboard:preview": "npm --prefix dashboard run preview",
     "dev:shim": "node scripts/dev-bin-shim.cjs",
     "validate:copy": "node scripts/validate-copy-registry.cjs",
+    "validate:ui-hardcode": "node scripts/ops/validate-ui-hardcode.cjs",
     "copy:pull": "node scripts/copy-sync.cjs pull",
     "copy:push": "node scripts/copy-sync.cjs push",
     "architecture:canvas": "node scripts/ops/architecture-canvas.cjs",
     "architecture:canvas:focus": "node scripts/ops/architecture-canvas.cjs --focus",
     "architecture:canvas:list-modules": "node scripts/ops/architecture-canvas.cjs --list-modules",
     "validate:guardrails": "node scripts/validate-architecture-guardrails.cjs",
-    "validate:insforge2-db": "node scripts/ops/insforge2-db-validate.cjs"
+    "validate:insforge2-db": "node scripts/ops/insforge2-db-validate.cjs",
+    "graph:scip": "node scripts/graph/generate-scip.cjs",
+    "graph:auto-index": "node scripts/graph/auto-index.cjs"
   },
   "bin": {
     "tracker": "bin/tracker.js",
@@ -37,9 +40,10 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=18"
+    "node": "20.x"
   },
   "devDependencies": {
+    "@sourcegraph/scip-typescript": "^0.3.6",
     "esbuild": "0.27.2"
   },
   "dependencies": {

package/src/commands/init.js

@@ -600,12 +600,37 @@ const trackerBinPath = ${JSON.stringify(trackerBinPath)};
 const fallbackPkg = ${JSON.stringify(fallbackPkg)};
 const selfPath = path.resolve(__filename);
 const home = os.homedir();
+const debugLogPath = path.join(trackerDir, 'notify.debug.jsonl');
+const debugEnabled = ['1', 'true'].includes((process.env.VIBEUSAGE_NOTIFY_DEBUG || '').toLowerCase());
+const debugMaxBytesRaw = Number.parseInt(process.env.VIBEUSAGE_NOTIFY_DEBUG_MAX_BYTES || '', 10);
+const debugMaxBytes = Number.isFinite(debugMaxBytesRaw) && debugMaxBytesRaw > 0
+  ? debugMaxBytesRaw
+  : 1_000_000;
 
 try {
   fs.mkdirSync(trackerDir, { recursive: true });
   fs.writeFileSync(signalPath, new Date().toISOString(), { encoding: 'utf8' });
 } catch (_) {}
 
+if (debugEnabled) {
+  try {
+    let size = 0;
+    try {
+      size = fs.statSync(debugLogPath).size;
+    } catch (err) {
+      if (err && err.code !== 'ENOENT') throw err;
+    }
+    if (size < debugMaxBytes) {
+      const entry = {
+        ts: new Date().toISOString(),
+        source,
+        cwd: process.cwd()
+      };
+      fs.appendFileSync(debugLogPath, JSON.stringify(entry) + os.EOL, 'utf8');
+    }
+  } catch (_) {}
+}
+
 // Throttle spawn: at most once per 20 seconds.
 try {
     const throttlePath = path.join(trackerDir, 'sync.throttle');

package/src/commands/sync.js

@@ -24,6 +24,7 @@ const {
   recordUploadSuccess,
   recordUploadFailure
 } = require('../lib/upload-throttle');
+const { purgeProjectUsage } = require('../lib/project-usage-purge');
 const { resolveTrackerPaths } = require('../lib/tracker-paths');
 const { resolveRuntimeConfig } = require('../lib/runtime-config');
 
@@ -45,6 +46,8 @@ async function cmdSync(argv) {
     const cursorsPath = path.join(trackerDir, 'cursors.json');
     const queuePath = path.join(trackerDir, 'queue.jsonl');
     const queueStatePath = path.join(trackerDir, 'queue.state.json');
+    const projectQueuePath = path.join(trackerDir, 'project.queue.jsonl');
+    const projectQueueStatePath = path.join(trackerDir, 'project.queue.state.json');
     const uploadThrottlePath = path.join(trackerDir, 'upload.throttle.json');
 
     const config = await readJson(configPath);
@@ -85,6 +88,7 @@ async function cmdSync(argv) {
       rolloutFiles,
       cursors,
       queuePath,
+      projectQueuePath,
       onProgress: (p) => {
         if (!progress?.enabled) return;
         const pct = p.total > 0 ? p.index / p.total : 1;
@@ -106,6 +110,7 @@ async function cmdSync(argv) {
         projectFiles: claudeFiles,
         cursors,
         queuePath,
+        projectQueuePath,
         onProgress: (p) => {
           if (!progress?.enabled) return;
           const pct = p.total > 0 ? p.index / p.total : 1;
@@ -129,6 +134,7 @@ async function cmdSync(argv) {
         sessionFiles: geminiFiles,
         cursors,
         queuePath,
+        projectQueuePath,
         onProgress: (p) => {
           if (!progress?.enabled) return;
           const pct = p.total > 0 ? p.index / p.total : 1;
@@ -152,6 +158,7 @@ async function cmdSync(argv) {
         messageFiles: opencodeFiles,
         cursors,
         queuePath,
+        projectQueuePath,
         onProgress: (p) => {
           if (!progress?.enabled) return;
           const pct = p.total > 0 ? p.index / p.total : 1;
@@ -165,6 +172,21 @@ async function cmdSync(argv) {
       });
     }
 
+    if (cursors?.projectHourly?.projects && projectQueuePath && projectQueueStatePath) {
+      for (const [projectKey, meta] of Object.entries(cursors.projectHourly.projects)) {
+        if (!meta || typeof meta !== 'object') continue;
+        if (meta.status !== 'blocked' || !meta.purge_pending) continue;
+        await purgeProjectUsage({
+          projectKey,
+          projectQueuePath,
+          projectQueueStatePath,
+          projectState: cursors.projectHourly
+        });
+        meta.purge_pending = false;
+        meta.purged_at = new Date().toISOString();
+      }
+    }
+
     cursors.updatedAt = new Date().toISOString();
     await writeJson(cursorsPath, cursors);
 
@@ -178,8 +200,12 @@ async function cmdSync(argv) {
     let uploadAttempted = false;
     if (deviceToken) {
       const beforeState = (await readJson(queueStatePath)) || { offset: 0 };
+      const projectBeforeState = (await readJson(projectQueueStatePath)) || { offset: 0 };
       const queueSize = await safeStatSize(queuePath);
-      const pendingBytes = Math.max(0, queueSize - Number(beforeState.offset || 0));
+      const projectQueueSize = await safeStatSize(projectQueuePath);
+      const pendingBytes =
+        Math.max(0, queueSize - Number(beforeState.offset || 0)) +
+        Math.max(0, projectQueueSize - Number(projectBeforeState.offset || 0));
       let maxBatches = opts.auto ? 3 : opts.drain ? 10_000 : 10;
       let batchSize = UPLOAD_DEFAULTS.batchSize;
       let allowUpload = pendingBytes > 0;
@@ -208,9 +234,11 @@ async function cmdSync(argv) {
       }
 
       if (progress?.enabled && pendingBytes > 0 && allowUpload) {
-        const pct = queueSize > 0 ? Number(beforeState.offset || 0) / queueSize : 0;
+        const totalSize = queueSize + projectQueueSize;
+        const totalOffset = Number(beforeState.offset || 0) + Number(projectBeforeState.offset || 0);
+        const pct = totalSize > 0 ? totalOffset / totalSize : 0;
         progress.start(
-          `Uploading ${renderBar(pct)} ${formatBytes(Number(beforeState.offset || 0))}/${formatBytes(queueSize)} | inserted 0 skipped 0`
+          `Uploading ${renderBar(pct)} ${formatBytes(totalOffset)}/${formatBytes(totalSize)} | inserted 0 skipped 0`
         );
       }
 
@@ -222,6 +250,8 @@ async function cmdSync(argv) {
             deviceToken,
             queuePath,
             queueStatePath,
+            projectQueuePath,
+            projectQueueStatePath,
             maxBatches,
             batchSize,
             onProgress: (u) => {
@@ -267,7 +297,11 @@ async function cmdSync(argv) {
 
     const afterState = (await readJson(queueStatePath)) || { offset: 0 };
     const queueSize = await safeStatSize(queuePath);
-    const pendingBytes = Math.max(0, queueSize - Number(afterState.offset || 0));
+    const projectAfterState = (await readJson(projectQueueStatePath)) || { offset: 0 };
+    const projectQueueSize = await safeStatSize(projectQueuePath);
+    const pendingBytes =
+      Math.max(0, queueSize - Number(afterState.offset || 0)) +
+      Math.max(0, projectQueueSize - Number(projectAfterState.offset || 0));
 
     if (pendingBytes <= 0) {
       await clearAutoRetry(trackerDir);

package/src/lib/project-usage-purge.js

@@ -0,0 +1,100 @@
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const readline = require('node:readline');
+
+async function purgeProjectUsage({ projectKey, projectQueuePath, projectQueueStatePath, projectState }) {
+  if (!projectKey || !projectQueuePath || !projectQueueStatePath || !projectState) {
+    return { removed: 0, kept: 0, removedBuckets: 0 };
+  }
+
+  let previousOffset = 0;
+  const previousState = await fsp.readFile(projectQueueStatePath, 'utf8').catch(() => null);
+  if (previousState) {
+    try {
+      const parsed = JSON.parse(previousState);
+      const offset = Number(parsed?.offset || 0);
+      if (Number.isFinite(offset) && offset >= 0) previousOffset = offset;
+    } catch (_err) {
+      previousOffset = 0;
+    }
+  }
+
+  const buckets = projectState.buckets && typeof projectState.buckets === 'object' ? projectState.buckets : {};
+  let removedBuckets = 0;
+  const prefix = `${projectKey}|`;
+  for (const key of Object.keys(buckets)) {
+    if (key.startsWith(prefix)) {
+      delete buckets[key];
+      removedBuckets += 1;
+    }
+  }
+  projectState.buckets = buckets;
+
+  let removed = 0;
+  let kept = 0;
+  let nextOffset = 0;
+  const st = await fsp.stat(projectQueuePath).catch(() => null);
+  if (st && st.isFile()) {
+    const tmpPath = `${projectQueuePath}.tmp`;
+    await fsp.mkdir(path.dirname(projectQueuePath), { recursive: true });
+    const input = fs.createReadStream(projectQueuePath, 'utf8');
+    const output = fs.createWriteStream(tmpPath, { encoding: 'utf8' });
+    const rl = readline.createInterface({ input, crlfDelay: Infinity });
+
+    let inputOffset = 0;
+    let outputOffset = 0;
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      const inputBytes = Buffer.byteLength(line, 'utf8') + 1;
+      inputOffset += inputBytes;
+      if (!trimmed) continue;
+      let parsed = null;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch (_err) {
+        const entry = trimmed + '\n';
+        output.write(entry);
+        outputOffset += Buffer.byteLength(entry, 'utf8');
+        kept += 1;
+        if (inputOffset <= previousOffset) {
+          nextOffset = outputOffset;
+        }
+        continue;
+      }
+      if (parsed && parsed.project_key === projectKey) {
+        removed += 1;
+        if (inputOffset <= previousOffset) {
+          nextOffset = outputOffset;
+        }
+        continue;
+      }
+      const entry = JSON.stringify(parsed) + '\n';
+      output.write(entry);
+      outputOffset += Buffer.byteLength(entry, 'utf8');
+      kept += 1;
+      if (inputOffset <= previousOffset) {
+        nextOffset = outputOffset;
+      }
+    }
+
+    await new Promise((resolve, reject) => {
+      output.end(resolve);
+      output.on('error', reject);
+    });
+
+    await fsp.rename(tmpPath, projectQueuePath);
+    if (previousOffset >= inputOffset) {
+      nextOffset = outputOffset;
+    }
+  } else {
+    await fsp.writeFile(projectQueuePath, '', 'utf8');
+    nextOffset = 0;
+  }
+
+  await fsp.writeFile(projectQueueStatePath, JSON.stringify({ offset: nextOffset }), 'utf8');
+
+  return { removed, kept, removedBuckets };
+}
+
+module.exports = { purgeProjectUsage };