bluera-knowledge 0.9.26 → 0.9.31

package/dist/{chunk-5QMHZUC4.js → chunk-RWSXP3PQ.js}

@@ -1,3 +1,142 @@
+// src/logging/logger.ts
+import pino from "pino";
+import { homedir } from "os";
+import { mkdirSync, existsSync } from "fs";
+import { join } from "path";
+var VALID_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal"];
+var VALID_LEVELS_SET = new Set(VALID_LEVELS);
+function getLogDir() {
+  return join(homedir(), ".bluera", "bluera-knowledge", "logs");
+}
+function ensureLogDir() {
+  const logDir = getLogDir();
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+  return logDir;
+}
+function isValidLogLevel(level) {
+  return VALID_LEVELS_SET.has(level);
+}
+function getLogLevel() {
+  const level = process.env["LOG_LEVEL"]?.toLowerCase();
+  if (level === void 0 || level === "") {
+    return "info";
+  }
+  if (!isValidLogLevel(level)) {
+    throw new Error(
+      `Invalid LOG_LEVEL: "${level}". Valid values: ${VALID_LEVELS.join(", ")}`
+    );
+  }
+  return level;
+}
+var rootLogger = null;
+function initializeLogger() {
+  if (rootLogger !== null) {
+    return rootLogger;
+  }
+  const logDir = ensureLogDir();
+  const logFile = join(logDir, "app.log");
+  const level = getLogLevel();
+  const options = {
+    level,
+    timestamp: pino.stdTimeFunctions.isoTime,
+    formatters: {
+      level: (label) => ({ level: label })
+    },
+    transport: {
+      target: "pino-roll",
+      options: {
+        file: logFile,
+        size: "10m",
+        // 10MB rotation
+        limit: { count: 5 },
+        // Keep 5 rotated files
+        mkdir: true
+      }
+    }
+  };
+  rootLogger = pino(options);
+  return rootLogger;
+}
+function createLogger(module) {
+  const root = initializeLogger();
+  return root.child({ module });
+}
+function isLevelEnabled(level) {
+  const currentLevel = getLogLevel();
+  const currentIndex = VALID_LEVELS.indexOf(currentLevel);
+  const checkIndex = VALID_LEVELS.indexOf(level);
+  return checkIndex >= currentIndex;
+}
+function getLogDirectory() {
+  return getLogDir();
+}
+function shutdownLogger() {
+  return new Promise((resolve3) => {
+    if (rootLogger !== null) {
+      rootLogger.flush();
+      setTimeout(() => {
+        rootLogger = null;
+        resolve3();
+      }, 100);
+    } else {
+      resolve3();
+    }
+  });
+}
+
+// src/logging/payload.ts
+import { writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { createHash } from "crypto";
+var MAX_PREVIEW_LENGTH = 500;
+var PAYLOAD_DUMP_THRESHOLD = 1e4;
+function getPayloadDir() {
+  const dir = join2(getLogDirectory(), "payload");
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  return dir;
+}
+function safeFilename(identifier) {
+  return identifier.replace(/[^a-zA-Z0-9-]/g, "_").substring(0, 50);
+}
+function summarizePayload(content, type, identifier, dumpFull = isLevelEnabled("trace")) {
+  const sizeBytes = Buffer.byteLength(content, "utf8");
+  const hash = createHash("md5").update(content).digest("hex").substring(0, 12);
+  const preview = truncateForLog(content, MAX_PREVIEW_LENGTH);
+  const baseSummary = { preview, sizeBytes, hash };
+  if (dumpFull && sizeBytes > PAYLOAD_DUMP_THRESHOLD) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const safeId = safeFilename(identifier);
+    const filename = `${timestamp}-${type}-${safeId}-${hash}.json`;
+    const filepath = join2(getPayloadDir(), filename);
+    writeFileSync(
+      filepath,
+      JSON.stringify(
+        {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type,
+          identifier,
+          sizeBytes,
+          content
+        },
+        null,
+        2
+      )
+    );
+    return { ...baseSummary, payloadFile: filename };
+  }
+  return baseSummary;
+}
+function truncateForLog(content, maxLength = MAX_PREVIEW_LENGTH) {
+  if (content.length <= maxLength) {
+    return content;
+  }
+  return content.substring(0, maxLength) + "... [truncated]";
+}
+
 // src/services/job.service.ts
 import fs from "fs";
 import path from "path";
@@ -200,7 +339,7 @@ var JobService = class {
 // src/services/config.service.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { dirname as dirname2, resolve } from "path";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 
 // src/types/config.ts
 var DEFAULT_CONFIG = {
@@ -239,8 +378,8 @@ var DEFAULT_CONFIG = {
 };
 
 // src/services/project-root.service.ts
-import { existsSync, statSync, realpathSync } from "fs";
-import { dirname, join, normalize, sep } from "path";
+import { existsSync as existsSync3, statSync, realpathSync } from "fs";
+import { dirname, join as join3, normalize, sep } from "path";
 var ProjectRootService = class {
   /**
    * Resolve project root directory using hierarchical detection.
@@ -270,8 +409,8 @@ var ProjectRootService = class {
     let currentPath = normalize(startPath);
     const root = normalize(sep);
     while (currentPath !== root) {
-      const gitPath = join(currentPath, ".git");
-      if (existsSync(gitPath)) {
+      const gitPath = join3(currentPath, ".git");
+      if (existsSync3(gitPath)) {
         try {
           const stats = statSync(gitPath);
           if (stats.isDirectory() || stats.isFile()) {
@@ -317,7 +456,7 @@ var ConfigService = class {
   configPath;
   dataDir;
   config = null;
-  constructor(configPath = `${homedir()}/.bluera/bluera-knowledge/config.json`, dataDir, projectRoot) {
+  constructor(configPath = `${homedir2()}/.bluera/bluera-knowledge/config.json`, dataDir, projectRoot) {
     this.configPath = configPath;
     if (dataDir !== void 0 && dataDir !== "") {
       this.dataDir = dataDir;
@@ -348,7 +487,7 @@ var ConfigService = class {
   }
   expandPath(path3, baseDir) {
     if (path3.startsWith("~")) {
-      return path3.replace("~", homedir());
+      return path3.replace("~", homedir2());
     }
     if (!path3.startsWith("/")) {
       return resolve(baseDir, path3);
@@ -359,7 +498,7 @@ var ConfigService = class {
 
 // src/services/store.service.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir3, stat } from "fs/promises";
-import { join as join2, resolve as resolve2 } from "path";
+import { join as join4, resolve as resolve2 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/types/brands.ts
@@ -430,6 +569,9 @@ var StoreService = class {
     await this.loadRegistry();
   }
   async create(input) {
+    if (!input.name || input.name.trim() === "") {
+      return err(new Error("Store name cannot be empty"));
+    }
     const existing = await this.getByName(input.name);
     if (existing !== void 0) {
       return err(new Error(`Store with name "${input.name}" already exists`));
@@ -467,7 +609,7 @@ var StoreService = class {
       case "repo": {
         let repoPath = input.path;
         if (input.url !== void 0) {
-          const cloneDir = join2(this.dataDir, "repos", id);
+          const cloneDir = join4(this.dataDir, "repos", id);
           const result = await cloneRepository({
             url: input.url,
             targetDir: cloneDir,
@@ -563,7 +705,7 @@ var StoreService = class {
     return ok(void 0);
   }
   async loadRegistry() {
-    const registryPath = join2(this.dataDir, "stores.json");
+    const registryPath = join4(this.dataDir, "stores.json");
     try {
       const content = await readFile2(registryPath, "utf-8");
       const data = JSON.parse(content);
@@ -580,7 +722,7 @@ var StoreService = class {
     }
   }
   async saveRegistry() {
-    const registryPath = join2(this.dataDir, "stores.json");
+    const registryPath = join4(this.dataDir, "stores.json");
     await writeFile2(registryPath, JSON.stringify(this.registry, null, 2));
   }
 };
@@ -659,6 +801,7 @@ var CodeUnitService = class {
 };
 
 // src/services/search.service.ts
+var logger = createLogger("search-service");
 var INTENT_FILE_BOOSTS = {
   "how-to": {
     "documentation-primary": 1.3,
@@ -729,79 +872,92 @@ var FRAMEWORK_PATTERNS = [
   { pattern: /\btypescript\b/i, terms: ["typescript", "ts"] },
   { pattern: /\bjwt\b/i, terms: ["jwt", "jsonwebtoken", "json-web-token"] }
 ];
-function classifyQueryIntent(query) {
+var 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
+];
+var 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
+];
+var 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
+];
+var 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
+];
+var 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
+];
+function classifyQueryIntents(query) {
   const q = query.toLowerCase();
-  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
-  ];
-  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
-  ];
-  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
-  ];
-  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
-  ];
-  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
-  ];
-  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";
-  }
-  return "how-to";
+  const intents = [];
+  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 });
+  }
+  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 (intents.length === 0) {
+    intents.push({ intent: "how-to", confidence: 0.5 });
+  }
+  return intents.sort((a, b) => b.confidence - a.confidence);
+}
+function getPrimaryIntent(intents) {
+  return intents[0]?.intent ?? "how-to";
+}
+var RRF_PRESETS = {
+  code: { k: 20, vectorWeight: 0.6, ftsWeight: 0.4 },
+  web: { k: 30, vectorWeight: 0.55, ftsWeight: 0.45 }
+};
+function detectContentType(results) {
+  const webCount = results.filter((r) => "url" in r.metadata).length;
+  return webCount > results.length / 2 ? "web" : "code";
 }
 var SearchService = class {
   lanceStore;
   embeddingEngine;
-  rrfConfig;
   codeUnitService;
   codeGraphService;
   graphCache;
-  constructor(lanceStore, embeddingEngine, rrfConfig = { k: 20, vectorWeight: 0.6, ftsWeight: 0.4 }, codeGraphService) {
+  constructor(lanceStore, embeddingEngine, codeGraphService) {
     this.lanceStore = lanceStore;
     this.embeddingEngine = embeddingEngine;
-    this.rrfConfig = rrfConfig;
     this.codeUnitService = new CodeUnitService();
     this.codeGraphService = codeGraphService;
     this.graphCache = /* @__PURE__ */ new Map();
@@ -825,6 +981,17 @@ var SearchService = class {
     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 = [];
     const fetchLimit = limit * 3;
     if (mode === "vector") {
@@ -847,13 +1014,22 @@ var SearchService = class {
       const graph = graphs.get(r.metadata.storeId) ?? null;
       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
     };
   }
   /**
@@ -871,7 +1047,9 @@ var SearchService = class {
       } else {
         const existingTermCount = this.countQueryTerms(existing.content, queryTerms);
         const newTermCount = this.countQueryTerms(result.content, queryTerms);
-        if (newTermCount > existingTermCount || newTermCount === existingTermCount && result.score > existing.score) {
+        const existingRelevance = existingTermCount * existing.score;
+        const newRelevance = newTermCount * result.score;
+        if (newRelevance > existingRelevance) {
           bySource.set(sourceKey, result);
         }
       }
@@ -913,7 +1091,7 @@ var SearchService = class {
     return results.sort((a, b) => b.score - a.score).slice(0, limit);
   }
   async hybridSearch(query, stores, limit, threshold) {
-    const intent = classifyQueryIntent(query);
+    const intents = classifyQueryIntents(query);
     const [vectorResults, ftsResults] = await Promise.all([
       this.vectorSearch(query, stores, limit * 2, threshold),
       this.ftsSearch(query, stores, limit * 2)
@@ -932,7 +1110,8 @@ var SearchService = class {
       }
     });
     const rrfScores = [];
-    const { k, vectorWeight, ftsWeight } = this.rrfConfig;
+    const contentType = detectContentType([...allDocs.values()]);
+    const { k, vectorWeight, ftsWeight } = RRF_PRESETS[contentType];
     for (const [id, result] of allDocs) {
       const vectorRank = vectorRanks.get(id) ?? Infinity;
       const ftsRank = ftsRanks.get(id) ?? Infinity;
@@ -941,14 +1120,18 @@ var SearchService = class {
       const fileTypeBoost = this.getFileTypeBoost(
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         result.metadata["fileType"],
-        intent
+        intents
       );
       const frameworkBoost = this.getFrameworkContextBoost(query, result);
+      const urlKeywordBoost = this.getUrlKeywordBoost(query, result);
+      const pathKeywordBoost = this.getPathKeywordBoost(query, result);
       const metadata = {
         vectorRRF,
         ftsRRF,
         fileTypeBoost,
-        frameworkBoost
+        frameworkBoost,
+        urlKeywordBoost,
+        pathKeywordBoost
       };
       if (vectorRank !== Infinity) {
         metadata.vectorRank = vectorRank;
@@ -958,7 +1141,7 @@ var SearchService = class {
       }
       rrfScores.push({
         id,
-        score: (vectorRRF + ftsRRF) * fileTypeBoost * frameworkBoost,
+        score: (vectorRRF + ftsRRF) * fileTypeBoost * frameworkBoost * urlKeywordBoost * pathKeywordBoost,
         result,
         metadata
       });
@@ -1003,7 +1186,7 @@ var SearchService = class {
    * Phase 4: Strengthened boosts for better documentation ranking.
    * Phase 1: Intent-based adjustments for context-aware ranking.
    */
-  getFileTypeBoost(fileType, intent) {
+  getFileTypeBoost(fileType, intents) {
     let baseBoost;
     switch (fileType) {
       case "documentation-primary":
@@ -1030,9 +1213,106 @@ var SearchService = class {
       default:
         baseBoost = 1;
     }
-    const intentBoosts = INTENT_FILE_BOOSTS[intent];
-    const intentMultiplier = intentBoosts[fileType ?? "other"] ?? 1;
-    return baseBoost * intentMultiplier;
+    let weightedMultiplier = 0;
+    let totalConfidence = 0;
+    for (const { intent, confidence } of intents) {
+      const intentBoosts = INTENT_FILE_BOOSTS[intent];
+      const multiplier = intentBoosts[fileType ?? "other"] ?? 1;
+      weightedMultiplier += multiplier * confidence;
+      totalConfidence += confidence;
+    }
+    const blendedMultiplier = totalConfidence > 0 ? weightedMultiplier / totalConfidence : 1;
+    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.
+   */
+  getUrlKeywordBoost(query, result) {
+    const url = result.metadata.url;
+    if (url === void 0 || url === "") return 1;
+    const urlPath = url.toLowerCase().replace(/[^a-z0-9]+/g, " ");
+    const stopWords = /* @__PURE__ */ 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"
+    ]);
+    const queryTerms = query.toLowerCase().split(/\s+/).filter((t2) => t2.length > 2 && !stopWords.has(t2));
+    if (queryTerms.length === 0) return 1;
+    const matchingTerms = queryTerms.filter((term) => urlPath.includes(term));
+    if (matchingTerms.length === 0) return 1;
+    const matchRatio = matchingTerms.length / queryTerms.length;
+    return 1 + 1 * 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.
+   */
+  getPathKeywordBoost(query, result) {
+    const path3 = result.metadata.path;
+    if (path3 === void 0 || path3 === "") return 1;
+    const pathSegments = path3.toLowerCase().replace(/[^a-z0-9]+/g, " ");
+    const stopWords = /* @__PURE__ */ 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"
+    ]);
+    const queryTerms = query.toLowerCase().split(/\s+/).filter((t2) => t2.length > 2 && !stopWords.has(t2));
+    if (queryTerms.length === 0) return 1;
+    const matchingTerms = queryTerms.filter((term) => pathSegments.includes(term));
+    if (matchingTerms.length === 0) return 1;
+    const matchRatio = matchingTerms.length / queryTerms.length;
+    return 1 + 1 * matchRatio;
   }
   /**
    * Get a score multiplier based on framework context.
@@ -1331,17 +1611,31 @@ var SearchService = class {
 
 // src/services/index.service.ts
 import { readFile as readFile3, readdir } from "fs/promises";
-import { join as join3, extname, basename } from "path";
-import { createHash } from "crypto";
+import { join as join5, extname, basename } from "path";
+import { createHash as createHash2 } from "crypto";
 
 // src/services/chunking.service.ts
-var ChunkingService = class {
+var CHUNK_PRESETS = {
+  code: { chunkSize: 768, chunkOverlap: 100 },
+  web: { chunkSize: 1200, chunkOverlap: 200 },
+  docs: { chunkSize: 1200, chunkOverlap: 200 }
+};
+var ChunkingService = class _ChunkingService {
   chunkSize;
   chunkOverlap;
   constructor(config) {
     this.chunkSize = config.chunkSize;
     this.chunkOverlap = config.chunkOverlap;
   }
+  /**
+   * Create a ChunkingService with preset configuration for a content type.
+   * - 'code': Smaller chunks (768/100) for precise code symbol matching
+   * - 'web': Larger chunks (1200/200) for web prose content
+   * - 'docs': Larger chunks (1200/200) for documentation
+   */
+  static forContentType(type) {
+    return new _ChunkingService(CHUNK_PRESETS[type]);
+  }
   /**
    * Chunk text content. Uses semantic chunking for Markdown and code files,
    * falling back to sliding window for other content.
@@ -1596,6 +1890,7 @@ var ChunkingService = class {
 };
 
 // src/services/index.service.ts
+var logger2 = createLogger("index-service");
 var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
   ".txt",
   ".md",
@@ -1640,12 +1935,22 @@ var IndexService = class {
     this.codeGraphService = options.codeGraphService;
   }
   async indexStore(store, onProgress) {
+    logger2.info({
+      storeId: store.id,
+      storeName: store.name,
+      storeType: store.type
+    }, "Starting store indexing");
     try {
       if (store.type === "file" || store.type === "repo") {
         return await this.indexFileStore(store, onProgress);
       }
+      logger2.error({ storeId: store.id, storeType: store.type }, "Unsupported store type for indexing");
       return err(new Error(`Indexing not supported for store type: ${store.type}`));
     } catch (error) {
+      logger2.error({
+        storeId: store.id,
+        error: error instanceof Error ? error.message : String(error)
+      }, "Store indexing failed");
       return err(error instanceof Error ? error : new Error(String(error)));
     }
   }
@@ -1654,6 +1959,11 @@ var IndexService = class {
     const files = await this.scanDirectory(store.path);
     const documents = [];
     let filesProcessed = 0;
+    logger2.debug({
+      storeId: store.id,
+      path: store.path,
+      fileCount: files.length
+    }, "Files scanned for indexing");
     const sourceFiles = [];
     onProgress?.({
       type: "start",
@@ -1663,7 +1973,7 @@ var IndexService = class {
     });
     for (const filePath of files) {
       const content = await readFile3(filePath, "utf-8");
-      const fileHash = createHash("md5").update(content).digest("hex");
+      const fileHash = createHash2("md5").update(content).digest("hex");
       const chunks = this.chunker.chunk(content, filePath);
       const ext = extname(filePath).toLowerCase();
       const fileName = basename(filePath).toLowerCase();
@@ -1717,17 +2027,26 @@ var IndexService = class {
       total: files.length,
       message: "Indexing complete"
     });
+    const timeMs = Date.now() - startTime;
+    logger2.info({
+      storeId: store.id,
+      storeName: store.name,
+      documentsIndexed: filesProcessed,
+      chunksCreated: documents.length,
+      sourceFilesForGraph: sourceFiles.length,
+      timeMs
+    }, "Store indexing complete");
     return ok({
       documentsIndexed: filesProcessed,
       chunksCreated: documents.length,
-      timeMs: Date.now() - startTime
+      timeMs
     });
   }
   async scanDirectory(dir) {
     const files = [];
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join3(dir, entry.name);
+      const fullPath = join5(dir, entry.name);
       if (entry.isDirectory()) {
         if (!["node_modules", ".git", "dist", "build"].includes(entry.name)) {
           files.push(...await this.scanDirectory(fullPath));
@@ -1798,10 +2117,33 @@ var IndexService = class {
     return false;
   }
 };
+function classifyWebContentType(url, title) {
+  const urlLower = url.toLowerCase();
+  const titleLower = (title ?? "").toLowerCase();
+  if (/\/api[-/]?(ref|reference|docs?)?\//i.test(urlLower) || /api\s*(reference|documentation)/i.test(titleLower)) {
+    return "documentation-primary";
+  }
+  if (/\/(getting[-_]?started|quickstart|tutorial|setup)\b/i.test(urlLower) || /(getting started|quickstart|tutorial)/i.test(titleLower)) {
+    return "documentation-primary";
+  }
+  if (/\/(docs?|documentation|reference|learn|manual|guide)/i.test(urlLower)) {
+    return "documentation";
+  }
+  if (/\/(examples?|demos?|samples?|cookbook)/i.test(urlLower)) {
+    return "example";
+  }
+  if (/changelog|release[-_]?notes/i.test(urlLower)) {
+    return "changelog";
+  }
+  if (/\/blog\//i.test(urlLower)) {
+    return "other";
+  }
+  return "documentation";
+}
 
 // src/services/code-graph.service.ts
 import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir4 } from "fs/promises";
-import { join as join4, dirname as dirname3 } from "path";
+import { join as join6, dirname as dirname3 } from "path";
 
 // src/analysis/code-graph.ts
 var CodeGraph = class {
@@ -3118,7 +3460,7 @@ var CodeGraphService = class {
     this.graphCache.clear();
   }
   getGraphPath(storeId) {
-    return join4(this.dataDir, "graphs", `${storeId}.json`);
+    return join6(this.dataDir, "graphs", `${storeId}.json`);
   }
   /**
    * Type guard for SerializedGraph structure.
@@ -3254,6 +3596,13 @@ var LanceStore = class {
       this.tables.delete(tableName);
     }
   }
+  close() {
+    this.tables.clear();
+    if (this.connection !== null) {
+      this.connection.close();
+      this.connection = null;
+    }
+  }
   getTableName(storeId) {
     return `documents_${storeId}`;
   }
@@ -3273,9 +3622,9 @@ var LanceStore = class {
 
 // src/db/embeddings.ts
 import { pipeline, env } from "@huggingface/transformers";
-import { homedir as homedir2 } from "os";
-import { join as join5 } from "path";
-env.cacheDir = join5(homedir2(), ".cache", "huggingface-transformers");
+import { homedir as homedir3 } from "os";
+import { join as join7 } from "path";
+env.cacheDir = join7(homedir3(), ".cache", "huggingface-transformers");
 var EmbeddingEngine = class {
   extractor = null;
   modelName;
@@ -3398,25 +3747,27 @@ function validateParsePythonResult(data) {
 }
 
 // src/crawl/bridge.ts
+var logger3 = createLogger("python-bridge");
 var PythonBridge = class {
   process = null;
   pending = /* @__PURE__ */ new Map();
   stoppingIntentionally = false;
   start() {
     if (this.process) return Promise.resolve();
+    logger3.debug("Starting Python bridge process");
     this.process = spawn2("python3", ["python/crawl_worker.py"], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.process.on("error", (err2) => {
-      console.error("Python bridge process error:", err2);
+      logger3.error({ error: err2.message, stack: err2.stack }, "Python bridge process error");
       this.rejectAllPending(new Error(`Process error: ${err2.message}`));
     });
     this.process.on("exit", (code, signal) => {
       if (code !== 0 && code !== null) {
-        console.error(`Python bridge process exited with code ${String(code)}`);
+        logger3.error({ code }, "Python bridge process exited with non-zero code");
         this.rejectAllPending(new Error(`Process exited with code ${String(code)}`));
       } else if (signal && !this.stoppingIntentionally) {
-        console.error(`Python bridge process killed with signal ${signal}`);
+        logger3.error({ signal }, "Python bridge process killed with signal");
         this.rejectAllPending(new Error(`Process killed with signal ${signal}`));
       }
       this.process = null;
@@ -3425,7 +3776,7 @@ var PythonBridge = class {
     if (this.process.stderr) {
       const stderrRl = createInterface({ input: this.process.stderr });
       stderrRl.on("line", (line) => {
-        console.error("Python bridge stderr:", line);
+        logger3.warn({ stderr: line }, "Python bridge stderr output");
       });
     }
     if (this.process.stdout === null) {
@@ -3460,18 +3811,24 @@ var PythonBridge = class {
               pending.resolve(validated);
             } catch (error) {
               if (error instanceof ZodError) {
-                console.error("Python bridge response validation failed:", error.issues);
-                console.error("Original response:", JSON.stringify(response.result));
+                logger3.error({
+                  issues: error.issues,
+                  response: JSON.stringify(response.result)
+                }, "Python bridge response validation failed");
                 pending.reject(new Error(`Invalid response format from Python bridge: ${error.message}`));
               } else {
                 const errorMessage = error instanceof Error ? error.message : String(error);
+                logger3.error({ error: errorMessage }, "Response validation error");
                 pending.reject(new Error(`Response validation error: ${errorMessage}`));
               }
             }
           }
         }
       } catch (err2) {
-        console.error("Failed to parse JSON response from Python bridge:", err2, "Line:", line);
+        logger3.error({
+          error: err2 instanceof Error ? err2.message : String(err2),
+          line
+        }, "Failed to parse JSON response from Python bridge");
       }
     });
     return Promise.resolve();
@@ -3570,7 +3927,9 @@ var PythonBridge = class {
 };
 
 // src/services/index.ts
+var logger4 = createLogger("services");
 async function createServices(configPath, dataDir, projectRoot) {
+  logger4.info({ configPath, dataDir, projectRoot }, "Initializing services");
   const config = new ConfigService(configPath, dataDir, projectRoot);
   const appConfig = await config.load();
   const resolvedDataDir = config.resolveDataDir();
@@ -3585,8 +3944,9 @@ async function createServices(configPath, dataDir, projectRoot) {
   const pythonBridge = new PythonBridge();
   await pythonBridge.start();
   const codeGraph = new CodeGraphService(resolvedDataDir, pythonBridge);
-  const search = new SearchService(lance, embeddings, void 0, codeGraph);
+  const search = new SearchService(lance, embeddings, codeGraph);
   const index = new IndexService(lance, embeddings, { codeGraphService: codeGraph });
+  logger4.info({ dataDir: resolvedDataDir }, "Services initialized successfully");
   return {
     config,
     store,
@@ -3599,7 +3959,18 @@ async function createServices(configPath, dataDir, projectRoot) {
   };
 }
 async function destroyServices(services) {
-  await services.pythonBridge.stop();
+  logger4.info("Shutting down services");
+  try {
+    services.lance.close();
+  } catch (e) {
+    logger4.error({ error: e }, "Error closing LanceStore");
+  }
+  try {
+    await services.pythonBridge.stop();
+  } catch (e) {
+    logger4.error({ error: e }, "Error stopping Python bridge");
+  }
+  await shutdownLogger();
 }
 
 export {
@@ -3608,10 +3979,15 @@ export {
   ok,
   err,
   extractRepoName,
+  createLogger,
+  summarizePayload,
+  truncateForLog,
+  ChunkingService,
+  classifyWebContentType,
   ASTParser,
   PythonBridge,
   JobService,
   createServices,
   destroyServices
 };
-//# sourceMappingURL=chunk-5QMHZUC4.js.map
+//# sourceMappingURL=chunk-RWSXP3PQ.js.map