grepmind-app 0.1.0-alpha

package/dist/routes/project.js

@@ -0,0 +1,675 @@
+/**
+ * Project API Routes
+ *
+ * Handles project open/close/current operations.
+ * Maintains server-side state for the currently active project.
+ */
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+const execAsync = promisify(exec);
+import { emitEvent } from './events.js';
+import { createProjectContext, initializeContext, disposeContext, } from '../context.js';
+import { RAGConfigSchema, CONFIG_FILE_NAME, ALL_CONFIG_FILE_NAMES, loadRAGConfig, saveRAGConfig, findRAGConfig, createProject as createProjectUtil, } from 'grepmind-config';
+// Server-side state: currently active project
+let currentProject = null;
+/**
+ * Get current project state.
+ */
+export function getCurrentProject() {
+    return currentProject;
+}
+/**
+ * Get current project context or throw if no project is open.
+ */
+export function requireProjectContext() {
+    if (!currentProject) {
+        throw new Error('No project is currently open');
+    }
+    return currentProject.context;
+}
+/**
+ * Set current project state (used internally).
+ */
+function setCurrentProject(project) {
+    currentProject = project;
+}
+/**
+ * Check if secrets have changed and need context recreation.
+ */
+function secretsChanged(oldSecrets, newSecrets) {
+    return (oldSecrets.voyageApiKey !== newSecrets.voyageApiKey ||
+        oldSecrets.localaiApiKey !== newSecrets.localaiApiKey ||
+        oldSecrets.ollamaBaseUrl !== newSecrets.ollamaBaseUrl);
+}
+/**
+ * Update secrets and recreate context if needed.
+ * Call this before operations that use embedding provider.
+ */
+export async function updateSecretsIfNeeded(newSecrets) {
+    if (!currentProject)
+        return;
+    // Check if secrets relevant to embedding have changed
+    if (!secretsChanged(currentProject.secrets, newSecrets)) {
+        return;
+    }
+    // Dispose old context
+    await disposeContext(currentProject.context);
+    // Recreate context with new secrets
+    const newContext = await openProjectContext(currentProject.path, currentProject.config, newSecrets);
+    // Update project state
+    currentProject.context = newContext;
+    currentProject.secrets = newSecrets;
+}
+/**
+ * Load and validate project config from file path
+ */
+async function loadProjectConfig(configPath) {
+    return loadRAGConfig(configPath);
+}
+/**
+ * Validate project path has a config file
+ */
+async function validateProjectPath(projectPath) {
+    const configPath = await findRAGConfig(projectPath);
+    if (!configPath) {
+        throw new Error(`Project config not found. Expected ${CONFIG_FILE_NAME} or legacy config in: ${projectPath}`);
+    }
+    return loadProjectConfig(configPath);
+}
+/**
+ * Create and initialize project context with core indexers.
+ */
+async function openProjectContext(projectPath, config, secrets) {
+    const context = createProjectContext(projectPath, config, secrets);
+    await initializeContext(context);
+    return context;
+}
+/**
+ * Close current project and release resources.
+ */
+async function closeCurrentProject() {
+    if (!currentProject)
+        return;
+    await disposeContext(currentProject.context);
+    currentProject = null;
+}
+/**
+ * Register project routes
+ */
+export async function projectRoutes(app) {
+    /**
+     * POST /api/project/open
+     * Open a project by path, validating config exists
+     */
+    app.post('/open', {
+        schema: {
+            body: {
+                type: 'object',
+                required: ['path'],
+                properties: {
+                    path: { type: 'string' },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        const { path: projectPath } = request.body;
+        try {
+            // Resolve to absolute path
+            const absolutePath = path.resolve(projectPath);
+            // Check directory exists
+            const stat = await fs.stat(absolutePath);
+            if (!stat.isDirectory()) {
+                return reply.status(400).send({
+                    error: 'Invalid path',
+                    message: 'Path must be a directory',
+                });
+            }
+            // If the same project is already open, just return current state
+            // This prevents interrupting background sync on page refresh
+            const existingProject = getCurrentProject();
+            if (existingProject && existingProject.path === absolutePath) {
+                // Update secrets if provided
+                const secrets = request.secrets || {};
+                if (Object.keys(secrets).length > 0) {
+                    await updateSecretsIfNeeded(secrets);
+                }
+                // Return existing project info without reinitializing
+                return reply.send({
+                    name: existingProject.config.name || path.basename(absolutePath),
+                    path: absolutePath,
+                    vaultPaths: existingProject.config.vaultPaths,
+                    code: existingProject.config.code.enabled ? {
+                        include: existingProject.config.code.include,
+                        exclude: existingProject.config.code.exclude,
+                    } : null,
+                    embeddingProvider: existingProject.config.embedding.provider,
+                    openedAt: existingProject.openedAt,
+                });
+            }
+            // Validate project config
+            const config = await validateProjectPath(absolutePath);
+            // Close existing project if any (different project)
+            await closeCurrentProject();
+            // Get secrets from request (via middleware)
+            const secrets = request.secrets || {};
+            // Create and initialize project context
+            const context = await openProjectContext(absolutePath, config, secrets);
+            // Set as current project
+            const projectState = {
+                path: absolutePath,
+                config,
+                context,
+                openedAt: new Date().toISOString(),
+                secrets,
+            };
+            setCurrentProject(projectState);
+            // Emit project opened event
+            emitEvent({
+                type: 'project:opened',
+                data: {
+                    path: absolutePath,
+                    name: config.name || path.basename(absolutePath),
+                },
+            });
+            // Return project info
+            return reply.send({
+                name: config.name || path.basename(absolutePath),
+                path: absolutePath,
+                vaultPaths: config.vaultPaths,
+                code: config.code.enabled ? {
+                    include: config.code.include,
+                    exclude: config.code.exclude,
+                } : null,
+                embeddingProvider: config.embedding.provider,
+                openedAt: projectState.openedAt,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            if (message.includes('not found')) {
+                return reply.status(404).send({
+                    error: 'Project config not found',
+                    message: `No ${CONFIG_FILE_NAME} found in ${projectPath}`,
+                });
+            }
+            if (message.includes('Invalid')) {
+                return reply.status(400).send({
+                    error: 'Invalid project config',
+                    message,
+                });
+            }
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to open project',
+                message,
+            });
+        }
+    });
+    /**
+     * POST /api/project/open-config
+     * Open a project by config file path
+     */
+    app.post('/open-config', {
+        schema: {
+            body: {
+                type: 'object',
+                required: ['configPath'],
+                properties: {
+                    configPath: { type: 'string' },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        const { configPath } = request.body;
+        try {
+            // Resolve to absolute path
+            const absoluteConfigPath = path.resolve(configPath);
+            // Verify it's a file and ends with .json
+            const stat = await fs.stat(absoluteConfigPath);
+            if (!stat.isFile()) {
+                return reply.status(400).send({
+                    error: 'Invalid path',
+                    message: 'Path must be a file',
+                });
+            }
+            const fileName = path.basename(absoluteConfigPath);
+            if (!ALL_CONFIG_FILE_NAMES.includes(fileName)) {
+                return reply.status(400).send({
+                    error: 'Invalid config file',
+                    message: `Expected file named: ${ALL_CONFIG_FILE_NAMES.join(' or ')}`,
+                });
+            }
+            // Project directory is parent of config file
+            const projectPath = path.dirname(absoluteConfigPath);
+            // If the same project is already open, just return current state
+            // This prevents interrupting background sync on page refresh
+            const existingProject = getCurrentProject();
+            if (existingProject && existingProject.path === projectPath) {
+                // Update secrets if provided
+                const secrets = request.secrets || {};
+                if (Object.keys(secrets).length > 0) {
+                    await updateSecretsIfNeeded(secrets);
+                }
+                // Return existing project info without reinitializing
+                return reply.send({
+                    name: existingProject.config.name || path.basename(projectPath),
+                    path: projectPath,
+                    vaultPaths: existingProject.config.vaultPaths,
+                    code: existingProject.config.code.enabled ? {
+                        include: existingProject.config.code.include,
+                        exclude: existingProject.config.code.exclude,
+                    } : null,
+                    embeddingProvider: existingProject.config.embedding.provider,
+                    openedAt: existingProject.openedAt,
+                });
+            }
+            // Load config from file
+            const config = await loadProjectConfig(absoluteConfigPath);
+            // Close existing project if any (different project)
+            await closeCurrentProject();
+            // Get secrets from request (via middleware)
+            const secrets = request.secrets || {};
+            // Create and initialize project context
+            const context = await openProjectContext(projectPath, config, secrets);
+            // Set as current project
+            const projectState = {
+                path: projectPath,
+                config,
+                context,
+                openedAt: new Date().toISOString(),
+                secrets,
+            };
+            setCurrentProject(projectState);
+            // Emit project opened event
+            emitEvent({
+                type: 'project:opened',
+                data: {
+                    path: projectPath,
+                    name: config.name || path.basename(projectPath),
+                },
+            });
+            // Return project info
+            return reply.send({
+                name: config.name || path.basename(projectPath),
+                path: projectPath,
+                vaultPaths: config.vaultPaths,
+                code: config.code.enabled ? {
+                    include: config.code.include,
+                    exclude: config.code.exclude,
+                } : null,
+                embeddingProvider: config.embedding.provider,
+                openedAt: projectState.openedAt,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            if (message.includes('not found')) {
+                return reply.status(404).send({
+                    error: 'Config file not found',
+                    message,
+                });
+            }
+            if (message.includes('Invalid')) {
+                return reply.status(400).send({
+                    error: 'Invalid config',
+                    message,
+                });
+            }
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to open project',
+                message,
+            });
+        }
+    });
+    /**
+     * GET /api/project/current
+     * Get currently active project or null
+     */
+    app.get('/current', async (request, reply) => {
+        if (!currentProject) {
+            return reply.send(null);
+        }
+        const { path: projectPath, config, openedAt } = currentProject;
+        return reply.send({
+            name: config.name || path.basename(projectPath),
+            path: projectPath,
+            vaultPaths: config.vaultPaths,
+            code: config.code.enabled ? {
+                include: config.code.include,
+                exclude: config.code.exclude,
+            } : null,
+            embeddingProvider: config.embedding.provider,
+            openedAt,
+        });
+    });
+    /**
+     * POST /api/project/close
+     * Close the current project
+     */
+    app.post('/close', async (request, reply) => {
+        if (!currentProject) {
+            return reply.status(400).send({
+                error: 'No project open',
+                message: 'No project is currently open',
+            });
+        }
+        const closedPath = currentProject.path;
+        await closeCurrentProject();
+        // Emit project closed event
+        emitEvent({
+            type: 'project:closed',
+            data: { path: closedPath },
+        });
+        return reply.send({ success: true });
+    });
+    /**
+     * GET /api/project/stats
+     * Get index statistics for current project
+     */
+    app.get('/stats', async (request, reply) => {
+        if (!currentProject) {
+            return reply.status(400).send({
+                error: 'No project open',
+                message: 'No project is currently open',
+            });
+        }
+        const { context, config } = currentProject;
+        try {
+            // Get notes index stats
+            let notesCount = 0;
+            let notesLastSync = null;
+            try {
+                const notesStats = await context.indexer.getStats();
+                notesCount = notesStats.totalFiles;
+                // Get last sync from git syncer if available
+                if (context.notesSyncer) {
+                    const syncState = await context.notesSyncer.getState();
+                    if (syncState?.lastSyncTimestamp) {
+                        notesLastSync = new Date(syncState.lastSyncTimestamp).toISOString();
+                    }
+                }
+            }
+            catch {
+                // Index might not exist yet
+            }
+            // Get code index stats if enabled
+            let codeCount = 0;
+            let codeLastSync = null;
+            const codeEnabled = (config.code.enabled || (config.code.include && config.code.include.length > 0)) && !!context.codeIndexer;
+            if (codeEnabled && context.codeIndexer) {
+                try {
+                    const codeStats = await context.codeIndexer.getStats();
+                    codeCount = codeStats.totalFiles;
+                    // TODO: Add code git syncer state
+                }
+                catch {
+                    // Index might not exist yet
+                }
+            }
+            return reply.send({
+                notesCount,
+                codeCount,
+                notesLastSync,
+                codeLastSync,
+                codeEnabled,
+            });
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to get stats',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/project/config
+     * Get the full configuration of the current project
+     */
+    app.get('/config', async (request, reply) => {
+        if (!currentProject) {
+            return reply.status(400).send({
+                error: 'No project open',
+                message: 'No project is currently open',
+            });
+        }
+        // Return the full config with the project path
+        return reply.send({
+            path: currentProject.path,
+            config: currentProject.config,
+        });
+    });
+    /**
+     * PUT /api/project/config
+     * Update the current project configuration
+     */
+    app.put('/config', async (request, reply) => {
+        if (!currentProject) {
+            return reply.status(400).send({
+                error: 'No project open',
+                message: 'No project is currently open',
+            });
+        }
+        try {
+            const updates = request.body;
+            // Merge with existing config (deep merge for nested objects)
+            const newConfig = {
+                ...currentProject.config,
+                ...updates,
+                embedding: {
+                    ...currentProject.config.embedding,
+                    ...(updates.embedding || {}),
+                },
+                reranking: {
+                    ...currentProject.config.reranking,
+                    ...(updates.reranking || {}),
+                },
+                code: {
+                    ...currentProject.config.code,
+                    ...(updates.code || {}),
+                },
+                gitSync: {
+                    ...currentProject.config.gitSync,
+                    ...(updates.gitSync || {}),
+                },
+                lancedb: {
+                    ...currentProject.config.lancedb,
+                    ...(updates.lancedb || {}),
+                },
+            };
+            // Validate the merged config
+            const validatedConfig = RAGConfigSchema.parse(newConfig);
+            // Find the config file to update
+            const configPath = await findRAGConfig(currentProject.path);
+            if (!configPath) {
+                return reply.status(500).send({
+                    error: 'Config file not found',
+                    message: 'Could not find config file in project directory',
+                });
+            }
+            // Write the updated config
+            await saveRAGConfig(configPath, validatedConfig);
+            // Check if embedding provider changed - need to reinitialize context
+            const embeddingChanged = currentProject.config.embedding.provider !== validatedConfig.embedding.provider ||
+                currentProject.config.embedding.model !== validatedConfig.embedding.model;
+            const codeChanged = currentProject.config.code.enabled !== validatedConfig.code.enabled ||
+                JSON.stringify(currentProject.config.code.include) !== JSON.stringify(validatedConfig.code.include) ||
+                currentProject.config.code.graph?.enabled !== validatedConfig.code.graph?.enabled ||
+                currentProject.config.code.tree?.enabled !== validatedConfig.code.tree?.enabled;
+            // Update the in-memory config
+            currentProject.config = validatedConfig;
+            // Get secrets from request (via middleware) - may have new secrets
+            const secrets = request.secrets || currentProject.secrets;
+            // Reinitialize context if embedding or code settings changed
+            if (embeddingChanged || codeChanged) {
+                await disposeContext(currentProject.context);
+                currentProject.context = await openProjectContext(currentProject.path, validatedConfig, secrets);
+                currentProject.secrets = secrets;
+            }
+            // Emit config updated event
+            emitEvent({
+                type: 'project:config:updated',
+                data: {
+                    path: currentProject.path,
+                    config: validatedConfig,
+                },
+            });
+            return reply.send({
+                success: true,
+                config: validatedConfig,
+            });
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return reply.status(400).send({
+                    error: 'Invalid config',
+                    message: error.message,
+                });
+            }
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to update config',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * POST /api/project/create
+     * Create a new project with full initialization
+     */
+    app.post('/create', async (request, reply) => {
+        const { path: projectPath, config: configInput } = request.body;
+        try {
+            const absolutePath = path.resolve(projectPath);
+            // Check if project already exists
+            const existingConfig = await findRAGConfig(absolutePath);
+            if (existingConfig) {
+                return reply.status(400).send({
+                    error: 'Project already exists',
+                    message: `A project already exists at ${absolutePath}`,
+                });
+            }
+            // Create project using config utility
+            const configPath = await createProjectUtil(absolutePath, {
+                name: configInput.name,
+                vaultPaths: configInput.vaultPaths,
+                lancedb: configInput.lancedb,
+                embedding: configInput.embedding,
+                reranking: configInput.reranking,
+                code: configInput.code,
+                gitSync: configInput.gitSync,
+            });
+            // Load the created config
+            const config = await loadRAGConfig(configPath);
+            // Emit project created event
+            emitEvent({
+                type: 'project:created',
+                data: {
+                    path: absolutePath,
+                    name: config.name || path.basename(absolutePath),
+                },
+            });
+            return reply.send({
+                success: true,
+                path: absolutePath,
+                configPath,
+                config,
+            });
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return reply.status(400).send({
+                    error: 'Invalid config',
+                    message: error.message,
+                });
+            }
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to create project',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/project/validate
+     * Validate a project path without opening it
+     */
+    app.get('/validate', {
+        schema: {
+            querystring: {
+                type: 'object',
+                required: ['path'],
+                properties: {
+                    path: { type: 'string' },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        const { path: projectPath } = request.query;
+        app.log.info(`Validating project path: ${projectPath}`);
+        try {
+            const absolutePath = path.resolve(projectPath);
+            app.log.info(`Resolved to: ${absolutePath}`);
+            const config = await validateProjectPath(absolutePath);
+            return reply.send({
+                valid: true,
+                name: config.name || path.basename(absolutePath),
+                path: absolutePath,
+                hasVault: config.vaultPaths.length > 0,
+                hasCode: config.code.enabled,
+            });
+        }
+        catch (error) {
+            app.log.error(`Validation error: ${error}`);
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return reply.send({
+                valid: false,
+                error: message,
+            });
+        }
+    });
+    /**
+     * POST /api/project/browse
+     * Open native file/folder dialog and return selected path
+     */
+    app.post('/browse', {
+        schema: {
+            body: {
+                type: 'object',
+                properties: {
+                    type: { type: 'string', enum: ['file', 'folder'] },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        const { type = 'folder' } = request.body || {};
+        try {
+            // Use osascript for native macOS dialog
+            const script = type === 'folder'
+                ? 'osascript -e \'tell application "System Events" to activate\' -e \'POSIX path of (choose folder with prompt "Select folder")\''
+                : 'osascript -e \'tell application "System Events" to activate\' -e \'POSIX path of (choose file with prompt "Select file")\'';
+            const { stdout } = await execAsync(script);
+            const selectedPath = stdout.trim();
+            if (!selectedPath) {
+                return reply.send({ cancelled: true });
+            }
+            return reply.send({ path: selectedPath });
+        }
+        catch (error) {
+            // User cancelled dialog (error code -128)
+            if (error instanceof Error && error.message.includes('-128')) {
+                return reply.send({ cancelled: true });
+            }
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to open dialog',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+}
+//# sourceMappingURL=project.js.map