snow-flow 3.0.1 → 3.0.3

package/README.md

@@ -21,11 +21,12 @@ Every interaction with Snow-Flow provides insights into ServiceNow best practice
 ### **Real Integration, Real Results**
 Unlike mock tools or simulations, Snow-Flow connects directly to your ServiceNow instance through secure OAuth authentication. Every operation is real, every deployment is functional, and every result is production-ready.
 
-## 🎉 Version 3.0.1 - Critical Timeout Fix
+## 🎉 Version 3.0.2 - Init Command Fixed
 
-### **Latest Fix (v3.0.1)**
+### **Latest Fix (v3.0.2)**
+- 🔧 **Init Command Fixed** - Now correctly uses .env.template with v3.0.1 timeout configuration
 - 🎯 **No Timeouts by Default** - Operations run until completion for maximum reliability
-- 🎛️ **Optional Timeout Configuration** - Set `MCP_MEMORY_TIMEOUT` only if needed
+- 🎛️ **Optional Timeout Configuration** - All timeouts commented out in generated .env file
 - 🚀 **100% Completion Rate** - No artificial timeout limitations
 
 ### **What's New in v3.0.0**

package/dist/cli.js

@@ -3689,44 +3689,37 @@ For full documentation, visit: https://github.com/groeimetai/snow-flow
     }
 }
 async function createEnvFile(targetDir, force = false) {
-    const envContent = `# ServiceNow Configuration
+    // Read content from .env.template file
+    let envContent;
+    try {
+        // Try to read from the project's .env.template file
+        const templatePath = (0, path_1.join)(__dirname, '..', '.env.template');
+        envContent = await fs_1.promises.readFile(templatePath, 'utf-8');
+        console.log('📋 Using .env.template for configuration');
+    }
+    catch (error) {
+        // If template not found, try alternative locations
+        try {
+            const alternativePath = (0, path_1.join)(process.cwd(), '.env.template');
+            envContent = await fs_1.promises.readFile(alternativePath, 'utf-8');
+            console.log('📋 Using .env.template from current directory');
+        }
+        catch (fallbackError) {
+            console.warn('⚠️  Could not find .env.template file, using embedded minimal version');
+            // Last resort: use embedded minimal version with v3.0.1 timeout config
+            envContent = `# ServiceNow Configuration
 # ===========================================
 
 # ServiceNow Instance URL (without https://)
 # Example: dev12345.service-now.com
 SNOW_INSTANCE=your-instance.service-now.com
 
-# ===========================================
-# OAuth Authentication (Required)
-# ===========================================
-# Snow-Flow uses OAuth for secure authentication to ServiceNow
-# 
-# How to set up OAuth in ServiceNow:
-# 1. Navigate to: System OAuth > Application Registry
-# 2. Click "New" > "Create an OAuth API endpoint for external clients"
-# 3. Fill in:
-#    - Name: Snow-Flow Development
-#    - Client ID: (will be auto-generated)
-#    - Client Secret: (set your own or auto-generate)
-# 4. Copy the Client ID and Secret below:
-
 # OAuth Client ID from ServiceNow Application Registry
 SNOW_CLIENT_ID=your-oauth-client-id
 
 # OAuth Client Secret from ServiceNow Application Registry
 SNOW_CLIENT_SECRET=your-oauth-client-secret
 
-# ===========================================
-# Legacy Username/Password (Not Recommended)
-# ===========================================
-# These fields are kept for backwards compatibility but are not used
-# Snow-Flow requires OAuth authentication for security
-# SNOW_USERNAME=not-used
-# SNOW_PASSWORD=not-used
-
-# Optional: Additional Configuration
-# SNOW_REDIRECT_URI=http://\${SNOW_REDIRECT_HOST:-localhost}:\${SNOW_REDIRECT_PORT:-3000}/callback
-
 # ===========================================
 # Snow-Flow Configuration
 # ===========================================
@@ -3740,44 +3733,33 @@ SNOW_FLOW_STRATEGY=development
 # Maximum number of agents
 SNOW_FLOW_MAX_AGENTS=5
 
-# Claude Code timeout configuration (in minutes)
-# Set to 0 to disable timeout (infinite execution time)
-# Default: 60 minutes
-SNOW_FLOW_TIMEOUT_MINUTES=0
-
-# ===========================================
-# Deployment Timeout Configuration
-# ===========================================
-
-# ServiceNow API timeout for regular operations (milliseconds)
-# Default: 60000 (60 seconds)
-SNOW_REQUEST_TIMEOUT=60000
-
-# ServiceNow API timeout for DEPLOYMENT operations (milliseconds)
-# Deployments need more time for complex widgets
-# Default: 300000 (5 minutes)
-SNOW_DEPLOYMENT_TIMEOUT=300000
-
-# MCP transport timeout for deployment operations (milliseconds)
-# Should be higher than SNOW_DEPLOYMENT_TIMEOUT
-# Default: 360000 (6 minutes)
-MCP_DEPLOYMENT_TIMEOUT=360000
-
 # ===========================================
-# How to Set Up ServiceNow OAuth
+# Timeout Configuration (v3.0.1+)
 # ===========================================
-# 1. Log into your ServiceNow instance as admin
-# 2. Navigate to: System OAuth > Application Registry
-# 3. Click "New" > "Create an OAuth application"
-# 4. Fill in:
-#    - Name: Snow-Flow Development
-#    - Client ID: (will be generated)
-#    - Client Secret: (will be generated)  
-#    - Redirect URL: http://\${SNOW_REDIRECT_HOST:-localhost}:\${SNOW_REDIRECT_PORT:-3000}/callback
-#    - Grant Type: Authorization Code
-# 5. Copy the Client ID and Client Secret to this file
-# 6. Run: snow-flow auth login
+# IMPORTANT: Snow-Flow has NO TIMEOUTS by default for maximum reliability.
+# Operations run until completion. Only set timeouts if you specifically need them.
+# All timeout values below are COMMENTED OUT - uncomment only what you need.
+
+# Memory Operations (TodoWrite, etc.)
+# MCP_MEMORY_TIMEOUT=30000      # 30 seconds
+# MCP_MEMORY_TIMEOUT=60000      # 1 minute
+# MCP_MEMORY_TIMEOUT=120000     # 2 minutes
+
+# ServiceNow API Operations
+# SNOW_API_TIMEOUT=60000        # 1 minute - quick operations
+# SNOW_API_TIMEOUT=180000       # 3 minutes - standard operations
+# SNOW_API_TIMEOUT=300000       # 5 minutes - complex queries
+
+# Deployment Operations
+# SNOW_DEPLOYMENT_TIMEOUT=300000  # 5 minutes - simple deployments
+# SNOW_DEPLOYMENT_TIMEOUT=600000  # 10 minutes - complex widgets
+
+# MCP transport timeout (should be higher than SNOW_DEPLOYMENT_TIMEOUT if both set)
+# MCP_DEPLOYMENT_TIMEOUT=360000   # 6 minutes
+# MCP_DEPLOYMENT_TIMEOUT=720000   # 12 minutes
 `;
+        }
+    }
     const envFilePath = (0, path_1.join)(targetDir, '.env');
     // Check if .env already exists
     try {

package/dist/utils/todo-manager-mcp.d.ts

@@ -0,0 +1,87 @@
+/**
+ * MCP-based Todo Manager
+ * Alternative to Claude Code's native TodoWrite which has a 30-second timeout
+ * This uses our memory tools with NO timeout by default
+ */
+export interface Todo {
+    id: string;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    priority?: 'low' | 'medium' | 'high' | 'critical';
+    assignedAgent?: string;
+    dependencies?: string[];
+    estimatedTime?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export declare class TodoManagerMCP {
+    private static instance;
+    private logger;
+    private readonly TODO_KEY;
+    private constructor();
+    static getInstance(): TodoManagerMCP;
+    /**
+     * Get all todos
+     */
+    getTodos(): Promise<Todo[]>;
+    /**
+     * Update todos (replaces entire list like TodoWrite)
+     */
+    updateTodos(todos: Todo[]): Promise<void>;
+    /**
+     * Add a single todo
+     */
+    addTodo(todo: Omit<Todo, 'id' | 'createdAt' | 'updatedAt'>): Promise<Todo>;
+    /**
+     * Update a single todo
+     */
+    updateTodo(id: string, updates: Partial<Todo>): Promise<Todo | null>;
+    /**
+     * Mark todo as completed
+     */
+    completeTodo(id: string): Promise<boolean>;
+    /**
+     * Mark todo as in progress
+     */
+    startTodo(id: string): Promise<boolean>;
+    /**
+     * Delete a todo
+     */
+    deleteTodo(id: string): Promise<boolean>;
+    /**
+     * Clear all todos
+     */
+    clearTodos(): Promise<void>;
+    /**
+     * Get todos by status
+     */
+    getTodosByStatus(status: Todo['status']): Promise<Todo[]>;
+    /**
+     * Get todos by priority
+     */
+    getTodosByPriority(priority: Todo['priority']): Promise<Todo[]>;
+    /**
+     * Get todos assigned to specific agent
+     */
+    getTodosByAgent(agent: string): Promise<Todo[]>;
+    /**
+     * Generate formatted todo list (similar to TodoWrite output)
+     */
+    getFormattedTodos(): Promise<string>;
+    /**
+     * Generate unique ID
+     */
+    private generateId;
+    /**
+     * Get statistics
+     */
+    getStats(): Promise<{
+        total: number;
+        pending: number;
+        inProgress: number;
+        completed: number;
+        completionRate: number;
+    }>;
+}
+export declare const todoManager: TodoManagerMCP;
+//# sourceMappingURL=todo-manager-mcp.d.ts.map

package/dist/utils/todo-manager-mcp.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * MCP-based Todo Manager
+ * Alternative to Claude Code's native TodoWrite which has a 30-second timeout
+ * This uses our memory tools with NO timeout by default
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.todoManager = exports.TodoManagerMCP = void 0;
+const reliable_memory_manager_js_1 = require("../mcp/shared/reliable-memory-manager.js");
+const logger_js_1 = require("./logger.js");
+class TodoManagerMCP {
+    constructor() {
+        this.TODO_KEY = 'mcp_todos';
+        this.logger = new logger_js_1.Logger('TodoManagerMCP');
+    }
+    static getInstance() {
+        if (!TodoManagerMCP.instance) {
+            TodoManagerMCP.instance = new TodoManagerMCP();
+        }
+        return TodoManagerMCP.instance;
+    }
+    /**
+     * Get all todos
+     */
+    async getTodos() {
+        try {
+            const todos = await reliable_memory_manager_js_1.reliableMemory.retrieve(this.TODO_KEY);
+            return todos || [];
+        }
+        catch (error) {
+            this.logger.error('Failed to retrieve todos:', error);
+            return [];
+        }
+    }
+    /**
+     * Update todos (replaces entire list like TodoWrite)
+     */
+    async updateTodos(todos) {
+        try {
+            // Add timestamps
+            const updatedTodos = todos.map(todo => ({
+                ...todo,
+                updatedAt: new Date(),
+                createdAt: todo.createdAt || new Date()
+            }));
+            // Store with NO timeout - operations run to completion
+            await reliable_memory_manager_js_1.reliableMemory.store(this.TODO_KEY, updatedTodos);
+            this.logger.info(`Updated ${todos.length} todos successfully`);
+            // Also store a backup with timestamp
+            const backupKey = `${this.TODO_KEY}_backup_${Date.now()}`;
+            await reliable_memory_manager_js_1.reliableMemory.store(backupKey, updatedTodos, 86400000); // 24 hour expiry for backups
+        }
+        catch (error) {
+            this.logger.error('Failed to update todos:', error);
+            throw error;
+        }
+    }
+    /**
+     * Add a single todo
+     */
+    async addTodo(todo) {
+        const todos = await this.getTodos();
+        const newTodo = {
+            ...todo,
+            id: this.generateId(),
+            createdAt: new Date(),
+            updatedAt: new Date()
+        };
+        todos.push(newTodo);
+        await this.updateTodos(todos);
+        return newTodo;
+    }
+    /**
+     * Update a single todo
+     */
+    async updateTodo(id, updates) {
+        const todos = await this.getTodos();
+        const index = todos.findIndex(t => t.id === id);
+        if (index === -1) {
+            this.logger.warn(`Todo ${id} not found`);
+            return null;
+        }
+        todos[index] = {
+            ...todos[index],
+            ...updates,
+            id: todos[index].id, // Preserve ID
+            createdAt: todos[index].createdAt, // Preserve creation date
+            updatedAt: new Date()
+        };
+        await this.updateTodos(todos);
+        return todos[index];
+    }
+    /**
+     * Mark todo as completed
+     */
+    async completeTodo(id) {
+        const result = await this.updateTodo(id, { status: 'completed' });
+        return result !== null;
+    }
+    /**
+     * Mark todo as in progress
+     */
+    async startTodo(id) {
+        const result = await this.updateTodo(id, { status: 'in_progress' });
+        return result !== null;
+    }
+    /**
+     * Delete a todo
+     */
+    async deleteTodo(id) {
+        const todos = await this.getTodos();
+        const filtered = todos.filter(t => t.id !== id);
+        if (filtered.length === todos.length) {
+            return false; // Nothing was deleted
+        }
+        await this.updateTodos(filtered);
+        return true;
+    }
+    /**
+     * Clear all todos
+     */
+    async clearTodos() {
+        await reliable_memory_manager_js_1.reliableMemory.delete(this.TODO_KEY);
+        this.logger.info('All todos cleared');
+    }
+    /**
+     * Get todos by status
+     */
+    async getTodosByStatus(status) {
+        const todos = await this.getTodos();
+        return todos.filter(t => t.status === status);
+    }
+    /**
+     * Get todos by priority
+     */
+    async getTodosByPriority(priority) {
+        const todos = await this.getTodos();
+        return todos.filter(t => t.priority === priority);
+    }
+    /**
+     * Get todos assigned to specific agent
+     */
+    async getTodosByAgent(agent) {
+        const todos = await this.getTodos();
+        return todos.filter(t => t.assignedAgent === agent);
+    }
+    /**
+     * Generate formatted todo list (similar to TodoWrite output)
+     */
+    async getFormattedTodos() {
+        const todos = await this.getTodos();
+        if (todos.length === 0) {
+            return 'No todos';
+        }
+        const lines = [];
+        // Group by status
+        const pending = todos.filter(t => t.status === 'pending');
+        const inProgress = todos.filter(t => t.status === 'in_progress');
+        const completed = todos.filter(t => t.status === 'completed');
+        if (inProgress.length > 0) {
+            lines.push('🔄 In Progress:');
+            inProgress.forEach(t => {
+                const priority = t.priority ? ` [${t.priority}]` : '';
+                const agent = t.assignedAgent ? ` (@${t.assignedAgent})` : '';
+                lines.push(`  ▶ ${t.content}${priority}${agent}`);
+            });
+        }
+        if (pending.length > 0) {
+            lines.push('\n📋 Pending:');
+            pending.forEach(t => {
+                const priority = t.priority ? ` [${t.priority}]` : '';
+                const agent = t.assignedAgent ? ` (@${t.assignedAgent})` : '';
+                lines.push(`  ○ ${t.content}${priority}${agent}`);
+            });
+        }
+        if (completed.length > 0) {
+            lines.push('\n✅ Completed:');
+            completed.forEach(t => {
+                lines.push(`  ✓ ${t.content}`);
+            });
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Generate unique ID
+     */
+    generateId() {
+        return `todo_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Get statistics
+     */
+    async getStats() {
+        const todos = await this.getTodos();
+        const stats = {
+            total: todos.length,
+            pending: todos.filter(t => t.status === 'pending').length,
+            inProgress: todos.filter(t => t.status === 'in_progress').length,
+            completed: todos.filter(t => t.status === 'completed').length,
+            completionRate: 0
+        };
+        if (stats.total > 0) {
+            stats.completionRate = (stats.completed / stats.total) * 100;
+        }
+        return stats;
+    }
+}
+exports.TodoManagerMCP = TodoManagerMCP;
+// Export singleton instance
+exports.todoManager = TodoManagerMCP.getInstance();
+//# sourceMappingURL=todo-manager-mcp.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.0.1",
-  "description": "Snow-Flow v3.0.1: Production-Ready ServiceNow Intelligence Platform - NO TIMEOUTS by default for maximum reliability. 100% REAL implementation with TensorFlow.js neural networks, direct ServiceNow API integration, and intelligent memory management. Includes 100+ MCP tools for operations, development, ML, analytics, and security. Full AI swarm orchestration with dynamic task categorization. Operations run to completion without artificial time limits.",
+  "version": "3.0.3",
+  "description": "Snow-Flow v3.0.3: Production-Ready ServiceNow Intelligence Platform - NO TIMEOUTS by default. Includes TodoWrite timeout documentation and MCP-based todo manager alternative. 100% REAL implementation with TensorFlow.js neural networks, direct ServiceNow API integration, and intelligent memory management. Includes 100+ MCP tools for operations, development, ML, analytics, and security. Full AI swarm orchestration with dynamic task categorization.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {