t3code-cli 0.14.0 → 0.14.2

package/dist/shared/t3ProjectFile.d.ts

@@ -1,3 +1,4 @@
+import { su as T3ProjectFile } from "../shared.js";
 import * as Schema from "effect/Schema";
 //#region upstream-t3code/packages/shared/src/t3ProjectFile.d.ts
 /**
@@ -7,6 +8,7 @@ import * as Schema from "effect/Schema";
 declare const T3ProjectFileFromJson: Schema.decodeTo<Schema.Struct<{
   readonly $schema: Schema.optionalKey<Schema.String>;
   readonly iconPath: Schema.optionalKey<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+  readonly defaultThreadEnvMode: Schema.optionalKey<Schema.Literals<readonly ["local", "worktree"]>>;
   readonly scripts: Schema.optionalKey<Schema.$Array<Schema.Struct<{
     readonly name: Schema.decodeTo<Schema.String, Schema.String, never, never>;
     readonly command: Schema.decodeTo<Schema.String, Schema.String, never, never>;
@@ -16,6 +18,12 @@ declare const T3ProjectFileFromJson: Schema.decodeTo<Schema.Struct<{
     readonly autoOpenPreview: Schema.optionalKey<Schema.Boolean>;
   }>>>;
 }>, Schema.String, never, never>;
+/**
+ * Decode raw `t3.json` contents, treating invalid or malformed files as
+ * absent. Clients use this to read optional defaults (scripts, thread env
+ * mode) without surfacing decode errors to the user.
+ */
+declare function parseT3ProjectFile(contents: string): T3ProjectFile | null;
 /**
  * Build the publishable JSON Schema document for `t3.json` (draft 2020-12).
  *
@@ -24,4 +32,4 @@ declare const T3ProjectFileFromJson: Schema.decodeTo<Schema.Struct<{
  */
 declare function buildT3ProjectFileJsonSchema(): Record<string, unknown>;
 //#endregion
-export { T3ProjectFileFromJson, buildT3ProjectFileJsonSchema };
+export { T3ProjectFileFromJson, buildT3ProjectFileJsonSchema, parseT3ProjectFile };

package/dist/shared/t3ProjectFile.js

@@ -1,10 +1,20 @@
-import { Iu as T3ProjectFile, fE as toJsonSchemaDocument, g as fromLenientJson, zu as T3_PROJECT_FILE_SCHEMA_URL } from "../shared.js";
+import { ND as decodeExit, UD as toJsonSchemaDocument, XA as isSuccess, g as fromLenientJson, vd as T3ProjectFile, xd as T3_PROJECT_FILE_SCHEMA_URL } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/t3ProjectFile.ts
 /**
 * Codec between the raw `t3.json` file contents (lenient JSONC string) and the
 * decoded {@link T3ProjectFile}.
 */
 const T3ProjectFileFromJson = fromLenientJson(T3ProjectFile);
+const decodeT3ProjectFile = decodeExit(T3ProjectFileFromJson);
+/**
+* Decode raw `t3.json` contents, treating invalid or malformed files as
+* absent. Clients use this to read optional defaults (scripts, thread env
+* mode) without surfacing decode errors to the user.
+*/
+function parseT3ProjectFile(contents) {
+	const decoded = decodeT3ProjectFile(contents);
+	return isSuccess(decoded) ? decoded.value : null;
+}
 /**
 * Build the publishable JSON Schema document for `t3.json` (draft 2020-12).
 *
@@ -22,4 +32,4 @@ function buildT3ProjectFileJsonSchema() {
 	return jsonSchema;
 }
 //#endregion
-export { T3ProjectFileFromJson, buildT3ProjectFileJsonSchema };
+export { T3ProjectFileFromJson, buildT3ProjectFileJsonSchema, parseT3ProjectFile };

package/dist/shared/terminalLabels.d.ts

@@ -1,4 +1,4 @@
-import { ix as TerminalSummary } from "../shared.js";
+import { NS as TerminalSummary } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/terminalLabels.d.ts
 /** Human-readable label for a terminal tab; matches mobile and web sidebars. */
 declare function getTerminalLabel(terminalId: string): string;

package/dist/shared/threadEnvMode.d.ts

@@ -0,0 +1,29 @@
+import { yE as ThreadEnvMode } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/threadEnvMode.d.ts
+/**
+ * Canonical priority order for a project's default thread env mode:
+ * per-project setting > checked-in t3.json > global server setting.
+ *
+ * An explicit composer pick outranks all of these; callers apply it before
+ * consulting the defaults. Web resolves the sources imperatively at draft
+ * creation, mobile reactively — both must route through this function so the
+ * platforms cannot disagree on the order.
+ */
+declare function resolveDefaultThreadEnvMode(sources: {
+  readonly projectSetting: ThreadEnvMode | null | undefined;
+  readonly projectFile: ThreadEnvMode | null | undefined;
+  readonly globalDefault: ThreadEnvMode;
+}): ThreadEnvMode;
+/**
+ * True once the resolved default can no longer change: an explicit pick or a
+ * source that outranks t3.json decided, or the file read settled. While
+ * false, nothing may persist the provisional default (for example into a
+ * draft's workspace selection) — it could differ from the final value.
+ */
+declare function isDefaultThreadEnvModeSettled(sources: {
+  readonly explicitMode: ThreadEnvMode | undefined;
+  readonly projectSetting: ThreadEnvMode | null | undefined;
+  readonly projectFilePending: boolean;
+}): boolean;
+//#endregion
+export { isDefaultThreadEnvModeSettled, resolveDefaultThreadEnvMode };

package/dist/shared/threadEnvMode.js

@@ -0,0 +1,24 @@
+//#region upstream-t3code/packages/shared/src/threadEnvMode.ts
+/**
+* Canonical priority order for a project's default thread env mode:
+* per-project setting > checked-in t3.json > global server setting.
+*
+* An explicit composer pick outranks all of these; callers apply it before
+* consulting the defaults. Web resolves the sources imperatively at draft
+* creation, mobile reactively — both must route through this function so the
+* platforms cannot disagree on the order.
+*/
+function resolveDefaultThreadEnvMode(sources) {
+	return sources.projectSetting ?? sources.projectFile ?? sources.globalDefault;
+}
+/**
+* True once the resolved default can no longer change: an explicit pick or a
+* source that outranks t3.json decided, or the file read settled. While
+* false, nothing may persist the provisional default (for example into a
+* draft's workspace selection) — it could differ from the final value.
+*/
+function isDefaultThreadEnvModeSettled(sources) {
+	return sources.explicitMode !== void 0 || sources.projectSetting != null || !sources.projectFilePending;
+}
+//#endregion
+export { isDefaultThreadEnvModeSettled, resolveDefaultThreadEnvMode };

package/dist/shared/toolActivity.d.ts

@@ -1,4 +1,4 @@
-import { jp as ToolLifecycleItemType } from "../shared.js";
+import { bm as ToolLifecycleItemType } from "../shared.js";
 //#region upstream-t3code/packages/shared/src/toolActivity.d.ts
 interface ToolActivityPresentationInput {
   readonly itemType?: ToolLifecycleItemType | null | undefined;

package/dist/shared/usageFormat.d.ts

@@ -0,0 +1,21 @@
+import { ol as UsageSummaryInput } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/usageFormat.d.ts
+declare function formatUsd(value: number): string;
+declare function formatCount(value: number): string;
+/**
+ * Compacts a token count to three significant figures with a unit suffix, so
+ * columns of numbers line up at a glance (`19.9B`, `76.7M`, `804K`).
+ */
+declare function formatTokens(value: number): string;
+declare function formatPercent(share: number, digits?: number): string;
+/** `2026-08-07` to `Aug 7`. */
+declare function formatDayShort(day: string): string;
+/** Inclusive day list between two `YYYY-MM-DD` bounds. */
+declare function enumerateDays(sinceDay: string, untilDay: string): readonly string[];
+/**
+ * The window the page requests, expressed in the viewer's own time zone so days
+ * line up with what they actually experienced.
+ */
+declare function makeWindow(days: number, now?: Date): UsageSummaryInput;
+//#endregion
+export { enumerateDays, formatCount, formatDayShort, formatPercent, formatTokens, formatUsd, makeWindow };

package/dist/shared/usageFormat.js

@@ -0,0 +1,90 @@
+import { Sl as UsageDay } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/usageFormat.ts
+/**
+* Display formatting for the usage page.
+*
+* @module usageFormat
+*/
+const CURRENCY = new Intl.NumberFormat("en-US", {
+	style: "currency",
+	currency: "USD",
+	minimumFractionDigits: 2,
+	maximumFractionDigits: 2
+});
+const INTEGER = new Intl.NumberFormat("en-US");
+function formatUsd(value) {
+	return CURRENCY.format(value);
+}
+function formatCount(value) {
+	return INTEGER.format(Math.round(value));
+}
+/**
+* Compacts a token count to three significant figures with a unit suffix, so
+* columns of numbers line up at a glance (`19.9B`, `76.7M`, `804K`).
+*/
+function formatTokens(value) {
+	const abs = Math.abs(value);
+	if (abs >= 0xe8d4a51000) return `${trim(value / 0xe8d4a51000)}T`;
+	if (abs >= 1e9) return `${trim(value / 1e9)}B`;
+	if (abs >= 1e6) return `${trim(value / 1e6)}M`;
+	if (abs >= 1e3) return `${trim(value / 1e3)}K`;
+	return INTEGER.format(Math.round(value));
+}
+function trim(value) {
+	const abs = Math.abs(value);
+	const digits = abs >= 100 ? 0 : abs >= 10 ? 1 : 2;
+	return value.toFixed(digits).replace(/\.0+$/, "");
+}
+function formatPercent(share, digits = 1) {
+	return `${(share * 100).toFixed(digits)}%`;
+}
+/** `2026-08-07` to `Aug 7`. */
+function formatDayShort(day) {
+	const [year, month, dayOfMonth] = day.split("-").map((part) => Number(part));
+	if (year === void 0 || month === void 0 || dayOfMonth === void 0) return day;
+	return `${[
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	][month - 1] ?? ""} ${dayOfMonth}`;
+}
+/** Inclusive day list between two `YYYY-MM-DD` bounds. */
+function enumerateDays(sinceDay, untilDay) {
+	const days = [];
+	const start = Date.parse(`${sinceDay}T00:00:00Z`);
+	const end = Date.parse(`${untilDay}T00:00:00Z`);
+	if (Number.isNaN(start) || Number.isNaN(end) || end < start) return days;
+	for (let cursor = start; cursor <= end; cursor += 864e5) days.push(new Date(cursor).toISOString().slice(0, 10));
+	return days;
+}
+/**
+* The window the page requests, expressed in the viewer's own time zone so days
+* line up with what they actually experienced.
+*/
+function makeWindow(days, now = /* @__PURE__ */ new Date()) {
+	const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+	const untilDay = new Intl.DateTimeFormat("en-CA", {
+		timeZone,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit"
+	}).format(now);
+	const [year = 0, month = 1, dayOfMonth = 1] = untilDay.split("-").map((part) => Number.parseInt(part, 10));
+	const start = new Date(Date.UTC(year, month - 1, dayOfMonth - (days - 1)));
+	return {
+		sinceDay: UsageDay.make(start.toISOString().slice(0, 10)),
+		untilDay: UsageDay.make(untilDay),
+		timeZone
+	};
+}
+//#endregion
+export { enumerateDays, formatCount, formatDayShort, formatPercent, formatTokens, formatUsd, makeWindow };

package/dist/shared/usageMerge.d.ts

@@ -0,0 +1,67 @@
+import { CD as EnvironmentId, al as UsageSummary, el as UsageProviderKind } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/usageMerge.d.ts
+interface EnvironmentUsage {
+  readonly environmentId: EnvironmentId;
+  readonly label: string;
+  readonly summary: UsageSummary;
+}
+interface ProviderTotals {
+  readonly provider: UsageProviderKind;
+  readonly costUsd: number;
+  readonly totalTokens: number;
+  readonly records: number;
+  readonly costShare: number;
+  readonly tokenShare: number;
+}
+interface ModelTotals {
+  readonly model: string;
+  readonly provider: UsageProviderKind;
+  readonly costUsd: number;
+  readonly totalTokens: number;
+  readonly records: number;
+  readonly costShare: number;
+}
+interface DailyTotals {
+  readonly day: string;
+  readonly costUsd: number;
+  readonly totalTokens: number;
+  readonly byProvider: ReadonlyMap<UsageProviderKind, {
+    costUsd: number;
+    totalTokens: number;
+  }>;
+}
+interface CostQuality {
+  readonly providerReportedShare: number;
+  readonly modelPricedShare: number;
+  readonly unpricedShare: number;
+  readonly cacheSavingsUsd: number;
+}
+interface MergedUsage {
+  readonly costUsd: number;
+  readonly uncachedInputTokens: number;
+  readonly cachedInputTokens: number;
+  readonly cacheCreationTokens: number;
+  readonly outputTokens: number;
+  readonly reasoningTokens: number;
+  readonly totalTokens: number;
+  readonly records: number;
+  readonly sessions: number;
+  readonly providers: readonly ProviderTotals[];
+  readonly models: readonly ModelTotals[];
+  readonly daily: readonly DailyTotals[];
+  readonly costQuality: CostQuality;
+  /** Environments whose data was dropped as a duplicate of another's. */
+  readonly duplicateSources: readonly string[];
+  readonly contributingEnvironments: readonly EnvironmentId[];
+  readonly staleEnvironments: readonly EnvironmentId[];
+}
+/**
+ * Merges every connected environment's summary.
+ *
+ * `expectedContractVersion` guards against an environment running older server
+ * code: rather than blocking the page, its data is excluded and its id is
+ * reported so the UI can say coverage is partial.
+ */
+declare function mergeUsage(environments: readonly EnvironmentUsage[], expectedContractVersion: number): MergedUsage;
+//#endregion
+export { CostQuality, DailyTotals, EnvironmentUsage, MergedUsage, ModelTotals, ProviderTotals, mergeUsage };

package/dist/shared/usageMerge.js

@@ -0,0 +1,218 @@
+//#region upstream-t3code/packages/shared/src/usageMerge.ts
+/**
+* Two sources are the same physical transcript directory only when host,
+* provider, path and filesystem identity all agree.
+*
+* `volumeId` is what stops two machines that happen to share a hostname and a
+* home path, which is every Mac in a fleet, from collapsing into one source and
+* having one of them silently dropped.
+*/
+function fingerprintKey(fingerprint) {
+	return [
+		fingerprint.hostId,
+		fingerprint.provider,
+		fingerprint.resolvedHomePath,
+		fingerprint.volumeId
+	].join(" ");
+}
+/**
+* Decides which environment owns each physical transcript directory.
+*
+* Several environments on one machine (worktree servers, for instance) resolve
+* the same provider home and would otherwise double count every token. The
+* first environment in a stable order claims a fingerprint; the rest have that
+* provider's buckets dropped. Environments are sorted by id so the winner does
+* not change between renders.
+*/
+function claimSources(environments) {
+	const ownerByFingerprint = /* @__PURE__ */ new Map();
+	const duplicates = [];
+	const ordered = [...environments].sort((a, b) => a.environmentId.localeCompare(b.environmentId));
+	for (const environment of ordered) for (const source of environment.summary.sources) {
+		if (source.status === "missing") continue;
+		const key = fingerprintKey(source.fingerprint);
+		if (ownerByFingerprint.has(key)) {
+			duplicates.push(`${environment.label}: ${source.fingerprint.resolvedHomePath}`);
+			continue;
+		}
+		ownerByFingerprint.set(key, environment.environmentId);
+	}
+	return {
+		ownerByFingerprint,
+		duplicates
+	};
+}
+/** Sources this environment owns after fingerprint claims, plus their buckets. */
+function ownedContribution(environment, ownerByFingerprint) {
+	const ownedProviders = /* @__PURE__ */ new Set();
+	let sessions = 0;
+	for (const source of environment.summary.sources) {
+		if (source.status === "missing") continue;
+		const key = fingerprintKey(source.fingerprint);
+		if (ownerByFingerprint.get(key) === environment.environmentId) {
+			ownedProviders.add(source.fingerprint.provider);
+			sessions += source.distinctSessions;
+		}
+	}
+	return {
+		buckets: environment.summary.buckets.filter((bucket) => ownedProviders.has(bucket.provider)),
+		sessions
+	};
+}
+function bucketTokens(bucket) {
+	return bucket.totals.uncachedInputTokens + bucket.totals.cachedInputTokens + bucket.totals.cacheCreationTokens + bucket.totals.outputTokens;
+}
+const EMPTY_MERGED = {
+	costUsd: 0,
+	uncachedInputTokens: 0,
+	cachedInputTokens: 0,
+	cacheCreationTokens: 0,
+	outputTokens: 0,
+	reasoningTokens: 0,
+	totalTokens: 0,
+	records: 0,
+	sessions: 0,
+	providers: [],
+	models: [],
+	daily: [],
+	costQuality: {
+		providerReportedShare: 0,
+		modelPricedShare: 0,
+		unpricedShare: 0,
+		cacheSavingsUsd: 0
+	},
+	duplicateSources: [],
+	contributingEnvironments: [],
+	staleEnvironments: []
+};
+/**
+* Merges every connected environment's summary.
+*
+* `expectedContractVersion` guards against an environment running older server
+* code: rather than blocking the page, its data is excluded and its id is
+* reported so the UI can say coverage is partial.
+*/
+function mergeUsage(environments, expectedContractVersion) {
+	if (environments.length === 0) return EMPTY_MERGED;
+	const current = [];
+	const staleEnvironments = [];
+	for (const environment of environments) if (environment.summary.contractVersion === expectedContractVersion) current.push(environment);
+	else staleEnvironments.push(environment.environmentId);
+	const { ownerByFingerprint, duplicates } = claimSources(current);
+	let costUsd = 0;
+	let uncachedInputTokens = 0;
+	let cachedInputTokens = 0;
+	let cacheCreationTokens = 0;
+	let outputTokens = 0;
+	let reasoningTokens = 0;
+	let records = 0;
+	let sessions = 0;
+	let cacheSavingsUsd = 0;
+	let providerReportedRecords = 0;
+	let unpricedRecords = 0;
+	const providerAccumulator = /* @__PURE__ */ new Map();
+	const modelAccumulator = /* @__PURE__ */ new Map();
+	const dailyAccumulator = /* @__PURE__ */ new Map();
+	const contributingEnvironments = [];
+	for (const environment of current) {
+		const { buckets, sessions: environmentSessions } = ownedContribution(environment, ownerByFingerprint);
+		if (buckets.length > 0) contributingEnvironments.push(environment.environmentId);
+		sessions += environmentSessions;
+		for (const bucket of buckets) {
+			const tokens = bucketTokens(bucket);
+			costUsd += bucket.costUsd;
+			cacheSavingsUsd += bucket.cacheSavingsUsd;
+			uncachedInputTokens += bucket.totals.uncachedInputTokens;
+			cachedInputTokens += bucket.totals.cachedInputTokens;
+			cacheCreationTokens += bucket.totals.cacheCreationTokens;
+			outputTokens += bucket.totals.outputTokens;
+			reasoningTokens += bucket.totals.reasoningTokens;
+			records += bucket.records;
+			unpricedRecords += bucket.unpricedRecords;
+			if (bucket.costSource === "providerReported") providerReportedRecords += bucket.records;
+			const provider = providerAccumulator.get(bucket.provider) ?? {
+				costUsd: 0,
+				totalTokens: 0,
+				records: 0
+			};
+			provider.costUsd += bucket.costUsd;
+			provider.totalTokens += tokens;
+			provider.records += bucket.records;
+			providerAccumulator.set(bucket.provider, provider);
+			const modelKey = `${bucket.provider} ${bucket.model}`;
+			const model = modelAccumulator.get(modelKey) ?? {
+				provider: bucket.provider,
+				costUsd: 0,
+				totalTokens: 0,
+				records: 0
+			};
+			model.costUsd += bucket.costUsd;
+			model.totalTokens += tokens;
+			model.records += bucket.records;
+			modelAccumulator.set(modelKey, model);
+			const day = dailyAccumulator.get(bucket.day) ?? {
+				costUsd: 0,
+				totalTokens: 0,
+				byProvider: /* @__PURE__ */ new Map()
+			};
+			day.costUsd += bucket.costUsd;
+			day.totalTokens += tokens;
+			const dayProvider = day.byProvider.get(bucket.provider) ?? {
+				costUsd: 0,
+				totalTokens: 0
+			};
+			dayProvider.costUsd += bucket.costUsd;
+			dayProvider.totalTokens += tokens;
+			day.byProvider.set(bucket.provider, dayProvider);
+			dailyAccumulator.set(bucket.day, day);
+		}
+	}
+	const totalTokens = uncachedInputTokens + cachedInputTokens + cacheCreationTokens + outputTokens;
+	const providers = [...providerAccumulator.entries()].map(([provider, totals]) => ({
+		provider,
+		costUsd: totals.costUsd,
+		totalTokens: totals.totalTokens,
+		records: totals.records,
+		costShare: costUsd === 0 ? 0 : totals.costUsd / costUsd,
+		tokenShare: totalTokens === 0 ? 0 : totals.totalTokens / totalTokens
+	})).sort((a, b) => b.costUsd - a.costUsd);
+	const models = [...modelAccumulator.entries()].map(([key, totals]) => ({
+		model: key.slice(key.indexOf(" ") + 1),
+		provider: totals.provider,
+		costUsd: totals.costUsd,
+		totalTokens: totals.totalTokens,
+		records: totals.records,
+		costShare: costUsd === 0 ? 0 : totals.costUsd / costUsd
+	})).sort((a, b) => b.costUsd - a.costUsd || b.totalTokens - a.totalTokens);
+	const daily = [...dailyAccumulator.entries()].map(([day, totals]) => ({
+		day,
+		costUsd: totals.costUsd,
+		totalTokens: totals.totalTokens,
+		byProvider: totals.byProvider
+	})).sort((a, b) => a.day.localeCompare(b.day));
+	return {
+		costUsd,
+		uncachedInputTokens,
+		cachedInputTokens,
+		cacheCreationTokens,
+		outputTokens,
+		reasoningTokens,
+		totalTokens,
+		records,
+		sessions,
+		providers,
+		models,
+		daily,
+		costQuality: {
+			providerReportedShare: records === 0 ? 0 : providerReportedRecords / records,
+			unpricedShare: records === 0 ? 0 : unpricedRecords / records,
+			modelPricedShare: records === 0 ? 0 : (records - providerReportedRecords - unpricedRecords) / records,
+			cacheSavingsUsd
+		},
+		duplicateSources: duplicates,
+		contributingEnvironments,
+		staleEnvironments
+	};
+}
+//#endregion
+export { mergeUsage };