gentle-pi 2.2.0 → 2.4.0

package/lib/agent-home.ts

@@ -0,0 +1,8 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// Pi Subagents resolves its global directory as `PI_CODING_AGENT_DIR || ~/.pi/agent`,
+// so an empty value must fall through here too or the two homes diverge again.
+export function resolveGentlePiAgentHome(env: NodeJS.ProcessEnv = process.env): string {
+	return env.GENTLE_PI_AGENT_HOME || env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
+}

package/lib/gentle-ai-renderer.ts

@@ -0,0 +1,70 @@
+import { keyHint, type AgentToolResult } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { sanitizeTerminalText } from "./terminal-theme.ts";
+
+type GentleAiLifecycleColor = "warning" | "success" | "error" | "dim";
+
+export interface GentleAiRenderTheme {
+	bold(value: string): string;
+	fg(color: GentleAiLifecycleColor, value: string): string;
+}
+
+export interface GentleAiRenderState {
+	lifecycleComponent?: boolean; genericLocked?: boolean;
+}
+
+export interface GentleAiRenderContext {
+	argsComplete?: boolean;
+	executionStarted?: boolean;
+	isPartial?: boolean;
+	isError?: boolean;
+	lastComponent?: unknown;
+	state?: unknown;
+}
+
+export function getGentleAiRenderState(state: unknown): GentleAiRenderState | undefined {
+	if (!state || typeof state !== "object" || Array.isArray(state)) return undefined;
+	const rowState = state as Record<string, unknown>, existing = rowState.gentleAiRender;
+	if (existing && typeof existing === "object" && !Array.isArray(existing)) return existing as GentleAiRenderState;
+	return (rowState.gentleAiRender = {} as GentleAiRenderState);
+}
+
+export interface GentleAiResultRenderOptions {
+	expanded?: boolean;
+}
+
+export function renderGentleAiResult(
+	result: AgentToolResult<unknown>,
+	options: GentleAiResultRenderOptions,
+): Text {
+	const textItems = result.content.flatMap((content) => (content.type === "text" ? [sanitizeTerminalText(content.text)] : []));
+	const text = textItems.join("\n");
+	const hasExpandableText = textItems.some((item) => item.length > 0);
+	const output = !hasExpandableText ? "" : options.expanded ? text : keyHint("app.tools.expand", "to expand");
+	return new Text(output, 0, 0);
+}
+
+export function renderGentleAiLifecycleCall(
+	operationPath: string,
+	theme: GentleAiRenderTheme,
+	context?: GentleAiRenderContext,
+	detail?: string,
+): Text {
+	const status = context?.isError
+		? "failed"
+		: context?.argsComplete === false
+			? "preparing"
+			: !context?.executionStarted || context.isPartial
+				? "running"
+				: "completed";
+	const color = status === "preparing" || status === "running" ? "warning" : status === "completed" ? "success" : "error";
+	const lines = [theme.fg(color, theme.bold(`🌹︎ Gentle AI · ${status} · ${operationPath}`))];
+	if (detail) lines.push(theme.fg("dim", sanitizeTerminalText(detail)));
+	const state = getGentleAiRenderState(context?.state);
+	const component = context?.lastComponent instanceof Text && (!state || state.lifecycleComponent === true)
+		? context.lastComponent
+		: new Text("", 0, 0);
+	if (state) state.lifecycleComponent = true;
+	component.setText(lines.join("\n"));
+	return component;
+}

package/lib/model-routing-authority.ts

@@ -0,0 +1,133 @@
+import { existsSync, readFileSync } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+
+export const THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+] as const;
+
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+
+export interface AgentRoutingEntry {
+	model?: string;
+	thinking?: ThinkingLevel;
+}
+
+export type AgentModelConfig = Record<string, AgentRoutingEntry>;
+
+export type ModelConfigFileResult =
+	| { status: "missing" }
+	| { status: "invalid"; path: string }
+	| { status: "valid"; config: AgentModelConfig };
+
+const SAFE_MODEL_ID_PATTERN = /^[A-Za-z0-9._~:@/+%-]+$/;
+const SAFE_AGENT_NAME_PATTERN = /^[A-Za-z0-9._:@/+%-]+$/;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+async function pathExists(path: string): Promise<boolean> {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export function isThinkingLevel(value: unknown): value is ThinkingLevel {
+	return (
+		typeof value === "string" &&
+		(THINKING_LEVELS as readonly string[]).includes(value)
+	);
+}
+
+export function normalizeModelId(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const model = value.trim();
+	if (model.length === 0) return undefined;
+	if (!SAFE_MODEL_ID_PATTERN.test(model)) return undefined;
+	return model;
+}
+
+export function normalizeRoutingEntry(value: unknown): AgentRoutingEntry | undefined {
+	if (typeof value === "string") {
+		const model = normalizeModelId(value);
+		return model ? { model } : undefined;
+	}
+	if (!isRecord(value)) return undefined;
+	const model = normalizeModelId(value.model);
+	const thinking = isThinkingLevel(value.thinking) ? value.thinking : undefined;
+	if (!model && !thinking) {
+		return Object.keys(value).length === 0 ? {} : undefined;
+	}
+	return { model, thinking };
+}
+
+export function normalizeModelConfig(value: unknown): AgentModelConfig | undefined {
+	if (!isRecord(value)) return undefined;
+	const cleaned: AgentModelConfig = {};
+	for (const [name, entryValue] of Object.entries(value)) {
+		if (!SAFE_AGENT_NAME_PATTERN.test(name)) continue;
+		const entry = normalizeRoutingEntry(entryValue);
+		if (entry) cleaned[name] = entry;
+	}
+	return cleaned;
+}
+
+function parseModelConfigFileValue(value: Record<string, unknown>): AgentModelConfig {
+	const config: AgentModelConfig = {};
+	for (const [name, entryValue] of Object.entries(value)) {
+		const entry = normalizeRoutingEntry(entryValue);
+		if (entry) config[name] = entry;
+	}
+	return config;
+}
+
+export function readModelConfigFile(path: string): ModelConfigFileResult {
+	if (!existsSync(path)) return { status: "missing" };
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+		if (!isRecord(parsed)) return { status: "invalid", path };
+		return { status: "valid", config: parseModelConfigFileValue(parsed) };
+	} catch {
+		return { status: "invalid", path };
+	}
+}
+
+export async function readModelConfigFileAsync(
+	path: string,
+): Promise<ModelConfigFileResult> {
+	if (!(await pathExists(path))) return { status: "missing" };
+	try {
+		const parsed: unknown = JSON.parse(await readFile(path, "utf8"));
+		if (!isRecord(parsed)) return { status: "invalid", path };
+		return { status: "valid", config: parseModelConfigFileValue(parsed) };
+	} catch {
+		return { status: "invalid", path };
+	}
+}
+
+export function readSavedModelConfig(
+	globalPath: string,
+	projectPath: string,
+): ModelConfigFileResult {
+	const globalResult = readModelConfigFile(globalPath);
+	if (globalResult.status !== "missing") return globalResult;
+	return readModelConfigFile(projectPath);
+}
+
+export async function readSavedModelConfigAsync(
+	globalPath: string,
+	projectPath: string,
+): Promise<ModelConfigFileResult> {
+	const globalResult = await readModelConfigFileAsync(globalPath);
+	if (globalResult.status !== "missing") return globalResult;
+	return readModelConfigFileAsync(projectPath);
+}