vault backup: 2026-01-08 09:34:22

2026-01-08 09:34:22 +08:00
parent e967fa874a
commit 0e4d21f721
28 changed files with 3164 additions and 271 deletions
@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+
+/**
+ * Memvid Prompt Indexer
+ *
+ * Usage: node memvid-index-prompt.cjs <memory_file_path> <prompt_text>
+ *
+ * This script chunks a large custom prompt and stores it in Memvid for semantic search.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Parse arguments
+const args = process.argv.slice(2);
+if (args.length < 2) {
+  console.error('Usage: node memvid-index-prompt.cjs <memory_file_path> <prompt_text>');
+  process.exit(1);
+}
+
+const memoryFilePath = args[0];
+const promptText = args[1];
+
+// MCP configuration
+const mcpCommand = 'uv';
+const mcpArgs = [
+  'run',
+  '--directory',
+  'D:\\works\\projects-windows\\memvid-agent-mcp',
+  'memvid_mcp_server.py'
+];
+
+const mcpEnv = {
+  ...process.env,
+  PYTHONUNBUFFERED: '1',
+  MEMVID_LOG_LEVEL: 'ERROR'
+};
+
+// JSON-RPC communication
+let messageId = 1;
+
+function createRequest(method, params = {}) {
+  return {
+    jsonrpc: '2.0',
+    id: messageId++,
+    method,
+    params
+  };
+}
+
+function sendRequest(proc, request) {
+  const message = JSON.stringify(request) + '\n';
+  proc.stdin.write(message);
+}
+
+/**
+ * Chunk prompt by semantic sections
+ * Looks for markdown headers, paragraphs, or splits by double newlines
+ */
+function chunkPrompt(text) {
+  const chunks = [];
+
+  // Split by markdown headers (## or ###)
+  const headerRegex = /^(#{2,3})\s+(.+)$/gm;
+  const matches = [...text.matchAll(headerRegex)];
+
+  if (matches.length > 0) {
+    // Has headers: split by sections
+    let lastIndex = 0;
+
+    for (let i = 0; i < matches.length; i++) {
+      const match = matches[i];
+      const nextMatch = matches[i + 1];
+      const start = match.index;
+      const end = nextMatch ? nextMatch.index : text.length;
+
+      const section = text.substring(start, end).trim();
+      if (section.length > 0) {
+        chunks.push({
+          title: match[2],
+          content: section,
+          category: match[1] === '##' ? 'section' : 'subsection'
+        });
+      }
+    }
+
+    // Add content before first header
+    if (matches[0].index > 0) {
+      const preamble = text.substring(0, matches[0].index).trim();
+      if (preamble.length > 100) {
+        chunks.unshift({
+          title: 'General Instructions',
+          content: preamble,
+          category: 'general'
+        });
+      }
+    }
+  } else {
+    // No headers: split by double newlines
+    const paragraphs = text.split(/\n\n+/).filter(p => p.trim().length > 50);
+
+    paragraphs.forEach((para, index) => {
+      // Try to extract a title from the first line
+      const lines = para.trim().split('\n');
+      const firstLine = lines[0];
+      const title = firstLine.length < 80 ? firstLine : `Instruction ${index + 1}`;
+
+      chunks.push({
+        title: title,
+        content: para.trim(),
+        category: 'instruction'
+      });
+    });
+  }
+
+  return chunks;
+}
+
+// Main execution
+async function main() {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(mcpCommand, mcpArgs, {
+      env: mcpEnv,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    let outputBuffer = '';
+    let errorBuffer = '';
+    let initialized = false;
+    let timeoutId = null;
+
+    const chunks = chunkPrompt(promptText);
+    let currentChunkIndex = 0;
+    let addedCount = 0;
+
+    function cleanup() {
+      if (timeoutId) clearTimeout(timeoutId);
+      proc.kill();
+    }
+
+    function processNextChunk() {
+      if (currentChunkIndex >= chunks.length) {
+        // All chunks added
+        console.log(JSON.stringify({
+          success: true,
+          added: addedCount,
+          total: chunks.length
+        }));
+
+        cleanup();
+        setTimeout(() => process.exit(0), 100);
+        resolve();
+        return;
+      }
+
+      const chunk = chunks[currentChunkIndex];
+      currentChunkIndex++;
+
+      const addRequest = createRequest('tools/call', {
+        name: 'memvid_add_text',
+        arguments: {
+          file_path: memoryFilePath,
+          content: chunk.content,
+          title: chunk.title,
+          tags: {
+            type: 'instruction',
+            category: chunk.category,
+            priority: chunk.category === 'general' ? 'high' : 'medium'
+          }
+        }
+      });
+
+      sendRequest(proc, addRequest);
+    }
+
+    proc.stdout.on('data', (data) => {
+      outputBuffer += data.toString();
+
+      const lines = outputBuffer.split('\n');
+      outputBuffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+
+        try {
+          const response = JSON.parse(line);
+
+          // Handle initialization
+          if (!initialized && response.id === 1) {
+            initialized = true;
+            // Start processing chunks
+            processNextChunk();
+          }
+          // Handle add result
+          else if (initialized && response.result) {
+            addedCount++;
+            // Process next chunk
+            processNextChunk();
+          }
+          // Handle errors
+          else if (response.error) {
+            console.error(JSON.stringify({
+              error: response.error.message || 'MCP error',
+              chunk: currentChunkIndex - 1
+            }));
+
+            cleanup();
+            setTimeout(() => process.exit(1), 100);
+            reject(new Error(response.error.message));
+          }
+        } catch (e) {
+          // Ignore non-JSON lines
+        }
+      }
+    });
+
+    proc.stderr.on('data', (data) => {
+      errorBuffer += data.toString();
+    });
+
+    proc.on('error', (error) => {
+      console.error(JSON.stringify({ error: error.message }));
+      cleanup();
+      reject(error);
+    });
+
+    proc.on('exit', (code) => {
+      if (code !== 0 && code !== null) {
+        console.error(JSON.stringify({
+          error: `MCP server exited with code ${code}`,
+          stderr: errorBuffer
+        }));
+        reject(new Error(`Process exited with code ${code}`));
+      }
+    });
+
+    // Initialize MCP connection
+    const initRequest = createRequest('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: {
+        name: 'claudian-memvid-indexer',
+        version: '1.0.0'
+      }
+    });
+
+    sendRequest(proc, initRequest);
+
+    // Timeout after 30 seconds
+    timeoutId = setTimeout(() => {
+      proc.kill();
+      console.error(JSON.stringify({ error: 'Indexing timeout' }));
+      reject(new Error('Timeout'));
+    }, 30000);
+  });
+}
+
+main().catch((error) => {
+  process.exit(1);
+});