memu-cli 0.1.0__tar.gz → 0.3.0__tar.gz

{memu_cli-0.1.0 → memu_cli-0.3.0}/.github/workflows/build.yml

@@ -25,7 +25,7 @@ jobs:
 
       - name: Sync dependencies
         run: |
-          uv sync --frozen --extra document
+          uv sync --frozen
           uv run pre-commit install
 
       - name: Run style checks

memu_cli-0.3.0/.github/workflows/publish-memu-cli.yml

@@ -0,0 +1,162 @@
+# Publishes the engine to PyPI as `memu-cli` — the one and only distribution.
+#
+# `memu-cli` versions independently of the release-please train (which still
+# cuts GitHub releases and the changelog), so the npm launcher and docs can
+# point at a stable install target; the version is set at build time from the
+# workflow input.
+#
+# First-time setup: add a trusted publisher on PyPI for project `memu-cli`
+# (workflow: publish-memu-cli.yml, environment: pypi).
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "memu-cli version to publish (e.g. 0.2.1)"
+        required: true
+        type: string
+
+name: publish-memu-cli
+
+jobs:
+  build-wheels:
+    name: build wheels (${{ matrix.label }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            label: linux-x86_64
+            target: x86_64-unknown-linux-gnu
+            extra-args: "--compatibility manylinux_2_39"
+            python-version: "3.13"
+          - os: ubuntu-latest
+            label: linux-aarch64
+            target: aarch64-unknown-linux-gnu
+            extra-args: "--compatibility manylinux_2_39"
+            python-version: "3.13"
+          - os: macos-15-intel
+            label: macos-x86_64
+            target: ""
+            extra-args: ""
+            python-version: "3.13"
+          - os: macos-latest
+            label: macos-aarch64
+            target: ""
+            extra-args: ""
+            python-version: "3.13"
+          - os: windows-latest
+            label: windows-x86_64
+            target: ""
+            extra-args: ""
+            python-version: "3.13"
+    steps:
+      - uses: actions/checkout@v6
+
+      # No $ anchors: Windows runners check out with CRLF line endings,
+      # where a trailing \r sits between the closing quote and the newline.
+      - name: Set memu-cli version
+        shell: bash
+        run: |
+          perl -pi -e 's/^version = "[^"]*"/version = "${{ inputs.version }}"/ if $. < 10' pyproject.toml
+          grep -q '^name = "memu-cli"' pyproject.toml || { echo "::error::pyproject is not memu-cli"; exit 1; }
+          grep -E '^(name|version) = ' pyproject.toml | head -2
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install maturin
+        run: uv tool install maturin
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Setup cross-compilation for Linux ARM64
+        if: matrix.label == 'linux-aarch64'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
+
+      - name: Build wheel
+        run: uvx maturin build --release --out dist ${{ matrix.extra-args }} ${{ matrix.target && format('--target {0}', matrix.target) || '' }}
+        env:
+          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
+
+      - name: Smoke test wheel
+        if: matrix.label != 'linux-aarch64'
+        shell: bash
+        run: uvx --isolated --from ./dist/memu_cli-*.whl memu --help
+
+      - name: Upload wheel artifact
+        uses: actions/upload-artifact@v6
+        with:
+          name: memu-cli-wheels-${{ matrix.label }}
+          path: dist/*.whl
+          if-no-files-found: error
+
+  build-sdist:
+    name: build sdist
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Set memu-cli version
+        shell: bash
+        run: |
+          perl -pi -e 's/^version = "[^"]*"/version = "${{ inputs.version }}"/ if $. < 10' pyproject.toml
+          grep -q '^name = "memu-cli"' pyproject.toml || { echo "::error::pyproject is not memu-cli"; exit 1; }
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          python-version: "3.13"
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install maturin
+        run: uv tool install maturin
+
+      - name: Build sdist
+        run: uvx maturin sdist --out dist
+
+      - name: Upload sdist artifact
+        uses: actions/upload-artifact@v6
+        with:
+          name: memu-cli-sdist
+          path: dist/*.tar.gz
+          if-no-files-found: error
+
+  publish:
+    name: publish memu-cli to PyPI
+    runs-on: ubuntu-latest
+    needs:
+      - build-wheels
+      - build-sdist
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Download wheel artifacts
+        uses: actions/download-artifact@v7
+        with:
+          pattern: memu-cli-wheels-*
+          merge-multiple: true
+          path: dist
+
+      - name: Download sdist artifact
+        uses: actions/download-artifact@v7
+        with:
+          name: memu-cli-sdist
+          path: dist
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/
+          skip-existing: true

{memu_cli-0.1.0 → memu_cli-0.3.0}/.github/workflows/release-please.yml

@@ -120,6 +120,9 @@ jobs:
           path: dist/*.tar.gz
           if-no-files-found: error
 
+  # Release artifacts go to the GitHub release only. PyPI publishing happens
+  # exclusively through publish-memu-cli.yml (the `memu-cli` distribution,
+  # versioned independently of this release train).
   publish:
     name: publish release artifacts
     runs-on: ubuntu-latest
@@ -128,9 +131,7 @@ jobs:
       - build-wheels
       - build-sdist
     if: ${{ needs.release-please.outputs.releases_created == 'true' && needs.release-please.outputs.tag_name != '' }}
-    environment: pypi
     permissions:
-      id-token: write
       contents: write
     steps:
       - name: Download wheel artifacts
@@ -153,8 +154,3 @@ jobs:
           file: dist/*
           tag: ${{ needs.release-please.outputs.tag_name }}
           file_glob: true
-
-      - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          packages-dir: dist/

memu_cli-0.3.0/AGENTS.md

@@ -0,0 +1,77 @@
+# AGENTS.md
+
+Operational guide for AI coding agents working in this repository.
+
+## Mission
+
+Ship small, verified feature and bugfix changes while preserving memU's current architecture.
+
+Core invariants:
+
+- `MemoryService` (`src/memu/app/service.py`) is the composition root: config, storage, and the embedding client pool. Its public surface is exactly the three `AgenticMixin` entry points — `list_all_recall_files`, `progressive_retrieve`, `commit_results`.
+- memU is embedding-only. No LLM/chat call happens anywhere in the service; do not add one.
+- Storage is pluggable across `inmemory`, `sqlite`, and `postgres`; repository contract changes require backend parity.
+- Scope data comes from `UserConfig.model`; validate `where` filters (`_normalize_where`) and do not bypass scope filtering.
+- Retrieval config lives in `ProgressiveRetrieveConfig` (`file` + `resource` layers); embedding profiles in `EmbeddingProfilesConfig`.
+
+## Layer Map
+
+- Service + three entry points: `src/memu/app/service.py`, `src/memu/app/agentic.py`
+- Config models/defaults: `src/memu/app/settings.py`
+- Storage protocols/factory: `src/memu/database/interfaces.py`, `src/memu/database/factory.py`
+- Backends: `src/memu/database/{inmemory,sqlite,postgres}/*`
+- Vector math/ranking: `src/memu/vector.py`
+- Embedding clients: `src/memu/embedding/*`
+- CLI (`memu`): `src/memu/cli.py`; shared `MEMU_*` config: `src/memu/env.py`
+- Host adapters (`memu-codex`, bridging pipeline): `src/memu/hosts/*`
+- Tests: `tests/*`
+
+Read the relevant implementation and nearby tests first. Prefer local patterns over new abstractions.
+
+## Implementation Rules
+
+- Keep changes narrow and localized to the affected layer.
+- Preserve async behavior and result shapes unless the task explicitly asks for a breaking change.
+- Maintain type hints and mypy compatibility.
+- Keep provider-specific logic inside `memu.embedding.backends`; storage-neutral logic outside concrete backends.
+- Do not duplicate client caching — use the existing `ClientPool` pattern.
+- Do not silently swallow errors that should be visible to callers or tests.
+
+## Backend Parity
+
+If a repository method, model field, filter behavior, or vector search contract changes:
+
+1. Update the protocol in `src/memu/database/repositories/`.
+2. Update `inmemory`, `sqlite`, and `postgres` implementations where applicable.
+3. Extend `tests/test_agentic.py` (runs against inmemory + sqlite).
+4. Check migrations/bootstrap behavior for SQL backends (`src/memu/database/postgres/migrations/`).
+
+## Testing And Validation
+
+Use `uv` for local runs.
+
+- Setup: `make install`
+- Run all tests: `make test`
+- Run focused tests: `uv run python -m pytest tests/<target_test>.py`
+- Full quality checks: `make check`
+
+Useful focused areas:
+
+- The three entry points end-to-end: `tests/test_agentic.py`
+- Vector ranking: `tests/test_vector.py`
+- Embedding providers/gateway: `tests/test_embedding.py`
+- CLI surface: `tests/test_cli.py`
+- Host adapter inject seam: `tests/test_host_instruction.py`
+
+## Documentation Rules
+
+- Update `README.md` or `npm/README.md` when user-visible behavior changes.
+- Add or update ADRs under `docs/adr/` for architectural changes; existing ADRs are historical records — do not rewrite them.
+- Do not document speculative features as implemented.
+
+## Done Criteria
+
+- Code compiles for touched paths; tests for changed behavior pass.
+- New behavior has test coverage.
+- Backend parity considered and implemented where needed.
+- No unrelated files modified.

memu_cli-0.3.0/PKG-INFO

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: memu-cli
+Version: 0.3.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: numpy>=2.3.4
+Requires-Dist: openai>=2.8.0
+Requires-Dist: pydantic>=2.12.4
+Requires-Dist: sqlmodel>=0.0.27
+Requires-Dist: alembic>=1.14.0
+Requires-Dist: pendulum>=3.1.0
+Requires-Dist: pgvector>=0.3.4 ; extra == 'postgres'
+Requires-Dist: sqlalchemy[postgresql-psycopgbinary]>=2.0.36 ; extra == 'postgres'
+Provides-Extra: postgres
+License-File: LICENSE.txt
+Summary: Personal memory as files — fast retrieval, higher accuracy, lower cost.
+Keywords: agent,agentic,agent-harness,harness,loop-engineering,context-engineering,context-window,memory,personal-information,workspace,retrieval,llm
+Author-email: MemU Team <contact@nevamind.ai>
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Bug Tracker, https://github.com/NevaMind-AI/MemU/issues
+Project-URL: Documentation, https://github.com/NevaMind-AI/MemU#readme
+Project-URL: Homepage, https://github.com/NevaMind-AI/MemU
+
+![MemU Banner](assets/banner.png)
+
+<div align="center">
+
+# memU
+
+### Personal memory, stored as files
+
+**Across Agents. Fast retrieval. Lower cost.**
+
+[![PyPI version](https://badge.fury.io/py/memu-cli.svg)](https://badge.fury.io/py/memu-cli)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Python 3.13+](https://img.shields.io/badge/python-3.13+-blue.svg)](https://www.python.org/downloads/)
+[![Discord](https://img.shields.io/badge/Discord-Join%20Chat-5865F2?logo=discord&logoColor=white)](https://discord.com/invite/hQZntfGsbJ)
+[![Twitter](https://img.shields.io/badge/Twitter-Follow-1DA1F2?logo=x&logoColor=white)](https://x.com/memU_ai)
+
+<a href="https://trendshift.io/repositories/17374" target="_blank"><img src="https://trendshift.io/api/badge/repositories/17374" alt="NevaMind-AI%2FmemU | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
+</div>
+
+---
+
+memU is a 500-line memory system for AI agents. Agents write what's worth keeping as Markdown; memU stores it, embeds it, and retrieves ranked context in a single call — embeddings are the only model calls it makes. The entire memory logic lives in [`agentic.py`](src/memu/app/agentic.py) + [`service.py`](src/memu/app/service.py); everything else is pluggable storage and embedding transport.
+
+**Installation is agent-driven.** The guides are written for the agent, not for you. One message is the whole setup — tell your agent:
+
+> Read https://raw.githubusercontent.com/NevaMind-AI/MemU/main/SKILL.md and follow it to install memU.
+
+It works for Codex, Claude Code, Cursor, OpenClaw, Hermes — and any other agent, via detection. Details in [Host adapters](#host-adapters-memory-for-desktop-coding-agents).
+
+## Quick start
+
+```python
+from memu.app import MemoryService
+
+service = MemoryService(
+    database_config={"metadata_store": {"provider": "sqlite", "dsn": "sqlite:///memu.sqlite3"}},
+)
+
+# 1. Persist agent-prepared memory: recall files (memory/skill tracks) + resources
+await service.commit_results(
+    recall_files=[
+        {
+            "name": "Profile",
+            "track": "memory",
+            "description": "who the user is",
+            "content": "# Profile\n- prefers dark roast coffee\n- ships on Fridays",
+        },
+        {
+            "name": "deploy-checklist",
+            "track": "skill",
+            "description": "how to deploy this repo",
+            "content": "1. run tests\n2. tag\n3. push",
+        },
+    ],
+    resource=[{"path": "/abs/path/notes.md", "description": "meeting notes from the launch review"}],
+)
+
+# 2. See what is stored, across every track
+files = await service.list_all_recall_files()
+
+# 3. Single-shot embedding retrieval over segments / files / resources
+context = await service.progressive_retrieve("What should I know about this user's launch preferences?")
+```
+
+Or straight from the terminal — no code:
+
+```bash
+export OPENAI_API_KEY=sk-...    # embedding API key — the only model calls memU makes
+
+npx memu-cli commit results.json     # {"recall_files": [...], "resource": [...]}
+npx memu-cli list-files
+npx memu-cli retrieve "What should I know about this user's launch preferences?"
+```
+
+State persists in a local SQLite database (`./data/memu.sqlite3` by default), so commit in one invocation and retrieve in the next.
+
+## How it works
+
+![memU memory system architecture](assets/structure-v2.png)
+
+### The data model
+
+Memory is a set of **recall files** — one Markdown document per topic (`track="memory"`) or per learned skill (`track="skill"`). Committing a file also writes its search index:
+
+| Record | What it is | How it's embedded |
+|---|---|---|
+| **RecallFile** | The Markdown document itself (`name`, `track`, `description`, `content`) | `name: description`, once at creation |
+| **RecallFileSegment** | Searchable slices of a file | memory track: one per content line (headings skipped); skill track: one `name: description` segment per skill |
+| **Resource** | A raw source on disk (`url`, `caption`) | its one-line caption |
+
+Segments are reconciled on every commit: lines that disappeared are deleted, only genuinely new lines are embedded, unchanged lines keep their vectors — so re-committing a lightly edited file is nearly free.
+
+### Retrieval
+
+`progressive_retrieve(query)` embeds the query **once** and returns three ranked layers:
+
+- `segments` — the matched slices, narrowest and usually most on-point, each with a `score`
+- `files` — the documents those segments belong to (usually what you want), each scored by its best segment and carrying its linked `resource_urls`
+- `resources` — matching raw sources, for when summaries are not enough
+
+There is no intention routing, sufficiency checking, or summarization — one embedding call in, ranked context out.
+
+## Host adapters: memory for desktop coding agents
+
+memU runs as a sidecar to a desktop agent (ADR 0008/0009/0010), one binary per host. Each binds two seams:
+
+- **record** — a scheduled bridging task slices new session logs into self-contained job files; the agent itself distills them into memory/skill Markdown; `commit` submits whatever the agent left on disk back through `commit_results`.
+- **inject** — a standing instruction in the host's instruction file tells the agent to run `<binary> retrieve` (→ `progressive_retrieve`) before answering.
+
+| Host | Binary | Session log it mines | Instruction file it patches |
+| --- | --- | --- | --- |
+| Codex | `memu-codex` | `~/.codex/sessions/**/*.jsonl` | `~/.codex/AGENTS.md` |
+| Claude Code | `memu-claude-code` | `~/.claude/projects/<project>/<session>.jsonl` | `~/.claude/CLAUDE.md` |
+| Cursor (Agent/CLI) | `memu-cursor` | `~/.cursor/projects/<project>/agent-transcripts/**.jsonl` | `./AGENTS.md` (per project) |
+| OpenClaw | `memu-openclaw` | `~/.openclaw/agents/<agentId>/sessions/*.jsonl` | `~/.openclaw/workspace/AGENTS.md` |
+| Hermes Agent | `memu-hermes` | `~/.hermes/state.db` (SQLite, read-only) | `~/.hermes/SOUL.md` |
+| **any other agent** | `memu-agent` | found by `memu-agent detect` (JSONL dialect sniffed) | found by `detect` (AGENTS.md / CLAUDE.md / SOUL.md / …) |
+
+For agents without a dedicated binary, `memu-agent detect` probes the machine and reports per agent whether **memorization** works (a recognizable session log exists) and whether **retrieval** works (an instruction file exists to patch) — then the same verbs run against what it found.
+
+All hosts share one store and one embedding space via `~/.memu/config.env` — what one host's sessions taught memU, another host retrieves.
+
+Installation is the one-message setup at the top of this README. [SKILL.md](SKILL.md) is the routing skill it hands your agent: install the package, identify which host you are (falling back to `memu-agent detect` for anything without a dedicated adapter), print that host's packaged install guide (`<binary> docs install`), and follow it — configure the store, register the scheduled bridging task, patch the instruction file, each step behind a verify gate — then report which seams (memorization / retrieval) are now active.
+
+Afterwards `<binary> doctor` proves the whole loop resolves: config, store, and a live retrieval.
+
+Adding another host means implementing one `TranscriptSource` (where its session logs live, how its records are shaped) plus a `HostSpec`-sized CLI — the pipeline, verbs, and instruction text are shared (ADR 0010).
+
+## Installation
+
+```bash
+pip install memu-cli         # library + memu + memu-codex CLIs
+npx memu-cli --help          # CLI via npm launcher (engine: PyPI package memu-cli)
+uvx --from memu-cli memu     # CLI via uv, no install
+```
+
+## Configuration
+
+Values resolve in order: process env → `~/.memu/config.env` → default. Every CLI flag has a matching variable:
+
+| Setting | Env var | Default |
+|---|---|---|
+| Store | `MEMU_DB` | `./data/memu.sqlite3` (CLI); **required** for host adapters |
+| Embedding provider | `MEMU_EMBED_PROVIDER` | `openai` (also: `jina`, `voyage`, `doubao`, `openrouter`); legacy `MEMU_LLM_PROVIDER` still read |
+| API key | `MEMU_API_KEY` | the provider's env var, e.g. `OPENAI_API_KEY` |
+| Embedding model | `MEMU_EMBED_MODEL` | the provider's default |
+| Base URL | `MEMU_BASE_URL` | the provider's default |
+
+### Storage backends
+
+| Provider | DSN | Vector search | Use for |
+|---|---|---|---|
+| `inmemory` | — | brute-force cosine | tests, throwaway sessions |
+| `sqlite` | `sqlite:///path.sqlite3` | brute-force cosine | local/default, single writer |
+| `postgres` | `postgresql://...` | pgvector | concurrent access, large stores (`pip install "memu-cli[postgres]"`) |
+
+```python
+service = MemoryService(
+    database_config={"metadata_store": {"provider": "postgres", "dsn": "postgresql://..."}},
+    embedding_profiles={"default": {"provider": "jina"}},
+)
+```
+
+### Multi-tenancy
+
+Every record carries optional scope fields (`user_id`, `agent_id` by default). Pass `user=` on writes and `where=` on reads to partition one store:
+
+```python
+await service.commit_results(recall_files=[...], user={"user_id": "alice"})
+await service.progressive_retrieve("launch preferences", where={"user_id": "alice"})
+```
+
+Need different scope fields? Supply your own model — filters are validated against it, unknown fields raise:
+
+```python
+from pydantic import BaseModel
+
+class TeamScope(BaseModel):
+    team_id: str | None = None
+    user_id: str | None = None
+
+service = MemoryService(user_config={"model": TeamScope})
+```
+
+## Development
+
+```bash
+make install     # uv sync + pre-commit hooks
+make test        # pytest with coverage
+make check       # lock check, pre-commit, mypy, deptry
+```
+
+Architecture decisions live in [`docs/adr/`](docs/adr/) — notably tracked workspace memorization (ADR 0006), the segment/file/resource retrieval lines (ADR 0007), and the host-adapter seams (ADR 0008/0009).
+
+## License
+
+Apache-2.0
+