Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

Add stacked git actions flow

Julius Marminge39390c0b9a87
diff --git a/apps/server/src/codexTextGenerator.ts b/apps/server/src/codexTextGenerator.ts
new file mode 100644
index 000000000..fac58a2f8
--- /dev/null
+++ b/apps/server/src/codexTextGenerator.ts
@@ -0,0 +1,232 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import type {
+ CommitMessageGenerationInput,
+ CommitMessageGenerationResult,
+ PrContentGenerationInput,
+ PrContentGenerationResult,
+ TextGenerationService,
+} from "./coreServices";
+import { runProcess } from "./processRunner";
+
+const COMMIT_OUTPUT_SCHEMA_JSON = {
+ type: "object",
+ properties: {
+ subject: { type: "string" },
+ body: { type: "string" },
+ },
+ required: ["subject", "body"],
+ additionalProperties: false,
+} as const;
+
+const PR_OUTPUT_SCHEMA_JSON = {
+ type: "object",
+ properties: {
+ title: { type: "string" },
+ body: { type: "string" },
+ },
+ required: ["title", "body"],
+ additionalProperties: false,
+} as const;
+
+function parseCommitOutput(raw: unknown): { subject: string; body: string } {
+ if (!raw || typeof raw !== "object") {
+ throw new Error("Codex returned a non-object commit message payload.");
+ }
+ const record = raw as Record<string, unknown>;
+ const subject = typeof record.subject === "string" ? record.subject.trim() : "";
+ const body = typeof record.body === "string" ? record.body : "";
+ if (subject.length === 0) {
+ throw new Error("Codex returned an empty commit subject.");
+ }
+ return { subject, body };
+}
+
+function parsePrOutput(raw: unknown): { title: string; body: string } {
+ if (!raw || typeof raw !== "object") {
+ throw new Error("Codex returned a non-object PR payload.");
+ }
+ const record = raw as Record<string, unknown>;
+ const title = typeof record.title === "string" ? record.title.trim() : "";
+ const body = typeof record.body === "string" ? record.body.trim() : "";
+ if (title.length === 0 || body.length === 0) {
+ throw new Error("Codex returned an invalid PR title/body payload.");
+ }
+ return { title, body };
+}
+
+function limitSection(value: string, maxChars: number): string {
+ if (value.length <= maxChars) return value;
+ const truncated = value.slice(0, maxChars);
+ return `${truncated}\n\n[truncated]`;
+}
+
+async function writeTempFile(prefix: string, content: string): Promise<string> {
+ const filePath = path.join(
+ os.tmpdir(),
+ `t3code-${prefix}-${process.pid}-${randomUUID()}.tmp`,
+ );
+ await fs.writeFile(filePath, content, "utf8");
+ return filePath;
+}
+
+async function safeUnlink(filePath: string): Promise<void> {
+ try {
+ await fs.unlink(filePath);
+ } catch {
+ // Best-effort cleanup.
+ }
+}
+
+function sanitizeCommitSubject(raw: string): string {
+ const singleLine = raw.trim().split(/\r?\n/g)[0]?.trim() ?? "";
+ const withoutTrailingPeriod = singleLine.replace(/[.]+$/g, "").trim();
+ if (withoutTrailingPeriod.length === 0) {
+ return "Update project files";
+ }
+
+ if (withoutTrailingPeriod.length <= 72) {
+ return withoutTrailingPeriod;
+ }
+ return withoutTrailingPeriod.slice(0, 72).trimEnd();
+}
+
+function sanitizePrTitle(raw: string): string {
+ const singleLine = raw.trim().split(/\r?\n/g)[0]?.trim() ?? "";
+ if (singleLine.length > 0) {
+ return singleLine;
+ }
+ return "Update project changes";
+}
+
+async function runCodexJson<T>({
+ cwd,
+ prompt,
+ outputSchemaJson,
+ parse,
+}: {
+ cwd: string;
+ prompt: string;
+ outputSchemaJson: object;
+ parse: (raw: unknown) => T;
+}): Promise<T> {
+ const schemaPath = await writeTempFile(
+ "codex-schema",
+ JSON.stringify(outputSchemaJson),
+ );
+ const outputPath = await writeTempFile("codex-output", "");
+
+ try {
+ await runProcess(
+ "codex",
+ [
+ "exec",
+ "--ephemeral",
+ "-s",
+ "read-only",
+ "--output-schema",
+ schemaPath,
+ "--output-last-message",
+ outputPath,
+ "-",
+ ],
+ {
+ cwd,
+ timeoutMs: 180_000,
+ stdin: prompt,
+ },
+ );
+
+ const rawOutput = (await fs.readFile(outputPath, "utf8")).trim();
+ if (rawOutput.length === 0) {
+ throw new Error("Codex returned an empty response.");
+ }
+
+ let parsedJson: unknown;
+ try {
+ parsedJson = JSON.parse(rawOutput);
+ } catch {
+ throw new Error("Codex returned invalid JSON output.");
+ }
+
+ return parse(parsedJson);
+ } finally {
+ await Promise.all([safeUnlink(schemaPath), safeUnlink(outputPath)]);
+ }
+}
+
+export class CodexTextGenerator implements TextGenerationService {
+ async generateCommitMessage(
+ input: CommitMessageGenerationInput,
+ ): Promise<CommitMessageGenerationResult> {
+ const prompt = [
+ "You write concise git commit messages.",
+ "Return a JSON object with keys: subject, body.",
+ "Rules:",
+ "- subject must be imperative, <= 72 chars, and no trailing period",
+ "- body can be empty string or short bullet points",
+ "- capture the primary user-visible or developer-visible change",
+ "",
+ `Branch: ${input.branch ?? "(detached)"}`,
+ "",
+ "Staged files:",
+ limitSection(input.stagedSummary, 6_000),
+ "",
+ "Staged patch:",
+ limitSection(input.stagedPatch, 40_000),
+ ].join("\n");
+
+ const generated = await runCodexJson({
+ cwd: input.cwd,
+ prompt,
+ outputSchemaJson: COMMIT_OUTPUT_SCHEMA_JSON,
+ parse: (raw) => parseCommitOutput(raw),
+ });
+
+ return {
+ subject: sanitizeCommitSubject(generated.subject),
+ body: generated.body.trim(),
+ };
+ }
+
+ async generatePrContent(
+ input: PrContentGenerationInput,
+ ): Promise<PrContentGenerationResult> {
+ const prompt = [
+ "You write GitHub pull request content.",
+ "Return a JSON object with keys: title, body.",
+ "Rules:",
+ "- title should be concise and specific",
+ "- body must be markdown and include headings '## Summary' and '## Testing'",
+ "- under Summary, provide short bullet points",
+ "- under Testing, include bullet points with concrete checks or 'Not run' where appropriate",
+ "",
+ `Base branch: ${input.baseBranch}`,
+ `Head branch: ${input.headBranch}`,
+ "",
+ "Commits:",
+ limitSection(input.commitSummary, 12_000),
+ "",
+ "Diff stat:",
+ limitSection(input.diffSummary, 12_000),
+ "",
+ "Diff patch:",
+ limitSection(input.diffPatch, 40_000),
+ ].join("\n");
+
+ const generated = await runCodexJson({
+ cwd: input.cwd,
+ prompt,
+ outputSchemaJson: PR_OUTPUT_SCHEMA_JSON,
+ parse: (raw) => parsePrOutput(raw),
+ });
+
+ return {
+ title: sanitizePrTitle(generated.title),
+ body: generated.body.trim(),
+ };
+ }
+}
diff --git a/apps/server/src/coreServices.ts b/apps/server/src/coreServices.ts
new file mode 100644
index 000000000..1f123b17c
--- /dev/null
+++ b/apps/server/src/coreServices.ts
@@ -0,0 +1,35 @@
+export interface CommitMessageGenerationInput {
+ cwd: string;
+ branch: string | null;
+ stagedSummary: string;
+ stagedPatch: string;
+}
+
+export interface CommitMessageGenerationResult {
+ subject: string;
+ body: string;
+}
+
+export interface PrContentGenerationInput {
+ cwd: string;
+ baseBranch: string;
+ headBranch: string;
+ commitSummary: string;
+ diffSummary: string;
+ diffPatch: string;
+}
+
+export interface PrContentGenerationResult {
+ title: string;
+ body: string;
+}
+
+export interface TextGenerationService {
+ generateCommitMessage(
+ input: CommitMessageGenerationInput,
+ ): Promise<CommitMessageGenerationResult>;
+ generatePrContent(
+ input: PrContentGenerationInput,
+ ): Promise<PrContentGenerationResult>;
+}
+
diff --git a/apps/server/src/gitManager.test.ts b/apps/server/src/gitManager.test.ts
new file mode 100644
index 000000000..57a3c7cc8
--- /dev/null
+++ b/apps/server/src/gitManager.test.ts
@@ -0,0 +1,397 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { GitManager } from "./gitManager";
+import {
+ type ProcessRunOptions,
+ type ProcessRunResult,
+ runProcess,
+} from "./processRunner";
+
+interface FakeGhScenario {
+ prListSequence?: string[];
+ createdPrUrl?: string;
+ defaultBranch?: string;
+ failWith?: Error;
+}
+
+interface FakeGitTextGenerator {
+ generateCommitMessage: (input: {
+ cwd: string;
+ branch: string | null;
+ stagedSummary: string;
+ stagedPatch: string;
+ }) => Promise<{ subject: string; body: string }>;
+ generatePrContent: (input: {
+ cwd: string;
+ baseBranch: string;
+ headBranch: string;
+ commitSummary: string;
+ diffSummary: string;
+ diffPatch: string;
+ }) => Promise<{ title: string; body: string }>;
+}
+
+const tempDirs: string[] = [];
+
+function makeTempDir(prefix: string): string {
+ const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+ tempDirs.push(dir);
+ return dir;
+}
+
+async function runGit(
+ cwd: string,
+ args: readonly string[],
+ allowNonZeroExit = false,
+): Promise<ProcessRunResult> {
+ return runProcess("git", args, { cwd, allowNonZeroExit });
+}
+
+async function runGitStdout(cwd: string, args: readonly string[]): Promise<string> {
+ const result = await runGit(cwd, args);
+ return result.stdout.trim();
+}
+
+async function initRepo(cwd: string): Promise<void> {
+ await runGit(cwd, ["init", "--initial-branch=main"]);
+ await runGit(cwd, ["config", "user.email", "[email protected]"]);
+ await runGit(cwd, ["config", "user.name", "Test User"]);
+ fs.writeFileSync(path.join(cwd, "README.md"), "hello\n");
+ await runGit(cwd, ["add", "README.md"]);
+ await runGit(cwd, ["commit", "-m", "Initial commit"]);
+}
+
+async function createBareRemote(): Promise<string> {
+ const remoteDir = makeTempDir("t3code-git-remote-");
+ await runProcess("git", ["init", "--bare"], { cwd: remoteDir });
+ return remoteDir;
+}
+
+function createTextGenerator(
+ overrides: Partial<FakeGitTextGenerator> = {},
+): FakeGitTextGenerator {
+ return {
+ generateCommitMessage: async () => ({
+ subject: "Implement stacked git actions",
+ body: "",
+ }),
+ generatePrContent: async () => ({
+ title: "Add stacked git actions",
+ body: "## Summary\n- Add stacked git workflow\n\n## Testing\n- Not run",
+ }),
+ ...overrides,
+ };
+}
+
+function createRunnerWithFakeGh(scenario: FakeGhScenario = {}): {
+ runner: (
+ command: string,
+ args: readonly string[],
+ options?: ProcessRunOptions,
+ ) => Promise<ProcessRunResult>;
+ ghCalls: string[];
+} {
+ const prListQueue = [...(scenario.prListSequence ?? [])];
+ const ghCalls: string[] = [];
+
+ const runner = async (
+ command: string,
+ args: readonly string[],
+ options?: ProcessRunOptions,
+ ): Promise<ProcessRunResult> => {
+ if (command !== "gh") {
+ return runProcess(command, args, options);
+ }
+
+ ghCalls.push(args.join(" "));
+ if (scenario.failWith) {
+ throw scenario.failWith;
+ }
+
+ if (args[0] === "pr" && args[1] === "list") {
+ const stdout = (prListQueue.shift() ?? "[]") + "\n";
+ return {
+ stdout,
+ stderr: "",
+ code: 0,
+ signal: null,
+ timedOut: false,
+ };
+ }
+
+ if (args[0] === "pr" && args[1] === "create") {
+ return {
+ stdout:
+ (scenario.createdPrUrl ??
+ "https://github.com/pingdotgg/codething-mvp/pull/101") + "\n",
+ stderr: "",
+ code: 0,
+ signal: null,
+ timedOut: false,
+ };
+ }
+
+ if (args[0] === "pr" && args[1] === "view") {
+ return {
+ stdout: "",
+ stderr: "",
+ code: 0,
+ signal: null,
+ timedOut: false,
+ };
+ }
+
+ if (args[0] === "repo" && args[1] === "view") {
+ return {
+ stdout: `${scenario.defaultBranch ?? "main"}\n`,
+ stderr: "",
+ code: 0,
+ signal: null,
+ timedOut: false,
+ };
+ }
+
+ throw new Error(`Unexpected gh command: ${args.join(" ")}`);
+ };
+
+ return { runner, ghCalls };
+}
+
+afterEach(() => {
+ for (const dir of tempDirs.splice(0, tempDirs.length)) {
+ fs.rmSync(dir, { recursive: true, force: true });
+ }
+});
+
+describe("GitManager", () => {
+ it("creates a commit when working tree is dirty", async () => {
+ const repoDir = makeTempDir("t3code-git-manager-");
+ await initRepo(repoDir);
+ fs.writeFileSync(path.join(repoDir, "README.md"), "hello\nworld\n");
+
+ const manager = new GitManager({
+ textGenerator: createTextGenerator(),
+ });
+ const result = await manager.runStackedAction({
+ cwd: repoDir,
+ action: "commit",
+ });
+
+ expect(result.commit.status).toBe("created");
+ expect(result.push.status).toBe("skipped_not_requested");
+ expect(result.pr.status).toBe("skipped_not_requested");
+ expect(await runGitStdout(repoDir, ["log", "-1", "--pretty=%s"])).toBe(
+ "Implement stacked git actions",
+ );
+ });
+
+ it("skips commit when there are no uncommitted changes", async () => {
+ const repoDir = makeTempDir("t3code-git-manager-");
+ await initRepo(repoDir);
+
+ const manager = new GitManager({
+ textGenerator: createTextGenerator(),
+ });
+ const result = await manager.runStackedAction({
+ cwd: repoDir,
+ action: "commit",
+ });
+
+ expect(result.commit.status).toBe("skipped_no_changes");
+ expect(result.push.status).toBe("skipped_not_requested");
+ expect(result.pr.status).toBe("skipped_not_requested");
+ });
+
+ it("commits and pushes with upstream auto-setup when needed", async () => {
+ const repoDir = makeTempDir("t3code-git-manager-");
+ await initRepo(repoDir);
+ await runGit(repoDir, ["checkout", "-b", "feature/stacked-flow"]);
+ const remoteDir = await createBareRemote();
+ await runGit(repoDir, ["remote", "add", "origin", remoteDir]);
+ fs.writeFileSync(path.join(repoDir, "feature.txt"), "feature\n");
+
+ const manager = new GitManager({
+ textGenerator: createTextGenerator(),
+ });
+ const result = await manager.runStackedAction({
+ cwd: repoDir,
+ action: "commit_push",
+ });
+
+ expect(result.commit.status).toBe("created");
+ expect(result.push.status).toBe("pushed");
+ expect(result.push.setUpstream).toBe(true);
+ expect(await runGitStdout(repoDir, ["rev-parse", "--abbrev-ref", "@{upstream}"])).toBe(
+ "origin/feature/stacked-flow",
+ );
+ });
+
+ it("skips push when branch is already up to date", async () => {
+ const repoDir = makeTempDir("t3code-git-manager-");
+ await initRepo(repoDir);
+ await runGit(repoDir, ["checkout", "-b", "feature/up-to-date"]);
+ const remoteDir = await createBareRemote();
+ await runGit(repoDir, ["remote", "add", "origin", remoteDir]);
+ await runGit(repoDir, ["push", "-u", "origin", "feature/up-to-date"]);
+
+ const manager = new GitManager({
+ textGenerator: createTextGenerator(),
+ });
+ const result = await manager.runStackedAction({
+ cwd: repoDir,
+ action: "commit_push",
+ });
+
+ expect(result.commit.status).toBe("skipped_no_changes");
+ expect(result.push.status).toBe("skipped_up_to_date");
+ });
+
+ it("opens existing PR for commit/push/pr action", async () => {
+ const repoDir = makeTempDir("t3code-git-manager-");
+ await initRepo(repoDir);
+ await runGit(repoDir, ["checkout", "-b", "feature/existing-pr"]);
+ const remoteDir = await createBareRemote();
+ await runGit(repoDir, ["remote", "add", "origin", remoteDir]);
+ await runGit(repoDir, ["push", "-u", "origin", "feature/existing-pr"]);
+
+ const { runner, ghCalls } = createRunnerWithFakeGh({
+ prListSequence: [
+ JSON.stringify([
+ {
+ number: 42,
+ title: "Existing PR",
+ url: "https://github.com/pingdotgg/codething-mvp/pull/42",
+ baseRefName: "main",
+ headRefName: "feature/existing-pr",
+ },
+ ]),
+ ],
+ });
+
+ const manager = new GitManager({
+ runProcess: runner,
+ textGenerator: createTextGenerator(),
+ });
+ const result = await manager.runStackedAction({
+ cwd: repoDir,
+ action: "commit_push_pr",
+ });
+
+ expect(result.pr.status).toBe("opened_existing");
+ expect(result.pr.number).toBe(42);
+ expect(
+ ghCalls.some((call) => call.startsWith("pr view feature/existing-pr --web")),
+ ).toBe(true);
+ });
+
+ it("creates PR when one does not already exist", async () => {
+ const repoDir = makeTempDir("t3code-git-manager-");
+ await initRepo(repoDir);
+ await runGit(repoDir, ["checkout", "-b", "feature-create-pr"]);
+ const remoteDir = await createBareRemote();
+ await runGit(repoDir, ["remote", "add", "origin", remoteDir]);
+ fs.writeFileSync(path.join(repoDir, "changes.txt"), "change\n");
+ await runGit(repoDir, ["add", "changes.txt"]);
+ await runGit(repoDir, ["commit", "-m", "Feature commit"]);
+ await runGit(repoDir, ["push", "-u", "origin", "feature-create-pr"]);
+ await runGit(repoDir, ["config", "branch.feature-create-pr.gh-merge-base", "main"]);
+
+ const { runner, ghCalls } = createRunnerWithFakeGh({
+ prListSequence: [
+ "[]",
+ JSON.stringify([
+ {
+ number: 88,
+ title: "Add stacked git actions",
+ url: "https://github.com/pingdotgg/codething-mvp/pull/88",
+ baseRefName: "main",
+ headRefName: "feature-create-pr",
+ },
+ ]),
+ ],
+ });
+
+ const manager = new GitManager({
+ runProcess: runner,
+ textGenerator: createTextGenerator(),
+ });
+ const result = await manager.runStackedAction({
+ cwd: repoDir,
+ action: "commit_push_pr",
+ });
+
+ expect(result.pr.status).toBe("created");
+ expect(result.pr.number).toBe(88);
+ expect(
+ ghCalls.some((call) => call.includes("pr create --base main --head feature-create-pr")),
+ ).toBe(true);
+ });
+
+ it("rejects push/pr actions from detached HEAD", async () => {
+ const repoDir = makeTempDir("t3code-git-manager-");
+ await initRepo(repoDir);
+ await runGit(repoDir, ["checkout", "--detach", "HEAD"]);
+
+ const manager = new GitManager({
+ textGenerator: createTextGenerator(),
+ });
+ await expect(
+ manager.runStackedAction({
+ cwd: repoDir,
+ action: "commit_push",
+ }),
+ ).rejects.toThrow("detached HEAD");
+ });
+
+ it("surfaces missing gh binary errors", async () => {
+ const repoDir = makeTempDir("t3code-git-manager-");
+ await initRepo(repoDir);
+ await runGit(repoDir, ["checkout", "-b", "feature/gh-missing"]);
+ const remoteDir = await createBareRemote();
+ await runGit(repoDir, ["remote", "add", "origin", remoteDir]);
+ await runGit(repoDir, ["push", "-u", "origin", "feature/gh-missing"]);
+
+ const { runner } = createRunnerWithFakeGh({
+ failWith: new Error("Command not found: gh"),
+ });
+ const manager = new GitManager({
+ runProcess: runner,
+ textGenerator: createTextGenerator(),
+ });
+
+ await expect(
+ manager.runStackedAction({
+ cwd: repoDir,
+ action: "commit_push_pr",
+ }),
+ ).rejects.toThrow("GitHub CLI (`gh`) is required");
+ });
+
+ it("surfaces gh auth errors with guidance", async () => {
+ const repoDir = makeTempDir("t3code-git-manager-");
+ await initRepo(repoDir);
+ await runGit(repoDir, ["checkout", "-b", "feature/gh-auth"]);
+ const remoteDir = await createBareRemote();
+ await runGit(repoDir, ["remote", "add", "origin", remoteDir]);
+ await runGit(repoDir, ["push", "-u", "origin", "feature/gh-auth"]);
+
+ const { runner } = createRunnerWithFakeGh({
+ failWith: new Error("authentication failed"),
+ });
+ const manager = new GitManager({
+ runProcess: runner,
+ textGenerator: createTextGenerator(),
+ });
+
+ await expect(
+ manager.runStackedAction({
+ cwd: repoDir,
+ action: "commit_push_pr",
+ }),
+ ).rejects.toThrow("gh auth login");
+ });
+});
diff --git a/apps/server/src/gitManager.ts b/apps/server/src/gitManager.ts
new file mode 100644
index 000000000..2cffb9d87
--- /dev/null
+++ b/apps/server/src/gitManager.ts
@@ -0,0 +1,623 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import {
+ gitRunStackedActionInputSchema,
+ gitRunStackedActionResultSchema,
+ gitStatusInputSchema,
+ gitStatusResultSchema,
+ type GitRunStackedActionInput,
+ type GitRunStackedActionResult,
+ type GitStatusInput,
+ type GitStatusResult,
+} from "@t3tools/contracts";
+
+import type {
+ CommitMessageGenerationResult,
+ PrContentGenerationResult,
+ TextGenerationService,
+} from "./coreServices";
+import { CodexTextGenerator } from "./codexTextGenerator";
+import { type ProcessRunOptions, runProcess } from "./processRunner";
+
+interface GitStatusDetails extends GitStatusResult {
+ upstreamRef: string | null;
+}
+
+interface GitManagerDeps {
+ runProcess?: (
+ command: string,
+ args: readonly string[],
+ options?: ProcessRunOptions,
+ ) => Promise<{
+ stdout: string;
+ stderr: string;
+ code: number | null;
+ signal: NodeJS.Signals | null;
+ timedOut: boolean;
+ }>;
+ textGenerator?: TextGenerationService;
+}
+
+interface OpenPrInfo {
+ number: number;
+ title: string;
+ url: string;
+ baseRefName: string;
+ headRefName: string;
+}
+
+function parseOpenPrList(raw: unknown): OpenPrInfo[] {
+ if (!Array.isArray(raw)) return [];
+
+ const parsed: OpenPrInfo[] = [];
+ for (const entry of raw) {
+ if (!entry || typeof entry !== "object") continue;
+ const record = entry as Record<string, unknown>;
+ const number = record.number;
+ const title = record.title;
+ const url = record.url;
+ const baseRefName = record.baseRefName;
+ const headRefName = record.headRefName;
+ if (
+ typeof number !== "number" ||
+ !Number.isInteger(number) ||
+ number <= 0
+ ) {
+ continue;
+ }
+ if (
+ typeof title !== "string" ||
+ typeof url !== "string" ||
+ typeof baseRefName !== "string" ||
+ typeof headRefName !== "string"
+ ) {
+ continue;
+ }
+ parsed.push({
+ number,
+ title,
+ url,
+ baseRefName,
+ headRefName,
+ });
+ }
+ return parsed;
+}
+
+function trimStdout(value: string): string {
+ return value.trim();
+}
+
+function limitContext(value: string, maxChars: number): string {
+ if (value.length <= maxChars) return value;
+ return `${value.slice(0, maxChars)}\n\n[truncated]`;
+}
+
+function sanitizeCommitMessage(
+ generated: CommitMessageGenerationResult,
+): CommitMessageGenerationResult {
+ const rawSubject = generated.subject.trim().split(/\r?\n/g)[0]?.trim() ?? "";
+ const subject = rawSubject.replace(/[.]+$/g, "").trim();
+ const safeSubject =
+ subject.length > 0 ? subject.slice(0, 72).trimEnd() : "Update project files";
+ return {
+ subject: safeSubject,
+ body: generated.body.trim(),
+ };
+}
+
+function extractBranchFromRef(ref: string): string {
+ const normalized = ref.trim();
+ const afterSlash = normalized.includes("/")
+ ? normalized.slice(normalized.lastIndexOf("/") + 1)
+ : normalized;
+ return afterSlash.trim();
+}
+
+function parseBranchAb(value: string): { ahead: number; behind: number } {
+ const match = value.match(/^\+(\d+)\s+-(\d+)$/);
+ if (!match) return { ahead: 0, behind: 0 };
+ return {
+ ahead: Number(match[1] ?? "0"),
+ behind: Number(match[2] ?? "0"),
+ };
+}
+
+function asCommandNotFound(
+ command: string,
+ error: unknown,
+): Error | undefined {
+ if (!(error instanceof Error)) return undefined;
+ if (!error.message.includes(`Command not found: ${command}`)) return undefined;
+ if (command === "gh") {
+ return new Error("GitHub CLI (`gh`) is required but not available on PATH.");
+ }
+ if (command === "codex") {
+ return new Error("Codex CLI (`codex`) is required but not available on PATH.");
+ }
+ if (command === "git") {
+ return new Error("Git is required but not available on PATH.");
+ }
+ return new Error(`${command} is required but not available on PATH.`);
+}
+
+function normalizeGitHubAuthError(error: unknown): Error | undefined {
+ if (!(error instanceof Error)) return undefined;
+ const lower = error.message.toLowerCase();
+ if (
+ lower.includes("authentication failed") ||
+ lower.includes("not logged in") ||
+ lower.includes("gh auth login") ||
+ lower.includes("no oauth token")
+ ) {
+ return new Error("GitHub CLI is not authenticated. Run `gh auth login` and retry.");
+ }
+ return undefined;
+}
+
+function normalizeNotGitRepoError(error: unknown): Error | undefined {
+ if (!(error instanceof Error)) return undefined;
+ if (error.message.toLowerCase().includes("not a git repository")) {
+ return new Error("Current folder is not a git repository.");
+ }
+ return undefined;
+}
+
+export class GitManager {
+ private readonly run: NonNullable<GitManagerDeps["runProcess"]>;
+ private readonly textGenerator: TextGenerationService;
+
+ constructor(deps: GitManagerDeps = {}) {
+ this.run = deps.runProcess ?? runProcess;
+ this.textGenerator = deps.textGenerator ?? new CodexTextGenerator();
+ }
+
+ async status(raw: GitStatusInput): Promise<GitStatusResult> {
+ const input = gitStatusInputSchema.parse(raw);
+ const details = await this.readStatusDetails(input.cwd);
+ return gitStatusResultSchema.parse({
+ branch: details.branch,
+ hasWorkingTreeChanges: details.hasWorkingTreeChanges,
+ hasUpstream: details.hasUpstream,
+ aheadCount: details.aheadCount,
+ behindCount: details.behindCount,
+ });
+ }
+
+ async runStackedAction(
+ raw: GitRunStackedActionInput,
+ ): Promise<GitRunStackedActionResult> {
+ const input = gitRunStackedActionInputSchema.parse(raw);
+ const wantsPush = input.action !== "commit";
+ const wantsPr = input.action === "commit_push_pr";
+
+ const initialStatus = await this.readStatusDetails(input.cwd);
+ if (wantsPush && !initialStatus.branch) {
+ throw new Error("Cannot push from detached HEAD.");
+ }
+ if (wantsPr && !initialStatus.branch) {
+ throw new Error("Cannot create a pull request from detached HEAD.");
+ }
+
+ const commit = await this.runCommitStep(input.cwd, initialStatus.branch);
+
+ const push = wantsPush
+ ? await this.runPushStep(input.cwd, initialStatus.branch)
+ : { status: "skipped_not_requested" as const };
+
+ const pr = wantsPr
+ ? await this.runPrStep(input.cwd, initialStatus.branch)
+ : { status: "skipped_not_requested" as const };
+
+ return gitRunStackedActionResultSchema.parse({
+ action: input.action,
+ commit,
+ push,
+ pr,
+ });
+ }
+
+ private async readStatusDetails(cwd: string): Promise<GitStatusDetails> {
+ let stdout = "";
+ try {
+ stdout = await this.runGitStdout(cwd, ["status", "--porcelain=2", "--branch"]);
+ } catch (error) {
+ throw (
+ asCommandNotFound("git", error) ??
+ normalizeNotGitRepoError(error) ??
+ (error instanceof Error ? error : new Error("Failed to read git status."))
+ );
+ }
+
+ let branch: string | null = null;
+ let upstreamRef: string | null = null;
+ let aheadCount = 0;
+ let behindCount = 0;
+ let hasWorkingTreeChanges = false;
+
+ for (const line of stdout.split(/\r?\n/g)) {
+ if (line.startsWith("# branch.head ")) {
+ const value = line.slice("# branch.head ".length).trim();
+ branch = value.startsWith("(") ? null : value;
+ continue;
+ }
+ if (line.startsWith("# branch.upstream ")) {
+ const value = line.slice("# branch.upstream ".length).trim();
+ upstreamRef = value.length > 0 ? value : null;
+ continue;
+ }
+ if (line.startsWith("# branch.ab ")) {
+ const value = line.slice("# branch.ab ".length).trim();
+ const parsed = parseBranchAb(value);
+ aheadCount = parsed.ahead;
+ behindCount = parsed.behind;
+ continue;
+ }
+ if (line.trim().length > 0 && !line.startsWith("#")) {
+ hasWorkingTreeChanges = true;
+ }
+ }
+
+ return {
+ branch,
+ upstreamRef,
+ hasWorkingTreeChanges,
+ hasUpstream: upstreamRef !== null,
+ aheadCount,
+ behindCount,
+ };
+ }
+
+ private async runCommitStep(
+ cwd: string,
+ branch: string | null,
+ ): Promise<{
+ status: "created" | "skipped_no_changes";
+ commitSha?: string | undefined;
+ subject?: string | undefined;
+ }> {
+ await this.runGit(cwd, ["add", "-A"]);
+ const stagedSummary = await this.runGitStdout(cwd, [
+ "diff",
+ "--cached",
+ "--name-status",
+ ]);
+ if (trimStdout(stagedSummary).length === 0) {
+ return { status: "skipped_no_changes" };
+ }
+
+ const stagedPatch = await this.runGitStdout(cwd, [
+ "diff",
+ "--cached",
+ "--patch",
+ "--minimal",
+ ]);
+
+ let generated: CommitMessageGenerationResult;
+ try {
+ generated = sanitizeCommitMessage(
+ await this.textGenerator.generateCommitMessage({
+ cwd,
+ branch,
+ stagedSummary: limitContext(stagedSummary, 8_000),
+ stagedPatch: limitContext(stagedPatch, 50_000),
+ }),
+ );
+ } catch (error) {
+ throw asCommandNotFound("codex", error) ?? error;
+ }
+
+ const commitArgs = ["commit", "-m", generated.subject];
+ if (generated.body.length > 0) {
+ commitArgs.push("-m", generated.body);
+ }
+ await this.runGit(cwd, commitArgs);
+
+ const commitSha = trimStdout(await this.runGitStdout(cwd, ["rev-parse", "HEAD"]));
+ return {
+ status: "created",
+ commitSha,
+ subject: generated.subject,
+ };
+ }
+
+ private async runPushStep(
+ cwd: string,
+ fallbackBranch: string | null,
+ ): Promise<{
+ status: "pushed" | "skipped_not_requested" | "skipped_up_to_date";
+ branch?: string | undefined;
+ upstreamBranch?: string | undefined;
+ setUpstream?: boolean | undefined;
+ }> {
+ const details = await this.readStatusDetails(cwd);
+ const branch = details.branch ?? fallbackBranch;
+ if (!branch) {
+ throw new Error("Cannot push from detached HEAD.");
+ }
+
+ if (details.hasUpstream && details.aheadCount === 0) {
+ return {
+ status: "skipped_up_to_date",
+ branch,
+ ...(details.upstreamRef ? { upstreamBranch: details.upstreamRef } : {}),
+ };
+ }
+
+ if (!details.hasUpstream) {
+ await this.runGit(cwd, ["push", "-u", "origin", branch]);
+ return {
+ status: "pushed",
+ branch,
+ upstreamBranch: `origin/${branch}`,
+ setUpstream: true,
+ };
+ }
+
+ await this.runGit(cwd, ["push"]);
+ return {
+ status: "pushed",
+ branch,
+ ...(details.upstreamRef ? { upstreamBranch: details.upstreamRef } : {}),
+ setUpstream: false,
+ };
+ }
+
+ private async runPrStep(
+ cwd: string,
+ fallbackBranch: string | null,
+ ): Promise<{
+ status: "created" | "opened_existing" | "skipped_not_requested";
+ url?: string | undefined;
+ number?: number | undefined;
+ baseBranch?: string | undefined;
+ headBranch?: string | undefined;
+ title?: string | undefined;
+ }> {
+ const details = await this.readStatusDetails(cwd);
+ const branch = details.branch ?? fallbackBranch;
+ if (!branch) {
+ throw new Error("Cannot create a pull request from detached HEAD.");
+ }
+ if (!details.hasUpstream) {
+ throw new Error("Current branch has not been pushed. Push before creating a PR.");
+ }
+
+ const existing = await this.findOpenPr(cwd, branch);
+ if (existing) {
+ await this.openPrInBrowser(cwd, branch);
+ return {
+ status: "opened_existing",
+ url: existing.url,
+ number: existing.number,
+ baseBranch: existing.baseRefName,
+ headBranch: existing.headRefName,
+ title: existing.title,
+ };
+ }
+
+ const baseBranch = await this.resolveBaseBranch(cwd, branch, details.upstreamRef);
+ const commitSummary = await this.runGitStdout(cwd, [
+ "log",
+ "--oneline",
+ `${baseBranch}..HEAD`,
+ ]);
+ const diffSummary = await this.runGitStdout(cwd, [
+ "diff",
+ "--stat",
+ `${baseBranch}..HEAD`,
+ ]);
+ const diffPatch = await this.runGitStdout(cwd, [
+ "diff",
+ "--patch",
+ "--minimal",
+ `${baseBranch}..HEAD`,
+ ]);
+
+ let generated: PrContentGenerationResult;
+ try {
+ generated = await this.textGenerator.generatePrContent({
+ cwd,
+ baseBranch,
+ headBranch: branch,
+ commitSummary: limitContext(commitSummary, 20_000),
+ diffSummary: limitContext(diffSummary, 20_000),
+ diffPatch: limitContext(diffPatch, 60_000),
+ });
+ } catch (error) {
+ throw asCommandNotFound("codex", error) ?? error;
+ }
+
+ const bodyFile = path.join(
+ os.tmpdir(),
+ `t3code-pr-body-${process.pid}-${randomUUID()}.md`,
+ );
+ await fs.writeFile(bodyFile, generated.body, "utf8");
+
+ try {
+ await this.runGh(cwd, [
+ "pr",
+ "create",
+ "--base",
+ baseBranch,
+ "--head",
+ branch,
+ "--title",
+ generated.title,
+ "--body-file",
+ bodyFile,
+ ]);
+ } finally {
+ try {
+ await fs.unlink(bodyFile);
+ } catch {
+ // Best-effort cleanup.
+ }
+ }
+
+ const created = await this.findOpenPr(cwd, branch);
+ await this.openPrInBrowser(cwd, branch);
+
+ if (!created) {
+ return {
+ status: "created",
+ baseBranch,
+ headBranch: branch,
+ title: generated.title,
+ };
+ }
+
+ return {
+ status: "created",
+ url: created.url,
+ number: created.number,
+ baseBranch: created.baseRefName,
+ headBranch: created.headRefName,
+ title: created.title,
+ };
+ }
+
+ private async openPrInBrowser(cwd: string, branch: string): Promise<void> {
+ try {
+ await this.runGh(cwd, ["pr", "view", branch, "--web"]);
+ } catch {
+ // Opening the browser is best-effort.
+ }
+ }
+
+ private async findOpenPr(
+ cwd: string,
+ branch: string,
+ ): Promise<OpenPrInfo | null> {
+ const stdout = await this.runGhStdout(cwd, [
+ "pr",
+ "list",
+ "--head",
+ branch,
+ "--state",
+ "open",
+ "--limit",
+ "1",
+ "--json",
+ "number,title,url,baseRefName,headRefName",
+ ]);
+
+ const raw = trimStdout(stdout);
+ if (raw.length === 0) return null;
+
+ let parsedJson: unknown;
+ try {
+ parsedJson = JSON.parse(raw);
+ } catch {
+ throw new Error("GitHub CLI returned invalid PR list JSON.");
+ }
+
+ const parsed = parseOpenPrList(parsedJson);
+ return parsed[0] ?? null;
+ }
+
+ private async resolveBaseBranch(
+ cwd: string,
+ branch: string,
+ upstreamRef: string | null,
+ ): Promise<string> {
+ const mergeBaseConfig = await this.runGitStdout(
+ cwd,
+ ["config", "--get", `branch.${branch}.gh-merge-base`],
+ true,
+ );
+ const configured = trimStdout(mergeBaseConfig);
+ if (configured.length > 0) return configured;
+
+ if (upstreamRef) {
+ const upstreamBranch = extractBranchFromRef(upstreamRef);
+ if (upstreamBranch.length > 0 && upstreamBranch !== branch) {
+ return upstreamBranch;
+ }
+ }
+
+ try {
+ const ghDefault = await this.runGhStdout(cwd, [
+ "repo",
+ "view",
+ "--json",
+ "defaultBranchRef",
+ "--jq",
+ ".defaultBranchRef.name",
+ ]);
+ const defaultBranch = trimStdout(ghDefault);
+ if (defaultBranch.length > 0) return defaultBranch;
+ } catch {
+ // Fall through to deterministic fallback.
+ }
+
+ return "main";
+ }
+
+ private async runGit(
+ cwd: string,
+ args: readonly string[],
+ allowNonZeroExit = false,
+ ): Promise<void> {
+ try {
+ await this.run("git", args, {
+ cwd,
+ allowNonZeroExit,
+ });
+ } catch (error) {
+ throw (
+ asCommandNotFound("git", error) ??
+ normalizeNotGitRepoError(error) ??
+ (error instanceof Error ? error : new Error("Git command failed."))
+ );
+ }
+ }
+
+ private async runGitStdout(
+ cwd: string,
+ args: readonly string[],
+ allowNonZeroExit = false,
+ ): Promise<string> {
+ try {
+ const result = await this.run("git", args, {
+ cwd,
+ allowNonZeroExit,
+ });
+ return result.stdout;
+ } catch (error) {
+ throw (
+ asCommandNotFound("git", error) ??
+ normalizeNotGitRepoError(error) ??
+ (error instanceof Error ? error : new Error("Git command failed."))
+ );
+ }
+ }
+
+ private async runGh(cwd: string, args: readonly string[]): Promise<void> {
+ try {
+ await this.run("gh", args, { cwd });
+ } catch (error) {
+ throw (
+ asCommandNotFound("gh", error) ??
+ normalizeGitHubAuthError(error) ??
+ (error instanceof Error ? error : new Error("GitHub CLI command failed."))
+ );
+ }
+ }
+
+ private async runGhStdout(cwd: string, args: readonly string[]): Promise<string> {
+ try {
+ const result = await this.run("gh", args, { cwd });
+ return result.stdout;
+ } catch (error) {
+ throw (
+ asCommandNotFound("gh", error) ??
+ normalizeGitHubAuthError(error) ??
+ (error instanceof Error ? error : new Error("GitHub CLI command failed."))
+ );
+ }
+ }
+}
diff --git a/apps/server/src/processRunner.ts b/apps/server/src/processRunner.ts
new file mode 100644
index 000000000..c1d7102c1
--- /dev/null
+++ b/apps/server/src/processRunner.ts
@@ -0,0 +1,134 @@
+import { spawn } from "node:child_process";
+
+export interface ProcessRunOptions {
+ cwd?: string | undefined;
+ timeoutMs?: number | undefined;
+ env?: NodeJS.ProcessEnv | undefined;
+ stdin?: string | undefined;
+ allowNonZeroExit?: boolean | undefined;
+}
+
+export interface ProcessRunResult {
+ stdout: string;
+ stderr: string;
+ code: number | null;
+ signal: NodeJS.Signals | null;
+ timedOut: boolean;
+}
+
+function commandLabel(command: string, args: readonly string[]): string {
+ return [command, ...args].join(" ");
+}
+
+function normalizeSpawnError(
+ command: string,
+ args: readonly string[],
+ error: unknown,
+): Error {
+ if (!(error instanceof Error)) {
+ return new Error(`Failed to run ${commandLabel(command, args)}.`);
+ }
+
+ const maybeCode = (error as NodeJS.ErrnoException).code;
+ if (maybeCode === "ENOENT") {
+ return new Error(`Command not found: ${command}`);
+ }
+
+ return new Error(
+ `Failed to run ${commandLabel(command, args)}: ${error.message}`,
+ );
+}
+
+function normalizeExitError(
+ command: string,
+ args: readonly string[],
+ result: ProcessRunResult,
+): Error {
+ const reason = result.timedOut
+ ? "timed out"
+ : `failed (code=${result.code ?? "null"}, signal=${result.signal ?? "null"})`;
+ const stderr = result.stderr.trim();
+ const detail = stderr.length > 0 ? ` ${stderr}` : "";
+ return new Error(`${commandLabel(command, args)} ${reason}.${detail}`);
+}
+
+export async function runProcess(
+ command: string,
+ args: readonly string[],
+ options: ProcessRunOptions = {},
+): Promise<ProcessRunResult> {
+ const timeoutMs = options.timeoutMs ?? 60_000;
+
+ return new Promise<ProcessRunResult>((resolve, reject) => {
+ const child = spawn(command, args, {
+ cwd: options.cwd,
+ env: options.env,
+ stdio: "pipe",
+ });
+
+ let stdout = "";
+ let stderr = "";
+ let timedOut = false;
+ let settled = false;
+ let forceKillTimer: ReturnType<typeof setTimeout> | null = null;
+
+ const timeoutTimer = setTimeout(() => {
+ timedOut = true;
+ child.kill("SIGTERM");
+ forceKillTimer = setTimeout(() => {
+ child.kill("SIGKILL");
+ }, 1_000);
+ }, timeoutMs);
+
+ const finalize = (callback: () => void): void => {
+ if (settled) return;
+ settled = true;
+ clearTimeout(timeoutTimer);
+ if (forceKillTimer) {
+ clearTimeout(forceKillTimer);
+ }
+ callback();
+ };
+
+ child.stdout.on("data", (chunk: Buffer | string) => {
+ stdout += chunk.toString();
+ });
+
+ child.stderr.on("data", (chunk: Buffer | string) => {
+ stderr += chunk.toString();
+ });
+
+ child.once("error", (error) => {
+ finalize(() => {
+ reject(normalizeSpawnError(command, args, error));
+ });
+ });
+
+ child.once("close", (code, signal) => {
+ const result: ProcessRunResult = {
+ stdout,
+ stderr,
+ code,
+ signal,
+ timedOut,
+ };
+
+ finalize(() => {
+ if (
+ !options.allowNonZeroExit &&
+ (timedOut || (code !== null && code !== 0))
+ ) {
+ reject(normalizeExitError(command, args, result));
+ return;
+ }
+ resolve(result);
+ });
+ });
+
+ if (options.stdin !== undefined) {
+ child.stdin.write(options.stdin);
+ }
+ child.stdin.end();
+ });
+}
+
diff --git a/apps/server/src/wsServer.test.ts b/apps/server/src/wsServer.test.ts
index ef5cb1b96..8b3a19876 100644
--- a/apps/server/src/wsServer.test.ts
+++ b/apps/server/src/wsServer.test.ts
@@ -85,6 +85,10 @@ describe("WebSocket Server", () => {
devUrl?: string;
authToken?: string;
stateDir?: string;
+ gitManager?: {
+ status: (input: { cwd: string }) => Promise<unknown>;
+ runStackedAction: (input: { cwd: string; action: string }) => Promise<unknown>;
+ };
} = {},
): ReturnType<typeof createServer> {
const stateDir = options.stateDir ?? makeTempDir("t3code-ws-state-");
@@ -94,6 +98,7 @@ describe("WebSocket Server", () => {
...(options.devUrl ? { devUrl: options.devUrl } : {}),
...(options.authToken ? { authToken: options.authToken } : {}),
projectRegistry: new ProjectRegistry(stateDir),
+ ...(options.gitManager ? { gitManager: options.gitManager as never } : {}),
});
}
@@ -281,6 +286,70 @@ describe("WebSocket Server", () => {
expect(afterRemove.result).toEqual([]);
});
+ it("responds to git.status via the git manager", async () => {
+ const gitManager = {
+ status: vi.fn().mockResolvedValue({
+ branch: "feature/test",
+ hasWorkingTreeChanges: true,
+ hasUpstream: false,
+ aheadCount: 0,
+ behindCount: 0,
+ }),
+ runStackedAction: vi.fn(),
+ };
+
+ server = createTestServer({ cwd: "/test", gitManager });
+ await server.start();
+ const addr = server.httpServer.address();
+ const port = typeof addr === "object" && addr !== null ? addr.port : 0;
+
+ const ws = await connectWs(port);
+ connections.push(ws);
+ await waitForMessage(ws);
+
+ const response = await sendRequest(ws, WS_METHODS.gitStatus, {
+ cwd: "/test",
+ });
+ expect(response.error).toBeUndefined();
+ expect(response.result).toEqual({
+ branch: "feature/test",
+ hasWorkingTreeChanges: true,
+ hasUpstream: false,
+ aheadCount: 0,
+ behindCount: 0,
+ });
+ expect(gitManager.status).toHaveBeenCalledWith({ cwd: "/test" });
+ });
+
+ it("returns errors from git.runStackedAction", async () => {
+ const gitManager = {
+ status: vi.fn(),
+ runStackedAction: vi
+ .fn()
+ .mockRejectedValue(new Error("Cannot push from detached HEAD.")),
+ };
+
+ server = createTestServer({ cwd: "/test", gitManager });
+ await server.start();
+ const addr = server.httpServer.address();
+ const port = typeof addr === "object" && addr !== null ? addr.port : 0;
+
+ const ws = await connectWs(port);
+ connections.push(ws);
+ await waitForMessage(ws);
+
+ const response = await sendRequest(ws, WS_METHODS.gitRunStackedAction, {
+ cwd: "/test",
+ action: "commit_push",
+ });
+ expect(response.result).toBeUndefined();
+ expect(response.error?.message).toContain("detached HEAD");
+ expect(gitManager.runStackedAction).toHaveBeenCalledWith({
+ cwd: "/test",
+ action: "commit_push",
+ });
+ });
+
it("prunes missing projects on startup", async () => {
const stateDir = makeTempDir("t3code-ws-prune-state-");
const existing = makeTempDir("t3code-ws-existing-project-");
diff --git a/apps/server/src/wsServer.ts b/apps/server/src/wsServer.ts
index ae9dc7ca6..5178718fc 100644
--- a/apps/server/src/wsServer.ts
+++ b/apps/server/src/wsServer.ts
@@ -19,6 +19,7 @@ import { WebSocketServer, type WebSocket } from "ws";
import { createLogger } from "./logger";
import { ProjectRegistry } from "./projectRegistry";
import { ProviderManager } from "./providerManager";
+import { GitManager } from "./gitManager";
const MIME_TYPES: Record<string, string> = {
".html": "text/html; charset=utf-8",
@@ -43,6 +44,7 @@ export interface ServerOptions {
devUrl?: string | undefined;
logWebSocketEvents?: boolean | undefined;
projectRegistry?: ProjectRegistry | undefined;
+ gitManager?: GitManager | undefined;
authToken?: string | undefined;
}
@@ -63,11 +65,13 @@ export function createServer(options: ServerOptions) {
devUrl,
logWebSocketEvents: explicitLogWsEvents,
projectRegistry: providedRegistry,
+ gitManager: providedGitManager,
authToken,
} = options;
const providerManager = new ProviderManager();
const projectRegistry =
providedRegistry ?? new ProjectRegistry(path.join(os.homedir(), ".t3", "userdata"));
+ const gitManager = providedGitManager ?? new GitManager();
const clients = new Set<WebSocket>();
const logger = createLogger("ws");
const logWebSocketEvents =
@@ -304,6 +308,12 @@ export function createServer(options: ServerOptions) {
return undefined;
}
+ case WS_METHODS.gitStatus:
+ return gitManager.status(request.params as never);
+
+ case WS_METHODS.gitRunStackedAction:
+ return gitManager.runStackedAction(request.params as never);
+
case WS_METHODS.serverGetConfig:
return { cwd };
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 3c28c7da5..d9869197c 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -1,5 +1,8 @@
import {
PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
+ type GitRunStackedActionResult,
+ type GitStackedAction,
+ type GitStatusResult,
type ProviderApprovalDecision,
type ProviderEvent,
} from "@t3tools/contracts";
@@ -7,6 +10,7 @@ import {
type FormEvent,
Fragment,
type KeyboardEvent,
+ useCallback,
useEffect,
useMemo,
useRef,
@@ -52,6 +56,14 @@ function editorLabel(editor: (typeof EDITORS)[number]): string {
const LAST_EDITOR_KEY = "t3code:last-editor";
const MAX_VISIBLE_WORK_LOG_ENTRIES = 6;
+const GIT_ACTION_ITEMS: Array<{
+ id: GitStackedAction;
+ label: string;
+}> = [
+ { id: "commit", label: "Commit" },
+ { id: "commit_push", label: "Commit & Push" },
+ { id: "commit_push_pr", label: "Commit, Push & Create PR" },
+];
function workToneClass(tone: "thinking" | "tool" | "info" | "error"): string {
if (tone === "error") return "text-rose-300/50 dark:text-rose-300/50";
@@ -132,6 +144,35 @@ function derivePendingApprovals(
return Array.from(pending.values());
}
+function summarizeGitActionResult(result: GitRunStackedActionResult): string {
+ const parts: string[] = [];
+
+ if (result.commit.status === "created") {
+ parts.push(`Committed: ${result.commit.subject ?? "changes saved"}.`);
+ } else {
+ parts.push("No local changes to commit.");
+ }
+
+ if (result.push.status === "pushed") {
+ const upstream = result.push.upstreamBranch;
+ parts.push(
+ upstream ? `Pushed to ${upstream}.` : "Pushed to remote branch.",
+ );
+ } else if (result.push.status === "skipped_up_to_date") {
+ parts.push("Push skipped: branch already up to date.");
+ }
+
+ if (result.pr.status === "created") {
+ parts.push(result.pr.url ? `PR created: ${result.pr.url}` : "PR created.");
+ } else if (result.pr.status === "opened_existing") {
+ parts.push(
+ result.pr.url ? `Opened existing PR: ${result.pr.url}` : "Opened existing PR.",
+ );
+ }
+
+ return parts.join(" ");
+}
+
export default function ChatView() {
const { state, dispatch } = useStore();
const api = useMemo(() => readNativeApi(), []);
@@ -140,6 +181,11 @@ export default function ChatView() {
const [isConnecting, setIsConnecting] = useState(false);
const [isModelMenuOpen, setIsModelMenuOpen] = useState(false);
const [isEditorMenuOpen, setIsEditorMenuOpen] = useState(false);
+ const [isGitMenuOpen, setIsGitMenuOpen] = useState(false);
+ const [isGitActionRunning, setIsGitActionRunning] = useState(false);
+ const [gitStatus, setGitStatus] = useState<GitStatusResult | null>(null);
+ const [gitActionNotice, setGitActionNotice] = useState<string | null>(null);
+ const [gitActionError, setGitActionError] = useState<string | null>(null);
const [lastEditor, setLastEditor] = useState<EditorId>(() => {
const stored = localStorage.getItem(LAST_EDITOR_KEY);
return EDITORS.some((e) => e.id === stored)
@@ -160,6 +206,7 @@ export default function ChatView() {
const textareaRef = useRef<HTMLTextAreaElement>(null);
const modelMenuRef = useRef<HTMLDivElement>(null);
const editorMenuRef = useRef<HTMLDivElement>(null);
+ const gitMenuRef = useRef<HTMLDivElement>(null);
const activeThread = state.threads.find((t) => t.id === state.activeThreadId);
const activeProject = state.projects.find((p) => p.id === activeThread?.projectId);
@@ -265,6 +312,49 @@ export default function ChatView() {
approvalPolicy: "on-request",
sandboxMode: "workspace-write",
} as const);
+ const gitActionsDisabled =
+ !api || !activeProject || !gitStatus || isGitActionRunning;
+ const pushActionDisabled = gitActionsDisabled || gitStatus.branch === null;
+
+ const refreshGitStatus = useCallback(async () => {
+ if (!api || !activeProject) {
+ setGitStatus(null);
+ return;
+ }
+
+ const nextStatus = await api.git.status({ cwd: activeProject.cwd });
+ setGitStatus(nextStatus);
+ }, [api, activeProject]);
+
+ const runGitAction = useCallback(
+ async (action: GitStackedAction) => {
+ if (!api || !activeProject) return;
+
+ setIsGitMenuOpen(false);
+ setIsGitActionRunning(true);
+ setGitActionError(null);
+ setGitActionNotice(null);
+ try {
+ const result = await api.git.runStackedAction({
+ cwd: activeProject.cwd,
+ action,
+ });
+ setGitActionNotice(summarizeGitActionResult(result));
+ } catch (error) {
+ setGitActionError(
+ error instanceof Error ? error.message : "Git action failed.",
+ );
+ } finally {
+ setIsGitActionRunning(false);
+ try {
+ await refreshGitStatus();
+ } catch {
+ setGitStatus(null);
+ }
+ }
+ },
+ [api, activeProject, refreshGitStatus],
+ );
const handleRuntimeModeChange = async (
mode: "approval-required" | "full-access",
@@ -309,6 +399,42 @@ export default function ChatView() {
setExpandedWorkGroups({});
}, [activeThread?.id]);
+ useEffect(() => {
+ setGitActionNotice(null);
+ setGitActionError(null);
+ }, [activeProject?.id]);
+
+ useEffect(() => {
+ let cancelled = false;
+ if (!api || !activeProject) {
+ setGitStatus(null);
+ return;
+ }
+
+ const load = async () => {
+ try {
+ const nextStatus = await api.git.status({ cwd: activeProject.cwd });
+ if (!cancelled) {
+ setGitStatus(nextStatus);
+ }
+ } catch (error) {
+ if (!cancelled) {
+ setGitStatus(null);
+ setGitActionError(
+ error instanceof Error
+ ? error.message
+ : "Failed to read git status.",
+ );
+ }
+ }
+ };
+
+ void load();
+ return () => {
+ cancelled = true;
+ };
+ }, [api, activeProject]);
+
// Auto-resize textarea
useEffect(() => {
const ta = textareaRef.current;
@@ -362,6 +488,22 @@ export default function ChatView() {
};
}, [isEditorMenuOpen]);
+ useEffect(() => {
+ if (!isGitMenuOpen) return;
+
+ const handleClickOutside = (event: MouseEvent) => {
+ if (!gitMenuRef.current) return;
+ if (event.target instanceof Node && !gitMenuRef.current.contains(event.target)) {
+ setIsGitMenuOpen(false);
+ }
+ };
+
+ window.addEventListener("mousedown", handleClickOutside);
+ return () => {
+ window.removeEventListener("mousedown", handleClickOutside);
+ };
+ }, [isGitMenuOpen]);
+
// Cmd+O / Ctrl+O to open in last-used editor
useEffect(() => {
const handler = (e: globalThis.KeyboardEvent) => {
@@ -617,6 +759,49 @@ export default function ChatView() {
)}
</div>
)}
+ {/* Git actions */}
+ {activeProject && (
+ <div className="relative" ref={gitMenuRef}>
+ <button
+ type="button"
+ className="inline-flex items-center gap-1.5 rounded-md border border-border px-2 py-1 text-[10px] text-muted-foreground/70 transition-colors duration-150 hover:bg-accent hover:text-foreground/80 disabled:cursor-not-allowed disabled:opacity-60"
+ onClick={() => setIsGitMenuOpen((v) => !v)}
+ disabled={!gitStatus || isGitActionRunning}
+ >
+ {isGitActionRunning ? "Running..." : "Git actions"}
+ <span aria-hidden="true">▾</span>
+ </button>
+ {isGitMenuOpen && (
+ <div className="absolute right-0 top-full z-50 mt-1 w-[240px] rounded-xl border border-border bg-popover p-2 shadow-xl">
+ <p className="px-2 pb-1 text-[10px] uppercase tracking-[0.1em] text-muted-foreground/60">
+ Git actions
+ </p>
+ {GIT_ACTION_ITEMS.map((item) => {
+ const disabled =
+ item.id === "commit" ? gitActionsDisabled : pushActionDisabled;
+ return (
+ <button
+ key={item.id}
+ type="button"
+ className="mb-1 flex w-full items-center rounded-lg px-2 py-2 text-left text-[11px] text-foreground transition-colors duration-150 hover:bg-accent disabled:cursor-not-allowed disabled:opacity-50"
+ disabled={disabled}
+ onClick={() => {
+ void runGitAction(item.id);
+ }}
+ >
+ {item.label}
+ </button>
+ );
+ })}
+ {gitStatus?.branch === null && (
+ <p className="px-2 pt-1 text-[10px] text-amber-500 dark:text-amber-300">
+ Detached HEAD: push and PR actions are unavailable.
+ </p>
+ )}
+ </div>
+ )}
+ </div>
+ )}
{/* Diff toggle */}
<button
type="button"
@@ -639,6 +824,18 @@ export default function ChatView() {
</div>
)}
+ {gitActionError && (
+ <div className="mx-4 mt-3 rounded-lg border border-rose-400/20 bg-rose-900/20 px-3 py-2 text-xs text-rose-200">
+ {gitActionError}
+ </div>
+ )}
+
+ {gitActionNotice && (
+ <div className="mx-4 mt-3 rounded-lg border border-emerald-400/20 bg-emerald-500/[0.08] px-3 py-2 text-xs text-emerald-100">
+ {gitActionNotice}
+ </div>
+ )}
+
{pendingApprovals.length > 0 && (
<div className="mx-4 mt-3 space-y-2">
{pendingApprovals.map((approval) => {
diff --git a/apps/web/src/wsNativeApi.ts b/apps/web/src/wsNativeApi.ts
index 257efa47a..6d85f513f 100644
--- a/apps/web/src/wsNativeApi.ts
+++ b/apps/web/src/wsNativeApi.ts
@@ -96,6 +96,10 @@ export function createWsNativeApi(): NativeApi {
openInEditor: (cwd, editor) =>
transport.request(WS_METHODS.shellOpenInEditor, { cwd, editor }),
},
+ git: {
+ status: (input) => transport.request(WS_METHODS.gitStatus, input),
+ runStackedAction: (input) => transport.request(WS_METHODS.gitRunStackedAction, input),
+ },
contextMenu: {
show: async <T extends string>(
items: readonly { id: T; label: string }[],
diff --git a/packages/contracts/src/git.test.ts b/packages/contracts/src/git.test.ts
new file mode 100644
index 000000000..de13eed5d
--- /dev/null
+++ b/packages/contracts/src/git.test.ts
@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+
+import {
+ gitRunStackedActionInputSchema,
+ gitRunStackedActionResultSchema,
+ gitStackedActionSchema,
+ gitStatusInputSchema,
+ gitStatusResultSchema,
+} from "./git";
+
+describe("git contracts", () => {
+ it("parses git status input and trims cwd", () => {
+ const parsed = gitStatusInputSchema.parse({ cwd: " /tmp/repo " });
+ expect(parsed.cwd).toBe("/tmp/repo");
+ });
+
+ it("parses git status result", () => {
+ const parsed = gitStatusResultSchema.parse({
+ branch: "feature/git-actions",
+ hasWorkingTreeChanges: true,
+ hasUpstream: false,
+ aheadCount: 0,
+ behindCount: 0,
+ });
+ expect(parsed.branch).toBe("feature/git-actions");
+ expect(parsed.hasWorkingTreeChanges).toBe(true);
+ });
+
+ it("accepts supported stacked actions", () => {
+ expect(gitStackedActionSchema.parse("commit")).toBe("commit");
+ expect(gitStackedActionSchema.parse("commit_push")).toBe("commit_push");
+ expect(gitStackedActionSchema.parse("commit_push_pr")).toBe(
+ "commit_push_pr",
+ );
+ });
+
+ it("parses stacked action input", () => {
+ const parsed = gitRunStackedActionInputSchema.parse({
+ cwd: "/tmp/repo",
+ action: "commit_push",
+ });
+ expect(parsed.action).toBe("commit_push");
+ });
+
+ it("parses stacked action result with metadata", () => {
+ const parsed = gitRunStackedActionResultSchema.parse({
+ action: "commit_push_pr",
+ commit: {
+ status: "created",
+ commitSha: "abc123",
+ subject: "Implement stacked git actions",
+ },
+ push: {
+ status: "pushed",
+ branch: "feature/git-actions",
+ upstreamBranch: "origin/feature/git-actions",
+ setUpstream: true,
+ },
+ pr: {
+ status: "created",
+ url: "https://github.com/pingdotgg/codething-mvp/pull/123",
+ number: 123,
+ baseBranch: "main",
+ headBranch: "feature/git-actions",
+ title: "Add stacked git actions workflow",
+ },
+ });
+
+ expect(parsed.commit.status).toBe("created");
+ expect(parsed.pr.number).toBe(123);
+ });
+});
+
diff --git a/packages/contracts/src/git.ts b/packages/contracts/src/git.ts
new file mode 100644
index 000000000..360923f07
--- /dev/null
+++ b/packages/contracts/src/git.ts
@@ -0,0 +1,66 @@
+import { z } from "zod";
+
+export const gitStatusInputSchema = z.object({
+ cwd: z.string().trim().min(1),
+});
+
+export const gitStatusResultSchema = z.object({
+ branch: z.string().min(1).nullable(),
+ hasWorkingTreeChanges: z.boolean(),
+ hasUpstream: z.boolean(),
+ aheadCount: z.number().int().nonnegative(),
+ behindCount: z.number().int().nonnegative(),
+});
+
+export const gitStackedActionSchema = z.enum([
+ "commit",
+ "commit_push",
+ "commit_push_pr",
+]);
+
+const gitCommitStepStatusSchema = z.enum(["created", "skipped_no_changes"]);
+const gitPushStepStatusSchema = z.enum([
+ "pushed",
+ "skipped_not_requested",
+ "skipped_up_to_date",
+]);
+const gitPrStepStatusSchema = z.enum([
+ "created",
+ "opened_existing",
+ "skipped_not_requested",
+]);
+
+export const gitRunStackedActionInputSchema = z.object({
+ cwd: z.string().trim().min(1),
+ action: gitStackedActionSchema,
+});
+
+export const gitRunStackedActionResultSchema = z.object({
+ action: gitStackedActionSchema,
+ commit: z.object({
+ status: gitCommitStepStatusSchema,
+ commitSha: z.string().min(1).optional(),
+ subject: z.string().min(1).optional(),
+ }),
+ push: z.object({
+ status: gitPushStepStatusSchema,
+ branch: z.string().min(1).optional(),
+ upstreamBranch: z.string().min(1).optional(),
+ setUpstream: z.boolean().optional(),
+ }),
+ pr: z.object({
+ status: gitPrStepStatusSchema,
+ url: z.string().url().optional(),
+ number: z.number().int().positive().optional(),
+ baseBranch: z.string().min(1).optional(),
+ headBranch: z.string().min(1).optional(),
+ title: z.string().min(1).optional(),
+ }),
+});
+
+export type GitStatusInput = z.input<typeof gitStatusInputSchema>;
+export type GitStatusResult = z.infer<typeof gitStatusResultSchema>;
+export type GitStackedAction = z.infer<typeof gitStackedActionSchema>;
+export type GitRunStackedActionInput = z.input<typeof gitRunStackedActionInputSchema>;
+export type GitRunStackedActionResult = z.infer<typeof gitRunStackedActionResultSchema>;
+
diff --git a/packages/contracts/src/index.ts b/packages/contracts/src/index.ts
index ec007fc29..430f4fd84 100644
--- a/packages/contracts/src/index.ts
+++ b/packages/contracts/src/index.ts
@@ -6,3 +6,4 @@ export * from "./provider";
export * from "./model";
export * from "./ws";
export * from "./project";
+export * from "./git";
diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.ts
index e1f748f83..84c1a3001 100644
--- a/packages/contracts/src/ipc.ts
+++ b/packages/contracts/src/ipc.ts
@@ -1,4 +1,10 @@
import type { AgentConfig, AgentExit, OutputChunk } from "./agent";
+import type {
+ GitRunStackedActionInput,
+ GitRunStackedActionResult,
+ GitStatusInput,
+ GitStatusResult,
+} from "./git";
import type {
ProviderEvent,
ProviderInterruptTurnInput,
@@ -62,6 +68,12 @@ export interface NativeApi {
shell: {
openInEditor: (cwd: string, editor: EditorId) => Promise<void>;
};
+ git: {
+ status: (input: GitStatusInput) => Promise<GitStatusResult>;
+ runStackedAction: (
+ input: GitRunStackedActionInput,
+ ) => Promise<GitRunStackedActionResult>;
+ };
contextMenu: {
show: <T extends string>(
items: readonly { id: T; label: string }[],
diff --git a/packages/contracts/src/ws.ts b/packages/contracts/src/ws.ts
index 3264ca0eb..243606693 100644
--- a/packages/contracts/src/ws.ts
+++ b/packages/contracts/src/ws.ts
@@ -19,6 +19,10 @@ export const WS_METHODS = {
// Shell methods
shellOpenInEditor: "shell.openInEditor",
+ // Git methods
+ gitStatus: "git.status",
+ gitRunStackedAction: "git.runStackedAction",
+
// Server meta
serverGetConfig: "server.getConfig",
} as const;