glancey 2.0.0

package/dist/config.js

@@ -0,0 +1,788 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { z } from 'zod';
+/**
+ * Zod schema for configuration validation
+ */
+const ChunkingConfigSchema = z.object({
+    maxLines: z.number().min(10).max(500).optional(),
+    overlap: z.number().min(0).max(50).optional(),
+});
+const SearchConfigSchema = z.object({
+    semanticWeight: z.number().min(0).max(1).optional(),
+    keywordWeight: z.number().min(0).max(1).optional(),
+    /** Automatically reindex when stale files are detected before search (default: true) */
+    autoReindex: z.boolean().optional(),
+});
+const EmbeddingConfigSchema = z.object({
+    backend: z.enum(['ollama', 'gemini']).optional(),
+    model: z.string().optional(),
+    /** Number of concurrent requests to Ollama (default: 10). Increase if your system has capacity. */
+    ollamaConcurrency: z.number().min(1).max(200).optional(),
+});
+const DashboardConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    port: z.number().min(1024).max(65535).optional(),
+    openBrowser: z.boolean().optional(),
+});
+const IndexingConfigSchema = z.object({
+    /** Delay in milliseconds between embedding batches (default: 0) */
+    batchDelayMs: z.number().min(0).max(10000).optional(),
+    /** Number of chunks to embed per batch (default: 32). Higher values reduce overhead but use more memory. */
+    batchSize: z.number().min(1).max(1000).optional(),
+});
+const ConfigSchema = z.object({
+    patterns: z.array(z.string()).optional(),
+    excludePatterns: z.array(z.string()).optional(),
+    embedding: EmbeddingConfigSchema.optional(),
+    chunking: ChunkingConfigSchema.optional(),
+    search: SearchConfigSchema.optional(),
+    dashboard: DashboardConfigSchema.optional(),
+    indexing: IndexingConfigSchema.optional(),
+    instructions: z.string().optional(),
+});
+const DEFAULT_PATTERNS = [
+    '**/*.ts',
+    '**/*.tsx',
+    '**/*.js',
+    '**/*.jsx',
+    '**/*.py',
+    '**/*.go',
+    '**/*.rs',
+    '**/*.java',
+    '**/*.rb',
+    '**/*.php',
+    '**/*.c',
+    '**/*.cpp',
+    '**/*.h',
+    '**/*.hpp',
+    '**/*.cs',
+    '**/*.swift',
+    '**/*.kt',
+];
+const DEFAULT_EXCLUDE_PATTERNS = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/.git/**',
+    '**/build/**',
+    '**/target/**',
+    '**/__pycache__/**',
+    '**/venv/**',
+    '**/.venv/**',
+    '**/vendor/**',
+    '**/*.min.js',
+    '**/*.min.css',
+];
+/**
+ * Default chunking configuration
+ */
+export const DEFAULT_CHUNKING = {
+    maxLines: 100,
+    overlap: 20,
+};
+/**
+ * Default search configuration
+ */
+export const DEFAULT_SEARCH = {
+    semanticWeight: 0.7,
+    keywordWeight: 0.3,
+    autoReindex: true,
+};
+/**
+ * Default dashboard configuration
+ */
+export const DEFAULT_DASHBOARD = {
+    enabled: true,
+    port: 24300,
+    openBrowser: true,
+};
+/**
+ * Default indexing configuration
+ */
+export const DEFAULT_INDEXING = {
+    batchDelayMs: 0,
+    batchSize: 256,
+};
+export const DEFAULT_CONFIG = {
+    patterns: DEFAULT_PATTERNS,
+    excludePatterns: DEFAULT_EXCLUDE_PATTERNS,
+    chunking: DEFAULT_CHUNKING,
+    search: DEFAULT_SEARCH,
+    dashboard: DEFAULT_DASHBOARD,
+    indexing: DEFAULT_INDEXING,
+};
+const CONFIG_FILENAMES = ['.glancey.json', 'glancey.config.json'];
+/**
+ * Local config filename for user-specific overrides (gitignored)
+ * Settings saved from the dashboard are written here instead of the main config
+ */
+const LOCAL_CONFIG_FILENAME = '.glancey.local.json';
+/**
+ * Load and validate configuration from project directory
+ */
+/**
+ * Format a Zod validation error into a user-friendly message
+ */
+function formatValidationError(error, rawConfig) {
+    const pathArray = error.path.map((p) => String(p));
+    const fieldPath = pathArray.join('.');
+    const rawValue = getValueAtPath(rawConfig, pathArray);
+    const rawValueStr = rawValue === undefined ? 'undefined' : JSON.stringify(rawValue);
+    switch (error.code) {
+        case 'invalid_type': {
+            const expected = error.expected;
+            const suggestion = getSuggestionForType(fieldPath, String(expected), rawValue);
+            return `  - ${fieldPath}: Expected ${expected}, got ${typeof rawValue} ${rawValueStr}${suggestion}`;
+        }
+        case 'too_small': {
+            const issueMin = error;
+            const suggestion = getSuggestionForRange(fieldPath, 'minimum', issueMin.minimum);
+            return `  - ${fieldPath}: Value ${rawValueStr} is below minimum ${issueMin.minimum}${suggestion}`;
+        }
+        case 'too_big': {
+            const issueMax = error;
+            const suggestion = getSuggestionForRange(fieldPath, 'maximum', issueMax.maximum);
+            return `  - ${fieldPath}: Value ${rawValueStr} exceeds maximum ${issueMax.maximum}${suggestion}`;
+        }
+        case 'invalid_value': {
+            // Handle enum validation errors
+            const issueVal = error;
+            if (issueVal.values) {
+                const options = issueVal.values.map((o) => `'${String(o)}'`).join(', ');
+                return `  - ${fieldPath}: Invalid value ${rawValueStr}. Valid options: ${options}`;
+            }
+            return `  - ${fieldPath}: Invalid value ${rawValueStr}`;
+        }
+        default:
+            return `  - ${fieldPath}: ${error.message}`;
+    }
+}
+/**
+ * Get the value at a path in an object
+ */
+function getValueAtPath(obj, pathSegments) {
+    let current = obj;
+    for (const segment of pathSegments) {
+        if (current === null || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+/**
+ * Get suggestions for common type mistakes
+ */
+function getSuggestionForType(fieldPath, expected, rawValue) {
+    // Check for string that looks like a number
+    if (expected === 'number' && typeof rawValue === 'string') {
+        const num = Number(rawValue);
+        if (!isNaN(num)) {
+            return `\n    Suggestion: Remove quotes to use numeric value: ${num}`;
+        }
+    }
+    // Check for string that looks like a boolean
+    if (expected === 'boolean' && typeof rawValue === 'string') {
+        const lower = rawValue.toLowerCase();
+        if (lower === 'true' || lower === 'false') {
+            return `\n    Suggestion: Remove quotes to use boolean value: ${lower}`;
+        }
+    }
+    // Check for array expected but got single value
+    if (expected === 'array' && typeof rawValue === 'string') {
+        return `\n    Suggestion: Wrap the value in an array: ["${rawValue}"]`;
+    }
+    return '';
+}
+/**
+ * Get suggestions for range violations
+ */
+function getSuggestionForRange(fieldPath, boundType, _bound) {
+    const fieldSuggestions = {
+        'chunking.maxLines': boundType === 'minimum'
+            ? '\n    Suggestion: Use a value between 10 and 500 lines per chunk'
+            : '\n    Suggestion: Use a value between 10 and 500 lines per chunk',
+        'chunking.overlap': boundType === 'minimum'
+            ? '\n    Suggestion: Use a value between 0 and 50 lines for overlap'
+            : '\n    Suggestion: Use a value between 0 and 50 lines for overlap',
+        'search.semanticWeight': '\n    Suggestion: Use a value between 0.0 and 1.0 for search weights',
+        'search.keywordWeight': '\n    Suggestion: Use a value between 0.0 and 1.0 for search weights',
+        'dashboard.port': '\n    Suggestion: Use a port number between 1024 and 65535',
+    };
+    return fieldSuggestions[fieldPath] || '';
+}
+/**
+ * Print formatted validation warnings to console
+ */
+function printValidationWarnings(filename, errors, rawConfig) {
+    console.warn(`[glancey] Warning: Invalid config in ${filename}`);
+    for (const error of errors) {
+        console.warn(formatValidationError(error, rawConfig));
+    }
+    console.warn('  Using default values for invalid fields.');
+}
+/**
+ * Extract valid configuration values from a raw config object.
+ * This allows us to use valid fields while falling back to defaults for invalid ones.
+ */
+function extractValidConfig(rawConfig) {
+    if (typeof rawConfig !== 'object' || rawConfig === null) {
+        return {};
+    }
+    const config = rawConfig;
+    const result = {};
+    // Try to parse each section independently
+    if (config.patterns !== undefined) {
+        const patternsResult = z.array(z.string()).safeParse(config.patterns);
+        if (patternsResult.success) {
+            result.patterns = patternsResult.data;
+        }
+    }
+    if (config.excludePatterns !== undefined) {
+        const excludeResult = z.array(z.string()).safeParse(config.excludePatterns);
+        if (excludeResult.success) {
+            result.excludePatterns = excludeResult.data;
+        }
+    }
+    if (config.instructions !== undefined) {
+        const instructionsResult = z.string().safeParse(config.instructions);
+        if (instructionsResult.success) {
+            result.instructions = instructionsResult.data;
+        }
+    }
+    if (config.embedding !== undefined) {
+        const embeddingResult = EmbeddingConfigSchema.safeParse(config.embedding);
+        if (embeddingResult.success) {
+            result.embedding = embeddingResult.data;
+        }
+    }
+    if (config.chunking !== undefined) {
+        // Try to extract valid individual fields from chunking
+        const chunkingResult = extractValidChunking(config.chunking);
+        if (Object.keys(chunkingResult).length > 0) {
+            result.chunking = chunkingResult;
+        }
+    }
+    if (config.search !== undefined) {
+        // Try to extract valid individual fields from search
+        const searchResult = extractValidSearch(config.search);
+        if (Object.keys(searchResult).length > 0) {
+            result.search = searchResult;
+        }
+    }
+    if (config.dashboard !== undefined) {
+        // Try to extract valid individual fields from dashboard
+        const dashboardResult = extractValidDashboard(config.dashboard);
+        if (Object.keys(dashboardResult).length > 0) {
+            result.dashboard = dashboardResult;
+        }
+    }
+    if (config.indexing !== undefined) {
+        // Try to extract valid individual fields from indexing
+        const indexingResult = extractValidIndexing(config.indexing);
+        if (Object.keys(indexingResult).length > 0) {
+            result.indexing = indexingResult;
+        }
+    }
+    return result;
+}
+/**
+ * Extract valid chunking config fields
+ */
+function extractValidChunking(rawChunking) {
+    if (typeof rawChunking !== 'object' || rawChunking === null) {
+        return {};
+    }
+    const chunking = rawChunking;
+    const result = {};
+    if (chunking.maxLines !== undefined) {
+        const maxLinesResult = z.number().min(10).max(500).safeParse(chunking.maxLines);
+        if (maxLinesResult.success) {
+            result.maxLines = maxLinesResult.data;
+        }
+    }
+    if (chunking.overlap !== undefined) {
+        const overlapResult = z.number().min(0).max(50).safeParse(chunking.overlap);
+        if (overlapResult.success) {
+            result.overlap = overlapResult.data;
+        }
+    }
+    return result;
+}
+/**
+ * Extract valid search config fields
+ */
+function extractValidSearch(rawSearch) {
+    if (typeof rawSearch !== 'object' || rawSearch === null) {
+        return {};
+    }
+    const search = rawSearch;
+    const result = {};
+    if (search.semanticWeight !== undefined) {
+        const semanticResult = z.number().min(0).max(1).safeParse(search.semanticWeight);
+        if (semanticResult.success) {
+            result.semanticWeight = semanticResult.data;
+        }
+    }
+    if (search.keywordWeight !== undefined) {
+        const keywordResult = z.number().min(0).max(1).safeParse(search.keywordWeight);
+        if (keywordResult.success) {
+            result.keywordWeight = keywordResult.data;
+        }
+    }
+    if (search.autoReindex !== undefined) {
+        const autoReindexResult = z.boolean().safeParse(search.autoReindex);
+        if (autoReindexResult.success) {
+            result.autoReindex = autoReindexResult.data;
+        }
+    }
+    return result;
+}
+/**
+ * Extract valid dashboard config fields
+ */
+function extractValidDashboard(rawDashboard) {
+    if (typeof rawDashboard !== 'object' || rawDashboard === null) {
+        return {};
+    }
+    const dashboard = rawDashboard;
+    const result = {};
+    if (dashboard.enabled !== undefined) {
+        const enabledResult = z.boolean().safeParse(dashboard.enabled);
+        if (enabledResult.success) {
+            result.enabled = enabledResult.data;
+        }
+    }
+    if (dashboard.port !== undefined) {
+        const portResult = z.number().min(1024).max(65535).safeParse(dashboard.port);
+        if (portResult.success) {
+            result.port = portResult.data;
+        }
+    }
+    if (dashboard.openBrowser !== undefined) {
+        const openBrowserResult = z.boolean().safeParse(dashboard.openBrowser);
+        if (openBrowserResult.success) {
+            result.openBrowser = openBrowserResult.data;
+        }
+    }
+    return result;
+}
+/**
+ * Extract valid indexing config fields
+ */
+function extractValidIndexing(rawIndexing) {
+    if (typeof rawIndexing !== 'object' || rawIndexing === null) {
+        return {};
+    }
+    const indexing = rawIndexing;
+    const result = {};
+    if (indexing.batchDelayMs !== undefined) {
+        const batchDelayResult = z.number().min(0).max(10000).safeParse(indexing.batchDelayMs);
+        if (batchDelayResult.success) {
+            result.batchDelayMs = batchDelayResult.data;
+        }
+    }
+    if (indexing.batchSize !== undefined) {
+        const batchSizeResult = z.number().min(1).max(100).safeParse(indexing.batchSize);
+        if (batchSizeResult.success) {
+            result.batchSize = batchSizeResult.data;
+        }
+    }
+    return result;
+}
+/**
+ * Load local config overrides (user-specific settings, gitignored)
+ */
+async function loadLocalConfig(projectPath) {
+    const localConfigPath = path.join(projectPath, LOCAL_CONFIG_FILENAME);
+    try {
+        const content = await fs.readFile(localConfigPath, 'utf-8');
+        const rawConfig = JSON.parse(content);
+        // Validate with Zod (lenient - just extract valid parts)
+        const result = ConfigSchema.safeParse(rawConfig);
+        if (result.success) {
+            return result.data;
+        }
+        // Try to salvage valid parts
+        return extractValidConfig(rawConfig);
+    }
+    catch {
+        // Local config doesn't exist, return empty
+        return {};
+    }
+}
+/**
+ * Deep merge two config objects, with localConfig taking precedence
+ */
+function mergeConfigs(baseConfig, localConfig) {
+    return {
+        patterns: localConfig.patterns || baseConfig.patterns,
+        excludePatterns: localConfig.excludePatterns || baseConfig.excludePatterns,
+        embedding: {
+            ...baseConfig.embedding,
+            ...localConfig.embedding,
+        },
+        chunking: {
+            ...baseConfig.chunking,
+            ...localConfig.chunking,
+        },
+        search: {
+            ...baseConfig.search,
+            ...localConfig.search,
+        },
+        dashboard: {
+            ...baseConfig.dashboard,
+            ...localConfig.dashboard,
+        },
+        indexing: {
+            ...baseConfig.indexing,
+            ...localConfig.indexing,
+        },
+        instructions: localConfig.instructions ?? baseConfig.instructions,
+    };
+}
+export async function loadConfig(projectPath) {
+    let baseConfig = DEFAULT_CONFIG;
+    // Load project config
+    for (const filename of CONFIG_FILENAMES) {
+        const configPath = path.join(projectPath, filename);
+        try {
+            const content = await fs.readFile(configPath, 'utf-8');
+            const rawConfig = JSON.parse(content);
+            // Validate with Zod
+            const result = ConfigSchema.safeParse(rawConfig);
+            if (!result.success) {
+                // Print detailed validation warnings
+                printValidationWarnings(filename, result.error.issues, rawConfig);
+                // Try to salvage valid parts of the config by validating each section separately
+                const validConfig = extractValidConfig(rawConfig);
+                baseConfig = {
+                    patterns: validConfig.patterns || DEFAULT_PATTERNS,
+                    excludePatterns: validConfig.excludePatterns || DEFAULT_EXCLUDE_PATTERNS,
+                    embedding: validConfig.embedding,
+                    chunking: {
+                        ...DEFAULT_CHUNKING,
+                        ...validConfig.chunking,
+                    },
+                    search: {
+                        ...DEFAULT_SEARCH,
+                        ...validConfig.search,
+                    },
+                    dashboard: {
+                        ...DEFAULT_DASHBOARD,
+                        ...validConfig.dashboard,
+                    },
+                    indexing: {
+                        ...DEFAULT_INDEXING,
+                        ...validConfig.indexing,
+                    },
+                    instructions: validConfig.instructions,
+                };
+                break;
+            }
+            const userConfig = result.data;
+            baseConfig = {
+                patterns: userConfig.patterns || DEFAULT_PATTERNS,
+                excludePatterns: userConfig.excludePatterns || DEFAULT_EXCLUDE_PATTERNS,
+                embedding: userConfig.embedding,
+                chunking: {
+                    ...DEFAULT_CHUNKING,
+                    ...userConfig.chunking,
+                },
+                search: {
+                    ...DEFAULT_SEARCH,
+                    ...userConfig.search,
+                },
+                dashboard: {
+                    ...DEFAULT_DASHBOARD,
+                    ...userConfig.dashboard,
+                },
+                indexing: {
+                    ...DEFAULT_INDEXING,
+                    ...userConfig.indexing,
+                },
+                instructions: userConfig.instructions,
+            };
+            break;
+        }
+        catch (error) {
+            // Check if it's a JSON parse error
+            if (error instanceof SyntaxError) {
+                console.warn(`[glancey] Warning: Invalid JSON in ${filename}`);
+                console.warn(`  - ${error.message}`);
+                console.warn('  Suggestion: Check for trailing commas, missing quotes, or other JSON syntax errors.');
+                continue;
+            }
+            // Config file doesn't exist, continue to next
+        }
+    }
+    // Load and merge local config overrides
+    const localConfig = await loadLocalConfig(projectPath);
+    return mergeConfigs(baseConfig, localConfig);
+}
+/**
+ * Get default file patterns
+ */
+export function getDefaultPatterns() {
+    return [...DEFAULT_PATTERNS];
+}
+/**
+ * Get default exclude patterns
+ */
+export function getDefaultExcludePatterns() {
+    return [...DEFAULT_EXCLUDE_PATTERNS];
+}
+/**
+ * Get chunking config with defaults
+ */
+export function getChunkingConfig(config) {
+    return {
+        ...DEFAULT_CHUNKING,
+        ...config.chunking,
+    };
+}
+/**
+ * Get search config with defaults
+ */
+export function getSearchConfig(config) {
+    return {
+        ...DEFAULT_SEARCH,
+        ...config.search,
+    };
+}
+/**
+ * Get dashboard config with defaults
+ */
+export function getDashboardConfig(config) {
+    return {
+        ...DEFAULT_DASHBOARD,
+        ...config.dashboard,
+    };
+}
+/**
+ * Get indexing config with defaults
+ */
+export function getIndexingConfig(config) {
+    return {
+        ...DEFAULT_INDEXING,
+        ...config.indexing,
+    };
+}
+/**
+ * Get project instructions from config
+ */
+export function getInstructions(config) {
+    return config.instructions;
+}
+/**
+ * Load secrets from .glancey/secrets.json
+ */
+export async function loadSecrets(projectPath) {
+    const secretsPath = path.join(projectPath, '.glancey', 'secrets.json');
+    try {
+        const content = await fs.readFile(secretsPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Save secrets to .glancey/secrets.json
+ */
+export async function saveSecrets(projectPath, secrets) {
+    const lanceDir = path.join(projectPath, '.glancey');
+    const secretsPath = path.join(lanceDir, 'secrets.json');
+    // Ensure .glancey directory exists
+    await fs.mkdir(lanceDir, { recursive: true });
+    // Load existing secrets and merge
+    const existing = await loadSecrets(projectPath);
+    const merged = { ...existing, ...secrets };
+    await fs.writeFile(secretsPath, JSON.stringify(merged, null, 2));
+}
+/**
+ * Save embedding settings from dashboard
+ * - Stores backend preference in .glancey.local.json (gitignored, user-specific)
+ * - Stores API key in .glancey/secrets.json (gitignored)
+ */
+export async function saveEmbeddingSettings(projectPath, settings) {
+    // Load existing local config (user-specific overrides)
+    const localConfigPath = path.join(projectPath, LOCAL_CONFIG_FILENAME);
+    let localConfig = {};
+    try {
+        const content = await fs.readFile(localConfigPath, 'utf-8');
+        localConfig = JSON.parse(content);
+    }
+    catch {
+        // File doesn't exist, start fresh
+    }
+    // Update embedding config
+    localConfig.embedding = {
+        ...localConfig.embedding,
+        backend: settings.backend,
+    };
+    // Update ollamaConcurrency if provided
+    if (settings.ollamaConcurrency !== undefined) {
+        localConfig.embedding.ollamaConcurrency = settings.ollamaConcurrency;
+    }
+    // Update indexing batch size if provided
+    if (settings.batchSize !== undefined) {
+        localConfig.indexing = {
+            ...localConfig.indexing,
+            batchSize: settings.batchSize,
+        };
+    }
+    // Save to local config (gitignored, user-specific)
+    await fs.writeFile(localConfigPath, JSON.stringify(localConfig, null, 2));
+    // Save API key to secrets if provided
+    if (settings.apiKey) {
+        if (settings.backend === 'gemini') {
+            await saveSecrets(projectPath, { geminiApiKey: settings.apiKey });
+        }
+    }
+}
+/**
+ * Get current embedding settings including secrets
+ */
+export async function getEmbeddingSettings(projectPath) {
+    const config = await loadConfig(projectPath);
+    const secrets = await loadSecrets(projectPath);
+    const backend = config.embedding?.backend || 'ollama';
+    // Check for API key based on backend
+    let hasApiKey = false;
+    if (backend === 'gemini') {
+        hasApiKey = !!(secrets.geminiApiKey || process.env.GEMINI_API_KEY);
+    }
+    return {
+        backend,
+        hasApiKey,
+        ollamaUrl: process.env.OLLAMA_URL || 'http://localhost:11434',
+        ollamaConcurrency: config.embedding?.ollamaConcurrency || 1,
+        batchSize: config.indexing?.batchSize || DEFAULT_INDEXING.batchSize,
+    };
+}
+/**
+ * Save dashboard settings to .glancey.local.json (gitignored, user-specific)
+ */
+export async function saveDashboardSettings(projectPath, settings) {
+    const localConfigPath = path.join(projectPath, LOCAL_CONFIG_FILENAME);
+    let localConfig = {};
+    try {
+        const content = await fs.readFile(localConfigPath, 'utf-8');
+        localConfig = JSON.parse(content);
+    }
+    catch {
+        // File doesn't exist, start fresh
+    }
+    // Update dashboard config
+    localConfig.dashboard = {
+        ...localConfig.dashboard,
+        enabled: settings.enabled,
+    };
+    // Only update port if provided
+    if (settings.port !== undefined) {
+        localConfig.dashboard.port = settings.port;
+    }
+    // Only update openBrowser if provided
+    if (settings.openBrowser !== undefined) {
+        localConfig.dashboard.openBrowser = settings.openBrowser;
+    }
+    await fs.writeFile(localConfigPath, JSON.stringify(localConfig, null, 2));
+}
+/**
+ * Get current dashboard settings
+ */
+export async function getDashboardSettings(projectPath) {
+    const config = await loadConfig(projectPath);
+    return {
+        enabled: config.dashboard?.enabled ?? DEFAULT_DASHBOARD.enabled,
+        port: config.dashboard?.port ?? DEFAULT_DASHBOARD.port,
+        openBrowser: config.dashboard?.openBrowser ?? DEFAULT_DASHBOARD.openBrowser,
+    };
+}
+/**
+ * Save search weights to .glancey.local.json (gitignored, user-specific)
+ */
+export async function saveSearchWeights(projectPath, settings) {
+    const localConfigPath = path.join(projectPath, LOCAL_CONFIG_FILENAME);
+    let localConfig = {};
+    try {
+        const content = await fs.readFile(localConfigPath, 'utf-8');
+        localConfig = JSON.parse(content);
+    }
+    catch {
+        // File doesn't exist, start fresh
+    }
+    // Update search config
+    localConfig.search = {
+        ...localConfig.search,
+        semanticWeight: settings.semanticWeight,
+        keywordWeight: settings.keywordWeight,
+    };
+    await fs.writeFile(localConfigPath, JSON.stringify(localConfig, null, 2));
+}
+/**
+ * Get current search weights
+ */
+export async function getSearchWeights(projectPath) {
+    const config = await loadConfig(projectPath);
+    return {
+        semanticWeight: config.search?.semanticWeight ?? DEFAULT_SEARCH.semanticWeight,
+        keywordWeight: config.search?.keywordWeight ?? DEFAULT_SEARCH.keywordWeight,
+    };
+}
+/**
+ * Add a pattern to include or exclude patterns in .glancey.local.json
+ */
+export async function addPattern(projectPath, pattern, type) {
+    const localConfigPath = path.join(projectPath, LOCAL_CONFIG_FILENAME);
+    let localConfig = {};
+    try {
+        const content = await fs.readFile(localConfigPath, 'utf-8');
+        localConfig = JSON.parse(content);
+    }
+    catch {
+        // File doesn't exist, start fresh
+    }
+    // Get effective config to check for duplicates and get current patterns
+    const effectiveConfig = await loadConfig(projectPath);
+    if (type === 'include') {
+        const currentPatterns = effectiveConfig.patterns || [];
+        if (!currentPatterns.includes(pattern)) {
+            localConfig.patterns = [...currentPatterns, pattern];
+        }
+    }
+    else {
+        const currentPatterns = effectiveConfig.excludePatterns || [];
+        if (!currentPatterns.includes(pattern)) {
+            localConfig.excludePatterns = [...currentPatterns, pattern];
+        }
+    }
+    await fs.writeFile(localConfigPath, JSON.stringify(localConfig, null, 2));
+}
+/**
+ * Remove a pattern from include or exclude patterns in .glancey.local.json
+ */
+export async function removePattern(projectPath, pattern, type) {
+    const localConfigPath = path.join(projectPath, LOCAL_CONFIG_FILENAME);
+    let localConfig = {};
+    try {
+        const content = await fs.readFile(localConfigPath, 'utf-8');
+        localConfig = JSON.parse(content);
+    }
+    catch {
+        // File doesn't exist, start fresh
+    }
+    // Get effective config to get current patterns
+    const effectiveConfig = await loadConfig(projectPath);
+    if (type === 'include') {
+        const currentPatterns = effectiveConfig.patterns || [];
+        localConfig.patterns = currentPatterns.filter((p) => p !== pattern);
+    }
+    else {
+        const currentPatterns = effectiveConfig.excludePatterns || [];
+        localConfig.excludePatterns = currentPatterns.filter((p) => p !== pattern);
+    }
+    await fs.writeFile(localConfigPath, JSON.stringify(localConfig, null, 2));
+}
+//# sourceMappingURL=config.js.map