@oh-my-pi/pi-coding-agent 14.0.5 → 14.1.1

package/src/tools/write.ts

@@ -1,3 +1,4 @@
+import { Database } from "bun:sqlite";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type {
@@ -9,7 +10,7 @@ import type {
 } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
+import { isEnoent, isRecord, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { unzipSync, zipSync } from "fflate";
 import { stripHashlinePrefixes } from "../edit";
@@ -34,7 +35,18 @@ import {
 	replaceTabs,
 	shortenPath,
 } from "./render-utils";
+import {
+	deleteRowByKey,
+	deleteRowByRowId,
+	insertRow,
+	isSqliteFile,
+	parseSqlitePathCandidates,
+	resolveTableRowLookup,
+	updateRowByKey,
+	updateRowByRowId,
+} from "./sqlite-reader";
 import { ToolError } from "./tool-errors";
+import { toolResult } from "./tool-result";
 
 const writeSchema = Type.Object({
 	path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
@@ -94,6 +106,14 @@ interface ResolvedArchiveWritePath {
 	exists: boolean;
 }
 
+interface ResolvedSqliteWritePath {
+	absolutePath: string;
+	sqlitePath: string;
+	table: string;
+	key?: string;
+	exists: boolean;
+}
+
 function isArchivePathNotFound(error: unknown): boolean {
 	if (isEnoent(error)) return true;
 	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOTDIR";
@@ -125,6 +145,29 @@ function normalizeArchiveWriteSubPath(rawPath: string): string {
 	return normalizedParts.join("/");
 }
 
+function parseSqliteWriteTarget(subPath: string, queryString: string): { table: string; key?: string } {
+	if (queryString.trim().length > 0) {
+		throw new ToolError("SQLite write paths do not support query parameters");
+	}
+
+	const normalized = subPath.replace(/^:+/, "").trim();
+	if (!normalized) {
+		throw new ToolError("SQLite write path must target a table");
+	}
+
+	const separatorIndex = normalized.indexOf(":");
+	const table = separatorIndex === -1 ? normalized : normalized.slice(0, separatorIndex);
+	const key = separatorIndex === -1 ? undefined : normalized.slice(separatorIndex + 1);
+	if (!table) {
+		throw new ToolError("SQLite write path must target a table");
+	}
+	if (key !== undefined && key.length === 0) {
+		throw new ToolError("SQLite row writes require a non-empty row key");
+	}
+
+	return { table, key };
+}
+
 /**
  * Write tool implementation.
  *
@@ -262,6 +305,132 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		};
 	}
 
+	async #resolveSqliteWritePath(writePath: string): Promise<ResolvedSqliteWritePath | null> {
+		const candidates = parseSqlitePathCandidates(writePath).filter(candidate => candidate.sqlitePath !== writePath);
+		if (candidates.length === 0) {
+			return null;
+		}
+
+		const fallbackCandidate = candidates[candidates.length - 1]!;
+		const fallbackTarget = parseSqliteWriteTarget(fallbackCandidate.subPath, fallbackCandidate.queryString);
+		const fallback: ResolvedSqliteWritePath = {
+			absolutePath: resolvePlanPath(this.session, fallbackCandidate.sqlitePath),
+			sqlitePath: fallbackCandidate.sqlitePath,
+			table: fallbackTarget.table,
+			key: fallbackTarget.key,
+			exists: false,
+		};
+
+		let sawExistingNonSqlite = false;
+		for (const candidate of candidates) {
+			const target = parseSqliteWriteTarget(candidate.subPath, candidate.queryString);
+			const absolutePath = resolvePlanPath(this.session, candidate.sqlitePath);
+			try {
+				const stat = await Bun.file(absolutePath).stat();
+				if (stat.isDirectory()) {
+					continue;
+				}
+				if (!(await isSqliteFile(absolutePath))) {
+					sawExistingNonSqlite = true;
+					continue;
+				}
+
+				return {
+					absolutePath,
+					sqlitePath: candidate.sqlitePath,
+					table: target.table,
+					key: target.key,
+					exists: true,
+				};
+			} catch (error) {
+				if (!isArchivePathNotFound(error)) {
+					throw error;
+				}
+			}
+		}
+
+		if (sawExistingNonSqlite) {
+			return null;
+		}
+
+		return fallback;
+	}
+
+	async #writeSqliteRow(
+		displayPath: string,
+		content: string,
+		resolvedSqlitePath: ResolvedSqliteWritePath,
+	): Promise<AgentToolResult<WriteToolDetails>> {
+		let db: Database | null = null;
+		try {
+			if (!resolvedSqlitePath.exists) {
+				throw new ToolError(`SQLite database '${displayPath}' not found`);
+			}
+
+			db = new Database(resolvedSqlitePath.absolutePath, { create: false, strict: true });
+			db.run("PRAGMA busy_timeout = 3000");
+
+			const trimmedContent = content.trim();
+			let resultText: string;
+			if (trimmedContent.length === 0) {
+				if (!resolvedSqlitePath.key) {
+					throw new ToolError("SQLite deletes require a row key in the path");
+				}
+
+				const lookup = resolveTableRowLookup(db, resolvedSqlitePath.table);
+				const deleted =
+					lookup.kind === "pk"
+						? deleteRowByKey(db, resolvedSqlitePath.table, lookup, resolvedSqlitePath.key)
+						: deleteRowByRowId(db, resolvedSqlitePath.table, resolvedSqlitePath.key);
+				resultText =
+					deleted > 0
+						? `Deleted row '${resolvedSqlitePath.key}' from ${resolvedSqlitePath.table}`
+						: `No row deleted from ${resolvedSqlitePath.table} for key '${resolvedSqlitePath.key}'`;
+			} else {
+				let parsedContent: unknown;
+				try {
+					parsedContent = Bun.JSON5.parse(content);
+				} catch (error) {
+					throw new ToolError(
+						`SQLite write content must be valid JSON5: ${error instanceof Error ? error.message : String(error)}`,
+					);
+				}
+
+				if (!isRecord(parsedContent)) {
+					throw new ToolError("SQLite write content must be a JSON object");
+				}
+
+				if (resolvedSqlitePath.key) {
+					const lookup = resolveTableRowLookup(db, resolvedSqlitePath.table);
+					const updated =
+						lookup.kind === "pk"
+							? updateRowByKey(db, resolvedSqlitePath.table, lookup, resolvedSqlitePath.key, parsedContent)
+							: updateRowByRowId(db, resolvedSqlitePath.table, resolvedSqlitePath.key, parsedContent);
+					resultText =
+						updated > 0
+							? `Updated row '${resolvedSqlitePath.key}' in ${resolvedSqlitePath.table}`
+							: `No row updated in ${resolvedSqlitePath.table} for key '${resolvedSqlitePath.key}'`;
+				} else {
+					insertRow(db, resolvedSqlitePath.table, parsedContent);
+					resultText = `Inserted row into ${resolvedSqlitePath.table}`;
+				}
+			}
+
+			invalidateFsScanAfterWrite(resolvedSqlitePath.absolutePath);
+			return toolResult<WriteToolDetails>({}).text(resultText).sourcePath(resolvedSqlitePath.absolutePath).done();
+		} catch (error) {
+			if (isEnoent(error)) {
+				throw new ToolError(`SQLite database '${displayPath}' not found`);
+			}
+			if (error instanceof ToolError) {
+				throw error;
+			}
+			throw new ToolError(error instanceof Error ? error.message : String(error));
+		} finally {
+			db?.close();
+		}
+	}
+
 	async execute(
 		_toolCallId: string,
 		{ path, content }: WriteParams,
@@ -291,6 +460,23 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 				return archiveResult;
 			}
 
+			const resolvedSqlitePath = await this.#resolveSqliteWritePath(path);
+			if (resolvedSqlitePath) {
+				enforcePlanModeWrite(this.session, resolvedSqlitePath.sqlitePath, { op: "update" });
+
+				const sqliteResult = await this.#writeSqliteRow(path, cleanContent, resolvedSqlitePath);
+				if (stripped) {
+					const firstText = sqliteResult.content.find(
+						(block): block is { type: "text"; text: string } =>
+							block.type === "text" && typeof block.text === "string",
+					);
+					if (firstText) {
+						firstText.text += `\nNote: auto-stripped hashline display prefixes from content before writing.`;
+					}
+				}
+				return sqliteResult;
+			}
+
 			enforcePlanModeWrite(this.session, path, { op: "create" });
 			const absolutePath = resolvePlanPath(this.session, path);
 			const batchRequest = getLspBatchRequest(context?.toolCall);

package/src/utils/commit-message-generator.ts

@@ -52,6 +52,7 @@ function getSmolModelCandidates(
 	const configuredSmol = resolveModelRoleValue(settings.getModelRole("smol"), availableModels, {
 		settings,
 		matchPreferences,
+		modelRegistry: registry,
 	});
 	addCandidate(configuredSmol.model, configuredSmol.thinkingLevel);
 

package/src/utils/edit-mode.ts

@@ -1,6 +1,6 @@
 import { $env, $flag } from "@oh-my-pi/pi-utils";
 
-export type EditMode = "replace" | "patch" | "hashline" | "chunk";
+export type EditMode = "replace" | "patch" | "hashline" | "chunk" | "vim";
 
 export const DEFAULT_EDIT_MODE: EditMode = "hashline";
 
@@ -9,6 +9,7 @@ const EDIT_MODE_IDS = {
 	hashline: "hashline",
 	patch: "patch",
 	replace: "replace",
+	vim: "vim",
 } as const satisfies Record<string, EditMode>;
 
 export const EDIT_MODES = Object.keys(EDIT_MODE_IDS) as EditMode[];

package/src/utils/git.ts

@@ -146,6 +146,10 @@ const NO_OPTIONAL_LOCKS = "--no-optional-locks";
 const HEAD_REF_PREFIX = "ref:";
 const LOCAL_BRANCH_PREFIX = "refs/heads/";
 const DEFAULT_BRANCH_REFS = ["refs/remotes/origin/HEAD", "refs/remotes/upstream/HEAD"] as const;
+const SHORT_LIVED_GIT_CONFIG: readonly (readonly [key: string, value: string])[] = [
+	["core.fsmonitor", "false"],
+	["core.untrackedCache", "false"],
+];
 
 interface CommandOptions {
 	readonly env?: Record<string, string | undefined>;
@@ -183,7 +187,7 @@ async function runCommand(
 	args: readonly string[],
 	options: CommandOptions = {},
 ): Promise<GitCommandResult> {
-	const commandArgs = options.readOnly ? withNoOptionalLocks(args) : [...args];
+	const commandArgs = withShortLivedGitConfig(options.readOnly ? withNoOptionalLocks(args) : [...args]);
 	const child = Bun.spawn(["git", ...commandArgs], {
 		cwd,
 		env: options.env ? { ...process.env, ...options.env } : undefined,
@@ -212,6 +216,25 @@ function withNoOptionalLocks(args: readonly string[]): string[] {
 	return [NO_OPTIONAL_LOCKS, ...args];
 }
 
+function withShortLivedGitConfig(args: readonly string[]): string[] {
+	const prefix: string[] = [];
+	for (const [key, value] of SHORT_LIVED_GIT_CONFIG) {
+		if (hasGitConfig(args, key, value)) continue;
+		prefix.push("-c", `${key}=${value}`);
+	}
+	return [...prefix, ...args];
+}
+
+function hasGitConfig(args: readonly string[], key: string, value: string): boolean {
+	const expected = `${key}=${value}`;
+	for (let index = 0; index < args.length - 1; index += 1) {
+		if (args[index] === "-c" && args[index + 1] === expected) {
+			return true;
+		}
+	}
+	return false;
+}
+
 async function runChecked(
 	cwd: string,
 	args: readonly string[],

package/src/utils/session-color.ts

@@ -0,0 +1,55 @@
+/**
+ * Derive a stable hue (0-359) from a string using djb2 hash.
+ */
+function nameToHue(name: string): number {
+	let hash = 5381;
+	for (let i = 0; i < name.length; i++) {
+		hash = ((hash << 5) + hash) ^ name.charCodeAt(i);
+		hash = hash >>> 0; // keep 32-bit unsigned
+	}
+	return hash % 360;
+}
+
+/**
+ * Convert HSL (h: 0-360, s: 0-1, l: 0-1) to a CSS hex string.
+ */
+function hslToHex(h: number, s: number, l: number): string {
+	const a = s * Math.min(l, 1 - l);
+	const f = (n: number) => {
+		const k = (n + h / 30) % 12;
+		const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+		return Math.round(255 * color)
+			.toString(16)
+			.padStart(2, "0");
+	};
+	return `#${f(0)}${f(8)}${f(4)}`;
+}
+
+/**
+ * Derive a stable CSS hex accent color from a session name.
+ * High saturation, vivid — suitable for both status bar text and border coloring.
+ */
+export function getSessionAccentHex(name: string): string {
+	return hslToHex(nameToHue(name), 0.9, 0.72);
+}
+
+/**
+ * Auto-generated titles should not drive the session accent.
+ * Legacy sessions with unknown title source keep the old behavior.
+ */
+export function getSessionAccentHexForTitle(
+	name: string | undefined,
+	titleSource: "auto" | "user" | undefined,
+): string | undefined {
+	if (!name || titleSource === "auto") return undefined;
+	return getSessionAccentHex(name);
+}
+
+/**
+ * Convert a hex accent color to an ANSI-16m foreground escape sequence.
+ * Returns `undefined` if `hex` is nullish or Bun.color conversion fails.
+ */
+export function getSessionAccentAnsi(hex: string | undefined): string | undefined {
+	if (!hex) return undefined;
+	return Bun.color(hex, "ansi-16m") ?? undefined;
+}

package/src/utils/title-generator.ts

@@ -27,7 +27,7 @@ function getTitleModel(
 	const availableModels = registry.getAvailable();
 	if (availableModels.length === 0) return undefined;
 
-	const titleModel = resolveRoleSelection(["commit", "smol"], settings, availableModels);
+	const titleModel = resolveRoleSelection(["commit", "smol"], settings, availableModels, registry);
 	if (titleModel) {
 		return { model: titleModel.model, thinkingLevel: titleModel.thinkingLevel };
 	}
@@ -153,20 +153,29 @@ function getFallbackTerminalTitle(cwd: string | undefined): string | undefined {
 	return sanitizeTerminalTitlePart(baseName);
 }
 
-export function formatSessionTerminalTitle(sessionName: string | undefined, cwd?: string): string {
-	const label = sanitizeTerminalTitlePart(sessionName) ?? getFallbackTerminalTitle(cwd);
+export function formatSessionTerminalTitle(
+	sessionName: string | undefined,
+	cwd?: string,
+	titleSource?: "auto" | "user" | undefined,
+): string {
+	const label =
+		sanitizeTerminalTitlePart(titleSource === "auto" ? undefined : sessionName) ?? getFallbackTerminalTitle(cwd);
 	return label ? `${DEFAULT_TERMINAL_TITLE}: ${label}` : DEFAULT_TERMINAL_TITLE;
 }
 
 /**
- * Set the terminal title using OSC 2. Unsupported terminals ignore it.
+ * Set the terminal title using OSC 0 (sets both tab and window title). Unsupported terminals ignore it.
  */
 export function setTerminalTitle(title: string): void {
-	process.stdout.write(`\x1b]2;${sanitizeTerminalTitlePart(title) ?? DEFAULT_TERMINAL_TITLE}\x07`);
+	process.stdout.write(`\x1b]0;${sanitizeTerminalTitlePart(title) ?? DEFAULT_TERMINAL_TITLE}\x07`);
 }
 
-export function setSessionTerminalTitle(sessionName: string | undefined, cwd?: string): void {
-	setTerminalTitle(formatSessionTerminalTitle(sessionName, cwd));
+export function setSessionTerminalTitle(
+	sessionName: string | undefined,
+	cwd?: string,
+	titleSource?: "auto" | "user" | undefined,
+): void {
+	setTerminalTitle(formatSessionTerminalTitle(sessionName, cwd, titleSource));
 }
 
 /**