boomtick-cli 0.2.1__py3-none-any.whl

dev_tools/dist/tools/jules/create-session.test.js

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { createJulesSessionHandler } from "./create-session.js";
+import * as shell from "../../lib/shell.js";
+import { setupTestEnv, teardownTestEnv } from "../../lib/test-utils.js";
+vi.mock("../../lib/shell.js", () => ({
+    runCommand: vi.fn(),
+}));
+describe("createJulesSessionHandler", () => {
+    beforeEach(() => {
+        setupTestEnv();
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: JSON.stringify({
+                status: "success",
+                name: "sessions/1234567890",
+                state: "IN_PROGRESS",
+                createTime: new Date().toISOString(),
+            }),
+            stderr: "",
+            exitCode: 0,
+            durationMs: 10,
+            command: "td-cli agent dispatch"
+        });
+    });
+    afterEach(() => {
+        teardownTestEnv();
+        vi.clearAllMocks();
+    });
+    it("should create a session with just task", async () => {
+        const result = await createJulesSessionHandler({ task: "do work" });
+        expect(result.id).toBe("1234567890");
+        expect(result.status).toBe("IN_PROGRESS");
+        expect(result.createdAt).toBeInstanceOf(Date);
+        expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+            "agent", "dispatch", "main", "do work"
+        ]);
+    });
+    it("should create a session with specific branch", async () => {
+        const result = await createJulesSessionHandler({ task: "do work", branch: "feature-x" });
+        expect(result.id).toBe("1234567890");
+        expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+            "agent", "dispatch", "feature-x", "do work"
+        ]);
+    });
+    it("should create a session with PR number", async () => {
+        vi.mocked(shell.runCommand).mockImplementation(async (cmd, args) => {
+            if (args[1] === "view") {
+                return {
+                    stdout: JSON.stringify({ status: "success", pr: { headRefName: "pr-branch" } }),
+                    stderr: "",
+                    exitCode: 0,
+                    durationMs: 10,
+                    command: "td-cli gh view"
+                };
+            }
+            return {
+                stdout: JSON.stringify({
+                    status: "success",
+                    name: "sessions/1234567890",
+                    state: "IN_PROGRESS",
+                    createTime: new Date().toISOString(),
+                }),
+                stderr: "",
+                exitCode: 0,
+                durationMs: 10,
+                command: "td-cli agent dispatch"
+            };
+        });
+        const result = await createJulesSessionHandler({ task: "do work", pr: 42 });
+        expect(result.id).toBe("1234567890");
+        expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+            "gh", "view", "42"
+        ]);
+        expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+            "agent", "dispatch", "pr-branch", "do work"
+        ]);
+    });
+    it("should throw error if PR view fails", async () => {
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: JSON.stringify({ status: "error", message: "PR not found" }),
+            stderr: "Original error",
+            exitCode: 1,
+            durationMs: 10,
+            command: "td-cli gh view"
+        });
+        await expect(createJulesSessionHandler({ task: "do work", pr: 999 }))
+            .rejects.toThrow("td-cli returned error: PR not found");
+    });
+    it("should throw descriptive error if PR JSON is invalid", async () => {
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: "invalid json",
+            stderr: "",
+            exitCode: 0,
+            durationMs: 10,
+            command: "td-cli gh view"
+        });
+        await expect(createJulesSessionHandler({ task: "do work", pr: 42 }))
+            .rejects.toThrow("td-cli returned non-JSON output with exit code 0: invalid json");
+    });
+});

dev_tools/dist/tools/jules/get-messages.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { runCommand } from "../../lib/shell.js";
+export const GetJulesMessagesInputSchema = z.object({
+    sessionId: z.string(),
+});
+export async function getJulesMessagesHandler(input) {
+    const result = await runCommand("td-cli", ["agent", "messages", input.sessionId]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to get messages: ${result.stderr}`);
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to get messages: ${output.message}`);
+    }
+    return {
+        id: input.sessionId.replace("sessions/", ""),
+        messages: output.messages,
+    };
+}

dev_tools/dist/tools/jules/get-messages.test.js

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { getJulesMessagesHandler } from "./get-messages.js";
+import * as shell from "../../lib/shell.js";
+import { setupTestEnv, teardownTestEnv } from "../../lib/test-utils.js";
+vi.mock("../../lib/shell.js", () => ({
+    runCommand: vi.fn(),
+}));
+describe("getJulesMessagesHandler", () => {
+    beforeEach(() => {
+        setupTestEnv();
+    });
+    afterEach(() => {
+        teardownTestEnv();
+        vi.clearAllMocks();
+    });
+    it("should return messages from td-cli", async () => {
+        const mockMessages = [
+            {
+                role: "user",
+                content: "Hello Jules",
+                time: new Date().toISOString(),
+            },
+            {
+                role: "jules",
+                content: "Applying fixes...",
+                time: new Date().toISOString(),
+            },
+        ];
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: JSON.stringify({ status: "success", messages: mockMessages }),
+            stderr: "",
+            exitCode: 0,
+            durationMs: 0,
+            command: "td-cli agent messages"
+        });
+        const result = await getJulesMessagesHandler({ sessionId: "123" });
+        expect(result.id).toBe("123");
+        expect(result.messages.length).toBe(2);
+        expect(result.messages[0].role).toBe("user");
+        expect(result.messages[0].content).toBe("Hello Jules");
+        expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+            "agent", "messages", "123"
+        ]);
+    });
+});

dev_tools/dist/tools/jules/get-pr.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { runTDCli } from "../../lib/td-cli.js";
+import { parseJulesSession } from "./shared.js";
+export const GetJulesPullRequestInputSchema = z.object({
+    sessionId: z.string(),
+});
+export async function getJulesPullRequestHandler(input) {
+    const output = await runTDCli(["agent", "get-session", input.sessionId]);
+    const session = parseJulesSession(output.session);
+    return {
+        id: session.id,
+        pullRequestUrl: session.pullRequestUrl,
+    };
+}

dev_tools/dist/tools/jules/get-pr.test.js

@@ -0,0 +1,37 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { getJulesPullRequestHandler } from "./get-pr.js";
+import * as shell from "../../lib/shell.js";
+import { setupTestEnv, teardownTestEnv } from "../../lib/test-utils.js";
+vi.mock("../../lib/shell.js", () => ({
+    runCommand: vi.fn(),
+}));
+describe("getJulesPullRequestHandler", () => {
+    beforeEach(() => {
+        setupTestEnv();
+    });
+    afterEach(() => {
+        teardownTestEnv();
+        vi.clearAllMocks();
+    });
+    it("should get PR from td-cli", async () => {
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: JSON.stringify({
+                status: "success",
+                session: {
+                    name: "sessions/123",
+                    outputs: [{ pullRequest: { url: "https://github.com/pr/1" } }]
+                }
+            }),
+            stderr: "",
+            exitCode: 0,
+            durationMs: 0,
+            command: "td-cli agent get-session"
+        });
+        const result = await getJulesPullRequestHandler({ sessionId: "123" });
+        expect(result.id).toBe("123");
+        expect(result.pullRequestUrl).toBe("https://github.com/pr/1");
+        expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+            "agent", "get-session", "123"
+        ]);
+    });
+});

dev_tools/dist/tools/jules/get-session.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { runTDCli } from "../../lib/td-cli.js";
+import { parseJulesSession } from "./shared.js";
+export const GetJulesSessionInputSchema = z.object({
+    sessionId: z.string(),
+});
+export async function getJulesSessionHandler(input) {
+    const output = await runTDCli(["agent", "get-session", input.sessionId]);
+    return parseJulesSession(output.session);
+}

dev_tools/dist/tools/jules/list-sessions.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { runCommand } from "../../lib/shell.js";
+export const ListJulesSessionsInputSchema = z.object({
+    pageSize: z.number().optional(),
+    pageToken: z.string().optional(),
+});
+export async function listJulesSessionsHandler(input) {
+    const result = await runCommand("td-cli", ["agent", "sync"]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to list sessions: ${result.stderr}`);
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to list sessions: ${output.message}`);
+    }
+    const sessions = output.sessions || [];
+    return sessions.map((session) => {
+        const name = session.name || "";
+        const id = name.startsWith("sessions/") ? name.substring(9) : name;
+        let status = "PENDING";
+        if (session.state === "SUCCEEDED" || session.state === "COMPLETED")
+            status = "COMPLETED";
+        else if (session.state === "FAILED" || session.state === "CANCELLED" || session.state === "TERMINATED")
+            status = "FAILED";
+        else if (session.state === "IN_PROGRESS")
+            status = "IN_PROGRESS";
+        let pullRequestUrl;
+        if (session.outputs && Array.isArray(session.outputs)) {
+            for (const out of session.outputs) {
+                if (out.pullRequest && out.pullRequest.url) {
+                    pullRequestUrl = out.pullRequest.url;
+                    break;
+                }
+            }
+        }
+        return {
+            id,
+            status,
+            createdAt: session.createTime ? new Date(session.createTime) : new Date(),
+            pullRequestUrl,
+        };
+    });
+}

dev_tools/dist/tools/jules/send-message.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { runCommand } from "../../lib/shell.js";
+export const SendJulesMessageInputSchema = z.object({
+    sessionId: z.union([z.string(), z.array(z.string())]),
+    message: z.string(),
+});
+export async function sendJulesMessageHandler(input) {
+    const sessionIds = Array.isArray(input.sessionId) ? input.sessionId.join(",") : input.sessionId;
+    const result = await runCommand("td-cli", ["agent", "send", sessionIds, input.message]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to send message: ${result.stderr}`);
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to send message: ${output.message}`);
+    }
+    return {
+        id: Array.isArray(input.sessionId) ? input.sessionId.map(id => id.replace("sessions/", "")) : input.sessionId.replace("sessions/", ""),
+        status: "success",
+        message: "Message sent successfully",
+    };
+}

dev_tools/dist/tools/jules/send-message.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { sendJulesMessageHandler } from "./send-message.js";
+import * as shell from "../../lib/shell.js";
+import { setupTestEnv, teardownTestEnv } from "../../lib/test-utils.js";
+vi.mock("../../lib/shell.js", () => ({
+    runCommand: vi.fn(),
+}));
+describe("sendJulesMessageHandler", () => {
+    beforeEach(() => {
+        setupTestEnv();
+    });
+    afterEach(() => {
+        teardownTestEnv();
+        vi.clearAllMocks();
+    });
+    it("should send a message via td-cli", async () => {
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: JSON.stringify({ status: "success", message: "Message sent successfully" }),
+            stderr: "",
+            exitCode: 0,
+            durationMs: 0,
+            command: "td-cli agent send"
+        });
+        const result = await sendJulesMessageHandler({ sessionId: "123", message: "hi" });
+        expect(result.id).toBe("123");
+        expect(result.status).toBe("success");
+        expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+            "agent", "send", "123", "hi"
+        ]);
+    });
+    it("should support batch message sending", async () => {
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: JSON.stringify({
+                status: "success",
+                message: "Batch send completed. 2/2 successful.",
+                results: [
+                    { sessionId: "s1", status: "success" },
+                    { sessionId: "s2", status: "success" }
+                ]
+            }),
+            stderr: "",
+            exitCode: 0,
+            durationMs: 0,
+            command: "td-cli agent send"
+        });
+        const result = await sendJulesMessageHandler({
+            sessionId: ["sessions/s1", "sessions/s2"],
+            message: "hi batch"
+        });
+        expect(result.id).toEqual(["s1", "s2"]);
+        expect(result.status).toBe("success");
+        expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+            "agent", "send", "sessions/s1,sessions/s2", "hi batch"
+        ]);
+    });
+});

dev_tools/dist/tools/jules/shared.js

@@ -0,0 +1,26 @@
+export function parseJulesSession(data) {
+    const name = data.name || "";
+    const id = name.startsWith("sessions/") ? name.substring(9) : name;
+    let status = "PENDING";
+    if (data.state === "SUCCEEDED" || data.state === "COMPLETED")
+        status = "COMPLETED";
+    else if (data.state === "FAILED" || data.state === "CANCELLED" || data.state === "TERMINATED")
+        status = "FAILED";
+    else if (data.state === "IN_PROGRESS")
+        status = "IN_PROGRESS";
+    let pullRequestUrl;
+    if (data.outputs && Array.isArray(data.outputs)) {
+        for (const out of data.outputs) {
+            if (out.pullRequest && out.pullRequest.url) {
+                pullRequestUrl = out.pullRequest.url;
+                break;
+            }
+        }
+    }
+    return {
+        id,
+        status,
+        createdAt: data.createTime ? new Date(data.createTime) : new Date(),
+        pullRequestUrl,
+    };
+}

dev_tools/dist/tools/jules/trigger-feedback.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { runCommand } from "../../lib/shell.js";
+export const TriggerJulesFeedbackInputSchema = z.object({
+    sessionId: z.string(),
+});
+export async function triggerJulesFeedbackHandler(input) {
+    const result = await runCommand("td-cli", ["agent", "trigger-feedback", input.sessionId]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to trigger feedback: ${result.stderr}`);
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to trigger feedback: ${output.message}`);
+    }
+    return output;
+}

dev_tools/dist/tools/jules/trigger-feedback.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { triggerJulesFeedbackHandler } from "./trigger-feedback.js";
+import * as shell from "../../lib/shell.js";
+import { setupTestEnv, teardownTestEnv } from "../../lib/test-utils.js";
+vi.mock("../../lib/shell.js", () => ({
+    runCommand: vi.fn(),
+}));
+describe("triggerJulesFeedbackHandler", () => {
+    beforeEach(() => {
+        setupTestEnv();
+    });
+    afterEach(() => {
+        teardownTestEnv();
+        vi.clearAllMocks();
+    });
+    it("should return success output from td-cli", async () => {
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: JSON.stringify({ status: "success", feedback: "All checks passed successfully. You may proceed." }),
+            stderr: "",
+            exitCode: 0,
+            durationMs: 0,
+            command: "td-cli agent trigger-feedback"
+        });
+        const result = await triggerJulesFeedbackHandler({ sessionId: "123" });
+        expect(result.status).toBe("success");
+        expect(result.feedback).toBe("All checks passed successfully. You may proceed.");
+        expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+            "agent", "trigger-feedback", "123"
+        ]);
+    });
+    it("should throw error if td-cli returns error", async () => {
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: JSON.stringify({ status: "error", message: "Session not found" }),
+            stderr: "",
+            exitCode: 0,
+            durationMs: 0,
+            command: "td-cli agent trigger-feedback"
+        });
+        await expect(triggerJulesFeedbackHandler({ sessionId: "123" }))
+            .rejects.toThrow("Failed to trigger feedback: Session not found");
+    });
+});

dev_tools/dist/tools/repo.commit_patch.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const CommitPatchInputSchema = z.object({
+    worktreePath: z.string(),
+    message: z.string(),
+    allowedFiles: z.array(z.string()),
+    writeMode: z.boolean().optional().default(false),
+});
+export async function commitPatchHandler(args) {
+    if (!args.writeMode) {
+        throw new Error("writeMode must be true to commit changes.");
+    }
+    const statusResult = await runCommand("git", ["status", "--porcelain"], { cwd: args.worktreePath });
+    const changedFiles = statusResult.stdout.trim().split("\n").filter(l => l.length > 0).map(l => l.substring(3));
+    const forbiddenFiles = changedFiles.filter(f => !args.allowedFiles.includes(f));
+    if (forbiddenFiles.length > 0) {
+        throw new Error(`The following files are not in the allowed list: ${forbiddenFiles.join(", ")}`);
+    }
+    if (changedFiles.length === 0) {
+        throw new Error("No changes to commit.");
+    }
+    await runCommand("git", ["add", "."], { cwd: args.worktreePath });
+    const commitResult = await runCommand("git", ["commit", "-m", args.message], { cwd: args.worktreePath });
+    if (commitResult.exitCode !== 0) {
+        throw new Error(`Failed to commit: ${commitResult.stderr}`);
+    }
+    const shaResult = await runCommand("git", ["rev-parse", "HEAD"], { cwd: args.worktreePath });
+    return {
+        success: true,
+        commitSha: shaResult.stdout.trim(),
+        changedFiles
+    };
+}

dev_tools/dist/tools/repo.create_branch.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const CreateBranchInputSchema = z.object({
+    branchName: z.string(),
+    baseBranch: z.string().optional().default("main"),
+});
+export async function createBranchHandler(args) {
+    const params = CreateBranchInputSchema.parse(args);
+    // Ensure latest base branch
+    await runCommand("git", ["fetch", "origin", params.baseBranch]);
+    // Create branch from origin base branch
+    const result = await runCommand("git", ["checkout", "-b", params.branchName, `origin/${params.baseBranch}`]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to create branch ${params.branchName}: ${result.stderr}`);
+    }
+    return {
+        success: true,
+        branchName: params.branchName,
+        baseBranch: params.baseBranch
+    };
+}

dev_tools/dist/tools/repo.create_branch.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createBranchHandler } from "./repo.create_branch.js";
+import * as shell from "../lib/shell.js";
+vi.mock("../lib/shell.js", () => ({
+    runCommand: vi.fn(),
+}));
+describe("repo.create_branch", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should create a new branch from a base branch", async () => {
+        const args = {
+            branchName: "new-feature",
+            baseBranch: "main",
+        };
+        shell.runCommand.mockResolvedValue({ exitCode: 0, stdout: "", stderr: "" });
+        const result = await createBranchHandler(args);
+        expect(shell.runCommand).toHaveBeenCalledWith("git", ["fetch", "origin", "main"]);
+        expect(shell.runCommand).toHaveBeenCalledWith("git", ["checkout", "-b", "new-feature", "origin/main"]);
+        expect(result).toEqual({
+            success: true,
+            branchName: "new-feature",
+            baseBranch: "main",
+        });
+    });
+    it("should use default base branch 'main' if not provided", async () => {
+        const args = {
+            branchName: "another-feature",
+        };
+        shell.runCommand.mockResolvedValue({ exitCode: 0, stdout: "", stderr: "" });
+        const result = await createBranchHandler(args);
+        expect(shell.runCommand).toHaveBeenCalledWith("git", ["fetch", "origin", "main"]);
+        expect(shell.runCommand).toHaveBeenCalledWith("git", ["checkout", "-b", "another-feature", "origin/main"]);
+    });
+    it("should throw error if git command fails", async () => {
+        const args = {
+            branchName: "fail-branch",
+        };
+        shell.runCommand.mockResolvedValue({ exitCode: 1, stdout: "", stderr: "Error creating branch" });
+        await expect(createBranchHandler(args)).rejects.toThrow("Failed to create branch fail-branch: Error creating branch");
+    });
+});

dev_tools/dist/tools/repo.create_repair_branch.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+import { createWorktree } from "../lib/git.js";
+export const CreateRepairBranchInputSchema = z.object({
+    prNumber: z.number(),
+    repairBranchName: z.string().optional(),
+    writeMode: z.boolean().optional().default(false),
+});
+export async function createRepairBranchHandler(args) {
+    if (!args.writeMode) {
+        throw new Error("writeMode must be true to create a repair branch.");
+    }
+    const prResult = await runCommand("gh", [
+        "pr",
+        "view",
+        args.prNumber.toString(),
+        "--json", "headRefName,baseRefName,title"
+    ]);
+    if (prResult.exitCode !== 0) {
+        throw new Error(`Failed to get PR info: ${prResult.stderr}`);
+    }
+    const { headRefName, baseRefName, title } = JSON.parse(prResult.stdout);
+    const sanitizedTitle = title.toLowerCase().replace(/[^a-z0-9]/g, "-").substring(0, 30);
+    const repairBranch = args.repairBranchName || `agent/repair-pr-${args.prNumber}-${sanitizedTitle}`;
+    // Ensure latest
+    await runCommand("git", ["fetch", "origin", headRefName]);
+    await runCommand("git", ["fetch", "origin", baseRefName]);
+    const worktreePath = await createWorktree(`origin/${headRefName}`, args.prNumber);
+    // Create the actual repair branch in the worktree
+    await runCommand("git", ["checkout", "-b", repairBranch], { cwd: worktreePath });
+    return {
+        prNumber: args.prNumber,
+        originalBranch: headRefName,
+        repairBranch,
+        baseBranch: baseRefName,
+        worktreePath
+    };
+}

dev_tools/dist/tools/repo.get_changed_files.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const GetChangedFilesInputSchema = z.object({
+    base: z.string().optional().default("main"),
+    head: z.string().optional().default("HEAD"),
+});
+export async function getChangedFilesHandler(args) {
+    const result = await runCommand("git", [
+        "diff",
+        "--name-status",
+        `${args.base}...${args.head}`
+    ]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to get changed files: ${result.stderr}`);
+    }
+    const files = result.stdout.trim().split("\n").filter(line => line.length > 0).map(line => {
+        const [status, path] = line.split(/\s+/);
+        return { status, path };
+    });
+    return { files };
+}

dev_tools/dist/tools/repo.get_command_schema.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const GetCommandSchemaInputSchema = z.object({
+    commandPath: z.string().describe("The CLI command path to retrieve the schema for (e.g. 'gh audit-pr')"),
+});
+export async function getCommandSchemaHandler(args) {
+    // Sanitize input to prevent command injection (allow only alphanumeric, spaces, hyphens, and underscores)
+    const sanitizedPath = args.commandPath.replace(/[^a-zA-Z0-9-_ ]/g, "");
+    const result = await runCommand("td-cli", ["schema", sanitizedPath]);
+    if (result.exitCode !== 0) {
+        // Log stderr for debugging but don't expose it to the user
+        // Using comma-separated arguments to satisfy semgrep unsafe-formatstring
+        console.error("td-cli schema failed for", sanitizedPath, ":", result.stderr);
+        throw new Error(`Failed to get command schema for '${sanitizedPath}'`);
+    }
+    try {
+        const parsed = JSON.parse(result.stdout);
+        if (parsed.status === "error") {
+            throw new Error(parsed.message || "Failed to get command schema");
+        }
+        // Return the full payload (which contains the 'schema' object)
+        return parsed;
+    }
+    catch (e) {
+        throw new Error(`Failed to parse command schema output: ${e}`);
+    }
+}