oh-my-adhd 0.2.10 → 0.2.11

package/dist/mcp/lib/brain.js

@@ -14,6 +14,14 @@ export const SCHEMA_VERSION = 1;
 async function appendLog(level, msg) {
     try {
         const entry = `${new Date().toISOString()} [${level}] ${msg}\n`;
+        // Rotate log at 10MB
+        try {
+            const stat = await fs.stat(LOG_FILE);
+            if (stat.size > 10 * 1024 * 1024) {
+                await fs.rename(LOG_FILE, LOG_FILE + ".1").catch(() => { });
+            }
+        }
+        catch { /* file may not exist yet */ }
         await fs.appendFile(LOG_FILE, entry, "utf-8");
     }
     catch { /* logging failures must never crash the server */ }
@@ -218,7 +226,13 @@ export async function saveCapture(content, threadId) {
             manifest.push(meta);
         await writeManifest(manifest.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()));
         // Session-scoped dump marker for stop-hook
-        await fs.writeFile(path.join(BRAIN_DIR, ".last-dump"), String(Date.now()), "utf-8").catch(() => { });
+        let sid = "";
+        try {
+            sid = (await fs.readFile(path.join(BRAIN_DIR, ".session-current"), "utf-8")).trim();
+        }
+        catch { }
+        const lastDumpFile = path.join(BRAIN_DIR, sid ? `.last-dump-${sid}` : ".last-dump");
+        await fs.writeFile(lastDumpFile, String(Date.now()), "utf-8").catch(() => { });
     });
     return { capture, threadId: tid, title, skipped };
 }

package/dist/mcp/mcp/server.js

@@ -15,9 +15,10 @@ import { registerWikiStructure } from "./tools/wiki-structure.js";
 import { registerWikiSave } from "./tools/wiki-save.js";
 import { registerWikiDelete } from "./tools/wiki-delete.js";
 import { registerWikiExport } from "./tools/wiki-export.js";
+import { registerWikiImport } from "./tools/wiki-import.js";
 const server = new McpServer({
     name: "oh-my-adhd",
-    version: "0.2.0",
+    version: "0.2.11",
 });
 registerWikiDump(server);
 registerWikiRecall(server);
@@ -31,6 +32,7 @@ registerWikiStructure(server);
 registerWikiSave(server);
 registerWikiDelete(server);
 registerWikiExport(server);
+registerWikiImport(server);
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/mcp/mcp/tools/wiki-dump.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
-import { saveCapture, getThread, getThreads } from "../../lib/brain.js";
+import fs from "fs/promises";
+import path from "path";
+import { saveCapture, getThread, getThreads, BRAIN_DIR } from "../../lib/brain.js";
 import { findRelatedPages, upsertPageFromCapture } from "../../lib/linker.js";
 import { captureGitContext } from "../utils.js";
 export function registerWikiDump(server) {
@@ -70,9 +72,14 @@ export function registerWikiDump(server) {
                 if (todayCount >= 2)
                     respLines[0] = `저장됨 ✓ (오늘 ${todayCount}번째 🔥)`;
             }
-            // Only nag if user has NEVER successfully used structured schema — avoids repeated noise
-            const hasEverStructured = allThreads.some(t => t.id === result.threadId && (t.next_action || t.blocker));
-            if (!isStructured && !result.skipped && !hasEverStructured) {
+            // Only nag once — user can dismiss permanently by touching .nag-dismissed
+            let nagDismissed = false;
+            try {
+                await fs.access(path.join(BRAIN_DIR, ".nag-dismissed"));
+                nagDismissed = true;
+            }
+            catch { }
+            if (!isStructured && !result.skipped && !nagDismissed) {
                 respLines.push("");
                 respLines.push("💡 다음번엔 이 형식으로 쓰면 다음 세션에서 더 잘 복원돼:");
                 respLines.push("```");

package/dist/mcp/mcp/tools/wiki-import.js

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import { ensureBrainDirs, BRAIN_DIR, SCHEMA_VERSION } from "../../lib/brain.js";
+import fs from "fs/promises";
+import path from "path";
+export function registerWikiImport(server) {
+    server.tool("wiki_import", "wiki_export로 내보낸 JSON 백업 파일을 가져온다. 기존 데이터와 병합(merge)하며 중복 thread ID는 덮어쓴다.", {
+        inputPath: z.string().describe("가져올 .json 파일 경로 (wiki_export로 생성된 파일)"),
+        overwrite: z.boolean().optional().describe("true이면 같은 ID의 스레드를 덮어씀 (기본값: true)"),
+    }, async ({ inputPath, overwrite = true }) => {
+        try {
+            const resolved = path.resolve(inputPath);
+            if (!resolved.endsWith(".json")) {
+                return {
+                    content: [{ type: "text", text: "오류: inputPath는 .json 확장자로 끝나야 합니다." }],
+                    isError: true,
+                };
+            }
+            let raw;
+            try {
+                raw = await fs.readFile(resolved, "utf-8");
+            }
+            catch {
+                return {
+                    content: [{ type: "text", text: `오류: 파일을 읽을 수 없습니다: ${resolved}` }],
+                    isError: true,
+                };
+            }
+            let exportData;
+            try {
+                exportData = JSON.parse(raw);
+            }
+            catch {
+                return {
+                    content: [{ type: "text", text: "오류: JSON 파싱 실패. wiki_export로 생성된 파일인지 확인하세요." }],
+                    isError: true,
+                };
+            }
+            if (!exportData.threads || !Array.isArray(exportData.threads)) {
+                return {
+                    content: [{ type: "text", text: "오류: 유효하지 않은 내보내기 파일 형식입니다." }],
+                    isError: true,
+                };
+            }
+            if (exportData.schemaVersion && exportData.schemaVersion !== SCHEMA_VERSION) {
+                return {
+                    content: [{ type: "text", text: `오류: 스키마 버전 불일치 (파일: ${exportData.schemaVersion}, 현재: ${SCHEMA_VERSION})` }],
+                    isError: true,
+                };
+            }
+            await ensureBrainDirs();
+            const threadsDir = path.join(BRAIN_DIR, "threads");
+            const pagesDir = path.join(BRAIN_DIR, "pages");
+            const manifestFile = path.join(threadsDir, ".manifest.json");
+            // Load existing manifest
+            let manifest = [];
+            try {
+                manifest = JSON.parse(await fs.readFile(manifestFile, "utf-8"));
+            }
+            catch { /* start fresh if missing */ }
+            const existingIds = new Set(manifest.map(m => m.id));
+            let importedThreads = 0;
+            let skippedThreads = 0;
+            for (const thread of exportData.threads) {
+                if (!thread.id || !thread.title)
+                    continue;
+                if (!overwrite && existingIds.has(thread.id)) {
+                    skippedThreads++;
+                    continue;
+                }
+                // Write thread file
+                if (thread.content) {
+                    const threadFile = path.join(threadsDir, `${thread.id}.md`);
+                    const tmp = threadFile + ".tmp";
+                    await fs.writeFile(tmp, thread.content, "utf-8");
+                    await fs.rename(tmp, threadFile);
+                }
+                // Update manifest entry
+                const { content: _c, ...meta } = thread;
+                const idx = manifest.findIndex(m => m.id === thread.id);
+                if (idx >= 0)
+                    manifest[idx] = meta;
+                else
+                    manifest.push(meta);
+                importedThreads++;
+            }
+            // Write updated manifest atomically
+            const tmp = manifestFile + ".tmp";
+            await fs.writeFile(tmp, JSON.stringify(manifest, null, 2), "utf-8");
+            await fs.rename(tmp, manifestFile);
+            // Import pages if present
+            let importedPages = 0;
+            if (exportData.pages && Array.isArray(exportData.pages)) {
+                for (const page of exportData.pages) {
+                    if (!page.slug || !page.content)
+                        continue;
+                    const pageFile = path.join(pagesDir, `${page.slug}.md`);
+                    const tmp2 = pageFile + ".tmp";
+                    await fs.writeFile(tmp2, page.content, "utf-8");
+                    await fs.rename(tmp2, pageFile);
+                    importedPages++;
+                }
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            "가져오기 완료 ✓",
+                            `스레드: ${importedThreads}개 가져옴${skippedThreads > 0 ? ` (${skippedThreads}개 건너뜀)` : ""}`,
+                            `페이지: ${importedPages}개 가져옴`,
+                            `원본 파일: ${resolved}`,
+                        ].join("\n"),
+                    }],
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `오류: ${e.message ?? String(e)}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-adhd",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "description": "ADHD second brain — zero-friction capture, auto context restore, unstick. MCP-native Claude Code plugin.",
   "author": "Yeachan Heo",
   "repository": {

package/scripts/session-recall.mjs

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
-// SessionStart hook — writes .session-start timestamp + injects recall context as additionalContext
+// SessionStart hook — writes session marker + injects recall context as additionalContext
 import { readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 
 const BRAIN_DIR = process.env.OH_MY_ADHD_DIR ?? join(homedir(), ".oh-my-adhd");
-const SESSION_START_FILE = join(BRAIN_DIR, ".session-start");
 const MANIFEST = join(BRAIN_DIR, "threads", ".manifest.json");
 
-// Always write session start timestamp first
+// Generate unique session ID and write per-session start marker
 try {
   mkdirSync(BRAIN_DIR, { recursive: true });
-  writeFileSync(SESSION_START_FILE, String(Date.now()));
+  const sid = Math.random().toString(36).slice(2, 14) + Date.now().toString(36);
+  writeFileSync(join(BRAIN_DIR, `.session-start-${sid}`), String(Date.now()));
+  writeFileSync(join(BRAIN_DIR, ".session-current"), sid);
 } catch { /* non-fatal */ }
 
 // Build recall context from manifest
@@ -31,7 +32,6 @@ try {
   const openThreads = manifest.filter(t => t.is_open).slice(0, 4);
   if (openThreads.length === 0) process.exit(0);
 
-  // Sanitize stored content before injecting into model context (prompt injection prevention)
   const sanitize = (s, max) => String(s ?? "")
     .replace(/[\x00-\x1F\x7F]/g, " ")
     .replace(/[`$<>]/g, "")
@@ -55,8 +55,14 @@ try {
   lines.push("");
   lines.push(`이어서 갈까? thread: \`${top.id}\``);
 
-  process.stdout.write(JSON.stringify({ additionalContext: lines.join("\n") }));
+  // Cap additionalContext to prevent context bloat
+  const MAX_CHARS = 3500;
+  const context = lines.join("\n");
+  const capped = context.length > MAX_CHARS
+    ? context.slice(0, MAX_CHARS) + "\n...[더 보려면 wiki_query 사용]"
+    : context;
+
+  process.stdout.write(JSON.stringify({ additionalContext: capped }));
 } catch {
-  // No manifest / parse error — graceful degradation, never block session start
   process.exit(0);
 }

package/scripts/stop-hook.mjs

@@ -1,23 +1,47 @@
 #!/usr/bin/env node
 // oh-my-adhd Stop hook — blocks session end if no wiki_dump happened this session
-import { readFileSync } from "fs";
+import { readFileSync, readdirSync, unlinkSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 
+// Escape hatch: OMC_FORCE_EXIT=1 bypasses the block
+if (process.env.OMC_FORCE_EXIT === "1") process.exit(0);
+
 const BRAIN_DIR = process.env.OH_MY_ADHD_DIR ?? join(homedir(), ".oh-my-adhd");
 const MANIFEST = join(BRAIN_DIR, "threads", ".manifest.json");
-const SESSION_START_FILE = join(BRAIN_DIR, ".session-start");
-const LAST_DUMP_FILE = join(BRAIN_DIR, ".last-dump");
+const SESSION_CURRENT = join(BRAIN_DIR, ".session-current");
+
+// Clean up stale per-session files (>24h old)
+try {
+  const files = readdirSync(BRAIN_DIR);
+  const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+  for (const f of files) {
+    if (/^\.(session-start-|last-dump-)/.test(f)) {
+      try {
+        const content = readFileSync(join(BRAIN_DIR, f), "utf-8").trim();
+        const ts = parseInt(content, 10);
+        if (!isNaN(ts) && ts < cutoff) unlinkSync(join(BRAIN_DIR, f));
+      } catch { /* best-effort */ }
+    }
+  }
+} catch { /* never block on cleanup */ }
 
 try {
+  // Read current session ID written by session-recall.mjs
+  let sid = "";
+  try { sid = readFileSync(SESSION_CURRENT, "utf-8").trim(); } catch {}
+
+  const SESSION_START_FILE = join(BRAIN_DIR, sid ? `.session-start-${sid}` : ".session-start");
+  const LAST_DUMP_FILE = join(BRAIN_DIR, sid ? `.last-dump-${sid}` : ".last-dump");
+
   const sessionStartMs = parseInt(readFileSync(SESSION_START_FILE, "utf-8").trim(), 10);
   if (isNaN(sessionStartMs)) process.exit(0); // no marker — don't block
 
-  // Session-scoped check: did wiki_dump run after this session started?
+  // Allow stop if wiki_dump was called this session
   try {
     const lastDumpMs = parseInt(readFileSync(LAST_DUMP_FILE, "utf-8").trim(), 10);
     if (!isNaN(lastDumpMs) && lastDumpMs > sessionStartMs) process.exit(0);
-  } catch { /* .last-dump missing = no dump this session */ }
+  } catch { /* no dump file = no dump this session */ }
 
   let manifest;
   try {
@@ -30,7 +54,6 @@ try {
   const openThreads = manifest.filter(t => t.is_open);
   if (openThreads.length > 0) {
     const top = openThreads[0];
-    // Sanitize: strip control chars and injection-shaped strings before embedding in model-facing text
     const sanitize = (s, max) => String(s ?? "")
       .replace(/[\x00-\x1F\x7F]/g, " ")
       .replace(/[`$<>]/g, "")
@@ -40,7 +63,7 @@ try {
     const nextHint = top.next_action ? `\n→ 다음할것: ${sanitize(top.next_action, 60)}` : "";
     process.stdout.write(JSON.stringify({
       decision: "block",
-      reason: `저장 없이 끝내려고? "${title}" 스레드가 열려있어.${nextHint}\nwiki_dump로 결정/막힌것/다음할것 저장하고 끝내자.`,
+      reason: `저장 없이 끝내려고? "${title}" 스레드가 열려있어.${nextHint}\nwiki_dump로 결정/막힌것/다음할것 저장하고 끝내자.\n(강제 종료: OMC_FORCE_EXIT=1 설정)`,
     }));
   }
 } catch {