@plune-ai/cli 0.3.0 → 0.5.0

package/dist/index.js

@@ -315,7 +315,7 @@ function normalizeProviderError(err, secret, envVar) {
 }
 
 // src/providers/retry.ts
-var defaultSleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
+var defaultSleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
 function retryAfterMs(err) {
   if (typeof err !== "object" || err === null || !("headers" in err)) return void 0;
   const raw = readHeader(err.headers, "retry-after");
@@ -1460,6 +1460,210 @@ async function handleRun(options, depsFactory) {
     deps.cache.close();
   }
 }
+
+// src/cli/commands/sync.ts
+import * as fs6 from "fs";
+import * as path5 from "path";
+
+// src/types/run-result-schema.ts
+import { z as z2 } from "zod";
+var RUN_RESULT_SCHEMA_VERSION = 1;
+var binaryVerdictSchema = z2.object({
+  question: z2.string().min(1),
+  passed: z2.boolean()
+});
+var assertionResultRecordSchema = z2.object({
+  type: z2.string(),
+  passed: z2.boolean(),
+  score: z2.number().optional(),
+  reason: z2.string().optional(),
+  binaryVerdicts: z2.array(binaryVerdictSchema).optional()
+});
+var usageSchema = z2.object({
+  input_tokens: z2.number(),
+  output_tokens: z2.number(),
+  cost_usd: z2.number()
+});
+var runErrorSchema = z2.object({
+  code: z2.string(),
+  message: z2.string()
+});
+var rowResultSchema = z2.object({
+  vars: z2.record(z2.unknown()),
+  output: z2.string().nullable(),
+  cached: z2.boolean(),
+  usage: usageSchema.optional(),
+  latency_ms: z2.number().optional(),
+  error: runErrorSchema.optional(),
+  assertions: z2.array(assertionResultRecordSchema)
+});
+var summarySchema = z2.object({
+  total: z2.number(),
+  passed: z2.number(),
+  failed: z2.number(),
+  errored: z2.number(),
+  cost_usd: z2.number(),
+  duration_ms: z2.number()
+});
+var evalResultSchema = z2.object({
+  id: z2.string(),
+  tags: z2.array(z2.string()),
+  rows: z2.array(rowResultSchema),
+  passed: z2.boolean()
+});
+var runResultSchema = z2.object({
+  schemaVersion: z2.literal(RUN_RESULT_SCHEMA_VERSION),
+  plune_version: z2.string(),
+  started_at: z2.string(),
+  finished_at: z2.string(),
+  config_hash: z2.string(),
+  summary: summarySchema,
+  evals: z2.array(evalResultSchema)
+});
+function parseRunResult(value) {
+  return runResultSchema.parse(value);
+}
+
+// src/cli/credentials.ts
+import { chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname3, join as join3 } from "path";
+function credentialsFile() {
+  const base = process.env["XDG_CONFIG_HOME"]?.trim() || join3(homedir(), ".config");
+  return join3(base, "plune", "credentials.json");
+}
+function loadToken() {
+  try {
+    const parsed = JSON.parse(readFileSync3(credentialsFile(), "utf-8"));
+    return typeof parsed.token === "string" && parsed.token.length > 0 ? parsed.token : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/commands/sync.ts
+var DEFAULT_API_URL = "https://beta-api.plune.ai";
+var NotLoggedInError = class extends Error {
+  constructor() {
+    super('Not logged in. Run "plune login" first to save your API token.');
+    this.name = "NotLoggedInError";
+  }
+};
+var TokenRejectedError = class extends Error {
+  constructor() {
+    super(
+      'Your API token was rejected (revoked or invalid). Run "plune login" with a fresh token.'
+    );
+    this.name = "TokenRejectedError";
+  }
+};
+var SyncFileError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SyncFileError";
+  }
+};
+var SyncNetworkError = class extends Error {
+  constructor(apiUrl) {
+    super(
+      `Could not reach the Plune API at ${apiUrl}. Check your connection (or PLUNE_API_URL) and try again.`
+    );
+    this.name = "SyncNetworkError";
+  }
+};
+var SyncHttpError = class extends Error {
+  constructor(status, detail) {
+    super(`Sync failed \u2014 the server returned HTTP ${status}${detail ? ` (${detail})` : ""}.`);
+    this.status = status;
+    this.name = "SyncHttpError";
+  }
+  status;
+};
+function resolveApiUrl(explicit) {
+  const raw = explicit ?? process.env["PLUNE_API_URL"] ?? DEFAULT_API_URL;
+  return raw.replace(/\/+$/, "");
+}
+function readRun(cwd, file) {
+  const target = file !== void 0 ? path5.resolve(cwd, file) : path5.join(cwd, ".plune", "last-run.json");
+  let raw;
+  try {
+    raw = fs6.readFileSync(target, "utf8");
+  } catch {
+    throw new SyncFileError(
+      file !== void 0 ? `Run file not found: ${target}` : 'No run to sync. Run "plune run" first (or pass --file <path>).'
+    );
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    throw new SyncFileError(`Run file is not valid JSON: ${target}`);
+  }
+  try {
+    return parseRunResult(json);
+  } catch {
+    throw new SyncFileError(`Run file does not match the RunResult schema: ${target}`);
+  }
+}
+async function safeErrorDetail(res) {
+  try {
+    const body = await res.json();
+    return typeof body.error === "string" ? body.error : "";
+  } catch {
+    return "";
+  }
+}
+async function handleSync(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const apiUrl = resolveApiUrl(deps.apiUrl);
+  const token = (deps.loadToken ?? loadToken)();
+  if (token === null) throw new NotLoggedInError();
+  const run = readRun(cwd, deps.file);
+  const doFetch = deps.fetchImpl ?? fetch;
+  const endpoint = `${apiUrl}/v1/runs`;
+  let res;
+  try {
+    res = await doFetch(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+      body: JSON.stringify(run)
+    });
+  } catch {
+    throw new SyncNetworkError(apiUrl);
+  }
+  if (!res.ok) {
+    const detail = await safeErrorDetail(res);
+    if (res.status === 401) throw new TokenRejectedError();
+    throw new SyncHttpError(res.status, detail);
+  }
+  const body = await res.json().catch(() => ({}));
+  const id = typeof body.id === "string" ? body.id : "";
+  return { id, url: `${endpoint}/${id}` };
+}
+function reportSyncFailure(err, write) {
+  if (err instanceof NotLoggedInError || err instanceof TokenRejectedError || err instanceof SyncFileError) {
+    write(err.message + "\n");
+    return 2;
+  }
+  if (err instanceof SyncNetworkError || err instanceof SyncHttpError) {
+    write(err.message + "\n");
+    return 1;
+  }
+  return null;
+}
 export {
-  handleRun as run
+  NotLoggedInError,
+  RUN_RESULT_SCHEMA_VERSION,
+  SyncFileError,
+  SyncHttpError,
+  SyncNetworkError,
+  TokenRejectedError,
+  assertionConfigSchema,
+  assertionResultRecordSchema,
+  binaryVerdictSchema,
+  parseRunResult,
+  reportSyncFailure,
+  handleRun as run,
+  runResultSchema,
+  handleSync as sync
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plune-ai/cli",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "AI-powered assertion testing for LLM apps — write assertions, run them against any provider, get a pass/fail report (local, CI, or diff).",
   "keywords": [
     "ai",