ultracode 5.4.0 → 5.6.0

package/dist/chunks/history-tool-handlers-KCSCXZ7T.js

@@ -0,0 +1,208 @@
+import { GetEntityHistorySchema, DiffCommitsSchema, CheckoutCommitSchema, ListCommitsSchema } from './chunk-LVCP3H3F.js';
+import './chunk-NJUB245U.js';
+import { BaseToolHandler } from './chunk-SAMX3HJQ.js';
+import './chunk-WIE3G5ES.js';
+import './chunk-HNDYLCWI.js';
+import { TimeTravelManager, deserializeEntity } from './chunk-AIZUHUK6.js';
+import './chunk-XK2NY7RB.js';
+import './chunk-HEMJHRHZ.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+
+// src/tools/handlers/history-tool-handlers.ts
+init_logging();
+function errorResult(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }] };
+}
+var GetEntityHistoryToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return GetEntityHistorySchema.parse(args);
+  }
+  async execute(args) {
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const adapter = storage.getLibSQLAdapter?.();
+    if (!adapter?.getProllyNodeStore || !adapter?.getCommitManager) {
+      return errorResult("Prolly Tree not available - ensure project is indexed");
+    }
+    const nodeStore = adapter.getProllyNodeStore();
+    const commitManager = adapter.getCommitManager();
+    if (!nodeStore || !commitManager) {
+      return errorResult("Prolly Tree components not initialized");
+    }
+    const timeTravel = new TimeTravelManager(nodeStore, commitManager);
+    try {
+      const history = await timeTravel.getEntityHistory(args.entityId, args.limit);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                entityId: args.entityId,
+                changes: history.map((h) => ({
+                  commitHash: h.commitHash,
+                  changeType: h.changeType,
+                  timestamp: new Date(h.timestamp).toISOString(),
+                  entitySnapshot: h.newValue ? deserializeEntity(h.newValue) : null
+                })),
+                totalChanges: history.length
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      log.e("HISTORY", "get_entity_history_failed", { error: error.message });
+      return errorResult(`Failed to get entity history: ${error.message}`);
+    }
+  }
+};
+var DiffCommitsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return DiffCommitsSchema.parse(args);
+  }
+  async execute(args) {
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const adapter = storage.getLibSQLAdapter?.();
+    if (!adapter?.getProllyNodeStore || !adapter?.getCommitManager) {
+      return errorResult("Prolly Tree not available - ensure project is indexed");
+    }
+    const nodeStore = adapter.getProllyNodeStore();
+    const commitManager = adapter.getCommitManager();
+    if (!nodeStore || !commitManager) {
+      return errorResult("Prolly Tree components not initialized");
+    }
+    const timeTravel = new TimeTravelManager(nodeStore, commitManager);
+    try {
+      let commitB = args.commitB;
+      if (!commitB) {
+        const head = await commitManager.getBranchHead();
+        if (!head) return errorResult("No commits found - index the project first");
+        commitB = head.commitHash;
+      }
+      const diff = await timeTravel.diffCommits(args.commitA, commitB);
+      if (!diff) {
+        return errorResult(`Failed to diff commits: one or both commits not found`);
+      }
+      const result = {
+        commitA: args.commitA,
+        commitB,
+        summary: {
+          added: diff.treeDiff.added.length,
+          modified: diff.treeDiff.modified.length,
+          deleted: diff.treeDiff.deleted.length
+        }
+      };
+      if (args.includeEntities) {
+        result["added"] = diff.treeDiff.added.map((e) => ({ key: e.key }));
+        result["modified"] = diff.treeDiff.modified.map((e) => ({ key: e.key }));
+        result["deleted"] = diff.treeDiff.deleted.map((e) => ({ key: e.key }));
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (error) {
+      log.e("HISTORY", "diff_commits_failed", { error: error.message });
+      return errorResult(`Failed to diff commits: ${error.message}`);
+    }
+  }
+};
+var CheckoutCommitToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return CheckoutCommitSchema.parse(args);
+  }
+  async execute(args) {
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const adapter = storage.getLibSQLAdapter?.();
+    if (!adapter?.getProllyNodeStore || !adapter?.getCommitManager) {
+      return errorResult("Prolly Tree not available - ensure project is indexed");
+    }
+    const nodeStore = adapter.getProllyNodeStore();
+    const commitManager = adapter.getCommitManager();
+    if (!nodeStore || !commitManager) {
+      return errorResult("Prolly Tree components not initialized");
+    }
+    const timeTravel = new TimeTravelManager(nodeStore, commitManager);
+    try {
+      const commit = await commitManager.getCommit(args.commitHash);
+      if (!commit) {
+        return errorResult(`Commit not found: ${args.commitHash}`);
+      }
+      const result = {
+        commit: {
+          hash: commit.commitHash,
+          message: commit.message,
+          entityCount: commit.entityCount,
+          relationshipCount: commit.relationshipCount,
+          createdAt: new Date(commit.createdAt).toISOString(),
+          parentHash: commit.parentHash
+        }
+      };
+      if (args.entityId) {
+        const entity = await timeTravel.getEntityAt(args.entityId, args.commitHash);
+        result["entity"] = entity;
+      }
+      if (args.query) {
+        const entities = await timeTravel.searchEntitiesAt(args.commitHash, args.query, args.limit);
+        result["entities"] = entities.slice(args.offset, args.offset + args.limit);
+        result["totalMatches"] = entities.length;
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (error) {
+      log.e("HISTORY", "checkout_commit_failed", { error: error.message });
+      return errorResult(`Failed to checkout commit: ${error.message}`);
+    }
+  }
+};
+var ListCommitsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return ListCommitsSchema.parse(args);
+  }
+  async execute(args) {
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const adapter = storage.getLibSQLAdapter?.();
+    if (!adapter?.getCommitManager) {
+      return errorResult("Prolly Tree not available - ensure project is indexed");
+    }
+    const commitManager = adapter.getCommitManager();
+    if (!commitManager) {
+      return errorResult("Prolly Tree components not initialized");
+    }
+    try {
+      const history = await commitManager.getHistory(args.limit);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                commits: history.map((c) => ({
+                  hash: c.commitHash,
+                  message: c.message,
+                  entityCount: c.entityCount,
+                  relationshipCount: c.relationshipCount,
+                  createdAt: new Date(c.createdAt).toISOString(),
+                  parentHash: c.parentHash?.slice(0, 8) || null
+                })),
+                total: history.length
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      log.e("HISTORY", "list_commits_failed", { error: error.message });
+      return errorResult(`Failed to list commits: ${error.message}`);
+    }
+  }
+};
+
+export { CheckoutCommitToolHandler, DiffCommitsToolHandler, GetEntityHistoryToolHandler, ListCommitsToolHandler };
+//# sourceMappingURL=history-tool-handlers-KCSCXZ7T.js.map
+//# sourceMappingURL=history-tool-handlers-KCSCXZ7T.js.map

package/dist/chunks/incremental-updater-A2EL4QXU.js

@@ -0,0 +1,14 @@
+export { detectChanges, extractReferences, extractSections, markDeleted, mergeWithExisting, updateAllModuleDocs, updateModuleDoc, updateReferences } from './chunk-OEXPCY3F.js';
+import './chunk-KAYOX5EB.js';
+import './chunk-HNDYLCWI.js';
+import './chunk-CTXFPNDA.js';
+import './chunk-TJSOOFXA.js';
+import './chunk-AIZUHUK6.js';
+import './chunk-G6J42I55.js';
+import './chunk-TVOTA7EE.js';
+import './chunk-HEMJHRHZ.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-UN27MREV.js';
+import './chunk-NAQKA54E.js';
+//# sourceMappingURL=incremental-updater-A2EL4QXU.js.map
+//# sourceMappingURL=incremental-updater-A2EL4QXU.js.map

package/dist/chunks/incremental-updater-EQIKBVY2.js

@@ -0,0 +1,14 @@
+export { detectChanges, extractReferences, extractSections, markDeleted, mergeWithExisting, updateAllModuleDocs, updateModuleDoc, updateReferences } from './chunk-TR3HS7U6.js';
+import './chunk-Y4F7NZFZ.js';
+import './chunk-HNDYLCWI.js';
+import './chunk-CTXFPNDA.js';
+import './chunk-TJSOOFXA.js';
+import './chunk-AIZUHUK6.js';
+import './chunk-O6IE2MEZ.js';
+import './chunk-LH4OUKNZ.js';
+import './chunk-HEMJHRHZ.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-UN27MREV.js';
+import './chunk-NAQKA54E.js';
+//# sourceMappingURL=incremental-updater-EQIKBVY2.js.map
+//# sourceMappingURL=incremental-updater-EQIKBVY2.js.map

package/dist/chunks/incremental-updater-JFGRPH3B.js

@@ -0,0 +1,14 @@
+export { detectChanges, extractReferences, extractSections, markDeleted, mergeWithExisting, updateAllModuleDocs, updateModuleDoc, updateReferences } from './chunk-LEDJ7GVQ.js';
+import './chunk-J2WBGTK2.js';
+import './chunk-HNDYLCWI.js';
+import './chunk-CTXFPNDA.js';
+import './chunk-TJSOOFXA.js';
+import './chunk-AIZUHUK6.js';
+import './chunk-YS75L3ZS.js';
+import './chunk-XK2NY7RB.js';
+import './chunk-HEMJHRHZ.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-UN27MREV.js';
+import './chunk-NAQKA54E.js';
+//# sourceMappingURL=incremental-updater-JFGRPH3B.js.map
+//# sourceMappingURL=incremental-updater-JFGRPH3B.js.map

package/dist/chunks/incremental-updater-S5BAAGHP.js

@@ -0,0 +1 @@
+export{c as detectChanges,a as extractReferences,b as extractSections,f as markDeleted,e as mergeWithExisting,h as updateAllModuleDocs,g as updateModuleDoc,d as updateReferences}from'./chunk-4W6QYGXZ.js';import'./chunk-PY43JPWL.js';import'./chunk-RK5TLU72.js';import'./chunk-LESND2CW.js';import'./chunk-QUO46LUP.js';import'./chunk-3IFLFBQ4.js';import'./chunk-I6STSSAK.js';import'./chunk-SV3WKUNV.js';import'./chunk-PZF7YC35.js';import'./chunk-4BI7EBPQ.js';import'./chunk-F45ISXCP.js';import'./chunk-DXB73IDG.js';

package/dist/chunks/indexer-agent-ASKY7JPG.js

@@ -0,0 +1 @@
+export{a as IndexerAgent}from'./chunk-QIRZHZK2.js';import'./chunk-7YC4KTAW.js';import'./chunk-V5VLOVE7.js';import'./chunk-PY43JPWL.js';import'./chunk-RK5TLU72.js';import'./chunk-LESND2CW.js';import'./chunk-QUO46LUP.js';import'./chunk-3IFLFBQ4.js';import'./chunk-I6STSSAK.js';import'./chunk-SV3WKUNV.js';import'./chunk-PZF7YC35.js';import'./chunk-AIZJT6AG.js';import'./chunk-NWQZW3Y6.js';import'./chunk-KXUWGHHN.js';import'./chunk-2KIPXYOB.js';import'./chunk-OG62YNVF.js';import'./chunk-4BI7EBPQ.js';import'./chunk-F45ISXCP.js';import'./chunk-DXB73IDG.js';

package/dist/chunks/indexer-agent-NKAOF323.js

@@ -0,0 +1,21 @@
+export { IndexerAgent } from './chunk-PLPBXWOU.js';
+import './chunk-JPI46FLQ.js';
+import './chunk-IGUCJL3R.js';
+import './chunk-Y4F7NZFZ.js';
+import './chunk-HNDYLCWI.js';
+import './chunk-CTXFPNDA.js';
+import './chunk-TJSOOFXA.js';
+import './chunk-AIZUHUK6.js';
+import './chunk-O6IE2MEZ.js';
+import './chunk-LH4OUKNZ.js';
+import './chunk-HEMJHRHZ.js';
+import './chunk-IMQ6WSJV.js';
+import './chunk-GMVGCSNU.js';
+import './chunk-XV6GNSLC.js';
+import './chunk-F7CKCMXI.js';
+import './chunk-BMHPPH2B.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-UN27MREV.js';
+import './chunk-NAQKA54E.js';
+//# sourceMappingURL=indexer-agent-NKAOF323.js.map
+//# sourceMappingURL=indexer-agent-NKAOF323.js.map

package/dist/chunks/indexer-agent-PJN5IOKQ.js

@@ -0,0 +1,21 @@
+export { IndexerAgent } from './chunk-L376GZ44.js';
+import './chunk-JPI46FLQ.js';
+import './chunk-IGUCJL3R.js';
+import './chunk-KAYOX5EB.js';
+import './chunk-HNDYLCWI.js';
+import './chunk-CTXFPNDA.js';
+import './chunk-TJSOOFXA.js';
+import './chunk-AIZUHUK6.js';
+import './chunk-G6J42I55.js';
+import './chunk-TVOTA7EE.js';
+import './chunk-HEMJHRHZ.js';
+import './chunk-IMQ6WSJV.js';
+import './chunk-GMVGCSNU.js';
+import './chunk-XV6GNSLC.js';
+import './chunk-F7CKCMXI.js';
+import './chunk-BMHPPH2B.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-UN27MREV.js';
+import './chunk-NAQKA54E.js';
+//# sourceMappingURL=indexer-agent-PJN5IOKQ.js.map
+//# sourceMappingURL=indexer-agent-PJN5IOKQ.js.map

package/dist/chunks/indexer-agent-WRJFWKZX.js

@@ -0,0 +1,21 @@
+export { IndexerAgent } from './chunk-ESV6F6E3.js';
+import './chunk-JPI46FLQ.js';
+import './chunk-IGUCJL3R.js';
+import './chunk-J2WBGTK2.js';
+import './chunk-HNDYLCWI.js';
+import './chunk-CTXFPNDA.js';
+import './chunk-TJSOOFXA.js';
+import './chunk-AIZUHUK6.js';
+import './chunk-YS75L3ZS.js';
+import './chunk-XK2NY7RB.js';
+import './chunk-HEMJHRHZ.js';
+import './chunk-IMQ6WSJV.js';
+import './chunk-GMVGCSNU.js';
+import './chunk-XV6GNSLC.js';
+import './chunk-F7CKCMXI.js';
+import './chunk-BMHPPH2B.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-UN27MREV.js';
+import './chunk-NAQKA54E.js';
+//# sourceMappingURL=indexer-agent-WRJFWKZX.js.map
+//# sourceMappingURL=indexer-agent-WRJFWKZX.js.map

package/dist/chunks/indexing-pipeline-D4P2O72Z.js

@@ -0,0 +1,249 @@
+import { collectFilesAsync, init_file_extensions, file_extensions_exports } from './chunk-4GYRHAKO.js';
+import { getGraphStorage } from './chunk-J2WBGTK2.js';
+import './chunk-HNDYLCWI.js';
+import './chunk-CTXFPNDA.js';
+import './chunk-TJSOOFXA.js';
+import './chunk-AIZUHUK6.js';
+import './chunk-YS75L3ZS.js';
+import './chunk-XK2NY7RB.js';
+import './chunk-HEMJHRHZ.js';
+import { toError } from './chunk-5WKPA33T.js';
+import './chunk-BMHPPH2B.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import './chunk-UN27MREV.js';
+import { __require, __toCommonJS } from './chunk-NAQKA54E.js';
+import { statSync } from 'fs';
+
+// src/agents/dev/indexing-pipeline.ts
+init_logging();
+async function initializeIndexing(options) {
+  const { directory, excludePatterns = [], incremental = false, agentId } = options;
+  log.i("DEVAGENT", "Starting indexing", {
+    directory,
+    excludePatternsCount: excludePatterns.length,
+    samplePatterns: excludePatterns.slice(0, 5)
+  });
+  const collectResult = await collectFilesAsync(directory, { excludePatterns, agentId });
+  const allFiles = collectResult.files;
+  log.i("DEVAGENT", "Files collected", { count: allFiles.length });
+  return {
+    directory,
+    excludePatterns,
+    isIncremental: incremental,
+    agentId,
+    allFiles,
+    deletedEntityIds: []
+  };
+}
+async function detectChangedFiles(context) {
+  if (!context.isIncremental || context.allFiles.length === 0) {
+    return null;
+  }
+  const storage = await getGraphStorage();
+  const indexedFiles = await storage.getAllIndexedFiles();
+  if (indexedFiles.size === 0) {
+    return {
+      changedFiles: [],
+      newFiles: context.allFiles,
+      deletedFiles: [],
+      unchangedFiles: []
+    };
+  }
+  const changedFiles = [];
+  const newFiles = [];
+  const unchangedFiles = [];
+  for (const file of context.allFiles) {
+    const normalizedPath = file.replace(/\\/g, "/");
+    const lastIndexed = indexedFiles.get(normalizedPath);
+    if (lastIndexed === void 0) {
+      newFiles.push(file);
+    } else {
+      try {
+        const stats = statSync(file);
+        const mtime = stats.mtimeMs;
+        if (mtime > lastIndexed) {
+          changedFiles.push(file);
+        } else {
+          unchangedFiles.push(file);
+        }
+      } catch {
+        unchangedFiles.push(file);
+      }
+    }
+  }
+  const currentFilesSet = new Set(context.allFiles.map((file) => file.replace(/\\/g, "/")));
+  const deletedFiles = [];
+  for (const [indexedPath] of indexedFiles) {
+    if (!currentFilesSet.has(indexedPath)) {
+      deletedFiles.push(indexedPath);
+    }
+  }
+  log.i("DEVAGENT", "Smart incremental analysis", {
+    total: context.allFiles.length,
+    changed: changedFiles.length,
+    new: newFiles.length,
+    deleted: deletedFiles.length,
+    unchanged: unchangedFiles.length
+  });
+  return {
+    changedFiles,
+    newFiles,
+    deletedFiles,
+    unchangedFiles
+  };
+}
+async function cleanStaleEntities(filesToClean) {
+  if (filesToClean.length === 0) {
+    return [];
+  }
+  log.i("DEVAGENT", "Invalidating deleted files", {
+    fileCount: filesToClean.length
+  });
+  const storage = await getGraphStorage();
+  const deletedEntityIds = [];
+  for (const file of filesToClean) {
+    try {
+      const ids = await storage.deleteEntitiesByFilePath(file);
+      deletedEntityIds.push(...ids);
+      await storage.deleteFileInfo(file);
+    } catch (error) {
+      const err = toError(error);
+      log.w("DEVAGENT", "Failed to invalidate file", {
+        file,
+        error: err.message,
+        stack: err.stack
+      });
+    }
+  }
+  log.i("DEVAGENT", "Files invalidated", {
+    entityCount: deletedEntityIds.length
+  });
+  return deletedEntityIds;
+}
+async function applyChangeAnalysis(context, analysis) {
+  const filesToClean = [...analysis.changedFiles, ...analysis.deletedFiles];
+  const deletedEntityIds = await cleanStaleEntities(filesToClean);
+  const filesToProcess = [...analysis.changedFiles, ...analysis.newFiles];
+  log.i("DEVAGENT", "Files to process after analysis", {
+    toProcess: filesToProcess.length,
+    entitiesDeleted: deletedEntityIds.length
+  });
+  if (filesToProcess.length === 0) {
+    log.i("DEVAGENT", "No files changed, skipping indexing");
+  }
+  return {
+    ...context,
+    allFiles: filesToProcess,
+    deletedEntityIds
+  };
+}
+function separateCodeAndDataFiles(files) {
+  const codeFiles = [];
+  const dataFiles = [];
+  const { extname } = __require("path");
+  const { isCodeExtension } = (init_file_extensions(), __toCommonJS(file_extensions_exports));
+  for (const file of files) {
+    const ext = extname(file).toLowerCase();
+    if (isCodeExtension(ext)) {
+      codeFiles.push(file);
+    } else {
+      dataFiles.push(file);
+    }
+  }
+  log.i("DEVAGENT", "Files separated", {
+    codeFiles: codeFiles.length,
+    dataFiles: dataFiles.length
+  });
+  return {
+    codeFiles,
+    dataFiles
+  };
+}
+async function resolveSwaggerLinks() {
+  const storage = await getGraphStorage();
+  const allEntities = await storage.getAllEntities();
+  const hasSwagger = allEntities.some((e) => e.metadata?.["swaggerType"]);
+  if (!hasSwagger) {
+    return 0;
+  }
+  log.i("DEVAGENT", "swagger_link_start", { totalEntities: allEntities.length });
+  try {
+    const { analyzeSwaggerCodeLinks, buildSwaggerRelationships } = await import('./swagger-code-linker-WXUPZZEE.js');
+    const analysis = analyzeSwaggerCodeLinks(allEntities);
+    const totalLinks = analysis.producers.length + analysis.consumers.length + analysis.generatedTypes.length;
+    if (totalLinks === 0) {
+      log.i("DEVAGENT", "swagger_link_none");
+      return 0;
+    }
+    const swaggerRelationships = buildSwaggerRelationships(analysis);
+    const { nanoid } = await import('nanoid');
+    const relationships = swaggerRelationships.map((rel) => ({
+      id: nanoid(12),
+      fromId: `swagger:${rel.fromName}`,
+      toId: `swagger:${rel.toName}`,
+      type: rel.type,
+      metadata: {
+        ...rel.metadata,
+        fromFile: rel.fromFile,
+        toFile: rel.toFile
+      }
+    }));
+    const entityByName = /* @__PURE__ */ new Map();
+    for (const e of allEntities) {
+      entityByName.set(e.name, e.id);
+      entityByName.set(`${e.filePath}:${e.name}`, e.id);
+    }
+    for (const rel of relationships) {
+      const fromName = rel.fromId.replace("swagger:", "");
+      const toName = rel.toId.replace("swagger:", "");
+      const fromFile = rel.metadata?.fromFile;
+      const toFile = rel.metadata?.toFile;
+      if (fromFile) {
+        const fileKey = `${fromFile}:${fromName}`;
+        if (entityByName.has(fileKey)) {
+          rel.fromId = entityByName.get(fileKey);
+        }
+      }
+      if (!rel.fromId.startsWith("swagger:") === false && entityByName.has(fromName)) {
+        rel.fromId = entityByName.get(fromName);
+      }
+      if (toFile) {
+        const fileKey = `${toFile}:${toName}`;
+        if (entityByName.has(fileKey)) {
+          rel.toId = entityByName.get(fileKey);
+        }
+      }
+      if (!rel.toId.startsWith("swagger:") === false && entityByName.has(toName)) {
+        rel.toId = entityByName.get(toName);
+      }
+    }
+    const result = await storage.insertRelationships(relationships);
+    log.i("DEVAGENT", "swagger_link_done", {
+      producers: analysis.producers.length,
+      consumers: analysis.consumers.length,
+      generatedTypes: analysis.generatedTypes.length,
+      relationshipsCreated: result.processed,
+      configs: analysis.codegenConfigs
+    });
+    return result.processed;
+  } catch (error) {
+    log.w("DEVAGENT", "swagger_link_error", { error: error.message });
+    return 0;
+  }
+}
+function shouldUseIncrementalMode(context) {
+  return context.isIncremental && context.allFiles.length > 0;
+}
+function buildIndexingResult(context, filesProcessed, totalEntities, totalRelationships) {
+  return {
+    filesProcessed,
+    entitiesExtracted: totalEntities,
+    relationshipsCreated: totalRelationships,
+    totalFiles: context.allFiles.length,
+    deletedEntities: context.deletedEntityIds.length
+  };
+}
+
+export { applyChangeAnalysis, buildIndexingResult, cleanStaleEntities, detectChangedFiles, initializeIndexing, resolveSwaggerLinks, separateCodeAndDataFiles, shouldUseIncrementalMode };
+//# sourceMappingURL=indexing-pipeline-D4P2O72Z.js.map
+//# sourceMappingURL=indexing-pipeline-D4P2O72Z.js.map

package/dist/chunks/indexing-pipeline-L7C543N4.js

@@ -0,0 +1 @@
+import {f,e,d as d$1}from'./chunk-WZJJIJJU.js';import {d}from'./chunk-PY43JPWL.js';import'./chunk-RK5TLU72.js';import'./chunk-LESND2CW.js';import'./chunk-QUO46LUP.js';import'./chunk-3IFLFBQ4.js';import'./chunk-I6STSSAK.js';import'./chunk-SV3WKUNV.js';import'./chunk-PZF7YC35.js';import {a}from'./chunk-F3VMUQ7O.js';import'./chunk-OG62YNVF.js';import {R as R$1,I}from'./chunk-4BI7EBPQ.js';import'./chunk-F45ISXCP.js';import {a as a$1,f as f$1}from'./chunk-DXB73IDG.js';import {statSync}from'fs';R$1();async function R(e){let{directory:n,excludePatterns:i=[],incremental:s=false,agentId:a}=e;I.i("DEVAGENT","Starting indexing",{directory:n,excludePatternsCount:i.length,samplePatterns:i.slice(0,5)});let d=(await f(n,{excludePatterns:i,agentId:a})).files;return I.i("DEVAGENT","Files collected",{count:d.length}),{directory:n,excludePatterns:i,isIncremental:s,agentId:a,allFiles:d,deletedEntityIds:[]}}async function _(e){if(!e.isIncremental||e.allFiles.length===0)return null;let i=await(await d()).getAllIndexedFiles();if(i.size===0)return {changedFiles:[],newFiles:e.allFiles,deletedFiles:[],unchangedFiles:[]};let s=[],a=[],r=[];for(let o of e.allFiles){let f=o.replace(/\\/g,"/"),g=i.get(f);if(g===void 0)a.push(o);else try{statSync(o).mtimeMs>g?s.push(o):r.push(o);}catch{r.push(o);}}let d$1=new Set(e.allFiles.map(o=>o.replace(/\\/g,"/"))),c=[];for(let[o]of i)d$1.has(o)||c.push(o);return I.i("DEVAGENT","Smart incremental analysis",{total:e.allFiles.length,changed:s.length,new:a.length,deleted:c.length,unchanged:r.length}),{changedFiles:s,newFiles:a,deletedFiles:c,unchangedFiles:r}}async function T(e){if(e.length===0)return [];I.i("DEVAGENT","Invalidating deleted files",{fileCount:e.length});let n=await d(),i=[];for(let s of e)try{let a=await n.deleteEntitiesByFilePath(s);i.push(...a),await n.deleteFileInfo(s);}catch(a$1){let r=a(a$1);I.w("DEVAGENT","Failed to invalidate file",{file:s,error:r.message,stack:r.stack});}return I.i("DEVAGENT","Files invalidated",{entityCount:i.length}),i}async function $(e,n){let i=[...n.changedFiles,...n.deletedFiles],s=await T(i),a=[...n.changedFiles,...n.newFiles];return I.i("DEVAGENT","Files to process after analysis",{toProcess:a.length,entitiesDeleted:s.length}),a.length===0&&I.i("DEVAGENT","No files changed, skipping indexing"),{...e,allFiles:a,deletedEntityIds:s}}function v(e$1){let n=[],i=[],{extname:s}=a$1("path"),{isCodeExtension:a}=(e(),f$1(d$1));for(let r of e$1){let d=s(r).toLowerCase();a(d)?n.push(r):i.push(r);}return I.i("DEVAGENT","Files separated",{codeFiles:n.length,dataFiles:i.length}),{codeFiles:n,dataFiles:i}}async function L(){let e=await d(),n=await e.getAllEntities();if(!n.some(s=>s.metadata?.swaggerType))return 0;I.i("DEVAGENT","swagger_link_start",{totalEntities:n.length});try{let{analyzeSwaggerCodeLinks:s,buildSwaggerRelationships:a}=await import('./swagger-code-linker-2ZCSRI2C.js'),r=s(n);if(r.producers.length+r.consumers.length+r.generatedTypes.length===0)return I.i("DEVAGENT","swagger_link_none"),0;let c=a(r),{nanoid:o}=await import('nanoid'),f=c.map(t=>({id:o(12),fromId:`swagger:${t.fromName}`,toId:`swagger:${t.toName}`,type:t.type,metadata:{...t.metadata,fromFile:t.fromFile,toFile:t.toFile}})),g=new Map;for(let t of n)g.set(t.name,t.id),g.set(`${t.filePath}:${t.name}`,t.id);for(let t of f){let p=t.fromId.replace("swagger:",""),F=t.toId.replace("swagger:",""),E=t.metadata?.fromFile,x=t.metadata?.toFile;if(E){let u=`${E}:${p}`;g.has(u)&&(t.fromId=g.get(u));}if(t.fromId.startsWith("swagger:")&&g.has(p)&&(t.fromId=g.get(p)),x){let u=`${x}:${F}`;g.has(u)&&(t.toId=g.get(u));}t.toId.startsWith("swagger:")&&g.has(F)&&(t.toId=g.get(F));}let h=await e.insertRelationships(f);return I.i("DEVAGENT","swagger_link_done",{producers:r.producers.length,consumers:r.consumers.length,generatedTypes:r.generatedTypes.length,relationshipsCreated:h.processed,configs:r.codegenConfigs}),h.processed}catch(s){return I.w("DEVAGENT","swagger_link_error",{error:s.message}),0}}function z(e){return e.isIncremental&&e.allFiles.length>0}function M(e,n,i,s){return {filesProcessed:n,entitiesExtracted:i,relationshipsCreated:s,totalFiles:e.allFiles.length,deletedEntities:e.deletedEntityIds.length}}export{$ as applyChangeAnalysis,M as buildIndexingResult,T as cleanStaleEntities,_ as detectChangedFiles,R as initializeIndexing,L as resolveSwaggerLinks,v as separateCodeAndDataFiles,z as shouldUseIncrementalMode};