Merge pull request #67 from syou6162/pre_compact

feat: PreCompact JSON出力対応

Author: syou6162

CLAUDE.md

@@ -702,6 +702,68 @@ Notification:
         command: "get-task-status.sh"  # Returns JSON with additionalContext
 ```
 
+### PreCompact JSON Output
+
+PreCompact hooks support JSON output format for Claude Code integration. Actions can return structured output for pre-compaction processing:
+
+**Output Action** (type: `output`):
+```yaml
+PreCompact:
+  - matcher: "manual"  # optional: "manual" or "auto"
+    actions:
+      - type: output
+        message: "Pre-compaction processing message"
+```
+
+**Command Action** (type: `command`):
+Commands must output JSON with the following structure:
+```json
+{
+  "continue": true,
+  "stopReason": "Optional stop reason",
+  "suppressOutput": false,
+  "systemMessage": "Optional system message"
+}
+```
+
+**Important**: PreCompact uses **Common JSON Fields only**. Unlike other events, it has no `decision`, `reason`, or `hookSpecificOutput` fields. PreCompact is a pre-processing hook and **cannot block** compaction.
+
+**Matcher Support**:
+PreCompact hooks support a `matcher` field to filter by trigger type:
+- `"manual"`: Matches manual compaction triggers
+- `"auto"`: Matches automatic compaction triggers
+- Empty/omitted: Matches all triggers
+
+**Field Merging**:
+When multiple actions execute:
+- `continue`: Always `true` (compaction cannot be blocked)
+- `systemMessage`: Concatenated with newline separator
+- `stopReason` and `suppressOutput`: Last value wins
+
+**Exit Code Behavior**:
+PreCompact hooks **always exit with code 0**. The `continue` field is always `true` because compaction cannot be blocked.
+
+Errors are logged to stderr as warnings, but cchook continues to output JSON and exits successfully. This ensures pre-compaction processing completes even on errors.
+
+**Message Mapping**:
+Output action `message` field is mapped to `systemMessage` (shown to user, not to Claude). This maintains backward compatibility with the old stdout-based implementation.
+
+**Example**:
+```yaml
+PreCompact:
+  - matcher: "manual"
+    actions:
+      - type: output
+        message: "Manual compaction triggered - preparing context"
+  - matcher: "auto"
+    actions:
+      - type: command
+        command: "prepare-auto-compaction.sh"  # Returns JSON with systemMessage
+  - actions:
+      - type: output
+        message: "General pre-compaction cleanup"
+```
+
 ### SessionEnd JSON Output
 
 SessionEnd hooks support JSON output format for Claude Code integration. Actions can return structured output for session cleanup:

README.md

@@ -627,18 +627,18 @@ All conditions return proper error messages for unknown condition types, ensurin
   - Print message
   - Default `exit_status`:
     - 0 for SessionStart, UserPromptSubmit (non-blocking events)
-    - 2 for Notification, PreCompact
-  - Note: PreToolUse, Stop, PostToolUse, and SubagentStop use JSON output (exit_status ignored)
+    - 2 for Notification (legacy)
+  - Note: Most events use JSON output (exit_status ignored). See "JSON Output Events" below.
 
 ### Exit Status Control
 
-**JSON Output Events** (SessionStart, UserPromptSubmit, PreToolUse, Stop, SubagentStop, PostToolUse, SessionEnd):
+**JSON Output Events** (SessionStart, UserPromptSubmit, PreToolUse, Stop, SubagentStop, PostToolUse, PreCompact, SessionEnd, Notification):
 - Always exit with code 0
 - Control behavior via JSON fields (`decision`, `permissionDecision`, etc.)
 - Errors logged to stderr as warnings
 - See CLAUDE.md for detailed JSON output format
 
-**Legacy Exit Code Events** (Notification, PreCompact):
+**Legacy Exit Code Events** (Notification only):
 - 0
   - Success, allow execution, output to stdout
 - 2
@@ -653,6 +653,13 @@ All conditions return proper error messages for unknown condition types, ensurin
 - After JSON migration, use `decision` field: omit for allow, `"block"` for deny
 - `exit_status` field is ignored in JSON mode (stderr warning emitted)
 
+**Migration Note** (PreCompact):
+- Prior to JSON support, PreCompact used exit codes (default `exit_status: 2`)
+- After JSON migration, PreCompact uses Common JSON Fields only (no `decision` field)
+- PreCompact always returns `continue: true` (compaction cannot be blocked)
+- `exit_status` field is ignored in JSON mode (stderr warning emitted)
+- Matcher support added: `matcher: "manual"` or `"auto"` to filter by trigger type
+
 ### Template Syntax
 
 Access JSON data using `{.field}` syntax with full jq query support:

executor.go

@@ -466,17 +466,84 @@ func (e *ActionExecutor) ExecuteSubagentStopAction(action Action, input *Subagen
 
 // ExecutePreCompactAction executes an action for the PreCompact event.
 // Supports command execution and output actions.
-func (e *ActionExecutor) ExecutePreCompactAction(action Action, input *PreCompactInput, rawJSON interface{}) error {
+// ExecutePreCompactAction executes an action for the PreCompact event and returns ActionOutput.
+// PreCompact always returns continue=true (fail-safe: compaction cannot be blocked).
+// Errors are reported via systemMessage field, not by blocking execution.
+func (e *ActionExecutor) ExecutePreCompactAction(action Action, input *PreCompactInput, rawJSON interface{}) (*ActionOutput, error) {
 	switch action.Type {
 	case "command":
 		cmd := unifiedTemplateReplace(action.Command, rawJSON)
-		if err := e.runner.RunCommand(cmd, action.UseStdin, rawJSON); err != nil {
-			return err
+		stdout, stderr, exitCode, err := e.runner.RunCommandWithOutput(cmd, action.UseStdin, rawJSON)
+
+		// Command failed with non-zero exit code
+		if exitCode != 0 {
+			errMsg := fmt.Sprintf("Command failed with exit code %d: %s", exitCode, stderr)
+			if strings.TrimSpace(stderr) == "" && err != nil {
+				errMsg = fmt.Sprintf("Command failed with exit code %d: %v", exitCode, err)
+			}
+			fmt.Fprintf(os.Stderr, "Warning: %s\n", errMsg)
+			return &ActionOutput{
+				Continue:      true,
+				SystemMessage: errMsg,
+			}, nil
+		}
+
+		// Empty stdout - Allow compaction (validation-type CLI tools: silence = OK)
+		if strings.TrimSpace(stdout) == "" {
+			return &ActionOutput{
+				Continue: true,
+			}, nil
 		}
+
+		// Parse JSON output (PreCompactOutput has Common JSON Fields only)
+		var cmdOutput PreCompactOutput
+		if err := json.Unmarshal([]byte(stdout), &cmdOutput); err != nil {
+			errMsg := fmt.Sprintf("Command output is not valid JSON: %s", stdout)
+			fmt.Fprintf(os.Stderr, "Warning: %s\n", errMsg)
+			return &ActionOutput{
+				Continue:      true,
+				SystemMessage: errMsg,
+			}, nil
+		}
+
+		// Check for unsupported fields and log warnings to stderr
+		checkUnsupportedFieldsPreCompact(stdout)
+
+		// Build ActionOutput from parsed JSON
+		return &ActionOutput{
+			Continue:       true,
+			StopReason:     cmdOutput.StopReason,
+			SuppressOutput: cmdOutput.SuppressOutput,
+			SystemMessage:  cmdOutput.SystemMessage,
+		}, nil
+
 	case "output":
-		return handleOutput(action.Message, action.ExitStatus, rawJSON)
+		processedMessage := unifiedTemplateReplace(action.Message, rawJSON)
+
+		// Emit warning if exit_status is set (backward compatibility - no longer used)
+		if action.ExitStatus != nil {
+			fmt.Fprintf(os.Stderr, "Warning: exit_status field is ignored in PreCompact output actions (JSON output does not use exit codes)\n")
+		}
+
+		// Empty message is an error (fail-safe)
+		if strings.TrimSpace(processedMessage) == "" {
+			errMsg := "Empty message in PreCompact action"
+			fmt.Fprintf(os.Stderr, "Warning: %s\n", errMsg)
+			return &ActionOutput{
+				Continue:      true,
+				SystemMessage: errMsg,
+			}, nil
+		}
+
+		// Output action: message maps to systemMessage
+		return &ActionOutput{
+			Continue:      true,
+			SystemMessage: processedMessage,
+		}, nil
+
+	default:
+		return nil, fmt.Errorf("unknown action type: %s", action.Type)
 	}
-	return nil
 }
 
 // ExecuteSessionStartAction executes an action for the SessionStart event.
@@ -1241,6 +1308,28 @@ func checkUnsupportedFieldsSessionEnd(stdout string) {
 	}
 }
 
+//nolint:unused // Will be used in Step 3
+func checkUnsupportedFieldsPreCompact(stdout string) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(stdout), &data); err != nil {
+		return
+	}
+
+	supportedFields := map[string]bool{
+		"continue":       true,
+		"stopReason":     true,
+		"suppressOutput": true,
+		"systemMessage":  true,
+		// Note: decision, reason, hookSpecificOutput are NOT supported for PreCompact hooks
+	}
+
+	for field := range data {
+		if !supportedFields[field] {
+			fmt.Fprintf(os.Stderr, "Warning: Field '%s' is not supported for PreCompact hooks\n", field)
+		}
+	}
+}
+
 // checkUnsupportedFieldsNotification checks for unsupported fields in Notification JSON output
 // and logs warnings to stderr for any fields that are not in the supported list.
 func checkUnsupportedFieldsNotification(stdout string) {