@ottocode/sdk 0.1.245 → 0.1.247

package/src/core/src/tools/builtin/shell.ts

@@ -0,0 +1,273 @@
+import { tool, type Tool } from 'ai';
+import { spawn } from 'node:child_process';
+import { z } from 'zod/v3';
+import DESCRIPTION from './shell.txt' with { type: 'text' };
+import { getAugmentedPath } from '../bin-manager.ts';
+import { createToolError, type ToolResponse } from '../error.ts';
+import { injectCoAuthorIntoGitCommit } from './git-identity.ts';
+
+function normalizePath(p: string) {
+	const normalized = p.replace(/\\/g, '/');
+	const driveMatch = normalized.match(/^([A-Za-z]):\//);
+	const drivePrefix = driveMatch ? `${driveMatch[1]}:` : '';
+	const rest = driveMatch ? normalized.slice(2) : normalized;
+	const parts = rest.split('/');
+	const stack: string[] = [];
+	for (const part of parts) {
+		if (!part || part === '.') continue;
+		if (part === '..') stack.pop();
+		else stack.push(part);
+	}
+	if (drivePrefix) return `${drivePrefix}/${stack.join('/')}`;
+	return `/${stack.join('/')}`;
+}
+
+function resolveSafePath(projectRoot: string, p: string) {
+	const root = normalizePath(projectRoot);
+	const abs = normalizePath(`${root}/${p || '.'}`);
+	if (!(abs === root || abs.startsWith(`${root}/`))) {
+		throw new Error(`cwd escapes project root: ${p}`);
+	}
+	return abs;
+}
+
+function killProcessTree(pid: number) {
+	try {
+		process.kill(-pid, 'SIGTERM');
+	} catch {
+		try {
+			process.kill(pid, 'SIGTERM');
+		} catch {}
+	}
+}
+
+type ShellResult = ToolResponse<{
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+}>;
+
+type ShellStreamChunk =
+	| {
+			channel: 'output';
+			delta: string;
+	  }
+	| {
+			result: ShellResult;
+	  };
+
+const shellInputSchema = z
+	.object({
+		cmd: z
+			.string()
+			.describe('Non-interactive shell command to run (bash -c <cmd>)'),
+		cwd: z
+			.string()
+			.default('.')
+			.describe('Working directory relative to project root'),
+		allowNonZeroExit: z
+			.boolean()
+			.optional()
+			.default(false)
+			.describe('If true, do not throw on non-zero exit'),
+		timeout: z
+			.number()
+			.optional()
+			.default(300000)
+			.describe('Timeout in milliseconds (default: 300000 = 5 minutes)'),
+	})
+	.strict();
+
+type ShellInput = z.infer<typeof shellInputSchema>;
+
+type ShellToolFactory = (definition: {
+	description: string;
+	inputSchema: typeof shellInputSchema;
+	execute(
+		input: ShellInput,
+		options?: { abortSignal?: AbortSignal },
+	): AsyncIterable<ShellStreamChunk> | ShellResult;
+}) => Tool;
+
+export function buildShellTool(projectRoot: string): {
+	name: string;
+	tool: Tool;
+} {
+	const createTool = tool as unknown as ShellToolFactory;
+	const shell = createTool({
+		description: DESCRIPTION,
+		inputSchema: shellInputSchema,
+		execute(
+			{ cmd, cwd, allowNonZeroExit, timeout = 300000 }: ShellInput,
+			options?: { abortSignal?: AbortSignal },
+		): AsyncIterable<ShellStreamChunk> | ShellResult {
+			const abortSignal = options?.abortSignal;
+
+			if (abortSignal?.aborted) {
+				return createToolError('Command aborted before execution', 'abort', {
+					cmd,
+				});
+			}
+
+			const absCwd = resolveSafePath(projectRoot, cwd || '.');
+			const finalCmd = injectCoAuthorIntoGitCommit(cmd);
+
+			const proc = spawn(finalCmd, {
+				cwd: absCwd,
+				shell: true,
+				stdio: ['ignore', 'pipe', 'pipe'],
+				env: { ...process.env, PATH: getAugmentedPath() },
+				detached: true,
+			});
+
+			let stdout = '';
+			let stderr = '';
+			let didTimeout = false;
+			let didAbort = false;
+			let settled = false;
+			let done = false;
+			let timeoutId: ReturnType<typeof setTimeout> | null = null;
+			const queue: ShellStreamChunk[] = [];
+			let notify: (() => void) | null = null;
+
+			const wake = () => {
+				if (!notify) return;
+				notify();
+				notify = null;
+			};
+
+			const pushDelta = (text: string) => {
+				if (!text) return;
+				queue.push({ channel: 'output', delta: text });
+				wake();
+			};
+
+			const settle = (result: ShellResult) => {
+				if (settled) return;
+				settled = true;
+				if (timeoutId) clearTimeout(timeoutId);
+				if (abortSignal) {
+					abortSignal.removeEventListener('abort', onAbort);
+				}
+				queue.push({ result });
+				done = true;
+				wake();
+			};
+
+			const onAbort = () => {
+				if (settled) return;
+				didAbort = true;
+				if (proc.pid) killProcessTree(proc.pid);
+				else proc.kill('SIGTERM');
+			};
+
+			if (abortSignal) {
+				abortSignal.addEventListener('abort', onAbort, { once: true });
+			}
+
+			if (timeout > 0) {
+				timeoutId = setTimeout(() => {
+					didTimeout = true;
+					if (proc.pid) killProcessTree(proc.pid);
+					else proc.kill();
+				}, timeout);
+			}
+
+			proc.stdout?.on('data', (chunk) => {
+				const text = chunk.toString();
+				stdout += text;
+				pushDelta(text);
+			});
+
+			proc.stderr?.on('data', (chunk) => {
+				const text = chunk.toString();
+				stderr += text;
+				pushDelta(text);
+			});
+
+			proc.on('close', (exitCode) => {
+				if (didAbort) {
+					settle(
+						createToolError(`Command aborted by user: ${cmd}`, 'abort', {
+							cmd,
+							stdout,
+							stderr,
+						}),
+					);
+					return;
+				}
+
+				if (didTimeout) {
+					settle(
+						createToolError(
+							`Command timed out after ${timeout}ms: ${cmd}`,
+							'timeout',
+							{
+								parameter: 'timeout',
+								value: timeout,
+								stdout,
+								stderr,
+								suggestion: 'Increase timeout or optimize the command',
+							},
+						),
+					);
+					return;
+				}
+
+				if (exitCode !== 0 && !allowNonZeroExit) {
+					const errorDetail = stderr.trim() || stdout.trim() || '';
+					const errorMsg = `Command failed with exit code ${exitCode}${errorDetail ? `\n\n${errorDetail}` : ''}`;
+					settle(
+						createToolError(errorMsg, 'execution', {
+							exitCode,
+							stdout,
+							stderr,
+							cmd,
+							suggestion: 'Check command syntax or use allowNonZeroExit: true',
+						}),
+					);
+					return;
+				}
+
+				settle({
+					ok: true,
+					exitCode: exitCode ?? 0,
+					stdout,
+					stderr,
+				});
+			});
+
+			proc.on('error', (err) => {
+				settle(
+					createToolError(
+						`Command execution failed: ${err.message}`,
+						'execution',
+						{
+							cmd,
+							originalError: err.message,
+						},
+					),
+				);
+			});
+
+			const stream = async function* (): AsyncGenerator<ShellStreamChunk> {
+				while (!done || queue.length > 0) {
+					if (queue.length === 0) {
+						await new Promise<void>((resolve) => {
+							notify = resolve;
+						});
+					}
+					while (queue.length > 0) {
+						const chunk = queue.shift();
+						if (chunk) yield chunk;
+					}
+				}
+			};
+
+			return stream();
+		},
+	}) as unknown as Tool;
+	return { name: 'shell', tool: shell };
+}
+
+export const buildBashTool = buildShellTool;

package/src/core/src/tools/builtin/shell.txt

@@ -0,0 +1,13 @@
+- Execute a non-interactive shell command using `bash -lc`
+- Returns `stdout`, `stderr`, and `exitCode`
+- `cwd` is relative to the project root and sandboxed within it
+
+**Use `shell` for one-off, non-interactive commands.** These may be short-lived checks or long-running commands that finish on their own and do not require stdin. For commands that need interactive input, a TTY, or persistence across turns, use the `terminal` tool instead.
+
+## Usage tips
+
+- Chain commands with `&&` to fail-fast.
+- For long outputs, redirect to a file and `read` it back.
+- For long-running non-interactive commands, set an appropriate `timeout` and ensure the command exits on its own.
+- Batch independent checks (e.g. `git status && git diff`) in parallel tool calls rather than sequential shell chains when you need results separately.
+- Never use `shell` with `sed`/`awk` for programmatic file editing — use the dedicated file-editing tools instead.

package/src/core/src/tools/builtin/terminal.txt

@@ -1,4 +1,4 @@
-- Manage persistent terminals for long-running processes (dev servers, watchers, build processes)
+- Manage interactive and persistent terminals (REPLs, prompts, dev servers, watchers)
 - Returns terminal information and output
 - Supports creating, reading, writing, listing, and killing terminals
 
@@ -7,7 +7,7 @@
 ### start
 - Spawns a new persistent terminal (interactive shell by default)
 - Returns terminal ID for future operations
-- Use for processes that need to stay alive (dev servers, watchers, logs)
+- Use for commands that need stdin, a TTY, interactive input, or persistence across turns
 - Before starting, call `terminal(operation: "list")` to see if a matching service is already running
 - Provide a clear `purpose` or `title` (e.g. "web dev server port 9100") so humans can recognize it
 - Parameters:
@@ -51,22 +51,25 @@
 - Parameters:
   - terminalId (required): Terminal ID to kill
 
-## When to Use Terminal vs Bash
+## When to Use Terminal vs Shell
 
 ### Use terminal for:
+- Interactive commands that need stdin or a TTY: REPLs, prompts, shells, debuggers
 - Dev servers: npm run dev, bun dev
 - File watchers: bun test --watch, nodemon
 - Build watchers: bun build --watch
 - Log tailing: tail -f logs/app.log
 - Background services: docker compose up
 - Any process that needs to stay alive and produce continuous output
+- Any process you need to read from or write to across turns
 
-### Use bash for:
+### Use shell for:
 - Status checks: git status, ls, ps
 - One-off commands: mkdir, rm, curl
 - Quick scripts: bun run build, git commit
 - File operations: cat, sed, awk
-- Short-lived commands with immediate output
+- Non-interactive long-running commands that finish on their own (set an appropriate timeout)
+- Any command that does not need stdin, a TTY, or follow-up interaction
 
 ## Example Workflow
 
@@ -83,7 +86,7 @@
 
 ## Notes
 
-- Terminals persist across multiple LLM turns (unlike bash commands)
+- Terminals persist across multiple LLM turns (unlike shell commands)
 - Maximum 10 terminals per session
 - Exited terminals auto-cleanup after 5 minutes
 - Output is buffered (last 500 lines kept)

package/src/core/src/tools/loader.ts

@@ -4,7 +4,7 @@ import { finishTool } from './builtin/finish.ts';
 import { buildFsTools } from './builtin/fs/index.ts';
 import { buildGitTools } from './builtin/git.ts';
 import { progressUpdateTool } from './builtin/progress.ts';
-import { buildBashTool } from './builtin/bash.ts';
+import { buildShellTool } from './builtin/shell.ts';
 import { buildRipgrepTool } from './builtin/ripgrep.ts';
 import { buildGlobTool } from './builtin/glob.ts';
 import { buildApplyPatchTool } from './builtin/patch.ts';
@@ -12,7 +12,11 @@ import { updateTodosTool } from './builtin/todos.ts';
 import { buildWebSearchTool } from './builtin/websearch.ts';
 import { buildTerminalTool } from './builtin/terminal.ts';
 import type { TerminalManager } from '../terminals/index.ts';
-import { initializeSkills, buildSkillTool } from '../../../skills/index.ts';
+import {
+	initializeSkills,
+	buildSkillTool,
+	setSkillSettings,
+} from '../../../skills/index.ts';
 import { getMCPManager } from '../mcp/index.ts';
 import {
 	getMCPToolBriefs,
@@ -104,6 +108,7 @@ type FsHelpers = {
 const pluginPatterns = ['tools/*/tool.js', 'tools/*/tool.mjs'];
 
 let globalTerminalManager: TerminalManager | null = null;
+const staticToolDiscoveryCache = new Map<string, Promise<DiscoveredTool[]>>();
 
 export function setTerminalManager(manager: TerminalManager): void {
 	globalTerminalManager = manager;
@@ -113,42 +118,141 @@ export function getTerminalManager(): TerminalManager | null {
 	return globalTerminalManager;
 }
 
+function getStaticToolDiscoveryCacheKey(
+	projectRoot: string,
+	globalConfigDir?: string,
+): string {
+	return `${projectRoot}::${globalConfigDir ?? ''}`;
+}
+
+async function discoverStaticProjectTools(
+	projectRoot: string,
+	globalConfigDir?: string,
+	skillSettings?: {
+		enabled?: boolean;
+		items?: Record<string, { enabled?: boolean }>;
+	},
+): Promise<DiscoveredTool[]> {
+	setSkillSettings(skillSettings);
+	const cacheKey = getStaticToolDiscoveryCacheKey(projectRoot, globalConfigDir);
+	const cached = staticToolDiscoveryCache.get(cacheKey);
+	if (cached) return cached;
+
+	const discoveryPromise = (async () => {
+		const tools = new Map<string, Tool>();
+		for (const { name, tool } of buildFsTools(projectRoot))
+			tools.set(name, tool);
+		for (const { name, tool } of buildGitTools(projectRoot))
+			tools.set(name, tool);
+		// Built-ins
+		tools.set('finish', finishTool);
+		tools.set('progress_update', progressUpdateTool);
+		const shell = buildShellTool(projectRoot);
+		tools.set(shell.name, shell.tool);
+		// Search
+		const rg = buildRipgrepTool(projectRoot);
+		tools.set(rg.name, rg.tool);
+		const glob = buildGlobTool(projectRoot);
+		tools.set(glob.name, glob.tool);
+		// Patch/apply
+		const ap = buildApplyPatchTool(projectRoot);
+		tools.set(ap.name, ap.tool);
+		// Todo tracking
+		tools.set('update_todos', updateTodosTool);
+		// Web search
+		const ws = buildWebSearchTool();
+		tools.set(ws.name, ws.tool);
+		// Skills
+		await initializeSkills(projectRoot);
+		const skillTool = buildSkillTool();
+		tools.set(skillTool.name, skillTool.tool);
+
+		async function loadFromBase(base: string | null | undefined) {
+			if (!base) return;
+			try {
+				await fs.readdir(base);
+			} catch {
+				return;
+			}
+			for (const pattern of pluginPatterns) {
+				const files = await fg(pattern, { cwd: base, absolute: false });
+				for (const rel of files) {
+					const match = rel.match(/^tools\/([^/]+)\/tool\.(m?js)$/);
+					if (!match || !match[1]) continue;
+					const folder = match[1];
+					const absPath = join(base, rel).replace(/\\/g, '/');
+					try {
+						const plugin = await loadPlugin(absPath, folder, projectRoot);
+						if (plugin) tools.set(plugin.name, plugin.tool);
+					} catch {}
+				}
+			}
+			// Fallback: manual directory scan
+			try {
+				const toolsDir = join(base, 'tools');
+				const entries = await fs.readdir(toolsDir).catch(() => [] as string[]);
+				for (const folder of entries) {
+					const js = join(toolsDir, folder, 'tool.js');
+					const mjs = join(toolsDir, folder, 'tool.mjs');
+					const candidate = await fs
+						.stat(js)
+						.then(() => js)
+						.catch(
+							async () =>
+								await fs
+									.stat(mjs)
+									.then(() => mjs)
+									.catch(() => null),
+						);
+					if (!candidate) continue;
+					try {
+						const plugin = await loadPlugin(
+							candidate.replace(/\\/g, '/'),
+							folder,
+							projectRoot,
+						);
+						if (plugin) tools.set(plugin.name, plugin.tool);
+					} catch {}
+				}
+			} catch {}
+		}
+
+		await loadFromBase(globalConfigDir);
+		await loadFromBase(join(projectRoot, '.otto'));
+		return Array.from(tools.entries()).map(([name, tool]) => ({ name, tool }));
+	})();
+
+	staticToolDiscoveryCache.set(cacheKey, discoveryPromise);
+	try {
+		return await discoveryPromise;
+	} catch (error) {
+		staticToolDiscoveryCache.delete(cacheKey);
+		throw error;
+	}
+}
+
 export async function discoverProjectTools(
 	projectRoot: string,
 	globalConfigDir?: string,
+	skillSettings?: {
+		enabled?: boolean;
+		items?: Record<string, { enabled?: boolean }>;
+	},
 ): Promise<DiscoverResult> {
-	const tools = new Map<string, Tool>();
-	for (const { name, tool } of buildFsTools(projectRoot)) tools.set(name, tool);
-	for (const { name, tool } of buildGitTools(projectRoot))
-		tools.set(name, tool);
-	// Built-ins
-	tools.set('finish', finishTool);
-	tools.set('progress_update', progressUpdateTool);
-	const bash = buildBashTool(projectRoot);
-	tools.set(bash.name, bash.tool);
-	// Search
-	const rg = buildRipgrepTool(projectRoot);
-	tools.set(rg.name, rg.tool);
-	const glob = buildGlobTool(projectRoot);
-	tools.set(glob.name, glob.tool);
-	// Patch/apply
-	const ap = buildApplyPatchTool(projectRoot);
-	tools.set(ap.name, ap.tool);
-	// Todo tracking
-	tools.set('update_todos', updateTodosTool);
-	// Web search
-	const ws = buildWebSearchTool();
-	tools.set(ws.name, ws.tool);
-	// Terminal (if manager is available)
+	setSkillSettings(skillSettings);
+	const staticTools = await discoverStaticProjectTools(
+		projectRoot,
+		globalConfigDir,
+		skillSettings,
+	);
+	const tools = new Map<string, Tool>(
+		staticTools.map(({ name, tool }) => [name, tool]),
+	);
+
 	if (globalTerminalManager) {
 		const term = buildTerminalTool(projectRoot, globalTerminalManager);
 		tools.set(term.name, term.tool);
 	}
-	// Skills
-	// Always reinitialize to ensure skills are discovered for the current project
-	await initializeSkills(projectRoot);
-	const skillTool = buildSkillTool();
-	tools.set(skillTool.name, skillTool.tool);
 
 	const mcpManager = getMCPManager();
 	let mcpToolsRecord: Record<string, Tool> = {};
@@ -162,58 +266,6 @@ export async function discoverProjectTools(
 		}
 	}
 
-	async function loadFromBase(base: string | null | undefined) {
-		if (!base) return;
-		try {
-			await fs.readdir(base);
-		} catch {
-			return;
-		}
-		for (const pattern of pluginPatterns) {
-			const files = await fg(pattern, { cwd: base, absolute: false });
-			for (const rel of files) {
-				const match = rel.match(/^tools\/([^/]+)\/tool\.(m?js)$/);
-				if (!match || !match[1]) continue;
-				const folder = match[1];
-				const absPath = join(base, rel).replace(/\\/g, '/');
-				try {
-					const plugin = await loadPlugin(absPath, folder, projectRoot);
-					if (plugin) tools.set(plugin.name, plugin.tool);
-				} catch {}
-			}
-		}
-		// Fallback: manual directory scan
-		try {
-			const toolsDir = join(base, 'tools');
-			const entries = await fs.readdir(toolsDir).catch(() => [] as string[]);
-			for (const folder of entries) {
-				const js = join(toolsDir, folder, 'tool.js');
-				const mjs = join(toolsDir, folder, 'tool.mjs');
-				const candidate = await fs
-					.stat(js)
-					.then(() => js)
-					.catch(
-						async () =>
-							await fs
-								.stat(mjs)
-								.then(() => mjs)
-								.catch(() => null),
-					);
-				if (!candidate) continue;
-				try {
-					const plugin = await loadPlugin(
-						candidate.replace(/\\/g, '/'),
-						folder,
-						projectRoot,
-					);
-					if (plugin) tools.set(plugin.name, plugin.tool);
-				} catch {}
-			}
-		} catch {}
-	}
-
-	await loadFromBase(globalConfigDir);
-	await loadFromBase(join(projectRoot, '.otto'));
 	return {
 		tools: Array.from(tools.entries()).map(([name, tool]) => ({ name, tool })),
 		mcpToolsRecord,

package/src/index.ts

@@ -14,7 +14,10 @@
 // =======================
 // Provider types
 export type {
+	BuiltInProviderId,
 	ProviderId,
+	ProviderCompatibility,
+	ProviderPromptFamily,
 	ModelOwner,
 	ModelInfo,
 	ModelProviderBinding,
@@ -28,6 +31,7 @@ export type { ApiAuth, OAuth, AuthInfo, AuthFile } from './types/src/index.ts';
 export type {
 	DefaultConfig,
 	PathConfig,
+	ProviderSettingsEntry,
 	OttoConfig,
 	ReasoningLevel,
 } from './types/src/index.ts';
@@ -51,6 +55,29 @@ export {
 	modelSupportsReasoning,
 } from './providers/src/index.ts';
 export type { UnderlyingProviderKey } from './providers/src/index.ts';
+export {
+	discoverOllamaModels,
+	normalizeOllamaBaseURL,
+} from './providers/src/index.ts';
+export type {
+	DiscoverOllamaOptions,
+	DiscoverOllamaResult,
+} from './providers/src/index.ts';
+export {
+	isBuiltInProviderId,
+	getProviderSettings,
+	getProviderDefinition,
+	hasConfiguredProvider,
+	getConfiguredProviderIds,
+	getConfiguredProviderModels,
+	getConfiguredProviderDefaultModel,
+	providerAllowsAnyModel,
+	hasConfiguredModel,
+	getConfiguredProviderFamily,
+	getConfiguredProviderEnvVar,
+	getConfiguredProviderApiKey,
+} from './providers/src/index.ts';
+export type { ResolvedProviderDefinition } from './providers/src/index.ts';
 export {
 	isProviderAuthorized,
 	ensureProviderEnv,
@@ -193,6 +220,9 @@ export {
 	isAuthorized,
 	ensureEnv,
 	writeDefaults as setConfig,
+	writeProviderSettings,
+	removeProviderSettings,
+	writeSkillSettings,
 	readDebugConfig,
 	writeDebugConfig,
 	writeAuth,
@@ -339,8 +369,11 @@ export {
 export {
 	initializeSkills,
 	getDiscoveredSkills,
+	setSkillSettings,
+	filterDiscoveredSkills,
 	isSkillsInitialized,
 	buildSkillTool,
+	summarizeDescription,
 	rebuildSkillDescription,
 } from './skills/index.ts';
 

package/src/prompts/src/agents/build.txt

@@ -8,10 +8,9 @@ You help with coding and build tasks.
 
 Pick the right tool for the job (each tool's description has its full contract):
 
-- `edit` — one exact replacement in an existing file.
-- `multiedit` — several exact replacements in the same file.
-- `apply_patch` — structural diffs, file add/delete/rename, or multi-file changes awkward as exact replacements.
-- `write` — NEW files only, or >70% full-file rewrites. Never for targeted edits.
+- Use the exact-replacement editing tools available to you for targeted changes in existing files.
+- Use patch-style editing for structural diffs, file add/delete/rename, or multi-file changes when that capability is available.
+- Use `write` only for NEW files or >70% full-file rewrites. Never use it for targeted edits.
 
 **Always read a file immediately before editing it.** Memory and earlier context are not reliable — the file may have changed.
 
@@ -19,13 +18,13 @@ Pick the right tool for the job (each tool's description has its full contract):
 
 After making changes:
 
-1. Run project-specific build/lint/test commands with `bash` (check `package.json`, `README.md`, or `AGENTS.md` for the right command).
+1. Run project-specific build/lint/test commands with `shell` (check `package.json`, `README.md`, or `AGENTS.md` for the right command).
 2. Review diffs with `git_status` / `git_diff`.
 3. Do NOT commit unless the user explicitly asks. It is very important to only commit when asked.
 
 ## Terminal tool — when to use
 
-- Prefer `terminal` over `bash` for long-lived processes (dev servers, watchers, log tailing). `bash` is for one-off commands with immediate output.
+- Prefer `terminal` over `shell` for interactive or persistent processes (dev servers, watchers, log tailing). `shell` is for one-off non-interactive commands.
 - List existing terminals before starting a new one; reuse when possible to avoid duplicate services.
 - Give each terminal a clear `purpose` / `title` (e.g. "web dev server 9100").
 - Mention active terminals (purpose, command, port) in your responses so humans know what's running.