@yeshwanthyk/coding-agent 0.3.0 → 0.3.2

package/src/domain/commands/builtin/compact.ts

@@ -1,96 +0,0 @@
-import { handleCompact as doCompact } from "../../../compact-handler.js"
-import { addSystemMessage } from "../helpers.js"
-import type { CommandDefinition } from "../types.js"
-
-export const compactCommand: CommandDefinition = {
-	name: "compact",
-	execute: async (args, ctx) => {
-		if (ctx.isResponding()) {
-			addSystemMessage(ctx, "Cannot compact while responding. Use /abort first.")
-			return true
-		}
-
-		const messages = ctx.agent.state.messages
-		if (messages.length < 2) {
-			addSystemMessage(ctx, "Nothing to compact (need at least one exchange)")
-			return true
-		}
-
-		const customInstructions = args.trim() || undefined
-
-		// Emit session.before_compact hook - allows hooks to cancel or add context
-		const beforeCompactEvent = {
-			type: "session.before_compact" as const,
-			input: { sessionId: ctx.sessionManager.sessionId },
-			output: { cancel: false, prompt: undefined as string | undefined, context: [] as string[] },
-		}
-		await ctx.hookRunner?.emit(beforeCompactEvent)
-		if (beforeCompactEvent.output.cancel) {
-			addSystemMessage(ctx, "Compaction cancelled by hook")
-			return true
-		}
-
-		// Merge hook-provided instructions with user-provided ones
-		const hookPrompt = beforeCompactEvent.output.prompt
-		const mergedInstructions = [customInstructions, hookPrompt, ...beforeCompactEvent.output.context]
-			.filter(Boolean)
-			.join("\n\n") || undefined
-
-		ctx.setActivityState("compacting")
-		ctx.setIsResponding(true)
-
-		try {
-			const prevState = ctx.sessionManager.getCompactionState()
-
-			const { summary, summaryMessage, fileOps } = await doCompact({
-				agent: ctx.agent,
-				currentProvider: ctx.currentProvider,
-				getApiKey: ctx.getApiKey,
-				codexTransport: ctx.codexTransport,
-				customInstructions: mergedInstructions,
-				previousSummary: prevState?.lastSummary,
-				previousFileOps: prevState
-					? {
-						readFiles: prevState.readFiles,
-						modifiedFiles: prevState.modifiedFiles,
-					}
-					: undefined,
-			})
-
-			// Emit session.compact hook after successful compaction
-			await ctx.hookRunner?.emit({
-				type: "session.compact",
-				sessionId: ctx.sessionManager.sessionId,
-				summary,
-			})
-
-			ctx.agent.reset()
-			ctx.agent.replaceMessages([summaryMessage])
-
-			ctx.sessionManager.startSession(ctx.currentProvider, ctx.currentModelId, ctx.currentThinking)
-			ctx.sessionManager.appendMessage(summaryMessage)
-
-			const modified = new Set([...fileOps.edited, ...fileOps.written])
-			const readOnly = [...fileOps.read].filter((file) => !modified.has(file))
-			ctx.sessionManager.updateCompactionState({
-				lastSummary: summary,
-				readFiles: readOnly.sort(),
-				modifiedFiles: [...modified].sort(),
-			})
-
-			ctx.setMessages(() => [
-				{ id: crypto.randomUUID(), role: "assistant" as const, content: `Context compacted:\n\n${summary}` },
-			])
-			ctx.setToolBlocks(() => [])
-			ctx.setContextTokens(0)
-			ctx.setCacheStats(null)
-		} catch (err) {
-			addSystemMessage(ctx, `Compact failed: ${err instanceof Error ? err.message : String(err)}`)
-		} finally {
-			ctx.setIsResponding(false)
-			ctx.setActivityState("idle")
-		}
-
-		return true
-	},
-}

package/src/domain/commands/builtin/conceal.ts

@@ -1,9 +0,0 @@
-import type { CommandDefinition } from "../types.js"
-
-export const concealCommand: CommandDefinition = {
-	name: "conceal",
-	execute: (_args, ctx) => {
-		ctx.setConcealMarkdown((prev) => !prev)
-		return true
-	},
-}

package/src/domain/commands/builtin/diffwrap.ts

@@ -1,9 +0,0 @@
-import type { CommandDefinition } from "../types.js"
-
-export const diffwrapCommand: CommandDefinition = {
-	name: "diffwrap",
-	execute: (_args, ctx) => {
-		ctx.setDiffWrapMode((prev) => (prev === "word" ? "none" : "word"))
-		return true
-	},
-}

package/src/domain/commands/builtin/editor.ts

@@ -1,24 +0,0 @@
-import { buildEditorInvocation } from "../../../editor.js"
-import { defaultLaunchEditor } from "../helpers.js"
-import type { CommandDefinition } from "../types.js"
-
-export const editorCommand: CommandDefinition = {
-	name: "editor",
-	execute: async (_args, ctx) => {
-		if (ctx.openEditor) {
-			await ctx.openEditor()
-			return true
-		}
-
-		const editor = ctx.editor ?? { command: "nvim", args: [] }
-		const { command, args } = buildEditorInvocation(editor, ctx.cwd, { appendCwd: true })
-		const launch = ctx.launchEditor ?? defaultLaunchEditor
-		launch(command, args, ctx.cwd, (error) => {
-			ctx.setMessages((prev) => [
-				...prev,
-				{ id: crypto.randomUUID(), role: "assistant" as const, content: `Failed to launch editor: ${error.message}` },
-			])
-		})
-		return true
-	},
-}

package/src/domain/commands/builtin/exit.ts

@@ -1,14 +0,0 @@
-import type { CommandDefinition } from "../types.js"
-
-export const exitCommand: CommandDefinition = {
-	name: "exit",
-	aliases: ["quit"],
-	execute: (_args, ctx) => {
-		if (ctx.onExit) {
-			ctx.onExit()
-		} else {
-			process.exit(0)
-		}
-		return true
-	},
-}

package/src/domain/commands/builtin/followup.ts

@@ -1,24 +0,0 @@
-import { addSystemMessage } from "../helpers.js"
-import type { CommandDefinition } from "../types.js"
-
-const USAGE = "Usage: /followup <text>"
-
-export const followupCommand: CommandDefinition = {
-	name: "followup",
-	description: "Queue text to deliver after the agent becomes idle",
-	execute: async (args, ctx) => {
-		const text = args.trim()
-		if (!text) {
-			addSystemMessage(ctx, USAGE)
-			return true
-		}
-
-		if (ctx.isResponding()) {
-			await ctx.followUp(text)
-			return true
-		}
-
-		await ctx.submitPrompt(text, { mode: "followUp" })
-		return true
-	},
-}

package/src/domain/commands/builtin/index.ts

@@ -1,29 +0,0 @@
-import { clearCommand } from "./clear.js"
-import { compactCommand } from "./compact.js"
-import { concealCommand } from "./conceal.js"
-import { diffwrapCommand } from "./diffwrap.js"
-import { editorCommand } from "./editor.js"
-import { exitCommand } from "./exit.js"
-import { followupCommand } from "./followup.js"
-import { loginCommand } from "./login.js"
-import { modelCommand } from "./model.js"
-import { statusCommand } from "./status.js"
-import { steerCommand } from "./steer.js"
-import { themeCommand } from "./theme.js"
-import { thinkingCommand } from "./thinking.js"
-
-export const builtinCommands = [
-	exitCommand,
-	clearCommand,
-	thinkingCommand,
-	diffwrapCommand,
-	concealCommand,
-	themeCommand,
-	editorCommand,
-	modelCommand,
-	compactCommand,
-	statusCommand,
-	loginCommand,
-	steerCommand,
-	followupCommand,
-]

package/src/domain/commands/builtin/login.ts

@@ -1,118 +0,0 @@
-import { exec } from "node:child_process"
-import {
-	saveAnthropicTokens,
-	loadAnthropicTokens,
-	clearAnthropicTokens,
-	getAnthropicTokensPath,
-} from "@yeshwanthyk/agent-core"
-import { loginAnthropic } from "@yeshwanthyk/ai"
-import type { CommandDefinition } from "../types.js"
-import { addSystemMessage } from "../helpers.js"
-
-let pendingAuthUrl: string | null = null
-
-function openBrowser(url: string): void {
-	const cmd =
-		process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open"
-	exec(`${cmd} "${url}"`)
-}
-
-export const loginCommand: CommandDefinition = {
-	name: "login",
-	description: "Login with Anthropic OAuth (Claude Pro/Max)",
-	execute: async (args, ctx) => {
-		const configDir = ctx.configDir
-
-		// /login status - show current login status
-		if (args === "status") {
-			const tokens = loadAnthropicTokens({ configDir })
-			if (tokens) {
-				const expiresAt = new Date(tokens.expires).toLocaleString()
-				const isExpired = tokens.expires <= Date.now()
-				addSystemMessage(
-					ctx,
-					isExpired
-						? `Anthropic OAuth: Token expired at ${expiresAt}. Run /login to re-authenticate.`
-						: `Anthropic OAuth: Logged in, token expires ${expiresAt}`,
-				)
-			} else {
-				addSystemMessage(ctx, "Anthropic OAuth: Not logged in. Run /login to authenticate.")
-			}
-			return true
-		}
-
-		// /login clear - clear stored tokens
-		if (args === "clear" || args === "logout") {
-			clearAnthropicTokens({ configDir })
-			addSystemMessage(ctx, "Anthropic OAuth tokens cleared.")
-			return true
-		}
-
-		// /login <code#state> - complete the OAuth flow
-		if (args && args.includes("#")) {
-			if (!pendingAuthUrl) {
-				addSystemMessage(ctx, "No pending login. Run /login first to start the OAuth flow.")
-				return true
-			}
-
-			try {
-				const credentials = await loginAnthropic(
-					() => {}, // URL already shown
-					async () => args, // Return the provided code
-				)
-				saveAnthropicTokens(credentials, { configDir })
-				pendingAuthUrl = null
-				addSystemMessage(
-					ctx,
-					`Logged in successfully! Token saved to ${getAnthropicTokensPath({ configDir })}`,
-				)
-			} catch (err) {
-				pendingAuthUrl = null
-				addSystemMessage(ctx, `Login failed: ${err instanceof Error ? err.message : String(err)}`)
-			}
-			return true
-		}
-
-		// /login - start the OAuth flow
-		addSystemMessage(ctx, "Starting Anthropic OAuth flow...")
-
-		try {
-			// We need to capture the URL without completing the flow
-			const credentials = await loginAnthropic(
-				(url: string) => {
-					pendingAuthUrl = url
-					openBrowser(url)
-				},
-				async () => {
-					// Show instructions and return empty to abort this attempt
-					// User will call /login <code> to complete
-					throw new Error("PENDING")
-				},
-			)
-			// If we get here, somehow completed without user input (shouldn't happen)
-			saveAnthropicTokens(credentials, { configDir })
-			addSystemMessage(ctx, "Logged in successfully!")
-		} catch (err) {
-			if (err instanceof Error && err.message === "PENDING") {
-				// Expected - show instructions
-				addSystemMessage(
-					ctx,
-					[
-						"Browser opened for Anthropic login.",
-						"",
-						"After authorizing, you'll see a code like: abc123#xyz789",
-						"",
-						"Run: /login <code#state>",
-						"",
-						`Or visit: ${pendingAuthUrl}`,
-					].join("\n"),
-				)
-			} else {
-				pendingAuthUrl = null
-				addSystemMessage(ctx, `Login failed: ${err instanceof Error ? err.message : String(err)}`)
-			}
-		}
-
-		return true
-	},
-}

package/src/domain/commands/builtin/model.ts

@@ -1,66 +0,0 @@
-import { getModels, getProviders } from "@yeshwanthyk/ai"
-import { updateAppConfig } from "../../../config.js"
-import type { CommandDefinition } from "../types.js"
-import { addSystemMessage, resolveModel, resolveProvider } from "../helpers.js"
-
-export const modelCommand: CommandDefinition = {
-	name: "model",
-	execute: (args, ctx) => {
-		if (!args) {
-			addSystemMessage(ctx, "Usage: /model <provider> <modelId> (or /model <modelId>)")
-			return true
-		}
-
-		if (ctx.isResponding()) {
-			addSystemMessage(ctx, "Model cannot be changed while responding. Use /abort first.")
-			return true
-		}
-
-		const parts = args.split(/\s+/)
-		if (parts.length === 1) {
-			const modelId = parts[0]!
-			const model = resolveModel(ctx.currentProvider, modelId)
-			if (!model) {
-				const examples = getModels(ctx.currentProvider).slice(0, 5).map((m) => m.id).join(", ")
-				addSystemMessage(ctx, `Unknown model "${modelId}" for ${ctx.currentProvider}. Examples: ${examples}`)
-				return true
-			}
-
-			ctx.agent.setModel(model)
-			ctx.setCurrentModelId(model.id)
-			ctx.setDisplayModelId(model.id)
-			ctx.setDisplayContextWindow(model.contextWindow)
-			void updateAppConfig(
-				{ configDir: ctx.configDir, configPath: ctx.configPath },
-				{ model: model.id },
-			)
-			return true
-		}
-
-		const [providerRaw, ...modelParts] = parts
-		const provider = resolveProvider(providerRaw!)
-		if (!provider) {
-			addSystemMessage(ctx, `Unknown provider "${providerRaw}". Known: ${getProviders().join(", ")}`)
-			return true
-		}
-
-		const modelId = modelParts.join(" ")
-		const model = resolveModel(provider, modelId)
-		if (!model) {
-			const examples = getModels(provider).slice(0, 5).map((m) => m.id).join(", ")
-			addSystemMessage(ctx, `Unknown model "${modelId}" for ${provider}. Examples: ${examples}`)
-			return true
-		}
-
-		ctx.agent.setModel(model)
-		ctx.setCurrentProvider(provider)
-		ctx.setCurrentModelId(model.id)
-		ctx.setDisplayModelId(model.id)
-		ctx.setDisplayContextWindow(model.contextWindow)
-		void updateAppConfig(
-			{ configDir: ctx.configDir, configPath: ctx.configPath },
-			{ provider, model: model.id },
-		)
-		return true
-	},
-}

package/src/domain/commands/builtin/status.ts

@@ -1,32 +0,0 @@
-import { addSystemMessage } from "../helpers.js"
-import type { CommandDefinition } from "../types.js"
-
-const formatNumber = (n: number): string => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n))
-
-export const statusCommand: CommandDefinition = {
-	name: "status",
-	execute: (_args, ctx) => {
-		const model = ctx.agent.state.model
-		const messages = ctx.agent.state.messages
-		let usage: { totalTokens?: number; cacheRead?: number } | undefined
-		for (let i = messages.length - 1; i >= 0; i--) {
-			const msg = messages[i] as { role: string; usage?: { totalTokens?: number; cacheRead?: number } }
-			if (msg.role === "assistant" && msg.usage?.totalTokens) {
-				usage = msg.usage
-				break
-			}
-		}
-
-		let ctxStr = `0/${formatNumber(model.contextWindow)}`
-		let cache = ""
-		if (usage?.totalTokens) {
-			const pct = ((usage.totalTokens / model.contextWindow) * 100).toFixed(1)
-			ctxStr = `${formatNumber(usage.totalTokens)}/${formatNumber(model.contextWindow)} (${pct}%)`
-			if (usage.cacheRead) cache = ` | cache: ${formatNumber(usage.cacheRead)} read`
-		}
-		const turns = messages.filter((m) => (m as { role: string }).role === "user").length
-		const status = `${ctx.currentModelId} (${ctx.currentProvider}) | ${ctx.currentThinking} | ${ctxStr}${cache} | turns: ${turns}`
-		addSystemMessage(ctx, status)
-		return true
-	},
-}

package/src/domain/commands/builtin/steer.ts

@@ -1,24 +0,0 @@
-import { addSystemMessage } from "../helpers.js"
-import type { CommandDefinition } from "../types.js"
-
-const USAGE = "Usage: /steer <text>"
-
-export const steerCommand: CommandDefinition = {
-	name: "steer",
-	description: "Interrupt after the current tool turn with steering instructions",
-	execute: async (args, ctx) => {
-		const text = args.trim()
-		if (!text) {
-			addSystemMessage(ctx, USAGE)
-			return true
-		}
-
-		if (ctx.isResponding()) {
-			await ctx.steer(text)
-			return true
-		}
-
-		await ctx.submitPrompt(text, { mode: "steer" })
-		return true
-	},
-}

package/src/domain/commands/builtin/theme.ts

@@ -1,23 +0,0 @@
-import { THEME_NAMES } from "../../../theme-names.js"
-import { addSystemMessage } from "../helpers.js"
-import type { CommandDefinition } from "../types.js"
-
-export const themeCommand: CommandDefinition = {
-	name: "theme",
-	execute: (args, ctx) => {
-		const themeName = args.trim()
-
-		if (!themeName) {
-			addSystemMessage(ctx, `Available themes: ${THEME_NAMES.join(", ")}`)
-			return true
-		}
-
-		if (!THEME_NAMES.includes(themeName)) {
-			addSystemMessage(ctx, `Unknown theme "${themeName}". Available: ${THEME_NAMES.join(", ")}`)
-			return true
-		}
-
-		ctx.setTheme?.(themeName)
-		return true
-	},
-}

package/src/domain/commands/builtin/thinking.ts

@@ -1,16 +0,0 @@
-import { THINKING_LEVELS, type CommandDefinition } from "../types.js"
-import { updateAppConfig } from "../../../config.js"
-
-export const thinkingCommand: CommandDefinition = {
-	name: "thinking",
-	execute: (args, ctx) => {
-		const next = args.trim() as typeof THINKING_LEVELS[number]
-		if (!THINKING_LEVELS.includes(next)) return false
-
-		ctx.agent.setThinkingLevel(next)
-		ctx.setCurrentThinking(next)
-		ctx.setDisplayThinking(next)
-		void updateAppConfig({ configDir: ctx.configDir, configPath: ctx.configPath }, { thinking: next })
-		return true
-	},
-}

package/src/domain/commands/helpers.ts

@@ -1,41 +0,0 @@
-import { spawn } from "node:child_process"
-import type { Api, Model, KnownProvider } from "@yeshwanthyk/ai"
-import { getModels, getProviders } from "@yeshwanthyk/ai"
-import type { CommandContext } from "./types.js"
-
-export const resolveProvider = (raw: string): KnownProvider | undefined => {
-	const trimmed = raw.trim()
-	if (!trimmed) return undefined
-	const providers = getProviders()
-	return providers.includes(trimmed as KnownProvider) ? (trimmed as KnownProvider) : undefined
-}
-
-export const resolveModel = (provider: KnownProvider, raw: string): Model<Api> | undefined => {
-	const modelId = raw.trim()
-	if (!modelId) return undefined
-	return getModels(provider).find((m) => m.id === modelId) as Model<Api> | undefined
-}
-
-export const addSystemMessage = (ctx: CommandContext, content: string): void => {
-	ctx.setMessages((prev) => [
-		...prev,
-		{ id: crypto.randomUUID(), role: "assistant" as const, content },
-	])
-}
-
-export const defaultLaunchEditor = (
-	command: string,
-	args: string[],
-	cwd: string,
-	onError: (error: Error) => void,
-): void => {
-	try {
-		const child = spawn(command, args, { cwd, detached: true, stdio: "ignore" })
-		child.once("error", (err) => {
-			onError(err instanceof Error ? err : new Error(String(err)))
-		})
-		child.unref()
-	} catch (err) {
-		onError(err instanceof Error ? err : new Error(String(err)))
-	}
-}

package/src/domain/commands/registry.ts

@@ -1,42 +0,0 @@
-import type { CommandContext, CommandDefinition } from "./types.js"
-
-const normalizeName = (value: string): string => value.trim().toLowerCase()
-
-export class CommandRegistry {
-	private readonly definitions = new Map<string, CommandDefinition>()
-	private readonly lookup = new Map<string, CommandDefinition>()
-
-	register(definition: CommandDefinition): void {
-		const canonical = normalizeName(definition.name)
-		this.definitions.set(canonical, definition)
-		this.lookup.set(canonical, definition)
-		for (const alias of definition.aliases ?? []) {
-			const aliasKey = normalizeName(alias)
-			this.lookup.set(aliasKey, definition)
-		}
-	}
-
-	get(name: string): CommandDefinition | undefined {
-		return this.lookup.get(normalizeName(name))
-	}
-
-	list(): CommandDefinition[] {
-		return Array.from(this.definitions.values())
-	}
-
-	async execute(input: string, ctx: CommandContext): Promise<boolean> {
-		const trimmed = input.trim()
-		if (!trimmed.startsWith("/")) return false
-
-		const withoutSlash = trimmed.slice(1)
-		const whitespaceMatch = withoutSlash.match(/\s/)
-		const spaceIdx = whitespaceMatch?.index ?? -1
-		const commandName = spaceIdx === -1 ? withoutSlash : withoutSlash.slice(0, spaceIdx)
-		const args = spaceIdx === -1 ? "" : withoutSlash.slice(spaceIdx + 1)
-		const command = this.get(commandName)
-		if (!command) return false
-
-		const handled = command.execute(args, ctx)
-		return handled instanceof Promise ? await handled : handled
-	}
-}

package/src/domain/commands/types.ts

@@ -1,69 +0,0 @@
-import type { Agent, ThinkingLevel } from "@yeshwanthyk/agent-core"
-import type { CodexTransport } from "@yeshwanthyk/agent-core"
-import type { Api, Model, KnownProvider } from "@yeshwanthyk/ai"
-import type { SessionManager } from "../../session-manager.js"
-import type { ActivityState, ToolBlock, UIMessage } from "../../types.js"
-import type { EditorConfig } from "../../config.js"
-import type { HookRunner } from "../../hooks/index.js"
-import type { PromptDeliveryMode } from "@yeshwanthyk/runtime-effect/session/prompt-queue.js"
-import type { PromptSubmitOptions } from "@yeshwanthyk/runtime-effect/session/orchestrator.js"
-
-export const THINKING_LEVELS: ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh"]
-
-export interface CommandContext {
-	agent: Agent
-	sessionManager: SessionManager
-	configDir: string
-	configPath: string
-	cwd: string
-	editor?: EditorConfig
-	codexTransport: CodexTransport
-	getApiKey: (provider: string) => string | undefined
-
-	currentProvider: KnownProvider
-	currentModelId: string
-	currentThinking: ThinkingLevel
-
-	setCurrentProvider: (provider: KnownProvider) => void
-	setCurrentModelId: (modelId: string) => void
-	setCurrentThinking: (thinking: ThinkingLevel) => void
-
-	isResponding: () => boolean
-	setIsResponding: (value: boolean) => void
-	setActivityState: (state: ActivityState) => void
-	setMessages: (updater: (prev: UIMessage[]) => UIMessage[]) => void
-	setToolBlocks: (updater: (prev: ToolBlock[]) => ToolBlock[]) => void
-	setContextTokens: (value: number) => void
-	setCacheStats: (value: { cacheRead: number; input: number } | null) => void
-
-	setDisplayModelId: (modelId: string) => void
-	setDisplayThinking: (thinking: ThinkingLevel) => void
-	setDisplayContextWindow: (tokens: number) => void
-
-	setDiffWrapMode: (updater: (prev: "word" | "none") => "word" | "none") => void
-	setConcealMarkdown: (updater: (prev: boolean) => boolean) => void
-
-	setTheme?: (name: string) => void
-	launchEditor?: (command: string, args: string[], cwd: string, onError: (error: Error) => void) => void
-	openEditor?: () => Promise<void> | void
-
-	onExit?: () => void
-	hookRunner?: HookRunner
-	submitPrompt: (text: string, options?: PromptSubmitOptions) => Promise<void>
-	steer: (text: string) => Promise<void>
-	followUp: (text: string) => Promise<void>
-	sendUserMessage: (text: string, options?: { deliverAs?: PromptDeliveryMode }) => Promise<void>
-}
-
-export type CommandHandlerResult = boolean | Promise<boolean>
-
-export interface CommandDefinition {
-	name: string
-	aliases?: string[]
-	description?: string
-	execute: (args: string, ctx: CommandContext) => CommandHandlerResult
-}
-
-export type CommandHandler = CommandDefinition["execute"]
-
-export type ModelResolver = (provider: KnownProvider, modelId: string) => Model<Api> | undefined