Merge pull request #76 from syou6162/pre_commit

feat: commandアクションにoutput_format: text設定を追加

Author: syou6162

CLAUDE.md

@@ -297,6 +297,17 @@ SessionStart hooks **always exit with code 0**, even when:
 
 Errors are logged to stderr as warnings, but cchook continues to output JSON and exits successfully. This ensures Claude Code always receives a response.
 
+**Plain Text Output** (`output_format: text`):
+For commands that output plain text (not JSON), use `output_format: text` to treat the stdout as `additionalContext`:
+```yaml
+SessionStart:
+  - actions:
+      - type: command
+        command: "get-project-info.sh"  # Returns plain text, not JSON
+        output_format: text  # stdout treated as additionalContext
+```
+- Without `output_format: text`, non-JSON stdout causes `continue: false` (fail-safe)
+
 **Example**:
 ```yaml
 SessionStart:
@@ -433,6 +444,19 @@ PreToolUse hooks **always exit with code 0**. The `permissionDecision` field con
 
 Errors are logged to stderr as warnings, but cchook continues to output JSON and exits successfully. On errors, `permissionDecision` defaults to `"deny"` for safety.
 
+**Plain Text Output** (`output_format: text`):
+For commands that output plain text (not JSON), use `output_format: text` to treat the stdout as `permissionDecisionReason` with `permissionDecision: "allow"`:
+```yaml
+PreToolUse:
+  - matcher: "Bash"
+    actions:
+      - type: command
+        command: "shellcheck {.tool_input.command}"
+        output_format: text  # stdout treated as permissionDecisionReason, permissionDecision set to "allow"
+```
+- Non-zero exit code still causes fail-safe `permissionDecision: "deny"` behavior
+- Without `output_format: text`, non-JSON stdout causes `permissionDecision: "deny"` (fail-safe)
+
 **Example**:
 ```yaml
 PreToolUse:
@@ -641,6 +665,22 @@ After JSON migration:
 - Use `decision` field instead: omit for allow, `"block"` to prompt Claude
 - A stderr warning is emitted if `exit_status` is set (migration reminder)
 
+**Plain Text Output** (`output_format: text`):
+For commands that output plain text (not JSON), use `output_format: text` to treat the stdout as `additionalContext`:
+```yaml
+PostToolUse:
+  - matcher: "Write|Edit|MultiEdit"
+    conditions:
+      - type: file_extension
+        value: ".go"
+    actions:
+      - type: command
+        command: "gofmt -w {.tool_input.file_path}"
+        output_format: text  # stdout treated as additionalContext, not parsed as JSON
+```
+- Non-zero exit code still causes fail-safe `decision: "block"` behavior
+- Without `output_format: text`, non-JSON stdout causes `decision: "block"` (fail-safe)
+
 **Example**:
 ```yaml
 PostToolUse:
@@ -873,6 +913,17 @@ SessionEnd supports the `reason_is` condition to match session end reasons:
 - `"prompt_input_exit"`: User exited via prompt input
 - `"other"`: Other reasons
 
+**Plain Text Output** (`output_format: text`):
+For commands that output plain text (not JSON), use `output_format: text` to treat the stdout as `systemMessage`:
+```yaml
+SessionEnd:
+  - actions:
+      - type: command
+        command: "cleanup-session.sh"  # Returns plain text, not JSON
+        output_format: text  # stdout treated as systemMessage
+```
+- Without `output_format: text`, non-JSON stdout causes systemMessage set to error message
+
 **Example**:
 ```yaml
 SessionEnd:

README.md

@@ -149,6 +149,7 @@ PostToolUse:
     actions:
       - type: command
         command: "gofmt -w {.tool_input.file_path}"
+        output_format: text  # gofmt outputs plain text, not JSON
 
 # Guide users to use better alternatives
 PreToolUse:
@@ -241,6 +242,7 @@ PostToolUse:
     actions:
       - type: command
         command: "gofmt -w {.tool_input.file_path}"
+        output_format: text  # gofmt outputs plain text, not JSON
 
   - matcher: "Write|Edit"
     conditions:
@@ -249,6 +251,7 @@ PostToolUse:
     actions:
       - type: command
         command: "black {.tool_input.file_path}"
+        output_format: text  # black outputs plain text, not JSON
 ```
 
 Run pre-commit hooks automatically:
@@ -262,6 +265,7 @@ PostToolUse:
     actions:
       - type: command
         command: "pre-commit run --files {.tool_input.file_path}"
+        output_format: text  # pre-commit outputs plain text, not JSON
 ```
 
 Warn about sensitive file modifications:
@@ -631,6 +635,12 @@ All conditions return proper error messages for unknown condition types, ensurin
     - Solves issues with special characters (quotes, backslashes, newlines) in data
     - Safer than shell string interpolation for complex data
     - Example: `jq -r .tool_input.content` to extract content from JSON via stdin
+  - `output_format: text` (optional)
+    - Treat command's stdout as plain text instead of JSON
+    - Without this, non-JSON output causes fail-safe block/deny behavior
+    - Use for standard CLI tools like `gofmt`, `black`, `pre-commit run` that output plain text
+    - Non-zero exit code still triggers fail-safe behavior regardless of this setting
+    - Supported events: PreToolUse, PostToolUse, SessionStart, SessionEnd
 - `output`
   - Print message
   - Default `exit_status`:
@@ -702,8 +712,10 @@ PostToolUse:
     actions:
       - type: command
         command: "ruff format {.tool_input.file_path}"
+        output_format: text
       - type: command
         command: "ruff check --fix {.tool_input.file_path}"
+        output_format: text
 ```
 
 ### Multi-Step Workflows
@@ -717,8 +729,10 @@ PostToolUse:
     actions:
       - type: command
         command: "gofmt -w {.tool_input.file_path}"
+        output_format: text  # gofmt outputs plain text, not JSON
       - type: command
         command: "go vet {.tool_input.file_path}"
+        output_format: text  # go vet outputs plain text, not JSON
       - type: output
         message: "✅ Go file formatted and vetted: {.tool_input.file_path}"
 ```

executor.go

@@ -698,6 +698,15 @@ func (e *ActionExecutor) ExecuteSessionStartAction(action Action, input *Session
 			}, nil
 		}
 
+		// output_format: text - treat command output as plain text (no JSON parsing)
+		if action.OutputFormat != nil && *action.OutputFormat == "text" {
+			return &ActionOutput{
+				Continue:          true,
+				HookEventName:     "SessionStart",
+				AdditionalContext: strings.TrimSpace(stdout),
+			}, nil
+		}
+
 		// Parse JSON output
 		var cmdOutput SessionStartOutput
 		if err := json.Unmarshal([]byte(stdout), &cmdOutput); err != nil {
@@ -966,6 +975,14 @@ func (e *ActionExecutor) ExecuteSessionEndAction(action Action, input *SessionEn
 			}, nil
 		}
 
+		// output_format: text - treat command output as plain text (no JSON parsing)
+		if action.OutputFormat != nil && *action.OutputFormat == "text" {
+			return &ActionOutput{
+				Continue:      true,
+				SystemMessage: strings.TrimSpace(stdout),
+			}, nil
+		}
+
 		// Parse JSON output (SessionEndOutput has Common JSON Fields only)
 		var cmdOutput SessionEndOutput
 		if err := json.Unmarshal([]byte(stdout), &cmdOutput); err != nil {

executor_test.go

@@ -2841,3 +2841,148 @@ func TestExecuteSubagentStartAction_TypeCommand(t *testing.T) {
 		})
 	}
 }
+
+func TestExecuteSessionStartAction_OutputFormatText(t *testing.T) {
+	outputFormatText := "text"
+	tests := []struct {
+		name              string
+		stdout            string
+		stderr            string
+		exitCode          int
+		wantContinue      bool
+		wantHookEventName string
+		wantAdditionalCtx string
+	}{
+		{
+			name:              "output_format: text + text output -> additionalContext with HookEventName set",
+			stdout:            "Project: myapp\nBranch: main\n",
+			exitCode:          0,
+			wantContinue:      true,
+			wantHookEventName: "SessionStart",
+			wantAdditionalCtx: "Project: myapp\nBranch: main",
+		},
+		{
+			name:              "output_format: text + empty output -> continue=true, no additionalContext",
+			stdout:            "",
+			exitCode:          0,
+			wantContinue:      true,
+			wantHookEventName: "SessionStart",
+			wantAdditionalCtx: "",
+		},
+		{
+			name:              "output_format: text + non-zero exit code -> existing fail-safe behavior",
+			stdout:            "",
+			stderr:            "command error",
+			exitCode:          1,
+			wantContinue:      false,
+			wantHookEventName: "", // non-zero exit uses existing behavior (HookEventName not set)
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			action := Action{
+				Type:         "command",
+				Command:      "get-project-info.sh",
+				OutputFormat: &outputFormatText,
+			}
+			input := &SessionStartInput{}
+			runner := &stubRunnerWithOutput{
+				stdout:   tt.stdout,
+				stderr:   tt.stderr,
+				exitCode: tt.exitCode,
+			}
+			executor := NewActionExecutor(runner)
+			output, err := executor.ExecuteSessionStartAction(action, input, map[string]any{})
+
+			if err != nil {
+				t.Fatalf("Expected no error, got: %v", err)
+			}
+
+			if output == nil {
+				t.Fatal("Expected non-nil output, got nil")
+			}
+
+			if output.Continue != tt.wantContinue {
+				t.Errorf("Continue = %v, want %v", output.Continue, tt.wantContinue)
+			}
+
+			if output.HookEventName != tt.wantHookEventName {
+				t.Errorf("HookEventName = %q, want %q", output.HookEventName, tt.wantHookEventName)
+			}
+
+			if output.AdditionalContext != tt.wantAdditionalCtx {
+				t.Errorf("AdditionalContext = %q, want %q", output.AdditionalContext, tt.wantAdditionalCtx)
+			}
+		})
+	}
+}
+
+func TestExecuteSessionEndAction_OutputFormatText(t *testing.T) {
+	outputFormatText := "text"
+	tests := []struct {
+		name              string
+		stdout            string
+		stderr            string
+		exitCode          int
+		wantContinue      bool
+		wantSystemMessage string
+	}{
+		{
+			name:              "output_format: text + text output -> systemMessage with continue=true",
+			stdout:            "Cleanup completed.\nTemp files removed.\n",
+			exitCode:          0,
+			wantContinue:      true,
+			wantSystemMessage: "Cleanup completed.\nTemp files removed.",
+		},
+		{
+			name:              "output_format: text + empty output -> continue=true, no systemMessage",
+			stdout:            "",
+			exitCode:          0,
+			wantContinue:      true,
+			wantSystemMessage: "",
+		},
+		{
+			name:              "output_format: text + non-zero exit code -> existing fail-safe behavior",
+			stdout:            "",
+			stderr:            "command error",
+			exitCode:          1,
+			wantContinue:      true,
+			wantSystemMessage: "Command failed with exit code 1: command error",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			action := Action{
+				Type:         "command",
+				Command:      "cleanup.sh",
+				OutputFormat: &outputFormatText,
+			}
+			input := &SessionEndInput{}
+			runner := &stubRunnerWithOutput{
+				stdout:   tt.stdout,
+				stderr:   tt.stderr,
+				exitCode: tt.exitCode,
+			}
+			executor := NewActionExecutor(runner)
+			output, err := executor.ExecuteSessionEndAction(action, input, map[string]any{})
+
+			if err != nil {
+				t.Fatalf("Expected no error, got: %v", err)
+			}
+
+			if output == nil {
+				t.Fatal("Expected non-nil output, got nil")
+			}
+
+			if output.Continue != tt.wantContinue {
+				t.Errorf("Continue = %v, want %v", output.Continue, tt.wantContinue)
+			}
+
+			if output.SystemMessage != tt.wantSystemMessage {
+				t.Errorf("SystemMessage = %q, want %q", output.SystemMessage, tt.wantSystemMessage)
+			}
+		})
+	}
+}

executor_tool_permission.go

@@ -37,6 +37,16 @@ func (e *ActionExecutor) ExecutePreToolUseAction(action Action, input *PreToolUs
 			return nil, nil
 		}
 
+		// output_format: text - treat command output as plain text (no JSON parsing)
+		if action.OutputFormat != nil && *action.OutputFormat == "text" {
+			return &ActionOutput{
+				Continue:                 true,
+				PermissionDecision:       "allow",
+				PermissionDecisionReason: strings.TrimSpace(stdout),
+				HookEventName:            "PreToolUse",
+			}, nil
+		}
+
 		// Parse JSON output
 		var cmdOutput PreToolUseOutput
 		if err := json.Unmarshal([]byte(stdout), &cmdOutput); err != nil {
@@ -244,6 +254,16 @@ func (e *ActionExecutor) ExecutePostToolUseAction(action Action, input *PostTool
 			}, nil
 		}
 
+		// output_format: text - treat command output as plain text (no JSON parsing)
+		if action.OutputFormat != nil && *action.OutputFormat == "text" {
+			return &ActionOutput{
+				Continue:          true,
+				Decision:          "", // Allow tool result
+				AdditionalContext: strings.TrimSpace(stdout),
+				HookEventName:     "PostToolUse",
+			}, nil
+		}
+
 		// Parse JSON output (PostToolUseOutput with hookSpecificOutput)
 		var cmdOutput PostToolUseOutput
 		if err := json.Unmarshal([]byte(stdout), &cmdOutput); err != nil {