@dtt_siye/atool 1.3.0 → 1.4.0

package/lib/knowledge-graph.sh

@@ -9,6 +9,51 @@
 # in .atool-docs/inventory/ and output structured data to .atool-docs/knowledge-graph.json
 set -euo pipefail
 
+# === Internal Helper: Safe jq -s with Invalid JSON Filtering ===
+
+# Run jq -s safely on a directory's JSON files, skipping invalid ones.
+# Returns the jq output or the fallback value if no valid files exist.
+#
+# Args:
+#   $1 - filter:    jq filter expression
+#   $2 - json_dir:  directory containing *.json files (NOT a glob — bash expands globs before function call)
+#   $3 - fallback:  value to return if jq fails or no valid files (default: "{}")
+# Output: jq result or fallback to stdout
+_jq_slurp_safe() {
+    local filter="$1"
+    local json_dir="$2"
+    local fallback="${3:-}"
+    [[ -z "$fallback" ]] && fallback="{}"
+
+    if [[ ! -d "$json_dir" ]]; then
+        echo "$fallback"
+        return
+    fi
+
+    # Collect only valid JSON files from the directory
+    local valid_files=()
+    local f
+    for f in "$json_dir"/*.json; do
+        [[ ! -f "$f" ]] && continue
+        if jq '.' "$f" > /dev/null 2>&1; then
+            valid_files+=("$f")
+        fi
+    done
+
+    if [[ ${#valid_files[@]} -eq 0 ]]; then
+        echo "$fallback"
+        return
+    fi
+
+    local result
+    result=$(jq -s "$filter" "${valid_files[@]}" 2>/dev/null) || true
+    if [[ -n "$result" && "$result" != "null" ]]; then
+        echo "$result"
+    else
+        echo "$fallback"
+    fi
+}
+
 # === Node Counting ===
 
 # Count nodes by type from inventory JSON files.
@@ -32,12 +77,10 @@ count_graph_nodes() {
         return
     fi
 
-    # Aggregate node counts from all inventory JSON files.
-    # Each file has "files" array with "type" field per entry.
-    # Null-coalesce missing types to 0.
+    # Aggregate node counts from all valid inventory JSON files.
     local result
-    result=$(jq -s \
-        '[ .[].files // [] | .[].type ]
+    result=$(_jq_slurp_safe '
+        [ .[].files // [] | .[].type ]
        | group_by(.)
        | map({key: .[0], value: length})
        | from_entries
@@ -52,13 +95,9 @@ count_graph_nodes() {
            api_endpoint: (.api_endpoint // 0),
            route:        (.route        // 0),
            config:       (.config       // 0)
-         }' "$inventory_dir"/*.json 2>/dev/null)
+         }' "$inventory_dir" "{}")
 
-    if [[ -n "$result" ]]; then
-        echo "$result"
-    else
-        echo "{}"
-    fi
+    echo "$result"
 }
 
 # === Edge Counting ===
@@ -82,11 +121,10 @@ count_graph_edges() {
         return
     fi
 
-    # Aggregate edge counts from all inventory files.
-    # Each file has "outgoing_edges" array with "type" field per entry.
+    # Aggregate edge counts from all valid inventory files.
     local result
-    result=$(jq -s \
-        '[ .[].outgoing_edges // [] | .[].type ]
+    result=$(_jq_slurp_safe '
+        [ .[].outgoing_edges // [] | .[].type ]
        | group_by(.)
        | map({key: .[0], value: length})
        | from_entries
@@ -103,13 +141,9 @@ count_graph_edges() {
            persists_to:  (.persists_to  // 0),
            implements:   (.implements   // 0),
            extends:      (.extends      // 0)
-         }' "$inventory_dir"/*.json 2>/dev/null)
+         }' "$inventory_dir" "{}")
 
-    if [[ -n "$result" ]]; then
-        echo "$result"
-    else
-        echo "{}"
-    fi
+    echo "$result"
 }
 
 # === Cycle Detection ===
@@ -135,17 +169,16 @@ detect_cycles() {
     fi
 
     # Build adjacency list from depends_on edges: source_module -> [target_modules]
-    # Each edge in outgoing_edges has: type, source, target_module
     local adj_json
-    adj_json=$(jq -s \
-        '[ .[].outgoing_edges // []
+    adj_json=$(_jq_slurp_safe '
+        [ .[].outgoing_edges // []
          | .[]
          | select(.type == "depends_on")
          | {source: (.source // ""), target: (.target_module // "")}
          | select(.source != "" and .target != "") ]
        | group_by(.source)
        | map({key: .[0].source, value: (map(.target) | unique)})
-       | from_entries' "$inventory_dir"/*.json 2>/dev/null)
+       | from_entries' "$inventory_dir" "{}")
 
     if [[ -z "$adj_json" || "$adj_json" == "null" || "$adj_json" == "{}" ]]; then
         echo "[]"
@@ -209,8 +242,8 @@ compute_coupling_metrics() {
     fi
 
     local result
-    result=$(jq -s \
-        '[ .[].outgoing_edges // []
+    result=$(_jq_slurp_safe '
+        [ .[].outgoing_edges // []
            | .[]
            | select(.type == "depends_on")
            | {source: (.source // ""), target: (.target_module // "")}
@@ -233,13 +266,9 @@ compute_coupling_metrics() {
             else 0.5 end) as $inst |
 
            {key: $m, value: {ca: $ca, ce: $ce, instability: $inst}}
-         ] | from_entries' "$inventory_dir"/*.json 2>/dev/null)
+         ] | from_entries' "$inventory_dir" "{}")
 
-    if [[ -n "$result" ]]; then
-        echo "$result"
-    else
-        echo "{}"
-    fi
+    echo "$result"
 }
 
 # === Dependency Structure Matrix ===
@@ -265,8 +294,8 @@ generate_dsm() {
     fi
 
     local result
-    result=$(jq -s \
-        '[ .[].outgoing_edges // []
+    result=$(_jq_slurp_safe '
+        [ .[].outgoing_edges // []
            | .[]
            | select(.type == "depends_on")
            | {
@@ -287,13 +316,9 @@ generate_dsm() {
                        value: (map(.symbols) | add)
                      }) | from_entries)
            }
-         ] | from_entries' "$inventory_dir"/*.json 2>/dev/null)
+         ] | from_entries' "$inventory_dir" "{}")
 
-    if [[ -n "$result" ]]; then
-        echo "$result"
-    else
-        echo "{}"
-    fi
+    echo "$result"
 }
 
 # === Architectural Layer Detection ===
@@ -552,43 +577,372 @@ assemble_enhanced_graph() {
     fi
 
     local inventory_dir="$docs_dir/inventory"
+    local modules_dir="$docs_dir/modules"
     local output_file="$docs_dir/knowledge-graph.json"
 
-    # Step 1: Node assembly from inventory/*.json + modules/*/analysis.json
+    # Detect data source: prefer inventory/ (Phase 1 inventory data), fall back to modules/*/data.json (Phase 2 analysis)
     local nodes
-    nodes=$(jq -s '
-        # Collect all nodes from inventory files
-        [ .[].files // [] | .[] |
-            {
-                id:   ((.module // .path // "") | tostring),
-                name: (.name // (.path // "") | split("/") | .[-1]),
-                type: (.type // "unknown"),
-                path: (.path // ""),
-                module: (.module // "")
-            }
-            | select(.id != "")
-        ] | unique_by(.id)
-    ' "$inventory_dir"/*.json 2>/dev/null)
+    if [[ -d "$inventory_dir" ]] && compgen -G "${inventory_dir}/*.json" > /dev/null 2>&1; then
+        # === 多层级节点生成 ===
+        # 从 pre-scan 数据中提取: module → file → function/class/data_entity/api_endpoint
+        nodes=$(_jq_slurp_safe '
+            # 收集所有模块级节点
+            ([ .[].module // "" | select(. != "") ] | unique) as $module_names |
+
+            # 模块级节点 (level 1)
+            [ $module_names[] as $mod |
+                { id: "mod:\($mod)", name: $mod, type: "module", path: "", module: $mod, level: 1, parent: null }
+            ]
+
+            # 文件级 + 子元素节点 (level 2-3)
+            + [ .[] | . as $inv |
+                .module as $mod |
+                (.files // [])[] | . as $file |
+
+                # 文件级节点 (level 2) — wrapped in [] for valid array concatenation
+                [{
+                    id:   "file:\($mod)/\($file.path | split("/") | .[-1])",
+                    name: ($file.path | split("/") | .[-1]),
+                    type: (if ($file.path | test("\\.tsx?$"; "i")) then "component"
+                           elif ($file.path | test("store"; "i")) then "store"
+                           elif ($file.path | test("parser|parsers"; "i")) then "repository"
+                           elif ($file.path | test("service|commands|chat"; "i")) then "service"
+                           elif ($file.path | test("model|types"; "i")) then "data_entity"
+                           else "service" end),
+                    path: $file.path,
+                    module: $mod,
+                    level: 2,
+                    parent: "mod:\($mod)"
+                }]
+
+                # 函数级节点 (level 3)
+                + [ ($file.functions // [])[] | {
+                    id:   "fn:\($mod)/\($file.path | split("/") | .[-1])#\(.name)",
+                    name: .name,
+                    type: "function",
+                    path: $file.path,
+                    module: $mod,
+                    level: 3,
+                    parent: "file:\($mod)/\($file.path | split("/") | .[-1])",
+                    params: (.params // "")
+                } ]
+
+                # 类级节点 (level 3)
+                + [ ($file.classes // [])[] | {
+                    id:   "cls:\($mod)/\($file.path | split("/") | .[-1])#\(.name)",
+                    name: .name,
+                    type: (if .type == "interface" then "api_endpoint"
+                           elif .type == "enum" then "data_entity"
+                           else "service" end),
+                    path: $file.path,
+                    module: $mod,
+                    level: 3,
+                    parent: "file:\($mod)/\($file.path | split("/") | .[-1])",
+                    bases: (.bases // [])
+                } ]
+
+                # 数据模型节点 (level 3)
+                + [ ($file.data_models // [])[] | {
+                    id:   "data:\($mod)/\($file.path | split("/") | .[-1])#\(.name)",
+                    name: .name,
+                    type: "data_entity",
+                    path: $file.path,
+                    module: $mod,
+                    level: 3,
+                    parent: "file:\($mod)/\($file.path | split("/") | .[-1])",
+                    model_type: (.type // "unknown")
+                } ]
+
+                # API 端点节点 (level 3)
+                + [ ($file.api_endpoints // [])[] | {
+                    id:   "api:\($mod)/\($file.path | split("/") | .[-1])#\(.method)-\(.path // "unknown")",
+                    name: "\(.method) \(.path)",
+                    type: "api_endpoint",
+                    path: $file.path,
+                    module: $mod,
+                    level: 3,
+                    parent: "file:\($mod)/\($file.path | split("/") | .[-1])",
+                    http_method: .method,
+                    http_path: .path
+                } ]
+            ]
+
+            # 展平并去重
+            | flatten
+            | map(select(.id != null and .id != ""))
+            | unique_by(.id)
+        ' "$inventory_dir" "[]")
+    elif [[ -d "$modules_dir" ]]; then
+        # Fallback: build nodes from modules/*/data.json (Phase 2 output)
+        local nodes_tmp_dir
+        nodes_tmp_dir=$(mktemp -d)
+        local idx=0
+        for mf in "$modules_dir"/*/data.json; do
+            [[ ! -f "$mf" ]] && continue
+            # Skip invalid JSON files gracefully
+            jq '.' "$mf" > /dev/null 2>&1 || continue
+            local mod_slug
+            mod_slug=$(basename "$(dirname "$mf")")
+            # Extract all node types in one jq pass
+            # Handle both "files" (detailed) and "sourceFiles" (simpler) formats
+            jq --arg slug "$mod_slug" '
+                # Module-level node
+                [{id: $slug, name: (.responsibility // .description // $slug), type: "module", path: "", module: $slug}]
+                # Sub-component nodes from files[] or sourceFiles[]
+                + [((.files // .sourceFiles) // [])[] | {
+                    id:   (.path | split("/") | .[-1]),
+                    name: .role,
+                    type: (if (.path | test("\\.tsx?$"; "i")) then "component"
+                           elif (.path | test("store"; "i")) then "store"
+                           elif (.role | test("解析|parser|parse"; "i")) then "repository"
+                           else "service" end),
+                    path: .path,
+                    module: $slug
+                  }]
+                # Data entity nodes
+                + [(.data_entities // [])[] | {
+                    id:   .name,
+                    name: .name,
+                    type: "data_entity",
+                    path: "",
+                    module: $slug
+                  }]
+                # Exposed API nodes
+                + [(.exposed_apis // [])[] | {
+                    id:   .name,
+                    name: .description,
+                    type: "api_endpoint",
+                    path: "",
+                    module: $slug
+                  }]
+                | map(select(.id != null and .id != ""))
+            ' "$mf" > "$nodes_tmp_dir/$idx.json" 2>/dev/null || true
+            idx=$((idx + 1))
+        done
+        nodes=$(jq -s '[ .[] | .[] ] | unique_by(.id)' "$nodes_tmp_dir"/*.json 2>/dev/null) || true
+        rm -rf "$nodes_tmp_dir"
+    else
+        nodes="[]"
+    fi
 
     if [[ -z "$nodes" || "$nodes" == "null" ]]; then
         nodes="[]"
     fi
-
-    # Step 2: Edge assembly with weights
+    # Step 2: Edge assembly — 原始模块级边 + 从 imports 推断的文件级边 + 父子 contains 边
     local raw_edges
-    raw_edges=$(jq -s '
-        [ .[].outgoing_edges // [] | .[] |
-            {
-                source:          (.source // ""),
-                target:          (.target_module // .target // ""),
-                type:            (.type // "depends_on"),
-                symbols:         (.symbols // []),
-                confidence:      (.confidence // 1.0),
-                frequency:       1
-            }
-            | select(.source != "" and .target != "")
-        ]
-    ' "$inventory_dir"/*.json 2>/dev/null)
+    if [[ -d "$inventory_dir" ]] && compgen -G "${inventory_dir}/*.json" > /dev/null 2>&1; then
+        raw_edges=$(_jq_slurp_safe '
+            # Pre-compute lookup maps (must come before array construction; jq cannot use bindings as + operands)
+            (reduce (.[] | .module as $mod | (.files // [])[] | {file: ($mod + "/" + (.path | split("/") | .[-1])), exports: (.exports // [])}) as $f
+                ({}; .[$f.file] = $f.exports)) as $export_map |
+            (reduce (.[] | .module as $mod | (.files // [])[] | {fn: (.path | split("/") | .[-1]), mod: $mod}) as $entry
+                ({}; .[$entry.fn] = $entry.mod)) as $path_mod |
+
+            # === Part A: 原始 outgoing_edges (模块级) ===
+            [ .[].outgoing_edges // [] | .[] |
+                {
+                    source:          (.source // ""),
+                    target:          (.target_module // .target // ""),
+                    type:            (.type // "depends_on"),
+                    symbols:         (.symbols // []),
+                    confidence:      (.confidence // 1.0),
+                    frequency:       1
+                }
+                | select(.source != "" and .target != "")
+            ]
+
+            # === Part B: 从 imports 推断文件级依赖边 ===
+            + [ .[] | . as $inv |
+                .module as $mod |
+                (.files // [])[] | . as $file |
+                ($file.path | split("/") | .[-1]) as $filename |
+                ($file.imports // [])[] |
+                # 只处理本地 import (is_local == true 或以 ./ 开头)
+                select(.is_local == true or ((.from // "") | test("^\\."))) |
+                (.from // "") as $from_path |
+                # 推断目标模块：从 import 路径中提取
+                ($from_path | sub("^\\./"; "") | sub("^\\.\\./"; "") | split("/") | .[0]) as $target_hint |
+                # 生成文件级边
+                {
+                    source:     "file:\($mod)/\($filename)",
+                    target:     (if $target_hint != "" then "file:\($target_hint)/?" else "" end),
+                    type:       "imports",
+                    symbols:    [(.import // .from // "")] | map(select(. != "" and . != null)),
+                    confidence: 0.7,
+                    frequency:  1
+                }
+                | select(.source != "" and .target != "" and .target != "file:/?")
+            ]
+
+            # === Part C: 父子 contains 边 (module→file, file→function/class) ===
+            + [ .[] |
+                .module as $mod |
+                (.files // [])[] | . as $file |
+                ($file.path | split("/") | .[-1]) as $filename |
+
+                # module → file contains 边
+                [{ source: "mod:\($mod)", target: "file:\($mod)/\($filename)", type: "contains", symbols: [], confidence: 1.0, frequency: 1 }]
+
+                # file → function contains 边
+                + [ ($file.functions // [])[] |
+                    { source: "file:\($mod)/\($filename)", target: "fn:\($mod)/\($filename)#\(.name)", type: "contains", symbols: [], confidence: 1.0, frequency: 1 }
+                ]
+
+                # file → class contains 边
+                + [ ($file.classes // [])[] |
+                    { source: "file:\($mod)/\($filename)", target: "cls:\($mod)/\($filename)#\(.name)", type: "contains", symbols: [], confidence: 1.0, frequency: 1 }
+                ]
+
+                # file → data_model contains 边
+                + [ ($file.data_models // [])[] |
+                    { source: "file:\($mod)/\($filename)", target: "data:\($mod)/\($filename)#\(.name)", type: "contains", symbols: [], confidence: 1.0, frequency: 1 }
+                ]
+            ]
+
+            # === Part D: import → export 交叉引用边（函数级调用关系） ===
+            + [ .[] | .module as $mod |
+                (.files // [])[] | . as $file |
+                ($file.path | split("/") | .[-1]) as $filename |
+                ($file.imports // [])[] |
+                select(.is_local == true or ((.from // "") | test("^\\."))) |
+                (.from // "") as $from_path |
+                # 解析 import source → 目标文件名
+                ($from_path | sub("^\\./"; "") | sub("^\\.\\./"; "") | split("/") | .[-1] | sub("\\.(ts|tsx|js|jsx|vue|svelte)$"; "")) as $target_hint |
+                # 从 import symbols 和 export_map 做交叉引用
+                (.symbols // []) as $imported_syms |
+                ($imported_syms | length) as $sym_count |
+                # 如果有具名 import symbols，用它们生成函数级边
+                (if $sym_count > 0 then
+                    [$imported_syms[] | . as $sym |
+                        {
+                            source: "file:\($mod)/\($filename)",
+                            target: ("file:" + (if $from_path | test("^\\.\\.") then "" else "\($mod)/" end) + $target_hint),
+                            type: "calls",
+                            symbols: [$sym],
+                            confidence: 0.8,
+                            frequency: 1
+                        }
+                        | select(.target != "file:" and .target != .source)
+                    ]
+                # 否则生成文件级 imports 边（旧数据回退）
+                else
+                    [{
+                        source: "file:\($mod)/\($filename)",
+                        target: "file:\($target_hint)",
+                        type: "imports",
+                        symbols: [],
+                        confidence: 0.6,
+                        frequency: 1
+                    }
+                    | select(.target != "file:" and .target != .source)]
+                end)
+            ]
+
+            # 展平、去重、过滤
+            | flatten
+            | map(select(.source != "" and .target != "" and .source != .target))
+            | unique_by({source, target, type})
+        ' "$inventory_dir" "[]")
+    elif [[ -d "$modules_dir" ]]; then
+        # Fallback: build edges from modules/*/data.json dependencies
+        local edges_tmp_dir
+        edges_tmp_dir=$(mktemp -d)
+        local eidx=0
+
+        # Build multi-strategy path→module lookup over VALID data.json files
+        local valid_data_files=()
+        for mf in "$modules_dir"/*/data.json; do
+            [[ ! -f "$mf" ]] && continue
+            jq '.' "$mf" > /dev/null 2>&1 && valid_data_files+=("$mf")
+        done
+
+        local lookup_json="{}"
+        if [[ ${#valid_data_files[@]} -gt 0 ]]; then
+            # Build lookup: file paths + directory prefixes + module names → module slug
+            lookup_json=$(jq -s '
+                # Strategy 1: module name → module slug (direct reference)
+                [ .[] |
+                    (.module // "") as $slug |
+                    select($slug != "") |
+                    {key: $slug, value: $slug}
+                ]
+
+                # Strategy 2: file paths from files/sourceFiles
+                + [ .[] |
+                    (.module // "") as $slug |
+                    select($slug != "") |
+                    [((.files // .sourceFiles) // [])[].path] | map(select(. != "" and . != null)) | unique |
+                    map(. as $p | {key: $p, value: $slug})
+                ]
+
+                # Strategy 3: first directory segment → module slug
+                + [ .[] |
+                    (.module // "") as $slug |
+                    select($slug != "") |
+                    [((.files // .sourceFiles) // [])[].path] | map(select(. != "" and . != null)) | unique |
+                    map(. as $p | ($p | split("/") | .[0]) | select(. != "") | {key: ., value: $slug})
+                ]
+
+                | flatten | map(select(.key != null and .key != "")) |
+                reduce .[] as $entry ({}; .[$entry.key] = $entry.value)
+            ' "${valid_data_files[@]}" 2>/dev/null) || true
+        fi
+
+        [[ -z "$lookup_json" || "$lookup_json" == "null" ]] && lookup_json="{}"
+
+        # Add 2 and 3 segment prefix lookups from file paths
+        lookup_json=$(echo "$lookup_json" | jq '
+            reduce to_entries[] as $e (.;
+                ($e.key | split("/")) as $parts |
+                if ($parts | length) >= 2 then
+                    .[($parts[0:2] | join("/"))] = $e.value
+                else . end |
+                if ($parts | length) >= 3 then
+                    .[($parts[0:3] | join("/"))] = $e.value
+                else . end
+            )
+        ' 2>/dev/null) || true
+
+        [[ -z "$lookup_json" || "$lookup_json" == "null" ]] && lookup_json="{}"
+
+        for mf in "$modules_dir"/*/data.json; do
+            [[ ! -f "$mf" ]] && continue
+            # Skip invalid JSON files (e.g., frontend-core with parse errors)
+            jq '.' "$mf" > /dev/null 2>&1 || continue
+            local mod_slug
+            mod_slug=$(jq -r '.module // ""' "$mf" 2>/dev/null || true)
+            [[ -z "$mod_slug" ]] && mod_slug=$(basename "$(dirname "$mf")")
+            jq --arg slug "$mod_slug" --argjson pmap "$lookup_json" '
+                [(.dependencies.internal // [])[] |
+                    (if type == "string" then sub(" *\\(.*\\)"; "") else . end) as $raw_path |
+                    # Multi-strategy lookup: exact → 3-seg prefix → 2-seg prefix → 1-seg prefix
+                    ($pmap[$raw_path] //
+                     ($raw_path | split("/") | .[0:3] | join("/") as $k | $pmap[$k]) //
+                     ($raw_path | split("/") | .[0:2] | join("/") as $k | $pmap[$k]) //
+                     ($raw_path | split("/") | .[0] as $k | $pmap[$k]) //
+                     "UNKNOWN") as $target_mod |
+                    select($target_mod != $slug and $target_mod != "UNKNOWN") |
+                    {source: $slug, target: $target_mod, type: "depends_on", weight: 1, confidence: 0.8}
+                ] | map(select(.source != "" and .target != ""))
+            ' "$mf" > "$edges_tmp_dir/$eidx.json" 2>/dev/null || true
+            eidx=$((eidx + 1))
+        done
+
+        # Collect numbered edge files, skip empty ones
+        local edge_files_str=""
+        for ef in "$edges_tmp_dir"/[0-9]*.json; do
+            [[ ! -f "$ef" ]] && continue
+            [[ -s "$ef" ]] || continue
+            edge_files_str="$edge_files_str $ef"
+        done
+        if [[ -n "$edge_files_str" ]]; then
+            raw_edges=$(jq -s '[ .[] | if type == "array" then .[] else empty end ]' $edge_files_str 2>/dev/null \
+                | jq '[ .[] | select(.source != .target) ] | unique_by({source,target,type})' 2>/dev/null) || true
+        fi
+        rm -rf "$edges_tmp_dir"
+    else
+        raw_edges="[]"
+    fi
 
     if [[ -z "$raw_edges" || "$raw_edges" == "null" ]]; then
         raw_edges="[]"
@@ -596,15 +950,35 @@ assemble_enhanced_graph() {
 
     # Build a temporary graph to compute edge weights
     local weighted_edges
-    weighted_edges=$(echo "{\"nodes\":$nodes,\"edges\":$raw_edges}" | compute_edge_weights -)
+    weighted_edges=$(echo "{\"nodes\":$nodes,\"edges\":$raw_edges}" | compute_edge_weights -) || weighted_edges="$raw_edges"
 
     # Step 3: Layer detection
     local layers
-    layers=$(detect_architectural_layers "$project_root")
+    layers=$(detect_architectural_layers "$project_root") || layers="{}"
 
-    # Step 4: Graph metrics (Ca, Ce, I via existing compute_coupling_metrics)
+    # Step 4: Graph metrics (Ca, Ce, I)
     local coupling_metrics
-    coupling_metrics=$(compute_coupling_metrics "$inventory_dir")
+    if [[ -d "$inventory_dir" ]] && compgen -G "$inventory_dir/*.json" > /dev/null 2>&1; then
+        coupling_metrics=$(compute_coupling_metrics "$inventory_dir") || coupling_metrics="{}"
+    else
+        # Compute coupling from the edges we already assembled
+        coupling_metrics=$(echo "$weighted_edges" | jq '
+            [.[] | select(.type == "depends_on" or .type == "imports")] as $dep_edges |
+            ($dep_edges | map(.source) + map(.target) | unique) as $modules |
+            [ $modules[] as $m |
+                ($dep_edges | map(select(.source == $m).target) | unique | length) as $ce |
+                ($dep_edges | map(select(.target == $m).source) | unique | length) as $ca |
+                {
+                    key: $m,
+                    value: {
+                        ca: $ca,
+                        ce: $ce,
+                        instability: (if ($ce + $ca) > 0 then (($ce * 100 / ($ce + $ca)) | round) / 100 else 0 end)
+                    }
+                }
+            ] | from_entries
+        ' 2>/dev/null) || coupling_metrics="{}"
+    fi
 
     # Compute aggregate metrics from coupling data
     local aggregate_metrics
@@ -623,7 +997,7 @@ assemble_enhanced_graph() {
             avg_efferent:        (($avg_ce * 100 | round) / 100),
             coupling_per_module: $cm
         }
-    ')
+    ' 2>/dev/null) || aggregate_metrics='{"total_modules":0,"avg_afferent":0,"avg_efferent":0,"coupling_per_module":{}}'
 
     # Step 5: Importance score integration
     local importance_scores="{}"
@@ -637,15 +1011,43 @@ assemble_enhanced_graph() {
 
     # Step 6: Index construction
     local indexes
-    indexes=$(echo "{\"nodes\":$nodes,\"edges\":$weighted_edges}" | build_graph_indexes -)
+    indexes=$(echo "{\"nodes\":$nodes,\"edges\":$weighted_edges}" | build_graph_indexes -) || indexes="{}"
 
     # Detect cycles
     local cycles
-    cycles=$(detect_cycles "$inventory_dir")
+    if [[ -d "$inventory_dir" ]] && compgen -G "$inventory_dir/*.json" > /dev/null 2>&1; then
+        cycles=$(detect_cycles "$inventory_dir") || cycles="[]"
+    else
+        # Compute cycles from the edges we already assembled
+        cycles=$(echo "$weighted_edges" | jq '
+            [.[] | select(.type == "depends_on")] as $edges |
+            ($edges | map(.source) | unique) as $modules |
+            # Build adjacency list
+            ($edges | group_by(.source) | map({key: .[0].source, value: (map(.target) | unique)}) | from_entries) as $adj |
+            # 2-cycles
+            [ $modules[] as $a |
+              ($adj[$a] // [])[] as $b |
+              select($b > $a) |
+              select(($adj[$b] // []) | index($a)) |
+              [$a, $b] | sort
+            ] | unique
+        ' 2>/dev/null) || cycles="[]"
+    fi
 
     # Generate DSM
     local dsm
-    dsm=$(generate_dsm "$inventory_dir" 2>/dev/null || echo "{}")
+    if [[ -d "$inventory_dir" ]] && compgen -G "$inventory_dir/*.json" > /dev/null 2>&1; then
+        dsm=$(generate_dsm "$inventory_dir" 2>/dev/null || echo "{}")
+    else
+        dsm=$(echo "$weighted_edges" | jq '
+            [.[] | select(.type == "depends_on")] |
+            group_by(.source) |
+            map({
+                key: .[0].source,
+                value: (group_by(.target) | map({key: .[0].target, value: length}) | from_entries)
+            }) | from_entries
+        ' 2>/dev/null) || dsm="{}"
+    fi
 
     # Assemble final graph
     local timestamp
@@ -810,9 +1212,9 @@ compute_ck_metrics() {
         return
     fi
 
-    # Collect class nodes and their method/field information from inventory
+    # Collect class nodes and their method/field information from valid inventory files
     local inventory_data
-    inventory_data=$(jq -s '
+    inventory_data=$(_jq_slurp_safe '
         {
             # All class-type nodes
             classes: [ .[].files // [] | .[] |
@@ -830,7 +1232,7 @@ compute_ck_metrics() {
             # All edges for dependency analysis
             edges: [ .[].outgoing_edges // [] | .[] | . ]
         }
-    ' "$inventory_dir"/*.json 2>/dev/null)
+    ' "$inventory_dir" "{}")
 
     if [[ -z "$inventory_data" || "$inventory_data" == "null" ]]; then
         echo "{}"