@diegopetrucci/pi-extensions 0.1.72 → 0.1.74

package/extensions/annotate-last-message/web/md-renderer.js

@@ -0,0 +1,458 @@
+/* global globalThis */
+
+/**
+ * TLH annotate-last-message: pure markdown line parser.
+ *
+ * Single source of truth for the parsing logic.  ui.ts reads this file and
+ * inlines it as a dedicated script before app.js, so globalThis.__tlhMdRenderer
+ * is available when the app script runs.  Tests load this file directly in a
+ * Node.js vm context (no DOM required).
+ */
+(function (global) {
+  "use strict";
+
+  // -------------------------------------------------------------------------
+  // Fence-state machine
+  //
+  // Applied over the full ordered line list before per-line rendering begins.
+  // Each line is tagged as: 'plain' | 'fence-open' | 'fence-body' | 'fence-close'
+  //
+  // Fence-delimiter lines (the ``` or ~~~ lines) are tagged 'fence-open' or
+  // 'fence-close'; they are rendered visible but styled as block-edge markers
+  // (--mdCodeBlockBorder colour) rather than suppressed. Fence-body lines skip
+  // inline markdown processing and receive code-block styling instead.
+  //
+  // A fenced block that reaches end-of-input without a closing delimiter is
+  // left open; all remaining lines are tagged 'fence-body'.
+  // -------------------------------------------------------------------------
+
+  function isFenceDelimiter(text) {
+    // CommonMark §4.5: opening/closing fences allow at most 3 spaces of
+    // indentation. A line with 4+ leading spaces is an indented code block
+    // and must not be treated as a fence delimiter.
+    const m = /^ {0,3}(```+|~~~+)/.exec(text);
+    return m ? { char: m[1][0], len: m[1].length } : null;
+  }
+
+  /**
+   * applyFenceState(lineTexts) → Array<{ text: string, lineType: string }>
+   *
+   * One output entry per input entry; the count is always preserved.
+   */
+  function applyFenceState(lineTexts) {
+    const result = [];
+    let inFence = false;
+    let fenceChar = "";
+    let fenceLen = 0;
+
+    for (const text of lineTexts) {
+      const fence = isFenceDelimiter(text);
+
+      if (!inFence) {
+        if (fence) {
+          inFence = true;
+          fenceChar = fence.char;
+          fenceLen = fence.len;
+          result.push({ text, lineType: "fence-open" });
+        } else {
+          result.push({ text, lineType: "plain" });
+        }
+      } else {
+        // Close if same delimiter character, at least as many chars, and
+        // nothing but optional whitespace after the delimiter (CommonMark
+        // §4.5: a closing fence must not have trailing non-whitespace).
+        const afterDelim = fence ? text.replace(/^ {0,3}(?:```+|~~~+)/, "") : "";
+        if (
+          fence &&
+          fence.char === fenceChar &&
+          fence.len >= fenceLen &&
+          /^\s*$/.test(afterDelim)
+        ) {
+          inFence = false;
+          fenceChar = "";
+          fenceLen = 0;
+          result.push({ text, lineType: "fence-close" });
+        } else {
+          result.push({ text, lineType: "fence-body" });
+        }
+      }
+    }
+
+    return result;
+  }
+
+  // -------------------------------------------------------------------------
+  // Line classifier (called only on 'plain'-typed lines)
+  // -------------------------------------------------------------------------
+
+  /**
+   * classifyLine(text) → LineInfo
+   *
+   * Returned shapes:
+   *   { type: 'blank' }
+   *   { type: 'heading', level: 1-6, text: string }
+   *   { type: 'hr' }
+   *   { type: 'blockquote', text: string }
+   *   { type: 'ul', indent: string, bullet: string, text: string }
+   *   { type: 'ol', indent: string, bullet: string, text: string }
+   *   { type: 'plain', text: string }
+   */
+  function classifyLine(text) {
+    if (text.trim().length === 0) {
+      return { type: "blank" };
+    }
+
+    const trimmed = text.trimStart();
+    const indentLen = text.length - trimmed.length;
+
+    // CommonMark block-indentation rule: constructs that HIDE or REPLACE
+    // source characters (headings hide '#', thematic breaks replace the
+    // whole line, blockquotes hide '>') must have at most 3 spaces of
+    // leading indentation. At 4+ spaces the line is indented code and
+    // must render literally. List markers are exempt: they preserve every
+    // source character and only restyle the bullet, so nested-list
+    // indentation stays lenient.
+    const blockSafe = indentLen <= 3;
+
+    // ATX heading: # … through ###### …
+    // The heading content may optionally end with a closing # sequence.
+    if (blockSafe) {
+      const headingMatch = /^(#{1,6})\s+(.+?)(?:\s+#+\s*)?$/.exec(trimmed);
+      if (headingMatch) {
+        return { type: "heading", level: headingMatch[1].length, text: headingMatch[2] };
+      }
+    }
+
+    // Thematic break: 3+ dashes, stars, or underscores with optional spaces.
+    if (blockSafe) {
+      if (/^(?:(?:-[ \t]*){3,}|(?:\*[ \t]*){3,}|(?:_[ \t]*){3,})$/.test(trimmed)) {
+        return { type: "hr" };
+      }
+    }
+
+    // Blockquote: > text
+    if (blockSafe) {
+      const bqMatch = /^>[ \t]?(.*)/.exec(trimmed);
+      if (bqMatch) {
+        return { type: "blockquote", text: bqMatch[1] };
+      }
+    }
+
+    // Unordered list item: optional indent + (- * +) + one or more spaces + text
+    const ulMatch = /^(\s*)([-*+])[ \t]+(.*)/.exec(text);
+    if (ulMatch) {
+      return { type: "ul", indent: ulMatch[1], bullet: ulMatch[2], text: ulMatch[3] };
+    }
+
+    // Ordered list item: optional indent + number. + one or more spaces + text
+    const olMatch = /^(\s*)(\d+\.)[ \t]+(.*)/.exec(text);
+    if (olMatch) {
+      return { type: "ol", indent: olMatch[1], bullet: olMatch[2], text: olMatch[3] };
+    }
+
+    return { type: "plain", text };
+  }
+
+  // -------------------------------------------------------------------------
+  // Inline tokenizer
+  // -------------------------------------------------------------------------
+
+  function isMarkdownSpecial(ch) {
+    return ch === "*" || ch === "_" || ch === "~" || ch === "`" || ch === "[" || ch === "\\";
+  }
+
+  /**
+   * Try to parse an inline code span starting at position i.
+   * Returns { codeText, end } on success, null on failure.
+   */
+  function tryParseCodeSpan(text, i) {
+    // Count opening backtick run.
+    let tickCount = 0;
+    while (i + tickCount < text.length && text[i + tickCount] === "`") tickCount++;
+    const contentStart = i + tickCount;
+
+    // Find a closing run of exactly the same length.
+    let j = contentStart;
+    while (j < text.length) {
+      if (text[j] !== "`") {
+        j++;
+        continue;
+      }
+      let runLen = 0;
+      while (j + runLen < text.length && text[j + runLen] === "`") runLen++;
+      if (runLen === tickCount) {
+        return { codeText: text.slice(contentStart, j), end: j + tickCount };
+      }
+      j += runLen;
+    }
+    return null;
+  }
+
+  /**
+   * Find the closing position of an emphasis/strikethrough marker.
+   * Skips over backslash escapes and inline code spans.
+   * For single-char markers (star or underscore) the closer must be an
+   * isolated run of exactly 1; for 2- or 3-char markers the run must be
+   * exactly that length. Returns -1 if not found.
+   *
+   * When checkIntraword is true (used for underscore-based delimiters),
+   * a candidate closing run that is flanked by alphanumerics on both sides
+   * is skipped — CommonMark's intraword-underscore rule.
+   */
+  function findEmphasisCloser(text, marker, from, checkIntraword = false) {
+    const mLen = marker.length;
+    const mChar = marker[0];
+    let j = from;
+
+    while (j < text.length) {
+      // Backslash escape: skip the next character.
+      if (text[j] === "\\" && j + 1 < text.length) {
+        j += 2;
+        continue;
+      }
+
+      // Inline code span: skip its entire content.
+      if (text[j] === "`") {
+        let tickCount = 0;
+        while (j + tickCount < text.length && text[j + tickCount] === "`") tickCount++;
+        const closeAt = text.indexOf("`".repeat(tickCount), j + tickCount);
+        j = closeAt === -1 ? text.length : closeAt + tickCount;
+        continue;
+      }
+
+      if (text[j] === mChar) {
+        // Measure the run length at this position.
+        let runLen = 0;
+        while (j + runLen < text.length && text[j + runLen] === mChar) runLen++;
+
+        if (runLen === mLen) {
+          if (checkIntraword) {
+            // Underscore-based closing delimiter flanked by alphanumerics
+            // on both sides is intraword and cannot close emphasis.
+            const charBefore = j > 0 ? text[j - 1] : "";
+            const charAfter = j + mLen < text.length ? text[j + mLen] : "";
+            if (/[a-zA-Z0-9]/.test(charBefore) && /[a-zA-Z0-9]/.test(charAfter)) {
+              j += runLen;
+              continue;
+            }
+          }
+          return j;
+        }
+        // Wrong run length — skip the whole run and keep scanning.
+        j += runLen;
+        continue;
+      }
+
+      j++;
+    }
+
+    return -1;
+  }
+
+  /**
+   * tokenizeLine(text) → Token[]
+   *
+   * Parses inline markdown and returns a token tree.  Falls back to a single
+   * plain-text token if an error is thrown.
+   *
+   * Token shapes:
+   *   { type: 'text', text: string }
+   *   { type: 'code', text: string }
+   *   { type: 'bold', children: Token[] }
+   *   { type: 'italic', children: Token[] }
+   *   { type: 'boldItalic', children: Token[] }
+   *   { type: 'strikethrough', children: Token[] }
+   *   { type: 'link', labelTokens: Token[], url: string }
+   */
+  function tokenizeLine(text) {
+    try {
+      return parseInlineSpans(text);
+    } catch {
+      return [{ type: "text", text }];
+    }
+  }
+
+  function parseInlineSpans(text) {
+    const tokens = [];
+    let i = 0;
+    let buf = "";
+    let bracketMatches = null;
+
+    // Match raw brackets once per parse call; suffix rescans make runs quadratic.
+    function getBracketMatches() {
+      if (bracketMatches !== null) return bracketMatches;
+
+      bracketMatches = new Map();
+      const stack = [];
+      for (let k = 0; k < text.length; k++) {
+        if (text[k] === "[") {
+          stack.push(k);
+        } else if (text[k] === "]" && stack.length > 0) {
+          bracketMatches.set(stack.pop(), k);
+        }
+      }
+      return bracketMatches;
+    }
+
+    function flush() {
+      if (buf.length > 0) {
+        tokens.push({ type: "text", text: buf });
+        buf = "";
+      }
+    }
+
+    while (i < text.length) {
+      const ch = text[i];
+
+      // Backslash escape: treat next markdown-special character as literal.
+      if (ch === "\\" && i + 1 < text.length && isMarkdownSpecial(text[i + 1])) {
+        buf += text[i + 1];
+        i += 2;
+        continue;
+      }
+
+      // Inline code span.
+      if (ch === "`") {
+        const result = tryParseCodeSpan(text, i);
+        if (result) {
+          flush();
+          tokens.push({ type: "code", text: result.codeText });
+          i = result.end;
+          continue;
+        }
+        buf += ch;
+        i++;
+        continue;
+      }
+
+      // Link: [label](url)
+      if (ch === "[") {
+        const closeLabel = getBracketMatches().get(i) ?? -1;
+        if (closeLabel !== -1 && text[closeLabel + 1] === "(") {
+          const urlStart = closeLabel + 2;
+          const closeUrl = text.indexOf(")", urlStart);
+          if (closeUrl !== -1) {
+            flush();
+            const labelText = text.slice(i + 1, closeLabel);
+            const url = text.slice(urlStart, closeUrl);
+            tokens.push({ type: "link", labelTokens: parseInlineSpans(labelText), url });
+            i = closeUrl + 1;
+            continue;
+          }
+        }
+        buf += ch;
+        i++;
+        continue;
+      }
+
+      // Bold+italic: ***text*** or ___text___
+      if (
+        (ch === "*" && text[i + 1] === "*" && text[i + 2] === "*") ||
+        (ch === "_" && text[i + 1] === "_" && text[i + 2] === "_")
+      ) {
+        // Underscore-based opening: skip if flanked by alphanumerics
+        // on both sides (CommonMark intraword-underscore rule).
+        if (ch === "_") {
+          const charBefore = i > 0 ? text[i - 1] : "";
+          const charAfter = i + 3 < text.length ? text[i + 3] : "";
+          if (/[a-zA-Z0-9]/.test(charBefore) && /[a-zA-Z0-9]/.test(charAfter)) {
+            buf += ch.repeat(3);
+            i += 3;
+            continue;
+          }
+        }
+        const marker = ch.repeat(3);
+        const closeIdx = findEmphasisCloser(text, marker, i + 3, ch === "_");
+        if (closeIdx !== -1) {
+          const inner = text.slice(i + 3, closeIdx);
+          if (inner.length > 0 && inner[0] !== " " && inner[inner.length - 1] !== " ") {
+            flush();
+            tokens.push({ type: "boldItalic", children: parseInlineSpans(inner) });
+            i = closeIdx + 3;
+            continue;
+          }
+        }
+      }
+
+      // Bold: **text** or __text__
+      if (
+        (ch === "*" && text[i + 1] === "*" && text[i + 2] !== "*") ||
+        (ch === "_" && text[i + 1] === "_" && text[i + 2] !== "_")
+      ) {
+        // Underscore-based opening: skip if flanked by alphanumerics
+        // on both sides (CommonMark intraword-underscore rule).
+        if (ch === "_") {
+          const charBefore = i > 0 ? text[i - 1] : "";
+          const charAfter = i + 2 < text.length ? text[i + 2] : "";
+          if (/[a-zA-Z0-9]/.test(charBefore) && /[a-zA-Z0-9]/.test(charAfter)) {
+            buf += ch.repeat(2);
+            i += 2;
+            continue;
+          }
+        }
+        const marker = ch.repeat(2);
+        const closeIdx = findEmphasisCloser(text, marker, i + 2, ch === "_");
+        if (closeIdx !== -1) {
+          const inner = text.slice(i + 2, closeIdx);
+          if (inner.length > 0 && inner[0] !== " " && inner[inner.length - 1] !== " ") {
+            flush();
+            tokens.push({ type: "bold", children: parseInlineSpans(inner) });
+            i = closeIdx + 2;
+            continue;
+          }
+        }
+      }
+
+      // Strikethrough: ~~text~~
+      if (ch === "~" && text[i + 1] === "~") {
+        const closeIdx = text.indexOf("~~", i + 2);
+        if (closeIdx !== -1) {
+          const inner = text.slice(i + 2, closeIdx);
+          if (inner.length > 0) {
+            flush();
+            tokens.push({ type: "strikethrough", children: parseInlineSpans(inner) });
+            i = closeIdx + 2;
+            continue;
+          }
+        }
+      }
+
+      // Italic: *text* or _text_  (single marker, not start of ** or ***)
+      if ((ch === "*" && text[i + 1] !== "*") || (ch === "_" && text[i + 1] !== "_")) {
+        // Underscore-based opening: skip if flanked by alphanumerics
+        // on both sides (CommonMark intraword-underscore rule).
+        if (ch === "_") {
+          const charBefore = i > 0 ? text[i - 1] : "";
+          const charAfter = i + 1 < text.length ? text[i + 1] : "";
+          if (/[a-zA-Z0-9]/.test(charBefore) && /[a-zA-Z0-9]/.test(charAfter)) {
+            buf += ch;
+            i += 1;
+            continue;
+          }
+        }
+        const closeIdx = findEmphasisCloser(text, ch, i + 1, ch === "_");
+        if (closeIdx !== -1) {
+          const inner = text.slice(i + 1, closeIdx);
+          if (inner.length > 0 && inner[0] !== " " && inner[inner.length - 1] !== " ") {
+            flush();
+            tokens.push({ type: "italic", children: parseInlineSpans(inner) });
+            i = closeIdx + 1;
+            continue;
+          }
+        }
+      }
+
+      buf += ch;
+      i++;
+    }
+
+    flush();
+    return tokens;
+  }
+
+  global.__tlhMdRenderer = {
+    applyFenceState,
+    classifyLine,
+    tokenizeLine,
+  };
+})(globalThis);

package/extensions/code-reviewer/index.ts

@@ -29,6 +29,11 @@ const CODE_REVIEWER_MODEL_PREFERENCES = [
 	"openai.gpt-6-astra ",
 	"gpt-6-astra ",
 	"gpt-6-astra",
+	"openai/gpt-6.1-sol ",
+	"global.openai.gpt-6.1-sol ",
+	"us.openai.gpt-6.1-sol ",
+	"openai.gpt-6.1-sol ",
+	"gpt-6.1-sol ",
 	"openai/gpt-6-sol ",
 	"gpt-6-sol ",
 	"gpt-6-sol",
@@ -100,6 +105,7 @@ const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 	"azure-openai-responses": [
 		"gpt-6-astra ",
 		"gpt-6-astra",
+		"gpt-6.1-sol ",
 		"gpt-6-sol ",
 		"gpt-6-sol",
 		"gpt-5.6-sol",
@@ -137,6 +143,7 @@ const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 	"github-copilot": [
 		"gpt-6-astra ",
 		"gpt-6-astra",
+		"gpt-6.1-sol ",
 		"gpt-6-sol ",
 		"gpt-6-sol",
 		"gpt-5.6-sol",
@@ -159,6 +166,7 @@ const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 	opencode: [
 		"gpt-6-astra ",
 		"gpt-6-astra",
+		"gpt-6.1-sol ",
 		"gpt-6-sol ",
 		"gpt-6-sol",
 		"gpt-5.6-sol",
@@ -183,6 +191,7 @@ const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 	openrouter: [
 		"openai/gpt-6-astra ",
 		"openai/gpt-6-astra",
+		"openai/gpt-6.1-sol ",
 		"openai/gpt-6-sol ",
 		"openai/gpt-6-sol",
 		"openai/gpt-5.6-sol-pro",
@@ -221,10 +230,11 @@ const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 		"gpt-5.3-codex",
 		"gpt-5.4-mini",
 	],
-	openai: ["gpt-6-astra ", "gpt-6-astra", "gpt-6-sol ", "gpt-6-sol", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-6-luna ", "gpt-6-luna", "gpt-5.6-luna", "gpt-5.5", "gpt-5", "gpt-4.1", "o3", "o4-mini"],
+	openai: ["gpt-6-astra ", "gpt-6-astra", "gpt-6.1-sol ", "gpt-6-sol ", "gpt-6-sol", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-6-luna ", "gpt-6-luna", "gpt-5.6-luna", "gpt-5.5", "gpt-5", "gpt-4.1", "o3", "o4-mini"],
 	"openai-codex": [
 		"gpt-6-astra ",
 		"gpt-6-astra",
+		"gpt-6.1-sol ",
 		"gpt-6-sol ",
 		"gpt-6-sol",
 		"gpt-5.6-sol",
@@ -247,6 +257,7 @@ const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 		"anthropic/claude-sonnet-5",
 		"openai/gpt-6-astra ",
 		"openai/gpt-6-astra",
+		"openai/gpt-6.1-sol ",
 		"openai/gpt-6-sol ",
 		"openai/gpt-6-sol",
 		"openai/gpt-5.6-sol",

package/extensions/code-reviewer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-code-reviewer",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "A standalone pi extension that adds a read-only code_reviewer subagent tool for isolated code reviews.",
   "keywords": [
     "pi-package",
@@ -29,6 +29,7 @@
     ]
   },
   "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "typebox": "*"
   },

package/extensions/context-cap/README.md

@@ -25,7 +25,7 @@ With pi's default `reserveTokens` of 16,384, models larger than 200k will proact
 /context-cap toggle
 ```
 
-The extension starts enabled by default. Disabling is temporary for the current extension runtime/session; after `/reload`, `/new`, `/resume`, or `/fork`, the extension starts enabled again.
+The extension starts enabled by default. `/context-cap off` releases this extension instance's hold; a shared model remains capped while another extension instance still holds it. After `/reload`, `/new`, `/resume`, or `/fork`, a new extension instance starts enabled again.
 
 ## Install
 
@@ -55,6 +55,35 @@ Then reload pi:
 
 ## Notes
 
-- This extension mutates pi's in-memory model metadata only. It does not edit `models.json`.
-- The cap affects pi logic that reads `model.contextWindow`, including auto-compaction thresholding and UI context-window display.
-- Because pi also uses `model.contextWindow` for some overflow detection, a request that succeeds above 200k tokens on a larger model may be treated as overflow and retried after compaction. Use `/context-cap off` if you need the full model window temporarily.
+- This extension mutates only the active model handle's in-memory metadata. It does not edit `models.json` and does not pre-cap every model in the registry.
+- The cap applies only when the active model is a physical model with a finite, positive `contextWindow`. Virtual selections and missing/incompatible limits are left unchanged because Pi 0.99 does not expose a routed physical model before compaction.
+
+### Process-wide scope
+
+- The cap is process-wide for physical model objects shared through Pi's `ModelRuntime`, not session-local. Sessions without this extension—including child sessions launched by `code-reviewer`, `agent-workflow-audit`, `librarian`, and `triage-comments` with `noExtensions`—can observe the cap. Concurrent-session isolation is not claimed; this is an accepted Pi 0.99 host/API limitation.
+- A process-wide `WeakMap` keeps the first holder's original window and reference-counts extension instances. Only the last holder restores it, and only when the current value is still the cap written by the extension. External writes are not overwritten during restore, duplicate release is safe, and restarting the process clears the in-memory coordination. Extension copies with incompatible older state cannot coordinate.
+
+### Settings guard and alternative
+
+- On Pi hosts exposing `getSettings()`, the extension resolves `reserveTokens` using Pi's precedence: `compaction.modelOverrides["provider/model-id"].reserveTokens`, then `compaction.reserveTokens`, then the default `16,384`. It skips the cap when the resolved value is at least `200,000` (which would make the threshold zero or negative), or when any explicit entry exists for that model. Hosts without `getSettings()` use the older cap behavior without this guard.
+- Pi's provider request path also derives an output-token budget from the effective window (`contextWindow - contextTokens - 4096`, with any provider-specific clamp applied afterward). The cap can therefore reduce response or thinking-token budgets near the limit, in addition to causing earlier compaction; Pi's overflow handling may also treat a request above 200k as overflow and retry after compaction. Use `/context-cap off` when you need the full model window temporarily.
+- As a session-scoped alternative, configure Pi's own `compaction.modelOverrides` instead of this extension. The exact key is `provider/model-id`; to match this extension's default 200k threshold for a model with original window `W`, let `R` be the configured `reserveTokens` value (default `16,384`) and use:
+
+  ```text
+  reserveTokens = W - 200000 + R
+  ```
+
+  For example, with the default `R`, a 1,000,000-token model uses `816384`, yielding the same `183616` threshold as `200000 - 16384`:
+
+  ```json
+  {
+    "compaction": {
+      "modelOverrides": {
+        "provider/model-id": { "reserveTokens": 816384 }
+      }
+    }
+  }
+  ```
+
+  Choose this alternative or the extension; do not combine them. The extension deliberately skips a model with an explicit `modelOverrides` entry, and older extension copies may not detect it.
+- `/context-cap status` reports the process-wide original/effective window and how many other extension holders still hold the cap. No settings or session files are written by this extension.