hypomnema 1.0.0

package/hooks/hypo-auto-commit.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * hypo-auto-commit.mjs — Stop hook
+ *
+ * At session end: stage all changes, commit if any, then pull+push to sync remote.
+ */
+
+import { spawnSync } from 'child_process';
+import { HYPO_DIR } from './hypo-shared.mjs';
+
+function git(...args) {
+  return spawnSync('git', ['-C', HYPO_DIR, ...args], { encoding: 'utf-8', timeout: 30000 });
+}
+
+function hasRemote() {
+  const r = git('remote');
+  return (r.stdout || '').trim().length > 0;
+}
+
+git('add', '-A');
+const staged = git('diff', '--cached', '--name-only').stdout?.trim() || '';
+if (staged) {
+  const today = new Date().toISOString().slice(0, 10);
+  const commit = git('commit', '-m', `auto: ${today} wiki update`);
+  if (commit.status !== 0) {
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+    process.exit(0);
+  }
+}
+
+if (hasRemote()) {
+  git('pull', '--no-rebase', '-q');
+  git('push');
+}
+
+console.log(JSON.stringify({ continue: true, suppressOutput: true }));

package/hooks/hypo-auto-stage.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+/**
+ * hypo-auto-stage.mjs — PostToolUse hook
+ *
+ * When a file inside the wiki directory is written, stage it automatically.
+ */
+
+import { spawnSync } from 'child_process';
+import { HYPO_DIR } from './hypo-shared.mjs';
+
+let input = {};
+try {
+  const raw = await new Promise(r => {
+    let d = '';
+    process.stdin.on('data', c => d += c);
+    process.stdin.on('end', () => r(d));
+  });
+  input = JSON.parse(raw);
+} catch {
+  console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+  process.exit(0);
+}
+
+const filePath = input.tool_input?.file_path ?? '';
+
+if (filePath.startsWith(HYPO_DIR + '/') || filePath === HYPO_DIR) {
+  spawnSync('git', ['-C', HYPO_DIR, 'add', filePath], { stdio: 'ignore' });
+}
+
+console.log(JSON.stringify({ continue: true, suppressOutput: true }));

package/hooks/hypo-compact-guard.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * hypo-compact-guard.mjs — UserPromptSubmit hook
+ *
+ * Scope: detects "/compact" typed in chat only.
+ * The CLI built-in /compact does NOT fire UserPromptSubmit — use personal-wiki-check.mjs
+ * (PreCompact hook) as the hard gate for that path.
+ *
+ * Behavior: if session close is incomplete → instruct Claude to run session close
+ * immediately before /compact.
+ */
+
+import {
+  lastSubstantialOpIsSession,
+  hypoIsClean,
+  hotMdIsClean,
+  readChecklist,
+  isCompactCommand,
+  isGateSkipped,
+} from './hypo-shared.mjs';
+
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const data   = JSON.parse(input);
+    const prompt = (data.prompt || '').trim();
+
+    if (!isCompactCommand(prompt) || isGateSkipped()) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    const hasSession = lastSubstantialOpIsSession();
+    const gitStatus  = hypoIsClean();
+    const hotStatus  = hotMdIsClean();
+
+    if (hasSession && gitStatus.clean && hotStatus.clean) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    const reasons = [
+      !hasSession      ? 'session log entry missing' : '',
+      !gitStatus.clean ? gitStatus.reason : '',
+      !hotStatus.clean ? hotStatus.reason : '',
+    ].filter(Boolean);
+
+    const today     = new Date().toISOString().slice(0, 10);
+    const checklist = readChecklist(today);
+    const body      = checklist
+      ? `Checklist:\n${checklist}`
+      : 'See hypo-guide.md for the session-close checklist.';
+
+    console.log(JSON.stringify({
+      continue: true,
+      additionalContext: [
+        `[WIKI_AUTOCLOSE] /compact detected — session close incomplete (${reasons.join(', ')}).`,
+        `Do NOT wait for user input. Run wiki session close NOW, then retry /compact.`,
+        ``,
+        body,
+        ``,
+        `To bypass: set HYPO_SKIP_GATE=1`,
+      ].join('\n'),
+    }));
+  } catch {
+    // Fail-open: any parse/runtime error must not block the user's prompt.
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+  }
+});

package/hooks/hypo-cwd-change.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+/**
+ * hypo-cwd-change.mjs — CwdChanged hook
+ *
+ * When the working directory changes mid-session, re-inject the matching
+ * project hot.md. Skips if still within the same project subtree.
+ */
+
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { HYPO_DIR, buildOutput } from './hypo-shared.mjs';
+
+const PROJECTS_DIR = join(HYPO_DIR, 'projects');
+const GLOBAL_HOT   = join(HYPO_DIR, 'hot.md');
+const MAX_CHARS    = 3000;
+
+function parseFrontmatterField(content, key) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return null;
+  const line = match[1].split('\n').find(l => l.startsWith(`${key}:`));
+  if (!line) return null;
+  return line.slice(key.length + 1).trim().replace(/^['"]|['"]$/g, '');
+}
+
+function findProjectHot(cwd) {
+  if (!existsSync(PROJECTS_DIR)) return null;
+  for (const proj of readdirSync(PROJECTS_DIR)) {
+    const projDir = join(PROJECTS_DIR, proj);
+    if (!statSync(projDir).isDirectory()) continue;
+    const indexPath = join(projDir, 'index.md');
+    if (!existsSync(indexPath)) continue;
+    const content    = readFileSync(indexPath, 'utf-8');
+    const workingDir = parseFrontmatterField(content, 'working_dir');
+    if (!workingDir) continue;
+    const resolved = workingDir.startsWith('~/')
+      ? join(homedir(), workingDir.slice(2))
+      : workingDir;
+    if (cwd === resolved || cwd.startsWith(resolved + '/')) {
+      const hotPath = join(projDir, 'hot.md');
+      return { proj, hotPath: existsSync(hotPath) ? hotPath : null, resolved };
+    }
+  }
+  return null;
+}
+
+let raw = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => raw += chunk);
+process.stdin.on('end', () => {
+  try {
+    let data = {};
+    try { data = JSON.parse(raw); } catch {}
+
+    const newCwd = data.new_cwd || data.new_directory || data.cwd || process.cwd();
+    const oldCwd = data.old_cwd || data.old_directory || data.previous_cwd || '';
+
+    // Skip re-injection if still in the same project
+    const oldHit = oldCwd ? findProjectHot(oldCwd) : null;
+    const newHit = findProjectHot(newCwd);
+
+    if (oldHit && newHit && oldHit.proj === newHit.proj) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    if (newHit) {
+      const content = newHit.hotPath
+        ? readFileSync(newHit.hotPath, 'utf-8').slice(0, MAX_CHARS)
+        : '(no hot.md yet — will be created at session close)';
+      console.log(JSON.stringify(
+        buildOutput(`[WIKI: cwd changed → project=${newHit.proj}]\n\n${content}`, { continue: true, suppressOutput: true })
+      ));
+      return;
+    }
+
+    if (!existsSync(GLOBAL_HOT)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    const globalContent = readFileSync(GLOBAL_HOT, 'utf-8').slice(0, MAX_CHARS);
+    console.log(JSON.stringify(
+      buildOutput(`[WIKI: cwd changed → no project match, injecting global hot]\n\n${globalContent}`, { continue: true, suppressOutput: true })
+    ));
+
+  } catch (err) {
+    process.stderr.write(`[wiki-cwd-change] error: ${err.message}\n`);
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+  }
+});

package/hooks/hypo-file-watch.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ * hypo-file-watch.mjs — FileChanged hook
+ *
+ * When a hot.md inside the wiki is modified externally (e.g. by a remote
+ * agent or another Claude Code session), re-inject its contents.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { HYPO_DIR } from './hypo-shared.mjs';
+
+const MAX_CHARS = 2000;
+
+let raw = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => raw += chunk);
+process.stdin.on('end', () => {
+  try {
+    let data = {};
+    try { data = JSON.parse(raw); } catch {}
+
+    const filePath = data.file_path || data.path || '';
+
+    if (!filePath.startsWith(HYPO_DIR + '/') && filePath !== HYPO_DIR) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    if (!existsSync(filePath)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    const content = readFileSync(filePath, 'utf-8').slice(0, MAX_CHARS);
+    const relPath = filePath.replace(HYPO_DIR + '/', '');
+
+    console.log(JSON.stringify({
+      continue: true,
+      suppressOutput: true,
+      additionalContext: `[WIKI FILE UPDATED: ${relPath}]\n\n${content}`,
+    }));
+
+  } catch {
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+  }
+});

package/hooks/hypo-first-prompt.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+/**
+ * hypo-first-prompt.mjs — UserPromptSubmit hook
+ *
+ * Consumes the marker written by wiki-session-start.mjs.
+ * On the FIRST user prompt of a new session, injects a lightweight decision
+ * instruction so the LLM can decide whether to announce the resume context.
+ *
+ * hot.md content is NOT re-injected here — wiki-session-start.mjs already
+ * injected it on SessionStart. Only the decision hint is added.
+ * Marker expires after 10 minutes.
+ */
+
+import { readFileSync, unlinkSync, existsSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { buildOutput } from './hypo-shared.mjs';
+
+const MARKER_TTL = 10 * 60 * 1000; // 10 min
+
+let raw = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => raw += chunk);
+process.stdin.on('end', () => {
+  try {
+    let data = {};
+    try { data = JSON.parse(raw); } catch {}
+    const sessionId = data.session_id || 'default';
+    const MARKER_FILE = join(tmpdir(), `hypo-session-marker-${sessionId}.json`);
+
+    if (!existsSync(MARKER_FILE)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    const marker = JSON.parse(readFileSync(MARKER_FILE, 'utf-8'));
+    const age    = Date.now() - (marker.ts || 0);
+
+    try { unlinkSync(MARKER_FILE); } catch {}
+
+    if (age > MARKER_TTL) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    const hasSnapshot  = marker.hasSnapshot ?? (marker.hotPath && existsSync(marker.hotPath));
+    const snapshotNote = hasSnapshot ? '' : ' (no snapshot yet — first session)';
+
+    console.log(JSON.stringify(
+      buildOutput(
+        `[WIKI SESSION START: project=${marker.proj}${snapshotNote}]\nDecision hint: if the first message relates to this project → answer first, then add one line "Previously working on ${marker.proj} — continue?" If unrelated / simple Q&A → answer only, no mention.`,
+        { continue: true, suppressOutput: true }
+      )
+    ));
+
+  } catch {
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+  }
+});

package/hooks/hypo-hot-rebuild.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+/**
+ * hypo-hot-rebuild.mjs — Stop hook
+ *
+ * Rebuilds root hot.md in canonical format on every session end.
+ * Preserves the project pointer table rows while refreshing dates
+ * from each project's hot.md frontmatter `updated:` field.
+ *
+ * Claude manages: adding/removing project rows in the pointer table.
+ * This script manages: frontmatter, H2 structure, date fields.
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { HYPO_DIR } from './hypo-shared.mjs';
+
+const HOT_PATH = join(HYPO_DIR, 'hot.md');
+
+function parseFrontmatter(content) {
+  const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return {};
+  const result = {};
+  for (const line of m[1].split('\n')) {
+    const kv = line.match(/^(\w[\w_-]*):\s*(.*)$/);
+    if (kv) result[kv[1]] = kv[2].trim();
+  }
+  return result;
+}
+
+function getProjectDate(slug) {
+  const hotPath = join(HYPO_DIR, 'projects', slug, 'hot.md');
+  if (!existsSync(hotPath)) return null;
+  try {
+    return parseFrontmatter(readFileSync(hotPath, 'utf-8')).updated || null;
+  } catch {
+    return null;
+  }
+}
+
+function parsePointerRows(content) {
+  const rows = [];
+  for (const line of content.split('\n')) {
+    const m = line.match(/^\|\s*(.+?)\s*\|\s*.+?\s*\|\s*\[\[projects\/(.+?)\/hot\]\]\s*\|/);
+    if (m) rows.push({ name: m[1].trim(), slug: m[2].trim() });
+  }
+  return rows;
+}
+
+function rebuild() {
+  if (!existsSync(HOT_PATH)) return;
+
+  const current = readFileSync(HOT_PATH, 'utf-8');
+  const rows = parsePointerRows(current);
+  if (rows.length === 0) return;
+
+  const today = new Date().toISOString().slice(0, 10);
+
+  const tableRows = rows.map(({ name, slug }) => {
+    const date = getProjectDate(slug) || today;
+    return `| ${name} | ${date} | [[projects/${slug}/hot]] |`;
+  }).join('\n');
+
+  const canonical = `---
+title: Hot Cache — Pointer
+type: reference
+updated: ${today}
+tags: [wiki, operations]
+---
+
+# Hot Cache
+
+> Read at session start → navigate to the relevant project session-state.md and hot.md.
+> Update at session close: project session-state.md, project hot.md, and this file's "Active Projects" table.
+
+## Active Projects
+
+| Project | Last Session | Hot Cache |
+|---|---|---|
+${tableRows}
+
+## Session Start Checklist
+
+1. Check this file for the relevant project link
+2. Read \`projects/<name>/session-state.md\` for next tasks if it exists
+3. Read \`projects/<name>/hot.md\` for project background
+`;
+
+  if (canonical !== current) writeFileSync(HOT_PATH, canonical);
+}
+
+try {
+  rebuild();
+} catch {}
+
+try { console.log(JSON.stringify({ continue: true, suppressOutput: true })); } catch {}

package/hooks/hypo-lookup.mjs

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+/**
+ * hypo-lookup.mjs — UserPromptSubmit hook
+ *
+ * On every user prompt:
+ *   1. Extract keywords from the prompt
+ *   2. BM25-score against ~/hypomnema/index.md entries
+ *   HIT  → read matched pages, inject as additionalContext
+ *   MISS → inject top-3 closest slugs as a research signal
+ */
+
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, basename } from 'path';
+import { HYPO_DIR, buildOutput, loadHypoIgnore, isIgnored } from './hypo-shared.mjs';
+
+const INDEX_PATH = join(HYPO_DIR, 'index.md');
+const MAX_HITS   = 3;
+const MAX_CHARS  = 2000;
+
+// ── helpers ─────────────────────────────────────────────────────────────────
+
+function buildPageMap(dir, root = dir, map = {}, ignorePatterns = [], hypoDir = root) {
+  if (!existsSync(dir)) return map;
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (isIgnored(full, hypoDir, ignorePatterns)) continue;
+    if (statSync(full).isDirectory()) {
+      buildPageMap(full, root, map, ignorePatterns, hypoDir);
+    } else if (entry.endsWith('.md')) {
+      const rel = full.slice(root.length + 1).replace(/\.md$/, '');
+      map[rel] = full;
+      const bare = basename(entry, '.md');
+      if (!map[bare]) map[bare] = full;
+    }
+  }
+  return map;
+}
+
+function extractKeywords(prompt) {
+  const stop = new Set([
+    'the','and','for','with','this','that','have','from','are','was','were',
+    'what','when','where','how','why','who','can','could','should','would',
+    'does','did','will','not','but','its','also','just','more','any','all',
+    '어떤','어떻게','무엇','이런','그런','하는','하고','해서','있어','없어',
+    '되는','이거','저거','그거','이건','그건','저건','같은','하면','되면',
+    '인지','에서','으로','까지','부터','에게','한테','에도','에만','에는',
+  ]);
+  return [...new Set(
+    prompt.toLowerCase()
+      .split(/[\s,，.。?？!！()\[\]{}'"\/\\:;=+*&%$#@~`|<>]+/)
+      .filter(w => w.length >= 3 && !stop.has(w))
+  )];
+}
+
+function tokenize(text) {
+  return text.toLowerCase()
+    .split(/[\s\-_/.,，。?？!！()\[\]{}'"\\:;=+*&%$#@~`|<>]+/)
+    .filter(w => w.length >= 2);
+}
+
+function bm25Score(queryTerms, entries, k1 = 1.5, b = 0.75) {
+  const N = entries.length;
+  if (N === 0) return [];
+  const docTokens = entries.map(e => tokenize(e.slug + ' ' + e.desc));
+  const avgdl = docTokens.reduce((s, t) => s + t.length, 0) / N;
+  const df = {};
+  for (const tokens of docTokens) {
+    for (const t of new Set(tokens)) df[t] = (df[t] || 0) + 1;
+  }
+  const idf = t => Math.log(1 + (N - (df[t] || 0) + 0.5) / ((df[t] || 0) + 0.5));
+
+  return entries.map((e, i) => {
+    const tokens = docTokens[i];
+    const dl = tokens.length || 1;
+    const tf = {};
+    for (const t of tokens) tf[t] = (tf[t] || 0) + 1;
+    let score = 0;
+    for (const q of queryTerms) {
+      const f = tf[q] || 0;
+      if (f === 0) continue;
+      const norm = 1 - b + b * dl / avgdl;
+      score += idf(q) * (f * (k1 + 1)) / (f + k1 * norm);
+    }
+    return { ...e, score };
+  }).sort((a, c) => c.score - a.score);
+}
+
+function parseIndexEntries(indexContent) {
+  const entries = [];
+  for (const line of indexContent.split('\n')) {
+    if (line.trimStart().startsWith('<!--')) continue;
+    if (line.trimStart().startsWith('>')) continue;
+    const m = line.match(/\[\[([^\]]+)\]\]\s*[—\-]+\s*(.+)/);
+    if (!m) continue;
+    const raw  = m[1].trim();
+    const desc = m[2].trim();
+    const slug = raw.includes('|') ? raw.split('|')[0].trim() : raw;
+    entries.push({ slug, desc });
+  }
+  return entries;
+}
+
+// ── main ─────────────────────────────────────────────────────────────────────
+
+let input = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data   = JSON.parse(input);
+    const prompt = (data.prompt || '').trim();
+
+    if (!prompt || !existsSync(INDEX_PATH)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    const keywords = extractKeywords(prompt);
+    if (keywords.length === 0) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    const entries  = parseIndexEntries(readFileSync(INDEX_PATH, 'utf-8'));
+    const scored   = bm25Score(keywords, entries).filter(e => e.score > 0);
+    const topScore = scored[0]?.score ?? 0;
+    const matched  = scored.filter(e => e.score >= topScore * 0.5);
+
+    if (matched.length === 0) {
+      const topic   = keywords.slice(0, 5).join(', ');
+      const closest = bm25Score(keywords, entries).slice(0, 3).map(e => `[[${e.slug}]]`).join(', ');
+      console.log(JSON.stringify(
+        buildOutput(
+          `[WIKI LOOKUP: miss] "${topic}" — no match. Closest: ${closest || 'none'}`,
+          { continue: true, suppressOutput: true }
+        )
+      ));
+      return;
+    }
+
+    const ignorePatterns = loadHypoIgnore(HYPO_DIR);
+    const pageMap = {
+      ...buildPageMap(join(HYPO_DIR, 'pages'), join(HYPO_DIR, 'pages'), {}, ignorePatterns, HYPO_DIR),
+      ...buildPageMap(join(HYPO_DIR, 'projects'), join(HYPO_DIR, 'projects'), {}, ignorePatterns, HYPO_DIR),
+    };
+
+    const injected = [];
+    for (const { slug } of matched.slice(0, MAX_HITS)) {
+      const path = pageMap[slug]
+        ?? pageMap[slug.replace(/^(pages|projects)\//, '')]
+        ?? pageMap[basename(slug)];
+      if (path && existsSync(path)) {
+        injected.push(`=== [[${slug}]] ===\n${readFileSync(path, 'utf-8').slice(0, MAX_CHARS)}`);
+      }
+    }
+
+    if (injected.length === 0) {
+      const slugs = matched.slice(0, MAX_HITS).map(e => e.slug).join(', ');
+      console.log(JSON.stringify(
+        buildOutput(`[WIKI LOOKUP: index hit but files missing] ${slugs}`, { continue: true, suppressOutput: true })
+      ));
+      return;
+    }
+
+    const overflow = matched.length > MAX_HITS
+      ? `\n(+${matched.length - MAX_HITS} more matches — search wiki index for more)` : '';
+
+    console.log(JSON.stringify(
+      buildOutput(
+        `[WIKI LOOKUP: ${injected.length} page(s) matched]\n\n` + injected.join('\n\n') + overflow,
+        { continue: true, suppressOutput: true }
+      )
+    ));
+
+  } catch {
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+  }
+});