Significantly simplify this

Author: joshsymonds

ARCHITECTURE.md

@@ -1,15 +1,25 @@
 # claude-code-ntfy
 
-A transparent wrapper for Claude Code that monitors output and sends notifications via [ntfy.sh](https://ntfy.sh) based on configurable patterns and user activity.
+A transparent wrapper for Claude Code that sends a notification when Claude needs your attention.
 
 ## Features
 
-- = Smart notifications based on output patterns
-- >� Transparent wrapping - preserves all Claude Code functionality
-- =� User idle detection to avoid interruptions
-- <� Configurable regex patterns for triggers
-- =� Rate limiting and notification batching
-- =' Cross-platform support (Linux/macOS)
+- 🔔 Single notification when Claude needs attention
+- 🔄 Transparent wrapping - preserves all Claude Code functionality
+- 💤 Intelligent inactivity detection
+- 🖥️ Cross-platform support (Linux/macOS)
+
+### Intelligent Inactivity Detection
+
+The backstop timer provides smart notifications when Claude might need your attention:
+
+- **While Claude is outputting**: Timer is continuously reset
+- **When Claude stops**: A 30-second countdown begins
+- **If you start typing**: Timer is permanently disabled
+- **If Claude sent a bell**: Timer is disabled (you're already notified)
+- **After 30 seconds of inactivity**: ONE notification is sent
+
+This ensures you're notified when Claude needs input, but not when you're actively working.
 
 ## Installation
 
@@ -76,7 +86,7 @@ let
   claude-code-ntfy = pkgs.callPackage (pkgs.fetchFromGitHub {
     owner = "Veraticus";
     repo = "claude-code-ntfy";
-    rev = "ba76a6ce3b0bce2b17e5b9d528b8f4f80ec93cf8";
+    rev = "main";
     sha256 = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
   } + "/default.nix") { };
 in
@@ -98,18 +108,7 @@ For user-level installation with configuration management:
     settings = {
       ntfy_topic = "my-claude-notifications";
       ntfy_server = "https://ntfy.sh";
-      idle_timeout = "2m";
-      patterns = [
-        {
-          name = "error";
-          regex = "(?i)(error|failed|exception)";
-          enabled = true;
-        }
-      ];
-      rate_limit = {
-        window = "1m";
-        max_messages = 5;
-      };
+      backstop_timeout = "30s";
     };
   };
 }
@@ -143,33 +142,18 @@ Configure via environment variables:
 
 - `CLAUDE_NOTIFY_TOPIC` - Ntfy topic for notifications (required)
 - `CLAUDE_NOTIFY_SERVER` - Ntfy server URL (default: https://ntfy.sh)
-- `CLAUDE_NOTIFY_IDLE_TIMEOUT` - User idle timeout (default: 2m)
+- `CLAUDE_NOTIFY_BACKSTOP_TIMEOUT` - Inactivity timeout (default: 30s)
 - `CLAUDE_NOTIFY_QUIET` - Disable notifications (true/false)
-- `CLAUDE_NOTIFY_FORCE` - Force notifications even when active (true/false)
+- `CLAUDE_NOTIFY_CLAUDE_PATH` - Path to the real claude binary
 
 Or use a config file at `~/.config/claude-code-ntfy/config.yaml`:
 
 ```yaml
 ntfy_topic: "my-claude-notifications"
 ntfy_server: "https://ntfy.sh"
-idle_timeout: "2m"
-
-patterns:
-  - name: "bell"
-    regex: '\x07'
-    enabled: true
-  - name: "question"
-    regex: '\?\s*$'
-    enabled: true
-  - name: "error"
-    regex: '(?i)(error|failed|exception)'
-    enabled: true
-
-rate_limit:
-  window: "1m"
-  max_messages: 5
-
-batch_window: "5s"
+backstop_timeout: "30s"
+quiet: false
+claude_path: "/usr/local/bin/claude"
 ```
 
 ## Development

README.md

@@ -3,30 +3,21 @@ package main
 import (
 	"fmt"
 	"os"
-	"time"
 
 	"github.com/Veraticus/claude-code-ntfy/pkg/config"
-	"github.com/Veraticus/claude-code-ntfy/pkg/idle"
 	"github.com/Veraticus/claude-code-ntfy/pkg/interfaces"
 	"github.com/Veraticus/claude-code-ntfy/pkg/monitor"
 	"github.com/Veraticus/claude-code-ntfy/pkg/notification"
 	"github.com/Veraticus/claude-code-ntfy/pkg/process"
-	"github.com/Veraticus/claude-code-ntfy/pkg/status"
 )
 
 // Dependencies holds all the dependencies for the application
 type Dependencies struct {
-	Config              *config.Config
-	IdleDetector        interfaces.IdleDetector
-	Notifier            notification.Notifier
-	RateLimiter         interfaces.RateLimiter
-	PatternMatcher      monitor.PatternMatcher
-	NotificationManager *notification.Manager
-	OutputMonitor       interfaces.DataHandler
-	ProcessManager      *process.Manager
-	StatusIndicator     *status.Indicator
-	StatusReporter      *status.Reporter
-	stopChan            chan struct{}
+	Config         *config.Config
+	Notifier       notification.Notifier
+	OutputMonitor  interfaces.DataHandler
+	ProcessManager *process.Manager
+	stopChan       chan struct{}
 }
 
 // NewDependencies creates all dependencies with the given configuration
@@ -36,59 +27,32 @@ func NewDependencies(cfg *config.Config) (*Dependencies, error) {
 		stopChan: make(chan struct{}),
 	}
 
-	// Create idle detector
-	deps.IdleDetector = idle.NewIdleDetector()
-
-	// Create status indicator (only enabled if we have a terminal and notifications are enabled)
-	// The indicator will only flash briefly when notifications are sent
-	isTerminal := isatty(os.Stderr.Fd())
-	statusEnabled := isTerminal && !cfg.Quiet && cfg.NtfyTopic != ""
-	deps.StatusIndicator = status.NewIndicator(os.Stderr, statusEnabled)
-	deps.StatusReporter = status.NewReporter(deps.StatusIndicator)
-
-	// Start auto-refresh to keep the indicator visible despite Claude's screen clears
-	deps.StatusIndicator.StartAutoRefresh(deps.stopChan)
-
-	// Create pattern matcher and output monitor first (needed for terminal title)
-	deps.PatternMatcher = monitor.NewSimplePatternMatcher(cfg.Patterns)
-	outputMonitor := monitor.NewOutputMonitor(cfg, deps.PatternMatcher, deps.IdleDetector, nil) // nil notifier for now
-	deps.OutputMonitor = outputMonitor
-
 	// Create notification components
 	baseNotifier := notification.NewNtfyClient(cfg.NtfyServer, cfg.NtfyTopic)
 
-	// Wrap with context notifier
-	contextNotifier := notification.NewContextNotifier(baseNotifier, func() string {
-		return outputMonitor.GetTerminalTitle()
-	})
-
 	// Wrap with backstop notifier if configured
-	var finalNotifier notification.Notifier = contextNotifier
+	var finalNotifier notification.Notifier = baseNotifier
 	if cfg.BackstopTimeout > 0 {
-		finalNotifier = notification.NewBackstopNotifier(contextNotifier, cfg.BackstopTimeout)
+		finalNotifier = notification.NewBackstopNotifier(baseNotifier, cfg.BackstopTimeout)
 	}
 	deps.Notifier = finalNotifier
 
-	deps.RateLimiter = notification.NewTokenBucketRateLimiter(cfg.RateLimit.MaxMessages, cfg.RateLimit.Window)
-	deps.NotificationManager = notification.NewManager(cfg, deps.Notifier, deps.RateLimiter)
-
-	// Connect status reporter to notification manager
-	deps.NotificationManager.SetStatusReporter(deps.StatusReporter)
-
-	// Now set the notification manager on the output monitor
-	outputMonitor.SetNotifier(deps.NotificationManager)
+	// Create output monitor with the notifier
+	outputMonitor := monitor.NewOutputMonitor(cfg, deps.Notifier)
+	deps.OutputMonitor = outputMonitor
 
-	// Connect status indicator to output monitor for screen clear detection
-	if statusEnabled {
-		outputMonitor.SetScreenEventHandler(deps.StatusIndicator)
-		// Enable focus reporting display if configured
-		if cfg.EnableFocusDetection {
-			deps.StatusIndicator.SetFocusReportingEnabled(true)
+	// Create input handler that disables backstop timer
+	inputHandler := func() {
+		if backstopNotifier, ok := deps.Notifier.(*notification.BackstopNotifier); ok {
+			backstopNotifier.DisableBackstopTimer()
+			if os.Getenv("CLAUDE_NOTIFY_DEBUG") == "true" {
+				fmt.Fprintf(os.Stderr, "claude-code-ntfy: user input detected, disabling backstop timer\n")
+			}
 		}
 	}
 
 	// Create process manager
-	deps.ProcessManager = process.NewManager(cfg, deps.OutputMonitor)
+	deps.ProcessManager = process.NewManager(cfg, deps.OutputMonitor, inputHandler)
 
 	return deps, nil
 }
@@ -106,20 +70,11 @@ func (d *Dependencies) Close() {
 		d.stopChan = nil
 	}
 
-	// Clean up status indicator
-	if d.StatusIndicator != nil {
-		_ = d.StatusIndicator.Clear() // Best effort
-	}
-
 	// Close notifiers
 	// First try to close as backstop notifier
 	if backstopNotifier, ok := d.Notifier.(*notification.BackstopNotifier); ok {
 		_ = backstopNotifier.Close()
 	}
-
-	if d.NotificationManager != nil {
-		_ = d.NotificationManager.Close()
-	}
 }
 
 // Application represents the main application
@@ -136,23 +91,7 @@ func NewApplication(deps *Dependencies) *Application {
 
 // Run starts the application with the given command and arguments
 func (a *Application) Run(command string, args []string) error {
-	// Send startup notification if configured
-	if a.deps.Config.StartupNotify && !a.deps.Config.Quiet && a.deps.NotificationManager != nil {
-		pwd, _ := os.Getwd()
-		startupNotification := notification.Notification{
-			Title:   "Claude Code Session Started",
-			Message: fmt.Sprintf("Working directory: %s", pwd),
-			Time:    time.Now(),
-			Pattern: "startup",
-		}
-		_ = a.deps.NotificationManager.Send(startupNotification)
-
-		// After sending startup notification, update the startup time in output monitor
-		// to suppress subsequent notifications for StartupGracePeriod
-		if om, ok := a.deps.OutputMonitor.(*monitor.OutputMonitor); ok {
-			om.ResetStartTime()
-		}
-	}
+	// No startup notification - we only notify when Claude needs attention
 
 	if err := a.deps.ProcessManager.Start(command, args); err != nil {
 		return err