@staff0rd/assist 0.1005.0 → 0.1006.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -6,7 +6,7 @@ import { Command } from "commander";
6
6
  // package.json
7
7
  var package_default = {
8
8
  name: "@staff0rd/assist",
9
- version: "0.1005.0",
9
+ version: "0.1006.0",
10
10
  type: "module",
11
11
  main: "dist/index.js",
12
12
  bin: {
@@ -29275,6 +29275,29 @@ async function list3() {
29275
29275
  // src/commands/inbox/scan.ts
29276
29276
  import chalk183 from "chalk";
29277
29277
 
29278
+ // src/shared/formatTokens.ts
29279
+ function formatTokens(n) {
29280
+ if (n < 1e3) return String(n);
29281
+ if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
29282
+ return `${(n / 1e6).toFixed(1)}M`;
29283
+ }
29284
+
29285
+ // src/commands/inbox/formatScanCost.ts
29286
+ function formatScanCost(costUsd) {
29287
+ return `$${costUsd.toFixed(2)}`;
29288
+ }
29289
+
29290
+ // src/commands/inbox/scanUsageTokens.ts
29291
+ function scanUsageTokens(usage) {
29292
+ return usage.input + usage.output + usage.cacheRead + (usage.cacheWrite ?? 0);
29293
+ }
29294
+
29295
+ // src/commands/inbox/formatScanUsage.ts
29296
+ function formatScanUsage(usage) {
29297
+ const tokens = `${formatTokens(scanUsageTokens(usage))} tokens`;
29298
+ return usage.costUsd === null ? tokens : `${tokens} \xB7 ${formatScanCost(usage.costUsd)}`;
29299
+ }
29300
+
29278
29301
  // src/shared/db/upsertInboxMessages.ts
29279
29302
  async function upsertInboxMessages(orm, messages) {
29280
29303
  if (messages.length === 0) return 0;
@@ -29401,6 +29424,77 @@ function assistantScanEvents(content) {
29401
29424
  return content.map(blockEvent).filter((event) => event !== void 0).map((event) => ({ at: at2, ...event }));
29402
29425
  }
29403
29426
 
29427
+ // src/commands/review/parseTokenUsage.ts
29428
+ function count8(value) {
29429
+ return typeof value === "number" ? value : 0;
29430
+ }
29431
+ function parseTokenUsage(usage, keys) {
29432
+ if (typeof usage !== "object" || usage === null) return void 0;
29433
+ const raw = usage;
29434
+ const parsed = {
29435
+ input: count8(raw.input_tokens),
29436
+ output: count8(raw.output_tokens),
29437
+ cacheRead: count8(raw[keys.cacheRead])
29438
+ };
29439
+ if (keys.cacheWrite) parsed.cacheWrite = count8(raw[keys.cacheWrite]);
29440
+ return parsed;
29441
+ }
29442
+
29443
+ // src/commands/review/parseClaudeUsage.ts
29444
+ function parseClaudeUsage(usage) {
29445
+ return parseTokenUsage(usage, {
29446
+ cacheRead: "cache_read_input_tokens",
29447
+ cacheWrite: "cache_creation_input_tokens"
29448
+ });
29449
+ }
29450
+
29451
+ // src/commands/inbox/emptyScanUsage.ts
29452
+ function emptyScanUsage() {
29453
+ return {
29454
+ input: 0,
29455
+ output: 0,
29456
+ cacheRead: 0,
29457
+ cacheWrite: 0,
29458
+ costUsd: null,
29459
+ durationMs: null
29460
+ };
29461
+ }
29462
+
29463
+ // src/commands/inbox/createScanUsageTracker.ts
29464
+ var numberOrNull = (value) => typeof value === "number" ? value : null;
29465
+ function createScanUsageTracker() {
29466
+ const usage = emptyScanUsage();
29467
+ const turns = /* @__PURE__ */ new Map();
29468
+ let unsettled = 0;
29469
+ return {
29470
+ current: () => ({ ...usage }),
29471
+ // stream-json repeats a message's usage on every content-block line, so
29472
+ // each turn is counted once by message id, applying only the change.
29473
+ addTurn(id, raw) {
29474
+ const parsed = parseClaudeUsage(raw);
29475
+ if (!parsed) return false;
29476
+ const key = typeof id === "string" ? id : `turn-${turns.size}`;
29477
+ const previous = turns.get(key);
29478
+ turns.set(key, parsed);
29479
+ usage.input += parsed.input - (previous?.input ?? 0);
29480
+ usage.output += parsed.output - (previous?.output ?? 0);
29481
+ usage.cacheRead += parsed.cacheRead - (previous?.cacheRead ?? 0);
29482
+ usage.cacheWrite += (parsed.cacheWrite ?? 0) - (previous?.cacheWrite ?? 0);
29483
+ unsettled += scanUsageTokens(parsed) - (previous ? scanUsageTokens(previous) : 0);
29484
+ return true;
29485
+ },
29486
+ takeTurnTokens() {
29487
+ const tokens = unsettled;
29488
+ unsettled = 0;
29489
+ return tokens > 0 ? tokens : void 0;
29490
+ },
29491
+ finish(result) {
29492
+ usage.costUsd = numberOrNull(result.total_cost_usd);
29493
+ usage.durationMs = numberOrNull(result.duration_ms);
29494
+ }
29495
+ };
29496
+ }
29497
+
29404
29498
  // src/commands/inbox/inboxScanSchema.ts
29405
29499
  import { z as z14 } from "zod";
29406
29500
  var flaggedMessageSchema = z14.object({
@@ -29424,8 +29518,22 @@ function parseInboxScanOutput(stdout) {
29424
29518
  }
29425
29519
 
29426
29520
  // src/commands/inbox/createInboxScanParser.ts
29427
- function createInboxScanParser(onEvent) {
29521
+ function createInboxScanParser({
29522
+ onEvent = () => {
29523
+ },
29524
+ onUsage = () => {
29525
+ }
29526
+ } = {}) {
29527
+ const usage = createScanUsageTracker();
29428
29528
  let resultLine;
29529
+ const onAssistant = (message3) => {
29530
+ const counted = usage.addTurn(message3?.id, message3?.usage);
29531
+ for (const scanEvent of assistantScanEvents(message3?.content)) {
29532
+ const tokens = usage.takeTurnTokens();
29533
+ onEvent(tokens === void 0 ? scanEvent : { ...scanEvent, tokens });
29534
+ }
29535
+ if (counted) onUsage(usage.current());
29536
+ };
29429
29537
  return {
29430
29538
  onLine(line) {
29431
29539
  let event;
@@ -29434,14 +29542,19 @@ function createInboxScanParser(onEvent) {
29434
29542
  } catch {
29435
29543
  return;
29436
29544
  }
29437
- if (event.type === "assistant")
29438
- for (const scanEvent of assistantScanEvents(event.message?.content))
29439
- onEvent(scanEvent);
29440
- else if (event.type === "result") resultLine = line;
29545
+ if (event.type === "assistant") onAssistant(event.message);
29546
+ else if (event.type === "result") {
29547
+ resultLine = line;
29548
+ usage.finish(event);
29549
+ onUsage(usage.current());
29550
+ }
29441
29551
  },
29442
29552
  finish(failure) {
29443
29553
  if (!resultLine) throw new Error(`Inbox scan failed: ${failure}`);
29444
- return parseInboxScanOutput(resultLine);
29554
+ return {
29555
+ messages: parseInboxScanOutput(resultLine),
29556
+ usage: usage.current()
29557
+ };
29445
29558
  }
29446
29559
  };
29447
29560
  }
@@ -29520,14 +29633,13 @@ function buildInboxScanArgs(since) {
29520
29633
  function describeExit(code, signal) {
29521
29634
  return signal ? `claude was killed (${signal})` : `claude exited ${code}`;
29522
29635
  }
29523
- async function runInboxScanClaude(since, onEvent = () => {
29524
- }) {
29636
+ async function runInboxScanClaude(since, listener = {}) {
29525
29637
  const child = spawn6("claude", buildInboxScanArgs(since), {
29526
29638
  stdio: ["ignore", "pipe", "pipe"],
29527
29639
  windowsHide: true,
29528
29640
  timeout: 20 * 6e4
29529
29641
  });
29530
- const parser = createInboxScanParser(onEvent);
29642
+ const parser = createInboxScanParser(listener);
29531
29643
  const flush = attachLineParser(child, parser.onLine);
29532
29644
  const stderr = attachStderrCollector(child);
29533
29645
  const exit = await new Promise((resolve32, reject) => {
@@ -29552,25 +29664,28 @@ function toRow2(message3) {
29552
29664
  receivedAt: receivedAt && !Number.isNaN(receivedAt.getTime()) ? receivedAt : null
29553
29665
  };
29554
29666
  }
29555
- async function runInboxScan(orm, { wrap = (_since, run4) => run4(), onEvent } = {}) {
29667
+ async function runInboxScan(orm, { wrap = (_since, run4) => run4(), ...listener } = {}) {
29556
29668
  const startedAt = /* @__PURE__ */ new Date();
29557
29669
  const since = await readInboxLastScan(orm) ?? new Date(startedAt.getTime() - FIRST_SCAN_LOOKBACK_MS);
29558
- const flagged = await wrap(since, () => runInboxScanClaude(since, onEvent));
29559
- const added = await upsertInboxMessages(orm, flagged.map(toRow2));
29670
+ const { messages, usage } = await wrap(
29671
+ since,
29672
+ () => runInboxScanClaude(since, listener)
29673
+ );
29674
+ const added = await upsertInboxMessages(orm, messages.map(toRow2));
29560
29675
  await writeInboxLastScan(orm, startedAt);
29561
- return { flagged: flagged.length, added };
29676
+ return { flagged: messages.length, added, usage };
29562
29677
  }
29563
29678
 
29564
29679
  // src/commands/inbox/scan.ts
29565
29680
  async function scan() {
29566
- const { flagged, added } = await runInboxScan(await getDb(), {
29681
+ const { flagged, added, usage } = await runInboxScan(await getDb(), {
29567
29682
  wrap: (since, run4) => withSpinner(
29568
29683
  `Scanning Gmail and Slack (Slack since ${since.toISOString()})`,
29569
29684
  run4
29570
29685
  )
29571
29686
  });
29572
29687
  console.log(
29573
- `Flagged ${flagged} message(s) needing a reply, ${chalk183.bold(added)} new.`
29688
+ `Flagged ${flagged} message(s) needing a reply, ${chalk183.bold(added)} new. ${chalk183.dim(formatScanUsage(usage))}`
29574
29689
  );
29575
29690
  }
29576
29691
 
@@ -40881,30 +40996,6 @@ function simplifyShellCommand(command) {
40881
40996
  return truncate3(inner);
40882
40997
  }
40883
40998
 
40884
- // src/commands/review/parseTokenUsage.ts
40885
- function count8(value) {
40886
- return typeof value === "number" ? value : 0;
40887
- }
40888
- function parseTokenUsage(usage, keys) {
40889
- if (typeof usage !== "object" || usage === null) return void 0;
40890
- const raw = usage;
40891
- const parsed = {
40892
- input: count8(raw.input_tokens),
40893
- output: count8(raw.output_tokens),
40894
- cacheRead: count8(raw[keys.cacheRead])
40895
- };
40896
- if (keys.cacheWrite) parsed.cacheWrite = count8(raw[keys.cacheWrite]);
40897
- return parsed;
40898
- }
40899
-
40900
- // src/commands/review/parseClaudeUsage.ts
40901
- function parseClaudeUsage(usage) {
40902
- return parseTokenUsage(usage, {
40903
- cacheRead: "cache_read_input_tokens",
40904
- cacheWrite: "cache_creation_input_tokens"
40905
- });
40906
- }
40907
-
40908
40999
  // src/commands/review/parseClaudeEvent.ts
40909
41000
  function isAssistantEvent(value) {
40910
41001
  return typeof value === "object" && value !== null && value.type === "assistant";
@@ -47127,6 +47218,24 @@ function createAutoExit(exit, graceMs = DEFAULT_GRACE_MS) {
47127
47218
  };
47128
47219
  }
47129
47220
 
47221
+ // src/commands/sessions/daemon/inbox/createActivityThrottle.ts
47222
+ var ACTIVITY_THROTTLE_MS = 1e3;
47223
+ function createActivityThrottle(onActivity) {
47224
+ let pending;
47225
+ return {
47226
+ schedule() {
47227
+ pending ??= setTimeout(() => {
47228
+ pending = void 0;
47229
+ onActivity();
47230
+ }, ACTIVITY_THROTTLE_MS);
47231
+ },
47232
+ cancel() {
47233
+ clearTimeout(pending);
47234
+ pending = void 0;
47235
+ }
47236
+ };
47237
+ }
47238
+
47130
47239
  // src/shared/db/readInboxLastRun.ts
47131
47240
  import { eq as eq51 } from "drizzle-orm";
47132
47241
  var INBOX_LAST_RUN_KEY = "inbox.lastRun";
@@ -47177,15 +47286,10 @@ async function saveScanRun(run4) {
47177
47286
  }
47178
47287
 
47179
47288
  // src/commands/sessions/daemon/inbox/createScanRunLog.ts
47180
- var ACTIVITY_THROTTLE_MS = 1e3;
47181
47289
  var MAX_EVENTS = 1e3;
47182
47290
  function createScanRunLog(onActivity) {
47183
47291
  let run4;
47184
- let pending;
47185
- const flush = () => {
47186
- pending = void 0;
47187
- onActivity();
47188
- };
47292
+ const throttle = createActivityThrottle(onActivity);
47189
47293
  return {
47190
47294
  current: () => run4,
47191
47295
  begin() {
@@ -47193,17 +47297,22 @@ function createScanRunLog(onActivity) {
47193
47297
  status: "scanning",
47194
47298
  startedAt: (/* @__PURE__ */ new Date()).toISOString(),
47195
47299
  finishedAt: null,
47196
- events: []
47300
+ events: [],
47301
+ usage: emptyScanUsage()
47197
47302
  };
47198
47303
  },
47199
- add(event) {
47304
+ onEvent(event) {
47200
47305
  if (!run4 || run4.events.length >= MAX_EVENTS) return;
47201
47306
  run4.events.push(event);
47202
- pending ??= setTimeout(flush, ACTIVITY_THROTTLE_MS);
47307
+ throttle.schedule();
47308
+ },
47309
+ onUsage(usage) {
47310
+ if (!run4) return;
47311
+ run4.usage = usage;
47312
+ throttle.schedule();
47203
47313
  },
47204
47314
  async end(outcome) {
47205
- clearTimeout(pending);
47206
- pending = void 0;
47315
+ throttle.cancel();
47207
47316
  if (!run4) return;
47208
47317
  run4.events.push(outcomeEvent(outcome));
47209
47318
  run4.status = outcome.ok ? "finished" : "failed";
@@ -47275,11 +47384,16 @@ async function isScheduledScanDue(intervalMinutes) {
47275
47384
  }
47276
47385
 
47277
47386
  // src/commands/sessions/daemon/inbox/runLoggedInboxScan.ts
47278
- async function runLoggedInboxScan(reason4, onEvent) {
47387
+ async function runLoggedInboxScan(reason4, listener) {
47279
47388
  daemonLog(`inbox: scan started (${reason4})`);
47280
47389
  try {
47281
- const { flagged, added } = await runInboxScan(await getDb(), { onEvent });
47282
- daemonLog(`inbox: scan flagged ${flagged} message(s), ${added} new`);
47390
+ const { flagged, added, usage } = await runInboxScan(
47391
+ await getDb(),
47392
+ listener
47393
+ );
47394
+ daemonLog(
47395
+ `inbox: scan flagged ${flagged} message(s), ${added} new (${formatScanUsage(usage)})`
47396
+ );
47283
47397
  return { ok: true, flagged, added };
47284
47398
  } catch (error) {
47285
47399
  const message3 = error instanceof Error ? error.message : String(error);
@@ -47301,7 +47415,7 @@ function createInboxScanner() {
47301
47415
  scanning = true;
47302
47416
  runLog.begin();
47303
47417
  notify2("inbox");
47304
- const outcome = await runLoggedInboxScan(reason4, runLog.add);
47418
+ const outcome = await runLoggedInboxScan(reason4, runLog);
47305
47419
  lastError = outcome.ok ? void 0 : outcome.error;
47306
47420
  await runLog.end(outcome);
47307
47421
  scanning = false;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@staff0rd/assist",
3
- "version": "0.1005.0",
3
+ "version": "0.1006.0",
4
4
  "type": "module",
5
5
  "main": "dist/index.js",
6
6
  "bin": {