@fastino-ai/pioneer-cli 0.2.2 → 0.2.3

package/src/api.ts

@@ -12,6 +12,37 @@ export interface ApiResult<T = unknown> {
   error?: string;
 }
 
+/**
+ * Format authentication error with helpful fix instructions.
+ */
+function formatAuthError(originalError?: string): string {
+  return [
+    "Felix API authentication failed.",
+    "",
+    "To fix this, set your API key:",
+    "  export PIONEER_API_KEY=your-key-here",
+    "",
+    "Or login interactively:",
+    "  pioneer auth login",
+    originalError ? `\nOriginal error: ${originalError}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+/**
+ * Check if error is authentication-related.
+ */
+function isAuthError(status: number, errorText: string): boolean {
+  return (
+    status === 401 ||
+    status === 403 ||
+    errorText.toLowerCase().includes("authentication") ||
+    errorText.toLowerCase().includes("api key") ||
+    errorText.toLowerCase().includes("unauthorized")
+  );
+}
+
 async function request<T = unknown>(
   method: string,
   path: string,
@@ -21,6 +52,10 @@ async function request<T = unknown>(
   const apiKey = getApiKey();
   const url = `${baseUrl}${path}`;
 
+  // Debug logging
+  console.error(`[DEBUG] Request: ${method} ${url}`);
+  console.error(`[DEBUG] API Key present: ${!!apiKey}, starts with: ${apiKey?.slice(0, 10)}...`);
+
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
     "User-Agent": "pioneer-cli/0.1.0",
@@ -46,10 +81,22 @@ async function request<T = unknown>(
     }
 
     if (!res.ok) {
+      const rawError = data ? JSON.stringify(data) : text || `HTTP ${res.status}`;
+      
+      // Format authentication errors with helpful instructions
+      if (isAuthError(res.status, rawError)) {
+        console.error(`[DEBUG] Auth error - status: ${res.status}, response: ${rawError}`);
+        return {
+          ok: false,
+          status: res.status,
+          error: formatAuthError(rawError),
+        };
+      }
+
       return {
         ok: false,
         status: res.status,
-        error: data ? JSON.stringify(data) : text || `HTTP ${res.status}`,
+        error: rawError,
       };
     }
 
@@ -63,6 +110,15 @@ async function request<T = unknown>(
   }
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Common Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface DatasetRef {
+  name: string;
+  version: string;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Auth - validate API key by calling /felix/datasets
 // ─────────────────────────────────────────────────────────────────────────────
@@ -112,8 +168,12 @@ export interface Dataset {
   dataset_type: string;
   size?: number;
   sample_size?: number;
+  version_number?: string;
+  root_dataset_id?: string;
+  schema?: Record<string, unknown>;
+  schema_warnings?: string[];
   created_at: string;
-  updated_at: string;
+  updated_at?: string;
 }
 
 export interface DatasetListResponse {
@@ -122,12 +182,20 @@ export interface DatasetListResponse {
   count: number;
 }
 
-export async function listDatasets(): Promise<ApiResult<DatasetListResponse>> {
-  return request<DatasetListResponse>("GET", "/felix/datasets");
+export async function listDatasets(
+  options: { includeAllVersions?: boolean } = {}
+): Promise<ApiResult<DatasetListResponse>> {
+  const params = new URLSearchParams();
+  if (options.includeAllVersions) {
+    params.set("include_all_versions", "true");
+  }
+  const query = params.toString();
+  const url = query ? `/felix/datasets?${query}` : "/felix/datasets";
+  return request<DatasetListResponse>("GET", url);
 }
 
-export async function getDataset(datasetId: string): Promise<ApiResult<Dataset>> {
-  return request<Dataset>("GET", `/felix/datasets/${datasetId}`);
+export async function getDataset(dataset: DatasetRef): Promise<ApiResult<Dataset>> {
+  return request<Dataset>("GET", `/felix/datasets/${dataset.name}/${dataset.version}`);
 }
 
 export interface DatasetCreateRequest {
@@ -144,25 +212,160 @@ export async function createDataset(
   return request<Dataset>("POST", "/felix/datasets", req);
 }
 
-export async function deleteDataset(datasetId: string): Promise<ApiResult> {
-  return request("DELETE", `/felix/datasets/${datasetId}`);
+export async function deleteDataset(dataset: DatasetRef): Promise<ApiResult> {
+  return request("DELETE", `/felix/datasets/${dataset.name}/${dataset.version}`);
+}
+
+export interface DatasetUploadRequest {
+  dataset_name: string;
+  dataset_type?: "ner" | "classification" | "custom";
+  format?: "jsonl" | "csv" | "parquet";
+  schema?: Record<string, string>;
+}
+
+export async function uploadDataset(
+  filePath: string,
+  options: DatasetUploadRequest
+): Promise<ApiResult<Dataset>> {
+  const baseUrl = getBaseUrl().replace(/\/$/, "");
+  const apiKey = getApiKey();
+  const url = `${baseUrl}/datasets/upload`;
+
+  const headers: Record<string, string> = {
+    "User-Agent": "pioneer-cli/0.1.0",
+  };
+
+  if (apiKey) {
+    headers["X-API-Key"] = apiKey;
+  }
+
+  try {
+    const fs = await import("fs");
+    const path = await import("path");
+    const fileContent = fs.readFileSync(filePath);
+    const filename = path.basename(filePath);
+
+    const formData = new FormData();
+    formData.append("file", new Blob([fileContent]), filename);
+    formData.append("dataset_name", options.dataset_name);
+    if (options.dataset_type) {
+      formData.append("dataset_type", options.dataset_type);
+    }
+    if (options.format) {
+      formData.append("format", options.format);
+    }
+    if (options.schema) {
+      formData.append("schema", JSON.stringify(options.schema));
+    }
+
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: formData,
+    });
+
+    const text = await res.text();
+    let data: Dataset | undefined;
+    try {
+      data = JSON.parse(text) as Dataset;
+    } catch {
+      // Not JSON
+    }
+
+    if (!res.ok) {
+      return {
+        ok: false,
+        status: res.status,
+        error: data ? JSON.stringify(data) : text || `HTTP ${res.status}`,
+      };
+    }
+
+    return { ok: true, status: res.status, data };
+  } catch (err) {
+    return {
+      ok: false,
+      status: 0,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
 }
 
 export interface DatasetDownloadResponse {
   download_url: string;
+  file_path?: string;
+  size?: number;
+  dataset_name?: string;
+  version?: string;
 }
 
 export async function downloadDataset(
-  datasetId: string
+  dataset: DatasetRef,
+  format: "csv" | "jsonl" | "parquet" = "jsonl",
+  outputPath?: string
 ): Promise<ApiResult<DatasetDownloadResponse>> {
-  return request<DatasetDownloadResponse>(
-    "GET",
-    `/felix/datasets/${datasetId}/download`
-  );
+  const baseUrl = getBaseUrl().replace(/\/$/, "");
+  const apiKey = getApiKey();
+  const downloadUrl = `${baseUrl}/datasets/${dataset.name}/${dataset.version}/download?format=${format}`;
+
+  // Generate default filename if not specified
+  const safeDatasetName = dataset.name.replace(/[^a-zA-Z0-9-_]/g, "_");
+  if (!outputPath) {
+    outputPath = `${safeDatasetName}_${dataset.version}.${format}`;
+  }
+
+  // Download the file
+  const headers: Record<string, string> = {
+    "User-Agent": "pioneer-cli/0.1.0",
+  };
+
+  if (apiKey) {
+    headers["X-API-Key"] = apiKey;
+  }
+
+  try {
+    const res = await fetch(downloadUrl, {
+      method: "GET",
+      headers,
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      return {
+        ok: false,
+        status: res.status,
+        error: text || `HTTP ${res.status}`,
+      };
+    }
+
+    // Write the file
+    const fs = await import("fs");
+    const buffer = await res.arrayBuffer();
+    fs.writeFileSync(outputPath, Buffer.from(buffer));
+
+    return {
+      ok: true,
+      status: 200,
+      data: {
+        download_url: downloadUrl,
+        file_path: outputPath,
+        size: buffer.byteLength,
+        dataset_name: dataset.name,
+        version: dataset.version,
+      },
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      status: 0,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
 }
 
 export interface DatasetAnalysisRequest {
-  dataset_id: string;
+  dataset: DatasetRef;
+  task_type: string;
+  analyses: string[];
 }
 
 export interface DatasetAnalysisResponse {
@@ -171,10 +374,15 @@ export interface DatasetAnalysisResponse {
 }
 
 export async function analyzeDataset(
-  datasetId: string
+  dataset: DatasetRef,
+  taskType: string,
+  analyses: string[]
 ): Promise<ApiResult<DatasetAnalysisResponse>> {
   return request<DatasetAnalysisResponse>("POST", "/felix/dataset/analyze", {
-    dataset_id: datasetId,
+    dataset_name: dataset.name,
+    dataset_version: dataset.version,
+    task_type: taskType,
+    analyses: analyses,
   });
 }
 
@@ -437,7 +645,7 @@ export async function getJob(jobId: string): Promise<ApiResult<TrainingJob>> {
 
 export interface TrainingJobCreateRequest {
   model_name: string;
-  dataset_ids: string[];
+  datasets: DatasetRef[];
   base_model?: string;
   validation_data_percentage?: number;
   nr_epochs?: number;
@@ -515,7 +723,7 @@ export interface TrainedModel {
 
 export interface TrainedModelsListResponse {
   success: boolean;
-  models: TrainedModel[];
+  training_jobs: TrainedModel[];
   count: number;
 }
 
@@ -548,7 +756,7 @@ export async function listAllModels(): Promise<ApiResult<AllModelsResponse>> {
     status: 200,
     data: {
       deployed: deployedResult.data?.models ?? [],
-      trained: trainedResult.data?.models ?? [],
+      trained: trainedResult.data?.training_jobs ?? [],
     },
   };
 }
@@ -587,12 +795,333 @@ export async function getEvaluation(
 }
 
 export interface EvaluationCreateRequest {
-  dataset_id: string;
-  model_id?: string;
+  dataset: DatasetRef;
+  model_id: string;
+  task_type?: string;
+  text_column?: string;
+  label_column?: string;
 }
 
 export async function createEvaluation(
   req: EvaluationCreateRequest
 ): Promise<ApiResult<Evaluation>> {
-  return request<Evaluation>("POST", "/felix/evaluations", req);
+  const { dataset, ...rest } = req;
+  return request<Evaluation>("POST", "/felix/evaluations", {
+    ...rest,
+    dataset_name: dataset.name,
+    dataset_version: dataset.version,
+  });
+}
+
+export interface ModelWithEvaluation {
+  model_id: string;
+  model_name: string;
+  is_base_model: boolean;
+  evaluation?: Evaluation;
+}
+
+export interface DatasetEvaluationsResponse {
+  success: boolean;
+  dataset_id: string;
+  dataset_name: string;
+  sample_count: number;
+  models: ModelWithEvaluation[];
+  count: number;
+}
+
+export async function getDatasetEvaluations(
+  dataset: DatasetRef
+): Promise<ApiResult<DatasetEvaluationsResponse>> {
+  return request<DatasetEvaluationsResponse>(
+    "GET",
+    `/felix/datasets/${dataset.name}/${dataset.version}/evaluations`
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Benchmarks
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface BenchmarkInfo {
+  name: string;
+  description: string;
+  task: string;
+  dataset_source?: string;
+  metrics: string[];
+}
+
+export interface ListBenchmarksResponse {
+  success: boolean;
+  benchmarks: Record<string, BenchmarkInfo[]>;
+  count: number;
+}
+
+export async function listBenchmarks(): Promise<ApiResult<ListBenchmarksResponse>> {
+  return request<ListBenchmarksResponse>("GET", "/felix/benchmarks");
+}
+
+export interface BenchmarkEvaluationRequest {
+  model_id: string;
+  task: "ner" | "text_classification";
+  benchmark: string;
+  max_samples?: number;
+  split?: string;
+  benchmark_config?: Record<string, unknown>;
+}
+
+export interface BenchmarkEvaluationResponse {
+  success: boolean;
+  evaluation_id: string;
+  status: "pending" | "running" | "complete" | "errored";
+  task: string;
+  benchmark: string;
+  model_id: string;
+  metrics?: Record<string, unknown>;
+  error_message?: string;
+  created_at: string;
+  completed_at?: string;
+}
+
+export async function startBenchmarkEvaluation(
+  req: BenchmarkEvaluationRequest
+): Promise<ApiResult<BenchmarkEvaluationResponse>> {
+  return request<BenchmarkEvaluationResponse>("POST", "/felix/benchmarks/evaluate", req);
+}
+
+export async function getBenchmarkEvaluation(
+  evaluationId: string
+): Promise<ApiResult<BenchmarkEvaluationResponse>> {
+  return request<BenchmarkEvaluationResponse>(
+    "GET",
+    `/felix/benchmarks/evaluate/${evaluationId}`
+  );
+}
+
+export async function cancelBenchmarkEvaluation(
+  evaluationId: string
+): Promise<ApiResult<{ success: boolean; message: string }>> {
+  return request<{ success: boolean; message: string }>(
+    "POST",
+    `/felix/benchmarks/evaluate/${evaluationId}/cancel`
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Data Editing (operates on persisted datasets)
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface PIIFinding {
+  row_index: number;
+  column: string;
+  entity_type: string;
+  text: string;
+  start: number;
+  end: number;
+  score: number;
+}
+
+export interface DataEditingScanRequest {
+  dataset: DatasetRef;
+  columns?: string[];
+  threshold?: number;
+}
+
+export interface DataEditingScanResponse {
+  success: boolean;
+  dataset_id: string;
+  scan_type: "pii" | "phd";
+  findings_count: number;
+  affected_rows: number;
+  findings: PIIFinding[];
+}
+
+export async function scanForPII(
+  req: DataEditingScanRequest
+): Promise<ApiResult<DataEditingScanResponse>> {
+  const { dataset, ...rest } = req;
+  return request<DataEditingScanResponse>("POST", "/felix/data-editing/scan-pii", {
+    ...rest,
+    dataset_name: dataset.name,
+    dataset_version: dataset.version,
+  });
+}
+
+export async function scanForPHD(
+  req: DataEditingScanRequest
+): Promise<ApiResult<DataEditingScanResponse>> {
+  const { dataset, ...rest } = req;
+  return request<DataEditingScanResponse>("POST", "/felix/data-editing/scan-phd", {
+    ...rest,
+    dataset_name: dataset.name,
+    dataset_version: dataset.version,
+  });
+}
+
+export interface DataEditingRemoveRequest {
+  dataset: DatasetRef;
+  findings: PIIFinding[];
+  redaction_method?: "redact" | "remove_row" | "mask";
+  save_as_new?: boolean;
+}
+
+export interface DataEditingRemoveResponse {
+  success: boolean;
+  dataset_id: string;
+  new_dataset_id?: string;
+  rows_affected: number;
+  entities_removed: number;
+  message: string;
+}
+
+export async function removePII(
+  req: DataEditingRemoveRequest
+): Promise<ApiResult<DataEditingRemoveResponse>> {
+  const { dataset, ...rest } = req;
+  return request<DataEditingRemoveResponse>("POST", "/felix/data-editing/remove-pii", {
+    ...rest,
+    dataset_name: dataset.name,
+    dataset_version: dataset.version,
+  });
+}
+
+export interface DataEditingSubsampleRequest {
+  dataset: DatasetRef;
+  method?: "random" | "balanced" | "stratified";
+  n: number;
+  label_column?: string;
+  seed?: number;
+  save_as_new?: boolean;
+}
+
+export interface DataEditingSubsampleResponse {
+  success: boolean;
+  dataset_id: string;
+  new_dataset_id: string;
+  original_rows: number;
+  new_rows: number;
+  method: string;
+  message: string;
+}
+
+export async function subsampleDataset(
+  req: DataEditingSubsampleRequest
+): Promise<ApiResult<DataEditingSubsampleResponse>> {
+  const { dataset, ...rest } = req;
+  return request<DataEditingSubsampleResponse>("POST", "/felix/data-editing/subsample", {
+    ...rest,
+    dataset_name: dataset.name,
+    dataset_version: dataset.version,
+  });
+}
+
+export interface DataEditingCheckLabelsRequest {
+  dataset: DatasetRef;
+  text_column: string;
+  label_column: string;
+  sample_size?: number;
+}
+
+export interface LabelCheckResult {
+  row_index: number;
+  text: string;
+  current_label: string;
+  suggested_label: string;
+  confidence: number;
+  reasoning: string;
+}
+
+export interface DataEditingCheckLabelsResponse {
+  success: boolean;
+  dataset_id: string;
+  checked_count: number;
+  issues_found: number;
+  results: LabelCheckResult[];
+}
+
+export async function checkLabels(
+  req: DataEditingCheckLabelsRequest
+): Promise<ApiResult<DataEditingCheckLabelsResponse>> {
+  const { dataset, ...rest } = req;
+  return request<DataEditingCheckLabelsResponse>("POST", "/felix/data-editing/check-labels", {
+    ...rest,
+    dataset_name: dataset.name,
+    dataset_version: dataset.version,
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Hugging Face Integration
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface HuggingFacePushRequest {
+  hf_token: string;
+  repo_id: string;
+  private?: boolean;
+}
+
+export interface HuggingFacePushResponse {
+  success: boolean;
+  repo_url: string;
+  repo_id: string;
+  message?: string;
+}
+
+export async function pushDatasetToHub(
+  dataset: DatasetRef,
+  options: HuggingFacePushRequest
+): Promise<ApiResult<HuggingFacePushResponse>> {
+  return request<HuggingFacePushResponse>(
+    "POST",
+    `/datasets/${dataset.name}/${dataset.version}/push-to-hub`,
+    options
+  );
+}
+
+export interface HuggingFacePushModelRequest {
+  hf_token: string;
+  repo_id: string;
+  private?: boolean;
+}
+
+export interface HuggingFacePushModelResponse {
+  success: boolean;
+  repo_url: string;
+  repo_id: string;
+  message?: string;
+}
+
+export async function pushModelToHub(
+  jobId: string,
+  options: HuggingFacePushModelRequest
+): Promise<ApiResult<HuggingFacePushModelResponse>> {
+  return request<HuggingFacePushModelResponse>(
+    "POST",
+    `/felix/training-jobs/${jobId}/push-to-hub`,
+    options
+  );
+}
+
+export interface HuggingFacePullRequest {
+  hf_token?: string;
+  repo_id: string;
+  dataset_name?: string;
+  revision?: string;
+}
+
+export interface HuggingFacePullResponse {
+  success: boolean;
+  dataset_id: string;
+  dataset_name: string;
+  sample_count: number;
+  message?: string;
+}
+
+export async function pullDatasetFromHub(
+  options: HuggingFacePullRequest
+): Promise<ApiResult<HuggingFacePullResponse>> {
+  return request<HuggingFacePullResponse>(
+    "POST",
+    "/datasets/pull-from-hub",
+    options
+  );
 }