@dex-ai/coding-agent-sdk 0.1.21

package/src/extensions/workspace.ts

@@ -0,0 +1,236 @@
+/**
+ * Workspace Extension — detects git repos, project type, manages .dex/ directory.
+ *
+ * Two modes:
+ * - Single-repo: cwd is inside a git repository → standard behavior.
+ * - Multi-repo:  cwd is NOT a git repo but contains child directories that are
+ *                git repos → reports all child repositories for coordinated changes.
+ *
+ * The workspace layout is injected directly into the system prompt at session
+ * start (via session-start event) — no skill/tool fetch required.
+ */
+
+import type { Extension, AgentContext, Content } from "@dex-ai/sdk";
+import { existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { resolve, join, basename } from "node:path";
+import { execSync } from "node:child_process";
+import type { Workspace, Repository, ProjectType } from "../types";
+
+export interface WorkspaceExtensionOptions {
+	cwd?: string;
+	/** Maximum depth to scan for git repositories (relative to cwd). Default: 2. */
+	maxDepth?: number;
+}
+
+function isGitRepo(dir: string): boolean {
+	try {
+		execSync("git rev-parse --is-inside-work-tree", {
+			cwd: dir,
+			encoding: "utf-8",
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function detectGitRoot(cwd: string): string | null {
+	try {
+		return execSync("git rev-parse --show-toplevel", {
+			cwd,
+			encoding: "utf-8",
+			stdio: ["pipe", "pipe", "pipe"],
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+
+function detectBranch(cwd: string): string | undefined {
+	try {
+		return (
+			execSync("git branch --show-current", {
+				cwd,
+				encoding: "utf-8",
+				stdio: ["pipe", "pipe", "pipe"],
+			}).trim() || undefined
+		);
+	} catch {
+		return undefined;
+	}
+}
+
+function detectProjectType(root: string): ProjectType {
+	if (existsSync(join(root, "package.json"))) return "node";
+	if (
+		existsSync(join(root, "pyproject.toml")) ||
+		existsSync(join(root, "setup.py"))
+	)
+		return "python";
+	if (existsSync(join(root, "Cargo.toml"))) return "rust";
+	if (existsSync(join(root, "go.mod"))) return "go";
+	if (
+		existsSync(join(root, "pom.xml")) ||
+		existsSync(join(root, "build.gradle"))
+	)
+		return "java";
+	return "unknown";
+}
+
+/**
+ * Recursively scan directories for git repositories up to `maxDepth` levels.
+ * Stops descending into a directory once it's identified as a git repo.
+ */
+function discoverRepos(cwd: string, maxDepth: number): Repository[] {
+	const repos: Repository[] = [];
+
+	function scan(dir: string, depth: number): void {
+		if (depth > maxDepth) return;
+
+		let entries: string[];
+		try {
+			entries = readdirSync(dir);
+		} catch {
+			return;
+		}
+
+		for (const entry of entries) {
+			// Skip hidden dirs and node_modules
+			if (entry.startsWith(".") || entry === "node_modules") continue;
+
+			const childPath = join(dir, entry);
+			try {
+				if (!statSync(childPath).isDirectory()) continue;
+			} catch {
+				continue;
+			}
+
+			if (isGitRepo(childPath)) {
+				// Found a git repo — add it and don't descend further
+				repos.push({
+					path: childPath,
+					name: basename(childPath),
+					branch: detectBranch(childPath),
+					projectType: detectProjectType(childPath),
+				});
+			} else if (depth < maxDepth) {
+				// Not a git repo — keep scanning deeper
+				scan(childPath, depth + 1);
+			}
+		}
+	}
+
+	scan(cwd, 1);
+
+	// Sort alphabetically for consistent ordering
+	repos.sort((a, b) => a.name.localeCompare(b.name));
+	return repos;
+}
+
+/**
+ * Build a text description of the workspace layout for system prompt injection.
+ */
+function buildWorkspaceContext(workspace: Workspace): string {
+	if (!workspace.multiRepo || !workspace.repositories?.length) {
+		// Single-repo context
+		const lines = [
+			`## Workspace`,
+			``,
+			`- **Root**: \`${workspace.root}\``,
+			`- **Project type**: ${workspace.projectType}`,
+		];
+		if (workspace.gitBranch) {
+			lines.push(`- **Branch**: \`${workspace.gitBranch}\``);
+		}
+		return lines.join("\n");
+	}
+
+	// Multi-repo context
+	const lines = [
+		`## Workspace (Multi-Repository)`,
+		``,
+		`You are working in a workspace that contains **${workspace.repositories.length} repositories**.`,
+		`The working directory is \`${workspace.cwd}\` which is NOT itself a git repo — it's a parent folder containing multiple repos.`,
+		``,
+		`When making changes, be aware of which repository a file belongs to. You can make coordinated changes across multiple repos.`,
+		``,
+		`### Repositories`,
+		``,
+	];
+
+	for (const repo of workspace.repositories) {
+		const branch = repo.branch ? ` (branch: \`${repo.branch}\`)` : "";
+		const type = repo.projectType !== "unknown" ? ` [${repo.projectType}]` : "";
+		lines.push(`- **${repo.name}**${type}: \`${repo.path}\`${branch}`);
+	}
+
+	return lines.join("\n");
+}
+
+export function workspaceExtension(
+	opts: WorkspaceExtensionOptions = {},
+): Extension {
+	let workspace: Workspace | undefined;
+
+	return {
+		name: "workspace",
+
+		init(actx: AgentContext) {
+			const cwd = resolve(opts.cwd ?? process.cwd());
+			const maxDepth = opts.maxDepth ?? 2;
+			const gitRoot = detectGitRoot(cwd);
+
+			if (gitRoot !== null) {
+				// Single-repo mode: cwd is inside a git repo
+				const dexDir = join(gitRoot, ".dex");
+				const gitBranch = detectBranch(cwd);
+				const projectType = detectProjectType(gitRoot);
+
+				if (!existsSync(dexDir)) {
+					mkdirSync(dexDir, { recursive: true });
+				}
+
+				workspace = {
+					cwd,
+					root: gitRoot,
+					dexDir,
+					projectType,
+					multiRepo: false,
+					...(gitBranch !== undefined ? { gitBranch } : {}),
+				};
+			} else {
+				// Not in a git repo — scan for child repos (multi-repo mode)
+				const repositories = discoverRepos(cwd, maxDepth);
+				const multiRepo = repositories.length > 0;
+				const dexDir = join(cwd, ".dex");
+
+				if (!existsSync(dexDir)) {
+					mkdirSync(dexDir, { recursive: true });
+				}
+
+				workspace = {
+					cwd,
+					root: cwd,
+					dexDir,
+					projectType: detectProjectType(cwd),
+					multiRepo,
+					...(multiRepo ? { repositories } : {}),
+				};
+			}
+
+			actx.state.set("workspace", workspace);
+		},
+
+		on: {
+			"session-start"(actx: AgentContext) {
+				if (!workspace) return;
+				const text = buildWorkspaceContext(workspace);
+				const content: Content = { type: "text", text };
+				return (async function* () {
+					yield content;
+				})();
+			},
+		},
+	};
+}

package/src/index.ts

@@ -0,0 +1,45 @@
+/**
+ * @dex-ai/coding-agent-sdk — coding agent extensions + factory.
+ */
+
+export { CodingAgent } from "./create";
+export { envExtension } from "./extensions/env";
+export type { EnvExtensionOptions, EnvState } from "./extensions/env";
+export type {
+	CodingAgentOptions,
+	CodingAgentConfig,
+	Workspace,
+	Repository,
+	ProjectType,
+	ApprovalConfig,
+	ApprovalHandler,
+	ApprovalRequest,
+	ApprovalResult,
+	ToolCategory,
+	PermissionMode,
+	PermissionSettings,
+} from "./types";
+export {
+	settingsExtension,
+	loadGlobalSettings,
+	saveGlobalSettings,
+	addAllowedTool,
+	setPermissionMode,
+	setDefaultThinking,
+	saveProviderConfig,
+	setDefaultProvider,
+	saveLastUsedModel,
+	loadAgentState,
+} from "./extensions/settings";
+export type {
+	GlobalSettings,
+	SettingsExtensionState,
+	ProviderSettingsConfig,
+	AgentState,
+} from "./extensions/settings";
+export { listSessions } from "./extensions/session";
+export type { SessionInfo } from "./extensions/session";
+export { buildSystemPrompt } from "./extensions/system-prompt";
+export type { SystemPromptOptions } from "./extensions/system-prompt";
+export { tasksExtension } from "@dex-ai/core-extensions";
+export type { Task, TaskStatus, TaskEvent } from "@dex-ai/core-extensions";

package/src/types.ts

@@ -0,0 +1,148 @@
+/**
+ * Shared types for @dex-ai/coding-agent-sdk.
+ */
+
+import type { Extension } from "@dex-ai/sdk";
+
+/* ------------------------------------------------------------------ */
+/* Config                                                              */
+/* ------------------------------------------------------------------ */
+
+export interface CodingAgentConfig {
+	readonly provider: string;
+	readonly model: string;
+	readonly cwd: string;
+	readonly maxSteps?: number;
+	readonly maxTokens?: number;
+	readonly temperature?: number;
+	readonly approval?: ApprovalConfig;
+	readonly extensions?: ReadonlyArray<string>;
+}
+
+export interface ApprovalConfig {
+	/** Tools that never need approval. Default: ["read", "search"]. */
+	readonly safeTools?: ReadonlyArray<string>;
+	/** Regex patterns for bash commands that are auto-approved. */
+	readonly autoApprovePatterns?: ReadonlyArray<string>;
+	/** Approval mode. Default: "destructive". */
+	readonly mode?: "always" | "destructive" | "never";
+}
+
+/* ------------------------------------------------------------------ */
+/* Permission Mode                                                     */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Permission modes — controls how tool approvals are handled.
+ *   - 'read': allow read tools, require one-time session approval for all others
+ *   - 'auto': allow read tools + always-allowed tools, one-time session approval for rest
+ *   - 'yolo': bypass all permissions except deny list
+ */
+export type PermissionMode = "read" | "auto" | "yolo";
+
+export interface PermissionSettings {
+	/** Active permission mode. Default: 'auto'. */
+	readonly mode: PermissionMode;
+	/** Tools that are always allowed (auto-approved in 'auto' mode). */
+	readonly allowedTools?: ReadonlyArray<string>;
+	/** Tools that are always denied (blocked in 'yolo' mode). */
+	readonly deniedTools?: ReadonlyArray<string>;
+}
+
+/* ------------------------------------------------------------------ */
+/* Workspace                                                           */
+/* ------------------------------------------------------------------ */
+
+export type ProjectType =
+	| "node"
+	| "python"
+	| "rust"
+	| "go"
+	| "java"
+	| "unknown";
+
+export interface Repository {
+	/** Absolute path to the repository root. */
+	readonly path: string;
+	/** Directory name (basename). */
+	readonly name: string;
+	/** Current git branch. */
+	readonly branch?: string | undefined;
+	/** Detected project type. */
+	readonly projectType: ProjectType;
+}
+
+export interface Workspace {
+	/** Working directory. */
+	readonly cwd: string;
+	/** Git root (or cwd if no git). */
+	readonly root: string;
+	/** .dex/ directory path. */
+	readonly dexDir: string;
+	/** Detected project type (of root or primary repo). */
+	readonly projectType: ProjectType;
+	/** Current git branch (single-repo mode). */
+	readonly gitBranch?: string | undefined;
+	/** Whether we're in multi-repo mode (cwd contains multiple git repos). */
+	readonly multiRepo: boolean;
+	/** Child repositories (multi-repo mode only). */
+	readonly repositories?: ReadonlyArray<Repository> | undefined;
+}
+
+/* ------------------------------------------------------------------ */
+/* Approval                                                            */
+/* ------------------------------------------------------------------ */
+
+export type ToolCategory = "safe" | "write" | "execute" | "dangerous";
+
+export interface ApprovalRequest {
+	readonly toolName: string;
+	readonly toolCallId: string;
+	readonly input: unknown;
+	readonly category: ToolCategory;
+	readonly reason: string;
+}
+
+export type ApprovalResult =
+	| { readonly decision: "allow" }
+	| { readonly decision: "deny"; readonly reason?: string }
+	| { readonly decision: "allow-session" }
+	| { readonly decision: "allow-always" };
+
+export type ApprovalHandler = (
+	request: ApprovalRequest,
+) => Promise<ApprovalResult>;
+
+/* ------------------------------------------------------------------ */
+/* CodingAgent options                                                 */
+/* ------------------------------------------------------------------ */
+
+export interface CodingAgentOptions {
+	/** Provider extension name. */
+	readonly provider: string;
+	/** Model ID. */
+	readonly model: string;
+	/** Provider extension instance (e.g. openaiExtension()). */
+	readonly providerExtension: Extension;
+	/** Additional provider extensions (for multi-provider model switching). */
+	readonly providerExtensions?: ReadonlyArray<Extension> | undefined;
+	/** Working directory. Default: process.cwd(). */
+	readonly cwd?: string | undefined;
+	/** Additional root directories for the sandbox. The agent can `cd` into any of these. */
+	readonly rootDirs?: string[] | undefined;
+	/** Override the default system prompt. If omitted, uses the built-in Dex prompt. */
+	readonly systemPrompt?: string | undefined;
+	/** Explicit config overrides. */
+	readonly config?: Partial<CodingAgentConfig> | undefined;
+	/** Additional extensions (SDK or CLI unified). */
+	readonly extensions?: ReadonlyArray<Extension> | undefined;
+	/** Approval handler — provided by the CLI host or consumer. */
+	readonly onApproval?: ApprovalHandler | undefined;
+	/** Resume an existing session. */
+	readonly sessionId?: string | undefined;
+	/** Session storage directory. Default: .dex/sessions/. */
+	readonly sessionDir?: string | undefined;
+
+	/** Seed messages to restore conversation history (e.g. on reload). */
+	readonly messages?: ReadonlyArray<import("@dex-ai/sdk").Message> | undefined;
+}