@yeshwanthyk/coding-agent 0.3.0 → 0.3.3

package/src/adapters/acp/session.ts

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

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

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

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

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