@vimsucks/pi-goon 0.0.0-stage → 0.3.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Tom X Nguyen
+Copyright (c) 2026 vimsucks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,75 @@
-# Temporary Holding Version
+# @vimsucks/pi-goon
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Resume the current Pi session with `/goon` without sending a new continuation prompt to the model.
+
+## Installation
+
+Requires Pi 1.0.0 or later.
+
+Install from npm:
+
+```sh
+pi install npm:@vimsucks/pi-goon
+```
+
+Or install from GitHub:
+
+```sh
+pi install git:github.com/vimsucks/pi-goon
+```
+
+After installation, run `/reload` in the current session or restart Pi.
+
+## Usage
+
+- `/goon`: start an invisible continuation. If the agent is already running, Pi queues the continuation through its native follow-up queue.
+- `/goon status`: show whether the session is idle and the text of the last assistant message.
+- `/goon help`: show command help.
+
+After a network request fails or you cancel generation, run `/goon` to resume the task in the same session. If Pi has exited, reopen the original session before running `/goon`.
+
+## Keyboard shortcut
+
+The default shortcut is `Alt+G`. It performs the same action as `/goon` without submitting or clearing text in the editor. Run `/hotkeys` to inspect the active shortcuts.
+
+To change the shortcut, add a `goon` object to `~/.pi/agent/settings.json`. Keep the other settings in that file:
+
+```json
+{
+  "goon": {
+    "shortcut": "ctrl+alt+g"
+  }
+}
+```
+
+`goon.shortcut` accepts Pi key identifiers such as `alt+g`, `ctrl+alt+g`, or `f6`. Set it to `null` to disable the shortcut; `/goon` remains available. If the settings file or the `goon.shortcut` field is absent, the extension uses `alt+g`.
+
+The extension no longer reads `goon.json`. If you have that file, move its `shortcut` value to `goon.shortcut` in `settings.json`.
+
+If `PI_CODING_AGENT_DIR` is set, the extension reads `settings.json` from that directory. Only user-level settings apply; the extension does not read project settings.
+
+After changing the configuration, run `/reload`. If the configuration is invalid, Pi reports a loading error. Correct the configuration and run `/reload` again.
+
+Pi handles the shortcut through its native shortcut mechanism and applies its normal conflict rules. On macOS, configure the terminal to treat Option as Alt/Meta so it can send `Alt+G`. In Otty, open **Settings → Controls → Option as Alt** and select **Left** or **Both**. Otherwise, Option+G may insert `©` instead of triggering the shortcut.
+
+## How it works and limitations
+
+The extension uses `pi.sendMessage()` to add a hidden marker and start a native session turn. A `context` handler removes the marker before Pi sends a request to the model. The model receives no new `go on` prompt, and the marker is not displayed in the UI. The session journal still contains a hidden bookkeeping entry.
+
+When a marker is present, the handler also removes trailing failed or aborted assistant messages from the request. It retains messages with tool calls to preserve tool-call/result pairs. It does not rewrite session history.
+
+The extension does not resume automatically or guarantee continuation from the exact character where generation stopped. It preserves Pi's native queues, retries, and compaction behavior.
+
+## Development check
+
+Use Node.js 24 or later to run the offline check:
+
+```sh
+npm test
+```
+
+## Attribution and license
+
+This project is based on npm version `0.3.16` of [monotykamary/pi-invisible-continue](https://github.com/monotykamary/pi-invisible-continue), authored by Tom X Nguyen and declared under the MIT license. It retains the invisible continuation and message-filtering logic, renames the command to `/goon`, and uses its own `pi-goon:resume` marker.
+
+See [LICENSE](LICENSE).

package/goon.ts

@@ -0,0 +1,83 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  CONTINUE_COMMAND_DESCRIPTION,
+  INVISIBLE_CONTINUE_CUSTOM_TYPE,
+  getLastAssistantMessageText,
+  isInvisibleContinueMarker,
+  readShortcut,
+  stripTrailingIncompleteAssistants,
+} from "./src/index.ts";
+
+/**
+ * Resume through AgentSession instead of calling Agent.prompt([]) directly.
+ * The hidden custom message starts or queues a canonical session turn, while
+ * the context hook removes it before provider serialization.
+ */
+export default function invisibleContinueExtension(pi: ExtensionAPI) {
+  const shortcut = readShortcut();
+  if (shortcut !== null) {
+    pi.registerShortcut(shortcut, {
+      description: CONTINUE_COMMAND_DESCRIPTION,
+      handler: (ctx) => runContinueCommand(pi, ctx, ""),
+    });
+  }
+  pi.on("context", (event) => {
+    const hasMarker = event.messages.some((message) => isInvisibleContinueMarker(message));
+    const messages = event.messages.filter((message) => !isInvisibleContinueMarker(message));
+    const next = hasMarker ? stripTrailingIncompleteAssistants(messages) : messages;
+    if (next.length !== event.messages.length) return { messages: next };
+  });
+
+  pi.registerCommand("goon", {
+    description: CONTINUE_COMMAND_DESCRIPTION,
+    handler: async (args, ctx) => {
+      runContinueCommand(pi, ctx, args);
+    },
+  });
+}
+
+function runContinueCommand(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  args: string,
+): void {
+  const subcommand = args.trim().toLowerCase();
+
+  if (subcommand === "status") {
+    const last = getLastAssistantMessageText(ctx.sessionManager.getEntries());
+    ctx.ui.notify(
+      [
+        "pi-goon status:",
+        `  Agent idle: ${ctx.isIdle() ? "yes" : "no"}`,
+        `  Last assistant: ${last ?? "(none)"}`.slice(0, 120),
+      ].join("\n"),
+      "info",
+    );
+    return;
+  }
+
+  if (subcommand === "help") {
+    ctx.ui.notify(
+      [
+        "pi-goon  /goon     Resume loop invisibly",
+        "                        /goon status  Show diagnostics",
+        "                        /goon help    This message",
+      ].join("\n"),
+      "info",
+    );
+    return;
+  }
+
+  pi.sendMessage(
+    {
+      customType: INVISIBLE_CONTINUE_CUSTOM_TYPE,
+      content: [],
+      display: false,
+      details: undefined,
+    },
+    {
+      triggerTurn: true,
+      deliverAs: "followUp",
+    },
+  );
+}

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@vimsucks/pi-goon",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.3.1",
+  "description": "Resume a Pi session invisibly with /goon, without a new prompt for the model",
+  "type": "module",
+  "author": "vimsucks",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vimsucks/pi-goon.git"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "continue",
+    "resume"
+  ],
+  "files": [
+    "goon.ts",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=1.0.0"
+  },
+  "pi": {
+    "extensions": [
+      "./goon.ts"
+    ]
+  },
+  "scripts": {
+    "test": "node --test test.mjs"
+  }
 }

package/src/index.ts

@@ -0,0 +1,134 @@
+/** Shared constants and utilities for pi-goon. */
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export function readShortcut(): Parameters<ExtensionAPI["registerShortcut"]>[0] | null {
+  const agentDir = process.env.PI_CODING_AGENT_DIR?.replace(/^~(?=$|[\\/])/, homedir())
+    || join(homedir(), ".pi", "agent");
+  const path = join(agentDir, "settings.json");
+  let config: unknown;
+  try {
+    config = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return "alt+g";
+    throw new Error(`Cannot read ${path}`, { cause: error });
+  }
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error(`${path} must contain a JSON object`);
+  }
+  const goon = (config as { goon?: unknown }).goon;
+  if (goon === undefined) return "alt+g";
+  if (!goon || typeof goon !== "object" || Array.isArray(goon)) {
+    throw new Error(`${path}: goon must be a JSON object`);
+  }
+  const shortcut = (goon as { shortcut?: unknown }).shortcut;
+  if (shortcut === undefined) return "alt+g";
+  if (shortcut === null) return null;
+  if (typeof shortcut === "string") {
+    const match = /^((?:(?:ctrl|shift|alt|super)\+)*)(.+)$/.exec(shortcut);
+    if (match) {
+      const modifiers = match[1].split("+").filter(Boolean);
+      const key = match[2];
+      const validKey = /^[a-z0-9]$/.test(key)
+        || (key.length === 1 && "`-=[]\\;',./!@#$%^&*()_+|~{}:<>?".includes(key))
+        || /^(escape|esc|enter|return|tab|space|backspace|delete|insert|clear|home|end|pageUp|pageDown|up|down|left|right|f[1-9]|f1[0-2])$/.test(key);
+      if (validKey && new Set(modifiers).size === modifiers.length) {
+        return shortcut as Parameters<ExtensionAPI["registerShortcut"]>[0];
+      }
+    }
+  }
+  throw new Error(`${path}: goon.shortcut must be a Pi key identifier (e.g. alt+g) or null`);
+}
+
+export const CONTINUE_COMMAND_DESCRIPTION =
+  "Resume the agentic loop without sending a prompt the LLM can read";
+
+export const INVISIBLE_CONTINUE_CUSTOM_TYPE = "pi-goon:resume";
+
+export function isInvisibleContinueMarker(message: unknown): boolean {
+  if (!message || typeof message !== "object") return false;
+  const candidate = message as { role?: unknown; customType?: unknown };
+  return (
+    candidate.role === "custom" &&
+    candidate.customType === INVISIBLE_CONTINUE_CUSTOM_TYPE
+  );
+}
+
+const INCOMPLETE_ASSISTANT_STOP_REASONS = new Set(["error", "aborted"]);
+
+export function isIncompleteAssistantMessage(message: unknown): boolean {
+  if (!message || typeof message !== "object") return false;
+  const candidate = message as { role?: unknown; stopReason?: unknown };
+  return (
+    candidate.role === "assistant" &&
+    typeof candidate.stopReason === "string" &&
+    INCOMPLETE_ASSISTANT_STOP_REASONS.has(candidate.stopReason)
+  );
+}
+
+export function hasToolCallBlocks(message: unknown): boolean {
+  if (!message || typeof message !== "object") return false;
+  const content = (message as { content?: unknown }).content;
+  return (
+    Array.isArray(content) &&
+    content.some(
+      (block) =>
+        !!block &&
+        typeof block === "object" &&
+        (block as { type?: unknown }).type === "toolCall",
+    )
+  );
+}
+
+/**
+ * Pop trailing incomplete assistant attempts (retry-exhausted errors, aborts)
+ * so a continuation does not re-serve the failed run to the LLM.
+ *
+ * Guards: stops at the first message that is not an incomplete assistant,
+ * never pops an assistant carrying toolCall blocks (their tool results must
+ * stay paired), and never empties the context entirely.
+ */
+export function stripTrailingIncompleteAssistants<T>(
+  messages: ReadonlyArray<T>,
+): T[] {
+  const stripped = [...messages];
+  while (
+    stripped.length > 1 &&
+    isIncompleteAssistantMessage(stripped[stripped.length - 1]) &&
+    !hasToolCallBlocks(stripped[stripped.length - 1])
+  ) {
+    stripped.pop();
+  }
+  return stripped;
+}
+
+export function getLastAssistantMessageText(
+  entries: ReadonlyArray<{ type: string; message?: { role?: string; content?: unknown } }>,
+): string | undefined {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (
+      entry.type === "message" &&
+      entry.message?.role === "assistant" &&
+      entry.message.content
+    ) {
+      const content = entry.message.content;
+      if (typeof content === "string") return content;
+      if (Array.isArray(content)) {
+        const textBlocks = content.filter(
+          (block: unknown): block is { type: "text"; text: string } => {
+            if (!block || typeof block !== "object") return false;
+            const candidate = block as { type?: unknown; text?: unknown };
+            return candidate.type === "text" && typeof candidate.text === "string";
+          },
+        );
+        if (textBlocks.length === 0) return undefined;
+        return textBlocks.map((block) => block.text).join("\n");
+      }
+    }
+  }
+  return undefined;
+}