@fastino-ai/pioneer-cli 0.2.2 → 0.2.3

package/src/index.tsx

@@ -5,7 +5,7 @@
  */
 
 import React, { useState, useEffect } from "react";
-import { render, Box, Text, useApp, useInput } from "ink";
+import { render, Box, Text, useApp, useInput, useStdin, Static } from "ink";
 import Spinner from "ink-spinner";
 import TextInput from "ink-text-input";
 import * as fs from "fs";
@@ -16,15 +16,16 @@ import {
   getBaseUrl,
   saveConfig,
   clearApiKey,
-  getAgentConfig,
-  getBudgetConfig,
-  getSandboxConfig,
-  getMLConfig,
-  getSystemPrompt,
+  getHfToken,
 } from "./config.js";
 import * as api from "./api.js";
 import { ChatApp } from "./chat/ChatApp.js";
-import type { AgentConfig } from "./agent/types.js";
+import {
+  isEnabled as isTelemetryEnabled,
+  hasChosenTelemetry,
+  setEnabled as setTelemetryEnabled,
+  trackCommand,
+} from "./telemetry.js";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // ASCII Banner
@@ -43,8 +44,51 @@ const BANNER = `
 // Helpers
 // ─────────────────────────────────────────────────────────────────────────────
 
+// Fields to hide from JSON output (internal paths and user IDs)
+const HIDDEN_FIELDS = new Set([
+  "user_id",
+  "root_dataset_id",
+  "dataset_path",
+  "trained_model_path",
+  "sagemaker_job_name",
+]);
+
+function filterInternalFields(data: unknown): unknown {
+  if (data === null || data === undefined) {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map(filterInternalFields);
+  }
+  if (typeof data === "object") {
+    const filtered: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(data as Record<string, unknown>)) {
+      if (!HIDDEN_FIELDS.has(key)) {
+        filtered[key] = filterInternalFields(value);
+      }
+    }
+    return filtered;
+  }
+  return data;
+}
+
 function formatJson(data: unknown): string {
-  return JSON.stringify(data, null, 2);
+  return JSON.stringify(filterInternalFields(data), null, 2);
+}
+
+/**
+ * Parse a dataset string in "name:version" format into a DatasetRef object.
+ * Returns null if the format is invalid.
+ */
+function parseDatasetRef(datasetStr: string): api.DatasetRef | null {
+  const colonIndex = datasetStr.lastIndexOf(":");
+  if (colonIndex === -1) {
+    return null;
+  }
+  return {
+    name: datasetStr.slice(0, colonIndex),
+    version: datasetStr.slice(colonIndex + 1),
+  };
 }
 
 function parseArgs(argv: string[]): { command: string[]; flags: Record<string, string> } {
@@ -111,16 +155,131 @@ const JsonOutput: React.FC<{ data: unknown }> = ({ data }) => (
   </Box>
 );
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Telemetry Consent Prompt
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface TelemetryPromptProps {
+  onComplete: () => void;
+}
+
+const TelemetryPrompt: React.FC<TelemetryPromptProps> = ({ onComplete }) => {
+  const [selected, setSelected] = useState<"yes" | "no">("yes");
+
+  useInput((input, key) => {
+    if (key.leftArrow || key.rightArrow) {
+      setSelected((s) => (s === "yes" ? "no" : "yes"));
+    }
+    if (key.return) {
+      setTelemetryEnabled(selected === "yes");
+      onComplete();
+    }
+    if (input === "y" || input === "Y") {
+      setTelemetryEnabled(true);
+      onComplete();
+    }
+    if (input === "n" || input === "N") {
+      setTelemetryEnabled(false);
+      onComplete();
+    }
+  });
+
+  return (
+    <Box flexDirection="column" paddingX={1}>
+      <Text bold color="cyan">Pioneer CLI - Usage Analytics</Text>
+      <Text> </Text>
+      <Text>Help improve Pioneer by sharing usage data?</Text>
+      <Text> </Text>
+      <Text dimColor>What we collect:</Text>
+      <Text dimColor>  - Commands and features used</Text>
+      <Text dimColor>  - Session duration, tool usage</Text>
+      <Text dimColor>  - OS and CLI version</Text>
+      <Text> </Text>
+      <Text dimColor>We never collect your prompts or file contents.</Text>
+      <Text> </Text>
+      <Text dimColor>Change anytime: pioneer telemetry [enable|disable]</Text>
+      <Text> </Text>
+      <Box>
+        <Text>Share usage data? </Text>
+        <Text color={selected === "yes" ? "green" : "gray"} bold={selected === "yes"}>
+          {selected === "yes" ? "[Yes]" : " Yes "}
+        </Text>
+        <Text> / </Text>
+        <Text color={selected === "no" ? "red" : "gray"} bold={selected === "no"}>
+          {selected === "no" ? "[No]" : " No "}
+        </Text>
+        <Text dimColor> (Y/N or arrow keys)</Text>
+      </Box>
+    </Box>
+  );
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Telemetry Status Component
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface TelemetryStatusProps {
+  action?: string;
+}
+
+const TelemetryStatus: React.FC<TelemetryStatusProps> = ({ action }) => {
+  const { exit } = useApp();
+  const [message, setMessage] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (action === "enable") {
+      setTelemetryEnabled(true);
+      setMessage("Telemetry enabled. Thank you for helping improve Pioneer!");
+    } else if (action === "disable") {
+      setTelemetryEnabled(false);
+      setMessage("Telemetry disabled. No usage data will be collected.");
+    } else {
+      const enabled = isTelemetryEnabled();
+      setMessage(`Telemetry is currently ${enabled ? "enabled" : "disabled"}.`);
+    }
+    setTimeout(() => exit(), 500);
+  }, [action, exit]);
+
+  if (!message) return null;
+
+  return (
+    <Box flexDirection="column">
+      {action === "enable" && <Success message={message} />}
+      {action === "disable" && <Text color="yellow">{message}</Text>}
+      {!action && <Text>{message}</Text>}
+      {!action && (
+        <Text dimColor>
+          Use 'pioneer telemetry enable' or 'pioneer telemetry disable' to change.
+        </Text>
+      )}
+    </Box>
+  );
+};
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Auth Login Component
 // ─────────────────────────────────────────────────────────────────────────────
 
-const AuthLogin: React.FC = () => {
+interface AuthLoginProps {
+  apiKeyFromFlag?: string;
+}
+
+const AuthLogin: React.FC<AuthLoginProps> = ({ apiKeyFromFlag }) => {
   const { exit } = useApp();
+  const { isRawModeSupported } = useStdin();
   const [apiKey, setApiKey] = useState("");
-  const [state, setState] = useState<"input" | "validating" | "done" | "error">("input");
+  const [state, setState] = useState<"input" | "validating" | "done" | "error">(
+    apiKeyFromFlag ? "validating" : "input"
+  );
   const [error, setError] = useState("");
 
+  // Handle API key from flag (non-interactive)
+  useEffect(() => {
+    if (apiKeyFromFlag) {
+      handleSubmit(apiKeyFromFlag);
+    }
+  }, [apiKeyFromFlag]);
+
   const handleSubmit = async (value: string) => {
     if (!value.trim()) {
       setError("API key cannot be empty");
@@ -158,6 +317,16 @@ const AuthLogin: React.FC = () => {
     return <ErrorMessage error={error} />;
   }
 
+  // Check if raw mode is supported for interactive input
+  if (!isRawModeSupported) {
+    return (
+      <Box flexDirection="column">
+        <ErrorMessage error="Interactive input not supported in this terminal." />
+        <Text dimColor>Use: pioneer auth login --key YOUR_API_KEY</Text>
+      </Box>
+    );
+  }
+
   return (
     <Box flexDirection="column">
       <Text>Enter your Pioneer API key:</Text>
@@ -443,13 +612,17 @@ function DatasetListCommand() {
     <Box flexDirection="column">
       <Text bold color="cyan">Remote Datasets {remoteError ? "" : `(${remoteDatasets.length})`}</Text>
       {remoteError ? (
-        <Text dimColor color="red">  Error: {remoteError.slice(0, 50)}</Text>
+        <Box flexDirection="column">
+          {remoteError.split("\n").map((line, idx) => (
+            <Text key={idx} color="red">  {line}</Text>
+          ))}
+        </Box>
       ) : remoteDatasets.length === 0 ? (
         <Text dimColor>  No remote datasets</Text>
       ) : (
         remoteDatasets.map((ds) => (
           <Text key={ds.id}>
-            {"  "}<Text color="yellow">{ds.id.slice(0, 8)}</Text> {ds.dataset_name} <Text dimColor>({ds.dataset_type}, {ds.sample_size} examples)</Text>
+            {"  "}<Text color="yellow">{ds.dataset_name}:{ds.version_number || "v1"}</Text> <Text dimColor>({ds.dataset_type}, {ds.sample_size} examples)</Text>
           </Text>
         ))
       )}
@@ -540,7 +713,7 @@ function ModelListCommand({ filter }: ModelListCommandProps) {
 // Help Components
 // ─────────────────────────────────────────────────────────────────────────────
 
-type HelpContext = "root" | "auth" | "dataset" | "job" | "model" | "chat";
+type HelpContext = "root" | "auth" | "dataset" | "dataset-analyze" | "dataset-edit" | "job" | "model" | "chat" | "eval" | "benchmark";
 
 interface HelpProps {
   context?: HelpContext;
@@ -550,7 +723,7 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
   const { exit } = useApp();
 
   useEffect(() => {
-    setTimeout(() => exit(), 100);
+    setTimeout(() => exit(), 500);
   }, [exit]);
 
   // Auth help
@@ -558,9 +731,10 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
     return (
       <Box flexDirection="column">
         <Text bold>Auth Commands:</Text>
-        <Text>  auth login     Login with API key</Text>
-        <Text>  auth logout    Clear stored API key</Text>
-        <Text>  auth status    Show auth status</Text>
+        <Text>  auth login              Login with API key (interactive)</Text>
+        <Text>  auth login --key {"<key>"}  Login with API key (non-interactive)</Text>
+        <Text>  auth logout             Clear stored API key</Text>
+        <Text>  auth status             Show auth status</Text>
       </Box>
     );
   }
@@ -570,10 +744,11 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
     return (
       <Box flexDirection="column">
         <Text bold>Dataset Commands:</Text>
+        <Text dimColor>  {"<id>"} format: name:version (e.g., my-dataset:v1)</Text>
+        <Text> </Text>
         <Text>  dataset list              List all datasets</Text>
         <Text>  dataset get {"<id>"}          Get dataset details</Text>
         <Text>  dataset delete {"<id>"}       Delete a dataset</Text>
-        <Text>  dataset download {"<id>"}     Get download URL</Text>
         <Text>  dataset analyze {"<id>"}      Analyze a dataset</Text>
         <Text> </Text>
         <Text bold>  Generate:</Text>
@@ -604,6 +779,75 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <Text>  dataset infer classification   Infer classification labels</Text>
         <Text>  dataset infer fields           Infer input/output fields</Text>
         <Text>    --domain {"<desc>"}           Domain description (required)</Text>
+        <Text> </Text>
+        <Text bold>  Upload/Download:</Text>
+        <Text>  dataset upload {"<file>"}          Upload local file to Pioneer</Text>
+        <Text>    --name {"<name>"}               Dataset name (required)</Text>
+        <Text>    --type {"<type>"}               Type: ner, classification, custom</Text>
+        <Text>  dataset upload {"<id>"} --to hf    Upload Pioneer dataset to Hugging Face</Text>
+        <Text>    --repo {"<repo>"}               HF repo (required, e.g., username/dataset)</Text>
+        <Text>    --hf-token {"<token>"}          HF token (or use HF_TOKEN env var)</Text>
+        <Text>    --private                   Make repo private</Text>
+        <Text>  dataset download {"<id>"}          Download from Pioneer to local file</Text>
+        <Text>    --format {"<type>"}             Format: jsonl, csv, parquet (default: jsonl)</Text>
+        <Text>    --output {"<path>"}             Output file path</Text>
+        <Text>  dataset download --from hf     Download from Hugging Face to Pioneer</Text>
+        <Text>    --repo {"<repo>"}               HF repo (required, e.g., username/dataset)</Text>
+        <Text>    --hf-token {"<token>"}          HF token (optional, for private repos)</Text>
+        <Text>    --name {"<name>"}               Local dataset name (optional)</Text>
+        <Text>    --revision {"<rev>"}            Git revision/branch (optional)</Text>
+        <Text> </Text>
+        <Text bold>  Data Editing:</Text>
+        <Text>  dataset edit --help               Show data editing commands</Text>
+        <Text>  dataset edit scan-pii {"<id>"}        Scan for PII</Text>
+        <Text>  dataset edit subsample {"<id>"}       Create a subsample</Text>
+      </Box>
+    );
+  }
+
+  // Dataset edit help
+  if (context === "dataset-edit") {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Dataset Edit Commands:</Text>
+        <Text dimColor>  {"<dataset-id>"} format: name:version (e.g., my-dataset:v1)</Text>
+        <Text> </Text>
+        <Text>  dataset edit scan-pii {"<dataset-id>"}  Scan for PII</Text>
+        <Text>    --columns {"<col1,col2>"}            Columns to scan (optional, scans all if omitted)</Text>
+        <Text>    --threshold {"<n>"}                  Detection threshold (default: 0.5)</Text>
+        <Text>  dataset edit scan-phd {"<dataset-id>"}  Scan for prompt injection</Text>
+        <Text>    --columns {"<col1,col2>"}            Columns to scan (optional, scans all if omitted)</Text>
+        <Text>    --threshold {"<n>"}                  Detection threshold (default: 0.5)</Text>
+        <Text>  dataset edit subsample {"<dataset-id>"} Create a subsample</Text>
+        <Text>    --n {"<count>"}                      Target sample count (required)</Text>
+        <Text>    --method {"<type>"}                  Method: random, balanced, stratified</Text>
+        <Text>    --label-column {"<col>"}             Column for balanced sampling</Text>
+        <Text>    --seed {"<n>"}                       Random seed</Text>
+        <Text>  dataset edit check-labels {"<dataset-id>"} Check label quality with AI</Text>
+        <Text>    --text-column {"<col>"}              Text column (required)</Text>
+        <Text>    --label-column {"<col>"}             Label column (required)</Text>
+        <Text>    --sample-size {"<n>"}                Samples to check (default: 10)</Text>
+      </Box>
+    );
+  }
+
+  // Dataset analyze help
+  if (context === "dataset-analyze") {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Dataset Analyze Command:</Text>
+        <Text dimColor>  {"<id>"} format: name:version (e.g., my-dataset:v1)</Text>
+        <Text> </Text>
+        <Text>  dataset analyze {"<id>"}        Analyze a dataset</Text>
+        <Text> </Text>
+        <Text bold>  Required Options:</Text>
+        <Text>    --task-type {"<type>"}        Task type (required)</Text>
+        <Text>                              Options: ner, classification, generative</Text>
+        <Text>    --analyses {"<a1,a2,...>"}    Analyses to run (required, comma-separated)</Text>
+        <Text>                              Options: distribution, duplicates, outliers, splits, diversity</Text>
+        <Text> </Text>
+        <Text bold>  Example:</Text>
+        <Text>    dataset analyze abc123 --task-type ner --analyses distribution,duplicates</Text>
       </Box>
     );
   }
@@ -619,7 +863,7 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <Text>  job delete {"<id>"}    Delete a training job</Text>
         <Text>  job create         Create training job</Text>
         <Text>    --model-name {"<name>"}   Model name (required)</Text>
-        <Text>    --dataset-ids {"<ids>"}   Comma-separated dataset IDs (required)</Text>
+        <Text>    --datasets {"<ids>"}      Comma-separated dataset IDs (required)</Text>
         <Text>    --base-model {"<model>"}  Base model (default: fastino/gliner2-base-v1)</Text>
         <Text>    --epochs {"<n>"}          Number of epochs (default: 5)</Text>
       </Box>
@@ -636,6 +880,12 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
         <Text>  model list deployed    List deployed models only</Text>
         <Text>  model delete {"<id>"}      Undeploy a model</Text>
         <Text>  model download {"<id>"}    Get model download URL</Text>
+        <Text> </Text>
+        <Text bold>  Upload:</Text>
+        <Text>  model upload {"<job-id>"} --to hf   Upload trained model to Hugging Face</Text>
+        <Text>    --repo {"<repo>"}              HF repo (required, e.g., username/model)</Text>
+        <Text>    --hf-token {"<token>"}         HF token (or use HF_TOKEN env var)</Text>
+        <Text>    --private                  Make repo private</Text>
       </Box>
     );
   }
@@ -646,14 +896,46 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
       <Box flexDirection="column">
         <Text bold>Chat Commands:</Text>
         <Text>  chat                   Start interactive chat agent</Text>
-        <Text>    --provider {"<name>"}    LLM provider (anthropic, openai)</Text>
-        <Text>    --model {"<model>"}      Model to use</Text>
         <Text>    --message {"<msg>"}      Initial message to process</Text>
-        <Text>    --max-tokens {"<n>"}     Max tokens (default: 500000, 0=unlimited)</Text>
-        <Text>    --max-cost {"<n>"}       Max cost in USD (default: 5.0, 0=unlimited)</Text>
-        <Text>    --max-time {"<n>"}       Max time in seconds (default: 7200, 0=unlimited)</Text>
-        <Text>    --max-tools {"<n>"}      Max tool calls per turn (default: 50, 0=unlimited)</Text>
-        <Text>    --no-limit           Remove all limits</Text>
+        <Text> </Text>
+        <Text dimColor>  Note: Model selection available in chat via /model command</Text>
+      </Box>
+    );
+  }
+
+  // Eval help
+  if (context === "eval") {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Evaluation Commands:</Text>
+        <Text dimColor>  {"<dataset-id>"} format: name:version (e.g., my-dataset:v1)</Text>
+        <Text> </Text>
+        <Text>  eval list {"<dataset-id>"}         List evaluations for a dataset</Text>
+        <Text>  eval get {"<id>"}                 Get evaluation details</Text>
+        <Text>  eval create                   Create a new evaluation</Text>
+        <Text>    --model-id {"<id>"}            Model to evaluate (required)</Text>
+        <Text>    --dataset {"<id>"}             Dataset to evaluate on (required, name:version)</Text>
+        <Text>    --task-type {"<type>"}         Task type: ner, classification</Text>
+        <Text>    --text-column {"<col>"}        Text column name</Text>
+        <Text>    --label-column {"<col>"}       Label column name</Text>
+      </Box>
+    );
+  }
+
+  // Benchmark help
+  if (context === "benchmark") {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Benchmark Commands:</Text>
+        <Text>  benchmark list                List available benchmarks</Text>
+        <Text>  benchmark run                 Start a benchmark evaluation</Text>
+        <Text>    --model-id {"<id>"}            Model to evaluate (required)</Text>
+        <Text>    --task {"<type>"}              Task: ner, text_classification (required)</Text>
+        <Text>    --benchmark {"<name>"}         Benchmark name (required)</Text>
+        <Text>    --max-samples {"<n>"}          Max samples (default: 100)</Text>
+        <Text>    --split {"<name>"}             Dataset split (default: test)</Text>
+        <Text>  benchmark get {"<id>"}             Get evaluation status/results</Text>
+        <Text>  benchmark cancel {"<id>"}          Cancel running evaluation</Text>
       </Box>
     );
   }
@@ -669,17 +951,19 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
       <Text bold>Commands:</Text>
       <Text>  chat       Start interactive chat agent</Text>
       <Text>  auth       Authentication (login, logout, status)</Text>
-      <Text>  dataset    Manage datasets (list, generate, infer)</Text>
+      <Text>  dataset    Manage datasets (list, generate, edit, analyze)</Text>
       <Text>  job        Manage training jobs</Text>
       <Text>  model      Manage models</Text>
+      <Text>  eval       Model evaluations on datasets</Text>
+      <Text>  benchmark  Run benchmark evaluations</Text>
+      <Text>  telemetry  Manage anonymous usage analytics</Text>
       <Text> </Text>
       <Text dimColor>Run 'pioneer {"<command>"} --help' for details on a specific command.</Text>
       <Text> </Text>
       <Text dimColor>Environment:</Text>
-      <Text dimColor>  PIONEER_API_URL       API base URL (default: http://localhost:5001)</Text>
+      <Text dimColor>  PIONEER_API_URL       API base URL (default: https://api.fastino.ai)</Text>
       <Text dimColor>  PIONEER_API_KEY       API key (overrides saved key)</Text>
-      <Text dimColor>  ANTHROPIC_API_KEY     Anthropic API key for chat agent</Text>
-      <Text dimColor>  OPENAI_API_KEY        OpenAI API key for chat agent</Text>
+      <Text dimColor>  HF_TOKEN              Hugging Face token for push/pull operations</Text>
     </Box>
   );
 };
@@ -693,69 +977,8 @@ interface ChatWrapperProps {
 }
 
 const ChatWrapper: React.FC<ChatWrapperProps> = ({ flags }) => {
-  const { exit } = useApp();
-
-  // Build agent config from flags and stored config
-  const storedConfig = getAgentConfig();
-  const budgetConfig = getBudgetConfig();
-  const systemPrompt = getSystemPrompt();
-
-  // Apply budget overrides from flags
-  const budget = { ...budgetConfig };
-  let maxToolCalls = 50; // Default
-
-  if (flags["no-limit"] === "true") {
-    // Remove all limits
-    budget.maxTokens = undefined;
-    budget.maxCost = undefined;
-    budget.maxTime = undefined;
-    budget.maxIterations = undefined;
-    maxToolCalls = 1000; // Effectively unlimited
-  } else {
-    // Apply individual overrides (0 = unlimited)
-    if (flags["max-tokens"]) {
-      const val = parseInt(flags["max-tokens"], 10);
-      budget.maxTokens = val === 0 ? undefined : val;
-    }
-    if (flags["max-cost"]) {
-      const val = parseFloat(flags["max-cost"]);
-      budget.maxCost = val === 0 ? undefined : val;
-    }
-    if (flags["max-time"]) {
-      const val = parseInt(flags["max-time"], 10);
-      budget.maxTime = val === 0 ? undefined : val;
-    }
-    if (flags["max-tools"]) {
-      const val = parseInt(flags["max-tools"], 10);
-      maxToolCalls = val === 0 ? 1000 : val;
-    }
-  }
-
-  const agentConfig: AgentConfig = {
-    provider: (flags.provider as "anthropic" | "openai") || storedConfig.provider,
-    model: flags.model || storedConfig.model,
-    apiKey: storedConfig.apiKey,
-    baseUrl: storedConfig.baseUrl,
-    budget,
-    systemPrompt,
-    maxToolCalls,
-  };
-
-  // Validate we have an API key
-  if (!agentConfig.apiKey) {
-    return (
-      <Box flexDirection="column">
-        <ErrorMessage error="No API key configured. Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable." />
-        <Text dimColor>
-          Or run: export ANTHROPIC_API_KEY="your-key"
-        </Text>
-      </Box>
-    );
-  }
-
   const initialMessage = flags.message;
-
-  return <ChatApp config={agentConfig} initialMessage={initialMessage} />;
+  return <ChatApp initialMessage={initialMessage} />;
 };
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -768,8 +991,31 @@ interface AppProps {
 }
 
 const App: React.FC<AppProps> = ({ command, flags }) => {
+  // Check if raw mode is supported for interactive prompts
+  const { isRawModeSupported } = useStdin();
+  const [showTelemetryPrompt, setShowTelemetryPrompt] = useState(!hasChosenTelemetry());
   const [group, action, ...rest] = command;
 
+  // In non-interactive mode, skip telemetry prompt and default to disabled
+  useEffect(() => {
+    if (!isRawModeSupported && !hasChosenTelemetry()) {
+      setTelemetryEnabled(false);
+      setShowTelemetryPrompt(false);
+    }
+  }, [isRawModeSupported]);
+
+  // Track command usage (must be before any conditional returns)
+  useEffect(() => {
+    if (group && !showTelemetryPrompt) {
+      trackCommand(group, action);
+    }
+  }, [group, action, showTelemetryPrompt]);
+
+  // Show telemetry consent prompt on first run (but not for --help or --version, and only if interactive)
+  if (showTelemetryPrompt && isRawModeSupported && !flags.help && flags.version !== "true" && flags.v !== "true") {
+    return <TelemetryPrompt onComplete={() => setShowTelemetryPrompt(false)} />;
+  }
+
   // Root help (no command)
   if (!group) {
     return <Help />;
@@ -788,36 +1034,314 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
     if (flags.help === "true" || !action || action === "help") {
       return <Help context="auth" />;
     }
-    if (action === "login") return <AuthLogin />;
+    if (action === "login") return <AuthLogin apiKeyFromFlag={flags.key} />;
     if (action === "logout") return <AuthLogout />;
     if (action === "status") return <AuthStatus />;
     return <Help context="auth" />;
   }
 
+  // Telemetry commands
+  if (group === "telemetry") {
+    return <TelemetryStatus action={action} />;
+  }
+
   // Dataset commands
   if (group === "dataset") {
+    // Handle edit subcommand first (before general help check)
+    if (action === "edit") {
+      const subAction = rest[0];
+
+      if (flags.help === "true" || !subAction || subAction === "help") {
+        return <Help context="dataset-edit" />;
+      }
+
+      if (subAction === "scan-pii" && rest[1]) {
+        const dataset = parseDatasetRef(rest[1]);
+        if (!dataset) {
+          return <ErrorMessage error={`Invalid dataset format: ${rest[1]}. Use name:version format.`} />;
+        }
+        const columns = flags["columns"]?.split(",").filter(Boolean);
+        const threshold = flags["threshold"] ? parseFloat(flags["threshold"]) : undefined;
+
+        return (
+          <ApiCommand
+            action={() =>
+              api.scanForPII({
+                dataset,
+                columns: columns?.length ? columns : undefined,
+                threshold,
+              })
+            }
+          />
+        );
+      }
+
+      if (subAction === "scan-phd" && rest[1]) {
+        const dataset = parseDatasetRef(rest[1]);
+        if (!dataset) {
+          return <ErrorMessage error={`Invalid dataset format: ${rest[1]}. Use name:version format.`} />;
+        }
+        const columns = flags["columns"]?.split(",").filter(Boolean);
+        const threshold = flags["threshold"] ? parseFloat(flags["threshold"]) : undefined;
+
+        return (
+          <ApiCommand
+            action={() =>
+              api.scanForPHD({
+                dataset,
+                columns: columns?.length ? columns : undefined,
+                threshold,
+              })
+            }
+          />
+        );
+      }
+
+      if (subAction === "subsample" && rest[1]) {
+        const dataset = parseDatasetRef(rest[1]);
+        if (!dataset) {
+          return <ErrorMessage error={`Invalid dataset format: ${rest[1]}. Use name:version format.`} />;
+        }
+        const n = flags["n"] ? parseInt(flags["n"], 10) : undefined;
+        const method = flags["method"] as "random" | "balanced" | "stratified" | undefined;
+        const labelColumn = flags["label-column"];
+        const seed = flags["seed"] ? parseInt(flags["seed"], 10) : undefined;
+
+        if (!n) {
+          return <ErrorMessage error="--n is required (target sample count)" />;
+        }
+
+        return (
+          <ApiCommand
+            action={() =>
+              api.subsampleDataset({
+                dataset,
+                n,
+                method,
+                label_column: labelColumn,
+                seed,
+              })
+            }
+            successMessage="Subsample created"
+          />
+        );
+      }
+
+      if (subAction === "check-labels" && rest[1]) {
+        const dataset = parseDatasetRef(rest[1]);
+        if (!dataset) {
+          return <ErrorMessage error={`Invalid dataset format: ${rest[1]}. Use name:version format.`} />;
+        }
+        const textColumn = flags["text-column"];
+        const labelColumn = flags["label-column"];
+        const sampleSize = flags["sample-size"] ? parseInt(flags["sample-size"], 10) : undefined;
+
+        if (!textColumn || !labelColumn) {
+          return <ErrorMessage error="--text-column and --label-column are required" />;
+        }
+
+        return (
+          <ApiCommand
+            action={() =>
+              api.checkLabels({
+                dataset,
+                text_column: textColumn,
+                label_column: labelColumn,
+                sample_size: sampleSize,
+              })
+            }
+          />
+        );
+      }
+
+      return <Help context="dataset-edit" />;
+    }
+
     if (flags.help === "true" || !action || action === "help") {
       return <Help context="dataset" />;
     }
+
+    // Dataset upload command
+    if (action === "upload") {
+      const destination = flags["to"];
+
+      // Show help if no arguments provided
+      if (!rest[0] && !destination) {
+        return (
+          <Box flexDirection="column">
+            <Text bold>Dataset Upload:</Text>
+            <Text> </Text>
+            <Text>  Upload to Pioneer:</Text>
+            <Text>    dataset upload {"<file>"} --name {"<name>"} [--type {"<type>"}]</Text>
+            <Text> </Text>
+            <Text>  Upload to Hugging Face:</Text>
+            <Text>    dataset upload {"<id>"} --to hf --repo {"<repo>"} [--hf-token {"<token>"}] [--private]</Text>
+            <Text> </Text>
+            <Text dimColor>  {"<id>"} format: name:version (e.g., my-dataset:v1)</Text>
+          </Box>
+        );
+      }
+
+      // Upload to Hugging Face
+      if (destination === "hf") {
+        const datasetStr = rest[0];
+        if (!datasetStr) {
+          return <ErrorMessage error="Dataset ID required: dataset upload <name:version> --to hf --repo <repo>" />;
+        }
+        const dataset = parseDatasetRef(datasetStr);
+        if (!dataset) {
+          return <ErrorMessage error={`Invalid dataset format: ${datasetStr}. Use name:version format.`} />;
+        }
+
+        const repo = flags["repo"];
+        const hfTokenFlag = flags["hf-token"];
+        const isPrivate = flags["private"] === "true";
+
+        if (!repo) {
+          return <ErrorMessage error="--repo is required (e.g., username/dataset-name)" />;
+        }
+
+        const hfToken = getHfToken(hfTokenFlag);
+        if (!hfToken) {
+          return <ErrorMessage error="Hugging Face token required. Use --hf-token, HF_TOKEN env var, or set via config." />;
+        }
+
+        return (
+          <ApiCommand
+            action={() =>
+              api.pushDatasetToHub(dataset, {
+                hf_token: hfToken,
+                repo_id: repo,
+                private: isPrivate,
+              })
+            }
+            successMessage={`Dataset uploaded to Hugging Face: ${repo}`}
+          />
+        );
+      }
+
+      // Default: Upload file to Pioneer
+      const name = flags["name"];
+      const datasetType = flags["type"] as "ner" | "classification" | "custom" | undefined;
+
+      if (!name) {
+        return <ErrorMessage error="--name is required for dataset upload" />;
+      }
+
+      return (
+        <ApiCommand
+          action={() =>
+            api.uploadDataset(rest[0], {
+              dataset_name: name,
+              dataset_type: datasetType,
+            })
+          }
+          successMessage="Dataset uploaded"
+        />
+      );
+    }
+
+    // Dataset download command
+    if (action === "download") {
+      const source = flags["from"];
+
+      // Show help if no arguments provided
+      if (!rest[0] && !source) {
+        return (
+          <Box flexDirection="column">
+            <Text bold>Dataset Download:</Text>
+            <Text> </Text>
+            <Text>  Download from Pioneer:</Text>
+            <Text>    dataset download {"<id>"} [--format jsonl|csv|parquet] [--output {"<path>"}]</Text>
+            <Text> </Text>
+            <Text>  Download from Hugging Face:</Text>
+            <Text>    dataset download --from hf --repo {"<repo>"} [--hf-token {"<token>"}] [--name {"<name>"}]</Text>
+            <Text> </Text>
+            <Text dimColor>  {"<id>"} format: name:version (e.g., my-dataset:v1)</Text>
+          </Box>
+        );
+      }
+
+      // Download from Hugging Face
+      if (source === "hf") {
+        const repo = flags["repo"];
+        const hfTokenFlag = flags["hf-token"];
+        const datasetName = flags["name"];
+        const revision = flags["revision"];
+
+        if (!repo) {
+          return <ErrorMessage error="--repo is required (e.g., username/dataset-name)" />;
+        }
+
+        const hfToken = getHfToken(hfTokenFlag);
+
+        return (
+          <ApiCommand
+            action={() =>
+              api.pullDatasetFromHub({
+                repo_id: repo,
+                hf_token: hfToken,
+                dataset_name: datasetName,
+                revision,
+              })
+            }
+            successMessage={`Dataset downloaded from Hugging Face: ${repo}`}
+          />
+        );
+      }
+
+      // Default: Download from Pioneer
+      const dataset = parseDatasetRef(rest[0]);
+      if (!dataset) {
+        return <ErrorMessage error={`Invalid dataset format: ${rest[0]}. Use name:version format.`} />;
+      }
+      const format = (flags["format"] || "jsonl") as "csv" | "jsonl" | "parquet";
+      const output = flags["output"] || flags["o"];
+      return <ApiCommand action={() => api.downloadDataset(dataset, format, output)} />;
+    }
+
     if (action === "list") {
       return <DatasetListCommand />;
     }
     if (action === "get" && rest[0]) {
-      return <ApiCommand action={() => api.getDataset(rest[0])} />;
+      const dataset = parseDatasetRef(rest[0]);
+      if (!dataset) {
+        return <ErrorMessage error={`Invalid dataset format: ${rest[0]}. Use name:version format.`} />;
+      }
+      return <ApiCommand action={() => api.getDataset(dataset)} />;
     }
     if (action === "delete" && rest[0]) {
+      const dataset = parseDatasetRef(rest[0]);
+      if (!dataset) {
+        return <ErrorMessage error={`Invalid dataset format: ${rest[0]}. Use name:version format.`} />;
+      }
       return (
         <ApiCommand
-          action={() => api.deleteDataset(rest[0])}
+          action={() => api.deleteDataset(dataset)}
           successMessage={`Dataset ${rest[0]} deleted`}
         />
       );
     }
-    if (action === "download" && rest[0]) {
-      return <ApiCommand action={() => api.downloadDataset(rest[0])} />;
-    }
-    if (action === "analyze" && rest[0]) {
-      return <ApiCommand action={() => api.analyzeDataset(rest[0])} />;
+    if (action === "analyze") {
+      const datasetStr = rest[0];
+      const taskType = flags["task-type"];
+      const analyses = flags["analyses"]?.split(",");
+
+      // Show help if missing required params
+      if (!datasetStr || !taskType || !analyses || analyses.length === 0) {
+        return <Help context="dataset-analyze" />;
+      }
+
+      const dataset = parseDatasetRef(datasetStr);
+      if (!dataset) {
+        return <ErrorMessage error={`Invalid dataset format: ${datasetStr}. Use name:version format.`} />;
+      }
+
+      return (
+        <ApiCommand
+          action={() => api.analyzeDataset(dataset, taskType, analyses)}
+        />
+      );
     }
 
     // Generate commands
@@ -972,12 +1496,25 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
     }
     if (action === "create") {
       const modelName = flags["model-name"];
-      const datasetIds = flags["dataset-ids"]?.split(",") ?? [];
+      const datasetStrings = flags["datasets"]?.split(",").filter(Boolean) ?? [];
       const baseModel = flags["base-model"];
       const epochs = flags["epochs"] ? parseInt(flags["epochs"], 10) : undefined;
 
-      if (!modelName || datasetIds.length === 0) {
-        return <ErrorMessage error="--model-name and --dataset-ids are required" />;
+      if (!modelName || datasetStrings.length === 0) {
+        return <ErrorMessage error="--model-name and --datasets are required" />;
+      }
+
+      // Parse dataset strings in name:version format
+      const datasets: api.DatasetRef[] = [];
+      for (const ds of datasetStrings) {
+        const colonIndex = ds.lastIndexOf(":");
+        if (colonIndex === -1) {
+          return <ErrorMessage error={`Invalid dataset format: ${ds}. Use name:version format.`} />;
+        }
+        datasets.push({
+          name: ds.slice(0, colonIndex),
+          version: ds.slice(colonIndex + 1),
+        });
       }
 
       return (
@@ -985,7 +1522,7 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
           action={() =>
             api.createJob({
               model_name: modelName,
-              dataset_ids: datasetIds,
+              datasets,
               base_model: baseModel,
               nr_epochs: epochs,
             })
@@ -1027,9 +1564,162 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
     if (action === "download" && rest[0]) {
       return <ApiCommand action={() => api.downloadModel(rest[0])} />;
     }
+    // Model upload command
+    if (action === "upload") {
+      const destination = flags["to"];
+
+      // Show help if no arguments provided
+      if (!rest[0] && !destination) {
+        return (
+          <Box flexDirection="column">
+            <Text bold>Model Upload:</Text>
+            <Text> </Text>
+            <Text>  Upload to Hugging Face:</Text>
+            <Text>    model upload {"<job-id>"} --to hf --repo {"<repo>"} [--hf-token {"<token>"}] [--private]</Text>
+            <Text> </Text>
+            <Text dimColor>  Supported destinations: hf (more coming soon)</Text>
+          </Box>
+        );
+      }
+
+      // Upload to Hugging Face
+      if (destination === "hf") {
+        if (!rest[0]) {
+          return <ErrorMessage error="Job ID required: model upload <job-id> --to hf --repo <repo>" />;
+        }
+        const jobId = rest[0];
+        const repo = flags["repo"];
+        const hfTokenFlag = flags["hf-token"];
+        const isPrivate = flags["private"] === "true";
+
+        if (!repo) {
+          return <ErrorMessage error="--repo is required (e.g., username/model-name)" />;
+        }
+
+        const hfToken = getHfToken(hfTokenFlag);
+        if (!hfToken) {
+          return <ErrorMessage error="Hugging Face token required. Use --hf-token, HF_TOKEN env var, or set via config." />;
+        }
+
+        return (
+          <ApiCommand
+            action={() =>
+              api.pushModelToHub(jobId, {
+                hf_token: hfToken,
+                repo_id: repo,
+                private: isPrivate,
+              })
+            }
+            successMessage={`Model uploaded to Hugging Face: ${repo}`}
+          />
+        );
+      }
+
+      return <ErrorMessage error="--to is required. Supported destinations: hf" />;
+    }
     return <Help context="model" />;
   }
 
+  // Eval commands
+  if (group === "eval") {
+    if (flags.help === "true" || !action || action === "help") {
+      return <Help context="eval" />;
+    }
+    if (action === "list" && rest[0]) {
+      const dataset = parseDatasetRef(rest[0]);
+      if (!dataset) {
+        return <ErrorMessage error={`Invalid dataset format: ${rest[0]}. Use name:version format.`} />;
+      }
+      return <ApiCommand action={() => api.getDatasetEvaluations(dataset)} />;
+    }
+    if (action === "list" && !rest[0]) {
+      return <ErrorMessage error="Dataset ID is required: eval list <dataset-id>" />;
+    }
+    if (action === "get" && rest[0]) {
+      return <ApiCommand action={() => api.getEvaluation(rest[0])} />;
+    }
+    if (action === "create") {
+      const modelId = flags["model-id"];
+      const datasetStr = flags["dataset"];
+      const taskType = flags["task-type"];
+      const textColumn = flags["text-column"];
+      const labelColumn = flags["label-column"];
+
+      if (!modelId || !datasetStr) {
+        return <ErrorMessage error="--model-id and --dataset are required" />;
+      }
+
+      const dataset = parseDatasetRef(datasetStr);
+      if (!dataset) {
+        return <ErrorMessage error={`Invalid dataset format: ${datasetStr}. Use name:version format.`} />;
+      }
+
+      return (
+        <ApiCommand
+          action={() =>
+            api.createEvaluation({
+              model_id: modelId,
+              dataset,
+              task_type: taskType,
+              text_column: textColumn,
+              label_column: labelColumn,
+            })
+          }
+          successMessage="Evaluation created"
+        />
+      );
+    }
+    return <Help context="eval" />;
+  }
+
+  // Benchmark commands
+  if (group === "benchmark") {
+    if (flags.help === "true" || !action || action === "help") {
+      return <Help context="benchmark" />;
+    }
+    if (action === "list") {
+      return <ApiCommand action={api.listBenchmarks} />;
+    }
+    if (action === "run") {
+      const modelId = flags["model-id"];
+      const task = flags["task"] as "ner" | "text_classification";
+      const benchmark = flags["benchmark"];
+      const maxSamples = flags["max-samples"] ? parseInt(flags["max-samples"], 10) : undefined;
+      const split = flags["split"];
+
+      if (!modelId || !task || !benchmark) {
+        return <ErrorMessage error="--model-id, --task, and --benchmark are required" />;
+      }
+
+      return (
+        <ApiCommand
+          action={() =>
+            api.startBenchmarkEvaluation({
+              model_id: modelId,
+              task,
+              benchmark,
+              max_samples: maxSamples,
+              split,
+            })
+          }
+          successMessage="Benchmark evaluation started"
+        />
+      );
+    }
+    if (action === "get" && rest[0]) {
+      return <ApiCommand action={() => api.getBenchmarkEvaluation(rest[0])} />;
+    }
+    if (action === "cancel" && rest[0]) {
+      return (
+        <ApiCommand
+          action={() => api.cancelBenchmarkEvaluation(rest[0])}
+          successMessage="Benchmark evaluation cancelled"
+        />
+      );
+    }
+    return <Help context="benchmark" />;
+  }
+
   return <Help />;
 };
 
@@ -1039,7 +1729,7 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
 
 import packageJson from "../package.json";
 
-function main() {
+async function main() {
   const argv = process.argv.slice(2);
   const { command, flags } = parseArgs(argv);
 
@@ -1049,7 +1739,7 @@ function main() {
     process.exit(0);
   }
 
-  render(<App command={command} flags={flags} />);
+  await render(<App command={command} flags={flags} />).waitUntilExit();
 }
 
 main();