fss-link 1.6.1 → 1.6.12

package/scripts/process-session-log.py

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

package/scripts/quick-install.sh

@@ -1,195 +0,0 @@
-#!/bin/bash
-
-# FSS Link Quick Install Script
-# Universal installer that detects OS and runs appropriate installation
-
-set -e
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m'
-
-log_info() {
-    echo -e "${BLUE}[INFO]${NC} $1"
-}
-
-log_success() {
-    echo -e "${GREEN}[SUCCESS]${NC} $1"
-}
-
-log_warning() {
-    echo -e "${YELLOW}[WARNING]${NC} $1"
-}
-
-log_error() {
-    echo -e "${RED}[ERROR]${NC} $1"
-}
-
-# Detect operating system
-detect_os() {
-    case "$(uname -s)" in
-        Darwin)
-            OS="macos"
-            ;;
-        Linux)
-            OS="linux"
-            ;;
-        CYGWIN*|MINGW32*|MSYS*|MINGW*)
-            OS="windows"
-            ;;
-        *)
-            log_error "Unsupported operating system: $(uname -s)"
-            exit 1
-            ;;
-    esac
-    
-    log_info "Detected OS: $OS"
-}
-
-# Download installation script
-download_installer() {
-    local script_name="install-${OS}.sh"
-    local script_url="https://raw.githubusercontent.com/FSSCoding/fss-link/main/scripts/${script_name}"
-    
-    log_info "Downloading $script_name..."
-    
-    if command -v curl &> /dev/null; then
-        curl -fsSL "$script_url" -o "$script_name"
-    elif command -v wget &> /dev/null; then
-        wget -q "$script_url" -O "$script_name"
-    else
-        log_error "Neither curl nor wget found. Please install one of them."
-        exit 1
-    fi
-    
-    if [ -f "$script_name" ]; then
-        chmod +x "$script_name"
-        log_success "Downloaded $script_name"
-        return 0
-    else
-        log_error "Failed to download $script_name"
-        return 1
-    fi
-}
-
-# Run the appropriate installer
-run_installer() {
-    local script_name="install-${OS}.sh"
-    
-    if [ "$OS" = "windows" ]; then
-        # For Windows, we need PowerShell
-        log_info "For Windows installation, please run:"
-        log_info "PowerShell -ExecutionPolicy Bypass -File install-windows.ps1"
-        return 0
-    fi
-    
-    log_info "Running $script_name..."
-    ./"$script_name" "$@"
-    
-    # Clean up
-    rm -f "$script_name"
-}
-
-# NPM fallback installation
-npm_install() {
-    log_info "Attempting direct NPM installation..."
-    
-    if command -v npm &> /dev/null; then
-        npm install -g fss-link
-        
-        if command -v fss-link &> /dev/null; then
-            log_success "FSS Link installed via NPM"
-            log_info "Run 'fss-link --help' to get started"
-            return 0
-        else
-            log_error "NPM installation succeeded but fss-link command not found"
-            return 1
-        fi
-    else
-        log_error "NPM not found. Please install Node.js 20+ first."
-        return 1
-    fi
-}
-
-# Main function
-main() {
-    echo "🚀 FSS Link Universal Quick Installer"
-    echo "====================================="
-    echo ""
-    
-    # Handle help flag
-    if [ "${1:-}" = "--help" ] || [ "${1:-}" = "-h" ]; then
-        cat << EOF
-FSS Link Universal Quick Installer
-
-Usage: $0 [options]
-
-Options:
-  --help, -h     Show this help message
-  --npm-only     Skip OS-specific installer, use NPM directly
-  --version, -v  Show script version
-
-This script will:
-1. Detect your operating system
-2. Download the appropriate installation script
-3. Run the OS-specific installer
-4. Verify the installation
-
-Supported Systems:
-  - Linux (Ubuntu, Debian, CentOS, Fedora, Arch, openSUSE)
-  - macOS (10.15+)
-  - Windows (10+)
-
-Requirements:
-  - Node.js 20.0.0 or higher
-  - Build tools for native dependencies
-  - Internet connection for downloading
-
-Examples:
-  curl -fsSL https://raw.githubusercontent.com/FSSCoding/fss-link/main/scripts/quick-install.sh | bash
-  bash quick-install.sh --npm-only
-EOF
-        exit 0
-    fi
-    
-    # Handle version flag
-    if [ "${1:-}" = "--version" ] || [ "${1:-}" = "-v" ]; then
-        echo "FSS Link Universal Quick Installer v1.0.0"
-        exit 0
-    fi
-    
-    # Handle NPM-only installation
-    if [ "${1:-}" = "--npm-only" ]; then
-        npm_install
-        exit $?
-    fi
-    
-    # Detect OS
-    detect_os
-    
-    # Try downloading and running OS-specific installer
-    if download_installer; then
-        run_installer "$@"
-    else
-        log_warning "OS-specific installer download failed, trying NPM installation..."
-        npm_install
-    fi
-    
-    # Final verification
-    if command -v fss-link &> /dev/null; then
-        VERSION=$(fss-link --version 2>/dev/null || echo "unknown")
-        log_success "🎉 FSS Link installation complete!"
-        log_info "Version: $VERSION"
-        log_info "Run 'fss-link --help' to get started"
-    else
-        log_error "Installation may have failed - fss-link command not found"
-        log_info "Try running: npm install -g fss-link"
-        exit 1
-    fi
-}
-
-# Run main function with all arguments
-main "$@"

package/scripts/telemetry_gcp.js

@@ -1,188 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import path from 'path';
-import fs from 'fs';
-import { spawn, execSync } from 'child_process';
-import {
-  OTEL_DIR,
-  BIN_DIR,
-  fileExists,
-  waitForPort,
-  ensureBinary,
-  manageTelemetrySettings,
-  registerCleanup,
-} from './telemetry_utils.js';
-
-const OTEL_CONFIG_FILE = path.join(OTEL_DIR, 'collector-gcp.yaml');
-const OTEL_LOG_FILE = path.join(OTEL_DIR, 'collector-gcp.log');
-
-const getOtelConfigContent = (projectId) => `
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: "localhost:4317"
-processors:
-  batch:
-    timeout: 1s
-exporters:
-  googlecloud:
-    project: "${projectId}"
-    metric:
-      prefix: "custom.googleapis.com/gemini_cli"
-    log:
-      default_log_name: "gemini_cli"
-  debug:
-    verbosity: detailed
-service:
-  telemetry:
-    logs:
-      level: "debug"
-    metrics:
-      level: "none"
-  pipelines:
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [googlecloud]
-    metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [googlecloud, debug]
-    logs:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [googlecloud, debug]
-`;
-
-async function main() {
-  console.log('✨ Starting Local Telemetry Exporter for Google Cloud ✨');
-
-  let collectorProcess;
-  let collectorLogFd;
-
-  const originalSandboxSetting = manageTelemetrySettings(
-    true,
-    'http://localhost:4317',
-    'gcp',
-  );
-  registerCleanup(
-    () => [collectorProcess].filter((p) => p), // Function to get processes
-    () => [collectorLogFd].filter((fd) => fd), // Function to get FDs
-    originalSandboxSetting,
-  );
-
-  const projectId = process.env.OTLP_GOOGLE_CLOUD_PROJECT;
-  if (!projectId) {
-    console.error(
-      '🛑 Error: OTLP_GOOGLE_CLOUD_PROJECT environment variable is not exported.',
-    );
-    console.log(
-      '   Please set it to your Google Cloud Project ID and try again.',
-    );
-    console.log('   `export OTLP_GOOGLE_CLOUD_PROJECT=your-project-id`');
-    process.exit(1);
-  }
-  console.log(`✅ Using OTLP Google Cloud Project ID: ${projectId}`);
-
-  console.log('\n🔑 Please ensure you are authenticated with Google Cloud:');
-  console.log(
-    '  - Run `gcloud auth application-default login` OR ensure `GOOGLE_APPLICATION_CREDENTIALS` environment variable points to a valid service account key.',
-  );
-  console.log(
-    '  - The account needs "Cloud Trace Agent", "Monitoring Metric Writer", and "Logs Writer" roles.',
-  );
-
-  if (!fileExists(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
-
-  const otelcolPath = await ensureBinary(
-    'otelcol-contrib',
-    'open-telemetry/opentelemetry-collector-releases',
-    (version, platform, arch, ext) =>
-      `otelcol-contrib_${version}_${platform}_${arch}.${ext}`,
-    'otelcol-contrib',
-    false, // isJaeger = false
-  ).catch((e) => {
-    console.error(`🛑 Error getting otelcol-contrib: ${e.message}`);
-    return null;
-  });
-  if (!otelcolPath) process.exit(1);
-
-  console.log('🧹 Cleaning up old processes and logs...');
-  try {
-    execSync('pkill -f "otelcol-contrib"');
-    console.log('✅ Stopped existing otelcol-contrib process.');
-  } catch (_e) {
-    /* no-op */
-  }
-  try {
-    fs.unlinkSync(OTEL_LOG_FILE);
-    console.log('✅ Deleted old GCP collector log.');
-  } catch (e) {
-    if (e.code !== 'ENOENT') console.error(e);
-  }
-
-  if (!fileExists(OTEL_DIR)) fs.mkdirSync(OTEL_DIR, { recursive: true });
-  fs.writeFileSync(OTEL_CONFIG_FILE, getOtelConfigContent(projectId));
-  console.log(`📄 Wrote OTEL collector config to ${OTEL_CONFIG_FILE}`);
-
-  console.log(`🚀 Starting OTEL collector for GCP... Logs: ${OTEL_LOG_FILE}`);
-  collectorLogFd = fs.openSync(OTEL_LOG_FILE, 'a');
-  collectorProcess = spawn(otelcolPath, ['--config', OTEL_CONFIG_FILE], {
-    stdio: ['ignore', collectorLogFd, collectorLogFd],
-    env: { ...process.env },
-  });
-
-  console.log(
-    `⏳ Waiting for OTEL collector to start (PID: ${collectorProcess.pid})...`,
-  );
-
-  try {
-    await waitForPort(4317);
-    console.log(`✅ OTEL collector started successfully on port 4317.`);
-  } catch (err) {
-    console.error(`🛑 Error: OTEL collector failed to start on port 4317.`);
-    console.error(err.message);
-    if (collectorProcess && collectorProcess.pid) {
-      process.kill(collectorProcess.pid, 'SIGKILL');
-    }
-    if (fileExists(OTEL_LOG_FILE)) {
-      console.error('📄 OTEL Collector Log Output:');
-      console.error(fs.readFileSync(OTEL_LOG_FILE, 'utf-8'));
-    }
-    process.exit(1);
-  }
-
-  collectorProcess.on('error', (err) => {
-    console.error(`${collectorProcess.spawnargs[0]} process error:`, err);
-    process.exit(1);
-  });
-
-  console.log(`\n✨ Local OTEL collector for GCP is running.`);
-  console.log(
-    '\n🚀 To send telemetry, run the Gemini CLI in a separate terminal window.',
-  );
-  console.log(`\n📄 Collector logs are being written to: ${OTEL_LOG_FILE}`);
-  console.log(
-    `📄 Tail collector logs in another terminal: tail -f ${OTEL_LOG_FILE}`,
-  );
-  console.log(`\n📊 View your telemetry data in Google Cloud Console:`);
-  console.log(
-    `   - Logs: https://console.cloud.google.com/logs/query;query=logName%3D%22projects%2F${projectId}%2Flogs%2Fgemini_cli%22?project=${projectId}`,
-  );
-  console.log(
-    `   - Metrics: https://console.cloud.google.com/monitoring/metrics-explorer?project=${projectId}`,
-  );
-  console.log(
-    `   - Traces: https://console.cloud.google.com/traces/list?project=${projectId}`,
-  );
-  console.log(`\nPress Ctrl+C to exit.`);
-}
-
-main();