@humanlayer/agentlayer-justbash 0.0.7

package/src/tools/code-search.ts

@@ -0,0 +1,119 @@
+import type { CodeSearchInput } from '@humanlayer/agentlayer-core/interfaces'
+import { CodeSearchTool } from '@humanlayer/agentlayer-core/interfaces'
+import { CODE_SEARCH_DESCRIPTION } from '@humanlayer/agentlayer-core/prompts'
+import type { Bash } from 'just-bash'
+
+const DEFAULT_TIMEOUT_SEC = 30
+const CONTEXT7_BASE_URL = 'https://context7.com'
+
+export interface JustBashCodeSearchOptions {
+	exaApiKey?: string
+	context7ApiKey?: string
+	timeoutSec?: number
+}
+
+async function fetchExaViaBash(
+	bash: Bash,
+	input: CodeSearchInput,
+	apiKey: string,
+	timeoutSec: number,
+): Promise<string | null> {
+	try {
+		const query = `${input.query} -- for ${input.packageName} in ${input.language}`
+		const payload = JSON.stringify({ query, tokensNum: 5000 })
+		const escapedPayload = payload.replace(/'/g, "'\\''")
+
+		const result = await bash.exec(
+			`curl -s --max-time ${timeoutSec} ` +
+				`-H "Content-Type: application/json" ` +
+				`-H "x-api-key: ${apiKey}" ` +
+				`-d '${escapedPayload}' ` +
+				`https://api.exa.ai/context`,
+		)
+
+		if (result.exitCode !== 0) return null
+
+		const data = JSON.parse(result.stdout) as { response?: string }
+		return data.response ?? null
+	} catch {
+		return null
+	}
+}
+
+async function fetchContext7ViaBash(
+	bash: Bash,
+	input: CodeSearchInput,
+	apiKey: string,
+	timeoutSec: number,
+): Promise<string | null> {
+	try {
+		// Step 1: search for the library
+		const searchQuery = encodeURIComponent(input.query)
+		const libName = encodeURIComponent(input.packageName)
+
+		const searchResult = await bash.exec(
+			`curl -s --max-time ${timeoutSec} ` +
+				`-H "Authorization: Bearer ${apiKey}" ` +
+				`"${CONTEXT7_BASE_URL}/api/v2/libs/search?query=${searchQuery}&libraryName=${libName}"`,
+		)
+
+		if (searchResult.exitCode !== 0) return null
+
+		const searchData = JSON.parse(searchResult.stdout) as {
+			results?: Array<{ id: string; title: string; trustScore?: number }>
+		}
+		const libraries = searchData.results ?? []
+		if (libraries.length === 0) return null
+
+		const best = libraries.reduce((a, b) => ((b.trustScore ?? 0) > (a.trustScore ?? 0) ? b : a))
+
+		// Step 2: fetch context for the selected library
+		const contextQuery = encodeURIComponent(input.query)
+		const libId = encodeURIComponent(best.id)
+
+		const contextResult = await bash.exec(
+			`curl -s --max-time ${timeoutSec} ` +
+				`-H "Authorization: Bearer ${apiKey}" ` +
+				`"${CONTEXT7_BASE_URL}/api/v2/context?query=${contextQuery}&libraryId=${libId}"`,
+		)
+
+		if (contextResult.exitCode !== 0) return null
+		return contextResult.stdout
+	} catch {
+		return null
+	}
+}
+
+export function createCodeSearchTool(bash: Bash, opts: JustBashCodeSearchOptions) {
+	if (!opts.exaApiKey && !opts.context7ApiKey) {
+		throw new Error('At least one API key (exaApiKey or context7ApiKey) is required')
+	}
+
+	const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC
+
+	return CodeSearchTool.define(
+		async (input: CodeSearchInput): Promise<string> => {
+			const [exaResult, c7Result] = await Promise.all([
+				opts.exaApiKey ? fetchExaViaBash(bash, input, opts.exaApiKey, timeoutSec) : Promise.resolve(null),
+				opts.context7ApiKey
+					? fetchContext7ViaBash(bash, input, opts.context7ApiKey, timeoutSec)
+					: Promise.resolve(null),
+			])
+
+			const parts: string[] = []
+			if (c7Result) {
+				parts.push(`## Context7 Documentation\n\n${c7Result}`)
+			}
+			if (exaResult) {
+				parts.push(`## Exa Search Results\n\n${exaResult}`)
+			}
+
+			if (parts.length === 0) {
+				return `No documentation found for "${input.packageName}" with query: ${input.query}`
+			}
+
+			return parts.join('\n\n---\n\n')
+		},
+		{ description: CODE_SEARCH_DESCRIPTION },
+	)
+}

package/src/tools/edit.ts

@@ -0,0 +1,58 @@
+import { EditTool } from '@humanlayer/agentlayer-core/interfaces'
+import { EDIT_DESCRIPTION } from '@humanlayer/agentlayer-core/prompts'
+import type { Bash } from 'just-bash'
+
+export function createEditTool(bash: Bash) {
+	return EditTool.define(
+		async (input) => {
+			// Read the file content
+			const catResult = await bash.exec(`cat "${input.file_path}"`)
+			if (catResult.exitCode !== 0) {
+				throw new Error(`File ${input.file_path} not found`)
+			}
+
+			const content = catResult.stdout
+
+			if (!content.includes(input.old_string)) {
+				return { content, matchCount: 0 }
+			}
+
+			let updated: string
+			let matchCount: number
+
+			if (input.replace_all) {
+				let count = 0
+				let pos = 0
+				while (true) {
+					const idx = content.indexOf(input.old_string, pos)
+					if (idx === -1) break
+					count++
+					pos = idx + input.old_string.length
+				}
+				updated = content.split(input.old_string).join(input.new_string)
+				matchCount = count
+			} else {
+				// Single replacement — check for multiple matches
+				const firstIdx = content.indexOf(input.old_string)
+				const lastIdx = content.lastIndexOf(input.old_string)
+				if (firstIdx !== lastIdx) {
+					throw new Error(
+						'Found multiple matches for old_string. Provide more surrounding context to make the match unique.',
+					)
+				}
+				updated = content.replace(input.old_string, input.new_string)
+				matchCount = 1
+			}
+
+			// Write the updated content back using a heredoc
+			const DELIM = 'EDITEOF_8f3a2b1c'
+			const writeResult = await bash.exec(`cat > "${input.file_path}" <<'${DELIM}'\n${updated}\n${DELIM}`)
+			if (writeResult.exitCode !== 0) {
+				throw new Error(`Failed to write file ${input.file_path}: ${writeResult.stderr}`)
+			}
+
+			return { content: updated, matchCount }
+		},
+		{ description: EDIT_DESCRIPTION },
+	)
+}

package/src/tools/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 AFTER the line number prefix. The line number prefix format is: spaces + line number + arrow. Everything after that arrow is the actual file content to match. Never include any part of the line number prefix in the oldString or newString.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if `oldString` is not found in the file. Either provide a larger string with more surrounding context to make it unique or use `replaceAll` to change every instance of `oldString`.
+- The edit will FAIL if `oldString` matches multiple locations and `replaceAll` is not set.
+- Use `replaceAll` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.

package/src/tools/glob.ts

@@ -0,0 +1,33 @@
+import { GlobTool } from '@humanlayer/agentlayer-core/interfaces'
+import { GLOB_DESCRIPTION } from '@humanlayer/agentlayer-core/prompts'
+import type { Bash } from 'just-bash'
+
+export function createGlobTool(bash: Bash) {
+	return GlobTool.define(
+		async (input) => {
+			const searchPath = input.path ?? '.'
+			// Use rg --files with glob filter — rg is typically available in just-bash environments
+			const result = await bash.exec(`rg --files -g "${input.pattern}" "${searchPath}" 2>/dev/null`)
+
+			if (result.exitCode !== 0 && result.exitCode !== 1) {
+				// Non-zero / non-empty exit may mean rg not available — fall back to find
+				const findResult = await bash.exec(
+					`find "${searchPath}" -type f -name "${input.pattern}" 2>/dev/null | head -100`,
+				)
+				if (findResult.exitCode !== 0) {
+					return []
+				}
+				return findResult.stdout
+					.split('\n')
+					.map((l) => l.trim())
+					.filter(Boolean)
+			}
+
+			return result.stdout
+				.split('\n')
+				.map((l) => l.trim())
+				.filter(Boolean)
+		},
+		{ description: GLOB_DESCRIPTION },
+	)
+}

package/src/tools/glob.txt

@@ -0,0 +1,6 @@
+- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead
+- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches as a batch that are potentially useful.

package/src/tools/grep.ts

@@ -0,0 +1,53 @@
+import type { GrepMatch } from '@humanlayer/agentlayer-core/interfaces'
+import { GrepTool } from '@humanlayer/agentlayer-core/interfaces'
+import { GREP_DESCRIPTION } from '@humanlayer/agentlayer-core/prompts'
+import type { Bash } from 'just-bash'
+
+const MAX_MATCHES = 100
+
+export function createGrepTool(bash: Bash) {
+	return GrepTool.define(
+		async (input) => {
+			const searchPath = input.path ?? '.'
+			let cmd = `rg -nH --hidden --no-messages --regexp "${input.pattern}"`
+			if (input.include) {
+				cmd += ` --glob "${input.include}"`
+			}
+			cmd += ` "${searchPath}"`
+
+			const result = await bash.exec(cmd)
+
+			// Exit code 1 = no matches
+			if (result.exitCode === 1) {
+				return []
+			}
+
+			if (result.exitCode !== 0) {
+				throw new Error(`grep failed with exit code ${result.exitCode}: ${result.stderr}`)
+			}
+
+			// Parse `file:line:content` output lines
+			const matches: GrepMatch[] = []
+			for (const line of result.stdout.split('\n')) {
+				if (!line) continue
+				const colonIdx = line.indexOf(':')
+				if (colonIdx === -1) continue
+				const afterFile = line.indexOf(':', colonIdx + 1)
+				if (afterFile === -1) continue
+
+				const file = line.slice(0, colonIdx)
+				const lineNum = Number.parseInt(line.slice(colonIdx + 1, afterFile), 10)
+				const content = line.slice(afterFile + 1)
+
+				if (!Number.isNaN(lineNum)) {
+					matches.push({ file, line: lineNum, content })
+				}
+
+				if (matches.length >= MAX_MATCHES) break
+			}
+
+			return matches
+		},
+		{ description: GREP_DESCRIPTION },
+	)
+}

package/src/tools/grep.txt

@@ -0,0 +1,8 @@
+- Fast content search tool that works with any codebase size
+- Searches file contents using regular expressions
+- Supports full regex syntax (eg. "log.*Error", "function\s+\w+", etc.)
+- Filter files by pattern with the include parameter (eg. "*.js", "*.{ts,tsx}")
+- Returns file paths and line numbers with at least one match sorted by modification time
+- Use this tool when you need to find files containing specific patterns
+- If you need to identify/count the number of matches within files, use the Bash tool with `rg` (ripgrep) directly. Do NOT use `grep`.
+- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead

package/src/tools/index.ts

@@ -0,0 +1,12 @@
+export { createApplyPatchTool } from './apply-patch'
+export { createJustBashTool } from './bash'
+export { createCodeSearchTool, type JustBashCodeSearchOptions } from './code-search'
+export { createEditTool } from './edit'
+export { createGlobTool } from './glob'
+export { createGrepTool } from './grep'
+export { createListTool } from './list'
+export { createJustBashReadTool } from './read'
+export { createSkillToolFromVFS } from './skill'
+export { createWebFetchTool } from './web-fetch'
+export { createWebSearchTool, type JustBashWebSearchOptions } from './web-search'
+export { createWriteTool } from './write'

package/src/tools/list.ts

@@ -0,0 +1,41 @@
+import type { ListEntry } from '@humanlayer/agentlayer-core/interfaces'
+import { ListTool } from '@humanlayer/agentlayer-core/interfaces'
+import { LIST_DESCRIPTION } from '@humanlayer/agentlayer-core/prompts'
+import type { Bash } from 'just-bash'
+export function createListTool(bash: Bash) {
+	return ListTool.define(
+		async (input) => {
+			const dirPath = input.path ?? '.'
+
+			// Use ls -1F: appends '/' to directories, nothing to files
+			const result = await bash.exec(`ls -1F "${dirPath}" 2>/dev/null`)
+
+			if (result.exitCode !== 0) {
+				throw new Error(`Failed to list directory ${dirPath}: ${result.stderr}`)
+			}
+
+			const ignorePatterns = new Set<string>(['node_modules', '.git', 'dist', 'build', ...(input.ignore ?? [])])
+
+			const entries: ListEntry[] = []
+			for (const raw of result.stdout.split('\n')) {
+				const line = raw.trim()
+				if (!line) continue
+
+				if (line.endsWith('/')) {
+					// Directory
+					const name = line.slice(0, -1)
+					if (ignorePatterns.has(name)) continue
+					entries.push({ name, type: 'directory' })
+				} else {
+					// File (strip any trailing decorator: *, @, |, =, >)
+					const name = line.replace(/[*@|=>]$/, '')
+					if (ignorePatterns.has(name)) continue
+					entries.push({ name, type: 'file' })
+				}
+			}
+
+			return entries
+		},
+		{ description: LIST_DESCRIPTION },
+	)
+}

package/src/tools/list.txt

@@ -0,0 +1,5 @@
+Lists files and directories in a given path.
+
+- The path parameter must be absolute; omit it to use the current workspace directory.
+- You can optionally provide an array of glob patterns to ignore with the ignore parameter.
+- You should generally prefer the Glob and Grep tools if you know which directories to search.

package/src/tools/read.ts

@@ -0,0 +1,16 @@
+import { ReadTool } from '@humanlayer/agentlayer-core/interfaces'
+import { READ_DESCRIPTION } from '@humanlayer/agentlayer-core/prompts'
+import type { Bash } from 'just-bash'
+
+export function createJustBashReadTool(bash: Bash) {
+	return ReadTool.define(
+		async (input) => {
+			const result = await bash.exec(`cat "${input.file_path}"`)
+			if (result.exitCode !== 0) {
+				throw new Error(`File not found: ${input.file_path}`)
+			}
+			return result.stdout
+		},
+		{ description: READ_DESCRIPTION },
+	)
+}

package/src/tools/read.txt

@@ -0,0 +1,14 @@
+Read a file or directory from the local filesystem. If the path does not exist, an error is returned.
+
+Usage:
+- The filePath parameter should be an absolute path.
+- By default, this tool returns up to 2000 lines from the start of the file.
+- The offset parameter is the line number to start from (1-indexed).
+- To read later sections, call this tool again with a larger offset.
+- Use the grep tool to find specific content in large files or files with long lines.
+- If you are unsure of the correct file path, use the glob tool to look up filenames by glob pattern.
+- Contents are returned with each line prefixed by its line number as `<line>: <content>`. For example, if a file has contents "foo\n", you will receive "1: foo\n". For directories, entries are returned one per line (without line numbers) with a trailing `/` for subdirectories.
+- Any line longer than 2000 characters is truncated.
+- Call this tool in parallel when you know there are multiple files you want to read.
+- Avoid tiny repeated slices (30 line chunks). If you need more context, read a larger window.
+- This tool can read image files and PDFs and return them as file attachments.

package/src/tools/skill.ts

@@ -0,0 +1,49 @@
+import { createSkillTool } from '@humanlayer/agentlayer-core'
+import type { Skill } from '@humanlayer/agentlayer-core/interfaces'
+import type { Bash } from 'just-bash'
+
+function parseFrontmatterDescription(content: string): string | null {
+	const match = content.match(/^---\n([\s\S]*?)\n---/)
+	if (!match) return null
+	const fmMatch = match[1]?.match(/description:\s*(.+)/)
+	return fmMatch?.[1]?.trim() ?? null
+}
+
+function parseFirstHeading(content: string): string | null {
+	const match = content.match(/^#\s+(.+)/m)
+	return match?.[1]?.trim() ?? null
+}
+
+export async function createSkillToolFromVFS(bash: Bash, opts: { dirs: string | string[]; skills?: Skill[] }) {
+	const directories = Array.isArray(opts.dirs) ? opts.dirs : [opts.dirs]
+	const resolved: Skill[] = []
+
+	for (const dir of directories) {
+		let lsResult: { stdout: string; exitCode: number }
+		try {
+			lsResult = await bash.exec(`ls "${dir}"/*.md 2>/dev/null`)
+		} catch {
+			continue
+		}
+		if (lsResult.exitCode !== 0) continue
+
+		const files = lsResult.stdout.trim().split('\n').filter(Boolean)
+		for (const filePath of files) {
+			const catResult = await bash.exec(`cat "${filePath}"`)
+			if (catResult.exitCode !== 0) continue
+
+			const content = catResult.stdout
+			const name = filePath.split('/').pop()?.replace('.md', '') ?? filePath
+			const description = parseFrontmatterDescription(content) ?? parseFirstHeading(content) ?? name
+
+			resolved.push({ name, description, content })
+		}
+	}
+
+	const mergedMap = new Map(resolved.map((s) => [s.name, s]))
+	for (const skill of opts.skills ?? []) {
+		mergedMap.set(skill.name, skill)
+	}
+
+	return createSkillTool({ skills: [...mergedMap.values()] })
+}

package/src/tools/web-fetch.ts

@@ -0,0 +1,97 @@
+import { WebFetchTool } from '@humanlayer/agentlayer-core'
+import { WEB_FETCH_DESCRIPTION } from '@humanlayer/agentlayer-core/prompts'
+import type { Bash } from 'just-bash'
+import TurndownService from 'turndown'
+
+const MAX_RESPONSE_SIZE = 5 * 1024 * 1024 // 5MB in bytes
+const MAX_TIMEOUT_MS = 120_000
+
+/**
+ * Strip HTML tags from a string to produce plain text.
+ */
+function stripHtmlTags(html: string): string {
+	return html
+		.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+		.replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
+		.replace(/<[^>]+>/g, '')
+		.replace(/&amp;/g, '&')
+		.replace(/&lt;/g, '<')
+		.replace(/&gt;/g, '>')
+		.replace(/&quot;/g, '"')
+		.replace(/&#39;/g, "'")
+		.replace(/&nbsp;/g, ' ')
+		.replace(/\n{3,}/g, '\n\n')
+		.trim()
+}
+
+export function createWebFetchTool(bash: Bash) {
+	const turndown = new TurndownService({
+		headingStyle: 'atx',
+		codeBlockStyle: 'fenced',
+	})
+	turndown.remove(['script', 'style', 'meta', 'link', 'noscript', 'iframe'])
+
+	return WebFetchTool.define(
+		async (input) => {
+			if (!input.url.startsWith('http://') && !input.url.startsWith('https://')) {
+				throw new Error('URL must start with http:// or https://')
+			}
+
+			const timeoutSec = Math.min(input.timeout, MAX_TIMEOUT_MS) / 1000
+			const maxSizeBytes = MAX_RESPONSE_SIZE
+
+			// curl flags:
+			// -s: silent, -L: follow redirects
+			// --max-filesize: reject oversized responses
+			// --max-time: timeout
+			// -A: User-Agent
+			// -w '\n%{http_code}': append status code on last line
+			const result = await bash.exec(
+				`curl -sL --max-filesize ${maxSizeBytes} --max-time ${timeoutSec} ` +
+					`-A "Mozilla/5.0 (compatible; agent/1.0)" ` +
+					`-w '\\n%{http_code}' "${input.url}"`,
+			)
+
+			if (result.exitCode !== 0) {
+				// curl exit code 28 = timeout, 63 = file too large
+				if (result.exitCode === 28) {
+					throw new Error(`Request timed out after ${input.timeout}ms`)
+				}
+				if (result.exitCode === 63) {
+					throw new Error('Response too large (exceeds 5MB limit)')
+				}
+				throw new Error(`curl failed (exit ${result.exitCode}): ${result.stderr}`)
+			}
+
+			// Split off the status code appended by -w
+			const lines = result.stdout.split('\n')
+			const statusLine = lines[lines.length - 1]?.trim() ?? ''
+			const statusCode = Number.parseInt(statusLine, 10)
+			const body = lines.slice(0, -1).join('\n')
+
+			if (!Number.isNaN(statusCode) && statusCode >= 400) {
+				throw new Error(`Request failed with status code: ${statusCode}`)
+			}
+
+			if (input.format === 'html') {
+				return body
+			}
+
+			const isHtml = body.trimStart().startsWith('<!') || body.trimStart().toLowerCase().startsWith('<html')
+
+			if (input.format === 'text') {
+				if (isHtml) {
+					return stripHtmlTags(body)
+				}
+				return body
+			}
+
+			// format === 'markdown' (default)
+			if (isHtml) {
+				return turndown.turndown(body)
+			}
+			return body
+		},
+		{ description: WEB_FETCH_DESCRIPTION },
+	)
+}

package/src/tools/web-fetch.txt

@@ -0,0 +1,10 @@
+Fetches content from a URL and returns it in the requested format.
+
+Usage:
+- Provide a full URL starting with http:// or https://
+- The format parameter controls output: "markdown" (default) converts HTML to readable markdown, "text" strips all HTML tags, "html" returns the raw HTML
+- Default timeout is 30 seconds; maximum is 120 seconds
+- Responses larger than 5MB are rejected
+- Use markdown format for reading documentation, articles, or web pages
+- Use html format only when you need the raw HTML structure
+- Use text format when you need plain text without any markup

package/src/tools/web-search.ts

@@ -0,0 +1,59 @@
+import type { WebSearchInput, WebSearchResult } from '@humanlayer/agentlayer-core'
+import { WebSearchTool } from '@humanlayer/agentlayer-core'
+import { WEB_SEARCH_DESCRIPTION } from '@humanlayer/agentlayer-core/prompts'
+import type { Bash } from 'just-bash'
+
+const DEFAULT_TIMEOUT_SEC = 25
+
+export interface JustBashWebSearchOptions {
+	exaApiKey: string
+	timeoutSec?: number
+}
+
+export function createWebSearchTool(bash: Bash, opts: JustBashWebSearchOptions) {
+	const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC
+
+	return WebSearchTool.define(
+		async (input: WebSearchInput): Promise<WebSearchResult> => {
+			const payload = JSON.stringify({
+				query: input.query,
+				numResults: input.numResults,
+				contents: { text: { maxCharacters: 500 } },
+			})
+
+			// Escape single quotes in payload for shell safety
+			const escapedPayload = payload.replace(/'/g, "'\\''")
+
+			const result = await bash.exec(
+				`curl -s --max-time ${timeoutSec} ` +
+					`-H "Content-Type: application/json" ` +
+					`-H "x-api-key: ${opts.exaApiKey}" ` +
+					`-d '${escapedPayload}' ` +
+					`https://api.exa.ai/search`,
+			)
+
+			if (result.exitCode !== 0) {
+				if (result.exitCode === 28) {
+					throw new Error('Search request timed out')
+				}
+				throw new Error(`curl failed (exit ${result.exitCode}): ${result.stderr}`)
+			}
+
+			let data: { results?: Array<{ title?: string; url?: string; text?: string; snippet?: string }> }
+			try {
+				data = JSON.parse(result.stdout)
+			} catch {
+				throw new Error(`Failed to parse search response: ${result.stdout.slice(0, 200)}`)
+			}
+
+			const results = (data.results ?? []).map((r) => ({
+				title: r.title ?? '',
+				url: r.url ?? '',
+				snippet: r.text ?? r.snippet ?? '',
+			}))
+
+			return { results }
+		},
+		{ description: WEB_SEARCH_DESCRIPTION },
+	)
+}

package/src/tools/write.ts

@@ -0,0 +1,26 @@
+import { WriteTool } from '@humanlayer/agentlayer-core'
+import { WRITE_DESCRIPTION } from '@humanlayer/agentlayer-core/prompts'
+import type { Bash } from 'just-bash'
+
+export function createWriteTool(bash: Bash) {
+	return WriteTool.define(
+		async (input) => {
+			// Ensure parent directory exists
+			const dirResult = await bash.exec(`mkdir -p "$(dirname "${input.file_path}")"`)
+			if (dirResult.exitCode !== 0) {
+				throw new Error(`Failed to create parent directory for ${input.file_path}: ${dirResult.stderr}`)
+			}
+
+			// Write content using a heredoc to handle special characters safely
+			// We use a unique delimiter to avoid conflicts with content
+			const DELIM = 'WRITEOF_8f3a2b1c'
+			const writeResult = await bash.exec(`cat > "${input.file_path}" <<'${DELIM}'\n${input.content}\n${DELIM}`)
+			if (writeResult.exitCode !== 0) {
+				throw new Error(`Failed to write file ${input.file_path}: ${writeResult.stderr}`)
+			}
+
+			return `Successfully wrote to ${input.file_path}`
+		},
+		{ description: WRITE_DESCRIPTION },
+	)
+}

package/src/tools/write.txt

@@ -0,0 +1,8 @@
+Writes a file to the local filesystem.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.