@stackmemoryai/stackmemory 1.10.3 → 1.10.4

package/dist/src/utils/hook-installer.js

@@ -82,6 +82,13 @@ const CANONICAL_HOOKS = [
     timeout: 2,
     commandPrefix: "node",
     required: false
+  },
+  {
+    scriptName: "wiki-update.js",
+    eventType: "Stop",
+    timeout: 10,
+    commandPrefix: "node",
+    required: false
   }
 ];
 const DEAD_HOOKS = ["sms-response-handler.js"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.10.3",
+  "version": "1.10.4",
   "description": "Lossless, project-scoped memory for AI coding tools. Durable context across sessions with 56 MCP tools, FTS5 search, conductor orchestrator, loop/watch monitoring, snapshot capture, pre-flight overlap checks, Claude/Codex/OpenCode wrappers, Linear sync, and automatic hooks.",
   "engines": {
     "node": ">=20.0.0",

package/templates/claude-hooks/wiki-update.js

@@ -0,0 +1,373 @@
+#!/usr/bin/env node
+
+/**
+ * Wiki Update Hook
+ *
+ * Fires on session stop. Incrementally compiles new context (frames,
+ * entity states, anchors) into the wiki since the last compile.
+ *
+ * Works in any repo with StackMemory initialized + Obsidian configured:
+ *   - .stackmemory/context.db must exist
+ *   - .stackmemory/config.yaml must have obsidian.vaultPath
+ *
+ * The hook is lightweight: reads last compile timestamp from wiki/log.md,
+ * queries only new context, and writes updated .md articles.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const HOME = process.env.HOME || '/tmp';
+
+function main() {
+  try {
+    const cwd = process.cwd();
+
+    // 1. Check if StackMemory is initialized
+    const dbPath = path.join(cwd, '.stackmemory', 'context.db');
+    if (!fs.existsSync(dbPath)) return;
+
+    // 2. Check if Obsidian vault is configured
+    const configPath = path.join(cwd, '.stackmemory', 'config.yaml');
+    if (!fs.existsSync(configPath)) return;
+
+    const configContent = fs.readFileSync(configPath, 'utf-8');
+    const vaultMatch = configContent.match(
+      /obsidian:\s*\n\s+vaultPath:\s*["']?([^\n"']+)/
+    );
+    if (!vaultMatch) return;
+
+    const vaultPath = vaultMatch[1].trim();
+    if (!fs.existsSync(vaultPath)) return;
+
+    const subdirMatch = configContent.match(
+      /obsidian:\s*\n(?:\s+\w+:.*\n)*\s+subdir:\s*["']?([^\n"']+)/
+    );
+    const subdir = subdirMatch ? subdirMatch[1].trim() : 'stackmemory';
+    const wikiDir = path.join(vaultPath, subdir, 'wiki');
+
+    // 3. Ensure wiki directory exists
+    const dirs = [
+      wikiDir,
+      path.join(wikiDir, 'entities'),
+      path.join(wikiDir, 'concepts'),
+      path.join(wikiDir, 'sources'),
+      path.join(wikiDir, 'synthesis'),
+    ];
+    for (const dir of dirs) {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+
+    // 4. Get last compile time from log.md
+    const logPath = path.join(wikiDir, 'log.md');
+    let sinceEpoch = 0;
+    if (fs.existsSync(logPath)) {
+      const logContent = fs.readFileSync(logPath, 'utf-8');
+      const entries = logContent.match(/^## \[(\d{4}-\d{2}-\d{2})\]/gm);
+      if (entries && entries.length > 0) {
+        const last = entries[entries.length - 1];
+        const dateMatch = last.match(/\[(\d{4}-\d{2}-\d{2})\]/);
+        if (dateMatch) {
+          sinceEpoch = Math.floor(
+            new Date(dateMatch[1] + 'T00:00:00Z').getTime() / 1000
+          );
+        }
+      }
+    }
+
+    // 5. Open database and query new context
+    let Database;
+    try {
+      Database = require('better-sqlite3');
+    } catch {
+      // better-sqlite3 not available in this context
+      return;
+    }
+
+    const db = new Database(dbPath, { readonly: true });
+
+    const digests = db
+      .prepare(
+        `SELECT frame_id, name as frame_name, type as frame_type,
+                digest_text, created_at, closed_at
+         FROM frames
+         WHERE state = 'closed' AND digest_text IS NOT NULL
+           AND created_at >= ?
+         ORDER BY created_at DESC
+         LIMIT 100`
+      )
+      .all(sinceEpoch);
+
+    const entities = db
+      .prepare(
+        `SELECT entity_name, relation, value, context,
+                source_frame_id, valid_from, superseded_at
+         FROM entity_states
+         WHERE valid_from >= ?
+         ORDER BY valid_from DESC
+         LIMIT 500`
+      )
+      .all(sinceEpoch);
+
+    const anchors = db
+      .prepare(
+        `SELECT a.anchor_id, a.frame_id, f.name as frame_name,
+                a.type, a.text, a.priority, a.created_at
+         FROM anchors a
+         JOIN frames f ON f.frame_id = a.frame_id
+         WHERE a.created_at >= ?
+         ORDER BY a.created_at DESC
+         LIMIT 500`
+      )
+      .all(sinceEpoch);
+
+    db.close();
+
+    // 6. Skip if nothing new
+    if (digests.length === 0 && entities.length === 0 && anchors.length === 0) {
+      return;
+    }
+
+    // 7. Write source articles for new digests
+    let created = 0;
+    let updated = 0;
+
+    for (const d of digests) {
+      const slug = slugify(d.frame_name);
+      const filePath = path.join(wikiDir, 'sources', slug + '.md');
+      if (fs.existsSync(filePath)) continue;
+
+      const content = [
+        '---',
+        `title: "${escapeYaml(d.frame_name)}"`,
+        `category: source`,
+        `frame_id: "${d.frame_id}"`,
+        `frame_type: "${d.frame_type}"`,
+        `created: ${new Date(d.created_at * 1000).toISOString()}`,
+        `updated: ${new Date().toISOString()}`,
+        `tags: [source, ${d.frame_type}]`,
+        '---',
+        '',
+        `# ${d.frame_name}`,
+        '',
+        `> Frame \`${d.frame_id.slice(0, 8)}\` | Type: ${d.frame_type}`,
+        '',
+        '## Summary',
+        '',
+        d.digest_text || 'No digest.',
+        '',
+      ].join('\n');
+
+      fs.writeFileSync(filePath, content);
+      created++;
+    }
+
+    // 8. Write/update entity pages
+    const entitiesByName = {};
+    for (const e of entities) {
+      if (!entitiesByName[e.entity_name]) entitiesByName[e.entity_name] = [];
+      entitiesByName[e.entity_name].push(e);
+    }
+
+    for (const [name, states] of Object.entries(entitiesByName)) {
+      const slug = slugify(name);
+      const filePath = path.join(wikiDir, 'entities', slug + '.md');
+
+      if (!fs.existsSync(filePath)) {
+        const current = states.filter((s) => s.superseded_at === null);
+        const lines = [
+          '---',
+          `title: "${escapeYaml(name)}"`,
+          `category: entity`,
+          `created: ${new Date().toISOString()}`,
+          `updated: ${new Date().toISOString()}`,
+          `tags: [entity]`,
+          '---',
+          '',
+          `# ${name}`,
+          '',
+          '## Current State',
+          '',
+        ];
+        for (const s of current) {
+          lines.push(`- **${s.relation}**: ${s.value}`);
+          if (s.context) lines.push(`  - _Context: ${s.context}_`);
+        }
+        lines.push('');
+        fs.writeFileSync(filePath, lines.join('\n'));
+        created++;
+      } else {
+        // Append new states
+        let content = fs.readFileSync(filePath, 'utf-8');
+        let changed = false;
+        for (const s of states) {
+          if (content.includes(s.value)) continue;
+          const entry = `- **${s.relation}**: ${s.value}`;
+          content = content.trimEnd() + '\n' + entry + '\n';
+          changed = true;
+        }
+        if (changed) {
+          content = content.replace(
+            /updated:\s*.+/,
+            `updated: ${new Date().toISOString()}`
+          );
+          fs.writeFileSync(filePath, content);
+          updated++;
+        }
+      }
+    }
+
+    // 9. Write/update concept pages from anchors
+    const conceptMap = {
+      DECISION: 'Decisions',
+      FACT: 'Key Facts',
+      CONSTRAINT: 'Constraints',
+      RISK: 'Risks',
+      TODO: 'Action Items',
+      INTERFACE_CONTRACT: 'Interface Contracts',
+    };
+
+    const conceptGroups = {};
+    for (const a of anchors) {
+      const concept = conceptMap[a.type] || 'Notes';
+      if (!conceptGroups[concept]) conceptGroups[concept] = [];
+      conceptGroups[concept].push(a);
+    }
+
+    for (const [concept, items] of Object.entries(conceptGroups)) {
+      const slug = slugify(concept);
+      const filePath = path.join(wikiDir, 'concepts', slug + '.md');
+
+      if (!fs.existsSync(filePath)) {
+        const lines = [
+          '---',
+          `title: "${escapeYaml(concept)}"`,
+          `category: concept`,
+          `created: ${new Date().toISOString()}`,
+          `updated: ${new Date().toISOString()}`,
+          `tags: [concept]`,
+          '---',
+          '',
+          `# ${concept}`,
+          '',
+        ];
+        for (const a of items) {
+          const date = new Date(a.created_at * 1000).toISOString().slice(0, 10);
+          lines.push(
+            `- ${a.text}`,
+            `  - _${date} — from [[sources/${slugify(a.frame_name)}]]_`
+          );
+        }
+        lines.push('');
+        fs.writeFileSync(filePath, lines.join('\n'));
+        created++;
+      } else {
+        let content = fs.readFileSync(filePath, 'utf-8');
+        let changed = false;
+        for (const a of items) {
+          if (content.includes(a.text)) continue;
+          const date = new Date(a.created_at * 1000).toISOString().slice(0, 10);
+          const entry = `- ${a.text}\n  - _${date} — from [[sources/${slugify(a.frame_name)}]]_`;
+          content = content.trimEnd() + '\n' + entry + '\n';
+          changed = true;
+        }
+        if (changed) {
+          content = content.replace(
+            /updated:\s*.+/,
+            `updated: ${new Date().toISOString()}`
+          );
+          fs.writeFileSync(filePath, content);
+          updated++;
+        }
+      }
+    }
+
+    // 10. Update index.md
+    updateIndex(wikiDir);
+
+    // 11. Append to log.md
+    if (created > 0 || updated > 0) {
+      const now = new Date().toISOString().slice(0, 10);
+      const logEntry = `\n## [${now}] auto-update | session stop\n${created} created, ${updated} updated from ${digests.length} digests, ${entities.length} entities, ${anchors.length} anchors\n`;
+
+      if (fs.existsSync(logPath)) {
+        fs.appendFileSync(logPath, logEntry);
+      } else {
+        fs.writeFileSync(
+          logPath,
+          '# Wiki Log\n\n> Chronological record of wiki operations.\n' +
+            logEntry
+        );
+      }
+    }
+  } catch {
+    // Silent fail — never block the agent
+  }
+}
+
+function updateIndex(wikiDir) {
+  const categories = ['entities', 'concepts', 'sources', 'synthesis'];
+  const articles = [];
+
+  for (const cat of categories) {
+    const dir = path.join(wikiDir, cat);
+    if (!fs.existsSync(dir)) continue;
+    for (const f of fs.readdirSync(dir)) {
+      if (!f.endsWith('.md')) continue;
+      const content = fs.readFileSync(path.join(dir, f), 'utf-8');
+      const titleMatch = content.match(/^title:\s*"?([^"\n]+)"?\s*$/m);
+      articles.push({
+        path: `${cat}/${f}`,
+        title: titleMatch ? titleMatch[1] : f.replace('.md', ''),
+        category: cat,
+      });
+    }
+  }
+
+  const grouped = {};
+  for (const a of articles) {
+    if (!grouped[a.category]) grouped[a.category] = [];
+    grouped[a.category].push(a);
+  }
+
+  const lines = [
+    '---',
+    `updated: ${new Date().toISOString()}`,
+    `total_articles: ${articles.length}`,
+    '---',
+    '',
+    '# Wiki Index',
+    '',
+    `> ${articles.length} articles. Auto-maintained by StackMemory.`,
+    '',
+  ];
+
+  for (const [cat, items] of Object.entries(grouped)) {
+    lines.push(`## ${cat.charAt(0).toUpperCase() + cat.slice(1)}`, '');
+    for (const item of items.slice(0, 200)) {
+      const link = item.path.replace('.md', '');
+      lines.push(`- [[${link}|${item.title}]]`);
+    }
+    lines.push('');
+  }
+
+  fs.writeFileSync(path.join(wikiDir, 'index.md'), lines.join('\n'));
+}
+
+function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9-_\s]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
+    .slice(0, 60)
+    .replace(/-$/, '');
+}
+
+function escapeYaml(s) {
+  return s.replace(/"/g, '\\"').replace(/\n/g, ' ');
+}
+
+main();