yj/ dZddlZddlZddlZddlZddlZddlZddlZddlm Z m Z ddl m Z m Z ddlmZmZmZmZmZddlmZddlmZddlmZmZmZmZeejZ 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 GddZ/e GddZ0e GddZ1e GddZ2e Gdd Z3e Gd!d"Z4e Gd#d$Z5ej#d%Z6d&e5d e*eeeffd'Z7d(ed e*eeffd)Z8ej#d*Z9d+ed e*ee:efdzfd,Z;Gd-d.e Ze?hd6Z@d7d8d9d:ZAd;ed(ed e+fd<ZBd=ed e*e+effd>ZCd=ed e*e+effd?ZDd=ed e*e+effd@ZEd=ed e*e+effdAZFeFeCeDeDeEdBZGe?hdCZHdDZIdDZJdEZKdFZLdDZMdZNdGZOdHZPdIedJe:d e:fdKZQeLeMfdLedMed e*e:e:ffdNZReNeOfdLedMed e*e:e:ffdOZSej#dPZTdQed e+fdRZUdSeed e+fdTZVd&e3dQed e3fdUZWGdVdWe<ZXdS)Xa\ 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 ;/home/ragecks/.hermes/hermes-agent/tools/file_operations.py_strip_terminal_fence_leaksr'@s  !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/Qs? 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_endingsr4gs\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..9s8%%%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(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_raws  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_replacerr( patch_contentcdS)zApply a V4A format patch.Nr-)r_rs r& patch_v4azFileOperations.patch_v4arr(cdS)z>Delete a file. Returns WriteResult with .error set on failure.Nr-rs r& delete_filezFileOperations.delete_filerr( 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_paths3  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_filerr(.2rpatternr0 file_glob output_modecontextc dS)zSearch for content or files.Nr-) r_rr>r0rrrrrs r&searchzFileOperations.searchs 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>rrr)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..ns',,aqEz,,,,,,r()_LINTER_UNUSABLE_PATTERNSgetrany)rrpatternsrs @r&_looks_like_linter_unusabler asU),,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_inprocrqs1 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__r Fz YAMLError: r)yaml ImportErrorparse YAMLErrorrrra)rE_yaml_eventrs r&_lint_yaml_inprocr#}s"      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. rNr r rrrFr) astr SyntaxErrorrrrrarr)rE_astrlocs r&_lint_python_inprocr-s1 7x ::::;(J666186666a)99QU9C999999999 111a)00Q0000000001s, B=A*$B* B7BBB)r.json.yaml.yml.toml>r0r.r1r/rirr__hermes_not_regular__valuedefaultcT t|S#ttf$r|cYSwxYw)z8Best-effort integer coercion for tool pagination inputs.)rg TypeError ValueError)r3r4s r& _coerce_intr8s<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_limitsr:maxr8DEFAULT_READ_OFFSETDEFAULT_READ_LIMITmin)rrr: max_linesnormalized_offsetnormalized_limits r&normalize_read_paginationrCst766666 IA{63FGGHH"5*<==1c"2I>>?? . ..r(ctdt|t}tdt|t}||fS)zCReturn safe search pagination bounds for shell head/tail pipelines.rr)r<r8DEFAULT_SEARCH_OFFSETDEFAULT_SEARCH_LIMIT)rrrArBs r&normalize_search_paginationrGsFA{63HIIJJ1k%1EFFGG . ..r(z(?Z)dYd edeede*fd?Z+ dYd edeed@eede*fdAZ,de fdBZ-dCede fdDZ.d ede fdEZ/d eddfdFZ0dddGd edeed@eedefdHZ1 d_dLed edMedNeed)ed(edOedPede2fdQZ3dLed edMedNeed)ed(edOedPedee2fdRZ4dLed edNeedeefdSZ5dLed ed)ed(ede2f dTZ6dLed ed)ed(ede2f dUZ7dLed edNeed)ed(edOedPede2fdVZ8dLed edNeed)ed(edOedPede2fdWZ9dLed edNeed)ed(edOedPede2fdXZ:dS)`ShellFileOperationsz 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. rRNconfig/)envgetattrrR_command_cache)r_ terminal_envrRs r&__init__zShellFileOperations.__init__6se0  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. r\Nr]rR returncoder stdin_errorrrr)rr)rWrVrRexecuterr) r_r[rRr\r]kwargs effective_cwdrrs r&_execzShellFileOperations._execYs"  ( '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)rXrdrr)r_rers 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)rd_escape_shell_argrr'rr!rr fullmatchbase64 b64decodebinasciiErrorr7)r_r>rjrencodeds 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�Nric3HK|]}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 sumr?r8)r_r>rext non_printables r&_is_likely_binaryz%ShellFileOperations._is_likely_binarys 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_images4gt$$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]|)r;rr enumerater8r r!) r_rErrmax_line_lengthrnumberedir#s r&_add_line_numbersz%ShellFileOperations._add_line_numberss 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~/rNrUz[a-zA-Z0-9._-]+zecho ~) r6rdrrrfindrrpr8) r_r>rhomerest slash_idxusername expand_result user_homesuffixs r& _expand_pathz ShellFileOperations._expand_pathsr 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'z'"'"')tools.environments.localrr)r_rrs r&roz%ShellFileOperations._escape_shell_arg*sC =<<<<<oc""S[[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)r])rorr>dirnamerd)r_r>rEq_pathparentq_parenttmplscripts r& _atomic_writez!ShellFileOperations._atomic_write;s$''--&&-#))&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/rordrrr_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)rordrrr=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)roNOT_REGULAR_SENTINEL)r_r>rs r&_size_probe_cmdz#ShellFileOperations._size_probe_cmdsX"$$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_errors5KKKK    r(rrrc ||}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 }|||} | rt%d| dSddlm}d|zd z}||zd z }d|d|d||d|}||}|jdkrt%d|j St|j }|d krt=|\}}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).rlTzImage file detected. Automatically redirected to vision_analyze tool. Use vision_analyze with this file path to inspect the image contents.)rKrJrGrIr head -c 1000 rzUBinary file - cannot display as text. Use appropriate tools to handle this file type.rJrGrOrzsed -n ',zp' z | cut -b1-Failed to read file: rzwc -l < z Use offset=z to continue reading (showing -z of z lines)r,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 <= r)rErFrGrHrI)!rrCrdrr_unicode_variant_matchrrI_suggest_similar_filesr'rrrrrgr7 MAX_FILE_SIZErrDrvrr>rrr r~rorr;rr:endswithr) r_r>rr stat_resultvariantrr| stat_outputrG sample_bytes ext_binaryrJ sample_cmd sample_result sample_outputrline_clamp_bytesend_lineread_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  #m < A@@@@@22444q8E>A% -v - - - -T-C-CD-I-I - -* - - jj**  A % %$PK>/   K # # # #! # # # # #'#&F&&#&&"&&&    **;??#     s$ !D.. D=<D=2!M M#"M#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. rNnamercltjd|}dD]\}}|||}|S)NNFC))u rl) rl)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(rrU)rr>rbasenamererordrrrr'rr8r!) r_r>dir_pathls_cmd ls_result candidatesrrr0s @@@r&rz*ShellFileOperations._unicode_variant_matchsb7??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>rrrrrordrrrrr6r8setr<rSequenceMatcherratior 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} ||| }|rtd|d S|d ||} | jdkrtd | j St/t | 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)rKrJrGNrrru'Binary file — cannot display as text.rcat rr)rErG)rrdrrrr'rrrrrgr7rrDrvrr>rrr r~rorr:) r_r>rrrGrrrJrr cat_result raw_contentrs r&rz!ShellFileOperations.read_file_raw si   &&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  )? ZZ Et'='=d'C'C E EFF  1 $ $$OJrrrrGrucompacts r&rz#ShellFileOperations.read_file_bytes9sC  &&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_fileZs""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). rrrs r&rzShellFileOperations.delete_pathds ""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) z python3 -c rpython3rz python -c zFailed to delete rz unknown error) rrrkr<rdrorrr)r_r>rdeniedsnippetrs r&rz"ShellFileOperations._python_deletels<  &&'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.Mover#rzmv rlrzFailed to move z -> r)rrrkrdrorr)r_rrrr&rs r&rzShellFileOperations.move_files$$$$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.rNrz': candidate content fails z syntax validation (zC). The file was NOT created or modified. Fix the content and retry.rrr+rysurrogateescapezFailed 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_extensionrordrrrr4rr=r7_snapshot_lsp_baselinerr<encodeUnicodeEncodeErrorrr8rrhashlibsha256 hexdigestr_check_lint_deltarvr_maybe_lsp_diagnosticsr`)r_r>rErr&rr inproc_linter_ok _lint_errwant_prerroriginal_endingrrm content_bytesr} write_resultrlcontent_verifiedhash_cmd hash_resultdisk_sha expected_sha lint_resultrpblocks r&rzShellFileOperations.write_filesT  &&(--  -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 rrrrr)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,r2r,z5: 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.r-N)rvrwrxrorp)rrrurordrrr:tools.fuzzy_matchrIrJrKrr/r4rrOrr8rr8r`rp)r_r>rrrr&rrrErrrIr match_count _strategyrOrJerr_msgrK file_endingr@ verify_cmd verify_result_verify_bomless_verify_stdout_normalized_new_content_normalizedrwrFs 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_parserrWrXru)r_rrWrX operations parse_errorrs r&rzShellFileOperations.patch_v4aOsm( MLLLLLLL"1/-"@"@ K  N%L{%L%LMMM M&%j$77 r(c`tj|d}t|}||Ud||d}||}|jdkrtdd|d S|j }||\}}|d krtdd |d  St||rd n|S|tvrtdd|d 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. rNrrrTzFailed to read z for lint)rrrzNo linter available for z (missing dependency)rrvrzNo linter for z fileszLSP server handles u — shell linter skippedz not availablez{file}rr\) strip_ansic3fK|],}||V-dSrUrrWlns r&rz2ShellFileOperations._check_lint..s7IIbhhjjIIIIIIIr(xz not usable: )rr>rrr0rrordrrrLINTERS_SHELL_LINTER_LSP_REDUNDANT_lsp_will_handlerrhrr tools.ansi_stripr_rnextr)r_r>rErinprocrrrerr linter_cmdrrerr_r% first_lines r& _check_lintzShellFileOperations._check_lintms(gt$$Q'--// ##C((  L$"8"8">">LLL"jj22 (A--%d<]d<]<]<]^^^^%,fWooGBj  !$8mSV8m8m8mnnnnbr1BsCCC C g  d4PS4P4P4PQQQ Q - - -$2G2G2M2M -LcLLL  S\ ##%%a(  ** Qdx4O4O4OPPP P  4+A+A$+G+GHHC,,  q %@6=%Y%Y 4 3 3 3 3 3 j//5577GIIg&8&8&:&:III J#DD*TcT2BDD  $),2M,?,?,A,AI6=&&(((r    r(r.c|||}|js|jr|S||S|||}|js|js|js|Sd|jDfd|jD}|st d|jdSt ddd |z S) u\ Run post-write syntax lint with pre-write baseline comparison. Two-tier strategy: 1. **Syntax check** (in-process or shell-based, microseconds). Catches the bug class that motivated this layer: corrupt writes, mashed quotes, truncated output. Hot path. 2. **Delta refinement against pre-write content** when the syntax tier reports errors. Filter out errors that already existed pre-edit so the agent isn't distracted by inherited state. Semantic diagnostics from the LSP layer are fetched separately via :meth:`_maybe_lsp_diagnostics` and surfaced in the ``lsp_diagnostics`` field on :class:`WriteResult` / :class:`PatchResult`. Keeping the two channels separate lets the agent (and any downstream parsers) read syntax errors and semantic errors as independent signals. Args: path: File path (for linter selection). pre_content: File content BEFORE the write. Pass None for new files or when the pre-state isn't available — the delta refinement is skipped and all post errors are returned. post_content: File content AFTER the write. Optional; if None, the shell linter reads from disk (same as _check_lint). Returns: LintResult. ``output`` contains either the full post-lint errors (no pre-state) or just the new-error lines (delta refinement applied). )rENc^h|]*}||+Sr-rarbs r& z8ShellFileOperations._check_lint_delta.. s-PPPBRXXZZPRXXZZPPPr(chg|].}||v,|/Sr-ra)rWrc 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])rorvrrrrr!)r_r>rr.postpre post_linesrts @r&r8z%ShellFileOperations._check_lint_deltas-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. rVNFr)LocalEnvironment)rWrryr isinstance)r_rVrys 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.serversr}rr extensions)r_rr} ext_lowersrvs r&r1z*ShellFileOperations._lsp_handles_extension/ s 5  1 1 1 1 1 1 1   55 IIKK   CCN**tt+us  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.lsprrr< enabled_forr_r>rsvcs r&rhz$ShellFileOperations._lsp_will_handleF 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)r{rrrsnapshot_baseliners r&r2z*ShellFileOperations._snapshot_lsp_baselineh s##%%  F  - - - - - -+--CC    FF  ; F   ! !$ ' ' ' ' '    DD s) 77A A$#A$r-c|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: ) r{rrrragent.lsp.range_shiftrget_diagnostics_syncagent.lsp.reporterrr) r_r>rr.rrrrrrrrGs r&r9z*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 norgrz 2>/dev/null | head -20rr,rzzSimilar paths: , rz. rOrr)rGrrdror_try_multi_path_searchrr>rrrrrrr6r r!r _search_files_search_content)r_rr>r0rrrrrcheckmultirbasename_query hint_parts 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(rrNrrexistsrzpath contained z entries; searched z that existz; skipped missing: rrzz (+z more))rr8rrdrorr 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 |dsdS|rd||nd}|d|d||d||dd }d }d }|jpdD]F}|d \} } } | r|t| z }|d z }G|d kr d |d|dS|d|d||d||dd } d } d }| jpdD]F}|d \} } } | r| t| z } |d z }G| d kr d| d|dStj d|r|d|d||d||dd }td|jpdD}|d krd|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. rgNz --glob rzrg -i --count-matchesrlrrr^r:rz0 exact matches, but z case-insensitive match(es) in u/ file(s) — the pattern's casing may be wrong.z'rg --hidden --no-ignore --count-matchesz 0 matches in visible files, but z match(es) in us hidden or gitignored file(s) — these are excluded by default. Search the hidden path explicitly to include them.z[.\[\](){}?*+^$\\|]zrg -F --count-matchesc3K|]Y}|dd/t|ddVZdS)rrN) rpartitionisdigitrg)rWr#s r&rz8ShellFileOperations._zero_match_probe..{ sr??3''*2244DOOC((+,,r(z0 regex matches, but uy literal match(es) — the pattern contains regex metacharacters that likely need escaping (or pass a simpler substring).) rhrordrrrrrrgrrr)r_rr>r glob_exprprobeci_totalci_filesr#_p_sepnhiddenh_totalh_filesfixedf_totals r&_zero_match_probez%ShellFileOperations._zero_match_probe> sw  && 4FOWBt55i@@BBBUW   &I & &%%g.. & &151G1G1M1M & & &    \'R..00;;==  D//#..KBayy{{ CFF"A  a<<PPPPPP  &i & &%%g.. & &151G1G1M1M & & &    ](b//11<<>>  D//#..KBayy{{ 3q66!1  Q;;Q7QQQQQ  9+W 5 5 JJ* **))'22**595K5KD5Q5Q*** E "\/R6688CCEEG {{>G>>> 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**/rUrc3HK|]}|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 '*/.*'rrlz | tail -n +rz | head -n zfind z -type f -name z* -printf '%T@ %p\n' 2>/dev/null | sort -rnrr^z 2>/dev/null | sort -rnr,rrrc3HK|]}|dvo|dVdSrrrs r&rz4ShellFileOperations._search_files.. s8^^Dt;.G4??33G3G^^^^^^r(rrrHr)r6rr rrrh_search_files_rgrrordrrr8rrr resolve relative_tor7r<)r_rr>rrsearch_pattern search_roothas_hidden_path_ancestorhidden_excludehidden_filter_exprpagination_exprrerrr 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. rU*zrg --files --sortr=modified -g rlz 2>/dev/null | head -n rr^cg|]}||Sr-r-rWrs r&rz8ShellFileOperations._search_files_rg.. s@@@1a@Q@@@r(r,zrg --files -g cg|]}||Sr-r-rs r&rz8ShellFileOperations._search_files_rg.. DDDq!DDDDr(r) r6rordrrrrr8r<)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 ' '%%d++ ' '$ ' '  J337?? @@  4 4T : :@@@  E E+!7!7 !E!E++))$//++(++  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#installationrrNrl) rh_search_with_rg_search_with_greprrOrrrrrrrqrO) 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|t1|dpd |dzt#|d!|d"dd#$|dkrPt5|}|r?|t1|d|d|ddd#$t|}||||z}t|||||zkpt|||%S)&zSearch using ripgrep.)rz --line-numberz --no-headingz--with-filenamerLr-Cz--glob files_only-lcount-crerr.-nset -o pipefail; rlrr^r Search errorSearch failed: rutPattern contains \n — multiline mode (-U) was enabled automatically so the regex can match across line boundaries.Ncg|]}||Sr-r-rs r&rz7ShellFileOperations._search_with_rg..w rr(r,)rrrHrrqrrrrrHr^([A-Za-z]:)?(.*?):(\d+):(.*)$rrrzrr)rrrHrrq)rJr rreror!rdrrrrrrrr8r<rsplitrgr7rvaluesrcompilerrrr)r_rr>rrrrr cmd_parts multilinerrerrrrr error_msg_ml_notertotalrrr#r _match_rerrparseds r&rz#ShellFileOperations._search_with_rg2 s@ONN /w77  ,   ] + + + Q;;   dCLL1 2 2 2  L   h(>(>y(I(IJ K K K , & &   T " " " " G # #   T " " " //88999//55666 /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 \ ddg}|d|dkr$|dt|g|r*|d||g|dkr|dn|d kr|d ||||||||z|dkrd ndz} |d d dt| gdd|z} || d} t | \} } t| \}}| jdkrW| sC| p| j pd}td|dS|} |dkrmd| dD}t|}||||z}t||t| | S|d kri}| dD]_}d|vrY|dd}t|dkr0 t!|d||d<O#t"$rY[wxYw`t|t%|t| | St)jd}g}| dD]}|r|dkr ||}|r|t/|dpd|dzt!|d |d!d"d#$|dkrPt3|}|r?|t/|d|d|dd"d#$t|}||||z}t|||||zkpt| | %S)&zFallback search using grep.rz-rnHEz--exclude-dir='.*'rrz --includerrrrrerr.rrrlrr^rrrrcg|]}||Sr-r-rs r&rz9ShellFileOperations._search_with_grep.. rr(r,rrrrrrrrzrNrr)rrrHr)r rreror!rdrrrrrrrr8r<rrgr7rrrrrrrr)r_rr>rrrrrrrrerrrrrrrrrrr#rrrrrs r&rz%ShellFileOperations._search_with_grep sW%  -... Q;;   dCLL1 2 2 2  O   k4+A+A)+L+LM N N N , & &   T " " " " G # #   T " " " //88999//55666fnw{{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)  s6K K"!K"rU)NNN)ri)rrrr);rarbrcrdrerZrgrrdr<rhrv staticmethodbytesr~rrrrrorrrrrrrDrrrrrrrkrrrrrrurrrror8r{r1rhr2r9rrrrrrrrrr-r(r&rQrQ.sL !2!2#!2!2!2!2FCG $% % S% s% C% % )6% % % % N((((((sC>  $   \ Dc3$:'c'd'''' #####c####4######J7S7S7777"V6#V6V6V6V6V6V6p77S7x}7X`adXe7777*,,#,HSM,T,,,,(  3 # RU     C C    0     \ u u cu 3u 3u *u u u u n*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$JLKsK#K(3-K"K,/K>AKLOKT`KKKKZyyCyHSMy!$y.1y@CyNQyVbyyyyyyr(rQ)Yrdrqrsrrrr5rabcrr dataclassesrrtypingrrr r r pathlibr tools.binary_extensionsr agent.file_safetyrrrrr@rer_HOMEWRITE_DENIED_PATHSWRITE_DENIED_PREFIXESrrrr'r/r4r7tupler<r:r=rBrDrkrurrrrrrrrrgrrrrf frozensetrgrr rr#r'r-r0r/ MAX_LINESMAX_LINE_LENGTHrr=r>rErFrr8rCrGrIrJrMrOrQr-r(r&rs4  ########((((((((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:@ @ @ @ @ 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     J$J$J$J$J$.J$J$J$J$J$r(