@wayai/cli 0.3.47 → 0.3.49

package/dist/index.js

@@ -343,6 +343,16 @@ var init_api_client = __esm({
         if (opts?.limit) params.set("limit", String(opts.limit));
         return this.request("GET", `/api/evals/sessions/${sessionId}/runs?${params.toString()}`);
       }
+      /** Delete a single eval session (cascades runs/results/conversations server-side). */
+      async deleteEvalSession(hubId, sessionId) {
+        const params = new URLSearchParams({ hub_id: hubId });
+        return this.request("DELETE", `/api/evals/sessions/${sessionId}?${params.toString()}`);
+      }
+      /** Delete ALL eval sessions for a hub (each cascades server-side). */
+      async deleteAllEvalSessions(hubId) {
+        const params = new URLSearchParams({ hub_id: hubId });
+        return this.request("DELETE", `/api/evals/sessions?${params.toString()}`);
+      }
       async listScenarioSets(hubId) {
         const params = new URLSearchParams({ hub_id: hubId });
         return this.request("GET", `/api/evals/scenario-sets?${params.toString()}`);
@@ -5031,6 +5041,22 @@ function slugifyKebab(input, maxLength = 64) {
   if (typeof input !== "string") return "";
   return foldDiacritics(input).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").slice(0, maxLength).replace(/^-|-$/g, "");
 }
+function ensureUniqueSlug(slug, used) {
+  if (!used.has(slug)) {
+    used.add(slug);
+    return slug;
+  }
+  for (let i = 2; i < 1e6; i++) {
+    const suffix = `_${i}`;
+    const baseLen = Math.max(1, 50 - suffix.length);
+    const candidate = `${slug.slice(0, baseLen)}${suffix}`;
+    if (!used.has(candidate)) {
+      used.add(candidate);
+      return candidate;
+    }
+  }
+  throw new Error(`slug collision space exhausted for "${slug}"`);
+}
 function slugifySkillName(name) {
   return slugifyKebab(name, 64);
 }
@@ -9508,6 +9534,7 @@ function writeHubFolder(hubFolder, payload) {
   }
   writeResourceFiles(hubFolder, payload.resources || []);
   writeEvalYamlFiles(hubFolder, payload.evals || []);
+  writeJourneyYamlFiles(hubFolder, payload.journeys || []);
 }
 function buildYamlPayload(payload) {
   const result = {
@@ -9634,6 +9661,60 @@ function cleanEvalOrphans(evalsDir, writtenRelPaths) {
     }
   }
 }
+function buildJourneyYamlObject(journeyEntry, slug) {
+  const out = {};
+  if (journeyEntry.id) out.id = journeyEntry.id;
+  if (journeyEntry.name !== slug) out.name = journeyEntry.name;
+  out.agent = journeyEntry.agent;
+  if (journeyEntry.agent_id) out.agent_id = journeyEntry.agent_id;
+  if (journeyEntry.enabled === false) {
+    out.enabled = false;
+  }
+  if (journeyEntry.evaluator_instructions) {
+    out.evaluator_instructions = journeyEntry.evaluator_instructions;
+  }
+  if (journeyEntry.transcript && journeyEntry.transcript.length > 0) {
+    out.transcript = journeyEntry.transcript;
+  }
+  if (journeyEntry.step_config && Object.keys(journeyEntry.step_config).length > 0) {
+    out.step_config = journeyEntry.step_config;
+  }
+  return out;
+}
+function writeJourneyYamlFiles(hubFolder, journeys) {
+  const journeysDir = path11.join(hubFolder, "journeys");
+  if (journeys.length === 0) {
+    if (fs9.existsSync(journeysDir)) {
+      cleanJourneyOrphans(journeysDir, /* @__PURE__ */ new Set());
+      try {
+        if (fs9.readdirSync(journeysDir).length === 0) fs9.rmdirSync(journeysDir);
+      } catch {
+      }
+    }
+    return;
+  }
+  if (!fs9.existsSync(journeysDir)) {
+    fs9.mkdirSync(journeysDir, { recursive: true });
+  }
+  const writtenFiles = /* @__PURE__ */ new Set();
+  const usedSlugs = /* @__PURE__ */ new Set();
+  for (const journeyEntry of journeys) {
+    const slug = ensureUniqueSlug(slugify(journeyEntry.name), usedSlugs);
+    const fileName = `${slug}.yaml`;
+    const yamlContent = yaml4.dump(buildJourneyYamlObject(journeyEntry, slug), YAML_DUMP_OPTIONS);
+    fs9.writeFileSync(path11.join(journeysDir, fileName), yamlContent, "utf-8");
+    writtenFiles.add(fileName);
+  }
+  cleanJourneyOrphans(journeysDir, writtenFiles);
+}
+function cleanJourneyOrphans(journeysDir, writtenFiles) {
+  const entries = fs9.readdirSync(journeysDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".yaml") && !writtenFiles.has(entry.name)) {
+      fs9.unlinkSync(path11.join(journeysDir, entry.name));
+    }
+  }
+}
 function writeResourceFiles(hubFolder, resources) {
   const resourcesDir = path11.join(hubFolder, "resources");
   const currentSlugs = /* @__PURE__ */ new Set();
@@ -9656,6 +9737,7 @@ var YAML_DUMP_OPTIONS;
 var init_yaml_writer = __esm({
   "src/lib/yaml-writer.ts"() {
     "use strict";
+    init_dist();
     init_utils();
     init_resource_files();
     YAML_DUMP_OPTIONS = {
@@ -9777,6 +9859,10 @@ function parseHubFolder(hubFolder, opts) {
   if (evals.length > 0) {
     payload.evals = evals;
   }
+  const journeys = scanJourneyYamlFiles(hubFolder);
+  if (journeys.length > 0) {
+    payload.journeys = journeys;
+  }
   return payload;
 }
 function scanEvalYamlFiles(hubFolder) {
@@ -9865,6 +9951,76 @@ function parseEvalYaml(filePath, relPath, setName) {
   }
   return evalEntry;
 }
+function scanJourneyYamlFiles(hubFolder) {
+  const journeysDir = path12.join(hubFolder, "journeys");
+  if (!fs10.existsSync(journeysDir)) return [];
+  const journeys = [];
+  const seen = /* @__PURE__ */ new Set();
+  const entries = fs10.readdirSync(journeysDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      throw expected(
+        `Subfolders are not supported under journeys/: ${path12.relative(hubFolder, path12.join(journeysDir, entry.name))}. A journey owns its own managed scenario set \u2014 put each journey in a single journeys/<slug>.yaml file.`
+      );
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".yaml")) continue;
+    const journeyEntry = parseJourneyYaml(path12.join(journeysDir, entry.name), `journeys/${entry.name}`);
+    if (!journeyEntry) continue;
+    if (seen.has(journeyEntry.name)) {
+      throw expected(
+        `Duplicate journey: "${journeyEntry.name}" (in ${entry.name}). Each journey name must be unique.`
+      );
+    }
+    seen.add(journeyEntry.name);
+    journeys.push(journeyEntry);
+  }
+  return journeys;
+}
+function parseJourneyYaml(filePath, relPath) {
+  const content = fs10.readFileSync(filePath, "utf-8");
+  let raw;
+  try {
+    raw = yaml5.load(content);
+  } catch (err) {
+    if (err instanceof yaml5.YAMLException) {
+      throw expected(`Invalid YAML in ${relPath}: ${err.message}`);
+    }
+    throw err;
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    console.warn(`  Warning: skipping ${relPath} (not a YAML object)`);
+    return null;
+  }
+  const data = raw;
+  const fileSlug = path12.basename(filePath, ".yaml");
+  const journeyName = typeof data.name === "string" && data.name.trim().length > 0 ? data.name : fileSlug;
+  if (typeof data.agent !== "string" || data.agent.trim().length === 0) {
+    throw expected(`Journey "${journeyName}" in ${relPath}: missing required field "agent" (string).`);
+  }
+  if (data.transcript !== void 0 && !Array.isArray(data.transcript)) {
+    throw expected(`Journey "${journeyName}" in ${relPath}: "transcript" must be an array.`);
+  }
+  if (data.step_config !== void 0 && (typeof data.step_config !== "object" || Array.isArray(data.step_config) || data.step_config === null)) {
+    throw expected(`Journey "${journeyName}" in ${relPath}: "step_config" must be an object keyed by step_id.`);
+  }
+  const journeyEntry = {
+    name: journeyName,
+    agent: data.agent
+  };
+  if (typeof data.id === "string") journeyEntry.id = data.id;
+  if (typeof data.agent_id === "string") journeyEntry.agent_id = data.agent_id;
+  if (data.enabled === false) journeyEntry.enabled = false;
+  if (typeof data.evaluator_instructions === "string") {
+    journeyEntry.evaluator_instructions = data.evaluator_instructions;
+  }
+  if (Array.isArray(data.transcript)) {
+    journeyEntry.transcript = data.transcript;
+  }
+  if (data.step_config && typeof data.step_config === "object" && !Array.isArray(data.step_config)) {
+    journeyEntry.step_config = data.step_config;
+  }
+  return journeyEntry;
+}
 function scanAgentYamlFiles(hubFolder) {
   const agentsDir = path12.join(hubFolder, "agents");
   if (!fs10.existsSync(agentsDir)) return [];
@@ -10179,6 +10335,12 @@ Sync complete. Preview hub: ${result.preview_hub_id}`);
   if (c.states_created > 0) parts.push(`${c.states_created} state(s) created`);
   if (c.states_updated > 0) parts.push(`${c.states_updated} state(s) updated`);
   if (c.states_deleted > 0) parts.push(`${c.states_deleted} state(s) deleted`);
+  if (c.evals_created > 0) parts.push(`${c.evals_created} eval(s) created`);
+  if (c.evals_updated > 0) parts.push(`${c.evals_updated} eval(s) updated`);
+  if (c.evals_deleted > 0) parts.push(`${c.evals_deleted} eval(s) deleted`);
+  if (c.journeys_created > 0) parts.push(`${c.journeys_created} journey(s) created`);
+  if (c.journeys_updated > 0) parts.push(`${c.journeys_updated} journey(s) updated`);
+  if (c.journeys_deleted > 0) parts.push(`${c.journeys_deleted} journey(s) deleted`);
   if (c.teams_created > 0) parts.push(`${c.teams_created} team(s) created`);
   if (c.teams_updated > 0) parts.push(`${c.teams_updated} team(s) updated`);
   if (c.teams_deleted > 0) parts.push(`${c.teams_deleted} team(s) deleted`);
@@ -12048,6 +12210,80 @@ var init_journey_capture = __esm({
   }
 });
 
+// src/commands/eval-session-delete.ts
+var eval_session_delete_exports = {};
+__export(eval_session_delete_exports, {
+  evalSessionDeleteCommand: () => evalSessionDeleteCommand
+});
+async function evalSessionDeleteCommand(args2) {
+  const hubId = resolveActiveHubId(args2);
+  const { config, accessToken } = await requireAuth();
+  requireRepoConfig();
+  const skipConfirm = args2.includes("-y") || args2.includes("--yes");
+  const deleteAll = args2.includes("--all");
+  const sessionId = args2.find((a) => !a.startsWith("-"));
+  if (deleteAll && sessionId) {
+    console.error("Pass either a session id or --all, not both.");
+    process.exit(1);
+  }
+  if (!deleteAll && !sessionId) {
+    console.error("Usage: wayai eval session delete <session_id>");
+    console.error("       wayai eval session delete --all");
+    process.exit(1);
+  }
+  if (sessionId && !UUID_RE.test(sessionId)) {
+    console.error(`Invalid session id: ${sessionId}`);
+    process.exit(1);
+  }
+  const client = new ApiClient({ apiUrl: config.api_url, accessToken });
+  if (deleteAll) {
+    if (!skipConfirm) {
+      const confirmed = await confirm(
+        "This will permanently delete ALL eval sessions on this hub and their conversations. Continue?"
+      );
+      if (!confirmed) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    const result = await client.deleteAllEvalSessions(hubId);
+    console.log(
+      `Deleted ${result.data.deleted_sessions} session(s) and ${result.data.deleted_conversations} eval conversation(s).`
+    );
+    return;
+  }
+  if (!skipConfirm) {
+    const confirmed = await confirm(
+      "This will permanently delete this eval session and its conversations. Continue?"
+    );
+    if (!confirmed) {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  try {
+    const result = await client.deleteEvalSession(hubId, sessionId);
+    const deletedConversations = result.data?.deleted_conversations ?? 0;
+    console.log(`Deleted session ${sessionId} (${deletedConversations} eval conversation(s)).`);
+  } catch (err) {
+    if (err instanceof ApiError && err.status === 404) {
+      console.error(`Eval session not found: ${sessionId}`);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+var init_eval_session_delete = __esm({
+  "src/commands/eval-session-delete.ts"() {
+    "use strict";
+    init_auth();
+    init_repo_config();
+    init_workspace();
+    init_api_client();
+    init_utils();
+  }
+});
+
 // src/commands/eval.ts
 var eval_exports = {};
 __export(eval_exports, {
@@ -12077,6 +12313,18 @@ async function evalCommand(args2) {
       process.exit(1);
       return;
     }
+    case "session": {
+      const [sessionSub, ...sessionRest] = rest;
+      if (sessionSub === "delete") {
+        const { evalSessionDeleteCommand: evalSessionDeleteCommand2 } = await Promise.resolve().then(() => (init_eval_session_delete(), eval_session_delete_exports));
+        await evalSessionDeleteCommand2(sessionRest);
+        return;
+      }
+      console.error(`Unknown eval session subcommand: ${sessionSub ?? "(none)"}`);
+      printHelp();
+      process.exit(1);
+      return;
+    }
     case "help":
     case "--help":
     case "-h":
@@ -12100,6 +12348,9 @@ Subcommands:
                                      exchange as a scenario YAML in evals/.
   journey capture <conversation_id>  Capture a real conversation's FULL
                                      transcript as a platform-managed journey.
+  session delete <session_id>        Delete one eval session (and its
+                                     conversations). Destructive, irreversible.
+  session delete --all               Delete every eval session on the hub.
 
 Capture flags (scenario):
   --set <name>            Scenario set folder (created if missing). Default: "Default".
@@ -12110,10 +12361,16 @@ Journey capture flags:
   --name <journey_name>   Journey name. Default: derived from conversation ID.
   --instructions <text>   Default evaluator instructions for the journey's steps.
 
+Session delete flags:
+  --all                   Delete ALL sessions on the hub instead of one.
+  -y, --yes               Skip the confirmation prompt.
+
 Examples:
   wayai eval capture 11111111-2222-3333-4444-555555555555
   wayai eval capture <conv_id> --set regression-suite --name "Cancel order"
   wayai eval journey capture <conv_id> --name "Refund happy path"
+  wayai eval session delete 11111111-2222-3333-4444-555555555555
+  wayai eval session delete --all -y
 
 Authoring evals (create/update/delete) is file-driven \u2014 edit YAML in
 evals/ and run \`wayai push\`. Capture commands are for production replay only.
@@ -17373,6 +17630,7 @@ Commands:
   run-eval           Run all enabled evals and show results
   eval-results       View results from a completed eval session
   eval capture       Capture a real conversation as a scenario YAML
+  eval session delete  Delete one eval session (\`--all\` for every session on the hub)
   sync-skills        Sync skills to Anthropic/OpenAI provider connections
   sync-mcp           Re-discover an MCP connection's tools (refresh stale schemas)
   list               List organizations and hubs