claude-flow-novice 2.18.6 → 2.18.7

package/claude-assets/skills/cfn-ruvector-codebase-index/detect-stale-docs.sh

@@ -1,325 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-# Detect Stale Documentation Using RuVector
-#
-# Analyzes .md files to detect legacy/outdated documentation by:
-# 1. Extracting code references from documentation
-# 2. Checking if referenced files/functions still exist
-# 3. Finding documentation with no code references (orphaned)
-# 4. Detecting docs mentioning deprecated patterns
-#
-# Usage:
-#   detect-stale-docs.sh                    # Analyze all .md files
-#   detect-stale-docs.sh --report           # Generate detailed report
-#   detect-stale-docs.sh --cleanup          # Interactive cleanup mode
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-SEARCH_SCRIPT="$SCRIPT_DIR/search.sh"
-
-# Colors
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-MAGENTA='\033[0;35m'
-CYAN='\033[0;36m'
-NC='\033[0m'
-
-log_info() {
-  echo -e "${BLUE}[INFO]${NC} $*"
-}
-
-log_success() {
-  echo -e "${GREEN}[SUCCESS]${NC} $*"
-}
-
-log_warn() {
-  echo -e "${YELLOW}[WARN]${NC} $*"
-}
-
-log_error() {
-  echo -e "${RED}[ERROR]${NC} $*"
-}
-
-log_stale() {
-  echo -e "${MAGENTA}[STALE]${NC} $*"
-}
-
-# Find all .md files
-find_all_docs() {
-  find . -type f -name "*.md" \
-    -not -path "*/node_modules/*" \
-    -not -path "*/dist/*" \
-    -not -path "*/.git/*" \
-    -not -path "*/coverage/*" \
-    2>/dev/null || true
-}
-
-# Extract code file references from markdown
-# Looks for: src/file.ts, ./path/to/file.py, backtick code references
-extract_file_references() {
-  local md_file="$1"
-
-  # Pattern 1: Explicit file paths (src/file.ts, ./path/file.py)
-  grep -oE '\.?/?[a-zA-Z0-9_/-]+\.(ts|tsx|js|jsx|py|rs|go|java|sh)' "$md_file" 2>/dev/null || true
-
-  # Pattern 2: Backtick code references (`fileName.ts`)
-  grep -oE '`[a-zA-Z0-9_/-]+\.(ts|tsx|js|jsx|py|rs|go|java|sh)`' "$md_file" 2>/dev/null | tr -d '`' || true
-}
-
-# Extract function/class references from markdown
-extract_code_references() {
-  local md_file="$1"
-
-  # Pattern: `functionName()`, `ClassName`, `methodName()`
-  grep -oE '`[a-zA-Z_][a-zA-Z0-9_]*(\(\))?`' "$md_file" 2>/dev/null | tr -d '`()' || true
-}
-
-# Check if file exists in codebase
-file_exists_check() {
-  local file_ref="$1"
-
-  # Try exact path
-  if [[ -f "$file_ref" ]]; then
-    echo "exists"
-    return 0
-  fi
-
-  # Try without leading ./
-  local clean_path="${file_ref#./}"
-  if [[ -f "$clean_path" ]]; then
-    echo "exists"
-    return 0
-  fi
-
-  # Try searching in common directories
-  for prefix in "src/" "docker/" "tests/" "scripts/" ".claude/"; do
-    if [[ -f "${prefix}${clean_path}" ]]; then
-      echo "exists"
-      return 0
-    fi
-  done
-
-  echo "missing"
-  return 1
-}
-
-# Search for code reference in indexed codebase
-search_code_reference() {
-  local ref="$1"
-
-  # Use semantic search to find references
-  local results
-  results=$("$SEARCH_SCRIPT" "$ref" --top 1 2>/dev/null || echo "[]")
-
-  # Check if we got any results
-  local count
-  count=$(echo "$results" | jq -r 'length // 0')
-
-  if [[ $count -gt 0 ]]; then
-    echo "found"
-  else
-    echo "not-found"
-  fi
-}
-
-# Get file modification time
-get_file_age_days() {
-  local file="$1"
-  local mod_time
-
-  # macOS vs Linux stat
-  if [[ "$OSTYPE" == "darwin"* ]]; then
-    mod_time=$(stat -f %m "$file")
-  else
-    mod_time=$(stat -c %Y "$file")
-  fi
-
-  local current_time=$(date +%s)
-  local age_seconds=$((current_time - mod_time))
-  local age_days=$((age_seconds / 86400))
-
-  echo "$age_days"
-}
-
-# Analyze single markdown file
-analyze_doc() {
-  local md_file="$1"
-  local stale_score=0
-  local findings=()
-
-  # Get file age
-  local age_days
-  age_days=$(get_file_age_days "$md_file")
-
-  # Extract references
-  local file_refs
-  file_refs=$(extract_file_references "$md_file" | sort -u)
-
-  local code_refs
-  code_refs=$(extract_code_references "$md_file" | sort -u)
-
-  local total_file_refs=0
-  local missing_file_refs=0
-  local total_code_refs=0
-  local missing_code_refs=0
-
-  # Check file references
-  while IFS= read -r file_ref; do
-    [[ -z "$file_ref" ]] && continue
-    ((total_file_refs++))
-
-    if [[ $(file_exists_check "$file_ref") == "missing" ]]; then
-      ((missing_file_refs++))
-      findings+=("Missing file: $file_ref")
-    fi
-  done <<< "$file_refs"
-
-  # Check code references (sample first 10 to avoid too many API calls)
-  local code_refs_sample
-  code_refs_sample=$(echo "$code_refs" | head -10)
-
-  while IFS= read -r code_ref; do
-    [[ -z "$code_ref" ]] && continue
-    [[ ${#code_ref} -lt 3 ]] && continue  # Skip very short refs
-    ((total_code_refs++))
-
-    if [[ $(search_code_reference "$code_ref") == "not-found" ]]; then
-      ((missing_code_refs++))
-      findings+=("Not found in code: $code_ref")
-    fi
-  done <<< "$code_refs_sample"
-
-  # Calculate staleness score
-  # Age factor: 1 point per 90 days (old docs more likely stale)
-  local age_score=$((age_days / 90))
-  stale_score=$((stale_score + age_score))
-
-  # Missing references factor
-  if [[ $total_file_refs -gt 0 ]]; then
-    local missing_ratio=$((missing_file_refs * 100 / total_file_refs))
-    stale_score=$((stale_score + missing_ratio / 10))
-
-    if [[ $missing_ratio -gt 50 ]]; then
-      findings+=("HIGH: ${missing_ratio}% of file references are missing")
-    fi
-  fi
-
-  # No references at all (orphaned doc)
-  if [[ $total_file_refs -eq 0 && $total_code_refs -eq 0 ]]; then
-    stale_score=$((stale_score + 5))
-    findings+=("No code references found (orphaned)")
-  fi
-
-  # Check for deprecated keywords
-  if grep -qi "deprecated\|legacy\|old\|obsolete\|outdated" "$md_file"; then
-    stale_score=$((stale_score + 3))
-    findings+=("Contains deprecated/legacy keywords")
-  fi
-
-  # Output results
-  echo "$md_file|$stale_score|$age_days|$total_file_refs|$missing_file_refs|$total_code_refs|$missing_code_refs|$(IFS=';'; echo "${findings[*]}")"
-}
-
-# Main analysis
-main() {
-  local mode="${1:-}"
-
-  log_info "Detecting stale documentation..."
-  log_info "This may take a few minutes for large codebases..."
-  echo ""
-
-  local all_docs
-  all_docs=$(find_all_docs)
-
-  local total_docs
-  total_docs=$(echo "$all_docs" | wc -l)
-
-  log_info "Found $total_docs markdown files"
-  echo ""
-
-  # Results array
-  declare -a results
-  local progress=0
-
-  # Analyze each doc
-  while IFS= read -r md_file; do
-    [[ -z "$md_file" ]] && continue
-
-    ((progress++))
-    echo -ne "\r${BLUE}[PROGRESS]${NC} Analyzing $progress/$total_docs files..."
-
-    local result
-    result=$(analyze_doc "$md_file")
-    results+=("$result")
-  done <<< "$all_docs"
-
-  echo "" # New line after progress
-  echo ""
-
-  # Sort by staleness score (descending)
-  IFS=$'\n' sorted=($(sort -t'|' -k2 -nr <<<"${results[*]}"))
-
-  # Display results
-  echo -e "${GREEN}═══════════════════════════════════════════════════════════════${NC}"
-  echo -e "${GREEN}   Stale Documentation Report${NC}"
-  echo -e "${GREEN}═══════════════════════════════════════════════════════════════${NC}"
-  echo ""
-
-  local stale_count=0
-  local potentially_stale_count=0
-
-  for result in "${sorted[@]}"; do
-    IFS='|' read -r file score age total_files missing_files total_code missing_code findings <<< "$result"
-
-    # Skip if score is very low
-    [[ $score -lt 2 ]] && continue
-
-    # Determine status
-    local status
-    local status_color
-    if [[ $score -ge 10 ]]; then
-      status="STALE"
-      status_color="$RED"
-      ((stale_count++))
-    elif [[ $score -ge 5 ]]; then
-      status="LIKELY STALE"
-      status_color="$MAGENTA"
-      ((potentially_stale_count++))
-    else
-      status="POSSIBLY STALE"
-      status_color="$YELLOW"
-    fi
-
-    echo -e "${status_color}[${status}]${NC} Score: $score | Age: ${age}d"
-    echo "  File: $file"
-    echo "  References: ${total_files} files (${missing_files} missing), ${total_code} code refs (${missing_code} missing)"
-
-    if [[ -n "$findings" ]]; then
-      IFS=';' read -ra finding_array <<< "$findings"
-      for finding in "${finding_array[@]}"; do
-        echo "  - $finding"
-      done
-    fi
-
-    echo ""
-  done
-
-  # Summary
-  echo -e "${GREEN}═══════════════════════════════════════════════════════════════${NC}"
-  echo -e "${RED}Stale docs:${NC} $stale_count"
-  echo -e "${MAGENTA}Likely stale:${NC} $potentially_stale_count"
-  echo -e "${BLUE}Total analyzed:${NC} $total_docs"
-  echo -e "${GREEN}═══════════════════════════════════════════════════════════════${NC}"
-
-  # Recommendations
-  echo ""
-  log_info "Recommendations:"
-  echo "  1. Review files with score >= 10 for archival"
-  echo "  2. Update files with missing references"
-  echo "  3. Mark deprecated docs with clear warnings"
-  echo "  4. Consider moving legacy docs to /archive or /legacy directory"
-}
-
-main "$@"

package/claude-assets/skills/cfn-ruvector-codebase-index/embeddings.js

@@ -1,181 +0,0 @@
-#!/usr/bin/env node
-/**
- * OpenAI Embeddings Generator for RuVector Codebase Index
- *
- * Generates vector embeddings for code files using OpenAI's text-embedding-3-small model.
- * Supports batch processing and handles rate limiting.
- */
-
-import OpenAI from 'openai';
-import fs from 'fs';
-import path from 'path';
-
-const CONFIG = JSON.parse(fs.readFileSync(path.join(path.dirname(new URL(import.meta.url).pathname), 'config.json'), 'utf8'));
-
-// Initialize OpenAI client (direct API only - Z.ai doesn't support embeddings)
-const openai = new OpenAI({
-  apiKey: process.env.OPENAI_API_KEY,
-  baseURL: process.env.OPENAI_BASE_URL,
-});
-
-/**
- * Generate embedding for a single text input
- * @param {string} text - Input text to embed
- * @returns {Promise<number[]>} - 1536-dimensional embedding vector
- */
-async function generateEmbedding(text) {
-  try {
-    // Skip empty or very short text
-    if (!text || text.trim().length < 10) {
-      console.error('Error: Text too short for embedding (min 10 chars)');
-      return null;
-    }
-
-    const response = await openai.embeddings.create({
-      model: CONFIG.embeddingModel,
-      input: text,
-      dimensions: CONFIG.embeddingDimensions,
-    });
-
-    if (!response.data || !response.data[0] || !response.data[0].embedding) {
-      console.error('Error: OpenAI API returned empty response');
-      console.error('Response:', JSON.stringify(response, null, 2));
-      return null;
-    }
-
-    return response.data[0].embedding;
-  } catch (error) {
-    console.error('Error generating embedding:', error.message);
-    if (error.response) {
-      console.error('API Response:', error.response.status, error.response.data);
-    }
-    return null;
-  }
-}
-
-/**
- * Generate embeddings for multiple texts in batch
- * @param {string[]} texts - Array of texts to embed
- * @returns {Promise<number[][]>} - Array of embedding vectors
- */
-async function generateBatchEmbeddings(texts) {
-  const embeddings = [];
-
-  // Process in batches to respect rate limits
-  for (let i = 0; i < texts.length; i += CONFIG.batchSize) {
-    const batch = texts.slice(i, i + CONFIG.batchSize);
-
-    try {
-      const response = await openai.embeddings.create({
-        model: CONFIG.embeddingModel,
-        input: batch,
-        dimensions: CONFIG.embeddingDimensions,
-      });
-
-      embeddings.push(...response.data.map(d => d.embedding));
-
-      // Rate limiting: wait 100ms between batches
-      if (i + CONFIG.batchSize < texts.length) {
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }
-    } catch (error) {
-      console.error(`Error generating batch embeddings (batch ${i / CONFIG.batchSize + 1}):`, error.message);
-      throw error;
-    }
-  }
-
-  return embeddings;
-}
-
-/**
- * Store error pattern in RuVector
- */
-async function storeErrorPattern(doc) {
-  const data = JSON.parse(doc);
-  const { storeErrorPattern: storeError } = await import('./ruvector-learning.js');
-  return await storeError(data);
-}
-
-/**
- * Store learning in RuVector
- */
-async function storeLearning(doc) {
-  const data = JSON.parse(doc);
-  const { storeLearning: storeLrn } = await import('./ruvector-learning.js');
-  return await storeLrn(data);
-}
-
-/**
- * Query error patterns from RuVector
- */
-async function queryErrorPatterns(taskDescription, limit) {
-  const { queryErrorPatterns: queryErrors } = await import('./ruvector-learning.js');
-  return await queryErrors(taskDescription, limit);
-}
-
-/**
- * Query learnings from RuVector
- */
-async function queryLearnings(taskDescription, category, limit) {
-  const { queryLearnings: queryLrn } = await import('./ruvector-learning.js');
-  return await queryLrn(taskDescription, category, limit);
-}
-
-/**
- * CLI interface
- */
-async function main() {
-  const args = process.argv.slice(2);
-
-  if (args.length === 0) {
-    console.error('Usage: embeddings.js <command> [args...]');
-    console.error('Commands:');
-    console.error('  <text>                    - Generate embedding for text');
-    console.error('  --batch <file.json>       - Batch generate embeddings');
-    console.error('  store-error-pattern <doc> - Store error pattern');
-    console.error('  store-learning <doc>      - Store learning/pattern');
-    console.error('  query-error-patterns <desc> <limit> - Query error patterns');
-    console.error('  query-learnings <desc> <category> <limit> - Query learnings');
-    process.exit(1);
-  }
-
-  // Command routing
-  const command = args[0];
-
-  if (command === '--batch' && args[1]) {
-    // Batch mode: read JSON file with array of texts
-    const texts = JSON.parse(fs.readFileSync(args[1], 'utf8'));
-    const embeddings = await generateBatchEmbeddings(texts);
-    console.log(JSON.stringify(embeddings));
-  } else if (command === 'store-error-pattern' && args[1]) {
-    const result = await storeErrorPattern(args[1]);
-    console.log(JSON.stringify(result));
-  } else if (command === 'store-learning' && args[1]) {
-    const result = await storeLearning(args[1]);
-    console.log(JSON.stringify(result));
-  } else if (command === 'query-error-patterns' && args[1]) {
-    const limit = parseInt(args[2]) || 5;
-    const results = await queryErrorPatterns(args[1], limit);
-    console.log(JSON.stringify(results));
-  } else if (command === 'query-learnings' && args[1]) {
-    const category = args[2] || '';
-    const limit = parseInt(args[3]) || 5;
-    const results = await queryLearnings(args[1], category, limit);
-    console.log(JSON.stringify(results));
-  } else {
-    // Single mode: embed single text
-    const text = args.join(' ');
-    const embedding = await generateEmbedding(text);
-    console.log(JSON.stringify(embedding));
-  }
-}
-
-// Run if called directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  main().catch(err => {
-    console.error('Fatal error:', err);
-    process.exit(1);
-  });
-}
-
-export { generateEmbedding, generateBatchEmbeddings };

package/claude-assets/skills/cfn-ruvector-codebase-index/get-embedding-text.js

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-/**
- * Get Embedding Text - Helper script to generate embedding text for a file
- *
- * Usage: npx tsx get-embedding-text.js <file_path>
- *
- * Returns the embedding text string for use with embeddings.js
- */
-
-import { createEmbeddingText, parseFile } from './parser.js';
-
-const filePath = process.argv[2];
-
-if (!filePath) {
-  console.error('Usage: npx tsx get-embedding-text.js <file_path>');
-  process.exit(1);
-}
-
-try {
-  const metadata = parseFile(filePath);
-  const embeddingText = createEmbeddingText(filePath, metadata);
-  console.log(embeddingText);
-} catch (error) {
-  console.error('Error:', error.message);
-  process.exit(1);
-}

package/claude-assets/skills/cfn-ruvector-codebase-index/handle-file-moves.sh

@@ -1,147 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-# Handle File Moves in RuVector Index
-#
-# Detects file moves/renames from git and updates the index accordingly:
-# 1. Deletes old entry (with old path as ID)
-# 2. Indexes new entry (with new path as ID)
-#
-# This prevents orphaned entries when files are moved.
-#
-# Usage:
-#   handle-file-moves.sh                    # Auto-detect from last commit
-#   handle-file-moves.sh --from-diff        # Detect from staged changes
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-INDEX_SCRIPT="$SCRIPT_DIR/index.sh"
-
-# Colors
-BLUE='\033[0;34m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-RED='\033[0;31m'
-NC='\033[0m'
-
-log_info() {
-  echo -e "${BLUE}[INFO]${NC} $*"
-}
-
-log_success() {
-  echo -e "${GREEN}[SUCCESS]${NC} $*"
-}
-
-log_warn() {
-  echo -e "${YELLOW}[WARN]${NC} $*"
-}
-
-log_error() {
-  echo -e "${RED}[ERROR]${NC} $*"
-}
-
-# Delete entry from RuVector by file path (ID)
-delete_entry() {
-  local file_path="$1"
-
-  log_info "Deleting old entry: $file_path"
-
-  PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
-
-  node -e "
-    import { getCollection, COLLECTIONS } from '$PROJECT_ROOT/docker/trigger-dev/src/lib/ruvector-init.ts';
-
-    (async () => {
-      try {
-        const collection = getCollection(COLLECTIONS.CODEBASE_INDEX);
-
-        // RuVector delete by ID
-        await collection.delete('$file_path');
-
-        console.log('Deleted: $file_path');
-      } catch (error) {
-        // Entry might not exist, that's OK
-        console.log('Entry not found (already deleted or never indexed): $file_path');
-      }
-    })();
-  " || {
-    log_warn "Could not delete entry for: $file_path"
-  }
-}
-
-# Get file moves from last commit
-get_moves_from_commit() {
-  # Git diff-tree with --find-renames detects moves
-  # Format: R<percentage> <old-path> <new-path>
-  git diff-tree --no-commit-id --name-status --find-renames=90 -r HEAD 2>/dev/null | grep "^R" || true
-}
-
-# Get file moves from staged changes
-get_moves_from_staged() {
-  git diff --cached --name-status --find-renames=90 2>/dev/null | grep "^R" || true
-}
-
-# Process file moves
-process_moves() {
-  local moves="$1"
-  local move_count=0
-  local success_count=0
-
-  while IFS=$'\t' read -r status old_path new_path; do
-    [[ -z "$old_path" || -z "$new_path" ]] && continue
-
-    # Extract just the file paths (remove R100, R095 prefix)
-    status_code="${status#R}"
-
-    log_info "Detected move: $old_path -> $new_path (${status_code}% similar)"
-
-    ((move_count++))
-
-    # Delete old entry
-    delete_entry "$old_path"
-
-    # Index new entry (if file exists)
-    if [[ -f "$new_path" ]]; then
-      log_info "Re-indexing at new location: $new_path"
-
-      if "$INDEX_SCRIPT" --files "$new_path" 2>&1 | grep -q "Indexed: 1 files"; then
-        ((success_count++))
-        log_success "Updated index: $old_path -> $new_path"
-      else
-        log_error "Failed to index new location: $new_path"
-      fi
-    else
-      log_warn "New file not found (deleted?): $new_path"
-    fi
-
-  done <<< "$moves"
-
-  echo ""
-  if [[ $move_count -gt 0 ]]; then
-    log_success "Processed $move_count file move(s), $success_count successful"
-  else
-    log_info "No file moves detected"
-  fi
-}
-
-# Main
-main() {
-  local mode="${1:---from-commit}"
-
-  log_info "Detecting file moves..."
-
-  local moves
-  if [[ "$mode" == "--from-staged" ]]; then
-    moves=$(get_moves_from_staged)
-  else
-    moves=$(get_moves_from_commit)
-  fi
-
-  if [[ -z "$moves" ]]; then
-    log_info "No file moves detected"
-    exit 0
-  fi
-
-  process_moves "$moves"
-}
-
-main "$@"