@dex-ai/coding-agent 0.1.92

package/bin/dex.ts

@@ -0,0 +1,402 @@
+#!/usr/bin/env bun
+/**
+ * dex — coding agent CLI entry point.
+ */
+
+import { createCLIHost, runCLI } from "../src/host";
+import { headlessExtension } from "../src/extensions/headless";
+import { cliTuiExtension } from "../src/extensions/cli-tui";
+import { debugExtension } from "../src/extensions/debug";
+import { loadGlobalSettings, loadAgentState } from "@dex-ai/coding-agent-sdk";
+import { createStderrCapture, createStdoutGuard } from "../src/stderr-capture";
+import { openaiExtension } from "@dex-ai/openai";
+import { anthropicExtension } from "@dex-ai/anthropic";
+import type { CLIConfig } from "../src/types";
+import type { CLIExtension } from "../src/cli-extension";
+import type { Extension } from "@dex-ai/sdk";
+
+/* ------------------------------------------------------------------ */
+/* Parse args                                                          */
+/* ------------------------------------------------------------------ */
+
+function parseArgs(args: string[]): CLIConfig {
+	const settings = loadGlobalSettings();
+	const state = loadAgentState();
+	let mode: "tui" | "headless" = "tui";
+	let provider =
+		process.env.DEX_PROVIDER ??
+		settings.defaultProvider ??
+		state.lastProvider ??
+		"";
+	let model =
+		process.env.DEX_MODEL ?? settings.defaultModel ?? state.lastModel ?? "";
+	let sessionId: string | undefined;
+	let debug = false;
+	const positional: string[] = [];
+
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i]!;
+		if (arg === "--headless") mode = "headless";
+		else if (arg === "--debug") debug = true;
+		else if (arg === "--provider" && args[i + 1]) {
+			provider = args[++i]!;
+		} else if (arg === "--model" && args[i + 1]) {
+			model = args[++i]!;
+		} else if (arg === "--session" && args[i + 1]) {
+			sessionId = args[++i]!;
+		} else if (!arg.startsWith("-")) positional.push(arg);
+	}
+
+	return {
+		mode,
+		provider,
+		model,
+		cwd: process.cwd(),
+		initialPrompt: positional.length > 0 ? positional.join(" ") : undefined,
+		...(sessionId !== undefined ? { sessionId } : {}),
+		...(debug ? { debug: true } : {}),
+	};
+}
+
+/* ------------------------------------------------------------------ */
+/* Load custom provider extensions from ~/.dex/agent/extensions/       */
+/* ------------------------------------------------------------------ */
+
+import { existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { loadInstalledExtensions } from "../src/commands/extension-loader";
+
+const AGENT_EXTENSIONS_DIR = join(homedir(), ".dex", "agent", "extensions");
+
+async function loadCustomProviders(): Promise<{
+	providers: Map<string, Extension>;
+	extensions: Extension[];
+}> {
+	const providers = new Map<string, Extension>();
+	const extensions: Extension[] = [];
+
+	// 1. Load legacy ~/.dex/agent/extensions/ (bundled provider extensions)
+	if (existsSync(AGENT_EXTENSIONS_DIR)) {
+		const entries = readdirSync(AGENT_EXTENSIONS_DIR);
+		for (const entry of entries) {
+			const extPath = join(AGENT_EXTENSIONS_DIR, entry);
+			if (!statSync(extPath).isDirectory()) continue;
+
+			// Look for index.js (bundled, works from compiled binary) or index.ts
+			const indexJs = join(extPath, "index.js");
+			const indexTs = join(extPath, "index.ts");
+			const entryFile = existsSync(indexJs)
+				? indexJs
+				: existsSync(indexTs)
+					? indexTs
+					: null;
+
+			if (!entryFile) continue;
+
+			try {
+				const mod = await import(entryFile);
+				let ext: Extension | null = null;
+
+				// Resolve the extension object
+				if (typeof mod.provider === "function") {
+					ext = mod.provider();
+				} else if (typeof mod.default === "function") {
+					ext = mod.default();
+				} else if (
+					mod.default &&
+					typeof mod.default === "object" &&
+					mod.default.name
+				) {
+					ext = mod.default;
+				}
+
+				if (!ext) continue;
+
+				// Classify: if it provides models, it's a provider; otherwise general extension
+				if ((ext as any).models && (ext as any).models.length > 0) {
+					providers.set(entry, ext);
+				} else {
+					extensions.push(ext);
+				}
+			} catch (err) {
+				console.error(
+					`Failed to load extension "${entry}":`,
+					err instanceof Error ? err.message : err,
+				);
+			}
+		}
+	}
+
+	// 2. Load installed extensions from registry (isolated per-extension directories)
+	const cwd = process.cwd();
+	const installed = await loadInstalledExtensions(cwd);
+
+	for (const ext of installed.extensions) {
+		extensions.push(ext);
+	}
+	for (const [name, ext] of installed.providers) {
+		providers.set(name, ext);
+	}
+
+	return { providers, extensions };
+}
+
+import { createProviderFromConfig } from "../src/provider-registry";
+
+/* ------------------------------------------------------------------ */
+/* Resolve provider                                                    */
+/* ------------------------------------------------------------------ */
+
+async function resolveProvider(
+	name: string,
+	model: string,
+	customProviders: Map<string, Extension>,
+): Promise<Extension> {
+	// Check custom providers first (file-based extensions)
+	if (customProviders.has(name)) {
+		return customProviders.get(name)!;
+	}
+
+	// Check settings.json providers (case-insensitive lookup)
+	const settings = loadGlobalSettings();
+	const providerEntry = Object.entries(settings.providers ?? {}).find(
+		([key]) => key.toLowerCase() === name.toLowerCase(),
+	);
+	if (providerEntry) {
+		const [, providerConfig] = providerEntry;
+		return createProviderFromConfig(name, providerConfig);
+	}
+
+	// Built-in fallbacks
+	switch (name) {
+		case "openai":
+			try {
+				return openaiExtension({
+					name: "openai",
+					models: [model],
+					modelsPath: null,
+				});
+			} catch {
+				// No API key configured — return stub, user can configure later
+				return { name: "openai", models: [] };
+			}
+		case "anthropic":
+			try {
+				return anthropicExtension({
+					name: "anthropic",
+					models: [model],
+					modelsPath: null,
+				});
+			} catch {
+				return { name: "anthropic", models: [] };
+			}
+		default:
+			// Return a stub provider so the agent can still start up.
+			// The user will see a model resolution error when they try to generate
+			// and can fix it with /provider or /model commands.
+			return {
+				name,
+				models: [],
+			};
+	}
+}
+
+/**
+ * Resolve all additional provider extensions (excluding the primary one).
+ * These are loaded so the user can switch models at runtime via /model.
+ */
+async function resolveAdditionalProviders(
+	primaryName: string,
+	customProviders: Map<string, Extension>,
+): Promise<Extension[]> {
+	const additional: Extension[] = [];
+	const settings = loadGlobalSettings();
+	const primaryLower = primaryName.toLowerCase();
+
+	// Custom file-based providers
+	for (const [name, ext] of customProviders) {
+		if (name.toLowerCase() === primaryLower) continue;
+		additional.push(ext);
+	}
+
+	// Settings.json providers
+	const settingsProviderNames = new Set<string>();
+	for (const [name, providerConfig] of Object.entries(
+		settings.providers ?? {},
+	)) {
+		if (name.toLowerCase() === primaryLower) continue;
+		if (customProviders.has(name)) continue; // already added
+		settingsProviderNames.add(
+			(providerConfig as any).type?.toLowerCase() ?? name.toLowerCase(),
+		);
+		try {
+			additional.push(createProviderFromConfig(name, providerConfig));
+		} catch {
+			// Skip providers that fail to load
+		}
+	}
+
+	// Built-in fallbacks (only if not already the primary and not in settings)
+	if (
+		primaryLower !== "openai" &&
+		!customProviders.has("openai") &&
+		!settingsProviderNames.has("openai")
+	) {
+		try {
+			additional.push(openaiExtension({ name: "openai", modelsPath: null }));
+		} catch {
+			/* skip if no API key */
+		}
+	}
+	if (
+		primaryLower !== "anthropic" &&
+		!customProviders.has("anthropic") &&
+		!settingsProviderNames.has("anthropic")
+	) {
+		try {
+			additional.push(
+				anthropicExtension({ name: "anthropic", modelsPath: null }),
+			);
+		} catch {
+			/* skip if no API key */
+		}
+	}
+
+	return additional;
+}
+
+/* ------------------------------------------------------------------ */
+/* Main                                                                */
+/* ------------------------------------------------------------------ */
+
+// Intercept 'dex extension' subcommand — runs and exits without starting the agent
+if (process.argv[2] === "extension" || process.argv[2] === "ext") {
+	const { runExtensionCommand } = await import("../src/commands/extension");
+	runExtensionCommand(process.argv.slice(3));
+	process.exit(0);
+}
+
+// Intercept 'dex update' subcommand — updates dex + extensions and exits
+if (process.argv[2] === "update" || process.argv[2] === "upgrade") {
+	const { runUpdateCommand } = await import("../src/commands/update");
+	runUpdateCommand();
+	process.exit(0);
+}
+
+const config = parseArgs(process.argv.slice(2));
+
+// Load custom extensions (providers + general)
+const { providers: customProviders, extensions: userExtensions } =
+	await loadCustomProviders();
+
+// Shared state that persists across hot-reloads
+let capture: ReturnType<typeof createStderrCapture> | null = null;
+let debugExt: ReturnType<typeof debugExtension> | null = null;
+
+/** Cache-bust counter for hot-reloading ESM modules. */
+let reloadCounter = 0;
+
+/** Workspace root — all dex-ai-* repos live here. */
+const WORKSPACE_ROOT = join(import.meta.dir, "../../..");
+
+/**
+ * Invalidate Bun's module cache for all workspace source files.
+ * This ensures that changes to any dex-ai-* repo (vue-tui, sdk, extensions, etc.)
+ * are picked up on hot-reload. Only clears workspace source, not node_modules.
+ */
+function invalidateExtensionCache(): void {
+	for (const key of Object.keys(require.cache)) {
+		// Clear workspace sources but skip node_modules (3rd party deps don't change)
+		if (key.startsWith(WORKSPACE_ROOT) && !key.includes("/node_modules/")) {
+			delete require.cache[key];
+		}
+	}
+}
+
+/**
+ * Factory that creates fresh CLI extension instances.
+ * On reload, re-imports extension modules from disk to pick up source changes.
+ */
+async function createCliExtensions(): Promise<CLIExtension[]> {
+	const v = ++reloadCounter;
+
+	// Invalidate module cache for extension source files (including .vue components)
+	invalidateExtensionCache();
+
+	// Dynamic imports with cache-busting query param to bypass Bun's ESM cache
+	const [tuiMod, debugMod] = await Promise.all([
+		config.mode !== "headless"
+			? import("../src/extensions/cli-tui" + `?v=${v}`)
+			: null,
+		config.mode !== "headless"
+			? import("../src/extensions/debug" + `?v=${v}`)
+			: null,
+	]);
+
+	const exts: CLIExtension[] = [];
+
+	if (config.mode === "headless") {
+		const headlessMod = await import("../src/extensions/headless" + `?v=${v}`);
+		exts.push(headlessMod.headlessExtension());
+	} else {
+		// Debug extension — re-create with fresh module but same capture
+		const debugEnabled = config.debug || loadGlobalSettings().debug === true;
+		if (debugEnabled && debugMod) {
+			debugExt = debugMod.debugExtension({ capture: capture! });
+			exts.push(debugExt!);
+		}
+
+		exts.push(
+			tuiMod!.cliTuiExtension({
+				capture: capture!,
+				reloadVersion: v,
+			}),
+		);
+	}
+
+	return exts;
+}
+
+// Initial extension creation (no hot-reload needed for first boot)
+const cliExtensions: CLIExtension[] = [];
+
+if (config.mode === "headless") {
+	cliExtensions.push(headlessExtension());
+} else {
+	// Install stderr capture immediately — prevents background output from corrupting TUI.
+	// Must happen as early as possible before any async work that may write to stderr.
+	capture = createStderrCapture();
+	capture.install();
+
+	// Install stdout guard — redirects stray stdout writes (console.log, SDK debug output)
+	// to stderr (which is captured). TUI renderer writes pass through (contain ESC sequences).
+	const stdoutGuard = createStdoutGuard();
+	stdoutGuard.install();
+
+	// Debug extension — enabled via --debug flag or debug: true in ~/.dex/settings.json
+	const debugEnabled = config.debug || loadGlobalSettings().debug === true;
+	debugExt = debugEnabled ? debugExtension({ capture }) : null;
+	if (debugExt) cliExtensions.push(debugExt);
+
+	cliExtensions.push(cliTuiExtension({ capture }));
+}
+
+const providerExt = await resolveProvider(
+	config.provider,
+	config.model,
+	customProviders,
+);
+const additionalProviders = await resolveAdditionalProviders(
+	config.provider,
+	customProviders,
+);
+const host = await createCLIHost(
+	config,
+	cliExtensions,
+	providerExt,
+	createCliExtensions,
+	additionalProviders,
+	userExtensions,
+);
+await runCLI(host);

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@dex-ai/coding-agent",
+  "version": "0.1.92",
+  "description": "Coding agent CLI — event-driven terminal host with TUI, headless, and extensible modes.",
+  "type": "module",
+  "bin": {
+    "dex": "./bin/dex.ts"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "bin"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "dev": "bun run bin/dex.ts",
+    "build": "bash scripts/build.sh",
+    "deploy": "bash scripts/deploy.sh"
+  },
+  "dependencies": {
+    "@dex-ai/anthropic": "^0.1.3",
+    "@dex-ai/coding-agent-sdk": "^0.1.21",
+    "@dex-ai/google": "^0.1.2",
+    "@dex-ai/ollama": "^0.1.2",
+    "@dex-ai/openai": "^0.1.7",
+    "@dex-ai/openrouter": "^0.1.5",
+    "@dex-ai/context": "^0.7.12",
+    "@dex-ai/sdk": "^0.1.29",
+    "@dex-ai/vue-tui": "^0.1.9",
+    "@dex-ai/vue-tui-markdown": "^0.1.3",
+    "@vue/reactivity": "^3.5.0",
+    "@vue/runtime-core": "^3.5.0",
+    "@vue/shared": "^3.5.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/__tests__/command-validation.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Unit tests for command validation logic extracted from cli-tui.ts.
+ *
+ * Tests the validateCommand function behavior:
+ * - Recognized commands (exact match, with args, with subcommands)
+ * - Unrecognized commands
+ * - Empty / alone
+ * - Partial matches are NOT validated (they should auto-complete, not error)
+ */
+
+import { describe, it, expect } from "bun:test";
+
+// ─────────────────────────────────────────────────────────────
+// Extracted validation logic (mirrors cli-tui.ts)
+// ─────────────────────────────────────────────────────────────
+
+const availableCommands = [
+	{ name: "help", description: "Show available commands" },
+	{ name: "new", description: "Start a new conversation" },
+	{ name: "resume", description: "Resume a previous session" },
+	{ name: "model", description: "Switch the active model" },
+	{ name: "thinking", description: "Set thinking/reasoning level" },
+	{ name: "provider", description: "Manage API providers" },
+	{ name: "extension", description: "Manage extensions" },
+	{ name: "reload", description: "Reload configuration" },
+	{ name: "exit", description: "Exit the application" },
+	{ name: "quit", description: "Quit the application" },
+];
+
+const subcommands: Record<
+	string,
+	Array<{ name: string; description: string }>
+> = {
+	provider: [{ name: "provider add", description: "Add a new provider" }],
+};
+
+function validateCommand(input: string): { valid: boolean; reason?: string } {
+	const trimmed = input.trim();
+	if (!trimmed.startsWith("/")) {
+		return { valid: true };
+	}
+
+	const afterSlash = trimmed.slice(1);
+	const spaceIdx = afterSlash.indexOf(" ");
+	const commandName = spaceIdx > 0 ? afterSlash.slice(0, spaceIdx) : afterSlash;
+
+	if (!commandName) {
+		return {
+			valid: false,
+			reason:
+				"Type a command name after /. Press /help for available commands.",
+		};
+	}
+
+	const known = availableCommands.find((c) => c.name === commandName);
+	if (!known) {
+		return {
+			valid: false,
+			reason: `Unknown command: /${commandName}. Type /help for available commands.`,
+		};
+	}
+
+	if (spaceIdx > 0) {
+		const remainder = afterSlash.slice(spaceIdx + 1).trim();
+		if (remainder) {
+			const subs = subcommands[commandName];
+			if (subs) {
+				const subName = remainder.split(" ")[0]!;
+				const fullSub = `${commandName} ${subName}`;
+				const knownSub = subs.find((s) => s.name === fullSub);
+				if (!knownSub) {
+					const available = subs.map((s) => `/${s.name}`).join(", ");
+					return {
+						valid: false,
+						reason: `Unknown subcommand: /${commandName} ${subName}. Available: ${available}`,
+					};
+				}
+			}
+		}
+	}
+
+	return { valid: true };
+}
+
+// ─────────────────────────────────────────────────────────────
+// Tests
+// ─────────────────────────────────────────────────────────────
+
+describe("validateCommand", () => {
+	describe("non-command input", () => {
+		it("should accept regular messages (no / prefix)", () => {
+			expect(validateCommand("hello world")).toEqual({ valid: true });
+			expect(validateCommand("fix this bug")).toEqual({ valid: true });
+			expect(validateCommand("")).toEqual({ valid: true });
+		});
+	});
+
+	describe("exact valid commands", () => {
+		it("should accept all known commands", () => {
+			for (const cmd of availableCommands) {
+				expect(validateCommand(`/${cmd.name}`)).toEqual({ valid: true });
+			}
+		});
+
+		it("should accept commands with trailing whitespace", () => {
+			expect(validateCommand("/help  ")).toEqual({ valid: true });
+			expect(validateCommand("/model ")).toEqual({ valid: true });
+		});
+	});
+
+	describe("valid subcommands", () => {
+		it("should accept /provider add", () => {
+			expect(validateCommand("/provider add")).toEqual({ valid: true });
+		});
+
+		it("should accept /provider add with extra args", () => {
+			expect(validateCommand("/provider add extra-args")).toEqual({
+				valid: true,
+			});
+		});
+	});
+
+	describe("commands without subcommand restrictions", () => {
+		it("should accept /model with any args (no subcommands defined)", () => {
+			expect(validateCommand("/model gpt-4")).toEqual({ valid: true });
+			expect(validateCommand("/model custom-args here")).toEqual({
+				valid: true,
+			});
+		});
+
+		it("should accept /resume with any args", () => {
+			expect(validateCommand("/resume session-123")).toEqual({ valid: true });
+		});
+	});
+
+	describe("empty or incomplete commands", () => {
+		it("should reject just /", () => {
+			const result = validateCommand("/");
+			expect(result.valid).toBe(false);
+			expect(result.reason).toContain("Type a command name");
+		});
+
+		it("should reject / with only whitespace", () => {
+			const result = validateCommand("/   ");
+			expect(result.valid).toBe(false);
+			expect(result.reason).toContain("Type a command name");
+		});
+	});
+
+	describe("unrecognized commands", () => {
+		it("should reject unknown command names", () => {
+			const result = validateCommand("/foo");
+			expect(result.valid).toBe(false);
+			expect(result.reason).toContain("Unknown command: /foo");
+			expect(result.reason).toContain("/help");
+		});
+
+		it("should reject partial unknown commands", () => {
+			const result = validateCommand("/prov");
+			expect(result.valid).toBe(false);
+			expect(result.reason).toContain("Unknown command: /prov");
+		});
+
+		it("should reject unknown commands with args", () => {
+			const result = validateCommand("/bar baz qux");
+			expect(result.valid).toBe(false);
+			expect(result.reason).toContain("Unknown command: /bar");
+		});
+	});
+
+	describe("invalid subcommands", () => {
+		it("should reject unknown subcommands for /provider", () => {
+			const result = validateCommand("/provider remove");
+			expect(result.valid).toBe(false);
+			expect(result.reason).toContain("Unknown subcommand: /provider remove");
+			expect(result.reason).toContain("/provider add");
+		});
+
+		it("should reject unknown subcommands with extra args", () => {
+			const result = validateCommand("/provider delete my-provider");
+			expect(result.valid).toBe(false);
+			expect(result.reason).toContain("Unknown subcommand: /provider delete");
+		});
+	});
+
+	describe("guard against sending invalid commands to LLM", () => {
+		it("should NOT be valid for typos that could reach the LLM", () => {
+			// These are the cases we're trying to catch
+			const typoCases = [
+				"/prov",
+				"/hellp",
+				"/mdoel",
+				"/exitt",
+				"/modle",
+				"/proivder",
+			];
+
+			for (const typo of typoCases) {
+				const result = validateCommand(typo);
+				expect(result.valid).toBe(false);
+				expect(result.reason).toBeDefined();
+			}
+		});
+	});
+});