voyageai-cli 1.29.0 → 1.30.0

package/src/lib/workflow.js

@@ -26,6 +26,19 @@ const INTEGRATION_TOOLS = new Set(['http']);
 
 const ALL_TOOLS = new Set([...VAI_TOOLS, ...CONTROL_FLOW_TOOLS, ...PROCESSING_TOOLS, ...INTEGRATION_TOOLS]);
 
+// ════════════════════════════════════════════════════════════════════
+// Schema Limits (Phase 1 Enhanced Validation)
+// ════════════════════════════════════════════════════════════════════
+
+const SCHEMA_LIMITS = {
+  maxSteps: 50,
+  maxInputs: 20,
+  maxTemplateDepth: 5,
+  maxNameLength: 64,
+  maxDescriptionLength: 500,
+  maxStepNameLength: 100,
+};
+
 // ════════════════════════════════════════════════════════════════════
 // Validation
 // ════════════════════════════════════════════════════════════════════
@@ -180,6 +193,74 @@ function validateWorkflow(definition) {
   return errors;
 }
 
+/**
+ * Enhanced schema validation for publishable workflows.
+ * Runs all existing validateWorkflow() checks plus additional quality gates.
+ *
+ * @param {object} definition - Parsed workflow JSON
+ * @returns {string[]} errors
+ */
+function validateSchemaEnhanced(definition) {
+  const errors = validateWorkflow(definition);
+
+  if (!definition || typeof definition !== 'object') return errors;
+
+  // Step count limit
+  if (Array.isArray(definition.steps) && definition.steps.length > SCHEMA_LIMITS.maxSteps) {
+    errors.push(`Too many steps (${definition.steps.length}/${SCHEMA_LIMITS.maxSteps})`);
+  }
+
+  // Input count limit
+  if (definition.inputs && Object.keys(definition.inputs).length > SCHEMA_LIMITS.maxInputs) {
+    errors.push(`Too many inputs (${Object.keys(definition.inputs).length}/${SCHEMA_LIMITS.maxInputs})`);
+  }
+
+  // Name length
+  if (definition.name && definition.name.length > SCHEMA_LIMITS.maxNameLength) {
+    errors.push(`Workflow name too long (${definition.name.length}/${SCHEMA_LIMITS.maxNameLength})`);
+  }
+
+  // Description required (min 10 chars) for publishable workflows
+  if (!definition.description || definition.description.length < 10) {
+    errors.push('Description must be at least 10 characters');
+  }
+
+  // Description length limit
+  if (definition.description && definition.description.length > SCHEMA_LIMITS.maxDescriptionLength) {
+    errors.push(`Description too long (${definition.description.length}/${SCHEMA_LIMITS.maxDescriptionLength})`);
+  }
+
+  // Version must be valid semver
+  if (definition.version && !/^\d+\.\d+\.\d+/.test(definition.version)) {
+    errors.push('Version must be valid semver (e.g. 1.0.0)');
+  }
+
+  // Every input should have a description
+  for (const [key, spec] of Object.entries(definition.inputs || {})) {
+    if (!spec.description) {
+      errors.push(`Input "${key}" missing description`);
+    }
+  }
+
+  // Every step should have a human-readable name
+  if (Array.isArray(definition.steps)) {
+    for (const step of definition.steps) {
+      if (!step.name) {
+        errors.push(`Step "${step.id}" missing "name" field`);
+      } else if (step.name.length > SCHEMA_LIMITS.maxStepNameLength) {
+        errors.push(`Step "${step.id}" name too long (${step.name.length}/${SCHEMA_LIMITS.maxStepNameLength})`);
+      }
+    }
+  }
+
+  // Output section should exist
+  if (!definition.output || Object.keys(definition.output).length === 0) {
+    errors.push('Workflow should define an "output" section');
+  }
+
+  return errors;
+}
+
 /**
  * Detect circular dependencies in steps using DFS.
  * @param {Array} steps
@@ -794,7 +875,9 @@ function executeChunk(inputs) {
  * @returns {Promise<{ status: number, statusText: string, headers: object, body: any, durationMs: number }>}
  */
 async function executeHttp(inputs) {
-  const { url, method = 'GET', headers = {}, body, timeout = 30000, responseType = 'json', followRedirects = false } = inputs;
+  const effectiveResponseType = inputs.responseType || (inputs.extract === 'text' ? 'text' : 'json');
+  const { url, method = 'GET', headers = {}, body, timeout = 30000, followRedirects = false } = inputs;
+  const responseType = effectiveResponseType;
 
   if (!url || typeof url !== 'string') {
     throw new Error('http: "url" input is required');
@@ -857,6 +940,12 @@ async function executeHttp(inputs) {
     parsedBody = rawBody;
   }
 
+  // Strip HTML if extract: "text"
+  if (inputs.extract === 'text' && typeof parsedBody === 'string') {
+    const { stripHtml } = require('./readers');
+    parsedBody = stripHtml(parsedBody);
+  }
+
   // Collect response headers
   const respHeaders = {};
   response.headers.forEach((value, key) => {
@@ -1119,11 +1208,40 @@ async function executeIngest(inputs, defaults) {
   const { client, collection: col } = await getMongoCollection(db, collection);
   try {
     const result = await col.insertMany(docs);
+
+    // Auto-create vector search index if it doesn't exist
+    // Note: Atlas vector search indexes take a few seconds to become ready after creation.
+    // The search step may need a brief delay on first run.
+    let indexCreated = false;
+    try {
+      const indexes = await col.listSearchIndexes().toArray();
+      const hasVectorIndex = indexes.some(idx => idx.name === 'vector_index');
+      if (!hasVectorIndex) {
+        await col.createSearchIndex({
+          name: 'vector_index',
+          type: 'vectorSearch',
+          definition: {
+            fields: [{
+              type: 'vector',
+              path: 'embedding',
+              numDimensions: embRes.data[0].embedding.length,
+              similarity: 'cosine'
+            }]
+          }
+        });
+        indexCreated = true;
+      }
+    } catch (indexErr) {
+      // Ignore errors: index may already exist, or createSearchIndex may not be
+      // available on non-Atlas deployments
+    }
+
     return {
       insertedCount: result.insertedCount,
       chunks: chunks.length,
       source,
       model: embRes.model,
+      indexCreated,
     };
   } finally {
     await client.close();
@@ -1475,7 +1593,12 @@ async function executeWorkflow(definition, opts = {}) {
       try {
         let output;
 
-        if (step.tool === 'conditional') {
+        // Mock executor injection: if _mockExecutors has a mock for this tool, use it
+        const mockExecutor = opts._mockExecutors && opts._mockExecutors[step.tool];
+        if (mockExecutor && step.tool !== 'conditional') {
+          const resolvedInputs = resolveTemplate(step.inputs || {}, context);
+          output = await mockExecutor(resolvedInputs, step, context);
+        } else if (step.tool === 'conditional') {
           // Special handling: resolve then/else but pass raw condition to evaluator
           const rawCondition = step.inputs.condition;
           const resolvedInputs = {
@@ -1738,7 +1861,9 @@ function loadWorkflow(nameOrPath) {
 module.exports = {
   // Validation
   validateWorkflow,
+  validateSchemaEnhanced,
   detectCycles,
+  SCHEMA_LIMITS,
 
   // Dependency resolution
   buildDependencyGraph,
@@ -1756,6 +1881,7 @@ module.exports = {
   executeLoop,
   executeChunk,
   executeHttp,
+  executeIngest,
   executeAggregate,
 
   // Main execution

package/src/playground/announcements.md

@@ -20,6 +20,8 @@ id: ann-voyage-4
 badge: New Model
 published: 2026-02-14
 expires: 2026-03-15
+icon: 🚀
+bg_image: /assets/announcements/circuits.jpg
 cta_label: Try It Now
 cta_action: navigate
 cta_target: /benchmark
@@ -34,6 +36,8 @@ id: ann-marketplace-workflows
 badge: New
 published: 2026-02-12
 expires: 2026-03-01
+icon: 🏪
+bg_image: /assets/announcements/green-wave.jpg
 cta_label: Explore Marketplace
 cta_action: navigate
 cta_target: /workflows
@@ -48,6 +52,9 @@ id: ann-csv-ingestion
 badge: Update
 published: 2026-02-10
 expires: 2026-04-01
+icon: 📊
+bg_image: /assets/announcements/csvingest.jpg
+bg_color: linear-gradient(135deg, #1B5E20 0%, #2E7D32 100%)
 cta_label: Learn More
 cta_action: link
 cta_target: https://docs.vaicli.com/csv-import
@@ -62,6 +69,8 @@ id: ann-workflow-store
 badge: New
 published: 2026-02-13
 expires: 2026-03-15
+icon: ⚡
+bg_image: /assets/announcements/appstore.jpg
 cta_label: Browse Store
 cta_action: navigate
 cta_target: /workflows