ultracode 5.4.0 → 5.6.0

package/dist/chunks/semantic-tool-handlers-735UMO7Y.js

@@ -0,0 +1,817 @@
+import { DetectCodeClonesSchema } from './chunk-RAGUL4TA.js';
+import { projectPathParam } from './chunk-NJUB245U.js';
+import { SAFE_LIMITS, BaseToolHandler, MAX_PAGE_SIZE, paginate } from './chunk-Q5LPVLXA.js';
+import './chunk-TCHCDCDO.js';
+import './chunk-LH4OUKNZ.js';
+import './chunk-HEMJHRHZ.js';
+import { toError } from './chunk-5WKPA33T.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+import { readFileSync } from 'fs';
+import { z } from 'zod';
+
+// src/tools/handlers/semantic-tool-handlers.ts
+init_logging();
+var CONTENT_TOKEN_LIMIT = 8e3;
+var CHARS_PER_TOKEN = 4;
+function loadSourceCode(filePath, startLine, endLine) {
+  if (!filePath || !startLine || !endLine) return void 0;
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const start = Math.max(0, startLine - 1);
+    const end = Math.min(lines.length, endLine);
+    return lines.slice(start, end).join("\n");
+  } catch {
+    return void 0;
+  }
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function applyContentPagination(results, includeContent) {
+  if (!includeContent || results.length === 0) {
+    return { results };
+  }
+  let tokensUsed = 0;
+  let includedCount = 0;
+  const paginatedResults = [];
+  for (const result of results) {
+    const content = result.content;
+    if (content) {
+      const contentTokens = estimateTokens(content);
+      if (tokensUsed + contentTokens > CONTENT_TOKEN_LIMIT && includedCount > 0) {
+        paginatedResults.push({ ...result, content: void 0 });
+      } else {
+        tokensUsed += contentTokens;
+        includedCount++;
+        paginatedResults.push(result);
+      }
+    } else {
+      paginatedResults.push(result);
+    }
+  }
+  const hasMore = includedCount < results.filter((r) => r.content).length;
+  return {
+    results: paginatedResults,
+    ...hasMore ? {
+      contentPagination: {
+        includedCount,
+        totalCount: results.length,
+        tokensUsed,
+        tokenLimit: CONTENT_TOKEN_LIMIT,
+        hasMore,
+        message: `Content included for ${includedCount} of ${results.length} results (~${tokensUsed} tokens). Use offset to see more.`
+      }
+    } : {}
+  };
+}
+var SemanticSearchSchema = z.object({
+  query: z.string().describe("Natural language search query"),
+  projectPath: projectPathParam,
+  offset: z.number().optional().default(0),
+  limit: z.number().optional().default(SAFE_LIMITS.searchResults),
+  entityTypes: z.array(z.string()).optional().describe("Filter by entity types (function, class, interface, etc.)"),
+  minSimilarity: z.number().optional().default(0.7).describe("Minimum similarity threshold (0.0-1.0)"),
+  includeContent: z.boolean().optional().default(false).describe("Include full source code (startLine to endLine) in results"),
+  expandRelated: z.boolean().optional().default(false).describe("Expand results with graph neighbors (callers, dependencies, inheritors)"),
+  expansionDepth: z.number().optional().default(1).describe("Graph traversal depth for expansion (1 or 2 hops)"),
+  // Two-stage retrieval with reranking
+  rerank: z.boolean().optional().default(false).describe(
+    "Enable two-stage retrieval: rerank top results with cross-encoder for better precision (requires vLLM or TEI provider)"
+  ),
+  rerankTopK: z.number().optional().default(50).describe("Number of top embedding results to rerank (default: 50)"),
+  // New filters based on parser-extracted data
+  minCyclomatic: z.number().optional().describe("Filter: minimum cyclomatic complexity"),
+  maxCyclomatic: z.number().optional().describe("Filter: maximum cyclomatic complexity"),
+  hasExceptions: z.boolean().optional().describe("Filter: must have try-catch blocks"),
+  hasLoops: z.boolean().optional().describe("Filter: must have loops"),
+  hasAwaits: z.boolean().optional().describe("Filter: must have await expressions (async code)"),
+  hasDocumentation: z.boolean().optional().describe("Filter: must have documentation/docstrings"),
+  isDeprecated: z.boolean().optional().describe("Filter: deprecated entities only"),
+  minCallCount: z.number().optional().describe("Filter: minimum number of function calls"),
+  // History filters (Prolly Tree)
+  changedInLastCommits: z.number().optional().describe("Filter: only entities changed in last N graph commits (Prolly Tree)"),
+  changedSinceMs: z.number().optional().describe("Filter: only entities changed since this Unix timestamp (ms)")
+});
+var SemanticSearchToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return SemanticSearchSchema.parse(args);
+  }
+  async execute(args) {
+    const resolvedPath = this.resolveProjectPath(args);
+    const currentProject = this.getProjectContext().getCurrentProject();
+    log.d("SEMSEARCH", "proj_paths", { arg: args.projectPath, resolved: resolvedPath, current: currentProject });
+    if (args.projectPath && resolvedPath !== currentProject) {
+      if (!this.isProjectIndexed(resolvedPath)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: false,
+                  error: `Project not indexed: ${resolvedPath}`,
+                  hint: "Run 'index' tool on the target directory first",
+                  currentProject,
+                  requestedProject: resolvedPath
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      log.w("SEMSEARCH", "cross_proj", { current: currentProject, requested: resolvedPath });
+    }
+    const semanticAgent = await this.ensureSemanticAgentForProject(resolvedPath);
+    const initError = semanticAgent.getEmbeddingInitError();
+    if (initError) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: `Embedding provider initialization failed: ${initError.message}`,
+                hint: "Check if the configured embedding provider is available (Docker, Ollama, etc.)"
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    await this.ensureGraphStorageForProject(resolvedPath);
+    const safeLimit = Math.min(args.limit, MAX_PAGE_SIZE);
+    const searchResult = await semanticAgent.semanticSearch(args.query, 1e3);
+    let allResults = searchResult.results || [];
+    let rerankStats = { reranked: false, provider: "" };
+    if (args.rerank && allResults.length > 0) {
+      const provider = semanticAgent.getEmbeddingProvider?.();
+      const capabilities = provider?.getCapabilities?.();
+      if (capabilities?.rerank && provider?.rerank) {
+        try {
+          const topK = Math.min(args.rerankTopK, allResults.length);
+          const toRerank = allResults.slice(0, topK);
+          const documents = toRerank.map((r, idx) => ({
+            text: r.content || r.metadata?.content || r.name || "",
+            id: r.id || String(idx)
+          }));
+          const reranked = await provider.rerank(args.query, documents, {
+            topK,
+            threshold: args.minSimilarity
+          });
+          const rerankedMap = new Map(reranked.map((r) => [r.id, r.score]));
+          for (const result of toRerank) {
+            const newScore = rerankedMap.get(result.id);
+            if (newScore !== void 0) {
+              result.similarity = newScore;
+              result.reranked = true;
+            }
+          }
+          allResults = [...toRerank, ...allResults.slice(topK)];
+          allResults.sort(
+            (a, b) => (b.similarity || 0) - (a.similarity || 0)
+          );
+          rerankStats = { reranked: true, provider: provider.info?.name || "unknown" };
+        } catch (error) {
+          const err = toError(error);
+          log.w("SEMSEARCH", "rerank_fail", { err: err.message });
+        }
+      }
+    }
+    let filteredResults = allResults;
+    const hasFilters = args.minCyclomatic !== void 0 || args.maxCyclomatic !== void 0 || args.hasExceptions !== void 0 || args.hasLoops !== void 0 || args.hasAwaits !== void 0 || args.hasDocumentation !== void 0 || args.isDeprecated !== void 0 || args.minCallCount !== void 0;
+    if (hasFilters) {
+      filteredResults = allResults.filter((r) => {
+        const meta = r.metadata || {};
+        if (args.minCyclomatic !== void 0 && (meta.cyclomatic || 0) < args.minCyclomatic) return false;
+        if (args.maxCyclomatic !== void 0 && (meta.cyclomatic || Infinity) > args.maxCyclomatic) return false;
+        if (args.hasExceptions !== void 0 && meta.hasExceptions !== args.hasExceptions) return false;
+        if (args.hasLoops !== void 0 && meta.hasLoops !== args.hasLoops) return false;
+        if (args.hasAwaits !== void 0 && meta.hasAwaits !== args.hasAwaits) return false;
+        if (args.hasDocumentation !== void 0 && meta.hasDocumentation !== args.hasDocumentation) return false;
+        if (args.isDeprecated !== void 0 && meta.isDeprecated !== args.isDeprecated) return false;
+        if (args.minCallCount !== void 0 && (meta.callCount || 0) < args.minCallCount) return false;
+        return true;
+      });
+    }
+    if (args.changedInLastCommits !== void 0 || args.changedSinceMs !== void 0) {
+      const { getRecentlyChangedEntities } = await import('./recently-changed-FX5QR4Z2.js');
+      const storage = await this.context.getGraphStorage();
+      const adapter = storage.getLibSQLAdapter?.();
+      if (adapter) {
+        const recentlyChanged = await getRecentlyChangedEntities(adapter, {
+          lastCommits: args.changedInLastCommits,
+          sinceTimestamp: args.changedSinceMs
+        });
+        if (recentlyChanged) {
+          filteredResults = filteredResults.filter((r) => {
+            const entityId = r.metadata?.entityId || r.id?.replace(/^ent:/, "");
+            return entityId ? recentlyChanged.changedIds.has(entityId) : false;
+          });
+        }
+      }
+    }
+    let expandedResults = filteredResults;
+    let expansionStats = { expanded: false, neighborsAdded: 0 };
+    if (args.expandRelated && filteredResults.length > 0) {
+      const expansion = await this.expandWithGraphNeighbors(filteredResults, args.expansionDepth, args.minSimilarity);
+      expandedResults = expansion.results;
+      expansionStats = { expanded: true, neighborsAdded: expansion.neighborsAdded };
+    }
+    const paginatedResult = paginate(expandedResults, args.offset, safeLimit);
+    const queryExpansion = searchResult.expandedQuery ? {
+      expandedQuery: searchResult.expandedQuery,
+      ...searchResult.expansionInfo ? {
+        coocTerms: searchResult.expansionInfo.coocTerms?.length || 0,
+        prfTerms: searchResult.expansionInfo.prfTerms?.length || 0
+      } : {}
+    } : null;
+    const mappedResults = paginatedResult.data.map((r) => {
+      const meta = r.metadata || {};
+      const filePath = r.filePath || meta.filePath || meta.path;
+      const startLine = meta.startLine;
+      const endLine = meta.endLine;
+      const content = args.includeContent ? loadSourceCode(filePath, startLine, endLine) : void 0;
+      return {
+        id: r.id,
+        name: r.name || meta.name,
+        type: r.type || meta.entityType || meta.type,
+        similarity: r.similarity,
+        ...r.reranked ? { reranked: true } : {},
+        filePath,
+        startLine,
+        endLine,
+        language: meta.language,
+        // Complexity metrics (if available)
+        ...meta.cyclomatic ? {
+          complexity: {
+            cyclomatic: meta.cyclomatic,
+            cognitive: meta.cognitive,
+            linesOfCode: meta.linesOfCode,
+            nestingDepth: meta.nestingDepth
+          }
+        } : {},
+        // Control flow info (if available)
+        ...meta.hasBranches !== void 0 ? {
+          controlFlow: {
+            hasBranches: meta.hasBranches,
+            hasLoops: meta.hasLoops,
+            hasExceptions: meta.hasExceptions,
+            hasAwaits: meta.hasAwaits,
+            branchCount: meta.branchCount,
+            loopCount: meta.loopCount,
+            returnCount: meta.returnCount
+          }
+        } : {},
+        // Call info (if available)
+        ...meta.callCount ? {
+          calls: {
+            count: meta.callCount,
+            hasAsync: meta.hasAsyncCalls
+          }
+        } : {},
+        // Documentation info (if available)
+        ...meta.hasDocumentation ? {
+          documentation: {
+            hasDocumentation: true,
+            hasParams: meta.hasParams,
+            hasExamples: meta.hasExamples,
+            isDeprecated: meta.isDeprecated
+          }
+        } : {},
+        // Type info
+        ...meta.returnType ? { returnType: meta.returnType } : {},
+        ...meta.paramCount ? { paramCount: meta.paramCount } : {},
+        // Expansion info
+        ...r.isExpanded ? { isExpanded: true, relationshipType: r.relationshipType } : {},
+        // Content (loaded from file)
+        ...content ? { content } : {}
+      };
+    });
+    const { results: finalResults, contentPagination } = applyContentPagination(mappedResults, args.includeContent);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              query: args.query,
+              count: finalResults.length,
+              pagination: paginatedResult.pagination,
+              ...queryExpansion ? { queryExpansion } : {},
+              ...rerankStats.reranked ? { rerank: rerankStats } : {},
+              ...expansionStats.expanded ? { expansion: expansionStats } : {},
+              ...contentPagination ? { contentPagination } : {},
+              results: finalResults
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+  /**
+   * Expand search results with graph neighbors (callers, dependencies, inheritors)
+   */
+  async expandWithGraphNeighbors(results, depth, minSimilarity) {
+    const storage = await this.context.getGraphStorage();
+    const seen = new Set(results.map((r) => r.id));
+    const neighbors = [];
+    for (const result of results.slice(0, 20)) {
+      let entityId = result.metadata?.entityId;
+      if (!entityId && result.metadata?.name && result.metadata?.path) {
+        try {
+          const found = await storage.findEntities({
+            filters: {
+              name: result.metadata.name,
+              filePath: result.metadata.path
+            },
+            limit: 1
+          });
+          if (found.length > 0) {
+            entityId = found[0]?.id;
+          }
+        } catch {
+        }
+      }
+      if (!entityId) continue;
+      try {
+        const relationships = await storage.getRelationshipsForEntity(entityId);
+        for (const rel of relationships) {
+          const relatedId = rel.fromId === entityId ? rel.toId : rel.fromId;
+          if (seen.has(relatedId) || seen.has(`ent:${relatedId}`)) continue;
+          seen.add(relatedId);
+          const relatedEntity = await storage.getEntity(relatedId);
+          if (!relatedEntity) continue;
+          const neighborSimilarity = result.similarity * 0.7;
+          if (neighborSimilarity < minSimilarity) continue;
+          neighbors.push({
+            id: `ent:${relatedId}`,
+            name: relatedEntity.name,
+            type: relatedEntity.type,
+            similarity: neighborSimilarity,
+            filePath: relatedEntity.filePath,
+            content: relatedEntity.metadata?.["content"],
+            isExpanded: true,
+            relationshipType: rel.type,
+            metadata: { entityId: relatedId }
+          });
+        }
+        if (depth >= 2 && neighbors.length < 50) {
+          for (const neighbor of neighbors.slice(-10)) {
+            const neighborEntityId = neighbor.id?.replace(/^ent:/, "");
+            if (!neighborEntityId) continue;
+            try {
+              const hop2Rels = await storage.getRelationshipsForEntity(neighborEntityId);
+              for (const rel of hop2Rels.slice(0, 5)) {
+                const hop2Id = rel.fromId === neighborEntityId ? rel.toId : rel.fromId;
+                if (seen.has(hop2Id) || seen.has(`ent:${hop2Id}`)) continue;
+                seen.add(hop2Id);
+                const hop2Entity = await storage.getEntity(hop2Id);
+                if (!hop2Entity) continue;
+                const hop2Similarity = neighbor.similarity * 0.7;
+                if (hop2Similarity < minSimilarity) continue;
+                neighbors.push({
+                  id: `ent:${hop2Id}`,
+                  name: hop2Entity.name,
+                  type: hop2Entity.type,
+                  similarity: hop2Similarity,
+                  filePath: hop2Entity.filePath,
+                  content: hop2Entity.metadata?.["content"],
+                  isExpanded: true,
+                  relationshipType: `${rel.type} (2-hop)`,
+                  metadata: { entityId: hop2Id }
+                });
+              }
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    const combined = [...results, ...neighbors];
+    combined.sort((a, b) => (b.similarity || 0) - (a.similarity || 0));
+    return {
+      results: combined,
+      neighborsAdded: neighbors.length
+    };
+  }
+};
+var FindSimilarCodeSchema = z.object({
+  code: z.string().describe("Code snippet to find similar code for"),
+  projectPath: projectPathParam,
+  offset: z.number().optional().default(0),
+  limit: z.number().optional().default(SAFE_LIMITS.searchResults),
+  minSimilarity: z.number().optional().default(0.7).describe("Minimum similarity threshold (0.0-1.0)"),
+  includeContent: z.boolean().optional().default(false).describe("Include full source code (startLine to endLine) in results")
+});
+var FindSimilarCodeToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return FindSimilarCodeSchema.parse(args);
+  }
+  async execute(args) {
+    const resolvedPath = this.resolveProjectPath(args);
+    const semanticAgent = await this.ensureSemanticAgentForProject(resolvedPath);
+    const initError = semanticAgent.getEmbeddingInitError();
+    if (initError) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: `Embedding provider initialization failed: ${initError.message}`,
+                hint: "Check if the configured embedding provider is available (Docker, Ollama, etc.)"
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    const safeLimit = Math.min(args.limit, MAX_PAGE_SIZE);
+    const allResults = await semanticAgent.findSimilarCode(args.code, args.minSimilarity);
+    const paginatedResult = paginate(allResults, args.offset, safeLimit);
+    const mappedResults = paginatedResult.data.map((r) => {
+      const filePath = r.filePath || r.metadata?.path;
+      const startLine = r.metadata?.startLine;
+      const endLine = r.metadata?.endLine;
+      const content = args.includeContent ? loadSourceCode(filePath, startLine, endLine) : void 0;
+      return {
+        id: r.id,
+        name: r.name,
+        type: r.type,
+        similarity: r.similarity,
+        filePath,
+        startLine,
+        endLine,
+        ...content ? { content } : {}
+      };
+    });
+    const { results: finalResults, contentPagination } = applyContentPagination(mappedResults, args.includeContent);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              count: finalResults.length,
+              pagination: paginatedResult.pagination,
+              ...contentPagination ? { contentPagination } : {},
+              results: finalResults
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var DetectCodeClonesToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return DetectCodeClonesSchema.parse(args);
+  }
+  async execute(args) {
+    try {
+      const semanticAgent = await this.ensureSemanticAgentForProject();
+      const initError = semanticAgent.getEmbeddingInitError();
+      if (initError) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: false,
+                  error: `Embedding provider initialization failed: ${initError.message}`,
+                  hint: "Check if the configured embedding provider is available (Docker, Ollama, etc.)"
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      const minSimilarity = args.minSimilarity ?? 0.8;
+      const allClones = await semanticAgent.detectClones(minSimilarity);
+      if (!allClones || !Array.isArray(allClones)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  groupsFound: 0,
+                  clones: [],
+                  warning: "Clone detection unavailable - vector store may not be initialized"
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                groupsFound: allClones.length,
+                scope: args.scope ?? "all",
+                minSimilarity,
+                clones: allClones.map((group) => ({
+                  similarity: group.avgSimilarity,
+                  cloneType: group.cloneType,
+                  members: (group.members || []).map((m) => ({
+                    id: m.id,
+                    name: m.name,
+                    filePath: m.path,
+                    startLine: m.startLine,
+                    endLine: m.endLine
+                  }))
+                }))
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      log.e("CLONES", "detectClones failed", { error: err.message, stack: err.stack });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                groupsFound: 0,
+                clones: [],
+                error: err.message
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  }
+};
+var JscpdDetectClonesSchema = z.object({
+  directory: z.string().optional(),
+  minLines: z.number().optional().default(5),
+  minTokens: z.number().optional().default(50),
+  threshold: z.number().optional().default(0),
+  format: z.array(z.string()).optional(),
+  offset: z.number().optional().default(0),
+  limit: z.number().optional().default(SAFE_LIMITS.clones)
+});
+var JscpdDetectClonesToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return JscpdDetectClonesSchema.parse(args);
+  }
+  async execute(args) {
+    const targetDir = args.directory ? this.context.normalizeInputPath(args.directory) ?? this.resolveProjectPath({}) : this.resolveProjectPath({});
+    try {
+      const { runJscpdCloneDetection } = await import('./jscpd-ZS3WMD6W.js');
+      const result = await runJscpdCloneDetection({
+        paths: [targetDir],
+        formats: args.format || ["javascript", "typescript", "python"],
+        minLines: args.minLines,
+        minTokens: args.minTokens
+      });
+      const safeLimit = Math.min(args.limit, MAX_PAGE_SIZE);
+      const paginatedResult = paginate(result.clones, args.offset, safeLimit);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                duplicatesFound: paginatedResult.data.length,
+                pagination: paginatedResult.pagination,
+                statistics: {
+                  total: result.statistic.total,
+                  detectionDate: result.statistic.detectionDate
+                },
+                duplicates: paginatedResult.data.map((c) => ({
+                  format: c.format,
+                  foundDate: c.foundDate,
+                  duplicationA: {
+                    sourceId: c.duplicationA.sourceId,
+                    start: c.duplicationA.start,
+                    end: c.duplicationA.end
+                  },
+                  duplicationB: {
+                    sourceId: c.duplicationB.sourceId,
+                    start: c.duplicationB.start,
+                    end: c.duplicationB.end
+                  }
+                }))
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: err.message })
+          }
+        ]
+      };
+    }
+  }
+};
+var CrossLanguageSearchSchema = z.object({
+  query: z.string().describe("Search query"),
+  projectPath: projectPathParam,
+  languages: z.array(z.string()).optional().describe("Languages to search in"),
+  offset: z.number().optional().default(0),
+  limit: z.number().optional().default(SAFE_LIMITS.searchResults),
+  includeContent: z.boolean().optional().default(false).describe("Include full source code (startLine to endLine) in results")
+});
+var CrossLanguageSearchToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return CrossLanguageSearchSchema.parse(args);
+  }
+  async execute(args) {
+    const resolvedPath = this.resolveProjectPath(args);
+    const semanticAgent = await this.ensureSemanticAgentForProject(resolvedPath);
+    const safeLimit = Math.min(args.limit, MAX_PAGE_SIZE);
+    const languages = args.languages || [
+      "typescript",
+      "javascript",
+      "python",
+      "go",
+      "rust",
+      "java",
+      "cpp",
+      "swift",
+      "kotlin",
+      "csharp"
+    ];
+    const allResults = await semanticAgent.crossLanguageSearch(args.query, languages);
+    const paginatedResult = paginate(allResults, args.offset, safeLimit);
+    const mappedResults = paginatedResult.data.map((r) => {
+      const filePath = r.filePath || r.metadata?.path;
+      const startLine = r.metadata?.startLine;
+      const endLine = r.metadata?.endLine;
+      const content = args.includeContent ? loadSourceCode(filePath, startLine, endLine) : void 0;
+      return {
+        id: r.id,
+        name: r.name,
+        language: r.metadata?.language,
+        filePath,
+        startLine,
+        endLine,
+        similarity: r.similarity,
+        ...content ? { content } : {}
+      };
+    });
+    const { results: finalResults, contentPagination } = applyContentPagination(mappedResults, args.includeContent);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              query: args.query,
+              languages,
+              count: finalResults.length,
+              pagination: paginatedResult.pagination,
+              ...contentPagination ? { contentPagination } : {},
+              results: finalResults
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var PatternSearchSchema = z.object({
+  pattern: z.string(),
+  projectPath: projectPathParam,
+  mode: z.enum(["entity", "content", "semantic", "hybrid"]).optional().default("hybrid"),
+  entityTypes: z.array(z.string()).optional(),
+  offset: z.number().optional().default(0),
+  limit: z.number().optional().default(SAFE_LIMITS.searchResults),
+  minSimilarity: z.number().optional().default(0.7),
+  // History filters (Prolly Tree)
+  changedInLastCommits: z.number().optional().describe("Filter: only entities changed in last N graph commits (Prolly Tree)"),
+  changedSinceMs: z.number().optional().describe("Filter: only entities changed since this Unix timestamp (ms)")
+});
+var PatternSearchToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return PatternSearchSchema.parse(args);
+  }
+  async execute(args) {
+    const { PatternSearch } = await import('./pattern-search-WRBKEWYE.js');
+    const resolvedPath = this.resolveProjectPath(args);
+    const storage = await this.ensureGraphStorageForProject(resolvedPath);
+    const safeLimit = Math.min(args.limit, MAX_PAGE_SIZE);
+    let vectorStore = null;
+    let embeddingError = null;
+    try {
+      const semanticAgent = await this.ensureSemanticAgentForProject(resolvedPath);
+      embeddingError = semanticAgent.getEmbeddingInitError();
+      vectorStore = semanticAgent.getVectorStore?.();
+    } catch {
+    }
+    if ((args.mode === "semantic" || args.mode === "hybrid") && embeddingError) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: `Embedding provider initialization failed: ${embeddingError.message}`,
+                hint: "Check if the configured embedding provider is available. Use mode='entity' or 'content' for text-based search."
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    const patternSearch = new PatternSearch(storage, vectorStore, null);
+    await patternSearch.initialize();
+    let allResults = await patternSearch.search({
+      pattern: args.pattern,
+      mode: args.mode,
+      scope: { entityTypes: args.entityTypes },
+      limit: 500
+    });
+    if (args.changedInLastCommits !== void 0 || args.changedSinceMs !== void 0) {
+      const { getRecentlyChangedEntities } = await import('./recently-changed-FX5QR4Z2.js');
+      const adapter = storage.getLibSQLAdapter?.();
+      if (adapter) {
+        const recentlyChanged = await getRecentlyChangedEntities(adapter, {
+          lastCommits: args.changedInLastCommits,
+          sinceTimestamp: args.changedSinceMs
+        });
+        if (recentlyChanged) {
+          allResults = allResults.filter((r) => recentlyChanged.changedIds.has(r.entity.id));
+        }
+      }
+    }
+    const paginatedResult = paginate(allResults, args.offset, safeLimit);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              pattern: args.pattern,
+              mode: args.mode,
+              count: paginatedResult.data.length,
+              pagination: paginatedResult.pagination,
+              results: paginatedResult.data.map((r) => ({
+                id: r.entity.id,
+                name: r.entity.name,
+                type: r.entity.type,
+                matchType: r.matchType,
+                score: r.score,
+                filePath: r.entity.filePath,
+                startLine: r.entity.location?.start?.line,
+                endLine: r.entity.location?.end?.line,
+                snippet: r.snippet
+              }))
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+
+export { CrossLanguageSearchToolHandler, DetectCodeClonesToolHandler, FindSimilarCodeToolHandler, JscpdDetectClonesToolHandler, PatternSearchToolHandler, SemanticSearchToolHandler };
+//# sourceMappingURL=semantic-tool-handlers-735UMO7Y.js.map
+//# sourceMappingURL=semantic-tool-handlers-735UMO7Y.js.map