paimon 0.2.8__tar.gz → 0.3.0__tar.gz

{paimon-0.2.8/paimon.egg-info → paimon-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paimon
-Version: 0.2.8
+Version: 0.3.0
 Summary: A minimal code agent built on pydantic-ai + textual
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -14,6 +14,7 @@ Requires-Dist: pyyaml>=6
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-extensions>=4.12
 Requires-Dist: ddgs>=9
+Requires-Dist: pydantic-monty<2,>=1.0
 Dynamic: license-file
 
 # Paimon
@@ -46,7 +47,7 @@ The first launch asks for a provider, its API base and key, then a model. Then j
 
 While it runs: `Shift+Tab` switches how much the agent may do on its own (**read** only reads, **auto** edits inside the working directory and has a second model call approve everything else, **yolo** checks nothing and is the default), `Esc` interrupts the current turn, `Ctrl+P` opens the command palette, `Ctrl+C` quits. A line starting with `!` runs in a shell instead of being sent, and Paimon sees what it printed. `!!` keeps it to yourself.
 
-`Ctrl+T` opens another session in a pane of its own, `Ctrl+W` closes one, `Ctrl+PageUp` and `Ctrl+PageDown` move between them, and `Ctrl+G` jumps to a pane waiting for permission. Paimon can work in parallel: ask for two independent things and it starts a second agent in a tab of its own, where you can watch it work and answer what it asks, and whose answer comes back into the conversation when it is done. Closing the tab stops it. It can also leave a command running in a tab, a dev server or a watcher, instead of holding up a turn.
+`Ctrl+T` opens another session in a pane of its own, `Ctrl+W` closes one, `Ctrl+PageUp` and `Ctrl+PageDown` move between them, and `Ctrl+G` jumps to a pane waiting for permission. `Ctrl+L` returns keyboard focus to the current pane's input or pending answer. The status bar identifies input, reading, and answer focus; pane switches preserve reading focus, and background completion does not steal the keyboard. Paimon can work in parallel: ask for two independent things and it starts a second agent in a tab of its own, where you can watch it work and answer what it asks, and whose answer comes back into the conversation when it is done. Closing the tab stops it. It can also leave a command running in a tab, a dev server or a watcher, instead of holding up a turn.
 
 ## Web search
 
@@ -75,22 +76,25 @@ npx skills add aisk/paimon            # the same skill, via skills.sh
 
 ## Using Paimon as a library
 
-The agent loop is importable, so a Python program can drive it without going through the CLI. `Agent.open()` starts or resumes a session and `agent.run()` yields typed events, one per text chunk, tool call and turn end, which the caller renders or filters however it likes:
+The agent loop is importable, so a Python program can drive it without going through the CLI. `Agent.open()` starts or resumes a session and `agent.run_until_idle()` yields typed events, one per text chunk, tool call and turn end, which the caller renders or filters however it likes. It returns once the agent is done, including any agents it started along the way: their answers come back later, and it runs the model again on each of them until nothing is left running:
 
 ```python
 import asyncio
 
-from paimon.agent import Agent, TextDelta
+from paimon.agent import Agent
+from paimon.events import TextDelta
 
 async def main():
     agent = Agent.open(mode="auto")
-    async for event in agent.run("summarize the tests in this directory"):
+    async for event in agent.run_until_idle("summarize the tests in this directory"):
         if isinstance(event, TextDelta):
             print(event.text, end="", flush=True)
 
 asyncio.run(main())
 ```
 
+`agent.run()` runs exactly one turn and returns with those agents possibly still at work; it is the call for a program that wants to decide itself when to run the model again, with `agent.run(None)`. An agent runs one turn or compaction at a time, and starting a second while one is under way raises `AgentBusyError`.
+
 `Agent.open()` also takes a working directory, an async `confirm` callback for the permission prompts that are left, and a `toolset` to hand the model fewer tools or tools of your own. An agent holds its session until it goes away; to give it back at a definite moment, call `close()` or use the agent as a context manager. It writes the same session files as the CLI, so a run started in code can be resumed later with `paimon -r`.
 
 ## Sessions
@@ -111,6 +115,7 @@ paimon log a1b2c3    # what a session did, one line per event
 paimon --mode read                  # start in a more cautious permission mode (yolo is the default)
 paimon --strict                     # hold every command, even read-only ones
 paimon --no-web-search              # take the web search tool away for this run
+paimon --no-code-mode               # take the run_code tool away (or "code_mode": false in config.json)
 paimon --web                        # the same UI in a browser (--port, default 8000)
 paimon -p "what does cli.py do?"    # one answer on stdout, no UI
 cat log.txt | paimon -p "summarize this"
@@ -119,7 +124,7 @@ paimon --model zai:glm-4.7          # this model for this run only
 
 `-p` never stops to ask, so with the default `yolo` mode it can already write files and run commands. Add `--output-format result` for a single JSON object with the outcome, which is what a calling program should read. `paimon --help` lists the rest.
 
-Inside a [Herdr](https://herdr.dev) pane the UI reports its state and resume command to Herdr on its own, with nothing to install.
+Inside a [Herdr](https://herdr.dev) pane the UI reports its state and resume command to Herdr on its own, with nothing to install. It also reports its state to the terminal itself with [OSC 7501](https://mitchellh.com/writing/program-status-osc7501), for terminals that show it.
 
 ### Debugging the Textual UI
 
@@ -136,7 +141,7 @@ You can ask it, for example, to “find why `#prompt` is narrower than expected,
 
 Model settings are kept in `~/.config/paimon/config.json`, written by the first launch or by `paimon login`. Each provider keeps its own credentials, and `paimon model provider:name` or Switch model in the command palette picks the model to run on. A ChatGPT plan works in place of an API key: `paimon login chatgpt` signs in through the browser. `paimon login antigravity` does the same for an Antigravity plan, which Google does not support outside Antigravity: Paimon signs in as the Antigravity client and calls an internal endpoint, so the account may be limited or closed, and the risk is yours. Sessions live in `~/.local/share/paimon/sessions/`.
 
-Read and auto modes run a small set of clearly read-only commands (`ls`, `cat`, `git status`, …) on their own; `--strict` turns that off, and on Windows, where cmd.exe runs the commands, none are recognized. Read mode refuses everything else. Auto mode asks a reviewer model, which sees your messages and the agent's tool calls but not its reasoning or any tool output, and answers allow or block. It asks you instead when the reviewer cannot be reached or has blocked three calls in a row, and under `-p` those are refusals. Current models review with their provider's fast tier by default (GPT with Luna, Claude with Haiku, GLM with Flash) and the rest review with themselves; set `"review_model": "provider:name"` in the config to choose. **All of this is a guardrail against agent mistakes, not a security boundary.** For real isolation, run Paimon inside a container or VM.
+Read and auto modes run a small set of clearly read-only commands (`ls`, `cat`, `git status`, …) on their own; `--strict` turns that off. On Windows commands run in Git Bash, found through `git` on your PATH or the standard install locations; without Git for Windows they run in cmd.exe, and then none are recognized. Read mode refuses everything else. Auto mode asks a reviewer model, which sees your messages and the agent's tool calls but not its reasoning or any tool output, and answers allow or block. It asks you instead when the reviewer cannot be reached or has blocked three calls in a row, and under `-p` those are refusals. Current models review with their provider's fast tier by default (GPT with Luna, Claude with Haiku, GLM with Flash) and the rest review with themselves; set `"review_model": "provider:name"` in the config to choose. **All of this is a guardrail against agent mistakes, not a security boundary.** For real isolation, run Paimon inside a container or VM.
 
 ## Architecture
 
@@ -166,11 +171,12 @@ flowchart TD
         AgentLoop["agent.py<br/>Agent.run()"]
         LLM["llm.py<br/>build_model()"]
         PromptMod["prompt.py<br/>system prompt"]
-        ToolsMod["tools.py<br/>tool REGISTRY"]
+        ToolsMod["tools/<br/>tool REGISTRY"]
         SessionMod["session.py<br/>JSONL persistence"]
         Compaction["compaction.py"]
         Retry["retry.py"]
         Mentions["mentions.py<br/>@path expansion"]
+        JobMgr["jobs.py<br/>subagents, background commands"]
         Jobs["turns.py<br/>turn driver"]
     end
 
@@ -213,9 +219,10 @@ flowchart TD
     AgentLoop --> Compaction
     AgentLoop --> Retry
     AgentLoop --> Mentions
-    AgentLoop -. "spawn_agent" .-> AgentLoop
-    AgentLoop -. "spawn_agent" .-> AgentPane
-    AgentLoop -. "run_background" .-> CommandPane
+    AgentLoop --> JobMgr
+    JobMgr -. "spawn_agent" .-> AgentLoop
+    JobMgr -. "spawn_agent" .-> AgentPane
+    JobMgr -. "run_background" .-> CommandPane
 
     PromptMod --> Skills
 

{paimon-0.2.8 → paimon-0.3.0}/README.md

@@ -28,7 +28,7 @@ The first launch asks for a provider, its API base and key, then a model. Then j
 
 While it runs: `Shift+Tab` switches how much the agent may do on its own (**read** only reads, **auto** edits inside the working directory and has a second model call approve everything else, **yolo** checks nothing and is the default), `Esc` interrupts the current turn, `Ctrl+P` opens the command palette, `Ctrl+C` quits. A line starting with `!` runs in a shell instead of being sent, and Paimon sees what it printed. `!!` keeps it to yourself.
 
-`Ctrl+T` opens another session in a pane of its own, `Ctrl+W` closes one, `Ctrl+PageUp` and `Ctrl+PageDown` move between them, and `Ctrl+G` jumps to a pane waiting for permission. Paimon can work in parallel: ask for two independent things and it starts a second agent in a tab of its own, where you can watch it work and answer what it asks, and whose answer comes back into the conversation when it is done. Closing the tab stops it. It can also leave a command running in a tab, a dev server or a watcher, instead of holding up a turn.
+`Ctrl+T` opens another session in a pane of its own, `Ctrl+W` closes one, `Ctrl+PageUp` and `Ctrl+PageDown` move between them, and `Ctrl+G` jumps to a pane waiting for permission. `Ctrl+L` returns keyboard focus to the current pane's input or pending answer. The status bar identifies input, reading, and answer focus; pane switches preserve reading focus, and background completion does not steal the keyboard. Paimon can work in parallel: ask for two independent things and it starts a second agent in a tab of its own, where you can watch it work and answer what it asks, and whose answer comes back into the conversation when it is done. Closing the tab stops it. It can also leave a command running in a tab, a dev server or a watcher, instead of holding up a turn.
 
 ## Web search
 
@@ -57,22 +57,25 @@ npx skills add aisk/paimon            # the same skill, via skills.sh
 
 ## Using Paimon as a library
 
-The agent loop is importable, so a Python program can drive it without going through the CLI. `Agent.open()` starts or resumes a session and `agent.run()` yields typed events, one per text chunk, tool call and turn end, which the caller renders or filters however it likes:
+The agent loop is importable, so a Python program can drive it without going through the CLI. `Agent.open()` starts or resumes a session and `agent.run_until_idle()` yields typed events, one per text chunk, tool call and turn end, which the caller renders or filters however it likes. It returns once the agent is done, including any agents it started along the way: their answers come back later, and it runs the model again on each of them until nothing is left running:
 
 ```python
 import asyncio
 
-from paimon.agent import Agent, TextDelta
+from paimon.agent import Agent
+from paimon.events import TextDelta
 
 async def main():
     agent = Agent.open(mode="auto")
-    async for event in agent.run("summarize the tests in this directory"):
+    async for event in agent.run_until_idle("summarize the tests in this directory"):
         if isinstance(event, TextDelta):
             print(event.text, end="", flush=True)
 
 asyncio.run(main())
 ```
 
+`agent.run()` runs exactly one turn and returns with those agents possibly still at work; it is the call for a program that wants to decide itself when to run the model again, with `agent.run(None)`. An agent runs one turn or compaction at a time, and starting a second while one is under way raises `AgentBusyError`.
+
 `Agent.open()` also takes a working directory, an async `confirm` callback for the permission prompts that are left, and a `toolset` to hand the model fewer tools or tools of your own. An agent holds its session until it goes away; to give it back at a definite moment, call `close()` or use the agent as a context manager. It writes the same session files as the CLI, so a run started in code can be resumed later with `paimon -r`.
 
 ## Sessions
@@ -93,6 +96,7 @@ paimon log a1b2c3    # what a session did, one line per event
 paimon --mode read                  # start in a more cautious permission mode (yolo is the default)
 paimon --strict                     # hold every command, even read-only ones
 paimon --no-web-search              # take the web search tool away for this run
+paimon --no-code-mode               # take the run_code tool away (or "code_mode": false in config.json)
 paimon --web                        # the same UI in a browser (--port, default 8000)
 paimon -p "what does cli.py do?"    # one answer on stdout, no UI
 cat log.txt | paimon -p "summarize this"
@@ -101,7 +105,7 @@ paimon --model zai:glm-4.7          # this model for this run only
 
 `-p` never stops to ask, so with the default `yolo` mode it can already write files and run commands. Add `--output-format result` for a single JSON object with the outcome, which is what a calling program should read. `paimon --help` lists the rest.
 
-Inside a [Herdr](https://herdr.dev) pane the UI reports its state and resume command to Herdr on its own, with nothing to install.
+Inside a [Herdr](https://herdr.dev) pane the UI reports its state and resume command to Herdr on its own, with nothing to install. It also reports its state to the terminal itself with [OSC 7501](https://mitchellh.com/writing/program-status-osc7501), for terminals that show it.
 
 ### Debugging the Textual UI
 
@@ -118,7 +122,7 @@ You can ask it, for example, to “find why `#prompt` is narrower than expected,
 
 Model settings are kept in `~/.config/paimon/config.json`, written by the first launch or by `paimon login`. Each provider keeps its own credentials, and `paimon model provider:name` or Switch model in the command palette picks the model to run on. A ChatGPT plan works in place of an API key: `paimon login chatgpt` signs in through the browser. `paimon login antigravity` does the same for an Antigravity plan, which Google does not support outside Antigravity: Paimon signs in as the Antigravity client and calls an internal endpoint, so the account may be limited or closed, and the risk is yours. Sessions live in `~/.local/share/paimon/sessions/`.
 
-Read and auto modes run a small set of clearly read-only commands (`ls`, `cat`, `git status`, …) on their own; `--strict` turns that off, and on Windows, where cmd.exe runs the commands, none are recognized. Read mode refuses everything else. Auto mode asks a reviewer model, which sees your messages and the agent's tool calls but not its reasoning or any tool output, and answers allow or block. It asks you instead when the reviewer cannot be reached or has blocked three calls in a row, and under `-p` those are refusals. Current models review with their provider's fast tier by default (GPT with Luna, Claude with Haiku, GLM with Flash) and the rest review with themselves; set `"review_model": "provider:name"` in the config to choose. **All of this is a guardrail against agent mistakes, not a security boundary.** For real isolation, run Paimon inside a container or VM.
+Read and auto modes run a small set of clearly read-only commands (`ls`, `cat`, `git status`, …) on their own; `--strict` turns that off. On Windows commands run in Git Bash, found through `git` on your PATH or the standard install locations; without Git for Windows they run in cmd.exe, and then none are recognized. Read mode refuses everything else. Auto mode asks a reviewer model, which sees your messages and the agent's tool calls but not its reasoning or any tool output, and answers allow or block. It asks you instead when the reviewer cannot be reached or has blocked three calls in a row, and under `-p` those are refusals. Current models review with their provider's fast tier by default (GPT with Luna, Claude with Haiku, GLM with Flash) and the rest review with themselves; set `"review_model": "provider:name"` in the config to choose. **All of this is a guardrail against agent mistakes, not a security boundary.** For real isolation, run Paimon inside a container or VM.
 
 ## Architecture
 
@@ -148,11 +152,12 @@ flowchart TD
         AgentLoop["agent.py<br/>Agent.run()"]
         LLM["llm.py<br/>build_model()"]
         PromptMod["prompt.py<br/>system prompt"]
-        ToolsMod["tools.py<br/>tool REGISTRY"]
+        ToolsMod["tools/<br/>tool REGISTRY"]
         SessionMod["session.py<br/>JSONL persistence"]
         Compaction["compaction.py"]
         Retry["retry.py"]
         Mentions["mentions.py<br/>@path expansion"]
+        JobMgr["jobs.py<br/>subagents, background commands"]
         Jobs["turns.py<br/>turn driver"]
     end
 
@@ -195,9 +200,10 @@ flowchart TD
     AgentLoop --> Compaction
     AgentLoop --> Retry
     AgentLoop --> Mentions
-    AgentLoop -. "spawn_agent" .-> AgentLoop
-    AgentLoop -. "spawn_agent" .-> AgentPane
-    AgentLoop -. "run_background" .-> CommandPane
+    AgentLoop --> JobMgr
+    JobMgr -. "spawn_agent" .-> AgentLoop
+    JobMgr -. "spawn_agent" .-> AgentPane
+    JobMgr -. "run_background" .-> CommandPane
 
     PromptMod --> Skills
 

{paimon-0.2.8 → paimon-0.3.0}/README.zh-CN.md

@@ -28,7 +28,7 @@ uvx paimon
 
 运行时：`Shift+Tab` 切换 agent 的自主程度（**read** 只读，**auto** 放行工作目录内的编辑，其余操作交给另一次模型调用审批，**yolo** 不做任何检查，也是默认值），`Esc` 打断当前回合，`Ctrl+P` 打开命令面板，`Ctrl+C` 退出。以 `!` 开头的一行不发给模型，而是直接在 shell 里执行，输出 Paimon 也能看到。`!!` 则不告诉它。
 
-`Ctrl+T` 在新 pane 里打开另一个会话，`Ctrl+W` 关闭当前 pane，`Ctrl+PageUp` 和 `Ctrl+PageDown` 在 pane 之间切换，`Ctrl+G` 跳到正在等待授权的 pane。Paimon 也能并行干活：让它同时做两件互不相干的事，它会在单独的 tab 里起第二个 agent，你可以在那里看它干活、回答它的授权请求，做完后结果会回到当前会话里，关掉 tab 就是停掉它。它也能把一条命令留在 tab 里跑，比如开发服务器或者文件监视，不占着当前回合。
+`Ctrl+T` 在新 pane 里打开另一个会话，`Ctrl+W` 关闭当前 pane，`Ctrl+PageUp` 和 `Ctrl+PageDown` 在 pane 之间切换，`Ctrl+G` 跳到正在等待授权的 pane，`Ctrl+L` 将键盘焦点返回当前 pane 的输入框或待回答面板。状态栏会显示键盘当前在输入、阅读还是回答区域；切换 pane 会保留阅读焦点，后台任务完成不会抢走键盘。Paimon 也能并行干活：让它同时做两件互不相干的事，它会在单独的 tab 里起第二个 agent，你可以在那里看它干活、回答它的授权请求，做完后结果会回到当前会话里，关掉 tab 就是停掉它。它也能把一条命令留在 tab 里跑，比如开发服务器或者文件监视，不占着当前回合。
 
 ## 网页搜索
 
@@ -57,22 +57,25 @@ npx skills add aisk/paimon            # 通过 skills.sh 安装同一个 skill
 
 ## 当作库使用
 
-agent 循环本身是可以导入的，Python 程序不必经过 CLI 就能驱动它。`Agent.open()` 新建或恢复一个会话，`agent.run()` 产出类型化的事件，每段文本、每次工具调用、每个回合结束各一个，调用方自己决定怎么渲染或过滤：
+agent 循环本身是可以导入的，Python 程序不必经过 CLI 就能驱动它。`Agent.open()` 新建或恢复一个会话，`agent.run_until_idle()` 产出类型化的事件，每段文本、每次工具调用、每个回合结束各一个，调用方自己决定怎么渲染或过滤。它在 agent 做完之后才返回，包括它中途启动的其他 agent：这些 agent 的回答稍后才到，每到一个它就让模型再跑一轮，直到没有还在运行的为止：
 
 ```python
 import asyncio
 
-from paimon.agent import Agent, TextDelta
+from paimon.agent import Agent
+from paimon.events import TextDelta
 
 async def main():
     agent = Agent.open(mode="auto")
-    async for event in agent.run("summarize the tests in this directory"):
+    async for event in agent.run_until_idle("summarize the tests in this directory"):
         if isinstance(event, TextDelta):
             print(event.text, end="", flush=True)
 
 asyncio.run(main())
 ```
 
+`agent.run()` 只跑一个回合，返回时它启动的 agent 可能还在运行；想自己决定什么时候用 `agent.run(None)` 让模型再跑一轮的程序，用它。同一个 agent 一次只跑一个回合或一次压缩，前一个还没结束就开始下一个会抛出 `AgentBusyError`。
+
 `Agent.open()` 还接受工作目录、用于剩余权限确认的异步 `confirm` 回调，以及 `toolset`，可以只给模型一部分工具，或者换成你自己的工具。agent 被回收时会交还会话，想在确定的时刻交还就调 `close()`，或者把它当上下文管理器用。它写的会话文件和 CLI 一样，所以代码里跑出来的会话之后可以用 `paimon -r` 恢复。
 
 ## 会话
@@ -116,7 +119,7 @@ paimon --model zai:glm-4.7          # 仅本次运行使用该模型
 
 模型设置保存在 `~/.config/paimon/config.json`，由首次启动或 `paimon login` 写入。每个 provider 各自保存凭据，用 `paimon model provider:name` 或命令面板里的 Switch model 选择要用的模型。也可以用 ChatGPT 订阅代替 API key，`paimon login chatgpt` 会通过浏览器登录。会话存放在 `~/.local/share/paimon/sessions/`。
 
-read 和 auto 模式会直接执行一小组明确只读的命令（`ls`、`cat`、`git status` 等），`--strict` 可以关掉，Windows 上命令由 cmd.exe 执行，一条也不识别。read 模式拒绝其余所有操作。auto 模式把它们交给审批模型，它能看到你的消息和 agent 的工具调用，看不到 agent 的推理和工具输出，只回答放行或拦截。审批模型不可用或者连续拦截三次时改为询问你，`-p` 下则直接拒绝。当前的模型默认用同一家里快速档的那个来审批（GPT 用 Luna，Claude 用 Haiku，GLM 用 Flash），其余模型自己审自己，在配置里写 `"review_model": "provider:name"` 可以自行指定。**这些都是防止 agent 失误的护栏，不是安全边界。** 需要真正的隔离时，请在容器或虚拟机中运行 Paimon。
+read 和 auto 模式会直接执行一小组明确只读的命令（`ls`、`cat`、`git status` 等），`--strict` 可以关掉。Windows 上命令由 Git Bash 执行，通过 PATH 上的 `git` 或默认安装位置找到；没装 Git for Windows 时改由 cmd.exe 执行，这时一条也不识别。read 模式拒绝其余所有操作。auto 模式把它们交给审批模型，它能看到你的消息和 agent 的工具调用，看不到 agent 的推理和工具输出，只回答放行或拦截。审批模型不可用或者连续拦截三次时改为询问你，`-p` 下则直接拒绝。当前的模型默认用同一家里快速档的那个来审批（GPT 用 Luna，Claude 用 Haiku，GLM 用 Flash），其余模型自己审自己，在配置里写 `"review_model": "provider:name"` 可以自行指定。**这些都是防止 agent 失误的护栏，不是安全边界。** 需要真正的隔离时，请在容器或虚拟机中运行 Paimon。
 
 ## 架构
 
@@ -146,11 +149,12 @@ flowchart TD
         AgentLoop["agent.py<br/>Agent.run()"]
         LLM["llm.py<br/>build_model()"]
         PromptMod["prompt.py<br/>system prompt"]
-        ToolsMod["tools.py<br/>工具注册表"]
+        ToolsMod["tools/<br/>工具注册表"]
         SessionMod["session.py<br/>JSONL 持久化"]
         Compaction["compaction.py"]
         Retry["retry.py"]
         Mentions["mentions.py<br/>@path 展开"]
+        JobMgr["jobs.py<br/>子代理、后台命令"]
         Jobs["turns.py<br/>回合驱动"]
     end
 
@@ -193,9 +197,10 @@ flowchart TD
     AgentLoop --> Compaction
     AgentLoop --> Retry
     AgentLoop --> Mentions
-    AgentLoop -. "spawn_agent" .-> AgentLoop
-    AgentLoop -. "spawn_agent" .-> AgentPane
-    AgentLoop -. "run_background" .-> CommandPane
+    AgentLoop --> JobMgr
+    JobMgr -. "spawn_agent" .-> AgentLoop
+    JobMgr -. "spawn_agent" .-> AgentPane
+    JobMgr -. "run_background" .-> CommandPane
 
     PromptMod --> Skills
 

paimon-0.3.0/paimon/_grep_worker.py

@@ -0,0 +1,23 @@
+"""Disposable process for bounded, cancellable code searches."""
+
+import json
+import sys
+from pathlib import Path
+
+from .tools.grep import _grep
+from .tools.result import ToolError
+
+
+def main() -> None:
+    args, cwd, sandboxed = json.load(sys.stdin)
+    try:
+        result = _grep(args, Path(cwd), sandboxed=sandboxed)
+    except ToolError as exc:
+        # An object rather than a string, so the failure crosses the process
+        # boundary as one instead of being read back out of the text.
+        result = {"error": exc.text}
+    sys.stdout.write(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()