@gokulvenkatareddy/cortex 0.1.7

package/apps/octogent/apps/web/tests/app-workspace-setup.test.tsx

@@ -0,0 +1,217 @@
+import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import type { WorkspaceSetupSnapshot } from "@octogent/core";
+
+import { App } from "../src/App";
+import { jsonResponse, notFoundResponse, resetAppTestHarness } from "./test-utils/appTestHarness";
+
+const buildSetupSnapshot = (
+  overrides: Partial<WorkspaceSetupSnapshot> = {},
+): WorkspaceSetupSnapshot => ({
+  isFirstRun: true,
+  shouldShowSetupCard: true,
+  hasAnyTentacles: false,
+  tentacleCount: 0,
+  steps: [
+    {
+      id: "initialize-workspace",
+      title: "Initialize workspace",
+      description: "Create Octogent project files and runtime directories.",
+      complete: false,
+      required: true,
+      actionLabel: "Initialize workspace",
+      statusText: "Create .octogent project files before continuing.",
+      guidance: "Workspace initialization failed. Run the Octogent initializer in this repository.",
+      command: "octogent init",
+    },
+    {
+      id: "ensure-gitignore",
+      title: "Ignore .octogent",
+      description: "Add .octogent to .gitignore, or create .gitignore when it is missing.",
+      complete: false,
+      required: true,
+      actionLabel: "Update .gitignore",
+      statusText: "Add .octogent to .gitignore before creating tentacles.",
+      guidance:
+        "Git ignore entry is missing. Create or update .gitignore with the Octogent workspace path.",
+      command: "printf '.octogent\\n' >> .gitignore",
+    },
+    {
+      id: "check-claude",
+      title: "Check Claude Code",
+      description: "Verify the default Claude Code workflow is available on this machine.",
+      complete: true,
+      required: false,
+      actionLabel: "Check Claude Code",
+      statusText: "Claude Code is available.",
+      guidance: null,
+      command: null,
+    },
+    {
+      id: "check-git",
+      title: "Check Git",
+      description: "Verify Git is available for worktree-backed tentacles.",
+      complete: true,
+      required: false,
+      actionLabel: "Check Git",
+      statusText: "Git is available.",
+      guidance: null,
+      command: null,
+    },
+    {
+      id: "check-curl",
+      title: "Check curl",
+      description: "Verify curl is available for Claude hook callbacks.",
+      complete: true,
+      required: false,
+      actionLabel: "Check curl",
+      statusText: "curl is available.",
+      guidance: null,
+      command: null,
+    },
+    {
+      id: "create-tentacles",
+      title: "Create tentacles",
+      description: "Create at least one tentacle before launching a coding agent.",
+      complete: false,
+      required: true,
+      actionLabel: null,
+      statusText: "Create your first tentacle to continue.",
+      guidance: "Use the planner or manual creation to add at least one tentacle.",
+      command: null,
+    },
+  ],
+  ...overrides,
+});
+
+const mockAppRequests = (
+  resolveSetup: () => WorkspaceSetupSnapshot,
+  options: {
+    onEnsureGitignoreStep?: () => WorkspaceSetupSnapshot;
+  } = {},
+) => {
+  return 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/deck/tentacles") && method === "GET") {
+      return jsonResponse([]);
+    }
+
+    if (url.endsWith("/api/setup") && method === "GET") {
+      return jsonResponse(resolveSetup());
+    }
+
+    if (url.endsWith("/api/setup/steps/ensure-gitignore") && method === "POST") {
+      return jsonResponse(
+        options.onEnsureGitignoreStep ? options.onEnsureGitignoreStep() : resolveSetup(),
+      );
+    }
+
+    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({});
+    }
+
+    if (url.endsWith("/api/ui-state") && method === "PATCH") {
+      return jsonResponse({});
+    }
+
+    return notFoundResponse();
+  });
+};
+
+describe("App workspace setup", () => {
+  afterEach(() => {
+    cleanup();
+    resetAppTestHarness();
+  });
+
+  it("shows the setup card inside the normal Agents view on a fresh workspace", async () => {
+    const currentSetup = buildSetupSnapshot();
+    mockAppRequests(() => currentSetup);
+
+    render(<App />);
+
+    expect(await screen.findByLabelText("Workspace setup")).toBeInTheDocument();
+    expect(screen.getByRole("navigation", { name: "Primary navigation" })).toBeInTheDocument();
+    expect(screen.getByLabelText("Main content canvas")).toBeInTheDocument();
+    expect(screen.getByLabelText("Canvas graph view")).toBeInTheDocument();
+    expect(screen.getByLabelText("Runtime status strip")).toBeInTheDocument();
+    expect(
+      screen.getByRole("button", {
+        name: "[1] Agents",
+      }),
+    ).toHaveAttribute("aria-current", "page");
+  });
+
+  it("only marks a setup step complete after the refreshed server snapshot says it is done", async () => {
+    let currentSetup = buildSetupSnapshot();
+    mockAppRequests(() => currentSetup, {
+      onEnsureGitignoreStep: () => {
+        currentSetup = buildSetupSnapshot({
+          steps: buildSetupSnapshot().steps.map((step) =>
+            step.id === "ensure-gitignore"
+              ? {
+                  ...step,
+                  complete: true,
+                  statusText: ".gitignore covers .octogent.",
+                  guidance: null,
+                  command: null,
+                }
+              : step,
+          ),
+        });
+        return currentSetup;
+      },
+    });
+
+    render(<App />);
+
+    const setupCard = await screen.findByLabelText("Workspace setup");
+    fireEvent.click(within(setupCard).getByRole("button", { name: "Update .gitignore" }));
+
+    await waitFor(() => {
+      const gitignoreStep = screen.getByText("Ignore .octogent").closest(".workspace-setup-step");
+      expect(gitignoreStep).not.toBeNull();
+      expect(within(gitignoreStep as HTMLElement).getByText("Done")).toBeInTheDocument();
+    });
+  });
+});

package/apps/octogent/apps/web/tests/canvas-tentacle-panel.test.tsx

@@ -0,0 +1,195 @@
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { CanvasTentaclePanel } from "../src/components/canvas/CanvasTentaclePanel";
+
+const tentacle = {
+  tentacleId: "docs-knowledge",
+  displayName: "Docs & Knowledge",
+  description: "Keep docs aligned with the product.",
+  status: "active" as const,
+  color: "#ff6b2b",
+  octopus: {
+    animation: null,
+    expression: null,
+    accessory: null,
+    hairColor: null,
+  },
+  scope: { paths: [], tags: [] },
+  vaultFiles: ["todo.md"],
+  todoTotal: 2,
+  todoDone: 0,
+  todoItems: [
+    { text: "Audit docs", done: false },
+    { text: "Consolidate principles", done: false },
+  ],
+  suggestedSkills: ["docs-writer", "release-helper"],
+};
+
+describe("CanvasTentaclePanel actions", () => {
+  afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+  });
+
+  it("offers worktree and normal swarm options", async () => {
+    const onSpawnSwarm = vi.fn();
+
+    render(
+      <CanvasTentaclePanel
+        node={{
+          id: "docs-knowledge",
+          type: "tentacle",
+          x: 0,
+          y: 0,
+          vx: 0,
+          vy: 0,
+          pinned: false,
+          radius: 48,
+          tentacleId: "docs-knowledge",
+          label: "Docs & Knowledge",
+          color: "#ff6b2b",
+        }}
+        tentacle={tentacle}
+        sessions={[]}
+        onClose={() => {}}
+        onSpawnSwarm={onSpawnSwarm}
+      />,
+    );
+
+    const worktreeButton = await screen.findByRole("button", {
+      name: /spawn swarm \(worktrees\)/i,
+    });
+    const normalButton = await screen.findByRole("button", {
+      name: /spawn swarm \(normal\)/i,
+    });
+
+    fireEvent.click(worktreeButton);
+    fireEvent.click(normalButton);
+
+    expect(onSpawnSwarm).toHaveBeenNthCalledWith(1, "docs-knowledge", "worktree");
+    expect(onSpawnSwarm).toHaveBeenNthCalledWith(2, "docs-knowledge", "shared");
+  });
+
+  it("spawns a dedicated agent for an individual todo item", async () => {
+    const onSolveTodoItem = vi.fn();
+
+    vi.spyOn(globalThis, "fetch").mockImplementation(async (input, init) => {
+      const url = String(input);
+
+      if (url.endsWith("/api/deck/tentacles/docs-knowledge/todo/solve")) {
+        expect(init?.method).toBe("POST");
+        expect(init?.body).toBe(JSON.stringify({ itemIndex: 0 }));
+        return new Response(JSON.stringify({ terminalId: "docs-knowledge-todo-0" }), {
+          status: 201,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+
+      return new Response("not-found", { status: 404 });
+    });
+
+    render(
+      <CanvasTentaclePanel
+        node={{
+          id: "docs-knowledge",
+          type: "tentacle",
+          x: 0,
+          y: 0,
+          vx: 0,
+          vy: 0,
+          pinned: false,
+          radius: 48,
+          tentacleId: "docs-knowledge",
+          label: "Docs & Knowledge",
+          color: "#ff6b2b",
+        }}
+        tentacle={tentacle}
+        sessions={[]}
+        onClose={() => {}}
+        onSolveTodoItem={onSolveTodoItem}
+      />,
+    );
+
+    const solveButtons = await screen.findAllByRole("button", {
+      name: /spawn agent for todo item/i,
+    });
+
+    fireEvent.click(solveButtons[0] as HTMLElement);
+
+    await waitFor(() => {
+      expect(onSolveTodoItem).toHaveBeenCalledWith("docs-knowledge", 0);
+    });
+  });
+
+  it("refreshes centralized tentacle data after mutating todo items", async () => {
+    const onRefreshTentacleData = vi.fn().mockResolvedValue(undefined);
+
+    vi.spyOn(globalThis, "fetch").mockImplementation(async (input, init) => {
+      const url = String(input);
+
+      if (url.endsWith("/api/deck/tentacles/docs-knowledge/todo/toggle")) {
+        expect(init?.method).toBe("PATCH");
+        expect(init?.body).toBe(JSON.stringify({ itemIndex: 0, done: true }));
+        return new Response(null, { status: 200 });
+      }
+
+      return new Response("not-found", { status: 404 });
+    });
+
+    render(
+      <CanvasTentaclePanel
+        node={{
+          id: "docs-knowledge",
+          type: "tentacle",
+          x: 0,
+          y: 0,
+          vx: 0,
+          vy: 0,
+          pinned: false,
+          radius: 48,
+          tentacleId: "docs-knowledge",
+          label: "Docs & Knowledge",
+          color: "#ff6b2b",
+        }}
+        tentacle={tentacle}
+        sessions={[]}
+        onClose={() => {}}
+        onRefreshTentacleData={onRefreshTentacleData}
+      />,
+    );
+
+    fireEvent.click((await screen.findAllByRole("checkbox"))[0] as HTMLElement);
+
+    await waitFor(() => {
+      expect(onRefreshTentacleData).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  it("shows suggested skills in the tentacle detail panel", async () => {
+    render(
+      <CanvasTentaclePanel
+        node={{
+          id: "docs-knowledge",
+          type: "tentacle",
+          x: 0,
+          y: 0,
+          vx: 0,
+          vy: 0,
+          pinned: false,
+          radius: 48,
+          tentacleId: "docs-knowledge",
+          label: "Docs & Knowledge",
+          color: "#ff6b2b",
+        }}
+        tentacle={tentacle}
+        sessions={[]}
+        onClose={() => {}}
+      />,
+    );
+
+    expect(screen.getByText("Suggested Skills")).toBeInTheDocument();
+    expect(screen.getByText("docs-writer")).toBeInTheDocument();
+    expect(screen.getByText("release-helper")).toBeInTheDocument();
+  });
+});

package/apps/octogent/apps/web/tests/delete-all-terminals-dialog.test.tsx

@@ -0,0 +1,76 @@
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { DeleteAllTerminalsDialog } from "../src/components/canvas/DeleteAllTerminalsDialog";
+
+describe("DeleteAllTerminalsDialog", () => {
+  afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+  });
+
+  it("surfaces partial failures after refreshing the parent state", async () => {
+    const onDeleted = vi.fn();
+
+    vi.spyOn(globalThis, "fetch").mockImplementation(async (input, init) => {
+      const url = String(input);
+      const method = init?.method ?? "GET";
+
+      if (url.endsWith("/api/terminals/terminal-a") && method === "DELETE") {
+        return new Response(JSON.stringify({ error: "Terminal is busy." }), {
+          status: 409,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+
+      if (url.endsWith("/api/conversations/session-1") && method === "DELETE") {
+        return new Response(null, { status: 204 });
+      }
+
+      return new Response("not-found", { status: 404 });
+    });
+
+    render(
+      <DeleteAllTerminalsDialog
+        columns={[
+          {
+            terminalId: "terminal-a",
+            label: "terminal-a",
+            state: "live",
+            tentacleId: "tentacle-a",
+            tentacleName: "Tentacle A",
+            createdAt: "2026-02-24T10:00:00.000Z",
+          },
+        ]}
+        nodes={[
+          {
+            id: "i:session-1",
+            type: "inactive-session",
+            x: 0,
+            y: 0,
+            vx: 0,
+            vy: 0,
+            pinned: false,
+            radius: 12,
+            tentacleId: "tentacle-a",
+            label: "session-1",
+            color: "#ff6b2b",
+            sessionId: "session-1",
+          },
+        ]}
+        onCancel={vi.fn()}
+        onDeleted={onDeleted}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Confirm delete all terminals" }));
+
+    await waitFor(() => {
+      expect(onDeleted).toHaveBeenCalledWith({ hadFailures: true });
+    });
+
+    expect(screen.getByRole("alert")).toHaveTextContent(
+      "Failed to delete 1 item: Tentacle A: Terminal is busy.",
+    );
+  });
+});

package/apps/octogent/apps/web/tests/githubMetrics.test.tsx

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+
+import { buildGitHubCommitSeries } from "../src/app/githubMetrics";
+import type { GitHubRepoSummarySnapshot } from "../src/app/types";
+
+const createSummary = (
+  commitsPerDay: Array<{ date: string; count: number }>,
+): GitHubRepoSummarySnapshot => ({
+  status: "ok",
+  fetchedAt: "2026-03-01T00:00:00.000Z",
+  source: "gh-cli",
+  repo: "hesamsheikh/octogent",
+  stargazerCount: 0,
+  openIssueCount: 0,
+  openPullRequestCount: 0,
+  commitsPerDay,
+});
+
+describe("github metrics", () => {
+  it("trims leading zero-count days before the first commit", () => {
+    const series = buildGitHubCommitSeries(
+      createSummary([
+        { date: "2026-02-21", count: 0 },
+        { date: "2026-02-22", count: 0 },
+        { date: "2026-02-23", count: 0 },
+        { date: "2026-02-24", count: 2 },
+        { date: "2026-02-25", count: 1 },
+      ]),
+    );
+
+    expect(series).toEqual([
+      { date: "2026-02-24", count: 2 },
+      { date: "2026-02-25", count: 1 },
+    ]);
+  });
+
+  it("keeps the input range when no commits exist yet", () => {
+    const series = buildGitHubCommitSeries(
+      createSummary([
+        { date: "2026-02-21", count: 0 },
+        { date: "2026-02-22", count: 0 },
+        { date: "2026-02-23", count: 0 },
+      ]),
+    );
+
+    expect(series).toEqual([
+      { date: "2026-02-21", count: 0 },
+      { date: "2026-02-22", count: 0 },
+      { date: "2026-02-23", count: 0 },
+    ]);
+  });
+});

package/apps/octogent/apps/web/tests/hotkeys.test.tsx

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  isEditableEventTarget,
+  normalizeTickerQueryInput,
+  parsePrimaryNavKey,
+} from "../src/app/hotkeys";
+
+describe("hotkeys helpers", () => {
+  it("parses primary nav keys from 1 to 5", () => {
+    expect(parsePrimaryNavKey("1")).toBe(1);
+    expect(parsePrimaryNavKey("2")).toBe(2);
+    expect(parsePrimaryNavKey("3")).toBe(3);
+    expect(parsePrimaryNavKey("5")).toBe(5);
+  });
+
+  it("returns null for unsupported nav keys", () => {
+    expect(parsePrimaryNavKey("0")).toBeNull();
+    expect(parsePrimaryNavKey("10")).toBeNull();
+    expect(parsePrimaryNavKey("x")).toBeNull();
+    expect(parsePrimaryNavKey("/")).toBeNull();
+  });
+
+  it("detects editable element targets", () => {
+    const input = document.createElement("input");
+    const textarea = document.createElement("textarea");
+    const select = document.createElement("select");
+    const div = document.createElement("div");
+    const contentEditableDiv = document.createElement("div");
+    contentEditableDiv.contentEditable = "true";
+
+    expect(isEditableEventTarget(input)).toBe(true);
+    expect(isEditableEventTarget(textarea)).toBe(true);
+    expect(isEditableEventTarget(select)).toBe(true);
+    expect(isEditableEventTarget(contentEditableDiv)).toBe(true);
+    expect(isEditableEventTarget(div)).toBe(false);
+    expect(isEditableEventTarget(null)).toBe(false);
+  });
+
+  it("normalizes ticker input to uppercase with allowed symbols and max length", () => {
+    expect(normalizeTickerQueryInput("main branch? #1")).toBe("MAINBRANCH1");
+    expect(normalizeTickerQueryInput("abc.def/ghi-jkl_mno12345")).toBe("ABC.DEF/GHI-JKL_");
+  });
+});