fss-link 1.6.1 → 1.6.12

package/scripts/emergency-kill-vitest.sh

@@ -1,95 +0,0 @@
-#!/bin/bash
-
-# 🚨 EMERGENCY VITEST KILLER - System Recovery Script
-# Purpose: Kill all vitest processes when they consume excessive memory
-# Usage: ./scripts/emergency-kill-vitest.sh [--force]
-
-set -e
-
-# Colors for output
-RED='\033[0;31m'
-YELLOW='\033[1;33m'
-GREEN='\033[0;32m'
-NC='\033[0m' # No Color
-
-echo -e "${RED}🚨 EMERGENCY VITEST KILLER ACTIVATED${NC}"
-echo "Scanning for vitest processes..."
-
-# Find all vitest-related processes
-VITEST_PIDS=$(pgrep -f "vitest\|node.*test" 2>/dev/null || true)
-NODE_TEST_PIDS=$(pgrep -f "node.*\.test\." 2>/dev/null || true)
-ALL_PIDS="${VITEST_PIDS} ${NODE_TEST_PIDS}"
-
-if [ -z "$ALL_PIDS" ]; then
-    echo -e "${GREEN}✅ No vitest processes found running${NC}"
-    exit 0
-fi
-
-echo -e "${YELLOW}Found processes to kill:${NC}"
-echo "$ALL_PIDS" | tr ' ' '\n' | while read -r pid; do
-    if [ -n "$pid" ]; then
-        ps -p "$pid" -o pid,ppid,%cpu,%mem,cmd 2>/dev/null || true
-    fi
-done
-
-# Check for --force flag
-if [ "$1" = "--force" ]; then
-    echo -e "${RED}🔥 FORCE MODE: Killing immediately...${NC}"
-else
-    echo ""
-    echo -e "${YELLOW}⚠️  WARNING: This will kill ALL vitest and node test processes${NC}"
-    echo "Press ENTER to continue, or Ctrl+C to cancel..."
-    read -r
-fi
-
-# Kill processes gracefully first (SIGTERM)
-echo -e "${YELLOW}🔄 Attempting graceful shutdown (SIGTERM)...${NC}"
-for pid in $ALL_PIDS; do
-    if [ -n "$pid" ]; then
-        kill -TERM "$pid" 2>/dev/null || true
-        echo "Sent SIGTERM to PID $pid"
-    fi
-done
-
-# Wait 3 seconds for graceful shutdown
-echo "Waiting 3 seconds for graceful shutdown..."
-sleep 3
-
-# Check what's still running
-REMAINING_PIDS=$(pgrep -f "vitest\|node.*test" 2>/dev/null || true)
-if [ -n "$REMAINING_PIDS" ]; then
-    echo -e "${RED}💀 Force killing remaining processes (SIGKILL)...${NC}"
-    for pid in $REMAINING_PIDS; do
-        if [ -n "$pid" ]; then
-            kill -KILL "$pid" 2>/dev/null || true
-            echo "Sent SIGKILL to PID $pid"
-        fi
-    done
-else
-    echo -e "${GREEN}✅ All processes terminated gracefully${NC}"
-fi
-
-# Final verification
-sleep 1
-FINAL_CHECK=$(pgrep -f "vitest\|node.*test" 2>/dev/null || true)
-if [ -n "$FINAL_CHECK" ]; then
-    echo -e "${RED}❌ Some processes still running:${NC}"
-    echo "$FINAL_CHECK" | tr ' ' '\n' | while read -r pid; do
-        if [ -n "$pid" ]; then
-            ps -p "$pid" -o pid,ppid,%cpu,%mem,cmd 2>/dev/null || true
-        fi
-    done
-    echo ""
-    echo -e "${YELLOW}💡 You may need to run: sudo kill -9 <PID>${NC}"
-else
-    echo -e "${GREEN}🎉 SUCCESS: All vitest processes killed${NC}"
-fi
-
-# Memory recovery suggestions
-echo ""
-echo -e "${YELLOW}🔧 Memory Recovery Suggestions:${NC}"
-echo "1. Run: sync && echo 3 | sudo tee /proc/sys/vm/drop_caches"
-echo "2. Check memory: free -h"
-echo "3. Check for zombie processes: ps aux | grep defunct"
-echo ""
-echo -e "${GREEN}Emergency kill complete!${NC}"

package/scripts/extract-session-logs.sh

@@ -1,202 +0,0 @@
-#!/bin/bash
-# FSS Link Session Log Extractor
-# Extracts and organizes session logs from FSS Link checkpoint files
-
-set -euo pipefail
-
-# Configuration
-FSS_LINK_TMP_DIR="${HOME}/.fss-link/tmp"
-OUTPUT_DIR="/MASTERFOLDER/Projects/fss-link/fss-live-testing/session-logs"
-RAW_DIR="${OUTPUT_DIR}/raw"
-PROCESSED_DIR="${OUTPUT_DIR}/processed"
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Usage information
-usage() {
-    cat << EOF
-Usage: $0 [OPTIONS]
-
-Extract FSS Link session logs and prepare them for RAG indexing.
-
-OPTIONS:
-    -d, --days DAYS       Extract logs from last N days (default: 7)
-    -a, --all             Extract all available logs
-    -t, --tool TOOL       Filter by tool name (e.g., grep, read, write)
-    -s, --session ID      Extract specific session by ID
-    -l, --list            List available sessions
-    -h, --help            Show this help message
-
-EXAMPLES:
-    $0 --days 1                    # Extract logs from last 24 hours
-    $0 --tool grep                 # Extract only grep-related sessions
-    $0 --session 05e09634...       # Extract specific session
-    $0 --list                      # List all available sessions
-
-OUTPUT:
-    Raw logs:       ${RAW_DIR}/
-    Processed logs: ${PROCESSED_DIR}/
-    Analysis:       ${OUTPUT_DIR}/analysis/
-EOF
-    exit 1
-}
-
-# Parse arguments
-DAYS=7
-EXTRACT_ALL=false
-TOOL_FILTER=""
-SESSION_ID=""
-LIST_ONLY=false
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        -d|--days)
-            DAYS="$2"
-            shift 2
-            ;;
-        -a|--all)
-            EXTRACT_ALL=true
-            shift
-            ;;
-        -t|--tool)
-            TOOL_FILTER="$2"
-            shift 2
-            ;;
-        -s|--session)
-            SESSION_ID="$2"
-            shift 2
-            ;;
-        -l|--list)
-            LIST_ONLY=true
-            shift
-            ;;
-        -h|--help)
-            usage
-            ;;
-        *)
-            echo -e "${RED}Unknown option: $1${NC}"
-            usage
-            ;;
-    esac
-done
-
-# Ensure output directories exist
-mkdir -p "${RAW_DIR}" "${PROCESSED_DIR}" "${OUTPUT_DIR}/analysis"
-
-# List available sessions
-list_sessions() {
-    echo -e "${BLUE}=== Available FSS Link Sessions ===${NC}\n"
-
-    if [[ ! -d "${FSS_LINK_TMP_DIR}" ]]; then
-        echo -e "${RED}FSS Link tmp directory not found: ${FSS_LINK_TMP_DIR}${NC}"
-        exit 1
-    fi
-
-    find "${FSS_LINK_TMP_DIR}" -name "checkpoint*.json" -type f | while read -r checkpoint; do
-        session_dir=$(dirname "${checkpoint}")
-        session_id=$(basename "${session_dir}")
-        file_size=$(du -h "${checkpoint}" | cut -f1)
-        mod_time=$(stat -c '%y' "${checkpoint}" 2>/dev/null || stat -f '%Sm' "${checkpoint}")
-
-        # Try to extract some context from the file
-        context=$(jq -r '.messages[2].parts[0].text // "Unknown"' "${checkpoint}" 2>/dev/null | head -c 100)
-
-        echo -e "${GREEN}Session:${NC} ${session_id}"
-        echo -e "  ${YELLOW}File:${NC} ${checkpoint}"
-        echo -e "  ${YELLOW}Size:${NC} ${file_size}"
-        echo -e "  ${YELLOW}Modified:${NC} ${mod_time}"
-        echo -e "  ${YELLOW}Context:${NC} ${context}..."
-        echo ""
-    done
-}
-
-# Extract specific session
-extract_session() {
-    local session_path="$1"
-    local session_id="$2"
-    local output_name="$3"
-
-    echo -e "${BLUE}Extracting session: ${session_id}${NC}"
-
-    # Copy raw log
-    cp "${session_path}" "${RAW_DIR}/${output_name}.json"
-    echo -e "${GREEN}✓${NC} Raw log saved: ${RAW_DIR}/${output_name}.json"
-
-    # Process log with Python script
-    python3 /MASTERFOLDER/Projects/fss-link/scripts/process-session-log.py \
-        "${session_path}" \
-        "${PROCESSED_DIR}/${output_name}.md"
-
-    if [[ $? -eq 0 ]]; then
-        echo -e "${GREEN}✓${NC} Processed log saved: ${PROCESSED_DIR}/${output_name}.md"
-    else
-        echo -e "${RED}✗${NC} Failed to process session log"
-        return 1
-    fi
-}
-
-# Main execution
-main() {
-    if [[ "${LIST_ONLY}" == "true" ]]; then
-        list_sessions
-        exit 0
-    fi
-
-    echo -e "${BLUE}=== FSS Link Session Log Extractor ===${NC}\n"
-
-    # Specific session extraction
-    if [[ -n "${SESSION_ID}" ]]; then
-        session_path="${FSS_LINK_TMP_DIR}/${SESSION_ID}/checkpoint-fileRead.json"
-        if [[ ! -f "${session_path}" ]]; then
-            echo -e "${RED}Session not found: ${SESSION_ID}${NC}"
-            exit 1
-        fi
-
-        timestamp=$(date +%Y%m%d-%H%M%S)
-        extract_session "${session_path}" "${SESSION_ID}" "session-${timestamp}"
-        exit 0
-    fi
-
-    # Extract sessions based on filters
-    local count=0
-    find "${FSS_LINK_TMP_DIR}" -name "checkpoint*.json" -type f | while read -r checkpoint; do
-        session_dir=$(dirname "${checkpoint}")
-        session_id=$(basename "${session_dir}")
-
-        # Apply time filter
-        if [[ "${EXTRACT_ALL}" == "false" ]]; then
-            # Check if file was modified in last N days
-            if [[ $(find "${checkpoint}" -mtime "-${DAYS}" | wc -l) -eq 0 ]]; then
-                continue
-            fi
-        fi
-
-        # Apply tool filter
-        if [[ -n "${TOOL_FILTER}" ]]; then
-            if ! grep -qi "${TOOL_FILTER}" "${checkpoint}" 2>/dev/null; then
-                continue
-            fi
-        fi
-
-        # Extract this session
-        mod_date=$(stat -c '%Y' "${checkpoint}" 2>/dev/null || stat -f '%m' "${checkpoint}")
-        formatted_date=$(date -d "@${mod_date}" +%Y%m%d-%H%M%S 2>/dev/null || date -r "${mod_date}" +%Y%m%d-%H%M%S)
-        output_name="session-${formatted_date}-${session_id:0:8}"
-
-        extract_session "${checkpoint}" "${session_id}" "${output_name}"
-        ((count++))
-    done
-
-    echo -e "\n${GREEN}Extraction complete: ${count} sessions processed${NC}"
-    echo -e "${YELLOW}Next steps:${NC}"
-    echo -e "  1. Review processed logs in: ${PROCESSED_DIR}/"
-    echo -e "  2. Index with RAG: cd ${OUTPUT_DIR} && rag-index create processed/"
-    echo -e "  3. Search logs: rag fss-link-sessions 'your query'"
-}
-
-main

package/scripts/get-previous-tag.js

@@ -1,213 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { execSync } from 'child_process';
-
-/**
- * Determines the correct previous tag for release notes generation.
- * This function handles the complexity of mixed tag types (regular releases vs nightly releases).
- *
- * @param {string} currentTag - The current release tag (e.g., "v0.1.23")
- * @returns {string|null} - The previous tag to compare against, or null if no suitable tag found
- */
-export function getPreviousTag(currentTag) {
-  try {
-    // Parse the current tag to understand its type
-    const currentTagInfo = parseTag(currentTag);
-    if (!currentTagInfo) {
-      console.error(`Invalid current tag format: ${currentTag}`);
-      return null;
-    }
-
-    // Find the appropriate previous tag based on the current tag type
-    let previousTag = null;
-
-    if (currentTagInfo.isNightly) {
-      // For nightly releases, find the last stable release
-      previousTag = findLastStableTag(currentTagInfo);
-    } else {
-      // For stable releases, find the previous stable release
-      previousTag = findPreviousStableTag(currentTagInfo);
-    }
-
-    return previousTag;
-  } catch (error) {
-    console.error('Error getting previous tag:', error.message);
-    return null;
-  }
-}
-
-/**
- * Parses a tag string to extract version information and type
- */
-function parseTag(tag) {
-  // Remove 'v' prefix if present
-  const cleanTag = tag.startsWith('v') ? tag.substring(1) : tag;
-
-  // Match pattern: X.Y.Z or X.Y.Z-prerelease
-  const match = cleanTag.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
-  if (!match) {
-    return null;
-  }
-
-  const [, major, minor, patch, prerelease] = match;
-
-  return {
-    original: tag,
-    major: parseInt(major),
-    minor: parseInt(minor),
-    patch: parseInt(patch),
-    prerelease: prerelease || null,
-    isNightly: prerelease && prerelease.startsWith('nightly'),
-    isPreview: prerelease && prerelease.startsWith('preview'),
-    version: `${major}.${minor}.${patch}`,
-  };
-}
-
-/**
- * Finds the last stable tag for a nightly release
- * Assumes version numbers are incremental and checks backwards from current version
- */
-function findLastStableTag(currentTagInfo) {
-  // For nightly releases, find the stable version of the same version number first
-  const baseVersion = `v${currentTagInfo.version}`;
-
-  // Check if the stable version of the current version exists
-  if (tagExists(baseVersion)) {
-    return baseVersion;
-  }
-
-  // If not, look for the previous stable versions by decrementing version numbers
-  let { major, minor, patch } = currentTagInfo;
-
-  // Try decrementing patch version first
-  while (patch > 0) {
-    patch--;
-    const candidateTag = `v${major}.${minor}.${patch}`;
-    if (tagExists(candidateTag)) {
-      return candidateTag;
-    }
-  }
-
-  // Try decrementing minor version
-  while (minor > 0) {
-    minor--;
-    patch = 999; // Start from a high patch number and work backwards
-    while (patch >= 0) {
-      const candidateTag = `v${major}.${minor}.${patch}`;
-      if (tagExists(candidateTag)) {
-        return candidateTag;
-      }
-      patch--;
-      // Don't check too many patch versions to avoid infinite loops
-      if (patch < 0) break;
-    }
-  }
-
-  // Try decrementing major version
-  while (major > 0) {
-    major--;
-    minor = 999; // Start from a high minor number and work backwards
-    while (minor >= 0) {
-      patch = 999;
-      while (patch >= 0) {
-        const candidateTag = `v${major}.${minor}.${patch}`;
-        if (tagExists(candidateTag)) {
-          return candidateTag;
-        }
-        patch--;
-        if (patch < 0) break;
-      }
-      minor--;
-      if (minor < 0) break;
-    }
-  }
-
-  return null;
-}
-
-/**
- * Finds the previous stable tag for a stable release
- * Assumes version numbers are incremental and checks backwards from current version
- */
-function findPreviousStableTag(currentTagInfo) {
-  let { major, minor, patch } = currentTagInfo;
-
-  // Try decrementing patch version first
-  while (patch > 0) {
-    patch--;
-    const candidateTag = `v${major}.${minor}.${patch}`;
-    if (tagExists(candidateTag)) {
-      return candidateTag;
-    }
-  }
-
-  // Try decrementing minor version
-  while (minor > 0) {
-    minor--;
-    patch = 999; // Start from a high patch number and work backwards
-    while (patch >= 0) {
-      const candidateTag = `v${major}.${minor}.${patch}`;
-      if (tagExists(candidateTag)) {
-        return candidateTag;
-      }
-      patch--;
-      // Don't check too many patch versions to avoid infinite loops
-      if (patch < 0) break;
-    }
-  }
-
-  // Try decrementing major version
-  while (major > 0) {
-    major--;
-    minor = 999; // Start from a high minor number and work backwards
-    while (minor >= 0) {
-      patch = 999;
-      while (patch >= 0) {
-        const candidateTag = `v${major}.${minor}.${patch}`;
-        if (tagExists(candidateTag)) {
-          return candidateTag;
-        }
-        patch--;
-        if (patch < 0) break;
-      }
-      minor--;
-      if (minor < 0) break;
-    }
-  }
-
-  return null;
-}
-
-/**
- * Checks if a git tag exists
- */
-function tagExists(tag) {
-  try {
-    execSync(`git rev-parse --verify ${tag}`, { stdio: 'ignore' });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// CLI usage
-if (process.argv[1] === new URL(import.meta.url).pathname) {
-  const currentTag = process.argv[2];
-
-  if (!currentTag) {
-    console.error('Usage: node get-previous-tag.js <current-tag>');
-    process.exit(1);
-  }
-
-  const previousTag = getPreviousTag(currentTag);
-  if (previousTag) {
-    console.log(previousTag);
-  } else {
-    console.error('No suitable previous tag found');
-    process.exit(1);
-  }
-}

package/scripts/get-release-version.js

@@ -1,119 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { execSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-
-function getPackageVersion() {
-  const packageJsonPath = path.resolve(process.cwd(), 'package.json');
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-  return packageJson.version;
-}
-
-function incrementPatchVersion(version) {
-  const parts = version.split('.');
-  const major = parseInt(parts[0]);
-  const minor = parseInt(parts[1]);
-  const patch = parseInt(parts[2].split('-')[0]); // Handle pre-release versions
-  return `${major}.${minor}.${patch + 1}`;
-}
-
-function getLatestNightlyCount() {
-  try {
-    // Try to get the latest nightly tag from git to determine the counter
-    const currentVersion = getPackageVersion();
-    const nextVersion = incrementPatchVersion(currentVersion);
-    const tags = execSync(`git tag -l "v${nextVersion}-nightly.*"`)
-      .toString()
-      .trim();
-
-    if (!tags) return 0;
-
-    const nightlyTags = tags.split('\n').filter(Boolean);
-    const counts = nightlyTags.map((tag) => {
-      const match = tag.match(/nightly\.(\d+)$/);
-      return match ? parseInt(match[1]) : 0;
-    });
-
-    return Math.max(...counts, -1) + 1;
-  } catch (_error) {
-    // If we can't get tags, start from 0
-    return 0;
-  }
-}
-
-export function getNightlyTagName() {
-  const version = getPackageVersion();
-  const nextVersion = incrementPatchVersion(version);
-  const nightlyCount = getLatestNightlyCount();
-
-  return `v${nextVersion}-nightly.${nightlyCount}`;
-}
-
-export function getReleaseVersion() {
-  const isNightly = process.env.IS_NIGHTLY === 'true';
-  const manualVersion = process.env.MANUAL_VERSION;
-
-  let releaseTag;
-
-  if (isNightly) {
-    console.error('Calculating next nightly version...');
-    releaseTag = getNightlyTagName();
-  } else if (manualVersion) {
-    console.error(`Using manual version: ${manualVersion}`);
-    releaseTag = manualVersion;
-  } else {
-    throw new Error(
-      'Error: No version specified and this is not a nightly release.',
-    );
-  }
-
-  if (!releaseTag) {
-    throw new Error('Error: Version could not be determined.');
-  }
-
-  if (!releaseTag.startsWith('v')) {
-    console.error("Version is missing 'v' prefix. Prepending it.");
-    releaseTag = `v${releaseTag}`;
-  }
-
-  if (releaseTag.includes('+')) {
-    throw new Error(
-      'Error: Versions with build metadata (+) are not supported for releases. Please use a pre-release version (e.g., v1.2.3-alpha.4) instead.',
-    );
-  }
-
-  if (!releaseTag.match(/^v[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.-]+)?$/)) {
-    throw new Error(
-      'Error: Version must be in the format vX.Y.Z or vX.Y.Z-prerelease',
-    );
-  }
-
-  const releaseVersion = releaseTag.substring(1);
-  let npmTag = 'latest';
-  if (releaseVersion.includes('-')) {
-    const prereleasePart = releaseVersion.split('-')[1];
-    npmTag = prereleasePart.split('.')[0];
-
-    // Ensure nightly releases use 'nightly' tag, not 'latest'
-    if (npmTag === 'nightly') {
-      npmTag = 'nightly';
-    }
-  }
-
-  return { releaseTag, releaseVersion, npmTag };
-}
-
-if (process.argv[1] === new URL(import.meta.url).pathname) {
-  try {
-    const versions = getReleaseVersion();
-    console.log(JSON.stringify(versions));
-  } catch (error) {
-    console.error(error.message);
-    process.exit(1);
-  }
-}