orizu 0.0.2

package/dist/credentials.js

@@ -0,0 +1,30 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync, chmodSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+function getConfigDir() {
+    return join(homedir(), '.config', 'orizu');
+}
+function getCredentialsPath() {
+    return join(getConfigDir(), 'credentials.json');
+}
+export function saveCredentials(credentials) {
+    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() {
+    const path = getCredentialsPath();
+    if (!existsSync(path)) {
+        return null;
+    }
+    const raw = readFileSync(path, 'utf-8');
+    return JSON.parse(raw);
+}
+export function clearCredentials() {
+    const path = getCredentialsPath();
+    if (existsSync(path)) {
+        rmSync(path);
+    }
+}

package/dist/csv.js

@@ -0,0 +1,70 @@
+export function parseCSV(csvText) {
+    const result = [];
+    let currentRow = [];
+    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) {
+    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 = {};
+        headers.forEach((header, index) => {
+            obj[header] = row[index]?.trim() || '';
+        });
+        return obj;
+    });
+}

package/dist/file-parser.js

@@ -0,0 +1,64 @@
+import { readFileSync } from 'fs';
+import { extname } from 'path';
+import { parseCSVToObjects } from './csv.js';
+export function parseDatasetFile(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    let content;
+    try {
+        content = readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        const maybeError = error;
+        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) {
+    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;
+    });
+}

package/dist/http.js

@@ -0,0 +1,55 @@
+import { loadCredentials, saveCredentials } from './credentials.js';
+export function getBaseUrl() {
+    return process.env.ORIZU_BASE_URL || 'http://localhost:3000';
+}
+function isExpired(expiresAt) {
+    const nowUnix = Math.floor(Date.now() / 1000);
+    return expiresAt <= nowUnix + 30;
+}
+async function refreshCredentials(credentials) {
+    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();
+    const refreshed = {
+        accessToken: data.accessToken,
+        refreshToken: data.refreshToken,
+        expiresAt: data.expiresAt,
+        baseUrl: credentials.baseUrl,
+    };
+    saveCredentials(refreshed);
+    return refreshed;
+}
+export async function authedFetch(path, init = {}) {
+    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;
+}