kin/web/frontend/src/api.ts

const BASE = '/api'

async function get<T>(path: string): Promise<T> {
  const res = await fetch(`${BASE}${path}`)
  if (!res.ok) throw new Error(`${res.status} ${res.statusText}`)
  return res.json()
}

async function patch<T>(path: string, body: unknown): Promise<T> {
  const res = await fetch(`${BASE}${path}`, {
    method: 'PATCH',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(body),
  })
  if (!res.ok) throw new Error(`${res.status} ${res.statusText}`)
  return res.json()
}

async function post<T>(path: string, body: unknown): Promise<T> {
  const res = await fetch(`${BASE}${path}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(body),
  })
  if (!res.ok) throw new Error(`${res.status} ${res.statusText}`)
  return res.json()
}

async function del<T>(path: string): Promise<T> {
  const res = await fetch(`${BASE}${path}`, { method: 'DELETE' })
  if (!res.ok) throw new Error(`${res.status} ${res.statusText}`)
  return res.json()
}

export interface Project {
  id: string
  name: string
  path: string
  status: string
  priority: number
  tech_stack: string[] | null
  execution_mode: string | null
  autocommit_enabled: number | null
  obsidian_vault_path: string | null
  deploy_command: string | null
  created_at: string
  total_tasks: number
  done_tasks: number
  active_tasks: number
  blocked_tasks: number
  review_tasks: number
}

export interface ObsidianSyncResult {
  exported_decisions: number
  tasks_updated: number
  errors: string[]
  vault_path: string
}

export interface ProjectDetail extends Project {
  tasks: Task[]
  modules: Module[]
  decisions: Decision[]
}

export interface Task {
  id: string
  project_id: string
  title: string
  status: string
  priority: number
  assigned_role: string | null
  parent_task_id: string | null
  brief: Record<string, unknown> | null
  spec: Record<string, unknown> | null
  execution_mode: string | null
  blocked_reason: string | null
  dangerously_skipped: number | null
  category: string | null
  created_at: string
  updated_at: string
}

export interface Decision {
  id: number
  project_id: string
  task_id: string | null
  type: string
  category: string | null
  title: string
  description: string
  tags: string[] | null
  created_at: string
}

export interface Module {
  id: number
  project_id: string
  name: string
  type: string
  path: string
  description: string | null
  owner_role: string | null
  dependencies: string[] | null
}

export interface PipelineStep {
  id: number
  agent_role: string
  action: string
  output_summary: string | null
  success: boolean | number
  duration_seconds: number | null
  tokens_used: number | null
  model: string | null
  cost_usd: number | null
  created_at: string
}

export interface DeployResult {
  success: boolean
  exit_code: number
  stdout: string
  stderr: string
  duration_seconds: number
}

export interface TaskFull extends Task {
  pipeline_steps: PipelineStep[]
  related_decisions: Decision[]
  project_deploy_command: string | null
}

export interface PendingAction {
  type: string
  description: string
  original_item: Record<string, unknown>
  options: string[]
}

export interface CostEntry {
  project_id: string
  project_name: string
  runs: number
  total_tokens: number
  total_cost_usd: number
  total_duration_seconds: number
}

export interface AuditItem {
  id: string
  reason: string
}

export interface AuditResult {
  success: boolean
  already_done: AuditItem[]
  still_pending: AuditItem[]
  unclear: AuditItem[]
  duration_seconds?: number
  cost_usd?: number
  error?: string
}

export const api = {
  projects: () => get<Project[]>('/projects'),
  project: (id: string) => get<ProjectDetail>(`/projects/${id}`),
  task: (id: string) => get<Task>(`/tasks/${id}`),
  taskFull: (id: string) => get<TaskFull>(`/tasks/${id}/full`),
  taskPipeline: (id: string) => get<PipelineStep[]>(`/tasks/${id}/pipeline`),
  cost: (days = 7) => get<CostEntry[]>(`/cost?days=${days}`),
  createProject: (data: { id: string; name: string; path: string; tech_stack?: string[]; priority?: number }) =>
    post<Project>('/projects', data),
  createTask: (data: { project_id: string; title: string; priority?: number; route_type?: string; category?: string }) =>
    post<Task>('/tasks', data),
  approveTask: (id: string, data?: { decision_title?: string; decision_description?: string; decision_type?: string; create_followups?: boolean }) =>
    post<{ status: string; followup_tasks: Task[]; needs_decision: boolean; pending_actions: PendingAction[] }>(`/tasks/${id}/approve`, data || {}),
  resolveAction: (id: string, action: PendingAction, choice: string) =>
    post<{ choice: string; result: unknown }>(`/tasks/${id}/resolve`, { action, choice }),
  rejectTask: (id: string, reason: string) =>
    post<{ status: string }>(`/tasks/${id}/reject`, { reason }),
  reviseTask: (id: string, comment: string) =>
    post<{ status: string; comment: string }>(`/tasks/${id}/revise`, { comment }),
  runTask: (id: string) =>
    post<{ status: string }>(`/tasks/${id}/run`, {}),
  bootstrap: (data: { path: string; id: string; name: string }) =>
    post<{ project: Project }>('/bootstrap', data),
  auditProject: (projectId: string) =>
    post<AuditResult>(`/projects/${projectId}/audit`, {}),
  auditApply: (projectId: string, taskIds: string[]) =>
    post<{ updated: string[]; count: number }>(`/projects/${projectId}/audit/apply`, { task_ids: taskIds }),
  patchTask: (id: string, data: { status?: string; execution_mode?: string; priority?: number; route_type?: string; title?: string; brief_text?: string }) =>
    patch<Task>(`/tasks/${id}`, data),
  patchProject: (id: string, data: { execution_mode?: string; autocommit_enabled?: boolean; obsidian_vault_path?: string; deploy_command?: string }) =>
    patch<Project>(`/projects/${id}`, data),
  deployProject: (projectId: string) =>
    post<DeployResult>(`/projects/${projectId}/deploy`, {}),
  syncObsidian: (projectId: string) =>
    post<ObsidianSyncResult>(`/projects/${projectId}/sync/obsidian`, {}),
  deleteDecision: (projectId: string, decisionId: number) =>
    del<{ deleted: number }>(`/projects/${projectId}/decisions/${decisionId}`),
  createDecision: (data: { project_id: string; type: string; title: string; description: string; category?: string; tags?: string[] }) =>
    post<Decision>('/decisions', data),
}