fss-link 1.5.7 → 1.6.0

package/scripts/memory-monitor.sh

@@ -0,0 +1,165 @@
+#!/bin/bash
+
+# 📊 Memory Monitor for Test Processes
+# Purpose: Monitor memory usage during tests and auto-kill if dangerous
+# Usage: ./scripts/memory-monitor.sh [--auto-kill] [--threshold-gb=8]
+
+# Default settings
+AUTO_KILL=false
+THRESHOLD_GB=8
+INTERVAL=5
+
+# Colors
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# Parse arguments
+for arg in "$@"; do
+    case $arg in
+        --auto-kill)
+            AUTO_KILL=true
+            shift
+            ;;
+        --threshold-gb=*)
+            THRESHOLD_GB="${arg#*=}"
+            shift
+            ;;
+        --interval=*)
+            INTERVAL="${arg#*=}"
+            shift
+            ;;
+        --help)
+            echo "Memory Monitor for Test Processes"
+            echo ""
+            echo "Usage: $0 [options]"
+            echo ""
+            echo "Options:"
+            echo "  --auto-kill           Automatically kill processes exceeding threshold"
+            echo "  --threshold-gb=N      Memory threshold in GB (default: 8)"
+            echo "  --interval=N          Check interval in seconds (default: 5)"
+            echo "  --help               Show this help"
+            echo ""
+            echo "Examples:"
+            echo "  $0                           # Monitor only"
+            echo "  $0 --auto-kill              # Monitor and auto-kill at 8GB"
+            echo "  $0 --auto-kill --threshold-gb=4  # Auto-kill at 4GB"
+            exit 0
+            ;;
+    esac
+done
+
+THRESHOLD_KB=$((THRESHOLD_GB * 1024 * 1024))
+
+echo -e "${BLUE}📊 FSS Link Memory Monitor${NC}"
+echo -e "${YELLOW}Threshold: ${THRESHOLD_GB}GB | Auto-kill: ${AUTO_KILL} | Interval: ${INTERVAL}s${NC}"
+echo -e "${YELLOW}Press Ctrl+C to stop monitoring${NC}"
+echo ""
+
+# Function to format memory
+format_memory() {
+    local kb=$1
+    if [ $kb -gt 1048576 ]; then
+        echo "$((kb / 1024 / 1024))GB"
+    elif [ $kb -gt 1024 ]; then
+        echo "$((kb / 1024))MB"  
+    else
+        echo "${kb}KB"
+    fi
+}
+
+# Function to kill dangerous processes
+kill_dangerous_processes() {
+    local pids="$1"
+    echo -e "${RED}🚨 EMERGENCY: Memory threshold exceeded!${NC}"
+    echo -e "${RED}💀 Killing dangerous processes...${NC}"
+    
+    for pid in $pids; do
+        if [ -n "$pid" ]; then
+            kill -KILL "$pid" 2>/dev/null && echo "Killed PID $pid" || true
+        fi
+    done
+    
+    # Run the emergency script as backup
+    echo -e "${YELLOW}Running emergency cleanup...${NC}"
+    ./scripts/emergency-kill-vitest.sh --force
+}
+
+# Monitoring loop
+while true; do
+    clear
+    echo -e "${BLUE}📊 FSS Link Memory Monitor - $(date)${NC}"
+    echo -e "${YELLOW}Threshold: ${THRESHOLD_GB}GB | Auto-kill: ${AUTO_KILL}${NC}"
+    echo ""
+    
+    # System memory overview
+    echo -e "${GREEN}💻 System Memory:${NC}"
+    free -h
+    echo ""
+    
+    # Find test processes
+    TEST_PIDS=$(pgrep -f "vitest\|node.*test\|jest\|mocha" 2>/dev/null || true)
+    
+    if [ -z "$TEST_PIDS" ]; then
+        echo -e "${GREEN}✅ No test processes running${NC}"
+    else
+        echo -e "${YELLOW}🧪 Test Processes:${NC}"
+        printf "%-8s %-8s %-10s %-10s %s\n" "PID" "CPU%" "MEMORY" "STATUS" "COMMAND"
+        echo "────────────────────────────────────────────────────────────────"
+        
+        DANGEROUS_PIDS=""
+        TOTAL_TEST_MEMORY=0
+        
+        for pid in $TEST_PIDS; do
+            if [ -n "$pid" ]; then
+                # Get process info
+                if ps -p "$pid" > /dev/null 2>&1; then
+                    INFO=$(ps -p "$pid" -o pid,%cpu,rss,comm --no-headers 2>/dev/null)
+                    if [ -n "$INFO" ]; then
+                        MEMORY_KB=$(echo "$INFO" | awk '{print $3}')
+                        CPU=$(echo "$INFO" | awk '{print $2}')
+                        COMMAND=$(echo "$INFO" | awk '{print $4}')
+                        
+                        TOTAL_TEST_MEMORY=$((TOTAL_TEST_MEMORY + MEMORY_KB))
+                        
+                        # Format memory for display
+                        MEMORY_DISPLAY=$(format_memory $MEMORY_KB)
+                        
+                        # Check if dangerous
+                        STATUS="OK"
+                        if [ $MEMORY_KB -gt $THRESHOLD_KB ]; then
+                            STATUS="${RED}DANGER${NC}"
+                            DANGEROUS_PIDS="$DANGEROUS_PIDS $pid"
+                        elif [ $MEMORY_KB -gt $((THRESHOLD_KB / 2)) ]; then
+                            STATUS="${YELLOW}WARNING${NC}"
+                        else
+                            STATUS="${GREEN}OK${NC}"
+                        fi
+                        
+                        printf "%-8s %-8s %-10s %-20s %s\n" "$pid" "$CPU%" "$MEMORY_DISPLAY" "$STATUS" "$COMMAND"
+                    fi
+                fi
+            fi
+        done
+        
+        echo ""
+        echo -e "${BLUE}📈 Total Test Memory: $(format_memory $TOTAL_TEST_MEMORY)${NC}"
+        
+        # Check for auto-kill
+        if [ "$AUTO_KILL" = true ] && [ -n "$DANGEROUS_PIDS" ]; then
+            kill_dangerous_processes "$DANGEROUS_PIDS"
+            break
+        elif [ -n "$DANGEROUS_PIDS" ]; then
+            echo ""
+            echo -e "${RED}⚠️  DANGEROUS processes detected!${NC}"
+            echo -e "${YELLOW}Run with --auto-kill to automatically terminate them${NC}"
+            echo -e "${YELLOW}Or manually run: ./scripts/emergency-kill-vitest.sh${NC}"
+        fi
+    fi
+    
+    echo ""
+    echo -e "${BLUE}Next check in ${INTERVAL} seconds... (Ctrl+C to stop)${NC}"
+    sleep $INTERVAL
+done

package/scripts/postinstall-message.js

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// FSS Link postinstall guidance — printed after npm install -g fss-link
+'use strict';
+
+const lines = [
+  '',
+  '╔════════════════════════════════════════╗',
+  '║         FSS Link installed!            ║',
+  '╚════════════════════════════════════════╝',
+  '',
+  'Get started:',
+  '  fss-link              Launch interactive mode',
+  '  fss-link --help       Show all options',
+  '',
+  'Quick setup (CLI flags):',
+  '  fss-link --provider lm-studio --model your-model',
+  '  fss-link --provider bob-ai --model qwen3.5-35b-a3b',
+  '  fss-link --provider openai-api-key --model gpt-4o',
+  '',
+  'Or launch fss-link and use /auth to configure interactively.',
+  '',
+  'Settings saved to: ~/.fss-link/',
+  '',
+];
+
+console.log(lines.join('\n'));

package/scripts/prepare-package.js

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// ES module equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const rootDir = path.resolve(__dirname, '..');
+
+function copyFiles(packageName, filesToCopy) {
+  const packageDir = path.resolve(rootDir, 'packages', packageName);
+  if (!fs.existsSync(packageDir)) {
+    console.error(`Error: Package directory not found at ${packageDir}`);
+    process.exit(1);
+  }
+
+  console.log(`Preparing package: ${packageName}`);
+  for (const [source, dest] of Object.entries(filesToCopy)) {
+    const sourcePath = path.resolve(rootDir, source);
+    const destPath = path.resolve(packageDir, dest);
+    try {
+      fs.copyFileSync(sourcePath, destPath);
+      console.log(`Copied ${source} to packages/${packageName}/`);
+    } catch (err) {
+      console.error(`Error copying ${source}:`, err);
+      process.exit(1);
+    }
+  }
+}
+
+// Prepare 'core' package
+copyFiles('core', {
+  'README.md': 'README.md',
+  LICENSE: 'LICENSE',
+  '.npmrc': '.npmrc',
+});
+
+// Prepare 'cli' package
+copyFiles('cli', {
+  'README.md': 'README.md',
+  LICENSE: 'LICENSE',
+});
+
+console.log('Successfully prepared all packages.');

package/scripts/process-session-log.py

@@ -0,0 +1,302 @@
+#!/usr/bin/env python3
+"""
+FSS Link Session Log Processor
+Converts JSON session logs to markdown format optimized for RAG indexing
+"""
+
+import json
+import sys
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+import re
+
+
+class SessionLogProcessor:
+    """Process FSS Link session logs into RAG-optimized markdown"""
+
+    def __init__(self, input_path: str, output_path: str):
+        self.input_path = Path(input_path)
+        self.output_path = Path(output_path)
+        self.session_data: Dict[str, Any] = {}
+        self.metadata: Dict[str, Any] = {}
+        self.tool_calls: List[Dict[str, Any]] = []
+        self.errors: List[Dict[str, Any]] = []
+
+    def load_session(self) -> None:
+        """Load session log JSON file"""
+        try:
+            with open(self.input_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                # Handle both array format and object format
+                if isinstance(data, list):
+                    self.session_data = {'messages': data}
+                else:
+                    self.session_data = data
+        except Exception as e:
+            print(f"Error loading session file: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    def extract_metadata(self) -> None:
+        """Extract session metadata from JSON structure (called after analyze_conversation)"""
+        messages = self.session_data.get('messages', [])
+
+        # Extract session ID from file path
+        session_id = self.input_path.parent.name
+
+        # Count messages by role
+        user_messages = sum(1 for m in messages if m.get('role') == 'user')
+        model_messages = sum(1 for m in messages if m.get('role') == 'model')
+
+        # Estimate session duration from file modification time
+        file_mtime = self.input_path.stat().st_mtime
+        session_date = datetime.fromtimestamp(file_mtime)
+
+        # Get unique tools from tool_calls analysis
+        tools_used = sorted(list(set(call['tool'] for call in self.tool_calls)))
+
+        self.metadata = {
+            'session_id': session_id,
+            'session_date': session_date.isoformat(),
+            'total_messages': len(messages),
+            'user_messages': user_messages,
+            'model_messages': model_messages,
+            'tools_used': tools_used,
+            'total_tool_calls': len(self.tool_calls),
+            'total_errors': len(self.errors),
+            'source_file': str(self.input_path),
+        }
+
+    def _get_message_text(self, message: Dict[str, Any]) -> str:
+        """Extract text content from message structure"""
+        parts = message.get('parts', [])
+        if not parts:
+            return ""
+
+        # Handle both string and object parts
+        text_parts = []
+        for part in parts:
+            if isinstance(part, str):
+                text_parts.append(part)
+            elif isinstance(part, dict):
+                if 'text' in part:
+                    # Handle both string and list formats for text
+                    text = part['text']
+                    if isinstance(text, list):
+                        # Join list items (streaming format)
+                        text_parts.append(''.join(str(t) for t in text))
+                    else:
+                        text_parts.append(str(text))
+                elif 'functionCall' in part:
+                    # Function call representation
+                    func = part['functionCall']
+                    func_name = func.get('name', 'unknown')
+                    text_parts.append(f"[FUNCTION CALL: {func_name}]")
+
+        return ''.join(text_parts)  # Use join without separator for streaming format
+
+    def analyze_conversation(self) -> None:
+        """Analyze conversation for tool calls, errors, and key events"""
+        messages = self.session_data.get('messages', [])
+
+        for idx, msg in enumerate(messages):
+            role = msg.get('role', 'unknown')
+            content = self._get_message_text(msg)
+            parts = msg.get('parts', [])
+
+            if not content:
+                continue
+
+            # Detect function calls from parts structure
+            for part in parts:
+                if isinstance(part, dict) and 'functionCall' in part:
+                    func_name = part['functionCall'].get('name', 'unknown')
+                    self.tool_calls.append({
+                        'message_index': idx,
+                        'tool': func_name,
+                        'role': role,
+                        'content_preview': f"[FUNCTION CALL: {func_name}]"
+                    })
+
+            # Also detect from text content patterns
+            tool_patterns = {
+                'read_file': r'\[FUNCTION CALL: read_file\]',
+                'grep': r'\[FUNCTION CALL: search_file_content\]',
+                'glob': r'\[FUNCTION CALL: glob\]',
+                'TodoWrite': r'\[FUNCTION CALL: todo_write\]',
+                'bash': r'\[FUNCTION CALL: run_shell_command\]',
+                'write': r'\[FUNCTION CALL: write_file\]',
+            }
+
+            for tool_name, pattern in tool_patterns.items():
+                if re.search(pattern, content, re.IGNORECASE):
+                    # Only add if not already detected from functionCall
+                    already_detected = any(
+                        call['message_index'] == idx and tool_name in call['tool'].lower()
+                        for call in self.tool_calls
+                    )
+                    if not already_detected:
+                        self.tool_calls.append({
+                            'message_index': idx,
+                            'tool': tool_name,
+                            'role': role,
+                            'content_preview': content[:200]
+                        })
+
+            # Detect errors
+            error_patterns = [
+                r'error:',
+                r'failed:',
+                r'exception:',
+                r'traceback',
+                r'❌',
+            ]
+            for pattern in error_patterns:
+                if re.search(pattern, content, re.IGNORECASE):
+                    self.errors.append({
+                        'message_index': idx,
+                        'role': role,
+                        'error_preview': content[:300]
+                    })
+                    break
+
+    def generate_markdown(self) -> str:
+        """Generate RAG-optimized markdown output"""
+        lines = []
+
+        # Document header with metadata
+        lines.append(f"# FSS Link Session Log: {self.metadata['session_id'][:16]}...")
+        lines.append("")
+        lines.append(f"**Session Date**: {self.metadata['session_date']}")
+        lines.append(f"**Total Messages**: {self.metadata['total_messages']}")
+        lines.append(f"**User Messages**: {self.metadata['user_messages']}")
+        lines.append(f"**Model Messages**: {self.metadata['model_messages']}")
+        lines.append(f"**Tools Used**: {', '.join(self.metadata['tools_used']) if self.metadata['tools_used'] else 'None detected'}")
+        lines.append("")
+        lines.append("---")
+        lines.append("")
+
+        # Session summary
+        lines.append("## Session Summary")
+        lines.append("")
+        lines.append(f"This session contained {self.metadata['total_messages']} messages with "
+                    f"{len(self.tool_calls)} tool calls and {len(self.errors)} errors detected.")
+        lines.append("")
+
+        # Tool calls section
+        if self.tool_calls:
+            lines.append("## Tool Calls Detected")
+            lines.append("")
+
+            # Group by tool
+            tools_grouped = {}
+            for call in self.tool_calls:
+                tool = call['tool']
+                if tool not in tools_grouped:
+                    tools_grouped[tool] = []
+                tools_grouped[tool].append(call)
+
+            for tool, calls in sorted(tools_grouped.items()):
+                lines.append(f"### {tool} ({len(calls)} calls)")
+                lines.append("")
+                for call in calls[:5]:  # Limit to first 5 per tool
+                    lines.append(f"**Message {call['message_index']}** ({call['role']}):")
+                    lines.append(f"```")
+                    lines.append(call['content_preview'])
+                    lines.append(f"```")
+                    lines.append("")
+
+                if len(calls) > 5:
+                    lines.append(f"*... and {len(calls) - 5} more calls*")
+                    lines.append("")
+
+        # Errors section
+        if self.errors:
+            lines.append("## Errors and Issues")
+            lines.append("")
+            for idx, error in enumerate(self.errors[:10]):  # Limit to first 10
+                lines.append(f"### Error {idx + 1} (Message {error['message_index']})")
+                lines.append("")
+                lines.append(f"**Role**: {error['role']}")
+                lines.append("")
+                lines.append("```")
+                lines.append(error['error_preview'])
+                lines.append("```")
+                lines.append("")
+
+            if len(self.errors) > 10:
+                lines.append(f"*... and {len(self.errors) - 10} more errors*")
+                lines.append("")
+
+        # Full conversation
+        lines.append("## Full Conversation")
+        lines.append("")
+
+        messages = self.session_data.get('messages', [])
+        for idx, msg in enumerate(messages):
+            role = msg.get('role', 'unknown')
+            content = self._get_message_text(msg)
+
+            if not content:
+                continue
+
+            # Limit very long messages
+            if len(content) > 5000:
+                content = content[:5000] + "\n\n*[Message truncated for length]*"
+
+            lines.append(f"### Message {idx}: {role.upper()}")
+            lines.append("")
+            lines.append(content)
+            lines.append("")
+            lines.append("---")
+            lines.append("")
+
+        # Metadata footer for RAG
+        lines.append("## Metadata")
+        lines.append("")
+        lines.append("```json")
+        lines.append(json.dumps(self.metadata, indent=2))
+        lines.append("```")
+        lines.append("")
+
+        return '\n'.join(lines)
+
+    def process(self) -> None:
+        """Main processing workflow"""
+        print(f"Processing session log: {self.input_path.name}")
+
+        # Load and analyze (order matters: analyze first, then extract metadata)
+        self.load_session()
+        self.analyze_conversation()
+        self.extract_metadata()
+
+        # Generate markdown
+        markdown = self.generate_markdown()
+
+        # Write output
+        self.output_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.output_path, 'w', encoding='utf-8') as f:
+            f.write(markdown)
+
+        print(f"✓ Processed successfully")
+        print(f"  - Tools used: {', '.join(self.metadata['tools_used']) if self.metadata['tools_used'] else 'None'}")
+        print(f"  - Tool calls: {len(self.tool_calls)}")
+        print(f"  - Errors found: {len(self.errors)}")
+        print(f"  - Output: {self.output_path}")
+
+
+def main():
+    """Main entry point"""
+    if len(sys.argv) != 3:
+        print("Usage: process-session-log.py <input_json> <output_md>", file=sys.stderr)
+        sys.exit(1)
+
+    input_path = sys.argv[1]
+    output_path = sys.argv[2]
+
+    processor = SessionLogProcessor(input_path, output_path)
+    processor.process()
+
+
+if __name__ == '__main__':
+    main()