@aliou/pi-guardrails 0.9.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.9.0",
+  "version": "0.9.1",
   "license": "MIT",
   "type": "module",
   "private": false,

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,
   };