devmemory 0.1.0__py3-none-any.whl

devmemory/rules/devmemory.mdc

@@ -0,0 +1,203 @@
+---
+description: DevMemory agent coordination — shared persistent memory across sessions and agents
+alwaysApply: true
+---
+
+# DevMemory: Shared Agent Memory
+
+You have access to a shared project memory via the `agent-memory` MCP server.
+This memory persists across all sessions and is shared between every agent working on this project.
+Use it as a **knowledgebase** (look up past decisions) and **coordination tool** (leave context for future sessions).
+
+The project also maintains **knowledge files** in `.devmemory/knowledge/*.md` — these are the canonical source of architecture decisions, conventions, and gotchas. You are responsible for keeping them up to date.
+
+## 1. Before Starting Any Task
+
+**Always search memory first.** Before writing code, look up what's already known:
+
+```
+search_long_term_memory(text="<describe what you're about to work on>")
+```
+
+Search for:
+- Past decisions related to your task
+- Known issues or gotchas in the area you're touching
+- Established patterns and conventions
+- Previous attempts that failed and why
+
+If your task involves a specific file or module, also search for it:
+```
+search_long_term_memory(text="<module or file name> issues and patterns")
+```
+
+Also **read the relevant knowledge files** before starting:
+- `.devmemory/knowledge/architecture.md` — architecture decisions and design rationale
+- `.devmemory/knowledge/gotchas.md` — known issues, workarounds, and pitfalls
+- Any other `.md` files in `.devmemory/knowledge/` relevant to your task
+
+Incorporate any relevant context into your approach. If a previous session already tried and rejected an approach, don't repeat it.
+
+## 2. After Making Significant Decisions
+
+You have two ways to persist knowledge, use the right one:
+
+### Quick capture: `devmemory add` (CLI)
+
+For a single discovery or decision during a session, run:
+```bash
+devmemory add "<what you learned>" --topic <topic> --entity <entity>
+```
+
+Use this for:
+- A gotcha you just hit and solved
+- An API quirk you discovered mid-task
+- A quick decision that doesn't need a full write-up
+
+### Structured knowledge: update `.devmemory/knowledge/` files
+
+For anything that future agents should know about, **update the knowledge files directly** and then sync:
+
+**When to update knowledge files:**
+- You made an architecture decision (add to `architecture.md`)
+- You discovered a gotcha or workaround (add to `gotchas.md`)
+- You established a new convention or pattern (add to `conventions.md` — create if needed)
+- You added/changed a major dependency and why
+- You fixed a non-obvious bug that could regress
+
+**How to update:**
+1. Edit the appropriate `.devmemory/knowledge/*.md` file (or create a new one)
+2. Add a new `## Section Heading` with the content
+3. Run `devmemory learn` to sync the updated files into the memory store
+
+**Format for knowledge files:**
+```markdown
+---
+topics: [architecture, decisions]
+entities: [Redis, AMS]
+---
+
+## Section Title
+Content explaining what, why, and any relevant details.
+Each ## section becomes a separate searchable memory.
+```
+
+**If no existing file fits, create a new one.** Good filenames:
+- `architecture.md` — why we chose X over Y, system design
+- `gotchas.md` — things that break if you're not careful
+- `conventions.md` — coding patterns and project rules
+- `api-notes.md` — external API quirks and limitations
+- `dependencies.md` — why we use specific libraries
+
+### Also store via MCP for immediate availability
+
+After updating knowledge files, also store via MCP so the memory is searchable immediately (before the next `devmemory learn` run):
+
+```
+create_long_term_memories(memories=[{
+    "text": "<what was decided and why>",
+    "memory_type": "semantic",
+    "topics": ["<relevant>", "<topics>"],
+    "entities": ["<technologies>", "<modules>"]
+}])
+```
+
+### What to store as memories
+
+| Store | Don't store |
+|-------|-------------|
+| Architecture decisions with rationale | Implementation details obvious from code |
+| Known gotchas and workarounds | Temporary debugging notes |
+| Bug root causes and how they were fixed | Things that change every commit |
+| Project conventions and patterns | Redundant copies of commit messages |
+| API quirks and limitations discovered | Personal preferences |
+| Why approach A was chosen over B | Simple variable renames or formatting |
+
+## 3. Keeping Knowledge Files Fresh
+
+**This is a core responsibility.** Treat `.devmemory/knowledge/` files like living documentation.
+
+### During every session, ask yourself:
+
+1. **Did I discover something non-obvious?** → Add to `gotchas.md`
+2. **Did I make a design choice between alternatives?** → Add to `architecture.md`
+3. **Did I establish or follow a pattern?** → Add to `conventions.md` (create if missing)
+4. **Is any existing knowledge file outdated?** → Update it
+
+### After updating knowledge files:
+
+Always run the sync to push changes into the memory store:
+```bash
+devmemory learn
+```
+
+### Periodic review
+
+If the session involved significant work (new features, refactors, bug fixes), review the knowledge files before finishing:
+- Read through `.devmemory/knowledge/` files you touched or that relate to your work
+- Update anything that's now wrong or incomplete
+- Add sections for new knowledge gained during the session
+- Run `devmemory learn` to sync
+
+## 4. Memory Types
+
+Use **`semantic`** for timeless facts and decisions:
+- Project conventions, architecture choices, API quirks
+- These answer "how do we do X?" and "why did we choose Y?"
+
+Use **`episodic`** for time-bound events (include `event_date`):
+- Migrations, incidents, major refactors
+- These answer "what happened?" and "when did we change X?"
+
+## 5. Session Coordination
+
+Use working memory to coordinate across active sessions:
+
+**At session start** — check if another session left context:
+```
+get_working_memory(session_id="project-coordination")
+```
+
+**When starting a large task** — announce what you're working on:
+```
+set_working_memory(
+    session_id="project-coordination",
+    memories=[{
+        "text": "Currently refactoring the search command to add LLM synthesis",
+        "memory_type": "semantic",
+        "topics": ["active-work"]
+    }]
+)
+```
+
+**When finishing** — clear or update the coordination state.
+
+## 6. Search Before You Reinvent
+
+If you're about to:
+- Add a new dependency → search if there's a reason we use something else
+- Change an API pattern → search for conventions
+- Fix a bug → search if it was fixed before and regressed
+- Refactor a module → search for known issues and design decisions
+
+The 30 seconds spent searching can save hours of rediscovering what a previous session already learned.
+
+## 7. Summary: The Knowledge Loop
+
+```
+Session Start
+  ├─ Run: devmemory context  (generates .devmemory/CONTEXT.md briefing)
+  ├─ Read .devmemory/CONTEXT.md for pre-built context
+  ├─ search_long_term_memory(text="<your task>") for deeper dives
+  ├─ Read relevant .devmemory/knowledge/*.md files
+  └─ get_working_memory(session_id="project-coordination")
+
+During Work
+  ├─ Hit a gotcha? → devmemory add "..." or update gotchas.md
+  ├─ Made a decision? → update architecture.md
+  └─ Established a pattern? → update conventions.md
+
+Session End
+  ├─ Review and update .devmemory/knowledge/ files
+  ├─ devmemory learn  (sync knowledge files to memory store)
+  └─ Update working memory coordination state
+```

devmemory-0.1.0.dist-info/METADATA

@@ -0,0 +1,383 @@
+Metadata-Version: 2.4
+Name: devmemory
+Version: 0.1.0
+Summary: Sync AI coding context from Git AI to Redis Agent Memory Server for semantic search and recall.
+Project-URL: Homepage, https://github.com/devmemory/devmemory
+Project-URL: Repository, https://github.com/devmemory/devmemory
+Author: DevMemory
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,developer-tools,git,mcp,memory,redis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.12.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2.2; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.6.0; extra == 'dev'
+Requires-Dist: twine>=5.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# DevMemory 🚀🧠
+
+[![CI](https://github.com/devmemory/devmemory/actions/workflows/ci.yml/badge.svg)](https://github.com/devmemory/devmemory/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/devmemory.svg)](https://pypi.org/project/devmemory/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+> **TL;DR**: DevMemory is a long‑term memory for your AI coding agents.  
+> It remembers *why* code was written, *how* it changed, and *what* your team learned — then feeds that back into your agents. No more “reinvent the bug” speedruns. 🐛🔥
+
+Built on [Git AI](https://usegitai.com/) for silent capture and [Redis Agent Memory Server](https://github.com/redis/agent-memory-server) for semantic search and recall.
+
+---
+
+## 💡 What DevMemory Does (in human terms)
+
+- 🪝 **Hooks into your git workflow** via Git AI notes  
+- 🧬 **Extracts rich memories**:
+  - Commit summaries (who, what, why, which agent/model, how much AI)
+  - Per‑file code snippets
+  - Prompt‑level context with acceptance metrics
+- 🧠 **Stores everything in Redis AMS** as semantic vectors
+- 🔍 **Lets you ask**:  
+  *“How do we handle auth?”* → it searches, then LLM‑synthesizes an actual answer with sources  
+- 🧾 **Ships a knowledge protocol**: `.devmemory/knowledge/*.md` + CLI + Cursor rules so humans and agents keep the docs alive together
+
+If Entire saves *how* agents worked and Git AI tracks *who wrote which line*, DevMemory is the part that answers *“Okay, but what did we actually learn?”*.
+
+---
+
+## 🧮 How It Works
+
+```text
+Developer commits code
+        │
+        ▼
+Git AI captures AI attribution, prompts, agent/model info
+        │
+        ▼
+DevMemory syncs enriched memories to Redis AMS (automatic via post-commit hook)
+        │
+        ├─► Semantic search via CLI (with LLM-synthesized answers)
+        ├─► MCP recall in Cursor IDE (agents search memory before coding)
+        └─► Context briefing auto-generated on branch switch
+```
+
+**The knowledge loop:**
+
+1. **Capture** – Git AI silently records AI code attribution, prompts, and agent/model info on every commit
+2. **Enrich** – DevMemory extracts three layers per commit: enriched summary, per‑file code snapshots, and prompt‑level context with acceptance metrics
+3. **Search** – Semantic vector search with LLM‑powered answer synthesis (RAG over your git history)
+4. **Recall** – Cursor agents read memory via MCP before writing code, and persist new decisions after
+5. **Learn** – Human‑curated knowledge files (`.devmemory/knowledge/*.md`) feed the same store, capturing architecture decisions and gotchas
+
+> 🧵 Think of it as `git log` + “what we should have written in the ADR” + your AI agents actually reading it.
+
+---
+
+## 🎥 Demo (what it *feels* like)
+
+Imagine:
+
+```bash
+devmemory status          # ✅ Stack + hooks look good
+git commit -am "feat: add user auth"   # You used an AI agent heavily
+
+devmemory sync --latest   # Ingest that commit into memory
+devmemory search "how do we handle auth in this service?"
+```
+
+You get:
+
+- A concise answer synthesized by the LLM (RAG), describing:
+  - Which files implement auth
+  - Which agent/model was used
+  - Key decisions (e.g., why JWT vs sessions)
+- A **Sources** table listing:
+  - Commit summaries
+  - Relevant per‑file code snippets
+  - The original prompts that drove the changes
+
+> Drop in a GIF: `docs/demo.gif` — terminal recording of `status → commit → sync → search`.
+
+---
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Git
+- Docker + Docker Compose
+- Python 3.10+
+- OpenAI API key (for embeddings and answer synthesis)
+- [Git AI](https://usegitai.com/) (for AI code attribution capture)
+
+### One‑Line Setup
+
+```bash
+bash scripts/install.sh
+```
+
+This script:
+
+- Checks Docker / Python / Git AI
+- Sets up `.env` from `.env.example`
+- Starts Redis + AMS + MCP via Docker
+- Installs the `devmemory` CLI
+- Configures git hooks + Cursor MCP + agent rules in the current repo
+
+### Manual Setup
+
+```bash
+git clone https://github.com/devmemory/devmemory
+cd devmemory
+
+# Set up environment
+cp .env.example .env
+# Edit .env and add your OPENAI_API_KEY
+
+# Start the stack
+make up
+
+# Install the CLI
+pip install -e .
+
+# Set up hooks, MCP config, and Cursor rules in your project
+cd /path/to/your/project
+devmemory install
+
+# Check everything works
+devmemory status
+```
+
+---
+
+## ⌨️ CLI Commands
+
+### Core workflow 🧠
+
+```bash
+devmemory sync                       # Sync unsynced Git AI commits to Redis
+devmemory sync --latest              # Sync only the latest commit
+devmemory sync --all                 # Re-sync all commits
+devmemory sync --dry-run             # Preview what would be synced
+devmemory search "how do we auth"    # Semantic search with LLM-synthesized answer
+devmemory search "auth" -n 5         # Limit results
+devmemory search "auth" --raw        # Raw results without LLM synthesis
+devmemory status                     # Show system health, sync state, hooks
+```
+
+### Knowledge management 📚
+
+```bash
+devmemory add "We chose Redis over Postgres for vector search because..." --topic architecture
+devmemory add --interactive          # Interactive mode with prompts
+devmemory learn                      # Sync .devmemory/knowledge/*.md into memory store
+devmemory learn --dry-run            # Preview what would be synced
+devmemory context                    # Generate .devmemory/CONTEXT.md from git state + memory
+```
+
+### Setup and config ⚙️
+
+```bash
+devmemory install                    # Set up git hooks + Cursor MCP + agent rules
+devmemory install --skip-hook        # Skip hook installation
+devmemory install --skip-rule        # Skip Cursor agent rules
+devmemory config show                # Show current config
+devmemory config set endpoint URL    # Change AMS endpoint
+devmemory config reset               # Reset to defaults
+```
+
+---
+
+## 📚 Knowledge Files
+
+DevMemory supports human‑curated knowledge in `.devmemory/knowledge/*.md`.  
+Each markdown section (`## heading`) becomes a separate searchable memory.
+
+```text
+.devmemory/
+├── CONTEXT.md              # Auto-generated context briefing (gitignored)
+└── knowledge/
+    ├── architecture.md     # Architecture decisions and rationale
+    ├── gotchas.md          # Known issues and workarounds
+    └── conventions.md      # Coding patterns and project rules
+```
+
+Knowledge files use frontmatter for metadata:
+
+```markdown
+---
+topics: [architecture, decisions]
+entities: [Redis, AMS]
+---
+
+## Why We Chose Redis
+
+We chose Redis with vector search over dedicated vector DBs
+because it's already part of our stack and reduces complexity.
+```
+
+Run `devmemory learn` to sync knowledge files into the memory store.  
+Both automated capture (Git AI) **and** human knowledge feed the same searchable store.
+
+> 🧠 Pro tip: Treat `.devmemory/knowledge/` like living ADRs. Small, focused, and updated often.
+
+---
+
+## 🤝 Cursor Agent Integration
+
+`devmemory install` sets up three things for Cursor:
+
+1. **MCP server config** (`~/.cursor/mcp.json`) – Agents can search and write to the memory store via MCP tools (`search_long_term_memory`, `create_long_term_memories`, etc.)
+2. **Agent behavior rules** (`.cursor/rules/devmemory.mdc`) – Instructs agents to search memory before coding, persist decisions after significant work, and maintain knowledge files
+3. **Context rule** (`.cursor/rules/devmemory-context.mdc`) – Agents read `.devmemory/CONTEXT.md` at task start for a pre‑built briefing
+
+The result is a **compounding loop**: each agent session makes the next one smarter.  
+Your AI stops acting like a goldfish and starts acting like a teammate. 🐠➡️🧑‍💻
+
+---
+
+## 🪝 Git Hooks
+
+DevMemory installs two git hooks:
+
+| Hook | What it does |
+|------|--------------|
+| `post-commit`   | Runs `devmemory sync --latest` in background (auto‑syncs after every commit) |
+| `post-checkout` | Runs `devmemory context --quiet` (refreshes context briefing on branch switch) |
+
+---
+
+## 🏗 Architecture
+
+```text
+┌─────────────────────────────┐     ┌──────────────────┐     ┌─────────────────┐
+│   Developer Machine         │     │  Docker Stack     │     │  Cursor IDE     │
+│                             │     │                   │     │                 │
+│  Git AI (git hooks)         │     │  Redis Stack      │     │  MCP Client     │
+│         │                   │     │    ▲              │     │       │         │
+│         ▼                   │     │    │              │     │       ▼         │
+│  Git Notes (refs/ai)        │     │  AMS API (:8000)  │     │  MCP Server     │
+│         │                   │     │    ▲              │     │  (:9050)        │
+│         ▼                   │     │    │              │     │                 │
+│  devmemory sync ────────────┼─────┼────┘              │     │                 │
+│                             │     │                   │     │                 │
+│  devmemory search ──────────┼─────┼────► AMS Search ──┼─────┼──► LLM synth    │
+│                             │     │                   │     │                 │
+│  .devmemory/knowledge/*.md  │     │                   │     │  Agent rules    │
+│         │                   │     │                   │     │  (.cursor/rules)│
+│  devmemory learn ───────────┼─────┼────┘              │     │                 │
+│                             │     │                   │     │                 │
+│  devmemory context ─────────┼─────┼────► .devmemory/CONTEXT.md              │
+└─────────────────────────────┘     └──────────────────┘     └─────────────────┘
+```
+
+---
+
+## 🧾 What Gets Captured
+
+DevMemory extracts three memory layers from each Git AI commit:
+
+| Layer          | Type     | What it contains                                                                 | Answers                                  |
+|----------------|----------|----------------------------------------------------------------------------------|------------------------------------------|
+| Commit summary | semantic | Agent/model, prompts used, AI contribution stats, acceptance metrics, technologies, files | “Which agent was used?”, “How much AI code?” |
+| Per-file code  | episodic | Code snippets from diffs with key lines (imports, class/function defs)          | “How do we call the API?”, “What client for Redis?” |
+| Prompt context | semantic | Actual prompt text, acceptance rate, affected files                             | “What prompts were used?”, “What was the developer asking?” |
+
+Unique data points captured via Git AI and surfaced by DevMemory:
+- **AI vs human lines** per commit
+- **Acceptance rate** (lines accepted unchanged vs overridden)
+- **Time waiting for AI** per commit
+- **Agent and model** used (Cursor, Copilot, Claude Code, etc.)
+
+---
+
+## 🐳 Docker Stack
+
+The `docker-compose.yml` runs:
+
+| Service | Port | Description |
+|---------|------|-------------|
+| redis | 6379 | Redis Stack (vector search, JSON, streams) |
+| api | 8000 | Agent Memory Server REST API |
+| mcp | 9050 | MCP server for Cursor IDE (SSE mode) |
+| redis-insight | 16381 | RedisInsight UI (debug profile only) |
+
+```bash
+make up       # Start stack
+make down     # Stop stack
+make logs     # View logs
+make debug    # Start with RedisInsight
+make clean    # Stop and remove volumes
+make verify   # Run verification checks
+```
+
+---
+
+## 🌍 How DevMemory Fits the Ecosystem
+
+| Tool | What it does | Data store |
+|------|-------------|------------|
+| [Git AI](https://usegitai.com/) | Captures AI code attribution and prompts | Git Notes + SQLite |
+| [Entire](https://entire.io/) | Captures agent sessions/checkpoints | Git branch |
+| **DevMemory** | **Turns captured data into searchable, evolving team knowledge** | **Redis AMS** |
+
+Git AI and Entire are **capture tools**.  
+DevMemory is a **memory and knowledge tool** — it makes captured data searchable via semantic vector search, synthesizes answers with LLM, and feeds context back to AI agents automatically.
+
+---
+
+## ⚙️ Configuration
+
+Config is stored in `~/.devmemory/config.json`:
+
+```json
+{
+  "ams_endpoint": "http://localhost:8000",
+  "mcp_endpoint": "http://localhost:9050",
+  "namespace": "default",
+  "user_id": ""
+}
+```
+
+Environment variables (in `.env`):
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `OPENAI_API_KEY` | (required) | Used for embeddings and answer synthesis |
+| `GENERATION_MODEL` | `gpt-5-mini` | Model for LLM answer synthesis |
+| `EMBEDDING_MODEL` | `text-embedding-3-small` | Model for vector embeddings |
+
+---
+
+## 🧑‍💻 Contributing
+
+Contributions, bug reports, and wild feature ideas are very welcome. 💌  
+See [`CONTRIBUTING.md`](CONTRIBUTING.md) for details on running the stack, tests, and linting.
+
+If you build something cool with DevMemory, please open an issue or PR and show it off. ✨
+
+---
+
+## ⭐️ Supporting the Project
+
+If DevMemory helps you or your team:
+
+- Star the repo on GitHub ⭐
+- Tell your AI‑obsessed friends
+- Open issues with real‑world workflows you’d like memory support for
+
+Happy shipping — and may your agents never forget another architecture decision again. 🧠📦🚀

devmemory-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+devmemory/__init__.py,sha256=piBgWzTaWG5YZyKgrd5Z6l5EIKoL2ev-7Elpl507zcc,49
+devmemory/cli.py,sha256=gEiZjqM-UvfVEYkcDujhHjJ2AyXU_23DKnjNZLn3cew,4676
+devmemory/commands/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+devmemory/commands/add.py,sha256=A1s_xryp4EccBubeAU_6TEG3bSk7kZmlL5vam_tlhc4,4901
+devmemory/commands/config_cmd.py,sha256=9AQf9pjFWlAGQR1WmJmf3CF7gt8VU9dmXn6A4_HnDsA,1152
+devmemory/commands/context.py,sha256=4tLwq-cv6Us8UE5uj9RTlJJZH0S-EklykxoPumiVHbU,9358
+devmemory/commands/install.py,sha256=uy4-ge2-LSqV4YOkijvsus4BJy2UGMKIlS-R6VYAvoM,7166
+devmemory/commands/learn.py,sha256=e2j8-PSSZc-ea1KpYES6639cEq3R_qQuuKgHx0a6LIo,7130
+devmemory/commands/search.py,sha256=vYBTHrCGWAOOEDzKW0zhltdRPQHkJs8t5OpbvhUBj1E,8402
+devmemory/commands/status.py,sha256=dFFZ0YnJ5BEHfe5i_cNB1AR8ThzNwlULrBRQkBV8czI,2797
+devmemory/commands/sync.py,sha256=we1-vQvMNkLa3qBBbTzbWKL8xXYp8v2f9Sn6BZ2EBWo,4232
+devmemory/core/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+devmemory/core/ams_client.py,sha256=DBpoMmErvmtqGO0vv0jBsz5HLtL0uthBoYyAavdgZWQ,3629
+devmemory/core/config.py,sha256=7nRbVYpKU5asLy8oIROttDj2tg5Cz7e6qD9v0Zmr65k,1292
+devmemory/core/git_ai_parser.py,sha256=MPh30x7phe1r_Eb7tnzi4MmtkMxdGfwZEG3aoGPkiQ4,10762
+devmemory/core/llm_client.py,sha256=8IPfuNz0C8GXbItth8ldK3YQ20cnGITIyZVLRFBRpXs,3902
+devmemory/core/memory_formatter.py,sha256=QDZCEJON8K9ZQCA2mS5iinOtkBn7lJx0vljk1g4PVog,15670
+devmemory/core/sync_state.py,sha256=ytW1ri68Y9WLChOWnNVEPdWHBMIQAWfHSyH9yQzb3CY,1183
+devmemory/hooks/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+devmemory/hooks/post_commit.py,sha256=Jyq-VQzOzR1SnPabhDym3SonFQo0kTsCxqPwiZ0VVUg,161
+devmemory/rules/devmemory-context.mdc,sha256=jr6V4mC0Wjyg35cIxkF0Me_06hsEpT9g9WBzal2pXT4,634
+devmemory/rules/devmemory.mdc,sha256=XqPLyrobQl8mrg38yZAx5-iGNx5iHS8o3_ikmtS6cTk,7424
+devmemory-0.1.0.dist-info/METADATA,sha256=IWW0NshvyLVQhnopylBopJ_0hcda6uL2xrSvw8OOBYc,15237
+devmemory-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+devmemory-0.1.0.dist-info/entry_points.txt,sha256=a28PthmYnKgjgPjN0_DJAvPJ_qtnduNmHThSFIHAY18,49
+devmemory-0.1.0.dist-info/licenses/LICENSE,sha256=pxruW6GG91qP6weq4H2_1wrMyqGNheGU8iPVqD25AdI,1067
+devmemory-0.1.0.dist-info/RECORD,,

devmemory-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

devmemory-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+devmemory = devmemory.cli:main

devmemory-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 DevMemory
+
+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.
+