eagle-mem 1.0.3 → 1.1.0

package/bin/eagle-mem

@@ -21,6 +21,9 @@ case "$command" in
     update)     bash "$SCRIPTS_DIR/update.sh" "$PACKAGE_DIR" "$@" ;;
     scan)       bash "$SCRIPTS_DIR/scan.sh" "$@" ;;
     index)      bash "$SCRIPTS_DIR/index.sh" "$@" ;;
+    search)     bash "$SCRIPTS_DIR/search.sh" "$@" ;;
+    tasks)      bash "$SCRIPTS_DIR/tasks.sh" "$@" ;;
+    overview)   bash "$SCRIPTS_DIR/overview.sh" "$@" ;;
     help|--help|-h)
                 bash "$SCRIPTS_DIR/help.sh" ;;
     version|--version|-v|-V)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eagle-mem",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "Lightweight persistent memory for Claude Code — SQLite + FTS5, no daemon, no bloat",
   "bin": {
     "eagle-mem": "bin/eagle-mem"

package/scripts/help.sh

@@ -19,20 +19,26 @@ echo -e "  ${BOLD}Usage:${RESET}"
 echo -e "    eagle-mem ${CYAN}<command>${RESET}"
 echo ""
 echo -e "  ${BOLD}Commands:${RESET}"
+echo -e "    ${CYAN}search${RESET}      Search past sessions, files, and observations"
+echo -e "    ${CYAN}tasks${RESET}       Manage tracked tasks (add, done, block, list)"
+echo -e "    ${CYAN}overview${RESET}    View or set project overview"
+echo -e "    ${CYAN}scan${RESET}        Analyze a project and generate an overview"
+echo -e "    ${CYAN}index${RESET}       Index source files for code-level search"
 echo -e "    ${CYAN}install${RESET}     Set up hooks, database, and skills"
 echo -e "    ${CYAN}uninstall${RESET}   Remove hooks and optionally delete data"
 echo -e "    ${CYAN}update${RESET}      Re-deploy hooks and run new migrations"
-echo -e "    ${CYAN}scan${RESET}        Analyze a project and generate an overview"
-echo -e "    ${CYAN}index${RESET}       Index source files for code-level search"
 echo -e "    ${CYAN}help${RESET}        Show this help message"
 echo -e "    ${CYAN}version${RESET}     Show version number"
 echo ""
 echo -e "  ${BOLD}Examples:${RESET}"
-echo -e "    ${DIM}\$${RESET} eagle-mem install       ${DIM}# First-time setup${RESET}"
-echo -e "    ${DIM}\$${RESET} eagle-mem update        ${DIM}# After npm update${RESET}"
-echo -e "    ${DIM}\$${RESET} eagle-mem scan .         ${DIM}# Scan current project${RESET}"
-echo -e "    ${DIM}\$${RESET} eagle-mem index .        ${DIM}# Index source files${RESET}"
-echo -e "    ${DIM}\$${RESET} eagle-mem uninstall     ${DIM}# Clean removal${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem search \"auth bug\"  ${DIM}# Search memory${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem search --timeline  ${DIM}# Recent sessions${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem tasks              ${DIM}# List tasks${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem tasks add \"Fix X\"  ${DIM}# Add a task${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem overview           ${DIM}# View overview${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem scan .             ${DIM}# Scan current project${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem index .            ${DIM}# Index source files${RESET}"
+echo -e "    ${DIM}\$${RESET} eagle-mem install            ${DIM}# First-time setup${RESET}"
 echo ""
 echo -e "  ${BOLD}What it does:${RESET}"
 echo -e "    ${DOT} Saves session summaries to a shared SQLite database"
@@ -46,5 +52,7 @@ echo -e "    ${CYAN}/eagle-mem-search${RESET}    Search past sessions and observ
 echo -e "    ${CYAN}/eagle-mem-tasks${RESET}     Break work into tracked subtasks"
 echo -e "    ${CYAN}/eagle-mem-overview${RESET}  Generate a persistent project summary"
 echo ""
+echo -e "  ${DIM}Skills use these CLI commands under the hood — no raw SQL.${RESET}"
+echo ""
 echo -e "  ${DIM}https://github.com/eagleisbatman/eagle-mem${RESET}"
 echo ""

package/scripts/overview.sh

@@ -0,0 +1,156 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — Overview
+# CLI wrapper for project overview management
+# ═══════════════════════════════════════════════════════════
+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:-show}"
+shift 2>/dev/null || true
+
+project=""
+json_output=false
+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 overview${RESET} — Manage project overviews"
+            echo ""
+            echo -e "  ${BOLD}Usage:${RESET}"
+            echo -e "    eagle-mem overview                    ${DIM}# show current overview${RESET}"
+            echo -e "    eagle-mem overview ${CYAN}set${RESET} <text>         ${DIM}# set/update overview${RESET}"
+            echo -e "    eagle-mem overview ${CYAN}delete${RESET}             ${DIM}# delete overview${RESET}"
+            echo -e "    eagle-mem overview ${CYAN}list${RESET}               ${DIM}# list all overviews${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 ""
+            echo -e "  ${BOLD}Tip:${RESET} Use ${CYAN}eagle-mem scan${RESET} to auto-generate an overview from code."
+            echo ""
+            exit 0
+            ;;
+        *)  args+=("$1"); shift ;;
+    esac
+done
+
+[ -z "$project" ] && project=$(eagle_project_from_cwd "$(pwd)")
+project_sql=$(eagle_sql_escape "$project")
+
+# ─── Show overview ────────────────────────────────────────
+
+overview_show() {
+    if [ "$json_output" = true ]; then
+        eagle_db_json "SELECT project, content, updated_at FROM overviews WHERE project = '$project_sql';"
+        return
+    fi
+
+    local content
+    content=$(eagle_get_overview "$project")
+
+    if [ -z "$content" ]; then
+        eagle_dim "No overview for project '$project'"
+        eagle_dim "Run 'eagle-mem scan' or 'eagle-mem overview set <text>' to create one"
+        return
+    fi
+
+    echo ""
+    echo -e "  ${BOLD}Overview${RESET} ${DIM}($project)${RESET}"
+    echo -e "  ${DIM}─────────────────────────────────────${RESET}"
+    echo ""
+    echo -e "  $content"
+    echo ""
+}
+
+# ─── Set overview ─────────────────────────────────────────
+
+overview_set() {
+    local content="${args[*]:-}"
+
+    if [ -z "$content" ]; then
+        eagle_err "Usage: eagle-mem overview set <text>"
+        exit 1
+    fi
+
+    eagle_upsert_overview "$project" "$content"
+
+    if [ "$json_output" = true ]; then
+        printf '{"project":"%s","updated":true}\n' "$project"
+        return
+    fi
+
+    eagle_ok "Overview saved for '$project'"
+}
+
+# ─── Delete overview ──────────────────────────────────────
+
+overview_delete() {
+    eagle_db "DELETE FROM overviews WHERE project = '$project_sql';"
+
+    if [ "$json_output" = true ]; then
+        printf '{"project":"%s","deleted":true}\n' "$project"
+        return
+    fi
+
+    eagle_ok "Overview deleted for '$project'"
+}
+
+# ─── List all overviews ──────────────────────────────────
+
+overview_list() {
+    if [ "$json_output" = true ]; then
+        eagle_db_json "SELECT project, content, updated_at FROM overviews ORDER BY updated_at DESC;"
+        return
+    fi
+
+    local results
+    results=$(eagle_db "SELECT project, substr(content, 1, 80), updated_at FROM overviews ORDER BY updated_at DESC;")
+
+    if [ -z "$results" ]; then
+        eagle_dim "No overviews stored"
+        return
+    fi
+
+    echo ""
+    echo -e "  ${BOLD}All project overviews${RESET}"
+    echo -e "  ${DIM}─────────────────────────────────────${RESET}"
+    echo ""
+
+    while IFS='|' read -r proj snippet updated_at; do
+        [ -z "$proj" ] && continue
+        echo -e "  ${BOLD}$proj${RESET}  ${DIM}$updated_at${RESET}"
+        echo -e "  ${DIM}$snippet...${RESET}"
+        echo ""
+    done <<< "$results"
+}
+
+# ─── Dispatch ─────────────────────────────────────────────
+
+case "$action" in
+    show|view)   overview_show ;;
+    set|update)  overview_set ;;
+    delete|rm)   overview_delete ;;
+    list|ls)     overview_list ;;
+    --help|-h)
+        echo -e "  Run ${CYAN}eagle-mem overview --help${RESET} for usage"
+        ;;
+    *)
+        eagle_err "Unknown action: $action"
+        eagle_dim "  Run 'eagle-mem overview --help' for options"
+        exit 1
+        ;;
+esac

package/scripts/search.sh

@@ -0,0 +1,285 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — Search
+# CLI wrapper for memory search (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 ──────────────────────────────────────
+
+mode="keyword"
+project=""
+limit=10
+session_id=""
+json_output=false
+query=""
+cross_project=false
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --timeline|-t)      mode="timeline"; shift ;;
+        --session|-s)        mode="session"; session_id="$2"; shift 2 ;;
+        --files|-f)          mode="files"; shift ;;
+        --stats)             mode="stats"; shift ;;
+        --project|-p)        project="$2"; shift 2 ;;
+        --limit|-n)          limit="$2"; shift 2 ;;
+        --all|-a)            cross_project=true; shift ;;
+        --json|-j)           json_output=true; shift ;;
+        --help|-h)
+            echo -e "  ${BOLD}eagle-mem search${RESET} — Search persistent memory"
+            echo ""
+            echo -e "  ${BOLD}Usage:${RESET}"
+            echo -e "    eagle-mem search ${CYAN}<query>${RESET}                   ${DIM}# keyword search${RESET}"
+            echo -e "    eagle-mem search ${CYAN}--timeline${RESET}               ${DIM}# recent sessions${RESET}"
+            echo -e "    eagle-mem search ${CYAN}--session <id>${RESET}            ${DIM}# session details${RESET}"
+            echo -e "    eagle-mem search ${CYAN}--files${RESET}                  ${DIM}# frequently modified files${RESET}"
+            echo -e "    eagle-mem search ${CYAN}--stats${RESET}                  ${DIM}# project statistics${RESET}"
+            echo ""
+            echo -e "  ${BOLD}Options:${RESET}"
+            echo -e "    ${CYAN}-p, --project${RESET} <name>    Project name (default: current dir)"
+            echo -e "    ${CYAN}-n, --limit${RESET} <N>         Max results (default: 10)"
+            echo -e "    ${CYAN}-a, --all${RESET}               Search across all projects"
+            echo -e "    ${CYAN}-j, --json${RESET}              Output as JSON"
+            echo ""
+            exit 0
+            ;;
+        -*)
+            eagle_err "Unknown option: $1"
+            exit 1
+            ;;
+        *)
+            query="$1"; shift ;;
+    esac
+done
+
+[ -z "$project" ] && project=$(eagle_project_from_cwd "$(pwd)")
+
+# ─── Keyword search ──────────────────────────────────────
+
+search_keyword() {
+    local q; q=$(eagle_sql_escape "$query")
+    local p; p=$(eagle_sql_escape "$project")
+
+    local where_project=""
+    if [ "$cross_project" = false ]; then
+        where_project="AND s.project = '$p'"
+    fi
+
+    if [ "$json_output" = true ]; then
+        eagle_db_json "SELECT s.id, s.project, s.request, s.completed, s.learned, s.created_at
+                       FROM summaries s
+                       JOIN summaries_fts f ON f.rowid = s.id
+                       WHERE summaries_fts MATCH '$q'
+                       $where_project
+                       ORDER BY rank
+                       LIMIT $limit;"
+        return
+    fi
+
+    local results
+    results=$(eagle_db "SELECT s.id, s.project, s.request, s.completed, s.learned, s.created_at
+                        FROM summaries s
+                        JOIN summaries_fts f ON f.rowid = s.id
+                        WHERE summaries_fts MATCH '$q'
+                        $where_project
+                        ORDER BY rank
+                        LIMIT $limit;")
+
+    if [ -z "$results" ]; then
+        eagle_dim "No results for '$query'"
+        return
+    fi
+
+    echo ""
+    while IFS='|' read -r sid sproj req completed learned created_at; do
+        [ -z "$sid" ] && continue
+        echo -e "  ${BOLD}#$sid${RESET}  ${DIM}$created_at${RESET}"
+        if [ "$cross_project" = true ]; then
+            echo -e "  ${DIM}project:${RESET} $sproj"
+        fi
+        [ -n "$req" ] && echo -e "  ${CYAN}Request:${RESET} $req"
+        [ -n "$completed" ] && echo -e "  ${GREEN}Done:${RESET} $completed"
+        [ -n "$learned" ] && echo -e "  ${YELLOW}Learned:${RESET} $learned"
+        echo ""
+    done <<< "$results"
+}
+
+# ─── Timeline ────────────────────────────────────────────
+
+search_timeline() {
+    local p; p=$(eagle_sql_escape "$project")
+
+    if [ "$json_output" = true ]; then
+        eagle_db_json "SELECT s.id, s.request, s.completed, s.learned, s.next_steps, s.created_at
+                       FROM summaries s
+                       WHERE s.project = '$p'
+                       ORDER BY s.created_at DESC
+                       LIMIT $limit;"
+        return
+    fi
+
+    local results
+    results=$(eagle_db "SELECT s.id, s.request, s.completed, s.learned, s.next_steps, s.created_at
+                        FROM summaries s
+                        WHERE s.project = '$p'
+                        ORDER BY s.created_at DESC
+                        LIMIT $limit;")
+
+    if [ -z "$results" ]; then
+        eagle_dim "No sessions found for project '$project'"
+        return
+    fi
+
+    echo ""
+    echo -e "  ${BOLD}Recent sessions${RESET} ${DIM}($project)${RESET}"
+    echo -e "  ${DIM}─────────────────────────────────────${RESET}"
+    echo ""
+
+    while IFS='|' read -r sid req completed learned next_steps created_at; do
+        [ -z "$sid" ] && continue
+        echo -e "  ${BOLD}#$sid${RESET}  ${DIM}$created_at${RESET}"
+        [ -n "$req" ] && echo -e "  ${CYAN}Request:${RESET} $req"
+        [ -n "$completed" ] && echo -e "  ${GREEN}Done:${RESET} $completed"
+        [ -n "$learned" ] && echo -e "  ${YELLOW}Learned:${RESET} $learned"
+        [ -n "$next_steps" ] && echo -e "  ${DIM}Next:${RESET} $next_steps"
+        echo ""
+    done <<< "$results"
+}
+
+# ─── Session details ──────────────────────────────────────
+
+search_session() {
+    if [ "$json_output" = true ]; then
+        eagle_db_json "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;"
+        return
+    fi
+
+    local results
+    results=$(eagle_db "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;")
+
+    if [ -z "$results" ]; then
+        eagle_dim "No observations found for session '$session_id'"
+        return
+    fi
+
+    echo ""
+    echo -e "  ${BOLD}Session${RESET} ${DIM}$session_id${RESET}"
+    echo -e "  ${DIM}─────────────────────────────────────${RESET}"
+    echo ""
+
+    while IFS='|' read -r tool_name summary files_r files_m created_at; do
+        [ -z "$tool_name" ] && continue
+        local icon="$DOT"
+        case "$tool_name" in
+            Read) icon="${CYAN}R${RESET}" ;;
+            Write) icon="${GREEN}W${RESET}" ;;
+            Edit) icon="${YELLOW}E${RESET}" ;;
+            Bash) icon="${BLUE}\$${RESET}" ;;
+        esac
+        echo -e "  ${icon}  ${DIM}$created_at${RESET}  $summary"
+    done <<< "$results"
+    echo ""
+}
+
+# ─── Frequently modified files ────────────────────────────
+
+search_files() {
+    local p; p=$(eagle_sql_escape "$project")
+
+    if [ "$json_output" = true ]; then
+        eagle_db_json "SELECT json_each.value as file, COUNT(*) as times
+                       FROM observations, json_each(observations.files_modified)
+                       WHERE observations.project = '$p'
+                       GROUP BY json_each.value
+                       ORDER BY times DESC
+                       LIMIT $limit;"
+        return
+    fi
+
+    local results
+    results=$(eagle_db "SELECT json_each.value as file, COUNT(*) as times
+                        FROM observations, json_each(observations.files_modified)
+                        WHERE observations.project = '$p'
+                        GROUP BY json_each.value
+                        ORDER BY times DESC
+                        LIMIT $limit;")
+
+    if [ -z "$results" ]; then
+        eagle_dim "No file history for project '$project'"
+        return
+    fi
+
+    echo ""
+    echo -e "  ${BOLD}Frequently modified files${RESET} ${DIM}($project)${RESET}"
+    echo -e "  ${DIM}─────────────────────────────────────${RESET}"
+    echo ""
+
+    while IFS='|' read -r filepath count; do
+        [ -z "$filepath" ] && continue
+        printf "  ${GREEN}%3s×${RESET}  %s\n" "$count" "$filepath"
+    done <<< "$results"
+    echo ""
+}
+
+# ─── Stats ────────────────────────────────────────────────
+
+search_stats() {
+    local p; p=$(eagle_sql_escape "$project")
+
+    local sessions summaries observations tasks
+    sessions=$(eagle_db "SELECT COUNT(*) FROM sessions WHERE project = '$p';")
+    summaries=$(eagle_db "SELECT COUNT(*) FROM summaries WHERE project = '$p';")
+    observations=$(eagle_db "SELECT COUNT(*) FROM observations o JOIN sessions s ON s.id = o.session_id WHERE s.project = '$p';")
+    tasks=$(eagle_db "SELECT COUNT(*) FROM tasks WHERE project = '$p';")
+    local chunks
+    chunks=$(eagle_db "SELECT COUNT(*) FROM code_chunks WHERE project = '$p';")
+
+    if [ "$json_output" = true ]; then
+        printf '{"project":"%s","sessions":%s,"summaries":%s,"observations":%s,"tasks":%s,"code_chunks":%s}\n' \
+            "$project" "${sessions:-0}" "${summaries:-0}" "${observations:-0}" "${tasks:-0}" "${chunks:-0}"
+        return
+    fi
+
+    echo ""
+    echo -e "  ${BOLD}Stats${RESET} ${DIM}($project)${RESET}"
+    echo -e "  ${DIM}─────────────────────────────────────${RESET}"
+    echo ""
+    eagle_kv "Sessions:" "${sessions:-0}"
+    eagle_kv "Summaries:" "${summaries:-0}"
+    eagle_kv "Observations:" "${observations:-0}"
+    eagle_kv "Tasks:" "${tasks:-0}"
+    eagle_kv "Code chunks:" "${chunks:-0}"
+    echo ""
+}
+
+# ─── Dispatch ─────────────────────────────────────────────
+
+case "$mode" in
+    keyword)
+        if [ -z "$query" ]; then
+            eagle_err "Usage: eagle-mem search <query>"
+            eagle_dim "  Run 'eagle-mem search --help' for options"
+            exit 1
+        fi
+        search_keyword
+        ;;
+    timeline)    search_timeline ;;
+    session)     search_session ;;
+    files)       search_files ;;
+    stats)       search_stats ;;
+esac

package/scripts/tasks.sh

@@ -0,0 +1,240 @@
+#!/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:-list}"
+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))
+
+    eagle_db "INSERT INTO tasks (project, title, instructions, ordinal)
+              VALUES ('$project_sql', '$title_sql', '$instr_sql', $next_ord);"
+
+    local new_id
+    new_id=$(eagle_db "SELECT last_insert_rowid();")
+
+    if [ "$json_output" = true ]; then
+        printf '{"id":%s,"title":"%s","ordinal":%s}\n' "$new_id" "$title" "$next_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
+
+    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';"
+
+    local title
+    title=$(eagle_db "SELECT title FROM tasks WHERE id = $task_id;")
+
+    if [ "$json_output" = true ]; then
+        printf '{"id":%s,"status":"done"}\n' "$task_id"
+        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
+
+    eagle_db "UPDATE tasks SET status = 'blocked' WHERE id = $task_id AND project = '$project_sql';"
+
+    if [ "$json_output" = true ]; then
+        printf '{"id":%s,"status":"blocked"}\n' "$task_id"
+        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
+
+    local snap_sql; snap_sql=$(eagle_sql_escape "$snapshot")
+    eagle_db "UPDATE tasks SET context_snapshot = '$snap_sql' WHERE id = $task_id AND project = '$project_sql';"
+
+    if [ "$json_output" = true ]; then
+        printf '{"id":%s,"context_snapshot":true}\n' "$task_id"
+        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
+        printf '{"cleared":%s}\n' "${count:-0}"
+        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 "  Run ${CYAN}eagle-mem tasks --help${RESET} for usage"
+        ;;
+    *)
+        eagle_err "Unknown action: $action"
+        eagle_dim "  Run 'eagle-mem tasks --help' for options"
+        exit 1
+        ;;
+esac

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

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

@@ -3,8 +3,7 @@ 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.
+  'task loop', 'compact loop', 'eagle mem tasks'. Uses the eagle-mem CLI — never run raw sqlite3 queries.
 ---
 
 # Eagle Mem — TaskAware Compact Loop
@@ -14,7 +13,7 @@ Break complex work into subtasks stored in Eagle Mem's database. Execute one tas
 ## How it works
 
 1. **Plan**: Break the user's request into ordered subtasks
-2. **Store**: Write each subtask to the Eagle Mem database
+2. **Store**: Add each subtask via the CLI
 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
@@ -22,78 +21,72 @@ Break complex work into subtasks stored in Eagle Mem's database. Execute one tas
 
 ## 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:
+### List tasks
 
 ```bash
-~/.eagle-mem/db/task-ops.sh add "<project>" "<title>" "<instructions>" <ordinal>
+eagle-mem tasks
+eagle-mem tasks list
 ```
 
-If `task-ops.sh` doesn't exist yet, write directly:
+### Add 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
+3. Add tasks using the CLI:
 
 ```bash
-sqlite3 ~/.eagle-mem/memory.db "
-PRAGMA trusted_schema=ON;
-INSERT INTO tasks (project, title, instructions, ordinal)
-VALUES ('<project>', '<title>', '<instructions>', <ordinal>);
-"
+eagle-mem tasks add "Set up project structure" "Install deps, create folders, init config"
+eagle-mem tasks add "Implement auth middleware" "JWT validation, role checks, error responses"
+eagle-mem tasks add "Build CRUD endpoints" "Users and posts REST API with validation"
 ```
 
 4. Show the task plan to the user for confirmation
 5. After confirmation, start working on task #1
 
-### Viewing tasks
+### Complete a task
 
 ```bash
-sqlite3 ~/.eagle-mem/memory.db "
-SELECT id, title, status, ordinal FROM tasks
-WHERE project = '<project>'
-ORDER BY ordinal ASC, id ASC;
-"
+eagle-mem tasks done <id>
 ```
 
-### Completing a task
+After marking done:
+1. Emit your `<eagle-summary>` block
+2. Tell the user: **"Task #N complete. Run `/compact` to save progress and load the next task."**
 
-When the current task is done:
+### Block a task
 
-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>;
-"
+eagle-mem tasks block <id>
 ```
 
-2. Emit your `<eagle-summary>` block
-3. Tell the user: **"Task #N complete. Run `/compact` to save progress and load the next task."**
+### Set context snapshot
 
-### Skipping/blocking a task
+For tasks that depend on decisions from earlier tasks:
 
 ```bash
-sqlite3 ~/.eagle-mem/memory.db "
-UPDATE tasks SET status = 'blocked'
-WHERE id = <task_id>;
-"
+eagle-mem tasks context <id> "Using JWT with RS256, sessions stored in Redis"
 ```
 
-## Task design guidelines
+### Clear completed tasks
 
-- 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>;
-"
+eagle-mem tasks clear
 ```
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `-p, --project <name>` | Target a specific project (default: current directory) |
+| `-j, --json` | Output as JSON |
+
+## Task design guidelines
+
+- Each task should be **self-contained** — completable without mid-execution context from a previous task
+- Include instructions with enough detail that a fresh context window can pick it up
+- Use context snapshots for tasks that depend on decisions from earlier tasks
 - Order tasks so that foundational work comes first (schema before API, API before UI)
 
 ## The compact cycle
@@ -105,19 +98,3 @@ User request → Plan tasks → Execute task 1 → /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.