snow-flow 2.0.2 → 2.0.4

package/scripts/update-version.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Update version.ts with the current version from package.json
- * This script runs automatically after npm version
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// Read package.json
-const packageJsonPath = path.join(__dirname, '..', 'package.json');
-const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-const version = packageJson.version;
-
-// Path to version.ts
-const versionTsPath = path.join(__dirname, '..', 'src', 'version.ts');
-
-// Read current version.ts content
-const versionTsContent = fs.readFileSync(versionTsPath, 'utf8');
-
-// Replace the VERSION constant
-const updatedContent = versionTsContent.replace(
-  /export const VERSION = '[^']+';/,
-  `export const VERSION = '${version}';`
-);
-
-// Write updated content back
-fs.writeFileSync(versionTsPath, updatedContent, 'utf8');
-
-console.log(`✅ Updated version.ts to ${version}`);

package/src/agents/README.md

@@ -1,192 +0,0 @@
-# ServiceNow Specialist Agents
-
-This directory contains the implementation of ServiceNow specialist agents that work together through Claude Code to build, deploy, and maintain ServiceNow solutions.
-
-## ⚠️ IMPORTANT: Flow Builder Agent Removed in v1.4.0 ⚠️
-
-**Note**: The Flow Builder Agent and all flow-related functionality have been removed in v1.4.0 due to critical bugs. The agent file may still exist but is no longer functional. Please use ServiceNow's native Flow Designer interface directly for flow creation.
-
-## 🤖 Available Agents
-
-### 1. Widget Creator Agent (`widget-creator-agent.ts`)
-Specializes in creating ServiceNow Service Portal widgets.
-
-**Capabilities:**
-- HTML template creation
-- CSS styling and responsive design
-- Client-side JavaScript development
-- Server-side data processing
-- Chart.js integration
-- Demo data generation
-
-**MCP Tools Used:**
-- `snow_deploy` - Deploy widgets to ServiceNow
-- `snow_preview_widget` - Preview widget rendering
-- `snow_widget_test` - Test widget functionality
-
-### 2. Flow Builder Agent (`flow-builder-agent.ts`)
-Specializes in creating ServiceNow Flow Designer workflows.
-
-**Capabilities:**
-- Business process design
-- Flow trigger configuration
-- Approval workflow creation
-- Integration flow building
-- Error handling design
-
-**MCP Tools Used:**
-- `snow_create_flow` - Create flows from natural language
-- `snow_test_flow_with_mock` - Test flows with mock data
-- `snow_link_catalog_to_flow` - Link flows to catalog items
-
-### 3. Script Writer Agent (`script-writer-agent.ts`)
-Specializes in creating ServiceNow scripts.
-
-**Capabilities:**
-- Business rule creation
-- Script include development
-- Client script implementation
-- Scheduled job scripts
-- Performance optimization
-
-**MCP Tools Used:**
-- `snow_create_script_include` - Create script includes
-- `snow_create_business_rule` - Create business rules
-- `snow_create_client_script` - Create client scripts
-
-### 4. Test Agent (`test-agent.ts`)
-Specializes in testing ServiceNow artifacts.
-
-**Capabilities:**
-- Test scenario creation
-- Mock data generation
-- Integration testing
-- Performance validation
-- Quality assurance
-
-**MCP Tools Used:**
-- `snow_test_flow_with_mock` - Test flows
-- `snow_widget_test` - Test widgets
-- `snow_comprehensive_flow_test` - Comprehensive testing
-- `snow_cleanup_test_artifacts` - Clean up test data
-
-### 5. Security Agent (`security-agent.ts`)
-Specializes in ServiceNow security and compliance.
-
-**Capabilities:**
-- Security policy enforcement
-- Vulnerability scanning
-- Access control validation
-- Compliance checking (SOX, GDPR, HIPAA)
-- Security best practices
-
-**MCP Tools Used:**
-- `snow_create_access_control` - Create ACLs
-- `snow_security_scan` - Security scanning
-- `snow_run_compliance_scan` - Compliance validation
-
-## 🏗️ Architecture
-
-### Base Agent Class (`base-agent.ts`)
-All agents extend the `BaseAgent` class which provides:
-- Shared memory integration via SQLite
-- Progress reporting to Queen Agent
-- Inter-agent communication
-- Error handling and logging
-- Lifecycle management
-
-### Agent Communication Pattern
-```typescript
-// Agents communicate through shared memory
-await agent.storeArtifact(artifact);
-await agent.reportProgress('Task completed', 100);
-await agent.sendMessage(otherAgentId, 'coordination', data);
-```
-
-### Integration with Queen Agent
-The Queen Agent uses `AgentFactory` to spawn these specialized agents:
-```typescript
-const agent = await agentFactory.createSpecializedAgent('widget-creator');
-const result = await agent.execute(instruction, context);
-```
-
-## 🚀 Usage Examples
-
-### Creating a Widget
-```typescript
-const widgetAgent = new WidgetCreatorAgent({ debugMode: true });
-const result = await widgetAgent.execute(
-  'Create an incident dashboard widget with real-time charts'
-);
-```
-
-### Building a Flow
-```typescript
-const flowAgent = new FlowBuilderAgent({ debugMode: true });
-const result = await flowAgent.execute(
-  'Create an approval flow for catalog requests with manager approval'
-);
-```
-
-### Writing a Script
-```typescript
-const scriptAgent = new ScriptWriterAgent({ debugMode: true });
-const result = await scriptAgent.execute(
-  'Create a business rule to calculate incident priority'
-);
-```
-
-### Testing Artifacts
-```typescript
-const testAgent = new TestAgent({ debugMode: true });
-const result = await testAgent.execute(
-  'Test the incident dashboard widget with comprehensive scenarios'
-);
-```
-
-### Security Scanning
-```typescript
-const securityAgent = new SecurityAgent({ debugMode: true });
-const result = await securityAgent.execute(
-  'Perform security scan on all recent artifacts'
-);
-```
-
-## 🧪 Testing
-
-Run the agent test suite:
-```bash
-npm test src/agents/test-agents.ts
-```
-
-## 📝 Best Practices
-
-1. **Always use shared memory** for coordination between agents
-2. **Report progress regularly** for long-running tasks
-3. **Handle errors gracefully** and provide meaningful error messages
-4. **Store artifacts** in shared memory for other agents to use
-5. **Clean up resources** when agent tasks complete
-
-## 🔄 Agent Lifecycle
-
-1. **Initialization**: Agent is created with configuration
-2. **Execution**: Agent performs its specialized task
-3. **Coordination**: Agent communicates with other agents
-4. **Completion**: Agent reports results and stores artifacts
-5. **Cleanup**: Agent releases resources
-
-## 🔗 MCP Tool Integration
-
-Each agent knows which MCP tools to recommend for its tasks. The actual MCP tool execution happens through Claude Code, not directly by the agents. Agents provide:
-- Tool recommendations
-- Parameter preparation
-- Result interpretation
-- Error handling
-
-## 🎯 Future Enhancements
-
-- [ ] Add more specialized agents (Catalog Manager, Integration Specialist)
-- [ ] Implement agent learning from past executions
-- [ ] Add performance metrics collection
-- [ ] Enhance inter-agent coordination protocols
-- [ ] Add agent health monitoring

package/src/agents/base-agent.ts

@@ -1,251 +0,0 @@
-/**
- * Base Agent Class
- * Common functionality for all ServiceNow specialist agents
- */
-
-import { Agent, AgentMessage, ServiceNowArtifact, AgentType } from '../queen/types';
-import { QueenMemorySystem } from '../queen/queen-memory';
-import * as crypto from 'crypto';
-
-export interface AgentConfig {
-  id?: string;
-  type: AgentType;
-  capabilities: string[];
-  mcpTools: string[];
-  memoryPath?: string;
-  debugMode?: boolean;
-}
-
-export interface AgentResult {
-  success: boolean;
-  artifacts?: ServiceNowArtifact[];
-  message?: string;
-  error?: Error;
-  metadata?: Record<string, any>;
-}
-
-export abstract class BaseAgent implements Agent {
-  public id: string;
-  public type: AgentType;
-  public status: Agent['status'];
-  public task?: string;
-  public capabilities: string[];
-  public mcpTools: string[];
-  
-  protected memory: QueenMemorySystem;
-  protected debugMode: boolean;
-  protected messageQueue: AgentMessage[] = [];
-
-  constructor(config: AgentConfig) {
-    this.id = config.id || this.generateAgentId(config.type);
-    this.type = config.type;
-    this.status = 'idle';
-    this.capabilities = config.capabilities;
-    this.mcpTools = config.mcpTools;
-    this.debugMode = config.debugMode || false;
-    
-    // Initialize memory system
-    this.memory = new QueenMemorySystem(config.memoryPath);
-    
-    if (this.debugMode) {
-      console.log(`🤖 ${this.type} agent initialized with ID: ${this.id}`);
-    }
-  }
-
-  /**
-   * Execute the agent's main task
-   * Must be implemented by each specific agent
-   */
-  abstract execute(instruction: string, context?: Record<string, any>): Promise<AgentResult>;
-
-  /**
-   * Validate agent can handle the task
-   * Can be overridden by specific agents
-   */
-  async canHandle(instruction: string): Promise<boolean> {
-    // Default implementation checks if instruction mentions agent capabilities
-    const lowerInstruction = instruction.toLowerCase();
-    return this.capabilities.some(capability => 
-      lowerInstruction.includes(capability.toLowerCase().split(' ')[0])
-    );
-  }
-
-  /**
-   * Store artifact in shared memory for other agents
-   */
-  protected async storeArtifact(artifact: ServiceNowArtifact): Promise<void> {
-    const key = `artifact_${artifact.type}_${artifact.name}`;
-    await this.memory.storeInContext(key, artifact);
-    
-    if (this.debugMode) {
-      console.log(`📦 Stored artifact: ${key}`);
-    }
-  }
-
-  /**
-   * Retrieve artifact from shared memory
-   */
-  protected async getArtifact(type: string, name: string): Promise<ServiceNowArtifact | null> {
-    const key = `artifact_${type}_${name}`;
-    return await this.memory.getFromContext(key);
-  }
-
-  /**
-   * Report progress to Queen Agent
-   */
-  protected async reportProgress(message: string, percentage: number): Promise<void> {
-    const progressKey = `progress_${this.id}`;
-    await this.memory.storeInContext(progressKey, {
-      agentId: this.id,
-      agentType: this.type,
-      message,
-      percentage,
-      timestamp: new Date()
-    });
-    
-    if (this.debugMode) {
-      console.log(`📊 ${this.type}: ${message} (${percentage}%)`);
-    }
-  }
-
-  /**
-   * Send message to another agent
-   */
-  protected sendMessage(to: string, type: AgentMessage['type'], content: any): void {
-    const message: AgentMessage = {
-      from: this.id,
-      to,
-      type,
-      content,
-      timestamp: new Date()
-    };
-    
-    // Store in shared memory for recipient
-    const messageKey = `message_${to}_${Date.now()}`;
-    this.memory.storeInContext(messageKey, message);
-    
-    if (this.debugMode) {
-      console.log(`📨 Message sent from ${this.id} to ${to}: ${type}`);
-    }
-  }
-
-  /**
-   * Retrieve messages for this agent
-   */
-  protected async getMessages(): Promise<AgentMessage[]> {
-    const _messagePrefix = `message_${this.id}_`;
-    const messages: AgentMessage[] = [];
-    
-    // This is a simplified implementation
-    // In a real system, we'd query the memory system more efficiently
-    return messages;
-  }
-
-  /**
-   * Handle coordination with other agents
-   */
-  protected async coordinateWith(agentType: AgentType, request: any): Promise<any> {
-    const coordinationKey = `coordination_${this.id}_${agentType}_${Date.now()}`;
-    await this.memory.storeInContext(coordinationKey, {
-      from: this.id,
-      toType: agentType,
-      request,
-      timestamp: new Date()
-    });
-    
-    // Wait for response (simplified)
-    const responseKey = `${coordinationKey}_response`;
-    let attempts = 0;
-    while (attempts < 30) { // 30 second timeout
-      const response = await this.memory.getFromContext(responseKey);
-      if (response) {
-        return response;
-      }
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      attempts++;
-    }
-    
-    throw new Error(`Coordination timeout with ${agentType}`);
-  }
-
-  /**
-   * Log activity for learning
-   */
-  protected async logActivity(action: string, success: boolean, details?: any): Promise<void> {
-    const learningKey = `agent_activity_${this.type}_${action}`;
-    await this.memory.storeLearning(learningKey, JSON.stringify({
-      agentId: this.id,
-      action,
-      success,
-      details,
-      timestamp: new Date()
-    }), success ? 0.9 : 0.3);
-  }
-
-  /**
-   * Update agent status
-   */
-  protected setStatus(status: Agent['status']): void {
-    this.status = status;
-    const statusKey = `agent_status_${this.id}`;
-    this.memory.storeInContext(statusKey, {
-      agentId: this.id,
-      status,
-      timestamp: new Date()
-    });
-  }
-
-  /**
-   * Check if agent should work with another agent
-   */
-  protected shouldCoordinate(otherAgentType: AgentType): boolean {
-    // Define coordination rules
-    // Simplified coordination rules after flow-builder removal  
-    const coordinationRules: Partial<Record<AgentType, AgentType[]>> = {
-      'researcher': ['script-writer', 'researcher'],
-      'script-writer': ['tester', 'app-architect'], 
-      'widget-creator': ['researcher', 'ui-ux-specialist'],
-      'app-architect': ['script-writer', 'integration-specialist'],
-      'tester': ['script-writer', 'security-specialist'],
-      'integration-specialist': ['app-architect', 'script-writer']
-    };
-    
-    return coordinationRules[this.type]?.includes(otherAgentType) || false;
-  }
-
-  /**
-   * Generate unique agent ID
-   */
-  private generateAgentId(type: AgentType): string {
-    const timestamp = Date.now().toString(36);
-    const random = crypto.randomBytes(4).toString('hex');
-    return `${type}_${timestamp}_${random}`;
-  }
-
-  /**
-   * Get agent information
-   */
-  getInfo(): Record<string, any> {
-    return {
-      id: this.id,
-      type: this.type,
-      status: this.status,
-      capabilities: this.capabilities,
-      mcpTools: this.mcpTools,
-      task: this.task
-    };
-  }
-
-  /**
-   * Cleanup agent resources
-   */
-  async cleanup(): Promise<void> {
-    // Clean up any resources
-    this.messageQueue = [];
-    this.status = 'idle';
-    
-    if (this.debugMode) {
-      console.log(`🧹 ${this.type} agent ${this.id} cleaned up`);
-    }
-  }
-}