@likelz/pi-gpt 0.1.0 → 0.1.1

package/README.md

@@ -34,11 +34,22 @@ Edit `~/.pi/agent/extensions/pi-gpt.json` (under `PI_CODING_AGENT_DIR` when over
 ```json
 {
   "enabled": false,
-  "models": ["openai/gpt-6-astra"]
+  "models": ["/[/]gpt-6-astra$/"]
 }
 ```
 
-Use the exact `provider/model` identifiers shown by Pi, including any additional slashes in a model ID. The list starts empty; add models whose endpoint supports priority processing. Restart Pi or reload extensions after editing the file.
+Entries are either exact `provider/model` identifiers or JavaScript regular expressions wrapped in `/.../` (without flags). Regex rules run against the complete identifier, including additional slashes in the model ID. They use normal regex search semantics; add `^` and `$` where you need boundaries.
+
+| Rule                | Matches                                                                          |
+| ------------------- | -------------------------------------------------------------------------------- |
+| `/[/]gpt-6-astra$/` | `openai/gpt-6-astra`, `openai-codex/gpt-6-astra`, and `magpie/codex/gpt-6-astra` |
+| `/^openai[/]gpt-/`  | GPT model IDs under the `openai` provider                                        |
+| `openai/gpt-5.4`    | Only this exact identifier                                                       |
+| `/.*/`              | Every model                                                                      |
+
+`[/]` matches a literal slash, so the first rule requires the exact final model name and excludes `gpt-6-astra-pro`. Backslashes need JSON escaping: use `"/gpt-5\\.4$/"` to match a literal dot. Plain strings remain literal; `*` has regex meaning only inside `/.../` rules. Invalid regex configuration produces a warning and starts with fast mode disabled.
+
+The list starts empty; add rules for models whose endpoints support priority processing. Restart Pi or reload extensions after editing the file.
 
 - `/fast` toggles and persists `enabled`.
 - Unlisted models and disabled mode leave requests unchanged.
@@ -56,6 +67,24 @@ This extension requests **priority**, preserving the original behavior. OpenAI a
 
 Sources: [Ultrafast API](https://developers.openai.com/api/docs/guides/ultrafast-mode), [Fast API](https://developers.openai.com/api/docs/guides/fast-mode), [Codex speed and eligibility](https://learn.chatgpt.com/docs/agent-configuration/speed), [Codex pricing](https://learn.chatgpt.com/docs/pricing).
 
+## Publishing
+
+[Publish to npm](https://github.com/ekil1100/pi-gpt/actions/workflows/publish.yml) uses GitHub Actions OIDC. It needs no npm token secret. Node.js 24, npm 11.19.0, and Bun 1.4.2 are configured in the workflow. The `prepublishOnly` script runs checks, tests, and the build before publishing.
+
+Configure a GitHub Actions trusted publisher in the [npm package settings](https://www.npmjs.com/package/@likelz/pi-gpt/access):
+
+| Field                | Value                                      |
+| -------------------- | ------------------------------------------ |
+| Organization or user | `ekil1100`                                 |
+| Repository           | `pi-gpt`                                   |
+| Workflow filename    | `publish.yml`                              |
+| Environment name     | Leave empty                                |
+| Allowed actions      | Allow direct publishing with `npm publish` |
+
+Run the workflow manually to check installation, validation, and tarball contents without uploading. This dry run does not verify npm's OIDC trust configuration; that is exercised by an actual release.
+
+To release, update `package.json` to a new stable version, commit and push it, then push a matching tag such as `v0.1.1`. The workflow rejects tags that do not match the package version. Version `0.1.0` is already published and cannot be republished. OIDC publishing automatically includes provenance for this public repository and package.
+
 ## Development
 
 Use Bun 1.4.2 and Vite+ 1.0.0. Development was verified on Node.js 24.

package/dist/index.mjs

@@ -3,9 +3,20 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { Effect, Either, Schema } from "effect";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 //#region src/state.ts
+const isRegex = (rule) => rule.startsWith("/");
+const isValidRule = (rule) => {
+	if (!isRegex(rule)) return /^[^/\s]+\/[^\s]+$/.test(rule);
+	if (rule.length < 3 || !rule.endsWith("/")) return false;
+	try {
+		new RegExp(rule.slice(1, -1));
+		return true;
+	} catch {
+		return false;
+	}
+};
 const FastModeState = Schema.Struct({
 	enabled: Schema.Boolean,
-	models: Schema.Array(Schema.String.pipe(Schema.pattern(/^[^/\s]+\/[^\s]+$/)))
+	models: Schema.Array(Schema.String.pipe(Schema.filter(isValidRule, { message: () => "Expected a provider/model identifier or a valid /regex/ rule." })))
 });
 const emptyState = () => ({
 	enabled: false,
@@ -13,9 +24,10 @@ const emptyState = () => ({
 });
 const decodeState = Schema.decodeUnknownSync(Schema.parseJson(FastModeState));
 const modelKey = (model) => model ? `${model.provider}/${model.id}` : void 0;
+const matchesModel = (rule, key) => isRegex(rule) ? new RegExp(rule.slice(1, -1)).test(key) : rule === key;
 const isActive = (state, model) => {
 	const key = modelKey(model);
-	return state.enabled && key !== void 0 && state.models.includes(key);
+	return state.enabled && key !== void 0 && state.models.some((pattern) => matchesModel(pattern, key));
 };
 const transformRequest = (state, model, payload) => isActive(state, model) && typeof payload === "object" && payload !== null && !Array.isArray(payload) ? {
 	...payload,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likelz/pi-gpt",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "GPT fast mode for Pi with explicit model allowlists.",
   "keywords": [
     "gpt",

package/src/state.ts

@@ -1,8 +1,27 @@
 import { Schema } from "effect";
 
+const isRegex = (rule: string): boolean => rule.startsWith("/");
+
+const isValidRule = (rule: string): boolean => {
+  if (!isRegex(rule)) return /^[^/\s]+\/[^\s]+$/.test(rule);
+  if (rule.length < 3 || !rule.endsWith("/")) return false;
+  try {
+    new RegExp(rule.slice(1, -1));
+    return true;
+  } catch {
+    return false;
+  }
+};
+
 export const FastModeState = Schema.Struct({
   enabled: Schema.Boolean,
-  models: Schema.Array(Schema.String.pipe(Schema.pattern(/^[^/\s]+\/[^\s]+$/))),
+  models: Schema.Array(
+    Schema.String.pipe(
+      Schema.filter(isValidRule, {
+        message: () => "Expected a provider/model identifier or a valid /regex/ rule.",
+      }),
+    ),
+  ),
 });
 export type FastModeState = typeof FastModeState.Type;
 export const emptyState = (): FastModeState => ({ enabled: false, models: [] });
@@ -12,9 +31,14 @@ type Model = { readonly provider: string; readonly id: string } | undefined;
 export const modelKey = (model: Model): string | undefined =>
   model ? `${model.provider}/${model.id}` : undefined;
 
+const matchesModel = (rule: string, key: string): boolean =>
+  isRegex(rule) ? new RegExp(rule.slice(1, -1)).test(key) : rule === key;
+
 export const isActive = (state: FastModeState, model: Model): boolean => {
   const key = modelKey(model);
-  return state.enabled && key !== undefined && state.models.includes(key);
+  return (
+    state.enabled && key !== undefined && state.models.some((pattern) => matchesModel(pattern, key))
+  );
 };
 
 export const transformRequest = (