refactor(R2d.135): carve internal/api/aicrossrule subpackage

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: atulmgupta

internal/api/aicrossrule/doc.go

@@ -0,0 +1,4 @@
+// Package aicrossrule contains the AI cross-rule conflict detection handler.
+//
+// Layer: handler
+package aicrossrule

…al/api/ai_cross_rule_conflict_handler.go internal/api/aicrossrule/handler.gointernal/api/ai_cross_rule_conflict_handler.go renamed to internal/api/aicrossrule/handler.go internal/api/ai_cross_rule_conflict_handler.go renamed to internal/api/aicrossrule/handler.go

@@ -1,4 +1,4 @@
-package api
+package aicrossrule
 
 // Phase-50 / 0036 — A3 Cross-rule conflict detection.
 //
@@ -73,6 +73,7 @@ import (
 	"github.com/ev-dev-labs/teslasync/internal/ai/stream"
 	"github.com/ev-dev-labs/teslasync/internal/ai/tools"
 	"github.com/ev-dev-labs/teslasync/internal/ai/tools/diagnostic"
+	"github.com/ev-dev-labs/teslasync/internal/api/httpx"
 	tsauth "github.com/ev-dev-labs/teslasync/internal/auth"
 	dbalert "github.com/ev-dev-labs/teslasync/internal/database/alert"
 )
@@ -122,40 +123,40 @@ type aiCrossRuleConflictRequest struct {
 	Limit *int `json:"limit,omitempty"`
 }
 
-// AICrossRuleConflictHandler is the HTTP handler for
+// Handler is the HTTP handler for
 // POST /api/v1/ai/alerts/rules/conflicts.
 //
 // Stateless beyond its constructor inputs; safe for concurrent
 // use across requests. Construction is in router.go so the
 // dispatcher's tool registry + provider registry are wired
 // once at boot.
-type AICrossRuleConflictHandler struct {
+type Handler struct {
 	registry   *provider.Registry
 	tools      *tools.Registry
 	strategy   strategy.Strategy
 	headerName string
 	maxIters   int
 }
 
-// NewAICrossRuleConflictHandler constructs the handler. All
+// NewHandler constructs the handler. All
 // non-pointer arguments are required; the constructor panics
 // on a nil so the wiring bug surfaces at boot, not at first
 // request.
-func NewAICrossRuleConflictHandler(
+func NewHandler(
 	registry *provider.Registry,
 	toolReg *tools.Registry,
 	strat strategy.Strategy,
 	headerName string,
-) *AICrossRuleConflictHandler {
+) *Handler {
 	switch {
 	case registry == nil:
-		panic("api: NewAICrossRuleConflictHandler: nil provider.Registry")
+		panic("aicrossrule: NewHandler: nil provider.Registry")
 	case toolReg == nil:
-		panic("api: NewAICrossRuleConflictHandler: nil tools.Registry")
+		panic("aicrossrule: NewHandler: nil tools.Registry")
 	case strat == nil:
-		panic("api: NewAICrossRuleConflictHandler: nil strategy.Strategy")
+		panic("aicrossrule: NewHandler: nil strategy.Strategy")
 	}
-	return &AICrossRuleConflictHandler{
+	return &Handler{
 		registry:   registry,
 		tools:      toolReg,
 		strategy:   strat,
@@ -217,7 +218,7 @@ func parseCrossRuleConflictBody(w http.ResponseWriter, r *http.Request) (*aiCros
 // path either writes a structured frame onto the SSE stream
 // (when the writer has been opened) or a plain JSON 4xx/5xx
 // (before it has).
-func (h *AICrossRuleConflictHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	body, ok := parseCrossRuleConflictBody(w, r)
 	if !ok {
 		return
@@ -303,9 +304,17 @@ func (h *AICrossRuleConflictHandler) ServeHTTP(w http.ResponseWriter, r *http.Re
 	}
 }
 
-// Compile-time assertion: AICrossRuleConflictHandler satisfies
+// Compile-time assertion: Handler satisfies
 // http.Handler.
-var _ http.Handler = (*AICrossRuleConflictHandler)(nil)
+var _ http.Handler = (*Handler)(nil)
+
+func writeError(w http.ResponseWriter, status int, msg string) {
+	httpx.WriteError(w, status, msg)
+}
+
+func denyAllConfirm(_ context.Context, _ dispatch.ConfirmRequest) (dispatch.ConfirmDecision, error) {
+	return dispatch.ConfirmDenied, nil
+}
 
 // ---------------------------------------------------------------------
 // Production wiring for the CrossRuleConflictSource port declared by
@@ -314,26 +323,26 @@ var _ http.Handler = (*AICrossRuleConflictHandler)(nil)
 // AIInboxCategorizationSource pattern from slice 0035.
 // ---------------------------------------------------------------------
 
-// AICrossRuleConflictSource is the production
+// Source is the production
 // diagnostic.CrossRuleConflictSource. It composes the canonical
 // AlertRuleRepo (read-only) so the AI projection is grounded
 // in the SAME alert_rules rows the deterministic AlertStudio
 // renders. No write path is invoked.
 //
 // The struct holds one narrow read interface; the constructor
 // panics on a nil so a wiring bug surfaces at boot.
-type AICrossRuleConflictSource struct {
+type Source struct {
 	rules *dbalert.AlertRuleRepo
 }
 
-// NewAICrossRuleConflictSource constructs the adapter. Panics
+// NewSource constructs the adapter. Panics
 // on a nil repo so a wiring mistake surfaces at boot rather
 // than as a nil-deref on first AI request.
-func NewAICrossRuleConflictSource(rules *dbalert.AlertRuleRepo) *AICrossRuleConflictSource {
+func NewSource(rules *dbalert.AlertRuleRepo) *Source {
 	if rules == nil {
-		panic("api: NewAICrossRuleConflictSource: nil *dbalert.AlertRuleRepo")
+		panic("aicrossrule: NewSource: nil *dbalert.AlertRuleRepo")
 	}
-	return &AICrossRuleConflictSource{rules: rules}
+	return &Source{rules: rules}
 }
 
 // LoadRules implements diagnostic.CrossRuleConflictSource. Reads the
@@ -348,7 +357,7 @@ func NewAICrossRuleConflictSource(rules *dbalert.AlertRuleRepo) *AICrossRuleConf
 //
 // The Limit field caps the returned slice so a runaway request
 // cannot blow past the canonical 500-row cap.
-func (a *AICrossRuleConflictSource) LoadRules(ctx context.Context, f diagnostic.CrossRuleConflictFilters) ([]*alertmodel.AlertRule, error) {
+func (a *Source) LoadRules(ctx context.Context, f diagnostic.CrossRuleConflictFilters) ([]*alertmodel.AlertRule, error) {
 	limit := f.Limit
 	if limit <= 0 || limit > aiCrossRuleConflictMaxLimit {
 		limit = aiCrossRuleConflictDefaultLimit

…i/ai_cross_rule_conflict_handler_test.go internal/api/aicrossrule/handler_test.gointernal/api/ai_cross_rule_conflict_handler_test.go renamed to internal/api/aicrossrule/handler_test.go internal/api/ai_cross_rule_conflict_handler_test.go renamed to internal/api/aicrossrule/handler_test.go

@@ -15,9 +15,10 @@
 // (`go run ./cmd/ai-eval --feature cross-rule-conflict-detection`);
 // duplicating that here would require a live database fixture.
 
-package api
+package aicrossrule
 
 import (
+	"context"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -28,6 +29,22 @@ import (
 	"github.com/ev-dev-labs/teslasync/internal/ai/guard"
 )
 
+type stubGuardSettings struct {
+	mode string
+	on   map[string]bool
+}
+
+func (s *stubGuardSettings) AIMode(_ context.Context) (string, error) {
+	if s.mode == "" {
+		return "off", nil
+	}
+	return s.mode, nil
+}
+
+func (s *stubGuardSettings) AIFeatureEnabled(_ context.Context, id string) (bool, error) {
+	return s.on[id], nil
+}
+
 // TestCrossRuleConflictAIOffHidesConflictPanel is the load-
 // bearing off-mode contract proof for slice 0036. It mounts
 // the AI cross-rule-conflict-detection route through the guard
@@ -157,13 +174,13 @@ func TestAICrossRuleConflictHandler_PanicsOnNilWiring(t *testing.T) {
 		name string
 		fn   func()
 	}{
-		{"all nil", func() { NewAICrossRuleConflictHandler(nil, nil, nil, "") }},
+		{"all nil", func() { NewHandler(nil, nil, nil, "") }},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			defer func() {
 				if r := recover(); r == nil {
-					t.Fatalf("NewAICrossRuleConflictHandler(%s) did not panic", tc.name)
+					t.Fatalf("NewHandler(%s) did not panic", tc.name)
 				}
 			}()
 			tc.fn()
@@ -177,10 +194,10 @@ func TestAICrossRuleConflictSource_PanicsOnNilWiring(t *testing.T) {
 	t.Parallel()
 	defer func() {
 		if r := recover(); r == nil {
-			t.Fatal("NewAICrossRuleConflictSource(nil) did not panic")
+			t.Fatal("NewSource(nil) did not panic")
 		}
 	}()
-	NewAICrossRuleConflictSource(nil)
+	NewSource(nil)
 }
 
 // TestAICrossRuleConflictHandler_BodyParser_AcceptsEmpty

internal/api/router.go

@@ -28,6 +28,7 @@ import (
 	aichatbot "github.com/ev-dev-labs/teslasync/internal/api/aichatbot"
 	aiclimate "github.com/ev-dev-labs/teslasync/internal/api/aiclimate"
 	aicostfcst "github.com/ev-dev-labs/teslasync/internal/api/aicostfcst"
+	aicrossrule "github.com/ev-dev-labs/teslasync/internal/api/aicrossrule"
 	aidigest "github.com/ev-dev-labs/teslasync/internal/api/aidigest"
 	aidrivecoach "github.com/ev-dev-labs/teslasync/internal/api/aidrivecoach"
 	aidrivesearch "github.com/ev-dev-labs/teslasync/internal/api/aidrivesearch"
@@ -1751,21 +1752,21 @@ func NewRouter(db *database.DB, teslaClient *tesla.Client, mqttClient *mqtt.Clie
 	// `query_alert_rules` + `detect_rule_conflicts` are
 	// registered on the process-wide tool registry so the
 	// dispatcher can resolve the strategy's allowedTools at
-	// boot. AICrossRuleConflictSource adapts the canonical
+	// boot. aicrossrule.Source adapts the canonical
 	// AlertRuleRepo so the LLM reads the SAME rows the manual
 	// AlertStudio path reads — no parallel write path; the
 	// LLM never persists. The pure-functional structural
 	// detector lives in internal/ai/tools/cross_rule_conflict.go
 	// (DetectRuleConflicts) and is exercised in unit tests
 	// without IO.
 	diagnostic.RegisterCrossRuleConflictDetectionTools(aiToolRegistry, diagnostic.CrossRuleConflictDetectionSources{
-		Source: NewAICrossRuleConflictSource(dbalert.NewAlertRuleRepo(db)),
+		Source: aicrossrule.NewSource(dbalert.NewAlertRuleRepo(db)),
 	})
 	// cross-rule-conflict-detection handler. One per process;
 	// stateless beyond constructor inputs. Must be constructed
 	// AFTER the tool registration above so the dispatcher can
 	// resolve the strategy's allowedTools at boot.
-	aiCrossRuleConflictHandler := NewAICrossRuleConflictHandler(
+	aiCrossRuleConflictHandler := aicrossrule.NewHandler(
 		aiRegistry,
 		aiToolRegistry,
 		crossruleconflictdetection.New(),