@codori/client 0.0.6 → 0.0.8

package/app/composables/usePendingUserRequest.ts

@@ -0,0 +1,124 @@
+import { computed, ref, type Ref } from 'vue'
+import type { CodexRpcServerRequest } from '../../shared/codex-rpc'
+import {
+  buildPendingUserRequestDismissResponse,
+  parsePendingUserRequest,
+  type PendingUserRequest
+} from '../../shared/pending-user-request'
+
+type PendingUserRequestQueueEntry = {
+  request: PendingUserRequest
+  resolve: (value: unknown) => void
+  reject: (error: unknown) => void
+}
+
+type PendingUserRequestSession = {
+  current: Ref<PendingUserRequest | null>
+  queue: PendingUserRequestQueueEntry[]
+}
+
+const sessions = new Map<string, PendingUserRequestSession>()
+
+const sessionKey = (projectId: string, threadId: string | null) =>
+  `${projectId}::${threadId ?? '__draft__'}`
+
+const getSession = (projectId: string, threadId: string | null): PendingUserRequestSession => {
+  const key = sessionKey(projectId, threadId)
+  const existing = sessions.get(key)
+  if (existing) {
+    return existing
+  }
+
+  const session: PendingUserRequestSession = {
+    current: ref<PendingUserRequest | null>(null),
+    queue: []
+  }
+  sessions.set(key, session)
+  return session
+}
+
+const promoteNextRequest = (session: PendingUserRequestSession) => {
+  session.current.value = session.queue[0]?.request ?? null
+}
+
+const resolveQueuedRequest = (session: PendingUserRequestSession, responseFactory: (request: PendingUserRequest) => unknown) => {
+  while (session.queue.length > 0) {
+    const entry = session.queue.shift()
+    if (!entry) {
+      continue
+    }
+
+    entry.resolve(responseFactory(entry.request))
+  }
+
+  session.current.value = null
+}
+
+export const usePendingUserRequest = (projectId: string, activeThreadId: Ref<string | null>) => {
+  const resolveSession = (threadId: string | null) => getSession(projectId, threadId)
+
+  const handleServerRequest = async (request: CodexRpcServerRequest) => {
+    const normalized = parsePendingUserRequest(request)
+    if (!normalized) {
+      return null
+    }
+
+    const session = resolveSession(normalized.threadId ?? activeThreadId.value)
+
+    return await new Promise((resolve, reject) => {
+      session.queue.push({
+        request: normalized,
+        resolve,
+        reject
+      })
+
+      if (!session.current.value) {
+        promoteNextRequest(session)
+      }
+    })
+  }
+
+  const resolveCurrentRequest = (response: unknown) => {
+    const session = resolveSession(activeThreadId.value)
+    const current = session.queue.shift()
+    if (!current) {
+      return
+    }
+
+    current.resolve(response)
+    promoteNextRequest(session)
+  }
+
+  const rejectCurrentRequest = (error: unknown) => {
+    const session = resolveSession(activeThreadId.value)
+    const current = session.queue.shift()
+    if (!current) {
+      return
+    }
+
+    current.reject(error)
+    promoteNextRequest(session)
+  }
+
+  const cancelAllPendingRequests = () => {
+    const projectSessionPrefix = `${projectId}::`
+
+    for (const [key, session] of sessions.entries()) {
+      if (!key.startsWith(projectSessionPrefix)) {
+        continue
+      }
+
+      resolveQueuedRequest(session, buildPendingUserRequestDismissResponse)
+      sessions.delete(key)
+    }
+  }
+
+  return {
+    pendingRequest: computed(() => resolveSession(activeThreadId.value).current.value),
+    hasPendingRequest: computed(() => resolveSession(activeThreadId.value).current.value !== null),
+    handleServerRequest,
+    resolveCurrentRequest,
+    rejectCurrentRequest,
+    cancelAllPendingRequests
+  }
+}

package/app/composables/useThreadSummaries.ts

@@ -23,8 +23,34 @@ type UseThreadSummariesResult = ThreadSummariesState & {
 
 const states = new Map<string, ThreadSummariesState>()
 
+export const normalizeThreadTitleCandidate = (value: string | null | undefined) => {
+  const raw = value?.trim() ?? ''
+  if (!raw) {
+    return ''
+  }
+
+  const stripped = raw
+    .replace(/<\/?[a-z_]+>/gi, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+
+  if (!stripped) {
+    return ''
+  }
+
+  if (
+    /<(?:user_action|context)>/i.test(raw)
+    || /user initiated a review task/i.test(stripped)
+    || /review output from reviewer mode/i.test(stripped)
+  ) {
+    return 'Code Review'
+  }
+
+  return stripped
+}
+
 export const resolveThreadSummaryTitle = (thread: Pick<CodexThread, 'id' | 'name' | 'preview'>) => {
-  const nextTitle = thread.name?.trim() || thread.preview.trim()
+  const nextTitle = normalizeThreadTitleCandidate(thread.name) || normalizeThreadTitleCandidate(thread.preview)
   return nextTitle || `Thread ${thread.id}`
 }
 
@@ -41,7 +67,7 @@ export const renameThreadSummary = (
     updatedAt?: number
   }
 ) => {
-  const nextTitle = input.title.trim()
+  const nextTitle = normalizeThreadTitleCandidate(input.title)
   if (!nextTitle) {
     return threads
   }

package/app/pages/index.vue

@@ -53,7 +53,6 @@
               </p>
             </div>
           </div>
-
         </div>
       </div>
     </template>

package/app/utils/chat-turn-engagement.ts

@@ -31,9 +31,10 @@ export const shouldSubmitViaTurnSteer = (input: {
   liveStreamTurnId: string | null
   status: PromptSubmitStatus
 }) =>
-  input.activeThreadId !== null
-  && input.liveStreamThreadId === input.activeThreadId
-  && (input.liveStreamTurnId !== null || input.status === 'submitted' || input.status === 'streaming')
+  (input.activeThreadId !== null
+    && input.liveStreamThreadId === input.activeThreadId
+    && input.status === 'submitted')
+  || hasSteerableTurn(input)
 
 export const shouldAwaitThreadHydration = (input: {
   hasPendingThreadHydration: boolean
@@ -43,7 +44,26 @@ export const shouldAwaitThreadHydration = (input: {
   && input.routeThreadId !== null
 
 export const shouldRetrySteerWithTurnStart = (message: string) =>
-  /no active turn to steer/i.test(message)
+  /no active turn to steer|active turn is no longer available/i.test(message)
+
+export const shouldApplyNotificationToCurrentTurn = (input: {
+  liveStreamTurnId: string | null
+  lockedTurnId?: string | null
+  notificationMethod: string
+  notificationTurnId: string | null
+}) =>
+  (input.lockedTurnId ?? input.liveStreamTurnId) === null
+  || input.notificationTurnId === null
+  || input.notificationTurnId === (input.lockedTurnId ?? input.liveStreamTurnId)
+  || input.notificationMethod === 'turn/started'
+
+export const shouldAdvanceLiveStreamTurn = (input: {
+  lockedTurnId?: string | null
+  nextTurnId: string | null
+}) =>
+  !input.lockedTurnId
+  || !input.nextTurnId
+  || input.nextTurnId === input.lockedTurnId
 
 export const resolvePromptSubmitStatus = (input: {
   status: PromptSubmitStatus

package/app/utils/review-priority-badge.ts

@@ -0,0 +1,90 @@
+import type { ComarkElement, ComarkNode, ComarkPlugin, ComarkTree } from '@comark/vue'
+
+export const REVIEW_PRIORITY_BADGE_TAG = 'review-priority-badge'
+
+const REVIEW_PRIORITY_PATTERN = /^P([1-3])$/i
+
+const isElementNode = (node: ComarkNode): node is ComarkElement => {
+  return Array.isArray(node) && typeof node[0] === 'string'
+}
+
+const getPriorityLabel = (node: ComarkElement) => {
+  if (node[0] !== 'span') {
+    return null
+  }
+
+  const children = node.slice(2)
+
+  if (children.length !== 1 || typeof children[0] !== 'string') {
+    return null
+  }
+
+  const label = children[0].trim().toUpperCase()
+
+  return REVIEW_PRIORITY_PATTERN.test(label) ? label as `P${1 | 2 | 3}` : null
+}
+
+const createPriorityBadgeNode = (label: `P${1 | 2 | 3}`): ComarkElement => {
+  return [REVIEW_PRIORITY_BADGE_TAG, { priority: label.slice(1) }, label]
+}
+
+const replaceLeadingPriorityBadge = (children: ComarkNode[]) => {
+  const targetIndex = children.findIndex((child) => {
+    return typeof child !== 'string' || child.trim().length > 0
+  })
+
+  if (targetIndex === -1) {
+    return children
+  }
+
+  const target = children[targetIndex]
+
+  if (!target) {
+    return children
+  }
+
+  if (!isElementNode(target)) {
+    return children
+  }
+
+  const label = getPriorityLabel(target)
+
+  if (!label) {
+    return children
+  }
+
+  return children.map((child, index) => {
+    return index === targetIndex ? createPriorityBadgeNode(label) : child
+  })
+}
+
+const transformNode = (node: ComarkNode, parentTag?: string): ComarkNode => {
+  if (!isElementNode(node)) {
+    return node
+  }
+
+  const [tag, props, ...children] = node
+  let nextChildren = children.map(child => transformNode(child, tag))
+
+  if (tag === 'li' || (tag === 'p' && parentTag === 'li')) {
+    nextChildren = replaceLeadingPriorityBadge(nextChildren)
+  }
+
+  return [tag, props, ...nextChildren]
+}
+
+export const transformReviewPriorityBadges = (tree: ComarkTree): ComarkTree => {
+  return {
+    ...tree,
+    nodes: tree.nodes.map(node => transformNode(node))
+  }
+}
+
+export const reviewPriorityBadgePlugin = (): ComarkPlugin => {
+  return {
+    name: 'review-priority-badge',
+    post: (state) => {
+      state.tree = transformReviewPriorityBadges(state.tree)
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codori/client",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "private": false,
   "description": "Codori Nuxt dashboard for project browsing, Codex chat, and thread resume.",
   "type": "module",
@@ -41,10 +41,17 @@
     "@comark/vue": "^0.2.0",
     "@iconify-json/lucide": "^1.2.87",
     "@nuxt/ui": "^4.6.0",
+    "beautiful-mermaid": "^1.1.3",
+    "katex": "^0.16.45",
     "nuxt": "^4.3.0",
     "ofetch": "^1.4.1",
     "shiki": "^3.23.0",
     "tailwindcss": "^4.1.14",
     "vue": "^3.5.22"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^6.0.6",
+    "@vue/test-utils": "^2.4.6",
+    "jsdom": "^29.0.2"
   }
 }

package/server/api/codori/projects/[projectId]/git/branches.get.ts

@@ -0,0 +1,15 @@
+import { defineEventHandler, getRouterParam } from 'h3'
+import { encodeProjectIdSegment, type ProjectGitBranchesResponse } from '~~/shared/codori'
+import { proxyServerRequest } from '../../../../../utils/server-proxy'
+
+export default defineEventHandler(async (event) => {
+  const projectId = getRouterParam(event, 'projectId')
+  if (!projectId) {
+    throw new Error('Missing project id.')
+  }
+
+  return await proxyServerRequest<ProjectGitBranchesResponse>(
+    event,
+    `/api/projects/${encodeProjectIdSegment(projectId)}/git/branches`
+  )
+})

package/shared/codex-chat.ts

@@ -1,4 +1,4 @@
-import type { CodexThread, CodexThreadItem, CodexUserInput } from './codex-rpc'
+import type { CodexThread, CodexThreadItem, CodexTurn, CodexUserInput } from './codex-rpc'
 
 export const EVENT_PART = 'data-thread-event' as const
 export const ITEM_PART = 'data-thread-item' as const
@@ -8,6 +8,13 @@ export type ThreadEventData =
       kind: 'thread.started' | 'thread.ended' | 'thread.title' | 'turn.started' | 'turn.completed'
       title?: string | null
     }
+  | {
+      kind: 'review.started'
+      summary: string | null
+    }
+  | {
+      kind: 'review.completed'
+    }
   | {
       kind: 'turn.failed'
       error: {
@@ -161,6 +168,29 @@ const userInputToParts = (input: CodexUserInput): ChatPart[] => {
   }]
 }
 
+const getUserMessageText = (item: Extract<CodexThreadItem, { type: 'userMessage' }>) =>
+  item.content
+    .filter((input): input is Extract<CodexUserInput, { type: 'text' }> => input.type === 'text')
+    .map(input => input.text.trim())
+    .filter(Boolean)
+    .join('\n')
+
+const shouldHideReviewBootstrapUserMessage = (
+  item: Extract<CodexThreadItem, { type: 'userMessage' }>,
+  turn: CodexTurn
+) => {
+  const reviewLifecycle = turn.items.find((candidate): candidate is Extract<CodexThreadItem, { type: 'enteredReviewMode' | 'exitedReviewMode' }> =>
+    (candidate.type === 'enteredReviewMode' || candidate.type === 'exitedReviewMode')
+    && candidate.id === item.id
+  )
+
+  if (!reviewLifecycle) {
+    return false
+  }
+
+  return getUserMessageText(item) === reviewLifecycle.review.trim()
+}
+
 export const itemToMessages = (item: CodexThreadItem): ChatMessage[] => {
   switch (item.type) {
     case 'userMessage':
@@ -300,13 +330,53 @@ export const itemToMessages = (item: CodexThreadItem): ChatMessage[] => {
           }
         }]
       }]
+    case 'enteredReviewMode':
+      return [{
+        id: `${item.id}-review-started`,
+        role: 'system',
+        parts: [{
+          type: EVENT_PART,
+          data: {
+            kind: 'review.started',
+            summary: item.review.trim() || null
+          }
+        }]
+      }]
+    case 'exitedReviewMode': {
+      return [{
+        id: `${item.id}-review-completed`,
+        role: 'system',
+        parts: [{
+          type: EVENT_PART,
+          data: {
+            kind: 'review.completed'
+          }
+        }]
+      }, {
+        id: `${item.id}-review-output`,
+        role: 'assistant',
+        parts: [{
+          type: 'text',
+          text: item.review,
+          state: 'done'
+        }]
+      }]
+    }
     default:
       return []
   }
 }
 
 export const threadToMessages = (thread: CodexThread) =>
-  thread.turns.flatMap(turn => turn.items.flatMap(item => itemToMessages(item)))
+  thread.turns.flatMap((turn) =>
+    turn.items.flatMap((item) => {
+      if (item.type === 'userMessage' && shouldHideReviewBootstrapUserMessage(item, turn)) {
+        return []
+      }
+
+      return itemToMessages(item)
+    })
+  )
 
 export const eventToMessage = (id: string, data: ThreadEventData): ChatMessage => ({
   id,

package/shared/codex-rpc.ts

@@ -24,13 +24,17 @@ type JsonRpcNotification = {
   params?: unknown
 }
 
-type JsonRpcServerRequest = JsonRpcRequest
+export type CodexRpcServerRequest = JsonRpcRequest
+
+type JsonRpcServerRequest = CodexRpcServerRequest
 
 type PendingRequest = {
   resolve: (value: unknown) => void
   reject: (error: unknown) => void
 }
 
+export type CodexRpcServerRequestHandler = (request: CodexRpcServerRequest) => Promise<unknown> | unknown
+
 export type CodexUserInput =
   | {
       type: 'text'
@@ -131,6 +135,16 @@ export type CodexThreadItem =
       type: 'contextCompaction'
       id: string
     }
+  | {
+      type: 'enteredReviewMode'
+      id: string
+      review: string
+    }
+  | {
+      type: 'exitedReviewMode'
+      id: string
+      review: string
+    }
 
 export type CodexTurn = {
   id: string
@@ -186,6 +200,37 @@ export type TurnStartResponse = {
   }
 }
 
+export type ReviewTarget =
+  | {
+      type: 'uncommittedChanges'
+    }
+  | {
+      type: 'baseBranch'
+      branch: string
+    }
+  | {
+      type: 'commit'
+      sha: string
+      title?: string | null
+    }
+  | {
+      type: 'custom'
+      instructions: string
+    }
+
+export type ReviewDelivery = 'inline' | 'detached'
+
+export type ReviewStartParams = {
+  threadId: string
+  delivery?: ReviewDelivery
+  target: ReviewTarget
+}
+
+export type ReviewStartResponse = {
+  reviewThreadId: string
+  turn: CodexTurn
+}
+
 export type ModelListResponse = {
   data?: unknown[]
 }
@@ -209,7 +254,12 @@ const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
 const asError = (value: unknown) =>
   value instanceof Error ? value : new Error(typeof value === 'string' ? value : 'Unknown RPC error.')
 
-const toServerRequestResponse = async (request: JsonRpcServerRequest) => {
+export const toServerRequestResponse = async (
+  request: JsonRpcServerRequest,
+  options?: {
+    handler?: CodexRpcServerRequestHandler | null
+  }
+) => {
   switch (request.method) {
     case 'item/commandExecution/requestApproval':
     case 'item/fileChange/requestApproval':
@@ -217,8 +267,20 @@ const toServerRequestResponse = async (request: JsonRpcServerRequest) => {
     case 'item/permissions/requestApproval':
       return { permissions: {}, scope: 'turn' }
     case 'item/tool/requestUserInput':
+      if (options?.handler) {
+        const handled = await options.handler(request)
+        if (handled != null) {
+          return handled
+        }
+      }
       return { answers: {} }
     case 'mcpServer/elicitation/request':
+      if (options?.handler) {
+        const handled = await options.handler(request)
+        if (handled != null) {
+          return handled
+        }
+      }
       return { action: 'decline', content: null, _meta: null }
     case 'applyPatchApproval':
     case 'execCommandApproval':
@@ -290,6 +352,8 @@ export class CodexRpcClient {
 
   private listeners = new Set<(notification: CodexRpcNotification) => void>()
 
+  private serverRequestHandler: CodexRpcServerRequestHandler | null = null
+
   constructor(url: string) {
     this.url = url
   }
@@ -301,6 +365,16 @@ export class CodexRpcClient {
     }
   }
 
+  setServerRequestHandler(handler: CodexRpcServerRequestHandler | null) {
+    this.serverRequestHandler = handler
+
+    return () => {
+      if (this.serverRequestHandler === handler) {
+        this.serverRequestHandler = null
+      }
+    }
+  }
+
   async connect() {
     if (this.initialized && this.socket?.readyState === WebSocket.OPEN) {
       return
@@ -389,7 +463,9 @@ export class CodexRpcClient {
     }
 
     if ('id' in payload && 'method' in payload) {
-      const result = await toServerRequestResponse(payload)
+      const result = await toServerRequestResponse(payload, {
+        handler: this.serverRequestHandler
+      })
       this.sendRaw({
         id: payload.id,
         result

package/shared/codori.ts

@@ -1,3 +1,5 @@
+import { resolveApiUrl, shouldUseServerProxy } from './network'
+
 export type ProjectRuntimeStatus = 'running' | 'stopped' | 'error'
 
 export type ProjectRecord = {
@@ -38,6 +40,11 @@ export type ServiceUpdateResponse = {
   serviceUpdate: ServiceUpdateStatus
 }
 
+export type ProjectGitBranchesResponse = {
+  currentBranch: string | null
+  branches: string[]
+}
+
 export const normalizeProjectIdParam = (value: string | string[] | undefined) => {
   if (!value) {
     return null
@@ -57,6 +64,19 @@ export const toProjectThreadRoute = (projectId: string, threadId: string) =>
 
 export const encodeProjectIdSegment = (projectId: string) => encodeURIComponent(projectId)
 
+export const resolveProjectGitBranchesUrl = (input: {
+  projectId: string
+  configuredBase?: string | null
+}) => {
+  const requestPath = `/projects/${encodeProjectIdSegment(input.projectId)}/git/branches`
+
+  if (shouldUseServerProxy(input.configuredBase)) {
+    return `/api/codori${requestPath}`
+  }
+
+  return resolveApiUrl(requestPath, input.configuredBase)
+}
+
 export const projectStatusMeta = (status: ProjectRuntimeStatus) => {
   switch (status) {
     case 'running':