claude-flow-novice 2.6.0 → 2.9.0

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

@@ -1,235 +0,0 @@
-#!/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/../../.." && 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/transparency-middleware/memory_query.rs

@@ -1,85 +0,0 @@
-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/transparency-middleware/memory_repository.rs

@@ -1,140 +0,0 @@
-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/transparency-middleware/memory_schema.rs

@@ -1,64 +0,0 @@
-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/transparency-middleware/middleware-config.sh

@@ -1,29 +0,0 @@
-#!/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

package/.claude/skills/transparency-middleware/performance-benchmark.sh

@@ -1,79 +0,0 @@
-#!/bin/bash
-
-# Performance Benchmarking for Transparency Middleware
-# Version: 1.0.0
-# Measures message throughput, overhead, and memory usage
-
-set -euo pipefail
-
-# Source configuration
-source .claude/skills/transparency-middleware/middleware-config.sh
-
-# Benchmarking results file
-BENCHMARK_RESULTS="/tmp/transparency_benchmark_$(date +%Y%m%d_%H%M%S).json"
-
-# Performance Test Parameters
-TOTAL_MESSAGES=10000
-CONCURRENCY_LEVELS=(1 10 100)
-
-measure_performance() {
-    local concurrency="$1"
-    local start_time=$(date +%s.%N)
-    local peak_memory=0
-    local total_cpu_usage=0
-
-    # Simulate message processing
-    for ((i=0; i<TOTAL_MESSAGES; i++)); do
-        ./invoke-transparency-middleware.sh process \
-            --concurrency "$concurrency" \
-            --message-id "$i" &
-    done
-
-    wait
-
-    local end_time=$(date +%s.%N)
-    local duration=$(echo "$end_time - $start_time" | bc)
-    local messages_per_second=$(echo "$TOTAL_MESSAGES / $duration" | bc)
-
-    # Record performance metrics
-    jq -n \
-        --arg concurrency "$concurrency" \
-        --arg messages_total "$TOTAL_MESSAGES" \
-        --arg duration "$duration" \
-        --arg messages_per_second "$messages_per_second" \
-        '{
-            "concurrency": $concurrency,
-            "total_messages": $messages_total,
-            "duration_seconds": $duration,
-            "messages_per_second": $messages_per_second
-        }' > "$BENCHMARK_RESULTS"
-
-    # Validate performance
-    validate_performance "$messages_per_second"
-}
-
-validate_performance() {
-    local messages_per_second="$1"
-    local max_threshold=5000  # Adjust based on your system capabilities
-
-    if (( $(echo "$messages_per_second < $max_threshold" | bc -l) )); then
-        echo "Performance Test PASSED"
-        redis-cli publish "swarm:sprint-1.2:performance" "benchmark_passed:1.0"
-    else
-        echo "Performance Test FAILED"
-        redis-cli publish "swarm:sprint-1.2:performance" "benchmark_failed:0.0"
-        exit 1
-    fi
-}
-
-main() {
-    echo "Starting Transparency Middleware Performance Benchmarks"
-
-    for concurrency in "${CONCURRENCY_LEVELS[@]}"; do
-        measure_performance "$concurrency"
-    done
-
-    cat "$BENCHMARK_RESULTS"
-}
-
-main