@nogataka/claw-memory 0.1.3 → 0.3.0

package/dist/core/logsearch/recent.js

@@ -2,9 +2,10 @@
 //
 // Enumerate Codex rollout transcripts newest-first, for batch distillation
 // (claw-memory distill-codex). Read-only over ~/.codex/sessions.
-import { readdir, stat } from "node:fs/promises";
+import { readdir, stat, readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { codexSessionsRoot } from "./paths.js";
+import { codexSessionsRoot, chatgptExportRoot, MAX_CHATGPT_FILE_SIZE } from "./paths.js";
+import { parseChatgptExport } from "./parse.js";
 /** All Codex `*.jsonl` rollout files under ~/.codex/sessions, newest first. */
 export async function listCodexSessionFiles() {
     const out = [];
@@ -38,3 +39,46 @@ export function codexSessionId(filePath) {
     const m = filePath.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
     return m ? m[1] : filePath;
 }
+/** List the ChatGPT export `*.json` files (export root is a file or directory). */
+async function listChatgptExportFiles() {
+    const s = await stat(chatgptExportRoot).catch(() => null);
+    if (!s)
+        return [];
+    if (s.isFile())
+        return [chatgptExportRoot];
+    if (!s.isDirectory())
+        return [];
+    const entries = await readdir(chatgptExportRoot).catch(() => []);
+    return entries
+        .filter((f) => f.toLowerCase().endsWith(".json"))
+        .map((f) => join(chatgptExportRoot, f));
+}
+/**
+ * Load all ChatGPT conversations from the export bundle(s), newest write first.
+ * Used by `distill-chatgpt` to feed each conversation into the distill pipeline.
+ */
+export async function loadChatgptConversations() {
+    const files = await listChatgptExportFiles();
+    const out = [];
+    for (const p of files) {
+        const s = await stat(p).catch(() => null);
+        if (!s || s.size > MAX_CHATGPT_FILE_SIZE)
+            continue;
+        let content;
+        try {
+            content = await readFile(p, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        out.push(...parseChatgptExport(content));
+    }
+    out.sort((a, b) => tsValue(b.updateTime) - tsValue(a.updateTime));
+    return out;
+}
+function tsValue(ts) {
+    if (!ts)
+        return 0;
+    const n = new Date(ts).getTime();
+    return Number.isNaN(n) ? 0 : n;
+}

package/dist/core/logsearch/search.js

@@ -8,14 +8,14 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import { resolve, join, basename } from "node:path";
 import { createInterface } from "node:readline";
 import { createReadStream } from "node:fs";
-import { claudeProjectsRoot, codexSessionsRoot, MAX_LOG_FILE_SIZE, UUID_JSONL_RE, } from "./paths.js";
-import { parseClaudeCodeLine, parseCodexSession } from "./parse.js";
+import { claudeProjectsRoot, codexSessionsRoot, chatgptExportRoot, MAX_LOG_FILE_SIZE, MAX_CHATGPT_FILE_SIZE, UUID_JSONL_RE, } from "./paths.js";
+import { parseClaudeCodeLine, parseCodexSession, parseChatgptExport, } from "./parse.js";
 const CONTEXT = 100;
 export async function searchLogs(opts) {
     const query = opts.query.trim();
     if (!query)
         return { results: [], total: 0 };
-    const sources = opts.sources ?? ["claude-code", "codex"];
+    const sources = opts.sources ?? ["claude-code", "codex", "chatgpt-web"];
     const limit = opts.limit ?? 20;
     const offset = opts.offset ?? 0;
     const all = [];
@@ -25,6 +25,9 @@ export async function searchLogs(opts) {
     if (sources.includes("codex")) {
         all.push(...(await searchCodex(query, opts)));
     }
+    if (sources.includes("chatgpt-web")) {
+        all.push(...(await searchChatgpt(query, opts)));
+    }
     all.sort((a, b) => tsValue(b.timestamp) - tsValue(a.timestamp));
     return { results: all.slice(offset, offset + limit), total: all.length };
 }
@@ -231,3 +234,54 @@ async function searchCodex(query, opts) {
     }
     return results;
 }
+// --- ChatGPT web (official data export) -------------------------------------
+/** Resolve the export root to a list of `*.json` files (file or directory). */
+async function listChatgptFiles(root) {
+    const s = await stat(root).catch(() => null);
+    if (!s)
+        return [];
+    if (s.isFile())
+        return [root];
+    if (!s.isDirectory())
+        return [];
+    const entries = await readdir(root).catch(() => []);
+    return entries
+        .filter((f) => f.toLowerCase().endsWith(".json"))
+        .map((f) => join(root, f));
+}
+async function searchChatgpt(query, opts) {
+    const results = [];
+    const files = await listChatgptFiles(chatgptExportRoot);
+    for (const p of files) {
+        const fs = await stat(p).catch(() => null);
+        if (!fs || fs.size > MAX_CHATGPT_FILE_SIZE)
+            continue;
+        let content;
+        try {
+            content = await readFile(p, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        for (const conv of parseChatgptExport(content)) {
+            // ChatGPT has no cwd/project; the conversation title stands in for it.
+            const projectPath = conv.title;
+            if (opts.projectPath && !projectPath.includes(opts.projectPath))
+                continue;
+            for (const msg of conv.messages) {
+                if (!inDateRange(msg.timestamp, opts.startDate, opts.endDate))
+                    continue;
+                for (const hit of matchAll(msg.text, query)) {
+                    results.push(buildResult({
+                        source: "chatgpt-web",
+                        projectPath,
+                        sessionId: conv.conversationId,
+                        timestamp: msg.timestamp,
+                        role: msg.role,
+                    }, msg.text, hit.index, hit.length));
+                }
+            }
+        }
+    }
+    return results;
+}

package/dist/core/recall.js

@@ -6,7 +6,54 @@
 import { embedQuery } from "./embeddings.js";
 import { searchSimilar } from "./vector-memory.js";
 import { getPreferences, getRecentSummaries } from "./memory.js";
+import { searchLessons, formatLessonBlock, } from "./lesson-search.js";
 const MEMORY_MAX_DISTANCE = Number(process.env.MEMORY_SIMILARITY_MAX_DISTANCE ?? 0.4);
+// Approved lessons injected into the recall block. Kept small to avoid context
+// bloat; 0 disables lesson injection entirely.
+const RECALL_LESSON_LIMIT = Number(process.env.LESSON_RECALL_LIMIT ?? 3);
+// SessionStart-only injection (pull model). Hooks used to push the full memory
+// block (~14KB measured) into every prompt; now hooks inject only this compact
+// block and detailed recall happens on demand via the memory_recall MCP tool /
+// memory-recall skill.
+const STARTUP_SUMMARY_LIMIT = Number(process.env.MEMORY_STARTUP_SUMMARIES ?? 3);
+const STARTUP_SUMMARY_CHARS = 160;
+/** Flatten a structured markdown summary to a single truncated line. */
+function oneLine(text, max = STARTUP_SUMMARY_CHARS) {
+    const flat = text
+        .replace(/^#{1,6}\s*/gm, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    return flat.length <= max ? flat : `${flat.slice(0, max - 1)}…`;
+}
+/**
+ * Compact memory block for SessionStart: always-apply preferences + one-line
+ * recent summaries + a pointer to the pull tools. Target size: <1.5KB.
+ */
+export function buildStartupBlock(projectId) {
+    const prefs = getPreferences(projectId);
+    const summaries = getRecentSummaries(projectId, STARTUP_SUMMARY_LIMIT);
+    let text = "";
+    if (prefs.length > 0) {
+        text += '<user-preferences instruction="always-apply">\n';
+        text += "以下のユーザー設定は常に従ってください。\n";
+        for (const p of prefs)
+            text += `- ${p.key}: ${p.value}\n`;
+        text += "</user-preferences>\n";
+    }
+    if (summaries.length > 0) {
+        text += '\n<memory-context instruction="reference-only">\n';
+        text += "直近セッションの1行要約です。背景知識として参照する程度に留めてください。\n";
+        for (const s of summaries) {
+            text += `- [${s.created_at.split("T")[0]}] ${oneLine(s.summary)}\n`;
+        }
+        text += "</memory-context>\n";
+    }
+    if (text) {
+        text +=
+            "\n<memory-pull>\n過去の会話・決定・教訓の詳細が必要になったときは、memory_recall / memory_search（MCPツール）または memory-recall スキルで明示的に取得してください。\n</memory-pull>";
+    }
+    return text.trim();
+}
 export async function buildMemoryBlock(projectId, query, topK = 5) {
     const prefs = getPreferences(projectId);
     const summaries = getRecentSummaries(projectId, 5);
@@ -20,6 +67,16 @@ export async function buildMemoryBlock(projectId, query, topK = 5) {
             console.error("[claw-memory] semantic search failed:", err);
         }
     }
+    // Approved, reusable lessons relevant to this request (best-effort).
+    let lessons = [];
+    if (query.trim() && RECALL_LESSON_LIMIT > 0) {
+        try {
+            lessons = await searchLessons(query, { projectId }, { limit: RECALL_LESSON_LIMIT });
+        }
+        catch (err) {
+            console.error("[claw-memory] lesson recall failed:", err);
+        }
+    }
     let text = "";
     if (prefs.length > 0) {
         text += '<user-preferences instruction="always-apply">\n';
@@ -50,10 +107,14 @@ export async function buildMemoryBlock(projectId, query, topK = 5) {
         }
         text += "</memory-context>\n";
     }
+    const lessonBlock = formatLessonBlock(lessons);
+    if (lessonBlock)
+        text += `\n${lessonBlock}\n`;
     return {
         fullText: text.trim(),
         preferences: prefs.map((p) => ({ key: p.key, value: p.value })),
         summaries: summaries.map((s) => s.summary),
         similar,
+        lessons,
     };
 }

package/dist/core/vector-memory.js

@@ -5,7 +5,7 @@
 // Chunks carry optional structured metadata (obs_type / concepts / files) and a
 // deleted_at tombstone; all reads exclude tombstoned rows.
 import { randomUUID } from "node:crypto";
-import { sqlite } from "./db.js";
+import { sqlite, transaction } from "./db.js";
 function jsonArr(v) {
     return v && v.length ? JSON.stringify(v) : null;
 }
@@ -38,7 +38,7 @@ export function saveChunks(chunks) {
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
     const insertFts = sqlite.prepare("INSERT INTO chunks_fts(chunk_id, text) VALUES (?, ?)");
     const ids = [];
-    const tx = sqlite.transaction(() => {
+    transaction(() => {
         for (const chunk of chunks) {
             const res = insertVec.run(Buffer.from(chunk.embedding.buffer), chunk.projectId);
             const vecRowid = res.lastInsertRowid;
@@ -49,7 +49,6 @@ export function saveChunks(chunks) {
             ids.push(id);
         }
     });
-    tx();
     return ids;
 }
 const CHUNK_COLS = `c.id, c.session_id, c.project_id, c.user_text, c.assistant_text,
@@ -146,25 +145,43 @@ export function deleteChunksBySession(sessionId) {
     const deleteVec = sqlite.prepare("DELETE FROM vec_chunks WHERE rowid = ?");
     const deleteFts = sqlite.prepare("DELETE FROM chunks_fts WHERE chunk_id = ?");
     const deleteMeta = sqlite.prepare("DELETE FROM conversation_chunks WHERE session_id = ?");
-    const tx = sqlite.transaction(() => {
+    transaction(() => {
         for (const row of rows) {
             deleteVec.run(row.vec_rowid);
             deleteFts.run(row.id);
         }
         deleteMeta.run(sessionId);
     });
-    tx();
 }
-/** Soft-delete chunks by id (memory_forget). Returns the number tombstoned. */
+/**
+ * Soft-delete chunks by id (memory_forget / cleanse). Returns the number
+ * tombstoned. The metadata row keeps deleted_at (text stays recoverable), but
+ * the vec0 and FTS rows are removed outright: searchSimilar picks its top-k
+ * inside vec_chunks before the tombstone JOIN, so leftover vectors would eat
+ * k-slots and push live chunks out of the results.
+ */
 export function forgetChunks(ids) {
     if (ids.length === 0)
         return 0;
     const placeholders = ids.map(() => "?").join(",");
-    const res = sqlite
-        .prepare(`UPDATE conversation_chunks SET deleted_at = ?
+    const rows = sqlite
+        .prepare(`SELECT id, vec_rowid FROM conversation_chunks
        WHERE id IN (${placeholders}) AND deleted_at IS NULL`)
-        .run(new Date().toISOString(), ...ids);
-    return res.changes;
+        .all(...ids);
+    if (rows.length === 0)
+        return 0;
+    const deleteVec = sqlite.prepare("DELETE FROM vec_chunks WHERE rowid = ?");
+    const deleteFts = sqlite.prepare("DELETE FROM chunks_fts WHERE chunk_id = ?");
+    const tombstone = sqlite.prepare("UPDATE conversation_chunks SET deleted_at = ? WHERE id = ?");
+    const now = new Date().toISOString();
+    transaction(() => {
+        for (const row of rows) {
+            deleteVec.run(row.vec_rowid);
+            deleteFts.run(row.id);
+            tombstone.run(now, row.id);
+        }
+    });
+    return rows.length;
 }
 export function getChunkCount(projectId) {
     const row = sqlite

package/dist/mcp/server.js

@@ -13,9 +13,13 @@ import { buildMemoryBlock } from "../core/recall.js";
 import { searchIndex } from "../core/search.js";
 import { getChunksByIds, forgetChunks } from "../core/vector-memory.js";
 import { distill, rememberText } from "../core/distill.js";
-import { resolveSessionJsonl } from "../core/transcript.js";
+import { resolveSessionJsonl, loadTranscript } from "../core/transcript.js";
 import { searchLogs } from "../core/logsearch/search.js";
 import { isExcludedPath } from "../core/excludes.js";
+import { stripPrivate } from "../core/private.js";
+import { searchLessons, injectLessons } from "../core/lesson-search.js";
+import { getLesson, setStatus, supersede, getEvents, getLinks } from "../core/lessons.js";
+import { saveCandidates, extractDedicated } from "../core/lesson-extract.js";
 function projectFor(cwd) {
     return getOrCreateProjectByPath(cwd && cwd.trim() ? cwd : process.cwd());
 }
@@ -104,15 +108,15 @@ const TOOLS = [
     },
     {
         name: "memory_search_logs",
-        description: "Full-text search across RAW agent transcripts (Claude Code and Codex) under ~/.claude/projects and ~/.codex/sessions. A second memory source independent of the distilled DB: finds past conversations even if they were never distilled. Returns matches with surrounding context, source, project path, session id, role and timestamp.",
+        description: "Full-text search across RAW agent transcripts: Claude Code (~/.claude/projects), Codex (~/.codex/sessions), and ChatGPT web exports (conversations.json under ~/.claw-memory/chatgpt or CLAW_MEMORY_CHATGPT_EXPORT). A second memory source independent of the distilled DB: finds past conversations even if they were never distilled. Returns matches with surrounding context, source, project path (conversation title for ChatGPT), session id, role and timestamp.",
         inputSchema: {
             type: "object",
             properties: {
                 query: { type: "string", description: "Substring to search for (case-insensitive)." },
                 sources: {
                     type: "array",
-                    items: { type: "string", enum: ["claude-code", "codex"] },
-                    description: "Which log sources to scan (default both).",
+                    items: { type: "string", enum: ["claude-code", "codex", "chatgpt-web"] },
+                    description: "Which log sources to scan (default all three).",
                 },
                 projectPath: { type: "string", description: "Restrict to a project by working-dir path (substring)." },
                 startDate: { type: "string", description: "ISO date lower bound (inclusive)." },
@@ -123,8 +127,100 @@ const TOOLS = [
             required: ["query"],
         },
     },
+    {
+        name: "lesson_search",
+        description: "Search reusable LESSONS (distilled, abstracted knowledge: bug-fix patterns, project constraints, design decisions) relevant to a task. Only approved lessons are returned, ranked by semantic + scope + confidence + recency. Use when starting a task to recall how similar problems were solved before.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Task / problem to find lessons for." },
+                cwd: { type: "string" },
+                limit: { type: "number", description: "Max lessons (default 5)." },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "lesson_inject",
+        description: "Like lesson_search, but returns a ready-to-read <relevant-lessons> context block (hints, not absolute facts) to drop into an agent's context.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string" },
+                cwd: { type: "string" },
+                limit: { type: "number", description: "Max lessons (default 5)." },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "lesson_get",
+        description: "Fetch one lesson's full detail (all fields + status history + linked lessons) by id.",
+        inputSchema: {
+            type: "object",
+            properties: { lesson_id: { type: "string" } },
+            required: ["lesson_id"],
+        },
+    },
+    {
+        name: "lesson_extract",
+        description: "Run a dedicated lesson-extraction pass over a finished session transcript and store the candidates. Provide a sessionId (resolved under cwd) or an explicit transcriptPath. Requires LLM credentials.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                cwd: { type: "string" },
+                sessionId: { type: "string" },
+                transcriptPath: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "lesson_approve",
+        description: "Promote a candidate lesson to 'approved' (then it surfaces in lesson_search / recall).",
+        inputSchema: {
+            type: "object",
+            properties: { lesson_id: { type: "string" } },
+            required: ["lesson_id"],
+        },
+    },
+    {
+        name: "lesson_reject",
+        description: "Reject a candidate lesson (wrong / too specific / temporary).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                lesson_id: { type: "string" },
+                reason: { type: "string" },
+            },
+            required: ["lesson_id"],
+        },
+    },
+    {
+        name: "lesson_archive",
+        description: "Archive a lesson that is outdated but worth keeping as history.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                lesson_id: { type: "string" },
+                reason: { type: "string" },
+            },
+            required: ["lesson_id"],
+        },
+    },
+    {
+        name: "lesson_supersede",
+        description: "Replace an old lesson with a newer one (old becomes 'superseded' and is linked).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                old_lesson_id: { type: "string" },
+                new_lesson_id: { type: "string" },
+            },
+            required: ["old_lesson_id", "new_lesson_id"],
+        },
+    },
 ];
-const server = new Server({ name: "claw-memory", version: "0.1.0" }, { capabilities: { tools: {} } });
+const server = new Server({ name: "claw-memory", version: "0.3.0" }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
 server.setRequestHandler(CallToolRequestSchema, async (req) => {
     const name = req.params.name;
@@ -248,6 +344,82 @@ async function dispatch(name, args) {
             });
             return `${total}件ヒット (上位${results.length}件表示):\n${lines.join("\n")}`;
         }
+        case "lesson_search": {
+            const project = projectFor(args.cwd);
+            const hits = await searchLessons(String(args.query ?? ""), { projectId: project.id }, { limit: args.limit ?? 5 });
+            if (hits.length === 0)
+                return "(該当なし)";
+            return hits
+                .map((l) => `- id=${l.id} [${l.scope}] (conf=${l.confidence.toFixed(2)} score=${l.score.toFixed(2)}) ${l.title}`)
+                .join("\n");
+        }
+        case "lesson_inject": {
+            const project = projectFor(args.cwd);
+            const block = await injectLessons(String(args.query ?? ""), { projectId: project.id }, { limit: args.limit ?? 5 });
+            return block || "(該当する approved lesson なし)";
+        }
+        case "lesson_get": {
+            const lesson = getLesson(String(args.lesson_id ?? ""));
+            if (!lesson)
+                return "(該当なし)";
+            const events = getEvents(lesson.id);
+            const links = getLinks(lesson.id);
+            const parts = [
+                `# ${lesson.title}`,
+                `id=${lesson.id} | scope=${lesson.scope} | status=${lesson.status} | confidence=${lesson.confidence.toFixed(2)}`,
+                `\n${lesson.lesson}`,
+                lesson.appliesWhen.length ? `\nApplies when:\n${lesson.appliesWhen.map((s) => `- ${s}`).join("\n")}` : "",
+                lesson.avoidWhen.length ? `\nAvoid when:\n${lesson.avoidWhen.map((s) => `- ${s}`).join("\n")}` : "",
+                lesson.evidence ? `\nEvidence: ${lesson.evidence}` : "",
+                lesson.concepts.length ? `\nConcepts: ${lesson.concepts.join(", ")}` : "",
+                lesson.files.length ? `\nFiles: ${lesson.files.join(", ")}` : "",
+                lesson.sessionId ? `\nSource session: ${lesson.sessionId}` : "",
+                events.length ? `\nHistory: ${events.map((e) => `${e.eventType}(${e.oldStatus ?? "-"}→${e.newStatus ?? "-"})`).join(", ")}` : "",
+                links.length ? `\nLinks: ${links.map((k) => `${k.relation}→${k.linkedLessonId === lesson.id ? k.lessonId : k.linkedLessonId}`).join(", ")}` : "",
+            ];
+            return parts.filter(Boolean).join("\n");
+        }
+        case "lesson_extract": {
+            const cwd = args.cwd ?? process.cwd();
+            if (isExcludedPath(cwd))
+                return JSON.stringify({ skipped: "excluded project" });
+            const project = getOrCreateProjectByPath(cwd);
+            const sessionId = args.sessionId ?? "";
+            const transcriptPath = args.transcriptPath ??
+                (sessionId ? resolveSessionJsonl(cwd, sessionId) : undefined);
+            if (!transcriptPath) {
+                throw new Error("lesson_extract requires sessionId or transcriptPath");
+            }
+            const messages = loadTranscript(transcriptPath)
+                .map((m) => ({ ...m, text: stripPrivate(m.text) }))
+                .filter((m) => m.text.trim());
+            const transcript = messages
+                .map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.text.slice(0, 500)}`)
+                .join("\n");
+            const candidates = await extractDedicated(transcript);
+            const ids = await saveCandidates({
+                projectId: project.id,
+                sessionId: sessionId || transcriptPath,
+                candidates,
+            });
+            return JSON.stringify({ extracted: candidates.length, saved: ids.length });
+        }
+        case "lesson_approve": {
+            const ok = setStatus(String(args.lesson_id ?? ""), "approved");
+            return ok ? "approved" : "(該当なし)";
+        }
+        case "lesson_reject": {
+            const ok = setStatus(String(args.lesson_id ?? ""), "rejected", args.reason);
+            return ok ? "rejected" : "(該当なし)";
+        }
+        case "lesson_archive": {
+            const ok = setStatus(String(args.lesson_id ?? ""), "archived", args.reason);
+            return ok ? "archived" : "(該当なし)";
+        }
+        case "lesson_supersede": {
+            const ok = supersede(String(args.old_lesson_id ?? ""), String(args.new_lesson_id ?? ""));
+            return ok ? "superseded" : "(該当なし)";
+        }
         default:
             throw new Error(`unknown tool: ${name}`);
     }