@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.3

package/dist/builtin/subagents/src/shared/fast-mode.ts

@@ -1,87 +0,0 @@
-import {
-	type CodexFastModeResolvedSettings,
-	type CodexFastModeScope,
-	isCodexFastModeCandidateModelId,
-	SettingsManager,
-	shouldApplyCodexFastModeForScope,
-} from "@bastani/atomic";
-import { splitKnownThinkingSuffix } from "./model-info.js";
-
-export interface ResolveSubagentModelFastModeInput {
-	model?: string;
-	cwd: string;
-	settings?: CodexFastModeResolvedSettings;
-	scope?: CodexFastModeScope;
-}
-
-export interface ResolveSubagentModelFastModeMapInput {
-	models: readonly (string | undefined)[];
-	cwd: string;
-	settings?: CodexFastModeResolvedSettings;
-	scope?: CodexFastModeScope;
-}
-
-export interface ResolveSubagentModelFastModeMetadataInput {
-	model?: string;
-	modelCandidates: readonly (string | undefined)[];
-	cwd: string;
-	settings?: CodexFastModeResolvedSettings;
-	scope?: CodexFastModeScope;
-}
-
-export interface SubagentModelFastModeMetadata {
-	fastMode?: true;
-	modelFastModes: Record<string, boolean>;
-}
-
-export function getSubagentCodexFastModeSettings(cwd: string): CodexFastModeResolvedSettings {
-	try {
-		return SettingsManager.create(cwd).getCodexFastModeSettings();
-	} catch {
-		return { chat: false, workflow: false };
-	}
-}
-
-function providerFromModelId(model: string | undefined): string | undefined {
-	if (!model) return undefined;
-	const { baseModel } = splitKnownThinkingSuffix(model);
-	if (!isCodexFastModeCandidateModelId(baseModel)) return undefined;
-	return baseModel.split("/", 1)[0];
-}
-
-export function resolveSubagentCodexFastModeScope(workflowStageSubagentGuard: boolean | undefined): CodexFastModeScope {
-	return workflowStageSubagentGuard ? "workflow" : "chat";
-}
-
-export function resolveSubagentModelFastMode(input: ResolveSubagentModelFastModeInput): boolean {
-	const provider = providerFromModelId(input.model);
-	if (!provider) return false;
-	const settings = input.settings ?? getSubagentCodexFastModeSettings(input.cwd);
-	return shouldApplyCodexFastModeForScope({ provider }, settings, input.scope ?? "chat");
-}
-
-export function resolveSubagentModelFastModeMap(input: ResolveSubagentModelFastModeMapInput): Record<string, boolean> {
-	const settings = input.settings ?? getSubagentCodexFastModeSettings(input.cwd);
-	const fastModes: Record<string, boolean> = {};
-	for (const model of input.models) {
-		if (!model || Object.hasOwn(fastModes, model)) continue;
-		fastModes[model] = resolveSubagentModelFastMode({ model, cwd: input.cwd, settings, scope: input.scope });
-	}
-	return fastModes;
-}
-
-export function resolveSubagentModelFastModeMetadata(
-	input: ResolveSubagentModelFastModeMetadataInput,
-): SubagentModelFastModeMetadata {
-	const settings = input.settings ?? getSubagentCodexFastModeSettings(input.cwd);
-	const fastMode = resolveSubagentModelFastMode({ model: input.model, cwd: input.cwd, settings, scope: input.scope });
-	return {
-		...(fastMode ? { fastMode: true as const } : {}),
-		modelFastModes: resolveSubagentModelFastModeMap({
-			models: input.modelCandidates,
-			cwd: input.cwd,
-			settings,
-			scope: input.scope,
-		}),
-	};
-}

package/dist/builtin/subagents/src/shared/file-coalescer.ts

@@ -1,40 +0,0 @@
-interface TimerApi {
-	setTimeout(handler: () => void, delayMs: number): unknown;
-	clearTimeout(handle: unknown): void;
-}
-
-interface FileCoalescer {
-	schedule(file: string, delayMs?: number): boolean;
-	clear(): void;
-}
-
-const defaultTimerApi: TimerApi = {
-	setTimeout: (handler, delayMs) => setTimeout(handler, delayMs),
-	clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
-};
-
-export function createFileCoalescer(
-	handler: (file: string) => void,
-	defaultDelayMs: number,
-	timerApi: TimerApi = defaultTimerApi,
-): FileCoalescer {
-	const pending = new Map<string, unknown>();
-
-	return {
-		schedule(file: string, delayMs = defaultDelayMs): boolean {
-			if (pending.has(file)) return false;
-			const timer = timerApi.setTimeout(() => {
-				pending.delete(file);
-				handler(file);
-			}, delayMs);
-			pending.set(file, timer);
-			return true;
-		},
-		clear(): void {
-			for (const timer of pending.values()) {
-				timerApi.clearTimeout(timer);
-			}
-			pending.clear();
-		},
-	};
-}

package/dist/builtin/subagents/src/shared/fork-context.ts

@@ -1,79 +0,0 @@
-import * as fs from "node:fs";
-import { SessionManager } from "@bastani/atomic";
-
-type SubagentExecutionContext = "fresh" | "fork";
-
-interface ForkableSessionManager {
-	getSessionFile(): string | undefined;
-	getLeafId(): string | null;
-	getSessionDir?(): string;
-	openSession?: (path: string, sessionDir?: string) => { createBranchedSession(leafId: string): string | undefined };
-}
-
-interface ForkContextResolverOptions {
-	openSession?: (path: string, sessionDir?: string) => { createBranchedSession(leafId: string): string | undefined };
-}
-
-interface ForkContextResolver {
-	sessionFileForIndex(index?: number): string | undefined;
-}
-
-export function resolveSubagentContext(value: unknown): SubagentExecutionContext {
-	return value === "fork" ? "fork" : "fresh";
-}
-
-export function createForkContextResolver(
-	sessionManager: ForkableSessionManager,
-	requestedContext: unknown,
-	options: ForkContextResolverOptions = {},
-): ForkContextResolver {
-	if (resolveSubagentContext(requestedContext) !== "fork") {
-		return {
-			sessionFileForIndex: () => undefined,
-		};
-	}
-
-	const parentSessionFile = sessionManager.getSessionFile();
-	if (!parentSessionFile) {
-		throw new Error("Forked subagent context requires a persisted parent session.");
-	}
-
-	const leafId = sessionManager.getLeafId();
-	if (!leafId) {
-		throw new Error("Forked subagent context requires a current leaf to fork from.");
-	}
-
-	const openSession =
-		options.openSession ??
-		sessionManager.openSession ??
-		((file: string, dir?: string) => SessionManager.open(file, dir));
-	const sessionDir = sessionManager.getSessionDir?.();
-	const cachedSessionFiles = new Map<number, string>();
-
-	return {
-		sessionFileForIndex(index = 0): string | undefined {
-			const cached = cachedSessionFiles.get(index);
-			if (cached) return cached;
-			try {
-				if (!fs.existsSync(parentSessionFile)) {
-					throw new Error(
-						`Parent session file does not exist: ${parentSessionFile}. Pi has not persisted enough history to fork yet.`,
-					);
-				}
-				const sourceManager = openSession(parentSessionFile, sessionDir);
-				const sessionFile = sourceManager.createBranchedSession(leafId);
-				if (!sessionFile) {
-					throw new Error("Session manager did not return a forked session file.");
-				}
-				if (!fs.existsSync(sessionFile)) {
-					throw new Error(`Session manager returned a forked session file that does not exist: ${sessionFile}`);
-				}
-				cachedSessionFiles.set(index, sessionFile);
-				return sessionFile;
-			} catch (error) {
-				const cause = error instanceof Error ? error : new Error(String(error));
-				throw new Error(`Failed to create forked subagent session: ${cause.message}`, { cause });
-			}
-		},
-	};
-}

package/dist/builtin/subagents/src/shared/formatters.ts

@@ -1,89 +0,0 @@
-/**
- * Formatting utilities for display output
- */
-
-import { splitKnownThinkingSuffix, THINKING_LEVELS } from "./model-info.js";
-import type { Usage } from "./types.js";
-
-/**
- * Format token count with k suffix for large numbers
- */
-export function formatTokens(n: number): string {
-	return n < 1000 ? String(n) : n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
-}
-
-export function formatModelThinking(model?: string, thinking?: string, fastMode?: boolean): string {
-	const parsed = model ? splitKnownThinkingSuffix(model) : undefined;
-	// Keep the full `provider/model` id so subagent lines read exactly like the
-	// main chat's model display; only a known thinking suffix is split off.
-	const displayModel = parsed?.baseModel ?? model;
-	const explicitThinking = THINKING_LEVELS.find((level) => level === thinking?.trim());
-	const displayThinking = parsed?.thinkingSuffix ? parsed.thinkingSuffix.slice(1) : explicitThinking;
-	const parts = [displayModel, displayThinking ? `thinking ${displayThinking}` : undefined].filter(Boolean);
-	if (fastMode && parts.length > 0) parts.push("fast");
-	return parts.join(" · ");
-}
-
-/**
- * Format usage statistics into a compact string
- */
-export function formatUsage(u: Usage): string {
-	const parts: string[] = [];
-	if (u.turns) parts.push(`${u.turns} turn${u.turns > 1 ? "s" : ""}`);
-	if (u.input) parts.push(`in:${formatTokens(u.input)}`);
-	if (u.output) parts.push(`out:${formatTokens(u.output)}`);
-	if (u.cacheRead) parts.push(`R${formatTokens(u.cacheRead)}`);
-	if (u.cacheWrite) parts.push(`W${formatTokens(u.cacheWrite)}`);
-	if (u.cost) parts.push(`$${u.cost.toFixed(4)}`);
-	return parts.join(" ");
-}
-
-/**
- * Format duration in human-readable form
- */
-export function formatDuration(ms: number): string {
-	const totalSeconds = Math.floor(Math.max(0, ms) / 1000);
-	const hours = Math.floor(totalSeconds / 3600);
-	const minutes = Math.floor((totalSeconds % 3600) / 60);
-	const seconds = totalSeconds % 60;
-
-	if (hours > 0) return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
-	if (minutes > 0) return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
-	return `${seconds}s`;
-}
-
-/**
- * Format a tool call for display
- */
-export function formatToolCall(name: string, args: Record<string, unknown>, expanded = false): string {
-	switch (name) {
-		case "bash": {
-			const command = typeof args.command === "string" ? args.command : "";
-			const maxLength = expanded ? 240 : 60;
-			return `$ ${command.slice(0, maxLength)}${command.length > maxLength ? "..." : ""}`;
-		}
-		case "read":
-		case "write":
-		case "edit": {
-			const target =
-				typeof args.path === "string" ? args.path : typeof args.file_path === "string" ? args.file_path : "";
-			return `${name} ${shortenPath(target)}`;
-		}
-		default: {
-			const s = JSON.stringify(args);
-			const maxLength = expanded ? 160 : 40;
-			return `${name} ${s.slice(0, maxLength)}${s.length > maxLength ? "..." : ""}`;
-		}
-	}
-}
-
-/**
- * Shorten a path by replacing home directory with ~
- */
-export function shortenPath(p: string): string {
-	const home = process.env.HOME;
-	if (home && p.startsWith(home)) {
-		return `~${p.slice(home.length)}`;
-	}
-	return p;
-}

package/dist/builtin/subagents/src/shared/jsonl-writer.ts

@@ -1,83 +0,0 @@
-import * as fs from "node:fs";
-
-export interface DrainableSource {
-	pause(): void;
-	resume(): void;
-}
-
-export interface JsonlWriteStream {
-	write(chunk: string): boolean;
-	on?(event: "error", listener: (error: Error) => void): JsonlWriteStream;
-	once(event: "drain", listener: () => void): JsonlWriteStream;
-	end(callback?: () => void): void;
-}
-
-export const DEFAULT_MAX_JSONL_BYTES = 50 * 1024 * 1024;
-
-interface JsonlWriterDeps {
-	createWriteStream?: (filePath: string) => JsonlWriteStream;
-	maxBytes?: number;
-}
-
-interface JsonlWriter {
-	writeLine(line: string): void;
-	close(): Promise<void>;
-}
-
-export function createJsonlWriter(
-	filePath: string | undefined,
-	source: DrainableSource,
-	deps: JsonlWriterDeps = {},
-): JsonlWriter {
-	if (!filePath) {
-		return {
-			writeLine() {},
-			async close() {},
-		};
-	}
-
-	const createWriteStream =
-		deps.createWriteStream ?? ((targetPath: string) => fs.createWriteStream(targetPath, { flags: "a" }));
-	let stream: JsonlWriteStream | undefined;
-	try {
-		stream = createWriteStream(filePath);
-	} catch {
-		return {
-			writeLine() {},
-			async close() {},
-		};
-	}
-
-	let backpressured = false;
-	let closed = false;
-	let bytesWritten = 0;
-	const maxBytes = deps.maxBytes ?? DEFAULT_MAX_JSONL_BYTES;
-
-	return {
-		writeLine(line: string) {
-			if (!stream || closed || !line.trim()) return;
-			const chunk = `${line}\n`;
-			const chunkBytes = Buffer.byteLength(chunk, "utf-8");
-			if (bytesWritten + chunkBytes > maxBytes) return;
-			try {
-				const ok = stream.write(chunk);
-				bytesWritten += chunkBytes;
-				if (!ok && !backpressured) {
-					backpressured = true;
-					source.pause();
-					stream.once("drain", () => {
-						backpressured = false;
-						if (!closed) source.resume();
-					});
-				}
-			} catch {}
-		},
-		async close() {
-			if (!stream || closed) return;
-			closed = true;
-			const current = stream;
-			stream = undefined;
-			await new Promise<void>((resolve) => current.end(() => resolve()));
-		},
-	};
-}

package/dist/builtin/subagents/src/shared/model-info.ts

@@ -1,101 +0,0 @@
-export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
-export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
-export type ThinkingLevelMap = Partial<Record<ThinkingLevel, string | null>>;
-
-export interface ModelInfo {
-	provider: string;
-	id: string;
-	fullId: string;
-	reasoning?: boolean;
-	thinkingLevelMap?: ThinkingLevelMap;
-}
-
-interface RegistryModelLike {
-	provider: string;
-	id: string;
-	reasoning?: boolean;
-	thinkingLevelMap?: ThinkingLevelMap;
-}
-
-export function toModelInfo(model: RegistryModelLike): ModelInfo {
-	return {
-		provider: model.provider,
-		id: model.id,
-		fullId: `${model.provider}/${model.id}`,
-		reasoning: model.reasoning,
-		thinkingLevelMap: model.thinkingLevelMap,
-	};
-}
-
-interface KnownProviderRegistryLike {
-	getAvailable(): ReadonlyArray<{ provider: string }>;
-	/** Older hosts may not expose `getAll()`; callers probe at runtime and fall back
-	 * to `getAvailable()`. */
-	getAll?: () => ReadonlyArray<{ provider: string }>;
-}
-
-/** Collect the distinct providers of every model the registry knows about — including
- * providers without configured auth — falling back to `getAvailable()` when the host
- * registry does not expose `getAll()`. Used to pre-filter spawn candidates whose
- * provider is known but keyless. */
-export function collectKnownModelProviders(registry: KnownProviderRegistryLike): string[] {
-	const models = typeof registry.getAll === "function" ? registry.getAll() : registry.getAvailable();
-	return [...new Set(models.map((model) => model.provider))];
-}
-
-/** Resolve the effective thinking level from a model string (which may contain a known suffix like `:high`)
- * and an explicit thinking config value. Returns `undefined` when no thinking is applicable
- * (e.g. no model was specified, or the model has no suffix and no config was provided). */
-export function resolveEffectiveThinking(
-	model: string | undefined,
-	configThinking: string | undefined,
-): string | undefined {
-	if (!model) return undefined;
-	const { thinkingSuffix } = splitKnownThinkingSuffix(model);
-	if (thinkingSuffix) return thinkingSuffix.slice(1);
-	return THINKING_LEVELS.find((level) => level === configThinking);
-}
-
-export function splitKnownThinkingSuffix(model: string): { baseModel: string; thinkingSuffix: string } {
-	const colonIdx = model.lastIndexOf(":");
-	if (colonIdx === -1) return { baseModel: model, thinkingSuffix: "" };
-	const suffix = THINKING_LEVELS.find((level) => level === model.substring(colonIdx + 1));
-	if (!suffix) return { baseModel: model, thinkingSuffix: "" };
-	return {
-		baseModel: model.substring(0, colonIdx),
-		thinkingSuffix: `:${suffix}`,
-	};
-}
-
-export function findModelInfo(
-	model: string | undefined,
-	availableModels: ModelInfo[] | undefined,
-	preferredProvider?: string,
-): ModelInfo | undefined {
-	if (!model || !availableModels || availableModels.length === 0) return undefined;
-	const { baseModel } = splitKnownThinkingSuffix(model);
-	const exact = availableModels.find((entry) => entry.fullId === baseModel);
-	if (exact) return exact;
-
-	const matches = availableModels.filter((entry) => entry.id === baseModel);
-	if (preferredProvider) {
-		const preferred = matches.find((entry) => entry.provider === preferredProvider);
-		if (preferred) return preferred;
-	}
-	return matches.length === 1 ? matches[0] : undefined;
-}
-
-export function getSupportedThinkingLevels(model: ModelInfo | undefined): ThinkingLevel[] {
-	if (!model) return [...THINKING_LEVELS];
-	if (model.reasoning === false) return ["off"];
-
-	if (!model.thinkingLevelMap) return [...THINKING_LEVELS];
-
-	const levels = THINKING_LEVELS.filter((level) => {
-		const mapped = model.thinkingLevelMap?.[level];
-		if (mapped === null) return false;
-		if (level === "xhigh" || level === "max") return mapped !== undefined;
-		return true;
-	});
-	return levels;
-}

package/dist/builtin/subagents/src/shared/model-resolution.ts

@@ -1,78 +0,0 @@
-/**
- * Resolution of a selected model candidate id to a concrete registry model.
- *
- * `buildModelCandidates` yields `provider/model[:thinking]` strings. Those
- * strings alone never reach the child session: `createAgentSession` takes a
- * `Model<Api>` object, and when no model is supplied it restores the model
- * persisted in the session file. For a fork-context child that file is a copy
- * of the parent's, so the parent's model silently won. Resolving the selected
- * candidate to a real model here is what lets the configured model be handed
- * to the child session instead.
- *
- * The lookup semantics deliberately mirror the SDK's own fallback-entry
- * resolution (`resolveFallbackModel`), so the primary candidate and the
- * fallback candidates handed to the same session agree on what a candidate
- * string means.
- */
-
-import type { Api, Model } from "@bastani/pi-ai/compat";
-import { splitKnownThinkingSuffix, THINKING_LEVELS, type ThinkingLevel } from "./model-info.js";
-
-/** Registry surface needed to resolve a candidate; satisfied by `ctx.modelRegistry`. */
-export interface CandidateModelLookup {
-	getAvailable(): Model<Api>[];
-	find(provider: string, modelId: string): Model<Api> | undefined;
-	hasConfiguredAuth(model: Model<Api>): boolean;
-}
-
-/** A candidate string resolved to a concrete model and its requested thinking level. */
-export interface ResolvedCandidateModel {
-	model: Model<Api>;
-	thinkingLevel?: ThinkingLevel;
-}
-
-/**
- * Resolve one `provider/model[:thinking]` candidate id against the registry.
- * Returns `undefined` when the candidate names no usable model, which leaves
- * the caller on its previous behavior rather than failing the run.
- */
-export type CandidateModelResolver = (candidateId: string) => ResolvedCandidateModel | undefined;
-
-function thinkingLevelFromSuffix(suffix: string): ThinkingLevel | undefined {
-	if (!suffix) return undefined;
-	const level = suffix.slice(1);
-	return THINKING_LEVELS.find((known) => known === level);
-}
-
-export function resolveCandidateModel(
-	candidateId: string,
-	lookup: CandidateModelLookup,
-	preferredProvider?: string,
-): ResolvedCandidateModel | undefined {
-	const trimmed = candidateId.trim();
-	if (!trimmed) return undefined;
-	const { baseModel, thinkingSuffix } = splitKnownThinkingSuffix(trimmed);
-	const thinkingLevel = thinkingLevelFromSuffix(thinkingSuffix);
-	const slash = baseModel.indexOf("/");
-	if (slash < 0) {
-		const available = lookup.getAvailable().filter((entry) => entry.id === baseModel);
-		const model =
-			available.find((entry) => entry.provider === preferredProvider) ??
-			(available.length === 1 ? available[0] : undefined);
-		if (!model) return undefined;
-		return thinkingLevel === undefined ? { model } : { model, thinkingLevel };
-	}
-	const provider = baseModel.slice(0, slash);
-	const modelId = baseModel.slice(slash + 1);
-	const model = lookup.find(provider, modelId);
-	if (!model || !lookup.hasConfiguredAuth(model)) return undefined;
-	return thinkingLevel === undefined ? { model } : { model, thinkingLevel };
-}
-
-/** Bind a registry and the parent's provider into a reusable candidate resolver. */
-export function createCandidateModelResolver(
-	lookup: CandidateModelLookup,
-	preferredProvider?: string,
-): CandidateModelResolver {
-	return (candidateId: string) => resolveCandidateModel(candidateId, lookup, preferredProvider);
-}

package/dist/builtin/subagents/src/shared/session-identity.ts

@@ -1,10 +0,0 @@
-interface SessionIdentityManager {
-	getSessionFile(): string | null | undefined;
-	getSessionId(): string | null | undefined;
-}
-
-export function resolveCurrentSessionId(sessionManager: SessionIdentityManager): string {
-	const sessionId = sessionManager.getSessionFile() ?? sessionManager.getSessionId();
-	if (!sessionId) throw new Error("Current session identity is unavailable.");
-	return sessionId;
-}

package/dist/builtin/subagents/src/shared/session-tokens.ts

@@ -1,45 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { TokenUsage } from "./types.js";
-
-function findLatestSessionFile(sessionDir: string): string | null {
-	try {
-		const files = fs
-			.readdirSync(sessionDir)
-			.filter((f) => f.endsWith(".jsonl"))
-			.map((f) => path.join(sessionDir, f));
-		if (files.length === 0) return null;
-		files.sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-		return files[0] ?? null;
-	} catch {
-		// Session token lookup is optional metadata.
-		return null;
-	}
-}
-
-export function parseSessionTokens(sessionDir: string): TokenUsage | null {
-	const sessionFile = findLatestSessionFile(sessionDir);
-	if (!sessionFile) return null;
-	try {
-		const content = fs.readFileSync(sessionFile, "utf-8");
-		let input = 0;
-		let output = 0;
-		for (const line of content.split("\n")) {
-			if (!line.trim()) continue;
-			try {
-				const entry = JSON.parse(line);
-				const usage = entry.usage ?? entry.message?.usage;
-				if (usage) {
-					input += usage.inputTokens ?? usage.input ?? 0;
-					output += usage.outputTokens ?? usage.output ?? 0;
-				}
-			} catch {
-				// Ignore malformed lines while scanning usage entries.
-			}
-		}
-		return { input, output, total: input + output };
-	} catch {
-		// Usage extraction should not fail the run.
-		return null;
-	}
-}