claude-flow-novice 2.8.1 → 2.9.0

package/.claude/skills/ace-system/invoke-context-inject.sh

@@ -1,166 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# ACE Context Injection Wrapper
-# Dynamically injects context into execution environments
-#
-# Usage:
-#   ./invoke-context-inject.sh --context-file <file> --target-task <id> [OPTIONS]
-#
-# Arguments:
-#   --context-file     Source context JSON file (required)
-#   --target-task      Task ID to inject into (required)
-#   --merge-strategy   Merge strategy: simple, deep, priority-weighted, consensus-weighted
-#   --output           Output file path (optional, default: stdout)
-#   --memory-path      SQLite memory path (optional)
-##############################################################################
-
-set -euo pipefail
-
-# Default values
-CONTEXT_FILE=""
-TARGET_TASK=""
-MERGE_STRATEGY="deep"
-OUTPUT=""
-MEMORY_PATH="${ACE_MEMORY_PATH:-./.artifacts/database/swarm-memory.db}"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --context-file)
-      CONTEXT_FILE="$2"
-      shift 2
-      ;;
-    --target-task)
-      TARGET_TASK="$2"
-      shift 2
-      ;;
-    --merge-strategy)
-      MERGE_STRATEGY="$2"
-      shift 2
-      ;;
-    --output)
-      OUTPUT="$2"
-      shift 2
-      ;;
-    --memory-path)
-      MEMORY_PATH="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$CONTEXT_FILE" ] || [ -z "$TARGET_TASK" ]; then
-  echo "Error: --context-file and --target-task are required"
-  echo "Usage: $0 --context-file <file> --target-task <id> [OPTIONS]"
-  exit 1
-fi
-
-if [ ! -f "$CONTEXT_FILE" ]; then
-  echo "Error: Context file not found: $CONTEXT_FILE"
-  exit 1
-fi
-
-# Validate context file JSON
-if ! jq . "$CONTEXT_FILE" > /dev/null 2>&1; then
-  echo "Error: Invalid JSON in context file"
-  exit 1
-fi
-
-# Get project root
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Create Node.js runner script
-RUNNER_SCRIPT=$(mktemp --suffix=.mjs)
-trap "rm -f $RUNNER_SCRIPT" EXIT
-
-cat > "$RUNNER_SCRIPT" << EOF
-import ContextInjector from '${PROJECT_ROOT}/dist/ace/context-injection.js';
-import { readFileSync } from 'fs';
-
-const contextFile = process.argv[2];
-const targetTask = process.argv[3];
-const mergeStrategy = process.argv[4];
-
-const contextInjector = new ContextInjector();
-
-// Load source context
-const sourceContext = JSON.parse(readFileSync(contextFile, 'utf-8'));
-
-// Prepare target object for injection
-const target = {
-  taskId: targetTask,
-  timestamp: Date.now(),
-  status: 'pending'
-};
-
-// Strategy-specific injection
-async function injectByStrategy() {
-  switch (mergeStrategy) {
-    case 'simple':
-      // Simple override
-      return { ...target, ...sourceContext };
-
-    case 'deep':
-      // Deep merge using context injector
-      return await contextInjector.injectContext(target, sourceContext);
-
-    case 'priority-weighted':
-      // Weighted merge based on priority field
-      const prioritized = Object.entries(sourceContext)
-        .sort(([, a], [, b]) => {
-          const priorityA = typeof a === 'object' && a.priority ? a.priority : 0;
-          const priorityB = typeof b === 'object' && b.priority ? b.priority : 0;
-          return priorityB - priorityA;
-        })
-        .reduce((acc, [key, value]) => {
-          acc[key] = value;
-          return acc;
-        }, {});
-      return await contextInjector.injectContext(target, prioritized);
-
-    case 'consensus-weighted':
-      // Weight by consensus confidence if available
-      const weighted = Object.entries(sourceContext)
-        .filter(([, value]) => {
-          if (typeof value === 'object' && value.confidence !== undefined) {
-            return value.confidence >= 0.5; // Filter low confidence
-          }
-          return true;
-        })
-        .reduce((acc, [key, value]) => {
-          acc[key] = value;
-          return acc;
-        }, {});
-      return await contextInjector.injectContext(target, weighted);
-
-    default:
-      throw new Error(`Unknown merge strategy: ${mergeStrategy}`);
-  }
-}
-
-const injectedContext = await injectByStrategy();
-
-console.log(JSON.stringify({
-  taskId: targetTask,
-  mergeStrategy,
-  injectedAt: Date.now(),
-  context: injectedContext
-}, null, 2));
-EOF
-
-# Execute injection
-cd "$PROJECT_ROOT"
-
-if [ -n "$OUTPUT" ]; then
-  node "$RUNNER_SCRIPT" "$CONTEXT_FILE" "$TARGET_TASK" "$MERGE_STRATEGY" > "$OUTPUT"
-  echo "Injected context saved to: $OUTPUT" >&2
-else
-  node "$RUNNER_SCRIPT" "$CONTEXT_FILE" "$TARGET_TASK" "$MERGE_STRATEGY"
-fi

package/.claude/skills/ace-system/invoke-context-query.sh

@@ -1,127 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# ACE Context Query Wrapper
-# Searches for similar contexts using keyword matching
-#
-# Usage:
-#   ./invoke-context-query.sh --keywords "keyword1,keyword2" [OPTIONS]
-#
-# Arguments:
-#   --keywords              Comma-separated keywords (required)
-#   --similarity-threshold  Minimum similarity (0.0-1.0, default: 0.7)
-#   --max-results          Maximum results (default: 10)
-#   --memory-path          SQLite memory path (optional)
-##############################################################################
-
-set -euo pipefail
-
-# Default values
-KEYWORDS=""
-SIMILARITY_THRESHOLD=0.7
-MAX_RESULTS=10
-MEMORY_PATH="${ACE_MEMORY_PATH:-./.artifacts/database/swarm-memory.db}"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --keywords)
-      KEYWORDS="$2"
-      shift 2
-      ;;
-    --similarity-threshold)
-      SIMILARITY_THRESHOLD="$2"
-      shift 2
-      ;;
-    --max-results)
-      MAX_RESULTS="$2"
-      shift 2
-      ;;
-    --memory-path)
-      MEMORY_PATH="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$KEYWORDS" ]; then
-  echo "Error: --keywords is required"
-  echo "Usage: $0 --keywords 'keyword1,keyword2' [OPTIONS]"
-  exit 1
-fi
-
-# Get project root
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Create Node.js runner script
-RUNNER_SCRIPT=$(mktemp --suffix=.mjs)
-trap "rm -f $RUNNER_SCRIPT" EXIT
-
-cat > "$RUNNER_SCRIPT" << EOF
-import { SQLiteMemorySystem } from '${PROJECT_ROOT}/dist/memory/sqlite-memory-system.js';
-
-const keywords = process.argv[2].split(',').map(k => k.trim().toLowerCase());
-const similarityThreshold = parseFloat(process.argv[3]);
-const maxResults = parseInt(process.argv[4]);
-const memoryPath = process.argv[5];
-
-const memorySystem = new SQLiteMemorySystem(memoryPath);
-await memorySystem.initialize();
-
-// Calculate Jaccard similarity
-function jaccardSimilarity(set1, set2) {
-  const intersection = set1.filter(x => set2.includes(x));
-  const union = [...new Set([...set1, ...set2])];
-  return intersection.length / union.length;
-}
-
-// Extract keywords from context
-function extractKeywords(context) {
-  const text = JSON.stringify(context).toLowerCase();
-  const words = text.match(/\b\w+\b/g) || [];
-  return [...new Set(words)];
-}
-
-async function queryContexts() {
-  const db = memorySystem['db'];
-  if (!db) {
-    throw new Error('Database not initialized');
-  }
-
-  const rows = db.prepare('SELECT * FROM cognitive_reflections ORDER BY timestamp DESC').all();
-
-  const results = rows.map(row => {
-    const context = JSON.parse(row.context);
-    const contextKeywords = extractKeywords(context);
-    const similarity = jaccardSimilarity(keywords, contextKeywords);
-
-    return {
-      id: row.id,
-      timestamp: row.timestamp,
-      complexity: row.complexity,
-      similarity,
-      context,
-      insights: JSON.parse(row.insights)
-    };
-  });
-
-  // Filter by similarity threshold and sort
-  return results
-    .filter(r => r.similarity >= similarityThreshold)
-    .sort((a, b) => b.similarity - a.similarity)
-    .slice(0, maxResults);
-}
-
-const results = await queryContexts();
-console.log(JSON.stringify(results, null, 2));
-EOF
-
-# Execute query
-cd "$PROJECT_ROOT"
-node "$RUNNER_SCRIPT" "$KEYWORDS" "$SIMILARITY_THRESHOLD" "$MAX_RESULTS" "$MEMORY_PATH"

package/.claude/skills/ace-system/invoke-context-reflect.sh

@@ -1,98 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# ACE Context Reflection Wrapper
-# Generates cognitive reflections on context data
-#
-# Usage:
-#   ./invoke-context-reflect.sh --context '{"task": "..."}' [OPTIONS]
-#
-# Arguments:
-#   --context          JSON context object (required)
-#   --complexity       Override complexity calculation (optional)
-#   --output           Output file path (optional, default: stdout)
-#   --memory-path      SQLite memory path (optional)
-##############################################################################
-
-set -euo pipefail
-
-# Default values
-CONTEXT=""
-COMPLEXITY=""
-OUTPUT=""
-MEMORY_PATH="${ACE_MEMORY_PATH:-./.artifacts/database/swarm-memory.db}"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --context)
-      CONTEXT="$2"
-      shift 2
-      ;;
-    --complexity)
-      COMPLEXITY="$2"
-      shift 2
-      ;;
-    --output)
-      OUTPUT="$2"
-      shift 2
-      ;;
-    --memory-path)
-      MEMORY_PATH="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$CONTEXT" ]; then
-  echo "Error: --context is required"
-  echo "Usage: $0 --context '{\"task\": \"...\"}' [OPTIONS]"
-  exit 1
-fi
-
-# Validate JSON
-if ! echo "$CONTEXT" | jq . > /dev/null 2>&1; then
-  echo "Error: Invalid JSON context"
-  exit 1
-fi
-
-# Get project root
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Execute reflection using Node.js with inline code
-if [ -n "$OUTPUT" ]; then
-  node --input-type=module --eval "
-import ACEReflector from '${PROJECT_ROOT}/dist/ace/ace-reflector.js';
-
-const context = JSON.parse(process.argv[1]);
-const complexity = process.argv[2] ? parseFloat(process.argv[2]) : undefined;
-const memoryPath = process.argv[3];
-
-const reflector = new ACEReflector(memoryPath);
-await reflector.initialize();
-
-const reflection = await reflector.reflect(context, { complexity });
-console.log(JSON.stringify(reflection, null, 2));
-" "$CONTEXT" "$COMPLEXITY" "$MEMORY_PATH" > "$OUTPUT"
-  echo "Reflection saved to: $OUTPUT" >&2
-else
-  node --input-type=module --eval "
-import ACEReflector from '${PROJECT_ROOT}/dist/ace/ace-reflector.js';
-
-const context = JSON.parse(process.argv[1]);
-const complexity = process.argv[2] ? parseFloat(process.argv[2]) : undefined;
-const memoryPath = process.argv[3];
-
-const reflector = new ACEReflector(memoryPath);
-await reflector.initialize();
-
-const reflection = await reflector.reflect(context, { complexity });
-console.log(JSON.stringify(reflection, null, 2));
-" "$CONTEXT" "$COMPLEXITY" "$MEMORY_PATH"
-fi

package/.claude/skills/ace-system/invoke-context-stats.sh

@@ -1,188 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# ACE Context Statistics Wrapper
-# Queries reflection database for statistics and analysis
-#
-# Usage:
-#   ./invoke-context-stats.sh --query <type> [OPTIONS]
-#
-# Arguments:
-#   --query            Query type: reflections, insights, summary (required)
-#   --filter           MongoDB-style filter JSON (optional)
-#   --limit            Maximum results (default: 100)
-#   --memory-path      SQLite memory path (optional)
-##############################################################################
-
-set -euo pipefail
-
-# Default values
-QUERY=""
-FILTER="{}"
-LIMIT=100
-MEMORY_PATH="${ACE_MEMORY_PATH:-./.artifacts/database/swarm-memory.db}"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --query)
-      QUERY="$2"
-      shift 2
-      ;;
-    --filter)
-      FILTER="$2"
-      shift 2
-      ;;
-    --limit)
-      LIMIT="$2"
-      shift 2
-      ;;
-    --memory-path)
-      MEMORY_PATH="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Validation
-if [ -z "$QUERY" ]; then
-  echo "Error: --query is required"
-  echo "Usage: $0 --query <reflections|insights|summary> [OPTIONS]"
-  exit 1
-fi
-
-# Validate filter JSON
-if ! echo "$FILTER" | jq . > /dev/null 2>&1; then
-  echo "Error: Invalid JSON filter"
-  exit 1
-fi
-
-# Get project root
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Create Node.js runner script
-RUNNER_SCRIPT=$(mktemp --suffix=.mjs)
-trap "rm -f $RUNNER_SCRIPT" EXIT
-
-cat > "$RUNNER_SCRIPT" << EOF
-import { SQLiteMemorySystem } from '${PROJECT_ROOT}/dist/memory/sqlite-memory-system.js';
-import { AccessLevel } from '${PROJECT_ROOT}/dist/memory/memory-adapter.js';
-
-const queryType = process.argv[2];
-const filter = JSON.parse(process.argv[3]);
-const limit = parseInt(process.argv[4]);
-const memoryPath = process.argv[5];
-
-const memorySystem = new SQLiteMemorySystem(memoryPath);
-await memorySystem.initialize();
-
-async function queryReflections() {
-  // Query all reflections matching filter
-  const db = memorySystem['db'];
-  if (!db) {
-    throw new Error('Database not initialized');
-  }
-
-  let sql = 'SELECT * FROM cognitive_reflections';
-  const whereClauses = [];
-  const params = [];
-
-  // Apply filters
-  if (filter.complexity) {
-    if (filter.complexity.$gt !== undefined) {
-      whereClauses.push('complexity > ?');
-      params.push(filter.complexity.$gt);
-    }
-    if (filter.complexity.$lt !== undefined) {
-      whereClauses.push('complexity < ?');
-      params.push(filter.complexity.$lt);
-    }
-  }
-
-  if (filter.timestamp) {
-    if (filter.timestamp.$gt !== undefined) {
-      whereClauses.push('timestamp > ?');
-      params.push(filter.timestamp.$gt);
-    }
-  }
-
-  if (whereClauses.length > 0) {
-    sql += ' WHERE ' + whereClauses.join(' AND ');
-  }
-
-  sql += ' ORDER BY timestamp DESC LIMIT ?';
-  params.push(limit);
-
-  const rows = db.prepare(sql).all(...params);
-
-  return rows.map(row => ({
-    id: row.id,
-    timestamp: row.timestamp,
-    complexity: row.complexity,
-    context: JSON.parse(row.context),
-    insights: JSON.parse(row.insights)
-  }));
-}
-
-async function queryInsights() {
-  const reflections = await queryReflections();
-  const allInsights = reflections.flatMap(r => r.insights);
-
-  // Count insight frequency
-  const insightCounts = {};
-  allInsights.forEach(insight => {
-    insightCounts[insight] = (insightCounts[insight] || 0) + 1;
-  });
-
-  return Object.entries(insightCounts)
-    .map(([insight, count]) => ({ insight, count }))
-    .sort((a, b) => b.count - a.count);
-}
-
-async function querySummary() {
-  const reflections = await queryReflections();
-
-  const complexities = reflections.map(r => r.complexity);
-  const avgComplexity = complexities.reduce((a, b) => a + b, 0) / complexities.length;
-  const maxComplexity = Math.max(...complexities);
-  const minComplexity = Math.min(...complexities);
-
-  return {
-    totalReflections: reflections.length,
-    avgComplexity: avgComplexity || 0,
-    maxComplexity: maxComplexity || 0,
-    minComplexity: minComplexity || 0,
-    timeRange: {
-      earliest: Math.min(...reflections.map(r => r.timestamp)),
-      latest: Math.max(...reflections.map(r => r.timestamp))
-    }
-  };
-}
-
-let result;
-
-switch (queryType) {
-  case 'reflections':
-    result = await queryReflections();
-    break;
-  case 'insights':
-    result = await queryInsights();
-    break;
-  case 'summary':
-    result = await querySummary();
-    break;
-  default:
-    throw new Error(`Unknown query type: ${queryType}`);
-}
-
-console.log(JSON.stringify(result, null, 2));
-EOF
-
-# Execute query
-cd "$PROJECT_ROOT"
-node "$RUNNER_SCRIPT" "$QUERY" "$FILTER" "$LIMIT" "$MEMORY_PATH"

package/.claude/skills/ace-system/log-merge.sh

@@ -1,67 +0,0 @@
-#!/bin/bash
-# Log merge action to context_merge_log
-# Usage: ./log-merge.sh --merge-type new_bullet --bullet-id STRAT-007 --reflection-id refl-123
-
-set -e
-
-DB_PATH="${ACE_DB_PATH:-./.artifacts/database/swarm-memory.db}"
-MERGE_TYPE=""
-BULLET_ID=""
-REFLECTION_ID=""
-SIMILARITY_SCORE=""
-CURATOR_REASONING=""
-MERGED_FROM_IDS="[]"
-
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --merge-type) MERGE_TYPE="$2"; shift 2 ;;
-    --bullet-id) BULLET_ID="$2"; shift 2 ;;
-    --reflection-id) REFLECTION_ID="$2"; shift 2 ;;
-    --similarity-score) SIMILARITY_SCORE="$2"; shift 2 ;;
-    --curator-reasoning) CURATOR_REASONING="$2"; shift 2 ;;
-    --merged-from-ids) MERGED_FROM_IDS="$2"; shift 2 ;;
-    *) echo "Unknown option: $1"; exit 1 ;;
-  esac
-done
-
-if [ -z "$MERGE_TYPE" ] || [ -z "$BULLET_ID" ]; then
-  echo "Error: --merge-type and --bullet-id required"
-  exit 1
-fi
-
-LOG_ID="merge-$(date +%s)-$(openssl rand -hex 3)"
-
-sqlite3 "$DB_PATH" <<EOF
-CREATE TABLE IF NOT EXISTS context_merge_log (
-    id TEXT PRIMARY KEY,
-    merge_type TEXT NOT NULL CHECK (merge_type IN ('new_bullet', 'increment_helpful', 'increment_harmful', 'merge_similar', 'archive', 'edit', 'version_bump')),
-    bullet_id TEXT NOT NULL,
-    reflection_id TEXT,
-    old_content TEXT,
-    new_content TEXT,
-    similarity_score REAL,
-    merged_from_bullet_ids TEXT,
-    curator_agent_id TEXT,
-    curator_reasoning TEXT,
-    acl_level INTEGER NOT NULL DEFAULT 5 CHECK (acl_level BETWEEN 1 AND 6),
-    swarm_id TEXT,
-    project_id TEXT,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-);
-
-INSERT INTO context_merge_log (
-  id, merge_type, bullet_id, reflection_id, similarity_score,
-  merged_from_bullet_ids, curator_reasoning, acl_level
-) VALUES (
-  '${LOG_ID}',
-  '${MERGE_TYPE}',
-  '${BULLET_ID}',
-  $([ -n "$REFLECTION_ID" ] && echo "'$REFLECTION_ID'" || echo "NULL"),
-  $([ -n "$SIMILARITY_SCORE" ] && echo "${SIMILARITY_SCORE}" || echo "NULL"),
-  '${MERGED_FROM_IDS}',
-  '${CURATOR_REASONING}',
-  5
-);
-EOF
-
-echo "{\"status\":\"success\",\"log_id\":\"${LOG_ID}\",\"merge_type\":\"${MERGE_TYPE}\"}"

package/.claude/skills/ace-system/query-reflections.sh

@@ -1,35 +0,0 @@
-#!/bin/bash
-# Query pending reflections from context_reflections table
-# Usage: ./query-reflections.sh --status pending --limit 10
-
-set -e
-
-DB_PATH="${ACE_DB_PATH:-./.artifacts/database/swarm-memory.db}"
-STATUS="pending"
-LIMIT=10
-
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --status) STATUS="$2"; shift 2 ;;
-    --limit) LIMIT="$2"; shift 2 ;;
-    *) echo "Unknown option: $1"; exit 1 ;;
-  esac
-done
-
-sqlite3 "$DB_PATH" <<EOF
-SELECT json_group_array(
-  json_object(
-    'id', id,
-    'reflection_type', reflection_type,
-    'task_id', task_id,
-    'extracted_lessons', extracted_lessons,
-    'created_at', created_at
-  )
-)
-FROM (
-  SELECT * FROM context_reflections
-  WHERE curator_status = '${STATUS}'
-  ORDER BY created_at DESC
-  LIMIT ${LIMIT}
-);
-EOF