@davisliu2006/pi-permission-system 0.1.0 → 0.2.0

package/src/wildcard-editor.ts

@@ -0,0 +1,136 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { generateBashWildcard, generateBashWildcards } from "./ai-wildcard.ts";
+import { STATUS_KEY } from "./constants.ts";
+import { resolveAllowAlwaysMode } from "./policy-bash.ts";
+import { analyzeShellCommand } from "./shell.ts";
+import {
+  BROAD_WILDCARD_TITLE,
+  formatBroadWildcardConfirm,
+  formatBroadWildcardListConfirm,
+  STATUS_GENERATING_WILDCARD,
+  WILDCARD_EDITOR_TITLE,
+  WILDCARD_LIST_EDITOR_TITLE,
+} from "./ui-strings.ts";
+import { INVALID_WILDCARD_PREFIX } from "./warning-strings.ts";
+import {
+  validateWildcardSuggestion,
+  validateWildcardSuggestionList,
+} from "./wildcard-validation.ts";
+import type {
+  AllowAlwaysRule,
+  PermissionRequest,
+  PolicyResolution,
+} from "./types.ts";
+
+/**
+ * Single-command wildcard path.
+ */
+async function chooseSingleWildcard(
+  ctx: ExtensionContext,
+  command: string
+): Promise<AllowAlwaysRule | undefined> {
+  ctx.ui.setStatus(STATUS_KEY, STATUS_GENERATING_WILDCARD);
+  let suggestion: string | undefined;
+  try {
+    suggestion = await generateBashWildcard(ctx, command);
+  } finally {
+    ctx.ui.setStatus(STATUS_KEY, undefined);
+  }
+
+  let current = suggestion ?? command;
+  while (true) {
+    const edited = await ctx.ui.editor(WILDCARD_EDITOR_TITLE, current);
+    if (edited === undefined) {return undefined;}
+
+    const pattern = edited.trim();
+    const validation = validateWildcardSuggestion(pattern, command);
+    if (!validation.valid) {
+      ctx.ui.notify(`${INVALID_WILDCARD_PREFIX}${validation.reason}`, "warning");
+      current = pattern || command;
+      continue;
+    }
+
+    if (validation.broad) {
+      const confirmed = await ctx.ui.confirm(
+        BROAD_WILDCARD_TITLE,
+        formatBroadWildcardConfirm(pattern)
+      );
+      if (!confirmed) {
+        current = pattern;
+        continue;
+      }
+    }
+
+    return { kind: "wildcard", tool: "bash", body: pattern };
+  }
+}
+
+/**
+ * Multi-command wildcard path.
+ */
+async function chooseWildcardListRules(
+  ctx: ExtensionContext,
+  commands: readonly string[]
+): Promise<AllowAlwaysRule[] | undefined> {
+  ctx.ui.setStatus(STATUS_KEY, STATUS_GENERATING_WILDCARD);
+  let suggestion: string[] | undefined;
+  try {
+    suggestion = await generateBashWildcards(ctx, commands);
+  } finally {
+    ctx.ui.setStatus(STATUS_KEY, undefined);
+  }
+
+  let current = (suggestion ?? commands).join("; ");
+  while (true) {
+    const edited = await ctx.ui.editor(WILDCARD_LIST_EDITOR_TITLE, current);
+    if (edited === undefined) {return undefined;}
+
+    const validation = validateWildcardSuggestionList(edited, commands);
+    if (!validation.valid) {
+      ctx.ui.notify(`${INVALID_WILDCARD_PREFIX}${validation.reason}`, "warning");
+      current = edited.trim() || commands.join("; ");
+      continue;
+    }
+
+    if (validation.broadPatterns.length > 0) {
+      const confirmed = await ctx.ui.confirm(
+        BROAD_WILDCARD_TITLE,
+        formatBroadWildcardListConfirm(validation.broadPatterns)
+      );
+      if (!confirmed) {
+        current = validation.patterns.join("; ");
+        continue;
+      }
+    }
+
+    return validation.patterns.map((pattern) => ({
+      kind: "wildcard" as const,
+      tool: "bash" as const,
+      body: pattern,
+    }));
+  }
+}
+
+/**
+ * Selects the "allow always" matching rules for the request.
+ */
+export async function chooseAlwaysRules(
+  ctx: ExtensionContext,
+  request: PermissionRequest,
+  policy: PolicyResolution
+): Promise<AllowAlwaysRule[] | undefined> {
+  const mode = resolveAllowAlwaysMode(request, policy);
+
+  if (mode === "wildcard") {
+    const rule = await chooseSingleWildcard(ctx, request.body);
+    return rule ? [rule] : undefined;
+  }
+
+  if (mode === "wildcard-list") {
+    const analysis = request.bashAnalysis ?? analyzeShellCommand(request.body);
+    return chooseWildcardListRules(ctx, analysis.segments);
+  }
+
+  return [{ kind: "exact", tool: request.toolName, body: request.body }];
+}

package/src/wildcard-validation.ts

@@ -3,6 +3,29 @@ import {
   isValidWildcardPattern,
   matchesWildcard,
 } from "./matcher.ts";
+import {
+  formatWildcardListCountReason,
+  formatWildcardListItemReason,
+  WILDCARD_LENGTH_REASON,
+  WILDCARD_NO_MATCH_REASON,
+} from "./warning-strings.ts";
+
+export type WildcardValidationResult = {
+  valid: true;
+  broad: boolean;
+} | {
+  valid: false;
+  reason: string;
+};
+
+export type WildcardListValidationResult = {
+  valid: true;
+  patterns: string[];
+  broadPatterns: string[];
+} | {
+  valid: false;
+  reason: string;
+};
 
 /**
  * Validates a wildcard pattern against a command.
@@ -10,12 +33,54 @@ import {
 export function validateWildcardSuggestion(
   pattern: string,
   command: string
-): { valid: true; broad: boolean } | { valid: false; reason: string } {
+): WildcardValidationResult {
   if (!isValidWildcardPattern(pattern)) {
-    return { valid: false, reason: "Pattern must be between 1 and 500 characters." };
+    return { valid: false, reason: WILDCARD_LENGTH_REASON };
   }
   if (!matchesWildcard(pattern, command)) {
-    return { valid: false, reason: "Pattern does not match the current command." };
+    return { valid: false, reason: WILDCARD_NO_MATCH_REASON };
   }
   return { valid: true, broad: isMatchEverythingPattern(pattern) };
 }
+
+/**
+ * Splits a semicolon-separated wildcard list from the model or editor.
+ */
+export function splitWildcardList(value: string): string[] {
+  return value
+    .split(";")
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0);
+}
+
+/**
+ * Validates semicolon-separated patterns against a list of commands.
+ */
+export function validateWildcardSuggestionList(
+  patternsText: string,
+  commands: readonly string[]
+): WildcardListValidationResult {
+  const patterns = splitWildcardList(patternsText);
+  if (patterns.length !== commands.length) {
+    return {
+      valid: false,
+      reason: formatWildcardListCountReason(commands.length, patterns.length),
+    };
+  }
+
+  const broadPatterns: string[] = [];
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index]!;
+    const command = commands[index]!;
+    const result = validateWildcardSuggestion(pattern, command);
+    if (!result.valid) {
+      return {
+        valid: false,
+        reason: formatWildcardListItemReason(index + 1, pattern, result.reason),
+      };
+    }
+    if (result.broad) {broadPatterns.push(pattern);}
+  }
+
+  return { valid: true, patterns, broadPatterns };
+}