refactor(R2d.146): carve internal/api/aimlanom subpackage

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

Author: atulmgupta

internal/api/aimlanom/doc.go

@@ -0,0 +1,4 @@
+// Package aimlanom provides the AI learned anomaly baseline HTTP handler.
+package aimlanom
+
+// Layer: handler

…al/api/ai_ml_anomaly_baseline_handler.go internal/api/aimlanom/handler.gointernal/api/ai_ml_anomaly_baseline_handler.go renamed to internal/api/aimlanom/handler.go internal/api/ai_ml_anomaly_baseline_handler.go renamed to internal/api/aimlanom/handler.go

@@ -1,4 +1,4 @@
-package api
+package aimlanom
 
 // Phase-50 / 0062 — ML1 Learned per-vehicle anomaly baselines.
 //
@@ -55,6 +55,7 @@ import (
 	"github.com/ev-dev-labs/teslasync/internal/ai/strategy"
 	"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/api/httpx"
 	tsauth "github.com/ev-dev-labs/teslasync/internal/auth"
 	"github.com/ev-dev-labs/teslasync/internal/database"
 	"github.com/ev-dev-labs/teslasync/internal/ml/anomaly"
@@ -80,21 +81,21 @@ const aiLearnedAnomalyDefaultDays = 7
 // the LLM.
 const aiLearnedAnomalyMaxDays = 30
 
-// AILearnedAnomalyBaselineHandler is the HTTP handler for
+// Handler is the HTTP handler for
 // POST /api/v1/ai/ml/anomaly-baselines/train.
 //
 // 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 AILearnedAnomalyBaselineHandler struct {
+type Handler struct {
 	registry   *provider.Registry
 	tools      *tools.Registry
 	strategy   strategy.Strategy
 	headerName string
 	maxIters   int
 }
 
-// NewAILearnedAnomalyBaselineHandler 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.
 //
@@ -110,21 +111,21 @@ type AILearnedAnomalyBaselineHandler struct {
 //	(one per process).
 //
 // headerName: forward-auth header name; used to extract subject for audit.
-func NewAILearnedAnomalyBaselineHandler(
+func NewHandler(
 	registry *provider.Registry,
 	toolReg *tools.Registry,
 	strat strategy.Strategy,
 	headerName string,
-) *AILearnedAnomalyBaselineHandler {
+) *Handler {
 	switch {
 	case registry == nil:
-		panic("api: NewAILearnedAnomalyBaselineHandler: nil provider.Registry")
+		panic("aimlanom: NewHandler: nil provider.Registry")
 	case toolReg == nil:
-		panic("api: NewAILearnedAnomalyBaselineHandler: nil tools.Registry")
+		panic("aimlanom: NewHandler: nil tools.Registry")
 	case strat == nil:
-		panic("api: NewAILearnedAnomalyBaselineHandler: nil strategy.Strategy")
+		panic("aimlanom: NewHandler: nil strategy.Strategy")
 	}
-	return &AILearnedAnomalyBaselineHandler{
+	return &Handler{
 		registry:   registry,
 		tools:      toolReg,
 		strategy:   strat,
@@ -150,7 +151,7 @@ type aiLearnedAnomalyRequest struct {
 // dispatcher's deferred WriteDone. Every error 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 *AILearnedAnomalyBaselineHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	// 1) Decode + validate request body.
 	var body aiLearnedAnomalyRequest
 	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
@@ -245,27 +246,27 @@ func (h *AILearnedAnomalyBaselineHandler) ServeHTTP(w http.ResponseWriter, r *ht
 	}
 }
 
-// Compile-time assertion: AILearnedAnomalyBaselineHandler satisfies http.Handler.
-var _ http.Handler = (*AILearnedAnomalyBaselineHandler)(nil)
+// Compile-time assertion: Handler satisfies http.Handler.
+var _ http.Handler = (*Handler)(nil)
 
-// AISignalSampleSource is the production *database.DB-backed adapter
+// SignalSampleSource is the production *database.DB-backed adapter
 // that satisfies anomaly.SignalSampleSource. It runs ONE pgx query
 // scoped to the requested vehicle, lookback days, and signal
 // allowlist; rows are bucketed in-memory into the per-signal
 // observation slices the trainer expects. No new SQL semantics —
 // the same signal_log columns the deterministic detector at
 // internal/api/anomaly_handler.go already reads.
-type AISignalSampleSource struct {
+type SignalSampleSource struct {
 	db *database.DB
 }
 
-// NewAISignalSampleSource constructs the adapter. Panics on a nil
+// NewSignalSampleSource constructs the adapter. Panics on a nil
 // DB so the wiring bug surfaces at boot, not at first request.
-func NewAISignalSampleSource(db *database.DB) *AISignalSampleSource {
+func NewSignalSampleSource(db *database.DB) *SignalSampleSource {
 	if db == nil {
-		panic("api: NewAISignalSampleSource: nil *database.DB")
+		panic("aimlanom: NewSignalSampleSource: nil *database.DB")
 	}
-	return &AISignalSampleSource{db: db}
+	return &SignalSampleSource{db: db}
 }
 
 // SamplesForVehicle implements anomaly.SignalSampleSource. Returns
@@ -277,7 +278,7 @@ func NewAISignalSampleSource(db *database.DB) *AISignalSampleSource {
 // signal_log hypertable's primary index is (vehicle_id, ts), so
 // the selectivity comes from the time predicate; the field
 // allowlist is a final-stage filter.
-func (s *AISignalSampleSource) SamplesForVehicle(ctx context.Context, vehicleID int64, days int, signals []string) (map[string][]float64, error) {
+func (s *SignalSampleSource) SamplesForVehicle(ctx context.Context, vehicleID int64, days int, signals []string) (map[string][]float64, error) {
 	out := make(map[string][]float64, len(signals))
 	for _, sig := range signals {
 		out[sig] = nil
@@ -295,22 +296,30 @@ func (s *AISignalSampleSource) SamplesForVehicle(ctx context.Context, vehicleID
 		  AND (float_value IS NOT NULL OR int_value IS NOT NULL)`,
 		vehicleID, since, signals)
 	if err != nil {
-		return nil, fmt.Errorf("AISignalSampleSource: vehicle %d days %d: %w", vehicleID, days, err)
+		return nil, fmt.Errorf("SignalSampleSource: vehicle %d days %d: %w", vehicleID, days, err)
 	}
 	defer rows.Close()
 	for rows.Next() {
 		var field string
 		var v float64
 		if err := rows.Scan(&field, &v); err != nil {
-			return nil, fmt.Errorf("AISignalSampleSource: scan: %w", err)
+			return nil, fmt.Errorf("SignalSampleSource: scan: %w", err)
 		}
 		out[field] = append(out[field], v)
 	}
 	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("AISignalSampleSource: rows.Err: %w", err)
+		return nil, fmt.Errorf("SignalSampleSource: rows.Err: %w", err)
 	}
 	return out, nil
 }
 
-// Compile-time assertion: AISignalSampleSource satisfies anomaly.SignalSampleSource.
-var _ anomaly.SignalSampleSource = (*AISignalSampleSource)(nil)
+// Compile-time assertion: SignalSampleSource satisfies anomaly.SignalSampleSource.
+var _ anomaly.SignalSampleSource = (*SignalSampleSource)(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
+}

…i/ai_ml_anomaly_baseline_handler_test.go internal/api/aimlanom/handler_test.gointernal/api/ai_ml_anomaly_baseline_handler_test.go renamed to internal/api/aimlanom/handler_test.go internal/api/ai_ml_anomaly_baseline_handler_test.go renamed to internal/api/aimlanom/handler_test.go

@@ -17,9 +17,10 @@
 // learned-per-vehicle-anomaly-baselines`); duplicating that here
 // would require a live database fixture.
 
-package api
+package aimlanom
 
 import (
+	"context"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
@@ -31,6 +32,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
+}
+
 // TestLearnedAnomalyBaselineAIOffUsesSafeRangesOnly is the
 // load-bearing off-mode contract proof for slice 0062. It mounts
 // the AI learned-anomaly-baseline route through the guard with
@@ -123,27 +140,27 @@ func TestLearnedAnomalyBaselineAIOffUsesSafeRangesOnly(t *testing.T) {
 	}
 }
 
-// TestAILearnedAnomalyBaselineHandler_PanicsOnNilWiring asserts the
+// TestHandler_PanicsOnNilWiring asserts the
 // handler constructor refuses zero-valued dependencies. A wiring
 // bug at boot must surface as a panic, not as a nil-deref on first
 // request.
-func TestAILearnedAnomalyBaselineHandler_PanicsOnNilWiring(t *testing.T) {
+func TestHandler_PanicsOnNilWiring(t *testing.T) {
 	t.Parallel()
 	defer func() {
 		if r := recover(); r == nil {
-			t.Fatal("NewAILearnedAnomalyBaselineHandler(nil,nil,nil,\"\") did not panic")
+			t.Fatal("NewHandler(nil,nil,nil,\"\") did not panic")
 		}
 	}()
-	NewAILearnedAnomalyBaselineHandler(nil, nil, nil, "")
+	NewHandler(nil, nil, nil, "")
 }
 
-// TestAILearnedAnomalyBaselineHandler_RejectsBadRequestBodies pins
+// TestHandler_RejectsBadRequestBodies pins
 // the request-validation contract: missing vehicle_id, non-positive
 // vehicle_id, and out-of-range days must surface as 4xx BEFORE the
 // dispatcher is reached (so a confused caller cannot waste a
 // provider call). The baseline-coexistence test above already
 // proves the off-mode 404; this test pins the on-mode validator.
-func TestAILearnedAnomalyBaselineHandler_RejectsBadRequestBodies(t *testing.T) {
+func TestHandler_RejectsBadRequestBodies(t *testing.T) {
 	t.Parallel()
 	cases := []struct {
 		name string
@@ -184,7 +201,7 @@ func TestAILearnedAnomalyBaselineHandler_RejectsBadRequestBodies(t *testing.T) {
 }
 
 // validateLearnedAnomalyRequest mirrors the pre-dispatch validation
-// block in (*AILearnedAnomalyBaselineHandler).ServeHTTP. Kept in
+// block in (*Handler).ServeHTTP. Kept in
 // the test file (not exported from the production handler) so a
 // future change to ServeHTTP's validation must update both —
 // surfacing the divergence rather than letting it drift.

internal/api/router.go

@@ -31,6 +31,7 @@ import (
 	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"
+	aimlanom "github.com/ev-dev-labs/teslasync/internal/api/aimlanom"
 	airaghelp "github.com/ev-dev-labs/teslasync/internal/api/airaghelp"
 	airouteeff "github.com/ev-dev-labs/teslasync/internal/api/airouteeff"
 	aisearch "github.com/ev-dev-labs/teslasync/internal/api/aisearch"
@@ -1850,20 +1851,20 @@ func NewRouter(db *database.DB, teslaClient *tesla.Client, mqttClient *mqtt.Clie
 	// learned-per-vehicle-anomaly-baselines (Phase-50 / ML1, slice
 	// 0062) tools — train_anomaly_baseline + query_anomaly_baseline.
 	// Both READ-only; the trainer reads signal_log via the
-	// AISignalSampleSource adapter and returns a per-signal learned
+	// SignalSampleSource adapter and returns a per-signal learned
 	// envelope (mean / stddev / p5 / p95) clamped to the static
 	// safe-range envelope, with safe-range fallback per signal when
 	// fewer than anomaly.DefaultMinSamples observations exist in
 	// the lookback window. Tools registered BEFORE the handler is
 	// constructed so the dispatcher can resolve the strategy's
 	// allowedTools at boot.
 	predict.RegisterLearnedAnomalyBaselineTools(aiToolRegistry, predict.LearnedAnomalyBaselineSources{
-		Trainer: anomaly.NewTrainer(NewAISignalSampleSource(db)),
+		Trainer: anomaly.NewTrainer(aimlanom.NewSignalSampleSource(db)),
 	})
 	// learned-per-vehicle-anomaly-baselines handler. One per
 	// process; stateless beyond constructor inputs. Must be
 	// constructed AFTER the tool registration above.
-	aiLearnedAnomalyBaselinesHandler := NewAILearnedAnomalyBaselineHandler(
+	aiLearnedAnomalyBaselinesHandler := aimlanom.NewHandler(
 		aiRegistry,
 		aiToolRegistry,
 		learnedanomalybaselines.New(),