@luxass/pi-personal 0.0.0 → 0.1.1

package/src/crow/retry.ts

@@ -0,0 +1,38 @@
+import { type AssistantMessage, isRetryableAssistantError } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const TRANSIENT_STREAM_ERROR_PATTERN =
+  /\bclosed network connection\b|\bstream disconnected before completion: stream closed before response\.completed\b|\binvalid SSE data JSON\b/i;
+const NETWORK_ERROR_PREFIX = "network error:";
+
+export function normalizeTransientNetworkError(message: AssistantMessage): AssistantMessage {
+  if (message.stopReason !== "error" || !message.errorMessage) {
+    return message;
+  }
+  if (
+    isRetryableAssistantError(message) ||
+    !TRANSIENT_STREAM_ERROR_PATTERN.test(message.errorMessage)
+  ) {
+    return message;
+  }
+
+  return {
+    ...message,
+    errorMessage: `${NETWORK_ERROR_PREFIX} ${message.errorMessage}`,
+  };
+}
+
+export function registerTransientNetworkErrorRetry(pi: ExtensionAPI, providerId: string): void {
+  pi.on("message_end", (event) => {
+    const message = event.message;
+    if (message.role !== "assistant" || message.provider !== providerId) {
+      return undefined;
+    }
+
+    const normalized = normalizeTransientNetworkError(message);
+    if (normalized === message) {
+      return undefined;
+    }
+    return { message: normalized };
+  });
+}

package/src/custom-header.ts

@@ -0,0 +1,292 @@
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { keyText, VERSION } from "@earendil-works/pi-coding-agent";
+import {
+  Key,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+
+const HEADER_MAX_WIDTH = 88;
+const LOGO_MIN_WIDTH = 64;
+const PI_MASCOT = [
+  "      o    ",
+  "      |    ",
+  "  .---+---.",
+  "  | o   o |",
+  "  |  \\_/  |",
+  "  '-------'",
+  "    /   \\  ",
+];
+
+type ResourceSnapshot = {
+  context: string[];
+  skills: string[];
+  extensions: string[];
+};
+
+function fit(text: string, width: number): string {
+  const clipped = truncateToWidth(text, width, "…");
+  return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+
+function resourceName(path: string): string {
+  const parts = path.replaceAll("\\", "/").split("/");
+  const file = parts.at(-1) ?? path;
+  if (file === "index.ts" || file === "index.js") return parts.at(-2) ?? file;
+  return file.replace(/\.[cm]?[jt]sx?$/i, "");
+}
+
+async function collectResources(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+): Promise<ResourceSnapshot> {
+  const extensionPaths = new Set<string>();
+  try {
+    const extensionDir = dirname(fileURLToPath(import.meta.url));
+    for (const entry of await readdir(extensionDir, { withFileTypes: true })) {
+      if (entry.isFile() && /\.[cm]?[jt]sx?$/i.test(entry.name)) {
+        extensionPaths.add(join(extensionDir, entry.name));
+      }
+    }
+  } catch {
+    // The extension directory may not be readable.
+  }
+
+  for (const command of pi.getCommands()) {
+    if (command.source === "extension") extensionPaths.add(command.sourceInfo.path);
+  }
+  for (const tool of pi.getAllTools()) {
+    if (tool.sourceInfo.source !== "builtin" && tool.sourceInfo.source !== "sdk") {
+      extensionPaths.add(tool.sourceInfo.path);
+    }
+  }
+
+  const context: string[] = [];
+  let directory = resolve(ctx.cwd);
+  while (true) {
+    for (const filename of ["AGENTS.md", "CLAUDE.md"]) {
+      const path = join(directory, filename);
+      if (existsSync(path)) context.push(relative(ctx.cwd, path) || filename);
+    }
+    const parent = dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+
+  return {
+    context: context.toSorted(),
+    skills: pi
+      .getCommands()
+      .filter((command) => command.source === "skill")
+      .map((command) => command.name.replace(/^skill:/, ""))
+      .toSorted(),
+    extensions: [...extensionPaths].map(resourceName).filter(Boolean).toSorted(),
+  };
+}
+
+interface HeaderOptions {
+  theme: Theme;
+  width: number;
+  project: string;
+  model: Pick<NonNullable<ExtensionContext["model"]>, "provider" | "id" | "reasoning"> | undefined;
+  thinking: ReturnType<ExtensionAPI["getThinkingLevel"]>;
+  thinkingKey: string;
+}
+
+export function renderHeader({
+  theme,
+  width,
+  project,
+  model,
+  thinking,
+  thinkingKey,
+}: HeaderOptions): string[] {
+  if (width < 1) return [""];
+
+  const accent = (text: string) => theme.fg("accent", text);
+  const muted = (text: string) => theme.fg("muted", text);
+  const dim = (text: string) => theme.fg("dim", text);
+  const expanded = width >= LOGO_MIN_WIDTH;
+  const border = (text: string) => theme.fg(expanded ? "borderMuted" : "borderAccent", text);
+  const version = dim(`v${VERSION}`);
+  const title = `${accent("π")} ${theme.bold("Pi")} ${version}`;
+  const indent = width >= 44 ? "  " : "";
+  const panelWidth = Math.min(expanded ? HEADER_MAX_WIDTH : 72, width - indent.length);
+  const boxed = width >= 24;
+  const contentWidth = boxed ? panelWidth - 4 : width;
+  const separator = dim(" · ");
+  const workspace = theme.bold(theme.fg("text", project));
+  const modelLabel = model
+    ? `${width >= 44 ? dim(`${model.provider}/`) : ""}${theme.fg("text", model.id)}`
+    : muted("model pending");
+  const thinkingLabel = model?.reasoning ? `${muted("thinking ")}${accent(thinking)}` : "";
+  const metadata = [modelLabel, thinkingLabel].filter(Boolean).join(separator);
+  const line = (text = "") => `${indent}${border("│")} ${fit(text, contentWidth)} ${border("│")}`;
+
+  const hints = [
+    `${accent("/")} ${muted("commands")}`,
+    `${accent("!")} ${muted("shell")}`,
+    ...(model?.reasoning && thinkingKey
+      ? [`${accent(thinkingKey === "shift+tab" ? "⇧Tab" : thinkingKey)} ${muted("thinking")}`]
+      : []),
+    accent("/resources"),
+  ];
+  // Drop complete hints, not half a shortcut. Keep /resources available longest.
+  const hintWidth = expanded ? contentWidth - 4 : contentWidth;
+  while (hints.length > 1 && visibleWidth(hints.join("   ")) > hintWidth) {
+    hints.splice(hints.length - 2, 1);
+  }
+
+  if (expanded) {
+    const logoWidth = Math.max(...PI_MASCOT.map(visibleWidth));
+    const detailsWidth = contentWidth - logoWidth - 5;
+    const name = theme.bold(theme.fg("text", "Pi"));
+    const details = [
+      `${name}${" ".repeat(Math.max(1, detailsWidth - visibleWidth(name) - visibleWidth(version)))}${version}`,
+      "",
+      workspace,
+      modelLabel,
+      thinkingLabel,
+      "",
+    ];
+
+    return [
+      "",
+      `${indent}${border(`╭${"─".repeat(panelWidth - 2)}╮`)}`,
+      line(),
+      ...PI_MASCOT.map((logo, index) =>
+        line(
+          `  ${fit(theme.bold(accent(logo)), logoWidth)}   ${fit(details[index] ?? "", detailsWidth)}`,
+        ),
+      ),
+      line(),
+      line(`  ${hints.join("   ")}`),
+      line(),
+      `${indent}${border(`╰${"─".repeat(panelWidth - 2)}╯`)}`,
+      "",
+    ];
+  }
+
+  const session = `${workspace}${separator}${metadata}`;
+  const lines: string[] = [];
+  if (visibleWidth(session) <= contentWidth) {
+    lines.push(session);
+  } else {
+    lines.push(workspace);
+    if (visibleWidth(metadata) <= contentWidth) lines.push(metadata);
+    else lines.push(modelLabel, ...(thinkingLabel ? [thinkingLabel] : []));
+  }
+  if (contentWidth >= visibleWidth("/resources")) {
+    if (boxed) lines.push("");
+    lines.push(hints.join("   "));
+  }
+
+  if (!boxed) return ["", ...[title, ...lines].map((line) => fit(line, width)), ""];
+
+  const label = truncateToWidth(title, panelWidth - 5, "…");
+  return [
+    "",
+    `${indent}${border("╭─ ")}${label}${border(` ${"─".repeat(panelWidth - 5 - visibleWidth(label))}╮`)}`,
+    ...lines.map(line),
+    `${indent}${border(`╰${"─".repeat(panelWidth - 2)}╯`)}`,
+    "",
+  ];
+}
+
+function renderResources(snapshot: ResourceSnapshot, theme: Theme, width: number): string[] {
+  if (width < 6) return [fit("Resources", width)];
+
+  const panelWidth = Math.min(86, width);
+  const contentWidth = panelWidth - 2;
+  const border = (text: string) => theme.fg("borderAccent", text);
+  const heading = (text: string) => theme.fg("mdHeading", theme.bold(text));
+  const muted = (text: string) => theme.fg("muted", text);
+  const dim = (text: string) => theme.fg("dim", text);
+  const accent = (text: string) => theme.fg("accent", text);
+  const line = (text = "") => `${border("│")}${fit(text, contentWidth)}${border("│")}`;
+  const lines = [
+    border(`╭${"─".repeat(panelWidth - 2)}╮`),
+    line(`${accent("π")} ${heading("Resources")}`),
+    line(dim("Detected context, skill commands, and extensions")),
+    line(),
+  ];
+
+  const sections: Array<[string, string[], string]> = [
+    ["Context", snapshot.context, "✓"],
+    ["Skills", snapshot.skills, "•"],
+    ["Extensions", snapshot.extensions, "•"],
+  ];
+  for (const [label, items, marker] of sections) {
+    lines.push(line(heading(`${label} · ${items.length}`)));
+    const entries = wrapTextWithAnsi(
+      items.length > 0 ? items.join(", ") : "none detected",
+      Math.max(1, contentWidth - 4),
+    );
+    for (const [index, entry] of entries.entries()) {
+      const prefix = index === 0 ? `  ${marker} ` : "    ";
+      lines.push(line(`${index === 0 ? accent(prefix) : dim(prefix)}${muted(entry)}`));
+    }
+    lines.push(line());
+  }
+
+  lines.push(line(dim("Press Esc, Enter, or q to close")));
+  lines.push(border(`╰${"─".repeat(panelWidth - 2)}╯`));
+  return lines;
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", (_event, ctx) => {
+    if (ctx.mode !== "tui") return;
+
+    ctx.ui.setHeader((_tui, theme) => ({
+      render: (width: number) =>
+        renderHeader({
+          theme,
+          width,
+          project: basename(ctx.cwd) || "workspace",
+          model: ctx.model,
+          thinking: pi.getThinkingLevel(),
+          thinkingKey: keyText("app.thinking.cycle"),
+        }),
+      invalidate() {},
+    }));
+  });
+
+  pi.registerCommand("resources", {
+    description: "Show detected context, skill commands, and extensions",
+    handler: async (_args, ctx) => {
+      if (ctx.mode !== "tui") return;
+      const resources = await collectResources(pi, ctx);
+
+      await ctx.ui.custom<void>(
+        (tui, theme, _keybindings, done) => ({
+          render: (width: number) => renderResources(resources, theme, width),
+          handleInput: (data: string) => {
+            if (matchesKey(data, Key.escape) || matchesKey(data, Key.enter) || data === "q") {
+              done();
+            }
+            tui.requestRender();
+          },
+          invalidate() {},
+        }),
+        {
+          overlay: true,
+          overlayOptions: {
+            anchor: "center",
+            width: "70%",
+            minWidth: 46,
+            maxHeight: "80%",
+            margin: 2,
+          },
+        },
+      );
+    },
+  });
+}

package/src/git-interceptor.ts

@@ -0,0 +1,39 @@
+/**
+ * Git Interceptor
+ *
+ * Two guards for agent-driven git commands:
+ *
+ * 1. Editor hang prevention — Sets GIT_EDITOR, GIT_SEQUENCE_EDITOR to `true`
+ *    (no-op) and GIT_MERGE_AUTOEDIT to `no` so git never spawns an interactive
+ *    editor (nvim, vim, etc.) that would hang the bash process.
+ *
+ * 2. Hook bypass prevention — Blocks any command containing `--no-verify` so
+ *    the agent cannot circumvent git hooks (pre-commit, commit-msg, etc.).
+ *    The agent should fix hook failures or ask the human for help instead.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isToolCallEventType } from "@earendil-works/pi-coding-agent";
+
+const GIT_ENV_PREFIX = "export GIT_EDITOR=true GIT_SEQUENCE_EDITOR=true GIT_MERGE_AUTOEDIT=no\n";
+
+const NO_VERIFY_RE = /--no-verify\b/;
+
+const BLOCK_REASON =
+  "BLOCKED: --no-verify is not allowed. Git hooks exist for a reason. " +
+  "Do not attempt to bypass them. Instead: fix the underlying issue that " +
+  "is causing the hook to fail, or ask the user for help.";
+
+export default function (pi: ExtensionAPI) {
+  pi.on("tool_call", (event) => {
+    if (!isToolCallEventType("bash", event)) return undefined;
+    if (!event.input.command.includes("git")) return undefined;
+
+    if (NO_VERIFY_RE.test(event.input.command)) {
+      return { block: true, reason: BLOCK_REASON };
+    }
+
+    event.input.command = GIT_ENV_PREFIX + event.input.command;
+    return undefined;
+  });
+}

package/src/package-manager-interceptor.ts

@@ -0,0 +1,24 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isToolCallEventType } from "@earendil-works/pi-coding-agent";
+
+// Catch common dependency-install commands, including those after `cd ... &&`.
+// Keep the command intact: rewriting shell pipelines can change their meaning.
+const INSTALL =
+  /\b(?:pnpm\s+(?:install|add|i|dlx)|npm\s+(?:install|i|ci|exec)|bun\s+(?:install|add|i|x)|yarn\s+(?:install|add|dlx)|npx\b)(?=\s|$)/g;
+
+export default function (pi: ExtensionAPI) {
+  pi.on("tool_call", (event) => {
+    if (!isToolCallEventType("bash", event)) return undefined;
+
+    const command = event.input.command;
+    for (const match of command.matchAll(INSTALL)) {
+      if (/\bsfw\s+$/.test(command.slice(0, match.index))) continue;
+      return {
+        block: true,
+        reason:
+          "Package installs must run through Socket Firewall. Retry with sfw before the package manager (for example, sfw pnpm install).",
+      };
+    }
+    return undefined;
+  });
+}

package/src/worker-configuration-guard.ts

@@ -0,0 +1,191 @@
+/**
+ * Worker Configuration Guard
+ *
+ * Blocks high-confidence attempts to manually create or modify
+ * worker-configuration.d.ts. That file is generated by Cloudflare Wrangler and
+ * should be regenerated with `wrangler types` instead of hand-edited.
+ *
+ * Bash detection intentionally favors avoiding false positives over recognizing
+ * arbitrary mutations hidden inside scripts or shell evaluation.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isToolCallEventType } from "@earendil-works/pi-coding-agent";
+
+const PROTECTED_FILE = "worker-configuration.d.ts";
+
+const BLOCK_REASON =
+  `BLOCKED: ${PROTECTED_FILE} is generated and must not be manually ` +
+  "created, edited, deleted, or overwritten by an agent. Use the `read` tool " +
+  "to inspect it, or run `wrangler types` from the worker project to " +
+  "regenerate it instead.";
+
+const SHELL_COMMAND_SEPARATOR_RE = /(?:&&|\|\||[;|\n])/;
+const SHELL_OUTPUT_REDIRECTION_RE = /^\d*>>?$/;
+const SHELL_DIRECT_MUTATION_COMMANDS = new Set(["rm", "tee", "touch", "truncate"]);
+const SHELL_COPY_COMMANDS = new Set(["cp", "install", "mv", "rsync"]);
+
+/** Definite shell mutation categories recognized by the worker configuration guard. */
+export type WorkerConfigurationMutation =
+  | "copy-destination"
+  | "direct-file-command"
+  | "in-place-edit"
+  | "output-redirection";
+
+function normalizeToolPath(path: string): string {
+  return path.replace(/^@/, "").replaceAll("\\", "/");
+}
+
+function isProtectedPath(path: unknown): boolean {
+  if (typeof path !== "string") return false;
+  const normalized = normalizeToolPath(path);
+  return normalized.split("/").at(-1) === PROTECTED_FILE;
+}
+
+function tokenizeShellCommand(command: string): string[] {
+  const tokens: string[] = [];
+  let token = "";
+  let quote: "'" | '"' | undefined;
+
+  const pushToken = () => {
+    if (token.length === 0) return;
+    tokens.push(token);
+    token = "";
+  };
+
+  for (let index = 0; index < command.length; index += 1) {
+    const character = command[index];
+    if (character === undefined) continue;
+
+    if (quote !== undefined) {
+      if (character === quote) quote = undefined;
+      else token += character;
+      continue;
+    }
+
+    if (character === "'" || character === '"') {
+      quote = character;
+      continue;
+    }
+
+    if (character === "\\" && command[index + 1] !== undefined) {
+      token += command[index + 1];
+      index += 1;
+      continue;
+    }
+
+    if (/\s/.test(character)) {
+      pushToken();
+      if (character === "\n") tokens.push(character);
+      continue;
+    }
+
+    if (/[;&|<>]/.test(character)) {
+      pushToken();
+      const pair = character + (command[index + 1] ?? "");
+      if (["&&", "||", ">>", "<<"].includes(pair)) {
+        tokens.push(pair);
+        index += 1;
+      } else {
+        tokens.push(character);
+      }
+      continue;
+    }
+
+    token += character;
+  }
+
+  pushToken();
+  return tokens;
+}
+
+function splitShellCommandSegments(tokens: readonly string[]): string[][] {
+  const segments: string[][] = [[]];
+  for (const token of tokens) {
+    if (SHELL_COMMAND_SEPARATOR_RE.test(token)) segments.push([]);
+    else segments.at(-1)?.push(token);
+  }
+  return segments;
+}
+
+function shellCommandName(segment: readonly string[]): string | undefined {
+  return segment.find((token) => !token.includes("=") && !token.startsWith("-"));
+}
+
+/** Finds a definite shell mutation targeting Wrangler's generated worker configuration file. */
+export function findWorkerConfigurationMutation(
+  command: string,
+): WorkerConfigurationMutation | undefined {
+  const segments = splitShellCommandSegments(tokenizeShellCommand(command));
+
+  for (const segment of segments) {
+    for (let index = 0; index < segment.length - 1; index += 1) {
+      if (
+        SHELL_OUTPUT_REDIRECTION_RE.test(segment[index] ?? "") &&
+        isProtectedPath(segment[index + 1])
+      ) {
+        return "output-redirection";
+      }
+    }
+
+    const commandName = shellCommandName(segment);
+    if (commandName === undefined) continue;
+    const operands = segment.slice(segment.indexOf(commandName) + 1);
+
+    if (SHELL_DIRECT_MUTATION_COMMANDS.has(commandName) && operands.some(isProtectedPath)) {
+      return "direct-file-command";
+    }
+
+    if (
+      (commandName === "sed" || commandName === "perl") &&
+      operands.some(
+        (operand) =>
+          operand === "-i" || operand.startsWith("-i") || operand.startsWith("--in-place"),
+      ) &&
+      operands.some(isProtectedPath)
+    ) {
+      return "in-place-edit";
+    }
+
+    if (SHELL_COPY_COMMANDS.has(commandName)) {
+      const paths = operands.filter((operand) => !operand.startsWith("-"));
+      if (isProtectedPath(paths.at(-1))) return "copy-destination";
+    }
+
+    if (
+      commandName === "dd" &&
+      operands.some((operand) => operand.startsWith("of=") && isProtectedPath(operand.slice(3)))
+    ) {
+      return "direct-file-command";
+    }
+  }
+
+  return undefined;
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("tool_call", (event, ctx) => {
+    if (isToolCallEventType("write", event) || isToolCallEventType("edit", event)) {
+      if (isProtectedPath(event.input.path)) {
+        if (ctx.hasUI) {
+          ctx.ui.notify(
+            `Blocked manual change to ${PROTECTED_FILE}; run wrangler types.`,
+            "warning",
+          );
+        }
+        return { block: true, reason: BLOCK_REASON };
+      }
+
+      return undefined;
+    }
+
+    if (!isToolCallEventType("bash", event)) return undefined;
+    if (findWorkerConfigurationMutation(event.input.command) === undefined) return undefined;
+
+    if (ctx.hasUI) {
+      ctx.ui.notify(`Blocked manual change to ${PROTECTED_FILE}; run wrangler types.`, "warning");
+    }
+
+    return { block: true, reason: BLOCK_REASON };
+  });
+}

package/src/index.ts

@@ -1,7 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-export default function personal(pi: ExtensionAPI) {
-  pi.on("session_start", (_, ctx) => {
-    ctx.ui.notify("Personal extension activated.");
-  });
-}