refactor: simplify command pattern parser using shell-quote library

- Replace custom parsing logic with shell-quote library
- Implement simplified extractPatterns and processCommand functions
- Maintain all existing test compatibility
- Remove dependency on parseCommand from command-validation

Author: roomote

webview-ui/src/utils/commandPatterns.ts

@@ -1,4 +1,4 @@
-import { parseCommand } from "./command-validation"
+import { parse } from "shell-quote"
 
 export interface CommandPattern {
 	pattern: string
@@ -10,60 +10,63 @@ export interface SecurityWarning {
 	message: string
 }
 
-export function extractCommandPatterns(command: string): string[] {
-	if (!command?.trim()) return []
+function processCommand(cmd: string[], patterns: Set<string>): void {
+	if (!cmd.length || typeof cmd[0] !== "string") return
 
-	const patterns = new Set<string>()
+	const mainCmd = cmd[0]
 
-	// First, check if the command contains subshells and remove them
-	// This is important for security - we don't want to extract patterns from subshell contents
-	const cleanedCommand = command
-		.replace(/\$\([^)]*\)/g, "") // Remove $() subshells
-		.replace(/`[^`]*`/g, "") // Remove backtick subshells
+	// Skip if it's just a number (like "0" from "0 total")
+	if (/^\d+$/.test(mainCmd)) return
+
+	// Skip common output patterns that aren't commands
+	const skipWords = ["total", "error", "warning", "failed", "success", "done"]
+	if (skipWords.includes(mainCmd.toLowerCase())) return
+
+	patterns.add(mainCmd)
 
-	// Use parseCommand to split the cleaned command into sub-commands
-	// This ensures consistent parsing behavior with command-validation
-	const subCommands = parseCommand(cleanedCommand)
+	const breakingExps = [/^-/, /[\\/.~]/]
 
-	// Process each sub-command to extract patterns
-	for (const subCommand of subCommands) {
-		// Skip empty commands
-		if (!subCommand.trim()) continue
+	for (let i = 1; i < cmd.length; i++) {
+		const arg = cmd[i]
 
-		// Split the command into tokens
-		const tokens = subCommand.trim().split(/\s+/)
+		if (typeof arg !== "string" || breakingExps.some((re) => re.test(arg))) break
 
-		if (tokens.length === 0) continue
+		const pattern = cmd.slice(0, i + 1).join(" ")
+		patterns.add(pattern)
+	}
+}
 
-		const mainCmd = tokens[0]
+function extractPatterns(cmdStr: string): Set<string> {
+	const patterns = new Set<string>()
 
-		// Skip if it's just a number (like "0" from "0 total")
-		if (/^\d+$/.test(mainCmd)) continue
+	const parsed = parse(cmdStr)
 
-		// Skip common output patterns that aren't commands
-		const skipWords = ["total", "error", "warning", "failed", "success", "done"]
-		if (skipWords.includes(mainCmd.toLowerCase())) continue
+	const commandSeparators = new Set(["|", "&&", "||", ";"])
+	let current: string[] = []
+	for (const token of parsed) {
+		if (typeof token === "object" && "op" in token && commandSeparators.has(token.op)) {
+			if (current.length) processCommand(current, patterns)
+			current = []
+		} else {
+			current.push(String(token))
+		}
+	}
 
-		// Only add if it contains at least one letter or is a valid path
-		if (/[a-zA-Z]/.test(mainCmd) || mainCmd.includes("/")) {
-			patterns.add(mainCmd)
+	if (current.length) processCommand(current, patterns)
 
-			// Build up patterns progressively (e.g., "npm", "npm install", "npm install express")
-			// Stop at flags or special characters
-			const stopPatterns = [/^-/, /[\\/.~]/]
+	return patterns
+}
 
-			for (let i = 1; i < tokens.length; i++) {
-				const token = tokens[i]
+export function extractCommandPatterns(command: string): string[] {
+	if (!command?.trim()) return []
 
-				// Stop if we hit a flag or special character
-				if (stopPatterns.some((re) => re.test(token))) break
+	// First, check if the command contains subshells and remove them
+	// This is important for security - we don't want to extract patterns from subshell contents
+	const cleanedCommand = command
+		.replace(/\$\([^)]*\)/g, "") // Remove $() subshells
+		.replace(/`[^`]*`/g, "") // Remove backtick subshells
 
-				// Build the pattern up to this point
-				const pattern = tokens.slice(0, i + 1).join(" ")
-				patterns.add(pattern)
-			}
-		}
-	}
+	const patterns = extractPatterns(cleanedCommand)
 
 	return Array.from(patterns).sort()
 }