@hoverlover/cc-discord 0.3.3 → 0.4.0

package/hooks/check-discord-messages.ts

@@ -71,43 +71,88 @@ async function syncRuntimeContext({ hookEvent, hookInput }: { hookEvent: string;
   }
 }
 
+/**
+ * Build memory context using QMD semantic search.
+ *
+ * Queries the `agent-memory` QMD collection and formats results into the
+ * same MEMORY CONTEXT format the downstream prompts expect.
+ */
 async function buildMemoryContext({ queryText, runtimeState }: { queryText: string; runtimeState: any }) {
-  const memoryDbPath = join(DATA_DIR, "memory.db");
-  const memorySessionKey = buildMemorySessionKey({ sessionId, agentId });
+  if (!queryText?.trim()) return "";
 
-  let store: SqliteMemoryStore | undefined;
   try {
-    store = new SqliteMemoryStore({ dbPath: memoryDbPath, logger: noopLogger });
-    const coordinator = new MemoryCoordinator({ store, logger: noopLogger });
-    await coordinator.init();
+    const { execSync } = await import("node:child_process");
+
+    // Use `qmd search` (BM25) for fast keyword recall (~0.3s).
+    // `qmd query` would give LLM-reranked results but is too slow for a hook.
+    // -n 8 returns up to 8 relevant chunks.
+    // --min-score 0.3 filters low-relevance noise.
+    const raw = execSync(
+      `qmd search ${JSON.stringify(queryText)} -n 8 --min-score 0.3 --json 2>/dev/null`,
+      { encoding: "utf-8", timeout: 8_000 },
+    );
 
-    const packet = await coordinator.assembleContext({
-      sessionKey: memorySessionKey,
-      queryText,
-      runtimeContextId: runtimeState?.runtimeContextId || null,
-      runtimeEpoch: runtimeState?.runtimeEpoch || null,
-      includeSnapshot: true,
-      avoidCurrentRuntime: true,
-      activeWindowSize: 12,
-      maxCards: 6,
-      maxRecallTurns: 8,
-      maxTurnScan: 300,
-    });
+    const results: Array<{ docid: string; score: number; file: string; title: string; snippet: string }> =
+      JSON.parse(raw || "[]");
+
+    if (results.length === 0) return "";
+
+    // Expand the top results into readable turn snippets using `qmd get`.
+    // Each snippet in the JSON output has a line reference — we use `qmd get`
+    // to retrieve a fuller window of surrounding content.
+    const lines: string[] = [];
+    for (const result of results.slice(0, 8)) {
+      // Extract the path + line from the qmd:// URI
+      const qmdPath = result.file.replace(/^qmd:\/\//, "");
+      const lineMatch = result.snippet.match(/@@ -(\d+)/);
+      const lineNum = lineMatch ? parseInt(lineMatch[1], 10) : 1;
 
-    return coordinator.formatContextPacket(packet);
-  } catch {
-    return "";
-  } finally {
-    if (store) {
       try {
-        await store.close();
+        const content = execSync(
+          `qmd get "${qmdPath}:${lineNum}" -l 12 2>/dev/null`,
+          { encoding: "utf-8", timeout: 5_000 },
+        ).trim();
+
+        if (content) {
+          // Clean up markdown headers/frontmatter noise, keep the conversation content
+          const cleaned = content
+            .split("\n")
+            .filter((l: string) => !l.startsWith("---") && !l.startsWith("session_key:") && !l.startsWith("agent_id:"))
+            .join("\n")
+            .trim();
+
+          if (cleaned) {
+            const scoreLabel = `${Math.round(result.score * 100)}%`;
+            lines.push(`- [${scoreLabel}] ${truncateForMemory(cleaned, 320)}`);
+          }
+        }
       } catch {
-        /* ignore */
+        // Fall back to the snippet from the JSON
+        if (result.snippet) {
+          const snippetText = result.snippet
+            .replace(/@@ -\d+,?\d* @@.*\n?/, "")
+            .replace(/\(.*?before.*?after\)\n?/, "")
+            .trim();
+          if (snippetText) {
+            lines.push(`- [${Math.round(result.score * 100)}%] ${truncateForMemory(snippetText, 320)}`);
+          }
+        }
       }
     }
+
+    if (lines.length === 0) return "";
+    return `MEMORY CONTEXT:\nRelevant prior turns (semantic recall via QMD):\n${lines.join("\n")}`;
+  } catch {
+    return "";
   }
 }
 
+function truncateForMemory(text: string, maxLen: number): string {
+  const oneLine = text.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+  if (oneLine.length <= maxLen) return oneLine;
+  return `${oneLine.slice(0, maxLen - 1)}…`;
+}
+
 let hookInput: any;
 try {
   const chunks: Buffer[] = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hoverlover/cc-discord",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "Discord <-> Claude Code relay: use your Claude subscription to power per-channel AI bots",
   "type": "module",
   "bin": {

package/scripts/migrate-memory-to-qmd.ts

@@ -0,0 +1,188 @@
+#!/usr/bin/env bun
+/**
+ * Phase 1: Export memory.db turns to markdown files for QMD indexing.
+ *
+ * Reads all sessions and turns from the SQLite memory store and writes them
+ * as markdown files grouped by session into the Obsidian vault's
+ * agent-memory/conversations/ folder.
+ *
+ * Output directory: ~/Library/Mobile Documents/iCloud~md~obsidian/Documents/iCloud/agent-memory/
+ *
+ * File layout:
+ *   agent-memory/
+ *     conversations/
+ *       <date>-<channel-id>.md   (one file per session, named by date)
+ *
+ * Each file contains YAML-style frontmatter and all turns in order.
+ */
+
+import Database from "bun:sqlite";
+import { mkdirSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+// ── Paths ──────────────────────────────────────────────────────────
+const DATA_DIR = join(homedir(), ".cc-discord", "data");
+const DB_PATH = join(DATA_DIR, "memory.db");
+const OBSIDIAN_VAULT = join(
+  homedir(),
+  "Library",
+  "Mobile Documents",
+  "iCloud~md~obsidian",
+  "Documents",
+  "iCloud"
+);
+const AGENT_MEMORY_DIR = join(OBSIDIAN_VAULT, "agent-memory");
+const CONVERSATIONS_DIR = join(AGENT_MEMORY_DIR, "conversations");
+
+// ── Types ──────────────────────────────────────────────────────────
+interface SessionRow {
+  session_key: string;
+  agent_id: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+interface TurnRow {
+  id: string;
+  session_key: string;
+  turn_index: number;
+  role: string;
+  content: string;
+  metadata_json: string | null;
+  created_at: string;
+}
+
+// ── Helpers ────────────────────────────────────────────────────────
+
+/**
+ * Build a human-friendly filename from session metadata.
+ * Format: YYYY-MM-DD-<channel-id>.md
+ */
+function buildFilename(session: SessionRow): string {
+  // Extract date from created_at (ISO string → YYYY-MM-DD)
+  const date = session.created_at.slice(0, 10);
+  // Extract channel ID from session key (last segment after last colon)
+  const parts = session.session_key.split(":");
+  const channelId = parts[parts.length - 1] || "unknown";
+  return `${date}-${channelId}.md`;
+}
+
+/** Format a single turn as a markdown section. */
+function formatTurn(turn: TurnRow): string {
+  const roleLabel = turn.role === "user" ? "🧑 User" : "🤖 Assistant";
+  const ts = turn.created_at ? `  _(${turn.created_at})_` : "";
+
+  let meta = "";
+  if (turn.metadata_json) {
+    try {
+      const parsed = JSON.parse(turn.metadata_json);
+      if (parsed.runtimeContextId) {
+        meta = `\n> Runtime context: \`${parsed.runtimeContextId}\` epoch ${parsed.runtimeEpoch ?? "?"}`;
+      }
+    } catch {
+      // ignore malformed JSON
+    }
+  }
+
+  return `### Turn ${turn.turn_index} — ${roleLabel}${ts}${meta}\n\n${turn.content}\n`;
+}
+
+// ── Main ───────────────────────────────────────────────────────────
+function main() {
+  if (!existsSync(DB_PATH)) {
+    console.error(`❌  memory.db not found at ${DB_PATH}`);
+    process.exit(1);
+  }
+
+  const db = new Database(DB_PATH, { readonly: true });
+
+  // Fetch sessions
+  const sessions = db
+    .query<SessionRow, []>(
+      `SELECT session_key, agent_id, created_at, updated_at
+       FROM memory_sessions ORDER BY created_at`
+    )
+    .all();
+
+  console.log(`📦  Found ${sessions.length} session(s) in memory.db`);
+
+  // Verify Obsidian vault exists
+  if (!existsSync(OBSIDIAN_VAULT)) {
+    console.error(`❌  Obsidian vault not found at ${OBSIDIAN_VAULT}`);
+    process.exit(1);
+  }
+
+  // Prepare output directories
+  mkdirSync(CONVERSATIONS_DIR, { recursive: true });
+  console.log(`📂  Output directory: ${CONVERSATIONS_DIR}`);
+
+  let totalTurns = 0;
+  let filesWritten = 0;
+
+  for (const session of sessions) {
+    const turns = db
+      .query<TurnRow, [string]>(
+        `SELECT id, session_key, turn_index, role, content, metadata_json, created_at
+         FROM memory_turns
+         WHERE session_key = ?
+         ORDER BY turn_index`
+      )
+      .all(session.session_key);
+
+    if (turns.length === 0) {
+      console.log(`  ⏭  Skipping empty session: ${session.session_key}`);
+      continue;
+    }
+
+    totalTurns += turns.length;
+
+    // Build markdown with Obsidian-friendly filename
+    const filename = buildFilename(session);
+    const filePath = join(CONVERSATIONS_DIR, filename);
+
+    const frontmatter = [
+      "---",
+      `session_key: "${session.session_key}"`,
+      `agent_id: "${session.agent_id ?? ""}"`,
+      `source: cc-discord`,
+      `type: conversation`,
+      `created: "${session.created_at}"`,
+      `updated: "${session.updated_at}"`,
+      `turn_count: ${turns.length}`,
+      `first_turn: "${turns[0].created_at}"`,
+      `last_turn: "${turns[turns.length - 1].created_at}"`,
+      `tags:`,
+      `  - agent-memory`,
+      `  - conversation`,
+      `  - cc-discord`,
+      "---",
+    ].join("\n");
+
+    const header = `# Session: ${session.session_key}\n\n`;
+    const summary = `> **${turns.length} turns** · Agent \`${session.agent_id ?? "unknown"}\` · ${session.created_at} → ${session.updated_at}\n\n`;
+    const body = turns.map(formatTurn).join("\n---\n\n");
+
+    const markdown = `${frontmatter}\n\n${header}${summary}${body}`;
+
+    writeFileSync(filePath, markdown, "utf-8");
+    filesWritten++;
+    console.log(
+      `  ✅  ${filename} — ${turns.length} turn(s)`
+    );
+  }
+
+  db.close();
+
+  console.log(`\n🎉  Export complete!`);
+  console.log(`    Sessions exported : ${filesWritten}`);
+  console.log(`    Total turns       : ${totalTurns}`);
+  console.log(`    Output directory  : ${CONVERSATIONS_DIR}`);
+  console.log(`\nNext steps:`);
+  console.log(`  1. qmd collection remove cc-discord-memory  (remove old collection)`);
+  console.log(`  2. qmd collection add "${AGENT_MEMORY_DIR}" --name agent-memory`);
+  console.log(`  3. qmd embed`);
+  console.log(`  4. qmd query "test query"  — verify semantic search`);
+}
+
+main();

package/scripts/test-qmd-recall.ts

@@ -0,0 +1,64 @@
+#!/usr/bin/env bun
+/**
+ * Quick test: verify QMD-based memory recall works end-to-end.
+ */
+
+import { execSync } from "node:child_process";
+
+const queryText = "mattermost installation deployment";
+
+console.log(`Query: "${queryText}"\n`);
+
+const raw = execSync(
+  `qmd search ${JSON.stringify(queryText)} -n 8 --min-score 0.3 --json 2>/dev/null`,
+  { encoding: "utf-8", timeout: 8_000 },
+);
+
+const results: Array<{ docid: string; score: number; file: string; title: string; snippet: string }> =
+  JSON.parse(raw || "[]");
+
+console.log(`QMD returned ${results.length} result(s)\n`);
+
+const lines: string[] = [];
+for (const result of results.slice(0, 8)) {
+  const qmdPath = result.file.replace(/^qmd:\/\//, "");
+  const lineMatch = result.snippet.match(/@@ -(\d+)/);
+  const lineNum = lineMatch ? parseInt(lineMatch[1], 10) : 1;
+
+  try {
+    const content = execSync(
+      `qmd get "${qmdPath}:${lineNum}" -l 12 2>/dev/null`,
+      { encoding: "utf-8", timeout: 5_000 },
+    ).trim();
+
+    if (content) {
+      const cleaned = content
+        .split("\n")
+        .filter((l: string) => !l.startsWith("---") && !l.startsWith("session_key:") && !l.startsWith("agent_id:"))
+        .join("\n")
+        .trim();
+
+      if (cleaned) {
+        const scoreLabel = `${Math.round(result.score * 100)}%`;
+        const oneLine = cleaned.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+        lines.push(`- [${scoreLabel}] ${oneLine.slice(0, 320)}`);
+      }
+    }
+  } catch {
+    if (result.snippet) {
+      const snippetText = result.snippet
+        .replace(/@@ -\d+,?\d* @@.*\n?/, "")
+        .replace(/\(.*?before.*?after\)\n?/, "")
+        .trim();
+      if (snippetText) {
+        lines.push(`- [${Math.round(result.score * 100)}%] ${snippetText.replace(/\n/g, " ").slice(0, 320)}`);
+      }
+    }
+  }
+}
+
+console.log("MEMORY CONTEXT:");
+console.log("Relevant prior turns (semantic recall via QMD):");
+for (const line of lines) {
+  console.log(line);
+}

package/server/memory.ts

@@ -1,51 +1,55 @@
 /**
  * Memory integration for the relay server.
- * Persists inbound/outbound turns and assembles memory context for context injection.
  *
- * Session key strategy:
- * When a channelId is provided, turns are written to a per-channel key
- * (discord:{sessionId}:{channelId}) so that per-channel subagents can
- * retrieve them. This matches the key that wait-for-discord-messages
- * uses on the read side (agentId = channelId).
+ * Writes new turns as markdown to the Obsidian vault's agent-memory folder
+ * and triggers QMD re-indexing. Reads are handled by the hook via `qmd query`.
+ *
+ * SQLite is retained solely for runtime-state tracking (context epochs).
  *
- * When no channelId is available, falls back to the legacy shared key
- * (discord:{sessionId}:{CLAUDE_AGENT_ID}).
+ * Session key strategy:
+ * When a channelId is provided, turns are appended to a per-channel
+ * conversation file. When no channelId is available, falls back to the
+ * legacy shared key.
  */
 
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { MemoryCoordinator } from "../memory/core/MemoryCoordinator.ts";
 import { buildMemorySessionKey } from "../memory/core/session-key.ts";
 import { SqliteMemoryStore } from "../memory/providers/sqlite/SqliteMemoryStore.ts";
 import { CLAUDE_AGENT_ID, DATA_DIR, DISCORD_SESSION_ID } from "./config.ts";
 
+// ── Paths ──────────────────────────────────────────────────────────
+const OBSIDIAN_VAULT = join(
+  process.env.HOME || "",
+  "Library",
+  "Mobile Documents",
+  "iCloud~md~obsidian",
+  "Documents",
+  "iCloud",
+);
+const AGENT_MEMORY_DIR = join(OBSIDIAN_VAULT, "agent-memory");
+const CONVERSATIONS_DIR = join(AGENT_MEMORY_DIR, "conversations");
+
 /** Legacy fallback key for turns without a channel association. */
 const fallbackSessionKey = buildMemorySessionKey({
   sessionId: DISCORD_SESSION_ID,
   agentId: CLAUDE_AGENT_ID,
 });
 
+/**
+ * SQLite store is retained only for runtime-state tracking.
+ * It is NOT used for reading/writing memory turns.
+ */
 export const memoryStore = new SqliteMemoryStore({
   dbPath: join(DATA_DIR, "memory.db"),
   logger: console,
 });
+await memoryStore.init();
 
-export const memory = new MemoryCoordinator({
-  store: memoryStore,
-  logger: console,
-});
-
-await memory.init();
+// ── Helpers ────────────────────────────────────────────────────────
 
-/**
- * Resolve the memory session key for a turn.
- * If channelId is available, produces a per-channel key matching what
- * the subagent's wait-for-discord-messages will query.
- */
 function resolveSessionKey(channelId?: string): string {
   if (channelId) {
-    // Subagents set AGENT_ID=channelId and build their key as:
-    //   buildMemorySessionKey({ sessionId, agentId: channelId })
-    // => discord:{sessionId}:{channelId}
     return buildMemorySessionKey({
       sessionId: DISCORD_SESSION_ID,
       agentId: channelId,
@@ -54,6 +58,83 @@ function resolveSessionKey(channelId?: string): string {
   return fallbackSessionKey;
 }
 
+/**
+ * Build the filename for a conversation file.
+ * Format: <date>-<channelId>.md (matches export script naming).
+ */
+function resolveConversationFile(sessionKey: string): string {
+  const parts = sessionKey.split(":");
+  const channelId = parts[parts.length - 1] || "unknown";
+
+  // Look for an existing file matching this channel
+  const { readdirSync } = require("node:fs");
+  mkdirSync(CONVERSATIONS_DIR, { recursive: true });
+  const files: string[] = readdirSync(CONVERSATIONS_DIR);
+  const existing = files.find((f: string) => f.endsWith(`-${channelId}.md`));
+  if (existing) return join(CONVERSATIONS_DIR, existing);
+
+  // No existing file — create a new one with today's date
+  const today = new Date().toISOString().slice(0, 10);
+  return join(CONVERSATIONS_DIR, `${today}-${channelId}.md`);
+}
+
+/**
+ * Format a turn as markdown, matching the export format.
+ */
+function formatTurnMarkdown(role: string, content: string, metadata: any): string {
+  const roleLabel = role === "user" ? "🧑 User" : "🤖 Assistant";
+  const ts = new Date().toISOString();
+
+  let meta = "";
+  if (metadata?.runtimeContextId) {
+    meta = `\n> Runtime context: \`${metadata.runtimeContextId}\` epoch ${metadata.runtimeEpoch ?? "?"}`;
+  }
+
+  // We use "Turn ?" because exact index doesn't matter for QMD search
+  return `\n---\n\n### Turn — ${roleLabel}  _(${ts})_${meta}\n\n${content}\n`;
+}
+
+/**
+ * Create a new conversation file with frontmatter.
+ */
+function createConversationFile(filePath: string, sessionKey: string, agentId: string): void {
+  const now = new Date().toISOString();
+  const frontmatter = [
+    "---",
+    `session_key: "${sessionKey}"`,
+    `agent_id: "${agentId}"`,
+    `source: cc-discord`,
+    `type: conversation`,
+    `created: "${now}"`,
+    `updated: "${now}"`,
+    `tags:`,
+    `  - agent-memory`,
+    `  - conversation`,
+    `  - cc-discord`,
+    "---",
+    "",
+    `# Session: ${sessionKey}`,
+    "",
+  ].join("\n");
+
+  writeFileSync(filePath, frontmatter, "utf-8");
+}
+
+/**
+ * Trigger a background QMD re-index so new turns become searchable.
+ * Non-blocking — we don't wait for it to finish.
+ */
+function triggerQmdReindex(): void {
+  try {
+    const { exec } = require("node:child_process");
+    exec("qmd update 2>/dev/null", { timeout: 30_000 });
+  } catch {
+    // Best-effort; QMD will catch up on next explicit update or query
+  }
+}
+
+// ── Main API ───────────────────────────────────────────────────────
+
 export async function appendMemoryTurn({
   role,
   content,
@@ -68,21 +149,40 @@ export async function appendMemoryTurn({
     const sessionKey = resolveSessionKey(channelId);
     const runtimeState = await memoryStore.readRuntimeState(sessionKey);
 
-    const result = await memory.appendTurn({
-      sessionKey,
-      agentId: channelId || CLAUDE_AGENT_ID,
-      role,
-      content,
-      metadata: {
-        ...metadata,
-        runtimeContextId: runtimeState?.runtimeContextId || null,
-        runtimeEpoch: runtimeState?.runtimeEpoch || null,
-      },
-    });
-    console.log(
-      `[Memory] persisted ${role} turn to ${sessionKey} (batch=${result?.batchId}, turns=${result?.counts?.turns})`,
-    );
+    const enrichedMetadata = {
+      ...metadata,
+      runtimeContextId: runtimeState?.runtimeContextId || null,
+      runtimeEpoch: runtimeState?.runtimeEpoch || null,
+    };
+
+    // Resolve (or create) the conversation markdown file
+    const filePath = resolveConversationFile(sessionKey);
+
+    if (!existsSync(filePath)) {
+      createConversationFile(filePath, sessionKey, channelId || CLAUDE_AGENT_ID);
+    }
+
+    // Append the new turn
+    const turnMd = formatTurnMarkdown(role, content, enrichedMetadata);
+    appendFileSync(filePath, turnMd, "utf-8");
+
+    // Update the frontmatter "updated" timestamp
+    try {
+      const raw = readFileSync(filePath, "utf-8");
+      const updated = raw.replace(
+        /^updated: ".*"$/m,
+        `updated: "${new Date().toISOString()}"`,
+      );
+      if (updated !== raw) writeFileSync(filePath, updated, "utf-8");
+    } catch {
+      /* best-effort */
+    }
+
+    // Trigger non-blocking QMD re-index
+    triggerQmdReindex();
+
+    console.log(`[Memory/QMD] persisted ${role} turn to ${filePath}`);
   } catch (err: unknown) {
-    console.error("[Memory] failed to persist turn:", (err as Error).message);
+    console.error("[Memory/QMD] failed to persist turn:", (err as Error).message);
   }
 }