@trim21/personal-pi-extensions 0.0.122 → 0.0.124

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trim21/personal-pi-extensions",
-  "version": "0.0.122",
+  "version": "0.0.124",
   "type": "module",
   "description": "Custom pi coding-agent extensions: bwrap sandbox, workspace guard, opencode edit, and more",
   "keywords": [

package/src/gh-readonly.ts

@@ -48,8 +48,7 @@ interface GhResult {
 
 // ── helpers ──────────────────────────────────────────────────────────────────
 
-function execGh(
-  pi: ExtensionAPI,
+function runGh(
   args: string[],
   ctx: { cwd?: string; signal?: AbortSignal; timeout?: number },
 ): Promise<GhResult> {
@@ -119,29 +118,40 @@ function execGh(
   });
 }
 
-/** Result of a gh invocation. On failure, `args` carries the full raw command input for debugging. */
-export interface GhExecResult {
-  ok: boolean;
-  stdout: string;
-  error: string | null;
-  args: string[];
+/**
+ * Error thrown by `ghExec` when the `gh` invocation exits non-zero.
+ * The message carries the toolcall input (JSON) wrapped in `<input>` markers,
+ * and the command output wrapped in `<output>` markers.
+ */
+export class GhError extends Error {
+  readonly args: string[];
+  readonly code: number;
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly input?: unknown;
+
+  constructor(args: string[], result: GhResult, input?: unknown) {
+    const inputText = input === undefined ? "" : `<input>${JSON.stringify(input)}<input>\n`;
+    super(`${inputText}<output>${result.combined.trim() || `exit code ${result.code}`}<output>`);
+    this.name = "GhError";
+    this.args = args;
+    this.code = result.code;
+    this.stdout = result.stdout;
+    this.stderr = result.stderr;
+    this.input = input;
+  }
 }
 
+/** Run `gh` and return stdout. On non-zero exit, throws a `GhError` carrying the toolcall input and raw command. */
 async function ghExec(
-  pi: ExtensionAPI,
   args: string[],
-  ctx: { cwd?: string; signal?: AbortSignal },
-): Promise<GhExecResult> {
-  const result = await execGh(pi, args, ctx);
+  ctx: { cwd?: string; signal?: AbortSignal; input?: unknown },
+): Promise<string> {
+  const result = await runGh(args, ctx);
   if (result.code !== 0) {
-    return {
-      ok: false,
-      stdout: "",
-      error: result.combined.trim() || `exit code ${result.code}`,
-      args,
-    };
+    throw new GhError(args, result, ctx.input);
   }
-  return { ok: true, stdout: result.stdout, error: null, args };
+  return result.stdout;
 }
 
 function repoArgs(repo?: string): string[] {
@@ -171,22 +181,14 @@ function truncate(
 }
 
 /**
- * Convert a gh invocation result into a tool result.
- *
- * On failure, returns the error text as content and includes the raw command
- * input (`args`) in `details` so the user can debug what the model actually ran.
+ * Format a successful gh invocation's stdout into a tool result.
+ * Failures are thrown by `ghExec` as `GhError`, so only the success path lives here.
  */
-function toToolResult(res: GhExecResult): {
+function toToolResult(stdout: string): {
   content: Array<{ type: "text"; text: string }>;
   details: Record<string, unknown>;
 } {
-  if (!res.ok) {
-    return {
-      content: [{ type: "text", text: `gh ${res.args.join(" ")} failed: ${res.error}` }],
-      details: { error: res.error, args: res.args },
-    };
-  }
-  const { text, truncated } = truncate(res.stdout);
+  const { text, truncated } = truncate(stdout);
   return { content: [{ type: "text", text }], details: { truncated } };
 }
 
@@ -220,16 +222,16 @@ export function stepsDetail(
 }
 
 /** In-flight dedup map to avoid concurrent fetches of the same log. */
-const inflightLogs = new Map<string, Promise<GhExecResult & { log?: string }>>();
+const inflightLogs = new Map<string, Promise<string>>();
 
 async function getJobLog(
-  pi: ExtensionAPI,
   runId: string,
   jobId: number,
   effectiveRepo: string,
   signal: AbortSignal | undefined,
   cwd: string | undefined,
-): Promise<GhExecResult & { log?: string }> {
+  input?: unknown,
+): Promise<string> {
   const cacheDir = join(homedir(), ".cache", "pi", "ci-logs", runId);
   const cacheFile = join(cacheDir, `${jobId}.log`);
   const key = `${runId}:${jobId}`;
@@ -238,28 +240,27 @@ async function getJobLog(
   const inflight = inflightLogs.get(key);
   if (inflight) return inflight;
 
-  const fetchAndCache = async (): Promise<GhExecResult & { log?: string }> => {
+  const fetchAndCache = async (): Promise<string> => {
     // Check file cache
     try {
-      const cached = await readFile(cacheFile, "utf-8");
-      return { ok: true, stdout: cached, error: null, args: [], log: cached };
+      return await readFile(cacheFile, "utf-8");
     } catch {
       // Not cached, fetch from GitHub
     }
 
-    const res = await ghExec(pi, ["api", `/repos/${effectiveRepo}/actions/jobs/${jobId}/logs`], {
+    const log = await ghExec(["api", `/repos/${effectiveRepo}/actions/jobs/${jobId}/logs`], {
       cwd,
       signal,
+      input,
     });
-    if (!res.ok) return res;
 
     // Write to cache
     await mkdir(cacheDir, { recursive: true });
     await withFileMutationQueue(cacheFile, async () => {
-      await writeFile(cacheFile, res.stdout);
+      await writeFile(cacheFile, log);
     });
 
-    return { ...res, log: res.stdout };
+    return log;
   };
 
   const promise = fetchAndCache();
@@ -272,15 +273,14 @@ async function getJobLog(
 }
 
 async function resolveRepo(
-  pi: ExtensionAPI,
   repo: string | undefined,
   signal: AbortSignal | undefined,
   cwd: string | undefined,
-): Promise<GhExecResult & { repo?: string }> {
-  if (repo) return { ok: true, stdout: "", error: null, args: [], repo };
-  const res = await ghExec(pi, ["repo", "view", "--json", "nameWithOwner"], { cwd, signal });
-  if (!res.ok) return res;
-  return { ...res, repo: JSON.parse(res.stdout).nameWithOwner };
+  input?: unknown,
+): Promise<string> {
+  if (repo) return repo;
+  const stdout = await ghExec(["repo", "view", "--json", "nameWithOwner"], { cwd, signal, input });
+  return JSON.parse(stdout).nameWithOwner;
 }
 
 export function statusIcon(conclusion: string | null): string {
@@ -403,7 +403,6 @@ export default function (pi: ExtensionAPI) {
       const { number, repo } = params as { number: number | string; repo?: string };
       return toToolResult(
         await ghExec(
-          pi,
           [
             "issue",
             "view",
@@ -412,7 +411,7 @@ export default function (pi: ExtensionAPI) {
             "--json",
             "title,state,body,author,createdAt,updatedAt,closedAt,url,labels,assignees,comments,milestone,number",
           ],
-          { cwd: ctx.cwd, signal },
+          { cwd: ctx.cwd, signal, input: params },
         ),
       );
     },
@@ -434,7 +433,7 @@ export default function (pi: ExtensionAPI) {
       const args = ["issue", "list", ...repoArgs(repo)];
       if (state) args.push("--state", state);
       if (limit) args.push("--limit", String(limit));
-      return toToolResult(await ghExec(pi, args, { cwd: ctx.cwd, signal }));
+      return toToolResult(await ghExec(args, { cwd: ctx.cwd, signal, input: params }));
     },
   });
 
@@ -452,7 +451,6 @@ export default function (pi: ExtensionAPI) {
       const { number, repo } = params as { number: number | string; repo?: string };
       return toToolResult(
         await ghExec(
-          pi,
           [
             "pr",
             "view",
@@ -461,7 +459,7 @@ export default function (pi: ExtensionAPI) {
             "--json",
             "title,state,body,author,createdAt,updatedAt,mergedAt,mergedBy,headRefName,baseRefName,url,additions,deletions,changedFiles,labels,assignees,reviewRequests,reviews,comments,number",
           ],
-          { cwd: ctx.cwd, signal },
+          { cwd: ctx.cwd, signal, input: params },
         ),
       );
     },
@@ -485,7 +483,7 @@ export default function (pi: ExtensionAPI) {
       const args = ["pr", "list", ...repoArgs(repo)];
       if (state) args.push("--state", state);
       if (limit) args.push("--limit", String(limit));
-      return toToolResult(await ghExec(pi, args, { cwd: ctx.cwd, signal }));
+      return toToolResult(await ghExec(args, { cwd: ctx.cwd, signal, input: params }));
     },
   });
 
@@ -505,7 +503,7 @@ export default function (pi: ExtensionAPI) {
         repo?: string;
       };
       const args = ["pr", "diff", String(number), ...repoArgs(repo)];
-      return toToolResult(await ghExec(pi, args, { cwd: ctx.cwd, signal }));
+      return toToolResult(await ghExec(args, { cwd: ctx.cwd, signal, input: params }));
     },
   });
 
@@ -522,9 +520,10 @@ export default function (pi: ExtensionAPI) {
     async execute(_id, params, signal, _onUpdate, ctx) {
       const { number, repo } = params as { number: number | string; repo?: string };
       return toToolResult(
-        await ghExec(pi, ["pr", "checks", String(number), ...repoArgs(repo)], {
+        await ghExec(["pr", "checks", String(number), ...repoArgs(repo)], {
           cwd: ctx.cwd,
           signal,
+          input: params,
         }),
       );
     },
@@ -555,24 +554,23 @@ export default function (pi: ExtensionAPI) {
       };
       let out: string;
       if (reviews) {
-        const resolved = await resolveRepo(pi, repo, signal, ctx.cwd);
-        if (!resolved.ok) return toToolResult(resolved);
+        const effectiveRepo = await resolveRepo(repo, signal, ctx.cwd, params);
 
-        const [commentsRes, reviewsRes] = await Promise.all([
-          ghExec(pi, ["api", `/repos/${resolved.repo!}/pulls/${String(number)}/comments`], {
+        const [comments, reviewsOut] = await Promise.all([
+          ghExec(["api", `/repos/${effectiveRepo}/pulls/${String(number)}/comments`], {
             cwd: ctx.cwd,
             signal,
+            input: params,
           }),
-          ghExec(pi, ["api", `/repos/${resolved.repo!}/pulls/${String(number)}/reviews`], {
+          ghExec(["api", `/repos/${effectiveRepo}/pulls/${String(number)}/reviews`], {
             cwd: ctx.cwd,
             signal,
+            input: params,
           }),
         ]);
-        if (!commentsRes.ok) return toToolResult(commentsRes);
-        if (!reviewsRes.ok) return toToolResult(reviewsRes);
 
-        const reviewComments = JSON.parse(commentsRes.stdout);
-        const reviewSummaries = JSON.parse(reviewsRes.stdout);
+        const reviewComments = JSON.parse(comments);
+        const reviewSummaries = JSON.parse(reviewsOut);
 
         out = JSON.stringify(
           {
@@ -583,16 +581,14 @@ export default function (pi: ExtensionAPI) {
           2,
         );
       } else {
-        const res = await ghExec(
-          pi,
+        out = await ghExec(
           ["pr", "view", String(number), ...repoArgs(repo), "--json", "comments"],
           {
             cwd: ctx.cwd,
             signal,
+            input: params,
           },
         );
-        if (!res.ok) return toToolResult(res);
-        out = res.stdout;
       }
       const { text, truncated } = truncate(out);
       return {
@@ -615,11 +611,11 @@ export default function (pi: ExtensionAPI) {
     async execute(_id, params, signal, _onUpdate, ctx) {
       const { number, repo } = params as { number: number | string; repo?: string };
       return toToolResult(
-        await ghExec(
-          pi,
-          ["issue", "view", String(number), ...repoArgs(repo), "--json", "comments"],
-          { cwd: ctx.cwd, signal },
-        ),
+        await ghExec(["issue", "view", String(number), ...repoArgs(repo), "--json", "comments"], {
+          cwd: ctx.cwd,
+          signal,
+          input: params,
+        }),
       );
     },
   });
@@ -649,7 +645,7 @@ export default function (pi: ExtensionAPI) {
       if (limit) args.push("--limit", String(limit));
       if (status) args.push("--status", status);
       if (workflow) args.push("--workflow", workflow);
-      return toToolResult(await ghExec(pi, args, { cwd: ctx.cwd, signal }));
+      return toToolResult(await ghExec(args, { cwd: ctx.cwd, signal, input: params }));
     },
   });
 
@@ -700,16 +696,13 @@ export default function (pi: ExtensionAPI) {
 
       // ── Fetch specific step logs ───────────────────────────────────────
       if (step !== undefined && step !== null) {
-        const resolved = await resolveRepo(pi, repo, signal, ctx.cwd);
-        if (!resolved.ok) return toToolResult(resolved);
+        const effectiveRepo = await resolveRepo(repo, signal, ctx.cwd, params);
 
-        const jobsRes = await ghExec(
-          pi,
-          ["api", `/repos/${resolved.repo!}/actions/runs/${run_id}/jobs`],
-          { cwd: ctx.cwd, signal },
+        const jobsOut = await ghExec(
+          ["api", `/repos/${effectiveRepo}/actions/runs/${run_id}/jobs`],
+          { cwd: ctx.cwd, signal, input: params },
         );
-        if (!jobsRes.ok) return toToolResult(jobsRes);
-        const { jobs } = JSON.parse(jobsRes.stdout) as {
+        const { jobs } = JSON.parse(jobsOut) as {
           jobs: Array<{
             id: number;
             name: string;
@@ -804,16 +797,14 @@ export default function (pi: ExtensionAPI) {
           details: {},
         });
 
-        const logRes = await getJobLog(
-          pi,
+        const rawLog = await getJobLog(
           String(run_id),
           targetJob.id,
-          resolved.repo!,
+          effectiveRepo,
           signal,
           ctx.cwd,
+          params,
         );
-        if (!logRes.ok) return toToolResult(logRes);
-        const rawLog = logRes.log!;
 
         const stepLog = extractStepFromLog(rawLog, stepNum, targetJob.steps);
         if (stepLog === null) {
@@ -891,16 +882,14 @@ export default function (pi: ExtensionAPI) {
         details: {},
       });
 
-      const resolved = await resolveRepo(pi, repo, signal, ctx.cwd);
-      if (!resolved.ok) return toToolResult(resolved);
+      const effectiveRepo = await resolveRepo(repo, signal, ctx.cwd, params);
 
-      const jobsRes = await ghExec(
-        pi,
-        ["api", `/repos/${resolved.repo!}/actions/runs/${run_id}/jobs`],
-        { cwd: ctx.cwd, signal },
-      );
-      if (!jobsRes.ok) return toToolResult(jobsRes);
-      const { jobs } = JSON.parse(jobsRes.stdout) as {
+      const jobsOut = await ghExec(["api", `/repos/${effectiveRepo}/actions/runs/${run_id}/jobs`], {
+        cwd: ctx.cwd,
+        signal,
+        input: params,
+      });
+      const { jobs } = JSON.parse(jobsOut) as {
         jobs: Array<{
           id: number;
           name: string;
@@ -974,15 +963,14 @@ export default function (pi: ExtensionAPI) {
         if (failedSteps.length === 0) continue;
 
         try {
-          const logRes = await getJobLog(pi, String(run_id), j.id, resolved.repo!, signal, ctx.cwd);
-          if (!logRes.ok) {
-            contents.push({
-              type: "text",
-              text: `\n⚠️ Could not auto-fetch logs for ${j.name}: gh ${logRes.args.join(" ")} failed: ${logRes.error}`,
-            });
-            continue;
-          }
-          const rawLog = logRes.log!;
+          const rawLog = await getJobLog(
+            String(run_id),
+            j.id,
+            effectiveRepo,
+            signal,
+            ctx.cwd,
+            params,
+          );
 
           for (const fs of failedSteps) {
             if (fetchedCount >= maxFailed) break;
@@ -1047,12 +1035,12 @@ export default function (pi: ExtensionAPI) {
     }),
     async execute(_id, params, signal, _onUpdate, ctx) {
       const { run_id, repo } = params as { run_id: number | string; repo?: string };
-      const resolved = await resolveRepo(pi, repo, signal, ctx.cwd);
-      if (!resolved.ok) return toToolResult(resolved);
+      const effectiveRepo = await resolveRepo(repo, signal, ctx.cwd, params);
       return toToolResult(
-        await ghExec(pi, ["api", `/repos/${resolved.repo!}/actions/runs/${run_id}/jobs`], {
+        await ghExec(["api", `/repos/${effectiveRepo}/actions/runs/${run_id}/jobs`], {
           cwd: ctx.cwd,
           signal,
+          input: params,
         }),
       );
     },
@@ -1071,7 +1059,7 @@ export default function (pi: ExtensionAPI) {
       const { repo } = params as { repo?: string };
       const args = ["repo", "view"];
       if (repo) args.push(repo);
-      return toToolResult(await ghExec(pi, args, { cwd: ctx.cwd, signal }));
+      return toToolResult(await ghExec(args, { cwd: ctx.cwd, signal, input: params }));
     },
   });
 
@@ -1089,7 +1077,7 @@ export default function (pi: ExtensionAPI) {
       const { repo, limit } = params as { repo?: string; limit?: number };
       const args = ["release", "list", ...repoArgs(repo)];
       if (limit) args.push("--limit", String(limit));
-      return toToolResult(await ghExec(pi, args, { cwd: ctx.cwd, signal }));
+      return toToolResult(await ghExec(args, { cwd: ctx.cwd, signal, input: params }));
     },
   });
 
@@ -1106,9 +1094,10 @@ export default function (pi: ExtensionAPI) {
     async execute(_id, params, signal, _onUpdate, ctx) {
       const { tag, repo } = params as { tag: string; repo?: string };
       return toToolResult(
-        await ghExec(pi, ["release", "view", tag, ...repoArgs(repo)], {
+        await ghExec(["release", "view", tag, ...repoArgs(repo)], {
           cwd: ctx.cwd,
           signal,
+          input: params,
         }),
       );
     },
@@ -1144,7 +1133,7 @@ export default function (pi: ExtensionAPI) {
       const args = ["pr", "checks", String(number), ...repoArgs(repo), "--watch"];
       if (fail_fast) args.push("--fail-fast");
 
-      const result = await execGh(pi, args, { cwd: ctx.cwd, signal, timeout: 600_000 });
+      const result = await runGh(args, { cwd: ctx.cwd, signal, timeout: 600_000 });
 
       const exitCode = result.code;
       const stdout = result.stdout;
@@ -1191,7 +1180,7 @@ export default function (pi: ExtensionAPI) {
         details: {},
       });
 
-      const result = await execGh(pi, ["run", "watch", String(run_id), ...repoArgs(repo)], {
+      const result = await runGh(["run", "watch", String(run_id), ...repoArgs(repo)], {
         cwd: ctx.cwd,
         signal,
         timeout: 600_000,
@@ -1235,9 +1224,9 @@ export default function (pi: ExtensionAPI) {
         limit?: number;
       };
       const args = ["search", "issues", query];
-      if (!include_prs) args.push("--type", "issue");
+      if (include_prs) args.push("--include-prs");
       if (limit) args.push("--limit", String(limit));
-      return toToolResult(await ghExec(pi, args, { cwd: ctx.cwd, signal }));
+      return toToolResult(await ghExec(args, { cwd: ctx.cwd, signal, input: params }));
     },
   });
 
@@ -1258,7 +1247,7 @@ export default function (pi: ExtensionAPI) {
       const { query, limit } = params as { query: string; limit?: number };
       const args = ["search", "prs", query];
       if (limit) args.push("--limit", String(limit));
-      return toToolResult(await ghExec(pi, args, { cwd: ctx.cwd, signal }));
+      return toToolResult(await ghExec(args, { cwd: ctx.cwd, signal, input: params }));
     },
   });
 }