@yeshwanthyk/coding-agent 0.2.2

package/src/adapters/acp/session.ts

@@ -0,0 +1,289 @@
+/**
+ * ACP Session - wraps Agent and emits ACP updates
+ */
+
+import type { Agent, AgentEvent, Attachment } from "@yeshwanthyk/agent-core"
+import type { UpdateEmitter } from "./updates.js"
+import type { ContentBlock, SlashCommand, ModelOption, StopReason } from "./protocol.js"
+import { textChunk, thoughtChunk, toolCall, toolCallUpdate, toolNameToKind } from "./updates.js"
+import type { SessionOrchestratorService } from "@yeshwanthyk/runtime-effect/session/orchestrator.js"
+import { Effect } from "effect"
+
+export interface AcpSessionConfig {
+	sessionId: string
+	cwd: string
+	agent: Agent
+	sessionOrchestrator: SessionOrchestratorService
+	emitter: UpdateEmitter
+	models: ModelOption[]
+	currentModelId: string
+	contextWindow: number
+	thinkingLevel: string
+	setModel: (modelId: string) => boolean
+}
+
+export interface AcpSession {
+	id: string
+	cwd: string
+	prompt(content: ContentBlock[]): Promise<StopReason>
+	cancel(): void
+	getAvailableCommands(): SlashCommand[]
+	getModels(): { options: ModelOption[]; currentModelId: string }
+	setModel(modelId: string): boolean
+}
+
+// Slash commands exposed to Zed
+const AVAILABLE_COMMANDS: SlashCommand[] = [
+	{ name: "model", description: "Switch model: /model <modelId>" },
+	{ name: "thinking", description: "Set thinking: /thinking off|minimal|low|medium|high|xhigh" },
+	{ name: "status", description: "Show session status" },
+	{ name: "compact", description: "Compact conversation context" },
+	{ name: "clear", description: "Clear conversation" },
+]
+
+export function createAcpSession(config: AcpSessionConfig): AcpSession {
+	const { sessionId, cwd, agent, emitter, models, contextWindow, sessionOrchestrator } = config
+	let currentModelId = config.currentModelId
+	let thinkingLevel = config.thinkingLevel
+	let cancelled = false
+	let unsubscribe: (() => void) | null = null
+
+	// Track session stats
+	let turnCount = 0
+	let lastUsage: { totalTokens: number; cacheRead?: number; cacheWrite?: number } | null = null
+
+	// Track emitted content to avoid duplicate chunks
+	let lastEmittedTextLen = 0
+	let lastEmittedThinkingLen = 0
+
+	// Subscribe to agent events and emit ACP updates
+	function subscribeToEvents(): () => void {
+		lastEmittedTextLen = 0
+		lastEmittedThinkingLen = 0
+
+		return agent.subscribe((event: AgentEvent) => {
+			if (cancelled) return
+
+			switch (event.type) {
+				case "message_update":
+					if (event.message.role === "assistant") {
+						// Extract text and thinking from content
+						const content = event.message.content as unknown[]
+						let totalText = ""
+						let totalThinking = ""
+
+						for (const block of content) {
+							if (typeof block !== "object" || block === null) continue
+							const b = block as Record<string, unknown>
+							if (b.type === "text" && typeof b.text === "string") {
+								totalText += b.text
+							} else if (b.type === "thinking" && typeof b.thinking === "string") {
+								totalThinking += b.thinking
+							}
+						}
+
+						// Emit only new content (delta)
+						if (totalText.length > lastEmittedTextLen) {
+							const delta = totalText.slice(lastEmittedTextLen)
+							lastEmittedTextLen = totalText.length
+							emitter.emit(textChunk(delta))
+						}
+						if (totalThinking.length > lastEmittedThinkingLen) {
+							const delta = totalThinking.slice(lastEmittedThinkingLen)
+							lastEmittedThinkingLen = totalThinking.length
+							emitter.emit(thoughtChunk(delta))
+						}
+					}
+					break
+
+				case "tool_execution_start":
+					emitter.emit(
+						toolCall(
+							event.toolCallId,
+							event.toolName,
+							toolNameToKind(event.toolName),
+							event.args
+						)
+					)
+					break
+
+				case "tool_execution_update":
+					emitter.emit(
+						toolCallUpdate(
+							event.toolCallId,
+							"in_progress",
+							event.partialResult ? JSON.stringify(event.partialResult) : undefined
+						)
+					)
+					break
+
+				case "tool_execution_end":
+					emitter.emit(
+						toolCallUpdate(
+							event.toolCallId,
+							event.isError ? "failed" : "completed",
+							event.result ? JSON.stringify(event.result) : undefined
+						)
+					)
+					break
+
+				case "message_end":
+					// Capture usage from assistant messages
+					if (event.message.role === "assistant") {
+						const msg = event.message as { usage?: { totalTokens?: number; cacheRead?: number; cacheWrite?: number } }
+						if (msg.usage?.totalTokens) {
+							lastUsage = {
+								totalTokens: msg.usage.totalTokens,
+								cacheRead: msg.usage.cacheRead,
+								cacheWrite: msg.usage.cacheWrite,
+							}
+						}
+					}
+					break
+			}
+		})
+	}
+
+	async function prompt(content: ContentBlock[]): Promise<StopReason> {
+		cancelled = false
+		turnCount++
+		unsubscribe = subscribeToEvents()
+
+		try {
+			// Check for slash command
+			const firstText = content.find((b) => b.type === "text")?.text?.trim()
+			if (firstText?.startsWith("/")) {
+				return handleSlashCommand(firstText)
+			}
+
+			// Extract text and images
+			let textContent = ""
+			const images: Array<{ data: string; mimeType: string }> = []
+
+			for (const block of content) {
+				if (block.type === "text" && block.text) {
+					textContent += block.text
+				} else if (block.type === "image" && block.data && block.mimeType) {
+					images.push({ data: block.data, mimeType: block.mimeType })
+				}
+			}
+
+			if (!textContent && images.length === 0) {
+				return "end_turn"
+			}
+
+			// Convert images to attachment format
+			const attachments: Attachment[] = images.map((img, idx) => ({
+				id: `acp-img-${idx}`,
+				type: "image",
+				content: img.data,
+				mimeType: img.mimeType,
+				fileName: `image-${idx}`,
+				size: Math.ceil(img.data.length * 0.75),
+			}))
+
+			await Effect.runPromise(
+				sessionOrchestrator.submitPromptAndWait(textContent, {
+					mode: "followUp",
+					attachments: attachments.length > 0 ? attachments : undefined,
+				}),
+			)
+
+			return cancelled ? "cancelled" : "end_turn"
+		} finally {
+			unsubscribe?.()
+			unsubscribe = null
+		}
+	}
+
+	function handleSlashCommand(line: string): StopReason {
+		const parts = line.slice(1).split(/\s+/)
+		const cmd = parts[0]?.toLowerCase()
+		const args = parts.slice(1).join(" ")
+
+		switch (cmd) {
+			case "model":
+				if (args && setModel(args)) {
+					emitter.emit(textChunk(`Model switched to ${args}`))
+				} else if (args) {
+					emitter.emit(textChunk(`Unknown model: ${args}. Available: ${models.map((m) => m.modelId).join(", ")}`))
+				} else {
+					emitter.emit(textChunk(`Current model: ${currentModelId}\nAvailable: ${models.map((m) => m.modelId).join(", ")}`))
+				}
+				break
+
+			case "thinking": {
+				const levels = ["off", "minimal", "low", "medium", "high", "xhigh"]
+				if (levels.includes(args)) {
+					agent.setThinkingLevel(args as "off" | "minimal" | "low" | "medium" | "high" | "xhigh")
+					thinkingLevel = args
+					emitter.emit(textChunk(`Thinking level set to ${args}`))
+				} else {
+					emitter.emit(textChunk(`Invalid thinking level. Use: ${levels.join(", ")}`))
+				}
+				break
+			}
+
+			case "status": {
+				const provider = currentModelId.includes("/") ? currentModelId.split("/")[0] : "anthropic"
+				const fmt = (n: number) => n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n)
+				let ctx = `0/${fmt(contextWindow)}`
+				let cache = ""
+				if (lastUsage && contextWindow > 0) {
+					const pct = ((lastUsage.totalTokens / contextWindow) * 100).toFixed(1)
+					ctx = `${fmt(lastUsage.totalTokens)}/${fmt(contextWindow)} (${pct}%)`
+					if (lastUsage.cacheRead) cache = ` | cache: ${fmt(lastUsage.cacheRead)} read`
+				}
+				const status = `${currentModelId} (${provider}) | ${thinkingLevel} | ${ctx}${cache} | turns: ${turnCount}`
+				emitter.emit(textChunk(status))
+				break
+			}
+
+			case "clear":
+				agent.reset()
+				emitter.emit(textChunk("Conversation cleared"))
+				break
+
+			case "compact":
+				emitter.emit(textChunk("Compact not yet implemented in ACP mode"))
+				break
+
+			default:
+				emitter.emit(textChunk(`Unknown command: /${cmd}`))
+		}
+
+		return "end_turn"
+	}
+
+	function cancel(): void {
+		cancelled = true
+		agent.abort()
+	}
+
+	function getAvailableCommands(): SlashCommand[] {
+		return AVAILABLE_COMMANDS
+	}
+
+	function getModels(): { options: ModelOption[]; currentModelId: string } {
+		return { options: models, currentModelId }
+	}
+
+	function setModel(modelId: string): boolean {
+		const success = config.setModel(modelId)
+		if (success) {
+			currentModelId = modelId
+			emitter.emitModels(models, currentModelId)
+		}
+		return success
+	}
+
+	return {
+		id: sessionId,
+		cwd,
+		prompt,
+		cancel,
+		getAvailableCommands,
+		getModels,
+		setModel,
+	}
+}

package/src/adapters/acp/updates.ts

@@ -0,0 +1,96 @@
+/**
+ * ACP session/update notification emitter
+ * Bridges agent events to ACP protocol notifications
+ */
+
+import type {
+	SessionUpdate,
+	SessionUpdateParams,
+	SlashCommand,
+	ModelOption,
+	ToolCallKind,
+	ToolCallStatus,
+	JsonRpcNotification,
+} from "./protocol.js"
+import { makeNotification } from "./protocol.js"
+
+export interface UpdateEmitter {
+	emit(update: SessionUpdate): void
+	emitCommands(commands: SlashCommand[]): void
+	emitModels(availableModels: ModelOption[], currentModelId: string): void
+}
+
+export function createUpdateEmitter(
+	sessionId: string,
+	write: (notification: JsonRpcNotification) => void
+): UpdateEmitter {
+	const emit = (update: SessionUpdate): void => {
+		const params: SessionUpdateParams = { sessionId, update }
+		write(makeNotification("session/update", params))
+	}
+
+	return {
+		emit,
+
+		emitCommands(commands: SlashCommand[]): void {
+			emit({ sessionUpdate: "available_commands_update", availableCommands: commands })
+		},
+
+		emitModels(availableModels: ModelOption[], currentModelId: string): void {
+			emit({ sessionUpdate: "models_update", models: { availableModels, currentModelId } })
+		},
+	}
+}
+
+// ============================================================================
+// Convenience builders for common updates
+// ============================================================================
+
+export function textChunk(text: string): SessionUpdate {
+	return { sessionUpdate: "agent_message_chunk", content: { type: "text", text } }
+}
+
+export function thoughtChunk(text: string): SessionUpdate {
+	return { sessionUpdate: "agent_thought_chunk", content: { type: "text", text } }
+}
+
+export function toolCall(
+	toolCallId: string,
+	title: string,
+	kind: ToolCallKind,
+	rawInput?: unknown
+): SessionUpdate {
+	return {
+		sessionUpdate: "tool_call",
+		toolCallId,
+		title,
+		kind,
+		status: "pending",
+		rawInput,
+	}
+}
+
+export function toolCallUpdate(
+	toolCallId: string,
+	status: ToolCallStatus,
+	content?: string,
+	title?: string
+): SessionUpdate {
+	return {
+		sessionUpdate: "tool_call_update",
+		toolCallId,
+		status,
+		title,
+		content: content ? [{ type: "text" as const, text: content }] : undefined,
+	}
+}
+
+// Map tool names to ACP kinds
+export function toolNameToKind(name: string): ToolCallKind {
+	const lower = name.toLowerCase()
+	if (lower === "read" || lower.includes("read")) return "read"
+	if (lower === "write" || lower.includes("write")) return "write"
+	if (lower === "edit" || lower.includes("edit")) return "edit"
+	if (lower === "bash" || lower === "command" || lower.includes("terminal")) return "command"
+	return "other"
+}

package/src/adapters/cli/headless.ts

@@ -0,0 +1,112 @@
+import type { Message, TextContent } from "@yeshwanthyk/ai"
+import { Effect } from "effect"
+import { createRuntime, type RuntimeInitArgs } from "@runtime/factory.js"
+
+const readStdin = async (): Promise<string> => {
+	const chunks: Buffer[] = []
+	for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk))
+	return Buffer.concat(chunks).toString("utf8")
+}
+
+const textFromBlocks = (blocks: Array<{ type: string }>): string => {
+	const parts: string[] = []
+	for (const block of blocks) {
+		if (block.type === "text") parts.push((block as TextContent).text)
+	}
+	return parts.join("")
+}
+
+const renderMessage = (message: Message): string => {
+	if (message.role === "user") {
+		if (typeof message.content === "string") return message.content
+		return textFromBlocks(message.content)
+	}
+
+	if (message.role === "assistant") {
+		const parts: string[] = []
+		for (const block of message.content) {
+			if (block.type === "text") parts.push(block.text)
+		}
+		return parts.join("")
+	}
+
+	return textFromBlocks(message.content)
+}
+
+interface HeadlessArgs extends RuntimeInitArgs {
+	prompt?: string
+}
+
+export const runHeadless = async (args: HeadlessArgs) => {
+	const runtime = await createRuntime(
+		{
+			configDir: args.configDir,
+			configPath: args.configPath,
+			provider: args.provider,
+			model: args.model,
+			thinking: args.thinking,
+		},
+		"headless",
+	)
+
+	// Initialize hooks with no-op handlers for headless mode (single-shot, no UI)
+	runtime.hookRunner.initialize({
+		sendHandler: () => {},
+		sendMessageHandler: () => {},
+		sendUserMessageHandler: async () => {},
+		steerHandler: async () => {},
+		followUpHandler: async () => {},
+		isIdleHandler: () => true,
+		appendEntryHandler: (customType, data) => runtime.sessionManager.appendEntry(customType, data),
+		getSessionId: () => runtime.sessionManager.sessionId,
+		getModel: () => runtime.agent.state.model,
+		hasUI: false,
+	})
+
+	const prompt = (args.prompt ?? (await readStdin())).trim()
+	if (!prompt) {
+		process.stdout.write(JSON.stringify({ ok: false, error: "Empty prompt" }) + "\n")
+		process.exitCode = 2
+		return
+	}
+
+	try {
+		await Effect.runPromise(
+			runtime.sessionOrchestrator.submitPromptAndWait(prompt, { mode: "followUp" }),
+		)
+
+		const conversation = runtime.agent.state.messages.filter((m): m is Message => {
+			const role = (m as { role?: unknown }).role
+			return role === "user" || role === "assistant" || role === "toolResult"
+		})
+
+		const lastAssistant = [...conversation].reverse().find((m) => m.role === "assistant")
+		const assistant = lastAssistant ? renderMessage(lastAssistant) : ""
+
+		process.stdout.write(
+			JSON.stringify({
+				ok: true,
+				provider: runtime.config.provider,
+				model: runtime.config.modelId,
+				prompt,
+				assistant,
+				validationIssues: runtime.validationIssues,
+			}) + "\n",
+		)
+	} catch (err) {
+		process.stdout.write(
+			JSON.stringify({
+				ok: false,
+				provider: runtime.config.provider,
+				model: runtime.config.modelId,
+				prompt,
+				assistant: "",
+				error: err instanceof Error ? err.message : String(err),
+				validationIssues: runtime.validationIssues,
+			}) + "\n",
+		)
+		process.exitCode = 1
+	} finally {
+		await runtime.close().catch(() => {})
+	}
+}

package/src/adapters/cli/validate.ts

@@ -0,0 +1,50 @@
+import { createToolRegistry } from "@yeshwanthyk/base-tools"
+import { loadAppConfig } from "../../config.js"
+import { loadCustomCommands } from "@yeshwanthyk/runtime-effect/extensibility/custom-commands.js"
+import type { RuntimeInitArgs } from "@runtime/factory.js"
+import { loadExtensibility } from "@yeshwanthyk/runtime-effect/extensibility/index.js"
+import { formatValidationIssue, hasBlockingIssues } from "@ext/validation.js"
+import type { ValidationIssue } from "@ext/schema.js"
+import type { SendRef } from "@yeshwanthyk/runtime-effect/extensibility/custom-tools/types.js"
+import { SessionManager } from "../../session-manager.js"
+
+export const runValidate = async (args: RuntimeInitArgs = {}): Promise<void> => {
+	const loaded = await loadAppConfig({
+		configDir: args.configDir,
+		configPath: args.configPath,
+		provider: args.provider,
+		model: args.model,
+		thinking: args.thinking,
+	})
+
+	const { issues: commandIssues } = loadCustomCommands(loaded.configDir)
+	const sendRef: SendRef = { current: () => {} }
+	const sessionManager = new SessionManager(loaded.configDir)
+	
+	const builtinToolNames = Object.keys(createToolRegistry(process.cwd()))
+	
+	const extensibility = await loadExtensibility({
+		configDir: loaded.configDir,
+		cwd: process.cwd(),
+		sendRef,
+		builtinToolNames,
+		hasUI: false,
+		sessionManager,
+	})
+
+	const issues: ValidationIssue[] = [...commandIssues, ...extensibility.validationIssues]
+
+	if (issues.length === 0) {
+		process.stdout.write("No validation issues found.\n")
+		return
+	}
+
+	process.stdout.write(`Found ${issues.length} validation issue${issues.length === 1 ? "" : "s"}:\n`)
+	for (const issue of issues) {
+		process.stdout.write(`${formatValidationIssue(issue)}\n`)
+	}
+
+	if (hasBlockingIssues(issues)) {
+		process.exitCode = 1
+	}
+}

package/src/adapters/tui/app.tsx

@@ -0,0 +1,39 @@
+import { render } from "@opentui/solid"
+import { RuntimeProvider } from "../../runtime/context.js"
+import { createRuntime, type RuntimeInitArgs } from "@runtime/factory.js"
+import type { LoadedSession } from "../../session-manager.js"
+import { selectSession as selectSessionOpen } from "../../session-picker.js"
+import { TuiApp } from "@ui/app-shell/TuiApp.js"
+
+interface RunTuiArgs extends RuntimeInitArgs {
+	continueSession?: boolean
+	resumeSession?: boolean
+}
+
+export const runTuiOpen = async (args?: RunTuiArgs) => {
+	const runtime = await createRuntime(args, "tui")
+	const { sessionManager } = runtime
+	let initialSession: LoadedSession | null = null
+
+	if (args?.resumeSession) {
+		const selectedPath = await selectSessionOpen(sessionManager)
+		if (selectedPath === null) {
+			process.stdout.write("No session selected\n")
+			return
+		}
+		initialSession = sessionManager.loadSession(selectedPath)
+	}
+
+	if (args?.continueSession && !initialSession) {
+		initialSession = sessionManager.loadLatest()
+	}
+
+	render(
+		() => (
+			<RuntimeProvider runtime={runtime}>
+				<TuiApp initialSession={initialSession} />
+			</RuntimeProvider>
+		),
+		{ targetFps: 30, exitOnCtrlC: false, useKittyKeyboard: {} },
+	)
+}