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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsxindex 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 textareauseEffect(() => {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 editoruseEffect(() => {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 */}<buttontype="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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 3264ca0eb..243606693 100644--- a/packages/contracts/src/ws.ts+++ b/packages/contracts/src/ws.ts@@ -19,6 +19,10 @@ export const WS_METHODS = {// Shell methodsshellOpenInEditor: "shell.openInEditor",+ // Git methods+ gitStatus: "git.status",+ gitRunStackedAction: "git.runStackedAction",+// Server metaserverGetConfig: "server.getConfig",} as const;