memorix 1.1.9 → 1.1.11

package/src/store/chat-store.ts

@@ -1,119 +1,119 @@
-/**
- * ChatTranscriptStore — persistence for TUI chat history.
- *
- * Backed by the shared SQLite database (chat_transcript table).
- * Supports multiple threads (thread_id), so /new creates a new thread
- * and /resume reloads the most recent one.
- */
-
-import { getDatabase } from './sqlite-db.js';
-import type { ChatTranscriptMessage } from '../cli/tui/ChatView.js';
-
-export interface ChatThreadInfo {
-  threadId: string;
-  messageCount: number;
-  lastActivity: string;
-}
-
-function safeJsonParse(text: string, fallback: any): any {
-  try { return JSON.parse(text); } catch { return fallback; }
-}
-
-export class ChatTranscriptStore {
-  private db: any = null;
-
-  async init(dataDir: string): Promise<void> {
-    this.db = getDatabase(dataDir);
-  }
-
-  /** Append a message to a thread */
-  append(projectId: string, threadId: string, message: ChatTranscriptMessage): void {
-    if (!this.db) return;
-    const now = new Date().toISOString();
-    this.db.prepare(`
-      INSERT INTO chat_transcript (project_id, thread_id, role, content, sources_json, meta_json, error, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      projectId,
-      threadId,
-      message.role,
-      message.content,
-      JSON.stringify(message.sources || []),
-      JSON.stringify(message.meta || {}),
-      message.error ? 1 : 0,
-      message.timestamp || now,
-    );
-  }
-
-  /** Load all messages for a thread, oldest first */
-  load(projectId: string, threadId: string): ChatTranscriptMessage[] {
-    if (!this.db) return [];
-    const rows = this.db.prepare(`
-      SELECT role, content, sources_json, meta_json, error, created_at
-      FROM chat_transcript
-      WHERE project_id = ? AND thread_id = ?
-      ORDER BY id ASC
-    `).all(projectId, threadId);
-
-    return rows.map((row: any) => ({
-      role: row.role as 'user' | 'assistant',
-      content: row.content,
-      sources: safeJsonParse(row.sources_json, []),
-      meta: safeJsonParse(row.meta_json, {}),
-      error: row.error === 1,
-      timestamp: row.created_at,
-    }));
-  }
-
-  /** Delete all messages for a thread */
-  clear(projectId: string, threadId: string): void {
-    if (!this.db) return;
-    this.db.prepare(`
-      DELETE FROM chat_transcript
-      WHERE project_id = ? AND thread_id = ?
-    `).run(projectId, threadId);
-  }
-
-  /** List all threads for a project, most recently active first */
-  listThreads(projectId: string): ChatThreadInfo[] {
-    if (!this.db) return [];
-    const rows = this.db.prepare(`
-      SELECT thread_id, COUNT(*) as message_count, MAX(created_at) as last_activity
-      FROM chat_transcript
-      WHERE project_id = ?
-      GROUP BY thread_id
-      ORDER BY last_activity DESC
-    `).all(projectId);
-
-    return rows.map((row: any) => ({
-      threadId: row.thread_id,
-      messageCount: row.message_count,
-      lastActivity: row.last_activity,
-    }));
-  }
-
-  /** Get the most recent thread_id for a project */
-  getLatestThreadId(projectId: string): string | null {
-    if (!this.db) return null;
-    const row = this.db.prepare(`
-      SELECT thread_id FROM chat_transcript
-      WHERE project_id = ?
-      ORDER BY created_at DESC
-      LIMIT 1
-    `).get(projectId);
-    return row?.thread_id ?? null;
-  }
-
-  /** Generate a new thread ID (timestamp-based) */
-  newThreadId(): string {
-    return `t${Date.now().toString(36)}`;
-  }
-}
-
-// Singleton
-let _store: ChatTranscriptStore | null = null;
-
-export function getChatStore(): ChatTranscriptStore {
-  if (!_store) _store = new ChatTranscriptStore();
-  return _store;
-}
+/**
+ * ChatTranscriptStore — persistence for TUI chat history.
+ *
+ * Backed by the shared SQLite database (chat_transcript table).
+ * Supports multiple threads (thread_id), so /new creates a new thread
+ * and /resume reloads the most recent one.
+ */
+
+import { getDatabase } from './sqlite-db.js';
+import type { ChatTranscriptMessage } from '../cli/tui/ChatView.js';
+
+export interface ChatThreadInfo {
+  threadId: string;
+  messageCount: number;
+  lastActivity: string;
+}
+
+function safeJsonParse(text: string, fallback: any): any {
+  try { return JSON.parse(text); } catch { return fallback; }
+}
+
+export class ChatTranscriptStore {
+  private db: any = null;
+
+  async init(dataDir: string): Promise<void> {
+    this.db = getDatabase(dataDir);
+  }
+
+  /** Append a message to a thread */
+  append(projectId: string, threadId: string, message: ChatTranscriptMessage): void {
+    if (!this.db) return;
+    const now = new Date().toISOString();
+    this.db.prepare(`
+      INSERT INTO chat_transcript (project_id, thread_id, role, content, sources_json, meta_json, error, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      projectId,
+      threadId,
+      message.role,
+      message.content,
+      JSON.stringify(message.sources || []),
+      JSON.stringify(message.meta || {}),
+      message.error ? 1 : 0,
+      message.timestamp || now,
+    );
+  }
+
+  /** Load all messages for a thread, oldest first */
+  load(projectId: string, threadId: string): ChatTranscriptMessage[] {
+    if (!this.db) return [];
+    const rows = this.db.prepare(`
+      SELECT role, content, sources_json, meta_json, error, created_at
+      FROM chat_transcript
+      WHERE project_id = ? AND thread_id = ?
+      ORDER BY id ASC
+    `).all(projectId, threadId);
+
+    return rows.map((row: any) => ({
+      role: row.role as 'user' | 'assistant',
+      content: row.content,
+      sources: safeJsonParse(row.sources_json, []),
+      meta: safeJsonParse(row.meta_json, {}),
+      error: row.error === 1,
+      timestamp: row.created_at,
+    }));
+  }
+
+  /** Delete all messages for a thread */
+  clear(projectId: string, threadId: string): void {
+    if (!this.db) return;
+    this.db.prepare(`
+      DELETE FROM chat_transcript
+      WHERE project_id = ? AND thread_id = ?
+    `).run(projectId, threadId);
+  }
+
+  /** List all threads for a project, most recently active first */
+  listThreads(projectId: string): ChatThreadInfo[] {
+    if (!this.db) return [];
+    const rows = this.db.prepare(`
+      SELECT thread_id, COUNT(*) as message_count, MAX(created_at) as last_activity
+      FROM chat_transcript
+      WHERE project_id = ?
+      GROUP BY thread_id
+      ORDER BY last_activity DESC
+    `).all(projectId);
+
+    return rows.map((row: any) => ({
+      threadId: row.thread_id,
+      messageCount: row.message_count,
+      lastActivity: row.last_activity,
+    }));
+  }
+
+  /** Get the most recent thread_id for a project */
+  getLatestThreadId(projectId: string): string | null {
+    if (!this.db) return null;
+    const row = this.db.prepare(`
+      SELECT thread_id FROM chat_transcript
+      WHERE project_id = ?
+      ORDER BY created_at DESC
+      LIMIT 1
+    `).get(projectId);
+    return row?.thread_id ?? null;
+  }
+
+  /** Generate a new thread ID (timestamp-based) */
+  newThreadId(): string {
+    return `t${Date.now().toString(36)}`;
+  }
+}
+
+// Singleton
+let _store: ChatTranscriptStore | null = null;
+
+export function getChatStore(): ChatTranscriptStore {
+  if (!_store) _store = new ChatTranscriptStore();
+  return _store;
+}

package/src/store/file-lock.ts

@@ -1,100 +1,100 @@
-/**
- * File Lock & Atomic Write Utilities
- *
- * Provides cross-process file locking using .lock files with atomic creation
- * (O_CREAT | O_EXCL), and atomic file writes via temp-file-then-rename.
- *
- * This prevents data corruption when multiple MCP server instances
- * (e.g., Cursor + Windsurf) write to the same project directory simultaneously.
- */
-
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-
-/** Lock is considered stale after 10 seconds (process crash recovery) */
-const LOCK_STALE_MS = 10_000;
-/** Retry interval when waiting for lock */
-const RETRY_INTERVAL_MS = 50;
-/** Maximum retries before giving up (50ms × 60 = 3 seconds) */
-const MAX_RETRIES = 60;
-
-/**
- * Acquire a lock file atomically.
- * Uses O_WRONLY | O_CREAT | O_EXCL — fails if file already exists.
- * Handles stale locks from crashed processes.
- */
-export async function acquireLock(lockPath: string): Promise<void> {
-  for (let i = 0; i < MAX_RETRIES; i++) {
-    try {
-      const fd = await fs.open(lockPath, 'wx');
-      await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
-      await fd.close();
-      return;
-    } catch (err: unknown) {
-      const code = err instanceof Error && 'code' in err ? (err as NodeJS.ErrnoException).code : undefined;
-      if (code === 'EEXIST' || code === 'EPERM') {
-        // Lock exists — check if stale
-        try {
-          const stat = await fs.stat(lockPath);
-          if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
-            await fs.unlink(lockPath).catch(() => {});
-            continue;
-          }
-        } catch {
-          continue; // Lock disappeared — retry immediately
-        }
-        await new Promise(r => setTimeout(r, RETRY_INTERVAL_MS));
-      } else {
-        throw err;
-      }
-    }
-  }
-  // Last resort: force-remove stale lock and try once more
-  await fs.unlink(lockPath).catch(() => {});
-  try {
-    const fd = await fs.open(lockPath, 'wx');
-    await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
-    await fd.close();
-    return;
-  } catch {
-    throw new Error(`Failed to acquire lock: ${lockPath} (timeout after ${MAX_RETRIES * RETRY_INTERVAL_MS}ms)`);
-  }
-}
-
-/**
- * Release a lock file.
- */
-export async function releaseLock(lockPath: string): Promise<void> {
-  await fs.unlink(lockPath).catch(() => {});
-}
-
-/**
- * Execute a function while holding a project-level lock.
- * Ensures only one process writes to the project directory at a time.
- *
- * @param projectDir - The project data directory to lock
- * @param fn - The async function to execute while holding the lock
- * @returns The return value of fn
- */
-export async function withFileLock<T>(projectDir: string, fn: () => Promise<T>): Promise<T> {
-  const lockPath = path.join(projectDir, '.memorix.lock');
-  await acquireLock(lockPath);
-  try {
-    return await fn();
-  } finally {
-    await releaseLock(lockPath);
-  }
-}
-
-/**
- * Write a file atomically: write to .tmp, then rename.
- * Prevents partial writes from corrupting data files on crash.
- *
- * On most filesystems, rename() is atomic within the same directory,
- * so readers always see either the old complete file or the new complete file.
- */
-export async function atomicWriteFile(filePath: string, data: string): Promise<void> {
-  const tmpPath = filePath + `.tmp.${process.pid}`;
-  await fs.writeFile(tmpPath, data, 'utf-8');
-  await fs.rename(tmpPath, filePath);
-}
+/**
+ * File Lock & Atomic Write Utilities
+ *
+ * Provides cross-process file locking using .lock files with atomic creation
+ * (O_CREAT | O_EXCL), and atomic file writes via temp-file-then-rename.
+ *
+ * This prevents data corruption when multiple MCP server instances
+ * (e.g., Cursor + Windsurf) write to the same project directory simultaneously.
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+/** Lock is considered stale after 10 seconds (process crash recovery) */
+const LOCK_STALE_MS = 10_000;
+/** Retry interval when waiting for lock */
+const RETRY_INTERVAL_MS = 50;
+/** Maximum retries before giving up (50ms × 60 = 3 seconds) */
+const MAX_RETRIES = 60;
+
+/**
+ * Acquire a lock file atomically.
+ * Uses O_WRONLY | O_CREAT | O_EXCL — fails if file already exists.
+ * Handles stale locks from crashed processes.
+ */
+export async function acquireLock(lockPath: string): Promise<void> {
+  for (let i = 0; i < MAX_RETRIES; i++) {
+    try {
+      const fd = await fs.open(lockPath, 'wx');
+      await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
+      await fd.close();
+      return;
+    } catch (err: unknown) {
+      const code = err instanceof Error && 'code' in err ? (err as NodeJS.ErrnoException).code : undefined;
+      if (code === 'EEXIST' || code === 'EPERM') {
+        // Lock exists — check if stale
+        try {
+          const stat = await fs.stat(lockPath);
+          if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+            await fs.unlink(lockPath).catch(() => {});
+            continue;
+          }
+        } catch {
+          continue; // Lock disappeared — retry immediately
+        }
+        await new Promise(r => setTimeout(r, RETRY_INTERVAL_MS));
+      } else {
+        throw err;
+      }
+    }
+  }
+  // Last resort: force-remove stale lock and try once more
+  await fs.unlink(lockPath).catch(() => {});
+  try {
+    const fd = await fs.open(lockPath, 'wx');
+    await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
+    await fd.close();
+    return;
+  } catch {
+    throw new Error(`Failed to acquire lock: ${lockPath} (timeout after ${MAX_RETRIES * RETRY_INTERVAL_MS}ms)`);
+  }
+}
+
+/**
+ * Release a lock file.
+ */
+export async function releaseLock(lockPath: string): Promise<void> {
+  await fs.unlink(lockPath).catch(() => {});
+}
+
+/**
+ * Execute a function while holding a project-level lock.
+ * Ensures only one process writes to the project directory at a time.
+ *
+ * @param projectDir - The project data directory to lock
+ * @param fn - The async function to execute while holding the lock
+ * @returns The return value of fn
+ */
+export async function withFileLock<T>(projectDir: string, fn: () => Promise<T>): Promise<T> {
+  const lockPath = path.join(projectDir, '.memorix.lock');
+  await acquireLock(lockPath);
+  try {
+    return await fn();
+  } finally {
+    await releaseLock(lockPath);
+  }
+}
+
+/**
+ * Write a file atomically: write to .tmp, then rename.
+ * Prevents partial writes from corrupting data files on crash.
+ *
+ * On most filesystems, rename() is atomic within the same directory,
+ * so readers always see either the old complete file or the new complete file.
+ */
+export async function atomicWriteFile(filePath: string, data: string): Promise<void> {
+  const tmpPath = filePath + `.tmp.${process.pid}`;
+  await fs.writeFile(tmpPath, data, 'utf-8');
+  await fs.rename(tmpPath, filePath);
+}