bluera-knowledge 0.9.26 → 0.9.30

package/src/services/search.service.ts

@@ -6,13 +6,24 @@ import { CodeUnitService } from './code-unit.service.js';
 import type { CodeUnit } from '../types/search.js';
 import type { CodeGraphService } from './code-graph.service.js';
 import type { CodeGraph } from '../analysis/code-graph.js';
+import { createLogger } from '../logging/index.js';
+
+const logger = createLogger('search-service');
 
 /**
  * Query intent classification for context-aware ranking.
- * Phase 1: Different intents prioritize different content types.
+ * Different intents prioritize different content types.
  */
 export type QueryIntent = 'how-to' | 'implementation' | 'conceptual' | 'comparison' | 'debugging';
 
+/**
+ * Classified intent with confidence score for multi-intent queries.
+ */
+export interface ClassifiedIntent {
+  intent: QueryIntent;
+  confidence: number;
+}
+
 /**
  * Intent-based file type multipliers - CONSERVATIVE version.
  * Applied on top of base file-type boosts.
@@ -84,101 +95,120 @@ const FRAMEWORK_PATTERNS: Array<{ pattern: RegExp; terms: string[] }> = [
   { pattern: /\bjwt\b/i, terms: ['jwt', 'jsonwebtoken', 'json-web-token'] },
 ];
 
+// Pattern definitions for intent classification
+const HOW_TO_PATTERNS = [
+  /how (do|can|should|would) (i|you|we)/i,
+  /how to\b/i,
+  /what('s| is) the (best |right |correct )?(way|approach) to/i,
+  /i (need|want|have) to/i,
+  /show me how/i,
+  /\bwhat's the syntax\b/i,
+  /\bhow do i (use|create|make|set up|configure|implement|add|get)\b/i,
+  /\bi'm (trying|building|creating|making)\b/i,
+];
+
+const IMPLEMENTATION_PATTERNS = [
+  /how (does|is) .* (implemented|work internally)/i,
+  /\binternal(ly)?\b/i,
+  /\bsource code\b/i,
+  /\bunder the hood\b/i,
+  /\bimplementation (of|details?)\b/i,
+];
+
+const COMPARISON_PATTERNS = [
+  /\b(vs\.?|versus)\b/i,
+  /\bdifference(s)? between\b/i,
+  /\bcompare\b/i,
+  /\bshould (i|we) use .* or\b/i,
+  /\bwhat's the difference\b/i,
+  /\bwhich (one|is better)\b/i,
+  /\bwhen (should|to) use\b/i,
+];
+
+const DEBUGGING_PATTERNS = [
+  /\b(error|bug|issue|problem|crash|fail|broken|wrong)\b/i,
+  /\bdoesn't (work|compile|run)\b/i,
+  /\bisn't (working|updating|rendering)\b/i,
+  /\bwhy (is|does|doesn't|isn't)\b/i,
+  /\bwhat('s| is) (wrong|happening|going on)\b/i,
+  /\bwhat am i doing wrong\b/i,
+  /\bnot (working|updating|showing)\b/i,
+  /\bhow do i (fix|debug|solve|resolve)\b/i,
+];
+
+const CONCEPTUAL_PATTERNS = [
+  /\bwhat (is|are)\b/i,
+  /\bexplain\b/i,
+  /\bwhat does .* (mean|do)\b/i,
+  /\bhow does .* work\b/i,
+  /\bwhat('s| is) the (purpose|point|idea)\b/i,
+];
+
 /**
- * Classify the intent of a search query.
- * This helps adjust ranking based on what kind of answer the user wants.
+ * Classify query intents with confidence scores.
+ * Returns all matching intents, allowing queries to have multiple intents.
  */
-function classifyQueryIntent(query: string): QueryIntent {
+function classifyQueryIntents(query: string): ClassifiedIntent[] {
   const q = query.toLowerCase();
+  const intents: ClassifiedIntent[] = [];
+
+  // Check all pattern groups and add matching intents with confidence
+  if (IMPLEMENTATION_PATTERNS.some(p => p.test(q))) {
+    intents.push({ intent: 'implementation', confidence: 0.9 });
+  }
+
+  if (DEBUGGING_PATTERNS.some(p => p.test(q))) {
+    intents.push({ intent: 'debugging', confidence: 0.85 });
+  }
 
-  // How-to patterns: user wants to learn how to use/do something
-  const howToPatterns = [
-    /how (do|can|should|would) (i|you|we)/i,
-    /how to\b/i,
-    /what('s| is) the (best |right |correct )?(way|approach) to/i,
-    /i (need|want|have) to/i,
-    /show me how/i,
-    /\bwhat's the syntax\b/i,
-    /\bhow do i (use|create|make|set up|configure|implement|add|get)\b/i,
-    /\bi'm (trying|building|creating|making)\b/i,
-  ];
-
-  // Implementation patterns: user wants to understand internals
-  const implementationPatterns = [
-    /how (does|is) .* (implemented|work internally)/i,
-    /\binternal(ly)?\b/i,
-    /\bsource code\b/i,
-    /\bunder the hood\b/i,
-    /\bimplementation (of|details?)\b/i,
-  ];
-
-  // Comparison patterns: user is deciding between options
-  const comparisonPatterns = [
-    /\b(vs\.?|versus)\b/i,
-    /\bdifference(s)? between\b/i,
-    /\bcompare\b/i,
-    /\bshould (i|we) use .* or\b/i,
-    /\bwhat's the difference\b/i,
-    /\bwhich (one|is better)\b/i,
-    /\bwhen (should|to) use\b/i,
-  ];
-
-  // Debugging patterns: user is troubleshooting a problem
-  const debuggingPatterns = [
-    /\b(error|bug|issue|problem|crash|fail|broken|wrong)\b/i,
-    /\bdoesn't (work|compile|run)\b/i,
-    /\bisn't (working|updating|rendering)\b/i,
-    /\bwhy (is|does|doesn't|isn't)\b/i,
-    /\bwhat('s| is) (wrong|happening|going on)\b/i,
-    /\bwhat am i doing wrong\b/i,
-    /\bnot (working|updating|showing)\b/i,
-    /\bhow do i (fix|debug|solve|resolve)\b/i,
-  ];
-
-  // Conceptual patterns: user wants to understand a concept
-  const conceptualPatterns = [
-    /\bwhat (is|are)\b/i,
-    /\bexplain\b/i,
-    /\bwhat does .* (mean|do)\b/i,
-    /\bhow does .* work\b/i,
-    /\bwhat('s| is) the (purpose|point|idea)\b/i,
-  ];
-
-  // Check patterns in order of specificity
-  if (implementationPatterns.some(p => p.test(q))) {
-    return 'implementation';
-  }
-
-  if (debuggingPatterns.some(p => p.test(q))) {
-    return 'debugging';
-  }
-
-  if (comparisonPatterns.some(p => p.test(q))) {
-    return 'comparison';
-  }
-
-  if (howToPatterns.some(p => p.test(q))) {
-    return 'how-to';
-  }
-
-  if (conceptualPatterns.some(p => p.test(q))) {
-    return 'conceptual';
-  }
-
-  // Default to how-to as most queries are seeking practical usage
-  return 'how-to';
+  if (COMPARISON_PATTERNS.some(p => p.test(q))) {
+    intents.push({ intent: 'comparison', confidence: 0.8 });
+  }
+
+  if (HOW_TO_PATTERNS.some(p => p.test(q))) {
+    intents.push({ intent: 'how-to', confidence: 0.75 });
+  }
+
+  if (CONCEPTUAL_PATTERNS.some(p => p.test(q))) {
+    intents.push({ intent: 'conceptual', confidence: 0.7 });
+  }
+
+  // If no patterns match, use how-to as the baseline intent
+  if (intents.length === 0) {
+    intents.push({ intent: 'how-to', confidence: 0.5 });
+  }
+
+  // Sort by confidence descending
+  return intents.sort((a, b) => b.confidence - a.confidence);
+}
+
+/**
+ * Get primary intent for logging/display purposes.
+ */
+function getPrimaryIntent(intents: ClassifiedIntent[]): QueryIntent {
+  return intents[0]?.intent ?? 'how-to';
 }
 
-interface RRFConfig {
-  k: number;
-  vectorWeight: number;
-  ftsWeight: number;
+/**
+ * RRF presets for different content types.
+ * Web/docs content uses higher k to reduce noise from repetitive structure.
+ */
+const RRF_PRESETS = {
+  code: { k: 20, vectorWeight: 0.6, ftsWeight: 0.4 },
+  web: { k: 30, vectorWeight: 0.55, ftsWeight: 0.45 },
+} as const;
+
+/**
+ * Detect if results are primarily web content (have urls vs file paths).
+ */
+function detectContentType(results: SearchResult[]): 'web' | 'code' {
+  const webCount = results.filter(r => 'url' in r.metadata).length;
+  return webCount > results.length / 2 ? 'web' : 'code';
 }
 
 export class SearchService {
   private readonly lanceStore: LanceStore;
   private readonly embeddingEngine: EmbeddingEngine;
-  private readonly rrfConfig: RRFConfig;
   private readonly codeUnitService: CodeUnitService;
   private readonly codeGraphService: CodeGraphService | undefined;
   private readonly graphCache: Map<string, CodeGraph | null>;
@@ -186,13 +216,10 @@ export class SearchService {
   constructor(
     lanceStore: LanceStore,
     embeddingEngine: EmbeddingEngine,
-    // Lower k value (20 vs 60) produces more differentiated scores for top results
-    rrfConfig: RRFConfig = { k: 20, vectorWeight: 0.6, ftsWeight: 0.4 },
     codeGraphService?: CodeGraphService
   ) {
     this.lanceStore = lanceStore;
     this.embeddingEngine = embeddingEngine;
-    this.rrfConfig = rrfConfig;
     this.codeUnitService = new CodeUnitService();
     this.codeGraphService = codeGraphService;
     this.graphCache = new Map();
@@ -220,6 +247,18 @@ export class SearchService {
     const limit = query.limit ?? 10;
     const stores = query.stores ?? [];
     const detail = query.detail ?? 'minimal';
+    const intents = classifyQueryIntents(query.query);
+    const primaryIntent = getPrimaryIntent(intents);
+
+    logger.debug({
+      query: query.query,
+      mode,
+      limit,
+      stores,
+      detail,
+      intent: primaryIntent,
+      intents,
+    }, 'Search query received');
 
     let allResults: SearchResult[] = [];
 
@@ -254,13 +293,24 @@ export class SearchService {
       return this.addProgressiveContext(r, query.query, detail, graph);
     });
 
+    const timeMs = Date.now() - startTime;
+
+    logger.info({
+      query: query.query,
+      mode,
+      resultCount: enhancedResults.length,
+      dedupedFrom: allResults.length,
+      intents: intents.map(i => `${i.intent}(${i.confidence.toFixed(2)})`),
+      timeMs,
+    }, 'Search complete');
+
     return {
       query: query.query,
       mode,
       stores,
       results: enhancedResults,
       totalResults: enhancedResults.length,
-      timeMs: Date.now() - startTime,
+      timeMs,
     };
   }
 
@@ -273,20 +323,22 @@ export class SearchService {
     const queryTerms = query.toLowerCase().split(/\s+/).filter(t => t.length > 2);
 
     for (const result of results) {
-      // Use file path as the source key, fallback to document ID
+      // Use file path as the source key (or url for web content, or id as last resort)
       const sourceKey = result.metadata.path ?? result.metadata.url ?? result.id;
 
       const existing = bySource.get(sourceKey);
       if (!existing) {
         bySource.set(sourceKey, result);
       } else {
-        // Compare: prefer chunk with more query terms in content
+        // Score-weighted relevance: accounts for fileType/framework boosts
         const existingTermCount = this.countQueryTerms(existing.content, queryTerms);
         const newTermCount = this.countQueryTerms(result.content, queryTerms);
 
-        // Prefer chunk with more query terms, or higher score if same
-        if (newTermCount > existingTermCount ||
-            (newTermCount === existingTermCount && result.score > existing.score)) {
+        // Weight term count by score to account for ranking boosts
+        const existingRelevance = existingTermCount * existing.score;
+        const newRelevance = newTermCount * result.score;
+
+        if (newRelevance > existingRelevance) {
           bySource.set(sourceKey, result);
         }
       }
@@ -352,8 +404,8 @@ export class SearchService {
     limit: number,
     threshold?: number
   ): Promise<SearchResult[]> {
-    // Phase 1: Classify query intent for context-aware ranking
-    const intent = classifyQueryIntent(query);
+    // Classify query intents for context-aware ranking (supports multiple intents)
+    const intents = classifyQueryIntents(query);
 
     // Get both result sets
     const [vectorResults, ftsResults] = await Promise.all([
@@ -390,9 +442,14 @@ export class SearchService {
         ftsRRF: number;
         fileTypeBoost: number;
         frameworkBoost: number;
+        urlKeywordBoost: number;
+        pathKeywordBoost: number;
       };
     }> = [];
-    const { k, vectorWeight, ftsWeight } = this.rrfConfig;
+
+    // Select RRF config based on content type (web vs code)
+    const contentType = detectContentType([...allDocs.values()]);
+    const { k, vectorWeight, ftsWeight } = RRF_PRESETS[contentType];
 
     for (const [id, result] of allDocs) {
       const vectorRank = vectorRanks.get(id) ?? Infinity;
@@ -401,16 +458,22 @@ export class SearchService {
       const vectorRRF = vectorRank !== Infinity ? vectorWeight / (k + vectorRank) : 0;
       const ftsRRF = ftsRank !== Infinity ? ftsWeight / (k + ftsRank) : 0;
 
-      // Apply file-type boost (base + intent-adjusted)
+      // Apply file-type boost (base + multi-intent-adjusted)
       const fileTypeBoost = this.getFileTypeBoost(
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         result.metadata['fileType'] as string | undefined,
-        intent
+        intents
       );
 
       // Apply framework context boost
       const frameworkBoost = this.getFrameworkContextBoost(query, result);
 
+      // Apply URL keyword boost (helps "troubleshooting" find /troubleshooting pages)
+      const urlKeywordBoost = this.getUrlKeywordBoost(query, result);
+
+      // Apply path keyword boost (helps "dispatcher" find async_dispatcher.py)
+      const pathKeywordBoost = this.getPathKeywordBoost(query, result);
+
       const metadata: {
         vectorRank?: number;
         ftsRank?: number;
@@ -418,11 +481,15 @@ export class SearchService {
         ftsRRF: number;
         fileTypeBoost: number;
         frameworkBoost: number;
+        urlKeywordBoost: number;
+        pathKeywordBoost: number;
       } = {
         vectorRRF,
         ftsRRF,
         fileTypeBoost,
         frameworkBoost,
+        urlKeywordBoost,
+        pathKeywordBoost,
       };
 
       if (vectorRank !== Infinity) {
@@ -434,7 +501,7 @@ export class SearchService {
 
       rrfScores.push({
         id,
-        score: (vectorRRF + ftsRRF) * fileTypeBoost * frameworkBoost,
+        score: (vectorRRF + ftsRRF) * fileTypeBoost * frameworkBoost * urlKeywordBoost * pathKeywordBoost,
         result,
         metadata,
       });
@@ -490,7 +557,7 @@ export class SearchService {
    * Phase 4: Strengthened boosts for better documentation ranking.
    * Phase 1: Intent-based adjustments for context-aware ranking.
    */
-  private getFileTypeBoost(fileType: string | undefined, intent: QueryIntent): number {
+  private getFileTypeBoost(fileType: string | undefined, intents: ClassifiedIntent[]): number {
     // Base file-type boosts
     let baseBoost: number;
     switch (fileType) {
@@ -519,11 +586,96 @@ export class SearchService {
         baseBoost = 1.0;
     }
 
-    // Apply intent-based multiplier
-    const intentBoosts = INTENT_FILE_BOOSTS[intent];
-    const intentMultiplier = intentBoosts[fileType ?? 'other'] ?? 1.0;
+    // Blend intent-based multipliers weighted by confidence
+    let weightedMultiplier = 0;
+    let totalConfidence = 0;
+
+    for (const { intent, confidence } of intents) {
+      const intentBoosts = INTENT_FILE_BOOSTS[intent];
+      const multiplier = intentBoosts[fileType ?? 'other'] ?? 1.0;
+      weightedMultiplier += multiplier * confidence;
+      totalConfidence += confidence;
+    }
+
+    const blendedMultiplier = totalConfidence > 0
+      ? weightedMultiplier / totalConfidence
+      : 1.0;
+
+    return baseBoost * blendedMultiplier;
+  }
+
+  /**
+   * Get a score multiplier based on URL keyword matching.
+   * Boosts results where URL path contains significant query keywords.
+   * This helps queries like "troubleshooting" rank /troubleshooting pages first.
+   */
+  private getUrlKeywordBoost(query: string, result: SearchResult): number {
+    const url = result.metadata.url;
+    if (url === undefined || url === '') return 1.0;
+
+    // Extract path segments from URL and normalize
+    const urlPath = url.toLowerCase().replace(/[^a-z0-9]+/g, ' ');
+
+    // Common stop words to filter from queries
+    const stopWords = new Set([
+      'how', 'to', 'the', 'a', 'an', 'is', 'are', 'what', 'why', 'when',
+      'where', 'can', 'do', 'does', 'i', 'my', 'your', 'it', 'in', 'on',
+      'for', 'with', 'this', 'that', 'get', 'use', 'using'
+    ]);
+
+    // Extract meaningful query terms
+    const queryTerms = query.toLowerCase()
+      .split(/\s+/)
+      .filter(t => t.length > 2 && !stopWords.has(t));
+
+    if (queryTerms.length === 0) return 1.0;
+
+    // Count matching terms in URL path
+    const matchingTerms = queryTerms.filter(term => urlPath.includes(term));
+
+    if (matchingTerms.length === 0) return 1.0;
+
+    // Boost based on proportion of matching terms
+    // Single match: ~1.5, all terms match: ~2.0
+    const matchRatio = matchingTerms.length / queryTerms.length;
+    return 1.0 + (1.0 * matchRatio);
+  }
+
+  /**
+   * Get a score multiplier based on file path keyword matching.
+   * Boosts results where file path contains significant query keywords.
+   * This helps queries like "dispatcher" rank async_dispatcher.py higher.
+   */
+  private getPathKeywordBoost(query: string, result: SearchResult): number {
+    const path = result.metadata.path;
+    if (path === undefined || path === '') return 1.0;
+
+    // Extract path segments and normalize (split on slashes, dots, underscores, etc.)
+    const pathSegments = path.toLowerCase().replace(/[^a-z0-9]+/g, ' ');
+
+    // Common stop words to filter from queries
+    const stopWords = new Set([
+      'how', 'to', 'the', 'a', 'an', 'is', 'are', 'what', 'why', 'when',
+      'where', 'can', 'do', 'does', 'i', 'my', 'your', 'it', 'in', 'on',
+      'for', 'with', 'this', 'that', 'get', 'use', 'using'
+    ]);
+
+    // Extract meaningful query terms
+    const queryTerms = query.toLowerCase()
+      .split(/\s+/)
+      .filter(t => t.length > 2 && !stopWords.has(t));
+
+    if (queryTerms.length === 0) return 1.0;
+
+    // Count matching terms in file path
+    const matchingTerms = queryTerms.filter(term => pathSegments.includes(term));
+
+    if (matchingTerms.length === 0) return 1.0;
 
-    return baseBoost * intentMultiplier;
+    // Boost based on proportion of matching terms
+    // Single match: ~1.5, all terms match: ~2.0
+    const matchRatio = matchingTerms.length / queryTerms.length;
+    return 1.0 + (1.0 * matchRatio);
   }
 
   /**

package/src/services/snippet.service.ts

@@ -54,6 +54,11 @@ export function extractSnippet(
 
 /**
  * Find the position in content where the most query terms cluster together.
+ * Uses multi-factor scoring:
+ * - Query term density (base score)
+ * - Sentence completeness bonus
+ * - Code example presence bonus
+ * - Section header proximity bonus
  */
 function findBestMatchPosition(content: string, queryTerms: string[]): number {
   const lowerContent = content.toLowerCase();
@@ -73,7 +78,6 @@ function findBestMatchPosition(content: string, queryTerms: string[]): number {
     return -1;
   }
 
-  // Score each position by how many other terms are nearby (within 200 chars)
   const PROXIMITY_WINDOW = 200;
   const firstTerm = termPositions[0];
   if (firstTerm === undefined) {
@@ -83,15 +87,36 @@ function findBestMatchPosition(content: string, queryTerms: string[]): number {
   let bestScore = 0;
 
   for (const { position } of termPositions) {
-    // Count unique terms within proximity window
+    // Base score: count unique terms within proximity window
     const nearbyTerms = new Set<string>();
     for (const { term, position: otherPos } of termPositions) {
       if (Math.abs(position - otherPos) <= PROXIMITY_WINDOW) {
         nearbyTerms.add(term);
       }
     }
+    let score = nearbyTerms.size * 10; // Base: 10 points per unique term
+
+    // Extract window around position for bonus scoring
+    const windowStart = Math.max(0, position - PROXIMITY_WINDOW / 2);
+    const windowEnd = Math.min(content.length, position + PROXIMITY_WINDOW / 2);
+    const window = content.slice(windowStart, windowEnd);
+
+    // Bonus: Sentence completeness (contains sentence-ending punctuation)
+    if (/[.!?]/.test(window)) {
+      score += 5;
+    }
+
+    // Bonus: Code example presence (backticks, brackets, common code patterns)
+    if (/[`{}()[\]]|=>|function|const |let |var /.test(window)) {
+      score += 3;
+    }
+
+    // Bonus: Near markdown section header
+    const headerMatch = content.slice(Math.max(0, position - 100), position).match(/^#{1,3}\s+.+$/m);
+    if (headerMatch) {
+      score += 4;
+    }
 
-    const score = nearbyTerms.size;
     if (score > bestScore) {
       bestScore = score;
       bestPosition = position;

package/src/services/token.service.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { estimateTokens, formatTokenCount } from './token.service.js';
+
+describe('token.service', () => {
+  describe('estimateTokens', () => {
+    it('returns 0 for empty string', () => {
+      expect(estimateTokens('')).toBe(0);
+    });
+
+    it('estimates tokens for short text', () => {
+      // "hello" = 5 chars, 5/3.5 = 1.43, ceil = 2
+      expect(estimateTokens('hello')).toBe(2);
+    });
+
+    it('estimates tokens for longer text', () => {
+      // 35 chars / 3.5 = 10 tokens
+      const text = 'a'.repeat(35);
+      expect(estimateTokens(text)).toBe(10);
+    });
+
+    it('rounds up token count', () => {
+      // 7 chars / 3.5 = 2 tokens exactly
+      expect(estimateTokens('abcdefg')).toBe(2);
+      // 8 chars / 3.5 = 2.29, ceil = 3
+      expect(estimateTokens('abcdefgh')).toBe(3);
+    });
+  });
+
+  describe('formatTokenCount', () => {
+    it('formats small counts without suffix', () => {
+      expect(formatTokenCount(100)).toBe('~100');
+      expect(formatTokenCount(999)).toBe('~999');
+    });
+
+    it('formats counts >= 1000 with k suffix', () => {
+      expect(formatTokenCount(1000)).toBe('~1.0k');
+      expect(formatTokenCount(1500)).toBe('~1.5k');
+      expect(formatTokenCount(10000)).toBe('~10.0k');
+    });
+
+    it('formats zero', () => {
+      expect(formatTokenCount(0)).toBe('~0');
+    });
+  });
+});

package/src/services/token.service.ts

@@ -0,0 +1,33 @@
+/**
+ * Token estimation service using Anthropic's recommended heuristic.
+ * For Claude 3+ models, Anthropic recommends ~3.5 characters per token
+ * for English text. This varies by language.
+ *
+ * Note: The official @anthropic-ai/tokenizer package only works for
+ * pre-Claude 3 models. For accurate counts on Claude 3+, use the
+ * Token Count API. This heuristic is suitable for display purposes.
+ */
+
+const CHARS_PER_TOKEN = 3.5;
+
+/**
+ * Estimate token count for a string using character-based heuristic.
+ * @param text - The text to estimate tokens for
+ * @returns Estimated token count (rounded up)
+ */
+export function estimateTokens(text: string): number {
+  if (!text) return 0;
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+
+/**
+ * Format token count for display with appropriate suffix.
+ * @param tokens - Token count
+ * @returns Formatted string like "~1.2k" or "~847"
+ */
+export function formatTokenCount(tokens: number): string {
+  if (tokens >= 1000) {
+    return `~${(tokens / 1000).toFixed(1)}k`;
+  }
+  return `~${String(tokens)}`;
+}

package/src/types/result.test.ts

@@ -28,6 +28,16 @@ describe('Result type', () => {
       const result = err(new Error('failed'));
       expect(() => unwrap(result)).toThrow('failed');
     });
+
+    it('throws wrapped error for non-Error error value', () => {
+      const result = err('string error message');
+      expect(() => unwrap(result)).toThrow('string error message');
+    });
+
+    it('converts non-string error to string', () => {
+      const result = err(404);
+      expect(() => unwrap(result)).toThrow('404');
+    });
   });
 
   describe('unwrapOr', () => {

package/tests/integration/cli-consistency.test.ts

@@ -231,10 +231,7 @@ describe('CLI Consistency', () => {
       expect(result.stderr).toMatch(/^Error: Store not found: nonexistent/m);
     });
 
-    it('uses consistent "Error:" prefix for crawl store not found', () => {
-      const result = runCli('crawl https://example.com nonexistent');
-      expect(result.stderr).toMatch(/^Error: /m);
-    });
+    // Note: crawl auto-creates stores when not found, so no error test needed
   });
 
   describe('store delete Confirmation', () => {