@selesai/code 0.9.15 → 0.10.0

package/dist/extensions/pi-powerline-footer/tests/token-stats.test.ts

@@ -1,249 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { computeSessionTokenStats, SessionBranchCache, SessionTokenStatsCache } from "../token-stats.ts";
-
-function makeUsage(input: number, output: number, cacheRead = 0, cacheWrite = 0, costPerToken = 0.001) {
-  return {
-    input,
-    output,
-    cacheRead,
-    cacheWrite,
-    cost: { total: (input + output + cacheRead + cacheWrite) * costPerToken },
-  };
-}
-
-function assistantEvent(usage: ReturnType<typeof makeUsage>, stopReason: string = "stop") {
-  return {
-    type: "message",
-    message: {
-      role: "assistant",
-      content: [{ type: "text", text: "hi" }],
-      usage,
-      stopReason,
-    },
-  };
-}
-
-function userEvent() {
-  return {
-    type: "message",
-    message: { role: "user", content: [{ type: "text", text: "hello" }] },
-  };
-}
-
-function subagentToolResultEvent(costs: number[]) {
-  return {
-    type: "message",
-    message: {
-      role: "toolResult",
-      toolName: "subagent",
-      details: { results: costs.map((cost) => ({ usage: { cost } })) },
-    },
-  };
-}
-
-function subagentSlashResultEvent(costs: number[]) {
-  return {
-    type: "custom_message",
-    customType: "subagent-slash-result",
-    details: { result: { details: { results: costs.map((cost) => ({ usage: { cost } })) } } },
-  };
-}
-
-test("session branch cache reuses a leaf path and refreshes when the leaf changes", () => {
-  const cache = new SessionBranchCache();
-  let leafId = "leaf-1";
-  let branch: unknown[] = [{ id: leafId, value: 1 }];
-  let branchReads = 0;
-  const provider = {
-    getLeafId: () => leafId,
-    getBranch: () => {
-      branchReads += 1;
-      return branch;
-    },
-  };
-
-  assert.deepEqual(cache.get(null), []);
-
-  const first = cache.get(provider);
-  (branch[0] as { value: number }).value = 2;
-  assert.equal(cache.get(provider), first);
-  assert.equal((cache.get(provider)[0] as { value: number }).value, 2);
-  assert.equal(branchReads, 1);
-
-  leafId = "leaf-2";
-  branch = [...branch, { id: leafId }];
-  assert.equal(cache.get(provider), branch);
-  assert.equal(branchReads, 2);
-
-  cache.reset();
-  cache.get(provider);
-  assert.equal(branchReads, 3);
-});
-
-test("computeSessionTokenStats aggregates usage and tracks thinking level", () => {
-  const events = [
-    userEvent(),
-    { type: "thinking_level_change", thinkingLevel: "high" },
-    assistantEvent(makeUsage(10, 5)),
-    assistantEvent(makeUsage(20, 7, 3, 2), "error"), // skipped: error
-    assistantEvent(makeUsage(30, 9, 4, 1), "aborted"), // skipped: aborted
-    assistantEvent(makeUsage(40, 11, 6, 2)),
-  ];
-
-  const stats = computeSessionTokenStats(events);
-
-  assert.equal(stats.input, 50);
-  assert.equal(stats.output, 16);
-  assert.equal(stats.cacheRead, 6);
-  assert.equal(stats.cacheWrite, 2);
-  assert.ok(Math.abs(stats.cost - 0.074) < 1e-12);
-  assert.equal(stats.lastAssistant, (events[5] as any).message);
-  assert.equal(stats.thinkingLevelFromSession, "high");
-});
-
-test("computeSessionTokenStats sums subagent child run cost from tool results and slash results", () => {
-  const events = [
-    userEvent(),
-    assistantEvent(makeUsage(10, 5)),
-    subagentToolResultEvent([0.12, 0.34]),
-    subagentSlashResultEvent([0.5]),
-  ];
-
-  const stats = computeSessionTokenStats(events);
-  assert.ok(Math.abs(stats.subagentCost - 0.96) < 1e-12);
-});
-
-test("computeSessionTokenStats ignores assistant messages without tokens for lastAssistant", () => {
-  const events = [
-    assistantEvent(makeUsage(10, 5)),
-    assistantEvent(makeUsage(0, 0)),
-  ];
-
-  const stats = computeSessionTokenStats(events);
-  assert.equal(stats.lastAssistant, (events[0] as any).message);
-});
-
-test("cache reuses stats object while session is unchanged", () => {
-  const cache = new SessionTokenStatsCache();
-  const events = [userEvent(), assistantEvent(makeUsage(10, 5))];
-
-  const first = cache.get(events);
-  const second = cache.get(events);
-
-  assert.equal(second, first);
-});
-
-test("cache recomputes when events are appended", () => {
-  const cache = new SessionTokenStatsCache();
-  const events = [assistantEvent(makeUsage(10, 5))];
-
-  const first = cache.get(events);
-  events.push(assistantEvent(makeUsage(20, 7)));
-  const second = cache.get(events);
-
-  assert.notEqual(second, first);
-  assert.equal(second.input, 30);
-  assert.equal(second.output, 12);
-});
-
-test("cache recomputes when the last event is updated in place (streaming)", () => {
-  const cache = new SessionTokenStatsCache();
-  const tail = assistantEvent(makeUsage(10, 5), "streaming");
-  const events = [userEvent(), tail];
-
-  const first = cache.get(events);
-  assert.equal(first.output, 5);
-
-  // Streaming updates the trailing assistant message in place: same event
-  // count, same object references, fresh usage numbers.
-  tail.message.usage = makeUsage(10, 42);
-  tail.message.stopReason = "stop";
-
-  const second = cache.get(events);
-  assert.notEqual(second, first);
-  assert.equal(second.output, 42);
-  assert.equal(second.lastAssistant, tail.message);
-});
-
-test("cache recomputes when the last subagent result cost is updated in place", () => {
-  const cache = new SessionTokenStatsCache();
-  const tail = subagentToolResultEvent([0.1]);
-  const events = [assistantEvent(makeUsage(10, 5)), tail];
-
-  const first = cache.get(events);
-  assert.equal(first.subagentCost, 0.1);
-
-  tail.message.details.results = [{ usage: { cost: 0.3 } }];
-
-  const second = cache.get(events);
-  assert.notEqual(second, first);
-  assert.equal(second.subagentCost, 0.3);
-});
-
-test("cache recomputes when the last event turns into an error in place", () => {
-  const cache = new SessionTokenStatsCache();
-  const tail = assistantEvent(makeUsage(10, 5));
-  const events = [assistantEvent(makeUsage(1, 1)), tail];
-
-  const first = cache.get(events);
-  assert.equal(first.input, 11);
-
-  tail.message.stopReason = "error";
-
-  const second = cache.get(events);
-  assert.notEqual(second, first);
-  assert.equal(second.input, 1);
-});
-
-test("cache recomputes when the last event is replaced with a same-sized list", () => {
-  const cache = new SessionTokenStatsCache();
-  const events = [userEvent(), assistantEvent(makeUsage(10, 5))];
-
-  const first = cache.get(events);
-  events[1] = assistantEvent(makeUsage(10, 5));
-  const second = cache.get(events);
-
-  assert.notEqual(second, first);
-  assert.deepEqual(
-    { input: second.input, output: second.output },
-    { input: first.input, output: first.output },
-  );
-});
-
-test("cache does not rescan for in-place changes to non-trailing events", () => {
-  const cache = new SessionTokenStatsCache();
-  const head = assistantEvent(makeUsage(10, 5));
-  const events = [head, assistantEvent(makeUsage(20, 7))];
-
-  const first = cache.get(events);
-
-  // Historical events are treated as immutable; only the trailing event is
-  // re-validated. This documents the cache's correctness boundary.
-  head.message.usage = makeUsage(999, 999);
-  const second = cache.get(events);
-
-  assert.equal(second, first);
-  assert.equal(second.input, 30);
-});
-
-test("reset forces recomputation", () => {
-  const cache = new SessionTokenStatsCache();
-  const events = [assistantEvent(makeUsage(10, 5))];
-
-  const first = cache.get(events);
-  cache.reset();
-  const second = cache.get(events);
-
-  assert.notEqual(second, first);
-  assert.equal(second.input, first.input);
-});
-
-test("index.ts wires the token stats cache into buildSegmentContext", () => {
-  const source = readFileSync(new URL("../index.ts", import.meta.url), "utf-8");
-  assert.match(source, /import \{ SessionBranchCache, SessionTokenStatsCache \} from "\.\/token-stats\.ts";/);
-  assert.match(source, /sessionBranchCache\.get\(ctx\.sessionManager\)/);
-  assert.match(source, /tokenStatsCache\.get\(sessionEvents\)/);
-  assert.match(source, /tokenStatsCache\.reset\(\)/);
-});

package/dist/extensions/pi-powerline-footer/tests/tps.test.ts

@@ -1,39 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { calculateReliableTps, type TpsTiming } from "../tps.ts";
-
-function timing(overrides: Partial<TpsTiming> = {}): TpsTiming {
-	return {
-		messageStartMs: 0,
-		lastUpdateMs: 350,
-		firstTokenMs: 100,
-		updateCount: 5,
-		firstStreamUpdateMs: 150,
-		lastStreamUpdateMs: 350,
-		stallMs: 0,
-		generationMs: 400,
-		...overrides,
-	};
-}
-
-test("calculateReliableTps uses active stream time for sufficiently sampled output", () => {
-	assert.deepEqual(calculateReliableTps(100, timing()), {
-		tps: 500,
-		effectiveMs: 200,
-		isPrimary: true,
-	});
-});
-
-test("calculateReliableTps falls back around stalls and rejects implausible samples", () => {
-	assert.deepEqual(calculateReliableTps(100, timing({ updateCount: 2, firstStreamUpdateMs: 150, lastStreamUpdateMs: 250, generationMs: 500 })), {
-		tps: 200,
-		effectiveMs: 500,
-		isPrimary: false,
-	});
-	assert.deepEqual(calculateReliableTps(100, timing({ stallMs: 100 })), {
-		tps: 333.3,
-		effectiveMs: 300,
-		isPrimary: false,
-	});
-	assert.equal(calculateReliableTps(10_001, timing()), null);
-});

package/dist/extensions/pi-powerline-footer/tests/usage-display.test.ts

@@ -1,237 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { renderSegment } from "../segments.ts";
-import { mergeSegmentOptions, parsePowerlineConfig } from "../powerline-config.ts";
-import type { SegmentContext, StatusLineSegmentOptions } from "../types.ts";
-
-const PRESET_NAMES = ["default", "compact"];
-
-const originalNerdFonts = process.env.POWERLINE_NERD_FONTS;
-process.env.POWERLINE_NERD_FONTS = "0";
-
-test.after(() => {
-  if (originalNerdFonts === undefined) {
-    delete process.env.POWERLINE_NERD_FONTS;
-  } else {
-    process.env.POWERLINE_NERD_FONTS = originalNerdFonts;
-  }
-});
-
-function stripAnsi(text: string): string {
-  return text.replace(/\x1b\[[0-9;]*m/g, "");
-}
-
-function plainTheme(): any {
-  return {
-    fg: (_color: string, text: string) => text,
-    bg: (_color: string, text: string) => text,
-    bold: (text: string) => text,
-  };
-}
-
-function createSegmentContext(options: StatusLineSegmentOptions = {}, overrides: Partial<SegmentContext> = {}): SegmentContext {
-  return {
-    model: undefined,
-    thinkingLevel: "off",
-    sessionId: undefined,
-    usageStats: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, subagentCost: 0 },
-    contextTokens: 0,
-    contextPercent: 0,
-    contextWindow: 0,
-    contextApproximate: false,
-    autoCompactEnabled: true,
-    customCompactionEnabled: false,
-    usingSubscription: false,
-    queueSummary: { queueCount: 0, blockedCount: 0, compacting: false, leadingText: null, leadingIntent: null, leadingStatus: null },
-    sessionStartTime: Date.now(),
-    shellModeActive: false,
-    shellRunning: false,
-    shellName: null,
-    shellCwd: null,
-    git: { branch: null, staged: 0, unstaged: 0, untracked: 0 },
-    extensionStatuses: new Map(),
-    hiddenExtensionStatusKeys: new Set(),
-    customItemsById: new Map(),
-    options,
-    theme: plainTheme(),
-    colors: {},
-    ...overrides,
-  };
-}
-
-// ── context_pct format ──────────────────────────────────────────────────────
-
-test("context_pct defaults to the full tokens/window rendering", () => {
-  const ctx = createSegmentContext({}, {
-    contextTokens: 12300,
-    contextWindow: 200000,
-    contextPercent: 6.15,
-  });
-
-  const rendered = renderSegment("context_pct", ctx);
-  assert.equal(stripAnsi(rendered.content), "12k/200k (6.2%)");
-});
-
-test("context_pct percent format renders a bare rounded percentage", () => {
-  const ctx = createSegmentContext({ context: { format: "percent" } }, {
-    contextTokens: 12300,
-    contextWindow: 200000,
-    contextPercent: 6.15,
-  });
-
-  const rendered = renderSegment("context_pct", ctx);
-  assert.equal(stripAnsi(rendered.content), "6%");
-});
-
-test("context_pct renders unknown usage after compaction", () => {
-  const full = createSegmentContext({}, {
-    contextTokens: null,
-    contextWindow: 200000,
-    contextPercent: null,
-  });
-  const percent = createSegmentContext({ context: { format: "percent" } }, {
-    contextTokens: null,
-    contextWindow: 200000,
-    contextPercent: null,
-  });
-
-  assert.equal(stripAnsi(renderSegment("context_pct", full).content), "?/200k");
-  assert.equal(stripAnsi(renderSegment("context_pct", percent).content), "?");
-});
-
-test("context_pct marks context estimates as approximate", () => {
-  const full = createSegmentContext({}, {
-    contextTokens: 18000,
-    contextWindow: 272000,
-    contextPercent: 6.6176,
-    contextApproximate: true,
-  });
-  const percent = createSegmentContext({ context: { format: "percent" } }, {
-    contextTokens: 18000,
-    contextWindow: 272000,
-    contextPercent: 6.6176,
-    contextApproximate: true,
-  });
-
-  assert.equal(stripAnsi(renderSegment("context_pct", full).content), "~18k/272k (6.6%)");
-  assert.equal(stripAnsi(renderSegment("context_pct", percent).content), "~7%");
-});
-
-test("context_pct percent format keeps threshold colors and drops icons", () => {
-  for (const [percent, expected] of [[69, "69%"], [85, "85%"], [95, "95%"]] as const) {
-    const ctx = createSegmentContext({ context: { format: "percent" } }, {
-      contextTokens: percent,
-      contextWindow: 100,
-      contextPercent: percent,
-    });
-    const rendered = renderSegment("context_pct", ctx);
-    assert.equal(stripAnsi(rendered.content), expected);
-    assert.ok(!rendered.content.includes("◫"), "no context icon in percent mode");
-    assert.ok(!rendered.content.includes("AC"), "no auto-compact icon in percent mode");
-  }
-});
-
-// ── cache_read format ───────────────────────────────────────────────────────
-
-test("cache_read defaults to raw token count", () => {
-  const ctx = createSegmentContext({}, {
-    usageStats: { input: 1000, output: 0, cacheRead: 12300, cacheWrite: 0, cost: 0, subagentCost: 0 },
-  });
-
-  const rendered = renderSegment("cache_read", ctx);
-  assert.equal(stripAnsi(rendered.content), "cache in: 12k");
-});
-
-test("cache_read percent format renders the cache hit rate", () => {
-  const ctx = createSegmentContext({ cache_read: { format: "percent" } }, {
-    usageStats: { input: 2000, output: 0, cacheRead: 8000, cacheWrite: 0, cost: 0, subagentCost: 0 },
-  });
-
-  const rendered = renderSegment("cache_read", ctx);
-  assert.equal(stripAnsi(rendered.content), "cache 80%");
-});
-
-test("cache_read both format renders raw token count and cache hit rate", () => {
-  const ctx = createSegmentContext({ cache_read: { format: "both" } }, {
-    usageStats: { input: 2000, output: 0, cacheRead: 8000, cacheWrite: 0, cost: 0, subagentCost: 0 },
-  });
-
-  const rendered = renderSegment("cache_read", ctx);
-  assert.equal(stripAnsi(rendered.content), "cache in: 8.0k (80%)");
-});
-
-test("cache_read percent and both formats handle zero input without NaN", () => {
-  const percentCtx = createSegmentContext({ cache_read: { format: "percent" } }, {
-    usageStats: { input: 0, output: 0, cacheRead: 5, cacheWrite: 0, cost: 0, subagentCost: 0 },
-  });
-  assert.equal(stripAnsi(renderSegment("cache_read", percentCtx).content), "cache 100%");
-
-  const bothCtx = createSegmentContext({ cache_read: { format: "both" } }, {
-    usageStats: { input: 0, output: 0, cacheRead: 5, cacheWrite: 0, cost: 0, subagentCost: 0 },
-  });
-  assert.equal(stripAnsi(renderSegment("cache_read", bothCtx).content), "cache in: 5 (100%)");
-
-  const hidden = createSegmentContext({ cache_read: { format: "both" } });
-  assert.deepEqual(renderSegment("cache_read", hidden), { content: "", visible: false });
-});
-
-// ── queue segment ──────────────────────────────────────────────────────────
-
-test("queue segment hides when empty", () => {
-  const ctx = createSegmentContext();
-  assert.deepEqual(renderSegment("queue", ctx), { content: "", visible: false });
-});
-
-test("queue segment summarizes queued and blocked items", () => {
-  const ctx = createSegmentContext({}, {
-    queueSummary: { queueCount: 2, blockedCount: 1, compacting: false, leadingText: "fix README", leadingIntent: "post-compact", leadingStatus: "blocked" },
-  });
-
-  assert.equal(stripAnsi(renderSegment("queue", ctx).content), "q 2 · blocked 1");
-});
-
-test("queue segment highlights compaction-held prompts", () => {
-  const ctx = createSegmentContext({}, {
-    queueSummary: { queueCount: 1, blockedCount: 0, compacting: true, leadingText: "run after compact", leadingIntent: "post-compact", leadingStatus: "queued" },
-  });
-
-  assert.equal(stripAnsi(renderSegment("queue", ctx).content), "compact q 1");
-});
-
-// ── config parsing / merging ────────────────────────────────────────────────
-
-test("parsePowerlineConfig accepts context and cache_read formats", () => {
-  const config = parsePowerlineConfig({
-    context: { format: "percent" },
-    cache_read: { format: "both" },
-  }, PRESET_NAMES);
-
-  assert.equal(config.segmentOptions.context?.format, "percent");
-  assert.equal(config.segmentOptions.cache_read?.format, "both");
-});
-
-test("parsePowerlineConfig ignores invalid format values", () => {
-  const config = parsePowerlineConfig({
-    context: { format: "bogus" },
-    cache_read: { format: 42 },
-  }, PRESET_NAMES);
-
-  assert.equal(config.segmentOptions.context?.format, undefined);
-  assert.equal(config.segmentOptions.cache_read?.format, undefined);
-});
-
-test("parsePowerlineConfig defaults to upstream rendering when options are absent", () => {
-  const config = parsePowerlineConfig({}, PRESET_NAMES);
-  assert.equal(config.segmentOptions.context, undefined);
-  assert.equal(config.segmentOptions.cache_read, undefined);
-});
-
-test("mergeSegmentOptions merges context and cache_read per key", () => {
-  const merged = mergeSegmentOptions(
-    { context: { format: "percent" }, cache_read: { format: "percent" } },
-    { context: { format: "full" }, cache_read: { format: "both" } },
-  );
-
-  assert.equal(merged.context?.format, "full");
-  assert.equal(merged.cache_read?.format, "both");
-});