pi-guard 1.0.0

package/src/extract.ts

@@ -0,0 +1,424 @@
+import { parse as parseBash } from "unbash";
+import type {
+  ArithmeticExpression,
+  AssignmentPrefix,
+  Command,
+  CommandExpansionPart,
+  Node,
+  ParameterExpansionPart,
+  ProcessSubstitutionPart,
+  Redirect,
+  Script,
+  TestExpression,
+  Word,
+  WordPart,
+} from "unbash";
+import type { CommandRef } from "./types.ts";
+
+export type { CommandRef };
+
+export function extractAllCommandsFromAST(node: Script | Node, source: string): CommandRef[] {
+  const commands: CommandRef[] = [];
+  collectNode(node, source, commands);
+  return commands;
+}
+
+function collectNode(node: Script | Node | undefined, source: string, commands: CommandRef[]) {
+  if (!node) return;
+
+  switch (node.type) {
+    case "Script":
+    case "AndOr":
+    case "Pipeline":
+    case "CompoundList":
+      for (const child of node.commands) {
+        collectNode(child, source, commands);
+      }
+      return;
+
+    case "Statement":
+      collectNode(node.command, source, commands);
+      for (const redirect of node.redirects) {
+        collectRedirect(redirect, source, commands);
+      }
+      return;
+
+    case "Command":
+      collectCommand(node, source, commands);
+      return;
+
+    case "Subshell":
+    case "BraceGroup":
+      collectNode(node.body, source, commands);
+      return;
+
+    case "If":
+      collectNode(node.clause, source, commands);
+      collectNode(node.then, source, commands);
+      if (node.else) collectNode(node.else, source, commands);
+      return;
+
+    case "While":
+      collectNode(node.clause, source, commands);
+      collectNode(node.body, source, commands);
+      return;
+
+    case "For":
+      collectWord(node.name, source, commands);
+      for (const word of node.wordlist) {
+        collectWord(word, source, commands);
+      }
+      collectNode(node.body, source, commands);
+      return;
+
+    case "Select":
+      collectWord(node.name, source, commands);
+      for (const word of node.wordlist) {
+        collectWord(word, source, commands);
+      }
+      collectNode(node.body, source, commands);
+      return;
+
+    case "Case":
+      collectWord(node.word, source, commands);
+      for (const item of node.items) {
+        collectCaseItem(item, source, commands);
+      }
+      return;
+
+    case "Function":
+      collectWord(node.name, source, commands);
+      collectNode(node.body, source, commands);
+      for (const redirect of node.redirects) {
+        collectRedirect(redirect, source, commands);
+      }
+      return;
+
+    case "Coproc":
+      if (node.name) collectWord(node.name, source, commands);
+      collectNode(node.body, source, commands);
+      for (const redirect of node.redirects) {
+        collectRedirect(redirect, source, commands);
+      }
+      return;
+
+    case "TestCommand":
+      collectTestExpression(node.expression, source, commands);
+      return;
+
+    case "ArithmeticFor":
+      collectArithmeticExpression(node.initialize, source, commands);
+      collectArithmeticExpression(node.test, source, commands);
+      collectArithmeticExpression(node.update, source, commands);
+      collectNode(node.body, source, commands);
+      return;
+
+    case "ArithmeticCommand":
+      collectArithmeticExpression(node.expression, source, commands);
+      return;
+  }
+}
+
+function collectCommand(node: Command, source: string, commands: CommandRef[]) {
+  if (node.name) {
+    commands.push({ node, source });
+  }
+
+  for (const prefix of node.prefix) {
+    collectAssignment(prefix, source, commands);
+  }
+
+  for (const word of node.suffix) {
+    collectWord(word, source, commands);
+  }
+
+  for (const redirect of node.redirects) {
+    collectRedirect(redirect, source, commands);
+  }
+}
+
+function collectAssignment(assignment: AssignmentPrefix, source: string, commands: CommandRef[]) {
+  if (assignment.value) {
+    collectWord(assignment.value, source, commands);
+  }
+
+  if (assignment.array) {
+    for (const word of assignment.array) {
+      collectWord(word, source, commands);
+    }
+  }
+}
+
+function collectRedirect(redirect: Redirect, source: string, commands: CommandRef[]) {
+  if (redirect.target) {
+    collectWord(redirect.target, source, commands);
+  }
+
+  if (redirect.body?.parts) {
+    collectWord(redirect.body, source, commands);
+  }
+}
+
+function collectWord(word: Word | undefined, source: string, commands: CommandRef[]) {
+  if (!word?.parts) return;
+  for (const part of word.parts) {
+    collectWordPart(part, source, commands);
+  }
+}
+
+function collectWordPart(
+  part: WordPart | CommandExpansionPart | ProcessSubstitutionPart,
+  source: string,
+  commands: CommandRef[],
+) {
+  switch (part.type) {
+    case "DoubleQuoted":
+    case "LocaleString":
+      for (const child of part.parts) {
+        collectWordPart(child, source, commands);
+      }
+      return;
+
+    case "CommandExpansion":
+    case "ProcessSubstitution":
+      if (part.script) {
+        collectNode(part.script, expansionSource(part, source), commands);
+      }
+      return;
+
+    case "ParameterExpansion":
+      collectParameterExpansion(part, source, commands);
+      return;
+
+    case "ArithmeticExpansion":
+      collectArithmeticExpression(part.expression, source, commands);
+      return;
+
+    default:
+      return;
+  }
+}
+
+function collectParameterExpansion(part: ParameterExpansionPart, source: string, commands: CommandRef[]) {
+  if (part.operand) {
+    collectWord(part.operand, source, commands);
+  }
+
+  if (part.slice) {
+    collectWord(part.slice.offset, source, commands);
+    if (part.slice.length) {
+      collectWord(part.slice.length, source, commands);
+    }
+  }
+
+  if (part.replace) {
+    collectWord(part.replace.pattern, source, commands);
+    collectWord(part.replace.replacement, source, commands);
+  }
+}
+
+function expansionSource(part: CommandExpansionPart | ProcessSubstitutionPart, fallbackSource: string): string {
+  if (part.inner != null) return part.inner;
+
+  const text = part.text;
+  if (text.startsWith("$(") && text.endsWith(")")) {
+    return text.slice(2, -1);
+  }
+  if ((text.startsWith("<(") || text.startsWith(">(")) && text.endsWith(")")) {
+    return text.slice(2, -1);
+  }
+  if (text.startsWith("`") && text.endsWith("`")) {
+    return text.slice(1, -1);
+  }
+
+  return fallbackSource;
+}
+
+function collectCaseItem(item: { pattern: Word[]; body: Node }, source: string, commands: CommandRef[]) {
+  for (const pattern of item.pattern) {
+    collectWord(pattern, source, commands);
+  }
+  collectNode(item.body, source, commands);
+}
+
+function collectTestExpression(expr: TestExpression, source: string, commands: CommandRef[]) {
+  switch (expr.type) {
+    case "TestUnary":
+      collectWord(expr.operand, source, commands);
+      return;
+    case "TestBinary":
+      collectWord(expr.left, source, commands);
+      collectWord(expr.right, source, commands);
+      return;
+    case "TestLogical":
+      collectTestExpression(expr.left, source, commands);
+      collectTestExpression(expr.right, source, commands);
+      return;
+    case "TestNot":
+      collectTestExpression(expr.operand, source, commands);
+      return;
+    case "TestGroup":
+      collectTestExpression(expr.expression, source, commands);
+      return;
+  }
+}
+
+function collectArithmeticExpression(expr: ArithmeticExpression | undefined, source: string, commands: CommandRef[]) {
+  if (!expr) return;
+
+  switch (expr.type) {
+    case "ArithmeticBinary":
+      collectArithmeticExpression(expr.left, source, commands);
+      collectArithmeticExpression(expr.right, source, commands);
+      return;
+    case "ArithmeticUnary":
+      collectArithmeticExpression(expr.operand, source, commands);
+      return;
+    case "ArithmeticTernary":
+      collectArithmeticExpression(expr.test, source, commands);
+      collectArithmeticExpression(expr.consequent, source, commands);
+      collectArithmeticExpression(expr.alternate, source, commands);
+      return;
+    case "ArithmeticGroup":
+      collectArithmeticExpression(expr.expression, source, commands);
+      return;
+    case "ArithmeticCommandExpansion":
+      if (expr.script) {
+        // Extract inner source from text like "$(cmd)" -> "cmd"
+        const innerSource = expr.text.startsWith("$(") && expr.text.endsWith(")")
+          ? expr.text.slice(2, -1)
+          : expr.text;
+        collectNode(expr.script, innerSource, commands);
+      } else if (expr.inner) {
+        // Parse the inner text and collect commands (for double-quoted context)
+        const innerAst = parseBash(expr.inner);
+        collectArithmeticCommands(innerAst, expr.inner, commands);
+      }
+      return;
+    case "ArithmeticWord":
+      return;
+  }
+}
+
+function collectArithmeticCommands(node: Script | Node | undefined, source: string, commands: CommandRef[]) {
+  if (!node) return;
+
+  switch (node.type) {
+    case "Script":
+    case "AndOr":
+    case "Pipeline":
+    case "CompoundList":
+      for (const child of node.commands) {
+        collectArithmeticCommands(child, source, commands);
+      }
+      return;
+
+    case "Statement":
+      collectArithmeticCommands(node.command, source, commands);
+      for (const redirect of node.redirects) {
+        collectArithmeticRedirect(redirect, source, commands);
+      }
+      return;
+
+    case "Command":
+      if (node.name) {
+        commands.push({ node, source });
+      }
+      for (const prefix of node.prefix) {
+        collectAssignment(prefix, source, commands);
+      }
+      for (const word of node.suffix) {
+        collectWord(word, source, commands);
+      }
+      for (const redirect of node.redirects) {
+        collectArithmeticRedirect(redirect, source, commands);
+      }
+      return;
+
+    case "Subshell":
+    case "BraceGroup":
+      collectArithmeticCommands(node.body, source, commands);
+      return;
+
+    case "If":
+      collectArithmeticCommands(node.clause, source, commands);
+      collectArithmeticCommands(node.then, source, commands);
+      if (node.else) collectArithmeticCommands(node.else, source, commands);
+      return;
+
+    case "While":
+      collectArithmeticCommands(node.clause, source, commands);
+      collectArithmeticCommands(node.body, source, commands);
+      return;
+
+    case "For":
+      collectWord(node.name, source, commands);
+      for (const word of node.wordlist) {
+        collectWord(word, source, commands);
+      }
+      collectArithmeticCommands(node.body, source, commands);
+      return;
+
+    case "Select":
+      collectWord(node.name, source, commands);
+      for (const word of node.wordlist) {
+        collectWord(word, source, commands);
+      }
+      collectArithmeticCommands(node.body, source, commands);
+      return;
+
+    case "Case":
+      collectWord(node.word, source, commands);
+      for (const item of node.items) {
+        collectArithmeticCaseItem(item, source, commands);
+      }
+      return;
+
+    case "Function":
+      collectWord(node.name, source, commands);
+      collectArithmeticCommands(node.body, source, commands);
+      for (const redirect of node.redirects) {
+        collectArithmeticRedirect(redirect, source, commands);
+      }
+      return;
+
+    case "Coproc":
+      if (node.name) collectWord(node.name, source, commands);
+      collectArithmeticCommands(node.body, source, commands);
+      for (const redirect of node.redirects) {
+        collectArithmeticRedirect(redirect, source, commands);
+      }
+      return;
+
+    case "TestCommand":
+      collectTestExpression(node.expression, source, commands);
+      return;
+
+    case "ArithmeticFor":
+      collectArithmeticExpression(node.initialize, source, commands);
+      collectArithmeticExpression(node.test, source, commands);
+      collectArithmeticExpression(node.update, source, commands);
+      collectArithmeticCommands(node.body, source, commands);
+      return;
+
+    case "ArithmeticCommand":
+      collectArithmeticExpression(node.expression, source, commands);
+      return;
+  }
+}
+
+function collectArithmeticRedirect(redirect: Redirect, source: string, commands: CommandRef[]) {
+  if (redirect.target) {
+    collectWord(redirect.target, source, commands);
+  }
+  if (redirect.body?.parts) {
+    collectWord(redirect.body, source, commands);
+  }
+}
+
+function collectArithmeticCaseItem(item: { pattern: Word[]; body: Node }, source: string, commands: CommandRef[]) {
+  for (const pattern of item.pattern) {
+    collectWord(pattern, source, commands);
+  }
+  collectArithmeticCommands(item.body, source, commands);
+}

package/src/format.ts

@@ -0,0 +1,206 @@
+import type { Redirect, Word } from "unbash";
+import type { CommandRef } from "./types.ts";
+
+export const FORMAT_COMMAND_DEFAULT_MAX_LENGTH = 120;
+export const FORMAT_COMMAND_DEFAULT_ARG_MAX_LENGTH = 40;
+
+/**
+ * Format an extracted command for display.
+ *
+ * Re-serializes from AST tokens, preserving original quoting via source slices.
+ * The command name is always shown verbatim. If the full command fits, it is
+ * shown unchanged. Otherwise, the formatter starts from the full display and
+ * shrinks later tokens only as much as needed to fit within maxLength:
+ *   - Path-like tokens get path-aware middle elision that preserves the tail.
+ *   - Other tokens are prefix-truncated with "…".
+ *   - argMaxLength acts as the minimum per-token elision target, not a hard cap
+ *     when there is still room in the overall maxLength budget.
+ * If the total result still exceeds maxLength, it is hard-truncated with "…".
+ */
+export function formatCommand(
+  cmd: CommandRef,
+  options?: { maxLength?: number; argMaxLength?: number },
+): string {
+  const maxLength = options?.maxLength ?? FORMAT_COMMAND_DEFAULT_MAX_LENGTH;
+  const argMaxLength = options?.argMaxLength ?? FORMAT_COMMAND_DEFAULT_ARG_MAX_LENGTH;
+
+  const name = displayWord(cmd.node.name, cmd.source).replace(/\n/g, "↵");
+  const tokenSpecs = [
+    ...cmd.node.suffix.map(arg => {
+      const full = displayWord(arg, cmd.source).replace(/\n/g, "↵");
+      return makeTokenSpec(full, argMaxLength);
+    }),
+    ...cmd.node.redirects
+      .filter(redirect => !isRenderableHeredoc(redirect))
+      .map(redirect => {
+        const full = renderRedirect(redirect, cmd.source).replace(/\n/g, "↵");
+        return makeTokenSpec(full, argMaxLength);
+      }),
+    ...cmd.node.redirects
+      .filter(isRenderableHeredoc)
+      .map(redirect => {
+        const full = renderFullHeredoc(redirect, cmd.source);
+        const min = renderElidedHeredoc(redirect, cmd.source, argMaxLength);
+        return makeTokenSpec(full, argMaxLength, min);
+      }),
+  ];
+
+  const fullDisplay = [name, ...tokenSpecs.map(spec => spec.full)].join(" ");
+  if (fullDisplay.length <= maxLength) return fullDisplay;
+
+  const tokens = tokenSpecs.map(spec => spec.full);
+  let overflow = fullDisplay.length - maxLength;
+
+  for (let i = tokenSpecs.length - 1; i >= 0 && overflow > 0; i--) {
+    const spec = tokenSpecs[i]!;
+    const current = tokens[i]!;
+    const maxShrink = current.length - spec.min.length;
+    if (maxShrink <= 0) continue;
+
+    const nextTargetLength = current.length - Math.min(maxShrink, overflow);
+    const shrunk = spec.shrink(nextTargetLength);
+    tokens[i] = shrunk;
+    overflow -= current.length - shrunk.length;
+  }
+
+  let display = [name, ...tokens].join(" ");
+  if (display.length > maxLength) {
+    display = display.slice(0, maxLength - 1) + "…";
+  }
+
+  return display;
+}
+
+function isRenderableHeredoc(redirect: Redirect): boolean {
+  return (redirect.operator === "<<" || redirect.operator === "<<-") && redirect.content != null;
+}
+
+function renderRedirect(redirect: Redirect, source: string): string {
+  const prefix = redirectPrefix(redirect);
+  const target = redirect.target ? displayWord(redirect.target, source) : "";
+  return `${prefix}${target}`;
+}
+
+function renderFullHeredoc(redirect: Redirect, source: string): string {
+  const prefix = `${redirectPrefix(redirect)}${heredocTargetDisplay(redirect, source)}↵`;
+  return prefix + (redirect.content ?? "").replace(/\n/g, "↵") + heredocMarker(redirect, source);
+}
+
+function renderElidedHeredoc(redirect: Redirect, source: string, argMaxLength: number): string {
+  const prefix = `${redirectPrefix(redirect)}${heredocTargetDisplay(redirect, source)}↵`;
+  const content = (redirect.content ?? "").replace(/\n/g, "↵");
+  const full = content + heredocMarker(redirect, source);
+
+  if (full.length <= argMaxLength) {
+    return prefix + full;
+  }
+
+  return prefix + content.slice(0, argMaxLength) + "…";
+}
+
+function redirectPrefix(redirect: Redirect): string {
+  const fd = redirect.fileDescriptor != null ? String(redirect.fileDescriptor) : "";
+  const variableName = redirect.variableName ? `{${redirect.variableName}}` : "";
+  return `${fd}${variableName}${redirect.operator}`;
+}
+
+function heredocTargetDisplay(redirect: Redirect, source: string): string {
+  const marker = rawHeredocMarker(redirect, source);
+  return redirect.heredocQuoted ? `'${marker}'` : marker;
+}
+
+function heredocMarker(redirect: Redirect, source: string): string {
+  return rawHeredocMarker(redirect, source).replaceAll("\\", "");
+}
+
+function rawHeredocMarker(redirect: Redirect, source: string): string {
+  if (!redirect.target) return "";
+  const raw = displayWord(redirect.target, source);
+  return raw.length > 0 ? raw : (redirect.target.value ?? redirect.target.text);
+}
+
+function displayWord(word: Word | undefined, source: string): string {
+  if (!word) return "";
+  const sliced = source.slice(word.pos, word.end);
+  return sliced.length > 0 ? sliced : word.text;
+}
+
+function makeTokenSpec(full: string, argMaxLength: number, min = elideToken(full, argMaxLength)) {
+  return {
+    full,
+    min,
+    shrink: (targetLength: number) => shrinkToken(full, targetLength, min),
+  };
+}
+
+/** Elide a single argument token if warranted. */
+function elideToken(token: string, argMaxLength: number): string {
+  if (isPathToken(token)) {
+    const elided = elidePath(token);
+    return elided.length < token.length ? elided : token;
+  }
+  if (token.length > argMaxLength) {
+    return token.slice(0, argMaxLength) + "…";
+  }
+  return token;
+}
+
+function shrinkToken(token: string, targetLength: number, min: string): string {
+  if (token.length <= targetLength) return token;
+  if (targetLength <= min.length) return min;
+  if (targetLength <= 1) return "…";
+  if (isPathToken(token)) return shrinkPathToken(token, targetLength);
+  return token.slice(0, targetLength - 1) + "…";
+}
+
+/**
+ * Path-like detection using character composition.
+ * A token is considered path-like if:
+ *   - It contains a slash (required)
+ *   - It is not a URL (no ://)
+ *   - After stripping surrounding quotes, the non-space characters are
+ *     ≥85% path-safe ([a-zA-Z0-9/._~$@%+=,:-]) — handles bare relative
+ *     paths like packages/tui/src/terminal.ts and quoted paths with $
+ *     like "$PROJECT_ROOT/src/routes/$page.tsx"
+ *   - Spaces don't exceed 10% of the inner length (guards against sentences
+ *     that happen to contain a slash)
+ */
+function isPathToken(token: string): boolean {
+  if (!token.includes("/")) return false;
+  if (token.includes("://")) return false;
+  const inner = token.replace(/^["']|["']$/g, "");
+  const spaces = (inner.match(/ /g) ?? []).length;
+  if (spaces / inner.length > 0.1) return false;
+  const nonSpace = inner.replace(/ /g, "");
+  if (nonSpace.length === 0) return false;
+  const safe = (nonSpace.match(/[a-zA-Z0-9/._~$@%+=,:-]/g) ?? []).length;
+  return safe / nonSpace.length >= 0.85;
+}
+
+/**
+ * Path-aware elision: keep the first two segments and the last.
+ * /Users/jdiamond/code/pi-unbash → /Users/…/pi-unbash
+ */
+function elidePath(p: string): string {
+  const parts = p.split("/");
+  if (parts.length <= 3) return p;
+  return parts.slice(0, 2).join("/") + "/…/" + parts[parts.length - 1];
+}
+
+function shrinkPathToken(token: string, targetLength: number): string {
+  if (token.length <= targetLength) return token;
+  if (targetLength <= 1) return "…";
+
+  const lastSlash = token.lastIndexOf("/");
+  if (lastSlash <= 0) {
+    return token.slice(0, targetLength - 1) + "…";
+  }
+
+  const suffix = token.slice(lastSlash);
+  const prefixBudget = targetLength - suffix.length - 1;
+  if (prefixBudget <= 0) {
+    return token.slice(0, targetLength - 1) + "…";
+  }
+
+  return token.slice(0, prefixBudget) + "…" + suffix;
+}