sjEe UdZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z ddl m Z mZddlmZmZmZmZmZddlmZddlmZddlmZmZmZmZeej Z!ee!Z"ee!Z#ej$d Z%ej$d Z&d ed efd Z'ded eefdZ(d eded efdZ)dZ*d ed e+ee,ffdZ-d eed e,fdZ.ded e,fdZ/e GddZ0e GddZ1e GddZ2e GddZ3e Gdd Z4e Gd!d"Z5e Gd#d$Z6ej$d%Z7d&e6d e+eeeffd'Z8d(ed e+eeffd)Z9ej$d*Z:d+ed e+ee;efdzfd,Zd.<de?d efd/Z@dee?d0e;d efd1ZAGd2d3e ZBhd4ZCd5d6d7d8d9d:ZDeEhd;ZFdd?ZGd@ed(ed e,fdAZHdBed e+e,effdCZIdBed e+e,effdDZJdBed e+e,effdEZKdBed e+e,effdFZLeLeIeJeJeKdGZMeEhdHZNdIZOdIZPdJZQdKZRdIZSdZTdLZUdMZVdNedOe;d e;fdPZWeReSfdQedRed e+e;e;ffdSZXeTeUfdQedRed e+e;e;ffdTZYej$dUZZdVed e,fdWZ[dXeed e,fdYZ\d&e4dVed e4fdZZ]Gd[d\eBZ^dS)]a\ File Operations Module Provides file manipulation capabilities (read, write, patch, search) that work across all terminal backends (local, docker, ssh, singularity, modal, daytona, vercel_sandbox). The key insight is that all file operations can be expressed as shell commands, so we wrap the terminal backend's execute() interface to provide a unified file API. Usage: from tools.file_operations import ShellFileOperations from tools.terminal_tool import _active_environments # Get file operations for a terminal environment file_ops = ShellFileOperations(terminal_env) # Read a file result = file_ops.read_file("/path/to/file.py") # Write a file result = file_ops.write_file("/path/to/new.py", "print('hello')") # Search for content result = file_ops.search("TODO", path=".", file_glob="*.py") N)ABCabstractmethod) dataclassfield)OptionalListDictAnyClassVar)Path)BINARY_EXTENSIONS)build_write_denied_pathsbuild_write_denied_prefixesget_write_denied_erroris_write_deniedz!\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)z+'?\x07?__HERMES_FENCE_[A-Za-z0-9]+__\x07?'?textreturnct|s|Sg}|dD]}d|vpd|v}td|}td|}|dd}|r|ddkrr||d|S)z;Strip leaked terminal fence wrappers from file read output.Tkeepends__HERMES_FENCE_z]z' ) splitlines_OSC_SEQUENCE_REsub_FENCE_MARKER_REreplacestripappendjoin)r cleaned_lineslinehad_terminal_wrappercleaneds 9/home/agent/.hermes/hermes-agent/tools/file_operations.py_strip_terminal_fence_leaksr'As  !M..&&0D8KGtO"&&r400"&&r733//&"--  GMM*$=$=$C$C W%%%% 77= ! !!samplec:|sdS|dd}d|vrdSd|vrdSdS)u"Return the dominant line ending in ``sample`` or None if undetermined. Looks at the first few line breaks and picks ``\r\n`` if any are present (Windows / DOS), otherwise ``\n`` (Unix). Returns ``None`` for empty / single-line content where we can't tell. Used to preserve the file's original line endings across write_file and patch operations — without this the agent's bare-LF tool args silently normalize Windows-line-ending files, and patch produces mixed endings when only a substituted region changes. Ni  )r)heads r&_detect_line_endingr/Rs? t %4%=D ~~v t||t 4r(targetc|dddd}|dkr|S|dkr|ddS|S)a5Convert all line endings in ``text`` to ``target`` (``\n`` or ``\r\n``). Idempotent: ``_normalize_line_endings(_normalize_line_endings(x, "\r\n"), "\r\n") == _normalize_line_endings(x, "\r\n")``. Strips lone ``\r`` characters as well, so mixed-ending content is homogenized in a single pass. r+r, )r)rr0 lf_normalizeds r&_normalize_line_endingsr4hs\LL..66tTBBM ~~ $$T6222 Kr(uc~|r8|tr|ttddfS|dfS)zReturn (text-without-leading-BOM, had_bom). Only a single leading BOM is stripped; a BOM appearing mid-content is left alone (it's legitimate data there, not a file marker). NTF) startswith _UTF8_BOMlenrs r& _strip_bomr:sC  + **+C NNOO$d** ;r(cTt|o|tS)z)True if ``text`` begins with a UTF-8 BOM.)boolr6r7r9s r&_has_bomr=s :: 4$//)444r(pathc t|S)z.Return True if path is on the write deny list.)_shared_is_write_deniedr>s r&_is_write_deniedrBs "4 ( ((r(c$eZdZUdZdZeed<dZeed<dZ eed<dZ e ed<d Z e eed <dZe ed <dZe ed <d Ze eed <d Ze eed<d Ze eed<d Ze eed<eeZeeed<defdZd S) ReadResultzResult from reading a file.rcontentr total_lines file_sizeF truncatedNhint is_binaryis_imagebase64_content mime_type dimensionserrordefault_factory similar_filesrcHd|jDS)Nc*i|]\}}||gk ||SNr-.0kvs r& z&ReadResult.to_dict..s(TTTA!-AQSGG1GGGr(__dict__itemsselfs r&to_dictzReadResult.to_dicts$TT!4!4!6!6TTTTr()__name__ __module__ __qualname____doc__rEstr__annotations__rFintrGrHr<rIrrJrKrLrMrNrOrlistrRrdictr`r-r(r&rDrDs#%%GSKIsItD(3-ItHd$(NHSM(((#Ix}### $J $$$E8C=$uT:::M49:::UUUUUUUr(rDceZdZUdZdZeed<dZeed<dZ e eed<dZ e e e efed<dZe e ed <dZe e ed <dZe e ed <d efd ZdS) WriteResultzResult from writing a file.r bytes_writtenF dirs_createdNverifiedlintlsp_diagnosticsrOwarningrcHd|jDS)Nci|] \}}||| SrUr-rVs r&rZz'WriteResult.to_dict..sHHHA!-1---r(r[r^s r&r`zWriteResult.to_dicts$HH!4!4!6!6HHHHr()rarbrcrdrlrgrfrmr<rnrror rer rprOrqrir`r-r(r&rkrks%%M3L$ $Hhtn###%)D(4S> ")))&*OXc])))E8C=!GXc]!!!IIIIIIIr(rkcLeZdZUdZdZeed<dZeed<e e Z e eed<e e Z e eed<e e Ze eed <d Zeeeefed <d Zeeed <d Zeeed <dZeed<d Zeeed<defdZd S) PatchResultzResult from patching a file.FsuccessrdiffrPfiles_modified files_created files_deletedNrorprO no_changenoterc@d|ji}|jrd|d<|jr |j|d<|jr |j|d<|jr |j|d<|jr |j|d<|jr |j|d<|jr |j|d <|jr |j|d <|j r |j |d <|S) NrvTr{r|rwrxryrzrorprO) rvr{r|rwrxryrzrorprOr_results r&r`zPatchResult.to_dicts"+T\!: > '"&F;  9 '!YF6N 9 '!YF6N   ;'+':F# $   9&*&8F? #   9&*&8F? # 9 '!YF6N   =(,( ")))%)OXc])))E8C=ItD(3-r(ruc@eZdZUdZeed<eed<eed<dZeed<dS) SearchMatchzA single search match.r> line_numberrEgmtimeN) rarbrcrdrerfrgrfloatr-r(r&rrsF  III LLLE5r(rcPeZdZUdZeeZeee d<eeZ ee e d<ee Z ee efe d<dZee d<dZee d <d Zee e d <d Zee e d <d Zee e d <dZeee d<dee fdZddede fdZd S) SearchResultzResult from searching.rPmatchesfilescountsr total_countFrHN limit_reasonrqrO_DENSIFY_MIN_MATCHESrcLt|j|jkrdSg}d}|jD]e}|j|kr!||j|j}|d|jd|jfd|S)uKRender content-mode matches as a compact, path-grouped text block. The verbose form repeats the ``{"path","line","content"}`` keys and the full path string for every match. This groups consecutive matches by path (path printed once, then `` : `` rows), which is lossless — every path, line number, and content byte is preserved — and readable by the model without any decode step. Returns ``None`` when densification is not worthwhile (too few matches), so the caller falls back to the verbose array. Nz : r,) r8rrr>r rrErstripr!)r_lines current_pathms r&_densify_matcheszSearchResult._densify_matchess t|  t8 8 84&*  E EAv%% QV$$$ v  LLCamCCqy/?/?/A/ACC D D D Dyyr(densifycZd|ji}|jr9|r|nd}| d|d<||d<nd|jD|d<|jr |j|d<|jr |j|d<|jrd |d <|jr |j|d <|jr |j|d <|jr |j|d <|S)Nrztpath-grouped: each file path on its own line, followed by indented ': ' rows for matches in that filematches_format matches_textc8g|]}|j|j|jdS))r>r#rEr>rrE)rWrs r& z(SearchResult.to_dict..:s8%%%VQ]qyQQ%%%r(rrrTrHrrqrO) rrrrrrHrrqrO)r_rrdenses r&r`zSearchResult.to_dict-s%2D4D$E < /6@D))+++DE Q'(*/~&&%%!\%%%y! : )"jF7O ; +#{F8  > '"&F;    7%)%6F> " < - $ F9  : )"jF7O r(F)rarbrcrdrrhrrrrfrrerirr rgrrHr<rrrqrOrr rr`r-r(r&rrs=  !&t!-`` segments. Prefer the rightmost numeric separator so a path like ``dir/file-12-name.py-8-context`` resolves to ``dir/file-12-name.py`` line ``8`` instead of truncating at ``file``. rNz-(\d+)-)refinditerstartrggroupend)r#r candidater>s r&_parse_search_context_liners 44<<t E[T22  }t  D t U[[^^$$d599;;<<&8 88r())sPNG  zPNG image data)szJPEG image data)sGIF87aGIF image data)sGIF89ar)sRIFFz$RIFF container (WAV/AVI/WebP family))s%PDF-z PDF document)sPKz$ZIP archive (also docx/xlsx/jar/apk))sPKzZIP archive (empty))szgzip compressed data)sBZhzbzip2 compressed data)s7zXZzxz compressed data)s7z'z 7-Zip archive)sELFzELF executable)sMZzWindows PE executable)szMach-O executable (64-bit))sz$Mach-O universal binary / Java class)sSQLite format 3zSQLite database)sOggSz Ogg container)sfLaCz FLAC audio)sID3zMP3 audio (ID3 tag))sz$ISO media container (MP4/MOV family))sBMzBMP image data)sII*zTIFF image data (little-endian))sMM*zTIFF image data (big-endian)_MAGIC_SIGNATURESc|sdStD]B\}}||r(|dr|dddkr>|cSCdS)a%Best-effort human name for binary content from its magic bytes. Returns e.g. ``"PNG image data"`` or ``"unknown binary"``. Never raises. The ISO-media entry additionally checks for ``ftyp`` at offset 4, since the leading size field alone (three NULs) is too weak a signature. zunknown binaryz ISO mediasftyp)rr6)r)prefixnames r&identify_binary_bytesrsz  )    V $ $ {++ qs w0F0FKKK   r(rGct|pd}|dkr |dz dd}n|dkr |dz dd}n|d}d|d |d S) a One-line answer for the binary-file refusal. Naming the dead end: "Binary file" alone sends the model hunting for 'appropriate tools' that may not exist in its toolset. Naming the TYPE ("PNG image data, 4.1 KB") answers what-is-this in a single read. r(iz.1fz MBiz KBz bytesz Binary file (, u) — cannot display as text.)r)r)rGkindsizes r&describe_binary_filers !3 / /DK{+4444 d  d"++++### F4 F F4 F F FFr(ceZdZdZed&dedededefdZededefd Z d'ded e edefd Z e d'ded ede ede fdZ e d(dededededef dZededefdZedede fdZd(dedede fdZededede fdZe d)d eded!ed"e ededed#ed$edefd%Zd S)*FileOperationsz@Abstract interface for file operations across terminal backends.rr>offsetlimitrcdS)z$Read a file with pagination support.Nr-)r_r>rrs r& read_filezFileOperations.read_file  r(cdS)a Read the complete file content as a plain string. No pagination, no line-number prefixes, no per-line truncation. Returns ReadResult with .content = full file text, .error set on failure. Always reads to EOF regardless of file size. Nr-r_r>s r& read_file_rawzFileOperations.read_file_raw s  r(N max_bytesc"tdS)zCRead complete binary content as base64 across the backend boundary.z1Binary reads are not implemented for this backendrOrD)r_r>rs r&read_file_byteszFileOperations.read_file_bytess STTTTr(rE pre_contentcdS)z8Write content to a file, creating directories as needed.Nr-)r_r>rErs r& write_filezFileOperations.write_file  r(F old_string new_string replace_allcdS)z,Replace text in a file using fuzzy matching.Nr-)r_r>rrrs r& patch_replacezFileOperations.patch_replace!rr( patch_contentcdS)zApply a V4A format patch.Nr-)r_rs r& patch_v4azFileOperations.patch_v4a'rr(cdS)z>Delete a file. Returns WriteResult with .error set on failure.Nr-rs r& delete_filezFileOperations.delete_file,rr( recursivecP|rtdS||S)zCross-platform delete that handles files and (with recursive=True) directory trees. Default implementation delegates to ``delete_file`` for the non-recursive case; backends with native recursive support should override. z1Recursive delete not implemented for this backendr)rkrr_r>rs r& delete_pathzFileOperations.delete_path1s3  Z%XYYY Y%%%r(srcdstcdS)zSMove/rename a file from src to dst. Returns WriteResult with .error set on failure.Nr-)r_rrs r& move_filezFileOperations.move_file;rr(.2rpatternr0 file_glob output_modecontextc dS)zSearch for content or files.Nr-) r_rr>r0rrrrrs r&searchzFileOperations.search@s r(rrrUrrrENrrrEr)rarbrcrdrrergrDrrrrrkrr<rurrrrrrrr-r(r&rrsJJ  c 3 3 *   ^  # *   ^ UUCUHSMUZUUUU04  s S (  9D   ^ */  # 3 C #' 4?   ^  s {   ^      ^ &&&&&&&& S s {   ^ BKOP<=  c  C "3- 7: IL  69 BN   ^   r(r>.bmp.gif.ico.jpg.png.jpeg.webpz python -m py_compile {file} 2>&1znode --check {file} 2>&1znpx tsc --noEmit {file} 2>&1zgo vet {file} 2>&1zrustfmt --check {file} 2>&1).pyz.js.ts.go.rs>rr r)z/this is not the tsc command you are looking forz%could not determine executable to runznot found in npm registry)zno input filename givenzerror: not a workspace)zcannot find packagezgo: cannot find main module)npxrustfmtgobase_cmdct|}|sdS|tfd|DS)aUReturn True iff ``output`` from ``base_cmd`` indicates the linter itself couldn't run (a tooling gap), as opposed to a real lint error in the file being checked. ``base_cmd`` is the first word of the linter command line (``npx``, ``rustfmt``, ``go``, ...). ``output`` is the stdout/stderr captured from running it. Fc3 K|]}|vV dSrUr-)rWplowers r& z._looks_like_linter_unusable..s',,aqEz,,,,,,r()_LINTER_UNUSABLE_PATTERNSgetrany)r rpatternsrs @r&_looks_like_linter_unusablersU),,X66H u LLNNE ,,,,8,,, , ,,r(rEc ddl} ||dS#|j$r'}dd|jd|jd|jdfcYd}~Sd}~wt $r%}dt|jd |fcYd}~Sd}~wwxYw) z;In-process JSON syntax check. Returns (ok, error_message).rNTrFzJSONDecodeError:  (line , column )r) jsonloadsJSONDecodeErrormsglinenocolno Exceptiontypera)rE_jsones r&_lint_json_inprocr's1 Gx  VVVU!%UUUU17UUUUUUUUUU 111a)00Q0000000001s, A;A A; A;A60A;6A;c ddl}n#t$rYdSwxYw ||D]}dS#|j$r}dd|fcYd}~Sd}~wt$r%}dt |jd|fcYd}~Sd}~wwxYw)uwIn-process YAML syntax check. Returns (ok, error_message). Skipped gracefully if PyYAML isn't installed — YAML parsing is optional. Deliberately a *syntax-only* scan (``yaml.parse``), not ``safe_load``: loading rejects perfectly valid YAML that merely isn't a single plain document — multi-document streams (``---``-separated Kubernetes manifests raise ``ComposerError``) and application-defined tags (CloudFormation ``!Sub``/``!Ref``, Ansible ``!vault`` raise ``ConstructorError``). Those are content conventions for whatever consumes the file, not syntax errors, and this linter's verdict is used as a fail-closed WRITE gate in ``write_file`` — a false positive here refuses a legitimate write outright. ``yaml.parse`` still catches real scanner/parser failures (unclosed quotes, bad indentation, tab-mangled block maps). rN)T__SKIP__rFz YAMLError: r)yaml ImportErrorparse YAMLErrorr#r$ra)rE_yaml_eventr&s r&_lint_yaml_inprocr0s"      1kk'**  F x ?((('A''''''''' 111a)00Q0000000001s8 3 A;A A; A;A60A;6A;cddl} ||dS#t$r%}dt|jd|fcYd}~Sd}~wwxYw)zddl} ||dS#t$rH}|jrd|jd|jdnd}dt |jd |j|fcYd}~Sd}~wt$r%}dt |jd |fcYd}~Sd}~wwxYw) uIn-process Python syntax check via ast.parse. Catches SyntaxError, IndentationError, and everything else the ast module rejects — matching py_compile's scope but with no subprocess overhead and no dependency on a ``python`` in PATH. rNrrrrrFr) astr, SyntaxErrorr!rr$rar r#)rE_astr&locs r&_lint_python_inprocr:s1 7x ::::;(J666186666a)99QU9C999999999 111a)00Q0000000001s, B=A*$B* B7BBB)r.json.yaml.yml.toml>r=r;r>r<rirr__hermes_not_regular__valuedefaultcT t|S#ttf$r|cYSwxYw)z8Best-effort integer coercion for tool pagination inputs.)rg TypeError ValueError)r@rAs r& _coerce_intrE%s<5zz z "s ''rrcddlm}|}tdt|t}t|t }tdt ||}||fS)aReturn safe read_file pagination bounds. Tool schemas declare minimum/maximum values, but not every caller or provider enforces schemas before dispatch. Clamp here so invalid values cannot leak into sed ranges like ``0,-1p``. The upper bound on ``limit`` comes from ``tool_output.max_lines`` in config.yaml (defaults to the module-level ``MAX_LINES`` constant). r) get_max_linesr)tools.tool_output_limitsrGmaxrEDEFAULT_READ_OFFSETDEFAULT_READ_LIMITmin)rrrG max_linesnormalized_offsetnormalized_limits r&normalize_read_paginationrP-st766666 IA{63FGGHH"5*<==1c"2I>>?? . ..r(ctdt|t}tdt|t}||fS)zCReturn safe search pagination bounds for shell head/tail pipelines.rr)rIrEDEFAULT_SEARCH_OFFSETDEFAULT_SEARCH_LIMIT)rrrNrOs r&normalize_search_paginationrT@sFA{63HIIJJ1k%1EFFGG . ..r(z(?Z* ded ed?ed@edAe de+f dBZ,dCede+fdDZ-d`d edeede.fdEZ/ d`d edeedFeede.fdGZ0de fdHZ1dIede fdJZ2d ede fdKZ3d ede fdLZ4d eddfdMZ5dddNd edeedFeedefdOZ6 dfdSed edTedUeed+ed*edVedWede7fdXZ8dSed edTedUeed+ed*edVedWedee7fdYZ9dSed edUeedeefdZZ:dSed ed+ed*ede7f d[Z;dSed ed+ed*ede7f d\ZdSed edUeed+ed*edVedWede7fd_Z?dS)gShellFileOperationsz File operations implemented via shell commands. Works with ANY terminal backend that has execute(command, cwd) method. This includes local, docker, singularity, ssh, modal, and daytona environments. Ncwdc||_|p2t|ddp!tt|ddddpd|_i|_dS)u Initialize file operations with a terminal environment. Args: terminal_env: Any object with execute(command, cwd) method. Returns {"output": str, "returncode": int} cwd: Optional explicit fallback cwd when the terminal env has no cwd attribute (rare — most backends track cwd live). Note: Every _exec() call prefers the LIVE ``terminal_env.cwd`` over ``self.cwd`` so ``cd`` commands run via the terminal tool are picked up immediately. ``self.cwd`` is only used as a fallback when the env has no cwd at all — it is NOT the authoritative cwd, despite being settable at init time. Historical bug (fixed): prior versions of this class used the init-time cwd for every _exec() call, which caused relative paths passed to patch/read/write to target the wrong directory after the user ran ``cd`` in the terminal. Patches would claim success and return a plausible diff but land in the original directory, producing apparent silent failures. r_Nconfig/)envgetattrr__command_cache)r_ terminal_envr_s r&__init__zShellFileOperations.__init__wse0  V',t<<V7<4@@%NNVRU 02r(commandtimeout stdin_datarc:i}|r||d<|||d<|pt|jddp|j}|jj|fd|i|}|dd}|dr|dkrd}t |d d | S) uExecute command via terminal backend. Args: stdin_data: If provided, piped to the process's stdin instead of embedding in the command string. Bypasses ARG_MAX. Cwd resolution order (critical — see class docstring): 1. Explicit ``cwd`` arg (if provided) 2. Live ``self.env.cwd`` (tracks ``cd`` commands run via terminal) 3. Init-time ``self.cwd`` (fallback when env has no cwd attribute) This ordering ensures relative paths in file operations follow the terminal's current directory — not the directory this file_ops was originally created in. See test_file_ops_cwd_tracking.py. riNrjr_ returncoder stdin_errorrrr)rr)rdrcr_executerr) r_rhr_rirjkwargs effective_cwdrrs r&_execzShellFileOperations._execs"  ( 'F9   !#-F< Iwtx==I !!'GG}GGGJJ|Q// ::m $ $ aI::h++    r(cmdc||jvr>|d|d}|jdk|j|<|j|S)z6Check if a command exists in the environment (cached).z command -v z >/dev/null 2>&1 && echo 'yes'yes)rerqrr)r_rrrs r& _has_commandz ShellFileOperations._has_commands[ d) ) )ZZ Qc Q Q QRRF'-}':':'<'<'ED  $"3''r(r>lengthc|d|d||d}|jdkrdSt|j}d|}|sdStjd|sdS tj |d S#tj tf$rYdSwxYw) u-Fetch the first ``length`` raw bytes of a file through the terminal. File operations run through a terminal backend (possibly remote), so raw bytes cannot cross the transport directly — the terminal decodes stdout with ``errors="replace"`` and manufactures U+FFFD at every byte it cannot decode, including a multibyte character cut in half by ``head -c``. Wrapping the sample in base64 lets the original bytes survive the transport, so binary detection can happen at the byte layer where it is well-defined (#80308 and friends). Returns the sample bytes, or ``None`` when the transport could not produce clean base64 (exotic shells without ``base64``); callers fall back to the legacy text-sample heuristic in that case. zhead -c  z 2>/dev/null | base64rNrr(z[A-Za-z0-9+/]+={0,2}Tvalidate)rq_escape_shell_argrr'rr!rr fullmatchbase64 b64decodebinasciiErrorrD)r_r>rwrencodeds r&_sample_file_bytesz&ShellFileOperations._sample_file_bytess Sv S S 6 6t < < S S S    q 4-fm<<'''--//** 3|3W== 4 #Gd;;; ; +   44 sB**CCr)c|sdSd|vrdS |ddS#t$r_}|jt|dz kr9 |d|jdYd}~dS#t$rYnwxYwYd}~dSd}~wwxYw)uByte-layer binary detection (the boundary for the #80308 class). Contract: a file is text when its sample is valid UTF-8, allowing one incomplete multibyte sequence at the very end (an artifact of cutting the sample at a byte boundary, not a property of the file). Anything else — NUL bytes, mid-stream invalid UTF-8 such as latin-1 or true binaries — stays read-only, preserving the anti-mojibake guarantee the old U+FFFD check existed for: a read→edit→write round-trip must never rewrite undecodable bytes with replacement characters. A file that legitimately *contains* U+FFFD (EF BF BD — e.g. logs of lossy output) is valid UTF-8 and reads as text; the old text-layer check misclassified it because it could not tell a stored replacement character from a transport-manufactured one. FTutf-8N)decodeUnicodeDecodeErrorrr8)r)excs r&_is_likely_binary_bytesz+ShellFileOperations._is_likely_binary_bytess" 5 f  4  MM' " " "5!   yCKK!O++;SY;'..w777 55555)D44444 s2# B B "A11 A>;B=A>>BB content_samplec4tj|d}|tvrdS|rSd|ddvrdSt d|ddD}|t t|dz dkSdS) z Check if a file is likely binary. Uses extension check (fast) + content analysis (fallback). rTu�Nrvc3HK|]}t|dk|dvdVdS) z rN)ord)rWcs r&rz8ShellFileOperations._is_likely_binary..!sJ E Ea"%a&&2++!82C2C!"2C2C2C2C E Er(g333333?F)osr>splitextrr sumrLr8)r_r>rext non_printables r&_is_likely_binaryz%ShellFileOperations._is_likely_binary s gt$$Q'--// # # #4  I>%4%000t E E>%4%+@ E E EEEM 3s>':':D#A#AADH Hur(ctj|d}|tvS)z2Check if file is an image we can return as base64.r)rr>rrIMAGE_EXTENSIONS)r_r>rs r& _is_imagezShellFileOperations._is_image's4gt$$Q'--//&&&r(rrE start_linecddlm}|}|d}g}t||D]?\}}t ||kr |d|dz}||d|@d|S)uJAdd line numbers to content in ``LINE_NUM|CONTENT`` format. The gutter uses a compact ``|`` prefix (e.g. ``34|foo``) rather than a fixed-width zero/space-padded one (`` 34|foo``). The padding was pure token overhead: on dense source the padded gutter cost ~48% more tokens than the bare content and ~16% more than the compact form, because the leading spaces + zero-padding tokenize into extra tokens on every single line. An A/B (Sonnet 4.6, 2 passes) showed the compact gutter matches the padded gutter on line-reference / patch / value-lookup / structure tasks (4/4 both), while dropping line numbers entirely regressed line-referencing (the model hand-counted and was off-by-one, 3/4) — so we keep the numbers, just not the padding. rget_max_line_lengthr,)rNz... [truncated]|)rHrr enumerater8r r!) r_rErrmax_line_lengthrnumberedir#s r&_add_line_numbersz%ShellFileOperations._add_line_numbers,s A@@@@@--// d## j999 + +GAt4yy?**,_,-0AA OOqMM4MM * * * *yy"""r(c|s|S|dr9|d}|jdkr|jr|j}|dkr|S|dr ||ddzS|dd}|d}|dkr |d|n|}|rt jd|rt|d |}|jdkrQ|jr8|j}|dt|zd} || zS|S) z Expand shell-style paths like ~ and ~user to absolute paths. This must be done BEFORE shell escaping, since ~ doesn't expand inside single quotes. ~z echo $HOMErz~/rNrbz[a-zA-Z0-9._-]+zecho ~) r6rqrrrfindrr}r8) r_r>rhomerest slash_idxusername expand_result user_homesuffixs r& _expand_pathz ShellFileOperations._expand_pathFsr K ??3   2ZZ --F1$$)<)<)>)>$}**,,3;;K__T**+$qrr(?*ABBx IIcNN /8A~~4  ++42 -? J J2%)JJ/B/B/B$C$CM$.!33 8L8R8R8T8T3$1$8$>$>$@$@ !%a#h--&7&8&8!9(611 r(argc\ddlm}||}d|ddzdzS)a4Escape a string for safe use in shell commands. On Windows native drive paths (``C:\Users\x`` / ``C:/Users/x``) and mixed MSYS leftovers (``/c/Users\x``) are rewritten to the Git Bash ``/c/Users/x`` form via ``_bash_safe_path``: bash eats backslashes and MSYS otherwise mangles drive paths into the ``Directory \drivers\etc does not exist`` failure class. Reuses the env-layer translator so shell file ops and the terminal ``cd`` agree on the path form. No-op off Windows and for plain POSIX paths. r)_bash_safe_path''"'"')tools.environments.localrr)r_rrs r&r|z%ShellFileOperations._escape_shell_argksC =<<<<<oc""S[[i000366r(cddlm}m}|r!|r||dd}d|ddzdzS)uEscape a path argument destined for a NATIVE Windows binary. ``_escape_shell_arg`` rewrites Windows paths to the Git Bash MSYS form (``/c/Users/x``) so bash builtins resolve them. But native Windows binaries invoked from that bash (ripgrep installed via winget/cargo/choco, native git, etc.) do not understand ``/c/...`` paths — and Hermes disables MSYS argument conversion for its bash subprocesses (``MSYS_NO_PATHCONV=1`` / ``MSYS2_ARG_CONV_EXCL=*``, see ``_apply_windows_msys_bash_env_defaults``), so nothing ever translates the MSYS form back. The native tool then fails with ``The system cannot find the path specified. (os error 3)``. The forward-slash native form (``C:/Users/x``) is the one spelling every layer accepts: bash passes it through untouched (it is not an absolute POSIX path, so no conversion applies even without the opt-outs), and Windows APIs treat ``/`` and ``\`` as equivalent separators. MSYS builds of the same tools accept it too, so this is safe regardless of which flavor of the binary is installed. On non-Windows hosts this is exactly ``_escape_shell_arg``. r) _IS_WINDOWS_msys_to_windows_path\rbrr)rrrr)r_rrrs r&_escape_native_tool_argz+ShellFileOperations._escape_native_tool_arg|sl, POOOOOOO  @3 @'',,44T3??CS[[i000366r(rc||}tj|pd}||}|d}d|d|d|zdz}|||S)aWrite ``content`` to ``path`` atomically via temp-file + rename. Streams ``content`` over stdin into a temp file in the SAME directory as ``path`` (so the final ``mv`` is a real rename on the same filesystem, not a non-atomic cross-device copy), preserves the existing file's mode if it exists, then renames over the target. On any failure the temp file is removed so we never leak a partial ``.hermes-tmp`` file next to the user's data, and the original file is left untouched. Content rides stdin so there is no ARG_MAX limit. ``mkdir -p`` for the parent directory is folded into this script (one fewer subprocess vs. a separate ``mkdir -p`` call). Returns an :class:`ExecuteResult`; ``exit_code == 0`` means the file was swapped into place atomically. A non-zero exit means nothing was renamed and the original (if any) is intact. rz.hermes-tmp.XXXXXXz set -e; d=z; t=z; if [ -L "$t" ]; then rt="$(readlink -f "$t" 2>/dev/null || realpath "$t" 2>/dev/null || true)"; [ -n "$rt" ] && { t="$rt"; d="$(dirname "$t")"; }; fi; mkdir -p "$d"; tmp="$(mktemp -p "$d" a 2>/dev/null || mktemp "$d/.hermes-tmp.$$.XXXXXX" 2>/dev/null || { tmp="$d/.hermes-tmp.$$"; : > "$tmp" && echo "$tmp"; })"; [ -n "$tmp" ] || { echo "atomic write: could not create temp file" >&2; exit 1; }; trap 'rm -f \"$tmp\"' EXIT; if [ -e "$t" ]; then m="$(stat -c%a "$t" 2>/dev/null || stat -f%Lp "$t" 2>/dev/null || true)"; [ -n "$m" ] && chmod "$m" "$tmp" 2>/dev/null || true; fi; cat > "$tmp"; if [ ! -e "$t" ]; then chmod "=rw" "$tmp" 2>/dev/null || true; fi; mv -f "$tmp" "$t"; trap - EXIT)rj)r|rr>dirnamerq)r_r>rEq_pathparentq_parenttmplscripts r& _atomic_writez!ShellFileOperations._atomic_writes$''--&&-#))&11%%&:;;6 % % %% % % %"(,# ,"/#!  Hzz&Wz555r(rc|rt|Sd||d}||}|jdks|jsdSt|jS)uDetect the dominant line ending of a file on disk. If ``pre_content`` is already available (we just read the file for lint/LSP purposes), inspect that — zero extra exec calls. Otherwise issue a tiny ``head -c 4096`` to sample the first 4KB. Returns ``"\r\n"`` for CRLF (Windows), ``"\n"`` for LF (Unix), or ``None`` if undetermined (new file, empty file, single-line file with no line break in the first chunk). z head -c 4096 2>/dev/nullrN)r/r|rqrrr_r>rhead_cmd head_results r&_detect_file_line_endingz,ShellFileOperations._detect_file_line_endingsx  4&{33 3N4#9#9$#?#?MMMjj**  A % %[-? %4";#5666r(cd||d}||}|jdks|jsdSt |jS)u0Whether the file on disk starts with a UTF-8 BOM. Always probes the first 3 bytes on disk — do NOT trust ``pre_content`` for BOM detection because the most common provider (``read_file_raw``) deliberately strips BOMs so the agent never sees U+FEFF glyphs. Passing BOM-stripped content through ``pre_content`` would cause a false-negative and silently remove the marker on rewrite. A missing/empty file returns False (new writes get no BOM unless the caller explicitly includes one). z head -c 3 rrF)r|rqrrr=rs r& _file_has_bomz!ShellFileOperations._file_has_boms`K 6 6t < <JJJjj**  A % %[-? %5 *+++r( old_content new_contentfilenamec|d}|d}tj||d|d|}d|S)z2Generate unified diff between old and new content.Trza/zb/)fromfiletofiler)rdifflib unified_diffr!)r_rrr old_lines new_linesrws r& _unified_diffz!ShellFileOperations._unified_diffsn**D*99 **D*99 # y$(__"??    wwt}}r(c T||}d|d|d|dtd S)uByte size of a regular file, without opening one that never ends. ``wc -c < path`` opens the path. On a FIFO with no writer, a socket, or a character device like /dev/zero that never reaches EOF, that read blocks forever — and the read helpers pass no timeout to :meth:`_exec`, so the turn wedges until the process is killed. The device blocklist in ``tools/file_tools.py`` cannot cover this: it matches literal ``/dev/*`` names, while a FIFO is a file *type* and can sit at any path. ``[ -f ]`` is a stat, not an open — it answers exactly the question the size probe needs (regular file, symlinks followed) without touching the contents. Non-regular paths that exist report the sentinel so callers can say so instead of claiming the file is missing; a genuinely absent path still exits non-zero. zif [ -f z ]; then wc -c < z 2>/dev/null; elif [ -e z ]; then echo z; else exit 1; fi)r|NOT_REGULAR_SENTINEL)r_r>rs r&_size_probe_cmdz#ShellFileOperations._size_probe_cmd(sX"$$T** s  S    ,@    r(c*td|dS)z5Error for a path that exists but would block if read.z Cannot read 'z`': not a regular file (directory, FIFO, socket, or device). Reading it could block indefinitely.rrrAs r&_not_regular_errorz&ShellFileOperations._not_regular_error@s5KKKK    r(iirrrGzOptional[ReadResult]c tj|d}|tvrdS||jkrdSd|dt |dt |d|jd|jd }|d | |}|j d kr6d |j pd vr+|d | |}t|j pd }| d} |j d ks| d krdS|| tdzd} t!jd| vr| ddd n| } | d} t | d} t'| dd}n#t*t,t.f$rYdSwxYw||zdz }| |k}d|dg}|r%|d|dzd|d|d| d t5|| || ||d|S)alAttempt to read ``path`` as UTF-16 text, transcoded to UTF-8. Returns a populated ``ReadResult`` when the file is UTF-16 (BOM or zero-byte parity heuristic), else ``None`` so the caller falls back to the binary-file error. Files over 10 MiB are not rescued. ``path`` must already be expanded (caller ran ``_expand_path``). rNzimport sys, json, os p = z offset = z limit = z MAX = z SAMPLE = af try: size = os.path.getsize(p) if size > MAX: print('HERMES_UTF16:NO'); sys.exit(0) with open(p, 'rb') as f: data = f.read() sample = data[:SAMPLE] enc = None if sample[:2] == b'\xfe\xff': enc = 'utf-16-be' elif sample[:2] == b'\xff\xfe': enc = 'utf-16-le' else: odd = sum(1 for i in range(1, len(sample), 2) if sample[i] == 0) even = sum(1 for i in range(0, len(sample), 2) if sample[i] == 0) if even == 0 and odd >= 2: enc = 'utf-16-le' elif odd == 0 and even >= 2: enc = 'utf-16-be' if enc is None: print('HERMES_UTF16:NO'); sys.exit(0) text = data.decode(enc, 'replace') if text[:1] == '\ufeff': text = text[1:] text = text.replace('\r\n', '\n') lines = text.split('\n') total = len(lines) sel = lines[offset - 1: offset - 1 + limit] out = {'total_lines': total, 'encoding': enc, 'content': '\n'.join(sel)} print('HERMES_UTF16:OK') print(json.dumps(out, ensure_ascii=True)) except Exception: print('HERMES_UTF16:NO'); sys.exit(0) python3 -c rpython3r python -c zHERMES_UTF16:OKr,rErFencodingzutf-16zTranscoded from zP to UTF-8 for display. Text edits via patch/write_file would re-encode as UTF-8. Use offset= to continue reading (showing - of  lines)ryrErFrGrHrI)rr>rrr _UTF16_MAX_BYTESrg_UTF16_SAMPLE_BYTESrqr|rrr'rr8rrrrrerrDKeyErrorrCupperr rDrr!)r_r>rrrGrsnippetrrmarkerrdatarErFrend_linerH hint_partss r&_try_read_utf16z#ShellFileOperations._try_read_utf16Vsgt$$Q'--// # # #4 t, , ,4' :' :' :F ' :' :5zz' :' :* ' :' : 0 ' :' :' : VK$*@*@*I*IKKLL  q Y6=3FB%G%GZZ NT-C-CG-L-L N NOOF,V]-@bAA.//  q FQJJ4#&7"8"8899:@@BB :47??gmmD!44Q77PWXXD9oGd=122K488J99::HHHi0   44 E>A%(* R)9)9RRRS     HhlHH"HH%-HH3>HHH   **7F;;#*%%     sA4GG-,G-rc @ ||}t||\}}|||}|jdkri||}|=||||}d|d|d}|jr |d|jn||_|S||St|j }| tkr| |S t| } n#t$rd} YnwxYw| t kr ||rt%dd| d S||} | Vt(j|d t0v} | p|| } nXd ||d } || }t|j }|||} | r<||||| }||St%d| t;| | Sddlm}d|zd z}||zd z }d|d|d||d|}||}|jdkrt%d|j St|j }|d krtA|\}}d||}||}t|j } t| }n#t$rd}YnwxYw||k}d}|rd|d zd|d|d|d }|s|!drod||d}||}t|j } |jdkr"| d kr |dd!}| dkrt%d"ddd#$S||cxkrdkr nnt%d"|| d%|d&|d'|d($St%|"|||| ||)S)*a Read a file with pagination, binary detection, and line numbers. Args: path: File path (absolute or relative to cwd) offset: Line number to start from (1-indexed, default 1) limit: Maximum lines to return (default 500, max 2000) Returns: ReadResult with content, metadata, or error info rN)rrzNote: 'zD' not found byte-for-byte; resolved to the unicode-equivalent file 'zM' (invisible encoding difference: NFC/NFD or special space/quote characters).ryTzImage file detected. Automatically redirected to vision_analyze tool. Use vision_analyze with this file path to inspect the image contents.)rKrJrGrIr head -c 1000 rrJrGrOrrzsed -n ',zp' z | cut -b1-Failed to read file: rzwc -l < rrrrrr,z tail -c 1 z | wc -l0rzFile is empty (0 bytes).)rErFrGrIz Note: offset z is beyond the end of the file (z$ lines total). Retry with offset <= rr)#rrPrqrr_unicode_variant_matchrrI_suggest_similar_filesr'rrrrrgrD MAX_FILE_SIZErrDrrr>rrr rr|rrrrHrr:endswithr)!r_r>rr stat_resultvariantrr| stat_outputrG sample_bytes ext_binaryrJ sample_cmd sample_result sample_output utf16_resultrline_clamp_bytesrread_cmd read_result read_output_wc_cmd wc_result wc_outputrFrHrItail_cmd tail_result tail_outputs! r&rzShellFileOperations.read_files  &&1&%@@ jj!5!5d!;!;<<  A % % 11$77G"eLL#d##4;### :@N55 555$  ..t44 41+2DEE     "6 6 6**400 0 K--//00II   III  } $ $  >>$   #\  ..t44  #))$//288::>OOJ"Pd&B&B<&P&PIIS)?)?)E)ESSSJ JJz22M7 8LMMM..t]CCI   //feYOOL'###*<CC < A@@@@@22444q8E>A% -v - - - -T-C-CD-I-I - -* - - jj**  A % %$PK>/   K # # # #! # # # # #'#&F&&#&&"&&&    **;??#     s$ !D.. D=<D=!M>> N  N cttj|pd}tj|sdSdtdtfdd||d}||}|jdks|j sdSfd t|j D}t|d kr8|dksd |vr&tj ||dn|dSdS) uFind an existing file whose name is unicode-equivalent to ``path``. macOS names screenshots with a NARROW NO-BREAK SPACE (U+202F) before AM/PM, stores names NFD-decomposed, and Finder renames turn ' into ’ — all invisible in rendered text. Compare directory entries under a normalization that erases exactly those differences and return the on-disk spelling when exactly one entry matches. rNrrcltjd|}dD]\}}|||}|S)NNFC))u ry) ry)u’r)u‘r) unicodedata normalizer)routrrs r&_canonz:ShellFileOperations._unicode_variant_match.._canonsG't44C , ,S kk#s++Jr(ls -1 rrcBg|]}|r|k |k|Sr-r-)rWentryrrr0s r&rz>ShellFileOperations._unicode_variant_match..sJ    (**vve}}/F/F /F/F/Fr(rrb)rr>rbasenamerer|rqrrrr'rr8r!) r_r>dir_pathls_cmd ls_result candidatesrrr0s @@@r&rz*ShellFileOperations._unicode_variant_matchusb7??4((/C7##D)) 4      !!H$00::HHHJJv&&  ! # #9+;+A+A+C+C #4      4Y5EFFQQSS    z??a  /dev/null | head -50r,dZF<(g?Ng?rc|d S)Nrr-)xs r&z.s 1Q4%r()keycg|]\}}|Sr-r-)rWrfps r&rz>ShellFileOperations._suggest_similar_files..s...%!R2...r(rFile not found: )rOrR)rr>rrrrr|rqrrrrr6r8setrIrSequenceMatcherratior r!sortrD)r_r>rrbasename_no_extr lower_namerrscoredflfscorecommonsimilars r&rz*ShellFileOperations._suggest_similar_filess7??4((/C7##D))'**844Q7gx((+1133^^%% T$00::SSSJJv&&   ! # # (8(>(>(@(@ #%++--33D99# F# FWWYY##EEW%%a((+11337L7L7N7NNNEE]]:.. #*2G2G2K2K #EE2%%EE:%%#b''A++EE#RW--a00399;;sBB __s2ww6F6{{c#j//3r77&C&Cc&III "A::'"9*b##%''S#!#!E199MM5"',,x*C*C"DEEE  (((..6"1":...+T++!    r(c||}|||}|jdkr||St |j}|tkr| |S t|}n#t$rd}YnwxYw| |rtdd|S||}|Vtj|dt&v}|p||}nV|d||d}t |j} ||| }|r td|t/||S|d ||} | jdkrtd | j St1t | j\} } t| | S) zRead the complete file content as a plain string. No pagination, no line-number prefixes, no per-line truncation. Uses cat so the full file is returned regardless of size. rT)rKrJrGNrrrrcat rr)rErG)rrqrrrr'rrrrrgrDrrDrrr>rrr rr|rrr:) r_r>rrrGrrrJrr cat_result raw_contentrs r&rz!ShellFileOperations.read_file_rawss   &&jj!5!5d!;!;<<  A % %..t44 41+2DEE     "6 6 6**400 0 K--//00II   III  >>$   RttyQQQ Q..t44  #))$//288::>OOJ"Pd&B&B<&P&PII JJ'at7M7Md7S7S'a'a'abbM7 8LMMM..t]CCI  )*<CC ZZ Et'='=d'C'C E EFF  1 $ $$OJrrrrGrcompacts r&rz#ShellFileOperations.read_file_bytes sC  &&jj!5!5d!;!;<<  A % %$=t$=$=>>> >1+2DEE     "6 6 6**400 0 NK--//00II N N N$Ld$L$LMMM M M M N  Y%:%:#XIXXX)XXXX  **G)?)?)E)EGGHH   ! !$S7>$S$STTT T''5gnEEKKMMNN Y  Wt 4 4 4 4 4FO12 Y Y Y$WQU$W$WXXX X X X Y"    s$#!CC%$C%F)).GGc0||dS)u(Delete a single file. Cross-platform: runs via ``python -c`` against the terminal env's Python so it works on Windows shells (``cmd.exe``/PowerShell) that don't ship ``rm``. Directories are rejected here — use ``delete_path(recursive=True)`` for trees. Fr_python_deleters r&rzShellFileOperations.delete_file+s""45"999r(Frc0|||S)aCross-platform delete that handles files and (with recursive=True) directory trees. Always preferred over emitting ``rm -rf`` / ``Remove-Item -Recurse`` directly so the same tool call works on every backend (local / docker / ssh / Windows). rBrCrs r&rzShellFileOperations.delete_path5s ""49"===r(c ||}t|d}|rt|Sd|dt|d}|d||}|jdkr6d |jpd vr+|d ||}|jdkr1td |d |jpd pdStS)NDeleteverbrz-import shutil, pathlib, sys p = pathlib.Path(z) recursive = aI try: if p.is_dir() and not p.is_symlink(): if recursive: shutil.rmtree(p) else: print('is a directory: ' + str(p), file=sys.stderr); sys.exit(2) else: p.unlink() except FileNotFoundError: pass except Exception as exc: print(str(exc), file=sys.stderr); sys.exit(1) rrrrrzFailed to delete rz unknown error) rrrkr<rqr|rrr)r_r>rdeniedrrs r&rDz"ShellFileOperations._python_delete=s<  &&'8<<<  -V,,, , B $ B B ?? B B B ,K$*@*@*I*IKKLL  q Y6=3FB%G%GZZ NT-C-CG-L-L N NOOF  q %s%s%s&-BUSUA\A\A^A^Aqbq%s%sttt t}}r(rrc||}||}||fD]'}t|d}|rt|cS(|d||d||}|jdkrtd|d|d |jStS) zMove a file via mv.MoverHrzmv ryrzFailed to move z -> r)rrrkrqr|rr)r_rrrrJrs r&rzShellFileOperations.move_fileis$$$$s 1 1A+AF;;;F 1"000000 1 M$((-- M M0F0Fs0K0K M M    q %Vs%V%V%V%Vv}%V%VWWW W}}r(c ||}t|}|rt|Stjd|}|r*td|d|ddSt j|d }|tvrt |nd}|0||\}} |s | d krtd|d |d | d S|tvp| |} | rJ|nGd ||d} || } | jdkr| jr| j}|||} | dkrt'|d}|||rt+|s t,|z}||t j|}t3|} |dd}n.#t6$r!}td|d|dcYd}~Sd}~wwxYw|||}|jdkrtd|jSt;|}d} d||d}||}|jdkr|jrs|jd}tAj!|"}||k}|std|dSn#tF$rd}YnwxYw|$|||}d}|j%s|j&r|'|||}|r|}t||||r|(nd|S)u Write content to a file, creating parent directories as needed. Pipes content through stdin to avoid OS ARG_MAX limits on large files. The content never appears in the shell command string — only the file path does. Before anything touches disk, a fail-closed syntax gate runs against the CANDIDATE content: if ``path``'s extension is in ``_FAIL_CLOSED_INPROC_EXTS`` (JSON/YAML/TOML — structured data formats where a parse failure always means corruption) and the candidate content doesn't parse, the write is refused outright. No temp file, no rename, nothing on disk changes. After a write that clears the gate, runs a post-first / pre-lazy lint check via ``_check_lint_delta()``. If the new content is clean, the lint call is O(one parse). If the new content has errors the gate didn't already catch (i.e. errors from a linter outside ``_FAIL_CLOSED_INPROC_EXTS``, such as Python), the pre-write content is linted too and only errors newly introduced by this write are surfaced — pre-existing problems are filtered out so the agent isn't distracted chasing them. Args: path: File path to write content: Content to write pre_content: Pre-edit file content if the caller already has it (e.g. patch_replace read the file for fuzzy matching). When provided, skips a redundant ``cat`` subprocess to re-read the file for lint baseline / line-ending detection. BOM detection always probes disk (the most common provider — ``read_file_raw`` — strips BOMs, so trusting ``pre_content`` for BOM would cause false negatives and silent marker loss on rewrite). When None, reads from disk as before. Returns: WriteResult with bytes written, lint summary, or error. rz[\ud800-\udc7f\udd00-\udfff]zRefusing to write 'z0': content contains a lone surrogate character (rzH) that cannot be encoded as UTF-8. The file was NOT created or modified.rNr)z': candidate content fails z syntax validation (zC). The file was NOT created or modified. Fix the content and retry.r<rr+rsurrogateescapezFailed to write file: z sha256sum #Post-write verification failed for u{: on-disk content hash differs from the intended write. The write did not persist correctly — re-read the file and retry.r post_content)rlrmrnrorp))rrrkrrrrr>rr_FAIL_CLOSED_INPROC_EXTSLINTERS_INPROCr_lsp_handles_extensionr|rqrrrr4rr=r7_snapshot_lsp_baselinerr<encodeUnicodeEncodeErrorrr8rrhashlibsha256 hexdigestr#_check_lint_deltarvr_maybe_lsp_diagnosticsr`)r_r>rErrJrr inproc_linter_ok _lint_errwant_prerroriginal_endingrrm content_bytesr write_resultrlcontent_verifiedhash_cmd hash_resultdisk_sha expected_sha lint_resultrpblocks r&rzShellFileOperations.write_file|sT  &&(--  -V,,, , I5w ? ?  N$NN,-GGAJJNNN Bgt$$Q'--//36:R3R3R**3///X\  $*]733NC 9 22"NdNNNN4=NNN..(LD,G,G,L,L  5& M$"8"8">">LLL"jj22 (A--+2D-"-"4K77kJJ f $ $-gv>>G   dK 0 0 *'9J9J *')G ##D)))&&F|| , #NN74EFFMM!   C$CC,/CCC       ))$88  !Q & &%Sl>Q%S%STTT TM** ,0 $ND$:$:4$@$@NNNH**X..K$))k.@.F.F.H.H)&-3355;;==a@&~m<<FFHH #+|#; '&)$))) $ $ $#    $,,T{Y`,aa *.   (+"5 (//+G0E ("''%%*5?$$&&&4+     s1H&& I0I I ICM%% M43M4rrrc ||}t|}|rt|Sd||d}||}|jdkrtd|S|j}|} t|\}} ddlm } | ||||\} } }}|s| dkriddlm }||||rtddd |d  S|pd |} dd lm }|||| ||z }n#t$rYnwxYwt|St|}|rt| |} ||| | }|jrtd|jSd||d}||}|jdkrtd|St|j\}} |dddd}| dddd}||kr4td|dt%|dt%|dS||| |}|||| }td||g|r|nd|jS)ai Replace text in a file using fuzzy matching. Args: path: File path to modify old_string: Text to find (must be unique unless replace_all=True) new_string: Replacement text replace_all: If True, replace all occurrences Returns: PatchResult with diff and lint results rr<rrr)fuzzy_find_and_replace)is_already_appliedTuTFile already contains the target text — the edit appears to be already applied to z0. No write performed; do not re-send this patch.)rvr{r|z'Could not find match for old_string in )format_no_match_hint)rzFailed to write changes: z2Post-write verification failed: could not re-read r+r,r2rOz5: on-disk content differs from intended write (wrote z chars, read back zb chars after normalizing line endings). The patch did not persist. Re-read the file and try again.rPN)rvrwrxrorp)rrrur|rqrrr:tools.fuzzy_matchrlrmrnr#r/r4rrOrr8rr[r`rp)r_r>rrrrJrrrEr>rrlr match_count _strategyrOrmerr_msgrn file_endingrc verify_cmd verify_result_verify_bomless_verify_stdout_normalized_new_content_normalizedrwris r&rz!ShellFileOperations.patch_replaces  &&(--  -V,,, ,E$0066DDDjj**  A % %%CT%C%CDDD D$  ((  =<<<<<5K5K Z[6 6 2 [)U  .K1$$ = < < < < <!!':zBB " "@<@@@@ OOOOG BBBBBB//jRYZZZ    W--- -*'22  L1+{KKK t[3>'@@   W%UAS%U%UVVV VGD22488FFF  :..  "a ' '%`Z^%`%`aaa a( (<==$3$;$;FD$I$I$Q$QRVX\$]$]!"-"5"5fd"C"C"K"KDRV"W"W $(? ? ?MdMM566MM011MMM !!';== ,,TwU`,aa  6*5?$$&&&4)8    s0D DDrctddlm}m}||\}}|rtd|S|||}|S)a Apply a V4A format patch. V4A format: *** Begin Patch *** Update File: path/to/file.py @@ context hint @@ context line -removed line +added line *** End Patch Args: patch_content: V4A format patch string Returns: PatchResult with changes made r)parse_v4a_patchapply_v4a_operationszFailed to parse patch: r)tools.patch_parserrzr{ru)r_rrzr{ operations parse_errorrs r&rzShellFileOperations.patch_v4a sm( MLLLLLLL"1/-"@"@ K  N%L{%L%LMMM M&%j$77 r(ctj|d}t|}||Ud||d}||}|jdkrtdd|d S|j }||\}}|d krtdd |d  St||rd n|S|tvrtdd|d S|dkr&| |rtdd S|tvr*||rtdd|d St|} | d} || std| d S| d||} || d} | jdkrt'| | j rzddlm} | | j }t/d|D|dd}td| d|dd St| jdk| j r| j nd S)u8 Run syntax check on a file after editing. Prefers the in-process linter for structured formats (JSON, YAML, TOML) when possible — those parse via the Python stdlib in microseconds and don't require a subprocess. Falls back to the shell linter table for compiled/type-checked languages (py_compile, node --check, tsc, go vet, rustfmt). Args: path: File path (used to select the linter + for shell invocation). content: Optional file content. If provided AND an in-process linter matches the extension, we lint the content directly without re-reading the file from disk. Ignored for shell linters. Returns: LintResult with status and any errors. rNr<rrTzFailed to read z for lint)rrr)zNo linter available for z (missing dependency)rrvrzNo linter for z filesruProject tsconfig.json detected — per-file tsc skipped (single-file tsc can't resolve project aliases/globals; use the LSP tier or `tsc -p tsconfig.json` for real diagnostics).zLSP server handles u — shell linter skippedz not availablez{file}r'ri) strip_ansic3fK|],}||V-dSrUrrWlns r&rz2ShellFileOperations._check_lint.. s7IIbhhjjIIIIIIIr(xz not usable: )rr>rrrSrr|rqrrrLINTERS_has_ancestor_tsconfig_SHELL_LINTER_LSP_REDUNDANT_lsp_will_handlerrurrrtools.ansi_striprrnextr)r_r>rErinprocrrrerr linter_cmdr rrrrr% first_lines r& _check_lintzShellFileOperations._check_lint> sP(gt$$Q'--// ##C((  L$"8"8">">LLL"jj22 (A--%d<]d<]<]<]^^^^%,fWooGBj  !$8mSV8m8m8mnnnnbr1BsCCC C g  d4PS4P4P4PQQQ Q %<z8ShellFileOperations._check_lint_delta.. s-PPPBRXXZZPRXXZZPPPr(chg|].}||v,|/Sr-r)rWr pre_liness r&rz9ShellFileOperations._check_lint_delta.. s9jjjRrxxzzjbhhjj`iNiNibNiNiNir(Fu^Pre-existing lint errors — this edit didn't introduce new ones but the file is still broken.)rvrrzLNew lint errors introduced by this edit (pre-existing errors filtered out): r,r)rrvrrrrr!)r_r>rrQpostpre post_linesrs @r&r[z%ShellFileOperations._check_lint_delta s-Ll;; < 4< K  Kt[99 ; #+ SZ KQP#**?*?*A*APPP jjjj4;#9#9#;#;jjj  {x  8:>))J:O:OP    r(c~t|dd}|dS ddlm}n#t$rYdSwxYwt ||S)u}Return True iff this FileOperations is wired to a local backend. LSP servers run on the host process — they need access to the files they're linting. Remote/sandboxed backends (Docker, Modal, SSH, Daytona) keep files inside the sandbox where the host-side LSP server can't reach them, so we skip the LSP path for those entirely. rcNFr)LocalEnvironment)rdrrr# isinstance)r_rcrs r&_lsp_local_onlyz#ShellFileOperations._lsp_local_only sndE4(( ;5  A A A A A A A   55 #/000s  ,,rc|sdS ddlm}n#t$rYdSwxYw|}|D]}||jvrdSdS)uReturn True iff some registered LSP server claims this extension. Used to decide whether to capture pre-write content for the line-shift map. Capturing is cheap (one ``cat`` on the host) but pointless if no LSP would ever look at the file. Safe to call on remote backends — the registry is purely in-process metadata; we still gate the actual LSP path on :meth:`_lsp_local_only`. Fr)SERVERST)agent.lsp.serversrr#r extensions)r_rr ext_lowersrvs r&rTz*ShellFileOperations._lsp_handles_extension s 5  1 1 1 1 1 1 1   55 IIKK   CCN**tt+us  c|sdS tjtj|} tjtj|drdStj|}||krdS|}i#t$rYdSwxYw)uTrue iff a tsconfig.json exists in *path*'s directory or any ancestor. A single-file ``tsc`` invocation can't read that config, so its diagnostics for such a file are pure noise (unresolved aliases / ambient globals). Used by :meth:`_check_lint` to skip the per-file shell tsc for project TypeScript files. Best-effort and local-host only: a host-side ``os.path`` walk. On a remote/sandboxed backend the project tree isn't on this host, so the walk returns False and the shell linter runs exactly as before — never suppress lint based on a probe that couldn't answer. FTz tsconfig.json)rrr>rabspathisfiler!r#)r_r>drs r&rz*ShellFileOperations._has_ancestor_tsconfig1 s##%% 5  5 566A 7>>"',,q/"B"BCC 4++Q;; 5     55 sA:B>%B>;B>> C  C c |sdS ddlm}n#t$rYdSwxYw |}n#t$rYdSwxYw|dS t ||S#t$rYdSwxYw)u!Return True iff the LSP service is active AND will lint this file. Stronger than :meth:`_lsp_handles_extension` — that one only checks the static server registry. This one additionally requires the LSP service to be configured/enabled and the file to pass :meth:`agent.lsp.manager.LSPService.enabled_for` (which gates on workspace detection, disabled-server set, and the broken-pair short-circuit). Used by :meth:`_check_lint` to decide whether to skip the per-file shell linter for extensions in ``_SHELL_LINTER_LSP_REDUNDANT``. Best-effort: any failure path returns False so the shell linter runs as before — never suppress lint based on an LSP probe that couldn't actually answer the question. Fr get_service)r agent.lsprr#r< enabled_forr_r>rsvcs r&rz$ShellFileOperations._lsp_will_handleL s"##%% 5  - - - - - - -   55  +--CC   55  ;5 --.. .   55 s- -- < A  A !A44 BBc|sdS ddlm}|}n#t$rYdSwxYw|dS ||dS#t$rYdSwxYw)uLCapture pre-edit LSP diagnostics so the post-write delta is correct. Best-effort. Silent on every failure path — LSP is an enrichment layer and must never break a write. Skipped entirely on non-local backends (Docker, Modal, SSH, etc.) — the server can't see files inside the sandbox. Nrr)rrrr#snapshot_baseliners r&rUz*ShellFileOperations._snapshot_lsp_baselinen s##%%  F  - - - - - -+--CC    FF  ; F   ! !$ ' ' ' ' '    DD s) 77A A$#A$rPc|sdS ddlm}n#t$rYdSwxYw |}n#t$rYdSwxYw|||sdSd}|.|,||kr& ddlm}|||}n#t$rd}YnwxYw ||d|}n#t$rYdSwxYw|sdS ddlm } m } | ||} | sdS| d | zS#t$rYdSwxYw) uBest-effort LSP semantic diagnostics for ``path``. Returns a formatted ```` block, or empty string when LSP is unavailable / disabled / produced no errors. When both ``pre_content`` and ``post_content`` are provided, a line-shift map is built and passed to the LSPService so baseline diagnostics are remapped into post-edit coordinates before the set-difference. Without this, edits that delete or insert lines surface every pre-existing diagnostic below the edit point as "introduced by this edit". Wraps everything in a try/except so a misbehaving LSP server can't break a write. This intentionally swallows all errors — the calling tier already returned a clean syntax result, so ``""`` here just means "no extra info to add". Skipped entirely on non-local backends (Docker, Modal, SSH, etc.) — same reasoning as ``_snapshot_lsp_baseline``. rrrN)build_line_shiftT)delta line_shift)report_for_filetruncatez)LSP diagnostics introduced by this edit: ) rrrr#ragent.lsp.range_shiftrget_diagnostics_syncagent.lsp.reporterrr) r_r>rrQrrrrrrrrjs r&r\z*ShellFileOperations._maybe_lsp_diagnostics s6##%% 2  - - - - - - -   22  +--CC   22  ;cood33;2   "|'?KS_D_D_ "BBBBBB--k<HH  " " "!  " 224tPZ2[[KK   22  2  D D D D D D D D#OD+66E r8H5PQQ Q   22 sW -- < A  A 3B BBB22 C?CC. C.. C<;C<rrrrr0rrrc *t||\}}||}|d||d} d| jvr|||||||||} | | St j|pd} t j |} d|g} |d|| d}d |jvr=| r:|d || d }|j d kr|j r| }g}|j d D]q}|s| }||vs!||vs||ddr3|t j| |r|r3| dd|ddzt#d| d S|dkr|||||S||||||||S)a\ Search for content or files. Args: pattern: Regex (for content) or glob pattern (for files) path: Directory/file to search (default: cwd) target: "content" (grep) or "files" (glob) file_glob: File pattern filter for content search (e.g., "*.py") limit: Max results (default 50) offset: Skip first N results output_mode: "content", "files_only", or "count" context: Lines of context around matches Returns: SearchResult with matches or file list test -e ! && echo exists || echo not_found not_foundNrzPath not found: ztest -d z && echo yes || echo nortrz 2>/dev/null | head -20rr,rzSimilar paths: rrz. rOrr)rTrrqr|r_try_multi_path_searchrr>rrrrrrr6r r!r _search_files_search_content)r_rr>r0rrrrrcheckmultirbasename_queryr parent_checkrlower_qrrles r&rzShellFileOperations.search s&4FEBB   && ed&<&> >r(c Dd|dD} t| dkrdSgg} } | D]c} || } |d|| d}d|jvr| n| | d| sdSt}| D]} |dkr||| ||}n| || |||||}|j rD|j |j |j |j |j|j|xj|jz c_|jp|j|_|j d||_ |j d||_ d t| d t| d }| rO|d d | ddzz }t| dkr|dt| dz dz }||_|S)aRecover a not-found ``path`` that is really several paths in one string. Production trajectories show models passing "dir1 dir2 dir3" (or comma-separated lists) as ``path``. Split on whitespace/commas; when at least one candidate exists and at least two candidates were given, search every existing path, merge results, and note skipped parts. Returns None when this doesn't look like a multi-path string. chg|]/}|D]}||0Sr-)rr)rWchunkrs r&rz>ShellFileOperations._try_multi_path_search.. s:TTTuTTA!''))TTTTTr(rr%Nrrexistsrzpath contained z entries; searched z that existz; skipped missing: rr (+ more))rr8rrqr|rr rrrrOrextendrrupdaterrHr!rq)r_rr>r0rrrrrpartsexistingmissingrexpandedchkmergedrr|s r&rz*ShellFileOperations._try_multi_path_search s`UT 3TTT u::>>4' O OA((++H**^411(;;^^^C"SZ//XXW D DX N N N N 4 A AA  ((!UFCC**7Ay%+6AAy  N ! !#+ . . . L   * * * M  , , ,   #/ 1  %/@3=F  /|FUF+ ZUZZH ZZZ  7 )DIIgbqbk,B,BB BD7||a6c'llQ.6666 r(c |dsdSdtfd}ddtdtfd}|rd ||nd }|d |d ||d ||d d}||j\}} |dkr"d|dt| d|| dS|d|d ||d ||d d} || j\} } | dkr"d| dt| d|| dStj d|r|d|d ||d ||d d} || j\}}|dkr"d|dt|d||dSdS) aReturn a hint for a 0-match content search, or None. 13.9% of production content searches return zero matches and give the model nothing to steer by. Run ONE cheap case-insensitive count probe; if it hits, say so. If the pattern contains regex metacharacters, also probe it as a fixed string. Bounded: two rg invocations max, count-only output. rgNrcd}g}|pdD]V}|d\}}}|r'|t |z }||W||fS)z3Parse ``path:count`` lines from rg --count-matches.rr:)rr rpartitionisdigitrgr )rtotalper_filer#r_sepns r&_tallyz5ShellFileOperations._zero_match_probe.._tallyQ sEH2,,..99;; ' '!__S11 499;;'SVVOEOOA&&&(? "r(rcaprcd|d|}t||z }||dkrd|dndzS)Nrrrrr)r!r8)rrshownextras r& _paths_notez:ShellFileOperations._zero_match_probe.._paths_note\ sOIIhttn--EMMC'E5199/%////"E Er(z --glob rzrg -i --count-matchesryr r'rrz0 exact matches, but z case-insensitive match(es) in z file(s): u' — the pattern's casing may be wrong.z'rg --hidden --no-ignore --count-matchesz 0 matches in visible files, but z match(es) in z hidden or gitignored file(s): u# — these are excluded by default.z[.\[\](){}?*+^$\\|]zrg -F --count-matchesz0 regex matches, but z literal match(es) in ug — the pattern contains regex metacharacters that likely need escaping (or pass a simpler substring).)r) rurergr|rqrrr8rr)r_rr>rrr glob_exprprobeci_totalci_pathshiddenh_totalh_pathsfixedf_totalf_pathss r&_zero_match_probez%ShellFileOperations._zero_match_probeD s)  && 4 #3 # # # # F Fs F3 F F F F GPWBt55i@@BBBUW   &I & &%%g.. & &151M1Md1S1S & & &    $VEL11( a<<555(mm55/:{8/D/D555  &i & &%%g.. & &151M1Md1S1S & & &    "6&-00 Q;;M7MMw<<MM;w''MMM  9+W 5 5 JJ* **))'22**595Q5QRV5W5W*** E &vel33 GW{{>G>>7||>>/:{7/C/C>>> tr(c~|dsd|vr|}n|dd}t|}td|jD}|dr|||||S|dstdS|sd nd }|rd |nd } d } |s d |d zd|} d||| d||d| } | | d} t| \} }| s^|s\d||| d||d| }| |d} t| \} }g}| dD]}|s|d d }t|dkrJ|d dd r||d x|||r|}g}|D]} t||j}n$#t$$rt|j}YnwxYwtd|Dr{||||||z}t|t|t'||S)z-Search for files by name pattern (glob-like).z**/rbrc3HK|]}|dvo|dVdS>..rrNr6rWparts r&rz4ShellFileOperations._search_files.. sL' '   # <(<(<' ' ' ' ' ' r(rrzFile search requires 'rg' (ripgrep) or 'find'. Install ripgrep for best results: https://github.com/BurntSushi/ripgrep#installationrz-not -path '*/.*'rryz | tail -n +rz | head -n zfind z -type f -name z* -printf '%T@ %p\n' 2>/dev/null | sort -rnr$rz 2>/dev/null | sort -rnr,r%rrc3HK|]}|dvo|dVdSrrrs r&rz4ShellFileOperations._search_files.. s8^^Dt;.G4??33G3G^^^^^^r(rrrHr)r6rr rrru_search_files_rgrr|rqrrr8rrr resolve relative_torDr<)r_rr>rrsearch_pattern search_roothas_hidden_path_ancestorhidden_excludehidden_filter_exprpagination_exprrrrrr cmd_simplerr#rnormalized_rootfiltered_files file_path rel_partss r&rz!ShellFileOperations._search_files s!!%(( 4S-?-?$NN$]]3//3N4jj #&' ' #)' ' ' $ $     T " " N((ufMM M  (( K 5MT,,RT5CK1111 ' LKVaZKKEKKOMd,,T22M4FMMW[WmWmn|W}W}MM;JMMC,,7?? ||~~ Dl DC!7!7!=!=C?QCCbfbxbxzHcIcICC1@CCJZZ BZ77F#;F#C#C FLLLNN((.. # #D JJsA&&E5zzQ58#3#3C#<#<#D#D#F#F U1X&&&& T"""" $ :)1133ON" 1 1 6 $Y 7 7 9 9 E Eo V V \II!666 $Y 5III6^^T]^^^^^%%i0000"6&5.#89EE <((%     s79J11KKcd|vr|dsd|}n|}||z}d||d||d|}||d}t |\} } d| d D} | s| sd ||d||d|} || d}t |\} } d | d D} | |||z} t| t| t| |kpt| | S) adSearch for files by name using ripgrep's --files mode. rg --files respects .gitignore and excludes hidden directories by default, and uses parallel directory traversal for ~200x speedup over find on wide trees. Results are sorted by modification time (most recently edited first) when rg >= 13.0 supports --sortr. rb*zrg --files --sortr=modified -g ryz 2>/dev/null | head -n r$rcg|]}||Sr-r-rWr6s r&rz8ShellFileOperations._search_files_rg.. s@@@1a@Q@@@r(r,zrg --files -g cg|]}||Sr-r-r s r&rz8ShellFileOperations._search_files_rg.. DDDq!DDDDr(r) r6r|rrqrrrrr8r<)r_rr>rr glob_pattern fetch_limit cmd_sortedrrr all_files cmd_plainpages r&rz$ShellFileOperations._search_files_rg s g  g&8&8&=&= (w==LL"Lfn  'd.D.D\.R.R ' '++D11 ' '$ ' '  J337?? @@  4 4T : :@@@  E E+!7!7 !E!E++//55++(++  ZZ 2Z66F#;F#C#C FLDDFLLNN$8$8$>$>DDDI./I)nn 3ItL7I7I%     r(c d}|drd}||||||||} nA|dr||||||||} ntdS| jsg| jdkr\| jsU| jsN| jsG | |||} n#t$rd} YnwxYw| r| j s| n | j d | | _ |r| St| |S) z,Search for content inside files (grep-like).FrTgrepzqContent search requires ripgrep (rg) or grep. Install ripgrep: https://github.com/BurntSushi/ripgrep#installationrrNry) ru_search_with_rg_search_with_greprrOrrrrrr#rqr\) r_rr>rrrrrused_rgrrIs r&rz#ShellFileOperations._search_content sn   T " " G))'4E6*5w@@FF   v & & ++GT9eV,7BBFF \   \!3q!8!8"9/5|"9DJM"9 --gtYGG     \-3^![FNA[A[UYA[A[  M8IIIsB77 CCc  gd}t|} | r|d|dkr$|dt|g|r*|d||g|dkr|dn|dkr|d |||||||dkr||zd zn||z} |d d d t| gdd|z} || d} t| \} }t| \}}| j dkrW| sC| p| j pd}td|dS|} | rdnd}|dkrnd| dD}t|}||||z}t||t!|||S|dkri}| dD]_}d|vrY|dd}t|dkr0 t%|d||d<O#t&$rY[wxYw`t|t)|t!||St-jd}g}| dD]}|r|dkr ||}|r|t3|dpd |dzt%|d!|d"dd#$|dkrPt7|}|r?|t3|d|d|ddd#$t|}||||z}t|||||zkpt!|||%S)&zSearch using ripgrep.)rz --line-numberz --no-headingz--with-filenamerYr-Cz--glob files_only-lcount-crrr.-nset -o pipefail; ryr$rr% Search errorSearch failed: rutPattern contains \n — multiline mode (-U) was enabled automatically so the regex can match across line boundaries.Ncg|]}||Sr-r-r s r&rz7ShellFileOperations._search_with_rg.. rr(r,)rrrHrrqrrrrrHr^([A-Za-z]:)?(.*?):(\d+):(.*)$rrrrr)rrrHrrq)rWr rrer|rr!rqrrrrrrrr8r<rsplitrgrDrvaluesrcompilerrrr)r_rr>rrrrr cmd_parts multilinerrrrrrrr error_msg_ml_noterrrrr#r _match_rerrparseds r&rz#ShellFileOperations._search_with_rg; sBONN /w77  ,   ] + + + Q;;   dCLL1 2 2 2  L   h(>(>y(I(IJ K K K , & &   T " " " " G # #   T " " " //88999 55d;;<<< /6kkefns**uv~ #vtS-=-=>???"CHHY$7$77C,,7?? 7v>> W  q  #))++Vv}/B/B/D/DVI&C &C&CQRSSS S! = =   , & &DDFLLNN$8$8$>$>DDDI NNEVFUN23D!|,,)  G # #F ,,T22 ! !$;; KKQ//E5zzQ!/258}}F58,,)!!! D! 00|,,)   #DEEIG ,,T22  tt||OOD))NN;ggajj.B!''!**<$' OO ! 4C4 0$$$ Q;;7==F{!'(.q $*1IdsdO((( LLE6&5.01D!&5.0FD4F4F)  sK00 K=<K=c X ddg}|d|dkr$|dt|g|r*|d||g|dkr|dn|d kr|d ||||d p!t t jd |} | r||} nB|d r |ddn|} d} | dvr| d|| z } || ||z|dkrdndz} |dddt| gdd|z} | | d}t|\}}t|\}}|j dkrW| sC| p|j pd}td|dS|}|dkrmd| dD}t#|}||||z}t||t || S|d kri}| dD]_}d!|vrY|d!d"}t#|dkr0 t'|d"||d<O#t($rY[wxYw`t|t+|t ||#St jd$}g}| dD]}|r|d%kr ||}|r|t1|d"pd&|dzt'|d'|d(dd)*|dkrPt5|}|r?|t1|d|d"|ddd)*t#|}||||z}t|||||zkpt ||+S),zFallback search using grep.rz-rnHEz--exclude-dir='.*'rrz --includerrrr )rbz\\z^[A-Za-z]:[\\/]z./r%Nz"$PWD">rrrbrrr.r!r"ryr$rr#r$rcg|]}||Sr-r-r s r&rz9ShellFileOperations._search_with_grep.. rr(r,rrrr&r'rrrrr(r)rrrHr)r rrer|r6r<rrr!rqrrrrrrrr8r)rgrDrr*r+rrr)r_rr>rrrrrr, is_absoluter relative_pathrrrrrrrrr.rrrrr#rr0rrr1s r&rz%ShellFileOperations._search_with_grep sW%  -... Q;;   dCLL1 2 2 2  O   k4+A+A)+L+LM N N N , & &   T " " " " G # #   T " " " //88999oom44  H' . .9 9   K0066KK(,(=(=GDHH4M"KI--J4#9#9-#H#HJJJ %%%fnw{{B #vtS-=-=>???"CHHY$7$77C,,7?? 7v>> W  q  #))++Vv}/B/B/D/DVI&C &C&CQRSSS S , & &DDFLLNN$8$8$>$>DDDI NNEVFUN23D!|,,)  G # #F ,,T22 ! !$;; KKQ//E5zzQ!/258}}F58,,)!!! D! 00|,,)   #DEEIG ,,T22  tt||OOD))NN;ggajj.B!''!**<$' OO ! 4C4 0$$$ Q;;7==F{!'(.q $*1IdsdO(((LLE6&5.01D!&5.0FD4F4F)  s4M M M rU)NNN)rv)rrrr)@rarbrcrdrergrgrrqr<rur staticmethodbytesrrrrrr|rrrrrrrrDrrrrrrrrrrkrrrDrrrurrrrr[rrTrrrUr\rrrrrrrrrr-r(r&r^r^os !2!2#!2!2!2!2FCG $% % S% s% C% % )6% % % % N((((((sC>  $   \ Dc3$:'c'd'''' #####c####4######J7S7S7777"737377778V6#V6V6V6V6V6V6p77S7x}7X`adXe7777*,,#,HSM,T,,,,(  3 # RU     C C    0     \ $(\ C\ \ S\ #&\ +A\ \ \ \ |  c 3 3 *    B*3*8C=****X9 39 :9 9 9 9 v, #, *, , , , \  C HSM Z    B:: ::::>>>>>>>>*3*4*K****X S s {    (15K K sK SK ( K 9DK K K K d+0Q Q #Q 3Q CQ #'Q 4?Q Q Q Q fs{F>cF>F>CF>"3-F>7:F>ILF>F>69F>BNF>F>F>F>P/c//c/*23-/@C/MP/,//:=/BJA$JLO$JT`$J$J$J$JLNsN#N(3-N"N,/N>ANLONT`NNNN`GGCGHSMG!$G.1G@CGNQGVbGGGGGGr(r^)_rdr~rrrrrXrrabcrr dataclassesrrtypingrrr r r pathlibr tools.binary_extensionsr agent.file_safetyrrrrr@rer_HOMEWRITE_DENIED_PATHSWRITE_DENIED_PREFIXESr+rrr'r/r4r7tupler<r:r=rBrDrkrurrrrrrrrrgrrrfr7rrrrr frozensetrrrr'r0r4r:rSrR MAX_LINESMAX_LINE_LENGTHrrJrKrRrSrrErPrTrVrWrZr\r^r-r(r&rEsd4   ########((((((((66666666666666555555 IDIKK--e4433E::2:BCC2:LMM"c"c""""" ,#ss:  SU39-58C=5T5555 )3)4)))) UUUUUUU U& IIIIIII I0 %%%%%%% %P   IIIIIII IX              'BJ'QRR]uS(3-=O7P.6C.6E#s(O.6.6.6.6lBJRSS9S9U3S=-AD-H9999:5<%C"G%GSGSGGGG"@ @ @ @ @ S@ @ @ PNMM . % )  (   X(i(=(=(=>>   . -# -s -t - - - - 1s 1uT3Y'7 1 1 1 11s1uT3Y'71111@1s1uT3Y'7111111tSy)911110      *%9%H%H%HII   0sSS-@+=//c/%(/BGS/////&/D-A///'*/FKCQTHo////&2:&<== M M M M M MP8C=PTPPPP l S Ua     c'c'c'c'c'.c'c'c'c'c'r(