fss-link 1.5.7 → 1.6.0

package/scripts/extract-session-logs.sh

@@ -0,0 +1,202 @@
+#!/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/generate-git-commit-info.js

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { dirname, join, relative } from 'path';
+import { fileURLToPath } from 'url';
+import { readPackageUp } from 'read-package-up';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, '..');
+const scriptPath = relative(root, fileURLToPath(import.meta.url));
+const generatedCliDir = join(root, 'packages/cli/src/generated');
+const cliGitCommitFile = join(generatedCliDir, 'git-commit.ts');
+const generatedCoreDir = join(root, 'packages/core/src/generated');
+const coreGitCommitFile = join(generatedCoreDir, 'git-commit.ts');
+let gitCommitInfo = 'N/A';
+let cliVersion = 'UNKNOWN';
+
+if (!existsSync(generatedCliDir)) {
+  mkdirSync(generatedCliDir, { recursive: true });
+}
+
+if (!existsSync(generatedCoreDir)) {
+  mkdirSync(generatedCoreDir, { recursive: true });
+}
+
+try {
+  const gitHash = execSync('git rev-parse --short HEAD', {
+    encoding: 'utf-8',
+  }).trim();
+  if (gitHash) {
+    gitCommitInfo = gitHash;
+  }
+
+  const result = await readPackageUp();
+  cliVersion = result?.packageJson?.version ?? 'UNKNOWN';
+} catch {
+  // ignore
+}
+
+const fileContent = `/**
+ * @license
+ * Copyright ${new Date().getFullYear()} Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// This file is auto-generated by the build script (${scriptPath})
+// Do not edit this file manually.
+export const GIT_COMMIT_INFO = '${gitCommitInfo}';
+export const CLI_VERSION = '${cliVersion}';
+`;
+
+writeFileSync(cliGitCommitFile, fileContent);
+writeFileSync(coreGitCommitFile, fileContent);

package/scripts/get-previous-tag.js

@@ -0,0 +1,213 @@
+/**
+ * @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

@@ -0,0 +1,119 @@
+/**
+ * @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);
+  }
+}