@gokulvenkatareddy/cortex 0.1.7

package/apps/octogent/apps/web/tests/app-shell-navigation.test.tsx

@@ -0,0 +1,109 @@
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { App } from "../src/App";
+import { jsonResponse, notFoundResponse, resetAppTestHarness } from "./test-utils/appTestHarness";
+
+const mockShellRequests = () => {
+  vi.spyOn(globalThis, "fetch").mockImplementation(async (input, init) => {
+    const url = String(input);
+    const method = init?.method ?? "GET";
+
+    if (url.endsWith("/api/terminal-snapshots") && method === "GET") {
+      return jsonResponse([]);
+    }
+
+    if (url.endsWith("/api/codex/usage") && method === "GET") {
+      return jsonResponse({
+        status: "unavailable",
+        source: "none",
+        fetchedAt: "2026-02-27T12:00:00.000Z",
+      });
+    }
+
+    if (url.endsWith("/api/claude/usage") && method === "GET") {
+      return jsonResponse({
+        status: "unavailable",
+        source: "none",
+        fetchedAt: "2026-02-27T12:00:00.000Z",
+      });
+    }
+
+    if (url.endsWith("/api/github/summary") && method === "GET") {
+      return jsonResponse({
+        status: "unavailable",
+        source: "none",
+        fetchedAt: "2026-02-27T12:00:00.000Z",
+        commitsPerDay: [],
+      });
+    }
+
+    if (url.includes("/api/analytics/usage-heatmap") && method === "GET") {
+      return jsonResponse({
+        days: [],
+        projects: [],
+        models: [],
+      });
+    }
+
+    if (url.endsWith("/api/ui-state") && method === "GET") {
+      return jsonResponse({});
+    }
+
+    return notFoundResponse();
+  });
+};
+
+describe("App shell and navigation", () => {
+  afterEach(() => {
+    cleanup();
+    resetAppTestHarness();
+  });
+
+  it("renders the current shell chrome with navigation hints", async () => {
+    mockShellRequests();
+
+    render(<App />);
+
+    expect(await screen.findByLabelText("Runtime status strip")).toBeInTheDocument();
+    expect(screen.getByRole("navigation", { name: "Primary navigation" })).toBeInTheDocument();
+    expect(screen.getByLabelText("Main content canvas")).toBeInTheDocument();
+    expect(screen.getByLabelText("Telemetry ticker tape")).toBeInTheDocument();
+    expect(screen.queryByLabelText("Active Agents sidebar")).not.toBeInTheDocument();
+    expect(screen.getByText("Press 1-8 to navigate")).toBeInTheDocument();
+  });
+
+  it("supports keyboard-first primary navigation with number keys 1-8", async () => {
+    mockShellRequests();
+
+    render(<App />);
+    await screen.findByRole("navigation", { name: "Primary navigation" });
+
+    fireEvent.keyDown(window, { key: "4" });
+
+    expect(
+      screen.getByRole("button", {
+        name: "[4] Code Intel",
+      }),
+    ).toHaveAttribute("aria-current", "page");
+  });
+
+  it("renders settings panel when navigating to settings tab", async () => {
+    mockShellRequests();
+
+    render(<App />);
+    await screen.findByRole("navigation", { name: "Primary navigation" });
+
+    fireEvent.click(
+      screen.getByRole("button", {
+        name: "[8] Settings",
+      }),
+    );
+
+    expect(await screen.findByLabelText("Settings primary view")).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: /Soft chime/i })).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: /Retro beep/i })).toBeInTheDocument();
+    expect(screen.getByRole("switch", { name: "Show runtime status strip" })).toBeInTheDocument();
+    expect(screen.getByRole("switch", { name: "Enable X Monitor" })).toBeInTheDocument();
+  });
+});

package/apps/octogent/apps/web/tests/app-swarm-refresh.test.tsx

@@ -0,0 +1,268 @@
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { MockWebSocket, resetAppTestHarness } from "./test-utils/appTestHarness";
+
+const persistedUiStateMock = {
+  activePrimaryNav: 2 as const,
+  setActivePrimaryNav: vi.fn(),
+  applyHydratedUiState: vi.fn(),
+  isActiveAgentsSectionExpanded: true,
+  isAgentsSidebarVisible: false,
+  isBottomTelemetryVisible: false,
+  isClaudeUsageSectionExpanded: true,
+  isCodexUsageSectionExpanded: true,
+  isMonitorVisible: false,
+  isRuntimeStatusStripVisible: false,
+  isUiStateHydrated: true,
+  minimizedTerminalIds: [] as string[],
+  readUiState: vi.fn(),
+  setIsActiveAgentsSectionExpanded: vi.fn(),
+  setIsAgentsSidebarVisible: vi.fn(),
+  setIsBottomTelemetryVisible: vi.fn(),
+  setIsClaudeUsageSectionExpanded: vi.fn(),
+  setIsCodexUsageSectionExpanded: vi.fn(),
+  setIsMonitorVisible: vi.fn(),
+  setIsRuntimeStatusStripVisible: vi.fn(),
+  setIsUiStateHydrated: vi.fn(),
+  setMinimizedTerminalIds: vi.fn(),
+  setSidebarWidth: vi.fn(),
+  setTerminalCompletionSound: vi.fn(),
+  sidebarWidth: 280,
+  terminalCompletionSound: "pop" as const,
+  canvasOpenTerminalIds: [] as string[],
+  setCanvasOpenTerminalIds: vi.fn(),
+  canvasOpenTentacleIds: [] as string[],
+  setCanvasOpenTentacleIds: vi.fn(),
+  canvasTerminalsPanelWidth: null as number | null,
+  setCanvasTerminalsPanelWidth: vi.fn(),
+};
+
+vi.mock("../src/app/hooks/useBackendLivenessPolling", () => ({
+  useBackendLivenessPolling: () => "online",
+}));
+
+vi.mock("../src/app/hooks/useClaudeUsagePolling", () => ({
+  useClaudeUsagePolling: () => ({
+    claudeUsageSnapshot: null,
+    isRefreshingClaudeUsage: false,
+    refreshClaudeUsage: vi.fn(),
+  }),
+}));
+
+vi.mock("../src/app/hooks/useCodexUsagePolling", () => ({
+  useCodexUsagePolling: () => ({
+    codexUsageSnapshot: null,
+    refreshCodexUsage: vi.fn(),
+  }),
+}));
+
+vi.mock("../src/app/hooks/useConsoleKeyboardShortcuts", () => ({
+  useConsoleKeyboardShortcuts: () => {},
+}));
+
+vi.mock("../src/app/hooks/useGitHubPrimaryViewModel", () => ({
+  useGitHubPrimaryViewModel: () => ({
+    githubCommitCount30d: "0",
+    sparklinePoints: [],
+    githubOverviewGraphSeries: [],
+    githubOverviewGraphPolylinePoints: "",
+    githubOverviewHoverLabel: null,
+    githubStatusPill: null,
+    githubRepoLabel: "",
+    githubStarCountLabel: "",
+    githubOpenIssuesLabel: "",
+    githubOpenPrsLabel: "",
+    githubRecentCommits: [],
+  }),
+}));
+
+vi.mock("../src/app/hooks/useGithubSummaryPolling", () => ({
+  useGithubSummaryPolling: () => ({
+    githubRepoSummary: null,
+    isRefreshingGitHubSummary: false,
+    refreshGitHubRepoSummary: vi.fn(),
+  }),
+}));
+
+vi.mock("../src/app/hooks/useInitialColumnsHydration", async () => {
+  const React = await import("react");
+
+  return {
+    useInitialColumnsHydration: ({
+      setColumns,
+      setIsLoading,
+      setIsUiStateHydrated,
+    }: {
+      setColumns: (value: []) => void;
+      setIsLoading: (value: boolean) => void;
+      setIsUiStateHydrated: (value: boolean) => void;
+    }) => {
+      React.useEffect(() => {
+        setColumns([]);
+        setIsLoading(false);
+        setIsUiStateHydrated(true);
+      }, [setColumns, setIsLoading, setIsUiStateHydrated]);
+    },
+  };
+});
+
+vi.mock("../src/app/hooks/useMonitorRuntime", () => ({
+  useMonitorRuntime: () => null,
+}));
+
+vi.mock("../src/app/hooks/usePersistedUiState", () => ({
+  usePersistedUiState: () => persistedUiStateMock,
+}));
+
+vi.mock("../src/app/hooks/useTentacleGitLifecycle", () => ({
+  useTentacleGitLifecycle: () => ({
+    gitStatusByTentacleId: new Map(),
+    gitStatusLoadingByTentacleId: new Map(),
+    pullRequestByTentacleId: new Map(),
+    pullRequestLoadingByTentacleId: new Map(),
+    openGitTentacleId: null,
+    openGitTentacleStatus: null,
+    openGitTentaclePullRequest: null,
+    gitCommitMessageDraft: "",
+    gitDialogError: null,
+    isGitDialogLoading: false,
+    isGitDialogMutating: false,
+    setGitCommitMessageDraft: vi.fn(),
+    openTentacleGitActions: vi.fn(),
+    closeTentacleGitActions: vi.fn(),
+    commitTentacleChanges: vi.fn(),
+    commitAndPushTentacleBranch: vi.fn(),
+    pushTentacleBranch: vi.fn(),
+    syncTentacleBranch: vi.fn(),
+    mergeTentaclePullRequest: vi.fn(),
+  }),
+}));
+
+vi.mock("../src/app/hooks/useTerminalCompletionNotification", () => ({
+  useTerminalCompletionNotification: () => ({
+    playCompletionSoundPreview: vi.fn(),
+  }),
+}));
+
+vi.mock("../src/app/hooks/useTerminalMutations", () => ({
+  useTerminalMutations: () => ({
+    clearPendingDeleteTerminal: vi.fn(),
+    confirmDeleteTerminal: vi.fn(),
+    createTerminal: vi.fn(),
+    isCreatingTerminal: false,
+    isDeletingTerminalId: null,
+    pendingDeleteTerminal: null,
+    requestDeleteTerminal: vi.fn(),
+  }),
+}));
+
+vi.mock("../src/app/hooks/useTerminalStateReconciliation", () => ({
+  useTerminalStateReconciliation: () => {},
+}));
+
+vi.mock("../src/app/hooks/useUsageHeatmapPolling", () => ({
+  useUsageHeatmapPolling: () => ({
+    heatmapData: [],
+    isLoadingHeatmap: false,
+    refreshHeatmap: vi.fn(),
+  }),
+}));
+
+vi.mock("../src/components/ActiveAgentsSidebar", () => ({
+  ActiveAgentsSidebar: () => null,
+}));
+
+vi.mock("../src/components/ConsolePrimaryNav", () => ({
+  ConsolePrimaryNav: () => null,
+}));
+
+vi.mock("../src/components/PrimaryViewRouter", () => ({
+  PrimaryViewRouter: ({
+    canvasPrimaryViewProps,
+  }: {
+    canvasPrimaryViewProps: {
+      onSpawnSwarm?: (tentacleId: string, workspaceMode: "shared" | "worktree") => Promise<void>;
+      onSolveTodoItem?: ((tentacleId: string, itemIndex: number) => Promise<void>) | undefined;
+    };
+  }) => (
+    <div>
+      <button
+        type="button"
+        onClick={() => void canvasPrimaryViewProps.onSpawnSwarm?.("docs-knowledge", "shared")}
+      >
+        Spawn Swarm
+      </button>
+      <span>
+        {canvasPrimaryViewProps.onSolveTodoItem
+          ? "solve callback present"
+          : "solve callback omitted"}
+      </span>
+    </div>
+  ),
+}));
+
+vi.mock("../src/components/RuntimeStatusStrip", () => ({
+  RuntimeStatusStrip: () => null,
+}));
+
+vi.mock("../src/components/SidebarActionPanel", () => ({
+  SidebarActionPanel: () => null,
+}));
+
+vi.mock("../src/components/TelemetryTape", () => ({
+  TelemetryTape: () => null,
+}));
+
+import { App } from "../src/App";
+
+describe("App swarm actions", () => {
+  afterEach(() => {
+    cleanup();
+    resetAppTestHarness();
+  });
+
+  it("does not force a terminal snapshot refresh after spawning a swarm", async () => {
+    vi.stubGlobal("WebSocket", MockWebSocket as unknown as typeof WebSocket);
+
+    let terminalSnapshotReads = 0;
+    const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(async (input, init) => {
+      const url = String(input);
+      const method = init?.method ?? "GET";
+
+      if (url.endsWith("/api/terminal-snapshots") && method === "GET") {
+        terminalSnapshotReads += 1;
+        return new Response("[]", {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+
+      if (url.endsWith("/api/deck/tentacles/docs-knowledge/swarm") && method === "POST") {
+        return new Response(JSON.stringify({ ok: true }), {
+          status: 201,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+
+      return new Response("not-found", { status: 404 });
+    });
+
+    render(<App />);
+
+    expect(screen.getByText("solve callback omitted")).toBeInTheDocument();
+    fireEvent.click(screen.getByRole("button", { name: "Spawn Swarm" }));
+
+    await waitFor(() => {
+      expect(
+        fetchMock.mock.calls.some(
+          ([calledUrl, calledInit]) =>
+            String(calledUrl).endsWith("/api/deck/tentacles/docs-knowledge/swarm") &&
+            (calledInit?.method ?? "GET") === "POST",
+        ),
+      ).toBe(true);
+    });
+
+    expect(terminalSnapshotReads).toBe(0);
+  });
+});

package/apps/octogent/apps/web/tests/app-ui-state-persistence.test.tsx

@@ -0,0 +1,116 @@
+import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { App } from "../src/App";
+import { jsonResponse, notFoundResponse, resetAppTestHarness } from "./test-utils/appTestHarness";
+
+describe("App UI state persistence", () => {
+  afterEach(() => {
+    cleanup();
+    resetAppTestHarness();
+  });
+
+  it("hydrates ui state from the API and persists ui changes back to the API", async () => {
+    const uiStatePatchBodies: Array<Record<string, unknown>> = [];
+
+    vi.spyOn(globalThis, "fetch").mockImplementation(async (input, init) => {
+      const url = String(input);
+      const method = init?.method ?? "GET";
+
+      if (url.endsWith("/api/terminal-snapshots") && method === "GET") {
+        return jsonResponse([]);
+      }
+
+      if (url.endsWith("/api/claude/usage") && method === "GET") {
+        return jsonResponse({
+          status: "unavailable",
+          fetchedAt: "2026-02-24T10:00:00.000Z",
+          source: "none",
+        });
+      }
+
+      if (url.endsWith("/api/codex/usage") && method === "GET") {
+        return jsonResponse({
+          status: "unavailable",
+          fetchedAt: "2026-02-24T10:00:00.000Z",
+          source: "none",
+        });
+      }
+
+      if (url.endsWith("/api/github/summary") && method === "GET") {
+        return jsonResponse({
+          status: "unavailable",
+          source: "none",
+          fetchedAt: "2026-02-24T10:00:00.000Z",
+          commitsPerDay: [],
+        });
+      }
+
+      if (url.includes("/api/analytics/usage-heatmap") && method === "GET") {
+        return jsonResponse({
+          days: [],
+          projects: [],
+          models: [],
+        });
+      }
+
+      if (url.endsWith("/api/ui-state") && method === "GET") {
+        return jsonResponse({
+          activePrimaryNav: 8,
+          isRuntimeStatusStripVisible: false,
+          isMonitorVisible: false,
+          isBottomTelemetryVisible: false,
+          terminalCompletionSound: "retro-beep",
+        });
+      }
+
+      if (url.endsWith("/api/ui-state") && method === "PATCH") {
+        const body = init?.body;
+        if (typeof body === "string") {
+          uiStatePatchBodies.push(JSON.parse(body) as Record<string, unknown>);
+        }
+
+        return new Response(body ?? "{}", {
+          status: 200,
+          headers: {
+            "Content-Type": "application/json",
+          },
+        });
+      }
+
+      return notFoundResponse();
+    });
+
+    render(<App />);
+
+    expect(await screen.findByLabelText("Settings primary view")).toBeInTheDocument();
+    expect(screen.queryByLabelText("Runtime status strip")).toBeNull();
+    expect(screen.queryByLabelText("Telemetry ticker tape")).toBeNull();
+    expect(screen.getByRole("button", { name: /Retro beep/i })).toHaveAttribute(
+      "aria-pressed",
+      "true",
+    );
+    expect(screen.getByRole("switch", { name: "Show runtime status strip" })).toHaveAttribute(
+      "aria-checked",
+      "false",
+    );
+    expect(screen.getByRole("switch", { name: "Enable X Monitor" })).toHaveAttribute(
+      "aria-checked",
+      "false",
+    );
+
+    fireEvent.click(screen.getByRole("switch", { name: "Show runtime status strip" }));
+    fireEvent.click(screen.getByRole("switch", { name: "Enable X Monitor" }));
+    fireEvent.click(screen.getByRole("button", { name: /Double beep/i }));
+
+    await waitFor(() => {
+      expect(uiStatePatchBodies.some((body) => body.isRuntimeStatusStripVisible === true)).toBe(
+        true,
+      );
+      expect(uiStatePatchBodies.some((body) => body.isMonitorVisible === true)).toBe(true);
+      expect(
+        uiStatePatchBodies.some((body) => body.terminalCompletionSound === "double-beep"),
+      ).toBe(true);
+    });
+  });
+});