feat: handle pipelines with | head/tail and add MCP-aware suggestions

Pipelines ending in | head -n N or | tail -n N are now recognized and
mapped to the appropriate aifr limit parameter per command:
  - cat file | head -n N  →  aifr read --lines=1:N file
  - git log | head -n N   →  aifr log --max-count=N
  - grep pat . | head -N  →  aifr search --max-matches=N pat .
  - find/ls | head -N     →  --limit=N

Suggestions now carry MCP tool metadata (tool name + args). When --mcp
is set or an aifr MCP server is detected in .mcp.json / $AIFR_MCP,
the deny reason references the MCP tool call instead of a CLI command.

https://claude.ai/code/session_017inmawi6PUgMy9zSu6EXKv

Author: claude

cmd/aifr/cmd_hook_checkcommand.go

@@ -11,6 +11,8 @@ import (
 	"go.pennock.tech/aifr/internal/hookcmd"
 )
 
+var checkCommandMCP bool
+
 var checkCommandCmd = &cobra.Command{
 	Use:   "check-command",
 	Short: "Suggest aifr alternatives for Bash tool calls",
@@ -21,6 +23,12 @@ the Bash call and suggesting the aifr alternative.
 If the command is not something aifr handles, exits silently (exit 0,
 no output) so the Bash call continues through normal permission evaluation.
 
+Pipelines ending in | head -n N or | tail -n N are recognized and mapped
+to the appropriate aifr limit parameter (--max-count, --limit, --lines, etc.).
+
+When --mcp is set, or when an aifr MCP server is detected in .mcp.json,
+suggestions reference MCP tool calls instead of CLI sub-commands.
+
 Recognized commands: cat, head, tail, grep/rg, find, ls, wc, stat,
 diff, sed -n, sha256sum/md5sum, hexdump/xxd, git log, git diff.
 
@@ -48,7 +56,7 @@ Usage in Claude Code settings:
 			return err
 		}
 
-		result, err := hookcmd.CheckCommand(input)
+		result, err := hookcmd.CheckCommand(input, checkCommandMCP)
 		if err != nil {
 			return err
 		}
@@ -63,5 +71,7 @@ Usage in Claude Code settings:
 }
 
 func init() {
+	checkCommandCmd.Flags().BoolVar(&checkCommandMCP, "mcp", false,
+		"suggest MCP tool calls (auto-detected from .mcp.json and $AIFR_MCP if not set)")
 	hookCmd.AddCommand(checkCommandCmd)
 }

internal/hookcmd/hookcmd.go

@@ -1,11 +1,15 @@
 // Copyright 2026 — see LICENSE file for terms.
 package hookcmd
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"fmt"
+)
 
 // HookInput is the JSON payload received from a Claude Code hook on stdin.
 type HookInput struct {
 	SessionID     string          `json:"session_id"`
+	CWD           string          `json:"cwd"`
 	ToolName      string          `json:"tool_name"`
 	ToolInput     json.RawMessage `json:"tool_input"`
 	HookEventName string          `json:"hook_event_name"`
@@ -30,7 +34,11 @@ type HookDecision struct {
 
 // CheckCommand parses a PreToolUse hook payload and returns a hook output
 // denying the command with an aifr suggestion, or nil if no suggestion applies.
-func CheckCommand(input []byte) (*HookOutput, error) {
+//
+// When forceMCP is true, suggestions always reference MCP tool calls.
+// Otherwise, MCP availability is auto-detected from the working directory's
+// .mcp.json and the AIFR_MCP environment variable.
+func CheckCommand(input []byte, forceMCP bool) (*HookOutput, error) {
 	var hi HookInput
 	if err := json.Unmarshal(input, &hi); err != nil {
 		return nil, err
@@ -50,13 +58,33 @@ func CheckCommand(input []byte) (*HookOutput, error) {
 		return nil, nil
 	}
 
+	mcpMode := forceMCP || detectMCPAvailable(hi.CWD)
+
+	var reason string
+	if mcpMode {
+		reason = formatMCPReason(suggestion)
+	} else {
+		reason = formatCLIReason(suggestion)
+	}
+
 	return &HookOutput{
 		HookSpecificOutput: &HookDecision{
 			HookEventName: "PreToolUse",
 			Decision:      "deny",
-			Reason: "This " + suggestion.Original +
-				" invocation can be handled by aifr with access controls. Use: " +
-				suggestion.AifrCommand,
+			Reason:        reason,
 		},
 	}, nil
 }
+
+func formatCLIReason(s *Suggestion) string {
+	return "This " + s.Original +
+		" invocation can be handled by aifr with access controls. Use: " +
+		s.AifrCommand
+}
+
+func formatMCPReason(s *Suggestion) string {
+	argsJSON, _ := json.Marshal(s.ToolArgs)
+	return fmt.Sprintf(
+		"This %s invocation can be handled by aifr with access controls. Use the %s tool: %s",
+		s.Original, s.ToolName, string(argsJSON))
+}

internal/hookcmd/hookcmd_test.go

@@ -9,12 +9,13 @@ import (
 func TestCheckCommand_BashWithSuggestion(t *testing.T) {
 	input := `{
 		"session_id": "test-session",
+		"cwd": "/tmp/nonexistent",
 		"tool_name": "Bash",
 		"tool_input": {"command": "cat main.go"},
 		"hook_event_name": "PreToolUse"
 	}`
 
-	result, err := CheckCommand([]byte(input))
+	result, err := CheckCommand([]byte(input), false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -35,12 +36,13 @@ func TestCheckCommand_BashWithSuggestion(t *testing.T) {
 func TestCheckCommand_BashNoSuggestion(t *testing.T) {
 	input := `{
 		"session_id": "test-session",
+		"cwd": "/tmp/nonexistent",
 		"tool_name": "Bash",
 		"tool_input": {"command": "go test ./..."},
 		"hook_event_name": "PreToolUse"
 	}`
 
-	result, err := CheckCommand([]byte(input))
+	result, err := CheckCommand([]byte(input), false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -52,12 +54,13 @@ func TestCheckCommand_BashNoSuggestion(t *testing.T) {
 func TestCheckCommand_NonBashTool(t *testing.T) {
 	input := `{
 		"session_id": "test-session",
+		"cwd": "/tmp/nonexistent",
 		"tool_name": "Read",
 		"tool_input": {"file_path": "/tmp/test.go"},
 		"hook_event_name": "PreToolUse"
 	}`
 
-	result, err := CheckCommand([]byte(input))
+	result, err := CheckCommand([]byte(input), false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -67,43 +70,52 @@ func TestCheckCommand_NonBashTool(t *testing.T) {
 }
 
 func TestCheckCommand_InvalidJSON(t *testing.T) {
-	_, err := CheckCommand([]byte("not json"))
+	_, err := CheckCommand([]byte("not json"), false)
 	if err == nil {
 		t.Error("expected error for invalid JSON")
 	}
 }
 
-// TestCheckCommand_PipelinePassthrough is an end-to-end wiring test verifying
-// that a command pipeline (containing shell operators) passes through
-// CheckCommand without a suggestion. The full scope of complex pipeline
-// detection is covered in suggest_test.go via AnalyzeCommand tests.
-func TestCheckCommand_PipelinePassthrough(t *testing.T) {
+// TestCheckCommand_PipelineSuggestion is an end-to-end wiring test verifying
+// that a command pipeline with a recognized | head tail produces a suggestion
+// with the appropriate per-command limit parameter. The full scope of pipeline
+// and complex command analysis is covered in suggest_test.go.
+func TestCheckCommand_PipelineSuggestion(t *testing.T) {
 	input := `{
 		"session_id": "test-session",
+		"cwd": "/tmp/nonexistent",
 		"tool_name": "Bash",
 		"tool_input": {"command": "git log --oneline | head -n 10"},
 		"hook_event_name": "PreToolUse"
 	}`
 
-	result, err := CheckCommand([]byte(input))
+	result, err := CheckCommand([]byte(input), false)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if result != nil {
-		t.Errorf("expected nil for pipeline command, got result with decision %q",
-			result.HookSpecificOutput.Decision)
+	if result == nil {
+		t.Fatal("expected suggestion for pipeline command, got nil")
+	}
+	if result.HookSpecificOutput.Decision != "deny" {
+		t.Errorf("expected deny, got %q", result.HookSpecificOutput.Decision)
+	}
+	// Verify the reason mentions the aifr log command with --max-count.
+	reason := result.HookSpecificOutput.Reason
+	if reason == "" {
+		t.Error("expected non-empty reason")
 	}
 }
 
 func TestCheckCommand_OutputFormat(t *testing.T) {
 	input := `{
 		"session_id": "s1",
+		"cwd": "/tmp/nonexistent",
 		"tool_name": "Bash",
 		"tool_input": {"command": "head -50 README.md"},
 		"hook_event_name": "PreToolUse"
 	}`
 
-	result, err := CheckCommand([]byte(input))
+	result, err := CheckCommand([]byte(input), false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -137,3 +149,44 @@ func TestCheckCommand_OutputFormat(t *testing.T) {
 		t.Error("expected non-empty reason")
 	}
 }
+
+func TestCheckCommand_MCPMode(t *testing.T) {
+	input := `{
+		"session_id": "test-session",
+		"cwd": "/tmp/nonexistent",
+		"tool_name": "Bash",
+		"tool_input": {"command": "cat main.go"},
+		"hook_event_name": "PreToolUse"
+	}`
+
+	// CLI mode (forceMCP=false, no .mcp.json in /tmp/nonexistent)
+	cliResult, err := CheckCommand([]byte(input), false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if cliResult == nil {
+		t.Fatal("expected result")
+	}
+	cliReason := cliResult.HookSpecificOutput.Reason
+	if cliReason == "" {
+		t.Fatal("expected non-empty CLI reason")
+	}
+
+	// MCP mode (forceMCP=true)
+	mcpResult, err := CheckCommand([]byte(input), true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if mcpResult == nil {
+		t.Fatal("expected result")
+	}
+	mcpReason := mcpResult.HookSpecificOutput.Reason
+	if mcpReason == "" {
+		t.Fatal("expected non-empty MCP reason")
+	}
+
+	// CLI reason should reference the CLI command.
+	if cliReason == mcpReason {
+		t.Error("CLI and MCP reasons should differ")
+	}
+}

internal/hookcmd/mcpdetect.go

@@ -0,0 +1,52 @@
+// Copyright 2026 — see LICENSE file for terms.
+package hookcmd
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+)
+
+// detectMCPAvailable checks whether an aifr MCP server is likely available
+// in the current Claude Code session.
+//
+// Detection order:
+//  1. AIFR_MCP environment variable (any non-empty value → true)
+//  2. .mcp.json in the given working directory
+func detectMCPAvailable(cwd string) bool {
+	if os.Getenv("AIFR_MCP") != "" {
+		return true
+	}
+	if cwd != "" {
+		if checkMCPConfig(filepath.Join(cwd, ".mcp.json")) {
+			return true
+		}
+	}
+	return false
+}
+
+// checkMCPConfig reads a .mcp.json file and returns true if it contains
+// an aifr MCP server entry (matched by server name or command basename).
+func checkMCPConfig(path string) bool {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return false
+	}
+	var config struct {
+		MCPServers map[string]struct {
+			Command string `json:"command"`
+		} `json:"mcpServers"`
+	}
+	if err := json.Unmarshal(data, &config); err != nil {
+		return false
+	}
+	for name, server := range config.MCPServers {
+		if name == "aifr" {
+			return true
+		}
+		if filepath.Base(server.Command) == "aifr" {
+			return true
+		}
+	}
+	return false
+}

internal/hookcmd/shellparse.go

@@ -101,6 +101,59 @@ func hasShellOperators(s string) bool {
 	return false
 }
 
+// splitPipeline splits a command by unquoted pipe operators.
+// It recognizes || as a logical OR (kept in the stage, not split) and only
+// splits on single | pipe operators.
+func splitPipeline(s string) []string {
+	var stages []string
+	var cur strings.Builder
+	inSingle := false
+	inDouble := false
+	escaped := false
+	runes := []rune(s)
+
+	for i := 0; i < len(runes); i++ {
+		r := runes[i]
+		if escaped {
+			cur.WriteRune(r)
+			escaped = false
+			continue
+		}
+		if r == '\\' && !inSingle {
+			cur.WriteRune(r)
+			escaped = true
+			continue
+		}
+		if r == '\'' && !inDouble {
+			inSingle = !inSingle
+			cur.WriteRune(r)
+			continue
+		}
+		if r == '"' && !inSingle {
+			inDouble = !inDouble
+			cur.WriteRune(r)
+			continue
+		}
+		if r == '|' && !inSingle && !inDouble {
+			// || is logical OR, not a pipe — keep in current stage.
+			if i+1 < len(runes) && runes[i+1] == '|' {
+				cur.WriteRune(r)
+				cur.WriteRune(runes[i+1])
+				i++
+				continue
+			}
+			stages = append(stages, cur.String())
+			cur.Reset()
+			continue
+		}
+		cur.WriteRune(r)
+	}
+	if cur.Len() > 0 {
+		stages = append(stages, cur.String())
+	}
+	return stages
+}
+
 // baseName returns the last path component of cmd (strips directory prefix).
 func baseName(cmd string) string {
 	if idx := strings.LastIndex(cmd, "/"); idx >= 0 {