@codori/client 0.0.7 → 0.0.9

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/pages/projects/[...projectId]/threads/[threadId].vue

@@ -376,6 +376,7 @@ watch(
       <template #body>
         <VisualSubagentStack
           :agents="availablePanels"
+          :project-id="projectId"
           class="h-full min-h-0"
           @expand="openExpandedSubagent"
         />
@@ -441,6 +442,7 @@ watch(
         <SubagentTranscriptPanel
           v-if="expandedSubagentPanel"
           :agent="expandedSubagentPanel"
+          :project-id="projectId"
           :accent="expandedSubagentAccent"
           scroll-scope="expanded"
           expanded

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

@@ -48,14 +48,23 @@ export const shouldRetrySteerWithTurnStart = (message: string) =>
 
 export const shouldApplyNotificationToCurrentTurn = (input: {
   liveStreamTurnId: string | null
+  lockedTurnId?: string | null
   notificationMethod: string
   notificationTurnId: string | null
 }) =>
-  input.liveStreamTurnId === null
+  (input.lockedTurnId ?? input.liveStreamTurnId) === null
   || input.notificationTurnId === null
-  || input.notificationTurnId === input.liveStreamTurnId
+  || 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
   hasDraftContent: boolean

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/app/utils/slash-prompt-focus.ts

@@ -0,0 +1,8 @@
+// Slash-command popups are rendered as inert overlays. This helper is only for
+// the composer blur guard to recognize "still inside the slash popup" targets.
+export const isFocusWithinContainer = (
+  target: EventTarget | null | undefined,
+  container: ParentNode | null | undefined
+) =>
+  target instanceof Node
+  && Boolean(container?.contains(target))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codori/client",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "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/server/api/codori/projects/[projectId]/local-file.get.ts

@@ -0,0 +1,44 @@
+import {
+  createError,
+  defineEventHandler,
+  getQuery,
+  getRouterParam
+} from 'h3'
+import { encodeProjectIdSegment } from '~~/shared/codori'
+import type { ProjectLocalFileResponse } from '~~/shared/local-files'
+import { proxyServerRequest } from '../../../../utils/server-proxy'
+
+export default defineEventHandler(async (event) => {
+  const projectId = getRouterParam(event, 'projectId')
+  if (!projectId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Missing project id.'
+    })
+  }
+
+  const queryValue = getQuery(event).path
+  const path = typeof queryValue === 'string'
+    ? queryValue
+    : ''
+
+  if (!path) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Missing local file path.'
+    })
+  }
+
+  try {
+    return await proxyServerRequest<ProjectLocalFileResponse>(
+      event,
+      `/api/projects/${encodeProjectIdSegment(projectId)}/local-file?${new URLSearchParams({ path }).toString()}`
+    )
+  } catch (error) {
+    const details = error as { statusCode?: number, statusMessage?: string }
+    throw createError({
+      statusCode: details.statusCode ?? 500,
+      statusMessage: details.statusMessage ?? 'Local file preview failed.'
+    })
+  }
+})

package/shared/account-rate-limits.ts

@@ -0,0 +1,190 @@
+export type RateLimitWindow = {
+  usedPercent: number | null
+  resetsAt: string | null
+  windowDurationMins: number | null
+}
+
+export type RateLimitBucket = {
+  limitId: string
+  limitName: string | null
+  primary: RateLimitWindow | null
+  secondary: RateLimitWindow | null
+}
+
+const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+
+const toFiniteNumber = (value: unknown) => {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value
+  }
+
+  if (typeof value === 'bigint') {
+    return Number(value)
+  }
+
+  if (typeof value === 'string' && value.trim()) {
+    const parsed = Number(value)
+    if (Number.isFinite(parsed)) {
+      return parsed
+    }
+  }
+
+  return null
+}
+
+const toPercent = (value: unknown) => {
+  const parsed = toFiniteNumber(value)
+  if (parsed == null) {
+    return null
+  }
+
+  const normalized = parsed > 0 && parsed <= 1 ? parsed * 100 : parsed
+  return Math.max(0, Math.min(100, normalized))
+}
+
+const toTimestamp = (value: unknown) => {
+  if (typeof value !== 'string' || !value.trim()) {
+    return null
+  }
+
+  return Number.isNaN(Date.parse(value)) ? null : value
+}
+
+const normalizeRateLimitWindow = (value: unknown): RateLimitWindow | null => {
+  const record = isObjectRecord(value) ? value : null
+  if (!record) {
+    return null
+  }
+
+  const usedPercent = toPercent(record.usedPercent)
+  const resetsAt = toTimestamp(record.resetsAt)
+  const windowDurationMins = toFiniteNumber(record.windowDurationMins)
+
+  if (usedPercent == null && resetsAt == null && windowDurationMins == null) {
+    return null
+  }
+
+  return {
+    usedPercent,
+    resetsAt,
+    windowDurationMins
+  }
+}
+
+const mergeRateLimitWindow = (
+  existing: RateLimitWindow | null,
+  incoming: RateLimitWindow | null
+): RateLimitWindow | null => {
+  if (!existing) {
+    return incoming
+  }
+
+  if (!incoming) {
+    return existing
+  }
+
+  return {
+    usedPercent: incoming.usedPercent ?? existing.usedPercent,
+    resetsAt: incoming.resetsAt ?? existing.resetsAt,
+    windowDurationMins: incoming.windowDurationMins ?? existing.windowDurationMins
+  }
+}
+
+const normalizeRateLimitBucket = (value: unknown): RateLimitBucket | null => {
+  const record = isObjectRecord(value) ? value : null
+  if (!record) {
+    return null
+  }
+
+  const limitId = typeof record.limitId === 'string' && record.limitId.trim()
+    ? record.limitId.trim()
+    : null
+  const limitName = typeof record.limitName === 'string' && record.limitName.trim()
+    ? record.limitName.trim()
+    : null
+
+  if (!limitId && !limitName) {
+    return null
+  }
+
+  const primary = normalizeRateLimitWindow(record.primary)
+  const secondary = normalizeRateLimitWindow(record.secondary)
+  if (!primary && !secondary) {
+    return null
+  }
+
+  return {
+    limitId: limitId ?? limitName ?? 'unknown',
+    limitName,
+    primary,
+    secondary
+  }
+}
+
+const collectRateLimitCandidates = (value: unknown) => {
+  const root = isObjectRecord(value) ? value : null
+  const rateLimits = Array.isArray(root?.rateLimits) ? root.rateLimits : []
+  const rateLimitsByLimitId = isObjectRecord(root?.rateLimitsByLimitId)
+    ? Object.values(root.rateLimitsByLimitId)
+    : []
+
+  if (rateLimits.length > 0 || rateLimitsByLimitId.length > 0) {
+    return [...rateLimits, ...rateLimitsByLimitId]
+  }
+
+  return Array.isArray(value) ? value : []
+}
+
+export const normalizeAccountRateLimits = (value: unknown): RateLimitBucket[] => {
+  const bucketsById = new Map<string, RateLimitBucket>()
+
+  for (const candidate of collectRateLimitCandidates(value)) {
+    const bucket = normalizeRateLimitBucket(candidate)
+    if (!bucket) {
+      continue
+    }
+
+    const existing = bucketsById.get(bucket.limitId)
+    if (!existing) {
+      bucketsById.set(bucket.limitId, bucket)
+      continue
+    }
+
+    bucketsById.set(bucket.limitId, {
+      ...existing,
+      limitName: existing.limitName ?? bucket.limitName,
+      primary: mergeRateLimitWindow(existing.primary, bucket.primary),
+      secondary: mergeRateLimitWindow(existing.secondary, bucket.secondary)
+    })
+  }
+
+  return [...bucketsById.values()].sort((left, right) => {
+    const leftLabel = (left.limitName ?? left.limitId).toLowerCase()
+    const rightLabel = (right.limitName ?? right.limitId).toLowerCase()
+    return leftLabel.localeCompare(rightLabel)
+  })
+}
+
+export const formatRateLimitWindowDuration = (value: number | null) => {
+  if (value == null || value <= 0) {
+    return null
+  }
+
+  if (value % (60 * 24 * 7) === 0) {
+    const weeks = value / (60 * 24 * 7)
+    return `${weeks}w window`
+  }
+
+  if (value % (60 * 24) === 0) {
+    const days = value / (60 * 24)
+    return `${days}d window`
+  }
+
+  if (value % 60 === 0) {
+    const hours = value / 60
+    return `${hours}h window`
+  }
+
+  return `${value}m window`
+}

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,