refactor(R2d.133): carve internal/api/aifeedtri subpackage

Move the AI feedback queue triage handler and tests into a dedicated aifeedtri handler package. Update router wiring to use the new package-level constructor names.

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

Author: atulmgupta

internal/api/aifeedtri/doc.go

@@ -0,0 +1,3 @@
+// Package aifeedtri provides the AI feedback queue triage HTTP handler.
+// Layer: handler
+package aifeedtri

…ternal/api/ai_feedback_triage_handler.go internal/api/aifeedtri/handler.gointernal/api/ai_feedback_triage_handler.go renamed to internal/api/aifeedtri/handler.go internal/api/ai_feedback_triage_handler.go renamed to internal/api/aifeedtri/handler.go

@@ -1,8 +1,8 @@
-package api
+package aifeedtri
 
 // Phase-50 / 0046 — S5 Feedback queue triage.
 //
-// ai_feedback_triage_handler.go implements the LLM-backed handler
+// handler.go implements the LLM-backed handler
 // at POST /api/v1/ai/feedback/triage/draft. The flow mirrors
 // ai_log_trace_summarization_handler.go (body-driven, scope-bound,
 // no persistence — one-shot read-then-propose):
@@ -68,6 +68,7 @@ package api
 //     persistence path.
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
@@ -85,6 +86,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/feedback"
+	"github.com/ev-dev-labs/teslasync/internal/api/httpx"
 	tsauth "github.com/ev-dev-labs/teslasync/internal/auth"
 	dbuser "github.com/ev-dev-labs/teslasync/internal/database/user"
 )
@@ -109,6 +111,10 @@ const aiFeedbackTriageMaxBodyBytes = 16 * 1024
 // excerpt is always a strict subset of the persisted column.
 const aiFeedbackTriageBodyExcerptMaxChars = 4096
 
+func denyAllConfirm(_ context.Context, _ dispatch.ConfirmRequest) (dispatch.ConfirmDecision, error) {
+	return dispatch.ConfirmDenied, nil
+}
+
 // aiFeedbackTriageRequest is the typed body shape. feedback_id is
 // the only required field.
 type aiFeedbackTriageRequest struct {
@@ -117,13 +123,13 @@ type aiFeedbackTriageRequest struct {
 	FeedbackID int64 `json:"feedback_id"`
 }
 
-// AIFeedbackQueueTriageHandler is the HTTP handler for
+// Handler is the HTTP handler for
 // POST /api/v1/ai/feedback/triage/draft.
 //
 // 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 AIFeedbackQueueTriageHandler struct {
+type Handler struct {
 	registry   *provider.Registry
 	tools      *tools.Registry
 	strategy   strategy.Strategy
@@ -132,7 +138,7 @@ type AIFeedbackQueueTriageHandler struct {
 	maxIters   int
 }
 
-// NewAIFeedbackQueueTriageHandler 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.
 //
@@ -155,24 +161,24 @@ type AIFeedbackQueueTriageHandler struct {
 // headerName: forward-auth header name; used to extract subject
 //
 //	for audit.
-func NewAIFeedbackQueueTriageHandler(
+func NewHandler(
 	registry *provider.Registry,
 	toolReg *tools.Registry,
 	strat strategy.Strategy,
 	source feedback.FeedbackTriageSource,
 	headerName string,
-) *AIFeedbackQueueTriageHandler {
+) *Handler {
 	switch {
 	case registry == nil:
-		panic("api: NewAIFeedbackQueueTriageHandler: nil provider.Registry")
+		panic("aifeedtri: NewHandler: nil provider.Registry")
 	case toolReg == nil:
-		panic("api: NewAIFeedbackQueueTriageHandler: nil tools.Registry")
+		panic("aifeedtri: NewHandler: nil tools.Registry")
 	case strat == nil:
-		panic("api: NewAIFeedbackQueueTriageHandler: nil strategy.Strategy")
+		panic("aifeedtri: NewHandler: nil strategy.Strategy")
 	case source == nil:
-		panic("api: NewAIFeedbackQueueTriageHandler: nil feedback.FeedbackTriageSource")
+		panic("aifeedtri: NewHandler: nil feedback.FeedbackTriageSource")
 	}
-	return &AIFeedbackQueueTriageHandler{
+	return &Handler{
 		registry:   registry,
 		tools:      toolReg,
 		strategy:   strat,
@@ -189,27 +195,27 @@ func NewAIFeedbackQueueTriageHandler(
 func parseFeedbackTriageRequest(w http.ResponseWriter, r *http.Request) (aiFeedbackTriageRequest, bool) {
 	var req aiFeedbackTriageRequest
 	if r.Body == nil {
-		writeError(w, http.StatusBadRequest, "missing body")
+		httpx.WriteError(w, http.StatusBadRequest, "missing body")
 		return req, false
 	}
 	defer r.Body.Close()
 	bodyBytes, readErr := io.ReadAll(io.LimitReader(r.Body, aiFeedbackTriageMaxBodyBytes))
 	if readErr != nil {
-		writeError(w, http.StatusBadRequest, fmt.Sprintf("failed to read body: %v", readErr))
+		httpx.WriteError(w, http.StatusBadRequest, fmt.Sprintf("failed to read body: %v", readErr))
 		return req, false
 	}
-	if len(bytesTrim(bodyBytes)) == 0 {
-		writeError(w, http.StatusBadRequest, "empty body")
+	if len(bytes.TrimSpace(bodyBytes)) == 0 {
+		httpx.WriteError(w, http.StatusBadRequest, "empty body")
 		return req, false
 	}
 	dec := json.NewDecoder(strings.NewReader(string(bodyBytes)))
 	dec.DisallowUnknownFields()
 	if err := dec.Decode(&req); err != nil {
-		writeError(w, http.StatusBadRequest, fmt.Sprintf("invalid JSON body: %v", err))
+		httpx.WriteError(w, http.StatusBadRequest, fmt.Sprintf("invalid JSON body: %v", err))
 		return req, false
 	}
 	if req.FeedbackID <= 0 {
-		writeError(w, http.StatusBadRequest, "feedback_id must be > 0")
+		httpx.WriteError(w, http.StatusBadRequest, "feedback_id must be > 0")
 		return req, false
 	}
 	return req, true
@@ -220,7 +226,7 @@ func parseFeedbackTriageRequest(w http.ResponseWriter, r *http.Request) (aiFeedb
 // 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 *AIFeedbackQueueTriageHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	// 1) Parse + validate the request body.
 	req, ok := parseFeedbackTriageRequest(w, r)
 	if !ok {
@@ -233,7 +239,7 @@ func (h *AIFeedbackQueueTriageHandler) ServeHTTP(w http.ResponseWriter, r *http.
 	// stream — emit JSON 502 so the frontend falls back gracefully.
 	if _, err := h.registry.For(r.Context(), feedbackqueuetriage.FeatureID); err != nil {
 		log.Error().Err(err).Msg("ai feedback-queue-triage: provider.For failed")
-		writeError(w, http.StatusBadGateway, "ai provider unavailable")
+		httpx.WriteError(w, http.StatusBadGateway, "ai provider unavailable")
 		return
 	}
 
@@ -251,7 +257,7 @@ func (h *AIFeedbackQueueTriageHandler) ServeHTTP(w http.ResponseWriter, r *http.
 	sseW, ctx, err := stream.New(ctx, w, stream.WithFeatureID(feedbackqueuetriage.FeatureID))
 	if err != nil {
 		log.Error().Err(err).Msg("ai feedback-queue-triage: stream.New failed (non-flushable writer)")
-		writeError(w, http.StatusInternalServerError, "streaming not supported")
+		httpx.WriteError(w, http.StatusInternalServerError, "streaming not supported")
 		return
 	}
 
@@ -314,9 +320,9 @@ func synthesizeFeedbackTriageUserMessage(feedbackID int64) string {
 	)
 }
 
-// Compile-time assertion: AIFeedbackQueueTriageHandler satisfies
+// Compile-time assertion: Handler satisfies
 // http.Handler.
-var _ http.Handler = (*AIFeedbackQueueTriageHandler)(nil)
+var _ http.Handler = (*Handler)(nil)
 
 // ---------------------------------------------------------------------
 // Production wiring for the tool interface declared by
@@ -325,7 +331,7 @@ var _ http.Handler = (*AIFeedbackQueueTriageHandler)(nil)
 // the log-trace-summarization slice's AILogTraceWindowSource pattern.
 // ---------------------------------------------------------------------
 
-// AIFeedbackTriageSource is the production
+// FeedbackTriageSource is the production
 // feedback.FeedbackTriageSource. It wraps the canonical
 // *dbuser.UserFeedbackRepo.Get and PII-minimizes the row into a
 // FeedbackTriageEntry: only id / created_at / category / title /
@@ -334,18 +340,18 @@ var _ http.Handler = (*AIFeedbackQueueTriageHandler)(nil)
 // submitter_subject, submitter_ip, recent_errors, and console_tail
 // are NOT forwarded — defence in depth on top of
 // PolicyAlertBuilder's deny-by-default redaction.
-type AIFeedbackTriageSource struct {
+type FeedbackTriageSource struct {
 	repo *dbuser.UserFeedbackRepo
 }
 
-// NewAIFeedbackTriageSource constructs the production source
+// NewFeedbackTriageSource constructs the production source
 // adapter. Panics on a nil repo so the wiring bug surfaces at boot,
 // not at first request.
-func NewAIFeedbackTriageSource(repo *dbuser.UserFeedbackRepo) *AIFeedbackTriageSource {
+func NewFeedbackTriageSource(repo *dbuser.UserFeedbackRepo) *FeedbackTriageSource {
 	if repo == nil {
-		panic("api: NewAIFeedbackTriageSource: nil *dbuser.UserFeedbackRepo")
+		panic("aifeedtri: NewFeedbackTriageSource: nil *dbuser.UserFeedbackRepo")
 	}
-	return &AIFeedbackTriageSource{repo: repo}
+	return &FeedbackTriageSource{repo: repo}
 }
 
 // LoadFeedback implements feedback.FeedbackTriageSource. Returns
@@ -357,7 +363,7 @@ func NewAIFeedbackTriageSource(repo *dbuser.UserFeedbackRepo) *AIFeedbackTriageS
 // The body is truncated to aiFeedbackTriageBodyExcerptMaxChars to
 // bound the prompt-token budget; the canonical body is preserved
 // in the database column unchanged.
-func (a *AIFeedbackTriageSource) LoadFeedback(ctx context.Context, feedbackID int64) (*feedback.FeedbackTriageEntry, error) {
+func (a *FeedbackTriageSource) LoadFeedback(ctx context.Context, feedbackID int64) (*feedback.FeedbackTriageEntry, error) {
 	row, err := a.repo.Get(ctx, feedbackID)
 	if err != nil {
 		if errors.Is(err, dbuser.ErrFeedbackNotFound) {
@@ -382,6 +388,6 @@ func (a *AIFeedbackTriageSource) LoadFeedback(ctx context.Context, feedbackID in
 	}, nil
 }
 
-// Compile-time assertion: AIFeedbackTriageSource satisfies
+// Compile-time assertion: FeedbackTriageSource satisfies
 // feedback.FeedbackTriageSource.
-var _ feedback.FeedbackTriageSource = (*AIFeedbackTriageSource)(nil)
+var _ feedback.FeedbackTriageSource = (*FeedbackTriageSource)(nil)

…l/api/ai_feedback_triage_handler_test.go internal/api/aifeedtri/handler_test.gointernal/api/ai_feedback_triage_handler_test.go renamed to internal/api/aifeedtri/handler_test.go internal/api/ai_feedback_triage_handler_test.go renamed to internal/api/aifeedtri/handler_test.go

@@ -14,10 +14,11 @@
 // feedback-queue-triage`); duplicating that here would require a
 // live database fixture.
 
-package api
+package aifeedtri
 
 import (
 	"bytes"
+	"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
+}
+
 // TestFeedbackTriageAIOffManualLabelsWork is the load-bearing
 // off-mode contract proof for slice 0046. It mounts the AI
 // feedback-queue-triage route through the guard with ai_mode='off'
@@ -140,47 +157,47 @@ func TestFeedbackTriageAIOffManualLabelsWork(t *testing.T) {
 	}
 }
 
-// TestAIFeedbackQueueTriageHandler_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 TestAIFeedbackQueueTriageHandler_PanicsOnNilWiring(t *testing.T) {
+func TestHandler_PanicsOnNilWiring(t *testing.T) {
 	t.Parallel()
 	cases := []struct {
 		name string
 		fn   func()
 	}{
-		{"all nil", func() { NewAIFeedbackQueueTriageHandler(nil, nil, nil, nil, "") }},
+		{"all nil", func() { NewHandler(nil, nil, nil, nil, "") }},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			defer func() {
 				if r := recover(); r == nil {
-					t.Fatalf("NewAIFeedbackQueueTriageHandler(%s) did not panic", tc.name)
+					t.Fatalf("NewHandler(%s) did not panic", tc.name)
 				}
 			}()
 			tc.fn()
 		})
 	}
 }
 
-// TestNewAIFeedbackTriageSource_PanicsOnNilRepo asserts the
+// TestNewFeedbackTriageSource_PanicsOnNilRepo asserts the
 // production source adapter constructor refuses a nil repo.
-func TestNewAIFeedbackTriageSource_PanicsOnNilRepo(t *testing.T) {
+func TestNewFeedbackTriageSource_PanicsOnNilRepo(t *testing.T) {
 	t.Parallel()
 	defer func() {
 		if r := recover(); r == nil {
-			t.Fatal("NewAIFeedbackTriageSource(nil) did not panic")
+			t.Fatal("NewFeedbackTriageSource(nil) did not panic")
 		}
 	}()
-	_ = NewAIFeedbackTriageSource(nil)
+	_ = NewFeedbackTriageSource(nil)
 }
 
-// TestAIFeedbackQueueTriageHandler_RejectsBadBody asserts the
+// TestHandler_RejectsBadBody asserts the
 // handler validates the body BEFORE opening the SSE stream — a
 // missing, unparseable, or out-of-range field must surface as a
 // JSON 400, not a half-opened stream that confuses the frontend.
-func TestAIFeedbackQueueTriageHandler_RejectsBadBody(t *testing.T) {
+func TestHandler_RejectsBadBody(t *testing.T) {
 	t.Parallel()
 
 	cases := []struct {

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"
+	aifeedtri "github.com/ev-dev-labs/teslasync/internal/api/aifeedtri"
 	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"
@@ -2163,9 +2164,9 @@ func NewRouter(db *database.DB, teslaClient *tesla.Client, mqttClient *mqtt.Clie
 	// other slice tools above: must be registered before the
 	// handler constructor below so the strategy's allowedTools
 	// resolve at boot. The Source is the production
-	// AIFeedbackTriageSource adapter that wraps userFeedbackRepo
+	// FeedbackTriageSource adapter that wraps userFeedbackRepo
 	// and PII-minimizes the row into a FeedbackTriageEntry.
-	aiFeedbackTriageSource := NewAIFeedbackTriageSource(userFeedbackRepo)
+	aiFeedbackTriageSource := aifeedtri.NewFeedbackTriageSource(userFeedbackRepo)
 	feedback.RegisterFeedbackQueueTriageTools(aiToolRegistry, feedback.FeedbackQueueTriageSources{
 		Source:    aiFeedbackTriageSource,
 		Retriever: aiFeedbackTriageRetriever,
@@ -2174,7 +2175,7 @@ func NewRouter(db *database.DB, teslaClient *tesla.Client, mqttClient *mqtt.Clie
 	// beyond constructor inputs. Must be constructed AFTER the
 	// tool registration above so the dispatcher can resolve the
 	// strategy's allowedTools at boot.
-	aiFeedbackQueueTriageHandler := NewAIFeedbackQueueTriageHandler(
+	aiFeedbackQueueTriageHandler := aifeedtri.NewHandler(
 		aiRegistry,
 		aiToolRegistry,
 		feedbackqueuetriage.New(),