@alumbwe/anvil 1.0.20 → 1.0.21

package/vendor/@anvil/common/src/util/file-read-limits.ts

@@ -0,0 +1,236 @@
+import { FILE_READ_STATUS } from '../constants/paths'
+
+import type { FileReadWindow } from '../types/contracts/client'
+
+/** Maximum source characters returned by one read_files tool call. */
+export const MAX_READ_FILES_CHARS = 100_000
+
+/** Maximum estimated tokens returned by one read_files tool call. */
+export const MAX_READ_FILES_TOKENS = 20_000
+
+/** Maximum lines returned per file in one read_files tool call. */
+export const MAX_READ_FILE_LINES = 2_000
+
+/** Maximum characters returned per file in one read_files tool call. */
+export const MAX_READ_FILE_CHARS = 50_000
+
+export function windowFileRead(
+  content: string,
+  offset?: number,
+  limit?: number,
+): string {
+  const lines = content.split('\n')
+  if (lines.length > 1 && lines[lines.length - 1] === '') lines.pop()
+  const totalLines = lines.length
+  const start = Math.max(1, Math.floor(offset ?? 1))
+  const maxLines = Math.min(
+    Math.max(1, Math.floor(limit ?? MAX_READ_FILE_LINES)),
+    MAX_READ_FILE_LINES,
+  )
+
+  if (start > totalLines) {
+    return `[read_files: ${totalLines} lines total; offset ${start} is beyond the end of the file.]`
+  }
+
+  let end = Math.min(totalLines, start - 1 + maxLines)
+  let selected = lines.slice(start - 1, end).join('\n')
+  let charCapped = false
+  if (selected.length > MAX_READ_FILE_CHARS) {
+    charCapped = true
+    let chars = 0
+    let count = 0
+    for (let i = start - 1; i < end; i++) {
+      const lineLength = lines[i].length + (count > 0 ? 1 : 0)
+      if (chars + lineLength > MAX_READ_FILE_CHARS && count > 0) break
+      chars += lineLength
+      count++
+    }
+    end = start - 1 + count
+    selected = lines.slice(start - 1, end).join('\n')
+  }
+
+  if (start === 1 && end === totalLines) {
+    return content
+  }
+
+  const charCapNote = charCapped
+    ? ` The window was shortened to stay under ${MAX_READ_FILE_CHARS.toLocaleString()} characters.`
+    : ''
+  const continueNote =
+    end < totalLines
+      ? ` Use code_search to locate the part you need and read a window around it, or call read_files again with offset=${end + 1} to continue.`
+      : ''
+  return `${selected}\n\n[read_files: showing lines ${start}-${end} of ${totalLines}.${charCapNote}${continueNote}]`
+}
+
+export type FileReadWindows = Record<string, FileReadWindow[]>
+
+/**
+ * Read the line windows a `windowedFileReads` agent forwarded with a read_files
+ * call, if any. Absent for every other agent, and that absence is what keeps
+ * the legacy whole-file behavior.
+ *
+ * Hosted surfaces (Anvil Web/Cloud on Daytona, and the browser runtime) run
+ * read_files through their own override rather than the SDK's local reader, so
+ * each has to pick the windows out of the tool input itself.
+ */
+export function fileReadWindowsOf(input: unknown): FileReadWindows | undefined {
+  const windows =
+    input && typeof input === 'object'
+      ? (input as { fileWindows?: unknown }).fileWindows
+      : undefined
+  return windows && typeof windows === 'object' && !Array.isArray(windows)
+    ? (windows as FileReadWindows)
+    : undefined
+}
+
+/**
+ * Apply one file's windows to its content.
+ *
+ * Call this BEFORE the read budget (`createFileReadLimiter`), the order the
+ * SDK's local reader uses. The other way round, an offset past the budget's
+ * truncation point answers "beyond the end of the file" for a file that has
+ * those lines.
+ *
+ * A path with no explicit window still goes through `windowFileRead`, which is
+ * where the per-file 2,000-line cap comes from — that cap, more than the
+ * explicit offsets, is what a windowed agent saves on a large file.
+ */
+export function applyFileReadWindows(
+  content: string,
+  windows: FileReadWindow[] | undefined,
+): string {
+  // `Array.isArray`, not a truthiness check on `.length`: callers look these up
+  // by a model-supplied path in a map that lost its null prototype crossing the
+  // wire as JSON, so `windows` can be `Function.prototype` for a file named
+  // `constructor` — truthy, with a `.length` of 1 and no `.map`.
+  const list = Array.isArray(windows) && windows.length > 0 ? windows : [{}]
+  return list
+    .map((window) => windowFileRead(content, window?.offset, window?.limit))
+    .join('\n\n')
+}
+
+/** Small chunks avoid pathological BPE runtimes on repetitive Unicode. */
+const TOKEN_CHUNK_CHARS = 1_024
+
+type LimitedFileRead = {
+  content: string
+  includedChars: number
+  includedTokens: number
+}
+
+type FileReadLimiterOptions = {
+  /** A conservative local token estimator, including any desired safety factor. */
+  countTokens?: (text: string) => number
+}
+
+function avoidSplittingSurrogatePair(text: string, end: number): number {
+  if (
+    end > 0 &&
+    end < text.length &&
+    text.charCodeAt(end - 1) >= 0xd800 &&
+    text.charCodeAt(end - 1) <= 0xdbff
+  ) {
+    return end - 1
+  }
+  return end
+}
+
+function limitContentByTokens(
+  content: string,
+  tokenBudget: number,
+  countTokens: (text: string) => number,
+): { chars: number; tokens: number; truncated: boolean } {
+  let chars = 0
+  let tokens = 0
+
+  while (chars < content.length) {
+    let chunkEnd = Math.min(chars + TOKEN_CHUNK_CHARS, content.length)
+    chunkEnd = avoidSplittingSurrogatePair(content, chunkEnd)
+    if (chunkEnd === chars) chunkEnd++
+
+    const chunk = content.slice(chars, chunkEnd)
+    const chunkTokens = countTokens(chunk)
+    if (tokens + chunkTokens <= tokenBudget) {
+      chars = chunkEnd
+      tokens += chunkTokens
+      continue
+    }
+    // Keep only complete, independently verified chunks. This can leave less
+    // than one chunk of budget unused, but avoids costly exact-prefix fitting.
+    return { chars, tokens, truncated: true }
+  }
+
+  return { chars, tokens, truncated: false }
+}
+
+function limitFileReadContent(
+  content: string,
+  remainingChars: number,
+  remainingTokens: number,
+  countTokens?: (text: string) => number,
+): LimitedFileRead {
+  const charLimit = Math.min(content.length, Math.max(0, remainingChars))
+  const safeCharLimit = avoidSplittingSurrogatePair(content, charLimit)
+  const charLimitedContent = content.slice(0, safeCharLimit)
+  const tokenBudget = Math.max(0, remainingTokens)
+  const tokenLimit = countTokens
+    ? limitContentByTokens(charLimitedContent, tokenBudget, countTokens)
+    : {
+        chars: charLimitedContent.length,
+        tokens: 0,
+        truncated: false,
+      }
+  const includedChars = tokenLimit.chars
+  const includedTokens = tokenLimit.tokens
+
+  if (includedChars === content.length) {
+    return { content, includedChars, includedTokens }
+  }
+
+  let notice: string
+  if (tokenLimit.truncated) {
+    const hitAggregateLimit = remainingTokens < MAX_READ_FILES_TOKENS
+    notice = hitAggregateLimit
+      ? `${FILE_READ_STATUS.TOO_LARGE}: The combined read_files output exceeded the ${MAX_READ_FILES_TOKENS.toLocaleString()} estimated-token limit. This file was truncated after ${includedTokens.toLocaleString()} estimated tokens. Read it separately or use code_search for the relevant section.`
+      : `${FILE_READ_STATUS.TOO_LARGE}: This file exceeded the ${MAX_READ_FILES_TOKENS.toLocaleString()} estimated-token per-file limit. It was truncated after ${includedTokens.toLocaleString()} estimated tokens. Use code_search or a more targeted read for the relevant section.`
+  } else {
+    const hitAggregateLimit = remainingChars < MAX_READ_FILES_CHARS
+    notice = hitAggregateLimit
+      ? `${FILE_READ_STATUS.TOO_LARGE}: The combined read_files output exceeded the ${MAX_READ_FILES_CHARS.toLocaleString()} character hard limit. This file was truncated after ${includedChars.toLocaleString()} characters. Read it separately or use code_search for the relevant section.`
+      : `${FILE_READ_STATUS.TOO_LARGE}: This file is ${content.length.toLocaleString()} characters, exceeding the ${MAX_READ_FILES_CHARS.toLocaleString()} character hard limit. The content above has been truncated. Use code_search or a more targeted read for the relevant section.`
+  }
+
+  return {
+    content:
+      includedChars === 0
+        ? notice
+        : `${content.slice(0, includedChars)}\n\n${notice}`,
+    includedChars,
+    includedTokens,
+  }
+}
+
+/**
+ * Creates an ordered limiter for one read_files invocation. Status/error
+ * messages should bypass this limiter so they do not consume the content
+ * budget.
+ */
+export function createFileReadLimiter(options: FileReadLimiterOptions = {}) {
+  let remainingChars = MAX_READ_FILES_CHARS
+  let remainingTokens = MAX_READ_FILES_TOKENS
+
+  return {
+    limit(content: string): string {
+      const limited = limitFileReadContent(
+        content,
+        remainingChars,
+        remainingTokens,
+        options.countTokens,
+      )
+      remainingChars -= limited.includedChars
+      remainingTokens -= limited.includedTokens
+      return limited.content
+    },
+  }
+}

package/vendor/@anvil/common/src/util/file.ts

@@ -0,0 +1,339 @@
+import * as os from 'os'
+import * as path from 'path'
+
+import { z } from 'zod/v4'
+
+import type { AnvilFileSystem } from '../types/filesystem'
+import type { SkillsMap } from '../types/skill'
+
+export const FileTreeNodeSchema: z.ZodType<FileTreeNode> = z.object({
+  name: z.string(),
+  type: z.enum(['file', 'directory']),
+  children: z.lazy(() => z.array(FileTreeNodeSchema).optional()),
+  filePath: z.string(),
+})
+
+export interface FileTreeNode {
+  name: string
+  type: 'file' | 'directory'
+  filePath: string
+  lastReadTime?: number
+  children?: FileTreeNode[]
+}
+
+export interface DirectoryNode extends FileTreeNode {
+  type: 'directory'
+  children: FileTreeNode[]
+}
+
+export interface FileNode extends FileTreeNode {
+  type: 'file'
+  lastReadTime: number
+}
+
+export const FileVersionSchema = z.object({
+  path: z.string(),
+  content: z.string(),
+})
+
+export type FileVersion = z.infer<typeof FileVersionSchema>
+
+export const customToolDefinitionsSchema = z
+  .record(
+    z.string(),
+    z.object({
+      // inputSchema can be a Zod schema (from MCP tools) or a JSON Schema object
+      // (from SDK custom tools that have been serialized). The agent-runtime
+      // converts JSON schemas to Zod using ensureZodSchema() before use.
+      inputSchema: z.custom<z.ZodType | Record<string, unknown>>(),
+      endsAgentStep: z.boolean().optional().default(false),
+      description: z.string().optional(),
+      exampleInputs: z.record(z.string(), z.any()).array().optional(),
+    }),
+  )
+  .default(() => ({}))
+export type CustomToolDefinitions = NonNullable<
+  z.input<typeof customToolDefinitionsSchema>
+>
+
+export const ProjectFileContextSchema = z.object({
+  projectRoot: z.string(),
+  cwd: z.string(),
+  fileTree: z.array(z.custom<FileTreeNode>()),
+  fileTokenScores: z.record(z.string(), z.record(z.string(), z.number())),
+  tokenCallers: z
+    .record(z.string(), z.record(z.string(), z.array(z.string())))
+    .optional(),
+  knowledgeFiles: z.record(z.string(), z.string()),
+  userKnowledgeFiles: z.record(z.string(), z.string()).optional(),
+  agentTemplates: z.record(z.string(), z.any()).default(() => ({})),
+  customToolDefinitions: customToolDefinitionsSchema,
+  skills: z.record(z.string(), z.any()).optional(),
+  gitChanges: z.object({
+    status: z.string(),
+    diff: z.string(),
+    diffCached: z.string(),
+    lastCommitMessages: z.string(),
+  }),
+  changesSinceLastChat: z.record(z.string(), z.string()),
+  shellConfigFiles: z.record(z.string(), z.string()),
+  systemInfo: z.object({
+    platform: z.string(),
+    shell: z.string(),
+    nodeVersion: z.string(),
+    arch: z.string(),
+    homedir: z.string(),
+    cpus: z.number(),
+    chromeAvailable: z.boolean(),
+  }),
+})
+
+export type ProjectFileContext = {
+  projectRoot: string
+  cwd: string
+  fileTree: FileTreeNode[]
+  fileTokenScores: Record<string, Record<string, number>>
+  tokenCallers?: Record<string, Record<string, string[]>>
+  knowledgeFiles: Record<string, string>
+  userKnowledgeFiles?: Record<string, string>
+  agentTemplates: Record<string, any>
+  customToolDefinitions: CustomToolDefinitions
+  skills?: SkillsMap
+  gitChanges: {
+    status: string
+    diff: string
+    diffCached: string
+    lastCommitMessages: string
+  }
+  changesSinceLastChat: Record<string, string>
+  shellConfigFiles: Record<string, string>
+  systemInfo: {
+    platform: string
+    shell: string
+    nodeVersion: string
+    arch: string
+    homedir: string
+    cpus: number
+    chromeAvailable: boolean
+  }
+}
+
+export const fileRegex =
+  /<write_file>\s*<path>([^<]+)<\/path>\s*<content>([\s\S]*?)<\/content>\s*<\/write_file>/g
+export const fileWithNoPathRegex = /<write_file>([\s\S]*?)<\/write_file>/g
+
+export const parseFileBlocks = (fileBlocks: string) => {
+  let fileMatch
+  const files: Record<string, string> = {}
+  while ((fileMatch = fileRegex.exec(fileBlocks)) !== null) {
+    const [, filePath, fileContent] = fileMatch
+    files[filePath] = fileContent.startsWith('\n')
+      ? fileContent.slice(1)
+      : fileContent
+  }
+  return files
+}
+
+export const getStubProjectFileContext = (): ProjectFileContext => ({
+  projectRoot: '',
+  cwd: '',
+  fileTree: [],
+  fileTokenScores: {},
+  knowledgeFiles: {},
+  userKnowledgeFiles: {},
+  agentTemplates: {},
+  customToolDefinitions: {},
+  skills: {},
+  gitChanges: {
+    status: '',
+    diff: '',
+    diffCached: '',
+    lastCommitMessages: '',
+  },
+  changesSinceLastChat: {},
+  shellConfigFiles: {},
+  systemInfo: {
+    platform: '',
+    shell: '',
+    nodeVersion: '',
+    arch: '',
+    homedir: '',
+    cpus: 0,
+    chromeAvailable: false,
+  },
+})
+
+export const createMarkdownFileBlock = (filePath: string, content: string) => {
+  return `\`\`\`${filePath}\n${content}\n\`\`\``
+}
+
+export const parseMarkdownCodeBlock = (content: string) => {
+  const match = content.match(/^```(?:[a-zA-Z]+)?\n([\s\S]*)\n```$/)
+  if (match) {
+    return match[1] + '\n'
+  }
+  return content
+}
+
+export const createSearchReplaceBlock = (search: string, replace: string) => {
+  return `<<<<<<< SEARCH\n${search}\n=======\n${replace}\n>>>>>>> REPLACE`
+}
+
+export function printFileTree(
+  nodes: FileTreeNode[],
+  depth: number = 0,
+): string {
+  let result = ''
+  const indentation = ' '.repeat(depth)
+  for (const node of nodes) {
+    result += `${indentation}${node.name}${node.type === 'directory' ? '/' : ''}\n`
+    if (node.type === 'directory' && node.children) {
+      result += printFileTree(node.children, depth + 1)
+    }
+  }
+  return result
+}
+
+export function printFileTreeWithTokens(
+  nodes: FileTreeNode[],
+  fileTokenScores: Record<string, Record<string, number>>,
+  path: string[] = [],
+): string {
+  let result = ''
+  const depth = path.length
+  const indentToken = ' '
+  const indentation = indentToken.repeat(depth)
+  const indentationWithFile = indentToken.repeat(depth + 1)
+  for (const node of nodes) {
+    if (
+      node.type === 'directory' &&
+      (!node.children || node.children.length === 0)
+    ) {
+      // Skip empty directories
+      continue
+    }
+    result += `${indentation}${node.name}${node.type === 'directory' ? '/' : ''}`
+    path.push(node.name)
+    const filePath = path.join('/')
+    const tokenScores = fileTokenScores[filePath]
+    if (node.type === 'file' && tokenScores) {
+      const tokens = Object.keys(tokenScores)
+      if (tokens.length > 0) {
+        result += `\n${indentationWithFile}${tokens.join(' ')}`
+      }
+    }
+    result += '\n'
+    if (node.type === 'directory' && node.children) {
+      result += printFileTreeWithTokens(node.children, fileTokenScores, path)
+    }
+    path.pop()
+  }
+  return result
+}
+
+/**
+ * Ensures the given file contents ends with a newline character.
+ * @param contents - The file contents
+ * @returns the file contents with a newline character.
+ */
+export const ensureEndsWithNewline = (
+  contents: string | null,
+): string | null => {
+  if (contents === null || contents === '') {
+    // Leave empty file as is
+    return contents
+  }
+  if (contents.endsWith('\n')) {
+    return contents
+  }
+  return contents + '\n'
+}
+
+/**
+ * Node-compatible file existence check.
+ * Uses fs.stat instead of Bun-specific fs.exists.
+ */
+export async function fileExists(params: {
+  filePath: string
+  fs: AnvilFileSystem
+}): Promise<boolean> {
+  const { filePath, fs } = params
+
+  try {
+    await fs.stat(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export const ensureDirectoryExists = async (params: {
+  baseDir: string
+  fs: AnvilFileSystem
+}) => {
+  const { baseDir, fs } = params
+
+  const baseDirExists = await fileExists({ filePath: baseDir, fs })
+  if (!baseDirExists) {
+    await fs.mkdir(baseDir, { recursive: true })
+  }
+}
+
+/**
+ * Removes markdown code block syntax if present, including any language tag
+ */
+export const cleanMarkdownCodeBlock = (content: string): string => {
+  const cleanResponse = content.match(/^```(?:[a-zA-Z]+)?\n([\s\S]*)\n```$/)
+    ? content.replace(/^```(?:[a-zA-Z]+)?\n/, '').replace(/\n```$/, '')
+    : content
+  return cleanResponse
+}
+
+export function isValidFilePath(path: string) {
+  if (!path) return false
+
+  // Check for whitespace
+  if (/\s/.test(path)) return false
+
+  // Check for invalid characters
+  const invalidChars = /[<>:"|?*\x00-\x1F]/g
+  if (invalidChars.test(path)) return false
+
+  return true
+}
+
+export async function isDir(params: {
+  path: string
+  fs: AnvilFileSystem
+}): Promise<boolean> {
+  const { path, fs } = params
+
+  try {
+    const stats = await fs.stat(path)
+    return stats.isDirectory()
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Returns true if the `toPath` is a subdirectory of `fromPath`.
+ */
+export function isSubdir(fromPath: string, toPath: string) {
+  const resolvedFrom = path.resolve(fromPath)
+  const resolvedTo = path.resolve(toPath)
+
+  if (process.platform === 'win32') {
+    const fromDrive = path.parse(resolvedFrom).root.toLowerCase()
+    const toDrive = path.parse(resolvedTo).root.toLowerCase()
+    if (fromDrive !== toDrive) {
+      return false
+    }
+  }
+
+  return !path.relative(resolvedFrom, resolvedTo).startsWith('..')
+}
+
+export function isValidProjectRoot(dir: string): boolean {
+  return !isSubdir(dir, os.homedir())
+}

package/vendor/@anvil/common/src/util/format-code-search.ts

@@ -0,0 +1,115 @@
+/**
+ * Formats code search output to group matches by file.
+ *
+ * Input format: ./file.ts:line:content
+ * Output format:
+ * Found 3 matches
+ * ./file.ts:
+ *   Line 1: content
+ *   Line 2: another line content
+ *   Line 3: yet another line content
+ *
+ * (double newline between distinct files)
+ *
+ * @param stdout The raw stdout from ripgrep
+ * @param options.matchCount The number of actual matches, excluding context lines
+ * @returns Formatted output with matches grouped by file
+ */
+export function formatCodeSearchOutput(
+  stdout: string,
+  options: { matchCount?: number } = {},
+): string {
+  if (!stdout) {
+    return 'Found 0 matches'
+  }
+  const lines = stdout.split('\n')
+  const formatted: string[] = [
+    `Found ${options.matchCount ?? countFormattedMatches(lines)} matches`,
+  ]
+  let currentFile: string | null = null
+
+  for (const line of lines) {
+    if (!line.trim()) {
+      formatted.push(line)
+      continue
+    }
+
+    // Skip separator lines between result groups
+    if (line === '--') {
+      continue
+    }
+
+    // Ripgrep output format:
+    // - Match lines: filename:line_number:content
+    // - Context lines (with -A/-B/-C flags): filename-line_number-content
+
+    // Use regex to find the pattern: separator + digits + separator
+    // This handles filenames with hyphens/colons by matching the line number pattern
+    const parsedLine = parseRipgrepLine(line)
+
+    if (!parsedLine) {
+      formatted.push(line)
+      continue
+    }
+    const { filePath, lineNumber, content } = parsedLine
+
+    // Check if this is a new file (file paths don't start with whitespace)
+    if (filePath && !filePath.startsWith(' ') && !filePath.startsWith('\t')) {
+      if (filePath !== currentFile) {
+        // New file - add double newline before it (except for the first file)
+        if (currentFile !== null) {
+          formatted.push('')
+        }
+        currentFile = filePath
+        // Show file path with colon on its own line
+        formatted.push(filePath + ':')
+        formatted.push(`  Line ${lineNumber}: ${content}`)
+      } else {
+        formatted.push(`  Line ${lineNumber}: ${content}`)
+      }
+    } else {
+      // Line doesn't match expected format, keep as-is
+      formatted.push(line)
+    }
+  }
+
+  return formatted.join('\n')
+}
+
+function parseRipgrepLine(line: string): {
+  filePath: string
+  lineNumber: string
+  content: string
+  isContext: boolean
+} | null {
+  // Try match line pattern: filename:digits:content
+  const matchLineMatch = line.match(/(.*?):(\d+):(.*)$/)
+  if (matchLineMatch) {
+    return {
+      filePath: matchLineMatch[1],
+      lineNumber: matchLineMatch[2],
+      content: matchLineMatch[3],
+      isContext: false,
+    }
+  }
+
+  // Try context line pattern: filename-digits-content
+  const contextLineMatch = line.match(/(.*?)-(\d+)-(.*)$/)
+  if (contextLineMatch) {
+    return {
+      filePath: contextLineMatch[1],
+      lineNumber: contextLineMatch[2],
+      content: contextLineMatch[3],
+      isContext: true,
+    }
+  }
+
+  return null
+}
+
+function countFormattedMatches(lines: string[]): number {
+  return lines.filter((line) => {
+    const parsedLine = parseRipgrepLine(line)
+    return parsedLine && !parsedLine.isContext
+  }).length
+}