refactor(cli.ts): prettier issues fix

Author: stainless-app[bot]

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.22.1"
+  ".": "0.22.2"
 }

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.22.2 (2026-01-14)
+
+Full Changelog: [v0.22.1...v0.22.2](https://github.com/openlayer-ai/openlayer-ts/compare/v0.22.1...v0.22.2)
+
+### Chores
+
+* fix typo in descriptions ([f269804](https://github.com/openlayer-ai/openlayer-ts/commit/f2698047de4d1e6432c4e62e2609ca2d40b0de93))
+
 ## 0.22.1 (2026-01-12)
 
 Full Changelog: [v0.22.0...v0.22.1](https://github.com/openlayer-ai/openlayer-ts/compare/v0.22.0...v0.22.1)

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "openlayer",
-  "version": "0.22.1",
+  "version": "0.22.2",
   "description": "The official TypeScript library for the Openlayer API",
   "author": "Openlayer <support@openlayer.com>",
   "types": "dist/index.d.ts",

package.json

@@ -19,6 +19,7 @@ import { getCurrentTrace, postProcessTrace } from '../tracing/tracer';
 export interface RunReturn {
   otherFields: { [key: string]: any };
   output: any;
+  [key: string]: unknown;
 }
 
 interface Output {
@@ -42,6 +43,148 @@ export interface Config {
   numOfTokenColumnName?: string;
 }
 
+export type DatasetFormat = 'csv' | 'json';
+
+const DATASET_FILENAMES: Record<DatasetFormat, string> = {
+  csv: 'dataset.csv',
+  json: 'dataset.json',
+};
+
+export function detectDatasetFormat(datasetPath: string): DatasetFormat {
+  const ext = path.extname(datasetPath).toLowerCase();
+  if (ext === '.csv') {
+    return 'csv';
+  }
+  if (ext === '.json') {
+    return 'json';
+  }
+  throw new Error(`Unsupported dataset format: ${datasetPath}`);
+}
+
+function parseCsvLine(line: string): string[] {
+  const result: string[] = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < line.length; i += 1) {
+    const char = line[i];
+    const next = line[i + 1];
+
+    if (inQuotes) {
+      if (char === '"' && next === '"') {
+        current += '"';
+        i += 1; // skip escaped quote
+      } else if (char === '"') {
+        inQuotes = false;
+      } else {
+        current += char;
+      }
+    } else if (char === ',') {
+      result.push(current);
+      current = '';
+    } else if (char === '"') {
+      inQuotes = true;
+    } else {
+      current += char;
+    }
+  }
+
+  result.push(current);
+  return result;
+}
+
+export function parseCsv(content: string): Record<string, string>[] {
+  const lines = content.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  if (lines.length === 0) {
+    return [];
+  }
+
+  const headers = parseCsvLine(lines[0]!);
+  return lines.slice(1).map((line) => {
+    const values = parseCsvLine(line);
+    const row: Record<string, string> = {};
+    headers.forEach((header, idx) => {
+      row[header] = values[idx] ?? '';
+    });
+    return row;
+  });
+}
+
+function escapeCsvValue(value: unknown): string {
+  if (value === undefined || value === null) {
+    return '';
+  }
+  const str = String(value);
+  const needsQuotes = /[",\n\r]/.test(str);
+  const escaped = str.replace(/"/g, '""');
+  return needsQuotes ? `"${escaped}"` : escaped;
+}
+
+function collectHeaders(rows: Record<string, unknown>[]): string[] {
+  const headers: string[] = [];
+  rows.forEach((row) => {
+    Object.keys(row).forEach((key) => {
+      if (!headers.includes(key)) {
+        headers.push(key);
+      }
+    });
+  });
+  return headers;
+}
+
+export function serializeCsv(rows: Record<string, unknown>[]): string {
+  if (rows.length === 0) {
+    return '';
+  }
+  const headers = collectHeaders(rows);
+  const headerLine = headers.map(escapeCsvValue).join(',');
+  const dataLines = rows.map((row) => headers.map((header) => escapeCsvValue(row[header])).join(','));
+  return [headerLine, ...dataLines].join('\n');
+}
+
+export function loadDataset(datasetPath: string): { data: any[]; format: DatasetFormat } {
+  const datasetFullPath = path.resolve(datasetPath);
+  const rawData = fs.readFileSync(datasetFullPath, 'utf8');
+  const format = detectDatasetFormat(datasetFullPath);
+
+  if (format === 'json') {
+    const parsed = JSON.parse(rawData);
+    if (!Array.isArray(parsed)) {
+      throw new Error('Dataset JSON must be an array of records');
+    }
+    return { data: parsed, format };
+  }
+
+  const parsed = parseCsv(rawData);
+  return { data: parsed, format };
+}
+
+export function writeDataset(
+  outputDir: string,
+  rows: RunReturn[],
+  format: DatasetFormat,
+  config: Config,
+): void {
+  const outputDirPath = path.resolve(outputDir);
+  fs.mkdirSync(outputDirPath, { recursive: true });
+
+  const datasetFilename = DATASET_FILENAMES[format];
+  const datasetPath = path.join(outputDirPath, datasetFilename);
+  const configPath = path.join(outputDirPath, 'config.json');
+
+  if (format === 'json') {
+    fs.writeFileSync(datasetPath, JSON.stringify(rows, null, 4), 'utf8');
+  } else {
+    const csvContent = serializeCsv(rows);
+    fs.writeFileSync(datasetPath, csvContent, 'utf8');
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 4), 'utf8');
+
+  console.info(`Output written to ${datasetPath}`);
+  console.info(`Config written to ${configPath}`);
+}
+
 class CLIHandler {
   private run: (...args: any[]) => Promise<any>;
 
@@ -59,10 +202,7 @@ class CLIHandler {
     const options = program.opts();
     const { datasetPath, outputDir } = options;
 
-    // Load dataset
-    const datasetFullPath = path.resolve(datasetPath);
-    const rawData = fs.readFileSync(datasetFullPath, 'utf8');
-    const dataset = JSON.parse(rawData);
+    const { data: dataset, format } = loadDataset(datasetPath);
 
     // Process each item in the dataset dynamically
     Promise.all<Output>(

src/lib/core/cli.ts

@@ -1 +1 @@
-export const VERSION = '0.22.1'; // x-release-please-version
+export const VERSION = '0.22.2'; // x-release-please-version