@ottocode/sdk 0.1.200 → 0.1.202

package/src/core/src/mcp/types.ts

@@ -0,0 +1,42 @@
+export type MCPTransport = 'stdio' | 'http' | 'sse';
+export type MCPScope = 'global' | 'project';
+
+export interface MCPOAuthConfig {
+	clientId?: string;
+	callbackPort?: number;
+	scopes?: string[];
+}
+
+export interface MCPServerConfig {
+	name: string;
+	transport?: MCPTransport;
+
+	command?: string;
+	args?: string[];
+	env?: Record<string, string>;
+	cwd?: string;
+
+	url?: string;
+	headers?: Record<string, string>;
+
+	oauth?: MCPOAuthConfig;
+
+	disabled?: boolean;
+
+	scope?: MCPScope;
+}
+
+export interface MCPConfig {
+	servers: MCPServerConfig[];
+}
+
+export interface MCPServerStatus {
+	name: string;
+	connected: boolean;
+	tools: string[];
+	error?: string;
+	transport?: MCPTransport;
+	url?: string;
+	authRequired?: boolean;
+	authenticated?: boolean;
+}

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

@@ -24,14 +24,14 @@ export function buildRipgrepTool(projectRoot: string): {
 				.array(z.string())
 				.optional()
 				.describe('One or more glob patterns to include'),
-			maxResults: z.number().int().min(1).max(5000).optional().default(500),
+			maxResults: z.number().int().min(1).max(5000).optional().default(100),
 		}),
 		async execute({
 			query,
 			path = '.',
 			ignoreCase,
 			glob,
-			maxResults = 500,
+			maxResults = 100,
 		}: {
 			query: string;
 			path?: string;
@@ -95,12 +95,20 @@ export function buildRipgrepTool(projectRoot: string): {
 							.split('\n')
 							.filter(Boolean)
 							.slice(0, maxResults);
+						const TEXT_MAX = 200;
 						const matches = lines.map((l) => {
 							const m = l.match(/^(.+?):(\d+):(.*)$/s);
-							if (!m) return { file: '', line: 0, text: l };
+							if (!m)
+								return {
+									file: '',
+									line: 0,
+									text: l.length > TEXT_MAX ? l.slice(0, TEXT_MAX) + '…' : l,
+								};
 							const file = m[1];
 							const line = Number.parseInt(m[2], 10);
-							const text = m[3];
+							const raw = m[3];
+							const text =
+								raw.length > TEXT_MAX ? raw.slice(0, TEXT_MAX) + '…' : raw;
 							return { file, line, text };
 						});
 						resolve({ ok: true, count: matches.length, matches });

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

@@ -6,7 +6,6 @@ import { buildGitTools } from './builtin/git.ts';
 import { progressUpdateTool } from './builtin/progress.ts';
 import { buildBashTool } from './builtin/bash.ts';
 import { buildRipgrepTool } from './builtin/ripgrep.ts';
-import { buildGrepTool } from './builtin/grep.ts';
 import { buildGlobTool } from './builtin/glob.ts';
 import { buildApplyPatchTool } from './builtin/patch.ts';
 import { buildEditTool } from './builtin/edit.ts';
@@ -16,6 +15,8 @@ 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 { getMCPManager } from '../mcp/index.ts';
+import { convertMCPToolsToAISDK } from '../mcp/tools.ts';
 import fg from 'fast-glob';
 import { dirname, isAbsolute, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -120,8 +121,6 @@ export async function discoverProjectTools(
 	// Search
 	const rg = buildRipgrepTool(projectRoot);
 	tools.set(rg.name, rg.tool);
-	const grep = buildGrepTool(projectRoot);
-	tools.set(grep.name, grep.tool);
 	const glob = buildGlobTool(projectRoot);
 	tools.set(glob.name, glob.tool);
 	// Patch/apply
@@ -148,6 +147,14 @@ export async function discoverProjectTools(
 	const skillTool = buildSkillTool();
 	tools.set(skillTool.name, skillTool.tool);
 
+	const mcpManager = getMCPManager();
+	if (mcpManager?.started) {
+		const mcpTools = convertMCPToolsToAISDK(mcpManager);
+		for (const { name, tool } of mcpTools) {
+			tools.set(name, tool);
+		}
+	}
+
 	async function loadFromBase(base: string | null | undefined) {
 		if (!base) return;
 		try {

package/src/index.ts

@@ -171,6 +171,8 @@ export {
 	getGlobalToolsDir,
 	getGlobalCommandsDir,
 	getSecureAuthPath,
+	getSecureBaseDir,
+	getSecureOAuthDir,
 	getHomeDir,
 } from './config/src/paths.ts';
 export {
@@ -333,3 +335,33 @@ export {
 } from './tunnel/index.ts';
 
 export type { TunnelConnection, TunnelEvents } from './tunnel/index.ts';
+
+// =======================
+// MCP (Model Context Protocol)
+// =======================
+export {
+	MCPClientWrapper,
+	MCPServerManager,
+	convertMCPToolsToAISDK,
+	getMCPManager,
+	initializeMCP,
+	shutdownMCP,
+	loadMCPConfig,
+	addMCPServerToConfig,
+	removeMCPServerFromConfig,
+	OAuthCredentialStore,
+	OttoOAuthProvider,
+	OAuthCallbackServer,
+} from './core/src/index.ts';
+export type {
+	MCPServerConfig,
+	MCPConfig,
+	MCPServerStatus,
+	MCPToolInfo,
+	MCPTransport,
+	MCPOAuthConfig,
+	MCPScope,
+	StoredOAuthData,
+	OttoOAuthProviderOptions,
+	CallbackResult,
+} from './core/src/index.ts';

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

@@ -1,134 +0,0 @@
-import { tool, type Tool } from 'ai';
-import { z } from 'zod/v3';
-import { spawn } from 'node:child_process';
-import { join } from 'node:path';
-import DESCRIPTION from './grep.txt' with { type: 'text' };
-import { defaultIgnoreGlobs } from './ignore.ts';
-import { createToolError, type ToolResponse } from '../error.ts';
-import { resolveBinary } from '../bin-manager.ts';
-
-function expandTilde(p: string) {
-	const home = process.env.HOME || process.env.USERPROFILE || '';
-	if (!home) return p;
-	if (p === '~') return home;
-	if (p.startsWith('~/')) return `${home}/${p.slice(2)}`;
-	return p;
-}
-
-export function buildGrepTool(projectRoot: string): {
-	name: string;
-	tool: Tool;
-} {
-	const grep = tool({
-		description: DESCRIPTION,
-		inputSchema: z.object({
-			pattern: z
-				.string()
-				.describe('Regex pattern to search for in file contents'),
-			path: z
-				.string()
-				.optional()
-				.describe('Directory to search in (default: project root).'),
-			include: z
-				.string()
-				.optional()
-				.describe('File glob to include (e.g., "*.js", "*.{ts,tsx}")'),
-			ignore: z
-				.array(z.string())
-				.optional()
-				.describe('Glob patterns to exclude from search'),
-		}),
-		async execute(params: {
-			pattern: string;
-			path?: string;
-			include?: string;
-			ignore?: string[];
-		}): Promise<
-			ToolResponse<{
-				count: number;
-				matches: Array<{ file: string; line: number; text: string }>;
-			}>
-		> {
-			const pattern = String(params.pattern || '');
-			if (!pattern) {
-				return createToolError('pattern is required', 'validation', {
-					parameter: 'pattern',
-					suggestion: 'Provide a regex pattern to search for',
-				});
-			}
-
-			const p = expandTilde(String(params.path || '')).trim();
-			const isAbs = p.startsWith('/') || /^[A-Za-z]:[\\/]/.test(p);
-			const searchPath = p ? (isAbs ? p : join(projectRoot, p)) : projectRoot;
-
-			const rgBin = await resolveBinary('rg');
-			const args: string[] = ['-n', '--color', 'never'];
-			for (const g of defaultIgnoreGlobs(params.ignore)) {
-				args.push('--glob', g);
-			}
-			if (params.include) {
-				args.push('--glob', params.include);
-			}
-			args.push(pattern, searchPath);
-
-			let output = '';
-			try {
-				output = await new Promise<string>((resolve, reject) => {
-					const proc = spawn(rgBin, args, { cwd: projectRoot });
-					let stdout = '';
-					let stderr = '';
-					proc.stdout.on('data', (d) => {
-						stdout += d.toString();
-					});
-					proc.stderr.on('data', (d) => {
-						stderr += d.toString();
-					});
-					proc.on('close', (code) => {
-						if (code === 1) resolve('');
-						else if (code !== 0)
-							reject(new Error(stderr.trim() || 'ripgrep failed'));
-						else resolve(stdout);
-					});
-					proc.on('error', reject);
-				});
-			} catch (error: unknown) {
-				const err2 = error as { message?: string };
-				return createToolError(`ripgrep failed: ${err2.message}`, 'execution', {
-					parameter: 'pattern',
-					value: pattern,
-					suggestion:
-						'Check if ripgrep (rg) is installed and the pattern is valid',
-				});
-			}
-
-			const lines = output.trim().split('\n');
-			const matches: Array<{
-				file: string;
-				line: number;
-				text: string;
-			}> = [];
-
-			for (const line of lines) {
-				if (!line) continue;
-				const m = line.match(/^(.+?):(\d+):(.*)$/s);
-				if (!m) continue;
-				const filePath = m[1];
-				const lineNum = parseInt(m[2], 10);
-				const lineText = m[3];
-				if (!filePath || !Number.isFinite(lineNum)) continue;
-				matches.push({ file: filePath, line: lineNum, text: lineText });
-			}
-
-			const limit = 500;
-			const truncated = matches.length > limit;
-			const finalMatches = truncated ? matches.slice(0, limit) : matches;
-
-			return {
-				ok: true,
-				count: finalMatches.length,
-				matches: finalMatches,
-			};
-		},
-	});
-	return { name: 'grep', tool: grep };
-}

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

@@ -1,9 +0,0 @@
-- Fast content search tool powered by ripgrep (rg)
-- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
-- Optional include glob to filter files (e.g., "*.js", "*.{ts,tsx}")
-- Returns files with at least one match and line previews, sorted by modification time
-- Skips common build and cache folders by default; add 'ignore' patterns to refine
-
-Usage tips:
-- For counting matches, use the Bash tool with rg directly (do not use grep)
-- Batch multiple searches when exploring a codebase broadly