Waffle1412 / Typst Compiler Utility

#!/usr/bin/env bash # Default values jobs=0 # 0 means auto-detect output_dir="pdfs" verbose=0 quiet=0 create_dirs=0 dry_run=0 skip_newer=0 show_progress=1 force=0 select_mode=0 use_cache=1 # Enable caching by default use_git=1 # Enable Git integration by default cache_dir="${XDG_CACHE_HOME:-$HOME/.cache}/typst_compiler" dependency_scan=1 # Enable dependency scanning by default compile_log="typst_compile_errors.log" move_log="typst_move_errors.log" declare -a exclude_patterns # Show usage/help information show_help() { cat << EOF Usage: $(basename "$0") [OPTIONS] Compile Typst files and move generated PDFs to a designated directory. Options: -j, --jobs NUM Number of parallel jobs (default: auto-detect) -o, --output-dir DIR Output directory name (default: pdfs) -v, --verbose Increase verbosity -q, --quiet Suppress most output -c, --create-dirs Create output directories if they don't exist -d, --dry-run Show what would be done without doing it -s, --skip-newer Skip compilation if PDF is newer than source -S, --select Interactive selection mode using skim -f, --force Force compilation even if PDF exists --no-progress Disable progress bar --no-cache Disable compilation caching --no-git Disable Git-based change detection --clear-cache Clear the cache before compiling --no-deps Disable dependency scanning --cache-dir DIR Custom cache directory (default: ~/.cache/typst_compiler) --compile-log FILE Custom location for compilation log (default: $compile_log) --move-log FILE Custom location for move log (default: $move_log) -e, --exclude PATTERN Exclude files matching pattern (can be used multiple times) -h, --help Show this help message and exit Examples: $(basename "$0") -j 4 -o output -c $(basename "$0") --verbose --skip-newer $(basename "$0") -S # Select files to compile interactively $(basename "$0") -e "**/test/**" -e "**/draft/**" $(basename "$0") --no-git # Disable Git-based change detection EOF } # Parse command line arguments while [[ $# -gt 0 ]]; do case $1 in -j|--jobs) jobs="$2" shift 2 ;; -o|--output-dir) output_dir="$2" shift 2 ;; -v|--verbose) verbose=1 shift ;; -q|--quiet) quiet=1 shift ;; -c|--create-dirs) create_dirs=1 shift ;; -d|--dry-run) dry_run=1 shift ;; -s|--skip-newer) skip_newer=1 shift ;; -S|--select) select_mode=1 shift ;; -f|--force) force=1 shift ;; --no-progress) show_progress=0 shift ;; --no-cache) use_cache=0 shift ;; --no-git) use_git=0 shift ;; --clear-cache) rm -rf "${cache_dir}" shift ;; --no-deps) dependency_scan=0 shift ;; --cache-dir) cache_dir="$2" shift 2 ;; --compile-log) compile_log="$2" shift 2 ;; --move-log) move_log="$2" shift 2 ;; -e|--exclude) exclude_patterns+=("$2") shift 2 ;; -h|--help) show_help exit 0 ;; *) echo "Unknown option: $1" show_help exit 1 ;; esac done # Check for conflicting options if [ "$verbose" -eq 1 ] && [ "$quiet" -eq 1 ]; then echo "Error: Cannot use both --verbose and --quiet" exit 1 fi # Check if required tools are installed check_tool() { if ! command -v "$1" &> /dev/null; then echo "$1 is not installed. Please install it first." echo "On most systems: $2" exit 1 fi } check_tool "fd" "cargo install fd-find or apt/brew install fd-find" check_tool "rg" "cargo install ripgrep or apt/brew install ripgrep" check_tool "parallel" "apt/brew install parallel" check_tool "sha256sum" "Built-in on most Linux systems, on macOS: brew install coreutils" # Check for skim and bat if select mode is enabled if [ "$select_mode" -eq 1 ]; then check_tool "sk" "cargo install skim or apt/brew install skim" check_tool "bat" "cargo install bat or apt/brew install bat" fi # ANSI color codes GREEN='\033[0;32m' BLUE='\033[0;34m' YELLOW='\033[0;33m' RED='\033[0;31m' CYAN='\033[0;36m' PURPLE='\033[0;35m' NC='\033[0m' # No Color BOLD='\033[1m' # Nerd font icons ICON_SUCCESS="󰄬 " ICON_ERROR="󰅚 " ICON_WORKING="󰄾 " ICON_COMPILE="󰈙 " ICON_MOVE="󰆐 " ICON_COMPLETE="󰄲 " ICON_SUMMARY="󰋽 " ICON_INFO="󰋼 " ICON_DEBUG="󰃤 " ICON_SELECT="󰓾 " ICON_CACHE="󰆏 " ICON_GIT="󰊢 " # Logging functions log_debug() { if [ "$verbose" -eq 1 ]; then echo -e "${BLUE}$ICON_DEBUG${NC} $*" fi } log_info() { if [ "$quiet" -eq 0 ]; then echo -e "${CYAN}$ICON_INFO${NC} $*" fi } log_warning() { if [ "$quiet" -eq 0 ]; then echo -e "${YELLOW}⚠️ ${NC} $*" fi } log_error() { echo -e "${RED}${BOLD}$ICON_ERROR${NC} $*" } log_success() { if [ "$quiet" -eq 0 ]; then echo -e "${GREEN}${BOLD}$ICON_SUCCESS${NC} $*" fi } # Create a directory for temporary files temp_dir=$(mktemp -d) compile_failures_dir="$temp_dir/compile_failures" move_failures_dir="$temp_dir/move_failures" progress_dir="$temp_dir/progress" mkdir -p "$compile_failures_dir" "$move_failures_dir" "$progress_dir" # Create cache directories if caching is enabled if [ "$use_cache" -eq 1 ]; then mkdir -p "${cache_dir}/hashes" "${cache_dir}/deps" "${cache_dir}/pdfs" log_debug "Using cache directory: $cache_dir" fi # Create a lock file for progress updates and a flag for final progress progress_lock="/tmp/typst_progress_lock" final_progress_file="$temp_dir/final_progress" touch "$final_progress_file" # Initialize log files > "$compile_log" > "$move_log" # Store current working directory CWD=$(pwd) log_info "Starting Typst compilation process..." # Check if we're in a Git repository in_git_repo=0 git_repo_root="" check_git_repo() { if [ "$use_git" -eq 1 ] && command -v git &> /dev/null; then # Check if we're in a git repo if git_repo_root=$(git rev-parse --show-toplevel 2>/dev/null); then in_git_repo=1 log_info "${ICON_GIT} Git repository detected at: ${BOLD}$git_repo_root${NC}" return 0 else log_debug "Not in a Git repository, falling back to file hashing" return 1 fi else log_debug "Git integration disabled or git not found" return 1 fi } # Get list of changed files from Git get_git_changed_files() { local git_files="$temp_dir/git_changed_files.txt" # Get list of staged, unstaged, and untracked files git -C "$git_repo_root" ls-files --modified --others --exclude-standard > "$git_files" # Add staged files that may not show as modified git -C "$git_repo_root" diff --name-only --cached >> "$git_files" # If no previous commit exists, consider all tracked files as changed if ! git -C "$git_repo_root" rev-parse HEAD &>/dev/null; then git -C "$git_repo_root" ls-files >> "$git_files" fi # Filter to keep only .typ files and remove duplicates sort -u "$git_files" | grep '\.typ$' > "$temp_dir/git_changed_typ_files.txt" log_debug "Git reports $(wc -l < "$temp_dir/git_changed_typ_files.txt") changed .typ files" } # Build exclude arguments for fd fd_exclude_args=() for pattern in "${exclude_patterns[@]}"; do fd_exclude_args+=("-E" "$pattern") done # Create a list of files to process typst_files_list="$temp_dir/typst_files.txt" if [ "$select_mode" -eq 1 ]; then log_info "${PURPLE}$ICON_SELECT${NC} Interactive selection mode enabled" log_info "Use TAB to select multiple files, ENTER to confirm" # Set up bat configuration for Typst syntax highlighting bat_config="$temp_dir/bat_config" mkdir -p "$bat_config/syntaxes" export BAT_CONFIG_PATH="$bat_config" # Use skim with bat for preview to select files selected_files="$temp_dir/selected_files.txt" # Find all eligible .typ files for selection fd '\.typ$' --type f "${fd_exclude_args[@]}" . > "$typst_files_list.all" # Check if we found any files if [ ! -s "$typst_files_list.all" ]; then log_error "No .typ files found matching your criteria." rm -rf "$temp_dir" exit 0 fi # Prepare preview command for skim: use bat with custom syntax for .typ files preview_cmd="bat --color=always --style=numbers --map-syntax='*.typ:Markdown' {} 2>/dev/null || cat {}" # Use skim with bat preview to select files cat "$typst_files_list.all" | sk --multi \ --preview "$preview_cmd" \ --preview-window "right:70%" \ --height "80%" \ --prompt "Select .typ files to compile: " \ --header "TAB: Select multiple files, ENTER: Confirm, CTRL-C: Cancel" \ --no-mouse > "$selected_files" # Check if user selected any files if [ ! -s "$selected_files" ]; then log_error "No files selected. Exiting." rm -rf "$temp_dir" exit 0 fi # Use the selected files instead of all discovered files cp "$selected_files" "$typst_files_list" total_selected=$(wc -l < "$typst_files_list") total_available=$(wc -l < "$typst_files_list.all") log_info "Selected ${BOLD}$total_selected${NC} out of ${BOLD}$total_available${NC} available files" else # Normal mode - process all files fd '\.typ$' --type f "${fd_exclude_args[@]}" . > "$typst_files_list" log_info "Found ${BOLD}$(wc -l < "$typst_files_list")${NC} Typst files to process" # Check for Git repository and get changed files check_git_repo if [ "$in_git_repo" -eq 1 ] && [ "$force" -eq 0 ]; then get_git_changed_files # If no forced compilation, filter the file list to only include changed files if [ -s "$temp_dir/git_changed_typ_files.txt" ]; then cp "$typst_files_list" "$temp_dir/all_typ_files.txt" # Convert Git changed files to absolute paths while read -r file; do echo "$git_repo_root/$file" done < "$temp_dir/git_changed_typ_files.txt" | sort > "$temp_dir/git_absolute_paths.txt" # Find the intersection of all files and Git changed files comm -12 <(sort "$typst_files_list") "$temp_dir/git_absolute_paths.txt" > "$temp_dir/files_to_compile.txt" # Use the filtered list if there are changes, otherwise keep using all files if [ -s "$temp_dir/files_to_compile.txt" ]; then cp "$temp_dir/files_to_compile.txt" "$typst_files_list" git_changes_count=$(wc -l < "$typst_files_list") log_info "${ICON_GIT} Processing ${BOLD}$git_changes_count${NC} files with Git changes" else log_info "${ICON_GIT} No Git changes detected for .typ files" # If no changes detected and not forced, update progress and exit early if [ "$force" -eq 0 ]; then log_success "No files need to be compiled." rm -rf "$temp_dir" exit 0 fi fi fi fi fi total_files=$(wc -l < "$typst_files_list") # Function to extract Typst imports from a file extract_dependencies() { local file="$1" # Match both import formats: #import "file.typ" and #include "file.typ" # Also handle package imports: #import "@preview:0.1.0" # Return full paths to local imports, skipping package imports rg -U "#(import|include) \"(?!@)([^\"]+)\"" -r "$CWD/\$2" "$file" | \ while read -r dep; do # Resolve relative paths correctly if [[ "$dep" != /* ]]; then # If not absolute path, make it relative to the file's directory file_dir=$(dirname "$file") dep="$file_dir/$dep" fi # Normalize path dep=$(realpath --relative-to="$CWD" "$dep" 2>/dev/null || echo "$dep") # Only output if the dependency exists and is a .typ file if [[ "$dep" == *.typ ]] && [ -f "$dep" ]; then echo "$dep" fi done | sort -u # Sort and remove duplicates } # Function to build dependency graph for all files build_dependency_graph() { log_info "${ICON_CACHE} Building dependency graph..." # Create a deps file for each Typst file while read -r file; do file_hash=$(echo "$file" | md5sum | cut -d' ' -f1) deps_file="${cache_dir}/deps/${file_hash}.deps" # Skip if deps file is fresh and not forced if [ "$force" -eq 0 ] && [ -f "$deps_file" ] && [ "$file" -ot "$deps_file" ]; then log_debug "Using cached dependencies for $file" continue fi # Extract dependencies and save to deps file extract_dependencies "$file" > "$deps_file" log_debug "Updated dependencies for $file" done < "$typst_files_list" # Create sorted compilation order based on dependencies # Files with fewer dependencies (or no dependencies) come first if [ -f "$temp_dir/compile_order.txt" ]; then rm "$temp_dir/compile_order.txt" fi # First pass: count dependencies for each file declare -A dep_counts while read -r file; do file_hash=$(echo "$file" | md5sum | cut -d' ' -f1) deps_file="${cache_dir}/deps/${file_hash}.deps" # Count dependencies if [ -f "$deps_file" ]; then dep_count=$(wc -l < "$deps_file") else dep_count=0 fi dep_counts["$file"]=$dep_count done < "$typst_files_list" # Second pass: sort files by dependency count (ascending) while read -r file; do echo "${dep_counts["$file"]} $file" done < "$typst_files_list" | sort -n | cut -d' ' -f2- > "$temp_dir/compile_order.txt" log_debug "Created optimized compilation order" # If in a Git repo, consider dependent files of changed files if [ "$in_git_repo" -eq 1 ] && [ -f "$temp_dir/git_changed_typ_files.txt" ]; then log_info "${ICON_GIT} Analyzing dependencies of changed files..." # Track files to be compiled (start with directly changed files) cp "$typst_files_list" "$temp_dir/files_to_compile_with_deps.txt" # Identify files that depend on changed files (reverse dependencies) while read -r file; do file_hash=$(echo "$file" | md5sum | cut -d' ' -f1) # Find all files that have this file as a dependency grep -l "^$file$" "${cache_dir}"/deps/*.deps 2>/dev/null | while read -r dep_file; do # Extract the dependent file from the hash dependent_hash=$(basename "$dep_file" .deps) # Find the original filename for this hash while read -r potential_file; do potential_hash=$(echo "$potential_file" | md5sum | cut -d' ' -f1) if [ "$potential_hash" == "$dependent_hash" ]; then # Add this dependent file to the compilation list echo "$potential_file" >> "$temp_dir/files_to_compile_with_deps.txt" break fi done < "$temp_dir/all_typ_files.txt" done done < "$typst_files_list" # Remove duplicates and update the files list sort -u "$temp_dir/files_to_compile_with_deps.txt" > "$typst_files_list" # Update the total count new_total=$(wc -l < "$typst_files_list") if [ "$new_total" -gt "$total_files" ]; then log_info "${ICON_GIT} Added ${BOLD}$((new_total - total_files))${NC} additional files with dependencies" total_files=$new_total fi fi } # Function to check if a file has changed since last compilation has_file_changed() { local file="$1" # Force recompilation if requested if [ "$force" -eq 1 ]; then log_debug "Force recompilation of $file" return 0 # File considered changed fi # If using Git and in a Git repo, check if file is in the changed list if [ "$in_git_repo" -eq 1 ] && [ "$use_git" -eq 1 ]; then # Convert to repo-relative path local repo_path="${file#$git_repo_root/}" # Check if this file or any of its dependencies are changed according to Git if grep -q "^$git_repo_root/$repo_path$" "$temp_dir/git_absolute_paths.txt" 2>/dev/null; then log_debug "Git reports $file has changed" return 0 # File considered changed fi # If not in the changed list and we're only processing Git changes, # then this file must have a dependency that changed if [ -f "$temp_dir/git_changed_typ_files.txt" ]; then # Check dependencies (if enabled) if [ "$dependency_scan" -eq 1 ]; then local file_hash=$(echo "$file" | md5sum | cut -d' ' -f1) local deps_file="${cache_dir}/deps/${file_hash}.deps" if [ -f "$deps_file" ]; then while read -r dep; do if has_file_changed "$dep"; then log_debug "Dependency $dep of $file has changed" return 0 # Dependency has changed fi done < "$deps_file" fi fi log_debug "No changes to $file or its dependencies according to Git" return 1 # No changes detected via Git fi fi # Fall back to hash-based detection if Git not available or not conclusive local file_hash=$(echo "$file" | md5sum | cut -d' ' -f1) local hash_file="${cache_dir}/hashes/${file_hash}.sha256" # Check if hash file exists if [ ! -f "$hash_file" ]; then log_debug "No previous hash for $file" return 0 # File considered changed fi # Compare current file hash with stored hash local current_hash=$(sha256sum "$file" | cut -d' ' -f1) local stored_hash=$(cat "$hash_file") if [ "$current_hash" != "$stored_hash" ]; then log_debug "File $file has changed since last compilation" return 0 # File has changed fi # Check if any dependencies have changed if [ "$dependency_scan" -eq 1 ]; then local deps_file="${cache_dir}/deps/${file_hash}.deps" if [ -f "$deps_file" ]; then while read -r dep; do if has_file_changed "$dep"; then log_debug "Dependency $dep of $file has changed" return 0 # Dependency has changed fi done < "$deps_file" fi fi log_debug "File $file and its dependencies are unchanged" return 1 # File and dependencies haven't changed } # Function to update file hash after compilation update_file_hash() { local file="$1" local file_hash=$(echo "$file" | md5sum | cut -d' ' -f1) local hash_file="${cache_dir}/hashes/${file_hash}.sha256" # Update hash file sha256sum "$file" | cut -d' ' -f1 > "$hash_file" log_debug "Updated hash for $file" } # Function to cache compiled PDF cache_pdf() { local src_file="$1" local pdf_file="$2" if [ ! -f "$pdf_file" ]; then log_debug "No PDF file to cache: $pdf_file" return 1 fi local file_hash=$(echo "$src_file" | md5sum | cut -d' ' -f1) local cached_pdf="${cache_dir}/pdfs/${file_hash}.pdf" # Copy PDF to cache cp "$pdf_file" "$cached_pdf" log_debug "Cached PDF for $src_file" return 0 } # Function to retrieve cached PDF get_cached_pdf() { local src_file="$1" local target_file="$2" local file_hash=$(echo "$src_file" | md5sum | cut -d' ' -f1) local cached_pdf="${cache_dir}/pdfs/${file_hash}.pdf" if [ ! -f "$cached_pdf" ]; then log_debug "No cached PDF for $src_file" return 1 fi # Copy cached PDF to target location cp "$cached_pdf" "$target_file" log_debug "Retrieved cached PDF for $src_file" return 0 } # Function to update progress bar during processing update_progress_during() { # If progress is disabled, do nothing if [ "$show_progress" -eq 0 ]; then return 0 fi ( # Try to acquire lock, but don't wait if busy flock -n 200 || return 0 completed=$(find "$progress_dir" -type f | wc -l) percent=$((completed * 100 / total_files)) bar_length=50 filled_length=$((bar_length * completed / total_files)) # Create the progress bar bar="" for ((i=0; i<bar_length; i++)); do if [ $i -lt $filled_length ]; then bar="${bar}█" else bar="${bar}░" fi done # Calculate success and failure counts success=$((completed - $(find "$compile_failures_dir" "$move_failures_dir" -type f | wc -l))) compile_fails=$(find "$compile_failures_dir" -type f | wc -l) move_fails=$(find "$move_failures_dir" -type f | wc -l) # Clear the previous line and print the updated progress echo -ne "\r\033[K" echo -ne "${PURPLE}$ICON_WORKING Progress: ${GREEN}$bar ${BOLD}${percent}%${NC} " echo -ne "[${GREEN}${success}✓${NC}|${RED}${compile_fails}✗${NC}|${YELLOW}${move_fails}!${NC}] " echo -ne "${BLUE}($completed/$total_files)${NC}" # If all files are processed, print the completion message ONLY ONCE if [ $completed -eq $total_files ] && [ ! -e "$final_progress_file.done" ]; then touch "$final_progress_file.done" echo -e "\n${GREEN}${BOLD}$ICON_COMPLETE All files processed!${NC}" fi ) 200>"$progress_lock" } # Function to show final progress (called only once at the end) show_final_progress() { # If progress is disabled, do nothing if [ "$show_progress" -eq 0 ]; then return 0 fi ( flock -w 1 200 # Only proceed if the final progress hasn't been shown yet if [ -e "$final_progress_file.done" ]; then return 0 fi completed=$(find "$progress_dir" -type f | wc -l) percent=$((completed * 100 / total_files)) bar_length=50 filled_length=$((bar_length * completed / total_files)) # Create the progress bar bar="" for ((i=0; i<bar_length; i++)); do if [ $i -lt $filled_length ]; then bar="${bar}█" else bar="${bar}░" fi done # Calculate success and failure counts success=$((completed - $(find "$compile_failures_dir" "$move_failures_dir" -type f | wc -l))) compile_fails=$(find "$compile_failures_dir" -type f | wc -l) move_fails=$(find "$move_failures_dir" -type f | wc -l) # Clear the previous line and print the updated progress echo -ne "\r\033[K" echo -ne "${PURPLE}$ICON_WORKING Progress: ${GREEN}$bar ${BOLD}${percent}%${NC} " echo -ne "[${GREEN}${success}✓${NC}|${RED}${compile_fails}✗${NC}|${YELLOW}${move_fails}!${NC}] " echo -ne "${BLUE}($completed/$total_files)${NC}" # Mark final progress as shown touch "$final_progress_file.done" # If all files are processed, print the completion message if [ $completed -eq $total_files ]; then echo -e "\n${GREEN}${BOLD}$ICON_COMPLETE All files processed!${NC}" fi ) 200>"$progress_lock" } # Function to process a single .typ file process_file() { typfile="$1" file_id=$(echo "$typfile" | md5sum | cut -d' ' -f1) # Get the directory containing the .typ file typdir=$(dirname "$typfile") # Get the filename without path filename=$(basename "$typfile") # Get the filename without extension basename="${filename%.typ}" # Check if output directory exists or should be created target_dir="$typdir/$output_dir" if [ ! -d "$target_dir" ]; then if [ "$create_dirs" -eq 1 ]; then if [ "$dry_run" -eq 0 ]; then mkdir -p "$target_dir" log_debug "Created directory: $target_dir" else log_debug "[DRY RUN] Would create directory: $target_dir" fi else # Skip this file if output directory doesn't exist and --create-dirs not specified log_debug "Skipping $typfile (no $output_dir directory)" touch "$progress_dir/$file_id" update_progress_during return 0 fi fi target_pdf="$target_dir/$basename.pdf" # Skip if PDF is newer than source and --skip-newer is specified if [ "$skip_newer" -eq 1 ] && [ -f "$target_pdf" ]; then if [ "$typfile" -ot "$target_pdf" ] && [ "$force" -eq 0 ]; then log_debug "Skipping $typfile (PDF is newer)" touch "$progress_dir/$file_id" update_progress_during return 0 fi fi # Check if file has changed (if caching is enabled) if [ "$use_cache" -eq 1 ] && [ "$dry_run" -eq 0 ]; then if ! has_file_changed "$typfile"; then # Try to retrieve cached PDF if get_cached_pdf "$typfile" "$target_pdf"; then log_debug "Using cached PDF for $typfile" touch "$progress_dir/$file_id" update_progress_during return 0 fi fi fi # Create a temporary file for capturing compiler output temp_output="$temp_dir/output_${file_id}.log" # Add a header to the log before compilation { echo -e "\n===== COMPILING: $typfile =====" echo "$(date)" } > "$temp_output.header" # In dry run mode, just log what would be done if [ "$dry_run" -eq 1 ]; then log_debug "[DRY RUN] Would compile: $typfile" log_debug "[DRY RUN] Would move to: $target_pdf" touch "$progress_dir/$file_id" update_progress_during return 0 fi # Compile the .typ file using typst with --root flag and capture all output if ! typst compile --root "$CWD" "$typfile" > "$temp_output.stdout" 2> "$temp_output.stderr"; then # Store the failure echo "$typfile" > "$compile_failures_dir/$file_id" log_debug "Compilation failed for $typfile" # Combine stdout and stderr cat "$temp_output.stdout" "$temp_output.stderr" > "$temp_output.combined" # Filter the output to only include error messages using ripgrep rg "error:" -A 20 "$temp_output.combined" > "$temp_output.errors" || true # Lock the log file to avoid concurrent writes corrupting it ( flock -w 1 201 cat "$temp_output.header" "$temp_output.errors" >> "$compile_log" echo -e "\n" >> "$compile_log" ) 201>"$compile_log.lock" else # Check if the output PDF exists temp_pdf="$typdir/$basename.pdf" if [ -f "$temp_pdf" ]; then # Cache the PDF if caching is enabled if [ "$use_cache" -eq 1 ]; then cache_pdf "$typfile" "$temp_pdf" # Update file hash update_file_hash "$typfile" fi # Try to move the output PDF to the output directory move_header="$temp_dir/move_${file_id}.header" { echo -e "\n===== MOVING: $typfile =====" echo "$(date)" } > "$move_header" if ! mv "$temp_pdf" "$target_dir/" 2> "$temp_output.move_err"; then echo "$typfile -> $target_pdf" > "$move_failures_dir/$file_id" log_debug "Failed to move $basename.pdf to $target_dir/" # Lock the log file to avoid concurrent writes corrupting it ( flock -w 1 202 cat "$move_header" "$temp_output.move_err" >> "$move_log" echo "Failed to move $temp_pdf to $target_dir/" >> "$move_log" ) 202>"$move_log.lock" else log_debug "Moved $basename.pdf to $target_dir/" fi else # This is a fallback check in case typst doesn't return error code echo "$typfile" > "$compile_failures_dir/$file_id" log_debug "Compilation completed without errors but no PDF was generated for $typfile" # Lock the log file to avoid concurrent writes corrupting it ( flock -w 1 201 echo "Compilation completed without errors but no PDF was generated" >> "$compile_log" ) 201>"$compile_log.lock" fi fi # Mark this file as processed (for progress tracking) touch "$progress_dir/$file_id" # Update the progress bar update_progress_during } export -f process_file export -f update_progress_during export -f show_final_progress export -f log_debug export -f log_info export -f log_warning export -f log_error export -f log_success export -f has_file_changed export -f update_file_hash export -f cache_pdf export -f get_cached_pdf export CWD export temp_dir export compile_failures_dir export move_failures_dir export progress_dir export final_progress_file export progress_lock export compile_log export move_log export cache_dir export git_repo_root export in_git_repo export total_files export GREEN BLUE YELLOW RED CYAN PURPLE NC BOLD export ICON_SUCCESS ICON_ERROR ICON_WORKING ICON_COMPILE ICON_MOVE ICON_COMPLETE ICON_SUMMARY ICON_INFO ICON_DEBUG ICON_CACHE ICON_GIT export verbose export quiet export output_dir export create_dirs export dry_run export skip_newer export show_progress export force export use_cache export dependency_scan export use_git # Determine the number of CPU cores and use that many parallel jobs (if not specified) if [ "$jobs" -eq 0 ]; then jobs=$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 4) fi log_info "Using ${BOLD}$jobs${NC} parallel jobs for compilation" # Build dependency graph if dependency scanning is enabled if [ "$dependency_scan" -eq 1 ] && [ "$total_files" -gt 0 ]; then build_dependency_graph # Use optimized compilation order cp "$temp_dir/compile_order.txt" "$typst_files_list" log_info "Optimized compilation order based on dependencies" fi # Initialize progress bar if showing progress if [ "$show_progress" -eq 1 ]; then update_progress_during fi # Process files in parallel with --will-cite to suppress citation notice if [ "$total_files" -gt 0 ]; then cat "$typst_files_list" | parallel --will-cite --jobs "$jobs" process_file # Wait a moment for any remaining progress updates to complete sleep 0.5 # Show the final progress exactly once if showing progress if [ "$show_progress" -eq 1 ]; then show_final_progress fi # Print summary of failures if [ "$quiet" -eq 0 ]; then echo -e "\n${BOLD}${PURPLE}$ICON_SUMMARY Processing Summary${NC}" fi # Collect all failure files compile_failures=$(find "$compile_failures_dir" -type f | wc -l) move_failures=$(find "$move_failures_dir" -type f | wc -l) if [ "$compile_failures" -eq 0 ] && [ "$move_failures" -eq 0 ]; then log_success "All files processed successfully." else if [ "$compile_failures" -gt 0 ]; then echo -e "\n${RED}${BOLD}$ICON_ERROR Compilation failures:${NC}" find "$compile_failures_dir" -type f -exec cat {} \; | sort | while read -r failure; do echo -e "${RED}- $failure${NC}" done echo -e "${BLUE}See $compile_log for detailed error messages.${NC}" fi if [ "$move_failures" -gt 0 ]; then echo -e "\n${YELLOW}${BOLD}$ICON_ERROR Move failures:${NC}" find "$move_failures_dir" -type f -exec cat {} \; | sort | while read -r failure; do echo -e "${YELLOW}- $failure${NC}" done echo -e "${BLUE}See $move_log for detailed error messages.${NC}" fi fi # Cache usage statistics (if enabled and not in quiet mode) if [ "$use_cache" -eq 1 ] && [ "$quiet" -eq 0 ]; then cache_files=$(find "${cache_dir}/pdfs" -type f | wc -l) cache_size=$(du -sh "${cache_dir}" 2>/dev/null | cut -f1) echo -e "\n${CYAN}${ICON_CACHE} Cache statistics:${NC}" echo -e " - Cached files: ${BOLD}$cache_files${NC}" echo -e " - Cache size: ${BOLD}$cache_size${NC}" echo -e " - Cache location: ${BOLD}$cache_dir${NC}" fi else log_warning "No .typ files found to process." fi # Clean up temporary directory and lock files rm -rf "$temp_dir" rm -f "$progress_lock" "$compile_log.lock" "$move_log.lock" log_success "Processing complete."