@likelz/pi-gpt 0.1.1 → 0.1.2

package/README.md

@@ -34,14 +34,19 @@ Edit `~/.pi/agent/extensions/pi-gpt.json` (under `PI_CODING_AGENT_DIR` when over
 ```json
 {
   "enabled": false,
-  "models": ["/[/]gpt-6-astra$/"]
+  "models": ["gpt-6-astra"]
 }
 ```
 
-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.
+Entries support three forms, which can be mixed in the same list. Any matching rule enables fast mode when `enabled` is true:
+
+- **Model name** without `/`: case-sensitive, exact match against the final segment of the model identifier. `gpt-6-astra` matches across providers, including `magpie/codex/gpt-6-astra`, and excludes `gpt-6-astra-pro`.
+- **Full identifier** containing `/`: exact match against `provider/model`, including any additional model path segments.
+- **Regex** wrapped in `/.../` (without flags): JavaScript regular expression against the complete identifier. Existing regex rules keep their behavior. They use normal regex search semantics; add `^` and `$` where you need boundaries.
 
 | Rule                | Matches                                                                          |
 | ------------------- | -------------------------------------------------------------------------------- |
+| `gpt-6-astra`       | The exact final model name under any provider or path prefix                     |
 | `/[/]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                                                       |

package/dist/index.mjs

@@ -5,7 +5,7 @@ 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 (!isRegex(rule)) return /^[^/\s]+(?:\/[^\s]+)?$/.test(rule);
 	if (rule.length < 3 || !rule.endsWith("/")) return false;
 	try {
 		new RegExp(rule.slice(1, -1));
@@ -16,7 +16,7 @@ const isValidRule = (rule) => {
 };
 const FastModeState = Schema.Struct({
 	enabled: Schema.Boolean,
-	models: Schema.Array(Schema.String.pipe(Schema.filter(isValidRule, { message: () => "Expected a provider/model identifier or a valid /regex/ rule." })))
+	models: Schema.Array(Schema.String.pipe(Schema.filter(isValidRule, { message: () => "Expected a model name, provider/model identifier, or valid /regex/ rule." })))
 });
 const emptyState = () => ({
 	enabled: false,
@@ -24,7 +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 matchesModel = (rule, key) => {
+	if (isRegex(rule)) return new RegExp(rule.slice(1, -1)).test(key);
+	return rule === (rule.includes("/") ? key : key.slice(key.lastIndexOf("/") + 1));
+};
 const isActive = (state, model) => {
 	const key = modelKey(model);
 	return state.enabled && key !== void 0 && state.models.some((pattern) => matchesModel(pattern, key));

package/package.json

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

package/src/state.ts

@@ -3,7 +3,7 @@ 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 (!isRegex(rule)) return /^[^/\s]+(?:\/[^\s]+)?$/.test(rule);
   if (rule.length < 3 || !rule.endsWith("/")) return false;
   try {
     new RegExp(rule.slice(1, -1));
@@ -18,7 +18,7 @@ export const FastModeState = Schema.Struct({
   models: Schema.Array(
     Schema.String.pipe(
       Schema.filter(isValidRule, {
-        message: () => "Expected a provider/model identifier or a valid /regex/ rule.",
+        message: () => "Expected a model name, provider/model identifier, or valid /regex/ rule.",
       }),
     ),
   ),
@@ -31,8 +31,10 @@ 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;
+const matchesModel = (rule: string, key: string): boolean => {
+  if (isRegex(rule)) return new RegExp(rule.slice(1, -1)).test(key);
+  return rule === (rule.includes("/") ? key : key.slice(key.lastIndexOf("/") + 1));
+};
 
 export const isActive = (state: FastModeState, model: Model): boolean => {
   const key = modelKey(model);