@yeshwanthyk/coding-agent 0.3.0 → 0.3.2

package/src/domain/messaging/content.ts

@@ -1,117 +0,0 @@
-export const MESSAGE_CAP = 75
-
-export const appendWithCap = <T,>(arr: T[], item: T, cap = MESSAGE_CAP): T[] => {
-	const next = [...arr, item]
-	return next.length > cap ? next.slice(-cap) : next
-}
-
-export const getToolText = (result: unknown): string => {
-	if (!result || typeof result !== "object") return String(result)
-	const maybe = result as { content?: unknown }
-	const content = Array.isArray(maybe.content) ? maybe.content : []
-	const parts: string[] = []
-	for (const block of content) {
-		if (typeof block === "object" && block !== null && (block as Record<string, unknown>).type === "text") {
-			parts.push((block as Record<string, string>).text)
-		}
-	}
-	return parts.join("")
-}
-
-export const getEditDiffText = (result: unknown): string | null => {
-	if (!result || typeof result !== "object") return null
-	const maybe = result as { details?: { diff?: string } }
-	return maybe.details?.diff || null
-}
-
-export const extractText = (content: unknown[]): string => {
-	let text = ""
-	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") {
-			text += b.text
-		}
-	}
-	return text
-}
-
-const THINKING_SUMMARY_MAX = 80
-const THINKING_PREVIEW_MAX = 50
-
-export const buildThinkingSummary = (full: string): { summary: string; preview: string } => {
-	const trimmed = full.trim()
-	const lines = trimmed.split("\n").filter((l) => l.trim().length > 20)
-	const base = (lines[0]?.trim() || trimmed).slice(0, THINKING_SUMMARY_MAX)
-	const summary = base.length >= THINKING_SUMMARY_MAX ? base + "..." : base
-	const previewSource = summary || trimmed
-	const firstLine = previewSource.split("\n")[0] || ""
-	const preview = firstLine.length <= THINKING_PREVIEW_MAX
-		? firstLine
-		: firstLine.slice(0, THINKING_PREVIEW_MAX - 3) + "..."
-	return { summary, preview }
-}
-
-export const extractThinking = (content: unknown[]): { summary: string; preview: string; full: string } | null => {
-	for (const block of content) {
-		if (typeof block !== "object" || block === null) continue
-		const b = block as Record<string, unknown>
-		if (b.type === "thinking" && typeof b.thinking === "string") {
-			const full = b.thinking
-			const { summary, preview } = buildThinkingSummary(full)
-			return { summary, preview, full }
-		}
-	}
-	return null
-}
-
-export interface ExtractedToolCall {
-	id: string
-	name: string
-	args: unknown
-}
-
-export const extractToolCalls = (content: unknown[]): ExtractedToolCall[] => {
-	const toolCalls: ExtractedToolCall[] = []
-	for (const block of content) {
-		if (typeof block !== "object" || block === null) continue
-		const b = block as Record<string, unknown>
-		if (b.type === "toolCall" && typeof b.id === "string" && typeof b.name === "string") {
-			toolCalls.push({ id: b.id, name: b.name, args: b.arguments ?? {} })
-		}
-	}
-	return toolCalls
-}
-
-export type OrderedBlock =
-	| { type: "thinking"; id: string; summary: string; preview: string; full: string }
-	| { type: "text"; text: string }
-	| { type: "toolCall"; id: string; name: string; args: unknown }
-
-export const extractOrderedBlocks = (content: unknown[]): OrderedBlock[] => {
-	const blocks: OrderedBlock[] = []
-	let thinkingCounter = 0
-
-	for (const block of content) {
-		if (typeof block !== "object" || block === null) continue
-		const b = block as Record<string, unknown>
-
-		if (b.type === "thinking" && typeof b.thinking === "string") {
-			const full = b.thinking
-			const { summary, preview } = buildThinkingSummary(full)
-			blocks.push({
-				type: "thinking",
-				id: `thinking-${thinkingCounter++}`,
-				summary,
-				preview,
-				full,
-			})
-		} else if (b.type === "text" && typeof b.text === "string") {
-			blocks.push({ type: "text", text: b.text })
-		} else if (b.type === "toolCall" && typeof b.id === "string" && typeof b.name === "string") {
-			blocks.push({ type: "toolCall", id: b.id, name: b.name, args: b.arguments ?? {} })
-		}
-	}
-
-	return blocks
-}

package/src/editor.ts

@@ -1,103 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import * as path from "node:path"
-import { spawn } from "node:child_process"
-import type { CliRenderer } from "@yeshwanthyk/open-tui"
-import type { EditorConfig } from "./config.js"
-
-const CWD_PLACEHOLDER = "{cwd}"
-const LINE_JUMP_EDITORS = new Set([
-	"vi",
-	"vim",
-	"nvim",
-	"emacs",
-	"emacsclient",
-	"nano",
-	"hx",
-	"helix",
-	"micro",
-	"kak",
-	"kakoune",
-])
-
-const supportsLineJump = (command: string): boolean => {
-	const baseName = path.basename(command).toLowerCase()
-	return LINE_JUMP_EDITORS.has(baseName)
-}
-
-export const buildEditorInvocation = (
-	editor: EditorConfig,
-	cwd: string,
-	options?: { appendCwd?: boolean },
-): { command: string; args: string[] } => {
-	const usesCwd = editor.command.includes(CWD_PLACEHOLDER) || editor.args.some((arg) => arg.includes(CWD_PLACEHOLDER))
-	const command = editor.command.replaceAll(CWD_PLACEHOLDER, cwd)
-	const args = editor.args.map((arg) => arg.replaceAll(CWD_PLACEHOLDER, cwd))
-	if (options?.appendCwd !== false && !usesCwd) args.push(cwd)
-	return { command, args }
-}
-
-const runEditor = async (command: string, args: string[], cwd: string): Promise<void> => {
-	await new Promise<void>((resolve, reject) => {
-		const proc = spawn(command, args, { cwd, stdio: "inherit" })
-		proc.once("error", (err) => reject(err))
-		proc.once("exit", () => resolve())
-	})
-}
-
-export const openExternalEditor = async (opts: {
-	editor: EditorConfig
-	cwd: string
-	renderer: CliRenderer
-	initialValue: string
-}): Promise<string | undefined> => {
-	const { command, args } = buildEditorInvocation(opts.editor, opts.cwd, { appendCwd: false })
-	const dir = await mkdtemp(path.join(tmpdir(), "marvin-editor-"))
-	const filePath = path.join(dir, "prompt.md")
-	let suspended = false
-
-	try {
-		await writeFile(filePath, opts.initialValue, "utf8")
-		opts.renderer.suspend()
-		suspended = true
-		opts.renderer.currentRenderBuffer.clear()
-		await runEditor(command, [...args, filePath], opts.cwd)
-		const content = await readFile(filePath, "utf8")
-		return content.length > 0 ? content : undefined
-	} finally {
-		if (suspended) {
-			opts.renderer.currentRenderBuffer.clear()
-			opts.renderer.resume()
-			opts.renderer.requestRender()
-		}
-		await rm(dir, { recursive: true, force: true })
-	}
-}
-
-/**
- * Open an existing file in the user's editor.
- * Unlike openExternalEditor, this opens the file directly without creating a temp copy.
- */
-export const openFileInEditor = async (opts: {
-	editor: EditorConfig
-	filePath: string
-	line?: number
-	cwd: string
-	renderer: CliRenderer
-}): Promise<void> => {
-	const { command, args } = buildEditorInvocation(opts.editor, opts.cwd, { appendCwd: false })
-	const lineArg = typeof opts.line === "number" && Number.isFinite(opts.line) && opts.line > 0 && supportsLineJump(command)
-		? [`+${opts.line}`]
-		: []
-
-	opts.renderer.suspend()
-	opts.renderer.currentRenderBuffer.clear()
-
-	try {
-		await runEditor(command, [...args, ...lineArg, opts.filePath], opts.cwd)
-	} finally {
-		opts.renderer.currentRenderBuffer.clear()
-		opts.renderer.resume()
-		opts.renderer.requestRender()
-	}
-}

package/src/hooks/index.ts

@@ -1 +0,0 @@
-export * from "@yeshwanthyk/runtime-effect/hooks/index.js"

package/src/hooks/useAgentEvents.ts

@@ -1,28 +0,0 @@
-import { createEffect, onCleanup } from "solid-js"
-import type { Agent, AgentEvent } from "@yeshwanthyk/agent-core"
-import { createAgentEventHandler, type EventHandlerContext } from "../agent-events.js"
-
-export interface AgentEventsOptions {
-	agent: Agent
-	context: EventHandlerContext
-}
-
-export function useAgentEvents(options: AgentEventsOptions): void {
-	const handler = createAgentEventHandler(options.context)
-
-	createEffect(() => {
-		const unsubscribe = options.agent.subscribe((event: AgentEvent) => {
-			try {
-				handler(event)
-			} catch (err) {
-				if (process.env.NODE_ENV !== "production") {
-					console.error("Agent event handler error", err)
-				}
-			}
-		})
-		onCleanup(() => {
-			unsubscribe()
-			handler.dispose()
-		})
-	})
-}

package/src/hooks/useEditorBridge.ts

@@ -1,101 +0,0 @@
-import { createPatch } from "diff"
-import type { CliRenderer } from "@yeshwanthyk/open-tui"
-import { openExternalEditor, openFileInEditor } from "../editor.js"
-import type { EditorConfig } from "../config.js"
-
-interface ToastOptions {
-	title: string
-	message?: string
-	variant?: "success" | "warning" | "error" | "info"
-}
-
-interface EditorBridgeOptions {
-	editor?: EditorConfig
-	renderer: CliRenderer
-	pushToast: (toast: ToastOptions, ttlMs?: number) => void
-	isResponding: () => boolean
-	onSubmit: (text: string) => void
-}
-
-const DEFAULT_EDITOR: EditorConfig = { command: "nvim", args: [] }
-
-export function useEditorBridge(options: EditorBridgeOptions) {
-	const getEditor = (): EditorConfig => options.editor ?? DEFAULT_EDITOR
-
-	const openBuffer = async (initialValue = "") => {
-		try {
-			return await openExternalEditor({
-				editor: getEditor(),
-				cwd: process.cwd(),
-				renderer: options.renderer,
-				initialValue,
-			})
-		} catch (err) {
-			options.pushToast({
-				title: "Editor failed",
-				message: err instanceof Error ? err.message : String(err),
-				variant: "error",
-			}, 4000)
-			return undefined
-		}
-	}
-
-	const editFile = async (filePath: string, line?: number) => {
-		if (options.isResponding()) return
-
-		let beforeContent: string
-		try {
-			beforeContent = await Bun.file(filePath).text()
-		} catch (err) {
-			options.pushToast({
-				title: `Cannot read file: ${filePath}`,
-				message: err instanceof Error ? err.message : String(err),
-				variant: "error",
-			}, 3000)
-			return
-		}
-
-		try {
-			await openFileInEditor({
-				editor: getEditor(),
-				filePath,
-				line,
-				cwd: process.cwd(),
-				renderer: options.renderer,
-			})
-		} catch (err) {
-			options.pushToast({
-				title: err instanceof Error ? err.message : String(err),
-				variant: "error",
-			}, 3000)
-			return
-		}
-
-		let afterContent: string
-		try {
-			afterContent = await Bun.file(filePath).text()
-		} catch (err) {
-			options.pushToast({
-				title: `Cannot read file after edit: ${filePath}`,
-				message: err instanceof Error ? err.message : String(err),
-				variant: "error",
-			}, 3000)
-			return
-		}
-
-		if (beforeContent === afterContent) {
-			return
-		}
-
-		const diff = createPatch(filePath, beforeContent, afterContent)
-		const lines = diff.split("\n")
-		const hunkStart = lines.findIndex((line) => line.startsWith("@@"))
-		const diffBody = hunkStart >= 0 ? lines.slice(hunkStart).join("\n") : diff
-
-		const message = `Modified ${filePath}:\n${diffBody}`
-		options.onSubmit(message)
-		options.pushToast({ title: "Edit recorded", variant: "success" }, 1500)
-	}
-
-	return { openBuffer, editFile }
-}

package/src/hooks/useGitStatus.ts

@@ -1,28 +0,0 @@
-import { createSignal, onCleanup, onMount } from "solid-js"
-import { watch, type FSWatcher } from "fs"
-import { findGitHeadPath, getCurrentBranch } from "@runtime/git/git-info.js"
-
-export function useGitStatus(): () => string | null {
-	const [branch, setBranch] = createSignal<string | null>(getCurrentBranch())
-	let watcher: FSWatcher | null = null
-
-	onMount(() => {
-		const gitHeadPath = findGitHeadPath()
-		if (gitHeadPath) {
-			try {
-				watcher = watch(gitHeadPath, () => setBranch(getCurrentBranch()))
-			} catch {
-				// ignore watcher errors
-			}
-		}
-	})
-
-	onCleanup(() => {
-		if (watcher) {
-			watcher.close()
-			watcher = null
-		}
-	})
-
-	return branch
-}

package/src/hooks/usePromptQueue.ts

@@ -1,7 +0,0 @@
-export {
-	createPromptQueue,
-	type PromptQueue,
-	type PromptQueueItem,
-	type PromptDeliveryMode,
-	type QueueCounts,
-} from "@yeshwanthyk/runtime-effect/session/prompt-queue.js"

package/src/hooks/useSessionController.ts

@@ -1,5 +0,0 @@
-export {
-	createSessionController,
-	type SessionControllerOptions,
-	type SessionControllerState,
-} from "@runtime/session/session-controller.js"

package/src/hooks/useSpinner.ts

@@ -1,28 +0,0 @@
-import { createSignal, createEffect, onCleanup, type Accessor } from "solid-js"
-import type { ActivityState } from "../types.js"
-
-export function useSpinner(activityState: Accessor<ActivityState>): () => number {
-	const [spinnerFrame, setSpinnerFrame] = createSignal(0)
-	let spinnerInterval: ReturnType<typeof setInterval> | null = null
-
-	createEffect(() => {
-		if (activityState() !== "idle") {
-			if (!spinnerInterval) {
-				spinnerInterval = setInterval(() => setSpinnerFrame((frame) => (frame + 1) % 8), 200)
-			}
-		} else if (spinnerInterval) {
-			clearInterval(spinnerInterval)
-			spinnerInterval = null
-			setSpinnerFrame(0)
-		}
-	})
-
-	onCleanup(() => {
-		if (spinnerInterval) {
-			clearInterval(spinnerInterval)
-			spinnerInterval = null
-		}
-	})
-
-	return spinnerFrame
-}

package/src/hooks/useToastManager.ts

@@ -1,26 +0,0 @@
-import { createSignal, onCleanup } from "solid-js"
-import type { ToastItem } from "@yeshwanthyk/open-tui"
-
-export function useToastManager(limit = 3) {
-	const [toasts, setToasts] = createSignal<ToastItem[]>([])
-	const timeouts = new Set<ReturnType<typeof setTimeout>>()
-
-	onCleanup(() => {
-		for (const timeout of timeouts) {
-			clearTimeout(timeout)
-		}
-		timeouts.clear()
-	})
-
-	const pushToast = (toast: Omit<ToastItem, "id">, ttlMs = 2000) => {
-		const id = crypto.randomUUID()
-		setToasts((prev) => [{ id, ...toast }, ...prev].slice(0, limit))
-		const timeout = setTimeout(() => {
-			timeouts.delete(timeout)
-			setToasts((prev) => prev.filter((t) => t.id !== id))
-		}, ttlMs)
-		timeouts.add(timeout)
-	}
-
-	return { toasts, pushToast }
-}

package/src/index.ts

@@ -1,188 +0,0 @@
-#!/usr/bin/env bun
-
-import pkg from '../package.json';
-import { existsSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { parseArgs } from './args.js';
-import { runHeadless } from './adapters/cli/headless.js';
-import { runValidate } from './adapters/cli/validate.js';
-import { runAcp } from './adapters/acp/index.js';
-import type { ThinkingLevel } from '@yeshwanthyk/agent-core';
-
-declare const OTUI_TREE_SITTER_WORKER_PATH: string | undefined;
-
-const ensureTreeSitterWorkerPath = (): void => {
-  if (
-    process.env.OTUI_TREE_SITTER_WORKER_PATH ||
-    typeof OTUI_TREE_SITTER_WORKER_PATH !== 'undefined'
-  ) {
-    return;
-  }
-
-  const candidates: string[] = [];
-
-  const execDir = dirname(process.execPath);
-  candidates.push(join(execDir, 'parser.worker.js'));
-
-  try {
-    const moduleDir = dirname(fileURLToPath(import.meta.url));
-    candidates.push(join(moduleDir, 'parser.worker.js'));
-  } catch {
-    // Ignore non-file URLs (e.g. bundled snapshot)
-  }
-
-  try {
-    const require = createRequire(import.meta.url);
-    // Use dynamic string to prevent static analysis by bundler
-    const modulePath = ['@opentui', 'core', 'parser.worker.js'].join('/');
-    candidates.push(require.resolve(modulePath));
-  } catch {
-    // Ignore missing module resolution in minimal installs
-  }
-
-  for (const candidate of candidates) {
-    if (candidate && existsSync(candidate)) {
-      process.env.OTUI_TREE_SITTER_WORKER_PATH = candidate;
-      break;
-    }
-  }
-};
-
-ensureTreeSitterWorkerPath();
-
-// Dynamic import for TUI (requires solid plugin for TSX)
-const runTui = async (args: {
-  configDir?: string;
-  configPath?: string;
-  provider?: string;
-  model?: string;
-  thinking?: ThinkingLevel;
-  continueSession?: boolean;
-  resumeSession?: boolean;
-}) => {
-  const solidPlugin = (await import("@opentui/solid/bun-plugin")).default;
-  Bun.plugin(solidPlugin);
-
-  // Initialize tree-sitter parsers for code syntax highlighting
-  const { addDefaultParsers } = await import("@opentui/core");
-  const { parsersConfig } = await import("@yeshwanthyk/open-tui");
-  addDefaultParsers(parsersConfig.parsers);
-
-  const { runTuiOpen } = await import('./adapters/tui/app.js');
-  return runTuiOpen(args);
-};
-
-const printHelp = () => {
-  process.stdout.write(
-    [
-      'Usage:',
-      '  marvin [options] [prompt...]',
-      '  marvin validate [options]',
-      '',
-      'Options:',
-      '  --provider <name>            Provider (e.g. openai, anthropic, codex)',
-      '  --model <id>                 Model id or comma-separated list (Ctrl+P to cycle)',
-      '  --thinking <level>           off|minimal|low|medium|high|xhigh',
-      '  --config-dir <dir>           Config directory (default: ~/.config/marvin)',
-      '  --config <path>              Config file path (default: <config-dir>/config.json)',
-      '  -c, --continue               Resume most recent session for current directory',
-      '  -r, --resume                 Pick from recent sessions to resume',
-      '  --headless                   Run without TUI; reads prompt from args or stdin',
-      '  --acp                        Run as ACP server for Zed integration',
-      '  -h, --help                   Show help',
-      '  -v, --version                Print version',
-      '',
-      'Keybinds:',
-      '  Ctrl+P                       Cycle through --models list',
-      '  Shift+Tab                    Cycle thinking level',
-      '  Ctrl+C                       Clear input / double to exit',
-      '  Esc                          Abort current request',
-      '',
-      'Custom Commands:',
-      '  Place .md files in ~/.config/marvin/commands/',
-      '  Use /<name> [args] to expand the template.',
-      '  $ARGUMENTS in the template is replaced with args.',
-      '',
-      'Lifecycle Hooks:',
-      '  Place .ts files in ~/.config/marvin/hooks/',
-      '  Export default function(marvin) { marvin.on(event, handler) }',
-      '  Events: app.start, session.start/resume/clear, agent.start/end,',
-      '          turn.start/end, tool.execute.before/after',
-      '  Use marvin.send(text) to inject messages into conversation',
-      '',
-      'Custom Tools:',
-      '  Place .ts files in ~/.config/marvin/tools/',
-      '  Export default function(api) returning AgentTool or AgentTool[]',
-      '  api.cwd: current working directory',
-      '  api.exec(cmd, args, opts): run commands',
-      '',
-      'Validation:',
-      '  Run "marvin validate --config-dir <dir>" to check custom hooks/tools/commands',
-      '',
-      'Environment:',
-      '  OPENAI_API_KEY / ANTHROPIC_API_KEY / GEMINI_API_KEY / ...',
-      '',
-    ].join('\n')
-  );
-};
-
-const main = async () => {
-  const argv = process.argv.slice(2);
-  const args = parseArgs(argv);
-
-  if (args.version) {
-    process.stdout.write(`${pkg.name} ${pkg.version}\n`);
-    return;
-  }
-
-  if (args.help) {
-    printHelp();
-    return;
-  }
-
-  if (args.command === 'validate') {
-    await runValidate({
-      configDir: args.configDir,
-      configPath: args.configPath,
-      provider: args.provider,
-      model: args.model,
-      thinking: args.thinking,
-    });
-    return;
-  }
-
-  if (args.acp) {
-    await runAcp({
-      configDir: args.configDir,
-      configPath: args.configPath,
-      model: args.model,
-    });
-    return;
-  }
-
-  if (args.headless) {
-    await runHeadless({
-      prompt: args.prompt,
-      configDir: args.configDir,
-      configPath: args.configPath,
-      provider: args.provider,
-      model: args.model,
-      thinking: args.thinking,
-    });
-    return;
-  }
-
-  await runTui({
-    configDir: args.configDir,
-    configPath: args.configPath,
-    provider: args.provider,
-    model: args.model,
-    thinking: args.thinking,
-    continueSession: args.continue,
-    resumeSession: args.resume,
-  });
-};
-
-await main();