@yeshwanthyk/coding-agent 0.2.2

package/src/keyboard-handler.ts

@@ -0,0 +1,134 @@
+/**
+ * Keyboard event handling for TUI application
+ */
+
+import type { KeyEvent } from "@opentui/core"
+
+export interface KeyboardHandlerConfig {
+	// Autocomplete state getters
+	showAutocomplete: () => boolean
+	autocompleteItems: () => Array<{ label: string; description?: string }>
+	setAutocompleteIndex: (updater: (i: number) => number) => void
+	setShowAutocomplete: (v: boolean) => void
+	applyAutocomplete: () => boolean
+
+	// Responding state (getters for reactivity)
+	isResponding: () => boolean
+	retryStatus: () => string | null
+
+	// Actions
+	onAbort: () => string | null
+	onToggleThinking: () => void
+	onCycleModel: () => void
+	onCycleThinking: () => void
+	toggleLastToolExpanded: () => void
+	copySelectionToClipboard: () => void
+
+	// Editor control
+	clearEditor: () => void
+	setEditorText: (text: string) => void
+
+	// Ctrl+C timing
+	lastCtrlC: { current: number }
+
+	// Exit handler (must be called for proper cleanup)
+	onExit: () => void
+}
+
+export function createKeyboardHandler(config: KeyboardHandlerConfig): (e: KeyEvent) => void {
+	return (e: KeyEvent) => {
+		// Autocomplete navigation
+		if (config.showAutocomplete()) {
+			const items = config.autocompleteItems()
+			if (e.name === "up") {
+				config.setAutocompleteIndex((i) => (i > 0 ? i - 1 : items.length - 1))
+				e.preventDefault()
+				return
+			}
+			if (e.name === "down") {
+				config.setAutocompleteIndex((i) => (i < items.length - 1 ? i + 1 : 0))
+				e.preventDefault()
+				return
+			}
+			if (e.name === "tab" || e.name === "return") {
+				if (config.applyAutocomplete()) {
+					e.preventDefault()
+					return
+				}
+			}
+			if (e.name === "escape") {
+				config.setShowAutocomplete(false)
+				e.preventDefault()
+				return
+			}
+		}
+
+		// Ctrl+N/Ctrl+P for autocomplete navigation
+		if (config.showAutocomplete() && e.ctrl && (e.name === "n" || e.name === "p")) {
+			const items = config.autocompleteItems()
+			if (e.name === "n") {
+				config.setAutocompleteIndex((i) => (i < items.length - 1 ? i + 1 : 0))
+			} else {
+				config.setAutocompleteIndex((i) => (i > 0 ? i - 1 : items.length - 1))
+			}
+			e.preventDefault()
+			return
+		}
+
+		// Ctrl+C - clear or exit
+		if (e.ctrl && e.name === "c") {
+			const now = Date.now()
+			if (now - config.lastCtrlC.current < 750) {
+				config.onExit()
+			} else {
+				config.clearEditor()
+			}
+			config.lastCtrlC.current = now
+			e.preventDefault()
+			return
+		}
+
+		// Escape - abort if responding
+		if (e.name === "escape" && (config.isResponding() || config.retryStatus())) {
+			const restore = config.onAbort()
+			if (restore) config.setEditorText(restore)
+			e.preventDefault()
+			return
+		}
+
+		// Ctrl+O - toggle latest tool block
+		if (e.ctrl && e.name === "o") {
+			config.toggleLastToolExpanded()
+			e.preventDefault()
+			return
+		}
+
+		// Ctrl+T - toggle thinking visibility
+		if (e.ctrl && e.name === "t") {
+			config.onToggleThinking()
+			e.preventDefault()
+			return
+		}
+
+		// Ctrl+P - cycle model
+		if (e.ctrl && e.name === "p") {
+			config.onCycleModel()
+			e.preventDefault()
+			return
+		}
+
+		// Ctrl+Y - copy selection to clipboard
+		if (e.ctrl && e.name === "y") {
+			config.copySelectionToClipboard()
+			e.preventDefault()
+			return
+		}
+
+		// Shift+Tab - cycle thinking level
+		if (e.shift && e.name === "tab") {
+			config.onCycleThinking()
+			e.preventDefault()
+			return
+		}
+	}
+}

package/src/profiler.ts

@@ -0,0 +1,40 @@
+import { performance } from "node:perf_hooks"
+
+type Stat = { count: number; totalMs: number; maxMs: number }
+
+const enabled = process.env["MARVIN_TUI_PROFILE"] === "1"
+const reportEveryMs = 2000
+const stats = new Map<string, Stat>()
+let lastReport = performance.now()
+
+function record(name: string, ms: number): void {
+	if (!enabled) return
+	const stat = stats.get(name) ?? { count: 0, totalMs: 0, maxMs: 0 }
+	stat.count += 1
+	stat.totalMs += ms
+	if (ms > stat.maxMs) stat.maxMs = ms
+	stats.set(name, stat)
+
+	const now = performance.now()
+	if (now - lastReport < reportEveryMs) return
+	lastReport = now
+	try {
+		for (const [key, s] of stats) {
+			const avg = s.totalMs / Math.max(1, s.count)
+			process.stderr.write(`[perf] ${key} avg=${avg.toFixed(1)}ms max=${s.maxMs.toFixed(1)}ms n=${s.count}\n`)
+			s.count = 0
+			s.totalMs = 0
+			s.maxMs = 0
+		}
+	} catch {}
+}
+
+export function profile<T>(name: string, fn: () => T): T {
+	if (!enabled) return fn()
+	const start = performance.now()
+	try {
+		return fn()
+	} finally {
+		record(name, performance.now() - start)
+	}
+}

package/src/runtime/context.tsx

@@ -0,0 +1,16 @@
+import { createContext, useContext, type JSX } from "solid-js"
+import type { RuntimeContext as RuntimeServices } from "./factory.js"
+
+const RuntimeContext = createContext<RuntimeServices | null>(null)
+
+export const RuntimeProvider = (props: { runtime: RuntimeServices; children: JSX.Element }) => (
+	<RuntimeContext.Provider value={props.runtime}>{props.children}</RuntimeContext.Provider>
+)
+
+export const useRuntime = (): RuntimeServices => {
+	const ctx = useContext(RuntimeContext)
+	if (!ctx) {
+		throw new Error("RuntimeContext not found")
+	}
+	return ctx
+}

package/src/runtime/factory.ts

@@ -0,0 +1,63 @@
+import { Context, Effect, Exit, Layer, Scope } from "effect";
+import {
+  RuntimeLayer,
+  RuntimeServicesTag,
+  type AdapterKind,
+  type RuntimeLayerOptions,
+  type RuntimeServices,
+} from "@yeshwanthyk/runtime-effect/runtime.js";
+import type { LoadConfigOptions } from "@yeshwanthyk/runtime-effect/config.js";
+
+export type RuntimeInitArgs = LoadConfigOptions;
+
+export type RuntimeContext = RuntimeServices & {
+  /**
+   * Explicitly shuts down the runtime scope, allowing services like the LSP
+   * manager to flush state before the process exits.
+   */
+  close: () => Promise<void>;
+};
+
+const toLayerOptions = (args: RuntimeInitArgs | undefined, adapter: AdapterKind): RuntimeLayerOptions => ({
+  adapter,
+  configDir: args?.configDir,
+  configPath: args?.configPath,
+  provider: args?.provider,
+  model: args?.model,
+  thinking: args?.thinking,
+});
+
+export const createRuntime = async (
+  args: RuntimeInitArgs = {},
+  adapter: AdapterKind = "tui",
+): Promise<RuntimeContext> => {
+  const layer = RuntimeLayer(toLayerOptions(args, adapter)) as Layer.Layer<RuntimeServices, never, never>;
+
+  const setupEffect = Effect.gen(function* () {
+    const scope = yield* Scope.make();
+    const context = yield* Layer.buildWithScope(layer, scope);
+    const services = Context.get(context, RuntimeServicesTag);
+    return { services, scope };
+  });
+
+  const { services, scope } = await Effect.runPromise(setupEffect);
+
+  let closed = false;
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    process.removeListener("exit", exitHandler);
+    await Effect.runPromise(Scope.close(scope, Exit.void));
+  };
+
+  const exitHandler = () => {
+    void close();
+  };
+
+  process.once("exit", exitHandler);
+
+  return {
+    ...services,
+    close,
+  };
+};

package/src/runtime/git/git-info.ts

@@ -0,0 +1,25 @@
+import { existsSync, readFileSync } from "fs"
+import { dirname, join } from "path"
+
+export const findGitHeadPath = (startDir: string = process.cwd()): string | null => {
+	let dir = startDir
+	while (true) {
+		const gitHeadPath = join(dir, ".git", "HEAD")
+		if (existsSync(gitHeadPath)) return gitHeadPath
+		const parent = dirname(dir)
+		if (parent === dir) return null
+		dir = parent
+	}
+}
+
+export const getCurrentBranch = (startDir?: string): string | null => {
+	try {
+		const gitHeadPath = findGitHeadPath(startDir)
+		if (!gitHeadPath) return null
+		const content = readFileSync(gitHeadPath, "utf8").trim()
+		if (content.startsWith("ref: refs/heads/")) return content.slice(16)
+		return "detached"
+	} catch {
+		return null
+	}
+}

package/src/runtime/session/session-controller.ts

@@ -0,0 +1,208 @@
+import type { Agent, ThinkingLevel, AppMessage } from "@yeshwanthyk/agent-core"
+import type { Api, Model, KnownProvider } from "@yeshwanthyk/ai"
+import type { HookRunner } from "../../hooks/index.js"
+import type { SessionManager, LoadedSession } from "../../session-manager.js"
+import type { UIMessage, ToolBlock, UIContentBlock, UIShellMessage } from "../../types.js"
+import {
+	extractOrderedBlocks,
+	extractThinking,
+	extractToolCalls,
+	extractText,
+	getEditDiffText,
+	getToolText,
+} from "@domain/messaging/content.js"
+import { resolveProvider, resolveModel } from "@domain/commands/helpers.js"
+import type { PromptDeliveryMode, PromptQueue } from "@yeshwanthyk/runtime-effect/session/prompt-queue.js"
+
+export interface SessionControllerOptions {
+	initialProvider: KnownProvider
+	initialModel: Model<Api>
+	initialModelId: string
+	initialThinking: ThinkingLevel
+	agent: Agent
+	sessionManager: SessionManager
+	hookRunner: HookRunner
+	toolByName: Map<string, { label: string; source: "builtin" | "custom"; sourcePath?: string; renderCall?: any; renderResult?: any }>
+	setMessages: (updater: (prev: UIMessage[]) => UIMessage[]) => void
+	setContextTokens: (v: number) => void
+	setDisplayProvider: (provider: KnownProvider) => void
+	setDisplayModelId: (id: string) => void
+	setDisplayThinking: (v: ThinkingLevel) => void
+	setDisplayContextWindow: (v: number) => void
+	shellInjectionPrefix: string
+	promptQueue?: PromptQueue
+}
+
+export interface SessionControllerState {
+	ensureSession: () => void
+	restoreSession: (session: LoadedSession) => void
+	currentProvider: () => KnownProvider
+	setCurrentProvider: (p: KnownProvider) => void
+	currentModelId: () => string
+	setCurrentModelId: (id: string) => void
+	currentThinking: () => ThinkingLevel
+	setCurrentThinking: (t: ThinkingLevel) => void
+	isSessionStarted: () => boolean
+	followUp: (text: string) => Promise<void>
+	steer: (text: string) => Promise<void>
+	sendUserMessage: (text: string, options?: { deliverAs?: PromptDeliveryMode }) => Promise<void>
+}
+
+export function createSessionController(options: SessionControllerOptions): SessionControllerState {
+	let sessionStarted = false
+	let currentProvider = options.initialProvider
+	let currentModelId = options.initialModelId
+	let currentThinking = options.initialThinking
+
+	options.setDisplayProvider(currentProvider)
+
+	const ensureSession = () => {
+		if (!sessionStarted) {
+			options.sessionManager.startSession(currentProvider, currentModelId, currentThinking)
+			sessionStarted = true
+			void options.hookRunner.emit({ type: "session.start", sessionId: options.sessionManager.sessionId })
+		}
+	}
+
+	const restoreSession = (session: LoadedSession) => {
+		const { metadata } = session
+		const sessionMessages = session.messages as AppMessage[]
+		const resolvedProvider = resolveProvider(metadata.provider)
+		if (resolvedProvider) {
+			const resolvedModel = resolveModel(resolvedProvider, metadata.modelId)
+			if (resolvedModel) {
+				currentProvider = resolvedProvider
+				currentModelId = resolvedModel.id
+				currentThinking = metadata.thinkingLevel
+				options.setDisplayProvider(resolvedProvider)
+				options.agent.setModel(resolvedModel)
+				options.agent.setThinkingLevel(metadata.thinkingLevel)
+				options.setDisplayModelId(resolvedModel.id)
+				options.setDisplayThinking(metadata.thinkingLevel)
+				options.setDisplayContextWindow(resolvedModel.contextWindow)
+			}
+		}
+		options.agent.replaceMessages(sessionMessages)
+
+		for (let i = sessionMessages.length - 1; i >= 0; i--) {
+			const msg = sessionMessages[i] as { role: string; usage?: { totalTokens?: number } }
+			if (msg.role === "assistant" && msg.usage?.totalTokens) {
+				options.setContextTokens(msg.usage.totalTokens)
+				break
+			}
+		}
+
+		const toolResultMap = new Map<string, { output: string; editDiff: string | null; isError: boolean }>()
+		for (const msg of sessionMessages) {
+			if (msg.role === "toolResult") {
+				toolResultMap.set(msg.toolCallId, {
+					output: getToolText(msg),
+					editDiff: getEditDiffText(msg),
+					isError: msg.isError ?? false,
+				})
+			}
+		}
+
+		const uiMessages: UIMessage[] = []
+		for (const msg of sessionMessages) {
+			if (msg.role === "user") {
+				const contentText = typeof msg.content === "string" ? msg.content : extractText(msg.content as unknown[])
+				if (contentText.startsWith(options.shellInjectionPrefix)) continue
+				uiMessages.push({ id: crypto.randomUUID(), role: "user", content: contentText })
+			} else if (msg.role === "assistant") {
+				const text = extractText(msg.content as unknown[])
+				const thinking = extractThinking(msg.content as unknown[])
+				const toolCalls = extractToolCalls(msg.content as unknown[])
+				const tools: ToolBlock[] = toolCalls.map((tc) => {
+					const result = toolResultMap.get(tc.id)
+					const meta = options.toolByName.get(tc.name)
+					return {
+						id: tc.id,
+						name: tc.name,
+						args: tc.args,
+						output: result?.output,
+						editDiff: result?.editDiff || undefined,
+						isError: result?.isError ?? false,
+						isComplete: true,
+						label: meta?.label,
+						source: meta?.source,
+						sourcePath: meta?.sourcePath,
+						renderCall: meta?.renderCall,
+						renderResult: meta?.renderResult,
+					}
+				})
+				const orderedBlocks = extractOrderedBlocks(msg.content as unknown[])
+				const contentBlocks: UIContentBlock[] = orderedBlocks.map((block) => {
+					if (block.type === "thinking") {
+						return { type: "thinking", id: block.id, summary: block.summary, preview: block.preview, full: block.full }
+					} else if (block.type === "text") {
+						return { type: "text", text: block.text }
+					} else {
+						const tool = tools.find((t) => t.id === block.id)
+						return {
+							type: "tool",
+							tool: tool || { id: block.id, name: block.name, args: block.args, isError: false, isComplete: false },
+						}
+					}
+				})
+				uiMessages.push({ id: crypto.randomUUID(), role: "assistant", content: text, thinking: thinking || undefined, isStreaming: false, tools, contentBlocks })
+			} else if ((msg as { role: string }).role === "shell") {
+				const shellMsg = msg as unknown as UIShellMessage
+				uiMessages.push({
+					id: crypto.randomUUID(),
+					role: "shell",
+					command: shellMsg.command,
+					output: shellMsg.output,
+					exitCode: shellMsg.exitCode,
+					truncated: shellMsg.truncated,
+					tempFilePath: shellMsg.tempFilePath,
+					timestamp: shellMsg.timestamp,
+				})
+			}
+		}
+
+		options.setMessages(() => uiMessages)
+		const sessionPath = options.sessionManager.listSessions().find((s) => s.id === metadata.id)?.path || ""
+		options.sessionManager.continueSession(sessionPath, metadata.id)
+		sessionStarted = true
+		void options.hookRunner.emit({ type: "session.resume", sessionId: metadata.id })
+	}
+
+	const queueUserMessage = async (text: string, mode: PromptDeliveryMode) => {
+		const trimmed = text
+		if (!trimmed) return
+		const message: AppMessage = {
+			role: "user",
+			content: [{ type: "text", text: trimmed }],
+			timestamp: Date.now(),
+		}
+		options.promptQueue?.push({ text: trimmed, mode })
+		if (mode === "steer") {
+			await options.agent.steer(message)
+		} else {
+			await options.agent.followUp(message)
+		}
+	}
+
+	return {
+		ensureSession,
+		restoreSession,
+		currentProvider: () => currentProvider,
+		setCurrentProvider: (p) => {
+			currentProvider = p
+			options.setDisplayProvider(p)
+		},
+		currentModelId: () => currentModelId,
+		setCurrentModelId: (id) => {
+			currentModelId = id
+		},
+		currentThinking: () => currentThinking,
+		setCurrentThinking: (t) => {
+			currentThinking = t
+		},
+		isSessionStarted: () => sessionStarted,
+		followUp: (text) => queueUserMessage(text, "followUp"),
+		steer: (text) => queueUserMessage(text, "steer"),
+		sendUserMessage: (text, options) => queueUserMessage(text, options?.deliverAs ?? "followUp"),
+	}
+}

package/src/session-manager.ts

@@ -0,0 +1 @@
+export * from "@yeshwanthyk/runtime-effect/session-manager";

package/src/session-picker.tsx

@@ -0,0 +1,134 @@
+/**
+ * OpenTUI-based session picker
+ */
+
+import { render, useTerminalDimensions, useKeyboard } from "@opentui/solid"
+import { SelectList, ThemeProvider, useTheme, type SelectItem, type SelectListRef, type ThemeMode } from "@yeshwanthyk/open-tui"
+import type { SessionManager } from "./session-manager.js"
+
+/** Detect system dark/light mode (macOS only, defaults to dark) */
+function detectThemeMode(): ThemeMode {
+	try {
+		const result = Bun.spawnSync(["defaults", "read", "-g", "AppleInterfaceStyle"])
+		return result.stdout.toString().trim().toLowerCase() === "dark" ? "dark" : "light"
+	} catch {
+		return "dark"
+	}
+}
+
+interface SessionPickerProps {
+	sessions: Array<{
+		path: string
+		firstMessage: string
+		timestamp: number
+		messageCount: number
+		modelId: string
+	}>
+	onSelect: (path: string) => void
+	onCancel: () => void
+}
+
+function SessionPickerApp(props: SessionPickerProps) {
+	const { theme } = useTheme()
+	const dimensions = useTerminalDimensions()
+	let listRef: SelectListRef | undefined
+
+	const items: SelectItem[] = props.sessions.map((s) => ({
+		value: s.path,
+		label: formatFirstMessage(s.firstMessage),
+		description: formatMeta(s.timestamp, s.messageCount, s.modelId),
+	}))
+
+	useKeyboard((e: { name: string; ctrl?: boolean }) => {
+		if (e.name === "up" || (e.ctrl && e.name === "p")) {
+			listRef?.moveUp()
+		} else if (e.name === "down" || (e.ctrl && e.name === "n")) {
+			listRef?.moveDown()
+		} else if (e.name === "return") {
+			listRef?.select()
+		} else if (e.name === "escape" || (e.ctrl && e.name === "c")) {
+			props.onCancel()
+		}
+	})
+
+	return (
+		<box
+			flexDirection="column"
+			width={dimensions().width}
+			height={dimensions().height}
+		>
+			<text fg={theme.textMuted}>Resume Session</text>
+			<box height={1} />
+			<SelectList
+				ref={(r) => { listRef = r }}
+				items={items}
+				maxVisible={Math.min(10, dimensions().height - 4)}
+				width={dimensions().width - 2}
+				onSelect={(item) => props.onSelect(item.value)}
+				onCancel={props.onCancel}
+			/>
+			<box flexGrow={1} />
+			<text fg={theme.textMuted}>↑/↓ navigate · Enter select · Esc cancel</text>
+		</box>
+	)
+}
+
+function formatFirstMessage(msg: string): string {
+	return msg.replace(/\n/g, " ").slice(0, 60)
+}
+
+function formatMeta(ts: number, count: number, model: string): string {
+	const ago = formatRelativeTime(ts)
+	return `${ago} · ${count} msgs · ${model}`
+}
+
+function formatRelativeTime(ts: number): string {
+	const seconds = Math.floor((Date.now() - ts) / 1000)
+	if (seconds < 60) return `${seconds}s ago`
+	const minutes = Math.floor(seconds / 60)
+	if (minutes < 60) return `${minutes}m ago`
+	const hours = Math.floor(minutes / 60)
+	if (hours < 24) return `${hours}h ago`
+	const days = Math.floor(hours / 24)
+	return `${days}d ago`
+}
+
+export async function selectSession(sessionManager: SessionManager): Promise<string | null> {
+	const sessions = sessionManager.loadAllSessions()
+	if (sessions.length === 0) return null
+	if (sessions.length === 1) return sessions[0]!.path
+
+	return new Promise((resolve) => {
+		let resolved = false
+
+		const doResolve = (value: string | null) => {
+			if (resolved) return
+			resolved = true
+			if (value === null) {
+				// Cancel - exit immediately since we're done
+				process.stdout.write("\nNo session selected\n")
+				process.exit(0)
+			}
+			resolve(value)
+		}
+
+		const themeMode = detectThemeMode()
+
+		render(
+			() => (
+				<ThemeProvider mode={themeMode}>
+					<SessionPickerApp
+						sessions={sessions}
+						onSelect={(path) => doResolve(path)}
+						onCancel={() => doResolve(null)}
+					/>
+				</ThemeProvider>
+			),
+			{
+				targetFps: 30,
+				exitOnCtrlC: false,
+				useKittyKeyboard: {},
+			}
+		)
+	})
+}