pi-graphite 0.2.2 → 0.3.0

package/src/tools/recovery.ts

@@ -1,53 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { runGt } from "../lib/exec";
-import { ensureSuccess, renderText } from "../lib/result";
-import { CwdParam, StringEnum, Type, type ToolReturn } from "../lib/schema";
-
-export function registerRecovery(pi: ExtensionAPI) {
-  pi.registerTool({
-    name: "graphite_recovery",
-    label: "Graphite: recovery",
-    description:
-      "Recover from conflicts or mistakes: continue a halted command, abort it, or undo the most recent Graphite mutation in this worktree.",
-    promptSnippet:
-      "graphite_recovery: continue / abort / undo Graphite commands",
-    promptGuidelines: [
-      "After resolving a rebase conflict, run graphite_recovery action=continue to resume the original gt command.",
-      "graphite_recovery action=undo only undoes commands run from the current worktree.",
-    ],
-    parameters: Type.Object({
-      cwd: CwdParam,
-      action: StringEnum(["continue", "abort", "undo"] as const),
-      stageAll: Type.Optional(
-        Type.Boolean({ description: "action=continue: stage all changes first (--all)." }),
-      ),
-      force: Type.Optional(
-        Type.Boolean({ description: "action=abort|undo: skip confirmation prompt (--force)." }),
-      ),
-    }),
-    async execute(_id, p, signal): Promise<ToolReturn> {
-      let args: string[];
-      switch (p.action) {
-        case "continue":
-          args = ["continue"];
-          if (p.stageAll) args.push("--all");
-          break;
-        case "abort":
-          args = ["abort"];
-          if (p.force) args.push("--force");
-          break;
-        case "undo":
-          args = ["undo"];
-          if (p.force) args.push("--force");
-          break;
-      }
-      const label = `gt ${args.join(" ")}`;
-      const r = await runGt(args, { cwd: p.cwd, signal });
-      const f = await ensureSuccess(label, r, p.cwd);
-      return {
-        content: [{ type: "text", text: renderText(label, f) }],
-        details: { action: p.action, result: f },
-      };
-    },
-  });
-}

package/src/tools/remote.ts

@@ -1,108 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { runGt } from "../lib/exec";
-import { ensureSuccess, renderText } from "../lib/result";
-import {
-  CwdParam,
-  StringEnum,
-  Type,
-  requireConfirm,
-  type ToolReturn,
-} from "../lib/schema";
-
-export function registerRemoteSync(pi: ExtensionAPI) {
-  pi.registerTool({
-    name: "graphite_remote_sync",
-    label: "Graphite: remote sync",
-    description:
-      "Sync local branches with remote: `gt sync` (pull trunk + restack + cleanup) or `gt get` (fetch a branch / PR locally).",
-    promptSnippet:
-      "graphite_remote_sync: `gt sync` for cleanup+restack, or `gt get` to import a branch/PR",
-    promptGuidelines: [
-      "Run graphite_remote_sync action=sync at the start of a session to update trunk and restack open stacks.",
-      "graphite_remote_sync action=sync with force=true or deleteAll=true is destructive; pass confirmDestructive:true.",
-    ],
-    parameters: Type.Object({
-      cwd: CwdParam,
-      action: StringEnum(["sync", "get"] as const),
-
-      // sync
-      allTrunks: Type.Optional(Type.Boolean({ description: "sync: --all" })),
-      deleteAll: Type.Optional(
-        Type.Boolean({
-          description:
-            "sync|get: delete all merged/closed branches without prompting (--delete-all). Requires confirmDestructive.",
-        }),
-      ),
-      force: Type.Optional(
-        Type.Boolean({
-          description:
-            "sync|get: overwrite local branches with remote (--force). Requires confirmDestructive.",
-        }),
-      ),
-      restack: Type.Optional(
-        Type.Boolean({
-          description: "sync|get: restack after fetching (default true; pass false for --no-restack).",
-        }),
-      ),
-
-      // get
-      target: Type.Optional(
-        Type.String({ description: "get: branch name or PR number to fetch." }),
-      ),
-      downstack: Type.Optional(
-        Type.Boolean({ description: "get: --downstack (don't sync upstack)." }),
-      ),
-      remoteUpstack: Type.Optional(
-        Type.Boolean({ description: "get: --remote-upstack (include remote-only upstack)." }),
-      ),
-      checkout: Type.Optional(
-        Type.Boolean({ description: "get: check out target after sync (default true; false => --no-checkout)." }),
-      ),
-      unfrozen: Type.Optional(
-        Type.Boolean({ description: "get: --unfrozen (new branches editable)." }),
-      ),
-
-      confirmDestructive: Type.Optional(Type.Boolean()),
-    }),
-    async execute(_id, p, signal): Promise<ToolReturn> {
-      const args: string[] = [p.action];
-
-      if (p.action === "sync") {
-        if (p.force || p.deleteAll) {
-          requireConfirm(
-            p.confirmDestructive,
-            "gt sync with --force/--delete-all (may overwrite branches)",
-          );
-        }
-        if (p.allTrunks) args.push("--all");
-        if (p.deleteAll) args.push("--delete-all");
-        if (p.force) args.push("--force");
-        if (p.restack === false) args.push("--no-restack");
-      } else {
-        if (!p.target) throw new Error("action=get requires `target` (branch name or PR number).");
-        args.push(p.target);
-        if (p.downstack) args.push("--downstack");
-        if (p.remoteUpstack) args.push("--remote-upstack");
-        if (p.force) {
-          requireConfirm(p.confirmDestructive, "gt get --force (overwrites local branches)");
-          args.push("--force");
-        }
-        if (p.deleteAll) {
-          requireConfirm(p.confirmDestructive, "gt get --delete-all");
-          args.push("--delete-all");
-        }
-        if (p.checkout === false) args.push("--no-checkout");
-        if (p.restack === false) args.push("--no-restack");
-        if (p.unfrozen) args.push("--unfrozen");
-      }
-
-      const label = `gt ${args.join(" ")}`;
-      const r = await runGt(args, { cwd: p.cwd, signal });
-      const f = await ensureSuccess(label, r, p.cwd);
-      return {
-        content: [{ type: "text", text: renderText(label, f) }],
-        details: { action: p.action, result: f },
-      };
-    },
-  });
-}

package/src/tools/repo.ts

@@ -1,122 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { runGt } from "../lib/exec";
-import { ensureAllSuccess, ensureSuccess, renderText } from "../lib/result";
-import { CwdParam, StringEnum, Type, type ToolReturn } from "../lib/schema";
-
-const params = Type.Object({
-  cwd: CwdParam,
-  action: StringEnum(["status", "init", "set_trunk", "show_config"] as const),
-  trunk: Type.Optional(
-    Type.String({
-      description:
-        "Trunk branch name. Required for action=set_trunk. Optional for action=init (otherwise gt prompts).",
-    }),
-  ),
-  addAdditionalTrunk: Type.Optional(
-    Type.Boolean({
-      description:
-        "If true with action=set_trunk, add an additional trunk via `gt trunk --add` instead of replacing.",
-    }),
-  ),
-  reset: Type.Optional(
-    Type.Boolean({
-      description: "If true with action=init, untrack all branches (gt init --reset).",
-    }),
-  ),
-});
-
-export function registerRepo(pi: ExtensionAPI) {
-  pi.registerTool({
-    name: "graphite_repo",
-    label: "Graphite: repo",
-    description:
-      "Repo-level Graphite operations: status snapshot (log + trunk), init, set/add trunk, and show config.",
-    promptSnippet:
-      "graphite_repo: inspect repo state, initialize Graphite, configure trunk(s)",
-    parameters: params,
-    async execute(_id, p, signal): Promise<ToolReturn> {
-      const cwd = p.cwd;
-
-      if (p.action === "status") {
-        const [trunk, log] = await Promise.all([
-          runGt(["trunk"], { cwd, signal }),
-          runGt(["log", "short"], { cwd, signal }),
-        ]);
-        const [ft, fl] = await ensureAllSuccess(
-          [
-            { label: "gt trunk", result: trunk },
-            { label: "gt log short", result: log },
-          ],
-          cwd,
-        );
-        return {
-          content: [
-            {
-              type: "text",
-              text: [renderText("gt trunk", ft), renderText("gt log short", fl)].join("\n\n"),
-            },
-          ],
-          details: { trunk: ft, log: fl },
-        };
-      }
-
-      if (p.action === "init") {
-        const args = ["init"];
-        if (p.trunk) args.push("--trunk", p.trunk);
-        if (p.reset) args.push("--reset");
-        const r = await runGt(args, { cwd, signal });
-        const f = await ensureSuccess(`gt ${args.join(" ")}`, r, cwd);
-        return {
-          content: [{ type: "text", text: renderText(`gt ${args.join(" ")}`, f) }],
-          details: { result: f },
-        };
-      }
-
-      if (p.action === "set_trunk") {
-        if (!p.trunk) throw new Error("action=set_trunk requires `trunk`.");
-        if (!p.addAdditionalTrunk) {
-          const args = ["init", "--trunk", p.trunk];
-          const r = await runGt(args, { cwd, signal });
-          const f = await ensureSuccess(`gt ${args.join(" ")}`, r, cwd);
-          return {
-            content: [
-              { type: "text", text: renderText(`gt ${args.join(" ")}`, f) },
-            ],
-            details: { result: f },
-          };
-        }
-        // `gt trunk --add` is interactive (prompts for the new trunk name).
-        // With --no-interactive this will fail; surface that failure rather
-        // than silently misleading the caller.
-        const r = await runGt(["trunk", "--add"], { cwd, signal });
-        const f = await ensureSuccess("gt trunk --add", r, cwd);
-        return {
-          content: [{ type: "text", text: renderText("gt trunk --add", f) }],
-          details: { result: f },
-        };
-      }
-
-      // show_config
-      const [trunk, trunkAll] = await Promise.all([
-        runGt(["trunk"], { cwd, signal }),
-        runGt(["trunk", "--all"], { cwd, signal }),
-      ]);
-      const [ft, fta] = await ensureAllSuccess(
-        [
-          { label: "gt trunk", result: trunk },
-          { label: "gt trunk --all", result: trunkAll },
-        ],
-        cwd,
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: [renderText("gt trunk", ft), renderText("gt trunk --all", fta)].join("\n\n"),
-          },
-        ],
-        details: { trunk: ft, trunkAll: fta },
-      };
-    },
-  });
-}

package/src/tools/stack.ts

@@ -1,185 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { runGt } from "../lib/exec";
-import { ensureSuccess, renderText } from "../lib/result";
-import {
-  CwdParam,
-  StringEnum,
-  Type,
-  requireConfirm,
-  type ToolReturn,
-} from "../lib/schema";
-
-/* ------------------------------ stack_view ------------------------------ */
-
-export function registerStackView(pi: ExtensionAPI) {
-  pi.registerTool({
-    name: "graphite_stack_view",
-    label: "Graphite: stack view",
-    description:
-      "Show the Graphite stack as `gt log` (short/long/full). Read-only.",
-    promptSnippet:
-      "graphite_stack_view: read-only `gt log` of branches + dependencies",
-    parameters: Type.Object({
-      cwd: CwdParam,
-      mode: Type.Optional(
-        StringEnum(["short", "long", "full"] as const, {
-          description: "short = `gt log short`, long = `gt log long`, full = `gt log`.",
-        }),
-      ),
-      scope: Type.Optional(
-        StringEnum(["all_trunks", "current_stack", "default"] as const, {
-          description:
-            "all_trunks adds --all (only supported on mode=full/default). current_stack adds --stack. default does neither.",
-        }),
-      ),
-      showUntracked: Type.Optional(Type.Boolean()),
-      reverse: Type.Optional(Type.Boolean()),
-      steps: Type.Optional(Type.Integer({ minimum: 1 })),
-    }),
-    async execute(_id, p, signal): Promise<ToolReturn> {
-      // Empirically, current gt rejects `--all` on `gt log short` / `gt log long`
-      // ("Unknown argument: all"). Block that combination at the tool layer
-      // instead of exposing it to the model.
-      if (p.scope === "all_trunks" && (p.mode === "short" || p.mode === "long")) {
-        throw new Error(
-          "graphite_stack_view: scope='all_trunks' is not supported with mode='short'/'long' " +
-            "(current `gt` rejects `--all` on those forms). Omit `mode` (or use mode='full') to use --all.",
-        );
-      }
-
-      const sub =
-        p.mode === "short"
-          ? ["log", "short"]
-          : p.mode === "long"
-            ? ["log", "long"]
-            : ["log"];
-      const args = [...sub];
-      if (p.scope === "all_trunks") args.push("--all");
-      if (p.scope === "current_stack") args.push("--stack");
-      if (p.showUntracked) args.push("--show-untracked");
-      if (p.reverse) args.push("--reverse");
-      if (p.steps != null) args.push("--steps", String(p.steps));
-
-      const label = `gt ${args.join(" ")}`;
-      const r = await runGt(args, { cwd: p.cwd, signal });
-      const f = await ensureSuccess(label, r, p.cwd);
-      return {
-        content: [{ type: "text", text: renderText(label, f) }],
-        details: { result: f },
-      };
-    },
-  });
-}
-
-/* ----------------------------- stack_restack ----------------------------- */
-
-export function registerStackRestack(pi: ExtensionAPI) {
-  pi.registerTool({
-    name: "graphite_stack_restack",
-    label: "Graphite: restack",
-    description:
-      "Restack the current stack (or a chosen branch / scope) so each branch contains its parent's history. Local mutation only.",
-    promptSnippet:
-      "graphite_stack_restack: rebase stack so each branch contains parent history",
-    promptGuidelines: [
-      "Use graphite_stack_restack after editing a downstack branch to bring descendants up to date.",
-    ],
-    parameters: Type.Object({
-      cwd: CwdParam,
-      scope: Type.Optional(
-        StringEnum(["current_stack", "downstack", "upstack", "only"] as const, {
-          description:
-            "Default current_stack (no scope flag). downstack=--downstack, upstack=--upstack, only=--only.",
-        }),
-      ),
-      branch: Type.Optional(
-        Type.String({ description: "Branch to restack from (default: current branch)." }),
-      ),
-    }),
-    async execute(_id, p, signal): Promise<ToolReturn> {
-      const args = ["restack"];
-      if (p.branch) args.push("--branch", p.branch);
-      if (p.scope === "downstack") args.push("--downstack");
-      else if (p.scope === "upstack") args.push("--upstack");
-      else if (p.scope === "only") args.push("--only");
-
-      const label = `gt ${args.join(" ")}`;
-      const r = await runGt(args, { cwd: p.cwd, signal });
-      const f = await ensureSuccess(label, r, p.cwd);
-      return {
-        content: [{ type: "text", text: renderText(label, f) }],
-        details: { result: f },
-      };
-    },
-  });
-}
-
-/* --------------------------- stack_reorganize --------------------------- */
-
-export function registerStackReorganize(pi: ExtensionAPI) {
-  pi.registerTool({
-    name: "graphite_stack_reorganize",
-    label: "Graphite: stack reorganize",
-    description:
-      "Reorganize the stack: move a branch onto a new parent, fold a branch into its parent, or split by file pathspec. `gt reorder` is intentionally not exposed (editor-only).",
-    promptSnippet:
-      "graphite_stack_reorganize: move / fold / split-by-file branches",
-    parameters: Type.Object({
-      cwd: CwdParam,
-      action: StringEnum(["move_branch", "fold", "split_by_file"] as const),
-      onto: Type.Optional(Type.String({ description: "Target parent branch (action=move_branch)." })),
-      source: Type.Optional(
-        Type.String({ description: "Source branch to move (default current, action=move_branch)." }),
-      ),
-      onlyMove: Type.Optional(
-        Type.Boolean({ description: "action=move_branch: leave descendants behind (--only)." }),
-      ),
-      foldKeep: Type.Optional(
-        Type.Boolean({ description: "action=fold: keep current branch name (--keep)." }),
-      ),
-      foldStack: Type.Optional(
-        Type.Boolean({ description: "action=fold: fold the entire stack into one branch (--stack)." }),
-      ),
-      foldClose: Type.Optional(
-        Type.Boolean({ description: "action=fold: close associated PRs on GitHub (--close). Requires confirmRemote." }),
-      ),
-      filePatterns: Type.Optional(
-        Type.Array(Type.String(), {
-          description: "action=split_by_file: one or more pathspecs (-f). Repeat-flag style.",
-        }),
-      ),
-      confirmRemote: Type.Optional(Type.Boolean()),
-    }),
-    async execute(_id, p, signal): Promise<ToolReturn> {
-      let args: string[];
-      if (p.action === "move_branch") {
-        if (!p.onto) throw new Error("action=move_branch requires `onto`.");
-        args = ["move", "--onto", p.onto];
-        if (p.source) args.push("--source", p.source);
-        if (p.onlyMove) args.push("--only");
-      } else if (p.action === "fold") {
-        if (p.foldClose) requireConfirm(p.confirmRemote, "fold --close");
-        args = ["fold"];
-        if (p.foldKeep) args.push("--keep");
-        if (p.foldStack) args.push("--stack");
-        if (p.foldClose) args.push("--close");
-      } else {
-        if (!p.filePatterns || p.filePatterns.length === 0) {
-          throw new Error(
-            "action=split_by_file requires `filePatterns` (one or more pathspecs).",
-          );
-        }
-        args = ["split", "--by-file"];
-        for (const pat of p.filePatterns) args.push("-f", pat);
-      }
-
-      const label = `gt ${args.join(" ")}`;
-      const r = await runGt(args, { cwd: p.cwd, signal });
-      const f = await ensureSuccess(label, r, p.cwd);
-      return {
-        content: [{ type: "text", text: renderText(label, f) }],
-        details: { action: p.action, result: f },
-      };
-    },
-  });
-}