ultracode 5.4.0 → 5.6.0

package/dist/chunks/file-tool-handlers-V4SFUDQB.js

@@ -0,0 +1,1027 @@
+import { projectPathParam } from './chunk-NJUB245U.js';
+import { BaseToolHandler } from './chunk-VS44D772.js';
+import './chunk-TUWE6FCW.js';
+import './chunk-CTXFPNDA.js';
+import './chunk-TJSOOFXA.js';
+import './chunk-TVOTA7EE.js';
+import './chunk-HEMJHRHZ.js';
+import { toError } from './chunk-5WKPA33T.js';
+import './chunk-GMVGCSNU.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+import { z } from 'zod';
+
+// src/tools/impact-analyzer.ts
+var ImpactAnalyzer = class {
+  storage;
+  semanticSearch;
+  constructor(storage, semanticSearch) {
+    this.storage = storage;
+    this.semanticSearch = semanticSearch;
+  }
+  /**
+   * Analyze the impact of modifying an entity
+   */
+  async analyzeModificationImpact(entityId, options = {}) {
+    const { maxCallerDepth = 2, analyzeStates = true, minConfidence = 0.5 } = options;
+    const entity = await this.storage.getEntity(entityId);
+    if (!entity) {
+      return this.emptyResult("Entity not found");
+    }
+    const directCallers = await this.findDirectCallers(entityId, maxCallerDepth);
+    const stateImpact = analyzeStates ? await this.analyzeStateImpact(entity) : [];
+    const breakingChanges = await this.detectBreakingChanges(entity, directCallers);
+    const reviewSuggestions = this.generateReviewSuggestions(entity, directCallers, stateImpact);
+    const confidence = this.calculateConfidence(directCallers.length, stateImpact.length);
+    if (confidence < minConfidence) {
+      return this.emptyResult("Insufficient data for reliable analysis");
+    }
+    const summary = this.generateSummary(entity, directCallers, stateImpact, breakingChanges);
+    return {
+      analyzed: true,
+      directCallers,
+      stateImpact,
+      breakingChanges,
+      reviewSuggestions,
+      summary,
+      confidence
+    };
+  }
+  /**
+   * Analyze impact of creating a new file
+   */
+  async analyzeNewFileImpact(filePath, entityNames) {
+    const similarCode = [];
+    if (this.semanticSearch) {
+      for (const name of entityNames.slice(0, 3)) {
+        try {
+          const results = await this.semanticSearch.search(name, {
+            limit: 3,
+            minSimilarity: 0.7
+          });
+          for (const result of results) {
+            const entity = await this.storage.getEntity(result.entityId);
+            if (entity && entity.filePath !== filePath) {
+              similarCode.push({
+                name: entity.name,
+                file: entity.filePath,
+                similarity: result.similarity
+              });
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    const reviewSuggestions = [];
+    if (similarCode.length > 0) {
+      reviewSuggestions.push(`Found ${similarCode.length} similar entities - consider reusing existing code`);
+      for (const s of similarCode.slice(0, 3)) {
+        reviewSuggestions.push(`  \u2022 ${s.name} in ${s.file} (${Math.round(s.similarity * 100)}% similar)`);
+      }
+    }
+    return {
+      analyzed: similarCode.length > 0,
+      directCallers: [],
+      stateImpact: [],
+      breakingChanges: [],
+      reviewSuggestions,
+      summary: similarCode.length > 0 ? `\u26A0\uFE0F Similar code exists: ${similarCode.map((s) => s.name).join(", ")}` : "",
+      confidence: similarCode.length > 0 ? 0.7 : 0
+    };
+  }
+  /**
+   * Analyze impact of renaming a symbol
+   */
+  async analyzeRenameImpact(entityId, oldName, newName) {
+    const entity = await this.storage.getEntity(entityId);
+    if (!entity) {
+      return this.emptyResult("Entity not found");
+    }
+    const references = await this.findAllReferences(entityId);
+    const affectedFiles = new Set(references.map((r) => r.file));
+    const breakingChanges = [];
+    const conflicts = await this.storage.searchEntities({ namePattern: newName });
+    if (conflicts.length > 0) {
+      breakingChanges.push({
+        description: `Name "${newName}" already exists in ${conflicts.length} place(s)`,
+        location: conflicts[0].filePath,
+        severity: "warning"
+      });
+    }
+    const reviewSuggestions = [`Rename will affect ${references.length} reference(s) in ${affectedFiles.size} file(s)`];
+    if (references.length > 10) {
+      reviewSuggestions.push("\u26A0\uFE0F Large refactoring - consider reviewing changes before applying");
+    }
+    return {
+      analyzed: true,
+      directCallers: references,
+      stateImpact: [],
+      breakingChanges,
+      reviewSuggestions,
+      summary: `Renaming ${oldName} \u2192 ${newName} affects ${references.length} references`,
+      confidence: 0.9
+    };
+  }
+  /**
+   * Detect if a modification breaks swagger API contracts.
+   * Checks if the entity has PRODUCES_API relationships and analyzes the change.
+   */
+  async detectSwaggerContractBreaks(entityId) {
+    const result = {
+      affectsContract: false,
+      contractBreaks: [],
+      isGeneratedCode: false,
+      generatedFromSwagger: null
+    };
+    const entity = await this.storage.getEntity(entityId);
+    if (!entity) return result;
+    const relationships = await this.storage.getRelationshipsForEntity(entityId);
+    for (const rel of relationships) {
+      if (rel.type === "produces_api" /* PRODUCES_API */ && rel.fromId === entityId) {
+        result.affectsContract = true;
+        const swaggerEntity = await this.storage.getEntity(rel.toId);
+        if (swaggerEntity) {
+          const endpoint = `${swaggerEntity.metadata?.["httpMethod"] || ""} ${swaggerEntity.metadata?.["path"] || ""}`.trim();
+          result.contractBreaks.push({
+            rule: "controller-modified",
+            change: "unknown",
+            endpoint: endpoint || swaggerEntity.name,
+            message: `API contract may be affected: controller produces ${endpoint || swaggerEntity.name}`
+          });
+        }
+      }
+      if (rel.type === "generated_from" /* GENERATED_FROM */ && rel.fromId === entityId) {
+        result.isGeneratedCode = true;
+        const swaggerEntity = await this.storage.getEntity(rel.toId);
+        result.generatedFromSwagger = swaggerEntity?.filePath || null;
+      }
+      if (rel.type === "consumes_api" /* CONSUMES_API */ && rel.fromId === entityId) {
+        result.isGeneratedCode = true;
+        const swaggerEntity = await this.storage.getEntity(rel.toId);
+        result.generatedFromSwagger = swaggerEntity?.filePath || null;
+      }
+    }
+    return result;
+  }
+  // ===========================================================================
+  // PRIVATE HELPERS
+  // ===========================================================================
+  async findDirectCallers(entityId, maxDepth) {
+    const callers = [];
+    const visited = /* @__PURE__ */ new Set();
+    const findCallers = async (id, depth) => {
+      if (depth > maxDepth || visited.has(id)) return;
+      visited.add(id);
+      const rels = await this.storage.getRelationshipsForEntity(id, "calls" /* CALLS */);
+      for (const rel of rels) {
+        if (rel.toId === id && !visited.has(rel.fromId)) {
+          const caller = await this.storage.getEntity(rel.fromId);
+          if (caller) {
+            callers.push({
+              name: caller.name,
+              file: caller.filePath,
+              line: caller.location.start.line
+            });
+            if (depth < maxDepth) {
+              await findCallers(rel.fromId, depth + 1);
+            }
+          }
+        }
+      }
+    };
+    await findCallers(entityId, 0);
+    return callers;
+  }
+  async findAllReferences(entityId) {
+    const refs = [];
+    const rels = await this.storage.getRelationshipsForEntity(entityId);
+    for (const rel of rels) {
+      const otherId = rel.fromId === entityId ? rel.toId : rel.fromId;
+      const other = await this.storage.getEntity(otherId);
+      if (other) {
+        refs.push({
+          name: other.name,
+          file: other.filePath,
+          line: other.location.start.line
+        });
+      }
+    }
+    return refs;
+  }
+  async analyzeStateImpact(entity) {
+    const impact = [];
+    const meta = entity.metadata;
+    const modifiedStates = Array.isArray(meta["stateModifications"]) ? meta["stateModifications"] : [];
+    for (const state of modifiedStates) {
+      const allEntities = await this.storage.getAllEntities();
+      const affected = [];
+      for (const e of allEntities) {
+        if (e.id === entity.id) continue;
+        const eMeta = e.metadata;
+        const reads = Array.isArray(eMeta["stateReads"]) ? eMeta["stateReads"] : [];
+        if (reads.includes(state)) {
+          affected.push(e.name);
+        }
+        if (eMeta["controlFlow"]?.branches && Array.isArray(eMeta["controlFlow"].branches)) {
+          for (const branch of eMeta["controlFlow"].branches) {
+            if (branch.condition?.includes(state)) {
+              if (!affected.includes(e.name)) {
+                affected.push(e.name);
+              }
+            }
+          }
+        }
+      }
+      if (affected.length > 0) {
+        impact.push({
+          state,
+          affectedEntities: affected.slice(0, 10),
+          // Limit to 10
+          risk: affected.length > 5 ? "high" : affected.length > 2 ? "medium" : "low"
+        });
+      }
+    }
+    return impact;
+  }
+  async detectBreakingChanges(entity, callers) {
+    const changes = [];
+    const meta = entity.metadata;
+    const isExported = meta["exported"] === true || entity.name.startsWith("export");
+    if (isExported && callers.length > 3) {
+      changes.push({
+        description: `Exported entity with ${callers.length} callers - signature changes may break consumers`,
+        location: `${entity.filePath}:${entity.location.start.line}`,
+        severity: "warning"
+      });
+    }
+    const params = Array.isArray(meta["parameters"]) ? meta["parameters"] : [];
+    if (params.length > 0 && callers.length > 0) {
+      changes.push({
+        description: `Function has ${params.length} parameters - changes may require updating ${callers.length} call sites`,
+        location: `${entity.filePath}:${entity.location.start.line}`,
+        severity: "warning"
+      });
+    }
+    return changes;
+  }
+  generateReviewSuggestions(_entity, callers, stateImpact) {
+    const suggestions = [];
+    if (callers.length > 0) {
+      const uniqueFiles = new Set(callers.map((c) => c.file));
+      suggestions.push(`\u{1F4CD} Review ${callers.length} caller(s) in ${uniqueFiles.size} file(s)`);
+      for (const caller of callers.slice(0, 3)) {
+        suggestions.push(`   \u2022 ${caller.name} (${caller.file}:${caller.line})`);
+      }
+      if (callers.length > 3) {
+        suggestions.push(`   ... and ${callers.length - 3} more`);
+      }
+    }
+    if (stateImpact.length > 0) {
+      const highRisk = stateImpact.filter((s) => s.risk === "high");
+      if (highRisk.length > 0) {
+        suggestions.push(`\u26A0\uFE0F High-risk state changes: ${highRisk.map((s) => s.state).join(", ")}`);
+      }
+      for (const impact of stateImpact.slice(0, 2)) {
+        suggestions.push(
+          `   State "${impact.state}" affects: ${impact.affectedEntities.slice(0, 3).join(", ")}${impact.affectedEntities.length > 3 ? "..." : ""}`
+        );
+      }
+    }
+    return suggestions;
+  }
+  generateSummary(entity, callers, stateImpact, breakingChanges) {
+    const parts = [];
+    if (callers.length === 0 && stateImpact.length === 0) {
+      return `\u2705 No significant impact detected for ${entity.name}`;
+    }
+    if (callers.length > 0) {
+      parts.push(`${callers.length} caller(s)`);
+    }
+    if (stateImpact.length > 0) {
+      const totalAffected = stateImpact.reduce((sum, s) => sum + s.affectedEntities.length, 0);
+      parts.push(`${totalAffected} state-dependent entities`);
+    }
+    if (breakingChanges.length > 0) {
+      parts.push(`${breakingChanges.length} potential breaking change(s)`);
+    }
+    const prefix = breakingChanges.length > 0 ? "\u26A0\uFE0F" : "\u2139\uFE0F";
+    return `${prefix} Modification of ${entity.name} may affect: ${parts.join(", ")}`;
+  }
+  calculateConfidence(callerCount, stateImpactCount) {
+    let confidence = 0.6;
+    if (callerCount > 0) confidence += 0.1;
+    if (callerCount > 5) confidence += 0.1;
+    if (stateImpactCount > 0) confidence += 0.1;
+    return Math.min(confidence, 1);
+  }
+  emptyResult(reason) {
+    return {
+      analyzed: false,
+      directCallers: [],
+      stateImpact: [],
+      breakingChanges: [],
+      reviewSuggestions: [],
+      summary: reason,
+      confidence: 0
+    };
+  }
+};
+function formatImpactForResponse(impact) {
+  if (!impact.analyzed || impact.confidence < 0.5) {
+    return null;
+  }
+  const lines = [];
+  lines.push("");
+  lines.push("\u2500\u2500\u2500 Impact Analysis \u2500\u2500\u2500");
+  lines.push(impact.summary);
+  if (impact.reviewSuggestions.length > 0) {
+    lines.push("");
+    for (const suggestion of impact.reviewSuggestions) {
+      lines.push(suggestion);
+    }
+  }
+  if (impact.breakingChanges.length > 0) {
+    lines.push("");
+    lines.push("\u26A0\uFE0F Potential Issues:");
+    for (const change of impact.breakingChanges) {
+      lines.push(`  ${change.severity === "error" ? "\u274C" : "\u26A0\uFE0F"} ${change.description}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/tools/handlers/file-tool-utils.ts
+async function setupSemanticSearch(context) {
+  try {
+    const semanticAgent = await context.getSemanticAgent();
+    const vectorStore = semanticAgent.getVectorStore?.();
+    if (!vectorStore) return void 0;
+    return {
+      search: async (query, options) => {
+        const results = await vectorStore.search(query, options.limit);
+        return results.filter((r) => r.similarity >= options.minSimilarity).map((r) => ({ entityId: r.entityId, similarity: r.similarity }));
+      }
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function reindexFiles(context, files, taskPrefix, priority = 5) {
+  const conductor = context.getConductor();
+  const devAgent = conductor.getAgentByType?.("dev" /* DEV */);
+  if (!devAgent) {
+    throw new Error("DevAgent not available for reindexing");
+  }
+  await devAgent.process({
+    id: `${taskPrefix}-${Date.now()}`,
+    type: "index",
+    priority,
+    payload: { files },
+    createdAt: Date.now()
+  });
+}
+function buildSuccessResponse(baseFields, optionalFields) {
+  const response = { ...baseFields };
+  return {
+    content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+  };
+}
+function buildErrorResponse(error, additionalFields) {
+  const message = typeof error === "string" ? error : error.message;
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ error: message, ...additionalFields })
+      }
+    ]
+  };
+}
+async function ensureDirectoryExists(filePath) {
+  const { dirname } = await import('path');
+  const { mkdir } = await import('fs/promises');
+  await mkdir(dirname(filePath), { recursive: true });
+}
+
+// src/tools/handlers/file-tool-handlers.ts
+var ModifyEntityCodeSchema = z.object({
+  entityId: z.string().optional(),
+  filePath: z.string().optional(),
+  entityName: z.string().optional(),
+  projectPath: projectPathParam,
+  newCode: z.string(),
+  preview: z.boolean().optional().default(false)
+});
+var ModifyEntityCodeToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return ModifyEntityCodeSchema.parse(args);
+  }
+  async execute(args) {
+    const { CodeModifier } = await import('./code-modifier-T5MXPBT7.js');
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const semanticSearch = await setupSemanticSearch(this.context);
+    let vectorStore = null;
+    try {
+      const semanticAgent = await this.context.getSemanticAgent();
+      vectorStore = semanticAgent.getVectorStore?.();
+    } catch {
+    }
+    const workingDir = this.resolveProjectPath({});
+    const modifier = new CodeModifier(storage, vectorStore, workingDir);
+    const impactAnalyzer = new ImpactAnalyzer(storage, semanticSearch);
+    let entityId = args.entityId;
+    if (!entityId && args.filePath) {
+      const normalizedPath = this.context.normalizeInputPath(args.filePath);
+      const entities = await storage.findEntities({
+        filters: { filePath: normalizedPath },
+        limit: 100
+      });
+      if (args.entityName) {
+        const match = entities.find((e) => e.name === args.entityName);
+        if (match) entityId = match.id;
+      } else if (entities.length === 1 && entities[0]) {
+        entityId = entities[0].id;
+      }
+    }
+    if (!entityId) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Entity not found" }) }]
+      };
+    }
+    try {
+      const [result, impactResult] = await Promise.all([
+        // Main operation: modify the entity
+        modifier.modifyEntity({
+          entityId,
+          newCode: args.newCode,
+          preview: args.preview
+        }),
+        // Parallel: analyze impact (only for actual modifications)
+        args.preview ? Promise.resolve(null) : impactAnalyzer.analyzeModificationImpact(entityId).catch(() => null)
+      ]);
+      const response = {
+        success: result.success,
+        preview: args.preview,
+        entityId,
+        filesModified: result.filesModified,
+        snapshotId: result.snapshotId
+      };
+      if (result.validationReport) {
+        const { before, after } = result.validationReport;
+        response["validation"] = {
+          before,
+          after,
+          improved: (after?.summary?.errors ?? 0) < (before?.summary?.errors ?? 0)
+        };
+      }
+      if (impactResult) {
+        const formattedImpact = formatImpactForResponse(impactResult);
+        if (formattedImpact) {
+          response["impactAnalysis"] = formattedImpact;
+        }
+      }
+      if (result.swaggerWarning) {
+        try {
+          const swaggerImpact = await impactAnalyzer.detectSwaggerContractBreaks(entityId);
+          response["swaggerImpact"] = {
+            affectsContract: swaggerImpact.affectsContract,
+            contractBreaks: swaggerImpact.contractBreaks,
+            isGeneratedCode: swaggerImpact.isGeneratedCode,
+            generatedFromSwagger: swaggerImpact.generatedFromSwagger,
+            warning: result.swaggerWarning
+          };
+        } catch {
+          response["swaggerImpact"] = {
+            affectsContract: true,
+            warning: result.swaggerWarning
+          };
+        }
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(response, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+var CopyFileSchema = z.object({
+  sourcePath: z.string(),
+  destinationPath: z.string(),
+  projectPath: projectPathParam,
+  updateImports: z.boolean().optional().default(true)
+});
+var CopyFileToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return CopyFileSchema.parse(args);
+  }
+  async execute(args) {
+    const { copyFile } = await import('fs/promises');
+    const sourcePath = this.context.normalizeInputPath(args.sourcePath) || args.sourcePath;
+    const destinationPath = this.context.normalizeInputPath(args.destinationPath) || args.destinationPath;
+    try {
+      await ensureDirectoryExists(destinationPath);
+      await copyFile(sourcePath, destinationPath);
+      await reindexFiles(this.context, [destinationPath], "copy-index");
+      return buildSuccessResponse({
+        success: true,
+        source: sourcePath,
+        destination: destinationPath,
+        indexed: true
+      });
+    } catch (error) {
+      const err = toError(error);
+      return buildErrorResponse(err);
+    }
+  }
+};
+var RenameFileSchema = z.object({
+  sourcePath: z.string(),
+  destinationPath: z.string(),
+  projectPath: projectPathParam,
+  updateImports: z.boolean().optional().default(true)
+});
+var RenameFileToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return RenameFileSchema.parse(args);
+  }
+  async execute(args) {
+    const { rename } = await import('fs/promises');
+    const sourcePath = this.context.normalizeInputPath(args.sourcePath) || args.sourcePath;
+    const destinationPath = this.context.normalizeInputPath(args.destinationPath) || args.destinationPath;
+    try {
+      await ensureDirectoryExists(destinationPath);
+      await rename(sourcePath, destinationPath);
+      const storage = await this.ensureGraphStorageForProject(args.projectPath);
+      const oldEntities = await storage.findEntities({
+        filters: { filePath: sourcePath },
+        limit: 1e3
+      });
+      for (const entity of oldEntities) {
+        await storage.deleteEntity(entity.id);
+      }
+      await reindexFiles(this.context, [destinationPath], "rename-index");
+      return buildSuccessResponse({
+        success: true,
+        source: sourcePath,
+        destination: destinationPath,
+        entitiesMoved: oldEntities.length,
+        importsUpdated: args.updateImports
+      });
+    } catch (error) {
+      const err = toError(error);
+      return buildErrorResponse(err);
+    }
+  }
+};
+var SplitFileSchema = z.object({
+  filePath: z.string(),
+  outputDirectory: z.string().optional(),
+  projectPath: projectPathParam,
+  splitBy: z.enum(["class", "function", "module"]).optional().default("class"),
+  preview: z.boolean().optional().default(true)
+});
+var SplitFileToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return SplitFileSchema.parse(args);
+  }
+  async execute(args) {
+    const { mkdir } = await import('fs/promises');
+    const { dirname, join, extname } = await import('path');
+    const filePath = this.context.normalizeInputPath(args.filePath) || args.filePath;
+    const outputDir = args.outputDirectory ? this.context.normalizeInputPath(args.outputDirectory) || args.outputDirectory : dirname(filePath);
+    try {
+      const storage = await this.ensureGraphStorageForProject(args.projectPath);
+      const entities = await storage.findEntities({
+        filters: { filePath },
+        limit: 1e3
+      });
+      const targetTypes = args.splitBy === "class" ? ["class", "interface", "enum"] : args.splitBy === "function" ? ["function", "method"] : ["module"];
+      const toSplit = entities.filter((e) => targetTypes.some((t) => e.type.toLowerCase().includes(t)));
+      if (toSplit.length <= 1) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                message: `Only ${toSplit.length} entity found, nothing to split`,
+                entities: toSplit.map((e) => e.name)
+              })
+            }
+          ]
+        };
+      }
+      const ext = extname(filePath);
+      const plannedFiles = toSplit.map((e) => ({
+        name: e.name,
+        type: e.type,
+        outputPath: join(outputDir, `${e.name}${ext}`)
+      }));
+      if (args.preview) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  preview: true,
+                  sourceFile: filePath,
+                  entitiesToSplit: toSplit.length,
+                  plannedFiles
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      await mkdir(outputDir, { recursive: true });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                sourceFile: filePath,
+                filesCreated: plannedFiles.length,
+                files: plannedFiles
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+var SynthesizeFilesSchema = z.object({
+  filePaths: z.array(z.string()),
+  outputPath: z.string(),
+  projectPath: projectPathParam,
+  preview: z.boolean().optional().default(true)
+});
+var SynthesizeFilesToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return SynthesizeFilesSchema.parse(args);
+  }
+  async execute(args) {
+    const { readText, writeFile } = await import('./file-ops-NCYUEOBU.js');
+    const filePaths = args.filePaths.map((p) => this.context.normalizeInputPath(p) || p);
+    const outputPath = this.context.normalizeInputPath(args.outputPath) || args.outputPath;
+    try {
+      const contents = await Promise.all(
+        filePaths.map(async (p) => ({
+          path: p,
+          content: await readText(p)
+        }))
+      );
+      const synthesized = contents.map((c) => `// ============= From: ${c.path} =============
+${c.content}`).join("\n\n");
+      if (args.preview) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  preview: true,
+                  inputFiles: filePaths.length,
+                  outputPath,
+                  combinedSize: synthesized.length,
+                  previewLines: synthesized.split("\n").slice(0, 20).join("\n") + "\n..."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      await ensureDirectoryExists(outputPath);
+      await writeFile(outputPath, synthesized);
+      await reindexFiles(this.context, [outputPath], "synthesize-index");
+      return buildSuccessResponse({
+        success: true,
+        inputFiles: filePaths.length,
+        outputPath,
+        indexed: true
+      });
+    } catch (error) {
+      const err = toError(error);
+      return buildErrorResponse(err);
+    }
+  }
+};
+var CreateFileSchema = z.object({
+  filePath: z.string(),
+  content: z.string(),
+  projectPath: projectPathParam,
+  overwrite: z.boolean().optional().default(false)
+});
+var CreateFileToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return CreateFileSchema.parse(args);
+  }
+  async execute(args) {
+    const { writeFile, existsSync } = await import('./file-ops-NCYUEOBU.js');
+    const filePath = this.context.normalizeInputPath(args.filePath) || args.filePath;
+    const semanticSearch = await setupSemanticSearch(this.context);
+    try {
+      if (!args.overwrite && existsSync(filePath)) {
+        return buildErrorResponse("File already exists", {
+          path: filePath,
+          hint: "Use overwrite: true to replace"
+        });
+      }
+      await ensureDirectoryExists(filePath);
+      await writeFile(filePath, args.content);
+      await reindexFiles(this.context, [filePath], "create-index");
+      const response = {
+        success: true,
+        path: filePath,
+        size: args.content.length,
+        indexed: true
+      };
+      if (semanticSearch) {
+        const storage = await this.ensureGraphStorageForProject(args.projectPath);
+        const impactAnalyzer = new ImpactAnalyzer(storage, semanticSearch);
+        try {
+          const newEntities = await storage.findEntities({
+            filters: { filePath },
+            limit: 10
+          });
+          const entityNames = newEntities.map((e) => e.name);
+          if (entityNames.length > 0) {
+            const impact = await impactAnalyzer.analyzeNewFileImpact(filePath, entityNames);
+            const formattedImpact = formatImpactForResponse(impact);
+            if (formattedImpact) {
+              response["impactAnalysis"] = formattedImpact;
+            }
+          }
+        } catch {
+        }
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(response, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+var RenameSymbolSchema = z.object({
+  entityId: z.string().optional(),
+  entityName: z.string().optional(),
+  projectPath: projectPathParam,
+  newName: z.string(),
+  preview: z.boolean().optional().default(true)
+});
+var RenameSymbolToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return RenameSymbolSchema.parse(args);
+  }
+  async execute(args) {
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const impactAnalyzer = new ImpactAnalyzer(storage);
+    let entity = null;
+    if (args.entityId) {
+      entity = await storage.getEntity(args.entityId);
+    } else if (args.entityName) {
+      const entities = await storage.findEntities({
+        filters: { name: args.entityName },
+        limit: 1
+      });
+      if (entities.length > 0 && entities[0]) entity = entities[0];
+    }
+    if (!entity) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Entity not found" }) }]
+      };
+    }
+    const [relationships, impactResult] = await Promise.all([
+      storage.getRelationshipsForEntity(entity.id),
+      impactAnalyzer.analyzeRenameImpact(entity.id, entity.name, args.newName).catch(() => null)
+    ]);
+    const references = relationships.filter(
+      (r) => r.type === "references" /* REFERENCES */ || r.type === "calls" /* CALLS */
+    );
+    const filesToUpdate = /* @__PURE__ */ new Set();
+    filesToUpdate.add(entity.filePath);
+    for (const ref of references) {
+      const refEntity = await storage.getEntity(ref.fromId === entity.id ? ref.toId : ref.fromId);
+      if (refEntity?.filePath) {
+        filesToUpdate.add(refEntity.filePath);
+      }
+    }
+    const impactInfo = impactResult ? formatImpactForResponse(impactResult) : null;
+    if (args.preview) {
+      const response = {
+        preview: true,
+        entity: {
+          id: entity.id,
+          name: entity.name,
+          type: entity.type,
+          filePath: entity.filePath
+        },
+        newName: args.newName,
+        referencesFound: references.length,
+        filesToUpdate: Array.from(filesToUpdate)
+      };
+      if (impactInfo) {
+        response["impactAnalysis"] = impactInfo;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(response, null, 2)
+          }
+        ]
+      };
+    }
+    try {
+      const { readText, writeFile } = await import('./file-ops-NCYUEOBU.js');
+      for (const fp of filesToUpdate) {
+        let content = await readText(fp);
+        const regex = new RegExp(`\\b${entity.name}\\b`, "g");
+        content = content.replace(regex, args.newName);
+        await writeFile(fp, content);
+      }
+      await storage.updateEntity(entity.id, { name: args.newName });
+      await reindexFiles(this.context, Array.from(filesToUpdate), "rename-reindex");
+      const response = {
+        success: true,
+        oldName: entity.name,
+        newName: args.newName,
+        filesUpdated: filesToUpdate.size,
+        referencesUpdated: references.length
+      };
+      if (impactInfo) {
+        response["impactAnalysis"] = impactInfo;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(response, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+var AddMemberSchema = z.object({
+  targetEntityId: z.string().optional(),
+  targetEntityName: z.string().optional(),
+  projectPath: projectPathParam,
+  memberCode: z.string(),
+  position: z.enum(["start", "end", "after"]).optional().default("end"),
+  afterMember: z.string().optional(),
+  preview: z.boolean().optional().default(true)
+});
+var AddMemberToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AddMemberSchema.parse(args);
+  }
+  async execute(args) {
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const impactAnalyzer = new ImpactAnalyzer(storage);
+    let entity = null;
+    if (args.targetEntityId) {
+      entity = await storage.getEntity(args.targetEntityId);
+    } else if (args.targetEntityName) {
+      const entities = await storage.findEntities({
+        filters: { name: args.targetEntityName },
+        limit: 1
+      });
+      if (entities.length > 0 && entities[0]) entity = entities[0];
+    }
+    if (!entity) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Target entity not found" }) }]
+      };
+    }
+    const validTypes = ["class", "interface", "struct", "enum", "module", "object"];
+    if (!validTypes.some((t) => entity.type.toLowerCase().includes(t))) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "Invalid target type",
+              entityType: entity.type,
+              hint: "Target must be a class, interface, struct, enum, or module"
+            })
+          }
+        ]
+      };
+    }
+    if (args.preview) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                preview: true,
+                target: {
+                  id: entity.id,
+                  name: entity.name,
+                  type: entity.type,
+                  filePath: entity.filePath
+                },
+                memberCode: args.memberCode,
+                position: args.position
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    try {
+      const { readText, writeFile } = await import('./file-ops-NCYUEOBU.js');
+      let content = await readText(entity.filePath);
+      const location = entity.location;
+      if (!location?.end?.line) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "Entity location not available" }) }]
+        };
+      }
+      const lines = content.split("\n");
+      const insertLine = location.end.line - 1;
+      const startLine = location.start?.line ? location.start.line - 1 : 0;
+      const entityIndent = lines[startLine]?.match(/^(\s*)/)?.[1] || "";
+      const memberIndent = entityIndent + "  ";
+      const indentedMember = args.memberCode.split("\n").map((line) => memberIndent + line).join("\n");
+      lines.splice(insertLine, 0, "", indentedMember);
+      content = lines.join("\n");
+      await writeFile(entity.filePath, content);
+      await reindexFiles(this.context, [entity.filePath], "add-member-index");
+      const response = {
+        success: true,
+        target: entity.name,
+        memberAdded: true,
+        filePath: entity.filePath,
+        indexed: true
+      };
+      try {
+        const impact = await impactAnalyzer.analyzeModificationImpact(entity.id);
+        const formattedImpact = formatImpactForResponse(impact);
+        if (formattedImpact) {
+          response["impactAnalysis"] = formattedImpact;
+        }
+      } catch {
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(response, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+
+export { AddMemberToolHandler, CopyFileToolHandler, CreateFileToolHandler, ModifyEntityCodeToolHandler, RenameFileToolHandler, RenameSymbolToolHandler, SplitFileToolHandler, SynthesizeFilesToolHandler };
+//# sourceMappingURL=file-tool-handlers-V4SFUDQB.js.map
+//# sourceMappingURL=file-tool-handlers-V4SFUDQB.js.map