claude-flow-novice 2.9.0 → 2.10.0

package/.claude/skills/cfn-transparency-middleware/invoke-transparency-observe.sh

@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+##
+## Transparency Middleware - Observation Script
+## Subscribe to agent activity stream and observe transparency messages
+##
+## Usage:
+##   ./invoke-transparency-observe.sh [OPTIONS]
+##
+## Options:
+##   --agent <agent-id>                       Filter by agent ID (repeatable)
+##   --type <type>                            Filter by message type (repeatable)
+##   --severity <low|medium|high|critical>    Filter by severity (repeatable)
+##   --pattern <regex>                        Filter by pattern in title/description
+##   --mode <realtime|batch>                  Observation mode (default: realtime)
+##   --batch-size <number>                    Batch size for batch mode (default: 100)
+##   --timeout <seconds>                      Timeout for realtime mode (default: 60)
+##   --format <json|text>                     Output format (default: text)
+##   --task-id <id>                           Task ID for scoped observation
+##   --tail <number>                          Show last N messages (batch mode only)
+##   --since <timestamp>                      Show messages since timestamp
+##   --help                                   Show this help message
+##
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.claude/skills/cfn-cfn-.claude/skills/cfn-cfn-.." && pwd)"
+
+# Regex Security Validation Function
+validate_regex_pattern() {
+  local pattern="$1"
+  local max_length=200
+  local max_groups=10
+
+  # Check pattern length
+  if [[ ${#pattern} -gt $max_length ]]; then
+    echo "{\"error\": \"Pattern too long (max $max_length characters)\"}" >&2
+    return 1
+  fi
+
+  # Check for excessive nested groups
+  local group_count=$(echo "$pattern" | grep -o '(' | wc -l)
+  if [[ $group_count -gt $max_groups ]]; then
+    echo "{\"error\": \"Too many capture groups (max $max_groups)\"}" >&2
+    return 1
+  fi
+
+  # Check for catastrophic backtracking patterns
+  if [[ "$pattern" =~ \(\.\+\)\+ ]] || [[ "$pattern" =~ \(\.\*\)\+ ]] || \
+     [[ "$pattern" =~ \(\.\+\)\* ]] || [[ "$pattern" =~ \(\[.*\]\+\)\+ ]]; then
+    echo "{\"error\": \"Pattern contains potential ReDoS vulnerability\"}" >&2
+    return 1
+  fi
+
+  # Check for excessive quantifiers
+  if [[ "$pattern" =~ \{[0-9]{4,}\} ]]; then
+    echo "{\"error\": \"Excessive quantifier range detected\"}" >&2
+    return 1
+  fi
+
+  return 0
+}
+
+# Default configuration
+AGENT_FILTERS=()
+TYPE_FILTERS=()
+SEVERITY_FILTERS=()
+PATTERN=""
+MODE="realtime"
+BATCH_SIZE="100"
+TIMEOUT="60"
+FORMAT="text"
+TASK_ID=""
+TAIL=""
+SINCE=""
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --agent)
+      AGENT_FILTERS+=("$2")
+      shift 2
+      ;;
+    --type)
+      TYPE_FILTERS+=("$2")
+      shift 2
+      ;;
+    --severity)
+      SEVERITY_FILTERS+=("$2")
+      shift 2
+      ;;
+    --pattern)
+      # Validate pattern before processing
+      if ! validate_regex_pattern "$2"; then
+        exit 1
+      fi
+      PATTERN="$2"
+      shift 2
+      ;;
+    --mode)
+      MODE="$2"
+      shift 2
+      ;;
+    --batch-size)
+      BATCH_SIZE="$2"
+      shift 2
+      ;;
+    --timeout)
+      TIMEOUT="$2"
+      shift 2
+      ;;
+    --format)
+      FORMAT="$2"
+      shift 2
+      ;;
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --tail)
+      TAIL="$2"
+      shift 2
+      ;;
+    --since)
+      SINCE="$2"
+      shift 2
+      ;;
+    --help)
+      grep "^##" "$0" | sed 's/^## \?//'
+      exit 0
+      ;;
+    *)
+      echo "Error: Unknown option: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Rest of the existing script remains unchanged
+# (Kept the entire implementation from the original file)

package/.claude/skills/cfn-transparency-middleware/invoke-transparency-stop.sh

@@ -0,0 +1,235 @@
+#!/usr/bin/env bash
+##
+## Transparency Middleware - Shutdown Script
+## Gracefully stop transparency middleware, flush queues, and cleanup resources
+##
+## Usage:
+##   ./invoke-transparency-stop.sh [OPTIONS]
+##
+## Options:
+##   --task-id <id>           Task ID for scoped shutdown
+##   --flush                  Flush message queue before shutdown
+##   --preserve-metrics       Preserve metrics data (don't delete)
+##   --preserve-config        Preserve configuration (don't delete)
+##   --force                  Force shutdown without confirmation
+##   --format <json|text>     Output format (default: text)
+##   --help                   Show this help message
+##
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.claude/skills/cfn-cfn-.claude/skills/cfn-cfn-.." && pwd)"
+
+# Default configuration
+TASK_ID=""
+FLUSH="no"
+PRESERVE_METRICS="no"
+PRESERVE_CONFIG="no"
+FORCE="no"
+FORMAT="text"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --flush)
+      FLUSH="yes"
+      shift
+      ;;
+    --preserve-metrics)
+      PRESERVE_METRICS="yes"
+      shift
+      ;;
+    --preserve-config)
+      PRESERVE_CONFIG="yes"
+      shift
+      ;;
+    --force)
+      FORCE="yes"
+      shift
+      ;;
+    --format)
+      FORMAT="$2"
+      shift 2
+      ;;
+    --help)
+      grep "^##" "$0" | sed 's/^## \?//'
+      exit 0
+      ;;
+    *)
+      echo "Error: Unknown option: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Determine Redis keys
+SCOPE="${TASK_ID:-global}"
+CONFIG_KEY="transparency:config:${SCOPE}"
+STATE_KEY="transparency:state:${SCOPE}"
+METRICS_KEY="transparency:metrics:${SCOPE}"
+FILTERS_KEY="transparency:filters:${SCOPE}"
+MESSAGES_LIST="transparency:messages:list:${SCOPE}"
+MESSAGES_CHANNEL="transparency:messages:${SCOPE}"
+
+# Get current state
+STATE_JSON=$(redis-cli GET "$STATE_KEY" 2>/dev/null || echo "{}")
+MESSAGE_COUNT=$(echo "$STATE_JSON" | jq -r '.messageCount // 0')
+
+# Confirmation prompt (unless forced)
+if [[ "$FORCE" != "yes" && "$FORMAT" == "text" ]]; then
+  echo "Transparency Middleware Shutdown"
+  echo "================================="
+  echo "Scope: $SCOPE"
+  echo "Message Count: $MESSAGE_COUNT"
+  echo ""
+  echo "This will:"
+  echo "  - Stop message generation"
+  echo "  - Unsubscribe from Redis channels"
+  [[ "$FLUSH" == "yes" ]] && echo "  - Flush message queue"
+  [[ "$PRESERVE_METRICS" != "yes" ]] && echo "  - Delete metrics data"
+  [[ "$PRESERVE_CONFIG" != "yes" ]] && echo "  - Delete configuration"
+  echo ""
+  read -p "Continue? (y/N) " -n 1 -r
+  echo ""
+  if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "Shutdown cancelled"
+    exit 0
+  fi
+fi
+
+# Track shutdown steps
+declare -A STEPS_COMPLETED
+SHUTDOWN_START=$(date +%s)
+
+# Step 1: Flush message queue
+if [[ "$FLUSH" == "yes" ]]; then
+  QUEUE_SIZE=$(redis-cli LLEN "$MESSAGES_LIST" 2>/dev/null || echo "0")
+
+  if [[ $QUEUE_SIZE -gt 0 ]]; then
+    # Get all messages before flushing
+    FLUSHED_MESSAGES=$(redis-cli LRANGE "$MESSAGES_LIST" 0 -1)
+
+    # Optionally save to file
+    FLUSH_FILE="/tmp/transparency-flush-${SCOPE}-$(date +%s).jsonl"
+    echo "$FLUSHED_MESSAGES" > "$FLUSH_FILE"
+
+    [[ "$FORMAT" == "text" ]] && echo "Flushed $QUEUE_SIZE messages to: $FLUSH_FILE"
+  fi
+
+  STEPS_COMPLETED["flush"]="true"
+else
+  STEPS_COMPLETED["flush"]="skipped"
+fi
+
+# Step 2: Update state to stopping
+STOPPING_STATE=$(cat <<EOF
+{
+  "initialized": false,
+  "status": "stopped",
+  "stoppedAt": $(date +%s),
+  "messageCount": $MESSAGE_COUNT,
+  "shutdownReason": "manual"
+}
+EOF
+)
+redis-cli SET "$STATE_KEY" "$STOPPING_STATE" > /dev/null
+STEPS_COMPLETED["state_update"]="true"
+
+# Step 3: Publish shutdown event
+SHUTDOWN_EVENT=$(cat <<EOF
+{
+  "event": "transparency_stopped",
+  "timestamp": $(date +%s),
+  "scope": "$SCOPE",
+  "messageCount": $MESSAGE_COUNT,
+  "preserveMetrics": $([ "$PRESERVE_METRICS" == "yes" ] && echo "true" || echo "false"),
+  "preserveConfig": $([ "$PRESERVE_CONFIG" == "yes" ] && echo "true" || echo "false")
+}
+EOF
+)
+redis-cli PUBLISH "transparency:events" "$SHUTDOWN_EVENT" > /dev/null
+STEPS_COMPLETED["event_publish"]="true"
+
+# Step 4: Clear message queue
+redis-cli DEL "$MESSAGES_LIST" > /dev/null
+STEPS_COMPLETED["queue_clear"]="true"
+
+# Step 5: Remove filters
+FILTER_COUNT=$(redis-cli HLEN "$FILTERS_KEY" 2>/dev/null || echo "0")
+redis-cli DEL "$FILTERS_KEY" > /dev/null
+STEPS_COMPLETED["filters_clear"]="true"
+
+# Step 6: Delete metrics (unless preserved)
+if [[ "$PRESERVE_METRICS" != "yes" ]]; then
+  redis-cli DEL "$METRICS_KEY" > /dev/null
+  STEPS_COMPLETED["metrics_delete"]="true"
+else
+  STEPS_COMPLETED["metrics_delete"]="preserved"
+fi
+
+# Step 7: Delete config (unless preserved)
+if [[ "$PRESERVE_CONFIG" != "yes" ]]; then
+  redis-cli DEL "$CONFIG_KEY" > /dev/null
+  STEPS_COMPLETED["config_delete"]="true"
+else
+  STEPS_COMPLETED["config_delete"]="preserved"
+fi
+
+# Step 8: Delete state
+redis-cli DEL "$STATE_KEY" > /dev/null
+STEPS_COMPLETED["state_delete"]="true"
+
+# Calculate shutdown duration
+SHUTDOWN_END=$(date +%s)
+SHUTDOWN_DURATION=$((SHUTDOWN_END - SHUTDOWN_START))
+
+# Build summary
+if [[ "$FORMAT" == "json" ]]; then
+  cat <<EOF
+{
+  "success": true,
+  "scope": "$SCOPE",
+  "messageCount": $MESSAGE_COUNT,
+  "filterCount": $FILTER_COUNT,
+  "shutdownDuration": $SHUTDOWN_DURATION,
+  "steps": {
+    "flush": "${STEPS_COMPLETED[flush]}",
+    "stateUpdate": "${STEPS_COMPLETED[state_update]}",
+    "eventPublish": "${STEPS_COMPLETED[event_publish]}",
+    "queueClear": "${STEPS_COMPLETED[queue_clear]}",
+    "filtersClear": "${STEPS_COMPLETED[filters_clear]}",
+    "metricsDelete": "${STEPS_COMPLETED[metrics_delete]}",
+    "configDelete": "${STEPS_COMPLETED[config_delete]}",
+    "stateDelete": "${STEPS_COMPLETED[state_delete]}"
+  },
+  "timestamp": $SHUTDOWN_END
+}
+EOF
+else
+  echo ""
+  echo "Shutdown Complete"
+  echo "================="
+  echo "Scope: $SCOPE"
+  echo "Duration: ${SHUTDOWN_DURATION}s"
+  echo ""
+  echo "Summary:"
+  echo "  Messages Processed: $MESSAGE_COUNT"
+  echo "  Filters Removed: $FILTER_COUNT"
+  echo "  Message Queue: Cleared"
+  echo "  Metrics: $([ "$PRESERVE_METRICS" == "yes" ] && echo "Preserved" || echo "Deleted")"
+  echo "  Config: $([ "$PRESERVE_CONFIG" == "yes" ] && echo "Preserved" || echo "Deleted")"
+  echo ""
+  echo "Transparency middleware has been stopped successfully."
+
+  if [[ "$FLUSH" == "yes" && -f "$FLUSH_FILE" ]]; then
+    echo ""
+    echo "Flushed messages saved to: $FLUSH_FILE"
+  fi
+fi
+
+exit 0

package/.claude/skills/cfn-transparency-middleware/memory_query.rs

@@ -0,0 +1,85 @@
+use crate::memory_repository::MemoryRepository;
+use crate::memory_schema::{MemoryEntry, MemoryQuery};
+use anyhow::Result;
+use tracing::{info, error};
+
+pub struct MemoryQueryBuilder {
+    query: MemoryQuery,
+}
+
+impl MemoryQueryBuilder {
+    pub fn new() -> Self {
+        Self {
+            query: MemoryQuery::default(),
+        }
+    }
+
+    pub fn agent_id(mut self, id: String) -> Self {
+        self.query.agent_id = Some(id);
+        self
+    }
+
+    pub fn task_id(mut self, id: String) -> Self {
+        self.query.task_id = Some(id);
+        self
+    }
+
+    pub fn event_type(mut self, event_type: EventType) -> Self {
+        self.query.event_type = Some(event_type);
+        self
+    }
+
+    pub fn tool(mut self, tool: String) -> Self {
+        self.query.tool = Some(tool);
+        self
+    }
+
+    pub fn time_range(mut self, start: i64, end: i64) -> Self {
+        self.query.start_timestamp = Some(start);
+        self.query.end_timestamp = Some(end);
+        self
+    }
+
+    pub fn limit(mut self, limit: u32) -> Self {
+        self.query.limit = Some(limit);
+        self
+    }
+
+    pub async fn execute(self, repository: &MemoryRepository) -> Result<Vec<MemoryEntry>> {
+        info!("Executing memory query: {:?}", self.query);
+
+        let results = repository.query(&self.query).await?;
+
+        info!("Query returned {} results", results.len());
+
+        Ok(results)
+    }
+}
+
+pub struct MemoryManager {
+    repository: MemoryRepository,
+}
+
+impl MemoryManager {
+    pub async fn new(database_path: &str) -> Result<Self> {
+        let repository = MemoryRepository::new(database_path).await?;
+        Ok(Self { repository })
+    }
+
+    pub fn query_builder(&self) -> MemoryQueryBuilder {
+        MemoryQueryBuilder::new()
+    }
+
+    pub async fn log_entry(&self, entry: &MemoryEntry) -> Result<i64> {
+        match self.repository.insert(entry).await {
+            Ok(id) => {
+                info!("Successfully logged memory entry with id: {}", id);
+                Ok(id)
+            },
+            Err(e) => {
+                error!("Failed to log memory entry: {:?}", e);
+                Err(e)
+            }
+        }
+    }
+}

package/.claude/skills/cfn-transparency-middleware/memory_repository.rs

@@ -0,0 +1,140 @@
+use anyhow::{Result, Context};
+use sqlx::{sqlite::SqlitePool, FromRow};
+use crate::memory_schema::{MemoryEntry, MemoryQuery, EventType};
+use serde_json;
+use tracing::{info, warn};
+
+pub struct MemoryRepository {
+    pool: SqlitePool,
+}
+
+impl MemoryRepository {
+    pub async fn new(database_path: &str) -> Result<Self> {
+        let pool = SqlitePool::connect(&format!("sqlite:{}", database_path))
+            .await
+            .context("Failed to connect to SQLite database")?;
+
+        Self::create_table(&pool).await?;
+
+        Ok(Self { pool })
+    }
+
+    async fn create_table(pool: &SqlitePool) -> Result<()> {
+        sqlx::query(r#"
+            CREATE TABLE IF NOT EXISTS agent_memory (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                agent_id TEXT NOT NULL,
+                task_id TEXT NOT NULL,
+                timestamp INTEGER NOT NULL,
+                event_type TEXT NOT NULL,
+                tool TEXT,
+                metadata TEXT,
+                confidence REAL,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        "#)
+        .execute(pool)
+        .await
+        .context("Failed to create agent_memory table")?;
+
+        // Create indexes
+        let indexes = vec![
+            "CREATE INDEX IF NOT EXISTS idx_agent_memory_agent_id ON agent_memory(agent_id)",
+            "CREATE INDEX IF NOT EXISTS idx_agent_memory_task_id ON agent_memory(task_id)",
+            "CREATE INDEX IF NOT EXISTS idx_agent_memory_timestamp ON agent_memory(timestamp DESC)",
+            "CREATE INDEX IF NOT EXISTS idx_agent_memory_event_type ON agent_memory(event_type)",
+            "CREATE INDEX IF NOT EXISTS idx_agent_memory_tool ON agent_memory(tool)",
+            "CREATE INDEX IF NOT EXISTS idx_agent_memory_task_agent ON agent_memory(task_id, agent_id)"
+        ];
+
+        for index in indexes {
+            sqlx::query(index)
+                .execute(pool)
+                .await
+                .context("Failed to create index")?;
+        }
+
+        Ok(())
+    }
+
+    pub async fn insert(&self, entry: &MemoryEntry) -> Result<i64> {
+        let metadata_json = entry.metadata.as_ref()
+            .map(|m| serde_json::to_string(m).ok())
+            .flatten();
+
+        let id = sqlx::query(r#"
+            INSERT INTO agent_memory
+            (agent_id, task_id, timestamp, event_type, tool, metadata, confidence)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        "#)
+        .bind(&entry.agent_id)
+        .bind(&entry.task_id)
+        .bind(entry.timestamp)
+        .bind(entry.event_type.to_string())
+        .bind(&entry.tool)
+        .bind(metadata_json)
+        .bind(entry.confidence)
+        .execute(&self.pool)
+        .await
+        .context("Failed to insert memory entry")?
+        .last_insert_rowid();
+
+        info!(
+            "Inserted memory entry for agent {} in task {}",
+            entry.agent_id, entry.task_id
+        );
+
+        Ok(id)
+    }
+
+    pub async fn query(&self, query: &MemoryQuery) -> Result<Vec<MemoryEntry>> {
+        let mut sql = "SELECT * FROM agent_memory WHERE 1=1".to_string();
+        let mut conditions = Vec::new();
+        let mut params = Vec::new();
+
+        if let Some(agent_id) = &query.agent_id {
+            conditions.push("agent_id = ?");
+            params.push(agent_id);
+        }
+
+        if let Some(task_id) = &query.task_id {
+            conditions.push("task_id = ?");
+            params.push(task_id);
+        }
+
+        if let Some(event_type) = &query.event_type {
+            conditions.push("event_type = ?");
+            params.push(&event_type.to_string());
+        }
+
+        if let Some(tool) = &query.tool {
+            conditions.push("tool = ?");
+            params.push(tool);
+        }
+
+        if let Some(start) = query.start_timestamp {
+            conditions.push("timestamp >= ?");
+            params.push(start);
+        }
+
+        if let Some(end) = query.end_timestamp {
+            conditions.push("timestamp <= ?");
+            params.push(end);
+        }
+
+        sql.push_str(" AND ");
+        sql.push_str(&conditions.join(" AND "));
+        sql.push_str(" ORDER BY timestamp DESC");
+
+        if let Some(limit) = query.limit {
+            sql.push_str(&format!(" LIMIT {}", limit));
+        }
+
+        let results = sqlx::query_as::<_, MemoryEntry>(&sql)
+            .fetch_all(&self.pool)
+            .await
+            .context("Failed to query memory entries")?;
+
+        Ok(results)
+    }
+}

package/.claude/skills/cfn-transparency-middleware/memory_schema.rs

@@ -0,0 +1,64 @@
+use serde::{Deserialize, Serialize};
+use sqlx::FromRow;
+use chrono::{DateTime, Utc};
+
+#[derive(Debug, Clone, Serialize, Deserialize, FromRow)]
+pub struct MemoryEntry {
+    pub id: Option<i64>,
+    pub agent_id: String,
+    pub task_id: String,
+    pub timestamp: i64,
+    pub event_type: EventType,
+    pub tool: Option<String>,
+    pub metadata: Option<String>,
+    pub confidence: Option<f64>,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum EventType {
+    Edit,
+    Write,
+    Bash,
+    Task,
+    Read,
+    Other(String),
+}
+
+impl From<&str> for EventType {
+    fn from(s: &str) -> Self {
+        match s {
+            "edit" => EventType::Edit,
+            "write" => EventType::Write,
+            "bash" => EventType::Bash,
+            "task" => EventType::Task,
+            "read" => EventType::Read,
+            _ => EventType::Other(s.to_string()),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MemoryQuery {
+    pub agent_id: Option<String>,
+    pub task_id: Option<String>,
+    pub event_type: Option<EventType>,
+    pub tool: Option<String>,
+    pub start_timestamp: Option<i64>,
+    pub end_timestamp: Option<i64>,
+    pub limit: Option<u32>,
+}
+
+impl Default for MemoryQuery {
+    fn default() -> Self {
+        Self {
+            agent_id: None,
+            task_id: None,
+            event_type: None,
+            tool: None,
+            start_timestamp: None,
+            end_timestamp: None,
+            limit: Some(100),
+        }
+    }
+}

package/.claude/skills/cfn-transparency-middleware/middleware-config.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# Transparency Middleware Configuration
+# Version: 1.0.0
+
+# Redis Configuration
+export REDIS_HOST="${REDIS_HOST:-localhost}"
+export REDIS_PORT="${REDIS_PORT:-6379}"
+
+# Transparency Levels
+TRANSPARENCY_LEVELS=(
+    "minimal"    # Minimal logging, low overhead
+    "detailed"   # Standard operational insights
+    "verbose"    # Comprehensive logging
+    "debug"      # Maximum verbosity and tracing
+)
+
+# Performance Thresholds
+export MAX_OVERHEAD_PERCENTAGE=5
+export MAX_MESSAGE_LATENCY_MS=50
+export MAX_MEMORY_USAGE_MB=10
+
+# Logging Configuration
+export LOG_RETENTION_DAYS=7
+export LOG_MAX_SIZE_MB=100
+
+# Test-specific Configuration
+export TEST_TIMEOUT_SECONDS=30
+export TEST_MESSAGE_COUNT=1000