@yeshwanthyk/coding-agent 0.3.0 → 0.3.2

package/src/keyboard-handler.ts

@@ -1,134 +0,0 @@
-/**
- * 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

@@ -1,40 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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

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

package/src/session-picker.tsx

@@ -1,134 +0,0 @@
-/**
- * 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: {},
-			}
-		)
-	})
-}