@vibe-forge/client 3.0.0-alpha.6 → 3.0.0-alpha.7

package/src/api/auth.ts

@@ -1,46 +0,0 @@
-import { clearAuthToken } from './auth-token'
-import { fetchApiJson, fetchApiJsonOrThrow, jsonHeaders } from './base'
-
-export interface AuthStatus {
-  enabled: boolean
-  authenticated: boolean
-  usernames: string[]
-  passwordSource: 'config' | 'env' | 'generated'
-  passwordFilePath?: string
-  version?: string
-  token?: string
-}
-
-export interface LoginInput {
-  username: string
-  password: string
-  rememberDevice: boolean
-  returnToken?: boolean
-}
-
-export const getAuthStatus = () => fetchApiJson<AuthStatus>('/api/auth/status')
-
-export const login = (input: LoginInput) => (
-  fetchApiJsonOrThrow<AuthStatus>(
-    '/api/auth/login',
-    {
-      method: 'POST',
-      headers: jsonHeaders,
-      body: JSON.stringify(input)
-    },
-    '[api] login failed:'
-  )
-)
-
-export const logout = async () => {
-  const result = await fetchApiJsonOrThrow<{ ok: boolean }>(
-    '/api/auth/logout',
-    {
-      method: 'POST',
-      headers: jsonHeaders
-    },
-    '[api] logout failed:'
-  )
-  clearAuthToken()
-  return result
-}

package/src/api/automation.ts

@@ -1,98 +0,0 @@
-import type { EffortLevel, GitBranchKind, SessionPermissionMode } from '@vibe-forge/types'
-
-import { createApiUrl, fetchApiJson, jsonHeaders } from './base'
-
-export interface AutomationTrigger {
-  id: string
-  type: 'interval' | 'webhook' | 'cron'
-  intervalMs?: number | null
-  cronExpression?: string | null
-  webhookKey?: string | null
-}
-
-export interface AutomationTask {
-  id: string
-  title: string
-  prompt: string
-  model?: string | null
-  adapter?: string | null
-  effort?: EffortLevel | null
-  permissionMode?: SessionPermissionMode | null
-  createWorktree?: boolean | null
-  branchName?: string | null
-  branchKind?: GitBranchKind | null
-  branchMode?: 'checkout' | 'create' | null
-}
-
-export interface AutomationRule {
-  id: string
-  name: string
-  description?: string | null
-  type: 'interval' | 'webhook' | 'cron'
-  intervalMs?: number | null
-  webhookKey?: string | null
-  cronExpression?: string | null
-  prompt: string
-  enabled: boolean
-  createdAt: number
-  lastRunAt?: number | null
-  lastSessionId?: string | null
-  triggers?: AutomationTrigger[]
-  tasks?: AutomationTask[]
-}
-
-export interface AutomationRun {
-  id: string
-  ruleId: string
-  sessionId: string
-  runAt: number
-  taskId?: string | null
-  taskTitle?: string | null
-  status?: string
-  title?: string
-  lastMessage?: string
-  lastUserMessage?: string
-}
-
-export async function listAutomationRules(): Promise<{ rules: AutomationRule[] }> {
-  return fetchApiJson<{ rules: AutomationRule[] }>('/api/automation/rules')
-}
-
-export async function createAutomationRule(
-  rule: Partial<AutomationRule> & { immediateRun?: boolean }
-): Promise<{ rule: AutomationRule }> {
-  return fetchApiJson<{ rule: AutomationRule }>('/api/automation/rules', {
-    method: 'POST',
-    headers: jsonHeaders,
-    body: JSON.stringify(rule)
-  })
-}
-
-export async function updateAutomationRule(
-  id: string,
-  rule: Partial<AutomationRule> & { immediateRun?: boolean }
-): Promise<{ rule: AutomationRule }> {
-  return fetchApiJson<{ rule: AutomationRule }>(`/api/automation/rules/${id}`, {
-    method: 'PATCH',
-    headers: jsonHeaders,
-    body: JSON.stringify(rule)
-  })
-}
-
-export async function deleteAutomationRule(id: string): Promise<{ ok: boolean; removed: boolean }> {
-  return fetchApiJson<{ ok: boolean; removed: boolean }>(`/api/automation/rules/${id}`, {
-    method: 'DELETE'
-  })
-}
-
-export async function runAutomationRule(id: string): Promise<{ ok: boolean; sessionIds: string[] }> {
-  return fetchApiJson<{ ok: boolean; sessionIds: string[] }>(`/api/automation/rules/${id}/run`, {
-    method: 'POST'
-  })
-}
-
-export async function listAutomationRuns(id: string, limit = 50): Promise<{ runs: AutomationRun[] }> {
-  const url = createApiUrl(`/api/automation/rules/${id}/runs`)
-  url.searchParams.set('limit', limit.toString())
-  return fetchApiJson<{ runs: AutomationRun[] }>(url)
-}

package/src/api/base.ts

@@ -1,166 +0,0 @@
-import { createServerUrl, getServerBaseUrl } from '#~/runtime-config.js'
-
-import { applyAuthHeader } from './auth-token'
-
-export const jsonHeaders = { 'Content-Type': 'application/json' } as const
-
-export const getServerHost = () => {
-  return new URL(getServerUrl()).hostname
-}
-
-export const getServerPort = () => {
-  const { port, protocol } = new URL(getServerUrl())
-  if (port !== '') return port
-  return protocol === 'https:' ? '443' : '80'
-}
-
-export const getServerUrl = () => getServerBaseUrl()
-
-export const buildApiUrl = (path: string) => {
-  if (path.startsWith('http://') || path.startsWith('https://')) {
-    return path
-  }
-  return createServerUrl(path)
-}
-
-export const createApiUrl = (path: string) => new URL(buildApiUrl(path))
-
-export interface ApiSuccessEnvelope<T> {
-  success: true
-  data: T
-}
-
-export interface ApiErrorPayload {
-  code: string
-  message: string
-  details?: unknown
-}
-
-export interface ApiErrorEnvelope {
-  success: false
-  error: ApiErrorPayload
-}
-
-export class ApiError extends Error {
-  status: number
-  code: string
-  details?: unknown
-
-  constructor(status: number, payload: ApiErrorPayload) {
-    super(payload.message)
-    this.name = 'ApiError'
-    this.status = status
-    this.code = payload.code
-    this.details = payload.details
-  }
-}
-
-const isRecord = (value: unknown): value is Record<string, unknown> => {
-  return value != null && typeof value === 'object' && !Array.isArray(value)
-}
-
-const isApiSuccessEnvelope = <T>(value: unknown): value is ApiSuccessEnvelope<T> => {
-  return isRecord(value) && value.success === true && 'data' in value
-}
-
-const isApiErrorEnvelope = (value: unknown): value is ApiErrorEnvelope => {
-  return isRecord(value) &&
-    value.success === false &&
-    isRecord(value.error) &&
-    typeof value.error.message === 'string' &&
-    typeof value.error.code === 'string'
-}
-
-const parseResponseBody = async (res: Response): Promise<unknown> => {
-  const text = await res.text()
-  if (text.trim() === '') {
-    return null
-  }
-  try {
-    return JSON.parse(text) as unknown
-  } catch {
-    return text
-  }
-}
-
-const toApiError = (status: number, body: unknown, fallbackMessage: string) => {
-  if (isApiErrorEnvelope(body)) {
-    return new ApiError(status, body.error)
-  }
-
-  if (isRecord(body)) {
-    const message = typeof body.error === 'string'
-      ? body.error
-      : typeof body.message === 'string'
-      ? body.message
-      : fallbackMessage
-    const code = typeof body.code === 'string' ? body.code : 'request_failed'
-    return new ApiError(status, {
-      code,
-      message,
-      ...(body.details !== undefined ? { details: body.details } : {})
-    })
-  }
-
-  if (typeof body === 'string' && body.trim() !== '') {
-    return new ApiError(status, { code: 'request_failed', message: body })
-  }
-
-  return new ApiError(status, { code: 'request_failed', message: fallbackMessage })
-}
-
-const unwrapApiResponse = async <T>(res: Response, errorLabel?: string): Promise<T> => {
-  const body = await parseResponseBody(res)
-  if (!res.ok) {
-    const fallbackMessage = errorLabel ?? `Request failed with status ${res.status}`
-    const apiError = toApiError(res.status, body, fallbackMessage)
-    console.error(errorLabel ?? '[api] request failed', res.status, apiError.message, apiError.details)
-    throw apiError
-  }
-
-  if (isApiErrorEnvelope(body)) {
-    throw new ApiError(res.status, body.error)
-  }
-
-  if (isApiSuccessEnvelope<T>(body)) {
-    return body.data
-  }
-
-  return body as T
-}
-
-export const getApiErrorMessage = (error: unknown, fallback: string) => {
-  if (error instanceof ApiError && error.message.trim() !== '') {
-    return error.message
-  }
-  if (error instanceof Error && error.message.trim() !== '') {
-    return error.message
-  }
-  return fallback
-}
-
-const createRequestInit = (init?: RequestInit): RequestInit => {
-  const headers = new Headers(init?.headers)
-  applyAuthHeader(headers)
-  return {
-    ...init,
-    credentials: init?.credentials ?? 'include',
-    headers
-  }
-}
-
-export async function fetchApiJson<T>(pathOrUrl: string | URL, init?: RequestInit): Promise<T> {
-  const url = typeof pathOrUrl === 'string' ? buildApiUrl(pathOrUrl) : pathOrUrl.toString()
-  const res = await fetch(url, createRequestInit(init))
-  return unwrapApiResponse<T>(res)
-}
-
-export async function fetchApiJsonOrThrow<T>(
-  pathOrUrl: string | URL,
-  init: RequestInit,
-  errorLabel: string
-): Promise<T> {
-  const url = typeof pathOrUrl === 'string' ? buildApiUrl(pathOrUrl) : pathOrUrl.toString()
-  const res = await fetch(url, createRequestInit(init))
-  return unwrapApiResponse<T>(res, errorLabel)
-}

package/src/api/benchmark.ts

@@ -1,50 +0,0 @@
-import type { BenchmarkCase, BenchmarkCategory, BenchmarkResult, BenchmarkRunSummary } from '@vibe-forge/types'
-
-import { createApiUrl, fetchApiJson, fetchApiJsonOrThrow, jsonHeaders } from './base'
-
-export interface BenchmarkRunRequest {
-  category: string
-  title?: string
-  concurrency?: number
-  adapter?: string
-  model?: string
-  effort?: 'low' | 'medium' | 'high' | 'max'
-  systemPrompt?: string
-  permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions'
-}
-
-export async function listBenchmarkCategories(): Promise<{ categories: BenchmarkCategory[] }> {
-  return fetchApiJson<{ categories: BenchmarkCategory[] }>('/api/benchmark/categories')
-}
-
-export async function listBenchmarkCases(category?: string): Promise<{ cases: BenchmarkCase[] }> {
-  const url = createApiUrl('/api/benchmark/cases')
-  if (category) {
-    url.searchParams.set('category', category)
-  }
-  return fetchApiJson<{ cases: BenchmarkCase[] }>(url)
-}
-
-export async function getBenchmarkCase(category: string, title: string): Promise<{ case: BenchmarkCase }> {
-  return fetchApiJson<{ case: BenchmarkCase }>(
-    `/api/benchmark/cases/${encodeURIComponent(category)}/${encodeURIComponent(title)}`
-  )
-}
-
-export async function getBenchmarkResult(category: string, title: string): Promise<{ result: BenchmarkResult }> {
-  return fetchApiJson<{ result: BenchmarkResult }>(
-    `/api/benchmark/results/${encodeURIComponent(category)}/${encodeURIComponent(title)}`
-  )
-}
-
-export async function startBenchmarkRun(payload: BenchmarkRunRequest): Promise<{ run: BenchmarkRunSummary }> {
-  return fetchApiJsonOrThrow<{ run: BenchmarkRunSummary }>('/api/benchmark/run', {
-    method: 'POST',
-    headers: jsonHeaders,
-    body: JSON.stringify(payload)
-  }, 'Failed to start benchmark run')
-}
-
-export async function getBenchmarkRun(runId: string): Promise<{ run: BenchmarkRunSummary }> {
-  return fetchApiJson<{ run: BenchmarkRunSummary }>(`/api/benchmark/runs/${encodeURIComponent(runId)}`)
-}

package/src/api/config.ts

@@ -1,29 +0,0 @@
-import type { ConfigSource } from '@vibe-forge/core'
-import type { ConfigResponse, ConfigSchemaResponse } from '@vibe-forge/types'
-
-import { fetchApiJson, fetchApiJsonOrThrow, jsonHeaders } from './base'
-import type { ApiOkResponse } from './types'
-
-export async function getConfig(): Promise<ConfigResponse> {
-  return fetchApiJson<ConfigResponse>('/api/config')
-}
-
-export async function getConfigSchema(): Promise<ConfigSchemaResponse> {
-  return fetchApiJson<ConfigSchemaResponse>('/api/config/schema')
-}
-
-export async function updateConfig(
-  source: ConfigSource,
-  section: string,
-  value: unknown
-): Promise<ApiOkResponse> {
-  return fetchApiJsonOrThrow<ApiOkResponse>(
-    '/api/config',
-    {
-      method: 'PATCH',
-      headers: jsonHeaders,
-      body: JSON.stringify({ source, section, value })
-    },
-    '[api] update config failed:'
-  )
-}

package/src/api/git.ts

@@ -1,90 +0,0 @@
-import type {
-  GitBranchKind,
-  GitBranchListResult,
-  GitCommitPayload,
-  GitMutationResult,
-  GitPushPayload,
-  GitRepositoryState,
-  GitWorktreeListResult
-} from '@vibe-forge/types'
-
-import { fetchApiJson, jsonHeaders } from './base'
-
-export async function getSessionGitState(sessionId: string): Promise<GitRepositoryState> {
-  return fetchApiJson<GitRepositoryState>(`/api/sessions/${sessionId}/git`)
-}
-
-export async function getWorkspaceGitState(): Promise<GitRepositoryState> {
-  return fetchApiJson<GitRepositoryState>('/api/workspace/git')
-}
-
-export async function listSessionGitBranches(sessionId: string): Promise<GitBranchListResult> {
-  return fetchApiJson<GitBranchListResult>(`/api/sessions/${sessionId}/git/branches`)
-}
-
-export async function listWorkspaceGitBranches(): Promise<GitBranchListResult> {
-  return fetchApiJson<GitBranchListResult>('/api/workspace/git/branches')
-}
-
-export async function listSessionGitWorktrees(sessionId: string): Promise<GitWorktreeListResult> {
-  return fetchApiJson<GitWorktreeListResult>(`/api/sessions/${sessionId}/git/worktrees`)
-}
-
-export async function listWorkspaceGitWorktrees(): Promise<GitWorktreeListResult> {
-  return fetchApiJson<GitWorktreeListResult>('/api/workspace/git/worktrees')
-}
-
-export async function checkoutSessionGitBranch(
-  sessionId: string,
-  payload: {
-    name: string
-    kind: GitBranchKind
-  }
-): Promise<GitMutationResult> {
-  return fetchApiJson<GitMutationResult>(`/api/sessions/${sessionId}/git/checkout`, {
-    method: 'POST',
-    headers: jsonHeaders,
-    body: JSON.stringify(payload)
-  })
-}
-
-export async function createSessionGitBranch(
-  sessionId: string,
-  payload: {
-    name: string
-  }
-): Promise<GitMutationResult> {
-  return fetchApiJson<GitMutationResult>(`/api/sessions/${sessionId}/git/branches`, {
-    method: 'POST',
-    headers: jsonHeaders,
-    body: JSON.stringify(payload)
-  })
-}
-
-export async function commitSessionGitChanges(
-  sessionId: string,
-  payload: GitCommitPayload
-): Promise<GitMutationResult> {
-  return fetchApiJson<GitMutationResult>(`/api/sessions/${sessionId}/git/commit`, {
-    method: 'POST',
-    headers: jsonHeaders,
-    body: JSON.stringify(payload)
-  })
-}
-
-export async function pushSessionGitBranch(
-  sessionId: string,
-  payload: GitPushPayload = {}
-): Promise<GitMutationResult> {
-  return fetchApiJson<GitMutationResult>(`/api/sessions/${sessionId}/git/push`, {
-    method: 'POST',
-    headers: jsonHeaders,
-    body: JSON.stringify(payload)
-  })
-}
-
-export async function syncSessionGitBranch(sessionId: string): Promise<GitMutationResult> {
-  return fetchApiJson<GitMutationResult>(`/api/sessions/${sessionId}/git/sync`, {
-    method: 'POST'
-  })
-}

package/src/api/knowledge.ts

@@ -1,131 +0,0 @@
-import { createApiUrl, fetchApiJson } from './base'
-
-export interface SpecSummary {
-  id: string
-  name: string
-  description: string
-  params: { name: string; description?: string }[]
-  always: boolean
-  tags: string[]
-  skills: string[]
-  rules: string[]
-}
-
-export interface EntitySummary {
-  id: string
-  name: string
-  description: string
-  always: boolean
-  tags: string[]
-  skills: string[]
-  rules: string[]
-}
-
-export interface WorkspaceSummary {
-  id: string
-  name: string
-  description: string
-  path: string
-  cwd: string
-  pattern?: string
-}
-
-export interface RuleSummary {
-  id: string
-  name: string
-  description: string
-  always: boolean
-  globs?: string[]
-}
-
-export interface SkillSummary {
-  id: string
-  name: string
-  description: string
-  always: boolean
-  instancePath?: string
-  source: 'project' | 'plugin' | 'home'
-}
-
-export interface SpecDetail extends SpecSummary {
-  body: string
-}
-
-export interface EntityDetail extends EntitySummary {
-  body: string
-}
-
-export interface RuleDetail extends RuleSummary {
-  body: string
-}
-
-export interface SkillDetail extends SkillSummary {
-  body: string
-}
-
-export async function listSpecs(): Promise<{ specs: SpecSummary[] }> {
-  return fetchApiJson<{ specs: SpecSummary[] }>('/api/ai/specs')
-}
-
-export async function listSkills(): Promise<{ skills: SkillSummary[] }> {
-  return fetchApiJson<{ skills: SkillSummary[] }>('/api/ai/skills')
-}
-
-export async function createSkill(params: {
-  name: string
-  description?: string
-  body?: string
-}): Promise<{ skill: SkillDetail }> {
-  return fetchApiJson<{ skill: SkillDetail }>('/api/ai/skills', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(params)
-  })
-}
-
-export async function importSkillArchive(file: File): Promise<{ fileCount: number; targetDir: string }> {
-  return fetchApiJson<{ fileCount: number; targetDir: string }>('/api/ai/skills/import', {
-    method: 'POST',
-    headers: {
-      'Content-Type': file.type || 'application/octet-stream',
-      'x-file-name': encodeURIComponent(file.name)
-    },
-    body: file
-  })
-}
-
-export async function listEntities(): Promise<{ entities: EntitySummary[] }> {
-  return fetchApiJson<{ entities: EntitySummary[] }>('/api/ai/entities')
-}
-
-export async function listWorkspaces(): Promise<{ workspaces: WorkspaceSummary[] }> {
-  return fetchApiJson<{ workspaces: WorkspaceSummary[] }>('/api/ai/workspaces')
-}
-
-export async function listRules(): Promise<{ rules: RuleSummary[] }> {
-  return fetchApiJson<{ rules: RuleSummary[] }>('/api/ai/rules')
-}
-
-export async function getSpecDetail(path: string): Promise<{ spec: SpecDetail }> {
-  const url = createApiUrl('/api/ai/specs/detail')
-  url.searchParams.set('path', path)
-  return fetchApiJson<{ spec: SpecDetail }>(url)
-}
-
-export async function getEntityDetail(path: string): Promise<{ entity: EntityDetail }> {
-  const url = createApiUrl('/api/ai/entities/detail')
-  url.searchParams.set('path', path)
-  return fetchApiJson<{ entity: EntityDetail }>(url)
-}
-
-export async function getRuleDetail(path: string): Promise<{ rule: RuleDetail }> {
-  const url = createApiUrl('/api/ai/rules/detail')
-  url.searchParams.set('path', path)
-  return fetchApiJson<{ rule: RuleDetail }>(url)
-}
-
-export async function getSkillDetail(path: string): Promise<{ skill: SkillDetail }> {
-  const url = createApiUrl('/api/ai/skills/detail')
-  url.searchParams.set('path', path)
-  return fetchApiJson<{ skill: SkillDetail }>(url)
-}

package/src/api/projects.ts

@@ -1,15 +0,0 @@
-import type { Project } from '@vibe-forge/core'
-
-import { fetchApiJson, jsonHeaders } from './base'
-
-export async function listProjects(): Promise<{ projects: Project[] }> {
-  return fetchApiJson<{ projects: Project[] }>('/api/projects')
-}
-
-export async function createProject(name?: string): Promise<{ project: Project }> {
-  return fetchApiJson<{ project: Project }>('/api/projects', {
-    method: 'POST',
-    headers: jsonHeaders,
-    body: JSON.stringify({ name })
-  })
-}