ultracode 5.4.0 → 5.6.0

package/dist/chunks/snapshot-tool-handlers-6SIHZT2F.js

@@ -0,0 +1,201 @@
+import { BaseToolHandler } from './chunk-SAMX3HJQ.js';
+import './chunk-WIE3G5ES.js';
+import './chunk-XK2NY7RB.js';
+import './chunk-HEMJHRHZ.js';
+import { toError } from './chunk-5WKPA33T.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+import { z } from 'zod';
+
+var CreateSnapshotSchema = z.object({
+  description: z.string().optional(),
+  entityIds: z.array(z.string()).optional(),
+  filePaths: z.array(z.string()).optional()
+});
+var CreateSnapshotToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return CreateSnapshotSchema.parse(args);
+  }
+  async execute(args) {
+    const snapshotManager = await this.context.getSnapshotManager();
+    if (!snapshotManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Snapshot manager not available" }) }]
+      };
+    }
+    try {
+      const description = args.description || `Snapshot created at ${(/* @__PURE__ */ new Date()).toISOString()}`;
+      const files = args.filePaths?.map((p) => this.context.normalizeInputPath(p)).filter(Boolean);
+      const snapshotId = await snapshotManager.createSnapshot(description, files);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                snapshotId,
+                description,
+                createdAt: (/* @__PURE__ */ new Date()).toISOString()
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+var RollbackSnapshotSchema = z.object({
+  snapshotId: z.string().optional(),
+  steps: z.number().optional().default(1)
+});
+var RollbackSnapshotToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return RollbackSnapshotSchema.parse(args);
+  }
+  async execute(args) {
+    const snapshotManager = await this.context.getSnapshotManager();
+    if (!snapshotManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Snapshot manager not available" }) }]
+      };
+    }
+    try {
+      let targetSnapshotId = args.snapshotId;
+      if (!targetSnapshotId) {
+        const snapshots = await snapshotManager.listSnapshots(args.steps);
+        if (snapshots.length === 0) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: "No snapshots available to rollback" }) }]
+          };
+        }
+        const targetIndex = Math.min(args.steps - 1, snapshots.length - 1);
+        targetSnapshotId = snapshots[targetIndex].id;
+      }
+      await snapshotManager.rollback(targetSnapshotId);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                restoredSnapshot: targetSnapshotId,
+                message: `Rolled back to snapshot ${targetSnapshotId}`
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+var ListSnapshotsSchema = z.object({
+  limit: z.number().optional().default(20),
+  includeDetails: z.boolean().optional().default(false)
+});
+var ListSnapshotsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return ListSnapshotsSchema.parse(args);
+  }
+  async execute(args) {
+    const snapshotManager = await this.context.getSnapshotManager();
+    if (!snapshotManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Snapshot manager not available" }) }]
+      };
+    }
+    const snapshots = await snapshotManager.listSnapshots(args.limit);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              count: snapshots.length,
+              snapshots: snapshots.map((s) => ({
+                id: s.id,
+                description: s.description,
+                timestamp: s.timestamp,
+                createdAt: new Date(s.timestamp).toISOString(),
+                backend: s.backend,
+                filesCount: s.filesCount,
+                sizeBytes: s.sizeBytes
+              }))
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var CleanupSnapshotsSchema = z.object({
+  keepCount: z.number().optional().default(10),
+  olderThanDays: z.number().optional(),
+  dryRun: z.boolean().optional().default(true)
+});
+var CleanupSnapshotsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return CleanupSnapshotsSchema.parse(args);
+  }
+  async execute(args) {
+    const snapshotManager = await this.context.getSnapshotManager();
+    if (!snapshotManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Snapshot manager not available" }) }]
+      };
+    }
+    const allSnapshots = await snapshotManager.listSnapshots(1e3);
+    let toCleanup = [...allSnapshots];
+    toCleanup.sort((a, b) => b.timestamp - a.timestamp);
+    const toKeep = toCleanup.slice(0, args.keepCount);
+    toCleanup = toCleanup.slice(args.keepCount);
+    if (args.olderThanDays) {
+      const cutoffTime = Date.now() - args.olderThanDays * 24 * 60 * 60 * 1e3;
+      toCleanup = toCleanup.filter((s) => s.timestamp < cutoffTime);
+    }
+    if (!args.dryRun) {
+      for (const snapshot of toCleanup) {
+        await snapshotManager.deleteSnapshot(snapshot.id);
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              dryRun: args.dryRun,
+              totalSnapshots: allSnapshots.length,
+              snapshotsKept: toKeep.length,
+              snapshotsCleaned: toCleanup.length,
+              cleanedIds: toCleanup.map((s) => s.id)
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+
+export { CleanupSnapshotsToolHandler, CreateSnapshotToolHandler, ListSnapshotsToolHandler, RollbackSnapshotToolHandler };
+//# sourceMappingURL=snapshot-tool-handlers-6SIHZT2F.js.map
+//# sourceMappingURL=snapshot-tool-handlers-6SIHZT2F.js.map

package/dist/chunks/snapshot-tool-handlers-DS4P3KOT.js

@@ -0,0 +1,201 @@
+import { BaseToolHandler } from './chunk-VS44D772.js';
+import './chunk-TUWE6FCW.js';
+import './chunk-TVOTA7EE.js';
+import './chunk-HEMJHRHZ.js';
+import { toError } from './chunk-5WKPA33T.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+import { z } from 'zod';
+
+var CreateSnapshotSchema = z.object({
+  description: z.string().optional(),
+  entityIds: z.array(z.string()).optional(),
+  filePaths: z.array(z.string()).optional()
+});
+var CreateSnapshotToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return CreateSnapshotSchema.parse(args);
+  }
+  async execute(args) {
+    const snapshotManager = await this.context.getSnapshotManager();
+    if (!snapshotManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Snapshot manager not available" }) }]
+      };
+    }
+    try {
+      const description = args.description || `Snapshot created at ${(/* @__PURE__ */ new Date()).toISOString()}`;
+      const files = args.filePaths?.map((p) => this.context.normalizeInputPath(p)).filter(Boolean);
+      const snapshotId = await snapshotManager.createSnapshot(description, files);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                snapshotId,
+                description,
+                createdAt: (/* @__PURE__ */ new Date()).toISOString()
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+var RollbackSnapshotSchema = z.object({
+  snapshotId: z.string().optional(),
+  steps: z.number().optional().default(1)
+});
+var RollbackSnapshotToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return RollbackSnapshotSchema.parse(args);
+  }
+  async execute(args) {
+    const snapshotManager = await this.context.getSnapshotManager();
+    if (!snapshotManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Snapshot manager not available" }) }]
+      };
+    }
+    try {
+      let targetSnapshotId = args.snapshotId;
+      if (!targetSnapshotId) {
+        const snapshots = await snapshotManager.listSnapshots(args.steps);
+        if (snapshots.length === 0) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: "No snapshots available to rollback" }) }]
+          };
+        }
+        const targetIndex = Math.min(args.steps - 1, snapshots.length - 1);
+        targetSnapshotId = snapshots[targetIndex].id;
+      }
+      await snapshotManager.rollback(targetSnapshotId);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                restoredSnapshot: targetSnapshotId,
+                message: `Rolled back to snapshot ${targetSnapshotId}`
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+var ListSnapshotsSchema = z.object({
+  limit: z.number().optional().default(20),
+  includeDetails: z.boolean().optional().default(false)
+});
+var ListSnapshotsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return ListSnapshotsSchema.parse(args);
+  }
+  async execute(args) {
+    const snapshotManager = await this.context.getSnapshotManager();
+    if (!snapshotManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Snapshot manager not available" }) }]
+      };
+    }
+    const snapshots = await snapshotManager.listSnapshots(args.limit);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              count: snapshots.length,
+              snapshots: snapshots.map((s) => ({
+                id: s.id,
+                description: s.description,
+                timestamp: s.timestamp,
+                createdAt: new Date(s.timestamp).toISOString(),
+                backend: s.backend,
+                filesCount: s.filesCount,
+                sizeBytes: s.sizeBytes
+              }))
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var CleanupSnapshotsSchema = z.object({
+  keepCount: z.number().optional().default(10),
+  olderThanDays: z.number().optional(),
+  dryRun: z.boolean().optional().default(true)
+});
+var CleanupSnapshotsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return CleanupSnapshotsSchema.parse(args);
+  }
+  async execute(args) {
+    const snapshotManager = await this.context.getSnapshotManager();
+    if (!snapshotManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Snapshot manager not available" }) }]
+      };
+    }
+    const allSnapshots = await snapshotManager.listSnapshots(1e3);
+    let toCleanup = [...allSnapshots];
+    toCleanup.sort((a, b) => b.timestamp - a.timestamp);
+    const toKeep = toCleanup.slice(0, args.keepCount);
+    toCleanup = toCleanup.slice(args.keepCount);
+    if (args.olderThanDays) {
+      const cutoffTime = Date.now() - args.olderThanDays * 24 * 60 * 60 * 1e3;
+      toCleanup = toCleanup.filter((s) => s.timestamp < cutoffTime);
+    }
+    if (!args.dryRun) {
+      for (const snapshot of toCleanup) {
+        await snapshotManager.deleteSnapshot(snapshot.id);
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              dryRun: args.dryRun,
+              totalSnapshots: allSnapshots.length,
+              snapshotsKept: toKeep.length,
+              snapshotsCleaned: toCleanup.length,
+              cleanedIds: toCleanup.map((s) => s.id)
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+
+export { CleanupSnapshotsToolHandler, CreateSnapshotToolHandler, ListSnapshotsToolHandler, RollbackSnapshotToolHandler };
+//# sourceMappingURL=snapshot-tool-handlers-DS4P3KOT.js.map
+//# sourceMappingURL=snapshot-tool-handlers-DS4P3KOT.js.map

package/dist/chunks/snapshot-tool-handlers-JYHRFPC7.js

@@ -0,0 +1,201 @@
+import { BaseToolHandler } from './chunk-Q5LPVLXA.js';
+import './chunk-TCHCDCDO.js';
+import './chunk-LH4OUKNZ.js';
+import './chunk-HEMJHRHZ.js';
+import { toError } from './chunk-5WKPA33T.js';
+import './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+import { z } from 'zod';
+
+var CreateSnapshotSchema = z.object({
+  description: z.string().optional(),
+  entityIds: z.array(z.string()).optional(),
+  filePaths: z.array(z.string()).optional()
+});
+var CreateSnapshotToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return CreateSnapshotSchema.parse(args);
+  }
+  async execute(args) {
+    const snapshotManager = await this.context.getSnapshotManager();
+    if (!snapshotManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Snapshot manager not available" }) }]
+      };
+    }
+    try {
+      const description = args.description || `Snapshot created at ${(/* @__PURE__ */ new Date()).toISOString()}`;
+      const files = args.filePaths?.map((p) => this.context.normalizeInputPath(p)).filter(Boolean);
+      const snapshotId = await snapshotManager.createSnapshot(description, files);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                snapshotId,
+                description,
+                createdAt: (/* @__PURE__ */ new Date()).toISOString()
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+var RollbackSnapshotSchema = z.object({
+  snapshotId: z.string().optional(),
+  steps: z.number().optional().default(1)
+});
+var RollbackSnapshotToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return RollbackSnapshotSchema.parse(args);
+  }
+  async execute(args) {
+    const snapshotManager = await this.context.getSnapshotManager();
+    if (!snapshotManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Snapshot manager not available" }) }]
+      };
+    }
+    try {
+      let targetSnapshotId = args.snapshotId;
+      if (!targetSnapshotId) {
+        const snapshots = await snapshotManager.listSnapshots(args.steps);
+        if (snapshots.length === 0) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: "No snapshots available to rollback" }) }]
+          };
+        }
+        const targetIndex = Math.min(args.steps - 1, snapshots.length - 1);
+        targetSnapshotId = snapshots[targetIndex].id;
+      }
+      await snapshotManager.rollback(targetSnapshotId);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                restoredSnapshot: targetSnapshotId,
+                message: `Rolled back to snapshot ${targetSnapshotId}`
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+var ListSnapshotsSchema = z.object({
+  limit: z.number().optional().default(20),
+  includeDetails: z.boolean().optional().default(false)
+});
+var ListSnapshotsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return ListSnapshotsSchema.parse(args);
+  }
+  async execute(args) {
+    const snapshotManager = await this.context.getSnapshotManager();
+    if (!snapshotManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Snapshot manager not available" }) }]
+      };
+    }
+    const snapshots = await snapshotManager.listSnapshots(args.limit);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              count: snapshots.length,
+              snapshots: snapshots.map((s) => ({
+                id: s.id,
+                description: s.description,
+                timestamp: s.timestamp,
+                createdAt: new Date(s.timestamp).toISOString(),
+                backend: s.backend,
+                filesCount: s.filesCount,
+                sizeBytes: s.sizeBytes
+              }))
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var CleanupSnapshotsSchema = z.object({
+  keepCount: z.number().optional().default(10),
+  olderThanDays: z.number().optional(),
+  dryRun: z.boolean().optional().default(true)
+});
+var CleanupSnapshotsToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return CleanupSnapshotsSchema.parse(args);
+  }
+  async execute(args) {
+    const snapshotManager = await this.context.getSnapshotManager();
+    if (!snapshotManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Snapshot manager not available" }) }]
+      };
+    }
+    const allSnapshots = await snapshotManager.listSnapshots(1e3);
+    let toCleanup = [...allSnapshots];
+    toCleanup.sort((a, b) => b.timestamp - a.timestamp);
+    const toKeep = toCleanup.slice(0, args.keepCount);
+    toCleanup = toCleanup.slice(args.keepCount);
+    if (args.olderThanDays) {
+      const cutoffTime = Date.now() - args.olderThanDays * 24 * 60 * 60 * 1e3;
+      toCleanup = toCleanup.filter((s) => s.timestamp < cutoffTime);
+    }
+    if (!args.dryRun) {
+      for (const snapshot of toCleanup) {
+        await snapshotManager.deleteSnapshot(snapshot.id);
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              dryRun: args.dryRun,
+              totalSnapshots: allSnapshots.length,
+              snapshotsKept: toKeep.length,
+              snapshotsCleaned: toCleanup.length,
+              cleanedIds: toCleanup.map((s) => s.id)
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+
+export { CleanupSnapshotsToolHandler, CreateSnapshotToolHandler, ListSnapshotsToolHandler, RollbackSnapshotToolHandler };
+//# sourceMappingURL=snapshot-tool-handlers-JYHRFPC7.js.map
+//# sourceMappingURL=snapshot-tool-handlers-JYHRFPC7.js.map

package/dist/chunks/snapshot-tool-handlers-YEHMAT3L.js

@@ -0,0 +1 @@
+import {d as d$1}from'./chunk-XG3ACLWR.js';import'./chunk-XJ2Z5QQO.js';import'./chunk-SV3WKUNV.js';import'./chunk-PZF7YC35.js';import {a}from'./chunk-F3VMUQ7O.js';import'./chunk-4BI7EBPQ.js';import'./chunk-DXB73IDG.js';import {z}from'zod';var m=z.object({description:z.string().optional(),entityIds:z.array(z.string()).optional(),filePaths:z.array(z.string()).optional()}),h=class extends d$1{parseArgs(e){return m.parse(e)}async execute(e){let s=await this.context.getSnapshotManager();if(!s)return {content:[{type:"text",text:JSON.stringify({error:"Snapshot manager not available"})}]};try{let n=e.description||`Snapshot created at ${new Date().toISOString()}`,t=e.filePaths?.map(a=>this.context.normalizeInputPath(a)).filter(Boolean),r=await s.createSnapshot(n,t);return {content:[{type:"text",text:JSON.stringify({success:!0,snapshotId:r,description:n,createdAt:new Date().toISOString()},null,2)}]}}catch(n){let t=a(n);return {content:[{type:"text",text:JSON.stringify({error:t.message})}]}}}},y=z.object({snapshotId:z.string().optional(),steps:z.number().optional().default(1)}),u=class extends d$1{parseArgs(e){return y.parse(e)}async execute(e){let s=await this.context.getSnapshotManager();if(!s)return {content:[{type:"text",text:JSON.stringify({error:"Snapshot manager not available"})}]};try{let n=e.snapshotId;if(!n){let t=await s.listSnapshots(e.steps);if(t.length===0)return {content:[{type:"text",text:JSON.stringify({error:"No snapshots available to rollback"})}]};let r=Math.min(e.steps-1,t.length-1);n=t[r].id;}return await s.rollback(n),{content:[{type:"text",text:JSON.stringify({success:!0,restoredSnapshot:n,message:`Rolled back to snapshot ${n}`},null,2)}]}}catch(n){let t=a(n);return {content:[{type:"text",text:JSON.stringify({error:t.message})}]}}}},d=z.object({limit:z.number().optional().default(20),includeDetails:z.boolean().optional().default(false)}),S=class extends d$1{parseArgs(e){return d.parse(e)}async execute(e){let s=await this.context.getSnapshotManager();if(!s)return {content:[{type:"text",text:JSON.stringify({error:"Snapshot manager not available"})}]};let n=await s.listSnapshots(e.limit);return {content:[{type:"text",text:JSON.stringify({count:n.length,snapshots:n.map(t=>({id:t.id,description:t.description,timestamp:t.timestamp,createdAt:new Date(t.timestamp).toISOString(),backend:t.backend,filesCount:t.filesCount,sizeBytes:t.sizeBytes}))},null,2)}]}}},g=z.object({keepCount:z.number().optional().default(10),olderThanDays:z.number().optional(),dryRun:z.boolean().optional().default(true)}),f=class extends d$1{parseArgs(e){return g.parse(e)}async execute(e){let s=await this.context.getSnapshotManager();if(!s)return {content:[{type:"text",text:JSON.stringify({error:"Snapshot manager not available"})}]};let n=await s.listSnapshots(1e3),t=[...n];t.sort((a,c)=>c.timestamp-a.timestamp);let r=t.slice(0,e.keepCount);if(t=t.slice(e.keepCount),e.olderThanDays){let a=Date.now()-e.olderThanDays*24*60*60*1e3;t=t.filter(c=>c.timestamp<a);}if(!e.dryRun)for(let a of t)await s.deleteSnapshot(a.id);return {content:[{type:"text",text:JSON.stringify({dryRun:e.dryRun,totalSnapshots:n.length,snapshotsKept:r.length,snapshotsCleaned:t.length,cleanedIds:t.map(a=>a.id)},null,2)}]}}};export{f as CleanupSnapshotsToolHandler,h as CreateSnapshotToolHandler,S as ListSnapshotsToolHandler,u as RollbackSnapshotToolHandler};

package/dist/chunks/storage-paths-A3C7WHHG.js

@@ -0,0 +1,8 @@
+import { init_storage_paths } from './chunk-TVOTA7EE.js';
+export { DEFAULT_BRANCH, ensureDataDir, ensureGlobalDbDir, ensureProjectDir, getASTCacheDir, getBranchPaths, getCacheDir, getConfigDir, getConfigPath, getCoreLockPath, getCorePidPath, getCurrentGitBranch, getCurrentGitBranchOrDefault, getDataDir, getFaissHotBufferPath, getFaissIdMapPath, getFaissIndexPath, getFaissIndexPathByHash, getGlobalDbPaths, getIPCSocketPath, getLogsDir, getModelsDir, getMultiDbPaths, getProjectDir, getProjectHash, getProjectPaths, getProjectsDir, getSemanticConfigPath, getTreeSitterCacheDir, hashProjectPath, initializeStorageDirs, isBaseBranch, normalizeBranchName } from './chunk-TVOTA7EE.js';
+import './chunk-HEMJHRHZ.js';
+import './chunk-NAQKA54E.js';
+
+init_storage_paths();
+//# sourceMappingURL=storage-paths-A3C7WHHG.js.map
+//# sourceMappingURL=storage-paths-A3C7WHHG.js.map

package/dist/chunks/storage-paths-HDYH7WPM.js

@@ -0,0 +1 @@
+import {I}from'./chunk-SV3WKUNV.js';export{t as DEFAULT_BRANCH,b as ensureDataDir,y as ensureGlobalDbDir,x as ensureProjectDir,F as getASTCacheDir,z as getBranchPaths,e as getCacheDir,h as getConfigDir,i as getConfigPath,l as getCoreLockPath,k as getCorePidPath,v as getCurrentGitBranch,w as getCurrentGitBranchOrDefault,a as getDataDir,D as getFaissHotBufferPath,C as getFaissIdMapPath,A as getFaissIndexPath,B as getFaissIndexPathByHash,p as getGlobalDbPaths,c as getIPCSocketPath,d as getLogsDir,g as getModelsDir,q as getMultiDbPaths,n as getProjectDir,r as getProjectHash,o as getProjectPaths,f as getProjectsDir,j as getSemanticConfigPath,E as getTreeSitterCacheDir,m as hashProjectPath,G as initializeStorageDirs,u as isBaseBranch,s as normalizeBranchName}from'./chunk-SV3WKUNV.js';import'./chunk-PZF7YC35.js';import'./chunk-DXB73IDG.js';I();

package/dist/chunks/storage-paths-IMFRHBWF.js

@@ -0,0 +1,8 @@
+import { init_storage_paths } from './chunk-XK2NY7RB.js';
+export { DEFAULT_BRANCH, ensureDataDir, ensureGlobalDbDir, ensureProjectDir, getASTCacheDir, getBranchPaths, getCacheDir, getConfigDir, getConfigPath, getCoreLockPath, getCorePidPath, getCurrentGitBranch, getCurrentGitBranchOrDefault, getDataDir, getFaissHotBufferPath, getFaissIdMapPath, getFaissIndexPath, getFaissIndexPathByHash, getGlobalDbPaths, getIPCSocketPath, getLogsDir, getModelsDir, getMultiDbPaths, getProjectDir, getProjectHash, getProjectPaths, getProjectsDir, getSemanticConfigPath, getTreeSitterCacheDir, hashProjectPath, initializeStorageDirs, isBaseBranch, normalizeBranchName } from './chunk-XK2NY7RB.js';
+import './chunk-HEMJHRHZ.js';
+import './chunk-NAQKA54E.js';
+
+init_storage_paths();
+//# sourceMappingURL=storage-paths-IMFRHBWF.js.map
+//# sourceMappingURL=storage-paths-IMFRHBWF.js.map

package/dist/chunks/storage-paths-P3PUSMUD.js

@@ -0,0 +1,8 @@
+import { init_storage_paths } from './chunk-LH4OUKNZ.js';
+export { DEFAULT_BRANCH, ensureDataDir, ensureGlobalDbDir, ensureProjectDir, getASTCacheDir, getBranchPaths, getCacheDir, getConfigDir, getConfigPath, getCoreLockPath, getCorePidPath, getCurrentGitBranch, getCurrentGitBranchOrDefault, getDataDir, getFaissHotBufferPath, getFaissIdMapPath, getFaissIndexPath, getFaissIndexPathByHash, getGlobalDbPaths, getIPCSocketPath, getLogsDir, getModelsDir, getMultiDbPaths, getProjectDir, getProjectHash, getProjectPaths, getProjectsDir, getSemanticConfigPath, getTreeSitterCacheDir, hashProjectPath, initializeStorageDirs, isBaseBranch, normalizeBranchName } from './chunk-LH4OUKNZ.js';
+import './chunk-HEMJHRHZ.js';
+import './chunk-NAQKA54E.js';
+
+init_storage_paths();
+//# sourceMappingURL=storage-paths-P3PUSMUD.js.map
+//# sourceMappingURL=storage-paths-P3PUSMUD.js.map