@davisliu2006/pi-permission-system 0.1.0 → 0.3.0

package/README.md

@@ -29,7 +29,7 @@ Reject
 
 ## Configuration
 
-The supported top-level keys are: `default`, `tools`, `bash`, and `external_directory`.
+The supported top-level keys are: `default`, `tools`, `bash`, `external_directory`, and `settings`.
 
 `bash` body matching supports wildcard:
 - `*` matches any sequence and `?` matches one character
@@ -39,6 +39,8 @@ The supported top-level keys are: `default`, `tools`, `bash`, and `external_dire
 
 The builtin path tools in pi are: `read`, `write`, `edit`, `find`, `grep`, `ls`. `external_directory` overrides the settings for these path tools. The primary use is to override `write` and `edit` to a stronger policy for external directories.
 
+`settings` holds optional non-permission settings.
+
 ### Rule Precedence
 
 More specific rules override less specific rules:
@@ -49,7 +51,7 @@ More specific rules override less specific rules:
 
 ### Global Configuration
 
-Located in `.pi/agent/pi-permissions.jsonc`.
+Located in `~/.pi/agent/pi-permissions.jsonc`.
 
 Example:
 
@@ -90,19 +92,30 @@ Example:
         "rg*": "allow"
     },
     "external_directory": {
-        "write": "ask"
+        "write": "ask",
+        "edit": "ask"
     }
 }
 ```
 
 ### Local Configuration
 
-Located in a file in the local project directory root:
+Located in the local Pi config folder:
 
-`pi-permissions.jsonc`
+`<project-root>/.pi/pi-permissions.jsonc`
 
 Local configuration overrides global configuration, including `deny` rules.
 
+### Optional Settings
+
+```jsonc
+{
+    "settings": {
+        "ai-model": "provider/model-id"
+    }
+}
+```
+
 ## "Allow Always" Matching
 
 Matching is done as `(tool, body)`.
@@ -120,8 +133,10 @@ Body matching rules:
 
 ## Bash Matching Safeguards
 
-Bash matching safeguards against chaining.
+Bash matching safeguards against unsafe shell syntax.
+
+Sequences separated by `;`, `&&`, `||`, or newlines are split and each segment is matched against `bash` rules. The strictest result wins (`deny` > `ask` > `allow`).
 
-If a bash command contains shell chaining or control syntax (`;`, `&&`, `||`, `|`, `&`, newlines, command substitution, or process substitution), `bash` pattern rules are skipped and the `tools.bash` policy is used instead, falling back to `default`.
+If a command contains other chaining (`|`, `&`, command/process substitution, or parentheses), `bash` pattern rules (except for `deny`) are skipped and the `tools.bash` policy is used instead, falling back to `default`.
 
-"Allow always" for a chained command saves the exact command, not a wildcard.
+"Allow always" for complex sequences saves the exact command, not a wildcard.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davisliu2006/pi-permission-system",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Permission enforcement extension for the Pi coding agent.",
   "type": "module",
   "main": "./index.ts",
@@ -10,7 +10,8 @@
   "files": [
     "index.ts",
     "src",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
     "typecheck": "tsc -p tsconfig.json --noEmit",
@@ -21,7 +22,8 @@
     "pi-package",
     "pi",
     "pi-extension",
-    "permissions"
+    "permissions",
+    "pi-permissions"
   ],
   "author": "davisliu2006",
   "license": "MIT",
@@ -39,11 +41,13 @@
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": ">=0.78.0",
-    "@earendil-works/pi-coding-agent": ">=0.78.0"
+    "@earendil-works/pi-coding-agent": ">=0.78.0",
+    "@earendil-works/pi-tui": ">=0.78.0"
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.78.1",
     "@earendil-works/pi-coding-agent": "^0.78.1",
+    "@earendil-works/pi-tui": "^0.78.1",
     "@types/node": "^22.10.0",
     "typescript": "^5.7.3"
   }

package/src/ai-gen.ts

@@ -1,5 +1,6 @@
-import { complete, type Message } from "@earendil-works/pi-ai";
+import { complete, type Api, type Message, type Model } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { parseAiModelRef } from "./types.ts";
 
 export interface CompleteTextOptions {
   systemPrompt: string;
@@ -8,6 +9,8 @@ export interface CompleteTextOptions {
   timeoutMs: number;
   /** How to join multiple text blocks. Defaults to a single space. */
   joinWith?: string;
+  /** Optional `provider/model-id` override. Falls back to the session model. */
+  aiModel?: string;
 }
 
 /**
@@ -23,17 +26,37 @@ function timeoutSignal(signal: AbortSignal | undefined, timeoutMs: number): Abor
 }
 
 /**
- * Runs a single-turn text completion against the extension model.
+ * Resolves the model for helper completions.
+ */
+export function resolveCompletionModel(
+  ctx: ExtensionContext,
+  aiModel?: string
+): Model<Api> | undefined {
+  if (aiModel) {
+    const parsed = parseAiModelRef(aiModel);
+    if (parsed) {
+      const configured = ctx.modelRegistry.find(parsed.provider, parsed.modelId);
+      if (configured && ctx.modelRegistry.hasConfiguredAuth(configured)) {
+        return configured;
+      }
+    }
+  }
+  return ctx.model;
+}
+
+/**
+ * Runs a single-turn text completion against the extension helper model.
  * Returns undefined when the model/auth is unavailable, the call aborts, or no text is returned.
  */
 export async function completeText(
   ctx: ExtensionContext,
   options: CompleteTextOptions
 ): Promise<string | undefined> {
-  if (!ctx.model) {return undefined;}
+  const model = resolveCompletionModel(ctx, options.aiModel);
+  if (!model) {return undefined;}
 
   try {
-    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
     if (!auth.ok || !auth.apiKey) {return undefined;}
 
     // prompt
@@ -50,7 +73,7 @@ export async function completeText(
 
     // call model
     const response = await complete(
-      ctx.model,
+      model,
       {
         systemPrompt: options.systemPrompt,
         messages: [message],

package/src/ai-purpose.ts

@@ -41,7 +41,8 @@ function sanitizePurpose(value: string): string | undefined {
 export async function generateRequestPurpose(
   ctx: ExtensionContext,
   request: PermissionRequest,
-  context: string
+  context: string,
+  aiModel?: string
 ): Promise<string | undefined> {
   const key = cacheKey(request);
   const cached = purposeCache.get(key);
@@ -52,6 +53,7 @@ export async function generateRequestPurpose(
     userText: buildPurposeInstructions(context),
     maxTokens: MAX_PURPOSE_TOKENS,
     timeoutMs: PURPOSE_TIMEOUT_MS,
+    aiModel,
   });
   if (!text) {return undefined;}
 

package/src/ai-wildcard.ts

@@ -1,10 +1,19 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { completeText } from "./ai-gen.ts";
-import { buildWildcardInstructions, WILDCARD_SYSTEM_PROMPT } from "./prompts.ts";
-import { validateWildcardSuggestion } from "./wildcard-validation.ts";
+import {
+  buildWildcardInstructions,
+  buildWildcardListInstructions,
+  WILDCARD_LIST_SYSTEM_PROMPT,
+  WILDCARD_SYSTEM_PROMPT,
+} from "./prompts.ts";
+import {
+  validateWildcardSuggestion,
+  validateWildcardSuggestionList,
+} from "./wildcard-validation.ts";
 
 const WILDCARD_TIMEOUT_MS = 8000;
 const MAX_WILDCARD_TOKENS = 120;
+const MAX_WILDCARD_LIST_TOKENS = 240;
 
 /**
  * Sanitizes against:
@@ -26,11 +35,12 @@ function sanitizeWildcard(value: string): string | undefined {
 }
 
 /**
- * Generates the bash wildcard recommendation.
+ * Generates one bash wildcard recommendation.
  */
 export async function generateBashWildcard(
   ctx: ExtensionContext,
-  command: string
+  command: string,
+  aiModel?: string
 ): Promise<string | undefined> {
   const text = await completeText(ctx, {
     systemPrompt: WILDCARD_SYSTEM_PROMPT,
@@ -38,6 +48,7 @@ export async function generateBashWildcard(
     maxTokens: MAX_WILDCARD_TOKENS,
     timeoutMs: WILDCARD_TIMEOUT_MS,
     joinWith: "\n",
+    aiModel,
   });
   if (!text) {return undefined;}
 
@@ -49,3 +60,33 @@ export async function generateBashWildcard(
 
   return pattern;
 }
+
+/**
+ * Generates a list of bash wildcards.
+ * Expects semicolon-separated patterns back.
+ */
+export async function generateBashWildcards(
+  ctx: ExtensionContext,
+  commands: readonly string[],
+  aiModel?: string
+): Promise<string[] | undefined> {
+  if (commands.length === 0) {return undefined;}
+
+  const text = await completeText(ctx, {
+    systemPrompt: WILDCARD_LIST_SYSTEM_PROMPT,
+    userText: buildWildcardListInstructions(commands),
+    maxTokens: MAX_WILDCARD_LIST_TOKENS,
+    timeoutMs: WILDCARD_TIMEOUT_MS,
+    joinWith: "\n",
+    aiModel,
+  });
+  if (!text) {return undefined;}
+
+  const sanitized = sanitizeWildcard(text);
+  if (!sanitized) {return undefined;}
+
+  const validation = validateWildcardSuggestionList(sanitized, commands);
+  if (!validation.valid) {return undefined;}
+
+  return validation.patterns;
+}

package/src/config.ts

@@ -1,16 +1,27 @@
 import { readFile } from "node:fs/promises";
-import { ASK, PERMISSION_STATES_DESCRIPTION } from "./constants.ts";
+import { ASK } from "./constants.ts";
 import { parseJsonc } from "./jsonc.ts";
 import {
-  DEFAULT_PERMISSION_CONFIG,
   createDefaultPermissionConfig,
+  parseAiModelRef,
   toPermissionState,
   toRecord,
   type ConfigWarning,
   type PermissionConfig,
   type PermissionSection,
+  type PermissionSettings,
   type PermissionState,
 } from "./types.ts";
+import {
+  CONFIG_MUST_BE_OBJECT,
+  formatConfigParseFailure,
+  formatConfigReadFailure,
+  formatIgnoredSectionEntryWarning,
+  formatIgnoredSectionWarning,
+  IGNORED_AI_MODEL_WARNING,
+  IGNORED_DEFAULT_WARNING,
+  IGNORED_SETTINGS_WARNING,
+} from "./warning-strings.ts";
 
 const UNSAFE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 
@@ -29,7 +40,7 @@ function normalizeSection(
   if (!record) {
     warnings.push({
       path: configPath,
-      message: `Ignoring "${sectionName}": expected an object mapping names to ${PERMISSION_STATES_DESCRIPTION}.`,
+      message: formatIgnoredSectionWarning(sectionName),
     });
     return {};
   }
@@ -43,18 +54,51 @@ function normalizeSection(
     } else {
       warnings.push({
         path: configPath,
-        message: `Ignoring "${sectionName}.${key}": expected ${PERMISSION_STATES_DESCRIPTION}.`,
+        message: formatIgnoredSectionEntryWarning(sectionName, key),
       });
     }
   }
   return result;
 }
 
+/**
+ * Helper used by normalizeConfig.
+ * Ensures settings is a valid PermissionSettings object.
+ */
+function normalizeSettings(
+  raw: unknown,
+  configPath: string | undefined,
+  warnings: ConfigWarning[]
+): PermissionSettings {
+  if (raw === undefined) {return {};}
+  const record = toRecord(raw);
+  if (!record) {
+    warnings.push({
+      path: configPath,
+      message: IGNORED_SETTINGS_WARNING,
+    });
+    return {};
+  }
+
+  const settings: PermissionSettings = {};
+  if (record.ai_model !== undefined) {
+    if (typeof record.ai_model === "string" && parseAiModelRef(record.ai_model)) {
+      settings.ai_model = record.ai_model.trim();
+    } else {
+      warnings.push({
+        path: configPath,
+        message: IGNORED_AI_MODEL_WARNING,
+      });
+    }
+  }
+  return settings;
+}
+
 /**
  * Convert the raw config to a PermissionConfig.
  * Ensures the config is valid.
  */
-function normalizeConfig(
+export function normalizeConfig(
   rawConfig: unknown,
   configPath: string | undefined,
   warnings: ConfigWarning[]
@@ -63,7 +107,7 @@ function normalizeConfig(
   if (!config) {
     warnings.push({
       path: configPath,
-      message: "Permission config must be a JSON object; using defaults.",
+      message: CONFIG_MUST_BE_OBJECT,
     });
     return createDefaultPermissionConfig();
   }
@@ -72,7 +116,7 @@ function normalizeConfig(
   if (config.default !== undefined && parsedDefault === undefined) {
     warnings.push({
       path: configPath,
-      message: `Ignoring "default": expected ${PERMISSION_STATES_DESCRIPTION}.`,
+      message: IGNORED_DEFAULT_WARNING,
     });
   }
   const defaultState = parsedDefault ?? ASK;
@@ -87,6 +131,7 @@ function normalizeConfig(
       configPath,
       warnings
     ),
+    settings: normalizeSettings(config.settings, configPath, warnings),
   };
 }
 
@@ -105,7 +150,7 @@ async function loadConfigFile(
     if (code === "ENOENT") {return undefined;} // file does not exist
     warnings.push({
       path,
-      message: `Failed to read permission config: ${error instanceof Error ? error.message : String(error)}`,
+      message: formatConfigReadFailure(error),
     });
     return undefined;
   }
@@ -115,7 +160,7 @@ async function loadConfigFile(
   } catch (error) {
     warnings.push({
       path,
-      message: `Failed to parse permission config: ${error instanceof Error ? error.message : String(error)}`,
+      message: formatConfigParseFailure(error),
     });
     return undefined;
   }
@@ -150,7 +195,7 @@ export function mergeConfigs(
     return createDefaultPermissionConfig();
   }
 
-  globalConfig = globalConfig ?? DEFAULT_PERMISSION_CONFIG;
+  globalConfig = globalConfig ?? createDefaultPermissionConfig();
 
   return {
     default: localConfig?.default ?? globalConfig.default,
@@ -160,6 +205,10 @@ export function mergeConfigs(
       ...globalConfig.external_directory,
       ...(localConfig?.external_directory ?? {}),
     },
+    settings: {
+      ...globalConfig.settings,
+      ...(localConfig?.settings ?? {}),
+    },
   };
 }
 

package/src/constants.ts

@@ -1,9 +1,10 @@
 export const EXTENSION_NAME = "pi-permission-system";
 export const STATUS_KEY = EXTENSION_NAME;
-export const CONFIG_WARNING_PREFIX = `${EXTENSION_NAME}: `;
 export const MAX_CONFIG_WARNINGS = 5;
 
 export const CONFIG_FILENAME = "pi-permissions.jsonc";
+/** Local config directory under the cwd. */
+export const LOCAL_CONFIG_DIR_SEGMENTS = [".pi"] as const;
 
 export const ALLOW = "allow";
 export const ASK = "ask";

package/src/extension.ts

@@ -2,19 +2,18 @@ import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil
 import { join } from "node:path";
 
 import { clearPurposeCache, generateRequestPurpose } from "./ai-purpose.ts";
-import { generateBashWildcard } from "./ai-wildcard.ts";
 import { clearWildcardCache } from "./matcher.ts";
 import {
   ALLOW,
   CONFIG_FILENAME,
-  CONFIG_WARNING_PREFIX,
   DENY,
+  LOCAL_CONFIG_DIR_SEGMENTS,
   MAX_CONFIG_WARNINGS,
   STATUS_KEY,
 } from "./constants.ts";
 import { loadMergedConfig } from "./config.ts";
 import { promptForPermission } from "./permission-dialog.ts";
-import { findSessionApproval, resolvePolicy, willGenerateBashWildcard } from "./policy.ts";
+import { findSessionApproval, resolvePolicy } from "./policy.ts";
 import {
   buildPurposePromptContext,
   formatDenyReason,
@@ -23,22 +22,13 @@ import {
 } from "./prompts.ts";
 import { buildRequest } from "./request-builder.ts";
 import { SessionApprovalStore } from "./session-approvals.ts";
+import { STATUS_SUMMARIZING_REQUEST } from "./ui-strings.ts";
 import {
-  BROAD_WILDCARD_TITLE,
-  buildSelectorSummary,
-  formatBroadWildcardConfirm,
-  INVALID_WILDCARD_PREFIX,
-  STATUS_GENERATING_WILDCARD,
-  STATUS_SUMMARIZING_REQUEST,
-  WILDCARD_EDITOR_TITLE,
-} from "./ui-strings.ts";
-import { validateWildcardSuggestion } from "./wildcard-validation.ts";
-import {
-  type PermissionConfig,
-  type PermissionRequest,
-  type PolicyResolution,
-  type AllowAlwaysRule,
-} from "./types.ts";
+  CONFIG_WARNING_PREFIX,
+  formatSuppressedConfigWarnings,
+} from "./warning-strings.ts";
+import { chooseAlwaysRules } from "./wildcard-editor.ts";
+import type { PermissionConfig } from "./types.ts";
 
 interface ExtensionState {
   config?: PermissionConfig;
@@ -60,7 +50,7 @@ function createNewState(): ExtensionState {
 async function loadConfig(ctx: ExtensionContext): Promise<PermissionConfig> {
   const { config, warnings } = await loadMergedConfig(
     join(getAgentDir(), CONFIG_FILENAME),
-    join(ctx.cwd, CONFIG_FILENAME)
+    join(ctx.cwd, ...LOCAL_CONFIG_DIR_SEGMENTS, CONFIG_FILENAME)
   );
 
   if (ctx.hasUI) {
@@ -70,7 +60,7 @@ async function loadConfig(ctx: ExtensionContext): Promise<PermissionConfig> {
     if (warnings.length > MAX_CONFIG_WARNINGS) {
       const suppressed = warnings.length - MAX_CONFIG_WARNINGS;
       ctx.ui.notify(
-        `${CONFIG_WARNING_PREFIX}${suppressed} additional config warning(s) suppressed.`,
+        `${CONFIG_WARNING_PREFIX}${formatSuppressedConfigWarnings(suppressed)}`,
         "warning"
       );
     }
@@ -79,71 +69,6 @@ async function loadConfig(ctx: ExtensionContext): Promise<PermissionConfig> {
   return config;
 }
 
-/**
- * Selects the "allow always" matching rule for the request.
- */
-async function chooseAlwaysRule(
-  ctx: ExtensionContext,
-  request: PermissionRequest,
-  policy: PolicyResolution
-): Promise<AllowAlwaysRule | undefined> {
-  if (request.isExternalDirectory && policy.source === "external") {
-    return {
-      scope: "external_directory",
-      tool: request.toolName,
-      kind: "exact",
-      body: request.body,
-    };
-  }
-
-  // no wildcard
-  if (!willGenerateBashWildcard(request, policy)) {
-    return { scope: "tool", tool: request.toolName, kind: "exact", body: request.body };
-  }
-
-  // generate wildcard
-  ctx.ui.setStatus(STATUS_KEY, STATUS_GENERATING_WILDCARD);
-  let suggestion: string | undefined;
-  try {
-    suggestion = await generateBashWildcard(ctx, request.body);
-  } finally {
-    ctx.ui.setStatus(STATUS_KEY, undefined);
-  }
-
-  // show wildcard editor
-  let initial = suggestion ?? request.body;
-  while (true) {
-    const edited = await ctx.ui.editor(WILDCARD_EDITOR_TITLE, initial);
-    if (edited === undefined) {return undefined;}
-
-    const pattern = edited.trim();
-    const validation = validateWildcardSuggestion(pattern, request.body);
-    if (!validation.valid) {
-      ctx.ui.notify(`${INVALID_WILDCARD_PREFIX}${validation.reason}`, "warning");
-      initial = pattern || request.body;
-      continue;
-    }
-
-    if (validation.broad) {
-      const confirmed = await ctx.ui.confirm(
-        BROAD_WILDCARD_TITLE,
-        formatBroadWildcardConfirm(pattern)
-      );
-      if (!confirmed) {
-        initial = pattern;
-        continue;
-      }
-    }
-
-    return {
-      scope: "tool",
-      tool: "bash",
-      kind: "wildcard",
-      body: pattern,
-    };
-  }
-}
-
 /**
  * Registers the extension.
  */
@@ -195,32 +120,24 @@ export function registerPermissionSystem(pi: ExtensionAPI): void {
     }
 
     // check session approval
-    const sessionRequest =
-      policy.source === "external"
-        ? request
-        : { ...request, isExternalDirectory: false };
-    const approval = findSessionApproval(
-      state.approvals.getRules(),
-      sessionRequest,
-      policy.isChainedBash
-    );
+    const approval = findSessionApproval(state.approvals.getRules(), request);
     if (approval) {return undefined;} // approved, proceed
 
-    const summary = buildSelectorSummary(request);
     ctx.ui.setStatus(STATUS_KEY, STATUS_SUMMARIZING_REQUEST);
     let purpose: string | undefined;
     try {
       purpose = await generateRequestPurpose(
         ctx,
         request,
-        buildPurposePromptContext(request, policy)
+        buildPurposePromptContext(request),
+        config.settings.ai_model
       );
     } finally {
       ctx.ui.setStatus(STATUS_KEY, undefined);
     }
 
     while (true) {
-      const choice = await promptForPermission(ctx, request, policy, summary, purpose);
+      const choice = await promptForPermission(ctx, request, policy, purpose);
       if (choice.kind === "once") { // approved, proceed
         return;
       }
@@ -229,12 +146,19 @@ export function registerPermissionSystem(pi: ExtensionAPI): void {
       }
 
       // "allow always"
-      const rule = await chooseAlwaysRule(ctx, request, policy);
-      if (!rule) {
+      const rules = await chooseAlwaysRules(
+        ctx,
+        request,
+        policy,
+        config.settings.ai_model
+      );
+      if (!rules) {
         // the user cancelled the wildcard editor, return to the permission dialog
         continue;
       }
-      state.approvals.add(rule);
+      for (const rule of rules) {
+        state.approvals.add(rule);
+      }
       return undefined;
     }
   });