@dtt_siye/atool 1.1.0

package/lib/compute-importance.sh

@@ -0,0 +1,598 @@
+#!/usr/bin/env bash
+# aTool - lib/compute-importance.sh
+# Module importance scoring for project-analyze v5.0
+#
+# Usage: source this file, then call compute_importance <project_root> [--inventory-dir <path>]
+#   Or run directly: compute-importance.sh <project_root> [--inventory-dir <path>]
+#
+# Reads module structure and computes importance scores based on:
+#   - Centrality (20%): How many modules import this module
+#   - Size score (15%): Relative file count (log-scaled)
+#   - Entry point (15%): Contains router/main/App/entry files
+#   - Recency (10%): Recently changed files (git log, last 30 days)
+#   - Business critical (15%): Domain keywords in paths/files
+#   - Layer core (10%): Module in core business layer (service/domain)
+#   - API surface (10%): Number of exposed API endpoints
+#   - Data ownership (5%): Number of owned data entities
+#
+# Output format (tab-separated): module_path<tab>importance_score<tab>tier
+# tier is one of: deep, catalog, skip
+
+set -euo pipefail
+
+# shellcheck source=lib/common.sh
+# shellcheck disable=SC1091
+source "$(dirname "${BASH_SOURCE[0]}")/common.sh"
+
+# === Configuration ===
+
+BUSINESS_KEYWORDS="auth|authentication|login|session|token|jwt|oauth|permission|role|rbac|acl|payment|pay|order|cart|checkout|purchase|billing|invoice|subscription|user|account|member|profile|admin|tenant|customer"
+
+ENTRY_POINT_PATTERNS="router routes index main App app bootstrap setup server handler controller"
+
+# Directories to exclude from module discovery
+IMPORTANCE_EXCLUDE_DIRS=(
+    "node_modules" "vendor" ".git" "dist" "build" "target"
+    "__pycache__" ".next" ".nuxt" ".output" ".atool-docs"
+    "coverage" ".cache" ".turbo" ".gradle" ".mvn"
+)
+
+# Source file extensions for module detection
+SOURCE_EXTENSIONS=(
+    "*.ts" "*.tsx" "*.js" "*.jsx" "*.vue" "*.py" "*.java"
+    "*.kt" "*.go" "*.rs" "*.swift" "*.dart" "*.c" "*.cpp" "*.h"
+)
+
+# === Module Discovery ===
+
+# Build find exclude arguments from IMPORTANCE_EXCLUDE_DIRS
+# Args: none
+# Output: space-separated exclude args for find
+_build_importance_exclude_args() {
+    local args=""
+    for d in "${IMPORTANCE_EXCLUDE_DIRS[@]}"; do
+        args+="-not -path */${d}/* "
+    done
+    printf '%s' "$args"
+}
+
+# Scan project for source modules (directories with 3+ source files).
+# Args: PROJECT_ROOT - root directory to scan
+# Output: one module path per line
+discover_modules() {
+    local root="$1"
+
+    local exclude_args=()
+    for d in "${IMPORTANCE_EXCLUDE_DIRS[@]}"; do
+        exclude_args+=(-not -path "*/${d}/*")
+    done
+
+    local find_args=()
+    for ext in "${SOURCE_EXTENSIONS[@]}"; do
+        find_args+=(-o -name "$ext")
+    done
+
+    # Find all directories that contain 3+ source files (non-recursive per dir)
+    while IFS= read -r -d '' dir; do
+        local src_count
+        # shellcheck disable=SC2068
+        src_count=$(find "$dir" -maxdepth 1 -type f \( -false ${find_args[@]} \) 2>/dev/null | wc -l | tr -d ' ')
+        if [[ "$src_count" -ge 3 ]]; then
+            printf '%s\n' "$dir"
+        fi
+    done < <(find "$root" -type d "${exclude_args[@]}" -print0 2>/dev/null)
+}
+
+# === Factor 1: Centrality (30%) ===
+# Count how many modules import each module based on inventory JSON edges.
+# Args: INVENTORY_DIR - directory containing .json module inventory files
+#       MODULES_LIST - newline-separated list of module paths
+# Output: module_path=<importer_count> per line (for all modules, even those not in inventory)
+compute_centrality() {
+    local inventory_dir="$1"
+    local modules_list="$2"
+
+    # If no inventory data, all modules get centrality 0
+    if [[ ! -d "$inventory_dir" ]]; then
+        while IFS= read -r module; do
+            printf '%s=0\n' "$module"
+        done <<< "$modules_list"
+        return 0
+    fi
+
+    # Count inventory files; if none, return 0 for all
+    local inv_count=0
+    for _ in "$inventory_dir"/*.json; do
+        [[ -f "$_" ]] || continue
+        inv_count=$((inv_count + 1))
+    done
+
+    if [[ "$inv_count" -eq 0 ]]; then
+        while IFS= read -r module; do
+            printf '%s=0\n' "$module"
+        done <<< "$modules_list"
+        return 0
+    fi
+
+    # Count importers for each target module from outgoing edges
+    local centrality_data=""
+    if command -v jq &>/dev/null; then
+        # Parse all outgoing edges from inventory files
+        for inv_file in "$inventory_dir"/*.json; do
+            [[ -f "$inv_file" ]] || continue
+            # Extract target_module from outgoing_edges
+            local targets
+            targets=$(jq -r '(.outgoing_edges // [])[] | .[].target_module // empty' "$inv_file" 2>/dev/null || true)
+            if [[ -n "$targets" ]]; then
+                centrality_data+="$targets"$'\n'
+            fi
+        done
+    fi
+
+    # Count occurrences of each module path as an import target
+    while IFS= read -r module; do
+        local count=0
+        if [[ -n "$centrality_data" ]]; then
+            local module_name
+            module_name=$(basename "$module")
+            # Count how many times this module appears as a target
+            count=$(printf '%s' "$centrality_data" | grep -cF "$module_name" 2>/dev/null || echo "0")
+            # Also try matching by path
+            local by_path
+            by_path=$(printf '%s' "$centrality_data" | grep -cF "$module" 2>/dev/null || echo "0")
+            if [[ "$by_path" -gt "$count" ]]; then
+                count="$by_path"
+            fi
+        fi
+        printf '%s=%s\n' "$module" "$count"
+    done <<< "$modules_list"
+}
+
+# === Factor 2: Size Score (20%) ===
+# log(file_count) / log(max_files) — normalized 0..1
+# Args: MODULES_LIST - newline-separated list of module paths
+# Output: module_path <score> per line (space-separated)
+compute_size_score() {
+    local modules_list="$1"
+
+    local max_files=0
+
+    # First pass: find max file count
+    while IFS= read -r module; do
+        [[ -z "$module" ]] && continue
+        local src_count
+        src_count=$(find "$module" -maxdepth 1 -type f 2>/dev/null | wc -l | tr -d ' ')
+        if [[ "$src_count" -gt "$max_files" ]]; then
+            max_files="$src_count"
+        fi
+    done <<< "$modules_list"
+
+    # Second pass: compute log-scaled normalized score
+    if [[ "$max_files" -gt 0 ]]; then
+        while IFS= read -r module; do
+            [[ -z "$module" ]] && continue
+            local src_count
+            src_count=$(find "$module" -maxdepth 1 -type f 2>/dev/null | wc -l | tr -d ' ')
+            # Use awk for cross-platform log calculation (avoid bc dependency)
+            printf '%s %s\n' "$module" "$(awk "BEGIN { printf \"%.4f\", log($src_count + 1) / log($max_files + 1) }")"
+        done <<< "$modules_list"
+    else
+        # No files found; all modules get neutral score
+        while IFS= read -r module; do
+            [[ -z "$module" ]] && continue
+            printf '%s 0.0\n' "$module"
+        done <<< "$modules_list"
+    fi
+}
+
+# === Factor 3: Entry Point (20%) ===
+# Check if module contains entry-point files (router, main, App, etc.)
+# Args: MODULES_LIST - newline-separated list of module paths
+# Output: module_path <0|1> per line (space-separated)
+compute_entry_point() {
+    local modules_list="$1"
+
+    while IFS= read -r module; do
+        [[ -z "$module" ]] && continue
+        local found=0
+        for pattern in $ENTRY_POINT_PATTERNS; do
+            # Use find + head (cross-platform) instead of grep -qi
+            if find "$module" -maxdepth 1 -type f -iname "*${pattern}*" 2>/dev/null | head -1 | grep -q .; then
+                found=1
+                break
+            fi
+        done
+        printf '%s %d\n' "$module" "$found"
+    done <<< "$modules_list"
+}
+
+# === Factor 4: Recency (15%) ===
+# Normalize git commit count in last 30 days per module (0..1)
+# Args: PROJECT_ROOT - git repository root
+#       MODULES_LIST - newline-separated list of module paths
+# Output: module_path <score> per line (space-separated)
+compute_recency() {
+    local root="$1"
+    local modules_list="$2"
+
+    # Not a git repo: all modules get neutral 0.5
+    if ! git -C "$root" rev-parse --short &>/dev/null 2>&1; then
+        while IFS= read -r module; do
+            [[ -z "$module" ]] && continue
+            printf '%s 0.5\n' "$module"
+        done <<< "$modules_list"
+        return 0
+    fi
+
+    local max_commits=0
+
+    # First pass: find max commit count across modules
+    while IFS= read -r module; do
+        [[ -z "$module" ]] && continue
+        local rel_path
+        rel_path=$(cd "$root" && git ls-files -- "$module" 2>/dev/null | head -1 || true)
+        if [[ -n "$rel_path" ]]; then
+            local commit_count
+            commit_count=$(cd "$root" && git log --since="30 days ago" --oneline -- "$rel_path" 2>/dev/null | wc -l | tr -d ' ')
+            if [[ "$commit_count" -gt "$max_commits" ]]; then
+                max_commits="$commit_count"
+            fi
+        fi
+    done <<< "$modules_list"
+
+    # Second pass: compute normalized recency
+    if [[ "$max_commits" -gt 0 ]]; then
+        while IFS= read -r module; do
+            [[ -z "$module" ]] && continue
+            local rel_path
+            rel_path=$(cd "$root" && git ls-files -- "$module" 2>/dev/null | head -1 || true)
+            if [[ -n "$rel_path" ]]; then
+                local commit_count
+                commit_count=$(cd "$root" && git log --since="30 days ago" --oneline -- "$rel_path" 2>/dev/null | wc -l | tr -d ' ')
+                printf '%s %s\n' "$module" "$(awk "BEGIN { printf \"%.4f\", $commit_count / $max_commits }")"
+            else
+                printf '%s 0.0\n' "$module"
+            fi
+        done <<< "$modules_list"
+    else
+        # No git history in last 30 days; all modules get neutral score
+        while IFS= read -r module; do
+            [[ -z "$module" ]] && continue
+            printf '%s 0.5\n' "$module"
+        done <<< "$modules_list"
+    fi
+}
+
+# === Factor 5: Business Critical (15%) ===
+# Check if module path contains business-critical keywords
+# Args: MODULES_LIST - newline-separated list of module paths
+# Output: module_path <0|1> per line (space-separated)
+compute_business_critical() {
+    local modules_list="$1"
+
+    while IFS= read -r module; do
+        [[ -z "$module" ]] && continue
+        local found=0
+        # Convert pipe-separated keywords to newline-separated for iteration
+        # Use grep -iE for cross-platform case-insensitive extended regex
+        if printf '%s' "$BUSINESS_KEYWORDS" | tr '|' '\n' | while IFS= read -r keyword; do
+                # Use case-insensitive match via shell [[ ]] (cross-platform)
+                shopt -s nocasematch 2>/dev/null || true
+                if [[ "$module" == *"$keyword"* ]]; then
+                    echo "match"
+                    break
+                fi
+                shopt -u nocasematch 2>/dev/null || true
+            done | grep -q "match"; then
+            found=1
+        fi
+        printf '%s %d\n' "$module" "$found"
+    done <<< "$modules_list"
+}
+
+# === Factor 6: Layer Core (10%) ===
+# Check if module is in a core business layer (service, domain, application).
+# Uses directory name and architectural layer detection.
+# Args: MODULES_LIST - newline-separated list of module paths
+# Output: module_path <0|1> per line (space-separated)
+compute_layer_core() {
+    local modules_list="$1"
+    local core_patterns="service|domain|usecase|application|business|core|logic|facade|manager"
+
+    while IFS= read -r module; do
+        [[ -z "$module" ]] && continue
+        local found=0
+        local basename
+        basename=$(basename "$module")
+        # Check if module directory name matches core layer patterns
+        if printf '%s' "$core_patterns" | tr '|' '\n' | while IFS= read -r keyword; do
+                shopt -s nocasematch 2>/dev/null || true
+                if [[ "$basename" == *"$keyword"* ]]; then
+                    echo "match"
+                    break
+                fi
+                shopt -u nocasematch 2>/dev/null || true
+            done | grep -q "match"; then
+            found=1
+        fi
+        printf '%s %d\n' "$module" "$found"
+    done <<< "$modules_list"
+}
+
+# === Factor 7: API Surface (10%) ===
+# Count API endpoints exposed by module (normalized).
+# Checks for API-related files: controllers, routes, handlers, endpoints.
+# Args: MODULES_LIST - newline-separated list of module paths
+#       INVENTORY_DIR - optional path to inventory JSON (for accurate count)
+# Output: module_path <score> per line (space-separated), normalized 0..1
+compute_api_surface() {
+    local modules_list="$1"
+    local inventory_dir="${2:-}"
+
+    local max_endpoints=0
+    local -A module_api_counts 2>/dev/null || true  # May not work in older bash
+
+    # First pass: count API endpoints per module
+    local tmpfile
+    tmpfile=$(mktemp "${TMPDIR:-/tmp}/atool-api-surface.XXXXXX")
+
+    while IFS= read -r module; do
+        [[ -z "$module" ]] && continue
+        local count=0
+
+        # Try inventory JSON first for accurate count
+        if [[ -n "$inventory_dir" && -d "$inventory_dir" ]] && command -v jq &>/dev/null; then
+            local module_slug
+            module_slug=$(echo "$module" | tr '/' '-' | sed 's/^-//')
+            local inv_file="$inventory_dir/${module_slug}.json"
+            if [[ -f "$inv_file" ]]; then
+                count=$(jq '[.files[] | select(.type == "api_endpoint" or .type == "route")] | length' "$inv_file" 2>/dev/null || echo "0")
+            fi
+        fi
+
+        # Fallback: heuristic file counting
+        if [[ "$count" -eq 0 ]]; then
+            # Count files with API-related names
+            count=$(find "$module" -maxdepth 1 -type f \( -iname "*controller*" -o -iname "*handler*" -o -iname "*route*" -o -iname "*endpoint*" -o -iname "*api*" \) 2>/dev/null | wc -l | tr -d ' ')
+            # Also count @RequestMapping/@GetMapping/etc in Java files
+            local java_count=0
+            java_count=$(find "$module" -maxdepth 1 -name "*.java" -exec grep -l "@.*Mapping\|@Controller\|@RestController" {} \; 2>/dev/null | wc -l | tr -d ' ')
+            count=$((count + java_count))
+        fi
+
+        printf '%s %d\n' "$module" "$count" >> "$tmpfile"
+        if [[ "$count" -gt "$max_endpoints" ]]; then
+            max_endpoints="$count"
+        fi
+    done <<< "$modules_list"
+
+    # Second pass: normalize
+    while IFS=' ' read -r module count; do
+        [[ -z "$module" ]] && continue
+        if [[ "$max_endpoints" -gt 0 ]]; then
+            printf '%s %s\n' "$module" "$(awk "BEGIN { printf \"%.4f\", $count / $max_endpoints }")"
+        else
+            printf '%s 0.0\n' "$module"
+        fi
+    done < "$tmpfile"
+
+    rm -f "$tmpfile"
+}
+
+# === Factor 8: Data Ownership (5%) ===
+# Count data entities owned by module (normalized).
+# Checks for entity/model/schema/type definitions.
+# Args: MODULES_LIST - newline-separated list of module paths
+#       INVENTORY_DIR - optional path to inventory JSON
+# Output: module_path <score> per line (space-separated), normalized 0..1
+compute_data_ownership() {
+    local modules_list="$1"
+    local inventory_dir="${2:-}"
+
+    local max_entities=0
+    local tmpfile
+    tmpfile=$(mktemp "${TMPDIR:-/tmp}/atool-data-own.XXXXXX")
+
+    while IFS= read -r module; do
+        [[ -z "$module" ]] && continue
+        local count=0
+
+        # Try inventory JSON first
+        if [[ -n "$inventory_dir" && -d "$inventory_dir" ]] && command -v jq &>/dev/null; then
+            local module_slug
+            module_slug=$(echo "$module" | tr '/' '-' | sed 's/^-//')
+            local inv_file="$inventory_dir/${module_slug}.json"
+            if [[ -f "$inv_file" ]]; then
+                count=$(jq '[.files[] | select(.type == "data_entity" or .type == "store")] | length' "$inv_file" 2>/dev/null || echo "0")
+            fi
+        fi
+
+        # Fallback: heuristic counting
+        if [[ "$count" -eq 0 ]]; then
+            count=$(find "$module" -maxdepth 1 -type f \( -iname "*entity*" -o -iname "*model*" -o -iname "*schema*" -o -iname "*type*" -o -iname "*dto*" -o -iname "*vo*" \) 2>/dev/null | wc -l | tr -d ' ')
+        fi
+
+        printf '%s %d\n' "$module" "$count" >> "$tmpfile"
+        if [[ "$count" -gt "$max_entities" ]]; then
+            max_entities="$count"
+        fi
+    done <<< "$modules_list"
+
+    while IFS=' ' read -r module count; do
+        [[ -z "$module" ]] && continue
+        if [[ "$max_entities" -gt 0 ]]; then
+            printf '%s %s\n' "$module" "$(awk "BEGIN { printf \"%.4f\", $count / $max_entities }")"
+        else
+            printf '%s 0.0\n' "$module"
+        fi
+    done < "$tmpfile"
+
+    rm -f "$tmpfile"
+}
+
+# === Tier Classification ===
+# Map a composite score to a tier label.
+# Args: SCORE - composite importance score (0..1)
+# Output: tier label (deep, catalog, or skip)
+classify_tier() {
+    local score="$1"
+    # Use awk for cross-platform float comparison
+    local tier
+    tier=$(awk "BEGIN {
+        if ($score >= 0.6) print \"deep\"
+        else if ($score >= 0.3) print \"catalog\"
+        else print \"skip\"
+    }")
+    printf '%s' "$tier"
+}
+
+# === Normalize Centrality ===
+# Normalize raw importer counts to 0..1 range
+# Args: CENTRALITY_RAW - module=count lines
+# Output: module=<normalized_score> lines
+_normalize_centrality() {
+    local raw_data="$1"
+
+    local max_count=0
+    while IFS='=' read -r mod value; do
+        [[ -z "$mod" ]] && continue
+        if [[ "$value" -gt "$max_count" ]] 2>/dev/null; then
+            max_count="$value"
+        fi
+    done <<< "$raw_data"
+
+    while IFS='=' read -r mod value; do
+        [[ -z "$mod" ]] && continue
+        if [[ "$max_count" -gt 0 ]]; then
+            printf '%s=%s\n' "$mod" "$(awk "BEGIN { printf \"%.4f\", $value / $max_count }")"
+        else
+            printf '%s=0.0\n' "$mod"
+        fi
+    done <<< "$raw_data"
+}
+
+# === Main Entry Point ===
+# Compute composite importance scores for all discovered modules.
+# Args: PROJECT_ROOT - project root directory
+#       [--inventory-dir PATH] - optional path to inventory JSON files
+# Output: tab-separated: module_path<tab>importance_score<tab>tier
+compute_importance() {
+    local root="${1:-.}"
+    local inventory_dir="${root}/.atool-docs/inventory"
+
+    # Parse optional arguments
+    local shift_count=1
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --inventory-dir)
+                inventory_dir="$2"
+                shift 2
+                ;;
+            *)
+                shift
+                ;;
+        esac
+    done
+
+    if [[ ! -d "$root" ]]; then
+        log_error "Project root '$root' does not exist"
+        return 1
+    fi
+
+    log_info "Discovering modules in $root"
+    local modules
+    modules=$(discover_modules "$root")
+
+    if [[ -z "$modules" ]]; then
+        log_warn "No modules found in $root"
+        return 0
+    fi
+
+    local module_count
+    module_count=$(printf '%s' "$modules" | grep -c . || true)
+    log_info "Found $module_count modules"
+
+    # Compute all eight factors
+    log_info "Computing centrality..."
+    local centrality_raw
+    centrality_raw=$(compute_centrality "$inventory_dir" "$modules")
+    local centrality
+    centrality=$(_normalize_centrality "$centrality_raw")
+
+    log_info "Computing size scores..."
+    local size_scores
+    size_scores=$(compute_size_score "$modules")
+
+    log_info "Computing entry points..."
+    local entry_points
+    entry_points=$(compute_entry_point "$modules")
+
+    log_info "Computing recency..."
+    local recency
+    recency=$(compute_recency "$root" "$modules")
+
+    log_info "Computing business criticality..."
+    local business_critical
+    business_critical=$(compute_business_critical "$modules")
+
+    log_info "Computing layer core..."
+    local layer_core
+    layer_core=$(compute_layer_core "$modules")
+
+    log_info "Computing API surface..."
+    local api_surface
+    api_surface=$(compute_api_surface "$modules" "$inventory_dir")
+
+    log_info "Computing data ownership..."
+    local data_ownership
+    data_ownership=$(compute_data_ownership "$modules" "$inventory_dir")
+
+    # Build associative maps from factor outputs
+    # Using temporary files for portability (avoid bash 4+ associative arrays in pipe subshells)
+    local tmpdir
+    tmpdir=$(mktemp -d "${TMPDIR:-/tmp}/atool-importance.XXXXXX")
+
+    # Parse each factor into temp files: module<TAB>value
+    printf '%s\n' "$centrality" | sed 's/=/\t/' > "$tmpdir/centrality"
+    printf '%s\n' "$size_scores" | sed 's/ /\t/' > "$tmpdir/size"
+    printf '%s\n' "$entry_points" | sed 's/ /\t/' > "$tmpdir/entry"
+    printf '%s\n' "$recency" | sed 's/ /\t/' > "$tmpdir/recency"
+    printf '%s\n' "$business_critical" | sed 's/ /\t/' > "$tmpdir/business"
+    printf '%s\n' "$layer_core" | sed 's/ /\t/' > "$tmpdir/layer_core"
+    printf '%s\n' "$api_surface" | sed 's/ /\t/' > "$tmpdir/api_surface"
+    printf '%s\n' "$data_ownership" | sed 's/ /\t/' > "$tmpdir/data_ownership"
+
+    # Join all factors by module path and compute composite score
+    while IFS= read -r module; do
+        [[ -z "$module" ]] && continue
+
+        # Look up each factor value for this module
+        local c s e r b l a d
+        c=$(grep -F "$module" "$tmpdir/centrality" 2>/dev/null | head -1 | cut -f2 || echo "0")
+        s=$(grep -F "$module" "$tmpdir/size" 2>/dev/null | head -1 | cut -f2 || echo "0")
+        e=$(grep -F "$module" "$tmpdir/entry" 2>/dev/null | head -1 | cut -f2 || echo "0")
+        r=$(grep -F "$module" "$tmpdir/recency" 2>/dev/null | head -1 | cut -f2 || echo "0")
+        b=$(grep -F "$module" "$tmpdir/business" 2>/dev/null | head -1 | cut -f2 || echo "0")
+        l=$(grep -F "$module" "$tmpdir/layer_core" 2>/dev/null | head -1 | cut -f2 || echo "0")
+        a=$(grep -F "$module" "$tmpdir/api_surface" 2>/dev/null | head -1 | cut -f2 || echo "0")
+        d=$(grep -F "$module" "$tmpdir/data_ownership" 2>/dev/null | head -1 | cut -f2 || echo "0")
+
+        # Weighted composite: 20% centrality + 15% size + 15% entry + 15% business + 10% recency + 10% layer + 10% API + 5% data
+        local score
+        score=$(awk "BEGIN { printf \"%.4f\", 0.20 * ${c:-0} + 0.15 * ${s:-0} + 0.15 * ${e:-0} + 0.15 * ${b:-0} + 0.10 * ${r:-0} + 0.10 * ${l:-0} + 0.10 * ${a:-0} + 0.05 * ${d:-0} }")
+
+        local tier
+        tier=$(classify_tier "$score")
+
+        printf '%s\t%s\t%s\n' "$module" "$score" "$tier"
+    done <<< "$modules" | sort -t'	' -k2,2nr
+
+    # Cleanup temp directory
+    rm -rf "$tmpdir"
+}
+
+# === Standalone Execution ===
+# When run directly (not sourced), execute compute_importance with CLI args
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    compute_importance "$@"
+fi