@contextmirror/claude-memory 0.4.2 → 0.4.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Nathan / Context Mirror
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,10 @@
 # claude-memory
 
+[![npm version](https://img.shields.io/npm/v/@contextmirror/claude-memory.svg)](https://www.npmjs.com/package/@contextmirror/claude-memory)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org/)
+[![Discord](https://img.shields.io/discord/1454173469242822669?color=5865F2&label=Discord&logo=discord&logoColor=white)](https://discord.gg/JBpsSFB7EQ)
+
 Cross-project memory for Claude Code. Give Claude awareness of ALL your projects, not just the one you're in.
 
 ## The Problem
@@ -298,6 +303,12 @@ Run `claude-memory scan --quick` when you've made changes to multiple projects.
 **Is my code uploaded anywhere?**
 No. All data stays in `~/.claude-memory/` on your machine. Nothing is sent to any server.
 
+## Community
+
+Join our Discord for feedback, feature requests, and support:
+
+[![Discord](https://img.shields.io/discord/1454173469242822669?color=5865F2&label=Discord&logo=discord&logoColor=white)](https://discord.gg/JBpsSFB7EQ)
+
 ## License
 
 MIT

package/dist/__tests__/codeSearch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/codeSearch.test.js

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest';
+import { formatSearchResults } from '../utils/codeSearch.js';
+describe('Code Search', () => {
+    describe('formatSearchResults', () => {
+        it('should format empty results correctly', () => {
+            const result = formatSearchResults([], 'test');
+            expect(result).toBe('No results found for "test".');
+        });
+        it('should format single result correctly', () => {
+            const results = [{
+                    project: 'my-project',
+                    projectPath: '/home/user/my-project',
+                    file: '/home/user/my-project/src/index.ts',
+                    relativePath: 'src/index.ts',
+                    line: 10,
+                    content: 'const test = "hello";',
+                    context: {
+                        before: 'import { something } from "./lib";',
+                        after: 'export default test;',
+                    },
+                }];
+            const result = formatSearchResults(results, 'test');
+            expect(result).toContain('# Code Search Results for "test"');
+            expect(result).toContain('Found 1 result');
+            expect(result).toContain('## my-project');
+            expect(result).toContain('src/index.ts:10');
+            expect(result).toContain('const test = "hello";');
+        });
+        it('should group results by project', () => {
+            const results = [
+                {
+                    project: 'project-a',
+                    projectPath: '/path/a',
+                    file: '/path/a/file1.ts',
+                    relativePath: 'file1.ts',
+                    line: 1,
+                    content: 'line 1',
+                    context: { before: '', after: '' },
+                },
+                {
+                    project: 'project-b',
+                    projectPath: '/path/b',
+                    file: '/path/b/file2.ts',
+                    relativePath: 'file2.ts',
+                    line: 2,
+                    content: 'line 2',
+                    context: { before: '', after: '' },
+                },
+                {
+                    project: 'project-a',
+                    projectPath: '/path/a',
+                    file: '/path/a/file3.ts',
+                    relativePath: 'file3.ts',
+                    line: 3,
+                    content: 'line 3',
+                    context: { before: '', after: '' },
+                },
+            ];
+            const result = formatSearchResults(results, 'query');
+            expect(result).toContain('Found 3 results');
+            expect(result).toContain('## project-a');
+            expect(result).toContain('## project-b');
+        });
+    });
+});

package/dist/__tests__/license.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/license.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { validateKeyFormat, isLemonSqueezyKey } from '../license/index.js';
+describe('License Key Validation', () => {
+    describe('validateKeyFormat', () => {
+        it('should accept valid LemonSqueezy UUID keys', () => {
+            expect(validateKeyFormat('A1B2C3D4-E5F6-7890-ABCD-EF1234567890')).toBe(true);
+            expect(validateKeyFormat('a1b2c3d4-e5f6-7890-abcd-ef1234567890')).toBe(true);
+        });
+        it('should accept valid legacy CM- keys', () => {
+            expect(validateKeyFormat('CM-ABCD-1234-WXYZ')).toBe(true);
+            expect(validateKeyFormat('cm-abcd-1234-wxyz')).toBe(true);
+        });
+        it('should reject invalid key formats', () => {
+            expect(validateKeyFormat('')).toBe(false);
+            expect(validateKeyFormat('invalid-key')).toBe(false);
+            expect(validateKeyFormat('CM-ABC-1234-WXYZ')).toBe(false); // Wrong segment length
+            expect(validateKeyFormat('12345678-1234-1234-1234-123456789')).toBe(false); // Too short
+        });
+    });
+    describe('isLemonSqueezyKey', () => {
+        it('should identify LemonSqueezy UUID keys', () => {
+            expect(isLemonSqueezyKey('A1B2C3D4-E5F6-7890-ABCD-EF1234567890')).toBe(true);
+        });
+        it('should not identify legacy keys as LemonSqueezy', () => {
+            expect(isLemonSqueezyKey('CM-ABCD-1234-WXYZ')).toBe(false);
+        });
+    });
+});

package/dist/__tests__/stalenessDetector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/stalenessDetector.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { detectStaleProjects } from '../scanner/stalenessDetector.js';
+function createMockProject(overrides = {}) {
+    return {
+        name: 'test-project',
+        path: '/home/user/projects/test-project',
+        description: 'A test project',
+        language: 'typescript',
+        techStack: ['Node.js', 'TypeScript'],
+        currentBranch: 'main',
+        isDirty: false,
+        lastActivity: new Date().toISOString(),
+        hasFiles: {
+            readme: true,
+            claudeMd: false,
+            packageJson: true,
+            gitignore: true,
+        },
+        insights: [],
+        lastScanned: new Date().toISOString(),
+        ...overrides,
+    };
+}
+function createMockContext(projects = [], hoursAgo = 0) {
+    const lastUpdated = new Date(Date.now() - hoursAgo * 60 * 60 * 1000).toISOString();
+    return {
+        schemaVersion: 1,
+        lastUpdated,
+        projects,
+        insights: [],
+        userPatterns: [],
+    };
+}
+describe('Staleness Detection', () => {
+    describe('detectStaleProjects', () => {
+        it('should return no stale projects for fresh data', () => {
+            const context = createMockContext([createMockProject()], 0);
+            const report = detectStaleProjects(context);
+            expect(report.staleProjects).toHaveLength(0);
+            expect(report.dataAgeHours).toBeLessThan(1);
+        });
+        it('should mark data as stale after 24 hours', () => {
+            const context = createMockContext([createMockProject()], 25);
+            const report = detectStaleProjects(context);
+            expect(report.dataAgeHours).toBeGreaterThan(24);
+        });
+        it('should detect projects scanned more than 7 days ago', () => {
+            const oldScanDate = new Date(Date.now() - 8 * 24 * 60 * 60 * 1000).toISOString();
+            const project = createMockProject({ lastScanned: oldScanDate });
+            const context = createMockContext([project], 0);
+            const report = detectStaleProjects(context);
+            expect(report.staleProjects.length).toBeGreaterThanOrEqual(0);
+        });
+        it('should handle empty projects list', () => {
+            const context = createMockContext([], 0);
+            const report = detectStaleProjects(context);
+            expect(report.staleProjects).toHaveLength(0);
+        });
+    });
+});

package/dist/__tests__/updateChecker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/updateChecker.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+// Test version comparison logic
+function isNewerVersion(current, latest) {
+    const currentParts = current.split('.').map(Number);
+    const latestParts = latest.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const curr = currentParts[i] || 0;
+        const lat = latestParts[i] || 0;
+        if (lat > curr)
+            return true;
+        if (lat < curr)
+            return false;
+    }
+    return false;
+}
+describe('Update Checker', () => {
+    describe('version comparison', () => {
+        it('should detect newer major versions', () => {
+            expect(isNewerVersion('0.4.2', '1.0.0')).toBe(true);
+            expect(isNewerVersion('1.0.0', '2.0.0')).toBe(true);
+        });
+        it('should detect newer minor versions', () => {
+            expect(isNewerVersion('0.4.2', '0.5.0')).toBe(true);
+            expect(isNewerVersion('0.4.2', '0.5.1')).toBe(true);
+        });
+        it('should detect newer patch versions', () => {
+            expect(isNewerVersion('0.4.2', '0.4.3')).toBe(true);
+            expect(isNewerVersion('0.4.2', '0.4.10')).toBe(true);
+        });
+        it('should return false for same version', () => {
+            expect(isNewerVersion('0.4.2', '0.4.2')).toBe(false);
+        });
+        it('should return false for older versions', () => {
+            expect(isNewerVersion('0.4.2', '0.4.1')).toBe(false);
+            expect(isNewerVersion('0.4.2', '0.3.9')).toBe(false);
+            expect(isNewerVersion('1.0.0', '0.9.9')).toBe(false);
+        });
+        it('should handle missing patch version', () => {
+            expect(isNewerVersion('0.4', '0.4.1')).toBe(true);
+            expect(isNewerVersion('0.4.1', '0.5')).toBe(true);
+        });
+    });
+});

package/dist/cli.js

@@ -10,19 +10,26 @@
  */
 import { Command } from 'commander';
 import { readFileSync, existsSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { fileURLToPath } from 'url';
 import { scanProjects } from './scanner/projectScanner.js';
 import { generateGlobalContext, writeGlobalContext, getMemoryDir } from './scanner/contextGenerator.js';
 import { generateBriefing, briefingToClaudeMd } from './briefing/briefingGenerator.js';
 import { runSetupWizard } from './setup/setupWizard.js';
 import { activateLicense, deactivateLicense, getLicenseStatus } from './license/index.js';
 import { detectStaleProjects } from './scanner/stalenessDetector.js';
+// Get version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, '../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const VERSION = packageJson.version;
 const program = new Command();
 program
     .name('claude-memory')
     .description('Cross-project memory for Claude Code')
-    .version('0.4.2');
+    .version(VERSION);
 // Scan command
 program
     .command('scan')

package/dist/constants.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Centralized constants for Claude Memory
+ */
+export declare const GIT_TIMEOUT_MS = 10000;
+export declare const UPDATE_CHECK_INTERVAL_MS: number;
+export declare const STALE_DATA_HOURS = 24;
+export declare const STALE_PROJECT_DAYS = 7;
+export declare const MAX_README_CHARS = 3000;
+export declare const MAX_DESCRIPTION_CHARS = 200;
+export declare const PRODUCT_URL = "https://claude-memory.dev";
+export declare const DISCORD_URL = "https://discord.gg/JBpsSFB7EQ";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/@contextmirror/claude-memory";
+export declare const LEMONSQUEEZY_VALIDATE_URL = "https://api.lemonsqueezy.com/v1/licenses/validate";
+export declare const MEMORY_DIR_NAME = ".claude-memory";
+export declare const CONTEXT_FILE = "context.json";
+export declare const CONTEXT_BACKUP_FILE = "context.json.bak";
+export declare const CONFIG_FILE = "config.json";
+export declare const LICENSE_FILE = "license.json";
+export declare const UPDATE_CACHE_FILE = "update-check.json";
+export declare const GLOBAL_CONTEXT_MD = "global-context.md";
+export declare const PROJECT_MARKERS: string[];
+export declare const IGNORE_DIRS: string[];
+export declare const EXIT_SUCCESS = 0;
+export declare const EXIT_ERROR = 1;
+export declare const EXIT_INVALID_ARGS = 2;

package/dist/constants.js

@@ -0,0 +1,53 @@
+/**
+ * Centralized constants for Claude Memory
+ */
+// Timeouts
+export const GIT_TIMEOUT_MS = 10000;
+export const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+// Staleness thresholds
+export const STALE_DATA_HOURS = 24;
+export const STALE_PROJECT_DAYS = 7;
+// File limits
+export const MAX_README_CHARS = 3000;
+export const MAX_DESCRIPTION_CHARS = 200;
+// URLs
+export const PRODUCT_URL = 'https://claude-memory.dev';
+export const DISCORD_URL = 'https://discord.gg/JBpsSFB7EQ';
+export const NPM_REGISTRY_URL = 'https://registry.npmjs.org/@contextmirror/claude-memory';
+export const LEMONSQUEEZY_VALIDATE_URL = 'https://api.lemonsqueezy.com/v1/licenses/validate';
+// Paths
+export const MEMORY_DIR_NAME = '.claude-memory';
+export const CONTEXT_FILE = 'context.json';
+export const CONTEXT_BACKUP_FILE = 'context.json.bak';
+export const CONFIG_FILE = 'config.json';
+export const LICENSE_FILE = 'license.json';
+export const UPDATE_CACHE_FILE = 'update-check.json';
+export const GLOBAL_CONTEXT_MD = 'global-context.md';
+// Project detection patterns
+export const PROJECT_MARKERS = [
+    'package.json',
+    'Cargo.toml',
+    'pyproject.toml',
+    'go.mod',
+    '.git',
+    'requirements.txt',
+];
+// Directories to ignore during scanning
+export const IGNORE_DIRS = [
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '__pycache__',
+    'target',
+    '.venv',
+    'venv',
+    'coverage',
+    '.next',
+    '.nuxt',
+    '.cache',
+];
+// Exit codes
+export const EXIT_SUCCESS = 0;
+export const EXIT_ERROR = 1;
+export const EXIT_INVALID_ARGS = 2;

package/dist/license/index.d.ts

@@ -15,14 +15,18 @@ export declare function saveLicense(license: License): void;
  */
 export declare function isPro(): boolean;
 /**
- * Validate a license key format
+ * Check if key is LemonSqueezy format
+ */
+export declare function isLemonSqueezyKey(key: string): boolean;
+/**
+ * Validate a license key format (accepts both LemonSqueezy and legacy formats)
  */
 export declare function validateKeyFormat(key: string): boolean;
 /**
  * Activate a license key
  *
- * Phase 1: Offline validation (format check only)
- * Phase 2: Will call LemonSqueezy API for server validation
+ * For LemonSqueezy keys: Validates against their API
+ * For legacy keys: Format check only (backwards compatibility)
  */
 export declare function activateLicense(key: string): Promise<LicenseValidationResult>;
 /**

package/dist/license/index.js

@@ -4,10 +4,14 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { LEMONSQUEEZY_VALIDATE_URL } from '../constants.js';
 const MEMORY_DIR = join(homedir(), '.claude-memory');
 const LICENSE_PATH = join(MEMORY_DIR, 'license.json');
-// License key format: CM-XXXX-XXXX-XXXX (alphanumeric)
-const LICENSE_KEY_PATTERN = /^CM-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/i;
+// License key formats:
+// - LemonSqueezy: UUID format (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
+// - Legacy: CM-XXXX-XXXX-XXXX (alphanumeric)
+const LEMONSQUEEZY_KEY_PATTERN = /^[A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12}$/i;
+const LEGACY_KEY_PATTERN = /^CM-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/i;
 /**
  * Ensure the memory directory exists
  */
@@ -59,38 +63,92 @@ export function isPro() {
     return true;
 }
 /**
- * Validate a license key format
+ * Check if key is LemonSqueezy format
+ */
+export function isLemonSqueezyKey(key) {
+    return LEMONSQUEEZY_KEY_PATTERN.test(key);
+}
+/**
+ * Validate a license key format (accepts both LemonSqueezy and legacy formats)
  */
 export function validateKeyFormat(key) {
-    return LICENSE_KEY_PATTERN.test(key);
+    return LEMONSQUEEZY_KEY_PATTERN.test(key) || LEGACY_KEY_PATTERN.test(key);
+}
+/**
+ * Validate license key with LemonSqueezy API
+ */
+async function validateWithLemonSqueezy(key) {
+    try {
+        const response = await fetch(LEMONSQUEEZY_VALIDATE_URL, {
+            method: 'POST',
+            headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                license_key: key,
+            }),
+        });
+        const data = await response.json();
+        if (data.valid) {
+            return {
+                valid: true,
+                email: data.meta?.customer_email,
+            };
+        }
+        else {
+            return {
+                valid: false,
+                error: data.error || 'License key is not valid',
+            };
+        }
+    }
+    catch (err) {
+        // Network error - allow offline activation with warning
+        return {
+            valid: true, // Allow offline - will revalidate later
+            error: 'Could not reach license server. Activating offline.',
+        };
+    }
 }
 /**
  * Activate a license key
  *
- * Phase 1: Offline validation (format check only)
- * Phase 2: Will call LemonSqueezy API for server validation
+ * For LemonSqueezy keys: Validates against their API
+ * For legacy keys: Format check only (backwards compatibility)
  */
 export async function activateLicense(key) {
-    // Normalize key to uppercase
+    // Normalize key (LemonSqueezy keys are uppercase hex)
     const normalizedKey = key.toUpperCase();
     // Validate format
     if (!validateKeyFormat(normalizedKey)) {
         return {
             valid: false,
-            error: 'Invalid license key format. Expected: CM-XXXX-XXXX-XXXX',
+            error: 'Invalid license key format. Get your key from https://claude-memory.dev',
         };
     }
-    // TODO: Phase 2 - Call LemonSqueezy API to validate
-    // const response = await fetch('https://api.claude-memory.dev/validate', {
-    //   method: 'POST',
-    //   body: JSON.stringify({ key: normalizedKey }),
-    // });
-    // For now, accept any valid format (Phase 1 - offline)
+    let email;
+    // Validate LemonSqueezy keys with their API
+    if (isLemonSqueezyKey(normalizedKey)) {
+        const result = await validateWithLemonSqueezy(normalizedKey);
+        if (!result.valid) {
+            return {
+                valid: false,
+                error: result.error || 'License validation failed',
+            };
+        }
+        email = result.email;
+        // Show offline warning if applicable
+        if (result.error) {
+            console.log(`⚠️  ${result.error}`);
+        }
+    }
     const license = {
         key: normalizedKey,
         plan: 'pro',
         activatedAt: new Date().toISOString(),
-        // No expiration for now
+        email,
+        // Subscription licenses don't expire locally - LemonSqueezy handles this
     };
     saveLicense(license);
     return {

package/dist/mcp/server.js

@@ -11,14 +11,21 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { readFileSync, existsSync, readdirSync, statSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { fileURLToPath } from 'url';
 import { DEFAULT_MEMORY_CONFIG } from '../types/index.js';
 import { isPro, getProFeatureMessage } from '../license/index.js';
 import { detectStaleProjects, checkCurrentProjectStaleness, formatStalenessForMcp } from '../scanner/stalenessDetector.js';
 import { checkForUpdate, formatUpdateMessage } from '../utils/updateChecker.js';
+import { searchCode, formatSearchResults } from '../utils/codeSearch.js';
 const MEMORY_DIR = join(homedir(), '.claude-memory');
-const CURRENT_VERSION = '0.4.0'; // Update this with each release
+// Read version from package.json to ensure single source of truth
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, '../../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const CURRENT_VERSION = packageJson.version;
 // Tool definitions
 const tools = [
     {
@@ -405,22 +412,22 @@ function handleSearchCode(query, filePattern) {
     if (!context) {
         return 'No projects scanned yet. Run `claude-memory scan` first.';
     }
-    const lines = [
-        `# Code Search Results for "${query}"`,
-        '',
-    ];
-    // TODO: Implement actual code search
-    // For now, return a placeholder that shows the feature is gated
-    lines.push('Searching across projects:');
-    for (const p of context.projects) {
-        lines.push(`- ${p.name} (${p.path})`);
+    if (!query || query.trim().length === 0) {
+        return 'Please provide a search query.';
     }
-    lines.push('');
-    lines.push(`Pattern: ${filePattern || '*'}`);
-    lines.push('');
-    lines.push('> Note: Full code search implementation coming soon.');
-    lines.push('> This will index and search actual file contents across all your projects.');
-    return lines.join('\n');
+    // Map projects to the format expected by searchCode
+    const projects = context.projects.map(p => ({
+        name: p.name,
+        path: p.path,
+    }));
+    // Perform the search
+    const results = searchCode(projects, query, {
+        filePattern,
+        maxResults: 50,
+        caseSensitive: false,
+        contextLines: 1,
+    });
+    return formatSearchResults(results, query);
 }
 function handleGetProjectAnalysis(projectQuery) {
     const context = loadContext();
@@ -559,7 +566,7 @@ function getDirectoryStructure(dir, maxDepth, prefix = '', depth = 0) {
 async function main() {
     const server = new Server({
         name: 'claude-memory',
-        version: '0.1.0',
+        version: CURRENT_VERSION,
     }, {
         capabilities: {
             tools: {},

package/dist/utils/codeSearch.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Code search utility for Pro feature
+ */
+export interface SearchResult {
+    project: string;
+    projectPath: string;
+    file: string;
+    relativePath: string;
+    line: number;
+    content: string;
+    context: {
+        before: string;
+        after: string;
+    };
+}
+export interface SearchOptions {
+    filePattern?: string;
+    maxResults?: number;
+    caseSensitive?: boolean;
+    contextLines?: number;
+}
+/**
+ * Search for code across multiple projects
+ */
+export declare function searchCode(projects: Array<{
+    name: string;
+    path: string;
+}>, query: string, options?: SearchOptions): SearchResult[];
+/**
+ * Format search results for display
+ */
+export declare function formatSearchResults(results: SearchResult[], query: string): string;