boomtick-cli 0.2.1__py3-none-any.whl

dev_tools/dist/tools/ddgs.search.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const DdgsSearchInputSchema = z.object({
+    query: z.string(),
+    maxResults: z.number().optional().default(5),
+});
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function ddgsSearchHandler(args) {
+    const scriptPath = path.join(__dirname, "ddgs_search.py");
+    // Sanitize query by removing control characters, newlines, and null bytes
+    // eslint-disable-next-line no-control-regex
+    const safeQuery = args.query.replace(/[\x00-\x1F\x7F-\x9F]/g, " ").trim();
+    if (!safeQuery) {
+        throw new Error("Query cannot be empty after sanitization.");
+    }
+    const result = await runCommand("python3", [scriptPath, safeQuery, (args.maxResults ?? 5).toString()]);
+    // duckduckgo_search logs annoying deprecation warnings to stderr we want to ignore
+    // if it really failed, exitCode will be non-zero and we'll have stdout/stderr
+    if (result.exitCode !== 0) {
+        let parsedError = result.stderr || result.stdout;
+        const lines = parsedError.split("\n");
+        for (const line of lines) {
+            try {
+                const json = JSON.parse(line);
+                if (json.error) {
+                    parsedError = json.error;
+                    break;
+                }
+            }
+            catch {
+                // continue
+            }
+        }
+        throw new Error(`Failed to search ddgs: ${parsedError}`);
+    }
+    try {
+        const data = JSON.parse(result.stdout);
+        if (!Array.isArray(data)) {
+            throw new Error("Expected an array of search results");
+        }
+        return { results: data };
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to parse ddgs search results. Error: ${message}. Output was: ${result.stdout}`);
+    }
+}

dev_tools/dist/tools/ddgs.search.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ddgsSearchHandler } from "./ddgs.search.js";
+import { runCommand } from "../lib/shell.js";
+vi.mock("../lib/shell.js");
+describe("ddgsSearchHandler", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it("should parse arguments, sanitize query, and return search results", async () => {
+        const mockOutput = JSON.stringify([
+            { title: "Result 1", href: "https://example.com/1", body: "Description 1" },
+            { title: "Result 2", href: "https://example.com/2", body: "Description 2" },
+        ]);
+        vi.mocked(runCommand).mockResolvedValue({
+            stdout: mockOutput,
+            stderr: "",
+            exitCode: 0,
+            durationMs: 100,
+            command: "mock python3",
+        });
+        const result = await ddgsSearchHandler({ query: "test\nquery\x00", maxResults: 2 });
+        expect(runCommand).toHaveBeenCalledTimes(1);
+        expect(runCommand).toHaveBeenCalledWith("python3", [expect.stringContaining("ddgs_search.py"), "test query", "2"]);
+        expect(result.results).toHaveLength(2);
+        expect(result.results[0].title).toBe("Result 1");
+    });
+    it("should handle raw error when python script exits with non-zero code and non-JSON output", async () => {
+        vi.mocked(runCommand).mockResolvedValue({
+            stdout: "",
+            stderr: "Python script failed",
+            exitCode: 1,
+            durationMs: 100,
+            command: "mock python3",
+        });
+        await expect(ddgsSearchHandler({ query: "test query", maxResults: 2 })).rejects.toThrow("Failed to search ddgs: Python script failed");
+    });
+    it("should handle parsed JSON error when python script exits with non-zero code", async () => {
+        vi.mocked(runCommand).mockResolvedValue({
+            stdout: "",
+            stderr: JSON.stringify({ error: "Structured JSON error" }),
+            exitCode: 1,
+            durationMs: 100,
+            command: "mock python3",
+        });
+        await expect(ddgsSearchHandler({ query: "test query", maxResults: 2 })).rejects.toThrow("Failed to search ddgs: Structured JSON error");
+    });
+    it("should handle error when python output is not an array", async () => {
+        vi.mocked(runCommand).mockResolvedValue({
+            stdout: JSON.stringify({ error: "Something went wrong" }),
+            stderr: "",
+            exitCode: 0,
+            durationMs: 100,
+            command: "mock python3",
+        });
+        await expect(ddgsSearchHandler({ query: "test query", maxResults: 2 })).rejects.toThrow("Expected an array of search results");
+    });
+    it("should handle error when python output cannot be parsed", async () => {
+        vi.mocked(runCommand).mockResolvedValue({
+            stdout: "invalid json",
+            stderr: "",
+            exitCode: 0,
+            durationMs: 100,
+            command: "mock python3",
+        });
+        await expect(ddgsSearchHandler({ query: "test query", maxResults: 2 })).rejects.toThrow("Failed to parse ddgs search results");
+    });
+});

dev_tools/dist/tools/ddgs_search.py

@@ -0,0 +1,23 @@
+# pylint: disable=line-too-long
+"""DuckDuckGo Search tool."""
+import json
+import sys
+
+try:
+    from duckduckgo_search import DDGS
+except ImportError:
+    print(json.dumps({"error": "duckduckgo_search package not found. Please install it using 'pip install duckduckgo-search' (preferably in a virtual environment)."}), file=sys.stderr)
+    sys.exit(1)
+
+if len(sys.argv) != 3:
+    print(json.dumps({"error": f"Invalid argument count. Expected 2 (query, max_results), got {len(sys.argv) - 1}."}), file=sys.stderr)
+    sys.exit(1)
+
+try:
+    query = sys.argv[1]
+    max_results = int(sys.argv[2])
+    results = DDGS().text(query, max_results=max_results)
+    print(json.dumps(list(results)))
+except Exception as e:
+    print(json.dumps({"error": str(e)}), file=sys.stderr)
+    sys.exit(1)

dev_tools/dist/tools/github.checkout_branch.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const CheckoutBranchInputSchema = z.object({
+    branch: z.string(),
+    worktreePath: z.string().optional(),
+});
+export async function checkoutBranchHandler(args) {
+    const result = await runCommand("td-cli", ["gh", "checkout", args.branch], { cwd: args.worktreePath });
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to checkout branch ${args.branch}: ${result.stderr}`);
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to checkout branch: ${output.message}`);
+    }
+    return {
+        success: true,
+        branch: args.branch
+    };
+}

dev_tools/dist/tools/github.comment_triage_summary.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const CommentTriageSummaryInputSchema = z.object({
+    prNumber: z.number(),
+    body: z.string(),
+});
+export async function commentTriageSummaryHandler(args) {
+    const result = await runCommand("td-cli", [
+        "gh",
+        "post-comment",
+        "--pr", args.prNumber.toString(),
+        "--body", args.body
+    ]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to comment on PR: ${result.stderr}`);
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to comment on PR: ${output.message}`);
+    }
+    return {
+        success: true,
+        commentUrl: output.html_url || output.url
+    };
+}

dev_tools/dist/tools/github.create_issue.js

@@ -0,0 +1,28 @@
+import { runCommand } from "../lib/shell.js";
+import { sanitizeError } from "../lib/error_utils.js";
+import { CreateIssueInputSchema, CreateIssueResponseSchema } from "./contract.js";
+export { CreateIssueInputSchema };
+export async function createIssueHandler(args) {
+    const params = CreateIssueInputSchema.parse(args);
+    const cmdArgs = ["gh", "create-issue", "--title", params.title];
+    if (params.body)
+        cmdArgs.push("--body", params.body);
+    if (params.file)
+        cmdArgs.push("--file", params.file);
+    const result = await runCommand("td-cli", cmdArgs);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to create issue: ${sanitizeError(result.stderr)}`);
+    }
+    let output;
+    try {
+        output = JSON.parse(result.stdout);
+    }
+    catch (e) {
+        throw new Error(`Failed to parse CLI output: ${result.stdout}`);
+    }
+    const parsedOutput = CreateIssueResponseSchema.parse(output);
+    if (parsedOutput.status === "error") {
+        throw new Error(`Failed to create issue: ${parsedOutput.message}`);
+    }
+    return { status: "success", issue: parsedOutput.issue };
+}

dev_tools/dist/tools/github.create_issue.test.js

@@ -0,0 +1,54 @@
+import { describe, it, expect, vi } from "vitest";
+import { createIssueHandler } from "./github.create_issue.js";
+import * as shell from "../lib/shell.js";
+vi.mock("../lib/shell.js", () => ({
+    runCommand: vi.fn()
+}));
+describe("github.create_issue", () => {
+    it("should create an issue successfully", async () => {
+        const mockResponse = {
+            status: "success",
+            issue: {
+                number: 123,
+                title: "Test Issue",
+                html_url: "https://github.com/owner/repo/issues/123",
+                state: "open"
+            }
+        };
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: JSON.stringify(mockResponse),
+            stderr: "",
+            exitCode: 0,
+            durationMs: 10,
+            command: "td-cli gh create-issue --title 'Test Issue' --body 'Test Body'"
+        });
+        const result = await createIssueHandler({ title: "Test Issue", body: "Test Body", file: null });
+        expect(result.status).toBe("success");
+        expect(result.issue?.number).toBe(123);
+        expect(result.issue?.title).toBe("Test Issue");
+    });
+    it("should throw error on command failure", async () => {
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: "",
+            stderr: "Auth failed",
+            exitCode: 1,
+            durationMs: 10,
+            command: "td-cli gh create-issue"
+        });
+        await expect(createIssueHandler({ title: "Test Issue", body: "Test Body", file: null })).rejects.toThrow("Failed to create issue: Auth failed");
+    });
+    it("should handle error status from CLI output", async () => {
+        const mockResponse = {
+            status: "error",
+            message: "Repo not found"
+        };
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: JSON.stringify(mockResponse),
+            stderr: "",
+            exitCode: 0,
+            durationMs: 10,
+            command: "td-cli gh create-issue"
+        });
+        await expect(createIssueHandler({ title: "Test Issue", body: "Test Body", file: null })).rejects.toThrow("Failed to create issue: Repo not found");
+    });
+});

dev_tools/dist/tools/github.create_pull_request.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const CreatePullRequestInputSchema = z.object({
+    title: z.string(),
+    body: z.string(),
+    head: z.string(),
+    base: z.string().optional().default("main"),
+    draft: z.boolean().optional().default(false),
+});
+export async function createPullRequestHandler(args) {
+    const tdArgs = [
+        "gh",
+        "create-pr",
+        "--title", args.title,
+        "--body", args.body,
+        "--head", args.head,
+        "--base", args.base
+    ];
+    if (args.draft) {
+        tdArgs.push("--draft");
+    }
+    const result = await runCommand("td-cli", tdArgs);
+    if (result.exitCode !== 0) {
+        // Attempt to parse stdout as JSON to see if there's a structured error message
+        try {
+            const errorOutput = JSON.parse(result.stdout);
+            if (errorOutput.status === "error") {
+                throw new Error(`Failed to create pull request: ${errorOutput.message}`);
+            }
+        }
+        catch (e) {
+            // If parsing fails, fall back to stderr or a generic message
+        }
+        throw new Error(`Failed to create pull request: ${result.stderr || result.stdout || "Unknown error"}`);
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to create pull request: ${output.message}`);
+    }
+    return {
+        success: true,
+        url: output.pr.html_url
+    };
+}

dev_tools/dist/tools/github.get_merge_conflict_files.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const GetMergeConflictFilesInputSchema = z.object({
+    prNumber: z.number(),
+    baseBranch: z.string().optional().default("main"),
+});
+export async function getMergeConflictFilesHandler(args) {
+    const result = await runCommand("td-cli", [
+        "gh", "merge-conflicts", args.prNumber.toString(),
+        "--base", args.baseBranch || "main"
+    ]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to get merge conflicts: ${result.stderr}`);
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to get merge conflicts: ${output.message}`);
+    }
+    return {
+        prNumber: output.prNumber,
+        baseBranch: output.baseBranch,
+        headRef: output.headRef,
+        conflictFiles: output.conflictFiles,
+        commandLog: output.commandLog
+    };
+}

dev_tools/dist/tools/github.get_pr.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+import { sanitizeError } from "../lib/error_utils.js";
+export const GetPrInputSchema = z.object({
+    prNumber: z.number().describe("The number of the PR to view."),
+});
+export async function getPrHandler(args) {
+    const params = GetPrInputSchema.parse(args);
+    const result = await runCommand("td-cli", ["gh", "view", params.prNumber.toString()]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to get PR details: ${sanitizeError(result.stderr)}`);
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to get PR details: ${output.message}`);
+    }
+    return { pr: output.pr };
+}

dev_tools/dist/tools/github.get_pr_diff.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const GetPrDiffInputSchema = z.object({
+    prNumber: z.number(),
+});
+export async function getPrDiffHandler(args) {
+    const result = await runCommand("td-cli", [
+        "gh", "pr-diff", args.prNumber.toString()
+    ]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to get PR diff: ${result.stderr}`);
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to get PR diff: ${output.message}`);
+    }
+    // Every TypeScript tool file must be a pure routing shim
+    return {
+        prNumber: output.prNumber,
+        files: output.files,
+        diffText: output.diffText,
+        truncated: output.truncated
+    };
+}

dev_tools/dist/tools/github.issue_comment.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+import { sanitizeError } from "../lib/error_utils.js";
+export const IssueCommentInputSchema = z.object({
+    issueNumber: z.number().describe("The number of the issue to comment on."),
+    body: z.string().min(1, "Comment body cannot be empty").describe("The content of the comment."),
+});
+const IssueCommentOutputSchema = z.object({
+    status: z.string(),
+    comment: z.any().optional(),
+    message: z.string().optional(),
+});
+export async function issueCommentHandler(args) {
+    const params = IssueCommentInputSchema.parse(args);
+    const result = await runCommand("td-cli", ["gh", "issue-comment", params.issueNumber.toString(), "--body", params.body]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to post comment: ${sanitizeError(result.stderr)}`);
+    }
+    const output = IssueCommentOutputSchema.parse(JSON.parse(result.stdout));
+    if (output.status === "error") {
+        throw new Error(`Failed to post comment: ${output.message}`);
+    }
+    return { status: "success", comment: output.comment };
+}

dev_tools/dist/tools/github.issue_update.js

@@ -0,0 +1,29 @@
+import { runCommand } from "../lib/shell.js";
+import { sanitizeError } from "../lib/error_utils.js";
+import { IssueUpdateInputSchema, IssueUpdateResponseSchema } from "./contract.js";
+export { IssueUpdateInputSchema };
+export async function issueUpdateHandler(args) {
+    const params = IssueUpdateInputSchema.parse(args);
+    const cmdArgs = ["gh", "issue-update", params.issueNumber.toString()];
+    if (params.body)
+        cmdArgs.push("--body", params.body);
+    if (params.file)
+        cmdArgs.push("--file", params.file);
+    if (params.labels && params.labels.length > 0)
+        cmdArgs.push("--labels", params.labels.join(","));
+    if (params.addLabels && params.addLabels.length > 0)
+        cmdArgs.push("--add-labels", params.addLabels.join(","));
+    if (params.removeLabels && params.removeLabels.length > 0)
+        cmdArgs.push("--remove-labels", params.removeLabels.join(","));
+    if (params.state)
+        cmdArgs.push("--state", params.state);
+    const result = await runCommand("td-cli", cmdArgs);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to update issue: ${sanitizeError(result.stderr)}`);
+    }
+    const output = IssueUpdateResponseSchema.parse(JSON.parse(result.stdout));
+    if (output.status === "error") {
+        throw new Error(`Failed to update issue: ${output.message}`);
+    }
+    return { status: "success", issue: output.issue };
+}

dev_tools/dist/tools/github.issue_view.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+import { sanitizeError } from "../lib/error_utils.js";
+export const IssueViewInputSchema = z.object({
+    issueNumber: z.number().describe("The number of the issue to view."),
+});
+const IssueViewOutputSchema = z.object({
+    status: z.string(),
+    issue: z.object({
+        number: z.number(),
+        title: z.string(),
+        body: z.string().nullable().optional(),
+        state: z.string(),
+    }).optional(),
+    message: z.string().optional(),
+});
+export async function issueViewHandler(args) {
+    const params = IssueViewInputSchema.parse(args);
+    const result = await runCommand("td-cli", ["gh", "issue-view", params.issueNumber.toString()]);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to view issue: ${sanitizeError(result.stderr)}`);
+    }
+    const output = IssueViewOutputSchema.parse(JSON.parse(result.stdout));
+    if (output.status === "error") {
+        throw new Error(`Failed to view issue: ${output.message}`);
+    }
+    return { issue: output.issue };
+}

dev_tools/dist/tools/github.open_replacement_pr.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const OpenReplacementPrInputSchema = z.object({
+    originalPrNumber: z.number(),
+    repairBranch: z.string(),
+    baseBranch: z.string(),
+    title: z.string(),
+    body: z.string(),
+    draft: z.boolean().optional().default(true),
+    worktreePath: z.string().optional(),
+    pushMode: z.boolean().optional().default(false),
+});
+export async function openReplacementPrHandler(args) {
+    if (!args.pushMode) {
+        throw new Error("pushMode must be true to push and open a replacement PR.");
+    }
+    // Push the branch
+    const pushResult = await runCommand("git", ["push", "origin", args.repairBranch], { cwd: args.worktreePath });
+    if (pushResult.exitCode !== 0) {
+        throw new Error(`Failed to push branch: ${pushResult.stderr}`);
+    }
+    const prArgs = [
+        "pr",
+        "create",
+        "--base", args.baseBranch,
+        "--head", args.repairBranch,
+        "--title", args.title,
+        "--body", args.body
+    ];
+    if (args.draft) {
+        prArgs.push("--draft");
+    }
+    const result = await runCommand("gh", prArgs, { cwd: args.worktreePath });
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to open replacement PR: ${result.stderr}`);
+    }
+    return {
+        success: true,
+        url: result.stdout.trim()
+    };
+}

dev_tools/dist/tools/github.search_open_prs.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const SearchOpenPrsInputSchema = z.object({
+    state: z.enum(["open", "closed", "all"]).optional().default("open"),
+    includeDrafts: z.boolean().optional().default(true),
+    limit: z.number().min(1).max(100).optional().default(100),
+    labels: z.array(z.string()).optional(),
+});
+export async function searchOpenPrsHandler(args) {
+    const params = SearchOpenPrsInputSchema.parse(args);
+    const tdArgs = [
+        "gh", "search-prs",
+        "--state", params.state,
+        "--limit", params.limit.toString(),
+    ];
+    if (!params.includeDrafts) {
+        tdArgs.push("--no-include-drafts");
+    }
+    if (params.labels && params.labels.length > 0) {
+        tdArgs.push("--labels", params.labels.join(","));
+    }
+    const result = await runCommand("td-cli", tdArgs);
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to list PRs: ${result.stderr}`);
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to list PRs: ${output.message}`);
+    }
+    return { prs: output.prs };
+}

dev_tools/dist/tools/github.search_open_prs.test.js

@@ -0,0 +1,51 @@
+import { describe, it, expect, vi } from "vitest";
+import { searchOpenPrsHandler } from "./github.search_open_prs.js";
+import * as shell from "../lib/shell.js";
+vi.mock("../lib/shell.js", () => ({
+    runCommand: vi.fn()
+}));
+describe("github.search_open_prs", () => {
+    it("should return normalized PR objects", async () => {
+        const mockResponse = {
+            status: "success",
+            prs: [
+                { number: 1, title: "Test PR", author: { login: "user" }, isDraft: false }
+            ]
+        };
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: JSON.stringify(mockResponse),
+            stderr: "",
+            exitCode: 0,
+            durationMs: 10,
+            command: "gh pr list"
+        });
+        const result = await searchOpenPrsHandler({ state: "open", limit: 1, includeDrafts: true });
+        expect(result.prs).toHaveLength(1);
+        expect(result.prs[0].number).toBe(1);
+    });
+    it("should handle empty PR list", async () => {
+        const mockResponse = {
+            status: "success",
+            prs: []
+        };
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: JSON.stringify(mockResponse),
+            stderr: "",
+            exitCode: 0,
+            durationMs: 10,
+            command: "gh pr list"
+        });
+        const result = await searchOpenPrsHandler({ state: "open", limit: 10, includeDrafts: true });
+        expect(result.prs).toHaveLength(0);
+    });
+    it("should throw error on command failure", async () => {
+        vi.mocked(shell.runCommand).mockResolvedValue({
+            stdout: "",
+            stderr: "Auth failed",
+            exitCode: 1,
+            durationMs: 10,
+            command: "gh pr list"
+        });
+        await expect(searchOpenPrsHandler({ state: "open", limit: 10, includeDrafts: true })).rejects.toThrow("Failed to list PRs: Auth failed");
+    });
+});

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

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

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

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { runTDCli } from "../../lib/td-cli.js";
+import { parseJulesSession } from "./shared.js";
+export const CreateJulesSessionInputSchema = z.object({
+    task: z.string(),
+    branch: z.string().optional(),
+    pr: z.number().optional(),
+});
+export async function createJulesSessionHandler(input) {
+    let branch = input.branch;
+    if (!branch && input.pr) {
+        const prData = await runTDCli(["gh", "view", input.pr.toString()]);
+        branch = prData.pr.headRefName;
+    }
+    if (!branch) {
+        branch = process.env.DEFAULT_BASE_BRANCH || "main";
+    }
+    const output = await runTDCli(["agent", "dispatch", branch, input.task]);
+    return parseJulesSession(output.session || output);
+}