portable-agent-layer 0.99.2 → 0.101.0

package/src/tools/lib/wrapped/render.ts

@@ -0,0 +1,145 @@
+import { labelOfRuntime } from "../../../hooks/lib/agent-registry";
+import type { CostTotals } from "../cost-report";
+import { fmtDuration } from "../session-usage";
+import { fmtCost } from "../token-report";
+import type { RuntimeCost, WrappedAgents } from "./agents";
+import type { WrappedHabits } from "./habits";
+import type { SkillsNeverUsed, WrappedPal } from "./pal";
+import type { Best, WrappedRecords } from "./records";
+import type { WrappedTotals } from "./totals";
+import type { Tally } from "./year";
+
+const count = (n: number) => n.toLocaleString("en-US");
+
+function row(label: string, value: string): string {
+  return `    ${label.padEnd(20)} ${value}`;
+}
+
+function recordRow(
+  label: string,
+  record: Best | null,
+  format: (value: number) => string
+): string {
+  const value =
+    record === null ? "unknown" : `${format(record.value)}  (${record.label})`;
+  return `    ${label.padEnd(36)} ${value}`;
+}
+
+const days = (n: number) => `${count(n)} ${n === 1 ? "day" : "days"}`;
+
+export function recordsLines(records: WrappedRecords): string[] {
+  return [
+    "\n  Records\n",
+    recordRow(
+      "most projects registered in a day",
+      records.projectsRegisteredInADay,
+      count
+    ),
+    recordRow("most commits in a day", records.commitsInADay, count),
+    recordRow("longest project", records.longestProject, days),
+    recordRow("longest streak", records.longestStreak, days),
+    recordRow("longest agent-alone run", records.longestAgentRun, (sec) =>
+      fmtDuration(sec * 1000)
+    ),
+    recordRow("most expensive turn", records.mostExpensiveTurn, fmtCost),
+    recordRow(
+      "biggest tool burst",
+      records.biggestToolBurst,
+      (n) => `${count(n)} tool calls`
+    ),
+  ];
+}
+
+const percent = (share: number | null) =>
+  share === null ? "unknown" : `${Math.round(share * 100)}%`;
+
+function tallyLabel(tallies: Tally[]): string {
+  if (tallies.length === 0) return "unknown";
+  return tallies.map((t) => `${t.name} ${count(t.count)}`).join(" · ");
+}
+
+export function habitsLines(habits: WrappedHabits): string[] {
+  const hour = habits.mostActiveHour;
+  return [
+    "\n  Habits\n",
+    row(
+      "most active hour",
+      hour === null ? "unknown" : `${hour.label}  (active on ${days(hour.value)})`
+    ),
+    row("at night (22-06)", percent(habits.nightShare)),
+    row("on weekends", percent(habits.weekendShare)),
+    row("messages by channel", tallyLabel(habits.channels)),
+    row("skimmed replies", percent(habits.skimRate)),
+    row("corrections", percent(habits.correctionRate)),
+  ];
+}
+
+function neverUsedLines(never: SkillsNeverUsed | null): string[] {
+  if (never === null) return [row("skills never used", "unknown")];
+  const summary = `${count(never.names.length)} of ${count(never.installed)} since ${never.since}`;
+  const names = never.names.length > 0 ? [row("", never.names.join(", "))] : [];
+  return [row("skills never used", summary), ...names];
+}
+
+/** Nothing logs a steering rule being approved yet. */
+export function palLines(pal: WrappedPal): string[] {
+  const onTime = pal.promisesOnTime;
+  return [
+    "\n  PAL\n",
+    row("skills used", tallyLabel(pal.skillsUsed)),
+    ...neverUsedLines(pal.skillsNeverUsed),
+    row("rules approved", "unknown"),
+    row(
+      "promises on time",
+      onTime === null ? "unknown" : `${count(onTime)} of ${count(pal.promisesKept)}`
+    ),
+  ];
+}
+
+function tokensLabel(totals: WrappedTotals): string {
+  const unknown = totals.callsWithoutTokens;
+  return unknown > 0
+    ? `${count(totals.tokens)} + ${count(unknown)} calls without counts`
+    : count(totals.tokens);
+}
+
+function apiEquivalentLabel(cost: CostTotals): string {
+  const priced = fmtCost(cost.apiEquivalent);
+  return cost.unpriced > 0
+    ? `${priced} + ${count(cost.unpriced)} unpriced calls`
+    : priced;
+}
+
+const paidLabel = (paid: number | null) => (paid === null ? "unknown" : fmtCost(paid));
+
+function runtimeCostLabel({ runtime, calls, cost }: RuntimeCost): string {
+  const api = cost.unpriced === calls ? "unknown" : apiEquivalentLabel(cost);
+  return `${labelOfRuntime(runtime)}  API-equivalent ${api}, paid ${paidLabel(cost.paid)}`;
+}
+
+const labelled = (tallies: Tally[]) =>
+  tallies.map((t) => ({ ...t, name: labelOfRuntime(t.name) }));
+
+/** No agent reports which of Cursor's lines a human typed yet. */
+export function agentsLines(agents: WrappedAgents): string[] {
+  const [first, ...rest] = agents.costs.map(runtimeCostLabel);
+  return [
+    "\n  Agents\n",
+    row("messages by agent", tallyLabel(labelled(agents.messages))),
+    row("cost by agent", first ?? "unknown"),
+    ...rest.map((label) => row("", label)),
+    row("Cursor human vs AI", "unknown"),
+  ];
+}
+
+export function totalsLines(totals: WrappedTotals): string[] {
+  return [
+    "\n  Totals\n",
+    row("projects", count(totals.projects)),
+    row("sessions", count(totals.sessions)),
+    row("commits", count(totals.commits)),
+    row("tokens", tokensLabel(totals)),
+    row("API-equivalent", apiEquivalentLabel(totals.cost)),
+    row("paid", paidLabel(totals.cost.paid)),
+  ];
+}

package/src/tools/lib/wrapped/totals.ts

@@ -0,0 +1,55 @@
+import type { LoggedEvent } from "../../../hooks/lib/events";
+import { type CostTotals, costMonths, costTotals } from "../cost-report";
+import { numberOf, ofType } from "./year";
+
+export interface WrappedTotals {
+  projects: number;
+  sessions: number;
+  commits: number;
+  tokens: number;
+  callsWithoutTokens: number;
+  cost: CostTotals;
+}
+
+const TOKEN_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "cacheWrite5m",
+  "cacheWrite1h",
+  "cacheRead",
+] as const;
+
+function tokensOf(call: LoggedEvent): number | null {
+  const known = TOKEN_FIELDS.map((f) => numberOf(call[f])).filter((n) => n !== null);
+  return known.length === 0 ? null : known.reduce((sum, n) => sum + n, 0);
+}
+
+function distinct(values: (string | null)[]): number {
+  return new Set(values.filter((v) => v !== null)).size;
+}
+
+const isSpawnedCall = (e: LoggedEvent) =>
+  e.type === "model_call" && e.entrypoint === "sdk-cli";
+
+const showsTheUser = (e: LoggedEvent) =>
+  e.type === "turn" || (e.type === "model_call" && !isSpawnedCall(e));
+
+/** PAL's own background inference runs as SDK sessions nobody typed into. */
+function sessionsOfTheUser(events: LoggedEvent[]): number {
+  const spawned = new Set(events.filter(isSpawnedCall).map((e) => e.session));
+  for (const e of events.filter(showsTheUser)) spawned.delete(e.session);
+  return distinct(events.map((e) => e.session).filter((s) => !spawned.has(s)));
+}
+
+export function wrappedTotals(events: LoggedEvent[]): WrappedTotals {
+  const calls = ofType(events, "model_call");
+  const tokens = calls.map(tokensOf);
+  return {
+    projects: distinct(events.map((e) => e.project)),
+    sessions: sessionsOfTheUser(events),
+    commits: ofType(events, "commit").length,
+    tokens: tokens.reduce<number>((sum, n) => sum + (n ?? 0), 0),
+    callsWithoutTokens: tokens.filter((n) => n === null).length,
+    cost: costTotals(costMonths(calls)),
+  };
+}

package/src/tools/lib/wrapped/year.ts

@@ -0,0 +1,45 @@
+import {
+  allEventsSince,
+  type EventType,
+  type LoggedEvent,
+} from "../../../hooks/lib/events";
+import { localDay } from "../../../hooks/lib/wall-clock";
+
+export function dayOf(event: LoggedEvent): string {
+  return localDay(new Date(event.ts));
+}
+
+export function ofType(events: LoggedEvent[], type: EventType): LoggedEvent[] {
+  return events.filter((e) => e.type === type);
+}
+
+export const isUserActivity = (e: LoggedEvent) =>
+  e.type === "commit" ||
+  e.type === "turn" ||
+  (e.type === "model_call" && e.entrypoint !== "sdk-cli");
+
+export interface Tally {
+  name: string;
+  count: number;
+}
+
+/** Most frequent first, ties by name. */
+export function tally<T>(items: T[], nameOf: (item: T) => string): Tally[] {
+  const counts = new Map<string, number>();
+  for (const item of items) {
+    const name = nameOf(item);
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  return [...counts]
+    .map(([name, count]) => ({ name, count }))
+    .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+}
+
+export function numberOf(value: unknown): number | null {
+  return typeof value === "number" ? value : null;
+}
+
+export function eventsOfYear(year: number): LoggedEvent[] {
+  const dayBeforeInUtc = new Date(Date.UTC(year - 1, 11, 31));
+  return allEventsSince(dayBeforeInUtc).filter((e) => dayOf(e).startsWith(`${year}-`));
+}

package/src/tools/self-model.ts

@@ -19,7 +19,6 @@ import { copyFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { inference } from "../hooks/lib/inference";
-import { SONNET_MODEL } from "../hooks/lib/models";
 import { ensureDir, paths } from "../hooks/lib/paths";
 import { identity as loadSettingsIdentity } from "../hooks/lib/settings";
 import { logTokenUsage } from "../hooks/lib/token-usage";
@@ -90,7 +89,7 @@ async function composeSelfModel(days: number): Promise<string> {
     caller: "self-model",
   });
 
-  if (result.usage) logTokenUsage("self-model", result.usage, SONNET_MODEL);
+  logTokenUsage("self-model", result);
   if (result.success && result.output) {
     return result.output.trimEnd() + metaFooter(data);
   }