@yuangc/paseo-plugin-workspace-overview 0.0.0-stage → 1.0.0

package/index.server.ts

@@ -0,0 +1,33 @@
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { projectIconRpc } from "./shared/project-icon";
+import { readPaseoProjectIcon } from "./server/project-icon-impl";
+import { gitBranchesRpc } from "./shared/git-branches";
+import { readGitBranches } from "./server/git-branches-impl";
+import { terminalLaunchRpc } from "./shared/terminal-launch";
+import { launchWorkspaceTerminal } from "./server/terminal-launch-impl";
+import { autoCommitInfoRpc, autoCommitStartRpc, autoCommitStatusRpc } from "./shared/auto-commit";
+import { readAutoCommitInfo, readAutoCommitTaskStatus, startAutoCommitTask } from "./server/auto-commit-impl";
+import { agentCancelRpc, agentConfigSetRpc, agentRewindRpc, pluginReloadRpc } from "./shared/agent-config";
+import { cancelAgent, closeAgentConfigClient, rewindAgent, setAgentConfig, reloadPlugin } from "./server/agent-config-impl";
+
+export default function contribute(server: PluginServerContext) {
+  server.handle(projectIconRpc, async ({ projectId, projectDirectory }) => ({
+    dataUri: await readPaseoProjectIcon(projectId, projectDirectory),
+  }));
+
+  server.handle(gitBranchesRpc, async ({ projectDirectory }) =>
+    readGitBranches(projectDirectory),
+  );
+
+  server.handle(terminalLaunchRpc, launchWorkspaceTerminal);
+
+  server.handle(autoCommitInfoRpc, readAutoCommitInfo);
+  server.handle(autoCommitStartRpc, startAutoCommitTask);
+  server.handle(autoCommitStatusRpc, ({ taskId }) => readAutoCommitTaskStatus(taskId));
+  server.handle(agentConfigSetRpc, setAgentConfig);
+  server.handle(agentCancelRpc, cancelAgent);
+  server.handle(agentRewindRpc, rewindAgent);
+  server.handle(pluginReloadRpc, reloadPlugin);
+
+  return () => closeAgentConfigClient();
+}

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "@yuangc/paseo-plugin-workspace-overview",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@getpaseo/client": "0.8.0",
+    "@getpaseo/plugin": "0.8.0",
+    "@getpaseo/protocol": "0.8.0",
+    "@tanstack/react-query": "^5.90.11",
+    "@types/react": "~19.2.0",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
+    "typescript": "^5.9.3",
+    "zod": "^4.4.3"
+  },
+  "description": "Paseo plugin: workspace overview, agent previews, heatmap, auto-commit, terminal launch",
+  "files": [
+    "paseo-plugin.json",
+    "index.client.tsx",
+    "index.server.ts",
+    "client/",
+    "server/",
+    "shared/"
+  ],
+  "repository": {
+    "url": "git+https://github.com/ygcedu/paseo-plugin-workspace-overview.git"
+  }
+}

package/paseo-plugin.json

@@ -0,0 +1,4 @@
+{
+  "id": "workspace-overview",
+  "requirements": { "paseo": ">=0.8.0" }
+}

package/server/agent-config-impl.ts

@@ -0,0 +1,57 @@
+import { DaemonClient } from "@getpaseo/client/internal/daemon-client";
+import type { RpcInput } from "@getpaseo/plugin";
+import { agentCancelRpc, agentConfigSetRpc, agentRewindRpc, pluginReloadRpc } from "../shared/agent-config";
+
+let clientPromise: Promise<DaemonClient> | null = null;
+
+async function getClient(): Promise<DaemonClient> {
+  if (!clientPromise) {
+    clientPromise = (async () => {
+      const client = new DaemonClient({
+        url: "ws://127.0.0.1:6767/ws",
+        clientId: `workspace-overview-${process.pid}`,
+        clientType: "cli",
+        appVersion: "0.8.0",
+        reconnect: { enabled: false },
+      });
+      await client.connect();
+      return client;
+    })().catch((error) => {
+      clientPromise = null;
+      throw error;
+    });
+  }
+  return clientPromise;
+}
+
+export async function setAgentConfig({ agentId, field, value }: RpcInput<typeof agentConfigSetRpc>) {
+  const client = await getClient();
+  if (field === "model") await client.setAgentModel(agentId, value);
+  else if (field === "mode") await client.setAgentMode(agentId, value);
+  else await client.setAgentThinkingOption(agentId, value);
+  return { ok: true as const };
+}
+
+export async function cancelAgent({ agentId }: RpcInput<typeof agentCancelRpc>) {
+  const client = await getClient();
+  await client.cancelAgent(agentId);
+  return { ok: true as const };
+}
+
+export async function rewindAgent({ agentId, messageId, mode }: RpcInput<typeof agentRewindRpc>) {
+  const client = await getClient();
+  await client.rewindAgent(agentId, messageId, mode);
+  return { ok: true as const };
+}
+
+export async function reloadPlugin({ pluginId }: RpcInput<typeof pluginReloadRpc>) {
+  const client = await getClient();
+  await client.reloadPlugin(pluginId);
+  return { ok: true as const };
+}
+
+export async function closeAgentConfigClient() {
+  const pending = clientPromise;
+  clientPromise = null;
+  if (pending) await (await pending).close();
+}

package/server/auto-commit-impl.ts

@@ -0,0 +1,221 @@
+import { execFile, spawn } from "node:child_process";
+import { realpath } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, join, parse } from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const PLUGIN_ID = "workspace-overview";
+const PI_MODEL = "9router/coding";
+
+interface AutoCommitTask {
+  taskId: string;
+  cwd: string;
+  status: "running" | "done" | "error";
+  output: string;
+  error: string | null;
+  exitCode: number | null;
+  startedAt: string;
+  finishedAt: string | null;
+  cleanupScheduled: boolean;
+}
+
+const tasks = new Map<string, AutoCommitTask>();
+const startingDirectories = new Set<string>();
+
+function getModuleDirectory(): string | null {
+  const metaUrl = (import.meta as { url?: string }).url;
+  if (typeof metaUrl === "string" && metaUrl.length > 0) {
+    return dirname(fileURLToPath(metaUrl));
+  }
+
+  const stack = new Error().stack ?? "";
+  const match = stack.match(/\(?((?:\/[^():]+)+\/auto-commit-impl\.server\.[tj]s)/);
+  return match ? dirname(match[1]) : null;
+}
+
+function isPluginGitDirectory(directory: string): boolean {
+  return existsSync(join(directory, "paseo-plugin.json")) && existsSync(join(directory, ".git"));
+}
+
+function findPluginGitDirectoryFromCandidates(): string | null {
+  const moduleDirectory = getModuleDirectory();
+  const candidates = [moduleDirectory, process.cwd()].filter((value): value is string => Boolean(value));
+  for (const candidate of candidates) {
+    let directory = candidate;
+    const root = parse(directory).root;
+    while (directory && directory !== root) {
+      if (isPluginGitDirectory(directory)) {
+        return directory;
+      }
+      directory = dirname(directory);
+    }
+  }
+  return null;
+}
+
+async function findPluginGitDirectoryFromPaseoCli(): Promise<string | null> {
+  try {
+    const { stdout } = await execFileAsync("paseo", ["plugin", "ls"], {
+      encoding: "utf8",
+      maxBuffer: 1024 * 1024,
+    });
+    for (const line of stdout.split("\n")) {
+      if (!line.trim().startsWith(PLUGIN_ID)) continue;
+      const columns = line.trim().split(/\s{2,}/);
+      const directory = columns.find((value) => value.startsWith("/"));
+      if (directory && isPluginGitDirectory(directory)) return directory;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+async function findPluginGitDirectory(): Promise<string> {
+  const directory =
+    findPluginGitDirectoryFromCandidates() ??
+    (await findPluginGitDirectoryFromPaseoCli());
+  if (!directory) {
+    throw new Error(`找不到 ${PLUGIN_ID} 插件的 git 目录`);
+  }
+  return directory;
+}
+
+async function runGit(projectDirectory: string, args: string[]): Promise<string> {
+  const { stdout } = await execFileAsync("git", ["-C", projectDirectory, ...args], {
+    encoding: "utf8",
+    maxBuffer: 1024 * 1024,
+  });
+  return stdout.trim();
+}
+
+async function tryGit(projectDirectory: string, args: string[]): Promise<string | null> {
+  try {
+    return await runGit(projectDirectory, args);
+  } catch {
+    return null;
+  }
+}
+
+export async function readAutoCommitInfo(): Promise<{
+  cwd: string;
+  currentBranch: string | null;
+  hasChanges: boolean;
+  status: string;
+  recentMessages: string[];
+}> {
+  const projectDirectory = await findPluginGitDirectory();
+  return readAutoCommitInfoForDirectory(projectDirectory);
+}
+
+async function readAutoCommitInfoForDirectory(projectDirectory: string): Promise<{
+  cwd: string;
+  currentBranch: string | null;
+  hasChanges: boolean;
+  status: string;
+  recentMessages: string[];
+}> {
+  const [status, currentBranch, log] = await Promise.all([
+    runGit(projectDirectory, ["status", "--short"]),
+    tryGit(projectDirectory, ["symbolic-ref", "--quiet", "--short", "HEAD"]),
+    tryGit(projectDirectory, ["log", "--format=%s", "-8"]),
+  ]);
+
+  return {
+    cwd: projectDirectory,
+    currentBranch,
+    hasChanges: status.length > 0,
+    status,
+    recentMessages: (log ?? "").split("\n").filter(Boolean),
+  };
+}
+
+function buildAutoCommitPrompt() {
+  return [
+    "请帮我提交当前仓库里的待提交改动。",
+    "",
+    "你自己判断怎么提交：可以是一个 commit，也可以根据改动内容拆成多个 commit。",
+    "",
+    "请先用 git 查看最近几条 commit message，参考这个仓库已有的 message 风格。",
+    "然后自己阅读当前所有待提交代码，包括已修改文件和还没被 git 管理的新文件，理解改动内容后再提交。",
+    "",
+    "不要 push，也不要丢弃用户改动。",
+  ].join("\n");
+}
+
+function appendTaskOutput(task: AutoCommitTask, chunk: Buffer | string) {
+  task.output = `${task.output}${chunk.toString()}`.slice(-20_000);
+}
+
+function scheduleTaskCleanup(taskId: string) {
+  const timer = setTimeout(() => tasks.delete(taskId), 10 * 60_000);
+  timer.unref();
+}
+
+export async function startAutoCommitTask({ cwd }: { cwd: string }): Promise<{ taskId: string; cwd: string }> {
+  const directory = await realpath(cwd);
+  const running = [...tasks.values()].find((task) => task.cwd === directory && task.status === "running");
+  if (running) return { taskId: running.taskId, cwd: running.cwd };
+  if (startingDirectories.has(directory)) throw new Error("当前仓库正在启动提交任务，请稍后重试");
+  startingDirectories.add(directory);
+  try {
+    const info = await readAutoCommitInfoForDirectory(directory);
+    if (!info.hasChanges) {
+      throw new Error("没有待提交改动");
+    }
+
+    const task: AutoCommitTask = {
+      taskId: randomUUID(),
+      cwd: info.cwd,
+      status: "running",
+      output: "",
+      error: null,
+      exitCode: null,
+      startedAt: new Date().toISOString(),
+      finishedAt: null,
+      cleanupScheduled: false,
+    };
+    tasks.set(task.taskId, task);
+
+    const child = spawn("pi", ["--model", PI_MODEL, "--approve", "-p", buildAutoCommitPrompt()], {
+      cwd: info.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    child.stdout.on("data", (chunk) => appendTaskOutput(task, chunk));
+    child.stderr.on("data", (chunk) => appendTaskOutput(task, chunk));
+    child.on("error", (error) => {
+      task.status = "error";
+      task.error = error.message;
+      task.finishedAt = new Date().toISOString();
+      if (!task.cleanupScheduled) {
+        task.cleanupScheduled = true;
+        scheduleTaskCleanup(task.taskId);
+      }
+    });
+    child.on("close", (code) => {
+      task.exitCode = code;
+      task.status = code === 0 ? "done" : "error";
+      task.error = code === 0 ? null : task.error ?? `pi 进程退出，exit code ${code}`;
+      task.finishedAt = new Date().toISOString();
+      if (!task.cleanupScheduled) {
+        task.cleanupScheduled = true;
+        scheduleTaskCleanup(task.taskId);
+      }
+    });
+
+    return { taskId: task.taskId, cwd: task.cwd };
+  } finally {
+    startingDirectories.delete(directory);
+  }
+}
+
+export function readAutoCommitTaskStatus(taskId: string): AutoCommitTask {
+  const task = tasks.get(taskId);
+  if (!task) throw new Error(`找不到一键提交任务: ${taskId}`);
+  return task;
+}

package/server/git-branches-impl.ts

@@ -0,0 +1,81 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+interface GitBranchItem {
+  id: string;
+  label: string;
+  detail: string;
+}
+
+async function runGit(projectDirectory: string, args: string[]): Promise<string | null> {
+  try {
+    const { stdout } = await execFileAsync("git", ["-C", projectDirectory, ...args], {
+      encoding: "utf8",
+      maxBuffer: 1024 * 1024,
+    });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+
+export async function readGitBranches(projectDirectory: string): Promise<{
+  currentBranch: string | null;
+  defaultBranch: string | null;
+  branches: GitBranchItem[];
+}> {
+  const [refsOutput, currentBranchOutput, originHeadOutput] = await Promise.all([
+    runGit(projectDirectory, [
+      "for-each-ref",
+      "--format=%(refname)%09%(refname:short)",
+      "refs/heads",
+      "refs/remotes",
+    ]),
+    runGit(projectDirectory, ["symbolic-ref", "--quiet", "--short", "HEAD"]),
+    runGit(projectDirectory, [
+      "symbolic-ref",
+      "--quiet",
+      "--short",
+      "refs/remotes/origin/HEAD",
+    ]),
+  ]);
+
+  const branches = (refsOutput ?? "")
+    .split("\n")
+    .map((line) => line.split("\t"))
+    .filter(([refName, shortName]) =>
+      Boolean(refName && shortName && !refName.endsWith("/HEAD")),
+    )
+    .map(([refName, shortName]) => ({
+      id: shortName,
+      label: shortName,
+      detail: refName.startsWith("refs/heads/") ? "本地分支" : "远程分支",
+    }));
+
+  const localBranchIds = new Set(
+    branches.filter((branch) => branch.detail === "本地分支").map((branch) => branch.id),
+  );
+  const remoteDefault = originHeadOutput?.replace(/^origin\//, "") ?? null;
+  const defaultBranch =
+    currentBranchOutput ??
+    (remoteDefault && localBranchIds.has(remoteDefault) ? remoteDefault : originHeadOutput) ??
+    (localBranchIds.has("main") ? "main" : null) ??
+    (localBranchIds.has("master") ? "master" : null) ??
+    branches[0]?.id ??
+    null;
+
+  branches.sort((left, right) => {
+    if (left.id === currentBranchOutput) return -1;
+    if (right.id === currentBranchOutput) return 1;
+    if (left.detail !== right.detail) return left.detail === "本地分支" ? -1 : 1;
+    return left.label.localeCompare(right.label);
+  });
+
+  return {
+    currentBranch: currentBranchOutput,
+    defaultBranch,
+    branches,
+  };
+}

package/server/project-icon-impl.ts

@@ -0,0 +1,102 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+
+const ICON_NAMES = [
+  "favicon.svg",
+  "favicon.png",
+  "favico.svg",
+  "favico.png",
+  "icon.svg",
+  "icon.png",
+  "app-icon.svg",
+  "app-icon.png",
+  "apple-touch-icon.png",
+  "logo.svg",
+  "logo.png",
+  "favicon.ico",
+];
+
+const ICON_DIRECTORIES = ["public", "static", "priv/static", "assets", "images", "img", ""];
+const IGNORED_DIRECTORIES = new Set([".git", "node_modules", "dist", "build", ".next", ".nuxt", ".output", "coverage", ".cache", "vendor"]);
+
+function mimeType(bytes: Buffer, filePath: string): string | null {
+  if (bytes.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) return "image/png";
+  if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return "image/jpeg";
+  if (bytes.toString("ascii", 0, 6) === "GIF87a" || bytes.toString("ascii", 0, 6) === "GIF89a") return "image/gif";
+  if (bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP") return "image/webp";
+  if (bytes.toString("utf8", 0, 256).includes("<svg") || path.extname(filePath).toLowerCase() === ".svg") return "image/svg+xml";
+  if (path.extname(filePath).toLowerCase() === ".ico") return "image/x-icon";
+  return null;
+}
+
+async function readIcon(filePath: string): Promise<string | null> {
+  try {
+    const bytes = await readFile(filePath);
+    const mime = mimeType(bytes, filePath);
+    return mime ? `data:${mime};base64,${bytes.toString("base64")}` : null;
+  } catch {
+    return null;
+  }
+}
+
+function iconNameMatches(name: string): boolean {
+  return ICON_NAMES.includes(name.toLowerCase()) || /^(favicon-|apple-touch-icon-|icon-|android-chrome-|mstile-).+\.(svg|png)$/i.test(name);
+}
+
+async function findIconInDirectory(directory: string): Promise<string | null> {
+  try {
+    const entries = await readdir(directory);
+    const ordered = [
+      ...ICON_NAMES.flatMap((name) => entries.filter((entry) => entry.toLowerCase() === name)),
+      ...entries.filter(iconNameMatches),
+    ];
+    for (const entry of [...new Set(ordered)]) {
+      const icon = await readIcon(path.join(directory, entry));
+      if (icon) return icon;
+    }
+  } catch {
+    // Missing optional directory.
+  }
+  return null;
+}
+
+async function findIconRecursively(directory: string, depth: number): Promise<string | null> {
+  const direct = await findIconInDirectory(directory);
+  if (direct || depth <= 0) return direct;
+  try {
+    const entries = await readdir(directory);
+    for (const entry of entries) {
+      if (IGNORED_DIRECTORIES.has(entry)) continue;
+      const child = path.join(directory, entry);
+      try {
+        if (!(await stat(child)).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      const icon = await findIconRecursively(child, depth - 1);
+      if (icon) return icon;
+    }
+  } catch {
+    // Unreadable directory.
+  }
+  return null;
+}
+
+export async function readPaseoProjectIcon(projectId: string, projectDirectory: string): Promise<string | null> {
+  const paseoHome = process.env.PASEO_HOME?.trim() || path.join(homedir(), ".paseo");
+  const key = createHash("sha256").update(projectId).digest("hex");
+  const custom = await readIcon(path.join(paseoHome, "projects", "icons", `${key}.bin`));
+  if (custom) return custom;
+
+  for (const directory of ICON_DIRECTORIES) {
+    const icon = await findIconRecursively(path.join(projectDirectory, directory), directory ? 2 : 0);
+    if (icon) return icon;
+  }
+  for (const monorepoDirectory of ["packages", "apps"]) {
+    const icon = await findIconRecursively(path.join(projectDirectory, monorepoDirectory), 3);
+    if (icon) return icon;
+  }
+  return null;
+}

package/server/terminal-launch-impl.ts

@@ -0,0 +1,56 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const PROMPT_SENTINEL = "{{{prompt}}}";
+
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+function resolveProfileCommand(profile: { command: string; args: string[] }, prompt: string): string {
+  const replacePrompt = (value: string) => value.split(PROMPT_SENTINEL).join(prompt);
+  const args = profile.args.flatMap((arg) => {
+    const promptOnly = arg === PROMPT_SENTINEL || arg.endsWith(`=${PROMPT_SENTINEL}`);
+    return !prompt && promptOnly ? [] : [replacePrompt(arg)];
+  });
+  return [replacePrompt(profile.command), ...args].map(shellQuote).join(" ");
+}
+
+function findTerminalId(value: unknown): string | null {
+  if (!value || typeof value !== "object") return null;
+  const record = value as Record<string, unknown>;
+  if (typeof record.id === "string") return record.id;
+  for (const nested of Object.values(record)) {
+    const id = findTerminalId(nested);
+    if (id) return id;
+  }
+  return null;
+}
+
+export async function launchWorkspaceTerminal(input: {
+  workspaceDirectory: string;
+  workspaceId: string;
+  serverId: string;
+  prompt: string;
+  profile: { name: string; command: string; args: string[] } | null;
+}): Promise<{ terminalId: string }> {
+  const createArgs = ["terminal", "create", "--cwd", input.workspaceDirectory, "--json"];
+  if (input.profile?.name) createArgs.push("--name", input.profile.name);
+  const { stdout } = await execFileAsync("paseo", createArgs, { encoding: "utf8" });
+  const terminalId = findTerminalId(JSON.parse(stdout));
+  if (!terminalId) throw new Error("Paseo did not return the created terminal id");
+
+  const line = input.profile
+    ? resolveProfileCommand(input.profile, input.prompt.trim())
+    : input.prompt.trim();
+  if (line) {
+    await execFileAsync(
+      "paseo",
+      ["terminal", "send-keys", "--literal", terminalId, `${line}\r`, "--json"],
+      { encoding: "utf8" },
+    );
+  }
+
+  return { terminalId };
+}

package/shared/agent-activity.ts

@@ -0,0 +1,16 @@
+import type { AgentEntry } from "./overview-types";
+
+/**
+ * Returns the effective activity timestamp (ms since epoch) for an agent.
+ *
+ * Prefers `lastUserMessageAt` (real user interaction); falls back to
+ * `updatedAt` (metadata/status change) so the agent still appears in
+ * sorting and display without being invisible when no user message exists.
+ * Returns 0 when neither field is available — sort-last sentinel.
+ */
+export function agentActivityMs(agent: AgentEntry): number {
+  const iso = agent.lastUserMessageAt ?? agent.updatedAt;
+  if (!iso) return 0;
+  const t = new Date(iso).getTime();
+  return Number.isNaN(t) ? 0 : t;
+}

package/shared/agent-config.ts

@@ -0,0 +1,30 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const agentConfigSetRpc = defineRpc({
+  name: "overview.agent-config.set",
+  input: z.object({
+    agentId: z.string().min(1),
+    field: z.enum(["model", "mode", "thinking"]),
+    value: z.string().min(1),
+  }),
+  output: z.object({ ok: z.literal(true) }),
+});
+
+export const agentCancelRpc = defineRpc({
+  name: "overview.agent.cancel",
+  input: z.object({ agentId: z.string().min(1) }),
+  output: z.object({ ok: z.literal(true) }),
+});
+
+export const agentRewindRpc = defineRpc({
+  name: "overview.agent.rewind",
+  input: z.object({ agentId: z.string().min(1), messageId: z.string().min(1), mode: z.enum(["conversation", "files", "both"]) }),
+  output: z.object({ ok: z.literal(true) }),
+});
+
+export const pluginReloadRpc = defineRpc({
+  name: "overview.plugin.reload",
+  input: z.object({ pluginId: z.string().min(1) }),
+  output: z.object({ ok: z.literal(true) }),
+});

package/shared/auto-commit.ts

@@ -0,0 +1,38 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const autoCommitInfoRpc = defineRpc({
+  name: "auto_commit_info",
+  input: z.object({}),
+  output: z.object({
+    cwd: z.string(),
+    currentBranch: z.string().nullable(),
+    hasChanges: z.boolean(),
+    status: z.string(),
+    recentMessages: z.array(z.string()),
+  }),
+});
+
+export const autoCommitStartRpc = defineRpc({
+  name: "auto_commit_start",
+  input: z.object({ cwd: z.string().min(1) }),
+  output: z.object({
+    taskId: z.string(),
+    cwd: z.string(),
+  }),
+});
+
+export const autoCommitStatusRpc = defineRpc({
+  name: "auto_commit_status",
+  input: z.object({ taskId: z.string().min(1) }),
+  output: z.object({
+    taskId: z.string(),
+    cwd: z.string(),
+    status: z.enum(["running", "done", "error"]),
+    output: z.string(),
+    error: z.string().nullable(),
+    exitCode: z.number().nullable(),
+    startedAt: z.string(),
+    finishedAt: z.string().nullable(),
+  }),
+});