refactor(components): extract useDraftIntake hook

Move caseIntake state plus its four handlers (field change, analyze,
preset apply, note-audience change) and the INTAKE_PRESETS constant
out of DraftTab.tsx into a dedicated hook. Shell passes input,
currentTicket(Id), response, logEvent, and setWorkspacePersonalization
in; hook owns the caseIntake state and returns setCaseIntake so
useWorkspaceDraftState can still hydrate intake on draft load.

Author: saagar210

src/components/Draft/DraftTab.tsx

@@ -17,6 +17,7 @@ import { ConversationThread, ConversationEntry } from "./ConversationThread";
 import { useDraftApproval } from "./useDraftApproval";
 import { useDraftChecklist } from "./useDraftChecklist";
 import { useDraftFirstResponse } from "./useDraftFirstResponse";
+import { useDraftIntake } from "./useDraftIntake";
 import { ConversationInput } from "./ConversationInput";
 import { WorkspaceDialogs } from "./WorkspaceDialogs";
 import { WorkspaceModeShell } from "./WorkspaceModeShell";
@@ -41,7 +42,6 @@ import { useWorkspaceCommandBridge } from "../../features/workspace/useWorkspace
 import { useWorkspaceDraftState } from "../../features/workspace/useWorkspaceDraftState";
 import {
   applyResolutionKit,
-  analyzeCaseIntake,
   buildResolutionKitFromWorkspace,
   buildSimilarCases,
   compactLines,
@@ -66,10 +66,8 @@ import type {
 } from "../../types/llm";
 import type { ContextSource } from "../../types/knowledge";
 import type {
-  CaseIntake,
   GuidedRunbookTemplate,
   NextActionRecommendation,
-  NoteAudience,
   ResolutionKit,
   ResponseLength,
   SavedDraft,
@@ -205,32 +203,6 @@ function isEditableTarget(target: EventTarget | null): boolean {
   );
 }
 
-const INTAKE_PRESETS: Record<
-  "incident" | "access" | "rollout" | "device",
-  Partial<CaseIntake>
-> = {
-  incident: {
-    likely_category: "incident",
-    urgency: "high",
-    note_audience: "internal-note",
-  },
-  access: {
-    likely_category: "access",
-    urgency: "normal",
-    note_audience: "internal-note",
-  },
-  rollout: {
-    likely_category: "change-rollout",
-    urgency: "normal",
-    note_audience: "internal-note",
-  },
-  device: {
-    likely_category: "device-environment",
-    urgency: "normal",
-    note_audience: "internal-note",
-  },
-};
-
 export const DraftTab = forwardRef<DraftTabHandle, DraftTabProps>(
   function DraftTab(
     { initialDraft, onNavigateToSource, revampModeEnabled = false },
@@ -365,10 +337,6 @@ export const DraftTab = forwardRef<DraftTabHandle, DraftTabProps>(
       ConversationEntry[]
     >([]);
     const [handoffTouched, setHandoffTouched] = useState(false);
-    const [caseIntake, setCaseIntake] = useState<CaseIntake>(() => ({
-      ...parseCaseIntake(null),
-      note_audience: loadWorkspacePersonalization().preferred_note_audience,
-    }));
     const [similarCases, setSimilarCases] = useState<SimilarCase[]>([]);
     const [similarCasesLoading, setSimilarCasesLoading] = useState(false);
     const [compareCase, setCompareCase] = useState<SimilarCase | null>(null);
@@ -471,52 +439,22 @@ export const DraftTab = forwardRef<DraftTabHandle, DraftTabProps>(
       void refreshWorkspaceCatalog();
     }, [refreshWorkspaceCatalog]);
 
-    const handleIntakeFieldChange = useCallback(
-      (field: keyof CaseIntake, value: string) => {
-        setCaseIntake((prev) => ({
-          ...prev,
-          [field]: value,
-        }));
-      },
-      [],
-    );
-
-    const handleAnalyzeIntake = useCallback(() => {
-      setCaseIntake((prev) =>
-        analyzeCaseIntake(input, currentTicket ?? undefined, prev),
-      );
-      void logEvent("workspace_intake_analyzed", {
-        ticket_id: currentTicketId,
-        has_ticket: Boolean(currentTicketId),
-        has_response: Boolean(response.trim()),
-      });
-    }, [input, currentTicket, logEvent, currentTicketId, response]);
-
-    const handleApplyIntakePreset = useCallback(
-      (preset: "incident" | "access" | "rollout" | "device") => {
-        setCaseIntake((prev) => ({
-          ...prev,
-          ...INTAKE_PRESETS[preset],
-        }));
-        void logEvent("workspace_intake_preset_applied", { preset });
-      },
-      [logEvent],
-    );
-
-    const handleNoteAudienceChange = useCallback(
-      (audience: NoteAudience) => {
-        setCaseIntake((prev) => ({
-          ...prev,
-          note_audience: audience,
-        }));
-        setWorkspacePersonalization((prev) => ({
-          ...prev,
-          preferred_note_audience: audience,
-        }));
-        void logEvent("workspace_note_audience_changed", { audience });
-      },
-      [logEvent],
-    );
+    const {
+      caseIntake,
+      setCaseIntake,
+      handleIntakeFieldChange,
+      handleAnalyzeIntake,
+      handleApplyIntakePreset,
+      handleNoteAudienceChange,
+    } = useDraftIntake({
+      initialNoteAudience: workspacePersonalization.preferred_note_audience,
+      input,
+      currentTicket,
+      currentTicketId,
+      response,
+      logEvent,
+      setWorkspacePersonalization,
+    });
 
     const handleResponseLengthChange = useCallback((length: ResponseLength) => {
       setResponseLength(length);

src/components/Draft/useDraftIntake.test.ts

@@ -0,0 +1,71 @@
+// @vitest-environment jsdom
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { INTAKE_PRESETS, useDraftIntake } from "./useDraftIntake";
+
+function makeOptions(
+  overrides: Partial<Parameters<typeof useDraftIntake>[0]> = {},
+) {
+  return {
+    initialNoteAudience: "internal-note" as const,
+    input: "",
+    currentTicket: null,
+    currentTicketId: null,
+    response: "",
+    logEvent: vi.fn().mockResolvedValue(undefined),
+    setWorkspacePersonalization: vi.fn(),
+    ...overrides,
+  };
+}
+
+describe("useDraftIntake", () => {
+  it("updates individual intake fields", () => {
+    const { result } = renderHook(() => useDraftIntake(makeOptions()));
+
+    act(() => {
+      result.current.handleIntakeFieldChange("issue", "VPN outage");
+    });
+    expect(result.current.caseIntake.issue).toBe("VPN outage");
+
+    act(() => {
+      result.current.handleIntakeFieldChange("impact", "west region");
+    });
+    expect(result.current.caseIntake.impact).toBe("west region");
+    expect(result.current.caseIntake.issue).toBe("VPN outage");
+  });
+
+  it("applies preset values and logs the event", () => {
+    const logEvent = vi.fn().mockResolvedValue(undefined);
+    const { result } = renderHook(() =>
+      useDraftIntake(makeOptions({ logEvent })),
+    );
+
+    act(() => {
+      result.current.handleApplyIntakePreset("incident");
+    });
+
+    expect(result.current.caseIntake.likely_category).toBe(
+      INTAKE_PRESETS.incident.likely_category,
+    );
+    expect(result.current.caseIntake.urgency).toBe(
+      INTAKE_PRESETS.incident.urgency,
+    );
+    expect(logEvent).toHaveBeenCalledWith("workspace_intake_preset_applied", {
+      preset: "incident",
+    });
+  });
+
+  it("updates audience and syncs workspace personalization", () => {
+    const setWorkspacePersonalization = vi.fn();
+    const { result } = renderHook(() =>
+      useDraftIntake(makeOptions({ setWorkspacePersonalization })),
+    );
+
+    act(() => {
+      result.current.handleNoteAudienceChange("customer-safe");
+    });
+
+    expect(result.current.caseIntake.note_audience).toBe("customer-safe");
+    expect(setWorkspacePersonalization).toHaveBeenCalled();
+  });
+});

src/components/Draft/useDraftIntake.ts

@@ -0,0 +1,119 @@
+import { useCallback, useState } from "react";
+import type { JiraTicket } from "../../hooks/useJira";
+import type {
+  CaseIntake,
+  NoteAudience,
+  WorkspacePersonalization,
+} from "../../types/workspace";
+import {
+  analyzeCaseIntake,
+  parseCaseIntake,
+} from "../../features/workspace/workspaceAssistant";
+
+export type IntakePreset = "incident" | "access" | "rollout" | "device";
+
+export const INTAKE_PRESETS: Record<IntakePreset, Partial<CaseIntake>> = {
+  incident: {
+    likely_category: "incident",
+    urgency: "high",
+    note_audience: "internal-note",
+  },
+  access: {
+    likely_category: "access",
+    urgency: "normal",
+    note_audience: "internal-note",
+  },
+  rollout: {
+    likely_category: "change-rollout",
+    urgency: "normal",
+    note_audience: "internal-note",
+  },
+  device: {
+    likely_category: "device-environment",
+    urgency: "normal",
+    note_audience: "internal-note",
+  },
+};
+
+interface UseDraftIntakeOptions {
+  initialNoteAudience: NoteAudience;
+  input: string;
+  currentTicket: JiraTicket | null;
+  currentTicketId: string | null;
+  response: string;
+  logEvent: (event: string, payload?: Record<string, unknown>) => Promise<void>;
+  setWorkspacePersonalization: (
+    updater: (prev: WorkspacePersonalization) => WorkspacePersonalization,
+  ) => void;
+}
+
+export function useDraftIntake({
+  initialNoteAudience,
+  input,
+  currentTicket,
+  currentTicketId,
+  response,
+  logEvent,
+  setWorkspacePersonalization,
+}: UseDraftIntakeOptions) {
+  const [caseIntake, setCaseIntake] = useState<CaseIntake>(() => ({
+    ...parseCaseIntake(null),
+    note_audience: initialNoteAudience,
+  }));
+
+  const handleIntakeFieldChange = useCallback(
+    (field: keyof CaseIntake, value: string) => {
+      setCaseIntake((prev) => ({
+        ...prev,
+        [field]: value,
+      }));
+    },
+    [],
+  );
+
+  const handleAnalyzeIntake = useCallback(() => {
+    setCaseIntake((prev) =>
+      analyzeCaseIntake(input, currentTicket ?? undefined, prev),
+    );
+    void logEvent("workspace_intake_analyzed", {
+      ticket_id: currentTicketId,
+      has_ticket: Boolean(currentTicketId),
+      has_response: Boolean(response.trim()),
+    });
+  }, [input, currentTicket, logEvent, currentTicketId, response]);
+
+  const handleApplyIntakePreset = useCallback(
+    (preset: IntakePreset) => {
+      setCaseIntake((prev) => ({
+        ...prev,
+        ...INTAKE_PRESETS[preset],
+      }));
+      void logEvent("workspace_intake_preset_applied", { preset });
+    },
+    [logEvent],
+  );
+
+  const handleNoteAudienceChange = useCallback(
+    (audience: NoteAudience) => {
+      setCaseIntake((prev) => ({
+        ...prev,
+        note_audience: audience,
+      }));
+      setWorkspacePersonalization((prev) => ({
+        ...prev,
+        preferred_note_audience: audience,
+      }));
+      void logEvent("workspace_note_audience_changed", { audience });
+    },
+    [logEvent, setWorkspacePersonalization],
+  );
+
+  return {
+    caseIntake,
+    setCaseIntake,
+    handleIntakeFieldChange,
+    handleAnalyzeIntake,
+    handleApplyIntakePreset,
+    handleNoteAudienceChange,
+  };
+}