@sashabogi/foundation 0.1.5 → 0.1.7

package/dist/tools/demerzel/index.js

@@ -15,24 +15,241 @@
  * - demerzel_get_context: Get lines around a location
  * - demerzel_analyze: AI-powered deep analysis
  * - demerzel_semantic_search: Natural language code search
+ *
+ * Ported from Argus to Foundation.
  */
 import { z } from 'zod';
+import { existsSync, readFileSync, statSync, mkdtempSync, unlinkSync } from 'fs';
+import { join, resolve } from 'path';
+import { tmpdir } from 'os';
+import { createSnapshot, DEFAULT_EXTENSIONS, DEFAULT_EXCLUDE_PATTERNS } from './snapshot.js';
+import { createEnhancedSnapshot } from './enhanced-snapshot.js';
+import { analyze, searchDocument } from './engine.js';
+import { SemanticIndex } from './semantic-search.js';
+import { ConfigService } from '../../services/config.service.js';
+import { ProviderService } from '../../services/provider.service.js';
+import { isSessionDelegation } from '../../providers/types.js';
+// Tool limits and defaults
+const DEFAULT_FIND_FILES_LIMIT = 100;
+const MAX_FIND_FILES_LIMIT = 500;
+const DEFAULT_SEARCH_RESULTS = 50;
+const MAX_SEARCH_RESULTS = 200;
+const MAX_PATTERN_LENGTH = 500;
+const MAX_WILDCARDS = 20;
+/**
+ * Parse metadata section from an enhanced snapshot
+ */
+function parseSnapshotMetadata(content) {
+    // Check if this is an enhanced snapshot
+    if (!content.includes('METADATA: IMPORT GRAPH')) {
+        return null;
+    }
+    const importGraph = {};
+    const exportGraph = {};
+    const symbolIndex = {};
+    const exports = [];
+    // Parse import graph
+    const importSection = content.match(/METADATA: IMPORT GRAPH\n=+\n([\s\S]*?)\n\n=+\nMETADATA:/)?.[1] || '';
+    for (const block of importSection.split('\n\n')) {
+        const lines = block.trim().split('\n');
+        if (lines.length > 0 && lines[0].endsWith(':')) {
+            const file = lines[0].slice(0, -1);
+            importGraph[file] = lines.slice(1).map(l => l.replace(/^\s*->\s*/, '').trim()).filter(Boolean);
+        }
+    }
+    // Parse export index (symbol -> files)
+    const exportSection = content.match(/METADATA: EXPORT INDEX\n=+\n([\s\S]*?)\n\n=+\nMETADATA:/)?.[1] || '';
+    for (const line of exportSection.split('\n')) {
+        const match = line.match(/^([\w$]+):\s*(.+)$/);
+        if (match) {
+            symbolIndex[match[1]] = match[2].split(',').map(s => s.trim());
+        }
+    }
+    // Parse who imports whom (reverse graph)
+    const whoImportsSection = content.match(/METADATA: WHO IMPORTS WHOM\n=+\n([\s\S]*)$/)?.[1] || '';
+    for (const block of whoImportsSection.split('\n\n')) {
+        const lines = block.trim().split('\n');
+        if (lines.length > 0 && lines[0].includes(' is imported by:')) {
+            const file = lines[0].replace(' is imported by:', '').trim();
+            exportGraph[file] = lines.slice(1).map(l => l.replace(/^\s*<-\s*/, '').trim()).filter(Boolean);
+        }
+    }
+    // Parse file exports
+    const fileExportsSection = content.match(/METADATA: FILE EXPORTS\n=+\n([\s\S]*?)\n\n=+\nMETADATA:/)?.[1] || '';
+    for (const line of fileExportsSection.split('\n')) {
+        const match = line.match(/^([^:]+):(\d+)\s*-\s*(\w+)\s+(.+)$/);
+        if (match) {
+            exports.push({
+                file: match[1],
+                line: parseInt(match[2]),
+                type: match[3],
+                symbol: match[4].split(' ')[0], // Take first word as symbol name
+            });
+        }
+    }
+    return { importGraph, exportGraph, symbolIndex, exports };
+}
+/**
+ * Create a stub provider for when no provider is configured
+ * Returns an error message indicating configuration is needed
+ */
+function createStubProvider() {
+    return {
+        name: 'stub',
+        async complete(_messages) {
+            return {
+                content: '<<<FINAL>>>Analysis requires a configured AI provider. Please configure Foundation with an API key.<<<END>>>',
+                finishReason: 'stop',
+            };
+        },
+    };
+}
+/**
+ * Create a provider adapter that bridges Demerzel's AIProvider interface
+ * with Foundation's ProviderService.
+ *
+ * @param providerName - Name of the provider to use (e.g., 'ollama', 'anthropic')
+ * @param model - Model identifier to use for completions
+ * @returns AIProvider instance that delegates to Foundation's provider system
+ */
+function createProviderAdapter(providerName, model) {
+    return {
+        name: providerName,
+        async complete(messages, options) {
+            try {
+                // Get the provider from ProviderService
+                const providerManager = ProviderService.getInstance().getProviderManager();
+                // Check if provider is configured
+                if (!providerManager.isConfigured(providerName)) {
+                    return {
+                        content: `<<<FINAL>>>Provider '${providerName}' is not configured. Please configure it in ~/.foundation/config.yaml or use a different provider.<<<END>>>`,
+                        finishReason: 'error',
+                    };
+                }
+                const provider = providerManager.get(providerName);
+                // Extract system message if present (Demerzel uses system role, Foundation doesn't)
+                let systemContent = '';
+                const conversationMessages = [];
+                for (const msg of messages) {
+                    if (msg.role === 'system') {
+                        systemContent = msg.content;
+                    }
+                    else {
+                        conversationMessages.push({
+                            role: msg.role,
+                            content: msg.content,
+                        });
+                    }
+                }
+                // If we have a system message, prepend it to the first user message
+                if (systemContent && conversationMessages.length > 0 && conversationMessages[0].role === 'user') {
+                    conversationMessages[0] = {
+                        role: 'user',
+                        content: `${systemContent}\n\n${conversationMessages[0].content}`,
+                    };
+                }
+                else if (systemContent) {
+                    // If no user message yet, add system as user message
+                    conversationMessages.unshift({
+                        role: 'user',
+                        content: systemContent,
+                    });
+                }
+                // Build the completion request
+                const request = {
+                    model,
+                    messages: conversationMessages,
+                    temperature: options?.temperature ?? 0.7,
+                    max_tokens: options?.maxTokens ?? 4096,
+                };
+                // Execute the completion
+                const response = await provider.complete(request);
+                // Handle session delegation response
+                if (isSessionDelegation(response)) {
+                    // For session delegation, return the instructions as the content
+                    return {
+                        content: response.instructions,
+                        finishReason: 'stop',
+                    };
+                }
+                // Extract text content from the response
+                const textContent = response.content
+                    .filter(block => block.type === 'text')
+                    .map(block => block.text || '')
+                    .join('\n');
+                // Convert usage information
+                const usage = response.usage ? {
+                    promptTokens: response.usage.input_tokens,
+                    completionTokens: response.usage.output_tokens,
+                    totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+                } : undefined;
+                return {
+                    content: textContent,
+                    finishReason: response.stop_reason === 'end_turn' ? 'stop' :
+                        response.stop_reason === 'max_tokens' ? 'length' : 'stop',
+                    usage,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    content: `<<<FINAL>>>Error calling provider '${providerName}': ${errorMessage}<<<END>>>`,
+                    finishReason: 'error',
+                };
+            }
+        },
+    };
+}
 export function registerDemerzelTools(server) {
     // demerzel_snapshot
     server.tool('demerzel_snapshot', 'Create a codebase snapshot for efficient searching and analysis. Enhanced snapshots include import graph and export index. "I have been watching for 20,000 years."', {
         path: z.string().describe('Path to the codebase directory'),
         enhanced: z.boolean().optional().describe('Create enhanced snapshot with import graph (default: true)'),
         output: z.string().optional().describe('Output path for snapshot (default: .foundation/snapshot.txt)'),
-    }, async ({ path, enhanced = true, output: _output }) => {
-        // TODO: Port implementation from argus
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `[Stub] Would create ${enhanced ? 'enhanced' : 'basic'} snapshot for ${path}`,
-                },
-            ],
-        };
+    }, async ({ path, enhanced = true, output }) => {
+        const projectPath = resolve(path);
+        if (!existsSync(projectPath)) {
+            return {
+                content: [{ type: 'text', text: `Error: Path not found: ${projectPath}` }],
+                isError: true,
+            };
+        }
+        const outputPath = output ? resolve(output) : join(projectPath, '.foundation', 'snapshot.txt');
+        try {
+            const result = enhanced
+                ? createEnhancedSnapshot(projectPath, outputPath, {
+                    extensions: DEFAULT_EXTENSIONS,
+                    excludePatterns: DEFAULT_EXCLUDE_PATTERNS,
+                })
+                : createSnapshot(projectPath, outputPath, {
+                    extensions: DEFAULT_EXTENSIONS,
+                    excludePatterns: DEFAULT_EXCLUDE_PATTERNS,
+                });
+            const response = {
+                outputPath: result.outputPath,
+                fileCount: result.fileCount,
+                totalLines: result.totalLines,
+                totalSize: result.totalSize,
+                enhanced,
+            };
+            if (enhanced && 'metadata' in result) {
+                const enhancedResult = result;
+                response.metadata = {
+                    imports: enhancedResult.metadata.imports.length,
+                    exports: enhancedResult.metadata.exports.length,
+                    symbols: Object.keys(enhancedResult.metadata.symbolIndex).length,
+                };
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
     });
     // demerzel_search
     server.tool('demerzel_search', 'Fast regex search across codebase. Zero AI cost. Returns file:line:content matches.', {
@@ -40,77 +257,269 @@ export function registerDemerzelTools(server) {
         pattern: z.string().describe('Regex pattern to search'),
         maxResults: z.number().optional().describe('Maximum results (default: 50)'),
         caseInsensitive: z.boolean().optional().describe('Case insensitive search (default: true)'),
-    }, async ({ path, pattern, maxResults: _maxResults = 50, caseInsensitive: _caseInsensitive = true }) => {
-        // TODO: Port implementation from argus
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `[Stub] Would search for "${pattern}" in ${path}`,
-                },
-            ],
-        };
+    }, async ({ path, pattern, maxResults = DEFAULT_SEARCH_RESULTS, caseInsensitive = true }) => {
+        const snapshotPath = resolve(path);
+        if (!pattern || pattern.trim() === '') {
+            return {
+                content: [{ type: 'text', text: 'Error: Pattern cannot be empty' }],
+                isError: true,
+            };
+        }
+        if (!existsSync(snapshotPath)) {
+            return {
+                content: [{ type: 'text', text: `Error: Snapshot not found: ${snapshotPath}. Run demerzel_snapshot first.` }],
+                isError: true,
+            };
+        }
+        try {
+            const matches = searchDocument(snapshotPath, pattern, {
+                caseInsensitive,
+                maxResults: Math.min(maxResults, MAX_SEARCH_RESULTS),
+            });
+            const formattedMatches = matches.map(m => ({
+                lineNum: m.lineNum,
+                line: m.line.trim(),
+                match: m.match,
+            }));
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            count: formattedMatches.length,
+                            matches: formattedMatches,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
     });
     // demerzel_find_files
     server.tool('demerzel_find_files', 'Find files matching a glob pattern. Zero AI cost.', {
         path: z.string().describe('Path to snapshot file'),
         pattern: z.string().describe('Glob pattern (e.g., "*.ts", "src/**/*.tsx")'),
         limit: z.number().optional().describe('Maximum results (default: 100)'),
-    }, async ({ path, pattern, limit: _limit = 100 }) => {
-        // TODO: Port implementation from argus
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `[Stub] Would find files matching "${pattern}" in ${path}`,
-                },
-            ],
-        };
+    }, async ({ path, pattern, limit = DEFAULT_FIND_FILES_LIMIT }) => {
+        const snapshotPath = resolve(path);
+        if (!pattern || pattern.trim() === '') {
+            return {
+                content: [{ type: 'text', text: 'Error: Pattern cannot be empty' }],
+                isError: true,
+            };
+        }
+        if (pattern.length > MAX_PATTERN_LENGTH) {
+            return {
+                content: [{ type: 'text', text: `Error: Pattern too long (max ${MAX_PATTERN_LENGTH} characters)` }],
+                isError: true,
+            };
+        }
+        // ReDoS protection
+        const starCount = (pattern.match(/\*/g) || []).length;
+        if (starCount > MAX_WILDCARDS) {
+            return {
+                content: [{ type: 'text', text: `Error: Too many wildcards in pattern (max ${MAX_WILDCARDS})` }],
+                isError: true,
+            };
+        }
+        if (!existsSync(snapshotPath)) {
+            return {
+                content: [{ type: 'text', text: `Error: Snapshot not found: ${snapshotPath}. Run demerzel_snapshot first.` }],
+                isError: true,
+            };
+        }
+        try {
+            const content = readFileSync(snapshotPath, 'utf-8');
+            // Extract all FILE: markers
+            const fileRegex = /^FILE: \.\/(.+)$/gm;
+            const files = [];
+            let match;
+            while ((match = fileRegex.exec(content)) !== null) {
+                files.push(match[1]);
+            }
+            // Convert glob pattern to regex
+            let regexPattern = pattern
+                .replace(/[.+^${}()|[\]\\-]/g, '\\$&')
+                .replace(/\*\*/g, '<<<GLOBSTAR>>>')
+                .replace(/\*/g, '[^/]*?')
+                .replace(/<<<GLOBSTAR>>>/g, '.*?')
+                .replace(/\?/g, '.');
+            const regex = new RegExp(`^${regexPattern}$`, 'i');
+            const matching = files.filter(f => regex.test(f));
+            const limited = matching.slice(0, Math.min(limit, MAX_FIND_FILES_LIMIT)).sort();
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            pattern,
+                            files: limited,
+                            count: limited.length,
+                            totalMatching: matching.length,
+                            hasMore: matching.length > limit,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
     });
     // demerzel_find_symbol
     server.tool('demerzel_find_symbol', 'Locate where a function, class, or type is exported. Zero AI cost. Requires enhanced snapshot.', {
         path: z.string().describe('Path to snapshot file'),
         symbol: z.string().describe('Symbol name to find (e.g., "AuthProvider", "useAuth")'),
     }, async ({ path, symbol }) => {
-        // TODO: Port implementation from argus
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `[Stub] Would find symbol "${symbol}" in ${path}`,
-                },
-            ],
-        };
+        const snapshotPath = resolve(path);
+        if (!existsSync(snapshotPath)) {
+            return {
+                content: [{ type: 'text', text: `Error: Snapshot not found: ${snapshotPath}` }],
+                isError: true,
+            };
+        }
+        try {
+            const content = readFileSync(snapshotPath, 'utf-8');
+            const metadata = parseSnapshotMetadata(content);
+            if (!metadata) {
+                return {
+                    content: [{ type: 'text', text: 'Error: This snapshot does not have metadata. Create with enhanced=true.' }],
+                    isError: true,
+                };
+            }
+            const files = metadata.symbolIndex[symbol] || [];
+            const exportDetails = metadata.exports.filter(e => e.symbol === symbol);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            symbol,
+                            exportedFrom: files,
+                            details: exportDetails,
+                            count: files.length,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
     });
     // demerzel_find_importers
     server.tool('demerzel_find_importers', 'Find all files that import a given module. Zero AI cost. Requires enhanced snapshot.', {
         path: z.string().describe('Path to snapshot file'),
         target: z.string().describe('File path to find importers of (e.g., "src/auth.ts")'),
     }, async ({ path, target }) => {
-        // TODO: Port implementation from argus
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `[Stub] Would find importers of "${target}" in ${path}`,
-                },
-            ],
-        };
+        const snapshotPath = resolve(path);
+        if (!existsSync(snapshotPath)) {
+            return {
+                content: [{ type: 'text', text: `Error: Snapshot not found: ${snapshotPath}` }],
+                isError: true,
+            };
+        }
+        try {
+            const content = readFileSync(snapshotPath, 'utf-8');
+            const metadata = parseSnapshotMetadata(content);
+            if (!metadata) {
+                return {
+                    content: [{ type: 'text', text: 'Error: This snapshot does not have metadata. Create with enhanced=true.' }],
+                    isError: true,
+                };
+            }
+            // Normalize the target path
+            const normalizedTarget = target.startsWith('./') ? target.slice(2) : target;
+            const targetVariants = [normalizedTarget, './' + normalizedTarget, normalizedTarget.replace(/\.(ts|tsx|js|jsx)$/, '')];
+            // Find all files that import this target
+            const importers = [];
+            for (const [file, imports] of Object.entries(metadata.importGraph)) {
+                for (const imp of imports) {
+                    if (targetVariants.some(v => imp === v || imp.endsWith('/' + v) || imp.includes(v))) {
+                        importers.push(file);
+                        break;
+                    }
+                }
+            }
+            // Also check the exportGraph (direct mapping)
+            for (const variant of targetVariants) {
+                if (metadata.exportGraph[variant]) {
+                    importers.push(...metadata.exportGraph[variant]);
+                }
+            }
+            const unique = [...new Set(importers)];
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            target,
+                            importedBy: unique,
+                            count: unique.length,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
     });
     // demerzel_get_deps
     server.tool('demerzel_get_deps', 'Get all dependencies (imports) of a specific file. Zero AI cost. Requires enhanced snapshot.', {
         path: z.string().describe('Path to snapshot file'),
         file: z.string().describe('File path to get dependencies for'),
     }, async ({ path, file }) => {
-        // TODO: Port implementation from argus
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `[Stub] Would get dependencies of "${file}" in ${path}`,
-                },
-            ],
-        };
+        const snapshotPath = resolve(path);
+        if (!existsSync(snapshotPath)) {
+            return {
+                content: [{ type: 'text', text: `Error: Snapshot not found: ${snapshotPath}` }],
+                isError: true,
+            };
+        }
+        try {
+            const content = readFileSync(snapshotPath, 'utf-8');
+            const metadata = parseSnapshotMetadata(content);
+            if (!metadata) {
+                return {
+                    content: [{ type: 'text', text: 'Error: This snapshot does not have metadata. Create with enhanced=true.' }],
+                    isError: true,
+                };
+            }
+            // Normalize the file path
+            const normalizedFile = file.startsWith('./') ? file.slice(2) : file;
+            const fileVariants = [normalizedFile, './' + normalizedFile];
+            // Find imports for this file
+            let imports = [];
+            for (const variant of fileVariants) {
+                if (metadata.importGraph[variant]) {
+                    imports = metadata.importGraph[variant];
+                    break;
+                }
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            file,
+                            imports,
+                            count: imports.length,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
     });
     // demerzel_get_context
     server.tool('demerzel_get_context', 'Get lines of code around a specific location. Zero AI cost. Use after search to get more context.', {
@@ -120,31 +529,145 @@ export function registerDemerzelTools(server) {
         before: z.number().optional().describe('Lines before (default: 10)'),
         after: z.number().optional().describe('Lines after (default: 10)'),
     }, async ({ path, file, line, before = 10, after = 10 }) => {
-        // TODO: Port implementation from argus
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `[Stub] Would get context around line ${line} in ${file}`,
-                },
-            ],
-        };
+        const snapshotPath = resolve(path);
+        if (!existsSync(snapshotPath)) {
+            return {
+                content: [{ type: 'text', text: `Error: Snapshot not found: ${snapshotPath}` }],
+                isError: true,
+            };
+        }
+        try {
+            const content = readFileSync(snapshotPath, 'utf-8');
+            // Find the file section in the snapshot
+            const normalizedTarget = file.replace(/^\.\//, '');
+            const fileMarkerVariants = [
+                `FILE: ./${normalizedTarget}`,
+                `FILE: ${normalizedTarget}`,
+            ];
+            let fileStart = -1;
+            for (const marker of fileMarkerVariants) {
+                fileStart = content.indexOf(marker);
+                if (fileStart !== -1)
+                    break;
+            }
+            if (fileStart === -1) {
+                return {
+                    content: [{ type: 'text', text: `Error: File not found in snapshot: ${file}` }],
+                    isError: true,
+                };
+            }
+            // Find the end of this file section
+            const nextFileStart = content.indexOf('\nFILE:', fileStart + 1);
+            const metadataStart = content.indexOf('\nMETADATA:', fileStart);
+            const fileEnd = Math.min(nextFileStart === -1 ? Infinity : nextFileStart, metadataStart === -1 ? Infinity : metadataStart);
+            // Extract file content
+            const fileContent = content.slice(fileStart, fileEnd === Infinity ? undefined : fileEnd);
+            const fileLines = fileContent.split('\n').slice(2); // Skip FILE: header and separator
+            // Calculate range
+            const startLine = Math.max(0, line - before - 1);
+            const endLine = Math.min(fileLines.length, line + after);
+            // Extract context with line numbers
+            const contextLines = fileLines.slice(startLine, endLine).map((lineContent, idx) => {
+                const lineNum = startLine + idx + 1;
+                const marker = lineNum === line ? '>>>' : '   ';
+                return `${marker} ${lineNum.toString().padStart(4)}: ${lineContent}`;
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            file,
+                            targetLine: line,
+                            range: { start: startLine + 1, end: endLine },
+                            content: contextLines.join('\n'),
+                            totalLines: fileLines.length,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
     });
     // demerzel_analyze
     server.tool('demerzel_analyze', 'AI-powered deep analysis of codebase. Uses recursive reasoning across entire codebase. ~500 tokens cost.', {
-        path: z.string().describe('Path to snapshot file'),
+        path: z.string().describe('Path to snapshot file or codebase directory'),
         query: z.string().describe('Question about the codebase (be specific for best results)'),
         maxTurns: z.number().optional().describe('Maximum reasoning turns (default: 15)'),
     }, async ({ path, query, maxTurns = 15 }) => {
-        // TODO: Port implementation from argus
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `[Stub] Would analyze "${query}" in ${path}`,
-                },
-            ],
-        };
+        const inputPath = resolve(path);
+        if (!existsSync(inputPath)) {
+            return {
+                content: [{ type: 'text', text: `Error: Path not found: ${inputPath}` }],
+                isError: true,
+            };
+        }
+        let snapshotPath = inputPath;
+        let tempSnapshot = false;
+        try {
+            // If it's a directory, create a temporary enhanced snapshot
+            const stats = statSync(inputPath);
+            if (stats.isDirectory()) {
+                const tempDir = mkdtempSync(join(tmpdir(), 'demerzel-'));
+                snapshotPath = join(tempDir, 'snapshot.txt');
+                createEnhancedSnapshot(inputPath, snapshotPath, {
+                    extensions: DEFAULT_EXTENSIONS,
+                    excludePatterns: DEFAULT_EXCLUDE_PATTERNS,
+                });
+                tempSnapshot = true;
+            }
+            // Get provider configuration from ConfigService
+            const argusConfig = ConfigService.getInstance().getArgusConfig();
+            const providerName = argusConfig.provider ?? 'ollama';
+            const model = argusConfig.model ?? 'qwen2.5-coder:7b';
+            // Create provider adapter, falling back to stub if not configured
+            let provider;
+            try {
+                const providerManager = ProviderService.getInstance().getProviderManager();
+                if (providerManager.isConfigured(providerName)) {
+                    provider = createProviderAdapter(providerName, model);
+                }
+                else {
+                    // Fallback to stub provider with informative message
+                    provider = createStubProvider();
+                }
+            }
+            catch {
+                // Fallback to stub if ProviderService is not initialized
+                provider = createStubProvider();
+            }
+            const result = await analyze(provider, snapshotPath, query, { maxTurns });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            answer: result.answer,
+                            success: result.success,
+                            turns: result.turns,
+                            commands: result.commands,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
+        finally {
+            if (tempSnapshot && existsSync(snapshotPath)) {
+                try {
+                    unlinkSync(snapshotPath);
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+        }
     });
     // demerzel_semantic_search
     server.tool('demerzel_semantic_search', 'Search code using natural language. Uses FTS5 full-text search. More flexible than regex.', {
@@ -152,15 +675,63 @@ export function registerDemerzelTools(server) {
         query: z.string().describe('Natural language query or code terms'),
         limit: z.number().optional().describe('Maximum results (default: 20)'),
     }, async ({ path, query, limit = 20 }) => {
-        // TODO: Port implementation from argus
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `[Stub] Would semantic search "${query}" in ${path}`,
-                },
-            ],
-        };
+        const projectPath = resolve(path);
+        if (!query || query.trim() === '') {
+            return {
+                content: [{ type: 'text', text: 'Error: Query cannot be empty' }],
+                isError: true,
+            };
+        }
+        const snapshotPath = join(projectPath, '.foundation', 'snapshot.txt');
+        const indexPath = join(projectPath, '.foundation', 'search.db');
+        if (!existsSync(snapshotPath)) {
+            return {
+                content: [{ type: 'text', text: `Error: Snapshot not found: ${snapshotPath}. Run demerzel_snapshot first.` }],
+                isError: true,
+            };
+        }
+        let index = null;
+        try {
+            index = new SemanticIndex(indexPath);
+            // Check if index needs rebuilding
+            const stats = index.getStats();
+            const snapshotMtime = statSync(snapshotPath).mtimeMs;
+            const needsReindex = !stats.lastIndexed ||
+                new Date(stats.lastIndexed).getTime() < snapshotMtime ||
+                stats.snapshotPath !== snapshotPath;
+            if (needsReindex) {
+                index.indexFromSnapshot(snapshotPath);
+            }
+            const results = index.search(query, limit);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            query,
+                            count: results.length,
+                            results: results.map(r => ({
+                                file: r.file,
+                                symbol: r.symbol,
+                                type: r.type,
+                                snippet: r.content.split('\n').slice(0, 5).join('\n'),
+                            })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                isError: true,
+            };
+        }
+        finally {
+            if (index) {
+                index.close();
+            }
+        }
     });
 }
+// Re-export types and functions for external use
+export { createSnapshot, createEnhancedSnapshot, analyze, searchDocument, SemanticIndex };
 //# sourceMappingURL=index.js.map