@grec0/memory-bank-mcp 0.0.2

package/dist/common/indexManager.js

@@ -0,0 +1,332 @@
+/**
+ * @fileoverview Index manager for Memory Bank
+ * Coordinates scanning, chunking, embedding, and storage
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { scanFiles, scanSingleFile } from "./fileScanner.js";
+import { chunkCode } from "./chunker.js";
+/**
+ * Index manager coordinating the entire indexing pipeline
+ */
+export class IndexManager {
+    embeddingService;
+    vectorStore;
+    metadataPath;
+    metadata;
+    constructor(embeddingService, vectorStore, storagePath = ".memorybank") {
+        this.embeddingService = embeddingService;
+        this.vectorStore = vectorStore;
+        this.metadataPath = path.join(storagePath, "index-metadata.json");
+        this.metadata = this.loadMetadata();
+    }
+    /**
+     * Loads index metadata from disk
+     */
+    loadMetadata() {
+        try {
+            if (fs.existsSync(this.metadataPath)) {
+                const data = fs.readFileSync(this.metadataPath, "utf-8");
+                return JSON.parse(data);
+            }
+        }
+        catch (error) {
+            console.error(`Warning: Could not load index metadata: ${error}`);
+        }
+        return {
+            version: "1.0",
+            lastIndexed: 0,
+            files: {},
+        };
+    }
+    /**
+     * Saves index metadata to disk
+     */
+    saveMetadata() {
+        try {
+            const dir = path.dirname(this.metadataPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.metadataPath, JSON.stringify(this.metadata, null, 2));
+        }
+        catch (error) {
+            console.error(`Warning: Could not save index metadata: ${error}`);
+        }
+    }
+    /**
+     * Checks if a file needs reindexing
+     */
+    needsReindexing(file, forceReindex) {
+        if (forceReindex) {
+            return true;
+        }
+        const fileInfo = this.metadata.files[file.path];
+        if (!fileInfo) {
+            return true; // New file
+        }
+        if (fileInfo.hash !== file.hash) {
+            return true; // File changed
+        }
+        return false;
+    }
+    /**
+     * Indexes a single file
+     */
+    async indexFile(file, forceReindex = false) {
+        try {
+            // Check if file needs reindexing
+            if (!this.needsReindexing(file, forceReindex)) {
+                console.error(`Skipping ${file.path} (no changes)`);
+                return { chunksCreated: 0 };
+            }
+            console.error(`Indexing: ${file.path}`);
+            // Read file content
+            const content = fs.readFileSync(file.absolutePath, "utf-8");
+            // Get chunk size from environment or use defaults
+            const maxChunkSize = parseInt(process.env.MEMORYBANK_CHUNK_SIZE || "1000");
+            const chunkOverlap = parseInt(process.env.MEMORYBANK_CHUNK_OVERLAP || "200");
+            // Chunk the code
+            const chunks = chunkCode({
+                filePath: file.path,
+                content,
+                language: file.language,
+                maxChunkSize,
+                chunkOverlap,
+            });
+            if (chunks.length === 0) {
+                console.error(`Warning: No chunks created for ${file.path}`);
+                return { chunksCreated: 0 };
+            }
+            console.error(`  Created ${chunks.length} chunks`);
+            // Generate embeddings
+            const embeddingInputs = chunks.map((chunk) => ({
+                id: chunk.id,
+                content: chunk.content,
+            }));
+            const embeddings = await this.embeddingService.generateBatchEmbeddings(embeddingInputs);
+            console.error(`  Generated ${embeddings.length} embeddings`);
+            // Prepare chunk records for storage
+            const timestamp = Date.now();
+            const chunkRecords = chunks.map((chunk, i) => ({
+                id: chunk.id,
+                vector: embeddings[i].vector,
+                filePath: chunk.filePath,
+                content: chunk.content,
+                startLine: chunk.startLine,
+                endLine: chunk.endLine,
+                chunkType: chunk.chunkType,
+                name: chunk.name,
+                language: chunk.language,
+                fileHash: file.hash,
+                timestamp,
+                context: chunk.context,
+            }));
+            // Delete old chunks for this file
+            await this.vectorStore.deleteChunksByFile(file.path);
+            // Insert new chunks
+            await this.vectorStore.insertChunks(chunkRecords);
+            console.error(`  Stored ${chunkRecords.length} chunks in vector store`);
+            // Update metadata
+            this.metadata.files[file.path] = {
+                hash: file.hash,
+                lastIndexed: timestamp,
+                chunkCount: chunks.length,
+            };
+            this.metadata.lastIndexed = timestamp;
+            this.saveMetadata();
+            return { chunksCreated: chunks.length };
+        }
+        catch (error) {
+            const errorMsg = `Error indexing ${file.path}: ${error}`;
+            console.error(errorMsg);
+            return { chunksCreated: 0, error: errorMsg };
+        }
+    }
+    /**
+     * Indexes multiple files or a directory
+     */
+    async indexFiles(options) {
+        const startTime = Date.now();
+        console.error(`\n=== Starting indexing process ===`);
+        console.error(`Root path: ${options.rootPath}`);
+        console.error(`Force reindex: ${options.forceReindex || false}`);
+        // Initialize vector store
+        await this.vectorStore.initialize();
+        // Scan files
+        console.error(`\nScanning files...`);
+        const files = scanFiles({
+            rootPath: options.rootPath,
+            recursive: options.recursive !== undefined ? options.recursive : true,
+        });
+        if (files.length === 0) {
+            console.error("No files found to index");
+            return {
+                filesProcessed: 0,
+                chunksCreated: 0,
+                errors: [],
+                duration: Date.now() - startTime,
+            };
+        }
+        // Filter files that need reindexing
+        const filesToIndex = files.filter((file) => this.needsReindexing(file, options.forceReindex || false));
+        console.error(`\nFound ${files.length} files, ${filesToIndex.length} need indexing`);
+        if (filesToIndex.length === 0) {
+            console.error("All files are up to date");
+            return {
+                filesProcessed: 0,
+                chunksCreated: 0,
+                errors: [],
+                duration: Date.now() - startTime,
+            };
+        }
+        // Index files
+        const errors = [];
+        let totalChunks = 0;
+        let processedFiles = 0;
+        for (let i = 0; i < filesToIndex.length; i++) {
+            const file = filesToIndex[i];
+            console.error(`\n[${i + 1}/${filesToIndex.length}] Processing ${file.path}`);
+            const result = await this.indexFile(file, options.forceReindex || false);
+            if (result.error) {
+                errors.push(result.error);
+            }
+            else {
+                processedFiles++;
+                totalChunks += result.chunksCreated;
+            }
+        }
+        const duration = Date.now() - startTime;
+        console.error(`\n=== Indexing complete ===`);
+        console.error(`Files processed: ${processedFiles}`);
+        console.error(`Chunks created: ${totalChunks}`);
+        console.error(`Errors: ${errors.length}`);
+        console.error(`Duration: ${(duration / 1000).toFixed(2)}s`);
+        return {
+            filesProcessed: processedFiles,
+            chunksCreated: totalChunks,
+            errors,
+            duration,
+        };
+    }
+    /**
+     * Re-indexes a specific file by path
+     */
+    async reindexFile(filePath, rootPath) {
+        try {
+            // Scan the specific file
+            const file = scanSingleFile(filePath, rootPath);
+            if (!file) {
+                return {
+                    success: false,
+                    chunksCreated: 0,
+                    error: "File not found or not a code file",
+                };
+            }
+            // Initialize vector store
+            await this.vectorStore.initialize();
+            // Index the file
+            const result = await this.indexFile(file, true);
+            if (result.error) {
+                return {
+                    success: false,
+                    chunksCreated: 0,
+                    error: result.error,
+                };
+            }
+            return {
+                success: true,
+                chunksCreated: result.chunksCreated,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                chunksCreated: 0,
+                error: `Error reindexing file: ${error}`,
+            };
+        }
+    }
+    /**
+     * Gets statistics about the index
+     */
+    async getStats() {
+        await this.vectorStore.initialize();
+        const vectorStats = await this.vectorStore.getStats();
+        const fileHashes = await this.vectorStore.getFileHashes();
+        // Check for files that need reindexing
+        const pendingFiles = [];
+        for (const [filePath, storedHash] of fileHashes) {
+            const metadataHash = this.metadata.files[filePath]?.hash;
+            if (metadataHash && metadataHash !== storedHash) {
+                pendingFiles.push(filePath);
+            }
+        }
+        return {
+            totalFiles: vectorStats.fileCount,
+            totalChunks: vectorStats.totalChunks,
+            lastIndexed: vectorStats.lastUpdated,
+            languages: vectorStats.languageCounts,
+            pendingFiles: pendingFiles.length > 0 ? pendingFiles : undefined,
+        };
+    }
+    /**
+     * Searches the index
+     */
+    async search(query, options = {}) {
+        await this.vectorStore.initialize();
+        // Generate query embedding
+        const queryVector = await this.embeddingService.generateQueryEmbedding(query);
+        // Search vector store
+        const results = await this.vectorStore.search(queryVector, {
+            topK: options.topK || 10,
+            minScore: options.minScore || 0.0,
+            filterByFile: options.filterByFile,
+            filterByLanguage: options.filterByLanguage,
+        });
+        // Format results
+        return results.map((result) => ({
+            filePath: result.chunk.filePath,
+            content: result.chunk.content,
+            startLine: result.chunk.startLine,
+            endLine: result.chunk.endLine,
+            chunkType: result.chunk.chunkType,
+            name: result.chunk.name,
+            language: result.chunk.language,
+            score: result.score,
+        }));
+    }
+    /**
+     * Clears the entire index
+     */
+    async clearIndex() {
+        await this.vectorStore.initialize();
+        await this.vectorStore.clear();
+        this.metadata = {
+            version: "1.0",
+            lastIndexed: 0,
+            files: {},
+        };
+        this.saveMetadata();
+        // Clear embedding cache
+        this.embeddingService.clearCache();
+        console.error("Index cleared");
+    }
+    /**
+     * Removes a file from the index
+     */
+    async removeFile(filePath) {
+        await this.vectorStore.initialize();
+        await this.vectorStore.deleteChunksByFile(filePath);
+        delete this.metadata.files[filePath];
+        this.saveMetadata();
+        console.error(`Removed ${filePath} from index`);
+    }
+}
+/**
+ * Creates an index manager from environment variables
+ */
+export function createIndexManager(embeddingService, vectorStore) {
+    const storagePath = process.env.MEMORYBANK_STORAGE_PATH || ".memorybank";
+    return new IndexManager(embeddingService, vectorStore, storagePath);
+}

package/dist/common/setup.js

@@ -0,0 +1,49 @@
+// Global variables to store user IDs
+let adminUserId = null;
+import { getUserIdByEmail, getUserIdByUsername } from "./utils.js";
+/**
+ * Gets the admin user ID by looking up the user by email or username
+ *
+ * This function will try the following methods in order:
+ * 1. Use the cached admin user ID if available
+ * 2. Use the PLANKA_ADMIN_ID environment variable if set (for backwards compatibility)
+ * 3. Look up the admin user ID by email using PLANKA_ADMIN_EMAIL
+ * 4. Look up the admin user ID by username using PLANKA_ADMIN_USERNAME
+ */
+export async function getAdminUserId() {
+    if (adminUserId) {
+        return adminUserId;
+    }
+    try {
+        // Check for direct admin ID (for backwards compatibility)
+        const directAdminId = process.env.PLANKA_ADMIN_ID;
+        if (directAdminId) {
+            adminUserId = directAdminId;
+            return adminUserId;
+        }
+        // Try to get the admin ID by email
+        const adminEmail = process.env.PLANKA_ADMIN_EMAIL;
+        if (adminEmail) {
+            const id = await getUserIdByEmail(adminEmail);
+            if (id) {
+                adminUserId = id;
+                return adminUserId;
+            }
+        }
+        // If that fails, try to get the admin ID by username
+        const adminUsername = process.env.PLANKA_ADMIN_USERNAME;
+        if (adminUsername) {
+            const id = await getUserIdByUsername(adminUsername);
+            if (id) {
+                adminUserId = id;
+                return adminUserId;
+            }
+        }
+        console.error("Could not determine admin user ID. Please set PLANKA_ADMIN_ID, PLANKA_ADMIN_EMAIL, or PLANKA_ADMIN_USERNAME.");
+        return null;
+    }
+    catch (error) {
+        console.error("Failed to get admin user ID:", error);
+        return null;
+    }
+}

package/dist/common/types.js

@@ -0,0 +1,115 @@
+import { z } from "zod";
+// Planka schemas
+export const PlankaUserSchema = z.object({
+    id: z.string(),
+    email: z.string(),
+    name: z.string().nullable(),
+    username: z.string(),
+    avatarUrl: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string().nullable(),
+});
+export const PlankaProjectSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    background: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string().nullable(),
+});
+export const PlankaBoardSchema = z.object({
+    id: z.string(),
+    projectId: z.string(),
+    name: z.string(),
+    position: z.number(),
+    createdAt: z.string(),
+    updatedAt: z.string().nullable(),
+});
+export const PlankaListSchema = z.object({
+    id: z.string(),
+    boardId: z.string(),
+    name: z.string(),
+    position: z.number(),
+    createdAt: z.string(),
+    updatedAt: z.string().nullable(),
+});
+export const PlankaLabelSchema = z.object({
+    id: z.string(),
+    boardId: z.string(),
+    name: z.string(),
+    color: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string().nullable(),
+});
+// Define the stopwatch schema
+export const PlankaStopwatchSchema = z.object({
+    startedAt: z.string().nullable(),
+    total: z.number(),
+});
+export const PlankaCardSchema = z.object({
+    id: z.string(),
+    listId: z.string(),
+    name: z.string(),
+    description: z.string().nullable(),
+    position: z.number(),
+    dueDate: z.string().nullable(),
+    isCompleted: z.boolean().optional(),
+    stopwatch: PlankaStopwatchSchema.nullable().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string().nullable(),
+});
+export const PlankaTaskSchema = z.object({
+    id: z.string(),
+    cardId: z.string(),
+    name: z.string(),
+    isCompleted: z.boolean(),
+    position: z.number(),
+    createdAt: z.string(),
+    updatedAt: z.string().nullable(),
+});
+export const PlankaCommentSchema = z.object({
+    id: z.string(),
+    cardId: z.string(),
+    userId: z.string(),
+    text: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string().nullable(),
+});
+export const PlankaAttachmentSchema = z.object({
+    id: z.string(),
+    cardId: z.string(),
+    userId: z.string(),
+    name: z.string(),
+    url: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string().nullable(),
+});
+export const PlankaCardMembershipSchema = z.object({
+    id: z.string(),
+    cardId: z.string(),
+    userId: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string().nullable(),
+});
+export const PlankaBoardMembershipSchema = z.object({
+    id: z.string(),
+    boardId: z.string(),
+    userId: z.string(),
+    role: z.enum(["editor", "admin"]),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const PlankaProjectMembershipSchema = z.object({
+    id: z.string(),
+    projectId: z.string(),
+    userId: z.string(),
+    role: z.enum(["editor", "admin"]),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const PlankaCardLabelSchema = z.object({
+    id: z.string(),
+    cardId: z.string(),
+    labelId: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});