@plune-ai/cli 0.16.0 → 0.17.1

package/dist/index.js

@@ -1499,59 +1499,116 @@ import * as fs6 from "fs";
 import * as path5 from "path";
 
 // src/types/run-result-schema.ts
+import { z as z3 } from "zod";
+
+// src/types/test-case-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 TEST_CASE_SCHEMA_VERSION = 2;
+var externalKeySchema = z2.object({
+  kind: z2.enum(["playwright-id", "path-title", "allure-history", "cairn-stable", "eval-id", "qase", "testrail"]),
+  value: z2.string().min(1)
+});
+var manualStepSchema = z2.object({
+  action: z2.string().min(1),
+  expected: z2.string().min(1).optional()
 });
 var assertionResultRecordSchema = z2.object({
-  type: z2.string(),
+  type: z2.string().min(1),
   passed: z2.boolean(),
   score: z2.number().optional(),
-  reason: z2.string().optional(),
-  binaryVerdicts: z2.array(binaryVerdictSchema).optional()
+  reason: z2.string().optional()
+});
+var manualCaseSchema = z2.object({
+  type: z2.literal("manual"),
+  steps: z2.array(manualStepSchema).min(1),
+  expected: z2.string().min(1).optional()
+});
+var automatedCaseSchema = z2.object({
+  type: z2.literal("automated"),
+  specRef: z2.string().min(1)
+});
+var evalCaseSchema = z2.object({
+  type: z2.literal("eval"),
+  prompt: z2.string().min(1),
+  goldenSetId: z2.string().min(1).optional(),
+  assertions: z2.array(assertionResultRecordSchema).min(1)
+});
+var testCaseBaseSchema = z2.object({
+  schemaVersion: z2.literal(TEST_CASE_SCHEMA_VERSION),
+  id: z2.string().min(1),
+  externalKeys: z2.array(externalKeySchema).optional(),
+  /** ADR 0045 / plune#1246 — optional, purely additive; schemaVersion stays 2. */
+  is_flaky: z2.boolean().optional(),
+  /** ADR 0045 / plune#1246 — optional, purely additive; schemaVersion stays 2. */
+  is_muted: z2.boolean().optional()
+});
+var testCaseSchema = z2.discriminatedUnion("type", [
+  testCaseBaseSchema.merge(manualCaseSchema),
+  testCaseBaseSchema.merge(automatedCaseSchema),
+  testCaseBaseSchema.merge(evalCaseSchema)
+]);
+function parseTestCase(value) {
+  return testCaseSchema.parse(value);
+}
+
+// src/types/results.ts
+var ROW_INCONCLUSIVE = ["blocked", "skipped"];
+
+// src/types/run-result-schema.ts
+var RUN_RESULT_SCHEMA_VERSION = 1;
+var binaryVerdictSchema = z3.object({
+  question: z3.string().min(1),
+  passed: z3.boolean()
+});
+var assertionResultRecordSchema2 = z3.object({
+  type: z3.string(),
+  passed: z3.boolean(),
+  score: z3.number().optional(),
+  reason: z3.string().optional(),
+  binaryVerdicts: z3.array(binaryVerdictSchema).optional()
 });
-var usageSchema = z2.object({
-  input_tokens: z2.number(),
-  output_tokens: z2.number(),
-  cost_usd: z2.number()
+var usageSchema = z3.object({
+  input_tokens: z3.number(),
+  output_tokens: z3.number(),
+  cost_usd: z3.number()
 });
-var runErrorSchema = z2.object({
-  code: z2.string(),
-  message: z2.string()
+var runErrorSchema = z3.object({
+  code: z3.string(),
+  message: z3.string()
 });
-var rowResultSchema = z2.object({
-  vars: z2.record(z2.string(), z2.unknown()),
-  output: z2.string().nullable(),
-  cached: z2.boolean(),
+var rowResultSchema = z3.object({
+  vars: z3.record(z3.string(), z3.unknown()),
+  output: z3.string().nullable(),
+  cached: z3.boolean(),
   usage: usageSchema.optional(),
-  latency_ms: z2.number().optional(),
+  latency_ms: z3.number().optional(),
   error: runErrorSchema.optional(),
-  assertions: z2.array(assertionResultRecordSchema)
+  assertions: z3.array(assertionResultRecordSchema2),
+  /** ADR 0045. Optional and additive — the same enum the platform validates on `POST /v1/runs`. */
+  inconclusive: z3.enum(ROW_INCONCLUSIVE).optional()
 });
-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 summarySchema = z3.object({
+  total: z3.number(),
+  passed: z3.number(),
+  failed: z3.number(),
+  errored: z3.number(),
+  cost_usd: z3.number(),
+  duration_ms: z3.number()
 });
-var evalResultSchema = z2.object({
-  id: z2.string(),
-  tags: z2.array(z2.string()),
-  rows: z2.array(rowResultSchema),
-  passed: z2.boolean()
+var evalResultSchema = z3.object({
+  id: z3.string(),
+  tags: z3.array(z3.string()),
+  rows: z3.array(rowResultSchema),
+  passed: z3.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(),
+var runResultSchema = z3.object({
+  schemaVersion: z3.literal(RUN_RESULT_SCHEMA_VERSION),
+  plune_version: z3.string(),
+  started_at: z3.string(),
+  finished_at: z3.string(),
+  config_hash: z3.string(),
   summary: summarySchema,
-  evals: z2.array(evalResultSchema)
+  evals: z3.array(evalResultSchema)
 });
 function parseRunResult(value) {
   return runResultSchema.parse(value);
@@ -1934,17 +1991,20 @@ export {
   SyncFileError,
   SyncHttpError,
   SyncNetworkError,
+  TEST_CASE_SCHEMA_VERSION,
   TokenRejectedError,
   assertionConfigSchema,
-  assertionResultRecordSchema,
+  assertionResultRecordSchema2 as assertionResultRecordSchema,
   binaryVerdictSchema,
   formatIngestResult,
   handleIngest as ingest,
   parseRunResult,
+  parseTestCase,
   readCairnRun,
   reportIngestFailure,
   reportSyncFailure,
   handleRun as run,
   runResultSchema,
-  handleSync as sync
+  handleSync as sync,
+  testCaseSchema
 };