pullfrog 0.0.203 → 0.0.204

package/dist/internal/index.d.ts

@@ -9,4 +9,6 @@ export { modes } from "../modes.ts";
 export type { BuildPullfrogFooterParams, WorkflowRunFooterInfo, } from "../utils/buildPullfrogFooter.ts";
 export { buildPullfrogFooter, PULLFROG_DIVIDER, stripExistingFooter, } from "../utils/buildPullfrogFooter.ts";
 export type { ResourceUsage, UsageSummary } from "../utils/github.ts";
+export type { CreateProgressCommentTarget, ProgressComment, ProgressCommentType, } from "../utils/progressComment.ts";
+export { createLeapingProgressComment, deleteProgressCommentApi, getProgressComment, updateProgressComment, } from "../utils/progressComment.ts";
 export { isValidTimeString, parseTimeString, TIMEOUT_DISABLED, } from "../utils/time.ts";

package/dist/internal.js

@@ -93,14 +93,14 @@ var providers = {
     models: {
       grok: {
         displayName: "Grok",
-        resolve: "xai/grok-4",
-        openRouterResolve: "openrouter/x-ai/grok-4",
+        resolve: "xai/grok-4.3",
+        openRouterResolve: "openrouter/x-ai/grok-4.3",
         preferred: true
       },
       "grok-fast": {
         displayName: "Grok Fast",
-        resolve: "xai/grok-4-fast",
-        openRouterResolve: "openrouter/x-ai/grok-4-fast"
+        resolve: "xai/grok-4-1-fast",
+        openRouterResolve: "openrouter/x-ai/grok-4.1-fast"
       },
       "grok-code-fast": {
         displayName: "Grok Code Fast",
@@ -307,8 +307,8 @@ var providers = {
       },
       grok: {
         displayName: "Grok",
-        resolve: "openrouter/x-ai/grok-4",
-        openRouterResolve: "openrouter/x-ai/grok-4"
+        resolve: "openrouter/x-ai/grok-4.3",
+        openRouterResolve: "openrouter/x-ai/grok-4.3"
       },
       "deepseek-pro": {
         displayName: "DeepSeek Pro",
@@ -857,6 +857,103 @@ function stripExistingFooter(body) {
   return body.substring(0, dividerIndex).trimEnd();
 }
 
+// utils/progressComment.ts
+async function getProgressComment(ctx, comment) {
+  const result = await (comment.type === "review" ? ctx.octokit.rest.pulls.getReviewComment({
+    owner: ctx.owner,
+    repo: ctx.repo,
+    comment_id: comment.id
+  }) : ctx.octokit.rest.issues.getComment({
+    owner: ctx.owner,
+    repo: ctx.repo,
+    comment_id: comment.id
+  }));
+  return {
+    id: result.data.id,
+    body: result.data.body ?? void 0,
+    html_url: result.data.html_url
+  };
+}
+async function updateProgressComment(ctx, comment, body) {
+  const result = await (comment.type === "review" ? ctx.octokit.rest.pulls.updateReviewComment({
+    owner: ctx.owner,
+    repo: ctx.repo,
+    comment_id: comment.id,
+    body
+  }) : ctx.octokit.rest.issues.updateComment({
+    owner: ctx.owner,
+    repo: ctx.repo,
+    comment_id: comment.id,
+    body
+  }));
+  return {
+    id: result.data.id,
+    body: result.data.body ?? void 0,
+    html_url: result.data.html_url,
+    node_id: result.data.node_id
+  };
+}
+async function deleteProgressCommentApi(ctx, comment) {
+  if (comment.type === "review") {
+    await ctx.octokit.rest.pulls.deleteReviewComment({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      comment_id: comment.id
+    });
+    return;
+  }
+  await ctx.octokit.rest.issues.deleteComment({
+    owner: ctx.owner,
+    repo: ctx.repo,
+    comment_id: comment.id
+  });
+}
+async function createLeapingProgressComment(ctx, target, body) {
+  if (target.kind === "reviewReply") {
+    try {
+      const result2 = await ctx.octokit.rest.pulls.createReplyForReviewComment({
+        owner: ctx.owner,
+        repo: ctx.repo,
+        pull_number: target.pullNumber,
+        comment_id: target.replyToCommentId,
+        body
+      });
+      return {
+        comment: { id: result2.data.id, type: "review" },
+        body: result2.data.body ?? void 0,
+        html_url: result2.data.html_url
+      };
+    } catch (error) {
+      console.warn(
+        `[progressComment] review reply failed (parent ${target.replyToCommentId} on PR #${target.pullNumber}), falling back to issue comment:`,
+        error
+      );
+      const fallback = await ctx.octokit.rest.issues.createComment({
+        owner: ctx.owner,
+        repo: ctx.repo,
+        issue_number: target.pullNumber,
+        body
+      });
+      return {
+        comment: { id: fallback.data.id, type: "issue" },
+        body: fallback.data.body ?? void 0,
+        html_url: fallback.data.html_url
+      };
+    }
+  }
+  const result = await ctx.octokit.rest.issues.createComment({
+    owner: ctx.owner,
+    repo: ctx.repo,
+    issue_number: target.issueNumber,
+    body
+  });
+  return {
+    comment: { id: result.data.id, type: "issue" },
+    body: result.data.body ?? void 0,
+    html_url: result.data.html_url
+  };
+}
+
 // utils/time.ts
 var TIMEOUT_DISABLED = "none";
 var TIME_STRING_REGEX = /^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/;
@@ -875,8 +972,11 @@ export {
   PULLFROG_DIVIDER,
   TIMEOUT_DISABLED,
   buildPullfrogFooter,
+  createLeapingProgressComment,
+  deleteProgressCommentApi,
   getModelEnvVars,
   getModelProvider,
+  getProgressComment,
   getProviderDisplayName,
   isValidTimeString,
   modelAliases,
@@ -889,5 +989,6 @@ export {
   resolveDisplayAlias,
   resolveModelSlug,
   resolveOpenRouterModel,
-  stripExistingFooter
+  stripExistingFooter,
+  updateProgressComment
 };

package/dist/mcp/comment.d.ts

@@ -39,12 +39,15 @@ export declare const ReportProgress: import("arktype/internal/variants/object.ts
 /**
  * Report progress to a GitHub comment.
  *
- * progressCommentId has three states:
+ * progressComment has three states:
  *   - undefined: no comment yet — will create one if an issue/PR target exists
- *   - number:    active comment — will update it in place
+ *   - object:    active comment — will update it in place via the right REST endpoint for its type
  *   - null:      deliberately deleted (e.g. after submitting a PR review) — skips silently
  *
  * The body is always tracked in lastProgressBody for the job summary regardless of comment state.
+ *
+ * The "existing plan comment" path always targets a top-level issue comment (plan comments are
+ * created by create_issue_comment with type:"Plan", never as review-thread replies).
  */
 export declare function reportProgress(ctx: ToolContext, params: {
     body: string;
@@ -66,7 +69,7 @@ export declare function ReportProgressTool(ctx: ToolContext): import("fastmcp").
  * Delete the progress comment if it exists.
  * Used by main.ts for stranded-comment cleanup (orphaned "Leaping into action" or
  * checklist left by the todo tracker when the agent didn't call report_progress).
- * Sets progressCommentId to null so subsequent report_progress calls are no-ops.
+ * Sets progressComment to null so subsequent report_progress calls are no-ops.
  */
 export declare function deleteProgressComment(ctx: ToolContext): Promise<boolean>;
 export declare const ReplyToReviewComment: import("arktype/internal/variants/object.ts").ObjectType<{

package/dist/mcp/git.d.ts

@@ -6,6 +6,8 @@ export declare const PushBranch: import("arktype/internal/variants/object.ts").O
     force: import("arktype/internal/attributes.ts").Default<boolean, false>;
     branchName?: string;
 }, {}>;
+export type PushErrorKind = "concurrent-push" | "transient" | "unknown";
+export declare function classifyPushError(msg: string): PushErrorKind;
 export declare function PushBranchTool(ctx: ToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
     branchName?: string;
     force?: boolean;

package/dist/mcp/reviewComments.d.ts

@@ -97,6 +97,35 @@ interface GetReviewDataInput {
     reviewId: number;
     approvedBy?: string | undefined;
 }
+export interface FormatReviewDataInput {
+    review: ReviewResponse;
+    threads: ReviewThread[];
+    prFiles: ReviewPrFile[];
+    pullNumber: number;
+    reviewId: number;
+}
+export type ReviewResponse = {
+    body: string | null | undefined;
+    user: {
+        login: string;
+    } | null | undefined;
+};
+export type ReviewPrFile = {
+    filename: string;
+    patch?: string | undefined;
+};
+export declare function formatReviewData(input: FormatReviewDataInput): {
+    threadBlocks: Array<{
+        path: string;
+        lineRange: string;
+        content: string[];
+    }>;
+    reviewer: string;
+    formatted: {
+        toc: string;
+        content: string;
+    };
+} | undefined;
 export declare function getReviewData(input: GetReviewDataInput): Promise<{
     threadBlocks: Array<{
         path: string;

package/dist/mcp/server.d.ts

@@ -6,6 +6,8 @@ import type { PrepResult } from "../prep/index.ts";
 import type { DiffCoverageState } from "../utils/diffCoverage.ts";
 import type { OctokitWithPlugins } from "../utils/github.ts";
 import type { ResolvedPayload } from "../utils/payload.ts";
+import { type ProgressComment, type ProgressCommentType } from "../utils/progressComment.ts";
+import type { AccountPlan } from "../utils/runContext.ts";
 import type { RunContextData } from "../utils/runContextData.ts";
 import type { TodoTracker } from "../utils/todoTracking.ts";
 import type { CommentableLines } from "./review.ts";
@@ -48,7 +50,7 @@ export interface ToolState {
         promise: Promise<PrepResult[]> | undefined;
         results: PrepResult[] | undefined;
     };
-    progressCommentId: number | null | undefined;
+    progressComment: ProgressComment | null | undefined;
     hadProgressComment: boolean;
     lastProgressBody?: string;
     wasUpdated?: boolean;
@@ -63,7 +65,10 @@ export interface ToolState {
     diffCoverage?: DiffCoverageState | undefined;
 }
 interface InitToolStateParams {
-    progressCommentId: string | undefined;
+    progressComment: {
+        id: string;
+        type: ProgressCommentType;
+    } | undefined;
 }
 export declare function initToolState(params: InitToolStateParams): ToolState;
 export interface ToolContext {
@@ -84,6 +89,8 @@ export interface ToolContext {
     jobId: string | undefined;
     mcpServerUrl: string;
     tmpdir: string;
+    oss: boolean;
+    plan: AccountPlan;
     resolvedModel: string | undefined;
 }
 type JsonSchema = Record<string, unknown>;

package/dist/utils/payload.d.ts

@@ -9,7 +9,10 @@ export declare const JsonPayload: import("arktype/internal/variants/object.ts").
     eventInstructions?: string;
     event?: object;
     timeout?: string | undefined;
-    progressCommentId?: string | undefined;
+    progressComment?: {
+        id: string;
+        type: "issue" | "review";
+    } | undefined;
 }, {}>;
 export declare const Inputs: import("arktype/internal/variants/object.ts").ObjectType<{
     prompt: string;
@@ -33,7 +36,10 @@ export declare function resolvePayload(resolvedPromptInput: ResolvedPromptInput,
     event: PayloadEvent;
     timeout: string | undefined;
     cwd: string | undefined;
-    progressCommentId: string | undefined;
+    progressComment: {
+        id: string;
+        type: "issue" | "review";
+    } | undefined;
     push: import("../external.ts").PushPermission;
     shell: import("../external.ts").ShellPermission;
     proxyModel: string | undefined;

package/dist/utils/progressComment.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Single source of truth for reading, updating, deleting, and creating "progress comments" —
+ * the GitHub comments Pullfrog uses to surface a run's status.
+ *
+ * A progress comment can be one of two distinct GitHub entities with non-overlapping IDs and
+ * distinct REST endpoints:
+ *   - "issue":  a top-level issue/PR timeline comment (octokit.rest.issues.*Comment)
+ *   - "review": an inline PR review-thread comment   (octokit.rest.pulls.*ReviewComment)
+ *
+ * Callers carry a `ProgressComment` (id + type) value end-to-end so the right endpoint is always
+ * picked. Adding a third comment type later means one new branch in this file, not six.
+ */
+export type ProgressCommentType = "issue" | "review";
+export type ProgressComment = {
+    id: number;
+    type: ProgressCommentType;
+};
+/**
+ * Parse the on-the-wire `{ id: string; type }` shape (the form carried in `JsonPayload`)
+ * into the in-memory `ProgressComment` shape. Returns undefined when the id isn't a
+ * positive integer so callers can short-circuit cleanly. Callers handle logging.
+ */
+export declare function parseProgressComment(raw: {
+    id: string;
+    type: ProgressCommentType;
+} | null | undefined): ProgressComment | undefined;
+interface CommentResponse {
+    data: {
+        id: number;
+        body?: string | null | undefined;
+        html_url: string;
+        node_id?: string;
+    };
+}
+export interface ProgressCommentOctokit {
+    rest: {
+        issues: {
+            createComment: (params: {
+                owner: string;
+                repo: string;
+                issue_number: number;
+                body: string;
+            }) => Promise<CommentResponse>;
+            getComment: (params: {
+                owner: string;
+                repo: string;
+                comment_id: number;
+            }) => Promise<CommentResponse>;
+            updateComment: (params: {
+                owner: string;
+                repo: string;
+                comment_id: number;
+                body: string;
+            }) => Promise<CommentResponse>;
+            deleteComment: (params: {
+                owner: string;
+                repo: string;
+                comment_id: number;
+            }) => Promise<unknown>;
+        };
+        pulls: {
+            createReplyForReviewComment: (params: {
+                owner: string;
+                repo: string;
+                pull_number: number;
+                comment_id: number;
+                body: string;
+            }) => Promise<CommentResponse>;
+            getReviewComment: (params: {
+                owner: string;
+                repo: string;
+                comment_id: number;
+            }) => Promise<CommentResponse>;
+            updateReviewComment: (params: {
+                owner: string;
+                repo: string;
+                comment_id: number;
+                body: string;
+            }) => Promise<CommentResponse>;
+            deleteReviewComment: (params: {
+                owner: string;
+                repo: string;
+                comment_id: number;
+            }) => Promise<unknown>;
+        };
+    };
+}
+interface ApiCtx {
+    octokit: ProgressCommentOctokit;
+    owner: string;
+    repo: string;
+}
+/**
+ * Fetch a progress comment via the appropriate REST endpoint for its type.
+ * Returns the common subset of fields callers actually use.
+ */
+export declare function getProgressComment(ctx: ApiCtx, comment: ProgressComment): Promise<{
+    id: number;
+    body: string | undefined;
+    html_url: string;
+}>;
+/**
+ * Update a progress comment in place via the appropriate REST endpoint.
+ * Returns the common subset of fields callers actually use.
+ */
+export declare function updateProgressComment(ctx: ApiCtx, comment: ProgressComment, body: string): Promise<{
+    id: number;
+    body: string | undefined;
+    html_url: string;
+    node_id: string | undefined;
+}>;
+/**
+ * Delete a progress comment via the appropriate REST endpoint.
+ * Lower-level than `deleteProgressComment` in mcp/comment.ts — that one also clears
+ * tool state. Callers that don't have a ToolContext (post cleanup, error handlers)
+ * should use this directly; the higher-level wrapper delegates here.
+ */
+export declare function deleteProgressCommentApi(ctx: ApiCtx, comment: ProgressComment): Promise<void>;
+/**
+ * Discriminated target for `createLeapingProgressComment`. The two variants map to the two
+ * distinct GitHub create endpoints; review-reply additionally needs the parent comment ID.
+ */
+export type CreateProgressCommentTarget = {
+    kind: "issue";
+    issueNumber: number;
+} | {
+    kind: "reviewReply";
+    pullNumber: number;
+    replyToCommentId: number;
+};
+export interface CreatedProgressComment {
+    comment: ProgressComment;
+    body: string | undefined;
+    html_url: string;
+}
+/**
+ * Create the initial "Leaping into action..." progress comment.
+ *
+ * Reliability: when `kind: "reviewReply"` fails (e.g. the parent comment was deleted or the
+ * thread is otherwise unreachable), falls back to a top-level issue comment on the same PR
+ * rather than leaving the run with no progress surface. The fallback is logged.
+ *
+ * (PR # === issue # in GitHub's number space, so `pullNumber` doubles as the fallback target.)
+ */
+export declare function createLeapingProgressComment(ctx: ApiCtx, target: CreateProgressCommentTarget, body: string): Promise<CreatedProgressComment>;
+export {};

package/dist/utils/runContext.d.ts

@@ -20,10 +20,26 @@ export interface RepoSettings {
     learnings: string | null;
     envAllowlist: string | null;
 }
+/**
+ * Account-level billing plan. Orthogonal to repo-level OSS status. Mirrors
+ * the server's `AccountPlan` in `utils/billing.ts`. `"none"` = free tier,
+ * `"payg"` = card on file / pay-as-you-go.
+ */
+export type AccountPlan = "none" | "payg";
+/**
+ * "Is Pullfrog absorbing marginal infra cost for this repo?" — composite
+ * predicate over the two orthogonal dimensions (repo-level OSS, account-level
+ * plan). Mirrors `isInfraCovered` in the server's `utils/billing.ts`.
+ */
+export declare function isInfraCovered(params: {
+    isOss: boolean;
+    plan: AccountPlan;
+}): boolean;
 export interface RunContext {
     settings: RepoSettings;
     apiToken: string;
     oss: boolean;
+    plan: AccountPlan;
     proxyModel?: string | undefined;
     dbSecrets?: Record<string, string> | undefined;
 }

package/dist/utils/runContextData.d.ts

@@ -1,6 +1,6 @@
 import type { Octokit } from "@octokit/rest";
 import { type OctokitWithPlugins } from "./github.ts";
-import { type RepoSettings } from "./runContext.ts";
+import { type AccountPlan, type RepoSettings } from "./runContext.ts";
 export interface RunContextData {
     repo: {
         owner: string;
@@ -10,6 +10,7 @@ export interface RunContextData {
     repoSettings: RepoSettings;
     apiToken: string;
     oss: boolean;
+    plan: AccountPlan;
     proxyModel?: string | undefined;
     dbSecrets?: Record<string, string> | undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pullfrog",
-  "version": "0.0.203",
+  "version": "0.0.204",
   "type": "module",
   "bin": {
     "pullfrog": "dist/cli.mjs",