claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/validators/swarm-init-validator.js

@@ -0,0 +1,259 @@
+/**
+ * Swarm Initialization Validator
+ *
+ * Validates that swarm initialization is performed before spawning multiple agents.
+ * Ensures proper coordination and prevents inconsistent implementations across agents.
+ *
+ * @module validators/swarm-init-validator
+ */ import { Logger } from "../core/logger.js";
+const DEFAULT_CONFIG = {
+    requireSwarmForMultiAgent: true,
+    minAgentsRequiringSwarm: 2,
+    meshTopologyMaxAgents: 7,
+    hierarchicalTopologyMinAgents: 8
+};
+/**
+ * Validates swarm initialization before agent spawning
+ *
+ * @param agentCount - Number of agents to spawn
+ * @param swarmStatus - Current swarm status (optional, will check environment if not provided)
+ * @param config - Validator configuration
+ * @returns Validation result with error messages and suggestions
+ *
+ * @example
+ * ```typescript
+ * const result = await validateSwarmInit(3);
+ * if (!result.valid) {
+ *   console.error(result.error);
+ *   console.log(result.suggestion);
+ * }
+ * ```
+ */ export async function validateSwarmInit(agentCount, swarmStatus, config = {}) {
+    const logger = new Logger('SwarmInitValidator');
+    const cfg = {
+        ...DEFAULT_CONFIG,
+        ...config
+    };
+    // Single agent spawning doesn't require swarm
+    if (agentCount < cfg.minAgentsRequiringSwarm) {
+        return {
+            valid: true
+        };
+    }
+    // Check if swarm is required for this agent count
+    if (!cfg.requireSwarmForMultiAgent) {
+        logger.warn('Swarm validation is disabled in configuration');
+        return {
+            valid: true
+        };
+    }
+    // Get swarm status
+    const status = swarmStatus || await getSwarmStatus();
+    // Validate swarm is initialized
+    if (!status.initialized) {
+        const topology = agentCount <= cfg.meshTopologyMaxAgents ? 'mesh' : 'hierarchical';
+        return {
+            valid: false,
+            error: createErrorMessage(agentCount),
+            suggestion: createSuggestion(agentCount, topology),
+            topology,
+            maxAgents: agentCount
+        };
+    }
+    // Validate topology matches agent count
+    const topologyValidation = validateTopology(agentCount, status, cfg);
+    if (!topologyValidation.valid) {
+        return topologyValidation;
+    }
+    // Validate max agents capacity
+    if (status.maxAgents && agentCount > status.maxAgents) {
+        return {
+            valid: false,
+            error: `Cannot spawn ${agentCount} agents. Swarm configured for maximum ${status.maxAgents} agents.`,
+            suggestion: `Reinitialize swarm with increased maxAgents:\n  npx claude-flow-novice swarm init --topology ${status.topology} --max-agents ${agentCount}`
+        };
+    }
+    logger.info(`Swarm validation passed for ${agentCount} agents`);
+    return {
+        valid: true
+    };
+}
+/**
+ * Validates that topology matches agent count requirements
+ */ function validateTopology(agentCount, status, config) {
+    const expectedTopology = agentCount <= config.meshTopologyMaxAgents ? 'mesh' : 'hierarchical';
+    if (status.topology && status.topology !== expectedTopology) {
+        return {
+            valid: false,
+            error: `Topology mismatch: ${agentCount} agents require '${expectedTopology}' topology, but swarm is using '${status.topology}'.`,
+            suggestion: `Reinitialize swarm with correct topology:\n  npx claude-flow-novice swarm init --topology ${expectedTopology} --max-agents ${agentCount}`,
+            topology: expectedTopology,
+            maxAgents: agentCount
+        };
+    }
+    return {
+        valid: true
+    };
+}
+/**
+ * Creates error message for missing swarm initialization
+ */ function createErrorMessage(agentCount) {
+    return `
+❌ SWARM INITIALIZATION REQUIRED
+
+You are attempting to spawn ${agentCount} agents without initializing swarm.
+
+Without swarm coordination:
+  • Agents work independently with no shared context
+  • Results may be inconsistent (e.g., 3 different JWT secret solutions)
+  • No consensus validation or Byzantine fault tolerance
+  • Memory coordination is disabled
+
+This violates the mandatory coordination requirements in CLAUDE.md.
+`.trim();
+}
+/**
+ * Creates suggestion message with fix command
+ */ function createSuggestion(agentCount, topology) {
+    return `
+Fix:
+1. Initialize swarm first:
+   npx claude-flow-novice swarm init --topology ${topology} --max-agents ${agentCount}
+
+2. Then spawn agents:
+   [Your agent spawning command]
+
+Topology Selection:
+  • mesh: 2-7 agents (peer-to-peer coordination)
+  • hierarchical: 8+ agents (coordinator-led structure)
+
+See CLAUDE.md section "Swarm Initialization" for coordination requirements.
+`.trim();
+}
+/**
+ * Gets current swarm status from environment or MCP server
+ */ async function getSwarmStatus() {
+    const logger = new Logger('SwarmInitValidator');
+    // Check environment variables
+    const swarmId = process.env['CLAUDE_SWARM_ID'];
+    if (!swarmId) {
+        return {
+            initialized: false
+        };
+    }
+    // Try to get status from MCP server via swarm coordinator
+    try {
+        // Import dynamically to avoid circular dependencies
+        const { getSwarmCoordinator } = await import("../coordination/swarm-coordinator-factory.js").catch(()=>({
+                getSwarmCoordinator: null
+            }));
+        if (getSwarmCoordinator) {
+            const coordinator = getSwarmCoordinator();
+            if (coordinator) {
+                const status = coordinator.getSwarmStatus();
+                return {
+                    initialized: true,
+                    swarmId,
+                    activeAgents: status.agents.total,
+                    maxAgents: status.agents.total
+                };
+            }
+        }
+    } catch (error) {
+        logger.debug('Could not get swarm status from coordinator', error);
+    }
+    // If we have a swarm ID but can't get details, assume initialized
+    return {
+        initialized: true,
+        swarmId
+    };
+}
+/**
+ * Validates swarm initialization and throws error if invalid
+ *
+ * This is a convenience wrapper for validateSwarmInit that throws on validation failure.
+ * Use this in CLI commands where you want to halt execution on validation errors.
+ *
+ * @param agentCount - Number of agents to spawn
+ * @param swarmStatus - Current swarm status (optional)
+ * @param config - Validator configuration
+ * @throws Error if validation fails
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await requireSwarmInit(3);
+ *   // Proceed with spawning agents
+ * } catch (error) {
+ *   console.error(error.message);
+ *   process.exit(1);
+ * }
+ * ```
+ */ export async function requireSwarmInit(agentCount, swarmStatus, config) {
+    const result = await validateSwarmInit(agentCount, swarmStatus, config);
+    if (!result.valid) {
+        const errorMessage = `${result.error}\n\n${result.suggestion}`;
+        throw new Error(errorMessage);
+    }
+}
+/**
+ * Gets recommended topology for agent count
+ *
+ * @param agentCount - Number of agents
+ * @param config - Validator configuration
+ * @returns Recommended topology
+ */ export function getRecommendedTopology(agentCount, config = {}) {
+    const cfg = {
+        ...DEFAULT_CONFIG,
+        ...config
+    };
+    return agentCount <= cfg.meshTopologyMaxAgents ? 'mesh' : 'hierarchical';
+}
+/**
+ * Checks if swarm initialization is required for agent count
+ *
+ * @param agentCount - Number of agents
+ * @param config - Validator configuration
+ * @returns true if swarm initialization is required
+ */ export function isSwarmRequired(agentCount, config = {}) {
+    const cfg = {
+        ...DEFAULT_CONFIG,
+        ...config
+    };
+    return cfg.requireSwarmForMultiAgent && agentCount >= cfg.minAgentsRequiringSwarm;
+}
+/**
+ * Validates swarm configuration before initialization
+ *
+ * @param topology - Requested topology
+ * @param maxAgents - Maximum number of agents
+ * @param config - Validator configuration
+ * @returns Validation result
+ */ export function validateSwarmConfig(topology, maxAgents, config = {}) {
+    const cfg = {
+        ...DEFAULT_CONFIG,
+        ...config
+    };
+    // Validate topology matches max agents
+    const recommendedTopology = getRecommendedTopology(maxAgents, config);
+    if (topology !== recommendedTopology) {
+        return {
+            valid: false,
+            error: `Topology '${topology}' is not optimal for ${maxAgents} agents.`,
+            suggestion: `Recommended topology: '${recommendedTopology}'\n  • mesh: 2-${cfg.meshTopologyMaxAgents} agents\n  • hierarchical: ${cfg.hierarchicalTopologyMinAgents}+ agents`,
+            topology: recommendedTopology,
+            maxAgents
+        };
+    }
+    return {
+        valid: true
+    };
+}
+/**
+ * Factory for creating a swarm coordinator factory module
+ * This is a placeholder that will be replaced with actual implementation
+ */ export const SwarmCoordinatorFactory = {
+    getSwarmCoordinator () {
+        return null;
+    }
+};

package/dist/src/validators/todowrite-batching-validator.js

@@ -0,0 +1,215 @@
+/**
+ * TodoWrite Batching Validator
+ *
+ * Detects and warns about TodoWrite anti-patterns where multiple small calls
+ * are made instead of a single batched call with 5-10+ items.
+ *
+ * Anti-pattern example (bad):
+ *   TodoWrite([{...}])  // Call 1: 1 item
+ *   TodoWrite([{...}])  // Call 2: 1 item
+ *   TodoWrite([{...}])  // Call 3: 1 item
+ *
+ * Best practice (good):
+ *   TodoWrite([{...}, {...}, {...}, {...}, {...}])  // Single call: 5+ items
+ *
+ * @module validators/todowrite-batching-validator
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Validates TodoWrite call patterns to ensure proper batching behavior
+ *
+ * Tracks call frequency within a sliding time window and detects anti-patterns
+ * where multiple small calls are made instead of a single batched call.
+ *
+ * @example
+ * ```typescript
+ * const validator = new TodoWriteValidator({ strictMode: false });
+ *
+ * // Good: Single batched call
+ * validator.validateBatching([
+ *   { content: "Task 1", status: "pending", activeForm: "Doing task 1" },
+ *   { content: "Task 2", status: "pending", activeForm: "Doing task 2" },
+ *   { content: "Task 3", status: "pending", activeForm: "Doing task 3" },
+ *   { content: "Task 4", status: "pending", activeForm: "Doing task 4" },
+ *   { content: "Task 5", status: "pending", activeForm: "Doing task 5" }
+ * ]); // ✅ No warning
+ *
+ * // Bad: Multiple small calls
+ * validator.validateBatching([{ content: "Task 1", status: "pending", activeForm: "Doing task 1" }]);
+ * validator.validateBatching([{ content: "Task 2", status: "pending", activeForm: "Doing task 2" }]);
+ * // ⚠️ Warning: Batching anti-pattern detected
+ * ```
+ */ export class TodoWriteValidator {
+    /**
+   * Validates a TodoWrite call and checks for batching anti-patterns
+   *
+   * @param todos - Array of todos being written
+   * @throws Error if strictMode is enabled and anti-pattern detected
+   * @returns ValidationResult with detailed analysis
+   */ validateBatching(todos) {
+        const now = Date.now();
+        this.totalCallCount++;
+        // Log this call
+        this.callLog.push({
+            timestamp: now,
+            count: todos.length,
+            callIndex: this.totalCallCount
+        });
+        // Clean old entries outside time window
+        this.callLog = this.callLog.filter((entry)=>now - entry.timestamp < this.config.timeWindowMs);
+        // Calculate statistics
+        const totalItems = this.callLog.reduce((sum, entry)=>sum + entry.count, 0);
+        const averageItemsPerCall = totalItems / this.callLog.length;
+        const warnings = [];
+        const recommendations = [];
+        let isValid = true;
+        // Check for anti-pattern: too many calls in time window
+        if (this.callLog.length >= this.config.callThreshold) {
+            isValid = false;
+            const warningMessage = this.buildWarningMessage(totalItems, averageItemsPerCall);
+            warnings.push(warningMessage);
+            // Generate specific recommendations
+            recommendations.push(`Batch ALL todos in SINGLE TodoWrite call with ${this.config.minRecommendedItems}+ items`);
+            recommendations.push(`See CLAUDE.md: "TodoWrite batching requirement" and "1 MESSAGE = ALL RELATED OPERATIONS"`);
+            recommendations.push(`Example: TodoWrite([todo1, todo2, todo3, todo4, todo5]) instead of multiple calls`);
+            if (this.config.verbose) {
+                console.log("\n📊 TodoWrite Call Statistics:");
+                console.log(`   Total calls in window: ${this.callLog.length}`);
+                console.log(`   Total items: ${totalItems}`);
+                console.log(`   Average items per call: ${averageItemsPerCall.toFixed(2)}`);
+                console.log(`   Time window: ${this.config.timeWindowMs / 1000}s`);
+            }
+            // In strict mode, throw error
+            if (this.config.strictMode) {
+                throw new Error(`TodoWrite Batching Violation: ${warningMessage}\n\n` + `Recommendations:\n${recommendations.map((r)=>`  - ${r}`).join("\n")}`);
+            }
+            // Otherwise, log warning
+            console.warn(warningMessage);
+        }
+        // Additional check: warn if single call has too few items (informational only)
+        if (todos.length < this.config.minRecommendedItems && this.callLog.length === 1) {
+            recommendations.push(`Consider adding more todos to this batch (current: ${todos.length}, recommended: ${this.config.minRecommendedItems}+)`);
+        }
+        return {
+            isValid,
+            callCount: this.callLog.length,
+            totalItems,
+            averageItemsPerCall,
+            warnings,
+            recommendations
+        };
+    }
+    /**
+   * Builds a detailed warning message for batching anti-patterns
+   * @private
+   */ buildWarningMessage(totalItems, averageItemsPerCall) {
+        const timeWindowMinutes = this.config.timeWindowMs / 60000;
+        return `
+⚠️ TODOWRITE BATCHING ANTI-PATTERN DETECTED
+
+You have made ${this.callLog.length} TodoWrite calls in the last ${timeWindowMinutes} minutes.
+
+Best Practice: Batch ALL todos in SINGLE TodoWrite call with ${this.config.minRecommendedItems}-10+ items.
+
+Current calls (within ${timeWindowMinutes}min window):
+${this.callLog.map((entry, i)=>`  ${i + 1}. Call #${entry.callIndex}: ${entry.count} item${entry.count !== 1 ? "s" : ""} (${this.formatTimestamp(entry.timestamp)})`).join("\n")}
+
+Statistics:
+  - Total calls: ${this.callLog.length}
+  - Total items: ${totalItems}
+  - Average items per call: ${averageItemsPerCall.toFixed(2)}
+  - Recommended: 1 call with ${this.config.minRecommendedItems}+ items
+
+Impact:
+  - Multiple calls waste API resources
+  - Harder to track task relationships
+  - Violates "1 MESSAGE = ALL RELATED OPERATIONS" principle
+
+See CLAUDE.md: "TodoWrite batching requirement"
+    `.trim();
+    }
+    /**
+   * Formats timestamp for display in warning messages
+   * @private
+   */ formatTimestamp(timestamp) {
+        const secondsAgo = Math.floor((Date.now() - timestamp) / 1000);
+        if (secondsAgo < 60) return `${secondsAgo}s ago`;
+        const minutesAgo = Math.floor(secondsAgo / 60);
+        return `${minutesAgo}m ago`;
+    }
+    /**
+   * Gets current validation statistics
+   */ getStatistics() {
+        return {
+            totalCalls: this.totalCallCount,
+            callsInWindow: this.callLog.length,
+            timeWindowMs: this.config.timeWindowMs,
+            threshold: this.config.callThreshold
+        };
+    }
+    /**
+   * Resets the validator state (useful for testing)
+   */ reset() {
+        this.callLog = [];
+        this.totalCallCount = 0;
+    }
+    /**
+   * Updates validator configuration
+   */ updateConfig(config) {
+        this.config = {
+            ...this.config,
+            ...config
+        };
+    }
+    /**
+   * Checks if validation is currently passing (no anti-patterns detected)
+   */ isCurrentlyValid() {
+        return this.callLog.length < this.config.callThreshold;
+    }
+    constructor(config = {}){
+        _define_property(this, "callLog", []);
+        _define_property(this, "totalCallCount", 0);
+        _define_property(this, "config", void 0);
+        this.config = {
+            timeWindowMs: config.timeWindowMs ?? 300000,
+            callThreshold: config.callThreshold ?? 2,
+            strictMode: config.strictMode ?? false,
+            minRecommendedItems: config.minRecommendedItems ?? 5,
+            verbose: config.verbose ?? false
+        };
+    }
+}
+/**
+ * Global singleton instance for use across the application
+ */ let globalValidator = null;
+/**
+ * Gets the global TodoWrite validator instance
+ * Creates one if it doesn't exist
+ */ export function getGlobalValidator(config) {
+    if (!globalValidator) {
+        globalValidator = new TodoWriteValidator(config);
+    } else if (config) {
+        globalValidator.updateConfig(config);
+    }
+    return globalValidator;
+}
+/**
+ * Resets the global validator instance
+ * Useful for testing and cleanup
+ */ export function resetGlobalValidator() {
+    if (globalValidator) {
+        globalValidator.reset();
+    }
+    globalValidator = null;
+}

package/dist/src/validators/todowrite-integration.js

@@ -0,0 +1,187 @@
+/**
+ * TodoWrite Validator Integration
+ *
+ * Provides CLI flag support and tool integration for the TodoWrite batching validator.
+ * Can be enabled via --validate-batching flag or VALIDATE_TODOWRITE_BATCHING env var.
+ *
+ * @module validators/todowrite-integration
+ */ import { getGlobalValidator } from "./todowrite-batching-validator";
+/**
+ * Environment variables for controlling validation
+ */ const ENV_VALIDATE_BATCHING = "VALIDATE_TODOWRITE_BATCHING";
+const ENV_STRICT_MODE = "TODOWRITE_STRICT_MODE";
+const ENV_VERBOSE = "TODOWRITE_VERBOSE";
+/**
+ * Checks if validation is enabled via environment or config
+ */ export function isValidationEnabled(config) {
+    // Check environment variable first
+    if (process.env[ENV_VALIDATE_BATCHING] === "true") {
+        return true;
+    }
+    // Check config
+    return config?.enabled ?? false;
+}
+/**
+ * Gets integration config from environment and explicit config
+ */ export function getIntegrationConfig(explicitConfig) {
+    return {
+        enabled: isValidationEnabled(explicitConfig),
+        strictMode: process.env[ENV_STRICT_MODE] === "true" || explicitConfig?.strictMode,
+        verbose: process.env[ENV_VERBOSE] === "true" || explicitConfig?.verbose,
+        timeWindowMs: explicitConfig?.timeWindowMs,
+        callThreshold: explicitConfig?.callThreshold,
+        minRecommendedItems: explicitConfig?.minRecommendedItems
+    };
+}
+/**
+ * Validates a TodoWrite call with integrated configuration
+ *
+ * @param todos - Array of todos being written
+ * @param config - Optional configuration override
+ * @returns Validation result if enabled, null if disabled
+ */ export function validateTodoWrite(todos, config) {
+    const integrationConfig = getIntegrationConfig(config);
+    // Skip validation if not enabled
+    if (!integrationConfig.enabled) {
+        return null;
+    }
+    // Get global validator and update config
+    const validator = getGlobalValidator({
+        strictMode: integrationConfig.strictMode,
+        verbose: integrationConfig.verbose,
+        timeWindowMs: integrationConfig.timeWindowMs,
+        callThreshold: integrationConfig.callThreshold,
+        minRecommendedItems: integrationConfig.minRecommendedItems
+    });
+    // Validate and return result
+    return validator.validateBatching(todos);
+}
+/**
+ * CLI argument parser for validation flags
+ */ export function parseValidationFlags(args) {
+    const config = {
+        enabled: false,
+        strictMode: false,
+        verbose: false
+    };
+    for(let i = 0; i < args.length; i++){
+        const arg = args[i];
+        switch(arg){
+            case "--validate-batching":
+                config.enabled = true;
+                break;
+            case "--strict":
+            case "--strict-mode":
+                config.strictMode = true;
+                break;
+            case "--verbose":
+            case "-v":
+                config.verbose = true;
+                break;
+            case "--time-window":
+                config.timeWindowMs = parseInt(args[++i], 10);
+                break;
+            case "--threshold":
+                config.callThreshold = parseInt(args[++i], 10);
+                break;
+            case "--min-items":
+                config.minRecommendedItems = parseInt(args[++i], 10);
+                break;
+        }
+    }
+    return config;
+}
+/**
+ * Helper to display usage information
+ */ export function displayValidationHelp() {
+    console.log(`
+TodoWrite Batching Validator - Usage
+
+Detects anti-patterns where multiple small TodoWrite calls are made
+instead of a single batched call with 5-10+ items.
+
+CLI Flags:
+  --validate-batching         Enable TodoWrite batching validation
+  --strict, --strict-mode     Throw error on anti-pattern (default: warn)
+  --verbose, -v               Show detailed statistics
+  --time-window <ms>          Time window for detection (default: 300000 = 5min)
+  --threshold <count>         Number of calls before warning (default: 2)
+  --min-items <count>         Minimum recommended items (default: 5)
+
+Environment Variables:
+  VALIDATE_TODOWRITE_BATCHING=true    Enable validation globally
+  TODOWRITE_STRICT_MODE=true          Enable strict mode globally
+  TODOWRITE_VERBOSE=true              Enable verbose logging globally
+
+Examples:
+  # Enable validation with defaults
+  npx claude-flow-novice task --validate-batching
+
+  # Enable strict mode (throw error on anti-pattern)
+  npx claude-flow-novice task --validate-batching --strict
+
+  # Custom thresholds
+  npx claude-flow-novice task --validate-batching --threshold 3 --time-window 600000
+
+  # Via environment
+  export VALIDATE_TODOWRITE_BATCHING=true
+  npx claude-flow-novice task
+
+Best Practice:
+  Always batch ALL todos in SINGLE TodoWrite call with 5-10+ items.
+  See CLAUDE.md: "TodoWrite batching requirement"
+  `.trim());
+}
+/**
+ * Example integration with TodoWrite tool
+ * This function wraps the actual TodoWrite implementation
+ */ export function todoWriteWithValidation(todos, config) {
+    // Validate first if enabled
+    const validationResult = validateTodoWrite(todos, config);
+    if (validationResult && !validationResult.isValid) {
+        console.warn("\n⚠️ TodoWrite Batching Issue Detected\n");
+        console.warn("Recommendations:");
+        validationResult.recommendations.forEach((rec, i)=>{
+            console.warn(`  ${i + 1}. ${rec}`);
+        });
+        console.warn("");
+    }
+    // Proceed with actual TodoWrite implementation
+    // (This would call the real TodoWrite tool)
+    // For now, just log what would be written
+    if (config?.verbose) {
+        console.log(`\n✅ Writing ${todos.length} todos...`);
+    }
+}
+/**
+ * Express middleware for validation (if using HTTP API)
+ */ export function createValidationMiddleware(config) {
+    return (req, res, next)=>{
+        if (req.body && Array.isArray(req.body.todos)) {
+            try {
+                validateTodoWrite(req.body.todos, config);
+            } catch (error) {
+                // In strict mode, validation errors become HTTP errors
+                if (config?.strictMode) {
+                    return res.status(400).json({
+                        error: "TodoWrite Batching Violation",
+                        message: error.message
+                    });
+                }
+            }
+        }
+        next();
+    };
+}
+/**
+ * Integration status checker
+ */ export function getValidationStatus() {
+    const config = getIntegrationConfig();
+    const validator = getGlobalValidator();
+    return {
+        enabled: config.enabled,
+        strictMode: config.strictMode ?? false,
+        verbose: config.verbose ?? false,
+        statistics: validator.getStatistics()
+    };
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-flow-novice",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "Simplified Claude Flow for beginners - AI agent orchestration made easy",
   "type": "module",
   "mcpName": "io.github.ruvnet/claude-flow",
   "main": "dist/src/index.js",
   "bin": {
-    "claude-flow-novice": "dist/src/cli/minimal-main.js"
+    "claude-flow-novice": "dist/src/cli/main.js"
   },
   "scripts": {
     "dev": "tsx src/cli/main.ts",