carve-server 0.1.0__tar.gz

carve_server-0.1.0/.carveignore

@@ -0,0 +1,37 @@
+# Carve metadata
+*.crv
+
+.claude/
+test.py
+test2.py
+test3.py
+test4.py
+
+# VCS
+.git/
+.hg/
+.svn/
+
+# Python
+__pycache__/
+*.egg-info/
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+.tox/
+.eggs/
+.venv/
+venv/
+
+# JS
+node_modules/
+
+# Build output
+dist/
+build/
+*.db
+*.png
+*.jpg
+*.gif
+*.ico
+.playwright-mcp/

carve_server-0.1.0/.gitignore

@@ -0,0 +1,50 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.mypy_cache/
+.ruff_cache/
+
+# OS
+.DS_Store
+Thumbs.db
+
+scratch*
+.flask.log
+.flask.pid
+.playwright-mcp/
+.claude/

carve_server-0.1.0/CLAUDE.md

@@ -0,0 +1,235 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Carve is a Text Editor for Agents. It uses tree-sitter ASTs as the source of truth, treating source files as generated artifacts. The server exposes navigation and mutation tools via MCP (stdio) and HTTP (REST) transports.
+
+**Phase 1 and Phase 2 are complete.** See `TODO.md` for Phase 3 roadmap.
+
+## Commands
+
+```bash
+# Install (editable with dev deps)
+uv pip install -e ".[dev]"
+
+# Run all tests (149 tests, pytest-asyncio with asyncio_mode=auto)
+uv run pytest
+
+# Run a single test file
+uv run pytest tests/test_tools.py
+
+# Run a single test by name
+uv run pytest -k "test_detect_python"
+
+# Type check (strict mode enabled)
+uv run mypy carve/
+
+# Lint
+uv run ruff check carve/ tests/
+```
+
+## Architecture
+
+```
+carve/
+  models.py    - Pydantic models: TreeNode, NodeMetadata, TreeStore (in-memory single-file store)
+  node_id.py   - Hierarchical ID generation (e.g. "module::ClassName::method_name")
+  parser.py    - Tree-sitter parser with auto language detection from file extensions
+  tools.py     - All tool implementations: navigation (subtree, ancestors, inspect, search),
+                 mutation (insert, update, delete, validate_snippet),
+                 project (project_import, project_serialize)
+  server.py    - CarveServer wrapper + MCP transport (create_mcp_server) + HTTP transport (create_http_app via FastAPI)
+  cli.py       - CLI entry point (`carve serve --mcp` or `carve serve --http`)
+```
+
+**Key data flow:** Source file → `TreeSitterParser.to_tree_store()` → `TreeStore` (dict of `TreeNode` keyed by node ID) → tools operate on the store → `project_serialize()` regenerates source code.
+
+**Node IDs** are deterministic hierarchical paths built from the AST: `module::ClassName::method_name`. Each language defines its own set of named types that form hierarchy components (see `PYTHON_NAMED_TYPES`, `JAVASCRIPT_NAMED_TYPES`, etc. in `node_id.py`).
+
+**Dual transport:** `CarveServer` wraps all tool logic. Both MCP and HTTP transports delegate to it, so tool behavior is transport-agnostic.
+
+**Supported languages:** Python, JavaScript, HTML, CSS, JSON (via tree-sitter grammars). Unsupported extensions are stored as `text` (no AST, raw content only).
+
+## Using Carve Efficiently
+
+When using carve MCP tools to edit this codebase, prefer carve over file-based tools (Read, Edit, Write, Bash). Also use carve's custom tools (`run_test`, `run_typecheck`, `run_lint`, `run_install`, `run_flask`) instead of Bash for running commands.
+
+For the full reference on Carve workflows, read the `carve://guide` MCP resource.
+
+**Target the smallest node that covers your change.** Carve nodes go all the way down to individual statements. Replacing a single `assert_statement` or `expression_statement` is far more efficient than replacing an entire function.
+
+```
+# GOOD: update just the one statement that changed
+update(node_id="...::test_foo::assert_statement[1]", snippet='assert result == "new_value"')
+
+# WASTEFUL: replace the entire function to change one line
+update(node_id="...::test_foo", snippet="def test_foo(): ...")
+```
+
+**Use navigation tools for understanding, mutation tools for editing:**
+- `subtree` / `search` — structural overview without reading full files
+- `find_references` — cross-file dependency tracing
+- `inspect` — read a specific node's source
+- `update` at the statement level — surgical edits
+
+**Always pass sidecar metadata on every mutation.** The `insert`, `update`, `delete`, `move`, and `batch` tools accept `prompt`, `model`, and `notes` parameters that are logged to `.crv` sidecar files. You MUST pass these on every mutation call — without them the audit trail is empty.
+
+```
+# GOOD: includes sidecar metadata
+update(
+    node_id="module::Calculator::add",
+    snippet="def add(self, a, b): return a + b",
+    prompt="Simplify the add method",
+    model="claude-opus-4-6",
+    notes="Removed type annotations per user request"
+)
+
+# BAD: sidecar log entry will be full of nulls
+update(node_id="module::Calculator::add", snippet="def add(self, a, b): return a + b")
+```
+
+**Call `project_serialize` before testing.** Carve holds mutations in-memory. Files on disk are only updated when you serialize. Always serialize before running the server, tests, or any tool that reads from disk.
+
+**Use `insert` on a directory node to create new files.** Pass `file_name` along with `parent_id` pointing to the directory. New file creation via `insert` skips tree-sitter validation, which is important for languages with incomplete grammars (see Jinja note below).
+
+**For complete rewrites, use file-level `update`.** When every line changes (e.g., converting a todo app to a kanban board), update the file node directly rather than trying to surgically edit dozens of nodes. Reserve surgical edits for incremental changes.
+
+**Markdown works great for targeted edits.** The tree-sitter markdown grammar is complete — sections, headings, lists, code blocks are all distinct nodes. You can update a single `### Subsection` without touching the rest of the file.
+
+### Language-specific tips
+
+**Python:** Best Carve experience. Functions, classes, decorators, individual statements are all targetable. Use `subtree` with `depth=2` to see the structure, then `update` specific nodes.
+
+**Jinja/HTML templates:** Limited by incomplete `tree-sitter-jinja` grammar (see `BUGS.md` BUG-001). Key limitations:
+- `{% include %}`, `{% block %}`, `{% extends %}`, `{% set %}`, `{% macro %}` all cause syntax errors during validation
+- `insert` (new file creation) works because it skips validation
+- `update` fails on any file containing unsupported tags — even if your edit is on a different node
+- **Workaround:** Delete the file and recreate it with `insert` (whole-file replace)
+- Templates that only use `{% if %}`, `{% for %}`, and `{{ }}` can be updated normally
+- `template_data` nodes represent raw HTML fragments between Jinja tags — they slice across HTML element boundaries, so they're awkward to target
+
+**CSS-in-templates:** Styles embedded in `<style>` tags within Jinja templates land inside `template_data` nodes. If the template uses `{% include %}`, you can't update them surgically. Consider putting shared styles in a partial that only uses supported Jinja tags.
+
+### The example Flask app
+
+The `examples/` directory contains a Kanban board app used for demoing Carve. Useful commands:
+- `run_flask start` — start the server on port 5000
+- `run_flask stop` — stop it
+- `run_flask status` — check if running
+- The database is `examples/kanban.db` (SQLite, auto-created on first run)
+- Templates are in `examples/templates/` using Jinja2 with Pico CSS + htmx + SortableJS via CDN## Code Conventions
+
+- Python 3.11+, strict mypy, Pydantic models for all data structures
+- Ruff with rules: E, F, I, N, W, UP, B, C4, SIM; line length 100
+- Tests are class-based (`TestClassName`), use fixtures, and live in `tests/`
+- Commit messages follow conventional commits (`feat:`, `docs:`, `fix:`)
+
+## Testing Guidelines
+
+Tests must be **black-box behavioral tests** that survive internal refactoring. The public API surface is:
+
+1. **Tool functions** in `carve.tools` (subtree, ancestors, inspect, search, insert, update, delete, move, create_file, find_references, error_locate, ts_query, validate_snippet, project_import, project_serialize)
+2. **CarveServer** methods in `carve.server`
+3. **HTTP endpoints** via FastAPI
+
+### Rules for New Tests
+
+**Assert on tool return values, not model internals.**
+
+```python
+# GOOD: verify through the tool API
+result = insert(store, parent_id, "end", snippet)
+assert "error" not in result
+inspected = inspect(store, result["node_id"])
+assert "def greet" in inspected["source"]
+
+# BAD: reaching into model internals
+result = insert(store, parent_id, "end", snippet)
+node = store.get_node(result["node_id"])  # internal model access
+assert node.source == expected              # Pydantic field
+assert node.metadata.version == 2           # internal metadata
+```
+
+**Discover node IDs dynamically, don't hardcode them.**
+
+```python
+# GOOD: discover via search
+results = search(store, pattern="Calculator")
+calc_id = results[0]["node_id"]
+
+# BAD: hardcoded ID format
+calc_id = "module::Calculator"
+```
+
+**Set up stores via `project_import`, not parser internals.**
+
+```python
+# GOOD: use the tool API
+py_file = tmp_path / "test.py"
+py_file.write_text(source)
+store = project_import(str(py_file))
+
+# BAD: coupling to parser internals
+store = parser.to_tree_store(source, "python", "test.py")
+```
+
+**Verify side effects through tools or disk, not internal dicts.**
+
+```python
+# GOOD: verify deletion via search
+delete(store, node_id)
+results = search(store, pattern="greet")
+assert not any(r["node_id"] == node_id for r in results)
+
+# GOOD: verify disk write by reading the file
+result = update(store, node_id, new_snippet)
+content = Path(store.file_path).read_text()
+assert "new_function" in content
+
+# BAD: poking internal dicts
+delete(store, node_id)
+assert node_id not in store.file_sources  # internal dict
+assert store.get_node(node_id) is None     # internal method
+```
+
+**Verify sidecar writes by reading the .crv JSON file, not private functions.**
+
+```python
+# GOOD: read the file directly
+crv = tmp_path / "app.py.crv"
+entries = json.loads(crv.read_text())
+assert entries[-1]["operation"] == "update"
+
+# BAD: importing private helpers
+from carve.tools import _read_sidecar  # underscore = private
+entries = _read_sidecar(crv)
+```
+
+**Never import underscore-prefixed functions** (`_read_sidecar`, `_reindent_snippet`, `_validate_in_context`, etc.). These are implementation details. If behavior needs testing, test it through the public tool that calls it.
+
+### Acceptable Internal Tests
+
+`test_parser.py` tests parser and model internals directly — this is fine and expected for unit-testing the parser layer. These tests are understood to break when parser internals change. Keep them isolated in `test_parser.py` and label the file clearly.
+
+### Test File Organization
+
+| File | Purpose | API Layer |
+|------|---------|-----------|
+| `test_parser.py` | Parser/model unit tests (internal, expected to break on refactor) | `TreeSitterParser`, `TreeNode`, `TreeStore` |
+| `test_server.py` | Server + HTTP endpoint tests (gold standard for black-box) | `CarveServer`, HTTP |
+| `test_tools.py` | Tool behavior tests | Tool functions |
+| `test_multifile.py` | Multi-file/ProjectStore behavior | Tool functions + `project_import` |
+| `test_bugs.py` | Regression tests for fixed bugs | Tool functions |
+| `test_sidecar.py` | Sidecar persistence behavior | Tool functions + disk |
+| `test_ts_query.py` | Tree-sitter query behavior | `ts_query` tool |
+| `test_draft_promote.py` | Validation/indentation behavior | `insert`, `update` tools |
+
+## Bug Reporting
+
+When you encounter bugs during development or testing, write detailed bug reports to `BUGS.md`. Each report should include:
+- Summary of the issue
+- Exact steps to reproduce (code snippets or MCP tool call sequences)
+- Observed vs expected behavior
+- Likely cause if apparent

carve_server-0.1.0/CLAUDE.md.crv

@@ -0,0 +1,26 @@
+[
+  {
+    "operation": "update",
+    "node_id": "",
+    "timestamp": "2026-02-13T06:04:29.301004+00:00",
+    "model": null,
+    "prompt": null,
+    "notes": null
+  },
+  {
+    "operation": "insert",
+    "node_id": "section[0]::section[5]::section[0]",
+    "timestamp": "2026-02-13T17:05:55.304839+00:00",
+    "model": "claude-opus-4-6",
+    "prompt": "Add how-to-rename-a-file guidance to CLAUDE.md",
+    "notes": "No dedicated rename tool exists; compose create_file + move + delete instead"
+  },
+  {
+    "operation": "update",
+    "node_id": "section[0]::section[5]",
+    "timestamp": "2026-02-13T17:53:50.079649+00:00",
+    "model": "claude-opus-4-6",
+    "prompt": "Add practical tips learned from building the kanban board app",
+    "notes": "Added: serialize before testing, insert for new files, file-level update for rewrites, markdown works well, language-specific tips for Python/Jinja/CSS, Jinja limitations and workarounds, flask app docs"
+  }
+]

carve_server-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Scott Russell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

carve_server-0.1.0/PKG-INFO

@@ -0,0 +1,271 @@
+Metadata-Version: 2.4
+Name: carve-server
+Version: 0.1.0
+Summary: Text Editor for AI Agents
+Author-email: Scott Russell <me@scottrussell.net>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: tree-sitter>=0.24.0
+Requires-Dist: uvicorn>=0.34.0
+Provides-Extra: all
+Requires-Dist: tree-sitter-bash>=0.24.0; extra == 'all'
+Requires-Dist: tree-sitter-css>=0.24.0; extra == 'all'
+Requires-Dist: tree-sitter-html>=0.23.0; extra == 'all'
+Requires-Dist: tree-sitter-javascript>=0.24.0; extra == 'all'
+Requires-Dist: tree-sitter-jinja>=0.3.3; extra == 'all'
+Requires-Dist: tree-sitter-json>=0.24.0; extra == 'all'
+Requires-Dist: tree-sitter-markdown>=0.5.1; extra == 'all'
+Requires-Dist: tree-sitter-python>=0.24.0; extra == 'all'
+Requires-Dist: tree-sitter-toml>=0.7.0; extra == 'all'
+Requires-Dist: tree-sitter-yaml>=0.7.2; extra == 'all'
+Provides-Extra: bash
+Requires-Dist: tree-sitter-bash>=0.24.0; extra == 'bash'
+Provides-Extra: css
+Requires-Dist: tree-sitter-css>=0.24.0; extra == 'css'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.14.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.25.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.9.0; extra == 'dev'
+Requires-Dist: tree-sitter-bash>=0.24.0; extra == 'dev'
+Requires-Dist: tree-sitter-css>=0.24.0; extra == 'dev'
+Requires-Dist: tree-sitter-html>=0.23.0; extra == 'dev'
+Requires-Dist: tree-sitter-javascript>=0.24.0; extra == 'dev'
+Requires-Dist: tree-sitter-jinja>=0.3.3; extra == 'dev'
+Requires-Dist: tree-sitter-json>=0.24.0; extra == 'dev'
+Requires-Dist: tree-sitter-markdown>=0.5.1; extra == 'dev'
+Requires-Dist: tree-sitter-python>=0.24.0; extra == 'dev'
+Requires-Dist: tree-sitter-toml>=0.7.0; extra == 'dev'
+Requires-Dist: tree-sitter-yaml>=0.7.2; extra == 'dev'
+Provides-Extra: html
+Requires-Dist: tree-sitter-html>=0.23.0; extra == 'html'
+Provides-Extra: javascript
+Requires-Dist: tree-sitter-javascript>=0.24.0; extra == 'javascript'
+Provides-Extra: jinja
+Requires-Dist: tree-sitter-jinja>=0.3.3; extra == 'jinja'
+Provides-Extra: json
+Requires-Dist: tree-sitter-json>=0.24.0; extra == 'json'
+Provides-Extra: markdown
+Requires-Dist: tree-sitter-markdown>=0.5.1; extra == 'markdown'
+Provides-Extra: python
+Requires-Dist: tree-sitter-python>=0.24.0; extra == 'python'
+Provides-Extra: toml
+Requires-Dist: tree-sitter-toml>=0.7.0; extra == 'toml'
+Provides-Extra: yaml
+Requires-Dist: tree-sitter-yaml>=0.7.2; extra == 'yaml'
+Description-Content-Type: text/markdown
+
+# Carve
+
+**Text Editor for AI Agents**
+
+Carve lets AI agents edit code structurally instead of rewriting entire files. It parses source code into a tree-sitter AST, exposes navigation and mutation tools over MCP or HTTP, and regenerates source files from the tree.
+
+## Install
+
+```bash
+pip install carve-server
+```
+
+Install with language grammars:
+
+```bash
+# Individual languages
+pip install "carve-server[python]"
+pip install "carve-server[javascript]"
+
+# All supported languages
+pip install "carve-server[all]"
+```
+
+Supported: Python, JavaScript, HTML, CSS, JSON, Markdown, TOML, YAML, Bash, Jinja.
+
+## Quick Start (MCP)
+
+Add to your MCP client config (e.g. Claude Code `settings.json`):
+
+```json
+{
+  "mcpServers": {
+    "carve": {
+      "command": "carve",
+      "args": ["serve", "--mcp", "--path", "/path/to/your/project"]
+    }
+  }
+}
+```
+
+Or run directly:
+
+```bash
+carve serve --mcp --path ./my-project
+```
+
+The agent can then navigate and edit code through Carve's tool interface.
+
+## Quick Start (HTTP)
+
+```bash
+carve serve --http --path ./my-project --port 8080
+```
+
+Import a file, explore its structure, make a surgical edit:
+
+```bash
+# See the tree structure
+curl -X POST http://127.0.0.1:8080/tree/subtree \
+  -H "Content-Type: application/json" \
+  -d '{"node_id": "module", "depth": 2}'
+
+# Inspect a specific function
+curl -X POST http://127.0.0.1:8080/tree/inspect \
+  -H "Content-Type: application/json" \
+  -d '{"node_id": "module::MyClass::my_method"}'
+
+# Update just that function
+curl -X POST http://127.0.0.1:8080/tree/update \
+  -H "Content-Type: application/json" \
+  -d '{
+    "node_id": "module::MyClass::my_method",
+    "snippet": "def my_method(self, x):\n        return x * 2"
+  }'
+
+# Write changes to disk
+curl -X POST http://127.0.0.1:8080/project/serialize \
+  -H "Content-Type: application/json" \
+  -d '{}'
+```
+
+## How It Works
+
+```
+Source file → Tree-sitter AST → In-memory tree store → Tools → Regenerated source
+```
+
+Carve parses source files into a tree of named nodes with hierarchical IDs like `module::Calculator::add`. Agents navigate with `subtree`, `search`, and `inspect`, then make targeted edits with `insert`, `update`, and `delete` — down to individual statements. When done, `project_serialize` writes the tree back to disk.
+
+This means an agent can change one line inside a method without seeing or rewriting the rest of the file.
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `subtree` | Navigate tree structure from any node |
+| `ancestors` | Get the path from a node up to root |
+| `inspect` | Read a node's full source and metadata |
+| `search` | Find nodes by name pattern and/or type |
+| `find_references` | Cross-file dependency tracing |
+| `insert` | Add new code at a specific position |
+| `update` | Replace a node's implementation |
+| `delete` | Remove a node |
+| `move` | Relocate a node in the tree |
+| `batch` | Apply multiple mutations in one pass |
+| `ts_query` | Run tree-sitter S-expression queries |
+| `project_import` | Load a file or directory |
+| `project_serialize` | Write the tree back to source files |
+| `error_locate` | Map stack traces to node IDs |
+| `checkpoint` / `undo` / `redo` | Version control for mutations |
+
+## Configuration
+
+### carvesettings.toml
+
+Drop a `carvesettings.toml` in your project root to configure formatters, custom tools, and language mappings.
+
+```toml
+workspace = "."
+sidecars = true
+
+[formatters]
+python = "ruff format --quiet {file}"
+javascript = "prettier --write {file}"
+
+[tools]
+test = "uv run pytest {args}"
+lint = "uv run ruff check carve/ {args}"
+typecheck = "uv run mypy carve/"
+
+[language_map]
+".djhtml" = "jinja"
+".j2" = "jinja"
+
+[import_map]
+jinja = "tree_sitter_jinja"
+```
+
+**`formatters`** — Run after every disk write. `{file}` is replaced with the file path. Keyed by language name.
+
+**`tools`** — Custom shell commands exposed as MCP tools (prefixed with `run_`). Placeholders like `{args}` become tool parameters. Requires `--allow-custom-tools` to enable.
+
+**`sidecars`** — When `true` (default), Carve writes `.crv` sidecar files (see below). Set to `false` to disable.
+
+**`workspace`** — Default project path. Also settable via `CARVE_WORKSPACE` env var.
+
+**`language_map`** — Map file extensions to language names, extending the built-in defaults.
+
+**`import_map`** — Map language names to tree-sitter grammar module names.
+
+### .carveignore
+
+Controls which files are included when importing a directory. Uses gitignore-style patterns. Without this file, all supported files are included.
+
+```
+# Common defaults
+.git/
+__pycache__/
+*.egg-info/
+.venv/
+node_modules/
+dist/
+build/
+
+# Carve metadata
+*.crv
+
+# Project-specific
+*.db
+*.png
+```
+
+### .crv Sidecar Files
+
+Every time Carve mutates a source file, it appends an entry to a `.crv` JSON file next to it (e.g. `app.py.crv`). This is an audit trail of AI-driven changes:
+
+```json
+[
+  {
+    "operation": "update",
+    "node_id": "Calculator::add",
+    "timestamp": "2026-02-13T18:30:00+00:00",
+    "model": "claude-opus-4-6",
+    "prompt": "Simplify the add method",
+    "notes": "Removed type annotations per user request"
+  }
+]
+```
+
+Each entry records *what* changed, *when*, *which model* did it, and *why*. This metadata is restored when you re-import the file, so `inspect` shows the prompt and model that last touched each node.
+
+To disable: set `sidecars = false` in `carvesettings.toml`. To keep them out of version control, add `*.crv` to your `.gitignore`.
+
+## CLI Options
+
+```
+carve serve --mcp              # MCP server on stdio
+carve serve --http             # HTTP server (default port 8080)
+  --path DIR                   # Project directory or file to load
+  --port 8080                  # HTTP port
+  --host 127.0.0.1             # HTTP host
+  --read-only                  # Block all mutations
+  --no-create                  # Block new file creation
+  --no-delete                  # Block file/directory deletion
+  --allow-custom-tools         # Enable tools from carvesettings.toml
+```
+
+## License
+
+MIT