headlesscode 1.0.2

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/read_command_output.ts

@@ -0,0 +1,81 @@
+import type OpenAI from "openai"
+
+/**
+ * Native tool definition for read_command_output.
+ *
+ * This tool allows the LLM to retrieve full command output that was truncated
+ * during execute_command. When command output exceeds the preview threshold,
+ * the full output is persisted to disk and an artifact_id is provided. The
+ * LLM can then use this tool to read the full content or search within it.
+ */
+
+const READ_COMMAND_OUTPUT_DESCRIPTION = `Retrieve the full output from a command that was truncated in execute_command. Use this tool when:
+1. The execute_command result shows "[OUTPUT TRUNCATED - Full output saved to artifact: cmd-XXXX.txt]"
+2. You need to see more of the command output beyond the preview
+3. You want to search for specific content in large command output
+
+The tool supports two modes:
+- **Read mode**: Read output starting from a byte offset with optional limit
+- **Search mode**: Filter lines matching a regex or literal pattern (like grep)
+
+Parameters:
+- artifact_id: (required) The artifact filename from the truncated output message (e.g., "cmd-1706119234567.txt")
+- search: (optional) Pattern to filter lines. Supports regex or literal strings. Case-insensitive. **Omit this parameter entirely if you don't need to filter - do not pass null or empty string.**
+- offset: (optional) Byte offset to start reading from. Default: 0. Use for pagination.
+- limit: (optional) Maximum bytes to return. Default: 40KB.
+
+Example: Reading truncated command output
+{ "artifact_id": "cmd-1706119234567.txt" }
+
+Example: Reading with pagination (after first 40KB)
+{ "artifact_id": "cmd-1706119234567.txt", "offset": 40960 }
+
+Example: Searching for errors in build output
+{ "artifact_id": "cmd-1706119234567.txt", "search": "error|failed|Error" }
+
+Example: Finding specific test failures
+{ "artifact_id": "cmd-1706119234567.txt", "search": "FAIL" }`
+
+const ARTIFACT_ID_DESCRIPTION = `The artifact filename from the truncated command output (e.g., "cmd-1706119234567.txt")`
+
+const SEARCH_DESCRIPTION = `Optional regex or literal pattern to filter lines (case-insensitive, like grep). Omit this parameter if not searching - do not pass null or empty string.`
+
+const OFFSET_DESCRIPTION = `Byte offset to start reading from (default: 0, for pagination)`
+
+const LIMIT_DESCRIPTION = `Maximum bytes to return (default: 40KB)`
+
+export default {
+	type: "function",
+	function: {
+		name: "read_command_output",
+		description: READ_COMMAND_OUTPUT_DESCRIPTION,
+		// Note: strict mode is intentionally disabled for this tool.
+		// With strict: true, OpenAI requires ALL properties to be in the 'required' array,
+		// which forces the LLM to always provide explicit values (even null) for optional params.
+		// This creates verbose tool calls and poor UX. By disabling strict mode, the LLM can
+		// omit optional parameters entirely, making the tool easier to use.
+		parameters: {
+			type: "object",
+			properties: {
+				artifact_id: {
+					type: "string",
+					description: ARTIFACT_ID_DESCRIPTION,
+				},
+				search: {
+					type: "string",
+					description: SEARCH_DESCRIPTION,
+				},
+				offset: {
+					type: "number",
+					description: OFFSET_DESCRIPTION,
+				},
+				limit: {
+					type: "number",
+					description: LIMIT_DESCRIPTION,
+				},
+			},
+			required: ["artifact_id"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/read_file.ts

@@ -0,0 +1,169 @@
+import type OpenAI from "openai"
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+/** Default maximum lines to return per file (Codex-inspired predictable limit) */
+export const DEFAULT_LINE_LIMIT = 2000
+
+/** Maximum characters per line before truncation */
+export const MAX_LINE_LENGTH = 2000
+
+/** Default indentation levels to include above anchor (0 = unlimited) */
+export const DEFAULT_MAX_LEVELS = 0
+
+// ─── Helper Functions ─────────────────────────────────────────────────────────
+
+/**
+ * Generates the file support note, optionally including image format support.
+ *
+ * @param supportsImages - Whether the model supports image processing
+ * @returns Support note string
+ */
+function getReadFileSupportsNote(supportsImages: boolean): string {
+	if (supportsImages) {
+		return `Supports text extraction from PDF and DOCX files. Automatically processes and returns image files (PNG, JPG, JPEG, GIF, BMP, SVG, WEBP, ICO, AVIF) for visual analysis. May not handle other binary files properly.`
+	}
+	return `Supports text extraction from PDF and DOCX files, but may not handle other binary files properly.`
+}
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+/**
+ * Options for creating the read_file tool definition.
+ */
+export interface ReadFileToolOptions {
+	/** Whether the model supports image processing (default: false) */
+	supportsImages?: boolean
+}
+
+// ─── Schema Builder ───────────────────────────────────────────────────────────
+
+/**
+ * Creates the read_file tool definition with Codex-inspired modes.
+ *
+ * Two reading modes are supported:
+ *
+ * 1. **Slice Mode** (default): Simple offset/limit reading
+ *    - Reads contiguous lines starting from `offset` (1-based, default: 1)
+ *    - Limited to `limit` lines (default: 2000)
+ *    - Predictable and efficient for agent planning
+ *
+ * 2. **Indentation Mode**: Semantic code block extraction
+ *    - Anchored on a specific line number (1-based)
+ *    - Extracts the block containing that line plus context
+ *    - Respects code structure based on indentation hierarchy
+ *    - Useful for extracting functions, classes, or logical blocks
+ *
+ * @param options - Configuration options for the tool
+ * @returns Native tool definition for read_file
+ */
+export function createReadFileTool(options: ReadFileToolOptions = {}): OpenAI.Chat.ChatCompletionTool {
+	const { supportsImages = false } = options
+
+	// Build description based on capabilities
+	const descriptionIntro =
+		"Read a file and return its contents with line numbers for diffing or discussion. IMPORTANT: This tool reads exactly one file per call. If you need multiple files, issue multiple parallel read_file calls."
+
+	const modeDescription =
+		` Supports two modes: 'slice' (default) reads lines sequentially with offset/limit; 'indentation' extracts complete semantic code blocks around an anchor line based on indentation hierarchy.` +
+		` Slice mode is ideal for initial file exploration, understanding overall structure, reading configuration/data files, or when you need a specific line range. Use it when you don't have a target line number.` +
+		` PREFER indentation mode when you have a specific line number from search results, error messages, or definition lookups - it guarantees complete, syntactically valid code blocks without mid-function truncation.` +
+		` IMPORTANT: Indentation mode requires anchor_line to be useful. Without it, only header content (imports) is returned.`
+
+	const limitNote = ` By default, returns up to ${DEFAULT_LINE_LIMIT} lines per file. Lines longer than ${MAX_LINE_LENGTH} characters are truncated.`
+
+	const description =
+		descriptionIntro +
+		modeDescription +
+		limitNote +
+		" " +
+		getReadFileSupportsNote(supportsImages) +
+		` Example: { path: 'src/app.ts' }` +
+		` Example (indentation mode): { path: 'src/app.ts', mode: 'indentation', indentation: { anchor_line: 42 } }`
+
+	const indentationProperties: Record<string, unknown> = {
+		anchor_line: {
+			type: "integer",
+			description:
+				"1-based line number to anchor the extraction. REQUIRED for meaningful indentation mode results. The extractor finds the semantic block (function, method, class) containing this line and returns it completely. Without anchor_line, indentation mode defaults to line 1 and returns only imports/header content. Obtain anchor_line from: search results, error stack traces, definition lookups, codebase_search results, or condensed file summaries (e.g., '14--28 | export class UserService' means anchor_line=14).",
+		},
+		max_levels: {
+			type: "integer",
+			description: `Maximum indentation levels to include above the anchor (indentation mode, 0 = unlimited (default)). Higher values include more parent context.`,
+		},
+		include_siblings: {
+			type: "boolean",
+			description:
+				"Include sibling blocks at the same indentation level as the anchor block (indentation mode, default: false). Useful for seeing related methods in a class.",
+		},
+		include_header: {
+			type: "boolean",
+			description:
+				"Include file header content (imports, module-level comments) at the top of output (indentation mode, default: true).",
+		},
+		max_lines: {
+			type: "integer",
+			description:
+				"Hard cap on lines returned for indentation mode. Acts as a separate limit from the top-level 'limit' parameter.",
+		},
+	}
+
+	const properties: Record<string, unknown> = {
+		path: {
+			type: "string",
+			description: "Path to the file to read, relative to the workspace",
+		},
+		mode: {
+			type: "string",
+			enum: ["slice", "indentation"],
+			description:
+				"Reading mode. 'slice' (default): read lines sequentially with offset/limit - use for general file exploration or when you don't have a target line number (may truncate code mid-function). 'indentation': extract complete semantic code blocks containing anchor_line - PREFERRED when you have a line number because it guarantees complete, valid code blocks. WARNING: Do not use indentation mode without specifying indentation.anchor_line, or you will only get header content.",
+		},
+		offset: {
+			type: "integer",
+			description: "1-based line offset to start reading from (slice mode, default: 1)",
+		},
+		limit: {
+			type: "integer",
+			description: `Maximum number of lines to return (slice mode, default: ${DEFAULT_LINE_LIMIT})`,
+		},
+		indentation: {
+			type: "object",
+			description:
+				"Indentation mode options. Only used when mode='indentation'. You MUST specify anchor_line for useful results - it determines which code block to extract.",
+			properties: indentationProperties,
+			required: [],
+			additionalProperties: false,
+		},
+	}
+
+	return {
+		type: "function",
+		function: {
+			name: "read_file",
+			description,
+			// PATCHED (headlesscode, not upstream): `strict: true` was set here
+			// while `required` only lists `path` — `mode`, `offset`, `limit`,
+			// and `indentation` are all genuinely optional and NOT required,
+			// which violates OpenAI's own strict-mode contract (when
+			// strict:true, every property must be in `required`). Lenient
+			// hosts silently tolerate this; DeepSeek's official API endpoint
+			// validates it correctly and rejects the whole request with
+			// HTTP 400 the moment this tool is included — confirmed live,
+			// 2026-08-01. `read_command_output.ts` right next to this file
+			// already disables strict mode for exactly this reason (see its
+			// own comment) — this is the same fix, just missed here upstream.
+			parameters: {
+				type: "object",
+				properties,
+				required: ["path"],
+				additionalProperties: false,
+			},
+		},
+	} satisfies OpenAI.Chat.ChatCompletionTool
+}
+
+/**
+ * Default read_file tool with all parameters
+ */
+export const read_file = createReadFileTool()

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/run_slash_command.ts

@@ -0,0 +1,31 @@
+import type OpenAI from "openai"
+
+const RUN_SLASH_COMMAND_DESCRIPTION = `Execute a slash command to get specific instructions or content. Slash commands are predefined templates that provide detailed guidance for common tasks.`
+
+const COMMAND_PARAMETER_DESCRIPTION = `Name of the slash command to run (e.g., init, test, deploy)`
+
+const ARGS_PARAMETER_DESCRIPTION = `Optional additional context or arguments for the command`
+
+export default {
+	type: "function",
+	function: {
+		name: "run_slash_command",
+		description: RUN_SLASH_COMMAND_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				command: {
+					type: "string",
+					description: COMMAND_PARAMETER_DESCRIPTION,
+				},
+				args: {
+					type: ["string", "null"],
+					description: ARGS_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["command", "args"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/search_files.ts

@@ -0,0 +1,50 @@
+import type OpenAI from "openai"
+
+const SEARCH_FILES_DESCRIPTION = `Request to perform a regex search across files in a specified directory, providing context-rich results. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.
+
+Craft your regex patterns carefully to balance specificity and flexibility. Use this tool to find code patterns, TODO comments, function definitions, or any text-based information across the project. The results include surrounding context, so analyze the surrounding code to better understand the matches. Leverage this tool in combination with other tools for more comprehensive analysis.
+
+Parameters:
+- path: (required) The path of the directory to search in (relative to the current workspace directory). This directory will be recursively searched.
+- regex: (required) The regular expression pattern to search for. Uses Rust regex syntax.
+- file_pattern: (optional) Glob pattern to filter files (e.g., '*.ts' for TypeScript files). If not provided, it will search all files (*).
+
+Example: Searching for all .ts files in the current directory
+{ "path": ".", "regex": ".*", "file_pattern": "*.ts" }
+
+Example: Searching for function definitions in JavaScript files
+{ "path": "src", "regex": "function\\s+\\w+", "file_pattern": "*.js" }`
+
+const PATH_PARAMETER_DESCRIPTION = `Directory to search recursively, relative to the workspace`
+
+const REGEX_PARAMETER_DESCRIPTION = `Rust-compatible regular expression pattern to match`
+
+const FILE_PATTERN_PARAMETER_DESCRIPTION = `Optional glob to limit which files are searched (e.g., *.ts)`
+
+export default {
+	type: "function",
+	function: {
+		name: "search_files",
+		description: SEARCH_FILES_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: PATH_PARAMETER_DESCRIPTION,
+				},
+				regex: {
+					type: "string",
+					description: REGEX_PARAMETER_DESCRIPTION,
+				},
+				file_pattern: {
+					type: ["string", "null"],
+					description: FILE_PATTERN_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["path", "regex", "file_pattern"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/search_replace.ts

@@ -0,0 +1,51 @@
+import type OpenAI from "openai"
+
+const SEARCH_REPLACE_DESCRIPTION = `Use this tool to propose a search and replace operation on an existing file.
+
+The tool will replace ONE occurrence of old_string with new_string in the specified file.
+
+CRITICAL REQUIREMENTS FOR USING THIS TOOL:
+
+1. UNIQUENESS: The old_string MUST uniquely identify the specific instance you want to change. This means:
+   - Include AT LEAST 3-5 lines of context BEFORE the change point
+   - Include AT LEAST 3-5 lines of context AFTER the change point
+   - Include all whitespace, indentation, and surrounding code exactly as it appears in the file
+
+2. SINGLE INSTANCE: This tool can only change ONE instance at a time. If you need to change multiple instances:
+   - Make separate calls to this tool for each instance
+   - Each call must uniquely identify its specific instance using extensive context
+
+3. VERIFICATION: Before using this tool:
+   - If multiple instances exist, gather enough context to uniquely identify each one
+   - Plan separate tool calls for each instance`
+
+const search_replace = {
+	type: "function",
+	function: {
+		name: "search_replace",
+		description: SEARCH_REPLACE_DESCRIPTION,
+		parameters: {
+			type: "object",
+			properties: {
+				file_path: {
+					type: "string",
+					description:
+						"The path to the file you want to search and replace in. You can use either a relative path in the workspace or an absolute path. If an absolute path is provided, it will be preserved as is.",
+				},
+				old_string: {
+					type: "string",
+					description:
+						"The text to replace (must be unique within the file, and must match the file contents exactly, including all whitespace and indentation)",
+				},
+				new_string: {
+					type: "string",
+					description: "The edited text to replace the old_string (must be different from the old_string)",
+				},
+			},
+			required: ["file_path", "old_string", "new_string"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool
+
+export default search_replace

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/skill.ts

@@ -0,0 +1,33 @@
+import type OpenAI from "openai"
+
+const SKILL_DESCRIPTION = `Load and execute a skill by name. Skills provide specialized instructions for common tasks like creating MCP servers or custom modes.
+
+Use this tool when you need to follow specific procedures documented in a skill. Available skills are listed in the AVAILABLE SKILLS section of the system prompt.`
+
+const SKILL_PARAMETER_DESCRIPTION = `Name of the skill to load (e.g., create-mcp-server, create-mode). Must match a skill name from the available skills list.`
+
+const ARGS_PARAMETER_DESCRIPTION = `Optional context or arguments to pass to the skill`
+
+export default {
+	type: "function",
+	function: {
+		name: "skill",
+		description: SKILL_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				skill: {
+					type: "string",
+					description: SKILL_PARAMETER_DESCRIPTION,
+				},
+				args: {
+					type: ["string", "null"],
+					description: ARGS_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["skill", "args"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/switch_mode.ts

@@ -0,0 +1,31 @@
+import type OpenAI from "openai"
+
+const SWITCH_MODE_DESCRIPTION = `Request to switch to a different mode. This tool allows modes to request switching to another mode when needed, such as switching to Code mode to make code changes. The user must approve the mode switch.`
+
+const MODE_SLUG_PARAMETER_DESCRIPTION = `Slug of the mode to switch to (e.g., code, ask, architect)`
+
+const REASON_PARAMETER_DESCRIPTION = `Explanation for why the mode switch is needed`
+
+export default {
+	type: "function",
+	function: {
+		name: "switch_mode",
+		description: SWITCH_MODE_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				mode_slug: {
+					type: "string",
+					description: MODE_SLUG_PARAMETER_DESCRIPTION,
+				},
+				reason: {
+					type: "string",
+					description: REASON_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["mode_slug", "reason"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/update_todo_list.ts

@@ -0,0 +1,54 @@
+import type OpenAI from "openai"
+
+const UPDATE_TODO_LIST_DESCRIPTION = `Replace the entire TODO list with an updated checklist reflecting the current state. Always provide the full list; the system will overwrite the previous one. This tool is designed for step-by-step task tracking, allowing you to confirm completion of each step before updating, update multiple task statuses at once (e.g., mark one as completed and start the next), and dynamically add new todos discovered during long or complex tasks.
+
+Checklist Format:
+- Use a single-level markdown checklist (no nesting or subtasks)
+- List todos in the intended execution order
+- Status options: [ ] (pending), [x] (completed), [-] (in progress)
+
+Core Principles:
+- Before updating, always confirm which todos have been completed
+- You may update multiple statuses in a single update
+- Add new actionable items as they're discovered
+- Only mark a task as completed when fully accomplished
+- Keep all unfinished tasks unless explicitly instructed to remove
+
+Example: Initial task list
+{ "todos": "[x] Analyze requirements\\n[x] Design architecture\\n[-] Implement core logic\\n[ ] Write tests\\n[ ] Update documentation" }
+
+Example: After completing implementation
+{ "todos": "[x] Analyze requirements\\n[x] Design architecture\\n[x] Implement core logic\\n[-] Write tests\\n[ ] Update documentation\\n[ ] Add performance benchmarks" }
+
+When to Use:
+- Task involves multiple steps or requires ongoing tracking
+- Need to update status of several todos at once
+- New actionable items are discovered during execution
+- Task is complex and benefits from stepwise progress tracking
+
+When NOT to Use:
+- Only a single, trivial task
+- Task can be completed in one or two simple steps
+- Request is purely conversational or informational`
+
+const TODOS_PARAMETER_DESCRIPTION = `Full markdown checklist in execution order, using [ ] for pending, [x] for completed, and [-] for in progress`
+
+export default {
+	type: "function",
+	function: {
+		name: "update_todo_list",
+		description: UPDATE_TODO_LIST_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				todos: {
+					type: "string",
+					description: TODOS_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["todos"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/vendor/zoo-code/src/core/prompts/tools/native-tools/write_to_file.ts

@@ -0,0 +1,40 @@
+import type OpenAI from "openai"
+
+const WRITE_TO_FILE_DESCRIPTION = `Request to write content to a file. This tool is primarily used for creating new files or for scenarios where a complete rewrite of an existing file is intentionally required. If the file exists, it will be overwritten. If it doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.
+
+**Important:** You should prefer using other editing tools over write_to_file when making changes to existing files, since write_to_file is slower and cannot handle large files. Use write_to_file primarily for new file creation.
+
+When using this tool, use it directly with the desired content. You do not need to display the content before using the tool. ALWAYS provide the COMPLETE file content in your response. This is NON-NEGOTIABLE. Partial updates or placeholders like '// rest of code unchanged' are STRICTLY FORBIDDEN. Failure to do so will result in incomplete or broken code.
+
+When creating a new project, organize all new files within a dedicated project directory unless the user specifies otherwise. Structure the project logically, adhering to best practices for the specific type of project being created.
+
+Example: Writing a configuration file
+{ "path": "frontend-config.json", "content": "{\\n  \\"apiEndpoint\\": \\"https://api.example.com\\",\\n  \\"theme\\": {\\n    \\"primaryColor\\": \\"#007bff\\"\\n  }\\n}" }`
+
+const PATH_PARAMETER_DESCRIPTION = `The path of the file to write to (relative to the current workspace directory)`
+
+const CONTENT_PARAMETER_DESCRIPTION = `The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified. Do NOT include line numbers in the content.`
+
+export default {
+	type: "function",
+	function: {
+		name: "write_to_file",
+		description: WRITE_TO_FILE_DESCRIPTION,
+		strict: true,
+		parameters: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: PATH_PARAMETER_DESCRIPTION,
+				},
+				content: {
+					type: "string",
+					description: CONTENT_PARAMETER_DESCRIPTION,
+				},
+			},
+			required: ["path", "content"],
+			additionalProperties: false,
+		},
+	},
+} satisfies OpenAI.Chat.ChatCompletionTool

package/src/vendor/zoo-code/src/core/prompts/types.ts

@@ -0,0 +1,12 @@
+/**
+ * Settings passed to system prompt generation functions
+ */
+export interface SystemPromptSettings {
+	todoListEnabled: boolean
+	useAgentRules: boolean
+	/** When true, recursively discover and load .roo/rules from subdirectories */
+	enableSubfolderRules?: boolean
+	newTaskRequireTodos: boolean
+	/** When true, model should hide vendor/company identity in responses */
+	isStealthModel?: boolean
+}

package/src/vendor/zoo-code/src/i18n/index.ts

@@ -0,0 +1,19 @@
+/**
+ * SHIM — replaces zoo-code/src/i18n/index.ts.
+ *
+ * The original is a full i18n catalog keyed to the webview UI. The vendored
+ * CustomModesManager uses `t()` only to build user-facing error strings. The
+ * headless harness surfaces those as plain console output, so this shim returns
+ * the key (with `{param}` interpolation applied).
+ */
+
+export function t(key: string, params?: Record<string, unknown>): string {
+	if (!params) {
+		return key
+	}
+	let result = key
+	for (const [name, value] of Object.entries(params)) {
+		result = result.replaceAll(`{${name}}`, String(value))
+	}
+	return result
+}

package/src/vendor/zoo-code/src/integrations/misc/extract-text.ts

@@ -0,0 +1,81 @@
+/**
+ * Vendored subset of `zoo-code/src/integrations/misc/extract-text.ts`.
+ *
+ * Only the three pure text-formatting helpers used by the vendored
+ * MultiSearchReplaceDiffStrategy are carried here (verbatim from upstream):
+ *
+ *   - addLineNumbers
+ *   - everyLineHasLineNumbers
+ *   - stripLineNumbers
+ *
+ * The full upstream file also contains PDF/DOCX/XLSX extractors, binary-file
+ * detection and indentation slicing, none of which the headless harness needs —
+ * they pull in `pdf-parse`, `mammoth`, `isbinaryfile` and other GUI/service
+ * dependencies that are not worth carrying.
+ */
+
+export function addLineNumbers(content: string, startLine: number = 1): string {
+	// If content is empty, return empty string - empty files should not have line numbers
+	// If content is empty but startLine > 1, return "startLine | " because we know the file is not empty
+	// but the content is empty at that line offset
+	if (content === "") {
+		return startLine === 1 ? "" : `${startLine} | \n`
+	}
+
+	// Split into lines and handle trailing line feeds (\n)
+	const lines = content.split("\n")
+	const lastLineEmpty = lines[lines.length - 1] === ""
+	if (lastLineEmpty) {
+		lines.pop()
+	}
+
+	const maxLineNumberWidth = String(startLine + lines.length - 1).length
+	const numberedContent = lines
+		.map((line, index) => {
+			const lineNumber = String(startLine + index).padStart(maxLineNumberWidth, " ")
+			return `${lineNumber} | ${line}`
+		})
+		.join("\n")
+
+	return numberedContent + "\n"
+}
+// Checks if every line in the content has line numbers prefixed (e.g., "1 | content" or "123 | content")
+// Line numbers must be followed by a single pipe character (not double pipes)
+export function everyLineHasLineNumbers(content: string): boolean {
+	const lines = content.split(/\r?\n/) // Handles both CRLF (carriage return (\r) + line feed (\n)) and LF (line feed (\n)) line endings
+	return lines.length > 0 && lines.every((line) => /^\s*\d+\s+\|(?!\|)/.test(line))
+}
+
+/**
+ * Strips line numbers from content while preserving the actual content.
+ *
+ * @param content The content to process
+ * @param aggressive When false (default): Only strips lines with clear number patterns like "123 | content"
+ *                   When true: Uses a more lenient pattern that also matches lines with just a pipe character,
+ *                   which can be useful when LLMs don't perfectly format the line numbers in diffs
+ * @returns The content with line numbers removed
+ */
+export function stripLineNumbers(content: string, aggressive: boolean = false): string {
+	// Split into lines to handle each line individually
+	const lines = content.split(/\r?\n/)
+
+	// Process each line
+	const processedLines = lines.map((line) => {
+		// Match line number pattern and capture everything after the pipe
+		const match = aggressive ? line.match(/^\s*(?:\d+\s)?\|\s(.*)$/) : line.match(/^\s*\d+\s+\|(?!\|)\s?(.*)$/)
+		return match ? match[1] : line
+	})
+
+	// Join back with original line endings (carriage return (\r) + line feed (\n) or just line feed (\n))
+	const lineEnding = content.includes("\r\n") ? "\r\n" : "\n"
+	let result = processedLines.join(lineEnding)
+
+	// Preserve trailing newline if present in original content
+	if (content.endsWith(lineEnding)) {
+		if (!result.endsWith(lineEnding)) {
+			result += lineEnding
+		}
+	}
+
+	return result
+}