crow-cli 0.1.26__tar.gz → 0.1.28__tar.gz

crow_cli-0.1.28/PKG-INFO

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: crow-cli
+Version: 0.1.28
+Summary: Add your description here
+Project-URL: Homepage, https://github.com/crow-cli/crow-cli
+Project-URL: Repository, https://github.com/crow-cli/crow-cli
+Project-URL: Issues, https://github.com/crow-cli/crow-cli/issues
+Project-URL: Documentation, https://github.com/crow-cli/crow-cli#readme
+Requires-Python: >=3.14
+Requires-Dist: agent-client-protocol>=0.9.0
+Requires-Dist: coolname>=2.2.0
+Requires-Dist: directory-tree>=1.0.0
+Requires-Dist: fastmcp>=2.14.5
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: ipython>=9.10.0
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: json-schema-to-pydantic>=0.4.9
+Requires-Dist: openai>=2.21.0
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=14.3.3
+Requires-Dist: typer>=0.24.1
+Description-Content-Type: text/markdown
+
+# crow-cli
+
+<p>
+  <a href="https://pypi.org/project/crow-cli/"><img src="https://img.shields.io/pypi/v/crow-cli" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/crow-cli/"><img src="https://img.shields.io/pypi/pyversions/crow-cli" alt="Python versions"></a>
+  <a href="#license"><img src="https://img.shields.io/pypi/l/crow-cli" alt="License"></a>
+</p>
+
+[Documentation](https://crow-ai.dev)
+
+`crow-cli` is an [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) coding agent that runs in your terminal and inside ACP-compatible editors. It reads and edits code, runs shell commands, searches the web, and remembers your work across sessions.
+
+Most agent toolkits treat persistence as an afterthought. crow-cli treats it as the point: every session lives in a dedicated memory service ([crow-memory](#crow-memory--persistence--memory-api)) built on [LanceDB](https://lancedb.github.io/lancedb/) with ColBERT and ColPali embeddings, so agents recall past conversations semantically and can delegate work to one another. Sessions get memorable coolname ids (like `taupe-squirrel-of-splendid-potency`) you can resume or read from any other agent.
+
+## Requirements
+
+- Python 3.14+, managed with [uv](https://docs.astral.sh/uv/)
+- Docker, for the crow-memory and SearXNG services
+- An API key for an OpenAI-compatible LLM provider (OpenRouter, OpenAI, your own endpoint, …)
+
+| Platform | Notes |
+|----------|-------|
+| Linux    | glibc 2.35+ (Ubuntu 22.04+, Debian 12+, or equivalent) |
+| macOS    | 13+ (Ventura), Intel and Apple Silicon |
+| Windows  | 10+ (64-bit); WSL2 recommended |
+
+## Setup
+
+Install the CLI:
+
+```bash
+git clone https://github.com/crow-cli/crow-cli.git
+cd crow-cli
+uv tool install crow-cli --python 3.14      # or run without installing: uvx crow-cli --help
+```
+
+Initialize your configuration and start the backing services:
+
+```bash
+crow-cli init                          # scaffolds ~/.crow (config.yaml, .env, docker-compose)
+cd ~/.crow && docker compose up -d     # starts crow-memory + SearXNG
+```
+
+`crow-cli init` walks you through provider and model selection and writes your secrets to `~/.crow/.env`, referenced from the config as `${VAR}`.
+
+## Quick start
+
+```bash
+# One-shot prompt — prints the response and exits
+crow-cli run "explain what this repo does"
+
+# Continue an existing session by id
+crow-cli run -s <session-id> "now add tests"
+
+# Send a long, pre-written prompt from a file or stdin
+crow-cli run -f delegation.md -s <session-id>
+cat prompt.md | crow-cli run -
+
+# Interactive REPL
+crow-cli run -i
+
+# Run as an ACP agent server (for editors)
+crow-cli acp
+```
+
+Inspect stored sessions with `crow-cli inspect` (add `--session <id> --messages` to see a session's messages).
+
+## Using crow-cli in your editor
+
+crow-cli speaks ACP, so it works with any ACP-compatible client. For [Zed](https://zed.dev/), add to `~/.config/zed/settings.json`:
+
+```json
+{
+  "agent_servers": {
+    "crow-cli": {
+      "type": "custom",
+      "command": "crow-cli",
+      "args": ["acp"]
+    }
+  }
+}
+```
+
+The agent detects client capabilities (terminals, file read/write) and uses the native ACP versions when available, falling back to MCP tools otherwise.
+
+## What's in the box
+
+crow-cli is a monorepo. The pieces:
+
+### crow-cli — the agent
+
+The ACP-native agent: a streaming ReAct loop with tool calling, cancellation, conversation compaction, and multimodal input. Provider and model configuration lives in `~/.crow/config.yaml`.
+
+### crow-memory — persistence + memory API
+
+A standalone service — a LanceDB store with ColBERT (text) and ColPali (image) multivector embeddings — that the agent talks to over HTTP. It backs both session persistence and a semantic memory API, exposed to agents as three tools:
+
+- `list_sessions()` — sessions ordered by recent activity (who's working on what)
+- `query_memory(query)` — find which session discussed something, across all sessions
+- `query_session(session_id)` — read or search within one session (spans all of that session's agents)
+
+This is what makes multi-agent delegation work: launch a worker, then read its thoughts from any other agent. Today crow-memory runs as a Docker container the agent connects to; longer-term it moves toward an always-on daemon, in line with the ACP v2 direction.
+
+### crow-mcp — the tool server
+
+The built-in [MCP](https://modelcontextprotocol.io/) server providing the agent's tools:
+
+| Tool | What it does |
+|------|--------------|
+| `read` / `write` / `edit` | File access — `edit` does precise, fuzzy-matched string replacement |
+| `terminal` | Run shell commands in the workspace |
+| `web_search` / `web_fetch` | Search the web (via SearXNG) and fetch pages as markdown |
+| `capture_webcam` / `read_image_file` | Vision input |
+| `list_sessions` / `query_memory` / `query_session` | Memory (see above) |
+
+**Extensible by design:** register any MCP server in `~/.crow/config.yaml` and its tools appear alongside these automatically.
+
+> ⚠️ **Tool names are not namespaced.** crow-mcp registers its tools as `read`, `edit`, `terminal`, … — not `crow-mcp_read`. When you add your own MCP servers, watch for name collisions.
+
+### SearXNG — web search
+
+crow-cli ships a maintained SearXNG configuration (stored as JSON so the agent can drive it over MCP) so web search works out of the box, without hand-editing SearXNG settings.
+
+### Skills
+
+Agents load reusable skills from `~/.crow/skills/` — each a directory with a `SKILL.md` describing when and how to use it. Skill distribution is still being worked out; today skills are local directories.
+
+## Configuration
+
+`~/.crow/config.yaml` holds providers, models, and MCP servers; secrets live in `~/.crow/.env` and are interpolated with `${VAR}`.
+
+```yaml
+providers:
+  openrouter:
+    api_key: ${OPENROUTER_API_KEY}
+    base_url: https://openrouter.ai/api/v1
+models:
+  my-model:
+    provider: openrouter
+    model: anthropic/claude-sonnet-4
+```
+
+## Development
+
+```bash
+git clone https://github.com/crow-cli/crow-cli.git
+cd crow-cli
+uv sync --project crow-cli
+```
+
+Run the unit tests — fast and hermetic, no services required (tests that touch sessions use an in-memory fake of the memory service):
+
+```bash
+uv run --project crow-cli pytest crow-cli/tests/unit
+```
+
+The persistence layer itself is tested in `crow-memory`. Integration and end-to-end tiers are opt-in:
+
+```bash
+uv run --project crow-cli pytest crow-cli/tests --run-integration   # spawn the agent
+uv run --project crow-cli pytest crow-cli/tests --run-e2e           # live LLM calls (costs $)
+```
+
+## Project layout
+
+```
+crow-cli/               the agent — ACP server, ReAct loop, CLI
+crow-mcp/               built-in MCP tool server
+crow-memory/            persistence + memory service (LanceDB, ColBERT/ColPali)
+crow-task-mcp/          task-list MCP server for delegation (being reworked)
+crow-orchestrator-mcp/  orchestration MCP server for delegation (being reworked)
+```
+
+## License
+
+MIT

crow_cli-0.1.28/README.md

@@ -0,0 +1,176 @@
+# crow-cli
+
+<p>
+  <a href="https://pypi.org/project/crow-cli/"><img src="https://img.shields.io/pypi/v/crow-cli" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/crow-cli/"><img src="https://img.shields.io/pypi/pyversions/crow-cli" alt="Python versions"></a>
+  <a href="#license"><img src="https://img.shields.io/pypi/l/crow-cli" alt="License"></a>
+</p>
+
+[Documentation](https://crow-ai.dev)
+
+`crow-cli` is an [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) coding agent that runs in your terminal and inside ACP-compatible editors. It reads and edits code, runs shell commands, searches the web, and remembers your work across sessions.
+
+Most agent toolkits treat persistence as an afterthought. crow-cli treats it as the point: every session lives in a dedicated memory service ([crow-memory](#crow-memory--persistence--memory-api)) built on [LanceDB](https://lancedb.github.io/lancedb/) with ColBERT and ColPali embeddings, so agents recall past conversations semantically and can delegate work to one another. Sessions get memorable coolname ids (like `taupe-squirrel-of-splendid-potency`) you can resume or read from any other agent.
+
+## Requirements
+
+- Python 3.14+, managed with [uv](https://docs.astral.sh/uv/)
+- Docker, for the crow-memory and SearXNG services
+- An API key for an OpenAI-compatible LLM provider (OpenRouter, OpenAI, your own endpoint, …)
+
+| Platform | Notes |
+|----------|-------|
+| Linux    | glibc 2.35+ (Ubuntu 22.04+, Debian 12+, or equivalent) |
+| macOS    | 13+ (Ventura), Intel and Apple Silicon |
+| Windows  | 10+ (64-bit); WSL2 recommended |
+
+## Setup
+
+Install the CLI:
+
+```bash
+git clone https://github.com/crow-cli/crow-cli.git
+cd crow-cli
+uv tool install crow-cli --python 3.14      # or run without installing: uvx crow-cli --help
+```
+
+Initialize your configuration and start the backing services:
+
+```bash
+crow-cli init                          # scaffolds ~/.crow (config.yaml, .env, docker-compose)
+cd ~/.crow && docker compose up -d     # starts crow-memory + SearXNG
+```
+
+`crow-cli init` walks you through provider and model selection and writes your secrets to `~/.crow/.env`, referenced from the config as `${VAR}`.
+
+## Quick start
+
+```bash
+# One-shot prompt — prints the response and exits
+crow-cli run "explain what this repo does"
+
+# Continue an existing session by id
+crow-cli run -s <session-id> "now add tests"
+
+# Send a long, pre-written prompt from a file or stdin
+crow-cli run -f delegation.md -s <session-id>
+cat prompt.md | crow-cli run -
+
+# Interactive REPL
+crow-cli run -i
+
+# Run as an ACP agent server (for editors)
+crow-cli acp
+```
+
+Inspect stored sessions with `crow-cli inspect` (add `--session <id> --messages` to see a session's messages).
+
+## Using crow-cli in your editor
+
+crow-cli speaks ACP, so it works with any ACP-compatible client. For [Zed](https://zed.dev/), add to `~/.config/zed/settings.json`:
+
+```json
+{
+  "agent_servers": {
+    "crow-cli": {
+      "type": "custom",
+      "command": "crow-cli",
+      "args": ["acp"]
+    }
+  }
+}
+```
+
+The agent detects client capabilities (terminals, file read/write) and uses the native ACP versions when available, falling back to MCP tools otherwise.
+
+## What's in the box
+
+crow-cli is a monorepo. The pieces:
+
+### crow-cli — the agent
+
+The ACP-native agent: a streaming ReAct loop with tool calling, cancellation, conversation compaction, and multimodal input. Provider and model configuration lives in `~/.crow/config.yaml`.
+
+### crow-memory — persistence + memory API
+
+A standalone service — a LanceDB store with ColBERT (text) and ColPali (image) multivector embeddings — that the agent talks to over HTTP. It backs both session persistence and a semantic memory API, exposed to agents as three tools:
+
+- `list_sessions()` — sessions ordered by recent activity (who's working on what)
+- `query_memory(query)` — find which session discussed something, across all sessions
+- `query_session(session_id)` — read or search within one session (spans all of that session's agents)
+
+This is what makes multi-agent delegation work: launch a worker, then read its thoughts from any other agent. Today crow-memory runs as a Docker container the agent connects to; longer-term it moves toward an always-on daemon, in line with the ACP v2 direction.
+
+### crow-mcp — the tool server
+
+The built-in [MCP](https://modelcontextprotocol.io/) server providing the agent's tools:
+
+| Tool | What it does |
+|------|--------------|
+| `read` / `write` / `edit` | File access — `edit` does precise, fuzzy-matched string replacement |
+| `terminal` | Run shell commands in the workspace |
+| `web_search` / `web_fetch` | Search the web (via SearXNG) and fetch pages as markdown |
+| `capture_webcam` / `read_image_file` | Vision input |
+| `list_sessions` / `query_memory` / `query_session` | Memory (see above) |
+
+**Extensible by design:** register any MCP server in `~/.crow/config.yaml` and its tools appear alongside these automatically.
+
+> ⚠️ **Tool names are not namespaced.** crow-mcp registers its tools as `read`, `edit`, `terminal`, … — not `crow-mcp_read`. When you add your own MCP servers, watch for name collisions.
+
+### SearXNG — web search
+
+crow-cli ships a maintained SearXNG configuration (stored as JSON so the agent can drive it over MCP) so web search works out of the box, without hand-editing SearXNG settings.
+
+### Skills
+
+Agents load reusable skills from `~/.crow/skills/` — each a directory with a `SKILL.md` describing when and how to use it. Skill distribution is still being worked out; today skills are local directories.
+
+## Configuration
+
+`~/.crow/config.yaml` holds providers, models, and MCP servers; secrets live in `~/.crow/.env` and are interpolated with `${VAR}`.
+
+```yaml
+providers:
+  openrouter:
+    api_key: ${OPENROUTER_API_KEY}
+    base_url: https://openrouter.ai/api/v1
+models:
+  my-model:
+    provider: openrouter
+    model: anthropic/claude-sonnet-4
+```
+
+## Development
+
+```bash
+git clone https://github.com/crow-cli/crow-cli.git
+cd crow-cli
+uv sync --project crow-cli
+```
+
+Run the unit tests — fast and hermetic, no services required (tests that touch sessions use an in-memory fake of the memory service):
+
+```bash
+uv run --project crow-cli pytest crow-cli/tests/unit
+```
+
+The persistence layer itself is tested in `crow-memory`. Integration and end-to-end tiers are opt-in:
+
+```bash
+uv run --project crow-cli pytest crow-cli/tests --run-integration   # spawn the agent
+uv run --project crow-cli pytest crow-cli/tests --run-e2e           # live LLM calls (costs $)
+```
+
+## Project layout
+
+```
+crow-cli/               the agent — ACP server, ReAct loop, CLI
+crow-mcp/               built-in MCP tool server
+crow-memory/            persistence + memory service (LanceDB, ColBERT/ColPali)
+crow-task-mcp/          task-list MCP server for delegation (being reworked)
+crow-orchestrator-mcp/  orchestration MCP server for delegation (being reworked)
+```
+
+## License
+
+MIT

{crow_cli-0.1.26 → crow_cli-0.1.28}/crow-cli.spec

@@ -15,7 +15,6 @@ a = Analysis(
       + copy_metadata('rich')
       + copy_metadata('openai')
       + copy_metadata('httpx')
-      + copy_metadata('sqlalchemy')
       + copy_metadata('jinja2')
       + copy_metadata('pyyaml')
       + copy_metadata('coolname')
@@ -42,7 +41,6 @@ a = Analysis(
         'fastmcp',
         'openai',
         'httpx',
-        'sqlalchemy',
         'jinja2',
         'yaml',
         'coolname',

{crow_cli-0.1.26 → crow_cli-0.1.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crow-cli"
-version = "0.1.26"
+version = "0.1.28"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.14"
@@ -16,7 +16,6 @@ dependencies = [
     "openai>=2.21.0",
     "pyyaml>=6.0.3",
     "rich>=14.3.3",
-    "sqlalchemy>=2.0.46",
     "typer>=0.24.1",
 ]
 

{crow_cli-0.1.26 → crow_cli-0.1.28}/src/crow_cli/agent/configure.py

@@ -91,7 +91,7 @@ class LLMConfig:
 class Config:
     config_dir: Path
     llm: LLMConfig = field(default_factory=LLMConfig)
-    db_uri: str = ""
+    memory_url: str = ""
     mcp_servers: dict[str, Any] = field(default_factory=dict)
     max_retries_per_step: int = 3
     MAX_COMPACT_TOKENS: int = 190000
@@ -134,7 +134,7 @@ class Config:
             _logger.info("No config.yaml found, returning bare Config")
             return cls(
                 config_dir=target_dir,
-                db_uri=os.getenv("DATABASE_PATH", str(target_dir / "crow.db")),
+                memory_url="http://localhost:8901",
             )
 
         with open(config_file) as f:
@@ -162,9 +162,7 @@ class Config:
             )
 
         # Parse overrides
-        db_uri = parsed.get("db_uri") or os.getenv(
-            "DATABASE_PATH", str(target_dir / "crow.db")
-        )
+        memory_url = parsed.get("memory_url") or "http://localhost:8901"
         overrides = {}
         for key, typ in (
             ("max_retries_per_step", int),
@@ -186,7 +184,7 @@ class Config:
         return cls(
             config_dir=target_dir,
             llm=llm,
-            db_uri=db_uri,
+            memory_url=memory_url,
             mcp_servers=mcp_servers,
             system_prompt_path=system_prompt_path,
             **overrides,

{crow_cli-0.1.26 → crow_cli-0.1.28}/src/crow_cli/agent/context.py

@@ -97,7 +97,13 @@ def find_line_numbers(uri: str) -> dict[str, Any]:
 
 
 def get_directory_tree(cwd: str) -> str:
-    """Returns a string representation of the directory tree rooted at cwd."""
+    """Returns a string representation of the directory tree rooted at cwd.
+
+    Always returns a string. If the tree cannot be generated (e.g. a
+    permission-denied or missing directory), DisplayTree returns None; we
+    coerce that to an empty string so the ``-> str`` contract holds and callers
+    never have to handle None.
+    """
     ignores = ["node_modules", "*.egg_info", "__pycache__", ".venv", "refs"]
     tree = DisplayTree(stringRep=True, dirPath=cwd, ignoreList=ignores, maxDepth=3.0)
-    return tree
+    return tree or ""

{crow_cli-0.1.26 → crow_cli-0.1.28}/src/crow_cli/agent/default/defaults.py

@@ -10,6 +10,18 @@ Working directory:
 AGENTS.md:
 {{ agents_content }}
 
+{% if skills %}
+<SKILLS>
+You have skills available in `~/.crow/skills/`. When a task matches a skill's
+trigger below, read its SKILL.md and follow it.
+
+{% for skill in skills %}
+* **{{ skill.name }}** — {{ skill.description }}
+  Read it: `{{ skill.path }}`
+{% endfor %}
+</SKILLS>
+{% endif %}
+
 <ROLE>
 * Your primary role is to assist users by executing commands, modifying code, and solving technical problems effectively. You should be thorough, methodical, and prioritize quality over speed.
 * If the user asks a question, like "why is X happening", don't try to fix the problem. Just give an answer to the question.
@@ -123,11 +135,15 @@ AGENTS.md:
 * Use `AGENTS.md` under the repository root as your persistent memory for repository-specific knowledge and context.
 * Add important insights, patterns, and learnings to this file to improve future task performance.
 * This repository skill is automatically loaded for every conversation and helps maintain context across sessions.
-* You can use query_memory to access information from previous sessions.
+* Skills live in `~/.crow/skills/` (catalogued in the <SKILLS> block above when present). Each is a directory with a SKILL.md describing when and how to use it — read it before acting on a matching task.
+* You can use the memory tools to access information from previous sessions:
+  `list_sessions()` (who's been working, by last activity), `query_memory(query=...)`
+  (find which session discussed something), and `query_session(session_id=...)`
+  (read/search within one session).
 </MEMORY>
 
 <QUERY_MEMORY>
-When another agent finishes and you get a notification, DO NOT just sit there wondering what happened. Call `query_memory(session_id=<their_sid>, limit=1)` and actually read the damn message. That is how you know what they did. If you just need the latest answer, `limit=1` is your friend. If you need context, use `query` and `context`. I PITY THE FOOL WHO IGNORES THE CONTEXT OF PREVIOUS AGENTS.
+When another agent finishes and you get a notification, DO NOT just sit there wondering what happened. Call `query_session(session_id=<their_sid>)` and actually read the damn message — a bare call returns their latest message, so you don't even need a limit. That is how you know what they did. To search what they worked on, add `query=...`; for surrounding detail add `context=`. To see who's been working lately, call `list_sessions()`. I PITY THE FOOL WHO IGNORES THE CONTEXT OF PREVIOUS AGENTS.
 </QUERY_MEMORY>
 """
 
@@ -144,6 +160,32 @@ COMPOSE_YAML = """services:
     volumes:
       - ./searxng/:/etc/searxng
 
+  crow-memory:
+    image: ghcr.io/crow-cli/crow-memory:latest
+    # For local development, replace image with build:
+    #   build:
+    #     context: /path/to/crow-cli/crow-memory
+    #     dockerfile: Dockerfile
+    restart: always
+    ports:
+      - "8901:8901"
+    environment:
+      - CROW_MEMORY_PATH=/data/memory.lance
+      - CROW_MEMORY_HOST=0.0.0.0
+      - CROW_MEMORY_PORT=8901
+      - CUDA_VISIBLE_DEVICES=
+    volumes:
+      - ./memory.lance:/data/memory.lance
+    # GPU acceleration — uncomment when you want hardware-accelerated embeddings.
+    # CPU mode is ~100ms text / ~2-3s image, which is fine for background agents.
+    # deploy:
+    #   resources:
+    #     reservations:
+    #       devices:
+    #         - driver: nvidia
+    #           count: 1
+    #           capabilities: [gpu]
+
   litellm:
     image: ghcr.io/berriai/litellm:main-v1.82.6-nightly
     restart: always
@@ -172,8 +214,8 @@ mcpServers:
     args:
       - crow-mcp
 
-# DEFAULT LOCATION
-db_uri: sqlite:///${HOME}/.crow/crow.db
+# DEFAULT crow-memory service URL
+memory_url: http://localhost:8901
 
 # EXAMPLE PROVIDER
 # providers: