Terminal Tools on KnightLi Blog

What is oh-my-pi? An AI coding assistant that connects the terminal, IDE, and debugger

Sat, 23 May 2026 19:02:20 +0800

oh-my-pi is an AI Coding Agent for the terminal and editor. It is a fork of Mario Zechner’s Pi project, extended by can1357. Its goal is not just to provide a command-line chat UI, but to connect file reading, code search, structured edits, LSP, debuggers, browsers, subagents, and multiple model providers into one coding workflow.

From the project README, it feels more like an AI coding tool layer than a simple assistant: you can use it interactively in the terminal, connect editors through ACP, or embed it in Node projects through the SDK. For people already using Claude Code, Codex CLI, Cline, Cursor, or other agent tools, the interesting part is that oh-my-pi turns many abilities that usually live in separate tools into one built-in tool surface.

What problem is it trying to solve?

For many AI coding tools, the weak point is not the model itself, but the tool interface around it. When a model wants to change code but only has rough full-file reads, fragile string replacement, and one-off shell commands, the toolchain amplifies failure.

oh-my-pi tries to reduce those common points of friction:

File reads prefer structured summaries instead of dumping whole files into context.
Search, glob, find, syntax highlighting, and token counting are implemented natively where possible, reducing dependence on external commands.
Code writes can use LSP so renames, references, and file moves behave more like IDE operations.
Debugging can use DAP tools such as lldb, dlv, and debugpy, instead of relying only on logs and guesses.
Complex tasks can be split across subagents and returned as structured results.
Edits use content anchors and previews to reduce the chance of a bad patch landing directly on disk.

These choices show that the focus is not “can the model answer?”, but “can the model reliably complete a real code change?”

Installation

The project provides several installation paths. On macOS and Linux, you can use the install script:

`1`	`curl -fsSL https://omp.sh/install \| sh`

If you use Bun, the README recommends installing the npm package globally:

`1`	`bun install -g @oh-my-pi/pi-coding-agent`

On Windows PowerShell:

`1`	`irm https://omp.sh/install.ps1 \| iex`

The README also mentions pinning versions with mise:

`1`	`mise use -g github:can1357/oh-my-pi`

Before installing, check the Bun version requirement. The README lists macOS, Linux, and Windows support, and requires bun >= 1.3.14.

Capabilities worth watching

1. Tool calling goes beyond shell commands

oh-my-pi includes tools for file reads, search, writes, edits, AST edits, browser use, task splitting, debugging, and LSP. The README mentions 32 built-in tools, 13 LSP operations, and 27 DAP operations.

That means the agent does not have to wrap everything as command-line output. Reference lookup can go through LSP, PRs and issues can be read through a unified file-like interface, and web pages or PDFs can be converted into Markdown with link structure intact before being passed to the model.

2. LSP integration is useful for real codebases

In large projects, renaming and moving files often breaks re-exports, aliased imports, barrel files, or cross-directory references. The oh-my-pi README highlights that write paths can go through LSP. For example, file renames use workspace/willRenameFiles, making edits closer to semantic IDE operations.

This is useful for everyday refactoring in TypeScript, Rust, Go, Python, and similar projects, especially in cases where manual edits are possible but easy to miss.

3. The debugger is a first-class tool

Many AI coding flows still debug by adding logs, rerunning, and reading output. oh-my-pi connects DAP debuggers to the tool surface. The README gives examples with C programs using lldb, Go services using dlv, and Python processes using debugpy.

That changes how an agent handles bugs: it can pause a process, inspect stack frames, read local variables, and then decide what to do next, instead of guessing from error text alone.

4. Hashline editing reduces patch failures

The project emphasizes Hashline, an editing approach based on content anchors. The goal is to let the model point to the content it wants to change instead of repeatedly emitting large diffs. This reduces edit failures caused by whitespace, stale context, or failed string matching.

For agent tools, this matters a lot. Even a capable model feels clumsy if the write interface keeps failing and forcing retries.

5. Subagents and workspace isolation

The README introduces a task subagent capability: a task can be split across isolated workers, and results are returned as structured objects. The project also includes workspace isolation logic for parallel tasks, branch exploration, and avoiding overlapping edits.

This fits code review, migrations, bulk fixes, and test investigation. The value is not only speed; it is also cleaner separation between different exploration paths.

6. It can inherit existing rules and configs

On first run, oh-my-pi can read rules and configuration left by other tools, including .claude, .cursor, .windsurf, .gemini, .codex, .cline, .github/copilot, and .vscode.

That is practical. Many teams have already written rules for several AI tools. Rewriting them for every new tool is expensive, so oh-my-pi tries to reuse what is already on disk.

Four entry points

The project provides four main ways to use it:

Interactive TUI: run omp directly in the terminal.
One-shot command: use omp -p to send a single prompt.
Node SDK: embed it in a Node or TypeScript project through @oh-my-pi/pi-coding-agent.
RPC / ACP: connect other programs and editors through stdio or Agent Client Protocol.

This means it is not only for individual terminal users. It also leaves room for IDEs, plugins, automation platforms, and internal tools.

Who should try it?

oh-my-pi is a good fit for:

Developers who often edit, debug, and review code in the terminal.
People already using AI Coding Agents but unhappy with file reading, patching, search, or debugging reliability.
Developers who want to connect an agent to an editor, RPC layer, or Node service.
Users who need to switch between multiple models and providers in one tool.
Tool builders interested in LSP, DAP, AST editing, and subagent workflows.

If you only want a chat-style coding assistant that works immediately, the learning curve may feel high. It is better suited to people willing to understand the toolchain and treat the agent as a configurable development environment.

What to keep in mind

First, oh-my-pi is still a fast-moving open source project. Commits are frequent, and there are many issues and pull requests, so installation and usage may change.

Second, its capabilities depend heavily on your local environment. LSP, debuggers, Bun, model-provider authentication, terminal setup, and Windows or Unix differences can all affect the experience.

Third, having many built-in tools does not mean every scenario should enable everything. In practice, it is better to enable the tools needed for the task and configure rules, permissions, and workspace boundaries clearly.

Fourth, an AI Agent can write code, but it can also change the wrong code. Even with previews and content-anchored edits, important projects still need version control, tests, and human review.

Summary

The interesting part of oh-my-pi is not that it is another AI terminal shell. It is that it reorganizes the tool layer that often holds AI coding back: file reading, search, editing, LSP, debugging, browser access, subagents, and SDK integration all sit inside one agent workflow.

It is worth watching for people who care about AI coding infrastructure, and for developers comparing different Coding Agent approaches. The competition in AI coding tools is no longer just about model answer quality. It is also about who can connect models reliably to real codebases, real debugging workflows, and real team rules. oh-my-pi is an ambitious open source attempt in that direction.

References:

GitHub project: https://github.com/can1357/oh-my-pi
Official site: https://omp.sh/
SDK documentation: https://omp.sh/docs/sdk

DeepSeek-TUI: Run a DeepSeek Coding Agent in Your Terminal

Fri, 08 May 2026 13:41:15 +0800

DeepSeek-TUI is an AI coding agent that runs in the terminal. It is built around DeepSeek V4 models and starts from the deepseek command. Inside a keyboard-driven TUI, it can read and edit files, run shell commands, search the web, manage git, connect to MCP servers, and coordinate sub-agents.

It is closer to a terminal workbench than a simple chat CLI. The goal is not only to send a question to a model, but to combine code reading, file edits, commands, diagnostics, session recovery, and workspace rollback in one local workflow.

The repository is mainly written in Rust and uses the MIT license. Its GitHub description is: “Coding agent for DeepSeek models that runs in your terminal.”

Who It Is For

DeepSeek-TUI fits developers who prefer terminal workflows and want to use DeepSeek models for real local development tasks.

It is useful when you want to:

Use DeepSeek models for code changes and project analysis.
Work without opening a full IDE.
Let an AI tool read and modify a local workspace.
Switch between Plan, Agent, and YOLO modes.
Save sessions and resume long tasks.
Roll back workspace changes.
Connect MCP, LSP diagnostics, HTTP/SSE runtime APIs, and skills.

If you only need simple Q&A, a web client or lightweight CLI is enough. DeepSeek-TUI is better when the model should become part of your local development loop.

Installation

DeepSeek-TUI ships Rust binaries. The common entry command is deepseek, and the companion TUI binary is deepseek-tui.

Using npm:

1
2
3

npm install -g deepseek-tui
deepseek --version
deepseek --model auto

The npm package is an installer and wrapper that downloads prebuilt Rust binaries. It requires Node.js >=18.

Using Cargo:

1
2

cargo install deepseek-tui-cli --locked
cargo install deepseek-tui --locked

Using Homebrew:

1
2

brew tap Hmbown/deepseek-tui
brew install deepseek-tui

You can also download prebuilt binaries from GitHub Releases. The README lists Linux x64/ARM64, macOS x64/ARM64, and Windows x64 builds.

Docker:

docker run --rm -it \
  -e DEEPSEEK_API_KEY \
  -v "$PWD:/workspace" \
  ghcr.io/hmbown/deepseek-tui:latest

In mainland China, use npm or Cargo mirrors, or download release binaries manually.

Configure the API Key

On first launch, DeepSeek-TUI asks for your DeepSeek API key and saves it to:

`1`	`~/.deepseek/config.toml`

You can also configure it explicitly:

1
2

deepseek auth set --provider deepseek
deepseek auth status

Or use an environment variable:

1
2

export DEEPSEEK_API_KEY="YOUR_KEY"
deepseek

Check the setup:

`1`	`deepseek doctor`

If the wrong key source is used, run deepseek auth status. Saved config keys take precedence over the keyring and environment variables.

Clear a saved key:

`1`	`deepseek auth clear --provider deepseek`

Auto Mode

Auto mode:

`1`	`deepseek --model auto`

Inside the TUI:

`1`	`/model auto`

Auto mode chooses both:

Model: deepseek-v4-flash or deepseek-v4-pro
Thinking: off, high, or max

Before the real request, DeepSeek-TUI makes a small routing call to analyze the latest request and recent context. Simple tasks can stay on Flash with thinking off; coding, debugging, architecture, release, security review, or ambiguous multi-step work can move to Pro or higher thinking.

auto is local to DeepSeek-TUI. The upstream API receives the concrete model and thinking setting chosen for that turn. For benchmarks, strict cost control, or fixed behavior, use an explicit model.

Modes

Mode	Use
Plan	Read-only exploration and planning
Agent	Default interactive mode with approval gates
YOLO	Auto-approve tools in a trusted workspace

Plan is for investigation. Agent is safer for everyday coding. YOLO is fast but risky and should only be used in trusted workspaces and low-risk branches.

Tooling

The README lists a broad tool set:

File reads/writes and apply patch.
Shell execution.
Git operations.
Web search and browse.
Sub-agents.
MCP servers.
LSP diagnostics.
Session save/resume.
Workspace rollback.
Durable task queue.
HTTP/SSE runtime API.
Skills system.

LSP diagnostics are especially useful because errors from rust-analyzer, pyright, typescript-language-server, gopls, clangd, and similar tools can be fed back after edits.

Workspace rollback uses side-git snapshots and provides /restore and revert_turn. It does not touch the repository’s own .git, but normal git commits are still the safest baseline.

Common Commands

deepseek
deepseek "explain this function"
deepseek --model deepseek-v4-flash "summarize"
deepseek --model auto "fix this bug"
deepseek --yolo
deepseek auth set --provider deepseek
deepseek doctor
deepseek doctor --json
deepseek models
deepseek sessions
deepseek resume --last
deepseek resume <SESSION_ID>
deepseek fork <SESSION_ID>
deepseek serve --http
deepseek serve --acp
deepseek pr <N>
deepseek mcp list
deepseek mcp validate
deepseek update

Zed and ACP

DeepSeek-TUI can run as an Agent Client Protocol server:

{
  "agent_servers": {
    "DeepSeek": {
      "type": "custom",
      "command": "deepseek",
      "args": ["serve", "--acp"],
      "env": {}
    }
  }
}

The README notes that the first ACP slice supports new sessions and prompt responses, while tool-backed editing and checkpoint replay are not exposed through ACP yet.

Configuration and Providers

User config:

`1`	`~/.deepseek/config.toml`

Workspace overlay:

`1`	`<workspace>/.deepseek/config.toml`

Some sensitive fields, such as api_key, base_url, provider, and mcp_config_path, are denied in workspace overlays.

DeepSeek-TUI supports the default deepseek provider plus NVIDIA NIM, Fireworks, OpenAI-compatible endpoints, SGLang, vLLM, Ollama, and others.

OpenAI-compatible example:

1
2

deepseek auth set --provider openai --api-key "YOUR_OPENAI_COMPATIBLE_API_KEY"
OPENAI_BASE_URL="https://openai-compatible.example/v4" deepseek --provider openai --model glm-5

Ollama example:

1
2

ollama pull deepseek-coder:1.3b
deepseek --provider ollama --model deepseek-coder:1.3b

Cost and Context

DeepSeek-TUI is designed around DeepSeek V4. The README mentions deepseek-v4-pro and deepseek-v4-flash, 1M-token context windows, token usage, cost estimates, and prefix-cache telemetry.

For light tasks, deepseek-v4-flash or auto mode may be enough. For complex refactors, long-context debugging, and architecture work, use higher thinking or Pro.

Pricing and discounts change, so check DeepSeek’s official pricing page and the current TUI cost estimates before relying on numbers.

Suggested Workflow

Start safely:

Try it in a small test repository.
Run deepseek doctor.
Use Plan mode for read-only exploration.
Use Agent mode for small edits.
Review changes with git diff and tests.
Learn /restore and session recovery.
Use YOLO only in trusted temporary branches.

Do not store API keys in project files. For company code, confirm provider, logging, web search, and compliance rules first.

Summary

DeepSeek-TUI is a full terminal AI coding agent. It brings DeepSeek V4, TUI interaction, tool calls, LSP diagnostics, session recovery, rollback, MCP, and skills into one Rust-based workflow.

It is not the lightest DeepSeek client, but its strength is moving from chat to executable local development.