@fastino-ai/pioneer-cli 0.2.4 → 0.2.6

package/src/index.tsx

@@ -52,7 +52,7 @@ const HIDDEN_FIELDS = new Set([
   "root_dataset_id",
   "dataset_path",
   "trained_model_path",
-  "sagemaker_job_name",
+  "job_reference",
 ]);
 
 function filterInternalFields(data: unknown): unknown {
@@ -531,6 +531,58 @@ function ApiCommand<T>({ action, successMessage }: ApiCommandProps<T>) {
   );
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Job Logs Command (prettified output)
+// ─────────────────────────────────────────────────────────────────────────────
+
+function JobLogsCommand({ jobId }: { jobId: string }) {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [logs, setLogs] = useState<api.TrainingLog[]>([]);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    (async () => {
+      const result = await api.getJobLogs(jobId);
+      if (result.ok && result.data) {
+        setLogs(result.data.logs || []);
+        setState("done");
+      } else {
+        setError(result.error ?? "Unknown error");
+        setState("error");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+  }, [jobId, exit]);
+
+  if (state === "loading") {
+    return <Loading />;
+  }
+
+  if (state === "error") {
+    return <ErrorMessage error={error} />;
+  }
+
+  const formatLogEntry = (log: api.TrainingLog): string => {
+    const ts = new Date(log.timestamp).toLocaleTimeString();
+    return `[${ts}] [${log.level}] ${log.message}`;
+  };
+
+  return (
+    <Box flexDirection="column">
+      {logs.length === 0 ? (
+        <Text dimColor>No logs available</Text>
+      ) : (
+        logs.map((log) => (
+          <Text key={log.id} color={log.level === "ERROR" ? "red" : log.level === "WARNING" ? "yellow" : undefined}>
+            {formatLogEntry(log)}
+          </Text>
+        ))
+      )}
+    </Box>
+  );
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Local Dataset Helpers
 // ─────────────────────────────────────────────────────────────────────────────
@@ -747,9 +799,12 @@ function DatasetListCommand() {
         <Text dimColor>  No remote datasets</Text>
       ) : (
         remoteDatasets.map((ds) => (
-          <Text key={ds.id}>
-            {"  "}<Text color="yellow">{ds.dataset_name}:{ds.version_number || "v1"}</Text> <Text dimColor>({ds.dataset_type}, {ds.sample_size} examples)</Text>
-          </Text>
+          <Box key={ds.id} flexDirection="column">
+            <Text>
+              {"  "}<Text color="yellow">{ds.dataset_name}:{ds.version_number || "v1"}</Text> <Text dimColor>({ds.dataset_type}, {ds.sample_size} examples)</Text>
+            </Text>
+            <Text dimColor>    {ds.id}</Text>
+          </Box>
         ))
       )}
       <Text> </Text>
@@ -767,6 +822,530 @@ function DatasetListCommand() {
   );
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Competition List Command
+// ─────────────────────────────────────────────────────────────────────────────
+
+function CompetitionListCommand() {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [competitions, setCompetitions] = useState<api.CompetitionInfo[]>([]);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    (async () => {
+      const result = await api.listCompetitions();
+      if (result.ok && result.data) {
+        setCompetitions(result.data.competitions || []);
+        setState("done");
+      } else {
+        setError(result.error ?? "Unknown error");
+        setState("error");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+  }, [exit]);
+
+  if (state === "loading") {
+    return <Loading message="Loading competitions..." />;
+  }
+
+  if (state === "error") {
+    return <ErrorMessage error={error} />;
+  }
+
+  if (competitions.length === 0) {
+    return <Text dimColor>No active competitions found.</Text>;
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Text bold color="cyan">Active Competitions ({competitions.length})</Text>
+      <Text> </Text>
+      {competitions.map((comp, idx) => (
+        <Box key={comp.dataset_id} flexDirection="column" marginBottom={1}>
+          <Text bold color="yellow">
+            {idx + 1}. {comp.dataset_name}
+          </Text>
+          <Text>
+            {"  "}Type: <Text color="magenta">{comp.dataset_type}</Text>
+            {"  "}Samples: <Text color="blue">{comp.sample_count ?? "N/A"}</Text>
+            {"  "}Entries: <Text color="green">{comp.total_entries}</Text>
+          </Text>
+          {comp.description && (
+            <Text dimColor>{"  "}{comp.description}</Text>
+          )}
+          {comp.labels && comp.labels.length > 0 && (
+            <Text>{"  "}Labels: <Text color="cyan">{comp.labels.join(", ")}</Text></Text>
+          )}
+          {comp.winner && (
+            <Text>
+              {"  "}Winner: <Text color="green" bold>{comp.winner.display_name}</Text>
+              {" "}(F1: <Text color="yellow">{comp.winner.f1_score.toFixed(4)}</Text>)
+            </Text>
+          )}
+          <Text dimColor>{"  "}ID: {comp.dataset_id}</Text>
+        </Box>
+      ))}
+    </Box>
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Leaderboard Command
+// ─────────────────────────────────────────────────────────────────────────────
+
+function LeaderboardCommand({ datasetId, limit }: { datasetId: string; limit?: number }) {
+  const { exit } = useApp();
+  const [state, setState] = useState<"loading" | "done" | "error">("loading");
+  const [data, setData] = useState<api.LeaderboardEntriesResponse | null>(null);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    (async () => {
+      const result = await api.getLeaderboardEntries(datasetId, limit);
+      if (result.ok && result.data) {
+        setData(result.data);
+        setState("done");
+      } else {
+        setError(result.error ?? "Unknown error");
+        setState("error");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+  }, [datasetId, limit, exit]);
+
+  if (state === "loading") {
+    return <Loading message="Loading leaderboard..." />;
+  }
+
+  if (state === "error") {
+    return <ErrorMessage error={error} />;
+  }
+
+  if (!data || data.entries.length === 0) {
+    return (
+      <Box flexDirection="column">
+        <Text bold color="cyan">Leaderboard: {data?.dataset_name ?? datasetId}</Text>
+        <Text dimColor>  No entries yet. Be the first to submit!</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Text bold color="cyan">Leaderboard: {data.dataset_name} ({data.total_entries} entries)</Text>
+      <Text> </Text>
+      {/* Header */}
+      <Box>
+        <Box width={6}><Text bold dimColor>Rank</Text></Box>
+        <Box width={22}><Text bold dimColor>Name</Text></Box>
+        <Box width={22}><Text bold dimColor>Model</Text></Box>
+        <Box width={10}><Text bold dimColor>F1</Text></Box>
+        <Box width={10}><Text bold dimColor>Precision</Text></Box>
+        <Box width={10}><Text bold dimColor>Recall</Text></Box>
+      </Box>
+      {/* Entries */}
+      {data.entries.map((entry, idx) => {
+        const rank = entry.rank ?? idx + 1;
+        const isFirst = rank === 1;
+        return (
+          <Box key={entry.id}>
+            <Box width={6}>
+              <Text color={isFirst ? "yellow" : undefined} bold={isFirst}>
+                {isFirst ? `#${rank}` : `#${rank}`}
+              </Text>
+            </Box>
+            <Box width={22}>
+              <Text color={isFirst ? "yellow" : undefined} bold={isFirst}>
+                {entry.display_name.substring(0, 20)}
+              </Text>
+            </Box>
+            <Box width={22}>
+              <Text color="cyan">{entry.model_name.substring(0, 20)}</Text>
+            </Box>
+            <Box width={10}>
+              <Text color="green" bold>{entry.f1_score.toFixed(4)}</Text>
+            </Box>
+            <Box width={10}>
+              <Text>{entry.precision_score?.toFixed(4) ?? "N/A"}</Text>
+            </Box>
+            <Box width={10}>
+              <Text>{entry.recall_score?.toFixed(4) ?? "N/A"}</Text>
+            </Box>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Job Create Command (with auto-upload for local datasets)
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface ParsedDataset {
+  type: "local" | "remote";
+  name?: string;      // for remote name:version format
+  version?: string;   // for remote name:version format
+  id?: string;        // for remote UUID format
+}
+
+interface JobCreateCommandProps {
+  modelName: string;
+  datasets: ParsedDataset[];
+  baseModel?: string;
+  epochs?: number;
+}
+
+interface DatasetUploadStatus {
+  name: string;
+  path: string;
+  status: "pending" | "uploading" | "done" | "error";
+  error?: string;
+  uploadedRef?: api.DatasetRef;
+}
+
+// UUID pattern: 8-4-4-4-12 hex characters
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function isUUID(str: string): boolean {
+  return UUID_PATTERN.test(str);
+}
+
+function parseDatasetString(ds: string): ParsedDataset | { error: string } {
+  const trimmed = ds.trim();
+
+  if (trimmed.startsWith("local:")) {
+    const name = trimmed.slice(6); // remove "local:"
+    if (!name) {
+      return { error: `Invalid local dataset format: ${ds}. Use local:<name>` };
+    }
+    return { type: "local", name };
+  }
+
+  if (trimmed.startsWith("remote:")) {
+    const rest = trimmed.slice(7); // remove "remote:"
+
+    // Check if it's a UUID
+    if (isUUID(rest)) {
+      return { type: "remote", id: rest };
+    }
+
+    // Otherwise parse as name:version
+    const colonIndex = rest.lastIndexOf(":");
+    if (colonIndex === -1) {
+      // No version, default to latest
+      return { type: "remote", name: rest, version: "latest" };
+    }
+    return {
+      type: "remote",
+      name: rest.slice(0, colonIndex),
+      version: rest.slice(colonIndex + 1),
+    };
+  }
+
+  return { error: `Invalid dataset format: ${ds}. Use remote:<name>:<version>, remote:<uuid>, or local:<name>` };
+}
+
+function resolveLocalDatasetPath(name: string): string | null {
+  // Check if it's a local dataset by name (in ./datasets/ directory)
+  const localPath = path.join(DATASETS_DIR, `${name}.json`);
+  if (fs.existsSync(localPath)) {
+    return localPath;
+  }
+  // Check if it's a direct file path
+  if (fs.existsSync(name) && (name.endsWith(".json") || name.endsWith(".jsonl"))) {
+    return name;
+  }
+  return null;
+}
+
+function getLocalDatasetType(filePath: string): "ner" | "classification" | "custom" {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    const data = Array.isArray(parsed) ? parsed : parsed.data ?? [];
+    if (parsed.task_type) {
+      return parsed.task_type as "ner" | "classification" | "custom";
+    }
+    const firstItem = data[0] as Record<string, unknown> | undefined;
+    if (firstItem?.spans) return "ner";
+    if (firstItem?.label) return "classification";
+    return "custom";
+  } catch {
+    return "custom";
+  }
+}
+
+function convertJsonToJsonl(filePath: string): string {
+  // Convert JSON array to JSONL format for upload
+  const content = fs.readFileSync(filePath, "utf-8");
+  const parsed = JSON.parse(content);
+  const data = Array.isArray(parsed) ? parsed : parsed.data ?? [];
+
+  // Create temp JSONL file
+  const tempPath = filePath.replace(".json", ".jsonl");
+  const jsonlContent = data.map((item: unknown) => JSON.stringify(item)).join("\n");
+  fs.writeFileSync(tempPath, jsonlContent);
+  return tempPath;
+}
+
+function JobCreateCommand({ modelName, datasets, baseModel, epochs }: JobCreateCommandProps) {
+  const { exit } = useApp();
+  const [state, setState] = useState<"resolving" | "uploading" | "creating" | "done" | "error">("resolving");
+  const [uploadStatuses, setUploadStatuses] = useState<DatasetUploadStatus[]>([]);
+  const [jobResult, setJobResult] = useState<api.TrainingJob | null>(null);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    (async () => {
+      // Separate local and remote datasets
+      const localDatasets = datasets.filter((d): d is ParsedDataset & { type: "local"; name: string } =>
+        d.type === "local" && !!d.name
+      );
+      const remoteByNameVersion = datasets.filter((d): d is ParsedDataset & { type: "remote"; name: string } =>
+        d.type === "remote" && !!d.name
+      );
+      const remoteByUUID = datasets.filter((d): d is ParsedDataset & { type: "remote"; id: string } =>
+        d.type === "remote" && !!d.id
+      );
+
+      // Resolve UUIDs to name:version
+      const remoteDatasets: api.DatasetRef[] = remoteByNameVersion.map(d => ({
+        name: d.name,
+        version: d.version ?? "latest"
+      }));
+
+      if (remoteByUUID.length > 0) {
+        // Fetch dataset list to resolve UUIDs
+        const listResult = await api.listDatasets();
+        if (!listResult.ok || !listResult.data) {
+          setError(`Failed to resolve dataset UUIDs: ${listResult.error ?? "Unknown error"}`);
+          setState("error");
+          setTimeout(() => exit(), 500);
+          return;
+        }
+
+        for (const uuidDataset of remoteByUUID) {
+          const found = listResult.data.datasets.find(ds => ds.id === uuidDataset.id);
+          if (!found) {
+            setError(`Dataset not found with UUID: ${uuidDataset.id}`);
+            setState("error");
+            setTimeout(() => exit(), 500);
+            return;
+          }
+          remoteDatasets.push({
+            name: found.dataset_name,
+            version: found.version_number ?? "latest",
+          });
+        }
+      }
+
+      // Validate local datasets exist
+      const statuses: DatasetUploadStatus[] = [];
+      for (const local of localDatasets) {
+        const localPath = resolveLocalDatasetPath(local.name);
+        if (!localPath) {
+          setError(`Local dataset not found: ${local.name}`);
+          setState("error");
+          setTimeout(() => exit(), 500);
+          return;
+        }
+        statuses.push({ name: local.name, path: localPath, status: "pending" });
+      }
+
+      if (statuses.length === 0) {
+        // No local datasets, proceed directly to job creation
+        setState("creating");
+        const result = await api.createJob({
+          model_name: modelName,
+          datasets: remoteDatasets,
+          base_model: baseModel,
+          nr_epochs: epochs,
+        });
+        if (result.ok && result.data) {
+          setJobResult(result.data);
+          setState("done");
+        } else {
+          setError(result.error ?? "Failed to create job");
+          setState("error");
+        }
+        setTimeout(() => exit(), 500);
+        return;
+      }
+
+      // Upload local datasets
+      setUploadStatuses(statuses);
+      setState("uploading");
+
+      const uploadedDatasets: api.DatasetRef[] = [...remoteDatasets];
+      let hasError = false;
+
+      for (let i = 0; i < statuses.length; i++) {
+        const status = statuses[i];
+
+        // Update status to uploading
+        setUploadStatuses(prev => prev.map((s, idx) =>
+          idx === i ? { ...s, status: "uploading" as const } : s
+        ));
+
+        try {
+          // Convert JSON to JSONL if needed
+          let uploadPath = status.path;
+          let isTemp = false;
+          if (status.path.endsWith(".json")) {
+            uploadPath = convertJsonToJsonl(status.path);
+            isTemp = true;
+          }
+
+          const result = await api.uploadDataset(uploadPath, {
+            dataset_name: status.name,
+            dataset_type: getLocalDatasetType(status.path),
+            format: "jsonl",
+          });
+
+          // Clean up temp file
+          if (isTemp && uploadPath !== status.path) {
+            try { fs.unlinkSync(uploadPath); } catch { /* ignore */ }
+          }
+
+          if (result.ok && result.data) {
+            const uploadedRef: api.DatasetRef = {
+              name: result.data.dataset_name,
+              version: result.data.version_number ?? "latest",
+            };
+            uploadedDatasets.push(uploadedRef);
+            setUploadStatuses(prev => prev.map((s, idx) =>
+              idx === i ? { ...s, status: "done" as const, uploadedRef } : s
+            ));
+          } else {
+            hasError = true;
+            setUploadStatuses(prev => prev.map((s, idx) =>
+              idx === i ? { ...s, status: "error" as const, error: result.error } : s
+            ));
+          }
+        } catch (err) {
+          hasError = true;
+          setUploadStatuses(prev => prev.map((s, idx) =>
+            idx === i ? { ...s, status: "error" as const, error: err instanceof Error ? err.message : String(err) } : s
+          ));
+        }
+      }
+
+      if (hasError) {
+        setError("Some datasets failed to upload");
+        setState("error");
+        setTimeout(() => exit(), 500);
+        return;
+      }
+
+      // Create the job with all datasets
+      setState("creating");
+
+      const result = await api.createJob({
+        model_name: modelName,
+        datasets: uploadedDatasets,
+        base_model: baseModel,
+        nr_epochs: epochs,
+      });
+
+      if (result.ok && result.data) {
+        setJobResult(result.data);
+        setState("done");
+      } else {
+        setError(result.error ?? "Failed to create job");
+        setState("error");
+      }
+      setTimeout(() => exit(), 500);
+    })();
+  }, [modelName, datasets, baseModel, epochs, exit]);
+
+  if (state === "resolving") {
+    return <Loading message="Resolving datasets..." />;
+  }
+
+  if (state === "uploading") {
+    return (
+      <Box flexDirection="column">
+        <Text>
+          <Text color="blue"><Spinner type="dots" /></Text>
+          {" "}Uploading local datasets...
+        </Text>
+        {uploadStatuses.map((status, idx) => (
+          <Box key={idx}>
+            <Text>
+              {"  "}
+              {status.status === "pending" && <Text color="gray">○</Text>}
+              {status.status === "uploading" && <Text color="yellow"><Spinner type="dots" /></Text>}
+              {status.status === "done" && <Text color="green">✓</Text>}
+              {status.status === "error" && <Text color="red">✗</Text>}
+              {" "}{status.name}
+              {status.status === "done" && status.uploadedRef && (
+                <Text color="gray"> → {status.uploadedRef.name}:{status.uploadedRef.version}</Text>
+              )}
+              {status.status === "error" && status.error && (
+                <Text color="red"> ({status.error})</Text>
+              )}
+            </Text>
+          </Box>
+        ))}
+      </Box>
+    );
+  }
+
+  if (state === "creating") {
+    return <Loading message="Creating training job..." />;
+  }
+
+  if (state === "error") {
+    return (
+      <Box flexDirection="column">
+        {uploadStatuses.length > 0 && uploadStatuses.some(s => s.status === "done") && (
+          <Box flexDirection="column" marginBottom={1}>
+            <Text color="green">✓ Uploaded datasets:</Text>
+            {uploadStatuses.filter(s => s.status === "done").map((status, idx) => (
+              <Text key={idx} color="gray">
+                {"  "}{status.name} → {status.uploadedRef?.name}:{status.uploadedRef?.version}
+              </Text>
+            ))}
+          </Box>
+        )}
+        <ErrorMessage error={error} />
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      {uploadStatuses.length > 0 && (
+        <Box flexDirection="column" marginBottom={1}>
+          <Text color="green">✓ Uploaded local datasets:</Text>
+          {uploadStatuses.map((status, idx) => (
+            <Text key={idx} color="gray">
+              {"  "}{status.name} → {status.uploadedRef?.name}:{status.uploadedRef?.version}
+            </Text>
+          ))}
+        </Box>
+      )}
+      <Success message="Training job created" />
+      {jobResult && (
+        <Box flexDirection="column">
+          <Text>
+            {"  "}Job ID: <Text color="cyan">{jobResult.id}</Text>
+          </Text>
+          <Text>
+            {"  "}Model: <Text color="yellow">{jobResult.model_name}</Text>
+          </Text>
+          <Text>
+            {"  "}Status: <Text color="blue">{jobResult.status}</Text>
+          </Text>
+        </Box>
+      )}
+    </Box>
+  );
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Dataset Download Command
 // ─────────────────────────────────────────────────────────────────────────────
@@ -894,16 +1473,21 @@ function TrainedModelCard({ model, index }: TrainedModelCardProps) {
   const metricsDisplay = model.metrics ? (() => {
     const parts = [];
     
-    // Loss (prioritize best, then final validation, then eval validation)
-    if (model.metrics.best_validation_loss !== undefined) {
-      parts.push(`L:${model.metrics.best_validation_loss.toFixed(3)}`);
-    } else if (model.metrics.final_validation_loss !== undefined) {
-      parts.push(`L:${model.metrics.final_validation_loss.toFixed(3)}`);
+    // Training Loss (final epoch)
+    if (model.metrics.final_training_loss !== undefined) {
+      parts.push(`TL:${model.metrics.final_training_loss.toFixed(3)}`);
+    }
+    
+    // Validation Loss (prioritize FINAL, then eval, then best as fallback)
+    if (model.metrics.final_validation_loss !== undefined) {
+      parts.push(`VL:${model.metrics.final_validation_loss.toFixed(3)}`);
     } else if (model.metrics.eval_validation_loss !== undefined) {
-      parts.push(`L:${model.metrics.eval_validation_loss.toFixed(3)}`);
+      parts.push(`VL:${model.metrics.eval_validation_loss.toFixed(3)}`);
+    } else if (model.metrics.best_validation_loss !== undefined) {
+      parts.push(`VL:${model.metrics.best_validation_loss.toFixed(3)}`);
     }
     
-    // F1, Precision, Recall, Accuracy
+    // F1, Precision, Recall, Accuracy (from evaluation if available)
     if (model.metrics.eval_f1_score !== undefined) {
       parts.push(`F1:${model.metrics.eval_f1_score.toFixed(2)}`);
     }
@@ -1148,7 +1732,7 @@ function ModelListCommand({ filter }: ModelListCommandProps) {
 // Help Components
 // ─────────────────────────────────────────────────────────────────────────────
 
-type HelpContext = "root" | "auth" | "dataset" | "dataset-analyze" | "dataset-edit" | "job" | "model" | "chat" | "eval" | "benchmark";
+type HelpContext = "root" | "auth" | "dataset" | "dataset-analyze" | "dataset-edit" | "job" | "model" | "chat" | "eval" | "benchmark" | "competition";
 
 interface HelpProps {
   context?: HelpContext;
@@ -1307,7 +1891,10 @@ 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 {"<name[:version],...>"}   Comma-separated datasets (required)</Text>
+        <Text>    --dataset-ids {"<ids>"}   Comma-separated datasets (required)</Text>
+        <Text>                         remote:{"<name>"}:{"<version>"} - by name and version</Text>
+        <Text>                         remote:{"<uuid>"} - by UUID</Text>
+        <Text>                         local:{"<name>"} - auto-upload from ./datasets/</Text>
         <Text>    --base-model {"<model>"}  Base model (default: fastino/gliner2-base-v1)</Text>
         <Text>    --epochs {"<n>"}          Number of epochs (default: 5)</Text>
       </Box>
@@ -1385,6 +1972,22 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
     );
   }
 
+  // Competition help
+  if (context === "competition") {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Competition Commands:</Text>
+        <Text>  competition list                     List active competitions</Text>
+        <Text>  competition show {"<dataset-id>"}         View sample data for a competition</Text>
+        <Text>  competition leaderboard {"<dataset-id>"}  View leaderboard rankings</Text>
+        <Text>    --limit {"<n>"}                        Number of entries (default: 10)</Text>
+        <Text>  competition submit {"<dataset-id>"}       Submit evaluation to leaderboard</Text>
+        <Text>    --eval-id {"<id>"}                     Evaluation ID (required)</Text>
+        <Text>    --name {"<name>"}                      Display name (required)</Text>
+      </Box>
+    );
+  }
+
   // Root help - overview only
   return (
     <Box flexDirection="column">
@@ -1401,6 +2004,7 @@ const Help: React.FC<HelpProps> = ({ context = "root" }) => {
       <Text>  model      Manage models</Text>
       <Text>  eval       Model evaluations on datasets</Text>
       <Text>  benchmark  Run benchmark evaluations</Text>
+      <Text>  competition Competitions and leaderboards</Text>
       <Text>  telemetry  Manage anonymous usage analytics</Text>
       <Text> </Text>
       <Text dimColor>Run 'pioneer {"<command>"} --help' for details on a specific command.</Text>
@@ -1742,6 +2346,9 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
         }
 
         const hfToken = getHfToken(hfTokenFlag);
+        if (!hfToken) {
+          return <ErrorMessage error="HuggingFace token is required. Set HF_TOKEN env var or use --hf-token flag." />;
+        }
 
         return (
           <ApiCommand
@@ -1749,7 +2356,7 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
               api.pullDatasetFromHub({
                 repo_id: repo,
                 hf_token: hfToken,
-                dataset_name: datasetName,
+                name: datasetName,
                 revision,
               })
             }
@@ -1953,7 +2560,7 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
       return <ApiCommand action={() => api.getJob(rest[0])} />;
     }
     if (action === "logs" && rest[0]) {
-      return <ApiCommand action={() => api.getJobLogs(rest[0])} />;
+      return <JobLogsCommand jobId={rest[0]} />;
     }
     if (action === "delete" && rest[0]) {
       return (
@@ -1973,30 +2580,22 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
         return <ErrorMessage error="--model-name and --dataset-ids are required" />;
       }
 
-      // Parse dataset strings in name:version format
-      const datasets: api.DatasetRef[] = [];
+      // Parse dataset strings with explicit local:/remote: prefixes
+      const datasets: ParsedDataset[] = [];
       for (const ds of datasetStrings) {
-        const colonIndex = ds.lastIndexOf(":");
-        if (colonIndex === -1) {
-          return <ErrorMessage error={`Invalid dataset format: ${ds}. Use name[:version] format (e.g., my-dataset or my-dataset:v1).`} />;
+        const parsed = parseDatasetString(ds);
+        if ("error" in parsed) {
+          return <ErrorMessage error={parsed.error} />;
         }
-        datasets.push({
-          name: ds.slice(0, colonIndex),
-          version: ds.slice(colonIndex + 1),
-        });
+        datasets.push(parsed);
       }
 
       return (
-        <ApiCommand
-          action={() =>
-            api.createJob({
-              model_name: modelName,
-              datasets,
-              base_model: baseModel,
-              nr_epochs: epochs,
-            })
-          }
-          successMessage="Training job created"
+        <JobCreateCommand
+          modelName={modelName}
+          datasets={datasets}
+          baseModel={baseModel}
+          epochs={epochs}
         />
       );
     }
@@ -2164,9 +2763,9 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
             api.createEvaluation({
               model_id: modelId,
               dataset,
-              task_type: taskType,
-              text_column: textColumn,
-              label_column: labelColumn,
+              ...(taskType ? { task_type: taskType } : {}),
+              ...(textColumn ? { text_column: textColumn } : {}),
+              ...(labelColumn ? { label_column: labelColumn } : {}),
             })
           }
           successMessage="Evaluation created"
@@ -2224,6 +2823,44 @@ const App: React.FC<AppProps> = ({ command, flags }) => {
     return <Help context="benchmark" />;
   }
 
+  // Competition commands
+  if (group === "competition") {
+    if (flags.help === "true" || !action || action === "help") {
+      return <Help context="competition" />;
+    }
+    if (action === "list") {
+      return <CompetitionListCommand />;
+    }
+    if (action === "show" && rest[0]) {
+      return <ApiCommand action={() => api.getCompetitionSamples(rest[0])} />;
+    }
+    if (action === "leaderboard" && rest[0]) {
+      const limit = flags["limit"] ? parseInt(flags["limit"], 10) : undefined;
+      return <LeaderboardCommand datasetId={rest[0]} limit={limit} />;
+    }
+    if (action === "submit" && rest[0]) {
+      const evalId = flags["eval-id"];
+      const displayName = flags["name"];
+
+      if (!evalId || !displayName) {
+        return <ErrorMessage error="--eval-id and --name are required" />;
+      }
+
+      return (
+        <ApiCommand
+          action={() =>
+            api.submitToLeaderboard(rest[0], {
+              evaluation_id: evalId,
+              display_name: displayName,
+            })
+          }
+          successMessage="Submitted to leaderboard"
+        />
+      );
+    }
+    return <Help context="competition" />;
+  }
+
   return <Help />;
 };