@oh-my-pi/pi-coding-agent 6.8.5 → 6.9.0

package/src/core/voice.ts

@@ -1,314 +0,0 @@
-import { unlinkSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { completeSimple, type Model } from "@oh-my-pi/pi-ai";
-import { logger } from "@oh-my-pi/pi-utils";
-import { nanoid } from "nanoid";
-import voiceSummaryPrompt from "../prompts/voice-summary.md" with { type: "text" };
-import type { ModelRegistry } from "./model-registry";
-import { findSmolModel } from "./model-resolver";
-import { renderPromptTemplate } from "./prompt-templates";
-import type { VoiceSettings } from "./settings-manager";
-
-const DEFAULT_SAMPLE_RATE = 16000;
-const DEFAULT_CHANNELS = 1;
-const DEFAULT_BITS = 16;
-const SUMMARY_MAX_CHARS = 6000;
-const VOICE_SUMMARY_PROMPT = renderPromptTemplate(voiceSummaryPrompt);
-
-export interface VoiceRecordingHandle {
-	filePath: string;
-	stop: () => Promise<void>;
-	cancel: () => Promise<void>;
-	cleanup: () => void;
-}
-
-export class VoiceRecording implements VoiceRecordingHandle {
-	readonly filePath: string;
-	private proc: ReturnType<typeof Bun.spawn>;
-
-	constructor(_settings: VoiceSettings) {
-		const sampleRate = DEFAULT_SAMPLE_RATE;
-		const channels = DEFAULT_CHANNELS;
-		this.filePath = join(tmpdir(), `omp-voice-${nanoid()}.wav`);
-		const command = buildRecordingCommand(this.filePath, sampleRate, channels);
-		if (!command) {
-			throw new Error("No audio recorder found (install sox, arecord, or ffmpeg).");
-		}
-
-		logger.debug("voice: starting recorder", { command });
-		this.proc = Bun.spawn(command, {
-			stdin: "ignore",
-			stdout: "ignore",
-			stderr: "pipe",
-		});
-	}
-
-	async stop(): Promise<void> {
-		try {
-			this.proc.kill();
-		} catch {
-			// ignore
-		}
-		await this.proc.exited;
-	}
-
-	cleanup(): void {
-		try {
-			unlinkSync(this.filePath);
-		} catch {
-			// ignore cleanup errors
-		}
-	}
-
-	async cancel(): Promise<void> {
-		await this.stop();
-		this.cleanup();
-	}
-}
-
-export interface VoiceTranscriptionResult {
-	text: string;
-}
-
-export interface VoiceSynthesisResult {
-	audio: Uint8Array;
-	format: "wav" | "mp3" | "opus" | "aac" | "flac";
-}
-
-function buildRecordingCommand(filePath: string, sampleRate: number, channels: number): string[] | null {
-	const soxPath = Bun.which("sox") ?? Bun.which("rec");
-	if (soxPath) {
-		return [soxPath, "-d", "-r", String(sampleRate), "-c", String(channels), "-b", String(DEFAULT_BITS), filePath];
-	}
-
-	const arecordPath = Bun.which("arecord");
-	if (arecordPath) {
-		return [arecordPath, "-f", "S16_LE", "-r", String(sampleRate), "-c", String(channels), filePath];
-	}
-
-	const ffmpegPath = Bun.which("ffmpeg");
-	if (ffmpegPath) {
-		const platform = process.platform;
-		if (platform === "darwin") {
-			// avfoundation default input device; users can override by installing sox for reliability.
-			return [
-				ffmpegPath,
-				"-f",
-				"avfoundation",
-				"-i",
-				":0",
-				"-ac",
-				String(channels),
-				"-ar",
-				String(sampleRate),
-				"-y",
-				filePath,
-			];
-		}
-		if (platform === "linux") {
-			// alsa default input device (commonly "default").
-			return [
-				ffmpegPath,
-				"-f",
-				"alsa",
-				"-i",
-				"default",
-				"-ac",
-				String(channels),
-				"-ar",
-				String(sampleRate),
-				"-y",
-				filePath,
-			];
-		}
-		if (platform === "win32") {
-			// dshow default input device name varies; "audio=default" is a best-effort fallback.
-			return [
-				ffmpegPath,
-				"-f",
-				"dshow",
-				"-i",
-				"audio=default",
-				"-ac",
-				String(channels),
-				"-ar",
-				String(sampleRate),
-				"-y",
-				filePath,
-			];
-		}
-	}
-
-	return null;
-}
-
-export async function transcribeAudio(
-	filePath: string,
-	apiKey: string,
-	settings: VoiceSettings,
-): Promise<VoiceTranscriptionResult> {
-	const file = Bun.file(filePath);
-	const buffer = await file.arrayBuffer();
-	const blob = new File([buffer], "speech.wav", { type: "audio/wav" });
-	const form = new FormData();
-	form.append("file", blob);
-	form.append("model", settings.transcriptionModel ?? "whisper-1");
-	if (settings.transcriptionLanguage) {
-		form.append("language", settings.transcriptionLanguage);
-	}
-
-	const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
-		method: "POST",
-		headers: { Authorization: `Bearer ${apiKey}` },
-		body: form,
-	});
-
-	if (!response.ok) {
-		const errText = await response.text();
-		throw new Error(`Whisper transcription failed: ${response.status} ${errText}`);
-	}
-
-	const data = (await response.json()) as { text?: string };
-	return { text: (data.text ?? "").trim() };
-}
-
-export async function synthesizeSpeech(
-	text: string,
-	apiKey: string,
-	settings: VoiceSettings,
-): Promise<VoiceSynthesisResult> {
-	const format = settings.ttsFormat ?? "wav";
-	const response = await fetch("https://api.openai.com/v1/audio/speech", {
-		method: "POST",
-		headers: {
-			Authorization: `Bearer ${apiKey}`,
-			"Content-Type": "application/json",
-		},
-		body: JSON.stringify({
-			model: settings.ttsModel ?? "tts-1",
-			voice: settings.ttsVoice ?? "alloy",
-			format,
-			input: text,
-		}),
-	});
-
-	if (!response.ok) {
-		const errText = await response.text();
-		throw new Error(`TTS synthesis failed: ${response.status} ${errText}`);
-	}
-
-	const audio = new Uint8Array(await response.arrayBuffer());
-	return { audio, format };
-}
-
-function getPlayerCommand(filePath: string, format: VoiceSynthesisResult["format"]): string[] | null {
-	const platform = process.platform;
-	if (platform === "darwin") {
-		const afplay = Bun.which("afplay");
-		if (afplay) return [afplay, filePath];
-	}
-
-	if (platform === "linux") {
-		const paplay = Bun.which("paplay");
-		if (paplay) return [paplay, filePath];
-		const aplay = Bun.which("aplay");
-		if (aplay) return [aplay, filePath];
-		const ffplay = Bun.which("ffplay");
-		if (ffplay) return [ffplay, "-autoexit", "-nodisp", filePath];
-		const play = Bun.which("play");
-		if (play) return [play, filePath];
-	}
-
-	if (platform === "win32") {
-		if (format !== "wav") {
-			return null;
-		}
-		const ps = Bun.which("powershell");
-		if (ps) {
-			return [
-				ps,
-				"-NoProfile",
-				"-Command",
-				`(New-Object Media.SoundPlayer '${filePath.replace(/'/g, "''")}').PlaySync()`,
-			];
-		}
-	}
-
-	return null;
-}
-
-export async function playAudio(audio: Uint8Array, format: VoiceSynthesisResult["format"]): Promise<void> {
-	const filePath = join(tmpdir(), `omp-tts-${nanoid()}.${format}`);
-	await Bun.write(filePath, audio);
-
-	const command = getPlayerCommand(filePath, format);
-	if (!command) {
-		throw new Error("No audio player available for playback.");
-	}
-
-	const proc = Bun.spawn(command, {
-		stdin: "ignore",
-		stdout: "ignore",
-		stderr: "pipe",
-	});
-	await proc.exited;
-
-	try {
-		unlinkSync(filePath);
-	} catch {
-		// ignore cleanup errors
-	}
-}
-
-function extractTextFromResponse(response: { content: Array<{ type: string; text?: string }> }): string {
-	let text = "";
-	for (const content of response.content) {
-		if (content.type === "text" && content.text) {
-			text += content.text;
-		}
-	}
-	return text.trim();
-}
-
-export async function summarizeForVoice(
-	text: string,
-	registry: ModelRegistry,
-	savedSmolModel?: string,
-): Promise<string | null> {
-	const model = await findSmolModel(registry, savedSmolModel);
-	if (!model) {
-		logger.debug("voice: no smol model found for summary");
-		return null;
-	}
-
-	const apiKey = await registry.getApiKey(model);
-	if (!apiKey) {
-		logger.debug("voice: no API key for summary model", { provider: model.provider, id: model.id });
-		return null;
-	}
-
-	const truncated = text.length > SUMMARY_MAX_CHARS ? `${text.slice(0, SUMMARY_MAX_CHARS)}...` : text;
-	const request = {
-		model: `${model.provider}/${model.id}`,
-		systemPrompt: VOICE_SUMMARY_PROMPT,
-		userMessage: `<assistant_response>\n${truncated}\n</assistant_response>`,
-	};
-	logger.debug("voice: summary request", request);
-
-	try {
-		const response = await completeSimple(
-			model as Model<any>,
-			{
-				systemPrompt: request.systemPrompt,
-				messages: [{ role: "user", content: request.userMessage, timestamp: Date.now() }],
-			},
-			{ apiKey, maxTokens: 120 },
-		);
-		const summary = extractTextFromResponse(response);
-		return summary || null;
-	} catch (error) {
-		logger.debug("voice: summary error", { error: error instanceof Error ? error.message : String(error) });
-		return null;
-	}
-}

package/src/lib/worktree/collapse.ts

@@ -1,180 +0,0 @@
-import { nanoid } from "nanoid";
-import { WorktreeError, WorktreeErrorCode } from "./errors";
-import { git, gitWithInput } from "./git";
-import { find, remove, type Worktree } from "./operations";
-
-export type CollapseStrategy = "simple" | "merge-base" | "rebase";
-
-export interface CollapseOptions {
-	strategy?: CollapseStrategy;
-	keepSource?: boolean;
-}
-
-export interface CollapseResult {
-	filesChanged: number;
-	insertions: number;
-	deletions: number;
-}
-
-function diffStats(diff: string): CollapseResult {
-	let filesChanged = 0;
-	let insertions = 0;
-	let deletions = 0;
-
-	for (const line of diff.split("\n")) {
-		if (line.startsWith("diff --git ")) {
-			filesChanged += 1;
-			continue;
-		}
-		if (line.startsWith("+++") || line.startsWith("---")) continue;
-		if (line.startsWith("+")) {
-			insertions += 1;
-			continue;
-		}
-		if (line.startsWith("-")) {
-			deletions += 1;
-		}
-	}
-
-	return { filesChanged, insertions, deletions };
-}
-
-async function requireGitSuccess(result: { code: number; stderr: string }, message: string): Promise<void> {
-	if (result.code !== 0) {
-		throw new WorktreeError(
-			message + (result.stderr ? `\n${result.stderr.trim()}` : ""),
-			WorktreeErrorCode.COLLAPSE_FAILED,
-		);
-	}
-}
-
-async function ensureHasChanges(result: { stdout: string }): Promise<string> {
-	const diff = result.stdout;
-	if (!diff.trim()) {
-		throw new WorktreeError("No changes to collapse", WorktreeErrorCode.NO_CHANGES);
-	}
-	return diff;
-}
-
-async function collapseSimple(src: Worktree): Promise<string> {
-	await requireGitSuccess(await git(["add", "-A"], src.path), "Failed to stage changes");
-	return ensureHasChanges(await git(["diff", "HEAD"], src.path));
-}
-
-async function collapseMergeBase(src: Worktree, dst: Worktree): Promise<string> {
-	await requireGitSuccess(await git(["add", "-A"], src.path), "Failed to stage changes");
-
-	const baseResult = await git(["merge-base", "HEAD", dst.branch ?? "HEAD"], src.path);
-	if (baseResult.code !== 0) {
-		throw new WorktreeError("Could not find merge base", WorktreeErrorCode.COLLAPSE_FAILED);
-	}
-
-	const base = baseResult.stdout.trim();
-	if (!base) {
-		throw new WorktreeError("Could not find merge base", WorktreeErrorCode.COLLAPSE_FAILED);
-	}
-
-	return ensureHasChanges(await git(["diff", base], src.path));
-}
-
-async function collapseRebase(src: Worktree, dst: Worktree): Promise<string> {
-	await requireGitSuccess(await git(["add", "-A"], src.path), "Failed to stage changes");
-
-	const stagedResult = await git(["diff", "--cached", "--name-only"], src.path);
-	if (!stagedResult.stdout.trim()) {
-		throw new WorktreeError("No changes to collapse", WorktreeErrorCode.NO_CHANGES);
-	}
-
-	const headResult = await git(["rev-parse", "HEAD"], src.path);
-	if (headResult.code !== 0) {
-		throw new WorktreeError("Failed to resolve HEAD", WorktreeErrorCode.COLLAPSE_FAILED);
-	}
-	const originalHead = headResult.stdout.trim();
-	const tempBranch = `wt-collapse-${nanoid()}`;
-
-	await requireGitSuccess(await git(["checkout", "-b", tempBranch], src.path), "Failed to create temp branch");
-
-	const commitResult = await git(["commit", "--allow-empty-message", "-m", ""], src.path);
-	if (commitResult.code !== 0) {
-		await git(["checkout", originalHead], src.path);
-		await git(["branch", "-D", tempBranch], src.path);
-		throw new WorktreeError("Failed to commit changes", WorktreeErrorCode.COLLAPSE_FAILED);
-	}
-
-	const rebaseResult = await git(["rebase", dst.branch ?? "HEAD"], src.path);
-	if (rebaseResult.code !== 0) {
-		await git(["rebase", "--abort"], src.path);
-		await git(["checkout", originalHead], src.path);
-		await git(["branch", "-D", tempBranch], src.path);
-		throw new WorktreeError(
-			`Rebase conflicts:${rebaseResult.stderr ? `\n${rebaseResult.stderr.trim()}` : ""}`,
-			WorktreeErrorCode.REBASE_CONFLICTS,
-		);
-	}
-
-	const diffResult = await git(["diff", `${dst.branch ?? "HEAD"}..HEAD`], src.path);
-
-	await git(["checkout", originalHead], src.path);
-	await git(["branch", "-D", tempBranch], src.path);
-
-	return ensureHasChanges(diffResult);
-}
-
-async function applyDiff(diff: string, targetPath: string): Promise<void> {
-	let result = await gitWithInput(["apply"], diff, targetPath);
-	if (result.code === 0) return;
-
-	result = await gitWithInput(["apply", "--3way"], diff, targetPath);
-	if (result.code === 0) return;
-
-	throw new WorktreeError(
-		`Failed to apply diff:${result.stderr ? `\n${result.stderr.trim()}` : ""}`,
-		WorktreeErrorCode.APPLY_FAILED,
-	);
-}
-
-/**
- * Collapse changes from source worktree into destination.
- */
-export async function collapse(
-	source: string,
-	destination: string,
-	options?: CollapseOptions,
-): Promise<CollapseResult> {
-	const src = await find(source);
-	const dst = await find(destination);
-
-	if (src.path === dst.path) {
-		throw new WorktreeError("Source and destination are the same", WorktreeErrorCode.COLLAPSE_FAILED);
-	}
-
-	if (!options?.keepSource && src.isMain) {
-		throw new WorktreeError("Cannot remove main worktree", WorktreeErrorCode.CANNOT_MODIFY_MAIN);
-	}
-
-	const strategy = options?.strategy ?? "rebase";
-	let diff: string;
-
-	switch (strategy) {
-		case "simple":
-			diff = await collapseSimple(src);
-			break;
-		case "merge-base":
-			diff = await collapseMergeBase(src, dst);
-			break;
-		case "rebase":
-			diff = await collapseRebase(src, dst);
-			break;
-		default:
-			throw new WorktreeError(`Unknown strategy: ${strategy}`, WorktreeErrorCode.COLLAPSE_FAILED);
-	}
-
-	const stats = diffStats(diff);
-	await applyDiff(diff, dst.path);
-
-	if (!options?.keepSource) {
-		await remove(src.path, { force: true });
-	}
-
-	return stats;
-}

package/src/lib/worktree/constants.ts

@@ -1,14 +0,0 @@
-import { accessSync, constants } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-function getWorktreeBase(): string {
-	try {
-		accessSync("/work", constants.W_OK);
-		return "/work/.tree";
-	} catch {
-		return path.join(os.tmpdir(), ".tree");
-	}
-}
-
-export const WORKTREE_BASE = getWorktreeBase();

package/src/lib/worktree/errors.ts

@@ -1,23 +0,0 @@
-export enum WorktreeErrorCode {
-	NOT_GIT_REPO = "NOT_GIT_REPO",
-	WORKTREE_NOT_FOUND = "WORKTREE_NOT_FOUND",
-	WORKTREE_EXISTS = "WORKTREE_EXISTS",
-	CANNOT_MODIFY_MAIN = "CANNOT_MODIFY_MAIN",
-	NO_CHANGES = "NO_CHANGES",
-	COLLAPSE_FAILED = "COLLAPSE_FAILED",
-	REBASE_CONFLICTS = "REBASE_CONFLICTS",
-	APPLY_FAILED = "APPLY_FAILED",
-	OVERLAPPING_SCOPES = "OVERLAPPING_SCOPES",
-}
-
-export class WorktreeError extends Error {
-	readonly code: WorktreeErrorCode;
-	readonly cause?: Error;
-
-	constructor(message: string, code: WorktreeErrorCode, cause?: Error) {
-		super(message);
-		this.name = "WorktreeError";
-		this.code = code;
-		this.cause = cause;
-	}
-}

package/src/lib/worktree/git.ts

@@ -1,60 +0,0 @@
-import * as path from "node:path";
-import { ptree } from "@oh-my-pi/pi-utils";
-import { execCommand } from "../../core/exec";
-import { WorktreeError, WorktreeErrorCode } from "./errors";
-
-export interface GitResult {
-	code: number;
-	stdout: string;
-	stderr: string;
-}
-
-/**
- * Execute a git command.
- * @param args - Command arguments (excluding 'git')
- * @param cwd - Working directory (optional)
- * @returns Promise<GitResult>
- */
-export async function git(args: string[], cwd?: string): Promise<GitResult> {
-	const result = await execCommand("git", args, cwd ?? process.cwd());
-	return { code: result.code, stdout: result.stdout, stderr: result.stderr };
-}
-
-/**
- * Execute git command with stdin input.
- * Used for piping diffs to `git apply`.
- */
-export async function gitWithInput(args: string[], stdin: string, cwd?: string): Promise<GitResult> {
-	const proc = ptree.cspawn(["git", ...args], {
-		cwd: cwd ?? process.cwd(),
-		stdin: Buffer.from(stdin),
-	});
-
-	const [stdout, stderr] = await Promise.all([proc.stdout.text(), proc.stderr.text()]);
-
-	return { code: proc.exitCode ?? 0, stdout, stderr };
-}
-
-/**
- * Get repository root directory.
- * @throws Error if not in a git repository
- */
-export async function getRepoRoot(cwd?: string): Promise<string> {
-	const result = await git(["rev-parse", "--show-toplevel"], cwd ?? process.cwd());
-	if (result.code !== 0) {
-		throw new WorktreeError("Not a git repository", WorktreeErrorCode.NOT_GIT_REPO);
-	}
-	const root = result.stdout.trim();
-	if (!root) {
-		throw new WorktreeError("Not a git repository", WorktreeErrorCode.NOT_GIT_REPO);
-	}
-	return path.resolve(root);
-}
-
-/**
- * Get repository name (directory basename of repo root).
- */
-export async function getRepoName(cwd?: string): Promise<string> {
-	const root = await getRepoRoot(cwd);
-	return path.basename(root);
-}

package/src/lib/worktree/index.ts

@@ -1,15 +0,0 @@
-export { type CollapseOptions, type CollapseResult, type CollapseStrategy, collapse } from "./collapse";
-export { WORKTREE_BASE } from "./constants";
-export { WorktreeError, WorktreeErrorCode } from "./errors";
-export { getRepoName, getRepoRoot, git, gitWithInput as gitWithStdin } from "./git";
-export { create, find, list, prune, remove, type Worktree, which } from "./operations";
-export {
-	cleanupSessions,
-	createSession,
-	getSession,
-	listSessions,
-	type SessionStatus,
-	updateSession,
-	type WorktreeSession,
-} from "./session";
-export { formatStats, getStats, type WorktreeStats } from "./stats";