eagle-mem 1.0.3 → 1.2.0

package/scripts/tasks.sh

@@ -0,0 +1,291 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — Tasks
+# CLI wrapper for task management (replaces raw SQL in skills)
+# ═══════════════════════════════════════════════════════════
+set -euo pipefail
+
+SCRIPTS_DIR="$(cd "$(dirname "$0")" && pwd)"
+LIB_DIR="$SCRIPTS_DIR/../lib"
+
+. "$SCRIPTS_DIR/style.sh"
+. "$LIB_DIR/common.sh"
+. "$LIB_DIR/db.sh"
+
+eagle_ensure_db
+
+# ─── Parse arguments ──────────────────────────────────────
+
+action="${1:-pending}"
+shift 2>/dev/null || true
+
+project=""
+json_output=false
+
+# Extract global options from remaining args
+args=()
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --project|-p)   project="$2"; shift 2 ;;
+        --json|-j)      json_output=true; shift ;;
+        --help|-h)
+            echo -e "  ${BOLD}eagle-mem tasks${RESET} — Manage tracked tasks"
+            echo ""
+            echo -e "  ${BOLD}Usage:${RESET}"
+            echo -e "    eagle-mem tasks                           ${DIM}# list pending tasks${RESET}"
+            echo -e "    eagle-mem tasks ${CYAN}list${RESET}                      ${DIM}# list all tasks${RESET}"
+            echo -e "    eagle-mem tasks ${CYAN}add${RESET} <title> [instructions] ${DIM}# add a task${RESET}"
+            echo -e "    eagle-mem tasks ${CYAN}done${RESET} <id>                 ${DIM}# mark task complete${RESET}"
+            echo -e "    eagle-mem tasks ${CYAN}block${RESET} <id>                ${DIM}# mark task blocked${RESET}"
+            echo -e "    eagle-mem tasks ${CYAN}context${RESET} <id> <snapshot>    ${DIM}# set task context${RESET}"
+            echo -e "    eagle-mem tasks ${CYAN}clear${RESET}                     ${DIM}# remove all done tasks${RESET}"
+            echo ""
+            echo -e "  ${BOLD}Options:${RESET}"
+            echo -e "    ${CYAN}-p, --project${RESET} <name>    Project name (default: current dir)"
+            echo -e "    ${CYAN}-j, --json${RESET}              Output as JSON"
+            echo ""
+            exit 0
+            ;;
+        *)  args+=("$1"); shift ;;
+    esac
+done
+
+[ -z "$project" ] && project=$(eagle_project_from_cwd "$(pwd)")
+project_sql=$(eagle_sql_escape "$project")
+
+# ─── List tasks ───────────────────────────────────────────
+
+tasks_list() {
+    local filter="${1:-all}"
+
+    local where_status=""
+    case "$filter" in
+        pending) where_status="AND status IN ('pending', 'active')" ;;
+        done)    where_status="AND status = 'done'" ;;
+        all)     where_status="" ;;
+    esac
+
+    if [ "$json_output" = true ]; then
+        eagle_db_json "SELECT id, title, instructions, status, ordinal, context_snapshot, completed_at, created_at
+                       FROM tasks
+                       WHERE project = '$project_sql' $where_status
+                       ORDER BY ordinal ASC, id ASC;"
+        return
+    fi
+
+    local results
+    results=$(eagle_db "SELECT id, title, status, ordinal, instructions
+                        FROM tasks
+                        WHERE project = '$project_sql' $where_status
+                        ORDER BY ordinal ASC, id ASC;")
+
+    if [ -z "$results" ]; then
+        eagle_dim "No tasks for project '$project'"
+        return
+    fi
+
+    echo ""
+    echo -e "  ${BOLD}Tasks${RESET} ${DIM}($project)${RESET}"
+    echo -e "  ${DIM}─────────────────────────────────────${RESET}"
+    echo ""
+
+    while IFS='|' read -r tid title status ordinal instructions; do
+        [ -z "$tid" ] && continue
+        local icon marker
+        case "$status" in
+            active)  icon="${CYAN}▶${RESET}"; marker=" ${CYAN}[ACTIVE]${RESET}" ;;
+            pending) icon="${DIM}○${RESET}"; marker="" ;;
+            done)    icon="${GREEN}✓${RESET}"; marker=" ${DIM}[DONE]${RESET}" ;;
+            blocked) icon="${RED}✗${RESET}"; marker=" ${RED}[BLOCKED]${RESET}" ;;
+            *)       icon="$DOT"; marker="" ;;
+        esac
+        echo -e "  ${icon}  ${BOLD}#$tid${RESET} $title$marker"
+        [ -n "$instructions" ] && echo -e "     ${DIM}$instructions${RESET}"
+    done <<< "$results"
+    echo ""
+}
+
+# ─── Add task ─────────────────────────────────────────────
+
+tasks_add() {
+    local title="${args[0]:-}"
+    local instructions="${args[1]:-}"
+
+    if [ -z "$title" ]; then
+        eagle_err "Usage: eagle-mem tasks add <title> [instructions]"
+        exit 1
+    fi
+
+    local title_sql; title_sql=$(eagle_sql_escape "$title")
+    local instr_sql; instr_sql=$(eagle_sql_escape "$instructions")
+
+    local max_ord
+    max_ord=$(eagle_db "SELECT COALESCE(MAX(ordinal), 0) FROM tasks WHERE project = '$project_sql';")
+    local next_ord=$((max_ord + 1))
+
+    local new_id
+    new_id=$(eagle_db "INSERT INTO tasks (project, title, instructions, ordinal)
+              VALUES ('$project_sql', '$title_sql', '$instr_sql', $next_ord);
+              SELECT last_insert_rowid();")
+
+    if [ "$json_output" = true ]; then
+        jq -nc --arg id "$new_id" --arg title "$title" --argjson ord "$next_ord" \
+            '{id: ($id | tonumber), title: $title, ordinal: $ord}'
+        return
+    fi
+
+    eagle_ok "Task #$new_id added: $title"
+}
+
+# ─── Done ─────────────────────────────────────────────────
+
+tasks_done() {
+    local task_id="${args[0]:-}"
+
+    if [ -z "$task_id" ]; then
+        eagle_err "Usage: eagle-mem tasks done <id>"
+        exit 1
+    fi
+
+    if ! [[ "$task_id" =~ ^[0-9]+$ ]]; then
+        eagle_err "Task ID must be a number, got: $task_id"
+        exit 1
+    fi
+
+    local changed
+    changed=$(eagle_db "UPDATE tasks SET status = 'done', completed_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+              WHERE id = $task_id AND project = '$project_sql';
+              SELECT changes();")
+
+    if [ "${changed:-0}" -eq 0 ]; then
+        eagle_err "Task #$task_id not found in project '$project'"
+        exit 1
+    fi
+
+    local title
+    title=$(eagle_db "SELECT title FROM tasks WHERE id = $task_id AND project = '$project_sql';")
+
+    if [ "$json_output" = true ]; then
+        jq -nc --arg id "$task_id" '{id: ($id | tonumber), status: "done"}'
+        return
+    fi
+
+    eagle_ok "Task #$task_id done: $title"
+}
+
+# ─── Block ────────────────────────────────────────────────
+
+tasks_block() {
+    local task_id="${args[0]:-}"
+
+    if [ -z "$task_id" ]; then
+        eagle_err "Usage: eagle-mem tasks block <id>"
+        exit 1
+    fi
+
+    if ! [[ "$task_id" =~ ^[0-9]+$ ]]; then
+        eagle_err "Task ID must be a number, got: $task_id"
+        exit 1
+    fi
+
+    local changed
+    changed=$(eagle_db "UPDATE tasks SET status = 'blocked' WHERE id = $task_id AND project = '$project_sql';
+              SELECT changes();")
+
+    if [ "${changed:-0}" -eq 0 ]; then
+        eagle_err "Task #$task_id not found in project '$project'"
+        exit 1
+    fi
+
+    if [ "$json_output" = true ]; then
+        jq -nc --arg id "$task_id" '{id: ($id | tonumber), status: "blocked"}'
+        return
+    fi
+
+    eagle_ok "Task #$task_id blocked"
+}
+
+# ─── Context snapshot ─────────────────────────────────────
+
+tasks_context() {
+    local task_id="${args[0]:-}"
+    local snapshot="${args[1]:-}"
+
+    if [ -z "$task_id" ] || [ -z "$snapshot" ]; then
+        eagle_err "Usage: eagle-mem tasks context <id> <snapshot>"
+        exit 1
+    fi
+
+    if ! [[ "$task_id" =~ ^[0-9]+$ ]]; then
+        eagle_err "Task ID must be a number, got: $task_id"
+        exit 1
+    fi
+
+    local snap_sql; snap_sql=$(eagle_sql_escape "$snapshot")
+    local changed
+    changed=$(eagle_db "UPDATE tasks SET context_snapshot = '$snap_sql' WHERE id = $task_id AND project = '$project_sql';
+              SELECT changes();")
+
+    if [ "${changed:-0}" -eq 0 ]; then
+        eagle_err "Task #$task_id not found in project '$project'"
+        exit 1
+    fi
+
+    if [ "$json_output" = true ]; then
+        jq -nc --arg id "$task_id" '{id: ($id | tonumber), context_snapshot: true}'
+        return
+    fi
+
+    eagle_ok "Context saved for task #$task_id"
+}
+
+# ─── Clear done tasks ────────────────────────────────────
+
+tasks_clear() {
+    local count
+    count=$(eagle_db "SELECT COUNT(*) FROM tasks WHERE project = '$project_sql' AND status = 'done';")
+
+    eagle_db "DELETE FROM tasks WHERE project = '$project_sql' AND status = 'done';"
+
+    if [ "$json_output" = true ]; then
+        jq -nc --argjson cleared "${count:-0}" '{cleared: $cleared}'
+        return
+    fi
+
+    eagle_ok "Cleared ${count:-0} completed tasks"
+}
+
+# ─── Dispatch ─────────────────────────────────────────────
+
+case "$action" in
+    list)       tasks_list "all" ;;
+    pending)    tasks_list "pending" ;;
+    add)        tasks_add ;;
+    done)       tasks_done ;;
+    block)      tasks_block ;;
+    context)    tasks_context ;;
+    clear)      tasks_clear ;;
+    --help|-h)
+        echo -e "  ${BOLD}eagle-mem tasks${RESET} — Manage tracked tasks"
+        echo ""
+        echo -e "  ${BOLD}Usage:${RESET}"
+        echo -e "    eagle-mem tasks                           ${DIM}# list pending tasks${RESET}"
+        echo -e "    eagle-mem tasks ${CYAN}list${RESET}                      ${DIM}# list all tasks${RESET}"
+        echo -e "    eagle-mem tasks ${CYAN}add${RESET} <title> [instructions] ${DIM}# add a task${RESET}"
+        echo -e "    eagle-mem tasks ${CYAN}done${RESET} <id>                 ${DIM}# mark task complete${RESET}"
+        echo -e "    eagle-mem tasks ${CYAN}block${RESET} <id>                ${DIM}# mark task blocked${RESET}"
+        echo -e "    eagle-mem tasks ${CYAN}context${RESET} <id> <snapshot>    ${DIM}# set task context${RESET}"
+        echo -e "    eagle-mem tasks ${CYAN}clear${RESET}                     ${DIM}# remove all done tasks${RESET}"
+        echo ""
+        echo -e "  ${BOLD}Options:${RESET}"
+        echo -e "    ${CYAN}-p, --project${RESET} <name>    Project name (default: current dir)"
+        echo -e "    ${CYAN}-j, --json${RESET}              Output as JSON"
+        echo ""
+        exit 0
+        ;;
+    *)
+        eagle_err "Unknown action: $action"
+        eagle_dim "  Run 'eagle-mem tasks --help' for options"
+        exit 1
+        ;;
+esac

package/scripts/uninstall.sh

@@ -6,12 +6,12 @@
 set -euo pipefail
 
 SCRIPTS_DIR="$(cd "$(dirname "$0")" && pwd)"
+LIB_DIR="$SCRIPTS_DIR/../lib"
 
 . "$SCRIPTS_DIR/style.sh"
+. "$LIB_DIR/common.sh"
 
-EAGLE_MEM_DIR="${EAGLE_MEM_DIR:-$HOME/.eagle-mem}"
-SETTINGS="$HOME/.claude/settings.json"
-SKILLS_DIR="$HOME/.claude/skills"
+SETTINGS="$EAGLE_SETTINGS"
 
 eagle_header "Uninstall"
 
@@ -35,9 +35,9 @@ fi
 
 # ─── Remove skill symlinks ────────────────────────────────
 
-if [ -d "$SKILLS_DIR" ]; then
+if [ -d "$EAGLE_SKILLS_DIR" ]; then
     for skill in eagle-mem-search eagle-mem-tasks eagle-mem-overview; do
-        target="$SKILLS_DIR/$skill"
+        target="$EAGLE_SKILLS_DIR/$skill"
         if [ -L "$target" ]; then
             rm "$target"
             eagle_ok "Skill removed: $skill"

package/scripts/update.sh

@@ -7,11 +7,12 @@ set -euo pipefail
 
 PACKAGE_DIR="${1:-.}"
 SCRIPTS_DIR="$(cd "$(dirname "$0")" && pwd)"
+LIB_DIR="$SCRIPTS_DIR/../lib"
 
 . "$SCRIPTS_DIR/style.sh"
+. "$LIB_DIR/common.sh"
 
-EAGLE_MEM_DIR="${EAGLE_MEM_DIR:-$HOME/.eagle-mem}"
-SETTINGS="$HOME/.claude/settings.json"
+SETTINGS="$EAGLE_SETTINGS"
 
 eagle_header "Update"
 
@@ -87,13 +88,12 @@ fi
 
 # ─── Update skill symlinks ────────────────────────────────
 
-SKILLS_DIR="$HOME/.claude/skills"
 if [ -d "$PACKAGE_DIR/skills" ]; then
-    mkdir -p "$SKILLS_DIR"
+    mkdir -p "$EAGLE_SKILLS_DIR"
     for skill_dir in "$PACKAGE_DIR"/skills/*/; do
         [ ! -d "$skill_dir" ] && continue
         skill_name=$(basename "$skill_dir")
-        dst="$SKILLS_DIR/$skill_name"
+        dst="$EAGLE_SKILLS_DIR/$skill_name"
         [ -L "$dst" ] && rm "$dst"
         ln -sf "$skill_dir" "$dst"
     done

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

@@ -3,98 +3,78 @@ 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.
+  'update overview'. Uses the eagle-mem CLI — never run raw sqlite3 queries.
 ---
 
 # 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.
+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.
 
 ## 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
+1. Gather context about the project (recent sessions, file activity)
+2. Synthesize into a concise overview (2-4 sentences)
+3. Save via the CLI — one overview per project, updated in place
 
 The overview is automatically injected by the SessionStart hook.
 
-## Generating an overview
+## Commands
 
-### Step 1: Gather context
+### View current overview
 
 ```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;
-"
+eagle-mem overview
 ```
 
-Also check frequently modified files:
+### Auto-generate from code analysis
 
 ```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;
-"
+eagle-mem scan .
 ```
 
-### Step 2: Write the overview
+This scans the project structure (files, languages, frameworks, entry points, tests) and saves an overview automatically.
 
-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
+### Set overview manually
 
-Keep it under 500 characters. This gets injected into every session start, so brevity matters.
-
-### Step 3: Save to database
+When you want to write a custom overview based on session history:
 
+1. First, gather recent context:
 ```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;
-"
+eagle-mem search --timeline --limit 10
+eagle-mem search --files
 ```
 
-## Viewing the current overview
+2. 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
 
+3. Save it:
 ```bash
-sqlite3 ~/.eagle-mem/memory.db "
-SELECT project, content, updated_at FROM overviews
-WHERE project = '<project>';
-"
+eagle-mem overview set "eagle-mem: Node.js CLI tool providing persistent memory for Claude Code via SQLite + FTS5. Currently at v1.0.3 with 5 hooks, 3 skills, and CLI subcommands for search/tasks/overview."
 ```
 
-## Listing all project overviews
+Keep it under 500 characters — this gets injected into every session start.
+
+### List all project overviews
 
 ```bash
-sqlite3 ~/.eagle-mem/memory.db "
-SELECT project, substr(content, 1, 80) || '...', updated_at
-FROM overviews
-ORDER BY updated_at DESC;
-"
+eagle-mem overview list
 ```
 
-## Deleting an overview
+### Delete an overview
 
 ```bash
-sqlite3 ~/.eagle-mem/memory.db "
-DELETE FROM overviews WHERE project = '<project>';
-"
+eagle-mem overview delete
 ```
 
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `-p, --project <name>` | Target a specific project (default: current directory) |
+| `-j, --json` | Output as JSON |
+
 ## Guidelines
 
 - Update the overview when the project direction changes significantly

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

@@ -3,124 +3,76 @@ 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).
+  'search my history'. Uses the eagle-mem CLI — never run raw sqlite3 queries.
 ---
 
 # Eagle Mem — Memory Search
 
-Search the Eagle Mem database for past session summaries, observations, and task history.
+Search the Eagle Mem database for past session summaries, observations, and task history using the `eagle-mem` CLI.
 
-## Three-layer search pattern
+## Search commands
 
-### Layer 1: Compact search (default)
+### Keyword search (default)
 
-Fast keyword search across session summaries. Returns ~50-100 tokens per result.
+Search past sessions by keyword. Returns matching summaries ranked by relevance.
 
 ```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;
-"
+eagle-mem search "auth middleware"
 ```
 
-Use this first. If the user needs more detail, go to Layer 2 or 3.
+Cross-project search:
+```bash
+eagle-mem search "deploy issue" --all
+```
 
-### Layer 2: Timeline (chronological context)
+### Timeline (chronological)
 
-Show recent sessions for a project in time order. Good for "what have I been working on?"
+Show recent sessions for the current project in time order.
 
 ```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>;
-"
+eagle-mem search --timeline
+eagle-mem search --timeline --limit 20
 ```
 
-### Layer 3: Full details (observations)
+### Session details
 
-When the user needs to know exactly what files were touched or what tools were used:
+View all tool observations (files read/written, commands run) for a specific session.
 
 ```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;
-"
+eagle-mem search --session <session_id>
 ```
 
-## Additional queries
+### Frequently modified files
 
-### Cross-project search
+Show which files are touched most often in this project.
 
 ```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;
-"
+eagle-mem search --files
 ```
 
-### Files frequently modified
+### Project stats
+
+Get counts of sessions, summaries, observations, tasks, and code chunks.
 
 ```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;
-"
+eagle-mem search --stats
 ```
 
-### Task history
+## Options
 
-```bash
-sqlite3 ~/.eagle-mem/memory.db "
-SELECT id, title, status, completed_at
-FROM tasks
-WHERE project = '<project>'
-ORDER BY ordinal ASC, id ASC;
-"
-```
+| Flag | Description |
+|------|-------------|
+| `-p, --project <name>` | Target a specific project (default: current directory) |
+| `-n, --limit <N>` | Max results (default: 10) |
+| `-a, --all` | Search across all projects |
+| `-j, --json` | Output as JSON (for programmatic use) |
 
-### Session count and stats
+## Three-layer pattern
 
-```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>';
-"
-```
+Start with **keyword search** — it's fast and usually sufficient. If the user needs chronological context, use **--timeline**. If they need exact file-level detail, use **--session** with a specific session ID from a previous search result.
 
 ## 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
+- Keyword search supports FTS5 syntax: `word1 AND word2`, `"exact phrase"`, `word1 OR word2`
+- The `--json` flag is useful when you need to parse results programmatically
+- Project name defaults to the basename of the current working directory