grepmind-app 0.1.0-alpha

package/dist/routes/code.js

@@ -0,0 +1,974 @@
+/**
+ * Code API Routes
+ *
+ * Handles code index operations: search, symbols, files, status, sync.
+ * All operations work on the currently active project.
+ */
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { glob } from 'glob';
+import { getCurrentProject, requireProjectContext, updateSecretsIfNeeded } from './project.js';
+import { emitEvent } from './events.js';
+import { createSyncHandler } from './sync-handler.js';
+import { isError, getGitInfo } from 'grepmind-core';
+import { validateSecrets } from 'grepmind-config';
+/**
+ * Ensure a project is open and code indexing is enabled
+ */
+function requireCodeEnabled(reply) {
+    const project = getCurrentProject();
+    if (!project) {
+        reply.status(400).send({
+            error: 'No project open',
+            message: 'Open a project first using POST /api/project/open',
+        });
+        return false;
+    }
+    if (!project.config.code.enabled) {
+        reply.status(400).send({
+            error: 'Code indexing disabled',
+            message: 'Code indexing is not enabled for this project',
+        });
+        return false;
+    }
+    return true;
+}
+/**
+ * Get code root path for current project
+ */
+function getCodePaths() {
+    const project = getCurrentProject();
+    if (!project || !project.config.code.enabled)
+        return null;
+    // Code root is always the project directory
+    return [project.path];
+}
+/**
+ * Get primary code path (first from array, or project root).
+ * Used for backward compatibility with single-path operations.
+ */
+function getCodePath() {
+    const paths = getCodePaths();
+    return paths ? paths[0] : null;
+}
+/**
+ * Detect language from file extension
+ */
+function detectLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const languageMap = {
+        '.ts': 'typescript',
+        '.tsx': 'typescript',
+        '.js': 'javascript',
+        '.jsx': 'javascript',
+        '.py': 'python',
+        '.go': 'go',
+        '.rs': 'rust',
+        '.java': 'java',
+        '.c': 'c',
+        '.cpp': 'cpp',
+        '.h': 'c',
+        '.hpp': 'cpp',
+        '.cs': 'csharp',
+        '.rb': 'ruby',
+        '.php': 'php',
+        '.swift': 'swift',
+        '.kt': 'kotlin',
+        '.scala': 'scala',
+        '.vue': 'vue',
+        '.svelte': 'svelte',
+        '.html': 'html',
+        '.css': 'css',
+        '.scss': 'scss',
+        '.less': 'less',
+        '.json': 'json',
+        '.yaml': 'yaml',
+        '.yml': 'yaml',
+        '.toml': 'toml',
+        '.md': 'markdown',
+        '.sh': 'bash',
+        '.bash': 'bash',
+        '.zsh': 'zsh',
+        '.sql': 'sql',
+        '.graphql': 'graphql',
+        '.gql': 'graphql',
+    };
+    return languageMap[ext] || 'unknown';
+}
+/**
+ * Register code routes
+ */
+export async function codeRoutes(app) {
+    /**
+     * GET /api/code/status
+     * Get code index status for current project
+     */
+    app.get('/status', async (request, reply) => {
+        const project = getCurrentProject();
+        if (!project) {
+            return reply.status(400).send({
+                error: 'No project open',
+                message: 'Open a project first using POST /api/project/open',
+            });
+        }
+        if (!project.config.code.enabled) {
+            return reply.send({
+                enabled: false,
+                totalFiles: 0,
+                indexedFiles: 0,
+                totalSymbols: 0,
+                languages: {},
+            });
+        }
+        try {
+            const context = requireProjectContext();
+            const codePath = getCodePath();
+            if (!context.codeIndexer) {
+                return reply.send({
+                    enabled: true,
+                    totalFiles: 0,
+                    indexedFiles: 0,
+                    totalSymbols: 0,
+                    languages: {},
+                });
+            }
+            // Get actual stats from CodeIndexer
+            const stats = await context.codeIndexer.getStats();
+            // Get git info for branch awareness
+            const gitInfo = codePath ? getGitInfo(codePath) : null;
+            // Get overlay info if branch indexer is available
+            let overlayInfo = null;
+            if (context.codeBranchIndexer) {
+                overlayInfo = await context.codeBranchIndexer.getInfo();
+            }
+            const status = {
+                enabled: true,
+                totalFiles: stats.totalFiles,
+                indexedFiles: stats.totalFiles,
+                totalSymbols: stats.totalChunks,
+                languages: stats.languages,
+                lastSync: undefined,
+                lastSyncCommit: undefined,
+                branch: gitInfo?.branch || null,
+                isMainBranch: gitInfo?.isMainBranch ?? null,
+                overlay: overlayInfo,
+            };
+            return reply.send(status);
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to get status',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/code/git-info
+     * Get git branch information for current project's code path
+     */
+    app.get('/git-info', async (request, reply) => {
+        const codePath = getCodePath();
+        if (!codePath) {
+            return reply.send({
+                isGitRepo: false,
+                branch: null,
+                isMainBranch: null,
+                mainBranch: null,
+            });
+        }
+        const gitInfo = getGitInfo(codePath);
+        return reply.send({
+            isGitRepo: !!gitInfo,
+            branch: gitInfo?.branch || null,
+            isMainBranch: gitInfo?.isMainBranch ?? null,
+            mainBranch: gitInfo?.mainBranch || null,
+        });
+    });
+    /**
+     * GET /api/code/files
+     * List all code files with index status
+     */
+    app.get('/files', {
+        schema: {
+            querystring: {
+                type: 'object',
+                properties: {
+                    folder: { type: 'string' },
+                    language: { type: 'string' },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireCodeEnabled(reply))
+            return;
+        const { folder, language } = request.query;
+        const project = getCurrentProject();
+        const codePath = getCodePath();
+        const include = project.config.code.include || ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'];
+        const exclude = project.config.code.exclude || ['**/node_modules/**', '**/dist/**'];
+        try {
+            const context = requireProjectContext();
+            // Get indexed files for status lookup
+            let indexedPaths = new Set();
+            if (context.codeIndexer) {
+                indexedPaths = await context.codeIndexer.getIndexedFilePaths();
+            }
+            const codeFiles = [];
+            for (const pattern of include) {
+                const searchPattern = folder ? `${folder}/${pattern}` : pattern;
+                const files = await glob(searchPattern, {
+                    cwd: codePath,
+                    nodir: true,
+                    ignore: exclude,
+                });
+                for (const file of files) {
+                    const fullPath = path.join(codePath, file);
+                    const fileLang = detectLanguage(file);
+                    // Filter by language if specified
+                    if (language && fileLang !== language)
+                        continue;
+                    const stat = await fs.stat(fullPath);
+                    codeFiles.push({
+                        path: fullPath,
+                        name: path.basename(file),
+                        relativePath: file,
+                        language: fileLang,
+                        indexStatus: indexedPaths.has(file) ? 'indexed' : 'unindexed',
+                        size: stat.size,
+                    });
+                }
+            }
+            return reply.send(codeFiles);
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to list files',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/code/file/:path
+     * Get details for a specific code file with symbols
+     */
+    app.get('/file/*', async (request, reply) => {
+        if (!requireCodeEnabled(reply))
+            return;
+        const filePath = request.params['*'];
+        const codePath = getCodePath();
+        const fullPath = path.join(codePath, filePath);
+        try {
+            // Ensure path is within code root
+            if (!fullPath.startsWith(codePath)) {
+                return reply.status(400).send({
+                    error: 'Invalid path',
+                    message: 'Path must be within code root',
+                });
+            }
+            const stat = await fs.stat(fullPath);
+            const content = await fs.readFile(fullPath, 'utf-8');
+            // TODO: Get symbols from index
+            return reply.send({
+                path: fullPath,
+                name: path.basename(filePath),
+                relativePath: filePath,
+                language: detectLanguage(filePath),
+                indexStatus: 'unindexed',
+                size: stat.size,
+                content,
+                symbols: [], // TODO: Get from index
+            });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return reply.status(404).send({
+                    error: 'File not found',
+                    message: `Code file not found: ${filePath}`,
+                });
+            }
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Failed to get file',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/code/search
+     * Semantic search in code
+     */
+    app.get('/search', {
+        schema: {
+            querystring: {
+                type: 'object',
+                required: ['q'],
+                properties: {
+                    q: { type: 'string' },
+                    limit: { type: 'number', default: 10 },
+                    threshold: { type: 'number', default: 0.5 },
+                    language: { type: 'string' },
+                    symbolType: { type: 'string' },
+                    path: { type: 'string' },
+                    mode: { type: 'string', enum: ['hybrid', 'semantic', 'text'], default: 'hybrid' },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireCodeEnabled(reply))
+            return;
+        const { q, limit = 10, threshold = 0.5, language, symbolType, path: pathFilter, mode = 'hybrid' } = request.query;
+        try {
+            // Update secrets if changed (e.g., Voyage API key added after project open)
+            await updateSecretsIfNeeded(request.secrets || {});
+            const context = requireProjectContext();
+            if (!context.codeIndexer) {
+                return reply.status(400).send({
+                    error: 'Code indexer not available',
+                    message: 'Code indexing is not initialized for this project',
+                });
+            }
+            let searchResults;
+            if (mode === 'text') {
+                searchResults = await context.codeIndexer.searchFts({
+                    query: q,
+                    limit,
+                    language,
+                    symbolTypes: symbolType ? [symbolType] : undefined,
+                    path: pathFilter,
+                });
+            }
+            else if (mode === 'semantic') {
+                searchResults = await context.codeIndexer.search(q, {
+                    limit,
+                    threshold,
+                    language,
+                    symbolTypes: symbolType ? [symbolType] : undefined,
+                    path: pathFilter,
+                });
+            }
+            else {
+                searchResults = await context.codeIndexer.searchHybrid({
+                    query: q,
+                    limit,
+                    threshold,
+                    language,
+                    symbolTypes: symbolType ? [symbolType] : undefined,
+                    path: pathFilter,
+                });
+            }
+            if (isError(searchResults)) {
+                return reply.status(500).send({
+                    error: 'Search failed',
+                    message: searchResults.message,
+                });
+            }
+            const results = searchResults.map(r => ({
+                symbol: {
+                    id: r.id,
+                    name: r.symbolName,
+                    type: r.symbolType,
+                    path: path.join(getCodePath(), r.path),
+                    relativePath: r.path,
+                    signature: r.signature,
+                    docstring: r.docstring,
+                    startLine: r.startLine,
+                    endLine: r.endLine,
+                    parentSymbol: r.parentSymbol,
+                },
+                score: r.score,
+                content: r.content,
+            }));
+            return reply.send({
+                query: q,
+                results,
+                total: results.length,
+            });
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Search failed',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/code/symbols
+     * Search symbols by name (exact or wildcard)
+     */
+    app.get('/symbols', {
+        schema: {
+            querystring: {
+                type: 'object',
+                required: ['name'],
+                properties: {
+                    name: { type: 'string' },
+                    type: { type: 'string' },
+                    path: { type: 'string' },
+                    limit: { type: 'number', default: 20 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireCodeEnabled(reply))
+            return;
+        const { name, type, path: pathFilter, limit = 20 } = request.query;
+        try {
+            const context = requireProjectContext();
+            if (!context.codeIndexer) {
+                return reply.status(400).send({
+                    error: 'Code indexer not available',
+                    message: 'Code indexing is not initialized for this project',
+                });
+            }
+            // Convert absolute path to relative if needed
+            const codePath = getCodePath();
+            let relativePath = pathFilter;
+            if (pathFilter && path.isAbsolute(pathFilter) && pathFilter.startsWith(codePath)) {
+                relativePath = path.relative(codePath, pathFilter);
+            }
+            const searchResults = await context.codeIndexer.findSymbols(name, {
+                type,
+                path: relativePath,
+                limit,
+            });
+            if (isError(searchResults)) {
+                return reply.status(500).send({
+                    error: 'Symbol search failed',
+                    message: searchResults.message,
+                });
+            }
+            const symbols = searchResults.map(r => ({
+                id: r.id,
+                name: r.symbolName,
+                type: r.symbolType,
+                path: path.join(codePath, r.path),
+                relativePath: r.path,
+                signature: r.signature,
+                docstring: r.docstring,
+                startLine: r.startLine,
+                endLine: r.endLine,
+                parentSymbol: r.parentSymbol,
+                score: r.score,
+            }));
+            return reply.send({
+                name,
+                symbols,
+                total: symbols.length,
+            });
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Symbol search failed',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/code/graph/refs
+     * Find references for a symbol.
+     */
+    app.get('/graph/refs', {
+        schema: {
+            querystring: {
+                type: 'object',
+                properties: {
+                    symbolId: { type: 'string' },
+                    symbolName: { type: 'string' },
+                    file: { type: 'string' },
+                    includeImports: { type: 'boolean', default: true },
+                    limit: { type: 'number', default: 50 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireCodeEnabled(reply))
+            return;
+        const { symbolId, symbolName, file, includeImports = true, limit = 50 } = request.query;
+        if (!symbolId && !symbolName) {
+            return reply.status(400).send({
+                error: 'Invalid query',
+                message: 'Provide either symbolId or symbolName',
+            });
+        }
+        try {
+            const context = requireProjectContext();
+            if (!context.codeIndexer) {
+                return reply.status(400).send({
+                    error: 'Code indexer not available',
+                    message: 'Code indexing is not initialized for this project',
+                });
+            }
+            // Convert absolute path to relative if needed
+            let relativeFile = file;
+            if (file) {
+                const codePath = getCodePath();
+                if (path.isAbsolute(file) && file.startsWith(codePath)) {
+                    relativeFile = path.relative(codePath, file);
+                }
+            }
+            const result = await context.codeIndexer.graphRefs({
+                symbolId,
+                symbolName,
+                file: relativeFile,
+                includeImports,
+                limit,
+            });
+            if (isError(result)) {
+                const statusCode = result.code === 'NOT_FOUND' ? 404 : 500;
+                return reply.status(statusCode).send({
+                    error: result.code,
+                    message: result.message,
+                });
+            }
+            return reply.send(result);
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Graph refs failed',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/code/graph/calls
+     * Build callers/callees graph for a symbol.
+     */
+    app.get('/graph/calls', {
+        schema: {
+            querystring: {
+                type: 'object',
+                properties: {
+                    symbolId: { type: 'string' },
+                    symbolName: { type: 'string' },
+                    direction: { type: 'string', enum: ['callers', 'callees', 'both'], default: 'both' },
+                    depth: { type: 'number', default: 2 },
+                    limit: { type: 'number', default: 50 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireCodeEnabled(reply))
+            return;
+        const { symbolId, symbolName, direction = 'both', depth = 2, limit = 50 } = request.query;
+        if (!symbolId && !symbolName) {
+            return reply.status(400).send({
+                error: 'Invalid query',
+                message: 'Provide either symbolId or symbolName',
+            });
+        }
+        try {
+            const context = requireProjectContext();
+            if (!context.codeIndexer) {
+                return reply.status(400).send({
+                    error: 'Code indexer not available',
+                    message: 'Code indexing is not initialized for this project',
+                });
+            }
+            const result = await context.codeIndexer.graphCalls({
+                symbolId,
+                symbolName,
+                direction,
+                depth,
+                limit,
+            });
+            if (isError(result)) {
+                const statusCode = result.code === 'NOT_FOUND' ? 404 : 500;
+                return reply.status(statusCode).send({
+                    error: result.code,
+                    message: result.message,
+                });
+            }
+            return reply.send(result);
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Graph calls failed',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/code/graph/deps
+     * Build file dependency graph (imports/importedBy).
+     */
+    app.get('/graph/deps', {
+        schema: {
+            querystring: {
+                type: 'object',
+                required: ['file'],
+                properties: {
+                    file: { type: 'string' },
+                    direction: { type: 'string', enum: ['imports', 'importedBy', 'both'], default: 'both' },
+                    depth: { type: 'number', default: 1 },
+                    includeExternal: { type: 'boolean', default: false },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireCodeEnabled(reply))
+            return;
+        const { file, direction = 'both', depth = 1, includeExternal = false } = request.query;
+        try {
+            const context = requireProjectContext();
+            if (!context.codeIndexer) {
+                return reply.status(400).send({
+                    error: 'Code indexer not available',
+                    message: 'Code indexing is not initialized for this project',
+                });
+            }
+            // Convert absolute path to relative if needed
+            const codePath = getCodePath();
+            let relativeFile = file;
+            if (path.isAbsolute(file) && file.startsWith(codePath)) {
+                relativeFile = path.relative(codePath, file);
+            }
+            const result = await context.codeIndexer.graphDeps({
+                file: relativeFile,
+                direction,
+                depth,
+                includeExternal,
+            });
+            if (isError(result)) {
+                const statusCode = result.code === 'NOT_FOUND' ? 404 : 500;
+                return reply.status(statusCode).send({
+                    error: result.code,
+                    message: result.message,
+                });
+            }
+            return reply.send(result);
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Graph deps failed',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/code/graph/hierarchy
+     * Build class/interface hierarchy for a symbol.
+     */
+    app.get('/graph/hierarchy', {
+        schema: {
+            querystring: {
+                type: 'object',
+                properties: {
+                    symbolId: { type: 'string' },
+                    symbolName: { type: 'string' },
+                    direction: { type: 'string', enum: ['ancestors', 'descendants', 'both'], default: 'both' },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireCodeEnabled(reply))
+            return;
+        const { symbolId, symbolName, direction = 'both' } = request.query;
+        if (!symbolId && !symbolName) {
+            return reply.status(400).send({
+                error: 'Invalid query',
+                message: 'Provide either symbolId or symbolName',
+            });
+        }
+        try {
+            const context = requireProjectContext();
+            if (!context.codeIndexer) {
+                return reply.status(400).send({
+                    error: 'Code indexer not available',
+                    message: 'Code indexing is not initialized for this project',
+                });
+            }
+            const result = await context.codeIndexer.graphHierarchy({
+                symbolId,
+                symbolName,
+                direction,
+            });
+            if (isError(result)) {
+                const statusCode = result.code === 'NOT_FOUND' ? 404 : 500;
+                return reply.status(statusCode).send({
+                    error: result.code,
+                    message: result.message,
+                });
+            }
+            return reply.send(result);
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Graph hierarchy failed',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * GET /api/code/grep
+     * Exact text search in code files
+     */
+    app.get('/grep', {
+        schema: {
+            querystring: {
+                type: 'object',
+                required: ['pattern'],
+                properties: {
+                    pattern: { type: 'string' },
+                    regex: { type: 'boolean', default: false },
+                    caseSensitive: { type: 'boolean', default: false },
+                    limit: { type: 'number', default: 20 },
+                    language: { type: 'string' },
+                    context: { type: 'number', default: 1 },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireCodeEnabled(reply))
+            return;
+        const { pattern, regex = false, caseSensitive = false, limit = 20, language, context: contextLines = 1 } = request.query;
+        try {
+            const project = getCurrentProject();
+            const codePath = getCodePath();
+            const include = project.config.code.include || ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'];
+            const exclude = project.config.code.exclude || ['**/node_modules/**', '**/dist/**'];
+            // Build regex for search
+            let searchRegex;
+            try {
+                if (regex) {
+                    searchRegex = new RegExp(pattern, caseSensitive ? 'g' : 'gi');
+                }
+                else {
+                    // Escape special regex characters for literal search
+                    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                    searchRegex = new RegExp(escaped, caseSensitive ? 'g' : 'gi');
+                }
+            }
+            catch {
+                return reply.status(400).send({
+                    error: 'Invalid pattern',
+                    message: 'Invalid regular expression pattern',
+                });
+            }
+            const results = [];
+            let totalMatches = 0;
+            // Search through code files
+            for (const includePattern of include) {
+                const files = await glob(includePattern, {
+                    cwd: codePath,
+                    nodir: true,
+                    ignore: exclude,
+                });
+                for (const file of files) {
+                    if (totalMatches >= limit)
+                        break;
+                    const fileLang = detectLanguage(file);
+                    if (language && fileLang !== language)
+                        continue;
+                    const fullPath = path.join(codePath, file);
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    const lines = content.split('\n');
+                    const fileMatches = [];
+                    for (let i = 0; i < lines.length; i++) {
+                        if (totalMatches >= limit)
+                            break;
+                        if (searchRegex.test(lines[i])) {
+                            searchRegex.lastIndex = 0; // Reset regex state
+                            const contextBefore = [];
+                            const contextAfter = [];
+                            // Get context before
+                            for (let j = Math.max(0, i - contextLines); j < i; j++) {
+                                contextBefore.push(lines[j]);
+                            }
+                            // Get context after
+                            for (let j = i + 1; j <= Math.min(lines.length - 1, i + contextLines); j++) {
+                                contextAfter.push(lines[j]);
+                            }
+                            fileMatches.push({
+                                line: i + 1,
+                                content: lines[i],
+                                contextBefore,
+                                contextAfter,
+                            });
+                            totalMatches++;
+                        }
+                    }
+                    if (fileMatches.length > 0) {
+                        results.push({
+                            path: fullPath,
+                            relativePath: file,
+                            language: fileLang,
+                            matches: fileMatches,
+                        });
+                    }
+                }
+                if (totalMatches >= limit)
+                    break;
+            }
+            return reply.send({
+                pattern,
+                results,
+                total: totalMatches,
+            });
+        }
+        catch (error) {
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Grep failed',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * POST /api/code/sync
+     * Trigger code sync using SyncWal for recovery and progress tracking.
+     * Supports branch-aware sync: auto-detect mode by default.
+     *
+     * Mode:
+     * - 'auto' (default): overlay on feature branches, full reindex on main
+     * - 'reindex': force full reindex (errors on feature branch)
+     * - 'overlay': force overlay sync only
+     */
+    app.post('/sync', {
+        schema: {
+            body: {
+                type: 'object',
+                properties: {
+                    force: { type: 'boolean', default: false },
+                    resume: { type: 'boolean', default: false },
+                    mode: { type: 'string', enum: ['auto', 'reindex', 'overlay'], default: 'auto' },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireCodeEnabled(reply))
+            return;
+        // Update secrets if changed (e.g., Voyage API key added after project open)
+        await updateSecretsIfNeeded(request.secrets || {});
+        const codePath = getCodePath();
+        const gitInfo = getGitInfo(codePath);
+        const mode = request.body?.mode || 'auto';
+        // Determine sync mode
+        let useOverlay = false;
+        if (mode === 'auto') {
+            useOverlay = gitInfo ? !gitInfo.isMainBranch : false;
+        }
+        else if (mode === 'overlay') {
+            useOverlay = true;
+        }
+        const syncMode = useOverlay ? 'overlay' : 'reindex';
+        // Extra data for SSE events
+        const extraEventData = {
+            branch: gitInfo?.branch || null,
+            isMainBranch: gitInfo?.isMainBranch ?? null,
+            mode: syncMode,
+        };
+        const handler = createSyncHandler(app, {
+            type: 'code',
+            isEnabled: (ctx) => !!ctx.codeIndexer,
+            notEnabledError: 'Code indexing is not initialized for this project',
+            validate: async (ctx, body) => {
+                // Check if required secrets are present for the configured provider
+                const project = getCurrentProject();
+                if (!project)
+                    return 'No project open';
+                const secretsError = validateSecrets(project.config, project.secrets);
+                if (secretsError)
+                    return secretsError;
+                // Validate: don't allow reindex on feature branch
+                if (mode === 'reindex' && gitInfo && !gitInfo.isMainBranch) {
+                    return `Cannot use 'reindex' mode on feature branch '${gitInfo.branch}'. Use 'overlay' or 'auto' mode instead.`;
+                }
+                return null;
+            },
+            clearIndex: async (ctx) => {
+                await ctx.codeIndexer.clear();
+            },
+            getExtraEventData: () => extraEventData,
+            setupCallbacks: (ctx, emitProgress) => {
+                // Embedding progress callback - only send phase/current/progress
+                ctx.syncWal.onEmbeddingProgress((current, total) => {
+                    emitProgress({
+                        phase: 'embedding',
+                        current: `Embedding batch ${current}/${total}`,
+                        progress: Math.round((current / total) * 100),
+                    });
+                });
+                // Sub-phase progress (graph/tree building)
+                ctx.syncWal.onSubPhaseProgress((current, total, subPhase) => {
+                    const [phase, step] = subPhase.split(':');
+                    emitProgress({
+                        phase,
+                        current: `${step}: ${current}/${total}`,
+                        progress: total > 0 ? Math.round((current / total) * 100) : 0,
+                    });
+                });
+            },
+            runSync: async (ctx, recoveryPlan) => {
+                if (useOverlay && ctx.codeBranchIndexer) {
+                    return ctx.codeBranchIndexer.syncOverlay();
+                }
+                else {
+                    return ctx.codeIndexer.reindexAllWithSyncWal(recoveryPlan || undefined);
+                }
+            },
+        });
+        return handler(request, reply);
+    });
+    /**
+     * POST /api/code/reindex
+     * Reindex specific files or folders
+     */
+    app.post('/reindex', {
+        schema: {
+            body: {
+                type: 'object',
+                required: ['paths'],
+                properties: {
+                    paths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                },
+            },
+        },
+    }, async (request, reply) => {
+        if (!requireCodeEnabled(reply))
+            return;
+        const { paths } = request.body;
+        const project = getCurrentProject();
+        try {
+            emitEvent({
+                type: 'reindex:code:started',
+                data: { paths },
+            });
+            // TODO: Implement actual reindexing
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            emitEvent({
+                type: 'reindex:code:completed',
+                data: { paths },
+            });
+            return reply.send({
+                success: true,
+                message: `Reindexed ${paths.length} paths`,
+            });
+        }
+        catch (error) {
+            emitEvent({
+                type: 'reindex:code:error',
+                data: {
+                    paths,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                },
+            });
+            app.log.error(error);
+            return reply.status(500).send({
+                error: 'Reindex failed',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+}
+//# sourceMappingURL=code.js.map