pullfrog 0.1.1 → 0.1.3

package/dist/toolState.d.ts

@@ -0,0 +1,109 @@
+import type { AgentUsage } from "./agents/shared.ts";
+import type { PrepResult } from "./prep/types.ts";
+import type { DiffCoverageState } from "./utils/diffCoverage.ts";
+import { type ProgressComment, type ProgressCommentType } from "./utils/progressComment.ts";
+import type { TodoTracker } from "./utils/todoTracking.ts";
+export type BackgroundProcess = {
+    pid: number;
+    outputPath: string;
+    pidPath: string;
+};
+export type BrowserDaemon = {
+    binDir: string;
+    error?: never;
+} | {
+    binDir?: never;
+    error: string;
+};
+export type StoredPushDest = {
+    remoteName: string;
+    remoteBranch: string;
+    localBranch: string;
+};
+/**
+ * Valid inline-comment anchor lines per side at a particular checkout SHA.
+ * Lives here (not in `mcp/review.ts`) so `ToolState` — which caches
+ * `Map<path, CommentableLines>` per checkout — does not pull the MCP server
+ * graph into every consumer of run state (the action's main loop, agent
+ * harnesses, cf-worker indexing).
+ */
+export type CommentableLines = {
+    RIGHT: Set<number>;
+    LEFT: Set<number>;
+};
+/**
+ * mutable per-run record of facts that occurred during execution. shared
+ * between the action process and the MCP server (one process — toolState is
+ * just a JS object passed by reference into both surfaces).
+ *
+ * design rule: ToolState is LITERAL. each field records a thing that
+ * happened — `review` is set when `create_pull_request_review` succeeded,
+ * `finalSummaryWritten` flips when `report_progress` wrote a non-plan body,
+ * `selectedMode` is set when `select_mode` was called. fields should never
+ * encode the absence of an event ("unsubmittedReview", "missingArtifact"),
+ * speculative state, or values derived from other fields.
+ *
+ * any predicate the rest of the code needs ("the agent picked review mode but
+ * never produced a review or progress write") is computed inline at the call
+ * site, not stored. derived state in this struct invariably drifts from the
+ * literal fields under refactors and is the wrong layer for the check.
+ *
+ * write narrowly: prefer adding state inside the tool that mutates it (e.g.
+ * `create_pull_request_review` populates `toolState.review`) and reading
+ * narrowly elsewhere. don't introduce flags from main.ts that mirror what an
+ * MCP tool already records.
+ */
+export interface ToolState {
+    pushUrl?: string;
+    pushDest?: StoredPushDest;
+    issueNumber?: number;
+    checkoutSha?: string;
+    commentableLinesByFile?: Map<string, CommentableLines>;
+    commentableLinesPullNumber?: number;
+    commentableLinesCheckoutSha?: string | undefined;
+    beforeSha?: string;
+    selectedMode?: string;
+    backgroundProcesses: Map<string, BackgroundProcess>;
+    browserDaemon?: BrowserDaemon | undefined;
+    review?: {
+        id: number;
+        nodeId: string;
+        reviewedSha: string | undefined;
+    };
+    reviewReplies?: Map<number, {
+        commentId: number;
+        url: string | undefined;
+        bodyWithFooter: string;
+    }>;
+    dependencyInstallation?: {
+        status: "not_started" | "in_progress" | "completed" | "failed";
+        promise: Promise<PrepResult[]> | undefined;
+        results: PrepResult[] | undefined;
+    };
+    progressComment: ProgressComment | null | undefined;
+    hadProgressComment: boolean;
+    lastProgressBody?: string;
+    wasUpdated?: boolean;
+    finalSummaryWritten?: boolean;
+    existingPlanCommentId?: number;
+    previousPlanBody?: string;
+    summaryFilePath?: string;
+    summarySeed?: string;
+    summaryPersistAttempted?: boolean;
+    learningsFilePath?: string;
+    learningsSeed?: string;
+    learningsPersistAttempted?: boolean;
+    output?: string;
+    usageEntries: AgentUsage[];
+    model?: string | undefined;
+    todoTracker?: TodoTracker | undefined;
+    diffCoverage?: DiffCoverageState | undefined;
+}
+interface InitToolStateParams {
+    progressComment: {
+        id: string;
+        type: ProgressCommentType;
+    } | undefined;
+}
+export declare function initToolState(params: InitToolStateParams): ToolState;
+export {};

package/dist/utils/apiUrl.d.ts

@@ -7,3 +7,11 @@
  * enforces https:// for non-local URLs to prevent cleartext credential transmission.
  */
 export declare function getApiUrl(): string;
+/**
+ * true when the action is configured to talk to a localhost API server (i.e.
+ * `pnpm dev` running on the developer's box). signals we can use dev-only
+ * affordances like the `x-dev-repo` proxy-token bypass — the corresponding
+ * server-side dev gates (`NODE_ENV === "development"`) ensure these paths
+ * never activate against prod regardless of what the action does.
+ */
+export declare function isLocalApiUrl(): boolean;

package/dist/utils/browser.d.ts

@@ -1,4 +1,4 @@
-import type { ToolState } from "../mcp/server.ts";
+import type { ToolState } from "../toolState.ts";
 /**
  * ensure the agent-browser daemon is running by issuing a real command.
  *

package/dist/utils/errorReport.d.ts

@@ -1,4 +1,4 @@
-import type { ToolState } from "../mcp/server.ts";
+import type { ToolState } from "../toolState.ts";
 interface ReportErrorParams {
     toolState: ToolState;
     error: string;

package/dist/utils/instructions.d.ts

@@ -8,7 +8,10 @@ interface InstructionsContext {
     modes: Mode[];
     agentId: AgentId;
     outputSchema?: Record<string, unknown> | undefined;
-    learnings: string | null;
+    /** absolute path to the seeded learnings tmpfile, or null when the file
+     * couldn't be seeded for some reason. main.ts always seeds, so in
+     * practice this is always set; the null case keeps the type honest. */
+    learningsFilePath: string | null;
 }
 export interface ResolvedInstructions {
     full: string;

package/dist/utils/learnings.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Repo-level learnings — operational facts about a repo (setup steps, test
+ * commands, conventions, gotchas) that accumulate across agent runs and feed
+ * back into future runs as durable context. Modeled on the PR-summary tmpfile
+ * pattern (see action/utils/prSummary.ts):
+ *
+ *   1. server seeds `pullfrog-learnings.md` from `Repo.learnings` (or empty
+ *      when the repo has none yet)
+ *   2. the agent reads the file at startup as part of its context, and may
+ *      edit it in place at end-of-run when prompted by the reflection turn
+ *   3. main.ts reads the file back at end-of-run and PATCHes
+ *      `/api/repo/[owner]/[repo]/learnings` if it changed (byte-trim equality
+ *      against the seed determines change detection)
+ *
+ * Edit-in-place avoids stuffing the entire learnings list into both the
+ * prompt context and an `update_learnings` MCP tool call (which previously
+ * required passing the FULL merged list as a string parameter — an
+ * output-token tax that grew linearly with the learnings size).
+ */
+export declare const LEARNINGS_FILE_NAME = "pullfrog-learnings.md";
+export declare function learningsFilePath(tmpdir: string): string;
+/** seed the learnings file with the repo's current learnings, or an empty
+ * file when the repo has none yet. returns the absolute path. */
+export declare function seedLearningsFile(params: {
+    tmpdir: string;
+    current: string | null;
+}): Promise<string>;
+/** read the agent-edited learnings file. returns null when the file is
+ * missing or unreadable (treated as "no change"). caps content at the
+ * server's max length to avoid a 400 round-trip. */
+export declare function readLearningsFile(path: string): Promise<string | null>;

package/dist/utils/run.d.ts

@@ -1,6 +1,6 @@
 import type { AgentResult } from "../agents/shared.ts";
 import type { MainResult } from "../main.ts";
-import type { ToolState } from "../mcp/server.ts";
+import type { ToolState } from "../toolState.ts";
 export interface HandleAgentResultParams {
     result: AgentResult;
     toolState: ToolState;

package/dist/utils/setup.d.ts

@@ -1,5 +1,5 @@
 import type { ShellPermission } from "../external.ts";
-import type { ToolState } from "../mcp/server.ts";
+import type { ToolState } from "../toolState.ts";
 import type { OctokitWithPlugins } from "./github.ts";
 export interface SetupOptions {
     tempDir: string;

package/dist/utils/subprocess.d.ts

@@ -27,7 +27,6 @@ export interface SpawnOptions {
     onStdout?: (chunk: string) => void;
     onStderr?: (chunk: string) => void;
     killGroup?: boolean;
-    isPausedExternally?: () => boolean;
 }
 export interface SpawnResult {
     stdout: string;

package/package.json

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

package/dist/mcp/learnings.d.ts

@@ -1,6 +0,0 @@
-import type { ToolContext } from "./server.ts";
-export declare function UpdateLearningsTool(ctx: ToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
-    learnings: string;
-}, {
-    learnings: string;
-}>>;