@ottocode/sdk 0.1.180 → 0.1.182

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.180",
+	"version": "0.1.182",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",

package/src/core/src/index.ts

@@ -50,6 +50,8 @@ export type {
 export { buildFsTools } from './tools/builtin/fs/index';
 export { buildGitTools } from './tools/builtin/git';
 export { buildTerminalTool } from './tools/builtin/terminal';
+export { buildEditTool } from './tools/builtin/edit';
+export { buildMultiEditTool } from './tools/builtin/multiedit';
 
 // =======================
 // Terminals

package/src/core/src/providers/resolver.ts

@@ -204,7 +204,7 @@ export async function resolveModel(
 		const entry = catalog[provider];
 		const apiKey =
 			config.apiKey ||
-			process.env.ZAI_API_KEY ||
+			process.env.ZAI_CODING_API_KEY ||
 			process.env.ZHIPU_API_KEY ||
 			'';
 		const baseURL =

package/src/core/src/tools/builtin/edit/replacers.ts

@@ -0,0 +1,461 @@
+export type Replacer = (
+	content: string,
+	find: string,
+) => Generator<string, void, unknown>;
+
+const SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0.0;
+const MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.3;
+
+function levenshtein(a: string, b: string): number {
+	if (a === '' || b === '') {
+		return Math.max(a.length, b.length);
+	}
+	const matrix = Array.from({ length: a.length + 1 }, (_, i) =>
+		Array.from({ length: b.length + 1 }, (_, j) =>
+			i === 0 ? j : j === 0 ? i : 0,
+		),
+	);
+
+	for (let i = 1; i <= a.length; i++) {
+		for (let j = 1; j <= b.length; j++) {
+			const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+			matrix[i][j] = Math.min(
+				matrix[i - 1][j] + 1,
+				matrix[i][j - 1] + 1,
+				matrix[i - 1][j - 1] + cost,
+			);
+		}
+	}
+	return matrix[a.length][b.length];
+}
+
+export const SimpleReplacer: Replacer = function* (_content, find) {
+	yield find;
+};
+
+export const LineTrimmedReplacer: Replacer = function* (content, find) {
+	const originalLines = content.split('\n');
+	const searchLines = find.split('\n');
+
+	if (searchLines[searchLines.length - 1] === '') {
+		searchLines.pop();
+	}
+
+	for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
+		let matches = true;
+
+		for (let j = 0; j < searchLines.length; j++) {
+			const originalTrimmed = originalLines[i + j].trim();
+			const searchTrimmed = searchLines[j].trim();
+
+			if (originalTrimmed !== searchTrimmed) {
+				matches = false;
+				break;
+			}
+		}
+
+		if (matches) {
+			let matchStartIndex = 0;
+			for (let k = 0; k < i; k++) {
+				matchStartIndex += originalLines[k].length + 1;
+			}
+
+			let matchEndIndex = matchStartIndex;
+			for (let k = 0; k < searchLines.length; k++) {
+				matchEndIndex += originalLines[i + k].length;
+				if (k < searchLines.length - 1) {
+					matchEndIndex += 1;
+				}
+			}
+
+			yield content.substring(matchStartIndex, matchEndIndex);
+		}
+	}
+};
+
+export const BlockAnchorReplacer: Replacer = function* (content, find) {
+	const originalLines = content.split('\n');
+	const searchLines = find.split('\n');
+
+	if (searchLines.length < 3) {
+		return;
+	}
+
+	if (searchLines[searchLines.length - 1] === '') {
+		searchLines.pop();
+	}
+
+	const firstLineSearch = searchLines[0].trim();
+	const lastLineSearch = searchLines[searchLines.length - 1].trim();
+
+	const candidates: Array<{ startLine: number; endLine: number }> = [];
+	for (let i = 0; i < originalLines.length; i++) {
+		if (originalLines[i].trim() !== firstLineSearch) {
+			continue;
+		}
+
+		for (let j = i + 2; j < originalLines.length; j++) {
+			if (originalLines[j].trim() === lastLineSearch) {
+				candidates.push({ startLine: i, endLine: j });
+				break;
+			}
+		}
+	}
+
+	if (candidates.length === 0) {
+		return;
+	}
+
+	if (candidates.length === 1) {
+		const { startLine, endLine } = candidates[0];
+		const actualBlockSize = endLine - startLine + 1;
+		const searchBlockSize = searchLines.length;
+
+		let similarity = 0;
+		const linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2);
+
+		if (linesToCheck > 0) {
+			for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+				const originalLine = originalLines[startLine + j].trim();
+				const searchLine = searchLines[j].trim();
+				const maxLen = Math.max(originalLine.length, searchLine.length);
+				if (maxLen === 0) {
+					continue;
+				}
+				const distance = levenshtein(originalLine, searchLine);
+				similarity += (1 - distance / maxLen) / linesToCheck;
+
+				if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+					break;
+				}
+			}
+		} else {
+			similarity = 1.0;
+		}
+
+		if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+			let matchStartIndex = 0;
+			for (let k = 0; k < startLine; k++) {
+				matchStartIndex += originalLines[k].length + 1;
+			}
+			let matchEndIndex = matchStartIndex;
+			for (let k = startLine; k <= endLine; k++) {
+				matchEndIndex += originalLines[k].length;
+				if (k < endLine) {
+					matchEndIndex += 1;
+				}
+			}
+			yield content.substring(matchStartIndex, matchEndIndex);
+		}
+		return;
+	}
+
+	let bestMatch: { startLine: number; endLine: number } | null = null;
+	let maxSimilarity = -1;
+
+	for (const candidate of candidates) {
+		const { startLine, endLine } = candidate;
+		const actualBlockSize = endLine - startLine + 1;
+		const searchBlockSize = searchLines.length;
+
+		let similarity = 0;
+		const linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2);
+
+		if (linesToCheck > 0) {
+			for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+				const originalLine = originalLines[startLine + j].trim();
+				const searchLine = searchLines[j].trim();
+				const maxLen = Math.max(originalLine.length, searchLine.length);
+				if (maxLen === 0) {
+					continue;
+				}
+				const distance = levenshtein(originalLine, searchLine);
+				similarity += 1 - distance / maxLen;
+			}
+			similarity /= linesToCheck;
+		} else {
+			similarity = 1.0;
+		}
+
+		if (similarity > maxSimilarity) {
+			maxSimilarity = similarity;
+			bestMatch = candidate;
+		}
+	}
+
+	if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD && bestMatch) {
+		const { startLine, endLine } = bestMatch;
+		let matchStartIndex = 0;
+		for (let k = 0; k < startLine; k++) {
+			matchStartIndex += originalLines[k].length + 1;
+		}
+		let matchEndIndex = matchStartIndex;
+		for (let k = startLine; k <= endLine; k++) {
+			matchEndIndex += originalLines[k].length;
+			if (k < endLine) {
+				matchEndIndex += 1;
+			}
+		}
+		yield content.substring(matchStartIndex, matchEndIndex);
+	}
+};
+
+export const WhitespaceNormalizedReplacer: Replacer = function* (
+	content,
+	find,
+) {
+	const normalizeWhitespace = (text: string) =>
+		text.replace(/\s+/g, ' ').trim();
+	const normalizedFind = normalizeWhitespace(find);
+
+	const lines = content.split('\n');
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (normalizeWhitespace(line) === normalizedFind) {
+			yield line;
+		} else {
+			const normalizedLine = normalizeWhitespace(line);
+			if (normalizedLine.includes(normalizedFind)) {
+				const words = find.trim().split(/\s+/);
+				if (words.length > 0) {
+					const pattern = words
+						.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+						.join('\\s+');
+					try {
+						const regex = new RegExp(pattern);
+						const match = line.match(regex);
+						if (match) {
+							yield match[0];
+						}
+					} catch {
+						// skip invalid regex
+					}
+				}
+			}
+		}
+	}
+
+	const findLines = find.split('\n');
+	if (findLines.length > 1) {
+		for (let i = 0; i <= lines.length - findLines.length; i++) {
+			const block = lines.slice(i, i + findLines.length);
+			if (normalizeWhitespace(block.join('\n')) === normalizedFind) {
+				yield block.join('\n');
+			}
+		}
+	}
+};
+
+export const IndentationFlexibleReplacer: Replacer = function* (content, find) {
+	const removeIndentation = (text: string) => {
+		const lines = text.split('\n');
+		const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+		if (nonEmptyLines.length === 0) return text;
+
+		const minIndent = Math.min(
+			...nonEmptyLines.map((line) => {
+				const match = line.match(/^(\s*)/);
+				return match ? match[1].length : 0;
+			}),
+		);
+
+		return lines
+			.map((line) => (line.trim().length === 0 ? line : line.slice(minIndent)))
+			.join('\n');
+	};
+
+	const normalizedFind = removeIndentation(find);
+	const contentLines = content.split('\n');
+	const findLines = find.split('\n');
+
+	for (let i = 0; i <= contentLines.length - findLines.length; i++) {
+		const block = contentLines.slice(i, i + findLines.length).join('\n');
+		if (removeIndentation(block) === normalizedFind) {
+			yield block;
+		}
+	}
+};
+
+export const EscapeNormalizedReplacer: Replacer = function* (content, find) {
+	const unescapeString = (str: string): string => {
+		return str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (match, capturedChar) => {
+			switch (capturedChar) {
+				case 'n':
+					return '\n';
+				case 't':
+					return '\t';
+				case 'r':
+					return '\r';
+				case "'":
+					return "'";
+				case '"':
+					return '"';
+				case '`':
+					return '`';
+				case '\\':
+					return '\\';
+				case '\n':
+					return '\n';
+				case '$':
+					return '$';
+				default:
+					return match;
+			}
+		});
+	};
+
+	const unescapedFind = unescapeString(find);
+
+	if (content.includes(unescapedFind)) {
+		yield unescapedFind;
+	}
+
+	const lines = content.split('\n');
+	const findLines = unescapedFind.split('\n');
+
+	for (let i = 0; i <= lines.length - findLines.length; i++) {
+		const block = lines.slice(i, i + findLines.length).join('\n');
+		const unescapedBlock = unescapeString(block);
+
+		if (unescapedBlock === unescapedFind) {
+			yield block;
+		}
+	}
+};
+
+export const TrimmedBoundaryReplacer: Replacer = function* (content, find) {
+	const trimmedFind = find.trim();
+
+	if (trimmedFind === find) {
+		return;
+	}
+
+	if (content.includes(trimmedFind)) {
+		yield trimmedFind;
+	}
+
+	const lines = content.split('\n');
+	const findLines = find.split('\n');
+
+	for (let i = 0; i <= lines.length - findLines.length; i++) {
+		const block = lines.slice(i, i + findLines.length).join('\n');
+
+		if (block.trim() === trimmedFind) {
+			yield block;
+		}
+	}
+};
+
+export const ContextAwareReplacer: Replacer = function* (content, find) {
+	const findLines = find.split('\n');
+	if (findLines.length < 3) {
+		return;
+	}
+
+	if (findLines[findLines.length - 1] === '') {
+		findLines.pop();
+	}
+
+	const contentLines = content.split('\n');
+
+	const firstLine = findLines[0].trim();
+	const lastLine = findLines[findLines.length - 1].trim();
+
+	for (let i = 0; i < contentLines.length; i++) {
+		if (contentLines[i].trim() !== firstLine) continue;
+
+		for (let j = i + 2; j < contentLines.length; j++) {
+			if (contentLines[j].trim() === lastLine) {
+				const blockLines = contentLines.slice(i, j + 1);
+
+				if (blockLines.length === findLines.length) {
+					let matchingLines = 0;
+					let totalNonEmptyLines = 0;
+
+					for (let k = 1; k < blockLines.length - 1; k++) {
+						const blockLine = blockLines[k].trim();
+						const findLine = findLines[k].trim();
+
+						if (blockLine.length > 0 || findLine.length > 0) {
+							totalNonEmptyLines++;
+							if (blockLine === findLine) {
+								matchingLines++;
+							}
+						}
+					}
+
+					if (
+						totalNonEmptyLines === 0 ||
+						matchingLines / totalNonEmptyLines >= 0.5
+					) {
+						yield blockLines.join('\n');
+						break;
+					}
+				}
+				break;
+			}
+		}
+	}
+};
+
+export const MultiOccurrenceReplacer: Replacer = function* (content, find) {
+	let startIndex = 0;
+
+	while (true) {
+		const index = content.indexOf(find, startIndex);
+		if (index === -1) break;
+
+		yield find;
+		startIndex = index + find.length;
+	}
+};
+
+export const ALL_REPLACERS: Replacer[] = [
+	SimpleReplacer,
+	LineTrimmedReplacer,
+	BlockAnchorReplacer,
+	WhitespaceNormalizedReplacer,
+	IndentationFlexibleReplacer,
+	EscapeNormalizedReplacer,
+	TrimmedBoundaryReplacer,
+	ContextAwareReplacer,
+	MultiOccurrenceReplacer,
+];
+
+export function replace(
+	content: string,
+	oldString: string,
+	newString: string,
+	replaceAll = false,
+): string {
+	if (oldString === newString) {
+		throw new Error('oldString and newString must be different');
+	}
+
+	let notFound = true;
+
+	for (const replacer of ALL_REPLACERS) {
+		for (const search of replacer(content, oldString)) {
+			const index = content.indexOf(search);
+			if (index === -1) continue;
+			notFound = false;
+			if (replaceAll) {
+				return content.replaceAll(search, newString);
+			}
+			const lastIndex = content.lastIndexOf(search);
+			if (index !== lastIndex) continue;
+			return (
+				content.substring(0, index) +
+				newString +
+				content.substring(index + search.length)
+			);
+		}
+	}
+
+	if (notFound) {
+		throw new Error('oldString not found in content');
+	}
+	throw new Error(
+		'Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match.',
+	);
+}

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

@@ -0,0 +1,166 @@
+import { tool, type Tool } from 'ai';
+import { z } from 'zod/v3';
+import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative } from 'node:path';
+import DESCRIPTION from './edit.txt' with { type: 'text' };
+import { createToolError, type ToolResponse } from '../error.ts';
+import { replace } from './edit/replacers.ts';
+import { buildWriteArtifact } from './fs/util.ts';
+
+export function buildEditTool(projectRoot: string): {
+	name: string;
+	tool: Tool;
+} {
+	const editTool = tool({
+		description: DESCRIPTION,
+		inputSchema: z.object({
+			filePath: z
+				.string()
+				.describe(
+					'The path to the file to modify (relative to project root or absolute)',
+				),
+			oldString: z.string().describe('The text to replace'),
+			newString: z
+				.string()
+				.describe(
+					'The text to replace it with (must be different from oldString)',
+				),
+			replaceAll: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe('Replace all occurrences of oldString (default false)'),
+		}),
+		async execute({
+			filePath,
+			oldString,
+			newString,
+			replaceAll: replaceAllFlag = false,
+		}: {
+			filePath: string;
+			oldString: string;
+			newString: string;
+			replaceAll?: boolean;
+		}): Promise<
+			ToolResponse<{
+				output: string;
+				filePath: string;
+				artifact: unknown;
+			}>
+		> {
+			if (!filePath || filePath.trim().length === 0) {
+				return createToolError(
+					'Missing required parameter: filePath',
+					'validation',
+					{
+						parameter: 'filePath',
+						value: filePath,
+						suggestion: 'Provide a file path to edit',
+					},
+				);
+			}
+
+			if (oldString === newString) {
+				return createToolError(
+					'oldString and newString must be different',
+					'validation',
+					{
+						parameter: 'oldString',
+						suggestion: 'Provide different values for oldString and newString',
+					},
+				);
+			}
+
+			const absPath = isAbsolute(filePath)
+				? filePath
+				: join(projectRoot, filePath);
+			const relPath = relative(projectRoot, absPath);
+
+			try {
+				if (oldString === '') {
+					await mkdir(dirname(absPath), { recursive: true });
+					await writeFile(absPath, newString, 'utf-8');
+					const artifact = await buildWriteArtifact(
+						relPath,
+						false,
+						'',
+						newString,
+					);
+					return {
+						ok: true,
+						output: 'File created successfully.',
+						filePath: relPath,
+						artifact,
+					};
+				}
+
+				const fileStat = await stat(absPath).catch(() => null);
+				if (!fileStat) {
+					return createToolError(`File ${relPath} not found`, 'not_found', {
+						parameter: 'filePath',
+						value: relPath,
+						suggestion: 'Check the file path exists',
+					});
+				}
+				if (fileStat.isDirectory()) {
+					return createToolError(
+						`Path is a directory, not a file: ${relPath}`,
+						'validation',
+						{
+							parameter: 'filePath',
+							value: relPath,
+							suggestion: 'Provide a path to a file, not a directory',
+						},
+					);
+				}
+
+				const contentOld = await readFile(absPath, 'utf-8');
+				let contentNew: string;
+
+				try {
+					contentNew = replace(
+						contentOld,
+						oldString,
+						newString,
+						replaceAllFlag,
+					);
+				} catch (error) {
+					const message =
+						error instanceof Error ? error.message : String(error);
+					return createToolError(message, 'execution', {
+						suggestion: message.includes('multiple matches')
+							? 'Provide more surrounding context in oldString to uniquely identify the match, or use replaceAll: true'
+							: 'Verify the oldString matches the file content exactly',
+					});
+				}
+
+				await writeFile(absPath, contentNew, 'utf-8');
+
+				const artifact = await buildWriteArtifact(
+					relPath,
+					true,
+					contentOld,
+					contentNew,
+				);
+
+				return {
+					ok: true,
+					output: 'Edit applied successfully.',
+					filePath: relPath,
+					artifact,
+				};
+			} catch (error: unknown) {
+				return createToolError(
+					`Failed to edit file: ${error instanceof Error ? error.message : String(error)}`,
+					'execution',
+					{
+						parameter: 'filePath',
+						value: relPath,
+					},
+				);
+			}
+		},
+	});
+
+	return { name: 'edit', tool: editTool };
+}

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

@@ -0,0 +1,10 @@
+Performs exact string replacements in files.
+
+Usage:
+- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file.
+- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears in the file.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- The edit will FAIL if `oldString` is not found in the file with an error "oldString not found in content".
+- The edit will FAIL if `oldString` is found multiple times in the file with an error about multiple matches. Either provide a larger string with more surrounding context to make it unique or use `replaceAll` to change every instance.
+- Use `replaceAll` for replacing and renaming strings across the file. This parameter is useful for renaming a variable.
+- To create a new file, use an empty `oldString` and set `newString` to the file contents.