chore: add workspace hook, schedules library, and tests

Author: chriswritescode-dev

frontend/src/hooks/__tests__/useWorkspace.test.tsx

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { renderHook, waitFor } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { useWorkspace } from '../useWorkspace'
+import type { AssistantModeStatus, Repo } from '@opencode-manager/shared/types'
+
+const mocks = vi.hoisted(() => ({
+  getRepo: vi.fn(),
+  getAssistantModeStatus: vi.fn(),
+}))
+
+vi.mock('@/api/repos', () => ({
+  getRepo: mocks.getRepo,
+  getAssistantModeStatus: mocks.getAssistantModeStatus,
+}))
+
+const createWrapper = () => {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: { retry: false },
+      mutations: { retry: false },
+    },
+  })
+  return ({ children }: { children: React.ReactNode }) =>
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+}
+
+describe('useWorkspace', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('repoId === 0 (assistant)', () => {
+    it('returns assistant workspace with correct properties', async () => {
+      const mockStatus: AssistantModeStatus = {
+        repoId: 0,
+        directory: '/abs/assistant',
+        relativePath: 'repos/assistant',
+        files: {
+          agentsMd: { path: '', exists: false, created: false },
+          opencodeJson: { path: '', exists: false, created: false },
+        },
+        schedulesSkill: { path: '', exists: false, created: false },
+      }
+
+      mocks.getAssistantModeStatus.mockResolvedValue(mockStatus)
+
+      const { result } = renderHook(() => useWorkspace(0), { wrapper: createWrapper() })
+
+      await waitFor(() => {
+        expect(result.current.workspace).toBeDefined()
+      })
+
+      expect(result.current.workspace?.kind).toBe('assistant')
+      expect(result.current.workspace?.fullPath).toBe('/abs/assistant')
+      expect(result.current.workspace?.repoId).toBe(0)
+      expect(result.current.isLoading).toBe(false)
+      expect(result.current.isError).toBe(false)
+    })
+
+    it('does not call getRepo for assistant', async () => {
+      mocks.getAssistantModeStatus.mockResolvedValue({
+        directory: '/abs/assistant',
+        relativePath: 'repos/assistant',
+        files: { agentsMd: { path: '', exists: false, created: false }, opencodeJson: { path: '', exists: false, created: false } },
+        schedulesSkill: { path: '', exists: false, created: false },
+        repoId: 0,
+      })
+
+      renderHook(() => useWorkspace(0), { wrapper: createWrapper() })
+
+      await vi.waitFor(() => {
+        expect(mocks.getRepo).not.toHaveBeenCalled()
+      })
+    })
+  })
+
+  describe('repoId === 5 (real repo)', () => {
+    it('returns repo workspace with correct properties', async () => {
+      const mockRepo: Repo = {
+        id: 5,
+        repoUrl: 'https://x/my-repo',
+        localPath: 'repos/my-repo',
+        fullPath: '/abs/repos/my-repo',
+        sourcePath: undefined,
+        defaultBranch: 'main',
+        cloneStatus: 'ready',
+        clonedAt: 0,
+      }
+
+      mocks.getRepo.mockResolvedValue(mockRepo)
+
+      const { result } = renderHook(() => useWorkspace(5), { wrapper: createWrapper() })
+
+      await waitFor(() => {
+        expect(result.current.workspace).toBeDefined()
+      })
+
+      expect(result.current.workspace?.kind).toBe('repo')
+      expect(result.current.workspace?.repoId).toBe(5)
+      expect(result.current.workspace?.fullPath).toBe('/abs/repos/my-repo')
+      expect(result.current.workspace?.backHref).toBe('/repos/5')
+    })
+
+    it('does not call getAssistantModeStatus for repo', async () => {
+      const mockRepo: Repo = {
+        id: 5,
+        repoUrl: 'https://x/my-repo',
+        localPath: 'repos/my-repo',
+        fullPath: '/abs/repos/my-repo',
+        sourcePath: undefined,
+        defaultBranch: 'main',
+        cloneStatus: 'ready',
+        clonedAt: 0,
+      }
+
+      mocks.getRepo.mockResolvedValue(mockRepo)
+
+      renderHook(() => useWorkspace(5), { wrapper: createWrapper() })
+
+      await vi.waitFor(() => {
+        expect(mocks.getAssistantModeStatus).not.toHaveBeenCalled()
+      })
+    })
+  })
+
+  describe('repoId === undefined', () => {
+    it('returns undefined workspace', () => {
+      const { result } = renderHook(() => useWorkspace(undefined), { wrapper: createWrapper() })
+
+      expect(result.current.workspace).toBeUndefined()
+      expect(result.current.isLoading).toBe(false)
+    })
+  })
+})

frontend/src/hooks/useWorkspace.ts

@@ -0,0 +1,33 @@
+import { useQuery } from '@tanstack/react-query'
+import { getRepo } from '@/api/repos'
+import { useAssistantMode } from '@/hooks/useAssistantMode'
+import { isAssistantRepoId, workspaceFromAssistant, workspaceFromRepo } from '@/lib/schedules/workspace'
+import type { Workspace } from '@/lib/schedules/workspace'
+
+export function useWorkspace(repoId: number | undefined): {
+  workspace: Workspace | undefined
+  isLoading: boolean
+  isError: boolean
+} {
+  const assistantQuery = useAssistantMode(repoId)
+
+  const repoQuery = useQuery({
+    queryKey: ['repo', repoId],
+    queryFn: () => getRepo(repoId!),
+    enabled: repoId !== undefined && repoId > 0,
+  })
+
+  if (isAssistantRepoId(repoId)) {
+    return {
+      workspace: assistantQuery.status ? workspaceFromAssistant(assistantQuery.status) : undefined,
+      isLoading: assistantQuery.isLoading,
+      isError: assistantQuery.isError,
+    }
+  }
+
+  return {
+    workspace: repoQuery.data ? workspaceFromRepo(repoQuery.data) : undefined,
+    isLoading: repoQuery.isLoading,
+    isError: repoQuery.isError,
+  }
+}

frontend/src/lib/schedules/workspace.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest'
+import {
+  isAssistantRepoId,
+  workspaceFromRepo,
+  workspaceFromAssistant,
+} from './workspace'
+import type { AssistantModeStatus } from '@opencode-manager/shared/types'
+
+describe('isAssistantRepoId', () => {
+  it('returns true for repoId 0', () => {
+    expect(isAssistantRepoId(0)).toBe(true)
+  })
+
+  it('returns false for positive repoId', () => {
+    expect(isAssistantRepoId(5)).toBe(false)
+  })
+
+  it('returns false for undefined', () => {
+    expect(isAssistantRepoId(undefined)).toBe(false)
+  })
+})
+
+describe('workspaceFromRepo', () => {
+  it('returns correct workspace for a repo', () => {
+    const repo = {
+      id: 5,
+      repoUrl: 'https://x/y',
+      localPath: 'y',
+      fullPath: '/abs/y',
+      sourcePath: undefined,
+      defaultBranch: 'main',
+      cloneStatus: 'ready' as const,
+      clonedAt: 0,
+    }
+
+    const workspace = workspaceFromRepo(repo)
+
+    expect(workspace).toEqual({
+      repoId: 5,
+      kind: 'repo',
+      name: 'y',
+      subtitle: 'y',
+      fullPath: '/abs/y',
+      backHref: '/repos/5',
+    })
+  })
+})
+
+describe('workspaceFromAssistant', () => {
+  it('returns correct workspace for assistant', () => {
+    const status: AssistantModeStatus = {
+      repoId: 0,
+      directory: '/abs/assistant',
+      relativePath: 'repos/assistant',
+      files: {
+        agentsMd: { path: '', exists: false, created: false },
+        opencodeJson: { path: '', exists: false, created: false },
+      },
+      schedulesSkill: { path: '', exists: false, created: false },
+    }
+
+    const workspace = workspaceFromAssistant(status)
+
+    expect(workspace).toEqual({
+      repoId: 0,
+      kind: 'assistant',
+      name: 'Assistant',
+      subtitle: 'Assistant Workspace',
+      fullPath: '/abs/assistant',
+      backHref: '/repos/0/assistant',
+    })
+  })
+})

frontend/src/lib/schedules/workspace.ts

@@ -0,0 +1,40 @@
+import type { Repo } from '@/api/types'
+import type { AssistantModeStatus } from '@opencode-manager/shared/types'
+import { getRepoDisplayName } from '@/lib/utils'
+
+export interface Workspace {
+  repoId: number
+  kind: 'assistant' | 'repo'
+  name: string
+  subtitle: string
+  fullPath: string
+  backHref: string
+}
+
+export const ASSISTANT_REPO_ID = 0
+
+export function isAssistantRepoId(repoId: number | undefined): boolean {
+  return repoId === ASSISTANT_REPO_ID
+}
+
+export function workspaceFromRepo(repo: Repo): Workspace {
+  return {
+    repoId: repo.id,
+    kind: 'repo',
+    name: getRepoDisplayName(repo.repoUrl, repo.localPath, repo.sourcePath),
+    subtitle: repo.localPath,
+    fullPath: repo.fullPath,
+    backHref: `/repos/${repo.id}`,
+  }
+}
+
+export function workspaceFromAssistant(status: AssistantModeStatus): Workspace {
+  return {
+    repoId: ASSISTANT_REPO_ID,
+    kind: 'assistant',
+    name: 'Assistant',
+    subtitle: 'Assistant Workspace',
+    fullPath: status.directory,
+    backHref: `/repos/${ASSISTANT_REPO_ID}/assistant`,
+  }
+}