agny 0.1.0

package/dist/index.js

@@ -0,0 +1,457 @@
+#!/usr/bin/env node
+import {
+  clearCredentials,
+  cursorLogin,
+  cursorLoginWithToken,
+  cursorLogout,
+  cursorStatus,
+  cursorSync,
+  detectProjectContext,
+  finalizeReportAndGraphAsync,
+  getApiBaseUrl,
+  getCursorCachePath,
+  loadCredentials,
+  loadCursorCredentials,
+  parseCursorCsv,
+  parseLocalSourcesAsync,
+  saveCredentials,
+  syncCursorCache,
+  uploadBatch,
+  watch
+} from "./chunk-COBQNFEL.js";
+import {
+  install,
+  status,
+  uninstall
+} from "./chunk-FXTJMSTV.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/auth.ts
+import pc from "picocolors";
+import * as os from "os";
+var MAX_POLL_ATTEMPTS = 180;
+async function login() {
+  const credentials = loadCredentials();
+  if (credentials) {
+    console.log(pc.yellow(`
+  Already logged in as ${pc.bold(credentials.username)}`));
+    console.log(pc.gray("  Run 'agny logout' to sign out first.\n"));
+    return;
+  }
+  const baseUrl = getApiBaseUrl();
+  console.log(pc.cyan("\n  AGNY - Login\n"));
+  console.log(pc.gray("  Requesting authorization code..."));
+  let deviceCodeData;
+  try {
+    const response = await fetch(`${baseUrl}/api/auth/device`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ deviceName: getDeviceName() })
+    });
+    if (!response.ok) {
+      throw new Error(`Server returned ${response.status}`);
+    }
+    deviceCodeData = await response.json();
+  } catch (error) {
+    console.error(pc.red(`
+  Error: Failed to connect to server.`));
+    console.error(pc.gray(`  ${error.message}
+`));
+    process.exit(1);
+  }
+  console.log();
+  console.log(pc.white("  Open this URL in your browser:"));
+  console.log(pc.cyan(`  ${deviceCodeData.verificationUrl}
+`));
+  console.log(pc.white("  Enter this code:"));
+  console.log(pc.bold(pc.green(`  ${deviceCodeData.userCode}
+`)));
+  await openBrowser(deviceCodeData.verificationUrl);
+  console.log(pc.gray("  Waiting for authorization..."));
+  let attempts = 0;
+  const pollInterval = (deviceCodeData.interval || 5) * 1e3;
+  while (attempts < MAX_POLL_ATTEMPTS) {
+    await sleep(pollInterval);
+    attempts++;
+    try {
+      const response = await fetch(`${baseUrl}/api/auth/device/poll`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ deviceCode: deviceCodeData.deviceCode })
+      });
+      const data = await response.json();
+      if (data.status === "complete" && data.token && data.user) {
+        saveCredentials({
+          token: data.token,
+          username: data.user.username,
+          avatarUrl: data.user.avatarUrl,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        console.log(pc.green(`
+  Success! Logged in as ${pc.bold(data.user.username)}`));
+        console.log(pc.gray("  You can now use 'agny submit' to share your usage.\n"));
+        return;
+      }
+      if (data.status === "expired") {
+        console.error(pc.red("\n  Authorization code expired. Please try again.\n"));
+        process.exit(1);
+      }
+      process.stdout.write(pc.gray("."));
+    } catch {
+      process.stdout.write(pc.red("!"));
+    }
+  }
+  console.error(pc.red("\n\n  Timeout: Authorization took too long. Please try again.\n"));
+  process.exit(1);
+}
+async function logout() {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log(pc.yellow("\n  Not logged in.\n"));
+    return;
+  }
+  const username = credentials.username;
+  const cleared = clearCredentials();
+  if (cleared) {
+    console.log(pc.green(`
+  Logged out from ${pc.bold(username)}
+`));
+  } else {
+    console.error(pc.red("\n  Failed to clear credentials.\n"));
+    process.exit(1);
+  }
+}
+async function whoami() {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log(pc.yellow("\n  Not logged in."));
+    console.log(pc.gray("  Run 'agny login' to authenticate.\n"));
+    return;
+  }
+  console.log(pc.cyan("\n  AGNY - Account Info\n"));
+  console.log(pc.white(`  Username:  ${pc.bold(credentials.username)}`));
+  console.log(pc.gray(`  Logged in: ${new Date(credentials.createdAt).toLocaleDateString()}`));
+  console.log();
+}
+function getDeviceName() {
+  return `CLI on ${os.hostname()}`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function openBrowser(url) {
+  try {
+    const { exec } = await import("child_process");
+    const platform = process.platform;
+    let command;
+    if (platform === "darwin") {
+      command = `open "${url}"`;
+    } else if (platform === "win32") {
+      command = `start "" "${url}"`;
+    } else {
+      command = `xdg-open "${url}"`;
+    }
+    exec(command, (error) => {
+      if (error) {
+      }
+    });
+  } catch {
+  }
+}
+
+// src/submit.ts
+import * as fs from "fs";
+import * as crypto from "crypto";
+import pc2 from "picocolors";
+var formatCurrency = (val) => `$${val.toFixed(2)}`;
+async function submit(options = {}) {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log(pc2.yellow("\n  Not logged in."));
+    console.log(pc2.gray("  Run 'agny login' first.\n"));
+    process.exit(1);
+  }
+  const ctx = detectProjectContext();
+  console.log(pc2.cyan("\n  AGNY - Submit Usage Data\n"));
+  console.log(pc2.gray(`  Project: ${ctx.projectName} (${ctx.gitBranch || "no-git"})`));
+  console.log(pc2.gray("  Scanning local session data..."));
+  let data;
+  let cursorRows = [];
+  let localMessagesObject = null;
+  try {
+    const [parsedLocals, cursorSync2] = await Promise.all([
+      parseLocalSourcesAsync({
+        since: options.since,
+        until: options.until,
+        year: options.year
+      }),
+      loadCursorCredentials() ? syncCursorCache() : Promise.resolve({ synced: false, rows: 0 })
+    ]);
+    localMessagesObject = parsedLocals;
+    if (cursorSync2.synced) {
+      try {
+        const cursorCachePath = getCursorCachePath();
+        if (fs.existsSync(cursorCachePath)) {
+          const csvContent = fs.readFileSync(cursorCachePath, "utf-8");
+          cursorRows = parseCursorCsv(csvContent);
+        }
+      } catch {
+        console.warn(pc2.yellow("  Failed to read Cursor cache for details."));
+      }
+    }
+    const { report, graph } = await finalizeReportAndGraphAsync({
+      localMessages: localMessagesObject,
+      includeCursor: cursorSync2.synced,
+      since: options.since,
+      until: options.until,
+      year: options.year
+    });
+    data = graph;
+    data.summary.totalCost = report.totalCost;
+  } catch (error) {
+    console.error(pc2.red(`
+  Error generating data: ${error.message}
+`));
+    process.exit(1);
+  }
+  console.log(pc2.white("  Data to submit:"));
+  console.log(pc2.gray(`    Date range: ${data.meta.dateRange.start} to ${data.meta.dateRange.end}`));
+  console.log(pc2.gray(`    Active days: ${data.summary.activeDays}`));
+  console.log(pc2.gray(`    Total tokens: ${data.summary.totalTokens.toLocaleString()}`));
+  console.log(pc2.gray(`    Total cost: ${formatCurrency(data.summary.totalCost)}`));
+  console.log(pc2.gray(`    Sources: ${data.summary.sources.join(", ")}`));
+  console.log();
+  if (data.summary.totalTokens === 0) {
+    console.log(pc2.yellow("  No usage data found to submit.\n"));
+    return;
+  }
+  if (options.dryRun) {
+    console.log(pc2.yellow("  Dry run - not submitting data.\n"));
+    return;
+  }
+  console.log(pc2.gray("  Submitting to server..."));
+  const events = [];
+  const now = Date.now();
+  const ATTRIBUTION_THRESHOLD_MS = 4 * 60 * 60 * 1e3;
+  for (const msg of localMessagesObject?.messages || []) {
+    const isRecent = now - msg.timestamp < ATTRIBUTION_THRESHOLD_MS;
+    const idSeed = `${msg.timestamp}-${msg.modelId}-${msg.input}-${msg.output}-${msg.providerId || msg.source}`;
+    const external_id = crypto.createHash("sha256").update(idSeed).digest("hex").slice(0, 36);
+    events.push({
+      external_id,
+      source: msg.source,
+      source_type: msg.sourceType || "local",
+      model: msg.modelId,
+      provider: msg.providerId || msg.source,
+      input_tokens: msg.input,
+      output_tokens: msg.output,
+      cache_read: msg.cacheRead,
+      cache_write: msg.cacheWrite,
+      reasoning: msg.reasoning,
+      total_tokens: msg.input + msg.output + msg.cacheRead + msg.cacheWrite + msg.reasoning,
+      cost: 0,
+      // Server will calculate cost based on historical_rates
+      // Only attribute to project if recent or we have stronger evidence (not yet available in core)
+      project: isRecent ? ctx.projectName : "General",
+      project_path: isRecent ? ctx.projectPath : void 0,
+      git_branch: isRecent ? ctx.gitBranch || void 0 : void 0,
+      git_commit_hash: isRecent ? ctx.gitCommitHash || void 0 : void 0,
+      language: ctx.primaryLanguage || void 0,
+      session_id: `loc_${msg.timestamp}`,
+      timestamp: new Date(msg.timestamp).toISOString(),
+      date: new Date(msg.timestamp).toISOString().split("T")[0],
+      agent: msg.agent || void 0
+    });
+  }
+  for (const row of cursorRows) {
+    const isRecent = now - row.timestamp < ATTRIBUTION_THRESHOLD_MS;
+    const idSeed = `cursor-${row.timestamp}-${row.model}-${row.inputWithCacheWrite + row.inputWithoutCacheWrite}-${row.outputTokens}`;
+    const external_id = crypto.createHash("sha256").update(idSeed).digest("hex").slice(0, 36);
+    events.push({
+      external_id,
+      source: "cursor",
+      source_type: row.kind || "chat",
+      model: row.model,
+      provider: "cursor",
+      input_tokens: row.inputWithoutCacheWrite + row.inputWithCacheWrite,
+      output_tokens: row.outputTokens,
+      cache_read: row.cacheRead,
+      cache_write: row.inputWithCacheWrite,
+      reasoning: 0,
+      total_tokens: row.totalTokens || row.inputWithoutCacheWrite + row.inputWithCacheWrite + row.outputTokens,
+      cost: row.costToYou,
+      project: isRecent ? ctx.projectName : "General",
+      session_id: `cur_${row.timestamp}`,
+      timestamp: new Date(row.timestamp).toISOString(),
+      date: row.date
+    });
+  }
+  const payload = {
+    tps_avg: 0,
+    // Not calculated here
+    tps_max: 0,
+    total_input_tokens: 0,
+    // Server aggregates
+    total_output_tokens: 0,
+    total_cache_read: 0,
+    total_cache_write: 0,
+    total_cost: data.summary.totalCost,
+    projects: [{
+      name: ctx.projectName,
+      root_path: ctx.projectPath,
+      // Send root_path for collision fix
+      tokens: data.summary.totalTokens,
+      // Approximate contribution to this batch
+      models: data.summary.models,
+      last_active: (/* @__PURE__ */ new Date()).toISOString()
+    }],
+    events
+  };
+  console.log(pc2.gray("  Submitting to server..."));
+  try {
+    await uploadBatch(payload);
+    console.log(pc2.green("\n  Successfully submitted!"));
+    const baseUrl = getApiBaseUrl();
+    console.log(pc2.cyan(`  View your profile: ${baseUrl}/u/${credentials.username}
+`));
+  } catch (error) {
+    console.error(pc2.red(`
+  Error: Failed to submit data.`));
+    console.error(pc2.gray(`  ${error.message}
+`));
+    process.exit(1);
+  }
+}
+
+// src/utils/version-check.ts
+import pc3 from "picocolors";
+
+// src/utils/pkg.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function getPackageJson() {
+  const paths = [
+    join(__dirname, "../../package.json"),
+    join(__dirname, "../package.json"),
+    join(__dirname, "../../../package.json")
+  ];
+  for (const p of paths) {
+    if (existsSync2(p)) {
+      try {
+        const content = readFileSync2(p, "utf-8");
+        const pkg2 = JSON.parse(content);
+        if (pkg2.name === "agny") {
+          return pkg2;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return { name: "agny", version: "0.0.0" };
+}
+var pkg = getPackageJson();
+
+// src/utils/version-check.ts
+function getCurrentVersion() {
+  return pkg.version || "0.0.0";
+}
+async function getLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    const res = await fetch("https://registry.npmjs.org/agny/latest", {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version || null;
+  } catch {
+    return null;
+  }
+}
+function isNewer(latest, current) {
+  const l = latest.split(".").map(Number);
+  const c = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((l[i] || 0) > (c[i] || 0)) return true;
+    if ((l[i] || 0) < (c[i] || 0)) return false;
+  }
+  return false;
+}
+async function checkForUpdates() {
+  const current = getCurrentVersion();
+  const latest = await getLatestVersion();
+  if (latest && isNewer(latest, current)) {
+    console.log();
+    console.log(
+      pc3.yellow(`  \u26A0\uFE0F  Update available: ${pc3.bold(latest)} (current: ${current})`)
+    );
+    console.log(pc3.dim(`     Run: npm update -g agny`));
+    console.log();
+  }
+}
+
+// src/index.ts
+import pc4 from "picocolors";
+var program = new Command();
+program.name("agny").description("\u{1F525} Track your Brain RPM - The passive hustle tracker for AI-native builders").version(pkg.version);
+program.command("watch").description("Start watching AI tool logs (Cursor, Claude, etc.)").action(async () => {
+  try {
+    await watch();
+  } catch (e) {
+    console.error(pc4.red(`
+  Error: ${e.message}`));
+    process.exit(1);
+  }
+});
+program.command("login").description("Login to agny.log").action(async () => {
+  await login();
+});
+program.command("logout").description("Logout from agny.log").action(async () => {
+  await logout();
+});
+program.command("whoami").description("Check current account").action(async () => {
+  await whoami();
+});
+program.command("submit").description("Manually submit usage data").option("--dry-run", "Show what would be submitted without sending").action(async (options) => {
+  await submit(options);
+});
+program.command("install").description("Install background daemon (auto-start on login)").action(async () => {
+  await install();
+});
+program.command("uninstall").description("Uninstall background daemon").action(async () => {
+  await uninstall();
+});
+program.command("status").description("Check daemon status").action(async () => {
+  await status();
+});
+program.command("daemon-run", { hidden: true }).description("Internal: Run as daemon process").action(async () => {
+  const { runAsDaemon } = await import("./daemon-MNAFMFH4.js");
+  await runAsDaemon();
+});
+var cursorCmd = program.command("cursor").description("Cursor IDE integration");
+cursorCmd.command("login [token]").description("Login to Cursor (get token from cursor.com/settings)").action(async (token) => {
+  if (token) {
+    await cursorLoginWithToken(token);
+  } else {
+    await cursorLogin();
+  }
+});
+cursorCmd.command("sync").description("Sync Cursor usage data from API").action(async () => {
+  await cursorSync();
+});
+cursorCmd.command("status").description("Check Cursor auth and cache status").action(() => {
+  cursorStatus();
+});
+cursorCmd.command("logout").description("Clear Cursor credentials").action(() => {
+  cursorLogout();
+});
+checkForUpdates();
+program.parse();

package/dist/native-runner.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/native-runner.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+// src/native-runner.ts
+import { createRequire } from "module";
+import { readFileSync } from "fs";
+var require2 = createRequire(import.meta.url);
+var nativeCore = require2("../native-loader.cjs");
+async function main() {
+  const inputFile = process.argv[2];
+  if (!inputFile) {
+    process.stderr.write(JSON.stringify({ error: "No input file provided" }));
+    process.exit(1);
+  }
+  const input = readFileSync(inputFile, "utf-8");
+  let request;
+  try {
+    request = JSON.parse(input);
+  } catch (e) {
+    throw new Error(`Malformed JSON input: ${e.message}`);
+  }
+  const { method, args } = request;
+  if (!Array.isArray(args) || args.length === 0) {
+    throw new Error(`Invalid args for method '${method}': expected at least 1 argument`);
+  }
+  let result;
+  switch (method) {
+    case "parseLocalSources":
+      result = nativeCore.parseLocalSources(args[0]);
+      break;
+    case "finalizeReport":
+      result = await nativeCore.finalizeReport(args[0]);
+      break;
+    case "finalizeMonthlyReport":
+      result = await nativeCore.finalizeMonthlyReport(args[0]);
+      break;
+    case "finalizeGraph":
+      result = await nativeCore.finalizeGraph(args[0]);
+      break;
+    case "finalizeReportAndGraph":
+      result = await nativeCore.finalizeReportAndGraph(args[0]);
+      break;
+    default:
+      throw new Error(`Unknown method: ${method}`);
+  }
+  process.stdout.write(JSON.stringify(result));
+}
+main().catch((e) => {
+  const error = e;
+  process.stderr.write(JSON.stringify({
+    error: error.message,
+    stack: error.stack
+  }));
+  process.exit(1);
+});

package/dist/watcher-7NF53ITT.js

@@ -0,0 +1,6 @@
+import {
+  watch
+} from "./chunk-COBQNFEL.js";
+export {
+  watch
+};