@rosetears/aili-pi 0.1.5 → 0.1.7

package/src/vendor/pi-permission-modes/resolve.ts

@@ -0,0 +1,142 @@
+/**
+ * Generated AILI adaptation of pi-permission-modes@2.2.0.
+ * Source revision: 23d65d10a53b67043cae42322acf9044d6edb196.
+ * Regenerate with scripts/sync-permission-modes.ts; do not edit manually.
+ */
+/**
+ * Resolution engine — turns a (mode, surface, target) into an allow/ask/deny.
+ *
+ * Two composition rules, mirroring the opencode model:
+ *   - within a surface's pattern-map: LAST matching pattern wins (so a leading
+ *     `"*"` sets the default and later specific patterns override it);
+ *   - across layers (path gate · external_directory · the named surface):
+ *     MOST-RESTRICTIVE wins (deny > ask > allow).
+ *
+ * Pure and SDK-free (only `os.homedir()` for `~`/`$HOME` expansion) so the whole
+ * matrix is unit-testable. Out-of-project determination is passed in by the
+ * caller (computed via paths.isOutside) to keep this module free of fs/symlink
+ * concerns.
+ */
+
+import os from "node:os";
+import { FILE_SURFACES, type Action, type ModeDef, type Surface, type SurfaceValue } from "pi-permission-modes/src/schema.ts";
+
+const RANK: Record<Action, number> = { allow: 0, ask: 1, deny: 2 };
+
+/** Expand a leading `~` or `$HOME` to the user's home directory. */
+export function expandHome(s: string): string {
+  const home = os.homedir();
+  if (s === "~" || s === "$HOME") return home;
+  if (s.startsWith("~/")) return home + s.slice(1);
+  if (s.startsWith("$HOME/")) return home + s.slice(5);
+  return s;
+}
+
+/**
+ * Glob match: `*` matches any run of characters INCLUDING `/` (so `*` is a true
+ * universal fallback and `*.md` matches nested paths); `?` matches exactly one
+ * character. `~`/`$HOME` are expanded on both pattern and target before matching.
+ */
+export function matchPattern(pattern: string, target: string): boolean {
+  const p = expandHome(pattern);
+  const t = expandHome(target);
+  let re = "^";
+  for (const ch of p) {
+    if (ch === "*") re += ".*";
+    else if (ch === "?") re += ".";
+    else re += ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  re += "$";
+  return new RegExp(re, "s").test(t);
+}
+
+/**
+ * Resolve one surface value against a target. String shorthand returns directly;
+ * a pattern-map returns the action of the LAST matching pattern (definition
+ * order, via Object.entries — keep pattern keys non-numeric to preserve order).
+ * Returns undefined when the surface is absent or nothing matches.
+ */
+export function resolveSurface(value: SurfaceValue | undefined, target: string): Action | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value === "string") return value;
+  let result: Action | undefined;
+  for (const [pattern, action] of Object.entries(value)) {
+    if (matchPattern(pattern, target)) result = action;
+  }
+  return result;
+}
+
+/** Most-restrictive of the given actions (deny > ask > allow); undefined ignored. */
+export function mostRestrictive(...actions: (Action | undefined)[]): Action | undefined {
+  let best: Action | undefined;
+  let bestRank = -1;
+  for (const a of actions) {
+    if (a === undefined) continue;
+    if (RANK[a] > bestRank) {
+      best = a;
+      bestRank = RANK[a];
+    }
+  }
+  return best;
+}
+
+const isFileSurface = (s: Surface): boolean => FILE_SURFACES.includes(s);
+
+/**
+ * Decide the action for a (surface, target) under a mode. Folds the cross-cutting
+ * `path` gate (file surfaces only) and the `external_directory` gate (when the
+ * target is outside the project) into the named surface via most-restrictive.
+ *
+ * `opts.isOutside` — whether `target` resolves outside the project (caller
+ * computes via paths.isOutside). `opts.fallback` — the action when no layer
+ * matches at all (default "ask", least-privilege; built-in modes always specify
+ * a `"*"` so this only affects sparse user-authored modes).
+ */
+export function decide(
+  mode: ModeDef,
+  surface: Surface,
+  target: string,
+  opts: { isOutside?: boolean; fallback?: Action } = {},
+): Action {
+  const layers: (Action | undefined)[] = [];
+
+  // The base policy and the project tighten-only overlay are independent sources;
+  // composing both with most-restrictive means the overlay can only tighten.
+  const sources = mode.projectOverlay ? [mode.permission, mode.projectOverlay] : [mode.permission];
+  for (const perm of sources) {
+    if (isFileSurface(surface)) layers.push(resolveSurface(perm.path, target));
+    if (opts.isOutside) layers.push(resolveSurface(perm.external_directory, target));
+    layers.push(resolveSurface(perm[surface], target));
+  }
+
+  return mostRestrictive(...layers) ?? opts.fallback ?? "ask";
+}
+
+/**
+ * Decide the action for ONE extracted bash command (the tree-sitter path, where
+ * each command in a chain is judged separately). Per source (base policy +
+ * project tighten-only overlay), most-restrictive of:
+ *   - the `bash` surface matched against the joined "name args…" string;
+ *   - the cross-cutting `path` gate matched against that same joined string
+ *     (parity with the heuristic fallback, where `decide` folds `path` over the
+ *     whole command line);
+ *   - the `path` gate matched against each individual token (name and each
+ *     arg), so path globs like `*.env` bind bash arguments regardless of where
+ *     they sit in the command.
+ *
+ * Returns undefined when no layer matches at all; the caller picks the default
+ * (the dispatcher treats a fully-unmatched command as "allow" within a chain,
+ * matching resolveSurface semantics for absent surfaces).
+ */
+export function decideBashCommand(mode: ModeDef, name: string, args: string[]): Action | undefined {
+  const tokens = [name, ...args];
+  const joined = tokens.join(" ").trim();
+  const layers: (Action | undefined)[] = [];
+  const sources = mode.projectOverlay ? [mode.permission, mode.projectOverlay] : [mode.permission];
+  for (const perm of sources) {
+    layers.push(resolveSurface(perm.bash, joined));
+    layers.push(resolveSurface(perm.path, joined));
+    for (const tok of tokens) layers.push(resolveSurface(perm.path, tok));
+  }
+  return mostRestrictive(...layers);
+}

package/upstream/pi-permission-modes.lock.json

@@ -0,0 +1,47 @@
+{
+  "schemaVersion": 1,
+  "package": {
+    "name": "pi-permission-modes",
+    "version": "2.2.0",
+    "revision": "23d65d10a53b67043cae42322acf9044d6edb196",
+    "license": "MIT"
+  },
+  "upstreamFiles": [
+    {
+      "path": "src/index.ts",
+      "sha256": "fd4462a3b7ba986af734c2e17ba8ea7178df56c933e87ed444ba90ba24c2fd5b"
+    },
+    {
+      "path": "src/resolve.ts",
+      "sha256": "13f52a4a9c08d7a55f5f9d03f97302d864768838fb3e9fca2051cb7d94a0ae82"
+    },
+    {
+      "path": "LICENSE",
+      "sha256": "d87cb99b43f6bf8771e57be83485db11b977b9dfa21b6bd201b8d3d370bdce43"
+    }
+  ],
+  "adaptedFiles": [
+    {
+      "path": "src/vendor/pi-permission-modes/index.ts",
+      "sha256": "8bfa0364967a2b76e9900cc72b8f434ea1cfa6520899c7827488220f2e288ee8"
+    },
+    {
+      "path": "src/vendor/pi-permission-modes/resolve.ts",
+      "sha256": "f71688f847495da5122724f75c5ebe3b41066b3d3cac74cbe99f66b9906404f6"
+    },
+    {
+      "path": "licenses/pi-permission-modes-MIT.txt",
+      "sha256": "d87cb99b43f6bf8771e57be83485db11b977b9dfa21b6bd201b8d3d370bdce43"
+    }
+  ],
+  "localChanges": [
+    "Package-owned adapted entry redirects all unchanged sibling modules to the exact pi-permission-modes dependency while owning resolve.ts locally.",
+    "matchPattern compiles its anchored glob RegExp with dotAll so * and ? include ECMAScript line terminators."
+  ],
+  "generatedBy": "scripts/sync-permission-modes.ts",
+  "verification": [
+    "npm run verify:permission-modes",
+    "tests/unit/permission-patterns.test.ts",
+    "tests/integration/permission-modes.test.ts"
+  ]
+}