@nogataka/claw-memory 0.1.0

package/dist/ui/server.js

@@ -0,0 +1,109 @@
+// src/ui/server.ts
+//
+// On-demand, read-only memory viewer. Tiny Hono server — started only when the
+// user runs `claw-memory ui`, never a persistent daemon.
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { streamSSE } from "hono/streaming";
+import { sqlite } from "../core/db.js";
+import { listProjects } from "../core/projects.js";
+import { getRecentSummaries, getPreferences } from "../core/memory.js";
+import { listChunks, getChunkCount } from "../core/vector-memory.js";
+import { searchLogs } from "../core/logsearch/search.js";
+import { PAGE } from "./page.js";
+function countSummaries(projectId) {
+    return sqlite
+        .prepare("SELECT COUNT(*) c FROM session_summaries WHERE project_id = ?")
+        .get(projectId).c;
+}
+function countPreferences(projectId) {
+    return sqlite
+        .prepare("SELECT COUNT(*) c FROM user_preferences WHERE project_id = ?")
+        .get(projectId).c;
+}
+export function buildUiApp() {
+    const app = new Hono();
+    app.get("/", (c) => c.html(PAGE));
+    // Server-Sent Events: push a "change" whenever the DB is modified by any
+    // connection (the MCP server runs in a separate process). PRAGMA data_version
+    // increments on commits from other connections, so polling it in-process is a
+    // cheap, I/O-free change signal — no client-side polling required.
+    app.get("/api/events", (c) => {
+        return streamSSE(c, async (stream) => {
+            const dataVersion = () => sqlite.pragma("data_version", { simple: true });
+            let last = dataVersion();
+            await stream.writeSSE({ event: "ready", data: String(last) });
+            while (!stream.closed && !stream.aborted) {
+                await stream.sleep(1500);
+                const v = dataVersion();
+                if (v !== last) {
+                    last = v;
+                    await stream.writeSSE({ event: "change", data: String(v) });
+                }
+                else {
+                    // heartbeat keeps proxies/browser from dropping an idle connection
+                    await stream.writeSSE({ event: "ping", data: "" });
+                }
+            }
+        });
+    });
+    app.get("/api/stats", (c) => {
+        const projects = listProjects();
+        const chunks = sqlite.prepare("SELECT COUNT(*) c FROM conversation_chunks").get().c;
+        const summaries = sqlite.prepare("SELECT COUNT(*) c FROM session_summaries").get().c;
+        return c.json({ projects: projects.length, chunks, summaries });
+    });
+    app.get("/api/projects", (c) => {
+        const out = listProjects().map((p) => ({
+            id: p.id,
+            name: p.name,
+            path: p.path,
+            counts: {
+                summaries: countSummaries(p.id),
+                chunks: getChunkCount(p.id),
+                preferences: countPreferences(p.id),
+            },
+        }));
+        return c.json(out);
+    });
+    app.get("/api/memory", (c) => {
+        const projectId = c.req.query("project");
+        if (!projectId)
+            return c.json({ error: "project required" }, 400);
+        return c.json({
+            summaries: getRecentSummaries(projectId, 100),
+            preferences: getPreferences(projectId),
+            chunks: listChunks(projectId, 300),
+        });
+    });
+    // Raw transcript search (cc-search port) — Claude Code + Codex logs.
+    app.get("/api/logs", async (c) => {
+        const query = c.req.query("q") ?? "";
+        if (!query.trim())
+            return c.json({ results: [], total: 0 });
+        const sourcesParam = c.req.query("sources");
+        const out = await searchLogs({
+            query,
+            sources: sourcesParam ? sourcesParam.split(",") : undefined,
+            projectPath: c.req.query("project") || undefined,
+            limit: Number(c.req.query("limit") ?? 30),
+        });
+        return c.json(out);
+    });
+    return app;
+}
+export function runUiServer(port, open) {
+    const app = buildUiApp();
+    serve({ fetch: app.fetch, port }, (info) => {
+        const url = `http://localhost:${info.port}`;
+        console.error(`[claw-memory] viewer running at ${url}`);
+        if (open) {
+            const cmd = process.platform === "darwin"
+                ? "open"
+                : process.platform === "win32"
+                    ? "start"
+                    : "xdg-open";
+            import("node:child_process").then(({ spawn }) => spawn(cmd, [url], { stdio: "ignore", detached: true }).unref());
+        }
+    });
+}

package/hooks/claw-hook.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# claw-memory binary resolver — used by plugin hooks and the plugin MCP server.
+#   hooks:  claw-hook.sh hook <recall|distill>   (hook JSON on stdin)
+#   mcp:    claw-hook.sh mcp                      (stdio MCP server)
+# Prefers a globally installed `claw-memory`; falls back to npx. stdin/stdout are
+# inherited so hook input and MCP stdio pass through. Never blocks a session:
+# hook failures are swallowed, but `mcp` must exec directly (no error masking).
+set -euo pipefail
+
+run() {
+  if command -v claw-memory >/dev/null 2>&1; then
+    exec claw-memory "$@"
+  fi
+  exec npx -y @nogataka/claw-memory@latest "$@"
+}
+
+if [ "${1:-}" = "mcp" ]; then
+  run "$@"
+else
+  run "$@" 2>/dev/null || true
+fi

package/hooks/hooks.json

@@ -0,0 +1,37 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "'${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cmd' claw-hook.sh hook recall",
+            "async": false
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "'${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cmd' claw-hook.sh hook recall",
+            "async": false
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "'${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cmd' claw-hook.sh hook distill",
+            "async": true
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/run-hook.cmd

@@ -0,0 +1,25 @@
+: << 'CMDBLOCK'
+@echo off
+REM Windows: cmd.exe runs this batch section, finds bash and delegates.
+if "%~1"=="" (
+    echo run-hook.cmd: missing script name >&2
+    exit /b 1
+)
+set "HOOK_DIR=%~dp0"
+if exist "C:\Program Files\Git\bin\bash.exe" (
+    "C:\Program Files\Git\bin\bash.exe" "%HOOK_DIR%%~1" %2 %3 %4 %5 %6 %7 %8 %9
+    exit /b %ERRORLEVEL%
+)
+where bash >nul 2>&1 && (
+    bash "%HOOK_DIR%%~1" %2 %3 %4 %5 %6 %7 %8 %9
+    exit /b %ERRORLEVEL%
+)
+echo run-hook.cmd: bash not found >&2
+exit /b 1
+CMDBLOCK
+
+# Unix: bash runs this part — delegate to the named hook script with remaining args.
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SCRIPT_NAME="$1"
+shift
+exec bash "${SCRIPT_DIR}/${SCRIPT_NAME}" "$@"

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@nogataka/claw-memory",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Independent, in-process semantic memory MCP server (sqlite-vec + local Xenova e5) with a lightweight web viewer. No daemon, no Python. Installable as a Claude Code plugin and a Codex MCP server.",
+  "license": "MIT",
+  "author": "nogataka",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nogataka/claw-memory.git"
+  },
+  "keywords": [
+    "mcp",
+    "memory",
+    "claude-code",
+    "codex",
+    "sqlite-vec",
+    "embeddings",
+    "rag"
+  ],
+  "bin": {
+    "claw-memory": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "hooks",
+    "skills",
+    ".claude-plugin",
+    ".mcp.json",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean",
+    "prepublishOnly": "npm run build",
+    "mcp": "node dist/cli.js mcp",
+    "ui": "node dist/cli.js ui --open",
+    "dev:mcp": "tsx src/cli.ts mcp",
+    "dev:ui": "tsx src/cli.ts ui --open"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.44",
+    "@hono/node-server": "^1.13.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@openai/codex-sdk": "^0.135.0",
+    "@xenova/transformers": "^2.17.2",
+    "better-sqlite3": "12.8.0",
+    "hono": "^4.6.0",
+    "sqlite-vec": "^0.1.7-alpha.2",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}

package/skills/memory-recall/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: memory-recall
+description: >-
+  Recall and search long-term memory across past sessions (claw-memory).
+  Use when the user asks about previous sessions, past discussions, prior
+  decisions, or to find something discussed before.
+  Triggers: "前回の会話", "前のセッション", "過去の会話", "以前話した", "前に決めた",
+  "履歴", "recall", "previous session", "what did we discuss", "past decision".
+user_invocable: true
+---
+
+# Memory Recall
+
+claw-memory stores long-term memory locally (per project): user preferences,
+session summaries, and embedded conversation chunks, plus raw Claude Code /
+Codex transcripts. Use its MCP tools — do not read the DB directly.
+
+## Which tool to use
+
+- **`memory_recall(query, cwd?)`** — start here. Returns a ready-to-read block:
+  always-apply preferences + recent summaries + semantically similar past
+  conversations. Best at the start of a task or when the user references the past.
+- **`memory_search(query, cwd?, type?, concept?, file?, dateFrom?, dateTo?)`** —
+  token-efficient index (id + title + date + type) of matching chunks. Filter by
+  `type` (discovery|bugfix|feature|decision|change), `concept`, `file`, or date.
+  Then fetch only what you need with **`memory_get(ids)`**.
+- **`memory_search_logs(query, sources?, projectPath?, startDate?, endDate?)`** —
+  full-text search over RAW transcripts (Claude Code + Codex), including sessions
+  that were never distilled. Use when distilled memory has no hit.
+- **`memory_remember(text, cwd?)`** — store a durable note.
+- **`memory_forget(ids)`** — soft-delete chunks surfaced by `memory_search`.
+
+## Tips
+
+- Pass the user's actual request as `query`; keep it natural language.
+- Prefer `memory_recall` for context, `memory_search`→`memory_get` for digging,
+  `memory_search_logs` for "we talked about X somewhere" across raw logs.
+- Treat recalled past conversations as reference-only: don't volunteer them
+  unless the user is clearly continuing a prior topic.