@ottocode/sdk 0.1.173

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

@@ -0,0 +1,151 @@
+import { tool, type Tool } from 'ai';
+import { z } from 'zod/v3';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import GIT_STATUS_DESCRIPTION from './git.status.txt' with { type: 'text' };
+import GIT_DIFF_DESCRIPTION from './git.diff.txt' with { type: 'text' };
+import GIT_COMMIT_DESCRIPTION from './git.commit.txt' with { type: 'text' };
+import { createToolError, type ToolResponse } from '../error.ts';
+
+const execAsync = promisify(exec);
+
+export function buildGitTools(
+	projectRoot: string,
+): Array<{ name: string; tool: Tool }> {
+	// Helper to find git root directory
+	async function findGitRoot(): Promise<string> {
+		try {
+			const { stdout } = await execAsync(
+				`git -C "${projectRoot}" rev-parse --show-toplevel`,
+			);
+			return stdout.trim() || projectRoot;
+		} catch {
+			return projectRoot;
+		}
+	}
+
+	async function inRepo(): Promise<boolean> {
+		try {
+			const { stdout } = await execAsync(
+				`git -C "${projectRoot}" rev-parse --is-inside-work-tree`,
+			);
+			return stdout.trim() === 'true';
+		} catch {
+			return false;
+		}
+	}
+
+	const git_status = tool({
+		description: GIT_STATUS_DESCRIPTION,
+		inputSchema: z.object({}),
+		async execute(): Promise<
+			ToolResponse<{ staged: number; unstaged: number; raw: string[] }>
+		> {
+			if (!(await inRepo())) {
+				return createToolError('Not a git repository', 'not_found', {
+					suggestion: 'Initialize a git repository with git init',
+				});
+			}
+			const gitRoot = await findGitRoot();
+			const { stdout } = await execAsync(
+				`git -C "${gitRoot}" status --porcelain=v1`,
+			);
+			const lines = stdout.split('\n').filter(Boolean);
+			let staged = 0;
+			let unstaged = 0;
+			for (const line of lines) {
+				const x = line[0];
+				const y = line[1];
+				if (!x || !y) continue;
+				if (x === '!' && y === '!') continue; // ignored files
+				const isUntracked = x === '?' && y === '?';
+				if (x !== ' ' && !isUntracked) staged += 1;
+				if (isUntracked || y !== ' ') unstaged += 1;
+			}
+			return {
+				ok: true,
+				staged,
+				unstaged,
+				raw: lines.slice(0, 200),
+			};
+		},
+	});
+
+	const git_diff = tool({
+		description: GIT_DIFF_DESCRIPTION,
+		inputSchema: z.object({ all: z.boolean().optional().default(false) }),
+		async execute({
+			all,
+		}: {
+			all?: boolean;
+		}): Promise<ToolResponse<{ all: boolean; patch: string }>> {
+			if (!(await inRepo())) {
+				return createToolError('Not a git repository', 'not_found', {
+					suggestion: 'Initialize a git repository with git init',
+				});
+			}
+			const gitRoot = await findGitRoot();
+			// When all=true, show full working tree diff relative to HEAD
+			// so both staged and unstaged changes are included. Otherwise,
+			// show only the staged diff (index vs HEAD).
+			const cmd = all
+				? `git -C "${gitRoot}" diff HEAD`
+				: `git -C "${gitRoot}" diff --staged`;
+			const { stdout } = await execAsync(cmd, { maxBuffer: 10 * 1024 * 1024 });
+			const limited = stdout.split('\n').slice(0, 5000).join('\n');
+			return { ok: true, all: !!all, patch: limited };
+		},
+	});
+
+	const git_commit = tool({
+		description: GIT_COMMIT_DESCRIPTION,
+		inputSchema: z.object({
+			message: z.string().min(5),
+			amend: z.boolean().optional().default(false),
+			signoff: z.boolean().optional().default(false),
+		}),
+		async execute({
+			message,
+			amend,
+			signoff,
+		}: {
+			message: string;
+			amend?: boolean;
+			signoff?: boolean;
+		}): Promise<ToolResponse<{ result: string }>> {
+			if (!(await inRepo())) {
+				return createToolError('Not a git repository', 'not_found', {
+					suggestion: 'Initialize a git repository with git init',
+				});
+			}
+			const gitRoot = await findGitRoot();
+			const args = [
+				'git',
+				'-C',
+				`"${gitRoot}"`,
+				'commit',
+				'-m',
+				`"${message.replace(/"/g, '\\"')}"`,
+			];
+			if (amend) args.push('--amend');
+			if (signoff) args.push('--signoff');
+			try {
+				const { stdout } = await execAsync(args.join(' '));
+				return { ok: true, result: stdout.trim() };
+			} catch (error: unknown) {
+				const err = error as { stderr?: string; message?: string };
+				const txt = err.stderr || err.message || 'git commit failed';
+				return createToolError(txt, 'execution', {
+					suggestion:
+						'Check if there are staged changes and the commit message is valid',
+				});
+			}
+		},
+	});
+
+	return [
+		{ name: 'git_status', tool: git_status },
+		{ name: 'git_diff', tool: git_diff },
+		{ name: 'git_commit', tool: git_commit },
+	];
+}

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

@@ -0,0 +1,128 @@
+import { tool, type Tool } from 'ai';
+import { z } from 'zod/v3';
+import fg from 'fast-glob';
+import { join } from 'node:path';
+import { stat } from 'node:fs/promises';
+import DESCRIPTION from './glob.txt' with { type: 'text' };
+import { defaultIgnoreGlobs } from './ignore.ts';
+import { createToolError, type ToolResponse } from '../error.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 buildGlobTool(projectRoot: string): {
+	name: string;
+	tool: Tool;
+} {
+	const globTool = tool({
+		description: DESCRIPTION,
+		inputSchema: z.object({
+			pattern: z
+				.string()
+				.min(1)
+				.describe(
+					'Glob pattern to match files (e.g., "*.ts", "**/*.tsx", "src/**/*.{js,ts}")',
+				),
+			path: z
+				.string()
+				.optional()
+				.describe('Directory to search in (default: project root)'),
+			ignore: z
+				.array(z.string())
+				.optional()
+				.describe('Additional glob patterns to exclude'),
+			limit: z
+				.number()
+				.int()
+				.min(1)
+				.max(1000)
+				.optional()
+				.default(100)
+				.describe('Maximum number of files to return'),
+		}),
+		async execute({
+			pattern,
+			path = '.',
+			ignore,
+			limit = 100,
+		}: {
+			pattern: string;
+			path?: string;
+			ignore?: string[];
+			limit?: number;
+		}): Promise<
+			ToolResponse<{
+				count: number;
+				total: number;
+				files: string[];
+				truncated: boolean;
+			}>
+		> {
+			const p = expandTilde(String(path || '.')).trim();
+			const isAbs = p.startsWith('/') || /^[A-Za-z]:[\\/]/.test(p);
+			const searchPath = p ? (isAbs ? p : join(projectRoot, p)) : projectRoot;
+
+			// Build ignore patterns
+			const ignorePatterns = defaultIgnoreGlobs(ignore);
+
+			try {
+				// Use fast-glob to find matching files
+				const files = await fg(pattern, {
+					cwd: searchPath,
+					ignore: ignorePatterns,
+					onlyFiles: true,
+					absolute: false,
+					dot: false,
+				});
+
+				// Get file stats for sorting by modification time
+				const filesWithStats = await Promise.all(
+					files.map(async (file) => {
+						const fullPath = join(searchPath, file);
+						try {
+							const stats = await stat(fullPath);
+							return {
+								file,
+								mtime: stats.mtime.getTime(),
+							};
+						} catch {
+							return {
+								file,
+								mtime: 0,
+							};
+						}
+					}),
+				);
+
+				// Sort by modification time (most recent first) and limit
+				filesWithStats.sort((a, b) => b.mtime - a.mtime);
+				const limitedFiles = filesWithStats.slice(0, limit).map((f) => f.file);
+
+				return {
+					ok: true,
+					count: limitedFiles.length,
+					total: files.length,
+					files: limitedFiles,
+					truncated: files.length > limit,
+				};
+			} catch (error: unknown) {
+				const err = error as { message?: string };
+				return createToolError(
+					`Glob search failed: ${err.message || String(error)}`,
+					'execution',
+					{
+						parameter: 'pattern',
+						value: pattern,
+						suggestion: 'Check if the pattern syntax is valid',
+					},
+				);
+			}
+		},
+	});
+	return { name: 'glob', tool: globTool };
+}

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

@@ -0,0 +1,10 @@
+- Find files matching glob patterns (e.g., "*.ts", "**/*.tsx", "src/**/*.{js,ts}")
+- Returns a list of matching file paths relative to the search directory
+- Supports standard glob syntax: * (any chars), ** (any dirs), {a,b} (alternatives), [abc] (character sets)
+- Automatically excludes common build/cache folders (node_modules, dist, .git, etc.)
+- Results sorted by modification time (most recent first)
+
+Usage tips:
+- Use this tool to find files by name or extension patterns
+- Use Grep or Ripgrep tools to search file contents
+- Combine with path parameter to search in specific directories only

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

@@ -0,0 +1,136 @@
+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 idx1 = line.indexOf(':');
+				const idx2 = idx1 === -1 ? -1 : line.indexOf(':', idx1 + 1);
+				if (idx1 === -1 || idx2 === -1) continue;
+				const filePath = line.slice(0, idx1);
+				const lineNumStr = line.slice(idx1 + 1, idx2);
+				const lineText = line.slice(idx2 + 1);
+				const lineNum = parseInt(lineNumStr, 10);
+				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

@@ -0,0 +1,9 @@
+- 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

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

@@ -0,0 +1,45 @@
+export const IGNORE_PATTERNS: string[] = [
+	'node_modules/',
+	'__pycache__/',
+	'.git/',
+	'dist/',
+	'build/',
+	'target/',
+	'vendor/',
+	'bin/',
+	'obj/',
+	'.idea/',
+	'.vscode/',
+	'.zig-cache/',
+	'zig-out',
+	'.coverage',
+	'coverage/',
+	'vendor/',
+	'tmp/',
+	'temp/',
+	'.cache/',
+	'cache/',
+	'logs/',
+	'.venv/',
+	'venv/',
+	'env/',
+];
+
+export function defaultIgnoreGlobs(extra?: string[]): string[] {
+	const base = IGNORE_PATTERNS.map((p) => `!${p}*`);
+	if (Array.isArray(extra) && extra.length) return base.concat(extra);
+	return base;
+}
+
+export function toIgnoredBasenames(extra?: string[]): Set<string> {
+	const names = new Set<string>();
+	for (const p of IGNORE_PATTERNS) {
+		const n = p.replace(/\/$/, '');
+		if (n) names.add(n);
+	}
+	for (const p of extra ?? []) {
+		const n = String(p).replace(/^!/, '').replace(/\/$/, '');
+		if (n) names.add(n);
+	}
+	return names;
+}