aicp-tracker 1.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Alexey Pavlenko
+
+All rights reserved.
+
+This software is proprietary and confidential.
+
+Permission is granted to install and use this software solely for the purpose
+of interacting with the AICP Tracker service, and only with a valid and active subscription.
+
+You may NOT:
+- copy, modify, merge, publish, distribute, sublicense, or sell the software
+- use the software in any competing product or service
+- reverse engineer, decompile, or attempt to extract source code or algorithms
+- remove or alter any proprietary notices
+
+The software is provided "as is", without warranty of any kind.
+
+Access to the source code (if provided) is for review purposes only and does
+not grant any rights beyond what is explicitly stated in this license.

package/bin/aicp-tracker.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+'use strict';
+
+const [,, cmd, ...args] = process.argv;
+
+switch (cmd) {
+  case 'start':   require('../src/daemon').start(); break;
+  case 'stop':    require('../src/daemon').stop();  break;
+  case 'status':  require('../src/daemon').status(); break;
+  case 'setup':   require('./setup');               break;
+  case 'flush':   require('../src/wal').flush();    break;
+  default:
+    console.log(`
+  aicp-tracker <command>
+
+  Commands:
+    start    Start the background tracker (sends usage every 5 min)
+    stop     Stop the background tracker
+    status   Show tracker status and WAL queue depth
+    setup    Re-run the configuration wizard
+    flush    Force-send all pending WAL records now
+`);
+}

package/bin/setup.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+'use strict';
+
+// Runs on `npm install` (postinstall). Skipped in CI environments.
+if (process.env.CI || process.env.npm_config_yes) process.exit(0);
+
+const { prompt }    = require('enquirer');
+const { execSync }  = require('child_process');
+const fs            = require('fs');
+const os            = require('os');
+const path          = require('path');
+const config        = require('../src/config');
+const daemon        = require('../src/daemon');
+
+const API_URL   = 'http://147.5.102.208:3000';
+const TASK_NAME = 'AI Code Pulse Tracker';
+
+const PLANS = [
+  'Pro (monthly)',
+  'Pro (yearly)',
+  'Max',
+  'Team (standard)',
+  'Team (premium)',
+  'Enterprise',
+];
+
+// ── Auto-start installation (runs silently, non-fatal) ────────────────────────
+
+function installAutoStart() {
+  const nodePath   = process.execPath;
+  const scriptPath = path.resolve(__dirname, 'aicp-tracker.js');
+
+  try {
+    if (process.platform === 'win32') {
+      // Windows Task Scheduler: run at every login, current user only
+      execSync(
+        `schtasks /create /tn "${TASK_NAME}" /tr "\\"${nodePath}\\" \\"${scriptPath}\\" start" /sc ONLOGON /f`,
+        { stdio: 'ignore' }
+      );
+
+    } else if (process.platform === 'darwin') {
+      // macOS launchd: load on login
+      const plistDir  = path.join(os.homedir(), 'Library', 'LaunchAgents');
+      const plistPath = path.join(plistDir, 'com.aicp-tracker.plist');
+      fs.mkdirSync(plistDir, { recursive: true });
+      fs.writeFileSync(plistPath, `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>com.aicp-tracker</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${scriptPath}</string>
+    <string>start</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><false/>
+</dict>
+</plist>`);
+      execSync(`launchctl load "${plistPath}"`, { stdio: 'ignore' });
+
+    } else {
+      // Linux: systemd user service
+      const unitDir  = path.join(os.homedir(), '.config', 'systemd', 'user');
+      const unitPath = path.join(unitDir, 'aicp-tracker.service');
+      fs.mkdirSync(unitDir, { recursive: true });
+      fs.writeFileSync(unitPath, `[Unit]
+Description=AI Code Pulse Tracker
+
+[Service]
+Type=oneshot
+ExecStart=${nodePath} ${scriptPath} start
+RemainAfterExit=yes
+
+[Install]
+WantedBy=default.target
+`);
+      execSync('systemctl --user daemon-reload && systemctl --user enable --now aicp-tracker', { stdio: 'ignore' });
+    }
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ── Registration ──────────────────────────────────────────────────────────────
+
+async function register(email) {
+  const res = await fetch(`${API_URL}/api/v1/register`, {
+    method:  'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body:    JSON.stringify({ email }),
+    signal:  AbortSignal.timeout(15_000),
+  });
+  if (!res.ok) throw new Error(`Registration failed: HTTP ${res.status}`);
+  const json = await res.json();
+  if (!json.apiKey) throw new Error('No API key returned from server');
+  return json.apiKey;
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+async function main() {
+  console.log('\n\x1b[1m AI Code Pulse Tracker — first-time setup\x1b[0m\n');
+
+  let existing = null;
+  try { existing = config.load(); } catch {}
+  if (existing?.vcsUrl) {
+    console.log(`  Already configured (${existing.vcsUrl}). Re-running setup will overwrite it.\n`);
+  }
+
+  const answers = await prompt([
+    {
+      type: 'input',
+      name: 'vcsUrl',
+      message: 'VCS organisation URL (e.g. https://bitbucket.org/my-workspace or https://github.com/my-org)',
+      initial: existing?.vcsUrl || '',
+      validate: v => /^https?:\/\/(bitbucket\.org|github\.com)\/.+/.test(v.trim())
+        ? true
+        : 'Must be https://bitbucket.org/<slug> or https://github.com/<slug>',
+    },
+    {
+      type: 'input',
+      name: 'email',
+      message: 'Your email used in Bitbucket / GitHub',
+      initial: existing?.email || '',
+      validate: v => v.includes('@') ? true : 'Enter a valid email address',
+    },
+    {
+      type: 'select',
+      name: 'plan',
+      message: 'Your Claude Code plan',
+      choices: PLANS,
+      initial: existing?.plan ? PLANS.indexOf(existing.plan) : 0,
+    },
+  ]);
+
+  console.log('\n  Registering with AI Code Pulse server…');
+  const apiKey = await register(answers.email.trim());
+
+  config.save({
+    vcsUrl: answers.vcsUrl.trim(),
+    email:  answers.email.trim(),
+    plan:   answers.plan,
+    apiUrl: API_URL,
+    apiKey,
+  });
+
+  console.log('  \x1b[32m✔\x1b[0m Configuration saved');
+
+  console.log('  Installing auto-start (runs at every login)…');
+  const ok = installAutoStart();
+  console.log(ok
+    ? '  \x1b[32m✔\x1b[0m Auto-start installed'
+    : '  \x1b[33m⚠\x1b[0m Auto-start could not be installed — run `aicp-tracker start` manually'
+  );
+
+  console.log('  Starting tracker…');
+  daemon.start();
+  console.log('  \x1b[32m✔\x1b[0m Tracker running. Usage will be sent every 5 minutes.\n');
+}
+
+main().catch(e => {
+  console.warn('\n  [aicp-tracker] Setup skipped:', e.message, '\n  Run `aicp-tracker setup` to configure later.\n');
+});

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "aicp-tracker",
+  "version": "1.0.0",
+  "description": "AI Code Pulse — Claude Code usage tracker for JIRA cost attribution",
+  "main": "src/daemon.js",
+  "bin": {
+    "aicp-tracker": "./bin/aicp-tracker.js"
+  },
+  "scripts": {
+    "postinstall": "node bin/setup.js"
+  },
+  "dependencies": {
+    "enquirer": "^2.4.1"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "UNLICENSED",
+  "private": false
+}

package/src/config.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const CONFIG_DIR  = path.join(os.homedir(), '.aicp-tracker');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function ensureDir() {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+function load() {
+  if (!fs.existsSync(CONFIG_FILE)) return null;
+  return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+}
+
+function save(cfg) {
+  ensureDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), 'utf8');
+}
+
+function require_() {
+  const cfg = load();
+  if (!cfg) throw new Error('Not configured. Run: aicp-tracker setup');
+  return cfg;
+}
+
+module.exports = { CONFIG_FILE, CONFIG_DIR, load, save, require: require_ };

package/src/daemon-worker.js

@@ -0,0 +1,23 @@
+'use strict';
+
+// Spawned as a detached background process by daemon.js start()
+
+const path  = require('path');
+const fs    = require('fs');
+const { CONFIG_DIR } = require('./config');
+const { tick } = require('./daemon');
+
+const PID_FILE = path.join(CONFIG_DIR, 'daemon.pid');
+fs.writeFileSync(PID_FILE, String(process.pid), 'utf8');
+
+process.on('SIGTERM', () => {
+  try { fs.unlinkSync(PID_FILE); } catch {}
+  process.exit(0);
+});
+
+async function loop() {
+  try { await tick(); } catch (e) { console.error('[daemon-worker] tick error:', e.message); }
+  setTimeout(loop, 5 * 60 * 1000);
+}
+
+loop();

package/src/daemon.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const path      = require('path');
+const fs        = require('fs');
+const os        = require('os');
+const { findJsonlFiles } = require('./log-scanner');
+const { parseNewLines }  = require('./log-parser');
+const wal                = require('./wal');
+const { sendPending }    = require('./sender');
+const { CONFIG_DIR }     = require('./config');
+
+const PID_FILE    = path.join(CONFIG_DIR, 'daemon.pid');
+const INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+
+async function tick() {
+  const files = findJsonlFiles();
+  let total = 0;
+  for (const f of files) {
+    const records = parseNewLines(f);
+    if (records.length) {
+      wal.append(records);
+      total += records.length;
+    }
+  }
+  if (total > 0) console.log(`[daemon] Parsed ${total} new usage records from ${files.length} files`);
+  await sendPending();
+}
+
+function writePid() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(PID_FILE, String(process.pid), 'utf8');
+}
+
+function readPid() {
+  try { return parseInt(fs.readFileSync(PID_FILE, 'utf8'), 10); } catch { return null; }
+}
+
+function start() {
+  const existingPid = readPid();
+  if (existingPid) {
+    try {
+      process.kill(existingPid, 0); // check if running
+      console.log(`[daemon] Already running (pid ${existingPid})`);
+      return;
+    } catch {}
+  }
+
+  // Detach and run as background process
+  const child = require('child_process').spawn(
+    process.execPath,
+    [path.join(__dirname, 'daemon-worker.js')],
+    { detached: true, stdio: 'ignore' }
+  );
+  child.unref();
+  console.log(`[daemon] Started (pid ${child.pid})`);
+}
+
+function stop() {
+  const pid = readPid();
+  if (!pid) { console.log('[daemon] Not running'); return; }
+  try {
+    process.kill(pid, 'SIGTERM');
+    fs.unlinkSync(PID_FILE);
+    console.log(`[daemon] Stopped (pid ${pid})`);
+  } catch (e) {
+    console.warn('[daemon] Could not stop:', e.message);
+  }
+}
+
+function status() {
+  const pid = readPid();
+  const running = pid ? (() => { try { process.kill(pid, 0); return true; } catch { return false; } })() : false;
+  console.log(`[daemon] Status: ${running ? `running (pid ${pid})` : 'stopped'}`);
+  console.log(`[daemon] WAL pending: ${wal.pendingCount()} records`);
+}
+
+// When required directly (e.g. aicp-tracker start calls this)
+module.exports = { start, stop, status, tick };

package/src/log-parser.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const fs    = require('fs');
+const state = require('./state');
+
+// Tool names whose input.file_path / input.path we extract
+const FILE_TOOLS = new Set(['Read', 'Edit', 'Write', 'Glob', 'NotebookEdit', 'MultiEdit']);
+
+function parseNewLines(filePath) {
+  const offset = state.getOffset(filePath);
+  let stat;
+  try { stat = fs.statSync(filePath); } catch { return []; }
+  if (stat.size <= offset) return [];
+
+  const fd  = fs.openSync(filePath, 'r');
+  const buf = Buffer.alloc(stat.size - offset);
+  const read = fs.readSync(fd, buf, 0, buf.length, offset);
+  fs.closeSync(fd);
+  state.setOffset(filePath, offset + read);
+
+  const records = [];
+  const lines = buf.slice(0, read).toString('utf8').split('\n');
+
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+
+    if (entry.type !== 'assistant' && entry.message?.role !== 'assistant') continue;
+    const usage = entry.message?.usage;
+    if (!usage) continue;
+
+    let webSearchRequests = 0;
+    let webFetchRequests  = 0;
+    const filePaths = new Set();
+    const content = entry.message?.content;
+
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type !== 'tool_use') continue;
+        if (block.name === 'web_search' || block.name === 'WebSearch') webSearchRequests++;
+        if (block.name === 'web_fetch'  || block.name === 'WebFetch')  webFetchRequests++;
+        if (FILE_TOOLS.has(block.name)) {
+          const fp = block.input?.file_path || block.input?.path;
+          if (fp && typeof fp === 'string') filePaths.add(fp);
+        }
+      }
+    }
+
+    records.push({
+      sessionId:  entry.sessionId  || null,
+      uuid:       entry.uuid       || null,
+      parentUuid: entry.parentUuid || null,
+      timestamp:  entry.timestamp  || new Date().toISOString(),
+      gitBranch:  entry.gitBranch  || null,
+      model:      entry.message?.model || null,
+
+      input_tokens:                     usage.input_tokens                     || 0,
+      cache_creation_input_tokens:      usage.cache_creation_input_tokens      || 0,
+      cache_read_input_tokens:          usage.cache_read_input_tokens           || 0,
+      output_tokens:                    usage.output_tokens                    || 0,
+      ephemeral_user_input_tokens:      usage.ephemeral_user_input_tokens      || 0,
+      ephemeral_assistant_input_tokens: usage.ephemeral_assistant_input_tokens || 0,
+      ephemeral_tool_input_tokens:      usage.ephemeral_tool_input_tokens      || 0,
+
+      web_search_requests: webSearchRequests,
+      web_fetch_requests:  webFetchRequests,
+      file_paths:          [...filePaths],
+
+      // Claude Code logs do not include per-token USD pricing from Anthropic's API.
+      // Enterprise billing data must come from Anthropic's billing API separately.
+      enterprise_usd_per_token: null,
+
+      service_tier: usage.service_tier || null,
+      speed:        usage.cache_creation_input_tokens > 0 ? 'fast' : 'normal',
+    });
+  }
+
+  return records;
+}
+
+module.exports = { parseNewLines };

package/src/log-scanner.js

@@ -0,0 +1,28 @@
+'use strict';
+
+// Finds all Claude Code session jsonl files under ~/.claude/projects/
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const CLAUDE_DIR = path.join(os.homedir(), '.claude', 'projects');
+
+function findJsonlFiles() {
+  const results = [];
+  if (!fs.existsSync(CLAUDE_DIR)) return results;
+
+  for (const projectHash of fs.readdirSync(CLAUDE_DIR)) {
+    const projectDir = path.join(CLAUDE_DIR, projectHash);
+    if (!fs.statSync(projectDir).isDirectory()) continue;
+    for (const file of fs.readdirSync(projectDir)) {
+      if (file.endsWith('.jsonl')) {
+        results.push(path.join(projectDir, file));
+      }
+    }
+  }
+
+  return results;
+}
+
+module.exports = { findJsonlFiles };

package/src/sender.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const config = require('./config');
+const wal    = require('./wal');
+
+/**
+ * Groups an array of raw usage records into the nested API payload:
+ *   organization → useremail → date → [records]
+ */
+function buildPayload(cfg, records) {
+  const org   = cfg.vcsUrl.replace(/^https?:\/\/[^/]+\//, ''); // extract slug
+  const email = cfg.email;
+  const payload = {};
+
+  for (const rec of records) {
+    const date = rec.timestamp ? rec.timestamp.slice(0, 10) : new Date().toISOString().slice(0, 10);
+    payload[org]          = payload[org]          || {};
+    payload[org][email]   = payload[org][email]   || {};
+    payload[org][email][date] = payload[org][email][date] || [];
+    payload[org][email][date].push({
+      input_tokens:                     rec.input_tokens,
+      cache_creation_input_tokens:      rec.cache_creation_input_tokens,
+      cache_read_input_tokens:          rec.cache_read_input_tokens,
+      output_tokens:                    rec.output_tokens,
+      ephemeral_user_input_tokens:      rec.ephemeral_user_input_tokens,
+      ephemeral_assistant_input_tokens: rec.ephemeral_assistant_input_tokens,
+      ephemeral_tool_input_tokens:      rec.ephemeral_tool_input_tokens,
+      web_search_requests:              rec.web_search_requests,
+      web_fetch_requests:               rec.web_fetch_requests,
+      service_tier:                     rec.service_tier,
+      speed:                            rec.speed,
+      model:                            rec.model,
+      file_paths:                       rec.file_paths || [],
+      enterprise_usd_per_token:         rec.enterprise_usd_per_token || null,
+      sessionId:                        rec.sessionId,
+      uuid:                             rec.uuid,
+      parentUuid:                       rec.parentUuid,
+      gitBranch:                        rec.gitBranch,
+    });
+  }
+
+  return payload;
+}
+
+async function sendPending() {
+  const pending = wal.getPending();
+  if (!pending.length) return;
+
+  let cfg;
+  try { cfg = config.require(); } catch (e) { console.warn('[sender]', e.message); return; }
+
+  const payload = buildPayload(cfg, pending);
+  const uuids   = pending.map(r => r.uuid).filter(Boolean);
+
+  try {
+    const res = await fetch(`${cfg.apiUrl}/api/v1/ingest`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-API-Key': cfg.apiKey,
+      },
+      body: JSON.stringify({ plan: cfg.plan, data: payload }),
+      signal: AbortSignal.timeout(30_000),
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(`HTTP ${res.status}: ${text.slice(0, 200)}`);
+    }
+
+    wal.markSent(uuids);
+    console.log(`[sender] Sent ${pending.length} records (${uuids.length} with UUIDs)`);
+  } catch (e) {
+    wal.markFailed(uuids);
+    console.warn('[sender] Send failed (will retry next cycle):', e.message);
+  }
+}
+
+module.exports = { sendPending };

package/src/state.js

@@ -0,0 +1,36 @@
+'use strict';
+
+// Tracks the byte offset read so far in each jsonl file so we never re-parse old lines.
+
+const fs    = require('fs');
+const path  = require('path');
+const { CONFIG_DIR } = require('./config');
+
+const STATE_FILE = path.join(CONFIG_DIR, 'state.json');
+
+let _state = null;
+
+function load() {
+  if (_state) return _state;
+  try {
+    _state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+  } catch {
+    _state = { offsets: {} };
+  }
+  return _state;
+}
+
+function save() {
+  fs.writeFileSync(STATE_FILE, JSON.stringify(_state, null, 2), 'utf8');
+}
+
+function getOffset(filePath) {
+  return load().offsets[filePath] || 0;
+}
+
+function setOffset(filePath, offset) {
+  load().offsets[filePath] = offset;
+  save();
+}
+
+module.exports = { getOffset, setOffset };

package/src/wal.js

@@ -0,0 +1,69 @@
+'use strict';
+
+// Write-Ahead Log — records are written atomically to disk before any send attempt.
+// Status: 'pending' | 'sent' | 'failed'
+// On each cycle: retry all pending + failed, mark sent, prune old sent records.
+
+const fs   = require('fs');
+const path = require('path');
+const { CONFIG_DIR } = require('./config');
+
+const WAL_FILE  = path.join(CONFIG_DIR, 'wal.json');
+const SENT_TTL  = 7 * 24 * 60 * 60 * 1000; // keep sent records for 7 days
+
+function load() {
+  try { return JSON.parse(fs.readFileSync(WAL_FILE, 'utf8')); } catch { return { records: [] }; }
+}
+
+function _save(wal) {
+  const tmp = WAL_FILE + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(wal, null, 2), 'utf8');
+  fs.renameSync(tmp, WAL_FILE); // atomic on POSIX; best-effort on Windows
+}
+
+function append(records) {
+  const wal = load();
+  const now = Date.now();
+  for (const rec of records) {
+    wal.records.push({ ...rec, _walStatus: 'pending', _walAddedAt: now, _walAttempts: 0 });
+  }
+  _save(wal);
+}
+
+function getPending() {
+  const wal = load();
+  return wal.records.filter(r => r._walStatus === 'pending' || r._walStatus === 'failed');
+}
+
+function markSent(uuids) {
+  const set = new Set(uuids);
+  const wal = load();
+  const now = Date.now();
+  for (const r of wal.records) {
+    if (set.has(r.uuid)) { r._walStatus = 'sent'; r._walSentAt = now; }
+  }
+  // Prune records sent more than 7 days ago
+  wal.records = wal.records.filter(r => !(r._walStatus === 'sent' && now - r._walSentAt > SENT_TTL));
+  _save(wal);
+}
+
+function markFailed(uuids) {
+  const set = new Set(uuids);
+  const wal = load();
+  for (const r of wal.records) {
+    if (set.has(r.uuid)) { r._walStatus = 'failed'; r._walAttempts = (r._walAttempts || 0) + 1; }
+  }
+  _save(wal);
+}
+
+function pendingCount() {
+  return getPending().length;
+}
+
+async function flush() {
+  const count = pendingCount();
+  if (count === 0) { console.log('WAL: nothing pending.'); return; }
+  console.log(`WAL: ${count} pending records. Run \`aicp-tracker start\` to flush, or wait for next cycle.`);
+}
+
+module.exports = { append, getPending, markSent, markFailed, pendingCount, flush };