Deploy from GitHub Actions 2025-12-16_02-29-01

apps/backend/src/index.ts

@@ -32,7 +32,7 @@ if (typeof global.Path2D === 'undefined') {
   global.Path2D = class Path2D { };
 }
 
-const __dirname = typeof import.meta !== 'undefined' && import.meta.url 
+const __dirname = typeof import.meta !== 'undefined' && import.meta.url
   ? new URL('.', import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1')
   : process.cwd();
 // Load .env from backend directory, or root if not found
@@ -174,7 +174,7 @@ async function startServer() {
     // 🧠 NEURAL ORGANS INITIALIZATION
     // Phase B: Knowledge Synthesis
     // ============================================
-    
+
     // 1. Initialize Vector Service (Dark Matter)
     vectorService.init().then(() => {
       console.log('🌑 [DARK MATTER] Vector Engine Ready (384 dimensions)');
@@ -187,11 +187,11 @@ async function startServer() {
     console.log('🐝 [HIVE] Neural Telepathy Bus Attached');
 
     // 3. Start Knowledge Compiler (Brain) - Watch DropZone
-    const DROPZONE_PATH = process.env.DROPZONE_PATH || 
-      (process.platform === 'win32' 
+    const DROPZONE_PATH = process.env.DROPZONE_PATH ||
+      (process.platform === 'win32'
         ? 'C:\\Users\\claus\\Desktop\\WidgeTDC_DropZone'
         : '/app/data/dropzone');
-    
+
     neuralCompiler.startWatching(DROPZONE_PATH).then(() => {
       console.log(`📚 [BRAIN] Neural Compiler watching: ${DROPZONE_PATH}`);
     }).catch(err => {
@@ -210,11 +210,11 @@ async function startServer() {
     // 5. Start Prometheus Code Scanner (every hour)
     const SCAN_INTERVAL = parseInt(process.env.PROMETHEUS_SCAN_INTERVAL || '3600000');
     setTimeout(() => {
-      prometheus.scanAndPropose(path.join(__dirname, 'services')).catch(() => {});
+      prometheus.scanAndPropose(path.join(__dirname, 'services')).catch(() => { });
     }, 10000); // Initial scan after 10s
-    
+
     setInterval(() => {
-      prometheus.scanAndPropose(path.join(__dirname, 'services')).catch(() => {});
+      prometheus.scanAndPropose(path.join(__dirname, 'services')).catch(() => { });
     }, SCAN_INTERVAL);
     console.log('🔥 [PROMETHEUS] Code Evolution Scanner Active');
 
@@ -407,7 +407,10 @@ async function startServer() {
       vidensarkivBatchAddHandler,
       vidensarkivGetRelatedHandler,
       vidensarkivListHandler,
-      vidensarkivStatsHandler
+      vidensarkivStatsHandler,
+      vidensarkivReadHandler,
+      vidensarkivListFilesHandler,
+      vidensarkivReadFileHandler
     } = await import('./mcp/toolHandlers.js');
 
     mcpRegistry.registerTool('vidensarkiv.search', vidensarkivSearchHandler);
@@ -416,6 +419,9 @@ async function startServer() {
     mcpRegistry.registerTool('vidensarkiv.get_related', vidensarkivGetRelatedHandler);
     mcpRegistry.registerTool('vidensarkiv.list', vidensarkivListHandler);
     mcpRegistry.registerTool('vidensarkiv.stats', vidensarkivStatsHandler);
+    mcpRegistry.registerTool('vidensarkiv.read', vidensarkivReadHandler);
+    mcpRegistry.registerTool('vidensarkiv.list_files', vidensarkivListFilesHandler);
+    mcpRegistry.registerTool('vidensarkiv.read_file', vidensarkivReadFileHandler);
 
     // TaskRecorder Tools
     const {
@@ -565,11 +571,11 @@ async function startServer() {
     })();
 
     // Step 4: Setup routes
-    
+
     // 🛡️ ANGEL PROXY: Security Shield on all API routes
     app.use('/api', AngelProxy.cortexFirewall);
     console.log('🛡️ [ANGEL] Cortex Firewall Active on /api/*');
-    
+
     app.use('/api/mcp', mcpRouter);
     app.use('/api/mcp/autonomous', autonomousRouter);
     app.use('/api/memory', memoryRouter);

apps/backend/src/mcp/toolHandlers.ts

@@ -1,6 +1,8 @@
 import { McpContext } from '@widget-tdc/mcp-types';
 import { spawn } from 'child_process';
 import path from 'path';
+import * as fs from 'fs/promises';
+import * as os from 'os';
 import { MemoryRepository } from '../services/memory/memoryRepository.js';
 import { SragRepository } from '../services/srag/sragRepository.js';
 import { EvolutionRepository } from '../services/evolution/evolutionRepository.js';
@@ -461,6 +463,103 @@ export async function autonomousAgentTeamCoordinateHandler(payload: any, _ctx: M
 }
 
 // Vidensarkiv (PgVector) tool handlers
+export async function vidensarkivReadHandler(payload: any, _ctx: McpContext): Promise<any> {
+  const vectorStore = getNeo4jVectorStore();
+  const { id } = payload;
+
+  if (!id) {
+    throw new Error('id is required');
+  }
+
+  const record = await vectorStore.get(id);
+
+  if (!record) {
+    throw new Error(`Document with id ${id} not found`);
+  }
+
+  return {
+    success: true,
+    file: {
+      id: record.id,
+      content: record.content,
+      metadata: record.metadata
+    }
+  };
+}
+
+export async function vidensarkivListFilesHandler(payload: any, _ctx: McpContext): Promise<any> {
+  const { subfolder } = payload;
+  const homeDir = os.homedir();
+  // Use C:\Users\claus\Desktop\vidensarkiv if on Windows/Dev, or appropriate path
+  // For now, respect the ~/Desktop/vidensarkiv convention
+  const basePath = path.join(homeDir, 'Desktop', 'vidensarkiv');
+  const targetPath = subfolder ? path.join(basePath, subfolder) : basePath;
+
+  try {
+    // Ensure directory exists
+    try {
+      await fs.access(targetPath);
+    } catch {
+      await fs.mkdir(targetPath, { recursive: true });
+    }
+
+    const entries = await fs.readdir(targetPath, { withFileTypes: true });
+
+    const files = entries.map(entry => ({
+      name: entry.name,
+      path: subfolder ? path.join(subfolder, entry.name) : entry.name,
+      type: entry.isDirectory() ? 'folder' : 'file',
+      size: 0,
+      modified: new Date().toISOString()
+    }));
+
+    // Add size and mtime - parallelize
+    await Promise.all(files.map(async (file) => {
+      if (file.type === 'file') {
+        try {
+          const stat = await fs.stat(path.join(targetPath, file.name));
+          file.size = stat.size;
+          file.modified = stat.mtime.toISOString();
+        } catch (e) { console.error('Stat error', e); }
+      }
+    }));
+
+    return {
+      success: true,
+      files
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message,
+      files: []
+    };
+  }
+}
+
+export async function vidensarkivReadFileHandler(payload: any, _ctx: McpContext): Promise<any> {
+  const { filepath } = payload;
+  if (!filepath) throw new Error('filepath is required');
+
+  const homeDir = os.homedir();
+  const basePath = path.join(homeDir, 'Desktop', 'vidensarkiv');
+  // Prevent directory traversal
+  const safePath = path.join(basePath, filepath).replace(/\.\./g, '');
+
+  try {
+    const content = await fs.readFile(safePath, 'utf8');
+    return {
+      success: true,
+      content
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
 export async function vidensarkivSearchHandler(payload: any, ctx: McpContext): Promise<any> {
   const vectorStore = getNeo4jVectorStore();
   const { query, limit = 10, namespace } = payload;
@@ -1194,7 +1293,7 @@ export async function agenticRunHandler(payload: any, ctx: McpContext): Promise<
 // ---------------------------------------------------
 export async function widgetsUpdateStateHandler(payload: any, ctx: McpContext): Promise<any> {
   const { widgetId, state } = payload;
-  
+
   if (!widgetId) {
     throw new Error('widgetId required');
   }
@@ -1280,7 +1379,7 @@ export async function visionaryGenerateHandler(payload: any, ctx: McpContext): P
   }
 
   const llmService = getLlmService();
-  
+
   const systemContext = `
 You are The Visionary, an expert system architect and visualization specialist.
 Your goal is to generate valid Mermaid.js diagram code based on user requests.
@@ -1342,7 +1441,7 @@ ${(memories || []).join('\n')}
 // ---------------------------------------------------
 export async function dataAnalysisHandler(payload: any, ctx: McpContext): Promise<any> {
   const { data, type, params } = payload;
-  
+
   if (!data || !Array.isArray(data)) {
     throw new Error("Invalid payload: 'data' must be an array of objects.");
   }
@@ -1351,12 +1450,12 @@ export async function dataAnalysisHandler(payload: any, ctx: McpContext): Promis
     // Resolve path to python script
     // Assuming running from apps/backend
     const scriptPath = path.resolve(process.cwd(), 'python/analysis_engine.py');
-    
+
     // Check python command availability (python3 or python)
     const pythonCmd = process.platform === 'win32' ? 'python' : 'python3';
 
     const pythonProcess = spawn(pythonCmd, [scriptPath]);
-    
+
     let resultData = '';
     let errorData = '';
 
@@ -1382,9 +1481,9 @@ export async function dataAnalysisHandler(payload: any, ctx: McpContext): Promis
       try {
         const parsedResult = JSON.parse(resultData);
         if (!parsedResult.success) {
-           reject(new Error(parsedResult.error));
+          reject(new Error(parsedResult.error));
         } else {
-           resolve(parsedResult.data);
+          resolve(parsedResult.data);
         }
       } catch (e) {
         console.error('Failed to parse Python output:', resultData);

apps/backend/src/platform/vector/Neo4jVectorStoreAdapter.ts

@@ -86,13 +86,13 @@ export class Neo4jVectorStoreAdapter {
                     ` + "`vector.similarity_function`" + `: 'cosine'
                 }}
             `);
-            
+
             // Create constraint for ID
             await this.graphAdapter.query(`
                 CREATE CONSTRAINT vector_document_id IF NOT EXISTS
                 FOR (n:VectorDocument) REQUIRE n.id IS UNIQUE
             `);
-            
+
             logger.info(`🧠 Neo4j Vector Store initialized (${this.indexName}, ${this.dimension}D)`);
             this.isInitialized = true;
         } catch (error) {
@@ -140,12 +140,12 @@ export class Neo4jVectorStoreAdapter {
      */
     async batchUpsert(options: { records: VectorRecord[]; namespace?: string }): Promise<void> {
         if (!this.isInitialized) await this.initialize();
-        
+
         // Process in batches of 50 to avoid large transactions
         const batchSize = 50;
         for (let i = 0; i < options.records.length; i += batchSize) {
             const batch = options.records.slice(i, i + batchSize);
-            
+
             // Generate embeddings in parallel for the batch if needed
             const recordsWithEmbeddings = await Promise.all(batch.map(async (r) => {
                 if (!r.embedding && r.content) {
@@ -174,7 +174,7 @@ export class Neo4jVectorStoreAdapter {
                 namespace: options.namespace || 'default'
             });
         }
-        
+
         logger.info(`📦 Batch upserted ${options.records.length} vectors to Neo4j`);
     }
 
@@ -183,7 +183,7 @@ export class Neo4jVectorStoreAdapter {
      */
     async search(query: VectorQuery): Promise<VectorSearchResult[]> {
         if (!this.isInitialized) await this.initialize();
-        
+
         let searchVector = query.vector;
         if (!searchVector && query.text) {
             searchVector = await this.embeddings.generateEmbedding(query.text);
@@ -199,7 +199,7 @@ export class Neo4jVectorStoreAdapter {
         // Using Neo4j vector index query
         // Note: We filter by namespace AFTER the vector search if using db.index.vector.queryNodes
         // Ideally, we would use pre-filtering but that requires more complex cypher or newer Neo4j features
-        
+
         const cypher = `
             CALL db.index.vector.queryNodes($indexName, $k, $embedding)
             YIELD node, score
@@ -208,7 +208,7 @@ export class Neo4jVectorStoreAdapter {
         `;
 
         // We request more results than limit to account for filtering
-        const k = limit * 5; 
+        const k = limit * 5;
 
         const result = await this.graphAdapter.query(cypher, {
             indexName: this.indexName,
@@ -222,12 +222,12 @@ export class Neo4jVectorStoreAdapter {
             // record is an object where keys are the return values from Cypher
             // We returned: id, content, metadata, score
             // Note: metadata was returned as 'node', which contains properties
-            
+
             const properties = record.metadata?.properties || {};
-            
+
             // Clean up internal properties if needed
             delete properties.embedding;
-            
+
             return {
                 id: record.id,
                 content: record.content,
@@ -236,12 +236,41 @@ export class Neo4jVectorStoreAdapter {
             };
         });
     }
-    
+
     // Helper to be implemented after updating adapter
     async searchRaw(query: VectorQuery): Promise<VectorSearchResult[]> {
         return this.search(query);
     }
 
+    /**
+     * Get a vector document by ID
+     */
+    async get(id: string): Promise<VectorRecord | null> {
+        if (!this.isInitialized) await this.initialize();
+
+        const cypher = `
+            MATCH (n:VectorDocument {id: $id})
+            RETURN n.id as id, n.content as content, n.embedding as embedding, n.namespace as namespace, n as metadata
+        `;
+
+        const result = await this.graphAdapter.query(cypher, { id });
+
+        if (result.records.length === 0) {
+            return null;
+        }
+
+        const record = result.records[0];
+        const properties = record.metadata?.properties || {};
+        delete properties.embedding; // Remove large embedding array
+
+        return {
+            id: record.id,
+            content: record.content,
+            metadata: properties,
+            namespace: record.namespace
+        };
+    }
+
     /**
      * Get statistics
      */
@@ -260,7 +289,7 @@ export class Neo4jVectorStoreAdapter {
         `;
 
         const result = await this.graphAdapter.query(cypher);
-        
+
         const perNamespace: Record<string, number> = {};
         let totalRecords = 0;