ultracode 5.3.0 → 5.5.0

package/dist/chunks/analysis-tool-handlers-H2RXLDPX.js

@@ -0,0 +1,817 @@
+import { projectPathParam } from './chunk-NJUB245U.js';
+import { SAFE_LIMITS, BaseToolHandler, MAX_PAGE_SIZE, paginate } from './chunk-WLKASYMP.js';
+import './chunk-KMXE2SJJ.js';
+import './chunk-HNDYLCWI.js';
+import { TimeTravelManager } from './chunk-AIZUHUK6.js';
+import './chunk-ZD54CMKT.js';
+import './chunk-HEMJHRHZ.js';
+import { toError } from './chunk-5WKPA33T.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+import { execSync } from 'child_process';
+import { z } from 'zod';
+
+// src/tools/handlers/analysis-tool-handlers.ts
+init_logging();
+var SuggestRefactoringSchema = z.object({
+  entityId: z.string().optional(),
+  filePath: z.string().optional(),
+  projectPath: projectPathParam,
+  type: z.enum(["extract_method", "rename", "move", "simplify", "all"]).optional().default("all"),
+  offset: z.number().optional().default(0),
+  limit: z.number().optional().default(SAFE_LIMITS.searchResults)
+});
+var SuggestRefactoringToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return SuggestRefactoringSchema.parse(args);
+  }
+  async execute(args) {
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const semanticAgent = await this.context.getSemanticAgent();
+    const safeLimit = Math.min(args.limit, MAX_PAGE_SIZE);
+    let code;
+    const targetEntityId = args.entityId;
+    let targetFilePath = args.filePath ? this.context.normalizeInputPath(args.filePath) : void 0;
+    if (args.entityId) {
+      const entity = await storage.getEntity(args.entityId);
+      if (entity?.filePath) {
+        targetFilePath = entity.filePath;
+      }
+    }
+    if (!code && targetFilePath) {
+      try {
+        const { readFile } = await import('fs/promises');
+        code = await readFile(targetFilePath, "utf-8");
+      } catch {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: `Cannot read file: ${targetFilePath}` }) }]
+        };
+      }
+    }
+    if (!code) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "No code found. Provide entityId or filePath." }) }]
+      };
+    }
+    const allSuggestions = await semanticAgent.suggestRefactoring(code);
+    const paginatedResult = paginate(allSuggestions, args.offset, safeLimit);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              entityId: targetEntityId,
+              filePath: targetFilePath,
+              suggestionsFound: paginatedResult.data.length,
+              pagination: paginatedResult.pagination,
+              suggestions: paginatedResult.data.map(
+                (s) => ({
+                  type: s.type,
+                  impact: s.impact,
+                  confidence: s.confidence,
+                  description: s.description,
+                  entityId: targetEntityId,
+                  filePath: targetFilePath,
+                  suggestedCode: s.code
+                })
+              )
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var AnalyzeHotspotsSchema = z.object({
+  projectPath: projectPathParam,
+  metric: z.enum(["complexity", "changes", "coupling", "all"]).optional().default("complexity"),
+  offset: z.number().optional().default(0),
+  limit: z.number().optional().default(SAFE_LIMITS.hotspots),
+  includeHistoricalMetrics: z.boolean().optional().default(true).describe("Use Prolly Tree history for changeFrequency calculation"),
+  lookbackDays: z.number().optional().default(30).describe("Number of days to look back for change frequency")
+});
+var AnalyzeHotspotsToolHandler = class extends BaseToolHandler {
+  // Cache for change frequency to avoid redundant calculations within same execution
+  changeFrequencyCache = /* @__PURE__ */ new Map();
+  parseArgs(args) {
+    return AnalyzeHotspotsSchema.parse(args);
+  }
+  async execute(args) {
+    this.changeFrequencyCache.clear();
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const safeLimit = Math.min(args.limit, MAX_PAGE_SIZE);
+    const entities = await storage.findEntities({ filters: {}, limit: 5e3 });
+    const needsHistory = args.includeHistoricalMetrics && (args.metric === "changes" || args.metric === "all");
+    if (needsHistory) {
+      await this.preloadChangeFrequencies(entities, storage, args.lookbackDays);
+    }
+    const hotspots = [];
+    for (const entity of entities) {
+      const { score, changeMetrics } = this.calculateHotspotScore(entity, args.metric, args.includeHistoricalMetrics);
+      if (score > 0) {
+        const storedMetrics = entity.metadata?.["metrics"] ?? {};
+        const storedLinesOfCode = storedMetrics.linesOfCode;
+        const linesOfCode = storedLinesOfCode ?? (entity.location?.end?.line && entity.location?.start?.line ? entity.location.end.line - entity.location.start.line + 1 : void 0);
+        hotspots.push({
+          id: entity.id,
+          name: entity.name,
+          type: entity.type,
+          filePath: entity.filePath,
+          score: Math.round(score * 100) / 100,
+          metrics: {
+            ...storedMetrics,
+            ...linesOfCode !== void 0 && storedLinesOfCode === void 0 ? { linesOfCode } : {},
+            ...changeMetrics
+          }
+        });
+      }
+    }
+    hotspots.sort((a, b) => b.score - a.score);
+    const paginatedResult = paginate(hotspots, args.offset, safeLimit);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              metric: args.metric,
+              includeHistoricalMetrics: args.includeHistoricalMetrics,
+              lookbackDays: args.lookbackDays,
+              hotspotsFound: paginatedResult.data.length,
+              pagination: paginatedResult.pagination,
+              hotspots: paginatedResult.data,
+              nextSteps: [
+                "graph_metrics({metric:'pagerank'}) \u2014 rank hotspots by architectural importance",
+                "taint_analysis() \u2014 check if hotspots contain security vulnerabilities"
+              ]
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+  /**
+   * Pre-load change frequencies for all entities in a batch to minimize diff operations.
+   * Uses Prolly Tree history first, falls back to Git for entities without Prolly data.
+   */
+  async preloadChangeFrequencies(entities, storage, lookbackDays) {
+    const adapter = storage.getLibSQLAdapter?.();
+    const commitManager = adapter?.getCommitManager?.();
+    const nodeStore = adapter?.getProllyNodeStore?.();
+    const entityChangeCount = /* @__PURE__ */ new Map();
+    let prollyDataAvailable = false;
+    for (const entity of entities) {
+      entityChangeCount.set(entity.id, { count: 0, source: "none" });
+    }
+    if (commitManager && nodeStore) {
+      const sinceTimestamp = Date.now() - lookbackDays * 24 * 60 * 60 * 1e3;
+      const recentCommits = await commitManager.getCommitsSince(sinceTimestamp);
+      if (recentCommits.length >= 2) {
+        prollyDataAvailable = true;
+        const timeTravel = new TimeTravelManager(nodeStore, commitManager);
+        for (let i = 0; i < recentCommits.length - 1; i++) {
+          const current = recentCommits[i];
+          const parent = recentCommits[i + 1];
+          if (!current || !parent) continue;
+          try {
+            const diff = await timeTravel.diffCommits(parent.commitHash, current.commitHash);
+            if (!diff) continue;
+            for (const entry of [...diff.treeDiff.added, ...diff.treeDiff.modified, ...diff.treeDiff.deleted]) {
+              const existing = entityChangeCount.get(entry.key);
+              if (existing) {
+                entityChangeCount.set(entry.key, { count: existing.count + 1, source: "prolly" });
+              }
+            }
+          } catch (error) {
+            log.w("HOTSPOTS", "diff_failed", { error: error.message });
+          }
+        }
+        log.d("HOTSPOTS", "prolly_preload_complete", {
+          commits: recentCommits.length,
+          withChanges: [...entityChangeCount.values()].filter((v) => v.count > 0).length
+        });
+      } else {
+        log.d("HOTSPOTS", "insufficient_commits", { count: recentCommits.length });
+      }
+    } else {
+      log.d("HOTSPOTS", "prolly_not_available", { reason: "missing components" });
+    }
+    const gitChangeCache = /* @__PURE__ */ new Map();
+    let gitFallbackCount = 0;
+    for (const entity of entities) {
+      const current = entityChangeCount.get(entity.id);
+      if (!current || current.count > 0 || !entity.filePath) continue;
+      let gitCount = gitChangeCache.get(entity.filePath);
+      if (gitCount === void 0) {
+        gitCount = this.getChangeFrequencyFromGit(entity.filePath, lookbackDays);
+        gitChangeCache.set(entity.filePath, gitCount);
+      }
+      if (gitCount > 0) {
+        entityChangeCount.set(entity.id, { count: gitCount, source: "git" });
+        gitFallbackCount++;
+      }
+    }
+    if (gitFallbackCount > 0) {
+      log.d("HOTSPOTS", "git_fallback_complete", {
+        filesChecked: gitChangeCache.size,
+        entitiesUpdated: gitFallbackCount
+      });
+    }
+    for (const [entityId, data] of entityChangeCount) {
+      this.changeFrequencyCache.set(entityId, { changeCount: data.count, source: data.source });
+    }
+    log.d("HOTSPOTS", "preloaded_change_frequencies", {
+      entities: entities.length,
+      prollyAvailable: prollyDataAvailable,
+      withChanges: [...entityChangeCount.values()].filter((v) => v.count > 0).length
+    });
+  }
+  /**
+   * Get change frequency from Git log (fallback when Prolly data unavailable).
+   */
+  getChangeFrequencyFromGit(filePath, lookbackDays) {
+    try {
+      const since = new Date(Date.now() - lookbackDays * 24 * 60 * 60 * 1e3).toISOString().split("T")[0];
+      const output = execSync(`git log --oneline --since="${since}" -- "${filePath}"`, {
+        encoding: "utf-8",
+        timeout: 5e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const lines = output.trim().split("\n").filter(Boolean);
+      return lines.length;
+    } catch {
+      return 0;
+    }
+  }
+  calculateHotspotScore(entity, metric, includeHistoricalMetrics) {
+    const metrics = entity.metadata?.["metrics"] || {};
+    let score = 0;
+    let changeMetrics;
+    const linesOfCode = metrics.linesOfCode || (entity.location?.end?.line && entity.location?.start?.line ? entity.location.end.line - entity.location.start.line + 1 : 0);
+    if (metric === "complexity" || metric === "all") {
+      score += (metrics.cyclomaticComplexity || 0) * 2;
+      score += (metrics.cognitiveComplexity || 0) * 1.5;
+      score += (metrics.nestingDepth || 0) * 3;
+      score += linesOfCode / 50;
+      const paramCount = metrics.parameterCount || 0;
+      score += paramCount > 4 ? (paramCount - 4) * 2 : 0;
+    }
+    if (metric === "changes" || metric === "all") {
+      if (includeHistoricalMetrics) {
+        const cached = this.changeFrequencyCache.get(entity.id);
+        if (cached && cached.changeCount > 0) {
+          const changeScore = Math.log(cached.changeCount + 1) * 10;
+          score += changeScore;
+          changeMetrics = {
+            changeFrequency: cached.changeCount,
+            changeFrequencyScore: Math.round(changeScore * 100) / 100,
+            changeSource: cached.source
+          };
+        } else {
+          changeMetrics = {
+            changeFrequency: 0,
+            changeFrequencyScore: 0,
+            changeSource: "none"
+          };
+        }
+      } else {
+        score += (metrics.changeFrequency || 0) * 10;
+      }
+    }
+    if (metric === "coupling" || metric === "all") {
+      score += metrics.couplingScore || 0;
+      score += (metrics.dependencyCount || 0) / 5;
+    }
+    return { score, changeMetrics };
+  }
+};
+var FindRelatedConceptsSchema = z.object({
+  entityId: z.string().describe("Entity ID to find related concepts for"),
+  projectPath: projectPathParam,
+  offset: z.number().optional().default(0),
+  limit: z.number().optional().default(SAFE_LIMITS.searchResults)
+});
+var FindRelatedConceptsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return FindRelatedConceptsSchema.parse(args);
+  }
+  async execute(args) {
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const semanticAgent = await this.context.getSemanticAgent();
+    const safeLimit = Math.min(args.limit, MAX_PAGE_SIZE);
+    const entity = await storage.getEntity(args.entityId);
+    if (!entity) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: `Entity not found: ${args.entityId}` }) }]
+      };
+    }
+    const concept = entity.name;
+    const searchResult = await semanticAgent.semanticSearch(concept, 500);
+    const allRelated = searchResult.results || [];
+    const paginatedResult = paginate(allRelated, args.offset, safeLimit);
+    const enrichedRelated = await Promise.all(
+      paginatedResult.data.map(async (r) => {
+        try {
+          let ent = null;
+          const meta = r.metadata;
+          const metaEntityId = meta?.["entityId"];
+          if (metaEntityId && /^[0-9a-f]{12}$/.test(metaEntityId)) {
+            ent = await storage.getEntity(metaEntityId);
+          }
+          if (!ent && typeof r.id === "string" && r.id.startsWith("ent:")) {
+            const idPart = r.id.slice(4);
+            if (/^[0-9a-f]{12}$/.test(idPart)) {
+              ent = await storage.getEntity(idPart);
+            }
+          }
+          if (!ent) {
+            const compositeId = metaEntityId ?? (typeof r.id === "string" && r.id.startsWith("ent:") ? r.id.slice(4) : void 0);
+            if (compositeId && compositeId.includes(":")) {
+              const lastColon = compositeId.lastIndexOf(":");
+              const entityName = compositeId.slice(lastColon + 1);
+              if (entityName) {
+                const found = await storage.searchEntities({ namePattern: entityName });
+                ent = found.find((e) => e.metadata?.["communityId"] != null || e.metadata?.["pageRank"] != null) ?? found[0] ?? null;
+              }
+            }
+          }
+          if (!ent) return r;
+          const entMeta = ent.metadata ?? {};
+          const communityId = entMeta["communityId"];
+          const pageRank = entMeta["pageRank"];
+          if (communityId != null || pageRank != null) {
+            return {
+              ...r,
+              ...communityId != null ? { communityId } : {},
+              ...typeof pageRank === "number" ? { pageRank: Math.round(pageRank * 1e4) / 1e4 } : {}
+            };
+          }
+        } catch {
+        }
+        return r;
+      })
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              entityId: args.entityId,
+              concept,
+              relatedCount: enrichedRelated.length,
+              pagination: paginatedResult.pagination,
+              related: enrichedRelated
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var AnalyzeStateChaosSchema = z.object({
+  projectPath: projectPathParam,
+  scope: z.enum(["file", "module", "project"]).optional().default("project"),
+  stateIdentifiers: z.array(z.string()).optional(),
+  autoDetect: z.boolean().optional().default(true),
+  maxDepth: z.number().optional(),
+  excludePatterns: z.array(z.string()).optional(),
+  format: z.enum(["summary", "detailed", "json"]).optional().default("summary")
+});
+var AnalyzeStateChaosToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AnalyzeStateChaosSchema.parse(args);
+  }
+  async execute(args) {
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const { ChaosAnalyzer } = await import('./chaos-VM2PXERO.js');
+    const analyzer = new ChaosAnalyzer(storage);
+    const results = await analyzer.analyze({
+      scope: args.scope || "project",
+      stateIdentifiers: args.stateIdentifiers,
+      autoDetect: args.autoDetect ?? true,
+      maxDepth: args.maxDepth,
+      excludePatterns: args.excludePatterns
+    });
+    const graphContext = [];
+    for (const r of results) {
+      const identifier = r.statePattern.identifier;
+      if (!identifier) continue;
+      try {
+        const entities = await storage.searchEntities({ namePattern: identifier });
+        let pr = null;
+        let cid = null;
+        for (const ent of entities) {
+          const meta = ent.metadata ?? {};
+          if (meta["communityId"] != null || meta["pageRank"] != null) {
+            pr = meta["pageRank"];
+            cid = meta["communityId"];
+            break;
+          }
+        }
+        if (entities.length > 0) {
+          graphContext.push({
+            stateIdentifier: identifier,
+            pageRank: typeof pr === "number" ? pr : null,
+            communityId: typeof cid === "number" ? cid : null,
+            communityRisk: typeof pr === "number" && pr > 0.7 ? "high" : typeof pr === "number" && pr > 0.4 ? "medium" : "low"
+          });
+        }
+      } catch {
+      }
+    }
+    const chaosNextSteps = [
+      "graph_metrics({metric:'louvain'}) \u2014 cluster chaotic modules by community",
+      "graph_metrics({metric:'pagerank'}) \u2014 assess architectural importance of chaotic entities"
+    ];
+    if (args.format === "json") {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                statePatterns: results,
+                csharpPatterns: analyzer.csharpPatterns,
+                graphContext,
+                nextSteps: chaosNextSteps
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    if (args.format === "detailed" && (results.length > 0 || analyzer.csharpPatterns.length > 0)) {
+      const parts = [];
+      if (results.length > 0) {
+        parts.push(results.map((r) => analyzer.formatDetailed(r)).join("\n\n---\n\n"));
+      }
+      if (analyzer.csharpPatterns.length > 0 && results.length === 0) {
+        parts.push(analyzer.formatForAI(results));
+      }
+      return {
+        content: [{ type: "text", text: parts.join("\n\n") }]
+      };
+    }
+    const text = analyzer.formatForAI(results);
+    const nextStepsText = `
+
+---
+Next steps:
+${chaosNextSteps.map((s) => `- ${s}`).join("\n")}`;
+    return {
+      content: [{ type: "text", text: text + nextStepsText }]
+    };
+  }
+};
+var AnalyzeCodeImpactSchema = z.object({
+  entityId: z.string().optional(),
+  filePath: z.string().optional(),
+  projectPath: projectPathParam,
+  depth: z.number().optional().default(3),
+  highlightRecentChanges: z.boolean().optional().default(false).describe("Annotate impacted entities with recently-changed status (Prolly Tree)"),
+  recentCommitsCount: z.number().optional().default(10).describe("Number of recent commits to consider for highlighting")
+});
+var AnalyzeCodeImpactToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AnalyzeCodeImpactSchema.parse(args);
+  }
+  async execute(args) {
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    let entityId = args.entityId;
+    if (entityId) {
+      const directEntity = await storage.getEntity(entityId);
+      if (!directEntity) {
+        const byName = await storage.searchEntities({ namePattern: entityId });
+        if (byName.length > 0) {
+          if (args.filePath) {
+            const normalizedPath = this.context.normalizeInputPath(args.filePath);
+            const normalizedFilter = (normalizedPath || "").replace(/\\/g, "/").toLowerCase();
+            const inFile = byName.find((e) => {
+              const ep = (e.filePath || "").replace(/\\/g, "/").toLowerCase();
+              return ep.includes(normalizedFilter) || ep.endsWith(normalizedFilter);
+            });
+            if (inFile) entityId = inFile.id;
+            else entityId = byName[0].id;
+          } else {
+            entityId = byName[0].id;
+          }
+        } else {
+          entityId = void 0;
+        }
+      }
+    }
+    if (!entityId && args.filePath) {
+      const normalizedPath = this.context.normalizeInputPath(args.filePath);
+      const entities = await storage.findEntities({
+        filters: { filePath: normalizedPath },
+        limit: 1
+      });
+      if (entities.length > 0 && entities[0]) {
+        entityId = entities[0].id;
+      }
+    }
+    if (!entityId) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Entity not found" }) }]
+      };
+    }
+    const entity = await storage.getEntity(entityId);
+    const relationships = await storage.getRelationshipsForEntity(entityId);
+    const impactedEntities = /* @__PURE__ */ new Set();
+    let frontier = [entityId];
+    let currentDepth = 0;
+    while (frontier.length > 0 && currentDepth < args.depth) {
+      const nextFrontier = [];
+      for (const current of frontier) {
+        const rels = await storage.getRelationshipsForEntity(current);
+        for (const rel of rels) {
+          const targetId = rel.fromId === current ? rel.toId : rel.fromId;
+          if (!impactedEntities.has(targetId) && targetId !== entityId) {
+            impactedEntities.add(targetId);
+            nextFrontier.push(targetId);
+          }
+        }
+      }
+      frontier = nextFrontier;
+      currentDepth++;
+    }
+    let contractImpact;
+    {
+      const impactedIds = Array.from(impactedEntities);
+      const impactedBatch = await storage.getEntitiesBatch(impactedIds);
+      const affectedEndpoints = [];
+      const affectedSchemas = [];
+      const consumers = [];
+      for (const [, impEntity] of impactedBatch) {
+        if (impEntity.metadata?.["isApiContract"]) {
+          const swaggerType = impEntity.metadata["swaggerType"];
+          if (swaggerType === "endpoint") {
+            const sig = `${impEntity.metadata["httpMethod"] || ""} ${impEntity.metadata["path"] || ""}`.trim();
+            affectedEndpoints.push(sig || impEntity.name);
+          } else if (swaggerType === "schema") {
+            affectedSchemas.push(impEntity.name);
+          }
+        }
+      }
+      if (entity?.metadata?.["isApiContract"]) {
+        const swaggerType = entity.metadata["swaggerType"];
+        if (swaggerType === "endpoint") {
+          const sig = `${entity.metadata["httpMethod"] || ""} ${entity.metadata["path"] || ""}`.trim();
+          affectedEndpoints.push(sig || entity.name);
+        } else if (swaggerType === "schema") {
+          affectedSchemas.push(entity.name);
+        }
+      }
+      for (const rel of relationships) {
+        if (rel.type === "consumes_api" || rel.metadata?.context?.includes("consumes")) {
+          const consumerId = rel.fromId === entityId ? rel.toId : rel.fromId;
+          const consumer = impactedBatch.get(consumerId);
+          if (consumer) {
+            consumers.push(consumer.name);
+          }
+        }
+      }
+      if (affectedEndpoints.length > 0 || affectedSchemas.length > 0) {
+        const risk = affectedEndpoints.length > 3 || affectedSchemas.length > 5 ? "high" : affectedEndpoints.length > 0 ? "medium" : "low";
+        contractImpact = {
+          affectsApiContract: true,
+          affectedEndpoints: [...new Set(affectedEndpoints)],
+          affectedSchemas: [...new Set(affectedSchemas)],
+          breakingChangeRisk: risk,
+          consumers: [...new Set(consumers)],
+          warning: "Changes affect external API contract \u2014 consumers may break"
+        };
+      }
+    }
+    let recentlyChangedImpact;
+    if (args.highlightRecentChanges) {
+      const { getRecentlyChangedEntities } = await import('./recently-changed-FX5QR4Z2.js');
+      const adapter = storage.getLibSQLAdapter?.();
+      if (adapter) {
+        const recentlyChanged = await getRecentlyChangedEntities(adapter, {
+          lastCommits: args.recentCommitsCount
+        });
+        if (recentlyChanged) {
+          let recentlyAddedCount = 0;
+          let recentlyModifiedCount = 0;
+          for (const id of impactedEntities) {
+            if (recentlyChanged.addedIds.has(id)) recentlyAddedCount++;
+            else if (recentlyChanged.modifiedIds.has(id)) recentlyModifiedCount++;
+          }
+          const totalRecent = recentlyAddedCount + recentlyModifiedCount;
+          recentlyChangedImpact = {
+            recentlyAddedCount,
+            recentlyModifiedCount,
+            volatileRatio: impactedEntities.size > 0 ? Math.round(totalRecent / impactedEntities.size * 100) / 100 : 0,
+            commitsAnalyzed: recentlyChanged.commitsAnalyzed
+          };
+        }
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              entity: entity ? { id: entity.id, name: entity.name, type: entity.type } : null,
+              directRelationships: relationships.length,
+              totalImpactedEntities: impactedEntities.size,
+              impactDepth: args.depth,
+              riskLevel: impactedEntities.size > 50 ? "high" : impactedEntities.size > 20 ? "medium" : "low",
+              ...contractImpact ? { contractImpact } : {},
+              ...recentlyChangedImpact ? { recentlyChangedImpact } : {},
+              nextSteps: [
+                "graph_metrics({metric:'pagerank'}) \u2014 assess importance of impacted entities",
+                "taint_analysis() \u2014 check if impacted code has security vulnerabilities"
+              ]
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var AnalyzeSwaggerImpactSchema = z.object({
+  projectPath: projectPathParam,
+  swaggerFile: z.string().optional().describe("Path to swagger file (auto-detected if omitted)"),
+  schemaName: z.string().optional().describe("Specific schema name to analyze"),
+  endpointPath: z.string().optional().describe("Specific endpoint like 'GET /api/users'")
+});
+var AnalyzeSwaggerImpactToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AnalyzeSwaggerImpactSchema.parse(args);
+  }
+  async execute(args) {
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const allEntities = await storage.getAllEntities();
+    const allRelationships = await storage.getAllRelationships();
+    let swaggerEntities = allEntities.filter((e) => e.metadata?.["isApiContract"]);
+    if (swaggerEntities.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "No swagger/OpenAPI specifications found in the project graph. Index a project with swagger files first."
+            })
+          }
+        ]
+      };
+    }
+    if (args.swaggerFile) {
+      const normalizedPath = this.context.normalizeInputPath(args.swaggerFile);
+      swaggerEntities = swaggerEntities.filter(
+        (e) => e.filePath.replace(/\\/g, "/").toLowerCase().includes((normalizedPath || "").replace(/\\/g, "/").toLowerCase())
+      );
+    }
+    if (args.schemaName) {
+      swaggerEntities = swaggerEntities.filter(
+        (e) => e.metadata?.["swaggerType"] === "schema" && e.name === args.schemaName
+      );
+    }
+    if (args.endpointPath) {
+      const [method, ...pathParts] = args.endpointPath.split(" ");
+      const path = pathParts.join(" ");
+      swaggerEntities = swaggerEntities.filter((e) => {
+        if (e.metadata?.["swaggerType"] !== "endpoint") return false;
+        const entityMethod = (e.metadata["httpMethod"] || "").toUpperCase();
+        const entityPath = e.metadata["path"] || "";
+        return (!method || entityMethod === method.toUpperCase()) && (!path || entityPath === path);
+      });
+    }
+    const producers = [];
+    const consumers = [];
+    const generatedTypes = [];
+    const swaggerEntityIds = new Set(swaggerEntities.map((e) => e.id));
+    const entityMap = new Map(allEntities.map((e) => [e.id, e]));
+    for (const rel of allRelationships) {
+      if (rel.type === "produces_api") {
+        const from = entityMap.get(rel.fromId);
+        const to = entityMap.get(rel.toId);
+        if (from && to && (swaggerEntityIds.has(rel.toId) || swaggerEntityIds.has(rel.fromId))) {
+          producers.push({ name: from.name, file: from.filePath, type: from.type });
+        }
+      } else if (rel.type === "consumes_api") {
+        const from = entityMap.get(rel.fromId);
+        const to = entityMap.get(rel.toId);
+        if (from && to && (swaggerEntityIds.has(rel.toId) || swaggerEntityIds.has(rel.fromId))) {
+          consumers.push({ name: from.name, file: from.filePath, type: from.type });
+        }
+      } else if (rel.type === "generated_from") {
+        const from = entityMap.get(rel.fromId);
+        const to = entityMap.get(rel.toId);
+        if (from && to && (swaggerEntityIds.has(rel.toId) || swaggerEntityIds.has(rel.fromId))) {
+          generatedTypes.push({
+            name: from.name,
+            file: from.filePath,
+            schemaName: to.name
+          });
+        }
+      }
+    }
+    const totalAffected = producers.length + consumers.length + generatedTypes.length;
+    const breakingChangeRisk = totalAffected > 10 ? "high" : totalAffected > 3 ? "medium" : "low";
+    const recommendations = [];
+    if (consumers.length > 0) {
+      recommendations.push(`${consumers.length} generated client(s) may need regeneration after swagger changes`);
+    }
+    if (generatedTypes.length > 0) {
+      recommendations.push(
+        `${generatedTypes.length} generated type(s) are linked to swagger schemas \u2014 regenerate after schema changes`
+      );
+    }
+    if (producers.length > 0) {
+      recommendations.push(
+        `${producers.length} controller(s) produce this API \u2014 update swagger spec after changing these`
+      );
+    }
+    const endpoints = swaggerEntities.filter((e) => e.metadata?.["swaggerType"] === "endpoint").map((e) => ({
+      name: e.name,
+      method: e.metadata?.["httpMethod"],
+      path: e.metadata?.["path"]
+    }));
+    const schemas = swaggerEntities.filter((e) => e.metadata?.["swaggerType"] === "schema").map((e) => e.name);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              swaggerFiles: [...new Set(swaggerEntities.map((e) => e.filePath))],
+              endpoints,
+              schemas,
+              producers,
+              consumers,
+              generatedTypes,
+              breakingChangeRisk,
+              totalAffectedEntities: totalAffected,
+              recommendations
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var DetectTechnologyStackSchema = z.object({
+  directory: z.string().optional(),
+  projectPath: projectPathParam
+});
+var DetectTechnologyStackToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return DetectTechnologyStackSchema.parse(args);
+  }
+  async execute(args) {
+    const targetDir = args.directory ? this.context.normalizeInputPath(args.directory) ?? this.resolveProjectPath({}) : this.resolveProjectPath({ projectPath: args.projectPath });
+    try {
+      const { TechnologyDetector } = await import('./technology-detector-ACNN7RLQ.js');
+      const graphStorage = await this.context.getGraphStorage();
+      graphStorage.setProject(targetDir);
+      const detector = new TechnologyDetector(graphStorage, targetDir);
+      const stack = await detector.detectStack();
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                directory: targetDir,
+                languages: stack.languages,
+                frameworks: stack.frameworks,
+                buildTools: stack.buildTools,
+                dependencies: stack.dependencies,
+                confidence: stack.confidence
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+
+export { AnalyzeCodeImpactToolHandler, AnalyzeHotspotsToolHandler, AnalyzeStateChaosToolHandler, AnalyzeSwaggerImpactToolHandler, DetectTechnologyStackToolHandler, FindRelatedConceptsToolHandler, SuggestRefactoringToolHandler };
+//# sourceMappingURL=analysis-tool-handlers-H2RXLDPX.js.map
+//# sourceMappingURL=analysis-tool-handlers-H2RXLDPX.js.map