context-gatekeeper 0.3.0

package/dist/scripts/cli.ts

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+/**
+ * context-gatekeeper install helper CLI.
+ *
+ * Subcommands:
+ *   install   [agent ...]   - merge the MCP entry into one or more agents' configs
+ *   uninstall [agent ...]   - remove the MCP entry from one or more agents' configs
+ *   status                  - print a table of detected agents and install state
+ *   help                    - print usage
+ *
+ * Examples:
+ *   npx context-gatekeeper install --all
+ *   npx context-gatekeeper install cursor claude-code
+ *   npx context-gatekeeper uninstall --all
+ *   npx context-gatekeeper status
+ *
+ * Exit codes:
+ *   0 - success
+ *   1 - one or more operations failed (or were skipped, for uninstall)
+ *   2 - invalid usage
+ */
+
+import { installAgents, InstallResult } from './cli/install.ts';
+import { uninstallAgents, UninstallResult } from './cli/uninstall.ts';
+import { printStatus } from './cli/status.ts';
+import { detectAll, isValidAgent, AgentName, SUPPORTED_AGENTS } from './cli/detect.ts';
+
+const HELP = `context-gatekeeper installer
+
+Usage:
+  context-gatekeeper install [agent ...] [--all] [--local]
+  context-gatekeeper uninstall [agent ...] [--all] [--local]
+  context-gatekeeper status [--local]
+  context-gatekeeper help
+
+Agents:
+  ${SUPPORTED_AGENTS.join(', ')}
+
+Options:
+  --all      target every supported agent (default for uninstall when none given)
+  --local    write to project-local config (./.cursor/mcp.json, etc.) instead of global
+             (Claude Desktop is always global-only)
+
+Examples:
+  context-gatekeeper install --all
+  context-gatekeeper install cursor claude-code
+  context-gatekeeper uninstall cursor
+  context-gatekeeper status
+`;
+
+interface ParsedArgs {
+  command: string;
+  positional: string[];
+  flags: Set<string>;
+  flagValues: Map<string, string>;
+}
+
+function parseArgs(argv: string[]): ParsedArgs {
+  const [command = 'help', ...rest] = argv;
+  const positional: string[] = [];
+  const flags = new Set<string>();
+  const flagValues = new Map<string, string>();
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a.startsWith('--')) {
+      const eq = a.indexOf('=');
+      if (eq >= 0) {
+        const name = a.slice(2, eq);
+        const value = a.slice(eq + 1);
+        flags.add(name);
+        flagValues.set(name, value);
+      } else {
+        const name = a.slice(2);
+        const next = rest[i + 1];
+        if (next !== undefined && !next.startsWith('--') && TAKES_VALUE.has(name)) {
+          flags.add(name);
+          flagValues.set(name, next);
+          i++;
+        } else {
+          flags.add(name);
+        }
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  return { command, positional, flags, flagValues };
+}
+
+const TAKES_VALUE = new Set(['cwd']);
+
+function resolveAgents(positional: string[], allFlag: boolean): AgentName[] {
+  if (allFlag) return [...SUPPORTED_AGENTS];
+  if (positional.length === 0) return [];
+  const invalid = positional.filter((a) => !isValidAgent(a));
+  if (invalid.length > 0) {
+    console.error(`Unknown agent(s): ${invalid.join(', ')}`);
+    console.error(`Available: ${SUPPORTED_AGENTS.join(', ')}`);
+    process.exit(2);
+  }
+  return positional as AgentName[];
+}
+
+function reportInstall(results: InstallResult[]): number {
+  let failed = 0;
+  for (const r of results) {
+    const tag = r.status === 'error' ? 'ERROR' : r.status.toUpperCase().padEnd(9);
+    console.log(`[${tag}] ${r.agent.padEnd(15)} ${r.configPath}`);
+    if (r.message) console.log(`         ${r.message}`);
+    if (r.status === 'error') failed++;
+  }
+  return failed === 0 ? 0 : 1;
+}
+
+function reportUninstall(results: UninstallResult[]): number {
+  let failed = 0;
+  for (const r of results) {
+    const tag = r.status === 'error' ? 'ERROR' : r.status.toUpperCase().padEnd(9);
+    console.log(`[${tag}] ${r.agent.padEnd(15)} ${r.configPath}`);
+    if (r.message) console.log(`         ${r.message}`);
+    if (r.status === 'error') failed++;
+  }
+  return failed === 0 ? 0 : 1;
+}
+
+function main(argv: string[]): number {
+  const { command, positional, flags, flagValues } = parseArgs(argv);
+  const scope = flags.has('local') ? 'project' : 'global';
+  const allFlag = flags.has('all');
+  const cwd = flagValues.get('cwd');
+  const opts = cwd ? { scope, cwd } : { scope };
+
+  switch (command) {
+    case 'help':
+    case '--help':
+    case '-h': {
+      console.log(HELP);
+      return 0;
+    }
+    case 'install': {
+      const agents = resolveAgents(positional, allFlag);
+      if (agents.length === 0) {
+        console.error('No agents specified. Use --all or pass agent names.');
+        console.error(`Available: ${SUPPORTED_AGENTS.join(', ')}`);
+        return 2;
+      }
+      const results = installAgents(agents, opts);
+      return reportInstall(results);
+    }
+    case 'uninstall': {
+      const agents = resolveAgents(positional, allFlag);
+      if (agents.length === 0) {
+        console.error('No agents specified. Use --all or pass agent names.');
+        console.error(`Available: ${SUPPORTED_AGENTS.join(', ')}`);
+        return 2;
+      }
+      const results = uninstallAgents(agents, opts);
+      return reportUninstall(results);
+    }
+    case 'status': {
+      printStatus(detectAll(opts));
+      return 0;
+    }
+    default: {
+      console.error(`Unknown command: ${command}`);
+      console.log(HELP);
+      return 2;
+    }
+  }
+}
+
+const exitCode = main(process.argv.slice(2));
+process.exit(exitCode);

package/dist/services/classifier/index.d.ts

@@ -0,0 +1,36 @@
+import { Memory } from '../../models/types.js';
+import { LLMConfig } from './llm.js';
+export interface ClassificationResult {
+    memory: Memory;
+    relevance: number;
+    matchedBy: 'rule' | 'llm' | 'both';
+}
+/**
+ * Hybrid Classifier - combines rule-based and LLM-based classification
+ */
+export declare class HybridClassifier {
+    private memoryService;
+    private llmClassifier;
+    constructor(llmConfig?: LLMConfig);
+    /**
+     * Configure LLM settings
+     */
+    configureLLM(config: Partial<LLMConfig>): void;
+    /**
+     * Classify and rank memories for a given user input
+     *
+     * Process:
+     * 1. Rule-based quick filter (anchored + constraint)
+     * 2. LLM-based precise classification
+     * 3. Merge and deduplicate results
+     * 4. Sort by relevance
+     */
+    classify(userInput: string, projectTags?: string[], limit?: number): Promise<ClassificationResult[]>;
+    /**
+     * Quick classify using only rules (no LLM)
+     * Useful when LLM is unavailable
+     */
+    classifyWithRules(userInput: string, projectTags?: string[], limit?: number): ClassificationResult[];
+}
+export declare function getHybridClassifier(llmConfig?: LLMConfig): HybridClassifier;
+//# sourceMappingURL=index.d.ts.map

package/dist/services/classifier/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/classifier/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAG/C,OAAO,EAAmC,SAAS,EAAE,MAAM,UAAU,CAAC;AAEtE,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;CACpC;AAED;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,aAAa,CAAgB;gBAEzB,SAAS,CAAC,EAAE,SAAS;IAIjC;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI;IAI9C;;;;;;;;OAQG;IACG,QAAQ,CACZ,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,EAAE,EACtB,KAAK,GAAE,MAAW,GACjB,OAAO,CAAC,oBAAoB,EAAE,CAAC;IA2DlC;;;OAGG;IACH,iBAAiB,CACf,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,EAAE,EACtB,KAAK,GAAE,MAAW,GACjB,oBAAoB,EAAE;CAa1B;AAKD,wBAAgB,mBAAmB,CAAC,SAAS,CAAC,EAAE,SAAS,GAAG,gBAAgB,CAK3E"}

package/dist/services/classifier/index.js

@@ -0,0 +1,104 @@
+import { getMemoryService } from '../memory.js';
+import { extractKeywords, extractFileTypes, quickFilterHighPriority } from './rules.js';
+import { getLLMClassifier } from './llm.js';
+/**
+ * Hybrid Classifier - combines rule-based and LLM-based classification
+ */
+export class HybridClassifier {
+    memoryService = getMemoryService();
+    llmClassifier;
+    constructor(llmConfig) {
+        this.llmClassifier = getLLMClassifier(llmConfig);
+    }
+    /**
+     * Configure LLM settings
+     */
+    configureLLM(config) {
+        this.llmClassifier.configure(config);
+    }
+    /**
+     * Classify and rank memories for a given user input
+     *
+     * Process:
+     * 1. Rule-based quick filter (anchored + constraint)
+     * 2. LLM-based precise classification
+     * 3. Merge and deduplicate results
+     * 4. Sort by relevance
+     */
+    async classify(userInput, projectTags, limit = 10) {
+        // Extract features for rule matching
+        const keywords = extractKeywords(userInput);
+        const fileTypes = extractFileTypes(userInput);
+        // Step 1: Rule-based quick filter
+        const allMemories = this.memoryService.listAllMemories(projectTags);
+        const ruleMatches = quickFilterHighPriority(allMemories, keywords, fileTypes);
+        // Step 2: LLM-based precise classification
+        let llmResults = [];
+        try {
+            llmResults = await this.llmClassifier.classify(userInput, allMemories);
+        }
+        catch {
+            // LLM failed, continue with rules only
+        }
+        // Step 3: Merge results
+        const resultsMap = new Map();
+        // Add rule matches
+        for (const memory of ruleMatches) {
+            resultsMap.set(memory.id, {
+                memory,
+                relevance: 0.8, // Rule matches get high base relevance
+                matchedBy: 'rule'
+            });
+        }
+        // Add LLM matches (boost if already matched by rules)
+        for (const { memoryId, relevance } of llmResults) {
+            const existing = resultsMap.get(memoryId);
+            if (existing) {
+                existing.relevance = Math.min(1.0, existing.relevance + relevance * 0.2);
+                existing.matchedBy = 'both';
+            }
+            else {
+                const memory = this.memoryService.getMemory(memoryId);
+                if (memory) {
+                    resultsMap.set(memoryId, {
+                        memory,
+                        relevance,
+                        matchedBy: 'llm'
+                    });
+                }
+            }
+        }
+        // Step 4: Sort by relevance
+        const results = Array.from(resultsMap.values());
+        results.sort((a, b) => b.relevance - a.relevance);
+        // Update access counts for returned memories
+        for (const result of results) {
+            this.memoryService.getMemory(result.memory.id); // Triggers access count increment
+        }
+        return results.slice(0, limit);
+    }
+    /**
+     * Quick classify using only rules (no LLM)
+     * Useful when LLM is unavailable
+     */
+    classifyWithRules(userInput, projectTags, limit = 10) {
+        const keywords = extractKeywords(userInput);
+        const fileTypes = extractFileTypes(userInput);
+        const allMemories = this.memoryService.listAllMemories(projectTags);
+        const ruleMatches = quickFilterHighPriority(allMemories, keywords, fileTypes);
+        return ruleMatches.slice(0, limit).map(memory => ({
+            memory,
+            relevance: 0.8,
+            matchedBy: 'rule'
+        }));
+    }
+}
+// Singleton instance
+let hybridClassifierInstance = null;
+export function getHybridClassifier(llmConfig) {
+    if (!hybridClassifierInstance) {
+        hybridClassifierInstance = new HybridClassifier(llmConfig);
+    }
+    return hybridClassifierInstance;
+}
+//# sourceMappingURL=index.js.map

package/dist/services/classifier/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/services/classifier/index.ts"],"names":[],"mappings":"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"}

package/dist/services/classifier/llm.d.ts

@@ -0,0 +1,37 @@
+import { Memory } from '../../models/types.js';
+export interface LLMConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+}
+export interface ClassifierResult {
+    memoryId: string;
+    relevance: number;
+}
+/**
+ * Default LLM classifier using the agent's own model
+ * This can be overridden by user configuration
+ */
+export declare class LLMClassifier {
+    private config;
+    constructor(config?: LLMConfig);
+    /**
+     * Configure the LLM settings
+     */
+    configure(config: Partial<LLMConfig>): void;
+    /**
+     * Classify memories using LLM
+     * Returns memory IDs with relevance scores
+     */
+    classify(userInput: string, memories: Memory[]): Promise<ClassifierResult[]>;
+    /**
+     * Call the LLM API
+     */
+    private callLLM;
+    /**
+     * Parse LLM response to extract memory IDs
+     */
+    private parseLLMResponse;
+}
+export declare function getLLMClassifier(config?: LLMConfig): LLMClassifier;
+//# sourceMappingURL=llm.d.ts.map

package/dist/services/classifier/llm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm.d.ts","sourceRoot":"","sources":["../../../src/services/classifier/llm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAI/C,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AA2BD;;;GAGG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAY;gBAEd,MAAM,GAAE,SAAc;IAOlC;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI;IAI3C;;;OAGG;IACG,QAAQ,CACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAAE,GACjB,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAoB9B;;OAEG;YACW,OAAO;IAgCrB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAYzB;AAKD,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,aAAa,CAOlE"}

package/dist/services/classifier/llm.js

@@ -0,0 +1,119 @@
+import { LLMError } from '../../utils/errors.js';
+import { logger } from '../../utils/logger.js';
+/**
+ * Build the prompt for LLM-based memory classification
+ */
+function buildClassificationPrompt(userInput, memories) {
+    const memoryList = memories
+        .map(m => `- [${m.id}] (${m.priority}${m.anchored ? ', anchored' : ''}): ${m.content}`)
+        .join('\n');
+    return `Given the following user input and available memories, identify which memories are relevant to inject into the context.
+
+User Input:
+${userInput}
+
+Available Memories:
+${memoryList}
+
+Respond with a JSON array of memory IDs that should be injected, ordered by relevance (most relevant first).
+Format: ["memory-id-1", "memory-id-2", ...]
+If no memories are relevant, respond with an empty array: []
+Only respond with the JSON array, nothing else.`;
+}
+/**
+ * Default LLM classifier using the agent's own model
+ * This can be overridden by user configuration
+ */
+export class LLMClassifier {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            model: 'gpt-4o',
+            ...config
+        };
+    }
+    /**
+     * Configure the LLM settings
+     */
+    configure(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Classify memories using LLM
+     * Returns memory IDs with relevance scores
+     */
+    async classify(userInput, memories) {
+        if (memories.length === 0) {
+            return [];
+        }
+        const prompt = buildClassificationPrompt(userInput, memories);
+        try {
+            const response = await this.callLLM(prompt);
+            const memoryIds = this.parseLLMResponse(response);
+            // Calculate relevance scores (uniform initially, could be refined)
+            return memoryIds.map(id => ({ memoryId: id, relevance: 1.0 }));
+        }
+        catch (error) {
+            // Don't throw - let the fallback handle it
+            logger.error('LLM classification failed', { error: error instanceof Error ? error.message : String(error) });
+            return [];
+        }
+    }
+    /**
+     * Call the LLM API
+     */
+    async callLLM(prompt) {
+        const { apiKey, baseUrl, model } = this.config;
+        // If no API key is configured, we can't make the call
+        if (!apiKey) {
+            throw new LLMError('No LLM API key configured');
+        }
+        const url = baseUrl || 'https://api.openai.com/v1/chat/completions';
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`
+            },
+            body: JSON.stringify({
+                model: model || 'gpt-4o',
+                messages: [{ role: 'user', content: prompt }],
+                max_tokens: 500,
+                temperature: 0.1
+            })
+        });
+        if (!response.ok) {
+            throw new LLMError(`LLM API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.choices[0]?.message?.content || '[]';
+    }
+    /**
+     * Parse LLM response to extract memory IDs
+     */
+    parseLLMResponse(response) {
+        try {
+            // Try to extract JSON from the response
+            const jsonMatch = response.match(/\[[\s\S]*\]/);
+            if (jsonMatch) {
+                return JSON.parse(jsonMatch[0]);
+            }
+            return [];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+// Singleton instance
+let llmClassifierInstance = null;
+export function getLLMClassifier(config) {
+    if (!llmClassifierInstance) {
+        llmClassifierInstance = new LLMClassifier(config);
+    }
+    else if (config) {
+        llmClassifierInstance.configure(config);
+    }
+    return llmClassifierInstance;
+}
+//# sourceMappingURL=llm.js.map

package/dist/services/classifier/llm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm.js","sourceRoot":"","sources":["../../../src/services/classifier/llm.ts"],"names":[],"mappings":"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"}

package/dist/services/classifier/rules.d.ts

@@ -0,0 +1,22 @@
+import { Memory } from '../../models/types.js';
+/**
+ * Extract keywords from user input for rule-based matching
+ */
+export declare function extractKeywords(input: string): string[];
+/**
+ * Extract file types mentioned in input
+ */
+export declare function extractFileTypes(input: string): string[];
+/**
+ * Check if a memory matches the input based on rules
+ */
+export declare function memoryMatchesRules(memory: Memory, keywords: string[], fileTypes: string[]): {
+    matches: boolean;
+    relevance: number;
+};
+/**
+ * Quick filter for high-priority memories
+ * Returns memories that should be directly included
+ */
+export declare function quickFilterHighPriority(memories: Memory[], keywords: string[], fileTypes: string[]): Memory[];
+//# sourceMappingURL=rules.d.ts.map

package/dist/services/classifier/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/services/classifier/rules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE/C;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBvD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAgBxD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAAE,EAClB,SAAS,EAAE,MAAM,EAAE,GAClB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAmCzC;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAAE,EAClB,QAAQ,EAAE,MAAM,EAAE,EAClB,SAAS,EAAE,MAAM,EAAE,GAClB,MAAM,EAAE,CA2BV"}

package/dist/services/classifier/rules.js

@@ -0,0 +1,98 @@
+/**
+ * Extract keywords from user input for rule-based matching
+ */
+export function extractKeywords(input) {
+    // Simple word extraction (could be enhanced with NLP)
+    const words = input.toLowerCase()
+        .replace(/[^\w\s]/g, ' ')
+        .split(/\s+/)
+        .filter(word => word.length > 2);
+    // Remove common stop words
+    const stopWords = new Set([
+        'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can',
+        'had', 'her', 'was', 'one', 'our', 'out', 'has', 'have', 'been',
+        'would', 'could', 'this', 'that', 'with', 'they', 'from', 'what',
+        'when', 'where', 'which', 'their', 'there', 'these', 'those',
+        'over' // common preposition
+    ]);
+    return [...new Set(words.filter(word => !stopWords.has(word)))];
+}
+/**
+ * Extract file types mentioned in input
+ */
+export function extractFileTypes(input) {
+    const fileTypePatterns = [
+        /\b(\w+)\.(ts|js|tsx|jsx|py|rs|go|java|cpp|c|h|hpp|rs)\b/gi,
+        /\b(config|test|spec|index|main|app)\b/gi
+    ];
+    const types = [];
+    for (const pattern of fileTypePatterns) {
+        const matches = input.match(pattern);
+        if (matches) {
+            types.push(...matches.map(m => m.toLowerCase()));
+        }
+    }
+    return [...new Set(types)];
+}
+/**
+ * Check if a memory matches the input based on rules
+ */
+export function memoryMatchesRules(memory, keywords, fileTypes) {
+    const contentLower = memory.content.toLowerCase();
+    const memoryTags = memory.projectTags.map(t => t.toLowerCase());
+    let matchCount = 0;
+    let totalWeight = 0;
+    // Check keyword matches
+    for (const keyword of keywords) {
+        if (contentLower.includes(keyword)) {
+            matchCount += 2; // Keywords are more important
+            totalWeight += 2;
+        }
+    }
+    // Check file type matches
+    for (const fileType of fileTypes) {
+        if (contentLower.includes(fileType)) {
+            matchCount += 1;
+            totalWeight += 1;
+        }
+    }
+    // Check project tag matches
+    for (const tag of memoryTags) {
+        if (keywords.some(k => tag.includes(k) || k.includes(tag))) {
+            matchCount += 1;
+            totalWeight += 1;
+        }
+    }
+    const matches = matchCount > 0;
+    const relevance = totalWeight > 0 ? matchCount / totalWeight : 0;
+    return { matches, relevance };
+}
+/**
+ * Quick filter for high-priority memories
+ * Returns memories that should be directly included
+ */
+export function quickFilterHighPriority(memories, keywords, fileTypes) {
+    const anchoredMemories = memories.filter(m => m.anchored);
+    const constraintMemories = memories.filter(m => m.priority === 'constraint');
+    // Anchored memories are always included
+    const anchoredResults = anchoredMemories.map(m => ({
+        memory: m,
+        relevance: 1.0
+    }));
+    // Check constraint memories against rules
+    const constraintResults = [];
+    for (const memory of constraintMemories) {
+        const { matches, relevance } = memoryMatchesRules(memory, keywords, fileTypes);
+        if (matches) {
+            constraintResults.push({ memory, relevance });
+        }
+    }
+    // Sort constraint results by relevance
+    constraintResults.sort((a, b) => b.relevance - a.relevance);
+    // Combine and return
+    return [
+        ...anchoredResults.map(r => r.memory),
+        ...constraintResults.slice(0, 5).map(r => r.memory) // Limit to top 5 constraints
+    ];
+}
+//# sourceMappingURL=rules.js.map

package/dist/services/classifier/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","sourceRoot":"","sources":["../../../src/services/classifier/rules.ts"],"names":[],"mappings":"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"}

package/dist/services/compressor/index.d.ts

@@ -0,0 +1,3 @@
+export { ThresholdDetector, getThresholdDetector, DEFAULT_THRESHOLD_LOW, DEFAULT_THRESHOLD_HIGH } from './threshold.js';
+export { ContextCompressor, getContextCompressor } from './trigger.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/compressor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/compressor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxH,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC"}

package/dist/services/compressor/index.js

@@ -0,0 +1,3 @@
+export { ThresholdDetector, getThresholdDetector, DEFAULT_THRESHOLD_LOW, DEFAULT_THRESHOLD_HIGH } from './threshold.js';
+export { ContextCompressor, getContextCompressor } from './trigger.js';
+//# sourceMappingURL=index.js.map

package/dist/services/compressor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/services/compressor/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxH,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC"}