ultracode 5.4.0 → 5.6.0

package/dist/chunks/branch-tool-handlers-ZHJM6PDK.js

@@ -0,0 +1,276 @@
+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 { init_logging, log } from './chunk-VCCBEJQ5.js';
+import './chunk-NAQKA54E.js';
+import { execSync } from 'child_process';
+import { z } from 'zod';
+
+// src/tools/handlers/branch-tool-handlers.ts
+init_logging();
+var ListBranchesSchema = z.object({
+  includeStats: z.boolean().optional().default(false)
+});
+var ListBranchesToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return ListBranchesSchema.parse(args);
+  }
+  async execute(args) {
+    const branchManager = await this.context.getBranchManager();
+    if (!branchManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Branch manager not available" }) }]
+      };
+    }
+    const branches = branchManager.getActiveBranches();
+    const currentBranch = branchManager.getCurrentBranch();
+    const result = {
+      currentBranch,
+      branches: branches.map((b) => ({
+        name: b.name,
+        isCurrent: b.name === currentBranch,
+        lastIndexed: b.metadata?.lastIndexedAt || b.lastAccessed
+      }))
+    };
+    if (args.includeStats) {
+      result.stats = {
+        totalBranches: branches.length,
+        indexedBranches: branches.filter((b) => b.metadata?.lastIndexedAt).length
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  }
+};
+var SwitchBranchSchema = z.object({
+  branchName: z.string(),
+  createIfNotExists: z.boolean().optional().default(false),
+  baseBranch: z.string().optional().describe("Base branch for diff cache (default: main)")
+});
+var SwitchBranchToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return SwitchBranchSchema.parse(args);
+  }
+  async execute(args) {
+    const branchManager = await this.context.getBranchManager();
+    if (!branchManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Branch manager not available" }) }]
+      };
+    }
+    try {
+      await branchManager.switchBranch(args.branchName);
+      const baseBranches = ["main", "master", "develop", "dev"];
+      if (!baseBranches.includes(args.branchName.toLowerCase())) {
+        try {
+          const storage = await this.context.getGraphStorage();
+          const adapter = storage.getLibSQLAdapter?.();
+          if (adapter?.initBranchDiff) {
+            const baseBranch = args.baseBranch || "main";
+            await adapter.initBranchDiff(baseBranch);
+            log.i("BRANCHTOOLS", "branch_diff_init", {
+              branch: args.branchName,
+              base: baseBranch
+            });
+          }
+        } catch (diffError) {
+          log.w("BRANCHTOOLS", "branch_diff_init_fail", {
+            err: diffError.message
+          });
+        }
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              currentBranch: args.branchName,
+              message: `Switched to branch '${args.branchName}'`
+            })
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+var GetBranchStatusSchema = z.object({
+  branchName: z.string().optional()
+});
+var GetBranchStatusToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return GetBranchStatusSchema.parse(args);
+  }
+  async execute(args) {
+    const branchManager = await this.context.getBranchManager();
+    if (!branchManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Branch manager not available" }) }]
+      };
+    }
+    const branchName = args.branchName || branchManager.getCurrentBranch() || "main";
+    const metadata = branchManager.getBranchMetadata(branchName);
+    const dbPath = branchManager.getBranchDbPath(branchName);
+    const hasDb = branchManager.hasBranchDatabase(branchName);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              branch: branchName,
+              exists: hasDb,
+              dbPath,
+              metadata: metadata ? {
+                lastIndexedAt: metadata.lastIndexedAt,
+                entityCount: metadata.entityCount,
+                relationshipCount: metadata.relationshipCount,
+                fileCount: metadata.fileCount,
+                indexVersion: metadata.indexVersion
+              } : null
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var CleanupBranchesSchema = z.object({
+  keepCount: z.number().optional().default(10),
+  olderThanDays: z.number().optional(),
+  dryRun: z.boolean().optional().default(true)
+});
+var CleanupBranchesToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return CleanupBranchesSchema.parse(args);
+  }
+  async execute(args) {
+    const branchManager = await this.context.getBranchManager();
+    if (!branchManager) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "Branch manager not available" }) }]
+      };
+    }
+    const branches = branchManager.getActiveBranches();
+    const currentBranch = branchManager.getCurrentBranch();
+    const toCleanup = branches.filter((b) => b.name !== currentBranch && b.name !== "main" && b.name !== "master").slice(args.keepCount);
+    let deletedCount = 0;
+    if (!args.dryRun) {
+      deletedCount = await branchManager.cleanupOldBranches(args.keepCount);
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              dryRun: args.dryRun,
+              branchesFound: branches.length,
+              branchesToCleanup: args.dryRun ? toCleanup.length : deletedCount,
+              cleanedBranches: toCleanup.map((b) => b.name)
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var GetChangedFilesSchema = z.object({
+  baseBranch: z.string().optional(),
+  targetBranch: z.string().optional(),
+  includeUntracked: z.boolean().optional().default(false)
+});
+var GetChangedFilesToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return GetChangedFilesSchema.parse(args);
+  }
+  async execute(args) {
+    try {
+      const currentBranch = execSync("git symbolic-ref --short HEAD", { encoding: "utf-8" }).trim();
+      const targetBranch = args.targetBranch || currentBranch;
+      let baseBranch = args.baseBranch;
+      if (!baseBranch) {
+        try {
+          baseBranch = execSync("git symbolic-ref refs/remotes/origin/HEAD", { encoding: "utf-8" }).trim().replace("refs/remotes/origin/", "");
+        } catch {
+          try {
+            execSync("git rev-parse --verify main", { encoding: "utf-8" });
+            baseBranch = "main";
+          } catch {
+            try {
+              execSync("git rev-parse --verify master", { encoding: "utf-8" });
+              baseBranch = "master";
+            } catch {
+              baseBranch = currentBranch;
+            }
+          }
+        }
+      }
+      const output = execSync(`git diff --name-status ${baseBranch}...${targetBranch}`, {
+        encoding: "utf-8",
+        cwd: process.cwd()
+      });
+      const changedFiles = output.split("\n").filter((line) => line.trim()).map((line) => {
+        const [statusCode, ...pathParts] = line.split("	");
+        const path = pathParts.join("	");
+        const statusMap = {
+          A: "added",
+          M: "modified",
+          D: "deleted",
+          R: "renamed"
+        };
+        const firstChar = statusCode?.[0] ?? "";
+        const status = firstChar ? statusMap[firstChar] || statusCode : "unknown";
+        return { path, status };
+      });
+      const added = changedFiles.filter((f) => f.status === "added");
+      const modified = changedFiles.filter((f) => f.status === "modified");
+      const deleted = changedFiles.filter((f) => f.status === "deleted");
+      const renamed = changedFiles.filter((f) => f.status === "renamed");
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                baseBranch,
+                targetBranch,
+                totalChanges: changedFiles.length,
+                summary: {
+                  added: added.length,
+                  modified: modified.length,
+                  deleted: deleted.length,
+                  renamed: renamed.length
+                },
+                files: changedFiles
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      const err = toError(error);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }]
+      };
+    }
+  }
+};
+
+export { CleanupBranchesToolHandler, GetBranchStatusToolHandler, GetChangedFilesToolHandler, ListBranchesToolHandler, SwitchBranchToolHandler };
+//# sourceMappingURL=branch-tool-handlers-ZHJM6PDK.js.map
+//# sourceMappingURL=branch-tool-handlers-ZHJM6PDK.js.map