@aliou/pi-guardrails 0.8.0 → 0.9.1

package/README.md

@@ -93,7 +93,7 @@ All fields optional. Missing fields use defaults.
 Each rule has:
 
 - `id`: stable identifier used for overrides across scopes.
-- `patterns`: files to match (glob by default, regex if `regex: true`).
+- `patterns`: files to match (glob by default, regex if `regex: true`). Glob semantics: patterns containing `/` match the full relative path; patterns without `/` match basename only.
 - `allowedPatterns`: exceptions.
 - `protection`:
   - `noAccess`: block `read`, `write`, `edit`, `bash`, `grep`, `find`, `ls`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-guardrails",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -29,7 +29,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@aliou/pi-utils-settings": "^0.7.0",
+    "@aliou/pi-utils-settings": "^0.8.0",
     "@aliou/sh": "^0.1.0"
   },
   "peerDependencies": {

package/src/commands/settings-command.ts

@@ -1,16 +1,20 @@
 import {
+  FuzzySelector,
   getNestedValue,
   registerSettingsCommand,
   SettingsDetailEditor,
   type SettingsDetailField,
   type SettingsSection,
+  type SettingsTheme,
   setNestedValue,
+  Wizard,
 } from "@aliou/pi-utils-settings";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { getSettingsListTheme } from "@mariozechner/pi-coding-agent";
 import {
   type Component,
   Input,
+  Key,
+  matchesKey,
   type SettingItem,
   type SettingsListTheme,
 } from "@mariozechner/pi-tui";
@@ -38,6 +42,57 @@ const FEATURE_UI: Record<FeatureKey, { label: string; description: string }> = {
   },
 };
 
+const POLICY_EXAMPLES: Array<{
+  label: string;
+  description: string;
+  rule: PolicyRule;
+}> = [
+  {
+    label: "Secrets (.env)",
+    description: "Block dotenv-like files (glob)",
+    rule: {
+      id: "example-secret-env-files",
+      name: "Secret env files",
+      description: "Block .env files and variants",
+      patterns: [{ pattern: ".env" }, { pattern: ".env.*" }],
+      allowedPatterns: [
+        { pattern: ".env.example" },
+        { pattern: "*.sample.env" },
+      ],
+      protection: "noAccess",
+      onlyIfExists: true,
+      enabled: true,
+    },
+  },
+  {
+    label: "Logs (*.log)",
+    description: "Mark log files read-only (glob)",
+    rule: {
+      id: "example-log-files",
+      name: "Log files",
+      description: "Treat log files as read-only",
+      patterns: [{ pattern: "*.log" }, { pattern: "*.out" }],
+      protection: "readOnly",
+      onlyIfExists: true,
+      enabled: true,
+    },
+  },
+  {
+    label: "Regex env",
+    description: "Regex match for .env and .env.*",
+    rule: {
+      id: "example-regex-env",
+      name: "Regex env files",
+      description: "Regex example for env files",
+      patterns: [{ pattern: "^\\.env(\\..+)?$", regex: true }],
+      allowedPatterns: [{ pattern: "^\\.env\\.example$", regex: true }],
+      protection: "noAccess",
+      onlyIfExists: true,
+      enabled: true,
+    },
+  },
+];
+
 function toKebabCase(input: string): string {
   return input
     .trim()
@@ -46,67 +101,353 @@ function toKebabCase(input: string): string {
     .replace(/^-+|-+$/g, "");
 }
 
+function appendPolicyRule(
+  config: GuardrailsConfig | null,
+  example: PolicyRule,
+): GuardrailsConfig {
+  const next = structuredClone(config ?? {}) as GuardrailsConfig;
+  const currentRules = next.policies?.rules ?? [];
+
+  const existingIds = new Set(currentRules.map((rule) => rule.id));
+  const baseId =
+    toKebabCase(example.id || example.name || "example") || "example";
+  let id = baseId;
+  let i = 2;
+  while (existingIds.has(id)) {
+    id = `${baseId}-${i}`;
+    i++;
+  }
+
+  const rule = structuredClone(example);
+  rule.id = id;
+
+  next.policies = {
+    ...(next.policies ?? {}),
+    rules: [...currentRules, rule],
+  };
+
+  return next;
+}
+
+interface NewPolicyDraft {
+  name: string;
+  id: string;
+  protection: PolicyRule["protection"];
+  patterns: PatternConfig[];
+}
+
+class PolicyNameStep implements Component {
+  private readonly input = new Input();
+
+  constructor(
+    private readonly theme: SettingsListTheme,
+    private readonly state: NewPolicyDraft,
+    private readonly onComplete: () => void,
+  ) {
+    this.input.setValue(state.name);
+    this.input.onSubmit = () => {
+      const name = this.input.getValue().trim();
+      if (!name) return;
+      this.state.name = name;
+      if (!this.state.id) {
+        this.state.id = toKebabCase(name) || "policy";
+      }
+      this.onComplete();
+    };
+  }
+
+  invalidate() {}
+
+  render(width: number): string[] {
+    return [
+      this.theme.hint("  Step 1: Policy name"),
+      "",
+      ...this.input.render(Math.max(1, width - 2)).map((line) => ` ${line}`),
+      "",
+      this.theme.hint("  Example: Secret files"),
+      this.theme.hint("  Enter to continue"),
+    ];
+  }
+
+  handleInput(data: string): void {
+    this.input.handleInput(data);
+  }
+}
+
+class PolicyProtectionStep implements Component {
+  private readonly selector: FuzzySelector;
+
+  constructor(
+    theme: SettingsListTheme,
+    state: NewPolicyDraft,
+    onComplete: () => void,
+  ) {
+    this.selector = new FuzzySelector({
+      label: "Protection",
+      items: ["noAccess", "readOnly", "none"],
+      currentValue: state.protection,
+      theme,
+      onSelect: (value) => {
+        if (value === "noAccess" || value === "readOnly" || value === "none") {
+          state.protection = value;
+          onComplete();
+        }
+      },
+      onDone: () => {
+        // Esc is handled by Wizard.
+      },
+    });
+  }
+
+  invalidate(): void {
+    this.selector.invalidate?.();
+  }
+
+  render(width: number): string[] {
+    return this.selector.render(width);
+  }
+
+  handleInput(data: string): void {
+    this.selector.handleInput(data);
+  }
+}
+
+class PolicyPatternsStep implements Component {
+  private readonly editor: PatternEditor;
+
+  constructor(
+    theme: SettingsListTheme,
+    state: NewPolicyDraft,
+    onComplete: () => void,
+  ) {
+    this.editor = new PatternEditor({
+      label: "Policy patterns",
+      context: "file",
+      theme,
+      items: state.patterns.map((p) => ({
+        pattern: p.pattern,
+        description: p.pattern,
+        regex: p.regex,
+      })),
+      onSave: (items) => {
+        state.patterns = items
+          .map((item) => {
+            const pattern = item.pattern.trim();
+            if (!pattern) return null;
+            return {
+              pattern,
+              ...(item.regex ? { regex: true } : {}),
+            };
+          })
+          .filter((item): item is PatternConfig => item !== null);
+      },
+      onDone: () => {
+        if (state.patterns.length > 0) {
+          onComplete();
+        }
+      },
+    });
+  }
+
+  invalidate(): void {
+    this.editor.invalidate?.();
+  }
+
+  render(width: number): string[] {
+    return this.editor.render(width);
+  }
+
+  handleInput(data: string): void {
+    this.editor.handleInput(data);
+  }
+}
+
+class PolicyReviewStep implements Component {
+  constructor(
+    private readonly theme: SettingsListTheme,
+    private readonly state: NewPolicyDraft,
+  ) {}
+
+  invalidate() {}
+
+  render(_width: number): string[] {
+    const patternPreview =
+      this.state.patterns.length > 0
+        ? this.state.patterns
+            .slice(0, 3)
+            .map((p) => `${p.pattern}${p.regex ? " [regex]" : ""}`)
+            .join(", ")
+        : "(none)";
+
+    return [
+      this.theme.hint("  Review"),
+      "",
+      this.theme.hint(`  Name: ${this.state.name || "(empty)"}`),
+      this.theme.hint(`  ID: ${this.state.id || "(auto)"}`),
+      this.theme.hint(`  Protection: ${this.state.protection}`),
+      this.theme.hint(`  Patterns: ${this.state.patterns.length}`),
+      this.theme.hint(`  ${patternPreview}`),
+      "",
+      this.theme.hint("  Ctrl+S: create + open editor · Esc: cancel"),
+    ];
+  }
+
+  handleInput(_data: string): void {}
+}
+
 class AddRuleSubmenu implements Component {
-  private readonly onCreate: (name: string) => number | null;
-  private readonly openEditor: (
-    index: number,
-    done: (value?: string) => void,
-  ) => Component;
-  private readonly onDone: (value?: string) => void;
-  private readonly theme: SettingsListTheme;
-  private readonly nameInput = new Input();
+  private readonly wizard: Wizard;
   private activeEditor: Component | null = null;
 
   constructor(
-    theme: SettingsListTheme,
-    onCreate: (name: string) => number | null,
+    theme: SettingsTheme,
+    onCreate: (draft: NewPolicyDraft) => number | null,
     openEditor: (index: number, done: (value?: string) => void) => Component,
     onDone: (value?: string) => void,
   ) {
-    this.theme = theme;
-    this.onCreate = onCreate;
-    this.openEditor = openEditor;
-    this.onDone = onDone;
-
-    this.nameInput.onSubmit = () => {
-      const name = this.nameInput.getValue().trim();
-      if (!name) return;
-      const index = this.onCreate(name);
-      if (index === null) return;
-      this.activeEditor = this.openEditor(index, (value) => {
-        this.activeEditor = null;
-        this.onDone(value);
-      });
+    const state: NewPolicyDraft = {
+      name: "",
+      id: "",
+      protection: "readOnly",
+      patterns: [],
     };
-    this.nameInput.onEscape = () => this.onDone();
+
+    this.wizard = new Wizard({
+      title: "Add policy",
+      theme,
+      steps: [
+        {
+          label: "Name",
+          build: (ctx) =>
+            new PolicyNameStep(theme, state, () => {
+              ctx.markComplete();
+              ctx.goNext();
+            }),
+        },
+        {
+          label: "Protection",
+          build: (ctx) =>
+            new PolicyProtectionStep(theme, state, () => {
+              ctx.markComplete();
+              ctx.goNext();
+            }),
+        },
+        {
+          label: "Patterns",
+          build: (ctx) =>
+            new PolicyPatternsStep(theme, state, () => {
+              if (state.patterns.length === 0) {
+                ctx.markIncomplete();
+                return;
+              }
+              ctx.markComplete();
+              ctx.goNext();
+            }),
+        },
+        {
+          label: "Review",
+          build: (ctx) => {
+            ctx.markComplete();
+            return new PolicyReviewStep(theme, state);
+          },
+        },
+      ],
+      onComplete: () => {
+        if (!state.name.trim() || state.patterns.length === 0) return;
+        const index = onCreate(state);
+        if (index === null) return;
+        this.activeEditor = openEditor(index, (value) => {
+          this.activeEditor = null;
+          onDone(value);
+        });
+      },
+      onCancel: () => onDone(),
+      hintSuffix: "complete steps · Ctrl+S create",
+      minContentHeight: 12,
+    });
   }
 
-  invalidate() {
+  invalidate(): void {
     this.activeEditor?.invalidate?.();
+    this.wizard.invalidate?.();
   }
 
   render(width: number): string[] {
     if (this.activeEditor) {
       return this.activeEditor.render(width);
     }
+    return this.wizard.render(width);
+  }
 
-    return [
-      this.theme.label("+ Add policy", true),
-      "",
-      this.theme.hint("  Enter policy name:"),
-      ...this.nameInput.render(width - 2).map((line) => ` ${line}`),
+  handleInput(data: string): void {
+    if (this.activeEditor) {
+      this.activeEditor.handleInput?.(data);
+      return;
+    }
+    this.wizard.handleInput(data);
+  }
+}
+
+class ScopePickerSubmenu implements Component {
+  private selectedIndex = 0;
+
+  constructor(
+    private readonly theme: SettingsListTheme,
+    private readonly scopes: Array<"global" | "local" | "memory">,
+    private readonly onSelect: (scope: "global" | "local" | "memory") => void,
+    private readonly onDone: (value?: string) => void,
+  ) {}
+
+  invalidate() {}
+
+  render(_width: number): string[] {
+    const lines: string[] = [
+      this.theme.label(" Add example to scope", true),
       "",
-      this.theme.hint("  Enter: create + edit · Esc: back"),
+      this.theme.hint("  Select target scope:"),
     ];
+
+    for (let i = 0; i < this.scopes.length; i++) {
+      const scope = this.scopes[i];
+      if (!scope) continue;
+      const isSelected = i === this.selectedIndex;
+      const prefix = isSelected ? this.theme.cursor : "  ";
+      lines.push(`${prefix}${this.theme.value(scope, isSelected)}`);
+    }
+
+    lines.push("");
+    lines.push(this.theme.hint("  Enter: apply · Esc: back"));
+    return lines;
   }
 
   handleInput(data: string): void {
-    if (this.activeEditor) {
-      this.activeEditor.handleInput?.(data);
+    if (matchesKey(data, Key.up) || data === "k") {
+      this.selectedIndex =
+        this.selectedIndex === 0
+          ? this.scopes.length - 1
+          : this.selectedIndex - 1;
+      return;
+    }
+
+    if (matchesKey(data, Key.down) || data === "j") {
+      this.selectedIndex =
+        this.selectedIndex === this.scopes.length - 1
+          ? 0
+          : this.selectedIndex + 1;
       return;
     }
 
-    this.nameInput.handleInput(data);
+    if (matchesKey(data, Key.enter)) {
+      const scope = this.scopes[this.selectedIndex];
+      if (!scope) return;
+      this.onSelect(scope);
+      this.onDone(`applied to ${scope}`);
+      return;
+    }
+
+    if (matchesKey(data, Key.escape)) {
+      this.onDone();
+    }
   }
 }
 
@@ -316,39 +657,40 @@ export function registerGuardrailsSettings(pi: ExtensionAPI): void {
     configStore: configLoader,
     buildSections: (
       tabConfig: GuardrailsConfig | null,
-      resolved: ResolvedConfig,
-      { setDraft },
+      _resolved: ResolvedConfig,
+      { setDraft, theme },
     ): SettingsSection[] => {
-      const settingsTheme = getSettingsListTheme();
+      const settingsTheme = theme;
+      let scopedConfig = structuredClone(tabConfig ?? {}) as GuardrailsConfig;
+
+      function commitDraft(next: GuardrailsConfig): void {
+        scopedConfig = next;
+        setDraft(structuredClone(next));
+      }
 
       function count(id: string): string {
         const val =
-          (getNestedValue(tabConfig ?? {}, id) as unknown[] | undefined) ??
-          (getNestedValue(resolved, id) as unknown[]) ??
-          [];
+          (getNestedValue(scopedConfig, id) as unknown[] | undefined) ?? [];
         return `${val.length} items`;
       }
 
       function applyDraft(id: string, value: unknown): void {
-        const updated = structuredClone(tabConfig ?? {}) as GuardrailsConfig;
+        const updated = structuredClone(scopedConfig);
         setNestedValue(updated, id, value);
-        setDraft(updated);
+        commitDraft(updated);
       }
 
       function getPolicyRules(): PolicyRule[] {
-        return (
-          tabConfig?.policies?.rules?.map((r) => ({ ...r })) ??
-          resolved.policies.rules.map((r) => ({ ...r }))
-        );
+        return scopedConfig.policies?.rules?.map((r) => ({ ...r })) ?? [];
       }
 
       function setPolicyRules(rules: PolicyRule[]): void {
-        const updated = structuredClone(tabConfig ?? {}) as GuardrailsConfig;
+        const updated = structuredClone(scopedConfig);
         updated.policies = {
           ...(updated.policies ?? {}),
           rules,
         };
-        setDraft(updated);
+        commitDraft(updated);
       }
 
       function updateRule(
@@ -369,12 +711,12 @@ export function registerGuardrailsSettings(pi: ExtensionAPI): void {
         setPolicyRules(rules);
       }
 
-      function addRule(name: string): number | null {
-        const normalizedName = name.trim();
-        if (!normalizedName) return null;
+      function addRule(draft: NewPolicyDraft): number | null {
+        const normalizedName = draft.name.trim();
+        if (!normalizedName || draft.patterns.length === 0) return null;
 
         const rules = getPolicyRules();
-        const baseId = toKebabCase(normalizedName) || "policy";
+        const baseId = toKebabCase(draft.id || normalizedName) || "policy";
         const existingIds = new Set(rules.map((rule) => rule.id));
 
         let id = baseId;
@@ -388,8 +730,8 @@ export function registerGuardrailsSettings(pi: ExtensionAPI): void {
           id,
           name: normalizedName,
           description: "",
-          patterns: [{ pattern: "" }],
-          protection: "readOnly",
+          patterns: draft.patterns,
+          protection: draft.protection,
           onlyIfExists: true,
           enabled: true,
         });
@@ -404,11 +746,9 @@ export function registerGuardrailsSettings(pi: ExtensionAPI): void {
       ) {
         return (_val: string, submenuDone: (v?: string) => void) => {
           const items =
-            (getNestedValue(tabConfig ?? {}, id) as
+            (getNestedValue(scopedConfig, id) as
               | DangerousPattern[]
-              | undefined) ??
-            (getNestedValue(resolved, id) as DangerousPattern[]) ??
-            [];
+              | undefined) ?? [];
           let latestCount = items.length;
           return new PatternEditor({
             label,
@@ -431,10 +771,7 @@ export function registerGuardrailsSettings(pi: ExtensionAPI): void {
       ) {
         return (_val: string, submenuDone: (v?: string) => void) => {
           const currentItems =
-            (getNestedValue(tabConfig ?? {}, id) as
-              | PatternConfig[]
-              | undefined) ??
-            (getNestedValue(resolved, id) as PatternConfig[]) ??
+            (getNestedValue(scopedConfig, id) as PatternConfig[] | undefined) ??
             [];
           const items = currentItems.map((p) => ({
             pattern: p.pattern,
@@ -465,31 +802,39 @@ export function registerGuardrailsSettings(pi: ExtensionAPI): void {
         };
       }
 
+      function hasExplainModelOverride(): boolean {
+        return scopedConfig.permissionGate?.explainModel !== undefined;
+      }
+
       function getExplainModel(): string {
-        const model = tabConfig?.permissionGate?.explainModel;
-        if (model !== undefined) return model;
-        return resolved.permissionGate.explainModel ?? "";
+        return scopedConfig.permissionGate?.explainModel?.trim() ?? "";
       }
 
-      function getExplainTimeout(): number {
-        return (
-          tabConfig?.permissionGate?.explainTimeout ??
-          resolved.permissionGate.explainTimeout
-        );
+      function hasExplainTimeoutOverride(): boolean {
+        return scopedConfig.permissionGate?.explainTimeout !== undefined;
+      }
+
+      function getExplainTimeout(): number | null {
+        return scopedConfig.permissionGate?.explainTimeout ?? null;
       }
 
       const featureItems = (Object.keys(FEATURE_UI) as FeatureKey[])
         .filter((key) => key !== "policies")
-        .map((key) => ({
-          id: `features.${key}`,
-          label: FEATURE_UI[key].label,
-          description: FEATURE_UI[key].description,
-          currentValue:
-            (tabConfig?.features?.[key] ?? resolved.features[key])
-              ? "enabled"
-              : "disabled",
-          values: ["enabled", "disabled"],
-        }));
+        .map((key) => {
+          const scopedValue = scopedConfig.features?.[key];
+          return {
+            id: `features.${key}`,
+            label: FEATURE_UI[key].label,
+            description: FEATURE_UI[key].description,
+            currentValue:
+              scopedValue === undefined
+                ? "(inherited)"
+                : scopedValue
+                  ? "enabled"
+                  : "disabled",
+            values: ["enabled", "disabled"],
+          };
+        });
 
       const policyRules = getPolicyRules();
 
@@ -512,9 +857,11 @@ export function registerGuardrailsSettings(pi: ExtensionAPI): void {
           label: "  Enabled",
           description: FEATURE_UI.policies.description,
           currentValue:
-            (tabConfig?.features?.policies ?? resolved.features.policies)
-              ? "enabled"
-              : "disabled",
+            scopedConfig.features?.policies === undefined
+              ? "(inherited)"
+              : scopedConfig.features.policies
+                ? "enabled"
+                : "disabled",
           values: ["enabled", "disabled"],
         },
         ...policyRules.map((rule, index) => {
@@ -533,7 +880,7 @@ export function registerGuardrailsSettings(pi: ExtensionAPI): void {
       policyItems.push({
         id: "policies.addRule",
         label: "  + Add policy",
-        description: "Create policy, then open editor",
+        description: "Open wizard to create policy",
         currentValue: "",
         submenu: (_val: string, submenuDone: (v?: string) => void) =>
           new AddRuleSubmenu(
@@ -559,10 +906,11 @@ export function registerGuardrailsSettings(pi: ExtensionAPI): void {
               description:
                 "Show confirmation dialog for dangerous commands (if off, just warns)",
               currentValue:
-                (tabConfig?.permissionGate?.requireConfirmation ??
-                resolved.permissionGate.requireConfirmation)
-                  ? "on"
-                  : "off",
+                scopedConfig.permissionGate?.requireConfirmation === undefined
+                  ? "(inherited)"
+                  : scopedConfig.permissionGate.requireConfirmation
+                    ? "on"
+                    : "off",
               values: ["on", "off"],
             },
             {
@@ -605,17 +953,20 @@ export function registerGuardrailsSettings(pi: ExtensionAPI): void {
               description:
                 "Call an LLM to explain dangerous commands in the confirmation dialog",
               currentValue:
-                (tabConfig?.permissionGate?.explainCommands ??
-                resolved.permissionGate.explainCommands)
-                  ? "on"
-                  : "off",
+                scopedConfig.permissionGate?.explainCommands === undefined
+                  ? "(inherited)"
+                  : scopedConfig.permissionGate.explainCommands
+                    ? "on"
+                    : "off",
               values: ["on", "off"],
             },
             {
               id: "permissionGate.explainModel",
               label: "Explain model",
               description: "Model spec in provider/model-id format",
-              currentValue: getExplainModel() || "(not set)",
+              currentValue: hasExplainModelOverride()
+                ? getExplainModel() || "(not set)"
+                : "(inherited)",
               submenu: (_val: string, submenuDone: (v?: string) => void) =>
                 new SettingsDetailEditor({
                   title: "Explain Commands: Model",
@@ -645,20 +996,28 @@ export function registerGuardrailsSettings(pi: ExtensionAPI): void {
               id: "permissionGate.explainTimeout",
               label: "Explain timeout",
               description: "Timeout for LLM explanation in milliseconds",
-              currentValue: `${getExplainTimeout()}ms`,
+              currentValue: hasExplainTimeoutOverride()
+                ? `${getExplainTimeout()}ms`
+                : "(inherited)",
               submenu: (_val: string, submenuDone: (v?: string) => void) =>
                 new SettingsDetailEditor({
                   title: "Explain Commands: Timeout",
                   theme: settingsTheme,
                   onDone: submenuDone,
-                  getDoneSummary: () => `${getExplainTimeout()}ms`,
+                  getDoneSummary: () => {
+                    const timeout = getExplainTimeout();
+                    return timeout === null ? "(not set)" : `${timeout}ms`;
+                  },
                   fields: [
                     {
                       id: "permissionGate.explainTimeout",
                       type: "text",
                       label: "Timeout (ms)",
                       description: "Abort explanation call after this many ms",
-                      getValue: () => String(getExplainTimeout()),
+                      getValue: () => {
+                        const timeout = getExplainTimeout();
+                        return timeout === null ? "" : String(timeout);
+                      },
                       setValue: (value) => {
                         const parsed = Number.parseInt(value.trim(), 10);
                         if (Number.isNaN(parsed) || parsed < 1) return;
@@ -672,5 +1031,46 @@ export function registerGuardrailsSettings(pi: ExtensionAPI): void {
         },
       ];
     },
+    extraTabs: [
+      {
+        id: "examples",
+        label: "Examples",
+        buildSections: ({
+          enabledScopes,
+          getDraftForScope,
+          getRawForScope,
+          setDraftForScope,
+          theme,
+        }): SettingsSection[] => {
+          const items: SettingItem[] = POLICY_EXAMPLES.map((example) => ({
+            id: `examples.${example.rule.id}`,
+            label: `  ${example.label}`,
+            description: example.description,
+            currentValue: "apply",
+            submenu: (_val: string, submenuDone: (v?: string) => void) =>
+              new ScopePickerSubmenu(
+                theme,
+                enabledScopes,
+                (targetScope) => {
+                  const baseConfig =
+                    getDraftForScope(targetScope) ??
+                    getRawForScope(targetScope) ??
+                    null;
+                  const updated = appendPolicyRule(baseConfig, example.rule);
+                  setDraftForScope(targetScope, updated);
+                },
+                submenuDone,
+              ),
+          }));
+
+          return [
+            {
+              label: "Policy presets",
+              items,
+            },
+          ];
+        },
+      },
+    ],
   });
 }

package/src/components/pattern-editor.ts

@@ -12,7 +12,8 @@ import {
  *
  * List mode: navigate, delete with 'd', add with 'a', edit with 'e'/Enter.
  * Form mode: three-field form (pattern + description + regex toggle),
- *            Tab to switch fields, Enter to submit, Escape to cancel.
+ *            Tab to switch fields, Ctrl+R to toggle regex, Enter to submit,
+ *            Escape to cancel.
  */
 
 export interface PatternItem {
@@ -256,7 +257,7 @@ export class PatternEditor implements Component {
 
     lines.push(
       this.theme.hint(
-        "  Tab: switch field · Space: toggle regex · Enter: next/submit · Esc: cancel",
+        "  Tab: switch field · Ctrl+R: toggle regex · Enter: next/submit · Esc: cancel",
       ),
     );
 
@@ -308,17 +309,18 @@ export class PatternEditor implements Component {
       return;
     }
 
+    if (matchesKey(data, Key.ctrl("r"))) {
+      this.regexEnabled = !this.regexEnabled;
+      return;
+    }
+
     if (matchesKey(data, Key.escape)) {
       this.cancelForm();
       return;
     }
 
-    // Regex toggle: space toggles when on regex field
     if (this.activeField === "regex") {
-      if (data === " " || matchesKey(data, Key.enter)) {
-        this.regexEnabled = !this.regexEnabled;
-      }
-      // Enter on regex field submits if we already have a pattern
+      // Enter on regex field submits if we already have a pattern.
       if (matchesKey(data, Key.enter) && this.patternInput.getValue().trim()) {
         this.submitForm();
       }

package/src/hooks/policies.ts

@@ -1,11 +1,15 @@
 import { stat } from "node:fs/promises";
-import { resolve } from "node:path";
+import { isAbsolute, relative, resolve } from "node:path";
 import { parse } from "@aliou/sh";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import type { PolicyRule, Protection, ResolvedConfig } from "../config";
 import { emitBlocked } from "../utils/events";
 import { expandGlob, hasGlobChars } from "../utils/glob-expander";
-import { type CompiledPattern, compileFilePatterns } from "../utils/matching";
+import {
+  type CompiledPattern,
+  compileFilePatterns,
+  normalizeFilePath,
+} from "../utils/matching";
 import { walkCommands, wordToString } from "../utils/shell-utils";
 import { pendingWarnings } from "../utils/warnings";
 
@@ -113,6 +117,16 @@ function maybePathLike(token: string): boolean {
   );
 }
 
+function normalizeTargetForPolicy(filePath: string, cwd: string): string {
+  const absolute = resolve(cwd, filePath);
+  const rel = relative(cwd, absolute);
+
+  const candidate =
+    rel && !rel.startsWith("..") && !isAbsolute(rel) ? rel : absolute;
+
+  return normalizeFilePath(candidate);
+}
+
 function matchesAnyPolicyPattern(
   filePath: string,
   rules: CompiledRule[],
@@ -135,6 +149,7 @@ async function expandCandidate(candidate: string): Promise<string[]> {
 async function extractBashFileTargets(
   command: string,
   rules: CompiledRule[],
+  cwd: string,
 ): Promise<string[]> {
   const targets = new Set<string>();
 
@@ -143,8 +158,9 @@ async function extractBashFileTargets(
 
     const expanded = await expandCandidate(candidate);
     for (const file of expanded) {
-      if (matchesAnyPolicyPattern(file, rules)) {
-        targets.add(file);
+      const normalized = normalizeTargetForPolicy(file, cwd);
+      if (matchesAnyPolicyPattern(normalized, rules)) {
+        targets.add(normalized);
       }
     }
   };
@@ -182,8 +198,9 @@ async function extractBashFileTargets(
 
       const expanded = await expandCandidate(token);
       for (const file of expanded) {
-        if (matchesAnyPolicyPattern(file, rules)) {
-          targets.add(file);
+        const normalized = normalizeTargetForPolicy(file, cwd);
+        if (matchesAnyPolicyPattern(normalized, rules)) {
+          targets.add(normalized);
         }
       }
     }
@@ -259,14 +276,16 @@ export function setupPoliciesHook(pi: ExtensionAPI, config: ResolvedConfig) {
       targets = extractPathTarget(event.input);
     } else if (toolName === "bash") {
       const command = String(event.input.command ?? "");
-      targets = await extractBashFileTargets(command, compiledRules);
+      targets = await extractBashFileTargets(command, compiledRules, ctx.cwd);
     } else {
       return;
     }
 
     for (const target of targets) {
+      const normalizedTarget = normalizeTargetForPolicy(target, ctx.cwd);
+
       const effective = await getEffectiveProtection(
-        target,
+        normalizedTarget,
         compiledRules,
         ctx.cwd,
       );
@@ -276,11 +295,11 @@ export function setupPoliciesHook(pi: ExtensionAPI, config: ResolvedConfig) {
       if (!blockedTools.has(toolName)) continue;
 
       ctx.ui.notify(
-        `Blocked ${toolName} on protected file: ${target} (${effective.ruleId})`,
+        `Blocked ${toolName} on protected file: ${normalizedTarget} (${effective.ruleId})`,
         "warning",
       );
 
-      const reason = effective.blockMessage.replace("{file}", target);
+      const reason = effective.blockMessage.replace("{file}", normalizedTarget);
 
       emitBlocked(pi, {
         feature: "policies",

package/src/utils/matching.ts

@@ -8,6 +8,7 @@
  * Both support `regex: true` for full regex matching.
  */
 
+import { matchesGlob } from "node:path";
 import type { PatternConfig } from "../config";
 import { pendingWarnings } from "./warnings";
 
@@ -17,51 +18,34 @@ export interface CompiledPattern {
 }
 
 /**
- * Convert a glob pattern to a regex.
- * `*` matches any non-`/` chars, `?` matches a single char.
- * The rest is escaped.
+ * Normalize file paths before matching.
+ * - Use forward slashes for cross-platform consistency.
+ * - Drop leading "./" segments.
+ * - Collapse duplicate slashes.
  */
-export function globToRegex(glob: string): RegExp {
-  let regex = "";
-  for (const ch of glob) {
-    switch (ch) {
-      case "*":
-        regex += "[^/]*";
-        break;
-      case "?":
-        regex += "[^/]";
-        break;
-      case ".":
-      case "(":
-      case ")":
-      case "+":
-      case "^":
-      case "$":
-      case "{":
-      case "}":
-      case "|":
-      case "\\":
-      case "[":
-      case "]":
-        regex += `\\${ch}`;
-        break;
-      default:
-        regex += ch;
-    }
-  }
-  return new RegExp(`^${regex}$`, "i");
+export function normalizeFilePath(input: string): string {
+  const normalized = input
+    .replaceAll("\\", "/")
+    .replace(/^(?:\.\/)+/, "")
+    .replace(/\/{2,}/g, "/");
+  return normalized;
 }
 
 /**
  * Compile a single pattern for file-context matching.
- * Default: glob against the basename of the path.
- * regex: true -> full regex (case-insensitive) against the full path.
+ * Default: glob matching.
+ * - If pattern includes `/`, match full normalized relative path.
+ * - Otherwise, match basename only (backward compatible).
+ * regex: true -> full regex (case-insensitive) against normalized path.
  */
 export function compileFilePattern(config: PatternConfig): CompiledPattern {
   if (config.regex) {
     try {
       const re = new RegExp(config.pattern, "i");
-      return { test: (input) => re.test(input), source: config };
+      return {
+        test: (input) => re.test(normalizeFilePath(input)),
+        source: config,
+      };
     } catch {
       pendingWarnings.push(
         `Invalid regex in guardrails config: ${config.pattern}`,
@@ -70,12 +54,16 @@ export function compileFilePattern(config: PatternConfig): CompiledPattern {
     }
   }
 
-  const re = globToRegex(config.pattern);
+  const matchFullPath = config.pattern.includes("/");
+
   return {
     test: (input) => {
-      // Match against basename
-      const basename = input.split("/").pop() ?? input;
-      return re.test(basename);
+      const normalized = normalizeFilePath(input);
+      const candidate = matchFullPath
+        ? normalized
+        : (normalized.split("/").pop() ?? normalized);
+
+      return matchesGlob(candidate, config.pattern);
     },
     source: config,
   };