eagle-mem 1.0.0

package/skills/eagle-mem-overview/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: eagle-mem-overview
+description: >
+  Generate or update a project overview for Eagle Mem. Use when: 'eagle overview',
+  'project overview', 'summarize this project', 'eagle mem overview', 'what is this project',
+  'update overview'. Creates a persistent one-paragraph project summary injected at session start.
+---
+
+# Eagle Mem — Project Overview
+
+Generate a concise project overview that Eagle Mem injects at the start of every session. This gives fresh context windows an instant understanding of what the project is and what's been happening.
+
+## How it works
+
+1. Query recent summaries and observations for the current project
+2. Synthesize them into a concise overview (2-4 sentences)
+3. Save to the `overviews` table — one row per project, updated in place
+
+The overview is automatically injected by the SessionStart hook.
+
+## Generating an overview
+
+### Step 1: Gather context
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+SELECT request, completed, learned, next_steps, created_at
+FROM summaries
+WHERE project = '<project>'
+ORDER BY created_at DESC
+LIMIT 10;
+"
+```
+
+Also check frequently modified files:
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+PRAGMA trusted_schema=ON;
+SELECT json_each.value as file, COUNT(*) as times
+FROM observations, json_each(observations.files_modified)
+WHERE observations.project = '<project>'
+GROUP BY json_each.value
+ORDER BY times DESC
+LIMIT 10;
+"
+```
+
+### Step 2: Write the overview
+
+Synthesize the data into a concise overview covering:
+- **What** the project is (one sentence)
+- **Current state** — what's been worked on recently
+- **Key patterns** — tech stack, architecture decisions, active conventions
+
+Keep it under 500 characters. This gets injected into every session start, so brevity matters.
+
+### Step 3: Save to database
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+PRAGMA trusted_schema=ON;
+INSERT INTO overviews (project, content, updated_at)
+VALUES ('<project>', '<overview text>', strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+ON CONFLICT(project) DO UPDATE SET
+    content = excluded.content,
+    updated_at = excluded.updated_at;
+"
+```
+
+## Viewing the current overview
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+SELECT project, content, updated_at FROM overviews
+WHERE project = '<project>';
+"
+```
+
+## Listing all project overviews
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+SELECT project, substr(content, 1, 80) || '...', updated_at
+FROM overviews
+ORDER BY updated_at DESC;
+"
+```
+
+## Deleting an overview
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+DELETE FROM overviews WHERE project = '<project>';
+"
+```
+
+## Guidelines
+
+- Update the overview when the project direction changes significantly
+- Keep it factual — what IS, not what SHOULD BE
+- Don't include task lists or TODOs — those belong in the tasks table
+- The overview supplements (doesn't replace) recent session summaries

package/skills/eagle-mem-search/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: eagle-mem-search
+description: >
+  Search Eagle Mem's persistent memory database. Use when: 'eagle search', 'search memory',
+  'what did I do', 'eagle mem search', 'find in memory', 'past sessions', 'what happened with',
+  'search my history'. Three-layer search: compact index (fast) → timeline (chronological) →
+  full details (complete observations).
+---
+
+# Eagle Mem — Memory Search
+
+Search the Eagle Mem database for past session summaries, observations, and task history.
+
+## Three-layer search pattern
+
+### Layer 1: Compact search (default)
+
+Fast keyword search across session summaries. Returns ~50-100 tokens per result.
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+PRAGMA trusted_schema=ON;
+SELECT s.id, s.request, s.completed, s.created_at, s.project
+FROM summaries s
+JOIN summaries_fts f ON f.rowid = s.id
+WHERE summaries_fts MATCH '<query>'
+ORDER BY rank
+LIMIT 10;
+"
+```
+
+Use this first. If the user needs more detail, go to Layer 2 or 3.
+
+### Layer 2: Timeline (chronological context)
+
+Show recent sessions for a project in time order. Good for "what have I been working on?"
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+SELECT s.request, s.completed, s.learned, s.next_steps, s.created_at
+FROM summaries s
+WHERE s.project = '<project>'
+ORDER BY s.created_at DESC
+LIMIT <N>;
+"
+```
+
+### Layer 3: Full details (observations)
+
+When the user needs to know exactly what files were touched or what tools were used:
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+PRAGMA trusted_schema=ON;
+SELECT o.tool_name, o.tool_input_summary, o.files_read, o.files_modified, o.created_at
+FROM observations o
+WHERE o.session_id = '<session_id>'
+ORDER BY o.created_at ASC;
+"
+```
+
+## Additional queries
+
+### Cross-project search
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+PRAGMA trusted_schema=ON;
+SELECT s.project, s.request, s.completed, s.created_at
+FROM summaries s
+JOIN summaries_fts f ON f.rowid = s.id
+WHERE summaries_fts MATCH '<query>'
+ORDER BY rank
+LIMIT 10;
+"
+```
+
+### Files frequently modified
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+PRAGMA trusted_schema=ON;
+SELECT json_each.value as file, COUNT(*) as times
+FROM observations, json_each(observations.files_modified)
+WHERE observations.project = '<project>'
+GROUP BY json_each.value
+ORDER BY times DESC
+LIMIT 20;
+"
+```
+
+### Task history
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+SELECT id, title, status, completed_at
+FROM tasks
+WHERE project = '<project>'
+ORDER BY ordinal ASC, id ASC;
+"
+```
+
+### Session count and stats
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+SELECT
+    COUNT(DISTINCT s.id) as sessions,
+    COUNT(DISTINCT su.id) as summaries,
+    COUNT(DISTINCT o.id) as observations,
+    COUNT(DISTINCT t.id) as tasks
+FROM sessions s
+LEFT JOIN summaries su ON su.project = s.project
+LEFT JOIN observations o ON o.session_id = s.id
+LEFT JOIN tasks t ON t.project = s.project
+WHERE s.project = '<project>';
+"
+```
+
+## Usage tips
+
+- Start with Layer 1 (compact search) — it's fast and usually sufficient
+- Use FTS5 query syntax: `word1 AND word2`, `"exact phrase"`, `word1 OR word2`, `word1 NOT word2`
+- The `project` column maps to the directory name (basename of cwd)
+- Cross-project search omits the WHERE project clause
+- Observations are high-volume — query by session_id, not full table scans

package/skills/eagle-mem-tasks/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: eagle-mem-tasks
+description: >
+  TaskAware Compact Loop — break complex work into database-tracked subtasks with compaction
+  between each. Use when: 'eagle tasks', 'break this into tasks', 'create task plan',
+  'task loop', 'compact loop', 'eagle mem tasks'. Prevents context bloat and hallucination
+  by executing one task at a time with memory re-injection after each /compact.
+---
+
+# Eagle Mem — TaskAware Compact Loop
+
+Break complex work into subtasks stored in Eagle Mem's database. Execute one task at a time, compact between each, and let Eagle Mem re-inject context for the next task.
+
+## How it works
+
+1. **Plan**: Break the user's request into ordered subtasks
+2. **Store**: Write each subtask to the Eagle Mem database
+3. **Execute**: Work on the current task (marked `[ACTIVE]`)
+4. **Compact**: When done, tell the user to run `/compact`
+5. **Resume**: After compact, SessionStart re-injects memory + loads the next task
+6. **Repeat**: Until all tasks are done
+
+## Commands
+
+### Creating tasks
+
+When the user invokes `/eagle-mem-tasks` or asks to break work into tasks:
+
+1. Analyze the request and break it into 3-8 focused subtasks
+2. Each task should be completable in one context window (~50-100K tokens of work)
+3. Write tasks to the database using this pattern:
+
+```bash
+~/.eagle-mem/db/task-ops.sh add "<project>" "<title>" "<instructions>" <ordinal>
+```
+
+If `task-ops.sh` doesn't exist yet, write directly:
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+PRAGMA trusted_schema=ON;
+INSERT INTO tasks (project, title, instructions, ordinal)
+VALUES ('<project>', '<title>', '<instructions>', <ordinal>);
+"
+```
+
+4. Show the task plan to the user for confirmation
+5. After confirmation, start working on task #1
+
+### Viewing tasks
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+SELECT id, title, status, ordinal FROM tasks
+WHERE project = '<project>'
+ORDER BY ordinal ASC, id ASC;
+"
+```
+
+### Completing a task
+
+When the current task is done:
+
+1. Mark it complete:
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+PRAGMA trusted_schema=ON;
+UPDATE tasks SET status = 'done', completed_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE id = <task_id>;
+"
+```
+
+2. Emit your `<eagle-summary>` block
+3. Tell the user: **"Task #N complete. Run `/compact` to save progress and load the next task."**
+
+### Skipping/blocking a task
+
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+UPDATE tasks SET status = 'blocked'
+WHERE id = <task_id>;
+"
+```
+
+## Task design guidelines
+
+- Each task should be **self-contained** — completable without needing context from mid-execution of a previous task
+- Include `instructions` with enough detail that a fresh context window can pick it up
+- Include a `context_snapshot` for tasks that depend on decisions from earlier tasks:
+```bash
+sqlite3 ~/.eagle-mem/memory.db "
+PRAGMA trusted_schema=ON;
+UPDATE tasks SET context_snapshot = '<key decisions and state>'
+WHERE id = <task_id>;
+"
+```
+- Order tasks so that foundational work comes first (schema before API, API before UI)
+
+## The compact cycle
+
+```
+User request → Plan tasks → Execute task 1 → /compact
+→ Eagle Mem saves summary → Context cleared → Memory re-injected
+→ Task 2 loaded as [ACTIVE] → Execute task 2 → /compact
+→ ... repeat until all tasks done ...
+→ Final summary: "All N tasks complete."
+```
+
+This prevents context window bloat. Each task gets a fresh window with only relevant memory injected.
+
+## Example
+
+User: "Build a REST API with auth, CRUD endpoints, and tests"
+
+Tasks created:
+1. Set up project structure and dependencies
+2. Implement auth middleware (JWT)
+3. Build CRUD endpoints for users
+4. Build CRUD endpoints for posts
+5. Write integration tests
+6. Add error handling and validation
+
+Each task executes in its own compact cycle with full memory of what came before.