orizu 0.0.2

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "orizu",
+  "version": "0.0.2",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "orizu": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}

package/src/credentials.ts

@@ -0,0 +1,37 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync, chmodSync, existsSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+import { StoredCredentials } from './types.js'
+
+function getConfigDir(): string {
+  return join(homedir(), '.config', 'orizu')
+}
+
+function getCredentialsPath(): string {
+  return join(getConfigDir(), 'credentials.json')
+}
+
+export function saveCredentials(credentials: StoredCredentials) {
+  const dir = getConfigDir()
+  mkdirSync(dir, { recursive: true })
+  const path = getCredentialsPath()
+  writeFileSync(path, JSON.stringify(credentials, null, 2), 'utf-8')
+  chmodSync(path, 0o600)
+}
+
+export function loadCredentials(): StoredCredentials | null {
+  const path = getCredentialsPath()
+  if (!existsSync(path)) {
+    return null
+  }
+
+  const raw = readFileSync(path, 'utf-8')
+  return JSON.parse(raw) as StoredCredentials
+}
+
+export function clearCredentials() {
+  const path = getCredentialsPath()
+  if (existsSync(path)) {
+    rmSync(path)
+  }
+}

package/src/csv.ts

@@ -0,0 +1,83 @@
+export function parseCSV(csvText: string): string[][] {
+  const result: string[][] = []
+  let currentRow: string[] = []
+  let currentField = ''
+  let inQuotes = false
+  let i = 0
+
+  while (i < csvText.length) {
+    const char = csvText[i]
+    const nextChar = csvText[i + 1]
+
+    if (char === '"') {
+      if (inQuotes && nextChar === '"') {
+        currentField += '"'
+        i += 2
+        continue
+      }
+
+      inQuotes = !inQuotes
+      i++
+      continue
+    }
+
+    if (!inQuotes) {
+      if (char === ',') {
+        currentRow.push(currentField)
+        currentField = ''
+        i++
+        continue
+      }
+
+      if (char === '\n' || char === '\r') {
+        if (currentField || currentRow.length > 0) {
+          currentRow.push(currentField)
+          if (currentRow.some(field => field.trim())) {
+            result.push(currentRow)
+          }
+          currentRow = []
+          currentField = ''
+        }
+
+        if (char === '\r' && nextChar === '\n') {
+          i += 2
+        } else {
+          i++
+        }
+
+        continue
+      }
+    }
+
+    currentField += char
+    i++
+  }
+
+  if (currentField || currentRow.length > 0) {
+    currentRow.push(currentField)
+    if (currentRow.some(field => field.trim())) {
+      result.push(currentRow)
+    }
+  }
+
+  return result
+}
+
+export function parseCSVToObjects(csvText: string): Record<string, unknown>[] {
+  const rows = parseCSV(csvText)
+
+  if (rows.length < 2) {
+    return []
+  }
+
+  const headers = rows[0].map(header => header.trim())
+  const dataRows = rows.slice(1)
+
+  return dataRows.map(row => {
+    const obj: Record<string, unknown> = {}
+    headers.forEach((header, index) => {
+      obj[header] = row[index]?.trim() || ''
+    })
+    return obj
+  })
+}

package/src/file-parser.ts

@@ -0,0 +1,83 @@
+import { readFileSync } from 'fs'
+import { extname } from 'path'
+import { parseCSVToObjects } from './csv.js'
+
+export function parseDatasetFile(filePath: string): {
+  rows: Array<Record<string, unknown>>
+  sourceType: 'csv' | 'json' | 'jsonl'
+} {
+  const extension = extname(filePath).toLowerCase()
+  let content: string
+
+  try {
+    content = readFileSync(filePath, 'utf-8')
+  } catch (error) {
+    const maybeError = error as NodeJS.ErrnoException
+
+    if (maybeError.code === 'ENOENT') {
+      throw new Error(
+        `File not found: ${filePath}. Check the path and filename, then retry.`
+      )
+    }
+
+    if (maybeError.code === 'EPERM' || maybeError.code === 'EACCES') {
+      throw new Error(
+        `Cannot read file: ${filePath}. macOS may be blocking access to this folder (for example Downloads). Grant folder permission to your terminal app and retry.`
+      )
+    }
+
+    throw new Error(`Failed to read file ${filePath}: ${maybeError.message}`)
+  }
+
+  if (extension === '.csv') {
+    const rows = parseCSVToObjects(content)
+    return {
+      rows: ensureObjectRows(rows),
+      sourceType: 'csv',
+    }
+  }
+
+  if (extension === '.json') {
+    const data = JSON.parse(content)
+    if (!Array.isArray(data)) {
+      throw new Error('JSON file must contain a top-level array')
+    }
+
+    return {
+      rows: ensureObjectRows(data),
+      sourceType: 'json',
+    }
+  }
+
+  if (extension === '.jsonl') {
+    const lines = content.split(/\r?\n/).map(line => line.trim()).filter(Boolean)
+    const parsed = lines.map((line, index) => {
+      try {
+        return JSON.parse(line)
+      } catch {
+        throw new Error(`Invalid JSONL at line ${index + 1}`)
+      }
+    })
+
+    return {
+      rows: ensureObjectRows(parsed),
+      sourceType: 'jsonl',
+    }
+  }
+
+  throw new Error('Unsupported file type. Use .csv, .json, or .jsonl')
+}
+
+function ensureObjectRows(rows: unknown[]): Array<Record<string, unknown>> {
+  if (rows.length === 0) {
+    throw new Error('Dataset file contains no rows')
+  }
+
+  return rows.map((row, index) => {
+    if (!row || Array.isArray(row) || typeof row !== 'object') {
+      throw new Error(`Row ${index + 1} must be a JSON object`)
+    }
+
+    return row as Record<string, unknown>
+  })
+}

package/src/http.ts

@@ -0,0 +1,66 @@
+import { loadCredentials, saveCredentials } from './credentials.js'
+import { LoginResponse, StoredCredentials } from './types.js'
+
+export function getBaseUrl(): string {
+  return process.env.ORIZU_BASE_URL || 'http://localhost:3000'
+}
+
+function isExpired(expiresAt: number): boolean {
+  const nowUnix = Math.floor(Date.now() / 1000)
+  return expiresAt <= nowUnix + 30
+}
+
+async function refreshCredentials(credentials: StoredCredentials): Promise<StoredCredentials> {
+  const response = await fetch(`${credentials.baseUrl}/api/cli/auth/refresh`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ refreshToken: credentials.refreshToken }),
+  })
+
+  if (!response.ok) {
+    throw new Error('Session expired. Run `orizu login` again.')
+  }
+
+  const data = await response.json() as LoginResponse
+  const refreshed = {
+    accessToken: data.accessToken,
+    refreshToken: data.refreshToken,
+    expiresAt: data.expiresAt,
+    baseUrl: credentials.baseUrl,
+  }
+  saveCredentials(refreshed)
+  return refreshed
+}
+
+export async function authedFetch(path: string, init: RequestInit = {}) {
+  const credentials = loadCredentials()
+  if (!credentials) {
+    throw new Error('Not logged in. Run `orizu login` first.')
+  }
+
+  let activeCredentials = credentials
+  if (isExpired(activeCredentials.expiresAt)) {
+    activeCredentials = await refreshCredentials(activeCredentials)
+  }
+
+  let response = await fetch(`${activeCredentials.baseUrl}${path}`, {
+    ...init,
+    headers: {
+      ...(init.headers || {}),
+      Authorization: `Bearer ${activeCredentials.accessToken}`,
+    },
+  })
+
+  if (response.status === 401) {
+    activeCredentials = await refreshCredentials(activeCredentials)
+    response = await fetch(`${activeCredentials.baseUrl}${path}`, {
+      ...init,
+      headers: {
+        ...(init.headers || {}),
+        Authorization: `Bearer ${activeCredentials.accessToken}`,
+      },
+    })
+  }
+
+  return response
+}