pi-graphite 0.0.1 → 0.1.0

package/src/tools/repo.ts

@@ -0,0 +1,121 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runGt } from "../lib/exec";
+import { formatResult, 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 = formatResult(trunk);
+        const fl = formatResult(log);
+        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 = formatResult(r);
+        return {
+          content: [{ type: "text", text: renderText("gt init", f) }],
+          details: { result: f },
+        };
+      }
+
+      if (p.action === "set_trunk") {
+        if (!p.trunk) throw new Error("action=set_trunk requires `trunk`.");
+        const args = ["trunk"];
+        if (p.addAdditionalTrunk) args.push("--add");
+        // gt trunk --add prompts for trunk name; not all gt versions accept positional.
+        // Fall back to gt init --trunk for non-additional sets.
+        if (!p.addAdditionalTrunk) {
+          const r = await runGt(["init", "--trunk", p.trunk], { cwd, signal });
+          const f = formatResult(r);
+          return {
+            content: [
+              { type: "text", text: renderText(`gt init --trunk ${p.trunk}`, f) },
+            ],
+            details: { result: f },
+          };
+        }
+        // Additional trunk path: run interactively-allowed since --add prompts.
+        const r = await runGt(args, {
+          cwd,
+          signal,
+          allowInteractive: false,
+        });
+        const f = formatResult(r);
+        return {
+          content: [{ type: "text", text: renderText("gt trunk --add", f) }],
+          details: { result: f, note: "Additional trunk addition may require interactive input." },
+        };
+      }
+
+      // show_config
+      const [trunk, trunkAll] = await Promise.all([
+        runGt(["trunk"], { cwd, signal }),
+        runGt(["trunk", "--all"], { cwd, signal }),
+      ]);
+      return {
+        content: [
+          {
+            type: "text",
+            text: [
+              renderText("gt trunk", formatResult(trunk)),
+              renderText("gt trunk --all", formatResult(trunkAll)),
+            ].join("\n\n"),
+          },
+        ],
+        details: {
+          trunk: formatResult(trunk),
+          trunkAll: formatResult(trunkAll),
+        },
+      };
+    },
+  });
+}

package/src/tools/stack.ts

@@ -0,0 +1,176 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runGt } from "../lib/exec";
+import { formatResult, 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, 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> {
+      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 r = await runGt(args, { cwd: p.cwd, signal });
+      const f = formatResult(r);
+      return {
+        content: [{ type: "text", text: renderText(`gt ${args.join(" ")}`, 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 r = await runGt(args, { cwd: p.cwd, signal });
+      const f = formatResult(r);
+      return {
+        content: [{ type: "text", text: renderText(`gt ${args.join(" ")}`, 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> {
+      if (p.action === "move_branch") {
+        if (!p.onto) throw new Error("action=move_branch requires `onto`.");
+        const args = ["move", "--onto", p.onto];
+        if (p.source) args.push("--source", p.source);
+        if (p.onlyMove) args.push("--only");
+        const r = await runGt(args, { cwd: p.cwd, signal });
+        const f = formatResult(r);
+        return {
+          content: [{ type: "text", text: renderText(`gt ${args.join(" ")}`, f) }],
+          details: { result: f },
+        };
+      }
+
+      if (p.action === "fold") {
+        if (p.foldClose) requireConfirm(p.confirmRemote, "fold --close");
+        const args = ["fold"];
+        if (p.foldKeep) args.push("--keep");
+        if (p.foldStack) args.push("--stack");
+        if (p.foldClose) args.push("--close");
+        const r = await runGt(args, { cwd: p.cwd, signal });
+        const f = formatResult(r);
+        return {
+          content: [{ type: "text", text: renderText(`gt ${args.join(" ")}`, f) }],
+          details: { result: f },
+        };
+      }
+
+      // split_by_file
+      if (!p.filePatterns || p.filePatterns.length === 0) {
+        throw new Error("action=split_by_file requires `filePatterns` (one or more pathspecs).");
+      }
+      const args = ["split", "--by-file"];
+      for (const pat of p.filePatterns) args.push("-f", pat);
+      const r = await runGt(args, { cwd: p.cwd, signal });
+      const f = formatResult(r);
+      return {
+        content: [{ type: "text", text: renderText(`gt ${args.join(" ")}`, f) }],
+        details: { result: f },
+      };
+    },
+  });
+}

package/index.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = {};