claude-brain 0.30.2 → 0.30.3

package/src/hooks/queue.ts

@@ -1,129 +1,160 @@
-/**
- * Phase 17: File Queue
- * JSONL-based offline fallback when HTTP API server is unreachable.
- * Queue file: ~/.claude-brain/data/hook-queue.jsonl
- */
-
-import { appendFileSync, readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
-import { dirname, join, resolve } from 'node:path'
-import { homedir } from 'node:os'
-import type { CapturedKnowledge } from './types'
-
-/** Inline home path resolution — avoids @/config/home dependency for <200ms hook context */
-function getHookDataDir(): string {
-  const envHome = process.env.CLAUDE_BRAIN_HOME
-  const root = envHome ? resolve(envHome) : join(homedir(), '.claude-brain')
-  return join(root, 'data')
-}
-
-/** Get the queue file path */
-export function getQueuePath(): string {
-  return join(getHookDataDir(), 'hook-queue.jsonl')
-}
-
-/**
- * Append captured knowledge to the offline queue.
- * Creates the file and parent directory if needed.
- */
-export function appendToQueue(items: CapturedKnowledge[]): void {
-  if (items.length === 0) return
-
-  const queuePath = getQueuePath()
-  const dir = dirname(queuePath)
-
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true })
-  }
-
-  const lines = items.map(item => JSON.stringify(item)).join('\n') + '\n'
-  appendFileSync(queuePath, lines, 'utf-8')
-}
-
-/**
- * Read all items from the queue file.
- * Returns empty array if file doesn't exist.
- */
-export function readQueue(): CapturedKnowledge[] {
-  const queuePath = getQueuePath()
-
-  if (!existsSync(queuePath)) return []
-
-  try {
-    const content = readFileSync(queuePath, 'utf-8').trim()
-    if (!content) return []
-
-    return content
-      .split('\n')
-      .filter(line => line.trim())
-      .map(line => {
-        try {
-          return JSON.parse(line) as CapturedKnowledge
-        } catch {
-          return null
-        }
-      })
-      .filter((item): item is CapturedKnowledge => item !== null)
-  } catch {
-    return []
-  }
-}
-
-/**
- * Clear the queue file after successful processing.
- */
-export function clearQueue(): void {
-  const queuePath = getQueuePath()
-  if (existsSync(queuePath)) {
-    writeFileSync(queuePath, '', 'utf-8')
-  }
-}
-
-/**
- * Drain the queue by POSTing items to the ingest endpoint in batches.
- * Called on server startup.
- *
- * @param port The HTTP API port
- * @param batchSize Number of items per POST
- * @returns Number of items drained
- */
-export async function drainQueue(port: number = 3000, batchSize: number = 10): Promise<number> {
-  const items = readQueue()
-  if (items.length === 0) return 0
-
-  let drained = 0
-  const url = `http://localhost:${port}/api/hooks/ingest`
-
-  for (let i = 0; i < items.length; i += batchSize) {
-    const batch = items.slice(i, i + batchSize)
-    try {
-      const res = await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ knowledge: batch }),
-        signal: AbortSignal.timeout(5000),
-      })
-
-      if (res.ok) {
-        drained += batch.length
-      } else {
-        // Stop draining on first failure
-        break
-      }
-    } catch {
-      // Server not ready yet, stop
-      break
-    }
-  }
-
-  if (drained === items.length) {
-    clearQueue()
-  } else if (drained > 0) {
-    // Partially drained — rewrite queue with remaining items
-    const remaining = items.slice(drained)
-    const queuePath = getQueuePath()
-    const lines = remaining.map(item => JSON.stringify(item)).join('\n') + '\n'
-    writeFileSync(queuePath, lines, 'utf-8')
-  }
-
-  return drained
-}
+/**
+ * Phase 17: File Queue
+ * JSONL-based offline fallback when HTTP API server is unreachable.
+ * Queue file: ~/.claude-brain/data/hook-queue.jsonl
+ */
+
+import { appendFileSync, readFileSync, writeFileSync, existsSync, mkdirSync, renameSync, unlinkSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { homedir } from 'node:os'
+import type { CapturedKnowledge } from './types'
+
+/** Inline home path resolution — avoids @/config/home dependency for <200ms hook context */
+function getHookDataDir(): string {
+  const envHome = process.env.CLAUDE_BRAIN_HOME
+  const root = envHome ? resolve(envHome) : join(homedir(), '.claude-brain')
+  return join(root, 'data')
+}
+
+/** Get the queue file path */
+export function getQueuePath(): string {
+  return join(getHookDataDir(), 'hook-queue.jsonl')
+}
+
+/**
+ * Append captured knowledge to the offline queue.
+ * Creates the file and parent directory if needed.
+ */
+export function appendToQueue(items: CapturedKnowledge[]): void {
+  if (items.length === 0) return
+
+  const queuePath = getQueuePath()
+  const dir = dirname(queuePath)
+
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+
+  const lines = items.map(item => JSON.stringify(item)).join('\n') + '\n'
+  appendFileSync(queuePath, lines, 'utf-8')
+}
+
+/**
+ * Read all items from the queue file.
+ * Returns empty array if file doesn't exist.
+ */
+export function readQueue(): CapturedKnowledge[] {
+  const queuePath = getQueuePath()
+
+  if (!existsSync(queuePath)) return []
+
+  try {
+    const content = readFileSync(queuePath, 'utf-8').trim()
+    if (!content) return []
+
+    return content
+      .split('\n')
+      .filter(line => line.trim())
+      .map(line => {
+        try {
+          return JSON.parse(line) as CapturedKnowledge
+        } catch {
+          return null
+        }
+      })
+      .filter((item): item is CapturedKnowledge => item !== null)
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Clear the queue file after successful processing.
+ */
+export function clearQueue(): void {
+  const queuePath = getQueuePath()
+  if (existsSync(queuePath)) {
+    writeFileSync(queuePath, '', 'utf-8')
+  }
+}
+
+/**
+ * Drain the queue by POSTing items to the ingest endpoint in batches.
+ * Called on server startup.
+ *
+ * @param port The HTTP API port
+ * @param batchSize Number of items per POST
+ * @returns Number of items drained
+ */
+export async function drainQueue(port: number = 3000, batchSize: number = 10): Promise<number> {
+  const queuePath = getQueuePath()
+  const processingPath = queuePath + '.processing'
+
+  // Atomically move queue to processing file (prevents concurrent drains)
+  try {
+    renameSync(queuePath, processingPath)
+  } catch {
+    return 0 // No queue file or already being processed
+  }
+
+  // Read from the processing file
+  let items: CapturedKnowledge[]
+  try {
+    const content = readFileSync(processingPath, 'utf-8').trim()
+    if (!content) {
+      unlinkSync(processingPath)
+      return 0
+    }
+    items = content
+      .split('\n')
+      .filter(line => line.trim())
+      .map(line => { try { return JSON.parse(line) } catch { return null } })
+      .filter((item): item is CapturedKnowledge => item !== null)
+  } catch {
+    return 0
+  }
+
+  if (items.length === 0) {
+    try { unlinkSync(processingPath) } catch {}
+    return 0
+  }
+
+  let drained = 0
+  const url = `http://localhost:${port}/api/hooks/ingest`
+
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch = items.slice(i, i + batchSize)
+    try {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ knowledge: batch }),
+        signal: AbortSignal.timeout(5000),
+      })
+      if (res.ok) {
+        drained += batch.length
+      } else {
+        break
+      }
+    } catch {
+      break
+    }
+  }
+
+  if (drained === items.length) {
+    // All processed — remove processing file
+    try { unlinkSync(processingPath) } catch {}
+  } else if (drained > 0) {
+    // Partially drained — write remaining items back to queue
+    const remaining = items.slice(drained)
+    const lines = remaining.map(item => JSON.stringify(item)).join('\n') + '\n'
+    // Append to queue (new items may have been added during processing)
+    appendFileSync(queuePath, lines, 'utf-8')
+    try { unlinkSync(processingPath) } catch {}
+  } else {
+    // Nothing drained — move processing file back to queue
+    try { renameSync(processingPath, queuePath) } catch {}
+  }
+
+  return drained
+}