@tokentop/ttop 0.5.0 → 0.6.0

package/src/tui/views/ProjectsView.tsx

@@ -4,16 +4,21 @@ import { useKeyboard, useTerminalDimensions } from "@opentui/react";
 import type React from "react";
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import type { AgentSessionAggregate } from "../../agents/types.ts";
+import { SortOverlay } from "../components/SortOverlay.tsx";
 import { useAgentSessions } from "../contexts/AgentSessionContext.tsx";
 import { useInputFocus } from "../contexts/InputContext.tsx";
 import { useColors } from "../contexts/ThemeContext.tsx";
 import { useTimeWindow } from "../contexts/TimeWindowContext.tsx";
+import type { ProjectSortField } from "../types/projectSort.ts";
+import { getProjectSortFieldLabel, PROJECT_SORT_FIELDS } from "../types/projectSort.ts";
+import type { SortDirection } from "../types/sort.ts";
+import { getSortDirectionIndicator } from "../types/sort.ts";
 
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 
-type SortField = "cost" | "tokens" | "sessions" | "cache" | "cpr" | "activity";
+// ProjectSortField imported from ../types/projectSort.ts
 
 interface ModelStats {
   modelId: string;
@@ -264,50 +269,48 @@ function aggregateProjects(
 }
 
 // ---------------------------------------------------------------------------
-// Sort fields cycle
+// Sorting
 // ---------------------------------------------------------------------------
 
-const SORT_FIELDS: SortField[] = ["cost", "tokens", "sessions", "cache", "cpr", "activity"];
-
-const SORT_LABELS: Record<SortField, string> = {
-  cost: "COST",
-  tokens: "TOKENS",
-  sessions: "SESSIONS",
-  cache: "CACHE",
-  cpr: "$/REQ",
-  activity: "ACTIVITY",
-};
-
 function sortProjects(
   projects: ProjectStats[],
-  field: SortField,
-  _totalCost?: number,
+  field: ProjectSortField,
+  direction: SortDirection,
 ): ProjectStats[] {
   return [...projects].sort((a, b) => {
+    let cmp = 0;
     switch (field) {
       case "cost":
-        return b.cost - a.cost;
+        cmp = a.cost - b.cost;
+        break;
       case "tokens":
-        return b.tokens - a.tokens;
+        cmp = a.tokens - b.tokens;
+        break;
       case "sessions":
-        return b.sessionCount - a.sessionCount;
+        cmp = a.sessionCount - b.sessionCount;
+        break;
       case "cache": {
         const cacheA =
           a.inputTokens + a.cacheRead > 0 ? a.cacheRead / (a.inputTokens + a.cacheRead) : 0;
         const cacheB =
           b.inputTokens + b.cacheRead > 0 ? b.cacheRead / (b.inputTokens + b.cacheRead) : 0;
-        return cacheB - cacheA;
+        cmp = cacheA - cacheB;
+        break;
       }
       case "cpr": {
         const cprA = a.requestCount > 0 ? a.cost / a.requestCount : 0;
         const cprB = b.requestCount > 0 ? b.cost / b.requestCount : 0;
-        return cprB - cprA;
+        cmp = cprA - cprB;
+        break;
       }
       case "activity":
-        return b.activeSessions - a.activeSessions;
-      default:
-        return 0;
+        cmp = a.activeSessions - b.activeSessions;
+        break;
+      case "project":
+        cmp = a.name.localeCompare(b.name);
+        break;
     }
+    return direction === "desc" ? -cmp : cmp;
   });
 }
 
@@ -360,7 +363,8 @@ interface AggregateHeaderProps {
   projectCount: number;
   sessionCount: number;
   windowLabel: string;
-  sortField: SortField;
+  sortField: ProjectSortField;
+  sortDirection: SortDirection;
 }
 
 function AggregateHeader({
@@ -370,6 +374,7 @@ function AggregateHeader({
   sessionCount,
   windowLabel,
   sortField,
+  sortDirection,
 }: AggregateHeaderProps) {
   const colors = useColors();
   const avgPerProject = projectCount > 0 ? totalCost / projectCount : 0;
@@ -393,7 +398,10 @@ function AggregateHeader({
         <span fg={colors.text}>{formatCost(avgPerProject)}</span>
       </text>
       <text height={1} fg={colors.textMuted}>
-        [{windowLabel}] Sort: <span fg={colors.primary}>{SORT_LABELS[sortField]}</span>
+        [{windowLabel}] Sort:{" "}
+        <span fg={colors.primary}>
+          {getProjectSortFieldLabel(sortField)} {getSortDirectionIndicator(sortDirection)}
+        </span>
       </text>
     </box>
   );
@@ -1195,7 +1203,9 @@ export function ProjectsView() {
   const { setInputFocused } = useInputFocus();
 
   const [selectedIndex, setSelectedIndex] = useState(0);
-  const [sortField, setSortField] = useState<SortField>("cost");
+  const [sortField, setSortField] = useState<ProjectSortField>("cost");
+  const [sortDirection, setSortDirection] = useState<SortDirection>("desc");
+  const [showSortOverlay, setShowSortOverlay] = useState(false);
   const [showInsights, setShowInsights] = useState(termHeight >= 35);
   const [drawerProject, setDrawerProject] = useState<ProjectStats | null>(null);
   const [filterQuery, setFilterQuery] = useState("");
@@ -1246,13 +1256,44 @@ export function ProjectsView() {
 
   // Sort
   const sortedProjects = useMemo(
-    () => sortProjects(filteredProjects, sortField, totalCost),
-    [filteredProjects, sortField, totalCost],
+    () => sortProjects(filteredProjects, sortField, sortDirection),
+    [filteredProjects, sortField, sortDirection],
   );
 
   // Visible columns
   const visibleColumns: ColumnSpec[] = useMemo(() => getVisibleColumns(termWidth), [termWidth]);
 
+  // Map column keys → sort field IDs so we can hide sort fields for hidden columns.
+  // "tokens" has no dedicated column but is always available (related to cost data).
+  const COLUMN_TO_SORT_FIELD: Record<string, ProjectSortField> = {
+    project: "project",
+    cost: "cost",
+    sess: "sessions",
+    cache: "cache",
+    cpr: "cpr",
+    activity: "activity",
+  };
+
+  // Sort indicator helpers for column headers (matches SessionsTable pattern)
+  const sortIndicatorForCol = (colKey: string) => {
+    const field = COLUMN_TO_SORT_FIELD[colKey];
+    return field && sortField === field ? (sortDirection === "desc" ? "▼" : "▲") : " ";
+  };
+  const sortColorForCol = (colKey: string) => {
+    const field = COLUMN_TO_SORT_FIELD[colKey];
+    return field && sortField === field ? colors.primary : colors.textMuted;
+  };
+  const visibleSortFields = useMemo(() => {
+    const visibleFieldIds = new Set<ProjectSortField>(
+      visibleColumns
+        .map((c) => COLUMN_TO_SORT_FIELD[c.key])
+        .filter((id): id is ProjectSortField => id !== undefined),
+    );
+    // Always include tokens — no dedicated column but universally useful
+    visibleFieldIds.add("tokens");
+    return PROJECT_SORT_FIELDS.filter((f) => visibleFieldIds.has(f.id));
+  }, [visibleColumns]);
+
   // Stabilize selection across re-sorts: track selected project by path
   // so the highlight follows the same project when live data causes reordering.
   useLayoutEffect(() => {
@@ -1336,6 +1377,9 @@ export function ProjectsView() {
   useKeyboard(
     useCallback(
       (key: { name: string; shift?: boolean; ctrl?: boolean }) => {
+        // Sort overlay is open — let SortOverlay handle keys
+        if (showSortOverlay) return;
+
         // Drawer open: only Esc closes
         if (drawerProject) {
           if (key.name === "escape") {
@@ -1355,19 +1399,18 @@ export function ProjectsView() {
           return;
         }
 
+        // Open sort overlay menu
+        if (key.name === "s") {
+          setShowSortOverlay(true);
+          return;
+        }
+
         // Navigation
         if (key.name === "down" || key.name === "j") {
           setSelectedIndex((prev: number) => Math.min(prev + 1, sortedProjects.length - 1));
         } else if (key.name === "up" || key.name === "k") {
           setSelectedIndex((prev: number) => Math.max(prev - 1, 0));
         }
-        // Sort cycling
-        else if (key.name === "s") {
-          setSortField((prev: SortField) => {
-            const idx = SORT_FIELDS.indexOf(prev);
-            return SORT_FIELDS[(idx + 1) % SORT_FIELDS.length]!;
-          });
-        }
         // Time window
         else if (key.name === "t") {
           cycleWindow();
@@ -1401,7 +1444,15 @@ export function ProjectsView() {
           scrollOffsetRef.current = 0;
         }
       },
-      [drawerProject, isFiltering, sortedProjects, selectedIndex, cycleWindow, filterQuery],
+      [
+        drawerProject,
+        isFiltering,
+        sortedProjects,
+        selectedIndex,
+        cycleWindow,
+        filterQuery,
+        showSortOverlay,
+      ],
     ),
   );
 
@@ -1441,6 +1492,20 @@ export function ProjectsView() {
         />
       )}
 
+      {/* Sort overlay */}
+      {showSortOverlay && (
+        <SortOverlay
+          fields={visibleSortFields}
+          currentField={sortField}
+          currentDirection={sortDirection}
+          onSelect={(field, direction) => {
+            setSortField(() => field);
+            setSortDirection(() => direction);
+            setShowSortOverlay(false);
+          }}
+          onClose={() => setShowSortOverlay(false)}
+        />
+      )}
       {/* Aggregate header */}
       <AggregateHeader
         totalCost={visibleCost}
@@ -1449,6 +1514,7 @@ export function ProjectsView() {
         sessionCount={visibleSessions}
         windowLabel={windowLabel}
         sortField={sortField}
+        sortDirection={sortDirection}
       />
 
       {/* Column headers */}
@@ -1458,8 +1524,8 @@ export function ProjectsView() {
         </text>
         {visibleColumns.map((col: ColumnSpec) => (
           <box key={col.key} marginRight={1}>
-            <text width={col.width} height={1} fg={colors.textMuted}>
-              {padRight(col.label, col.width)}
+            <text width={col.width} height={1} fg={sortColorForCol(col.key)}>
+              {padRight(`${col.label}${sortIndicatorForCol(col.key)}`, col.width)}
             </text>
           </box>
         ))}

package/src/tui/views/RealTimeDashboard.tsx

@@ -2,11 +2,13 @@ import type { ScrollBoxRenderable } from "@opentui/core";
 import { useTerminalDimensions } from "@opentui/react";
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { notificationBus } from "@/plugins/notification-bus.ts";
+import { classifyProviderError } from "@/utils/error-category.ts";
 import { HelpOverlay } from "../components/HelpOverlay.tsx";
 import { KpiStrip } from "../components/KpiStrip.tsx";
 import { ProviderLimitsPanel } from "../components/ProviderLimitsPanel.tsx";
 import { SessionsTable } from "../components/SessionsTable.tsx";
 import { type DriverDimension, getSidebarMode, SmartSidebar } from "../components/SmartSidebar.tsx";
+import { SortOverlay } from "../components/SortOverlay.tsx";
 import { useAgentSessions } from "../contexts/AgentSessionContext.tsx";
 import { useConfig } from "../contexts/ConfigContext.tsx";
 import { useDashboardRuntime } from "../contexts/DashboardRuntimeContext.tsx";
@@ -15,6 +17,8 @@ import { usePlugins } from "../contexts/PluginContext.tsx";
 import { useColors } from "../contexts/ThemeContext.tsx";
 import { useTimeWindow } from "../contexts/TimeWindowContext.tsx";
 import { useDashboardKeyboard } from "../hooks/useDashboardKeyboard.ts";
+import type { SortDirection, SortField } from "../types/sort.ts";
+import { SORT_FIELDS } from "../types/sort.ts";
 import { getProviderColor } from "../utils/providerColor.ts";
 
 export function RealTimeDashboard() {
@@ -30,6 +34,23 @@ export function RealTimeDashboard() {
   const showLargeHeader = terminalHeight >= 35;
   const showProviderLimitsPanel = terminalHeight >= 24;
 
+  // SessionsTable hides REQ, NAME, DUR, TIME columns in narrow mode (<140).
+  // Filter sort fields to match visible columns.
+  const SESSIONS_WIDE_THRESHOLD = 140;
+  const NARROW_HIDDEN_FIELDS: ReadonlySet<SortField> = new Set([
+    "requests",
+    "name",
+    "duration",
+    "time",
+  ]);
+  const visibleSortFields = useMemo(
+    () =>
+      terminalWidth >= SESSIONS_WIDE_THRESHOLD
+        ? SORT_FIELDS
+        : SORT_FIELDS.filter((f) => !NARROW_HIDDEN_FIELDS.has(f.id)),
+    [terminalWidth],
+  );
+
   // Visible-row count for scroll tracking — every non-session-data line must be counted.
   const visibleRows = (() => {
     const appChrome = (showLargeHeader ? 7 : 1) + 1; // App.tsx: Header + StatusBar
@@ -61,7 +82,9 @@ export function RealTimeDashboard() {
   const [sidebarCollapsed, setSidebarCollapsed] = useState(config.display.sidebarCollapsed);
   const [filterQuery, setFilterQuery] = useState("");
   const [isFiltering, setIsFiltering] = useState(false);
-  const [sortField, setSortField] = useState<"cost" | "tokens" | "time">("cost");
+  const [sortField, setSortField] = useState<SortField>("time");
+  const [sortDirection, setSortDirection] = useState<SortDirection>("desc");
+  const [showSortOverlay, setShowSortOverlay] = useState(false);
   const [pendingG, setPendingG] = useState(false);
   const scrollOffsetRef = useRef(0);
   const selectedSessionIdRef = useRef<string | null>(null);
@@ -184,14 +207,53 @@ export function RealTimeDashboard() {
       const bActive = b.status === "active" ? 1 : 0;
       if (bActive !== aActive) return bActive - aActive;
 
-      if (sortField === "cost") return (b.totalCostUsd ?? 0) - (a.totalCostUsd ?? 0);
-      if (sortField === "tokens")
-        return b.totals.input + b.totals.output - (a.totals.input + a.totals.output);
-      return b.lastActivityAt - a.lastActivityAt;
+      let cmp = 0;
+      switch (sortField) {
+        case "cost":
+          cmp = (a.totalCostUsd ?? 0) - (b.totalCostUsd ?? 0);
+          break;
+        case "tokens":
+          cmp = a.totals.input + a.totals.output - (b.totals.input + b.totals.output);
+          break;
+        case "time":
+          cmp = a.lastActivityAt - b.lastActivityAt;
+          break;
+        case "requests":
+          cmp = a.requestCount - b.requestCount;
+          break;
+        case "duration": {
+          const aDur = (a.endedAt ?? Date.now()) - a.startedAt;
+          const bDur = (b.endedAt ?? Date.now()) - b.startedAt;
+          cmp = aDur - bDur;
+          break;
+        }
+        case "project": {
+          const aProj = a.projectPath?.split("/").pop() ?? "";
+          const bProj = b.projectPath?.split("/").pop() ?? "";
+          cmp = aProj.localeCompare(bProj);
+          break;
+        }
+        case "agent":
+          cmp = a.agentName.localeCompare(b.agentName);
+          break;
+        case "model": {
+          const aModel = a.streams[0]?.modelId ?? "";
+          const bModel = b.streams[0]?.modelId ?? "";
+          cmp = aModel.localeCompare(bModel);
+          break;
+        }
+        case "name": {
+          const aName = a.sessionName ?? "";
+          const bName = b.sessionName ?? "";
+          cmp = aName.localeCompare(bName);
+          break;
+        }
+      }
+      return sortDirection === "desc" ? -cmp : cmp;
     });
 
     return result;
-  }, [baseFilteredSessions, activeDriverFilter, driverDimension, sortField]);
+  }, [baseFilteredSessions, activeDriverFilter, driverDimension, sortField, sortDirection]);
 
   // Stabilize selection across re-sorts: track selected session by ID
   // so the highlight follows the same session when live data causes reordering.
@@ -261,6 +323,7 @@ export function RealTimeDashboard() {
       filterQuery,
       isFiltering,
       sortField,
+      sortDirection,
       pendingG,
       scrollOffset: scrollOffsetRef.current,
       limitSelectedIndex,
@@ -269,6 +332,7 @@ export function RealTimeDashboard() {
       selectedDriverIndex,
       activeDriverFilter,
       sidebarMode,
+      showSortOverlay,
     },
     actions: {
       setShowHelp,
@@ -280,12 +344,14 @@ export function RealTimeDashboard() {
       setFilterQuery,
       setIsFiltering,
       setSortField,
+      setSortDirection,
       setPendingG,
       setScrollOffset,
       setLimitSelectedIndex,
       setDriverDimension,
       setSelectedDriverIndex,
       setActiveDriverFilter,
+      setShowSortOverlay,
     },
     processedSessions,
   });
@@ -348,6 +414,19 @@ export function RealTimeDashboard() {
   return (
     <box flexDirection="column" flexGrow={1} padding={1} gap={1} overflow="hidden">
       {showHelp && <HelpOverlay />}
+      {showSortOverlay && (
+        <SortOverlay
+          fields={visibleSortFields}
+          currentField={sortField}
+          currentDirection={sortDirection}
+          onSelect={(field, direction) => {
+            setSortField(() => field);
+            setSortDirection(() => direction);
+            setShowSortOverlay(false);
+          }}
+          onClose={() => setShowSortOverlay(false)}
+        />
+      )}
 
       <KpiStrip
         totalCost={windowedKpis.cost}
@@ -382,7 +461,9 @@ export function RealTimeDashboard() {
           name: p.plugin.name,
           usedPercent: getMaxUsedPercent(p),
           color: providerColorOf(p.plugin.id),
-          ...(p.usage?.error ? { error: p.usage.error } : {}),
+          ...(p.usage?.error
+            ? { error: p.usage.error, errorCategory: classifyProviderError(p.usage.error) }
+            : {}),
         }))}
         focused={focusedPanel === "limits"}
         selectedIndex={limitSelectedIndex}
@@ -416,6 +497,8 @@ export function RealTimeDashboard() {
           focusedPanel={focusedPanel}
           windowLabel={windowLabel}
           getProviderColor={providerColorOf}
+          sortField={sortField}
+          sortDirection={sortDirection}
         />
 
         {!effectiveSidebarCollapsed && (
@@ -440,7 +523,7 @@ export function RealTimeDashboard() {
               : activeDriverFilter
                 ? `Filter: ${activeDriverFilter}  Esc clear`
                 : focusedPanel === "sessions"
-                  ? "/ filter  ↑↓ navigate  Enter details  s sort  l limits  Tab next  ⇧Tab prev"
+                  ? "/ filter  ↑↓ navigate  Enter details  s sort  l limits  Tab next"
                   : focusedPanel === "limits"
                     ? "←→ select provider  Tab next  ⇧Tab prev  Esc back"
                     : focusedPanel === "sidebar"

package/src/utils/__tests__/error-category.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test";
+import { classifyProviderError } from "../error-category.ts";
+
+describe("classifyProviderError", () => {
+  describe("auth errors", () => {
+    test("classifies expired token errors", () => {
+      expect(classifyProviderError("Token expired. Run any command in OpenCode to refresh.")).toBe(
+        "auth",
+      );
+      expect(
+        classifyProviderError(
+          "Token expired or invalid. Re-authenticate in OpenCode or Claude Code.",
+        ),
+      ).toBe("auth");
+      expect(classifyProviderError("OAuth token expired. Re-authenticate in OpenCode.")).toBe(
+        "auth",
+      );
+      expect(
+        classifyProviderError("OAuth token expired or invalid. Re-authenticate in OpenCode."),
+      ).toBe("auth");
+      expect(
+        classifyProviderError("OAuth token expired or invalid. Re-authenticate via Gemini CLI."),
+      ).toBe("auth");
+      expect(classifyProviderError("Claude Code token expired")).toBe("auth");
+    });
+
+    test("classifies scope errors", () => {
+      expect(
+        classifyProviderError(
+          "Token lacks required scope. Re-authenticate in OpenCode or Claude Code.",
+        ),
+      ).toBe("auth");
+    });
+
+    test("classifies missing credential errors", () => {
+      expect(
+        classifyProviderError(
+          "OAuth token or API key required. Authenticate via OpenCode or Claude Code.",
+        ),
+      ).toBe("auth");
+      expect(
+        classifyProviderError(
+          "OAuth token required. Sign in via OpenCode with ChatGPT Pro account.",
+        ),
+      ).toBe("auth");
+      expect(
+        classifyProviderError("OAuth token required. Sign in via OpenCode with Google account."),
+      ).toBe("auth");
+      expect(
+        classifyProviderError("OAuth token required. Login via Gemini CLI with Google account."),
+      ).toBe("auth");
+      expect(
+        classifyProviderError("API key required. Set OPENAI_API_KEY environment variable."),
+      ).toBe("auth");
+      expect(
+        classifyProviderError("API key required. Set PERPLEXITY_API_KEY environment variable."),
+      ).toBe("auth");
+      expect(classifyProviderError("API key required. Configure MiniMax in OpenCode.")).toBe(
+        "auth",
+      );
+      expect(classifyProviderError("API key required. Configure Chutes in OpenCode.")).toBe("auth");
+      expect(classifyProviderError("API key required. Configure Z.ai in OpenCode.")).toBe("auth");
+      expect(
+        classifyProviderError("API key required. Run /connect in OpenCode to set up Zen."),
+      ).toBe("auth");
+    });
+
+    test("classifies authorization failure errors", () => {
+      expect(classifyProviderError("Authorization failed. Check your MiniMax API key.")).toBe(
+        "auth",
+      );
+      expect(classifyProviderError("Authorization failed. Check your Chutes API key.")).toBe(
+        "auth",
+      );
+      expect(classifyProviderError("Authorization failed. Check your Z.ai API key.")).toBe("auth");
+    });
+
+    test("classifies invalid key errors", () => {
+      expect(classifyProviderError("Invalid API key")).toBe("auth");
+      expect(classifyProviderError("Unauthorized – check API key")).toBe("auth");
+    });
+
+    test("classifies HTTP status code auth errors", () => {
+      expect(classifyProviderError("API error: 401 Unauthorized")).toBe("auth");
+      expect(classifyProviderError("API error: 403 Forbidden")).toBe("auth");
+      expect(classifyProviderError("Authentication failed (401). Check API key.")).toBe("auth");
+    });
+
+    test("classifies not-configured errors", () => {
+      expect(classifyProviderError("Not configured: missing GitHub token")).toBe("auth");
+      expect(classifyProviderError("Copilot not enabled for this account")).toBe("auth");
+    });
+
+    test("classifies refresh failure errors", () => {
+      expect(classifyProviderError("No valid access token and refresh failed.")).toBe("auth");
+      expect(
+        classifyProviderError("ChatGPT account ID required. Re-authenticate in OpenCode."),
+      ).toBe("auth");
+      expect(
+        classifyProviderError(
+          "MiniMax groupId required. Set MINIMAX_GROUP_ID or configure in OpenCode.",
+        ),
+      ).toBe("auth");
+    });
+  });
+
+  describe("rate limit errors", () => {
+    test("classifies rate limit errors", () => {
+      expect(classifyProviderError("Rate limited")).toBe("rate_limit");
+      expect(classifyProviderError("API error: 429 Too Many Requests")).toBe("rate_limit");
+    });
+  });
+
+  describe("insufficient credits errors", () => {
+    test("classifies insufficient credits errors", () => {
+      expect(classifyProviderError("Insufficient credits")).toBe("insufficient_credits");
+    });
+  });
+
+  describe("timeout errors", () => {
+    test("classifies timeout errors", () => {
+      expect(classifyProviderError("The operation timed out")).toBe("timeout");
+      expect(classifyProviderError("Request timeout")).toBe("timeout");
+      expect(classifyProviderError("ETIMEDOUT")).toBe("timeout");
+      expect(classifyProviderError("Request aborted")).toBe("timeout");
+    });
+  });
+
+  describe("network errors", () => {
+    test("classifies network errors", () => {
+      expect(classifyProviderError("fetch failed")).toBe("network");
+      expect(classifyProviderError("ECONNREFUSED")).toBe("network");
+      expect(classifyProviderError("ENOTFOUND")).toBe("network");
+      expect(classifyProviderError("ECONNRESET")).toBe("network");
+      expect(classifyProviderError("DNS resolution failed")).toBe("network");
+      expect(classifyProviderError("Network error")).toBe("network");
+    });
+  });
+
+  describe("unknown errors", () => {
+    test("classifies unrecognized errors as unknown", () => {
+      expect(classifyProviderError("Unknown error")).toBe("unknown");
+      expect(classifyProviderError("API error: 500 Internal Server Error")).toBe("unknown");
+      expect(classifyProviderError("Something went wrong")).toBe("unknown");
+    });
+  });
+});

package/src/utils/currency.ts

@@ -26,7 +26,9 @@ export function parseCurrencyInput(input: string): number | null {
   } else if (hasComma) {
     const parts = normalized.split(",");
     // 3 digits after comma = thousands separator (1,234), otherwise decimal (10,50)
-    if (parts.length === 2 && parts[1]!.length === 3 && parts[0]!.length > 0) {
+    const afterComma = parts[1]?.length ?? 0;
+    const beforeComma = parts[0]?.length ?? 0;
+    if (parts.length === 2 && afterComma === 3 && beforeComma > 0) {
       normalized = normalized.replace(",", "");
     } else {
       normalized = normalized.replace(",", ".");
@@ -35,7 +37,7 @@ export function parseCurrencyInput(input: string): number | null {
 
   const parsed = parseFloat(normalized);
 
-  if (isNaN(parsed) || !isFinite(parsed)) {
+  if (Number.isNaN(parsed) || !Number.isFinite(parsed)) {
     return null;
   }