@nogataka/claw-memory 0.1.3 → 0.2.0

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,6 +127,98 @@ 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: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
@@ -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}`);
     }

package/dist/ui/page.js

@@ -42,17 +42,37 @@ export const PAGE = /* html */ `<!doctype html>
   .pref b { color:var(--accent); }
   .empty { color:var(--muted); padding:30px; text-align:center; }
   .cmeta { color:var(--muted); font-size:11px; margin:2px 0; word-break:break-all; }
-  header button#logsBtn { background:var(--chip); color:var(--fg); border:1px solid var(--border);
-    border-radius:6px; padding:6px 10px; cursor:pointer; font-size:12px; }
-  header button#logsBtn.on { background:var(--accent); color:#0d1117; border-color:var(--accent); }
+  header button#logsBtn, header button#lessonsBtn { background:var(--chip); color:var(--fg);
+    border:1px solid var(--border); border-radius:6px; padding:6px 10px; cursor:pointer; font-size:12px; }
+  header button#logsBtn.on, header button#lessonsBtn.on { background:var(--accent); color:#0d1117; border-color:var(--accent); }
   .src { color:var(--accent); font-size:10px; }
   .hl { background:#9e6a03; color:#fff; border-radius:2px; padding:0 1px; }
+  .lstatus { border-radius:4px; padding:1px 6px; font-size:10px; font-weight:600; }
+  .lstatus.candidate { background:#3a2d00; color:#e3b341; }
+  .lstatus.approved  { background:#03361a; color:#3fb950; }
+  .lstatus.rejected  { background:#3a0d0d; color:#f85149; }
+  .lstatus.archived  { background:#21262d; color:#8b949e; }
+  .lstatus.superseded{ background:#26203a; color:#a371f7; }
+  .lact { display:flex; flex-wrap:wrap; gap:6px; margin-top:10px; }
+  .lact button, .lact select { background:var(--chip); color:var(--fg); border:1px solid var(--border);
+    border-radius:6px; padding:4px 9px; cursor:pointer; font-size:11px; }
+  .lact button:hover { background:var(--accent); color:#0d1117; }
+  .lact button.danger:hover { background:#f85149; color:#fff; }
+  .lbody { white-space:pre-wrap; word-break:break-word; margin:6px 0; }
+  .lcond { font-size:12px; color:var(--muted); margin:3px 0; }
+  .lcond b { color:var(--fg); font-weight:600; }
+  .lhist { font-size:11px; color:var(--muted); margin-top:8px; border-top:1px solid var(--border); padding-top:6px; }
+  .lfilter { display:flex; gap:6px; margin-bottom:14px; flex-wrap:wrap; }
+  .lfilter button { background:var(--chip); color:var(--fg); border:1px solid var(--border);
+    border-radius:14px; padding:4px 12px; cursor:pointer; font-size:12px; }
+  .lfilter button.on { background:var(--accent); color:#0d1117; border-color:var(--accent); }
 </style>
 </head>
 <body>
 <header>
   <h1>🧠 claw-memory</h1>
   <span class="muted" id="stats"></span>
+  <button id="lessonsBtn" title="レッスン (再利用可能な知識のレビュー)">📚 Lessons</button>
   <button id="logsBtn" title="生ログ全文検索 (Claude Code + Codex)">🔎 ログ検索</button>
   <input id="search" placeholder="フィルタ (本文を絞り込み)" />
 </header>
@@ -90,13 +110,14 @@ function renderNav() {
     '<button data-id="'+p.id+'" class="'+(p.id===current?'active':'')+'">'
     + '<div class="nm">'+esc(p.name)+'</div>'
     + '<div class="pth">'+esc(p.path)+'</div>'
-    + '<div class="pth">'+p.counts.summaries+' sum · '+p.counts.chunks+' chunk · '+p.counts.preferences+' pref</div>'
+    + '<div class="pth">'+p.counts.summaries+' sum · '+p.counts.chunks+' chunk · '+p.counts.preferences+' pref · '+(p.counts.lessons||0)+' lesson</div>'
     + '</button>').join("");
   el("nav").querySelectorAll("button").forEach(b =>
     b.onclick = () => select(b.dataset.id));
 }
 async function select(id) {
   current = id; renderNav();
+  if (lessonMode) { loadLessons(); return; }
   const d = await (await fetch("/api/memory?project="+encodeURIComponent(id))).json();
   render(d);
 }
@@ -136,6 +157,7 @@ function currentPath() { const p = projects.find(x => x.id === current); return
 el("logsBtn").addEventListener("click", () => {
   logMode = !logMode;
   el("logsBtn").classList.toggle("on", logMode);
+  if (logMode && lessonMode) { lessonMode = false; el("lessonsBtn").classList.remove("on"); }
   el("search").value = "";
   el("search").placeholder = logMode
     ? "生ログ全文検索 (このプロジェクトのCC+Codexログ)"
@@ -175,6 +197,105 @@ async function runLogSearch(q) {
   el("main").innerHTML = '<div class="sect"><h2>Raw Log Search — ' + d.total + ' hits (showing ' + d.results.length + ')</h2>' + cards + '</div>';
 }
 
+// --- Lessons view ---------------------------------------------------------
+let lessonMode = false, lessonStatus = "candidate";
+const LSTATUSES = ["candidate","approved","conflicts","rejected","archived","superseded"];
+
+el("lessonsBtn").addEventListener("click", () => {
+  lessonMode = !lessonMode;
+  el("lessonsBtn").classList.toggle("on", lessonMode);
+  if (lessonMode && logMode) { logMode = false; el("logsBtn").classList.remove("on"); }
+  el("search").value = ""; filter = "";
+  el("search").placeholder = lessonMode ? "レッスンを絞り込み (本文)" : "フィルタ (本文を絞り込み)";
+  if (current) select(current);
+  else el("main").innerHTML = '<div class="empty">プロジェクトを選択してください</div>';
+});
+
+async function loadLessons() {
+  if (!current) return;
+  el("main").innerHTML = '<div class="empty">読み込み中…</div>';
+  const url = "/api/lessons?project=" + encodeURIComponent(current) + "&status=" + encodeURIComponent(lessonStatus);
+  let d;
+  try { d = await (await fetch(url)).json(); }
+  catch { el("main").innerHTML = '<div class="empty">読み込みに失敗しました</div>'; return; }
+  renderLessons(d);
+}
+
+function lfilterBar(counts) {
+  return '<div class="lfilter">' + LSTATUSES.map(s =>
+    '<button class="' + (s===lessonStatus?'on':'') + '" data-st="' + s + '">'
+    + s + ' (' + (counts[s]||0) + ')</button>').join("") + '</div>';
+}
+
+function renderLessons(d) {
+  const f = filter.toLowerCase();
+  const match = (t) => !f || (t||"").toLowerCase().includes(f);
+  const lessons = (d.lessons||[]).filter(l => match(l.title + " " + l.lesson));
+  const heading = lessonStatus === "candidate" ? "Candidate Review" : (lessonStatus + " lessons");
+  let h = lfilterBar(d.counts||{});
+  h += '<div class="sect"><h2>' + esc(heading) + '</h2>';
+  h += lessons.length ? lessons.map(lessonCard).join("") : '<div class="empty">該当するレッスンがありません</div>';
+  h += '</div>';
+  el("main").innerHTML = h;
+  el("main").querySelectorAll(".lfilter button").forEach(b =>
+    b.onclick = () => { lessonStatus = b.dataset.st; loadLessons(); });
+  bindLessonActions();
+}
+
+function lessonCard(l) {
+  const cond = (label, arr) => (arr && arr.length)
+    ? '<div class="lcond"><b>' + label + ':</b> ' + arr.map(esc).join("; ") + '</div>' : "";
+  const tags = [];
+  if (l.concepts && l.concepts.length) tags.push('🏷 ' + l.concepts.map(esc).join(", "));
+  if (l.files && l.files.length) tags.push('📄 ' + l.files.map(esc).join(", "));
+  return '<div class="card" data-id="' + l.id + '">'
+    + '<div class="meta">'
+    + '<span class="lstatus ' + esc(l.status) + '">' + esc(l.status) + '</span>'
+    + '<span class="tag">' + esc(l.scope) + '</span>'
+    + '<span class="tag">conf ' + Number(l.confidence).toFixed(2) + '</span>'
+    + (l.createdAt||"").split("T")[0] + '</div>'
+    + '<div class="u" style="font-weight:600">' + esc(l.title) + '</div>'
+    + '<div class="lbody">' + esc(l.lesson) + '</div>'
+    + cond("Applies when", l.appliesWhen)
+    + cond("Avoid when", l.avoidWhen)
+    + (l.evidence ? '<div class="lcond"><b>Evidence:</b> ' + esc(l.evidence) + '</div>' : "")
+    + (tags.length ? '<div class="cmeta">' + tags.join(" · ") + '</div>' : "")
+    + lessonActions(l)
+    + '</div>';
+}
+
+function lessonActions(l) {
+  const scopeOpts = ["global","project","repo","file","task","user_preference","team"]
+    .map(s => '<option ' + (s===l.scope?'selected':'') + '>' + s + '</option>').join("");
+  let btns = "";
+  if (l.status !== "approved") btns += '<button data-act="approve">✓ Approve</button>';
+  if (l.status !== "rejected") btns += '<button class="danger" data-act="reject">✕ Reject</button>';
+  if (l.status !== "archived") btns += '<button data-act="archive">🗄 Archive</button>';
+  btns += '<select data-act="scope" title="scope変更">' + scopeOpts + '</select>';
+  return '<div class="lact">' + btns + '</div>';
+}
+
+function bindLessonActions() {
+  el("main").querySelectorAll(".card[data-id]").forEach(card => {
+    const id = card.dataset.id;
+    card.querySelectorAll(".lact button").forEach(b =>
+      b.onclick = () => lessonAction(id, b.dataset.act));
+    const sel = card.querySelector('select[data-act="scope"]');
+    if (sel) sel.onchange = () => lessonAction(id, "scope", { scope: sel.value });
+  });
+}
+
+async function lessonAction(id, action, body) {
+  try {
+    await fetch("/api/lessons/" + encodeURIComponent(id) + "/" + action, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body||{}),
+    });
+  } catch { /* ignore */ }
+  loadLessons();
+}
+
 boot();
 connectEvents();
 </script>

package/dist/ui/server.js

@@ -10,6 +10,7 @@ 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 { listLessons, listConflicts, getConflictCount, getLesson, getLessonCount, getEvents, getLinks, setStatus, supersede, updateLesson, } from "../core/lessons.js";
 import { PAGE } from "./page.js";
 function countSummaries(projectId) {
     return sqlite
@@ -62,6 +63,7 @@ export function buildUiApp() {
                 summaries: countSummaries(p.id),
                 chunks: getChunkCount(p.id),
                 preferences: countPreferences(p.id),
+                lessons: getLessonCount({ projectId: p.id }),
             },
         }));
         return c.json(out);
@@ -76,6 +78,68 @@ export function buildUiApp() {
             chunks: listChunks(projectId, 300),
         });
     });
+    // --- Lesson layer -------------------------------------------------------
+    // The viewer is read-only for chunks/summaries, but lessons are reviewable:
+    // these POST routes are the only writes the UI performs, and only ever touch
+    // the lessons tables.
+    app.get("/api/lessons", (c) => {
+        const projectId = c.req.query("project") || undefined;
+        const status = c.req.query("status") || undefined;
+        // "conflicts" is a virtual view (lessons in a conflicts_with link), not a
+        // real status column value.
+        const lessons = status === "conflicts"
+            ? listConflicts(projectId, 500)
+            : listLessons({ projectId, status }, 500);
+        return c.json({
+            lessons,
+            counts: {
+                candidate: getLessonCount({ projectId, status: "candidate" }),
+                approved: getLessonCount({ projectId, status: "approved" }),
+                rejected: getLessonCount({ projectId, status: "rejected" }),
+                archived: getLessonCount({ projectId, status: "archived" }),
+                superseded: getLessonCount({ projectId, status: "superseded" }),
+                conflicts: getConflictCount(projectId),
+            },
+        });
+    });
+    app.get("/api/lessons/:id", (c) => {
+        const lesson = getLesson(c.req.param("id"));
+        if (!lesson)
+            return c.json({ error: "not found" }, 404);
+        return c.json({ lesson, events: getEvents(lesson.id), links: getLinks(lesson.id) });
+    });
+    app.post("/api/lessons/:id/:action", async (c) => {
+        const id = c.req.param("id");
+        const action = c.req.param("action");
+        const body = await c.req.json().catch(() => ({}));
+        let ok = false;
+        switch (action) {
+            case "approve":
+                ok = setStatus(id, "approved");
+                break;
+            case "reject":
+                ok = setStatus(id, "rejected", body.reason);
+                break;
+            case "archive":
+                ok = setStatus(id, "archived", body.reason);
+                break;
+            case "status":
+                ok = setStatus(id, body.status, body.note);
+                break;
+            case "scope":
+                ok = updateLesson(id, { scope: String(body.scope) });
+                break;
+            case "confidence":
+                ok = updateLesson(id, { confidence: Number(body.confidence) });
+                break;
+            case "supersede":
+                ok = supersede(id, String(body.newId));
+                break;
+            default:
+                return c.json({ error: "unknown action" }, 400);
+        }
+        return c.json({ ok }, ok ? 200 : 404);
+    });
     // Raw transcript search (cc-search port) — Claude Code + Codex logs.
     app.get("/api/logs", async (c) => {
         const query = c.req.query("q") ?? "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nogataka/claw-memory",
-  "version": "0.1.3",
+  "version": "0.2.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",