squish-memory 1.1.5 → 1.2.0

package/dist/config.js

@@ -4,239 +4,191 @@ import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-export function getDataDir() {
-    const projectRoot = process.env.CLAUDE_WORKING_DIRECTORY || process.cwd();
-    const dir = process.env.SQUISH_DATA_DIR || join(projectRoot, '.squish');
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    return dir;
-}
-// Load settings from config/settings.json
+const EMBEDDINGS_PROVIDERS = ['openai', 'ollama', 'lmstudio', 'transformers', 'local', 'none', 'google', 'auto'];
+const LLM_PROVIDERS = ['openai', 'anthropic', 'ollama', 'lmstudio', 'local'];
+const GRAPH_EXTRACTION_METHODS = ['llm', 'regex', 'auto'];
+const SCHEDULER_MODES = ['cron', 'interval', 'heartbeat'];
+const VISIBILITY_SCOPES = ['private', 'project', 'team', 'global'];
 function loadSettings() {
     const settingsPath = join(__dirname, 'config', 'settings.json');
     try {
         if (existsSync(settingsPath)) {
-            const content = readFileSync(settingsPath, 'utf-8');
-            return JSON.parse(content);
+            return JSON.parse(readFileSync(settingsPath, 'utf-8'));
         }
     }
-    catch (error) {
+    catch {
         console.warn('Failed to load settings.json, using defaults');
     }
     return {};
 }
 const settings = loadSettings();
-// Helper to get env var or settings value
-function getConfig(path, envVar, defaultValue) {
-    // Priority 1: Environment variable
-    if (envVar && process.env[envVar]) {
-        return process.env[envVar];
-    }
-    // Priority 2: Settings file
-    const keys = path.split('.');
+function readPath(path) {
     let value = settings;
-    for (const key of keys) {
+    for (const key of path.split('.')) {
         if (value && typeof value === 'object' && key in value) {
             value = value[key];
         }
         else {
-            value = undefined;
-            break;
+            return undefined;
         }
     }
-    if (value !== undefined) {
+    return value;
+}
+function rawConfig(path, envVar, defaultValue) {
+    if (envVar && Object.prototype.hasOwnProperty.call(process.env, envVar)) {
+        return process.env[envVar];
+    }
+    const settingsValue = readPath(path);
+    return settingsValue === undefined ? defaultValue : settingsValue;
+}
+function getString(path, envVar, defaultValue) {
+    const value = rawConfig(path, envVar, defaultValue);
+    return typeof value === 'string' ? value : String(value ?? defaultValue);
+}
+function getBoolean(path, envVar, defaultValue) {
+    const value = rawConfig(path, envVar, defaultValue);
+    if (typeof value === 'boolean')
         return value;
+    if (typeof value === 'number')
+        return value !== 0;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (['true', '1', 'yes', 'on'].includes(normalized))
+            return true;
+        if (['false', '0', 'no', 'off', ''].includes(normalized))
+            return false;
     }
-    // Priority 3: Default value
     return defaultValue;
 }
-// Mode detection: local (default), team (cloud with own db), remote (integrations)
-// Priority: remote > team > local
-const DATABASE_URL = process.env.DATABASE_URL || '';
-const SUPABASE_URL = process.env.SUPABASE_URL || '';
-const NEON_PROJECT_ID = process.env.NEON_PROJECT_ID || '';
-// Determine mode based on environment
+function getNumber(path, envVar, defaultValue) {
+    const value = rawConfig(path, envVar, defaultValue);
+    const parsed = typeof value === 'number' ? value : Number(value);
+    return Number.isFinite(parsed) ? parsed : defaultValue;
+}
+function getEnum(path, envVar, allowed, defaultValue) {
+    const value = getString(path, envVar, defaultValue).toLowerCase();
+    return allowed.includes(value) ? value : defaultValue;
+}
+export function getDataDir() {
+    const projectRoot = process.env.CLAUDE_WORKING_DIRECTORY || process.cwd();
+    const dir = getString('data.dir', 'SQUISH_DATA_DIR', join(projectRoot, '.squish'));
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    return dir;
+}
+const databaseUrl = process.env.DATABASE_URL || '';
+const supabaseUrlEnv = process.env.SUPABASE_URL || '';
+const neonProjectIdEnv = process.env.NEON_PROJECT_ID || '';
 function detectMode() {
-    // Remote mode: user has their own Supabase or Neon
-    if (SUPABASE_URL || NEON_PROJECT_ID) {
+    if (supabaseUrlEnv || neonProjectIdEnv)
         return 'remote';
-    }
-    // Team mode: PostgreSQL (self-hosted "local cloud")
-    if (DATABASE_URL.startsWith('postgres')) {
+    if (databaseUrl.startsWith('postgres'))
         return 'team';
-    }
-    // Local mode: default SQLite
     return 'local';
 }
 const detectedMode = detectMode();
-const isTeamMode = detectedMode === 'team';
-const isRemoteMode = detectedMode === 'remote';
-const isLocalMode = detectedMode === 'local';
-const isManagedMode = process.env.SQUISH_MANAGED_MODE === 'true';
-// Team/Remote backend selection
-const teamBackend = (() => {
-    const explicit = getConfig('team.backend', 'SQUISH_TEAM_BACKEND', '').toLowerCase();
-    if (explicit === 'supabase' || explicit === 'neon' || explicit === 'postgres') {
-        return explicit;
-    }
-    // Auto-detect based on env vars
-    if (SUPABASE_URL)
-        return 'supabase';
-    if (NEON_PROJECT_ID)
-        return 'neon';
-    return 'postgres'; // default to PostgreSQL
-})();
-const remoteBackend = (() => {
-    const explicit = getConfig('remote.backend', 'SQUISH_REMOTE_BACKEND', '').toLowerCase();
-    if (explicit === 'supabase' || explicit === 'neon') {
-        return explicit;
-    }
-    // Auto-detect based on env vars
-    if (SUPABASE_URL)
-        return 'supabase';
-    if (NEON_PROJECT_ID)
-        return 'neon';
-    return 'supabase'; // default to Supabase
-})();
-// Neon configuration
-const neonProjectId = process.env.NEON_PROJECT_ID || '';
-const neonServiceKey = process.env.NEON_SERVICE_KEY || '';
-// Embeddings providers:
-// - openai: OpenAI API (requires API key)
-// - ollama: Local Ollama server (any model)
-// - lmstudio: LM Studio local server (any model)
-// - local: TF-IDF offline (no dependencies)
-// - none: Disable embeddings (stub)
-// - google: Google Cloud embeddings
-// - auto: Smart fallback (cloud if available, local fallback)
-const VALID_PROVIDERS = new Set(['openai', 'ollama', 'lmstudio', 'local', 'none', 'google', 'auto']);
-const embeddingsProvider = (() => {
-    const explicit = getConfig('embeddings.provider', 'SQUISH_EMBEDDINGS_PROVIDER', 'local').toLowerCase();
-    if (VALID_PROVIDERS.has(explicit)) {
-        return explicit;
-    }
-    return 'local';
-})();
-// OpenAI Configuration
-const openAiApiKey = process.env.SQUISH_OPENAI_API_KEY || process.env.OPENAI_API_KEY || '';
-const openAiApiUrl = getConfig('api.openai.apiUrl', 'SQUISH_OPENAI_API_URL', 'https://api.openai.com/v1/embeddings');
-const openAiEmbeddingModel = getConfig('embeddings.models.openai.model', 'SQUISH_OPENAI_EMBEDDING_MODEL', 'text-embedding-3-small');
-// Google Configuration  
-const googleCloudApiKey = process.env.GOOGLE_CLOUD_API_KEY || process.env.SQUISH_GOOGLE_CLOUD_API_KEY || '';
-const googleCloudProject = process.env.GOOGLE_CLOUD_PROJECT || process.env.SQUISH_GOOGLE_CLOUD_PROJECT || '';
-const googleCloudLocation = process.env.GOOGLE_CLOUD_LOCATION || process.env.SQUISH_GOOGLE_CLOUD_LOCATION || 'us-central1';
-const googleEmbeddingModel = getConfig('embeddings.models.google.model', 'SQUISH_GOOGLE_EMBEDDING_MODEL', 'gemini-embedding-001');
-// Ollama Configuration
-const ollamaUrl = getConfig('api.ollama.url', 'SQUISH_OLLAMA_URL', 'http://localhost:11434');
-const ollamaEmbeddingModel = getConfig('embeddings.models.ollama.model', 'SQUISH_OLLAMA_EMBEDDING_MODEL', '');
-// LM Studio Configuration (OpenAI-compatible local server)
-const lmStudioUrl = getConfig('api.lmstudio.url', 'SQUISH_LM_STUDIO_URL', 'http://localhost:1234');
-const lmStudioEmbeddingModel = getConfig('embeddings.models.lmstudio.model', 'SQUISH_LM_STUDIO_EMBEDDING_MODEL', '');
+const embeddingsProvider = getEnum('embeddings.provider', 'SQUISH_EMBEDDINGS_PROVIDER', EMBEDDINGS_PROVIDERS, 'local');
+const llmEnabled = getBoolean('llm.enabled', 'SQUISH_LLM_ENABLED', false);
+const llmProvider = getEnum('llm.provider', 'SQUISH_LLM_PROVIDER', LLM_PROVIDERS, 'openai');
+const llmEndpoint = getString('llm.endpoint', 'SQUISH_LLM_ENDPOINT', '');
+const graphAutoBuild = getBoolean('graph.autoBuild', 'SQUISH_GRAPH_AUTO_BUILD', true);
+const graphExtractionMethod = getEnum('graph.extractionMethod', 'SQUISH_GRAPH_EXTRACTION_METHOD', GRAPH_EXTRACTION_METHODS, 'auto');
+const graphMaxContentLength = getNumber('graph.maxContentLength', 'SQUISH_GRAPH_MAX_CONTENT_LENGTH', 10000);
+const scoringWeights = {
+    recency: getNumber('scoring.weights.recency', 'SQUISH_WEIGHT_RECENCY', 0.5),
+    relevance: getNumber('scoring.weights.relevance', 'SQUISH_WEIGHT_RELEVANCE', 3),
+    importance: getNumber('scoring.weights.importance', 'SQUISH_WEIGHT_IMPORTANCE', 2),
+    vectorSim: getNumber('scoring.weights.vectorSim', 'SQUISH_WEIGHT_VECTOR_SIM', 3),
+    graphBoost: getNumber('scoring.weights.graphBoost', 'SQUISH_WEIGHT_GRAPH_BOOST', 1.5),
+};
 export const config = {
-    // Mode detection
     mode: detectedMode,
-    isLocalMode,
-    isTeamMode,
-    isRemoteMode,
-    // Backend selection
-    teamBackend: teamBackend,
-    remoteBackend: remoteBackend,
-    // Legacy support
-    isManagedMode,
-    redisEnabled: !!process.env.REDIS_URL,
+    isLocalMode: detectedMode === 'local',
+    isTeamMode: detectedMode === 'team',
+    isRemoteMode: detectedMode === 'remote',
+    teamBackend: getEnum('team.backend', 'SQUISH_TEAM_BACKEND', ['postgres', 'supabase', 'neon'], 'postgres'),
+    remoteBackend: getEnum('remote.backend', 'SQUISH_REMOTE_BACKEND', ['supabase', 'neon'], 'supabase'),
+    isManagedMode: getBoolean('managed.enabled', 'SQUISH_MANAGED_MODE', false),
+    managedMode: getBoolean('managed.enabled', 'SQUISH_MANAGED_MODE', false),
+    managedApiUrl: getString('managed.apiUrl', 'SQUISH_MANAGED_API_URL', 'https://api.squish.dev'),
+    managedApiKey: getString('managed.apiKey', 'SQUISH_MANAGED_API_KEY', ''),
+    redisEnabled: Boolean(process.env.REDIS_URL),
     dataDir: getDataDir(),
-    mcpServerPort: parseInt(getConfig('mcp.serverPort', 'SQUISH_MCP_PORT', '8767')),
-    embeddingsProvider: embeddingsProvider,
-    // OpenAI
-    openAiApiKey,
-    openAiApiUrl,
-    openAiEmbeddingModel,
-    // Google
-    googleCloudApiKey,
-    googleCloudProject,
-    googleCloudLocation,
-    googleEmbeddingModel,
-    // Ollama
-    ollamaUrl,
-    ollamaEmbeddingModel,
-    // LM Studio (OpenAI-compatible local)
-    lmStudioUrl,
-    lmStudioEmbeddingModel,
-    // Supabase configuration
-    supabaseUrl: getConfig('supabase.url', 'SUPABASE_URL', ''),
-    supabaseKey: getConfig('supabase.key', 'SUPABASE_SERVICE_KEY', ''),
-    // Neon configuration
+    mcpServerPort: getNumber('mcp.serverPort', 'SQUISH_MCP_PORT', 8767),
+    embeddingsProvider,
+    openAiApiKey: process.env.SQUISH_OPENAI_API_KEY || process.env.OPENAI_API_KEY || '',
+    openAiApiUrl: getString('api.openai.apiUrl', 'SQUISH_OPENAI_API_URL', 'https://api.openai.com/v1/embeddings'),
+    openAiEmbeddingModel: getString('embeddings.models.openai.model', 'SQUISH_OPENAI_EMBEDDING_MODEL', ''),
+    googleCloudApiKey: process.env.GOOGLE_CLOUD_API_KEY || process.env.SQUISH_GOOGLE_CLOUD_API_KEY || '',
+    googleCloudProject: process.env.GOOGLE_CLOUD_PROJECT || process.env.SQUISH_GOOGLE_CLOUD_PROJECT || '',
+    googleCloudLocation: process.env.GOOGLE_CLOUD_LOCATION || process.env.SQUISH_GOOGLE_CLOUD_LOCATION || 'us-central1',
+    googleEmbeddingModel: getString('embeddings.models.google.model', 'SQUISH_GOOGLE_EMBEDDING_MODEL', ''),
+    ollamaUrl: getString('api.ollama.url', 'SQUISH_OLLAMA_URL', 'http://localhost:11434'),
+    ollamaEmbeddingModel: getString('embeddings.models.ollama.model', 'SQUISH_OLLAMA_EMBEDDING_MODEL', ''),
+    lmStudioUrl: getString('api.lmstudio.url', 'SQUISH_LM_STUDIO_URL', 'http://localhost:1234'),
+    lmStudioEmbeddingModel: getString('embeddings.models.lmstudio.model', 'SQUISH_LM_STUDIO_EMBEDDING_MODEL', ''),
+    transformersLocalModel: getString('embeddings.models.transformers.model', 'SQUISH_LOCAL_MODEL', ''),
+    supabaseUrl: getString('supabase.url', 'SUPABASE_URL', ''),
+    supabaseKey: getString('supabase.key', 'SUPABASE_SERVICE_KEY', ''),
     neonProjectId: process.env.NEON_PROJECT_ID || '',
     neonServiceKey: process.env.NEON_SERVICE_KEY || '',
-    // Encryption configuration
-    clientEncryptionEnabled: getConfig('security.encryptionEnabled', null, false) !== false,
+    clientEncryptionEnabled: getBoolean('security.encryptionEnabled', null, false),
     encryptionPassphrase: process.env.SQUISH_ENCRYPTION_PASSPHRASE || '',
-    // Lifecycle Management
-    lifecycleEnabled: getConfig('features.lifecycleEnabled', 'SQUISH_LIFECYCLE_ENABLED', true) !== false,
-    lifecycleInterval: parseInt(process.env.SQUISH_LIFECYCLE_INTERVAL || '3600000'),
-    decayThreshold: parseFloat(process.env.SQUISH_DECAY_THRESHOLD || '0.1'),
-    // Session Summarization
-    summarizationEnabled: getConfig('features.summarizationEnabled', 'SQUISH_SUMMARIZATION_ENABLED', true) !== false,
-    incrementalThreshold: parseInt(process.env.SQUISH_INCREMENTAL_THRESHOLD || '10'),
-    rollingWindowSize: parseInt(process.env.SQUISH_ROLLING_WINDOW_SIZE || '50'),
-    // Agent-Aware Memory
-    agentIsolationEnabled: getConfig('features.agentIsolation', 'SQUISH_AGENT_ISOLATION_ENABLED', true) !== false,
-    defaultVisibilityScope: (process.env.SQUISH_DEFAULT_VISIBILITY || 'private'),
-    // Memory Governance
-    governanceEnabled: process.env.SQUISH_GOVERNANCE_ENABLED !== 'false',
-    // Memory Consolidation
-    consolidationEnabled: process.env.SQUISH_CONSOLIDATION_ENABLED === 'true',
-    consolidationSimilarityThreshold: parseFloat(process.env.SQUISH_CONSOLIDATION_THRESHOLD || '0.8'),
-    // Obsidian Integration (NEW)
-    obsidianEnabled: process.env.SQUISH_OBSIDIAN_ENABLED === 'true',
-    obsidianVaultPath: process.env.SQUISH_OBSIDIAN_VAULT_PATH || '',
-    // External Folder Memory (QMD Wrapper)
-    externalMemoryEnabled: process.env.SQUISH_EXTERNAL_MEMORY_ENABLED === 'true',
-    externalMemoryPath: process.env.SQUISH_EXTERNAL_MEMORY_PATH || '',
-    // DEPRECATED: QMD (kept for backward compat during transition)
-    qmdEnabled: false, // DEPRECATED - use Obsidian integration instead
-    qmdCollectionsPath: '', // DEPRECATED
-    qmdFallbackMode: 'local-only', // DEPRECATED
-    qmdCollectionMapping: {}, // DEPRECATED
-    // Managed Mode
-    managedMode: process.env.SQUISH_MANAGED_MODE === 'true',
-    managedApiUrl: process.env.SQUISH_MANAGED_API_URL || 'https://api.squish.dev',
-    managedApiKey: process.env.SQUISH_MANAGED_API_KEY || '',
-    // Session Auto-Load
-    sessionAutoLoadEnabled: process.env.SQUISH_SESSION_AUTO_LOAD !== 'false',
-    sessionAutoLoadRecentCount: parseInt(process.env.SQUISH_SESSION_AUTO_LOAD_RECENT_COUNT || '5'),
-    sessionAutoLoadImportanceThreshold: parseInt(process.env.SQUISH_SESSION_AUTO_LOAD_IMPORTANCE_THRESHOLD || '70'),
-    // Query Rewriting
-    queryRewritingEnabled: process.env.SQUISH_QUERY_REWRITING !== 'false',
-    queryRewritingContextMessages: parseInt(process.env.SQUISH_QUERY_REWRITING_CONTEXT_MESSAGES || '5'),
-    queryRewritingFallbackEnabled: process.env.SQUISH_QUERY_REWRITING_FALLBACK !== 'false',
-    // Feedback Tracking
-    feedbackTrackingEnabled: process.env.SQUISH_FEEDBACK_TRACKING !== 'false',
-    feedbackEchoBonus: parseInt(process.env.SQUISH_FEEDBACK_ECHO_BONUS || '10'),
-    feedbackFizzlePenalty: parseInt(process.env.SQUISH_FEEDBACK_FIZZLE_PENALTY || '5'),
-    // Scoring Weights (override defaults)
-    scoringWeights: {
-        recency: parseFloat(process.env.SQUISH_WEIGHT_RECENCY || '0.5'),
-        relevance: parseFloat(process.env.SQUISH_WEIGHT_RELEVANCE || '3'),
-        importance: parseFloat(process.env.SQUISH_WEIGHT_IMPORTANCE || '2'),
-        vectorSim: parseFloat(process.env.SQUISH_WEIGHT_VECTOR_SIM || '3'),
-        graphBoost: parseFloat(process.env.SQUISH_WEIGHT_GRAPH_BOOST || '1.5'),
+    lifecycleEnabled: getBoolean('features.lifecycleEnabled', 'SQUISH_LIFECYCLE_ENABLED', true),
+    lifecycleInterval: getNumber('lifecycle.interval', 'SQUISH_LIFECYCLE_INTERVAL', 3600000),
+    decayThreshold: getNumber('lifecycle.decay.threshold', 'SQUISH_DECAY_THRESHOLD', 0.1),
+    sectorDecayIntervals: {
+        episodic: getNumber('lifecycle.decay.episodic', 'SQUISH_DECAY_EPISODIC', 30),
+        semantic: getNumber('lifecycle.decay.semantic', 'SQUISH_DECAY_SEMANTIC', 90),
+        procedural: getNumber('lifecycle.decay.procedural', 'SQUISH_DECAY_PROCEDURAL', 180),
+        autobiographical: getNumber('lifecycle.decay.autobiographical', 'SQUISH_DECAY_AUTOBIOGRAPHICAL', 365),
+        working: getNumber('lifecycle.decay.working', 'SQUISH_DECAY_WORKING', 7),
     },
-    // Scheduler
-    schedulerMode: (process.env.SQUISH_SCHEDULER_MODE || 'cron'),
-    cronEnabled: process.env.SQUISH_CRON_ENABLED !== 'false',
-    heartbeatInterval: parseInt(process.env.SQUISH_HEARTBEAT_INTERVAL || '60000'),
-    jobRetentionDays: parseInt(process.env.SQUISH_JOB_RETENTION_DAYS || '30'),
-    // Core Memory
-    coreMemoryTotalBytes: parseInt(process.env.SQUISH_CORE_MEMORY_TOTAL_BYTES || '16384'),
-    coreMemorySectionBytes: parseInt(process.env.SQUISH_CORE_MEMORY_SECTION_BYTES || '4096'),
-    // Embeddings Performance
-    embeddingsTimeoutMs: parseInt(process.env.SQUISH_EMBEDDINGS_TIMEOUT_MS || '30000'),
-    embeddingsMaxRetries: parseInt(process.env.SQUISH_EMBEDDINGS_MAX_RETRIES || '3'),
-    embeddingsRetryDelayMs: parseInt(process.env.SQUISH_EMBEDDINGS_RETRY_DELAY_MS || '1000'),
-    openAiTimeoutMs: parseInt(process.env.SQUISH_OPENAI_TIMEOUT_MS || process.env.SQUISH_EMBEDDINGS_TIMEOUT_MS || '30000'),
-    ollamaTimeoutMs: parseInt(process.env.SQUISH_OLLAMA_TIMEOUT_MS || process.env.SQUISH_EMBEDDINGS_TIMEOUT_MS || '30000'),
-    googleTimeoutMs: parseInt(process.env.SQUISH_GOOGLE_TIMEOUT_MS || process.env.SQUISH_EMBEDDINGS_TIMEOUT_MS || '30000'),
+    summarizationEnabled: getBoolean('features.summarizationEnabled', 'SQUISH_SUMMARIZATION_ENABLED', true),
+    incrementalThreshold: getNumber('summarization.incrementalThreshold', 'SQUISH_INCREMENTAL_THRESHOLD', 10),
+    rollingWindowSize: getNumber('summarization.rollingWindowSize', 'SQUISH_ROLLING_WINDOW_SIZE', 50),
+    agentIsolationEnabled: getBoolean('features.agentIsolation', 'SQUISH_AGENT_ISOLATION_ENABLED', true),
+    defaultVisibilityScope: getEnum('visibility.defaultScope', 'SQUISH_DEFAULT_VISIBILITY', VISIBILITY_SCOPES, 'private'),
+    governanceEnabled: getBoolean('features.governanceEnabled', 'SQUISH_GOVERNANCE_ENABLED', true),
+    consolidationEnabled: getBoolean('features.consolidationEnabled', 'SQUISH_CONSOLIDATION_ENABLED', false),
+    consolidationSimilarityThreshold: getNumber('consolidation.similarityThreshold', 'SQUISH_CONSOLIDATION_THRESHOLD', 0.8),
+    obsidianEnabled: getBoolean('features.obsidianEnabled', 'SQUISH_OBSIDIAN_ENABLED', false),
+    obsidianVaultPath: getString('obsidian.vaultPath', 'SQUISH_OBSIDIAN_VAULT_PATH', ''),
+    externalMemoryEnabled: getBoolean('features.externalMemoryEnabled', 'SQUISH_EXTERNAL_MEMORY_ENABLED', false),
+    externalMemoryPath: getString('external.memoryPath', 'SQUISH_EXTERNAL_MEMORY_PATH', ''),
+    sessionAutoLoadEnabled: getBoolean('features.sessionAutoLoadEnabled', 'SQUISH_SESSION_AUTO_LOAD', true),
+    sessionAutoLoadRecentCount: getNumber('session.autoLoadRecentCount', 'SQUISH_SESSION_AUTO_LOAD_RECENT_COUNT', 5),
+    sessionAutoLoadImportanceThreshold: getNumber('session.autoLoadImportanceThreshold', 'SQUISH_SESSION_AUTO_LOAD_IMPORTANCE_THRESHOLD', 70),
+    queryRewritingEnabled: getBoolean('features.queryRewritingEnabled', 'SQUISH_QUERY_REWRITING', true),
+    queryRewritingContextMessages: getNumber('query.rewritingContextMessages', 'SQUISH_QUERY_REWRITING_CONTEXT_MESSAGES', 5),
+    queryRewritingFallbackEnabled: getBoolean('features.queryRewritingFallbackEnabled', 'SQUISH_QUERY_REWRITING_FALLBACK', true),
+    feedbackTrackingEnabled: getBoolean('features.feedbackTrackingEnabled', 'SQUISH_FEEDBACK_TRACKING', true),
+    feedbackEchoBonus: getNumber('feedback.echoBonus', 'SQUISH_FEEDBACK_ECHO_BONUS', 10),
+    feedbackFizzlePenalty: getNumber('feedback.fizzlePenalty', 'SQUISH_FEEDBACK_FIZZLE_PENALTY', 5),
+    scoringWeights,
+    schedulerMode: getEnum('scheduler.mode', 'SQUISH_SCHEDULER_MODE', SCHEDULER_MODES, 'cron'),
+    cronEnabled: getBoolean('scheduler.cronEnabled', 'SQUISH_CRON_ENABLED', true),
+    heartbeatInterval: getNumber('scheduler.heartbeatInterval', 'SQUISH_HEARTBEAT_INTERVAL', 60000),
+    jobRetentionDays: getNumber('scheduler.jobRetentionDays', 'SQUISH_JOB_RETENTION_DAYS', 30),
+    coreMemoryTotalBytes: getNumber('coreMemory.totalBytes', 'SQUISH_CORE_MEMORY_TOTAL_BYTES', 16384),
+    coreMemorySectionBytes: getNumber('coreMemory.sectionBytes', 'SQUISH_CORE_MEMORY_SECTION_BYTES', 4096),
+    embeddingsTimeoutMs: getNumber('embeddings.timeout', 'SQUISH_EMBEDDINGS_TIMEOUT_MS', 30000),
+    embeddingsMaxRetries: getNumber('embeddings.maxRetries', 'SQUISH_EMBEDDINGS_MAX_RETRIES', 3),
+    embeddingsRetryDelayMs: getNumber('embeddings.retryDelay', 'SQUISH_EMBEDDINGS_RETRY_DELAY_MS', 1000),
+    openAiTimeoutMs: getNumber('embeddings.models.openai.timeout', 'SQUISH_OPENAI_TIMEOUT_MS', getNumber('embeddings.timeout', 'SQUISH_EMBEDDINGS_TIMEOUT_MS', 30000)),
+    ollamaTimeoutMs: getNumber('embeddings.models.ollama.timeout', 'SQUISH_OLLAMA_TIMEOUT_MS', getNumber('embeddings.timeout', 'SQUISH_EMBEDDINGS_TIMEOUT_MS', 30000)),
+    googleTimeoutMs: getNumber('embeddings.models.google.timeout', 'SQUISH_GOOGLE_TIMEOUT_MS', getNumber('embeddings.timeout', 'SQUISH_EMBEDDINGS_TIMEOUT_MS', 30000)),
+    llmEnabled,
+    llmApiKey: process.env.SQUISH_LLM_API_KEY || process.env.OPENAI_API_KEY || '',
+    llmProvider,
+    llmExtractionModel: getString('llm.models.extraction', 'SQUISH_LLM_EXTRACTION_MODEL', ''),
+    llmReasoningModel: getString('llm.models.reasoning', 'SQUISH_LLM_REASONING_MODEL', ''),
+    llmEndpoint,
+    llm: { enabled: llmEnabled, provider: llmProvider, endpoint: llmEndpoint },
+    graphAutoBuild,
+    graphExtractionMethod,
+    graphMaxContentLength,
+    graph: { autoBuild: graphAutoBuild, extractionMethod: graphExtractionMethod, maxContentLength: graphMaxContentLength },
 };
 export default config;
 //# sourceMappingURL=config.js.map

package/dist/core/adapters/types.d.ts

@@ -105,49 +105,29 @@ export interface AdapterRegistry {
 /** Zod schemas for validation */
 export declare const SessionContextInputSchema: z.ZodObject<{
     project: z.ZodString;
-    mode: z.ZodDefault<z.ZodEnum<["startup", "resume", "compact"]>>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        startup: "startup";
+        resume: "resume";
+        compact: "compact";
+    }>>;
     sessionId: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    project: string;
-    mode: "resume" | "startup" | "compact";
-    sessionId?: string | undefined;
-}, {
-    project: string;
-    mode?: "resume" | "startup" | "compact" | undefined;
-    sessionId?: string | undefined;
-}>;
+}, z.core.$strip>;
 export declare const ToolObservationInputSchema: z.ZodObject<{
     toolName: z.ZodString;
     toolInput: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     toolResult: z.ZodUnknown;
     project: z.ZodString;
     sessionId: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    project: string;
-    toolName: string;
-    toolInput: Record<string, unknown>;
-    sessionId?: string | undefined;
-    toolResult?: unknown;
-}, {
-    project: string;
-    toolName: string;
-    toolInput: Record<string, unknown>;
-    sessionId?: string | undefined;
-    toolResult?: unknown;
-}>;
+}, z.core.$strip>;
 export declare const TimelineInputSchema: z.ZodObject<{
     query: z.ZodString;
-    depth: z.ZodDefault<z.ZodEnum<["index", "timeline", "detail"]>>;
+    depth: z.ZodDefault<z.ZodEnum<{
+        index: "index";
+        timeline: "timeline";
+        detail: "detail";
+    }>>;
     limit: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    query: string;
-    limit: number;
-    depth: "index" | "timeline" | "detail";
-}, {
-    query: string;
-    limit?: number | undefined;
-    depth?: "index" | "timeline" | "detail" | undefined;
-}>;
+}, z.core.$strip>;
 /** Tool category mapping */
 export declare const TOOL_CATEGORIES: Record<string, ToolObservationOutput['category']>;
 /**

package/dist/core/adapters/types.js

@@ -19,7 +19,7 @@ export const SessionContextInputSchema = z.object({
 });
 export const ToolObservationInputSchema = z.object({
     toolName: z.string(),
-    toolInput: z.record(z.unknown()),
+    toolInput: z.record(z.string(), z.unknown()),
     toolResult: z.unknown(),
     project: z.string(),
     sessionId: z.string().optional(),

package/dist/core/agent-preferences.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Agent Preferences - Accumulate and retrieve agent preferences from learnings
+ * Enables agents to learn and evolve over time
+ */
+/**
+ * Update agent preference from a learning
+ */
+export declare function updateAgentPreference(projectId: string, content: string, sourceMemoryId?: string): Promise<void>;
+/**
+ * Get all agent preferences for a project
+ */
+export declare function getAgentPreferences(projectId: string): Promise<Array<{
+    key: string;
+    value: string;
+}>>;
+//# sourceMappingURL=agent-preferences.d.ts.map

package/dist/core/agent-preferences.js

@@ -0,0 +1,124 @@
+/**
+ * Agent Preferences - Accumulate and retrieve agent preferences from learnings
+ * Enables agents to learn and evolve over time
+ */
+import { getDb } from '../db/index.js';
+import { eq, and } from 'drizzle-orm';
+import { logger } from './logger.js';
+/**
+ * Extract preference from learning content
+ * E.g., "Prefer bun over npm" -> key: "prefer_bun", value: "bun"
+ */
+function extractPreference(content) {
+    const patterns = [
+        // "Prefer X over Y"
+        /prefer\s+(\w+)\s+over\s+(\w+)/i,
+        // "Always use X"
+        /always\s+use\s+(\w+)/i,
+        // "Use X instead of Y"
+        /use\s+(\w+)\s+instead\s+of\s+(\w+)/i,
+        // "X is better than Y"
+        /(\w+)\s+is\s+better\s+than\s+(\w+)/i,
+        // "Don't use X"
+        /(?:don't|do not|never)\s+use\s+(\w+)/i,
+    ];
+    for (const pattern of patterns) {
+        const match = content.match(pattern);
+        if (match) {
+            const key = `prefer_${match[1].toLowerCase()}`;
+            const value = match[2]?.toLowerCase() || 'true';
+            return { key, value };
+        }
+    }
+    return null;
+}
+/**
+ * Update agent preference from a learning
+ */
+export async function updateAgentPreference(projectId, content, sourceMemoryId) {
+    const preference = extractPreference(content);
+    if (!preference)
+        return;
+    try {
+        const db = getDb();
+        // Check if preference exists
+        const existing = await db.query.agentPreferences?.findFirst(and(eq(db.schema.agentPreferences.projectId, projectId), eq(db.schema.agentPreferences.key, preference.key))).catch(() => null);
+        if (existing) {
+            // Update existing preference
+            await db.update(db.schema.agentPreferences)
+                .set({
+                value: preference.value,
+                sourceMemoryId: sourceMemoryId,
+                usageCount: (existing.usageCount ?? 0) + 1,
+                lastUpdated: Math.floor(Date.now() / 1000)
+            })
+                .where(eq(db.schema.agentPreferences.id, existing.id))
+                .catch(() => {
+                // Fallback for SQLite which uses different table name
+                const sqlite = db._?.sqlite || db;
+                if (sqlite) {
+                    sqlite.prepare(`
+              UPDATE agent_preferences 
+              SET value = ?, source_memory_id = ?, usage_count = usage_count + 1, last_updated = ?
+              WHERE project_id = ? AND key = ?
+            `).run(preference.value, sourceMemoryId, Math.floor(Date.now() / 1000), projectId, preference.key);
+                }
+            });
+            logger.info(`[AgentPrefs] Updated preference: ${preference.key} = ${preference.value}`);
+        }
+        else {
+            // Insert new preference
+            const id = `pref_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+            await db.insert(db.schema.agentPreferences)
+                .values({
+                id,
+                projectId,
+                key: preference.key,
+                value: preference.value,
+                sourceMemoryId: sourceMemoryId ?? null,
+                confidence: 0.5,
+                usageCount: 1
+            })
+                .catch(() => {
+                // Fallback for SQLite
+                const sqlite = db._?.sqlite || db;
+                if (sqlite) {
+                    sqlite.prepare(`
+              INSERT INTO agent_preferences (id, project_id, key, value, source_memory_id, confidence, usage_count)
+              VALUES (?, ?, ?, ?, ?, 0.5, 1)
+            `).run(id, projectId, preference.key, preference.value, sourceMemoryId ?? null);
+                }
+            });
+            logger.info(`[AgentPrefs] Created preference: ${preference.key} = ${preference.value}`);
+        }
+    }
+    catch (error) {
+        logger.warn(`[AgentPrefs] Failed to update preference:`, error);
+    }
+}
+/**
+ * Get all agent preferences for a project
+ */
+export async function getAgentPreferences(projectId) {
+    try {
+        const db = getDb();
+        const results = await db.query.agentPreferences?.findMany({
+            where: eq(db.schema.agentPreferences.projectId, projectId)
+        }).catch(() => []);
+        if (results && results.length > 0) {
+            return results.map(p => ({ key: p.key, value: p.value }));
+        }
+        // Fallback for SQLite
+        const sqlite = db._?.sqlite || db;
+        if (sqlite) {
+            const rows = sqlite.prepare('SELECT key, value FROM agent_preferences WHERE project_id = ?').all(projectId);
+            return rows.map(r => ({ key: r.key, value: r.value }));
+        }
+        return [];
+    }
+    catch (error) {
+        logger.warn(`[AgentPrefs] Failed to get preferences:`, error);
+        return [];
+    }
+}
+//# sourceMappingURL=agent-preferences.js.map

package/dist/core/algorithms/safety/safety-checks.d.ts

@@ -3,11 +3,7 @@
  * Checks run before creating merge proposals and are categorized as BLOCKER or WARNING.
  */
 import type { Memory } from '../../../db/drizzle/schema.js';
-export interface SafetyCheckResult {
-    passed: boolean;
-    warnings: string[];
-    blockers: string[];
-}
+import type { SafetyCheckResult } from '../../lib/types.js';
 export interface SafetyCheck {
     name: string;
     description: string;

package/dist/core/algorithms/types.d.ts

@@ -102,14 +102,6 @@ export interface ProjectMergeStatistics {
     };
     averageMergeSize: number;
 }
-/**
- * Merge safety check result
- */
-export interface SafetyCheckResult {
-    passed: boolean;
-    warnings: string[];
-    blockers: string[];
-}
 /**
  * Hash cache entry for fast duplicate detection
  */