@goldensheepai/toknxr-cli 0.3.0 → 0.4.0

package/lib/hallucination-patterns.js

@@ -0,0 +1,490 @@
+/**
+ * Hallucination Pattern Detection
+ * Static analysis patterns for detecting common code hallucinations
+ */
+/**
+ * Hallucination pattern detection engine
+ */
+export class HallucinationPatterns {
+    /**
+     * Detect mapping hallucinations (data type and structure issues)
+     */
+    static detectMappingHallucinations(code) {
+        const results = [];
+        const lines = code.split('\n');
+        // Check TypeError patterns
+        for (const [patternName, config] of Object.entries(this.MAPPING_PATTERNS)) {
+            for (const pattern of config.patterns) {
+                lines.forEach((line, index) => {
+                    const match = pattern.exec(line);
+                    if (match) {
+                        const confidence = this.calculatePatternConfidence(match, line, patternName);
+                        const evidence = this.extractEvidence(match, line, index + 1);
+                        results.push({
+                            pattern: patternName,
+                            confidence,
+                            evidence,
+                            lineNumbers: [index + 1],
+                            category: 'mapping',
+                            subtype: config.subtype,
+                            severity: config.severity,
+                        });
+                    }
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Detect naming hallucinations (identifier and reference issues)
+     */
+    static detectNamingHallucinations(code) {
+        const results = [];
+        const lines = code.split('\n');
+        for (const [patternName, config] of Object.entries(this.NAMING_PATTERNS)) {
+            for (const pattern of config.patterns) {
+                lines.forEach((line, index) => {
+                    const match = pattern.exec(line);
+                    if (match) {
+                        const confidence = this.calculatePatternConfidence(match, line, patternName);
+                        const evidence = this.extractEvidence(match, line, index + 1);
+                        results.push({
+                            pattern: patternName,
+                            confidence,
+                            evidence,
+                            lineNumbers: [index + 1],
+                            category: 'naming',
+                            subtype: config.subtype,
+                            severity: config.severity,
+                        });
+                    }
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Detect resource hallucinations (memory, file, network issues)
+     */
+    static detectResourceHallucinations(code) {
+        const results = [];
+        const lines = code.split('\n');
+        for (const [patternName, config] of Object.entries(this.RESOURCE_PATTERNS)) {
+            for (const pattern of config.patterns) {
+                lines.forEach((line, index) => {
+                    const match = pattern.exec(line);
+                    if (match) {
+                        const confidence = this.calculatePatternConfidence(match, line, patternName);
+                        const evidence = this.extractEvidence(match, line, index + 1);
+                        results.push({
+                            pattern: patternName,
+                            confidence,
+                            evidence,
+                            lineNumbers: [index + 1],
+                            category: 'resource',
+                            subtype: config.subtype,
+                            severity: config.severity,
+                        });
+                    }
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Detect logic hallucinations (logical inconsistencies)
+     */
+    static detectLogicHallucinations(code) {
+        const results = [];
+        const lines = code.split('\n');
+        for (const [patternName, config] of Object.entries(this.LOGIC_PATTERNS)) {
+            for (const pattern of config.patterns) {
+                lines.forEach((line, index) => {
+                    const match = pattern.exec(line);
+                    if (match) {
+                        const confidence = this.calculatePatternConfidence(match, line, patternName);
+                        const evidence = this.extractEvidence(match, line, index + 1);
+                        results.push({
+                            pattern: patternName,
+                            confidence,
+                            evidence,
+                            lineNumbers: [index + 1],
+                            category: 'logic',
+                            subtype: config.subtype,
+                            severity: config.severity,
+                        });
+                    }
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Analyze code structure for complexity and patterns
+     */
+    static analyzeCodeStructure(code) {
+        const lines = code.split('\n');
+        const analysis = {
+            functions: [],
+            classes: [],
+            imports: [],
+            variables: [],
+            complexity: 0,
+            linesOfCode: lines.filter(line => line.trim() && !line.trim().startsWith('#')).length,
+            hasAsyncCode: false,
+            hasErrorHandling: false,
+        };
+        // Extract functions
+        const functionPattern = /def\s+(\w+)\s*\(/g;
+        let match;
+        while ((match = functionPattern.exec(code)) !== null) {
+            analysis.functions.push(match[1]);
+        }
+        // Extract classes
+        const classPattern = /class\s+(\w+)\s*[:(]/g;
+        while ((match = classPattern.exec(code)) !== null) {
+            analysis.classes.push(match[1]);
+        }
+        // Extract imports
+        const importPattern = /(?:import|from)\s+(\w+)/g;
+        while ((match = importPattern.exec(code)) !== null) {
+            analysis.imports.push(match[1]);
+        }
+        // Extract variables
+        const variablePattern = /(\w+)\s*=/g;
+        while ((match = variablePattern.exec(code)) !== null) {
+            if (!analysis.variables.includes(match[1])) {
+                analysis.variables.push(match[1]);
+            }
+        }
+        // Check for async code
+        analysis.hasAsyncCode = /async\s+def|await\s+/.test(code);
+        // Check for error handling
+        analysis.hasErrorHandling = /try:|except|finally:|raise/.test(code);
+        // Calculate complexity (simplified cyclomatic complexity)
+        const complexityPatterns = [
+            /if\s+/g,
+            /elif\s+/g,
+            /else:/g,
+            /for\s+/g,
+            /while\s+/g,
+            /except/g,
+            /and\s+/g,
+            /or\s+/g,
+        ];
+        analysis.complexity = complexityPatterns.reduce((total, pattern) => {
+            const matches = code.match(pattern);
+            return total + (matches ? matches.length : 0);
+        }, 1); // Base complexity of 1
+        return analysis;
+    }
+    /**
+     * Extract evidence from pattern match
+     */
+    static extractEvidence(match, line, lineNumber) {
+        const evidence = [];
+        // Add the matched line as primary evidence
+        evidence.push({
+            type: 'code_line',
+            content: line.trim(),
+            lineNumber,
+            confidence: 0.9,
+        });
+        // Add specific match groups as evidence
+        if (match.length > 1) {
+            for (let i = 1; i < match.length; i++) {
+                if (match[i]) {
+                    evidence.push({
+                        type: 'identifier',
+                        content: match[i],
+                        lineNumber,
+                        confidence: 0.8,
+                    });
+                }
+            }
+        }
+        // Add context if there's a comment indicating the issue
+        const commentMatch = line.match(/#\s*(.+)$/);
+        if (commentMatch) {
+            evidence.push({
+                type: 'error_message',
+                content: commentMatch[1].trim(),
+                lineNumber,
+                confidence: 0.95,
+            });
+        }
+        return evidence;
+    }
+    /**
+     * Calculate confidence score for a pattern match
+     */
+    static calculatePatternConfidence(match, line, patternName) {
+        let confidence = 0.7; // Base confidence
+        // Increase confidence if there's an error comment
+        if (line.includes('#') && /error|exception|fail|wrong|issue/i.test(line)) {
+            confidence += 0.2;
+        }
+        // Increase confidence for specific error types in comments
+        const errorKeywords = {
+            typeError: /type.*error|cannot.*add|not.*callable/i,
+            indexError: /index.*out.*of.*range|list.*index/i,
+            keyError: /key.*error|key.*not.*found/i,
+            nameError: /name.*not.*defined|undefined.*variable/i,
+            attributeError: /has.*no.*attribute|attribute.*error/i,
+            importError: /no.*module.*named|import.*error/i,
+            memoryError: /memory.*error|out.*of.*memory/i,
+            recursionError: /recursion.*limit|maximum.*recursion/i,
+            ioError: /file.*not.*found|permission.*denied/i,
+        };
+        if (errorKeywords[patternName]?.test(line)) {
+            confidence += 0.15;
+        }
+        // Decrease confidence for common variable names that might be false positives
+        const commonNames = ['data', 'result', 'value', 'item', 'temp', 'x', 'y', 'i', 'j'];
+        if (match[1] && commonNames.includes(match[1].toLowerCase())) {
+            confidence -= 0.1;
+        }
+        // Ensure confidence is within bounds
+        return Math.max(0.1, Math.min(1.0, confidence));
+    }
+    /**
+     * Convert pattern match results to hallucination categories
+     */
+    static convertToHallucinationCategories(results) {
+        return results.map(result => ({
+            type: result.category,
+            subtype: result.subtype,
+            severity: result.severity,
+            confidence: result.confidence,
+            description: this.generateDescription(result),
+            evidence: result.evidence,
+            lineNumbers: result.lineNumbers,
+            suggestedFix: this.generateSuggestedFix(result),
+            businessImpact: this.calculateBusinessImpact(result),
+        }));
+    }
+    /**
+     * Generate human-readable description for a pattern match
+     */
+    static generateDescription(result) {
+        const descriptions = {
+            typeError: 'Potential type mismatch or incorrect type assumption',
+            indexError: 'Array or list index may be out of bounds',
+            keyError: 'Dictionary key may not exist',
+            nameError: 'Variable or function may not be defined',
+            attributeError: 'Object may not have the specified attribute or method',
+            importError: 'Module or package may not be available',
+            memoryError: 'Code may consume excessive memory',
+            recursionError: 'Infinite recursion or stack overflow risk',
+            ioError: 'File or I/O operation may fail',
+            logicDeviation: 'Logical inconsistency or contradiction detected',
+            logicBreakdown: 'Code logic may be fundamentally flawed',
+        };
+        return descriptions[result.pattern] ||
+            `Potential ${result.category} hallucination detected`;
+    }
+    /**
+     * Generate suggested fix for a pattern match
+     */
+    static generateSuggestedFix(result) {
+        const fixes = {
+            typeError: 'Verify data types and add type checking or conversion',
+            indexError: 'Add bounds checking before accessing array elements',
+            keyError: 'Use .get() method or check if key exists before access',
+            nameError: 'Define the variable or function before using it',
+            attributeError: 'Verify object type and available methods/attributes',
+            importError: 'Install required package or check import statement',
+            memoryError: 'Optimize data structures or add memory limits',
+            recursionError: 'Add base case or use iterative approach',
+            ioError: 'Add file existence check and error handling',
+            logicDeviation: 'Review and fix logical contradictions',
+            logicBreakdown: 'Restructure the logic flow',
+        };
+        return fixes[result.pattern] ||
+            'Review and test the code thoroughly';
+    }
+    /**
+     * Calculate business impact score for a pattern match
+     */
+    static calculateBusinessImpact(result) {
+        const severityMultipliers = {
+            low: { time: 0.5, cost: 1.1, quality: 5 },
+            medium: { time: 2.0, cost: 1.3, quality: 15 },
+            high: { time: 4.0, cost: 1.6, quality: 30 },
+            critical: { time: 8.0, cost: 2.0, quality: 50 },
+        };
+        const multiplier = severityMultipliers[result.severity];
+        const devTimeWasted = multiplier.time * result.confidence;
+        return {
+            estimatedDevTimeWasted: devTimeWasted,
+            costMultiplier: multiplier.cost,
+            qualityImpact: Math.round(multiplier.quality * result.confidence),
+            costOfHallucinations: devTimeWasted * 100, // $100/hour dev rate
+        };
+    }
+}
+HallucinationPatterns.MAPPING_PATTERNS = {
+    // TypeError patterns - incorrect type assumptions
+    typeError: {
+        patterns: [
+            /(\w+)\s*\+\s*(\w+).*#.*(?:string|str).*(?:int|integer|number)/i,
+            /(\w+)\.(\w+)\s*\(.*\).*#.*(?:not callable|has no attribute)/i,
+            /(\w+)\[(\w+)\].*#.*(?:not subscriptable|unhashable)/i,
+            /len\s*\(\s*(\w+)\s*\).*#.*(?:has no len|object of type)/i,
+            /for\s+\w+\s+in\s+(\w+).*#.*(?:not iterable|object is not iterable)/i,
+        ],
+        severity: 'high',
+        subtype: 'data_compliance',
+    },
+    // IndexError patterns - incorrect array/list access
+    indexError: {
+        patterns: [
+            /(\w+)\[(\d+)\].*#.*(?:index out of range|list index)/i,
+            /(\w+)\[(\w+)\].*#.*(?:index out of range|string index)/i,
+            /(\w+)\[(-\d+)\].*#.*(?:index out of range)/i,
+            /(\w+)\.pop\s*\(\s*(\d+)\s*\).*#.*(?:index out of range)/i,
+        ],
+        severity: 'medium',
+        subtype: 'structure_access',
+    },
+    // KeyError patterns - incorrect dictionary access
+    keyError: {
+        patterns: [
+            /(\w+)\[['"](\w+)['"]\].*#.*(?:key error|keyerror)/i,
+            /(\w+)\.get\s*\(\s*['"](\w+)['"]\s*\).*#.*(?:none|missing)/i,
+            /(\w+)\[(\w+)\].*#.*(?:key error|keyerror)/i,
+            /del\s+(\w+)\[['"](\w+)['"]\].*#.*(?:key error)/i,
+        ],
+        severity: 'medium',
+        subtype: 'structure_access',
+    },
+};
+HallucinationPatterns.NAMING_PATTERNS = {
+    // NameError patterns - undefined variables/functions
+    nameError: {
+        patterns: [
+            /(\w+)\s*=.*#.*(?:name.*not defined|undefined)/i,
+            /(\w+)\s*\(.*\).*#.*(?:name.*not defined|undefined)/i,
+            /print\s*\(\s*(\w+)\s*\).*#.*(?:name.*not defined)/i,
+            /return\s+(\w+).*#.*(?:name.*not defined)/i,
+            /if\s+(\w+).*#.*(?:name.*not defined)/i,
+        ],
+        severity: 'high',
+        subtype: 'identity',
+    },
+    // AttributeError patterns - incorrect method/property access
+    attributeError: {
+        patterns: [
+            /(\w+)\.(\w+).*#.*(?:has no attribute|attribute error)/i,
+            /(\w+)\.(\w+)\s*\(.*\).*#.*(?:has no attribute)/i,
+            /(\w+)\.(\w+)\s*=.*#.*(?:has no attribute)/i,
+            /del\s+(\w+)\.(\w+).*#.*(?:has no attribute)/i,
+        ],
+        severity: 'medium',
+        subtype: 'identity',
+    },
+    // ImportError patterns - incorrect module imports
+    importError: {
+        patterns: [
+            /import\s+(\w+).*#.*(?:no module named|import error)/i,
+            /from\s+(\w+)\s+import\s+(\w+).*#.*(?:cannot import|import error)/i,
+            /import\s+(\w+)\.(\w+).*#.*(?:no module named)/i,
+            /__import__\s*\(\s*['"](\w+)['"]\s*\).*#.*(?:no module)/i,
+        ],
+        severity: 'critical',
+        subtype: 'external_source',
+    },
+};
+HallucinationPatterns.RESOURCE_PATTERNS = {
+    // Memory-related patterns
+    memoryError: {
+        patterns: [
+            /\[\s*\w+\s*for\s+\w+\s+in\s+range\s*\(\s*\d{6,}\s*\)\s*\].*#.*(?:memory|out of memory)/i,
+            /\*\s*\[\s*\d+\s*\]\s*\*\s*\d{4,}.*#.*(?:memory)/i,
+            /(\w+)\s*=\s*\[\s*\]\s*\*\s*\d{6,}.*#.*(?:memory)/i,
+        ],
+        severity: 'high',
+        subtype: 'physical_constraint',
+    },
+    // Recursion-related patterns
+    recursionError: {
+        patterns: [
+            /def\s+(\w+)\s*\([^)]*\):\s*[^{]*\1\s*\([^)]*\).*#.*(?:recursion|stack)/i,
+            /(\w+)\s*\([^)]*\).*\1\s*\([^)]*\).*#.*(?:maximum recursion)/i,
+        ],
+        severity: 'critical',
+        subtype: 'computational_boundary',
+    },
+    // File/IO patterns
+    ioError: {
+        patterns: [
+            /open\s*\(\s*['"]([^'"]+)['"]\s*\).*#.*(?:no such file|permission denied)/i,
+            /with\s+open\s*\(\s*['"]([^'"]+)['"]\s*\).*#.*(?:file not found)/i,
+            /(\w+)\.read\s*\(\s*\).*#.*(?:closed file|io error)/i,
+        ],
+        severity: 'medium',
+        subtype: 'physical_constraint',
+    },
+};
+HallucinationPatterns.LOGIC_PATTERNS = {
+    // Logic deviation patterns
+    logicDeviation: {
+        patterns: [
+            /if\s+(\w+)\s*==\s*(\w+)\s*and\s+\1\s*!=\s*\2.*#.*(?:contradiction|impossible)/i,
+            /while\s+True:\s*[^{]*(?!break).*#.*(?:infinite|endless)/i,
+            /(\w+)\s*=\s*(\w+)\s*\/\s*0.*#.*(?:division by zero)/i,
+            /return\s+(\w+)\s*and\s+not\s+\1.*#.*(?:contradiction)/i,
+        ],
+        severity: 'high',
+        subtype: 'logic_deviation',
+    },
+    // Logic breakdown patterns
+    logicBreakdown: {
+        patterns: [
+            /if\s+(\w+):\s*[^{]*else:\s*[^{]*\1.*#.*(?:unreachable|dead code)/i,
+            /(\w+)\s*=\s*None\s*[^{]*\1\.(\w+).*#.*(?:none type|attribute)/i,
+            /assert\s+False.*#.*(?:assertion|always fails)/i,
+        ],
+        severity: 'critical',
+        subtype: 'logic_breakdown',
+    },
+};
+/**
+ * Factory function to create pattern detection results
+ */
+export function detectAllPatterns(code) {
+    const results = [];
+    results.push(...HallucinationPatterns.detectMappingHallucinations(code));
+    results.push(...HallucinationPatterns.detectNamingHallucinations(code));
+    results.push(...HallucinationPatterns.detectResourceHallucinations(code));
+    results.push(...HallucinationPatterns.detectLogicHallucinations(code));
+    // Sort by severity and confidence
+    return results.sort((a, b) => {
+        const severityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
+        const severityDiff = severityOrder[b.severity] - severityOrder[a.severity];
+        if (severityDiff !== 0)
+            return severityDiff;
+        return b.confidence - a.confidence;
+    });
+}
+/**
+ * Utility function to get pattern statistics
+ */
+export function getPatternStatistics(results) {
+    const stats = {
+        totalPatterns: results.length,
+        byCategory: {},
+        bySeverity: {},
+        avgConfidence: 0,
+    };
+    if (results.length === 0)
+        return stats;
+    // Count by category
+    results.forEach(result => {
+        stats.byCategory[result.category] = (stats.byCategory[result.category] || 0) + 1;
+        stats.bySeverity[result.severity] = (stats.bySeverity[result.severity] || 0) + 1;
+    });
+    // Calculate average confidence
+    stats.avgConfidence = results.reduce((sum, result) => sum + result.confidence, 0) / results.length;
+    return stats;
+}

package/lib/types/database-types.js

@@ -0,0 +1,5 @@
+/**
+ * Database Types for Hallucination Analysis
+ * TypeScript interfaces matching the PostgreSQL schema
+ */
+export {};

package/lib/types/hallucination-types.js

@@ -0,0 +1,74 @@
+/**
+ * Enhanced Hallucination Detection Types
+ * Based on CodeHalu research methodology for systematic code hallucination detection
+ *
+ * @see https://github.com/yuchen814/CodeHalu
+ * @version 1.0.0
+ */
+/**
+ * Error mapping for categorizing execution errors
+ */
+export const ERROR_CATEGORY_MAP = {
+    // Mapping Hallucinations
+    'TypeError': { type: 'mapping', subtype: 'data_compliance' },
+    'ValueError': { type: 'mapping', subtype: 'data_compliance' },
+    'IndexError': { type: 'mapping', subtype: 'structure_access' },
+    'KeyError': { type: 'mapping', subtype: 'structure_access' },
+    'AttributeError': { type: 'mapping', subtype: 'structure_access' },
+    // Naming Hallucinations
+    'NameError': { type: 'naming', subtype: 'identity' },
+    'UnboundLocalError': { type: 'naming', subtype: 'identity' },
+    'ImportError': { type: 'naming', subtype: 'external_source' },
+    'ModuleNotFoundError': { type: 'naming', subtype: 'external_source' },
+    // Resource Hallucinations
+    'MemoryError': { type: 'resource', subtype: 'physical_constraint' },
+    'RecursionError': { type: 'resource', subtype: 'physical_constraint' },
+    'OverflowError': { type: 'resource', subtype: 'computational_boundary' },
+    'TimeoutError': { type: 'resource', subtype: 'computational_boundary' },
+    // Logic Hallucinations (detected through execution analysis)
+    'AssertionError': { type: 'logic', subtype: 'logic_deviation' },
+    'SyntaxError': { type: 'logic', subtype: 'logic_breakdown' },
+    'IndentationError': { type: 'logic', subtype: 'logic_breakdown' },
+};
+/**
+ * Default business impact values by hallucination category
+ */
+export const DEFAULT_BUSINESS_IMPACT = {
+    mapping: {
+        estimatedDevTimeWasted: 2.5,
+        costMultiplier: 1.3,
+        qualityImpact: 25,
+        costOfHallucinations: 125.0,
+    },
+    naming: {
+        estimatedDevTimeWasted: 1.8,
+        costMultiplier: 1.2,
+        qualityImpact: 20,
+        costOfHallucinations: 90.0,
+    },
+    resource: {
+        estimatedDevTimeWasted: 4.0,
+        costMultiplier: 1.8,
+        qualityImpact: 40,
+        costOfHallucinations: 200.0,
+    },
+    logic: {
+        estimatedDevTimeWasted: 3.2,
+        costMultiplier: 1.5,
+        qualityImpact: 35,
+        costOfHallucinations: 160.0,
+    },
+};
+/**
+ * Default detection options
+ */
+export const DEFAULT_DETECTION_OPTIONS = {
+    enableExecution: true,
+    executionTimeoutMs: 5000,
+    memoryLimitMB: 128,
+    confidenceThreshold: 0.7,
+    includeLowSeverity: true,
+    focusCategories: ['mapping', 'naming', 'resource', 'logic'],
+    generateRecommendations: true,
+    codeContext: {},
+};

package/lib/types/index.js

@@ -0,0 +1,8 @@
+/**
+ * TokNXR Type Definitions
+ * Centralized exports for all TypeScript types and interfaces
+ */
+// Enhanced Hallucination Detection Types
+export * from './hallucination-types.js';
+// Database Types for Hallucination Analysis
+export * from './database-types.js';

package/lib/ui.js

@@ -96,11 +96,20 @@ export const createFilterInterface = (currentFilters) => {
         resolve(currentFilters);
     });
 };
-export const createSearchInterface = (fields) => {
-    return new Promise(resolve => {
-        console.log('Search interface is not implemented in this mock.');
-        resolve({ query: 'test', fields });
+export const createSearchInterface = async (fields) => {
+    const { selectedFields } = await inquirer.prompt({
+        type: 'checkbox',
+        name: 'selectedFields',
+        message: 'Which fields would you like to search in?',
+        choices: fields.map(field => ({ name: field, value: field, checked: true })),
+        validate: (answer) => {
+            if (!answer || answer.length < 1) {
+                return 'You must choose at least one field.';
+            }
+            return true;
+        }
     });
+    return { query: '', fields: selectedFields };
 };
 export class InteractiveDataExplorer {
     constructor(data) {
@@ -124,6 +133,64 @@ export class CliStateManager {
         return { budgets: {} };
     }
 }
-export const filterAndSearchInteractions = (interactions, _filters, _search) => {
-    return interactions;
+export const filterAndSearchInteractions = (interactions, _filters, search) => {
+    if (!search.query || search.query.trim().length === 0) {
+        return interactions;
+    }
+    const query = search.query.toLowerCase();
+    return interactions.filter(interaction => {
+        return search.fields.some(field => {
+            const value = interaction[field];
+            if (typeof value === 'string') {
+                return value.toLowerCase().includes(query);
+            }
+            return false;
+        });
+    });
+};
+// Helper functions for search results
+export const calcRelevanceScore = (interaction, query, fields) => {
+    const queryLower = query.toLowerCase();
+    let totalScore = 0;
+    let matchingFields = 0;
+    fields.forEach(field => {
+        const value = interaction[field];
+        if (typeof value === 'string') {
+            const valueLower = value.toLowerCase();
+            if (valueLower.includes(queryLower)) {
+                matchingFields++;
+                // Exact match gets highest score
+                if (valueLower === queryLower) {
+                    totalScore += 1.0;
+                }
+                else if (valueLower.startsWith(queryLower)) {
+                    totalScore += 0.8;
+                }
+                else if (valueLower.endsWith(queryLower)) {
+                    totalScore += 0.7;
+                }
+                else {
+                    // Partial match - score based on how much of the string matches
+                    const matchRatio = queryLower.length / valueLower.length;
+                    totalScore += 0.3 + (matchRatio * 0.3);
+                }
+            }
+        }
+    });
+    // Calculate final score
+    if (matchingFields === 0)
+        return 0;
+    const baseScore = totalScore / matchingFields;
+    const multiFieldBonus = matchingFields > 1 ? 0.2 : 0;
+    // Ensure exact matches get high scores
+    const finalScore = Math.min(1.0, baseScore + multiFieldBonus);
+    // Debug: log the score calculation for troubleshooting
+    // console.log(`Debug: query="${query}", baseScore=${baseScore}, finalScore=${finalScore}`);
+    return finalScore;
+};
+export const highlightMatch = (text, query) => {
+    if (!text || !query)
+        return text;
+    const regex = new RegExp(`(${query})`, 'gi');
+    return text.replace(regex, chalk.yellow.bold('$1'));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goldensheepai/toknxr-cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "CLI-powered AI effectiveness & code quality analysis tool - 100% Local",
   "license": "MIT",
   "type": "module",