@covibes/zeroshot 1.0.1

package/src/task-runner.js

@@ -0,0 +1,28 @@
+/**
+ * TaskRunner - Strategy Pattern interface for executing Claude tasks
+ *
+ * Implementations must provide a `run()` method that executes a Claude task
+ * with the given context and options. Different runners can implement various
+ * execution strategies (Claude CLI, mock responses, etc).
+ */
+class TaskRunner {
+  /**
+   * Execute a Claude task with the given context and options
+   *
+   * @param {string} _context - Full prompt/context for Claude to process
+   * @param {Object} _options - Execution options
+   * @param {string} _options.agentId - Identifier for this agent/task
+   * @param {string} _options.model - Model to use (e.g., 'opus', 'sonnet', 'haiku')
+   * @param {string} [_options.outputFormat] - Output format ('text', 'json', 'stream-json')
+   * @param {Object} [_options.jsonSchema] - JSON schema for structured output validation
+   * @param {string} [_options.cwd] - Working directory for task execution
+   * @param {boolean} [_options.isolation] - Whether to run in isolated container
+   *
+   * @returns {Promise<{success: boolean, output: string, error: string|null, taskId?: string}>} Result object with success status, output, error message, and optional taskId
+   */
+  run(_context, _options) {
+    throw new Error('TaskRunner.run() not implemented');
+  }
+}
+
+module.exports = TaskRunner;

package/src/template-resolver.js

@@ -0,0 +1,347 @@
+/**
+ * TemplateResolver - Resolves parameterized cluster templates
+ *
+ * Takes a base template with {{param}} placeholders and resolves them
+ * with provided parameter values. Pure data transformation, no magic.
+ *
+ * Resolution rules:
+ * 1. Load base template JSON
+ * 2. Deep clone
+ * 3. Walk all values, replace {{param}} with params[param]
+ * 4. Handle conditional agents via "condition" field
+ * 5. Fail hard if any {{param}} remains unresolved
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class TemplateResolver {
+  /**
+   * @param {string} templatesDir
+   */
+  constructor(templatesDir) {
+    this.templatesDir = templatesDir;
+    this.baseTemplatesDir = path.join(templatesDir, 'base-templates');
+  }
+
+  /**
+   * Resolve a template with parameters
+   * @param {string} baseName - Name of base template (without .json)
+   * @param {Object} params - Parameter values to substitute
+   * @returns {Object} Resolved cluster config
+   */
+  resolve(baseName, params) {
+    // Load base template
+    const templatePath = path.join(this.baseTemplatesDir, `${baseName}.json`);
+    if (!fs.existsSync(templatePath)) {
+      throw new Error(`Base template not found: ${baseName} (looked in ${templatePath})`);
+    }
+
+    const templateJson = fs.readFileSync(templatePath, 'utf8');
+    const template = JSON.parse(templateJson);
+
+    // Validate required params
+    this._validateParams(template, params);
+
+    // Deep clone and resolve
+    const resolved = this._resolveObject(JSON.parse(JSON.stringify(template)), params);
+
+    // Filter out conditional agents that don't meet their condition
+    if (resolved.agents) {
+      resolved.agents = resolved.agents.filter((/** @type {any} */ agent) => {
+        if (!agent.condition) return true;
+        const conditionMet = this._evaluateCondition(agent.condition, params);
+        delete agent.condition; // Remove condition field from final output
+        return conditionMet;
+      });
+    }
+
+    // Verify no unresolved placeholders remain
+    this._verifyResolved(resolved);
+
+    // Remove params schema from output (it's metadata, not config)
+    delete resolved.params;
+
+    return resolved;
+  }
+
+  /**
+   * Validate that required params are provided
+   * @private
+   * @param {any} template
+   * @param {any} params
+   */
+  _validateParams(template, params) {
+    if (!template.params) return;
+
+    const missing = [];
+    for (const [name, schema] of Object.entries(template.params)) {
+      if (params[name] === undefined && schema.default === undefined) {
+        missing.push(name);
+      }
+    }
+
+    if (missing.length > 0) {
+      throw new Error(`Missing required params: ${missing.join(', ')}`);
+    }
+  }
+
+  /**
+   * Recursively resolve placeholders in an object
+   * @private
+   * @param {any} obj
+   * @param {any} params
+   * @returns {any}
+   */
+  _resolveObject(obj, params) {
+    if (obj === null || obj === undefined) {
+      return obj;
+    }
+
+    if (typeof obj === 'string') {
+      return this._resolveString(obj, params);
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this._resolveObject(item, params));
+    }
+
+    if (typeof obj === 'object') {
+      /** @type {any} */
+      const result = {};
+      for (const [key, value] of Object.entries(obj)) {
+        result[key] = this._resolveObject(value, params);
+      }
+      return result;
+    }
+
+    return obj;
+  }
+
+  /**
+   * Resolve placeholders in a string
+   * Supports: {{param}} and {{#if condition}}...{{/if}}
+   * @private
+   * @param {any} str
+   * @param {any} params
+   * @returns {any}
+   */
+  _resolveString(str, params) {
+    // Handle simple {{param}} substitutions
+    let result = str.replace(
+      /\{\{(\w+)\}\}/g,
+      (/** @type {any} */ _match, /** @type {any} */ paramName) => {
+        if (params[paramName] !== undefined) {
+          return params[paramName];
+        }
+        // Return match unchanged if param not found (will be caught by verify)
+        return _match;
+      }
+    );
+
+    // Handle {{#if condition}}...{{/if}} blocks
+    result = result.replace(
+      /\{\{#if\s+([^}]+)\}\}([\s\S]*?)\{\{\/if\}\}/g,
+      (/** @type {any} */ _match, /** @type {any} */ condition, /** @type {any} */ content) => {
+        const conditionMet = this._evaluateCondition(condition, params);
+        return conditionMet ? content : '';
+      }
+    );
+
+    // Clean up multiple newlines from removed conditionals
+    result = result.replace(/\n{3,}/g, '\n\n');
+
+    return result;
+  }
+
+  /**
+   * Evaluate a simple condition expression
+   * Supports: param == 'value', param != 'value', {{param}} >= N
+   * @private
+   * @param {any} condition
+   * @param {any} params
+   * @returns {boolean}
+   */
+  _evaluateCondition(condition, params) {
+    // Replace {{param}} with actual values first
+    let expr = condition.trim();
+
+    // Replace {{param}} placeholders
+    expr = expr.replace(
+      /\{\{(\w+)\}\}/g,
+      (/** @type {any} */ _match, /** @type {any} */ paramName) => {
+        const value = params[paramName];
+        if (value === undefined) return 'undefined';
+        if (typeof value === 'string') return `"${value}"`;
+        return String(value);
+      }
+    );
+
+    // Replace bare param names
+    for (const [name, value] of Object.entries(params)) {
+      const regex = new RegExp(`\\b${name}\\b`, 'g');
+      if (typeof value === 'string') {
+        expr = expr.replace(regex, `"${value}"`);
+      } else {
+        expr = expr.replace(regex, String(value));
+      }
+    }
+
+    try {
+      // Parse and evaluate simple comparison expressions without eval
+      return this._evaluateSimpleExpression(expr);
+    } catch {
+      console.error(`Failed to evaluate condition: ${condition} (resolved: ${expr})`);
+      return false;
+    }
+  }
+
+  /**
+   * Evaluate simple comparison expressions without eval
+   * Supports: ==, !=, <, >, <=, >=, &&, ||
+   * @private
+   * @param {string} expr
+   * @returns {boolean}
+   */
+  _evaluateSimpleExpression(expr) {
+    // Handle logical operators (&&, ||) by splitting and recursing
+    if (expr.includes('||')) {
+      const parts = expr.split('||');
+      return parts.some((part) => this._evaluateSimpleExpression(part.trim()));
+    }
+    if (expr.includes('&&')) {
+      const parts = expr.split('&&');
+      return parts.every((part) => this._evaluateSimpleExpression(part.trim()));
+    }
+
+    // Handle comparison operators
+    const comparisonOps = ['==', '!=', '<=', '>=', '<', '>'];
+    for (const op of comparisonOps) {
+      if (expr.includes(op)) {
+        const [left, right] = expr.split(op).map((s) => s.trim());
+        const leftVal = this._parseValue(left);
+        const rightVal = this._parseValue(right);
+
+        switch (op) {
+          case '==':
+            return leftVal === rightVal;
+          case '!=':
+            return leftVal !== rightVal;
+          case '<':
+            return leftVal < rightVal;
+          case '>':
+            return leftVal > rightVal;
+          case '<=':
+            return leftVal <= rightVal;
+          case '>=':
+            return leftVal >= rightVal;
+        }
+      }
+    }
+
+    // If no operator found, treat as boolean literal or truthy value
+    return this._parseValue(expr) ? true : false;
+  }
+
+  /**
+   * Parse a value from string (number, boolean, string literal)
+   * @private
+   * @param {string} str
+   * @returns {any}
+   */
+  _parseValue(str) {
+    str = str.trim();
+
+    // String literals (single or double quotes)
+    if ((str.startsWith('"') && str.endsWith('"')) || (str.startsWith("'") && str.endsWith("'"))) {
+      return str.slice(1, -1);
+    }
+
+    // Boolean literals
+    if (str === 'true') return true;
+    if (str === 'false') return false;
+    if (str === 'undefined' || str === 'null') return undefined;
+
+    // Numbers
+    if (/^-?\d+(\.\d+)?$/.test(str)) {
+      return parseFloat(str);
+    }
+
+    // Return as-is for other cases
+    return str;
+  }
+
+  /**
+   * Verify no unresolved placeholders remain
+   * @private
+   * @param {any} obj
+   */
+  _verifyResolved(obj) {
+    const unresolved = this._findUnresolved(obj);
+    if (unresolved.length > 0) {
+      throw new Error(`Unresolved template placeholders: ${unresolved.join(', ')}`);
+    }
+  }
+
+  /**
+   * Find all unresolved {{param}} placeholders
+   * @private
+   * @param {any} obj
+   * @param {string} pathPrefix
+   * @returns {string[]}
+   */
+  _findUnresolved(obj, pathPrefix = '') {
+    const unresolved = [];
+
+    if (typeof obj === 'string') {
+      const matches = obj.match(/\{\{(\w+)\}\}/g);
+      if (matches) {
+        unresolved.push(...matches.map((m) => `${pathPrefix}: ${m}`));
+      }
+    } else if (Array.isArray(obj)) {
+      obj.forEach((item, i) => {
+        unresolved.push(...this._findUnresolved(item, `${pathPrefix}[${i}]`));
+      });
+    } else if (obj && typeof obj === 'object') {
+      for (const [key, value] of Object.entries(obj)) {
+        unresolved.push(...this._findUnresolved(value, `${pathPrefix}.${key}`));
+      }
+    }
+
+    return unresolved;
+  }
+
+  /**
+   * List available base templates
+   * @returns {string[]}
+   */
+  listTemplates() {
+    if (!fs.existsSync(this.baseTemplatesDir)) {
+      return [];
+    }
+    return fs
+      .readdirSync(this.baseTemplatesDir)
+      .filter((f) => f.endsWith('.json'))
+      .map((f) => f.replace('.json', ''));
+  }
+
+  /**
+   * Get template metadata (name, description, params)
+   * @param {any} baseName
+   * @returns {any}
+   */
+  getTemplateInfo(baseName) {
+    const templatePath = path.join(this.baseTemplatesDir, `${baseName}.json`);
+    if (!fs.existsSync(templatePath)) {
+      return null;
+    }
+    const template = JSON.parse(fs.readFileSync(templatePath, 'utf8'));
+    return {
+      name: template.name,
+      description: template.description,
+      params: template.params || {},
+    };
+  }
+}
+
+module.exports = TemplateResolver;

package/src/tui/CHANGES.txt

@@ -0,0 +1,133 @@
+TUI Performance & UX Improvements
+==================================
+
+## New Features
+
+### 4. Two-Level Navigation 🎯
+**Feature:** Completely separate layouts for overview vs detail
+**Implementation:**
+- Overview mode: ONLY shows clusters table + stats (agents/logs hidden)
+- Detail mode: ONLY shows agents + logs (clusters/stats hidden)
+- Enter key to drill into detail, Escape to return
+- Help text updates dynamically based on current view
+- Widgets physically shown/hidden (not just empty data)
+
+## Fixed Issues
+
+### 1. Slow Startup ⚡
+**Problem:** TUI took 5-10 seconds to start due to synchronous cluster loading
+**Solution:**
+- Deferred initial polls by 50-100ms to let UI render first
+- Shows "Loading..." message immediately
+- Lazy-loads cluster ledgers only when needed
+- Startup now instant (<100ms)
+
+### 2. Default Filter 🎯
+**Problem:** Showed all clusters (including stopped) by default
+**Solution:**
+- Changed default filter from "all" to "running"
+- User only sees active clusters
+- Can still use `--filter all` to see everything
+
+### 3. Cluster Selection 📍
+**Problem:** Agents and logs weren't properly filtered by selected cluster
+**Solution:**
+- Renderer now tracks selectedClusterId
+- Agents shown are for the selected cluster only
+- Logs filtered to show only messages from selected cluster
+- Messages cleared when switching between clusters
+- Navigate with ↑↓ or jk keys
+
+## Performance Improvements
+
+**Before:**
+- Startup: 5-10 seconds
+- All clusters loaded synchronously
+- All ledgers opened on startup
+- Unfiltered logs from all clusters
+
+**After:**
+- Startup: <100ms instant
+- Clusters loaded async after UI renders
+- Ledgers lazy-loaded when needed
+- Logs filtered to selected cluster only
+
+## Usage
+
+```bash
+# Shows only running clusters (default)
+vibe watch
+
+# Show all clusters (including stopped)
+vibe watch --filter all
+
+# Show only stopped clusters
+vibe watch --filter stopped
+```
+
+## Keyboard Navigation
+
+### Two-Level Navigation
+- **Overview Mode** (default): ONLY clusters + stats visible
+  - Large clusters table (16 rows) with system stats sidebar
+  - No agents or logs shown
+  - `↑` / `k` - Select previous cluster
+  - `↓` / `j` - Select next cluster
+  - `Enter` - Switch to detail view for selected cluster
+
+- **Detail Mode**: ONLY agents + logs visible
+  - Full-width agents table (9 rows)
+  - Full-width live logs (9 rows)
+  - Clusters table and stats hidden
+  - `Escape` - Switch back to overview mode
+
+Agents and logs auto-update in real-time when in detail view
+
+## Technical Changes
+
+### data-poller.js
+- Line 45-53: Deferred initial polls with setTimeout
+- Line 196-208: Added lazy loading for cluster ledgers
+- Line 201-203: Check if ledger DB exists before loading
+
+### index.js (TUI)
+- Line 21: Changed default filter to 'running'
+- Line 34-36: Added viewMode state ('overview' or 'detail') and detailClusterId
+- Line 48-49: Show "Loading..." message on startup
+- Line 107-119: Conditional rendering - agents only shown in detail view
+- Line 130-137: Conditional rendering for resource_stats case
+
+### keybindings.js
+- Line 14-37: Enter key handler to switch to detail view
+- Line 39-59: Escape key handler to switch to overview view
+- Line 22, 45: Clear messages when switching views
+- Line 29-34: Detail mode - hide clusters/stats, show agents/logs
+- Line 52-57: Overview mode - show clusters/stats, hide agents/logs
+- Line 24-27, 47-50: Update help text based on view mode
+
+### layout.js
+- Line 36: Expanded clusters table to 16 rows (from 6)
+- Line 66: Expanded stats box to 16 rows (from 6)
+- Line 85: Repositioned agent table to row 0, 9 rows, full width
+- Line 119: Repositioned logs to row 9, 9 rows, full width
+- Line 165-167: Initially hide agent table and logs (overview mode default)
+
+### cli/index.js
+- Line 1161: Changed default filter to 'running' in CLI option
+
+## Testing
+
+Run integration tests:
+```bash
+node tests/tui-integration.test.js    # Basic TUI startup and data loading
+node tests/tui-navigation-test.js     # Two-level navigation functionality
+```
+
+Expected: All tests pass, TUI starts instantly
+
+## Notes
+
+- Messages are cluster-scoped (only show for selected cluster)
+- Selection persists across refreshes
+- Empty clusters (no agents) still show in list
+- Logs clear when switching clusters to avoid confusion