deepcode-hku 2.2.0__tar.gz → 2.3.1__tar.gz

{deepcode_hku-2.2.0 → deepcode_hku-2.3.1}/MANIFEST.in

@@ -4,7 +4,10 @@ include LICENSE
 include THIRD_PARTY_NOTICES.md
 include requirements.txt
 include uv.lock
-include __init__.py
+# NOTE: the repository root is deliberately NOT a package (no `include __init__.py`).
+# A root __init__.py made `import deepcode` bind to the checkout directory instead of
+# deepcode.py on case-insensitive filesystems (pytest puts the package root on
+# sys.path), which broke `deepcode.main()` from a source checkout on Windows.
 recursive-include prompts *
 recursive-include schema *
 recursive-include cli *.py
@@ -12,6 +15,7 @@ recursive-include core *.py
 recursive-include core/skills/builtin *
 recursive-include core/application/goal_prompts *.md
 recursive-include app_server *.py
+recursive-include app_server/web_assets *
 recursive-include protocol *.json
 recursive-include utils *.py
 recursive-include tools *.py

{deepcode_hku-2.2.0/deepcode_hku.egg-info → deepcode_hku-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepcode-hku
-Version: 2.2.0
+Version: 2.3.1
 Summary: Open agentic coding with durable sessions, goals, and verification
 Home-page: https://github.com/HKUDS/DeepCode
 Author: DeepCode Team
@@ -37,15 +37,17 @@ Requires-Dist: openapi
 Requires-Dist: pathlib2
 Requires-Dist: prompt_toolkit>=3.0.0
 Requires-Dist: pydantic-settings>=2.14.2
-Requires-Dist: pypdf>=6.16.1
+Requires-Dist: pypdf>=6.19.0
 Requires-Dist: PyYAML>=6.0
 Requires-Dist: reportlab>=3.5.0
 Requires-Dist: rich>=13.0.0
+Provides-Extra: server
 Provides-Extra: advanced-documents
 Requires-Dist: docling>=2.113.0; extra == "advanced-documents"
 Provides-Extra: test
 Requires-Dist: pytest<10,>=8; extra == "test"
 Requires-Dist: pytest-asyncio<2,>=1; extra == "test"
+Requires-Dist: pyte<0.9,>=0.8.2; extra == "test"
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -139,11 +141,10 @@ Dynamic: summary
 *Work with DeepCode in a visual workspace for Sessions, goals, tool activity, code changes, and verification.*
 </div>
 
-DeepCode has one Agent runtime and two interfaces: an interactive CLI for
-terminal workflows and a Tauri Desktop workbench for visual Sessions, review,
-and settings. Both open the same local Projects, Session history, models,
-Skills, permissions, Goals, and Automations. See the
-[`Desktop source guide`](desktop/README.md) to run the application locally.
+DeepCode provides TUI, Desktop, and Web clients over one shared local service.
+They share Projects, Session history, models, Skills, permissions, Goals, and
+Automations. Use `deepcode`, `deepcode desktop`, or `deepcode web`; see
+[Quick start](#quick-start) for installation and your first task.
 
 ---
 
@@ -194,6 +195,14 @@ Skills, permissions, Goals, and Automations. See the
   - [Automate repeatable engineering work](#automate-repeatable-engineering-work)
   - [Paper2Code](#paper2code)
 - [⚡ Quick start](#quick-start)
+  - [Launch commands at a glance](#launch-commands-at-a-glance)
+  - [Install the runtime](#install-the-runtime)
+  - [Configure a model](#configure-a-model)
+  - [Start the TUI](#start-the-tui)
+  - [Start Desktop](#start-desktop)
+  - [Start Web](#start-web)
+  - [Complete your first task](#complete-your-first-task)
+  - [Manage the shared background service](#manage-the-shared-background-service)
 - [🧭 Using DeepCode](#using-deepcode)
 - [⚙️ Headless and automation](docs/HEADLESS_AND_AUTOMATION.md)
 - [🔬 Paper2Code](#paper2code-1)
@@ -212,6 +221,100 @@ Skills, permissions, Goals, and Automations. See the
 
 ## News
 
+**2026-10-12 · DeepCode v2.3.1: Markdown answers in the TUI, a Windows service that stays up, `/compact` for coding sessions, and community fixes**
+
+- **Answers render as Markdown while they stream.** Headings, lists, bold
+  text and tables are formatted as each line completes; code blocks are not
+  indented or wrapped by DeepCode, links show their address, and the line
+  still being written is previewed above the status line. `/raw` prints
+  answers exactly as written, for copying. The reasoning card now comes
+  before the answer, and `Ctrl+O` mid-answer no longer repeats or drops
+  lines. See [The terminal UI](docs/guide/the-tui.md).
+- **The Windows service stays up.** On a Windows install in a virtual
+  environment, the background service no longer stops right after it starts,
+  whether the TUI, `deepcode service start`, or `deepcode web` launched it.
+- **`/compact` handles coding sessions.** Tool-call arguments, such as the file
+  a `write_file` call carries, now count when compaction picks what to keep and
+  checks that the summary is smaller. Sessions that wrote large files compact
+  instead of being refused, and the report shows the characters actually
+  replaced. (#258)
+- **Community fixes.** Diff lines that contain a Unicode line separator or a
+  form feed stay whole (#253); web fetch refuses private addresses tunnelled
+  through NAT64 or IPv4-compatible IPv6 (#254); the destructive-command screen
+  also catches absolute paths such as `/bin/rm -rf /` (#255); and `glob` finds
+  files when the project sits under a directory named `build` or `venv` (#256).
+- **Security updates.** pypdf, PyJWT, urllib3, and multidict move to patched
+  releases.
+
+**2026-10-10 · A steadier terminal UI: answers shown once, keys that keep your draft, and an orderly `/compact`**
+
+- **Answers appear once.** The TUI no longer prints an answer a second time
+  when it finishes, and a stopped answer keeps the text already shown, in every
+  client.
+- **Keys that keep your draft.** `Esc` interrupts only from an empty prompt and
+  otherwise closes a completion menu; `Ctrl+C` first clears what you are
+  typing. Stopping a command no longer closes the TUI. See
+  [The terminal UI](docs/guide/the-tui.md).
+- **Calm when the service is slow.** Typing, completion, and `Ctrl+C` stay
+  responsive while the background service is busy; a slow answer is reported
+  instead of retried three times, and `/reconnect` brings your conversation
+  back after a restart.
+- **`/compact` waits its turn.** A message sent during compaction waits for the
+  summary, the next reply no longer starts with a failed request, and a refusal
+  says why instead of "internal error". See [Sessions](docs/guide/sessions.md).
+- **Current settings, safer Goals.** Default model and access changes show up
+  in the TUI, `/new` follows your defaults, and `/goal clear out …` sets a new
+  objective instead of clearing the Goal.
+
+**2026-09-28 · DeepCode v2.3.0: voice dictation, Opper and Bedrock, Desktop polish, and opt-in hardening**
+
+- **Dictate your prompt.** Add a `dictation` block to your config and the
+  Desktop and Web composer gains a microphone. See
+  [Voice dictation](docs/guide/dictation.md). (#240)
+- **More providers and models.** Opper and Amazon Bedrock join the provider
+  templates, and DeepSeek V4 gets its own 1M context window and pricing.
+  (#242, #208, #249)
+- **Desktop polish.** Drag the conversation's edge to resize it, import a
+  VS Code color theme, and choose from fonts that are actually installed.
+  (#238, #207, #239)
+- **Opt-in hardening.** `providers.egress` limits which hosts receive your
+  prompts, `DEEPCODE_COMMAND_SCREEN=strict` screens risky commands,
+  `DEEPCODE_BASH_SCRUB_ENV=1` keeps provider keys out of shell commands, and
+  `DEEPCODE_KEYRING=1` reads keys from the OS keychain. (#229, #230, #232,
+  #246)
+- **Leaner memory and clearer signals.** `MEMORY.md` can be a short index of
+  topic files, `mcp list` flags servers worth a second look, and the agent is
+  reminded when a call keeps returning the same result. (#233, #241, #247)
+- **Steadier everywhere.** The state database keeps its locks when several
+  DeepCode processes share it, and a round of Windows fixes landed. (#210,
+  #235, #236, #237)
+
+<details>
+<summary><strong>Earlier updates, August to early September 2026</strong></summary>
+
+**2026-09-09 · TUI, Desktop, and Web share one local background service**
+
+- **Choose your interface.** Run `deepcode` for the TUI, `deepcode desktop`
+  for the native app, or `deepcode web` to open the workbench in your browser.
+  All three connect to the same local service; Web needs no DeepCode account.
+- **Continue the same task across interfaces.** Closing a client leaves running
+  work in the background. Reconnect from another interface to follow the same
+  conversation, review tool activity, and respond to approvals. The computer
+  must remain awake, and pending approvals still need your response.
+- **Configure and verify your models.** Save cloud or local model connections
+  for use across all three interfaces. Browse available models, check a model's
+  response, and test streaming and tool calls before using a custom server.
+  See [Models and providers](docs/guide/models.md).
+- **Manage your background service and prepare for upgrades.** Use
+  `deepcode service` commands to check status, read logs, or stop after current
+  work finishes. Create a runtime snapshot before upgrading and restore it when
+  needed; keep project files in your usual version control or backup.
+  See [Upgrading DeepCode](docs/UPGRADE_AND_RESTORE.md).
+
+Start with the updated [Quick start](#quick-start) and
+[first coding task tutorial](docs/guide/getting-started.md).
+([#212](https://github.com/HKUDS/DeepCode/pull/212))
+
 **2026-09-06 · DeepCode v2.2.0: Session context-window caps, compaction that leaves a memory, and a fully localized Desktop**
 
 - **Cap a Session's context window.** `/context 64k` in the TUI or the
@@ -391,9 +494,6 @@ Skills, permissions, Goals, and Automations. See the
   `/rename`, `/delete`, `/retry`, with tab completion for session ids,
   transcript modes, permission presets, and effort levels.
 
-<details>
-<summary><strong>Earlier August 2026 updates</strong></summary>
-
 **2026-08-14 · Subagent runtime, compaction, and one-way persistence**
 
 - **Delegate to Codex or Claude Code as a subagent.** `spawn_agent` gains
@@ -665,9 +765,9 @@ you finish real software engineering work more reliably.
 
 ## Core capabilities
 
-DeepCode provides a complete local Coding Agent workflow. CLI and Desktop are
-two ways to use the same Agent, Sessions, models, Skills, permissions, and task
-state.
+DeepCode provides a complete local Coding Agent workflow. TUI, Desktop, and Web
+use the same Agent, Sessions, models, Skills, permissions, and task state through
+the shared local service.
 
 <p align="center">
   <img src="assets/readme/verification-loop.png" alt="DeepCode Agent Harness and verification loop" width="1080" />
@@ -786,7 +886,14 @@ Automation does not launch a separate, reduced Agent. It uses the same
 Sessions, models, Skills, permissions, approvals, and recovery behavior, and
 keeps the history of every run.
 
-### Paper2Code
+### Shared background service
+
+Desktop, Web, TUI, `exec`, `loop`, and MCP task calls use the same local service.
+Starting a client starts the service when needed. Closing a client leaves its
+accepted tasks running; explicitly stop the service to shut down the runtime.
+See [Quick start](#quick-start) for installation and launch commands.
+
+## Paper2Code
 
 Paper2Code was DeepCode's original research direction and remains its dedicated
 workflow for research reproduction.
@@ -800,156 +907,188 @@ run, be inspected, and keep improving.
 
 ## Quick start
 
-DeepCode has two interfaces with separate installation paths. Choose one to get
-started; both use the same Agent runtime and canonical Session history.
+Use DeepCode to explore a repository, make changes, and run tests. Choose the
+terminal, desktop app, or browser—your projects and conversations are available
+in all three.
 
-> `uv tool install --python 3.12 deepcode-hku` installs the CLI and shared
-> Python runtime. It does **not** install the Tauri Desktop application.
+### Launch commands at a glance
 
-### Option A — Install the CLI
+After installation, open the interface you prefer:
 
-Install `uv` first if it is not already available. On Windows PowerShell:
+| Interface | Start command |
+|---|---|
+| **TUI** — work in your terminal | `deepcode` |
+| **Desktop** — use a native app | `deepcode desktop` |
+| **Web** — work in your browser | `deepcode web` |
 
-```powershell
-winget install --id astral-sh.uv --exact
-```
+DeepCode starts its local background service automatically. You can close an
+interface and return to your conversation later.
+
+### Install the runtime
 
-Open a new terminal after the first `uv` installation, then run:
+#### Published package
+
+With `uv` installed, run:
 
 ```console
 uv tool install --python 3.12 deepcode-hku
 deepcode init
 ```
 
-The explicit Python selection is intentional: DeepCode requires Python 3.12+
-and must not fall back to an unsupported legacy package on an older interpreter.
-If an existing uv tool environment still contains DeepCode 1.x, migrate it with
-`uv tool upgrade --python 3.12 deepcode-hku`.
+On Windows, you can install `uv` with `winget install --id astral-sh.uv --exact`,
+then open a new terminal. DeepCode requires Python 3.12 or later.
+
+To use the native app, also install DeepCode Desktop from
+[GitHub Releases](https://github.com/HKUDS/DeepCode/releases). To try changes
+that have not been released yet, install from source below.
+
+<details>
+<summary>Install from source</summary>
+
+#### Current source checkout
+
+You will need Git, `uv`, and Node.js 22 or later. Run these commands in your terminal:
+
+```console
+git clone https://github.com/HKUDS/DeepCode.git
+cd DeepCode
+npm --prefix desktop ci
+npm --prefix desktop run build:web
+uv tool install --python 3.12 --force .
+deepcode init
+```
+
+If you already have the repository, start in its root directory and skip cloning.
+You can now run `deepcode` from any directory. For source Desktop, also install
+Rust and the platform dependencies described in the [Desktop guide](desktop/README.md).
+
+</details>
+
+If your terminal cannot find `deepcode`, run `uv tool update-shell` and open a
+new terminal.
 
-Create a model connection once. `--api-key` opens a non-echoing prompt:
+### Configure a model
+
+Choose either the graphical setup or the terminal commands below.
+
+**In Desktop or Web:** open **Settings → AI providers**, select **Add provider**,
+and enter your provider's API key. Click **Save and check** to load its models.
+Under **Agent model**, choose a model and click **Save and verify model** to try
+a short request. Then choose the connection and model in your conversation's
+message box.
+
+<div align="center">
+  <img src="assets/setting_model.png" alt="Choose a provider and model in DeepCode settings" width="100%" style="border-radius: 10px; box-shadow: 0 8px 20px rgba(45,55,72,0.2); margin: 15px 0;"/>
+</div>
+
+**In your terminal:** this example connects to OpenRouter. Enter your API key
+when prompted; it will not be displayed as you type.
 
 ```console
-deepcode provider set personal-openrouter --template openrouter --label "OpenRouter · Personal" --api-key
-deepcode provider models personal-openrouter --refresh
-deepcode provider test personal-openrouter --model <model-id>
+deepcode provider set my-openrouter --template openrouter --api-key
+deepcode provider models my-openrouter --refresh
 ```
 
-Enter the repository you want DeepCode to work in and start the interactive
-Agent:
+Choose a model from the list. Replace `MODEL_ID` below with its exact ID and
+send a short test request:
 
 ```console
-cd <your-project>
-deepcode
+deepcode provider test my-openrouter --model MODEL_ID
 ```
 
-`deepcode init` creates minimal user configuration under `~/.deepcode/`.
-Credentials are stored separately in user-private storage and are never written
-to Session history. `pipx install deepcode-hku` and `pip install deepcode-hku`
-are also supported in an appropriate Python 3.12+ environment.
+You can use the same connection in all three interfaces. For other providers,
+local models, and tool-calling checks, see [Models and providers](docs/guide/models.md).
 
-### Option B — Install Desktop
+### Start the TUI
 
-Desktop release bundles are distributed separately from the Python package.
-Check [GitHub Releases](https://github.com/HKUDS/DeepCode/releases) for a signed
-installer for your platform. If no installer is attached, use the source setup
-below.
+Open a terminal in the project you want to work on. On your first visit, use
+`--trust` to allow DeepCode to work in that folder. With the connection configured
+above:
 
-#### macOS and Linux from source
+```console
+cd /path/to/your-project
+deepcode --trust --connection my-openrouter --model MODEL_ID
+```
 
-Install the platform dependencies from the
-[Tauri 2 prerequisite guide](https://v2.tauri.app/start/prerequisites/), plus
-Git, Python 3.12+, `uv`, Node.js 22+, and stable Rust. Then run:
+Replace the path with your project directory; on Windows, for example,
+`C:\projects\my-app`. For later visits, run `deepcode` in that directory and use
+`/model` to choose your connection and model. Use `/help` to see available commands.
 
-```bash
-git clone https://github.com/HKUDS/DeepCode.git
-cd DeepCode
-uv venv --python 3.12
-uv pip install --python .venv/bin/python -e .
-.venv/bin/deepcode init
-cd desktop
-npm ci
-npm run setup:sidecar
-npm run build:sidecar
-cd ..
-mkdir -p ~/.local/bin
-ln -sf "$(pwd)/scripts/deepcode-desktop" ~/.local/bin/deepcode-desktop
-export PATH="$HOME/.local/bin:$PATH"
-deepcode-desktop
+### Start Desktop
+
+```console
+deepcode desktop
 ```
 
-The final link is a one-time source launcher installation. Afterwards,
-`deepcode-desktop` starts this checkout from any directory, provided
-`~/.local/bin` is on `PATH`. Add the export to your shell profile if it is not
-already configured. The command launches Desktop; add or select the repository
-you want to work on from the Project sidebar.
-
-#### Windows from source
-
-Windows requires Microsoft Edge WebView2 and the Visual Studio 2022 Build Tools
-workload **Desktop development with C++**. Accept the UAC prompt raised by Build
-Tools:
-
-```powershell
-winget install --id Git.Git --exact
-winget install --id astral-sh.uv --exact
-winget install --id OpenJS.NodeJS.LTS --exact
-winget install --id Rustlang.Rustup --exact
-winget install --id Microsoft.VisualStudio.2022.BuildTools --exact `
-  --override "--wait --passive --norestart --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended"
+Add your project folder, confirm that you trust it, and click **New thread**.
+Choose a model in the message box, then describe what you want to do.
+
+If you installed from source, this command opens the development app. Its first
+launch may take longer while dependencies are prepared; keep the terminal open
+while you use it. See the [Desktop guide](desktop/README.md) for platform setup
+and custom installation paths.
+
+### Start Web
+
+```console
+deepcode web
 ```
 
-Close PowerShell, open a new window, and verify the toolchains:
+DeepCode opens a browser tab. Add your project folder on this computer, confirm
+that you trust it, and create a thread. Select a model and send your first message.
+No DeepCode account is needed.
+
+To copy the access link and open it yourself, use `deepcode web --no-open`.
+Open the link within 60 seconds. If it expires or the page asks you to sign in
+again, run `deepcode web` to get a fresh link.
+
+### Complete your first task
 
-```powershell
-git --version
-uv --version
-node --version
-rustup default stable-msvc
-rustc --version
-cargo --version
+Start by asking DeepCode to help you understand your project:
+
+```text
+Explain how this project is organized and how to run its tests.
+Do not change any files yet.
 ```
 
-Clone, prepare, and start Desktop:
+Then ask for a small change, describing the behavior you want and how to check it:
 
-```powershell
-git clone https://github.com/HKUDS/DeepCode.git
-Set-Location DeepCode
-uv venv --python 3.12
-uv pip install --python .venv\Scripts\python.exe -e .
-.venv\Scripts\deepcode.exe init
-Set-Location desktop
-npm ci
-$env:DEEPCODE_PYTHON = (Resolve-Path ..\.venv\Scripts\python.exe)
-npm run setup:sidecar
-npm run build:sidecar
-npm run tauri -- dev
+```text
+Add tests for the configuration loader's handling of missing and invalid
+values. Follow the existing test style, run the relevant tests, and summarize
+the changes and results.
 ```
 
-Keep that PowerShell window open while Desktop is running. See the
-[Desktop source guide](desktop/README.md#windows-powershell) for subsequent
-launches and troubleshooting.
+Adapt the task to your repository. Follow the tool activity as DeepCode works,
+respond to any approval requests, and review the changed files and test output.
+You can send a follow-up message to adjust the task, or use the stop button
+(`/stop` in the TUI) to interrupt it.
 
-#### Configure the Desktop model
+Your conversation is saved automatically. In Desktop/Web, select it from the
+project's thread list. In the TUI, use `/resume` to pick a saved conversation.
+You can switch interfaces and continue the same task.
 
-Open **Settings → AI providers** after Desktop starts.
+For a complete exercise in a new folder, follow
+[Your first coding task](docs/guide/getting-started.md). It takes you through
+creating a Python function, testing it, and returning to the conversation later.
 
-<div align="center">
-  <img src="assets/setting_model.png" alt="Configure an AI provider and model in DeepCode Desktop" width="100%" style="border-radius: 10px; box-shadow: 0 8px 20px rgba(45,55,72,0.2); margin: 15px 0;"/>
+### Manage the shared background service
 
-  <sub>Provider credentials, model discovery, and inference verification stay in one Desktop workflow.</sub>
-</div>
+Closing an interface leaves running tasks in the background. Pending approvals
+still need your response, and the computer must remain awake for work to continue.
+
+Most days, you can just launch your preferred interface. When you need to inspect
+or stop the background service, use the command for that action:
 
-1. Select **Add provider**, choose the service, and enter an API key or its
-   environment-variable name.
-2. Select **Save and check** to verify the credential and load the provider's
-   model catalog without sending repository content.
-3. Under **Agent model**, choose an exact model ID and select **Save and verify
-   model**. This final check sends only a minimal inference request.
-4. Add or open a Project, create a Session, choose the model, Thinking effort,
-   and access level, then describe the task in natural language.
+| What you want to do | Command |
+|---|---|
+| Check whether DeepCode is running | `deepcode service status` |
+| Read recent logs | `deepcode service logs --lines 100` |
+| Stop after current work finishes | `deepcode service stop --drain --timeout 60` |
+| Start automatically after signing into your computer | `deepcode service install --at-login` |
 
-> The interface changes how the work is presented, not the Agent, policy,
-> configuration, or Session history behind it.
+For updates and backups, follow [Upgrading DeepCode](docs/UPGRADE_AND_RESTORE.md).
+If something does not work, start with [Troubleshooting](docs/guide/troubleshooting.md).
 
 ## Using DeepCode
 
@@ -961,10 +1100,10 @@ skills and memory, and headless automation — with worked examples.
 
 Every task lives in a durable Session attached to its original Project. Open a
 Project in Desktop or start `deepcode` from its directory, then create a new
-Session or resume an existing one. The same history can move between Desktop
-and CLI without export or conversion.
+Session or resume an existing one. The same history is available in TUI,
+Desktop, and Web without export or conversion.
 
-| What you want to do | Desktop | Interactive CLI |
+| What you want to do | Desktop / Web | Interactive CLI |
 |---|---|---|
 | Start a Session | **New thread** | `/new [title]` |
 | Resume local history | Select it under the Project | `/resume` |
@@ -985,9 +1124,11 @@ and CLI without export or conversion.
 | Rename or delete a Session | Session context menu | `/rename <title>` · `/delete <id>` |
 
 Session history, tool activity, approvals, Goal state, and verification evidence
-remain together. A Session has one live writer at a time: Desktop and the CLI
-may hold it open together, but if one is mid-Turn the other refuses new input
-with a message naming the holder instead of corrupting shared history. Archiving hides a Session without deleting its history;
+remain together. TUI, Desktop, and Web can observe the same Session while the
+shared service serializes its execution. Normal input during a Turn steers the
+active work; explicit queueing requests a subsequent Turn. The interface reports
+how the input was accepted. Closing a client leaves accepted work running.
+Archiving hides a Session without deleting its history;
 permanent deletion removes the Session records but never repository files.
 
 ### Connections and models
@@ -1308,6 +1449,9 @@ On Windows PowerShell, activate with `.\.venv\Scripts\Activate.ps1`.
 
 ### Verification
 
+To reproduce CI's Python environment and understand each check, see the
+[CI guide](docs/CI.md).
+
 ```bash
 uvx pre-commit run --all-files
 python -m compileall -q app_server cli core tools workflows