ultracode 5.4.0 → 5.6.0

package/dist/chunks/graph-metrics-tool-handlers-3AV4X4ZY.js

@@ -0,0 +1,65 @@
+import { BaseToolHandler } from './chunk-SAMX3HJQ.js';
+import './chunk-WIE3G5ES.js';
+import './chunk-XK2NY7RB.js';
+import './chunk-HEMJHRHZ.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+import { z } from 'zod';
+
+var GraphMetricsSchema = z.object({
+  projectPath: z.string().optional(),
+  metric: z.enum(["pagerank", "louvain", "centrality", "bus_factor"]),
+  topN: z.number().optional().default(20),
+  minCommunitySize: z.number().optional().default(2),
+  persist: z.boolean().optional().default(false)
+});
+var GraphMetricsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return GraphMetricsSchema.parse(args);
+  }
+  async execute(args) {
+    const projectPath = this.resolveProjectPath(args);
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const { GraphMetricsAnalyzer } = await import('./graph-metrics-P5IGB3AU.js');
+    const { GraphMetricsFormatter } = await import('./graph-metrics-P5IGB3AU.js');
+    const analyzer = new GraphMetricsAnalyzer(storage);
+    const result = await analyzer.analyze({
+      projectPath,
+      metric: args.metric,
+      topN: args.topN,
+      minCommunitySize: args.minCommunitySize,
+      persist: args.persist
+    });
+    const summary = GraphMetricsFormatter.toSummary(result);
+    const text = GraphMetricsFormatter.formatAsText(result);
+    let totalItems = 0;
+    if (result.metric === "pagerank" || result.metric === "centrality") {
+      totalItems = result.entries.length;
+    } else if (result.metric === "louvain") {
+      totalItems = result.communities.length;
+    } else if (result.metric === "bus_factor") {
+      totalItems = result.byFile.length;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              summary,
+              formatted: text,
+              metric: args.metric,
+              totalItems
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+
+export { GraphMetricsToolHandler };
+//# sourceMappingURL=graph-metrics-tool-handlers-3AV4X4ZY.js.map
+//# sourceMappingURL=graph-metrics-tool-handlers-3AV4X4ZY.js.map

package/dist/chunks/graph-metrics-tool-handlers-3VMDQHJ6.js

@@ -0,0 +1,65 @@
+import { BaseToolHandler } from './chunk-VS44D772.js';
+import './chunk-TUWE6FCW.js';
+import './chunk-TVOTA7EE.js';
+import './chunk-HEMJHRHZ.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+import { z } from 'zod';
+
+var GraphMetricsSchema = z.object({
+  projectPath: z.string().optional(),
+  metric: z.enum(["pagerank", "louvain", "centrality", "bus_factor"]),
+  topN: z.number().optional().default(20),
+  minCommunitySize: z.number().optional().default(2),
+  persist: z.boolean().optional().default(false)
+});
+var GraphMetricsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return GraphMetricsSchema.parse(args);
+  }
+  async execute(args) {
+    const projectPath = this.resolveProjectPath(args);
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const { GraphMetricsAnalyzer } = await import('./graph-metrics-P5IGB3AU.js');
+    const { GraphMetricsFormatter } = await import('./graph-metrics-P5IGB3AU.js');
+    const analyzer = new GraphMetricsAnalyzer(storage);
+    const result = await analyzer.analyze({
+      projectPath,
+      metric: args.metric,
+      topN: args.topN,
+      minCommunitySize: args.minCommunitySize,
+      persist: args.persist
+    });
+    const summary = GraphMetricsFormatter.toSummary(result);
+    const text = GraphMetricsFormatter.formatAsText(result);
+    let totalItems = 0;
+    if (result.metric === "pagerank" || result.metric === "centrality") {
+      totalItems = result.entries.length;
+    } else if (result.metric === "louvain") {
+      totalItems = result.communities.length;
+    } else if (result.metric === "bus_factor") {
+      totalItems = result.byFile.length;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              summary,
+              formatted: text,
+              metric: args.metric,
+              totalItems
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+
+export { GraphMetricsToolHandler };
+//# sourceMappingURL=graph-metrics-tool-handlers-3VMDQHJ6.js.map
+//# sourceMappingURL=graph-metrics-tool-handlers-3VMDQHJ6.js.map

package/dist/chunks/graph-metrics-tool-handlers-BZ6E6YHF.js

@@ -0,0 +1 @@
+import {d}from'./chunk-XG3ACLWR.js';import'./chunk-XJ2Z5QQO.js';import'./chunk-SV3WKUNV.js';import'./chunk-PZF7YC35.js';import'./chunk-4BI7EBPQ.js';import'./chunk-DXB73IDG.js';import {z}from'zod';var u=z.object({projectPath:z.string().optional(),metric:z.enum(["pagerank","louvain","centrality","bus_factor"]),topN:z.number().optional().default(20),minCommunitySize:z.number().optional().default(2),persist:z.boolean().optional().default(false)}),a=class extends d{parseArgs(t){return u.parse(t)}async execute(t){let c=this.resolveProjectPath(t),s=await this.ensureGraphStorageForProject(t.projectPath),{GraphMetricsAnalyzer:m}=await import('./graph-metrics-32VYWSIZ.js'),{GraphMetricsFormatter:i}=await import('./graph-metrics-32VYWSIZ.js'),e=await new m(s).analyze({projectPath:c,metric:t.metric,topN:t.topN,minCommunitySize:t.minCommunitySize,persist:t.persist}),l=i.toSummary(e),p=i.formatAsText(e),o=0;return e.metric==="pagerank"||e.metric==="centrality"?o=e.entries.length:e.metric==="louvain"?o=e.communities.length:e.metric==="bus_factor"&&(o=e.byFile.length),{content:[{type:"text",text:JSON.stringify({summary:l,formatted:p,metric:t.metric,totalItems:o},null,2)}]}}};export{a as GraphMetricsToolHandler};

package/dist/chunks/graph-metrics-tool-handlers-IYBGSXL7.js

@@ -0,0 +1,65 @@
+import { BaseToolHandler } from './chunk-Q5LPVLXA.js';
+import './chunk-TCHCDCDO.js';
+import './chunk-LH4OUKNZ.js';
+import './chunk-HEMJHRHZ.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+import { z } from 'zod';
+
+var GraphMetricsSchema = z.object({
+  projectPath: z.string().optional(),
+  metric: z.enum(["pagerank", "louvain", "centrality", "bus_factor"]),
+  topN: z.number().optional().default(20),
+  minCommunitySize: z.number().optional().default(2),
+  persist: z.boolean().optional().default(false)
+});
+var GraphMetricsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return GraphMetricsSchema.parse(args);
+  }
+  async execute(args) {
+    const projectPath = this.resolveProjectPath(args);
+    const storage = await this.ensureGraphStorageForProject(args.projectPath);
+    const { GraphMetricsAnalyzer } = await import('./graph-metrics-P5IGB3AU.js');
+    const { GraphMetricsFormatter } = await import('./graph-metrics-P5IGB3AU.js');
+    const analyzer = new GraphMetricsAnalyzer(storage);
+    const result = await analyzer.analyze({
+      projectPath,
+      metric: args.metric,
+      topN: args.topN,
+      minCommunitySize: args.minCommunitySize,
+      persist: args.persist
+    });
+    const summary = GraphMetricsFormatter.toSummary(result);
+    const text = GraphMetricsFormatter.formatAsText(result);
+    let totalItems = 0;
+    if (result.metric === "pagerank" || result.metric === "centrality") {
+      totalItems = result.entries.length;
+    } else if (result.metric === "louvain") {
+      totalItems = result.communities.length;
+    } else if (result.metric === "bus_factor") {
+      totalItems = result.byFile.length;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              summary,
+              formatted: text,
+              metric: args.metric,
+              totalItems
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+
+export { GraphMetricsToolHandler };
+//# sourceMappingURL=graph-metrics-tool-handlers-IYBGSXL7.js.map
+//# sourceMappingURL=graph-metrics-tool-handlers-IYBGSXL7.js.map

package/dist/chunks/graph-storage-factory-2CQ2RPDV.js

@@ -0,0 +1,13 @@
+export { configureGraphStorage, getGraphStorage, getLibSQLAdapter, handleDatabaseCorruption, initializeGraphStorage, isDatabaseCorruptionError, isStorageReady, resetGraphStorage, setGlobalProjectContext } from './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';
+export { DatabaseCorruptionError, SUPPORTED_DIMENSIONS, getEmbeddingColumn, normalizeToSupportedDimension } from './chunk-UN27MREV.js';
+import './chunk-NAQKA54E.js';
+//# sourceMappingURL=graph-storage-factory-2CQ2RPDV.js.map
+//# sourceMappingURL=graph-storage-factory-2CQ2RPDV.js.map

package/dist/chunks/graph-storage-factory-C5SMMYL6.js

@@ -0,0 +1,13 @@
+export { configureGraphStorage, getGraphStorage, getLibSQLAdapter, handleDatabaseCorruption, initializeGraphStorage, isDatabaseCorruptionError, isStorageReady, resetGraphStorage, setGlobalProjectContext } from './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';
+export { DatabaseCorruptionError, SUPPORTED_DIMENSIONS, getEmbeddingColumn, normalizeToSupportedDimension } from './chunk-UN27MREV.js';
+import './chunk-NAQKA54E.js';
+//# sourceMappingURL=graph-storage-factory-C5SMMYL6.js.map
+//# sourceMappingURL=graph-storage-factory-C5SMMYL6.js.map

package/dist/chunks/graph-storage-factory-EEO2V3GJ.js

@@ -0,0 +1 @@
+export{c as configureGraphStorage,d as getGraphStorage,f as getLibSQLAdapter,j as handleDatabaseCorruption,e as initializeGraphStorage,k as isDatabaseCorruptionError,i as isStorageReady,g as resetGraphStorage,h as setGlobalProjectContext}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'./chunk-4BI7EBPQ.js';export{g as DatabaseCorruptionError,b as SUPPORTED_DIMENSIONS,c as getEmbeddingColumn,d as normalizeToSupportedDimension}from'./chunk-F45ISXCP.js';import'./chunk-DXB73IDG.js';

package/dist/chunks/graph-storage-factory-WBCTXP34.js

@@ -0,0 +1,13 @@
+export { configureGraphStorage, getGraphStorage, getLibSQLAdapter, handleDatabaseCorruption, initializeGraphStorage, isDatabaseCorruptionError, isStorageReady, resetGraphStorage, setGlobalProjectContext } 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 './chunk-VCCBEJQ5.js';
+export { DatabaseCorruptionError, SUPPORTED_DIMENSIONS, getEmbeddingColumn, normalizeToSupportedDimension } from './chunk-UN27MREV.js';
+import './chunk-NAQKA54E.js';
+//# sourceMappingURL=graph-storage-factory-WBCTXP34.js.map
+//# sourceMappingURL=graph-storage-factory-WBCTXP34.js.map

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

@@ -0,0 +1 @@
+import {a,b,c as c$1,d as d$2}from'./chunk-NI6OXODU.js';import'./chunk-W5ZEGGQZ.js';import {d}from'./chunk-XG3ACLWR.js';import'./chunk-XJ2Z5QQO.js';import'./chunk-RK5TLU72.js';import {d as d$1,c}from'./chunk-3IFLFBQ4.js';import'./chunk-SV3WKUNV.js';import'./chunk-PZF7YC35.js';import {R,I}from'./chunk-4BI7EBPQ.js';import'./chunk-DXB73IDG.js';R();function n(l){return {content:[{type:"text",text:JSON.stringify({error:l})}]}}var x=class extends d{parseArgs(e){return a.parse(e)}async execute(e){let o=(await this.ensureGraphStorageForProject(e.projectPath)).getLibSQLAdapter?.();if(!o?.getProllyNodeStore||!o?.getCommitManager)return n("Prolly Tree not available - ensure project is indexed");let s=o.getProllyNodeStore(),i=o.getCommitManager();if(!s||!i)return n("Prolly Tree components not initialized");let a=new d$1(s,i);try{let t=await a.getEntityHistory(e.entityId,e.limit);return {content:[{type:"text",text:JSON.stringify({entityId:e.entityId,changes:t.map(r=>({commitHash:r.commitHash,changeType:r.changeType,timestamp:new Date(r.timestamp).toISOString(),entitySnapshot:r.newValue?c(r.newValue):null})),totalChanges:t.length},null,2)}]}}catch(t){return I.e("HISTORY","get_entity_history_failed",{error:t.message}),n(`Failed to get entity history: ${t.message}`)}}},P=class extends d{parseArgs(e){return b.parse(e)}async execute(e){let o=(await this.ensureGraphStorageForProject(e.projectPath)).getLibSQLAdapter?.();if(!o?.getProllyNodeStore||!o?.getCommitManager)return n("Prolly Tree not available - ensure project is indexed");let s=o.getProllyNodeStore(),i=o.getCommitManager();if(!s||!i)return n("Prolly Tree components not initialized");let a=new d$1(s,i);try{let t=e.commitB;if(!t){let c=await i.getBranchHead();if(!c)return n("No commits found - index the project first");t=c.commitHash;}let r=await a.diffCommits(e.commitA,t);if(!r)return n("Failed to diff commits: one or both commits not found");let m={commitA:e.commitA,commitB:t,summary:{added:r.treeDiff.added.length,modified:r.treeDiff.modified.length,deleted:r.treeDiff.deleted.length}};return e.includeEntities&&(m.added=r.treeDiff.added.map(c=>({key:c.key})),m.modified=r.treeDiff.modified.map(c=>({key:c.key})),m.deleted=r.treeDiff.deleted.map(c=>({key:c.key}))),{content:[{type:"text",text:JSON.stringify(m,null,2)}]}}catch(t){return I.e("HISTORY","diff_commits_failed",{error:t.message}),n(`Failed to diff commits: ${t.message}`)}}},w=class extends d{parseArgs(e){return c$1.parse(e)}async execute(e){let o=(await this.ensureGraphStorageForProject(e.projectPath)).getLibSQLAdapter?.();if(!o?.getProllyNodeStore||!o?.getCommitManager)return n("Prolly Tree not available - ensure project is indexed");let s=o.getProllyNodeStore(),i=o.getCommitManager();if(!s||!i)return n("Prolly Tree components not initialized");let a=new d$1(s,i);try{let t=await i.getCommit(e.commitHash);if(!t)return n(`Commit not found: ${e.commitHash}`);let r={commit:{hash:t.commitHash,message:t.message,entityCount:t.entityCount,relationshipCount:t.relationshipCount,createdAt:new Date(t.createdAt).toISOString(),parentHash:t.parentHash}};if(e.entityId){let m=await a.getEntityAt(e.entityId,e.commitHash);r.entity=m;}if(e.query){let m=await a.searchEntitiesAt(e.commitHash,e.query,e.limit);r.entities=m.slice(e.offset,e.offset+e.limit),r.totalMatches=m.length;}return {content:[{type:"text",text:JSON.stringify(r,null,2)}]}}catch(t){return I.e("HISTORY","checkout_commit_failed",{error:t.message}),n(`Failed to checkout commit: ${t.message}`)}}},T=class extends d{parseArgs(e){return d$2.parse(e)}async execute(e){let o=(await this.ensureGraphStorageForProject(e.projectPath)).getLibSQLAdapter?.();if(!o?.getCommitManager)return n("Prolly Tree not available - ensure project is indexed");let s=o.getCommitManager();if(!s)return n("Prolly Tree components not initialized");try{let i=await s.getHistory(e.limit);return {content:[{type:"text",text:JSON.stringify({commits:i.map(a=>({hash:a.commitHash,message:a.message,entityCount:a.entityCount,relationshipCount:a.relationshipCount,createdAt:new Date(a.createdAt).toISOString(),parentHash:a.parentHash?.slice(0,8)||null})),total:i.length},null,2)}]}}catch(i){return I.e("HISTORY","list_commits_failed",{error:i.message}),n(`Failed to list commits: ${i.message}`)}}};export{w as CheckoutCommitToolHandler,P as DiffCommitsToolHandler,x as GetEntityHistoryToolHandler,T as ListCommitsToolHandler};

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

@@ -0,0 +1,208 @@
+import { GetEntityHistorySchema, DiffCommitsSchema, CheckoutCommitSchema, ListCommitsSchema } from './chunk-LVCP3H3F.js';
+import './chunk-NJUB245U.js';
+import { BaseToolHandler } from './chunk-VS44D772.js';
+import './chunk-TUWE6FCW.js';
+import './chunk-HNDYLCWI.js';
+import { TimeTravelManager, deserializeEntity } from './chunk-AIZUHUK6.js';
+import './chunk-TVOTA7EE.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-FSNJYXV2.js.map
+//# sourceMappingURL=history-tool-handlers-FSNJYXV2.js.map

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

@@ -0,0 +1,208 @@
+import { GetEntityHistorySchema, DiffCommitsSchema, CheckoutCommitSchema, ListCommitsSchema } from './chunk-LVCP3H3F.js';
+import './chunk-NJUB245U.js';
+import { BaseToolHandler } from './chunk-Q5LPVLXA.js';
+import './chunk-TCHCDCDO.js';
+import './chunk-HNDYLCWI.js';
+import { TimeTravelManager, deserializeEntity } from './chunk-AIZUHUK6.js';
+import './chunk-LH4OUKNZ.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-JZAH4EIQ.js.map
+//# sourceMappingURL=history-tool-handlers-JZAH4EIQ.js.map