fensu-cli 0.4.0__tar.gz → 0.5.0__tar.gz

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/Cargo.lock

@@ -392,7 +392,7 @@ checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
 
 [[package]]
 name = "fensu-cli"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "cap-fs-ext",
  "cap-std",

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fensu-cli
-Version: 0.4.0
+Version: 0.5.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/crates/fensu-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fensu-cli"
-version = "0.4.0" # x-release-please-version
+version = "0.5.0" # x-release-please-version
 edition.workspace = true
 license.workspace = true
 publish = false

fensu_cli-0.5.0/crates/fensu-cli/src/command/constants.rs

@@ -0,0 +1,19 @@
+pub(crate) const MEMORY_SCHEMA_PREFIX: &str = "memory.";
+pub(crate) const OPTION_TERMINATOR: &str = "--";
+pub(crate) const MAP_SHORT_HELP: &str = "-h";
+pub(crate) const LONG_OPTION_PREFIX: &str = "--";
+pub(crate) const QUERY_FORMAT_LONG: &str = "long";
+pub(crate) const QUERY_FORMAT_TABLE: &str = "table";
+pub(crate) const QUERY_FORMAT_JSON: &str = "json";
+pub(crate) const QUERY_FORMAT_CSV: &str = "csv";
+pub(crate) const RELATION_KIND_TABLE: &str = "table";
+pub(crate) const RELATION_KIND_VIEW: &str = "view";
+pub(crate) const ARCHIVE_STATE_ARCHIVED: &str = "archived";
+pub(crate) const RESOLUTION_STATUS_RESOLVED: &str = "resolved";
+pub(crate) const DEFAULT_QUERY_LIMIT: usize = 20;
+pub(crate) const MAX_QUERY_LIMIT: usize = 1000;
+pub(crate) const MAP_USAGE: &str = "usage: fensu map [-h] [--direction {downstream,upstream}] [--depth DEPTH]\n                 [--root ROOTS] [--paths {absolute,relative,compact,none}]\n                 [--color {auto,always,never}] [--cache | --no-cache]\n                 [--cache-stats]\n                 symbol";
+pub(crate) const MAP_HELP: &str = "usage: fensu map [-h] [--direction {downstream,upstream}] [--depth DEPTH]\n                 [--root ROOTS] [--paths {absolute,relative,compact,none}]\n                 [--color {auto,always,never}] [--cache | --no-cache]\n                 [--cache-stats]\n                 symbol\n\npositional arguments:\n  symbol                bare, dotted, or path::function project symbol\n\noptions:\n  -h, --help            show this help message and exit\n  --direction {downstream,upstream}\n  --depth DEPTH         maximum call depth\n  --root ROOTS          Python import root to map; repeat for multiple roots\n  --paths {absolute,relative,compact,none}\n                        path display style\n  --color {auto,always,never}\n                        ANSI color behavior\n  --cache               enable map index caching\n  --no-cache            disable map index caching\n  --cache-stats         write map cache operation counts to stderr\n";
+pub(crate) const DEFAULT_GRAPH_DEPTH: usize = 2;
+pub(crate) const DEFAULT_GRAPH_NODES: usize = 50;
+pub(crate) const DEFAULT_GRAPH_EDGES: usize = 100;

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/crates/fensu-cli/src/command/helpers/map_parsing.rs

@@ -1,5 +1,6 @@
 use crate::command::constants::{LONG_OPTION_PREFIX, MAP_SHORT_HELP, MAP_USAGE, OPTION_TERMINATOR};
-use crate::mapping::models::{MapOptions, PathMode};
+use crate::mapping::constants::{MAP_DIRECTION_DOWNSTREAM, MAP_DIRECTION_UPSTREAM};
+use crate::mapping::models::{MapDirection, MapOptions, PathMode};
 
 const LONG_OPTIONS: &[&str] = &[
     "--help",
@@ -15,6 +16,7 @@ const LONG_OPTIONS: &[&str] = &[
 
 pub(crate) fn parse(arguments: &[String]) -> Result<Option<MapOptions>, String> {
     let mut symbol = None;
+    let mut direction = MapDirection::Downstream;
     let mut depth = 3;
     let mut roots = Vec::new();
     let mut path_mode = PathMode::Relative;
@@ -49,7 +51,16 @@ pub(crate) fn parse(arguments: &[String]) -> Result<Option<MapOptions>, String>
             "-h" | "--help" => return Ok(None),
             "--direction" => {
                 let value = option_value(arguments, &mut position, resolved, inline)?;
-                choice(resolved, value, &["downstream"])?;
+                choice(
+                    resolved,
+                    value,
+                    &[MAP_DIRECTION_DOWNSTREAM, MAP_DIRECTION_UPSTREAM],
+                )?;
+                direction = if value == MAP_DIRECTION_UPSTREAM {
+                    MapDirection::Upstream
+                } else {
+                    MapDirection::Downstream
+                };
             }
             "--depth" => {
                 let value = option_value(arguments, &mut position, resolved, inline)?;
@@ -117,6 +128,7 @@ pub(crate) fn parse(arguments: &[String]) -> Result<Option<MapOptions>, String>
         symbol.ok_or_else(|| parser_error("the following arguments are required: symbol"))?;
     Ok(Some(MapOptions {
         symbol,
+        direction,
         depth,
         roots,
         path_mode,

fensu_cli-0.5.0/crates/fensu-cli/src/command/main/help.rs

@@ -0,0 +1,3 @@
+pub(crate) fn help() -> String {
+    "Usage: fensu {init,check,rule,map,skills,memory} ...\n\nCommands:\n  init    Initialize Fensu configuration for a repository.\n  check   Evaluate repository architecture rules.\n  rule    Show details for one rule.\n  map     Render a directional project call map.\n  skills  Generate and install agent guidance.\n  memory  Synchronize, inspect, and query persistent repository memory.\n\nRun `fensu <command> --help` for command-specific options.\n".to_owned()
+}

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/crates/fensu-cli/src/configuration/helpers/loading.rs

@@ -38,5 +38,7 @@ pub(crate) fn load_optional(start: &Path) -> Result<Option<(PathBuf, Config)>, S
 
 pub(crate) fn custom_rules_are_configured(start: &Path) -> Result<bool, String> {
     let (_, config) = load(start)?;
-    Ok(!config.rule_paths.is_empty() || !config.rule_modules.is_empty())
+    Ok(!config.rule_paths.is_empty()
+        || !config.rule_modules.is_empty()
+        || !config.rule_options.is_empty())
 }

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/crates/fensu-cli/src/configuration/helpers/parsing.rs

@@ -30,6 +30,11 @@ pub(crate) fn build(
         ignore: strings(table.get("ignore")),
         rule_paths: strings(table.get("rule_paths")),
         rule_modules: strings(table.get("rule_modules")),
+        rule_options: table
+            .get("rule_options")
+            .and_then(toml::Value::as_table)
+            .cloned()
+            .unwrap_or_default(),
         cache_enabled: cache
             .and_then(|values| values.get("enabled"))
             .and_then(toml::Value::as_bool)

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/crates/fensu-cli/src/configuration/helpers/validation.rs

@@ -19,6 +19,7 @@ pub(crate) fn validate(table: &toml::map::Map<String, toml::Value>) -> Result<()
             "ignore",
             "rule_paths",
             "rule_modules",
+            "rule_options",
             "thresholds",
             "roles",
             "contracts",
@@ -37,6 +38,7 @@ pub(crate) fn validate(table: &toml::map::Map<String, toml::Value>) -> Result<()
     validate_optional_table(table, "cache", &["enabled", "require_cacheable"])?;
     validate_optional_table(table, "evaluation", &["include", "exclude"])?;
     validate_optional_table(table, "skills", &["name"])?;
+    validate_rule_options(table.get("rule_options"))?;
     for name in [
         "tests",
         "tooling",
@@ -63,6 +65,19 @@ pub(crate) fn validate(table: &toml::map::Map<String, toml::Value>) -> Result<()
     Ok(())
 }
 
+fn validate_rule_options(value: Option<&toml::Value>) -> Result<(), String> {
+    let Some(value) = value else {
+        return Ok(());
+    };
+    let rules = value
+        .as_table()
+        .ok_or_else(|| "Config key rule_options must be a table.".to_owned())?;
+    if rules.values().any(|options| !options.is_table()) {
+        return Err("Config key rule_options must contain rule-code tables.".to_owned());
+    }
+    Ok(())
+}
+
 fn validate_nested_roots(roots: Vec<String>) -> Result<(), String> {
     for (index, first) in roots.iter().enumerate() {
         let first = first.split('/').collect::<Vec<_>>();

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/crates/fensu-cli/src/helpers/check_evaluation.rs

@@ -78,6 +78,7 @@ pub(crate) fn evaluate_and_render(
                 observations: HashMap::new(),
                 custom_registrations: Vec::new(),
                 repo_root: root.to_string_lossy().into_owned(),
+                rule_options: native_rule_options(codes)?,
             };
             let plans = plan_core_rule_queries(program(source), codes, &context);
             context.observations = observe(root, &plans, &program_by_path, &program_by_module);
@@ -156,6 +157,26 @@ pub(crate) fn evaluate_and_render(
     Ok((output, i32::from(!blocking_faults.is_empty())))
 }
 
+fn native_rule_options(
+    codes: &[String],
+) -> Result<HashMap<String, HashMap<String, String>>, String> {
+    let mut by_code = HashMap::new();
+    for code in codes {
+        let rule = rule::rule(code).ok_or_else(|| format!("Unknown native rule code: {code}"))?;
+        let mut values = HashMap::new();
+        for option in &rule.options {
+            values.insert(
+                option.name.clone(),
+                serde_json::to_string(&option.current_value).map_err(|error| error.to_string())?,
+            );
+        }
+        if !values.is_empty() {
+            by_code.insert(rule.code.clone(), values);
+        }
+    }
+    Ok(by_code)
+}
+
 pub(crate) fn selected_rules(select: &[String], ignore: &[String]) -> Vec<&'static RuleMetadata> {
     rule::catalogue()
         .iter()

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/crates/fensu-cli/src/helpers/check_policy.rs

@@ -270,7 +270,7 @@ pub(crate) fn check_identity(
     warnings: bool,
 ) -> String {
     let mut digest = Sha256::new();
-    digest.update(b"fensu-native-check-v2\0");
+    digest.update(b"fensu-native-check-v3\0");
     digest.update(env!("CARGO_PKG_VERSION").as_bytes());
     digest.update(&config.raw);
     digest.update([u8::from(warnings)]);

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/crates/fensu-cli/src/helpers/rule.rs

@@ -5,7 +5,7 @@ use std::sync::OnceLock;
 
 use crate::configuration::main::load;
 use crate::constants::{COLOR_ALWAYS, COLOR_AUTO, COLOR_NEVER, OPTION_COLOR};
-use crate::models::{Config, RuleMetadata};
+use crate::models::{Config, RuleMetadata, RuleOptionMetadata, RuleOptionValue};
 use crate::skills::main::catalogue::load_rule_catalogue;
 
 static CATALOGUE: OnceLock<Vec<RuleMetadata>> = OnceLock::new();
@@ -24,7 +24,10 @@ pub(crate) fn rule_output(arguments: &[String]) -> Result<String, String> {
     let project_root = config_path
         .parent()
         .ok_or_else(|| "Configuration has no parent directory.".to_owned())?;
-    let catalogue = if loaded.rule_paths.is_empty() && loaded.rule_modules.is_empty() {
+    let catalogue = if loaded.rule_paths.is_empty()
+        && loaded.rule_modules.is_empty()
+        && loaded.rule_options.is_empty()
+    {
         catalogue().to_vec()
     } else {
         load_rule_catalogue(&loaded, project_root)?
@@ -91,11 +94,81 @@ fn render(metadata: &RuleMetadata, config: &Config, color: bool) -> String {
     };
     let mut output = format!("{header}\n");
     render_metadata(&mut output, metadata, color);
+    render_options(&mut output, metadata);
     render_exceptions(&mut output, metadata, config);
     render_rule_ignores(&mut output, metadata, config);
     output
 }
 
+fn render_options(output: &mut String, metadata: &RuleMetadata) {
+    if metadata.options.is_empty() {
+        return;
+    }
+    let mut options = metadata.options.iter().collect::<Vec<_>>();
+    options.sort_by(|left, right| left.name.cmp(&right.name));
+    output.push_str("\nOptions:\n");
+    for option in options {
+        output.push_str(&format!("  {}\n", option.name));
+        for (label, value) in option_lines(option) {
+            output.push_str(&format!("    {label}: {value}\n"));
+        }
+    }
+}
+
+fn option_lines(option: &RuleOptionMetadata) -> [(&'static str, String); 9] {
+    [
+        ("Type", option_type(&option.kind).to_owned()),
+        ("Required", option.required.to_string()),
+        (
+            "Default",
+            if option.required {
+                "required".to_owned()
+            } else {
+                option_value(option.default.as_ref())
+            },
+        ),
+        ("Current value", option_value(Some(&option.current_value))),
+        (
+            "Description",
+            option
+                .description
+                .clone()
+                .unwrap_or_else(|| "None".to_owned()),
+        ),
+        (
+            "Choices",
+            serde_json::to_string(&option.choices).unwrap_or_else(|_| "null".to_owned()),
+        ),
+        ("Minimum", optional_number(option.minimum)),
+        ("Maximum", optional_number(option.maximum)),
+        (
+            "Minimum items",
+            option
+                .minimum_items
+                .map_or_else(|| "None".to_owned(), |value| value.to_string()),
+        ),
+    ]
+}
+
+fn option_type(kind: &str) -> &str {
+    match kind {
+        "string_list" => "list[string]",
+        "integer_list" => "list[integer]",
+        other => other,
+    }
+}
+
+fn option_value(value: Option<&RuleOptionValue>) -> String {
+    value.map_or_else(
+        || "None".to_owned(),
+        |value| serde_json::to_string(value).unwrap_or_else(|_| "null".to_owned()),
+    )
+}
+
+fn optional_number(value: Option<i64>) -> String {
+    value.map_or_else(|| "None".to_owned(), |value| value.to_string())
+}
+
 fn render_metadata(output: &mut String, metadata: &RuleMetadata, color: bool) {
     let enabled = if metadata.enabled_by_default {
         "yes"

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/crates/fensu-cli/src/mapping/constants.rs

@@ -5,6 +5,8 @@ pub(crate) const EXPRESSION_STRING: &str = "string";
 pub(crate) const EXPRESSION_SUBSCRIPT: &str = "subscript";
 pub(crate) const INIT_MODULE_FILE: &str = "__init__.py";
 pub(crate) const INIT_MODULE: &str = "__init__";
+pub(crate) const MAP_DIRECTION_DOWNSTREAM: &str = "downstream";
+pub(crate) const MAP_DIRECTION_UPSTREAM: &str = "upstream";
 pub(crate) const SELF_RECEIVER: &str = "self";
 pub(crate) const CLASS_RECEIVER: &str = "cls";
 pub(crate) const MAX_COMPACT_PATH_PARTS: usize = 4;

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/crates/fensu-cli/src/mapping/helpers/execution.rs

@@ -3,7 +3,9 @@ use std::io::{self, IsTerminal};
 use std::path::Path;
 
 use crate::mapping::helpers::{cache, index, project, render, tree};
-use crate::mapping::models::{MapCacheStats, MapOptions, ProjectIndex, SourceSnapshot};
+use crate::mapping::models::{
+    MapCacheStats, MapDirection, MapOptions, ProjectIndex, SourceSnapshot,
+};
 use crate::models::CliOutput;
 
 pub(crate) fn execute(options: MapOptions) -> Result<CliOutput, String> {
@@ -19,7 +21,10 @@ pub(crate) fn execute(options: MapOptions) -> Result<CliOutput, String> {
         (index::build(&snapshots)?, None)
     };
     let root = index::select(&project_index.functions, &options.symbol)?;
-    let call_tree = tree::build_tree(root, &project_index, options.depth);
+    let call_tree = match options.direction {
+        MapDirection::Downstream => tree::build_tree(root, &project_index, options.depth),
+        MapDirection::Upstream => tree::build_upstream_tree(root, &project_index, options.depth),
+    };
     let use_color = env::var_os("NO_COLOR").is_none()
         && match options.color.as_str() {
             "always" => true,

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/crates/fensu-cli/src/mapping/helpers/tree_policy.inc

@@ -10,8 +10,16 @@ use crate::mapping::models::{
     MappingExpression, MappingStatement, ProjectIndex, ResolvedCallable, UnresolvedCall,
 };
 
-type MethodCache = BTreeMap<(String, String, bool), Option<FunctionDefinition>>;
+type CallableStateKey = (String, Option<String>);
+type MethodCache = BTreeMap<(String, String, bool), Option<String>>;
 type ReceiverState = BTreeMap<String, Option<String>>;
+type IncomingCallers = BTreeMap<CallableStateKey, BTreeMap<CallableStateKey, CallableState>>;
+
+#[derive(Clone)]
+struct CallableState {
+    definition_key: String,
+    dispatch_class_key: Option<String>,
+}
 
 pub(crate) fn build_tree(
     root: FunctionDefinition,
@@ -32,6 +40,216 @@ pub(crate) fn build_tree(
     )
 }
 
+pub(crate) fn build_upstream_tree(
+    root: FunctionDefinition,
+    index: &ProjectIndex,
+    depth: usize,
+) -> CallMapNode {
+    let dispatch = root
+        .owning_class
+        .as_deref()
+        .map(|class| build_class_key(&root.module_name, class));
+    let callers = incoming_callers(index);
+    build_upstream_node(
+        root,
+        dispatch,
+        index,
+        &callers,
+        depth,
+        &BTreeSet::new(),
+        true,
+    )
+}
+
+fn build_upstream_node(
+    definition: FunctionDefinition,
+    dispatch_class_key: Option<String>,
+    index: &ProjectIndex,
+    callers: &IncomingCallers,
+    remaining_depth: usize,
+    ancestors: &BTreeSet<CallableStateKey>,
+    aggregate_dispatch: bool,
+) -> CallMapNode {
+    let key = (definition.key(), dispatch_class_key.clone());
+    let dispatch_class_name =
+        dispatch_class_name(&definition, dispatch_class_key.as_deref(), index);
+    if ancestors.contains(&key) {
+        return CallMapNode {
+            definition,
+            entries: Vec::new(),
+            dispatch_class_name,
+            cycle: true,
+            truncated: false,
+        };
+    }
+    let incoming = incoming_states(&key, callers, aggregate_dispatch);
+    if remaining_depth == 0 {
+        return CallMapNode {
+            definition,
+            entries: Vec::new(),
+            dispatch_class_name,
+            cycle: false,
+            truncated: !incoming.is_empty(),
+        };
+    }
+    let mut next_ancestors = ancestors.clone();
+    next_ancestors.insert(key);
+    let entries = incoming
+        .into_iter()
+        .filter_map(|caller| {
+            let caller_definition = index.functions.get(&caller.definition_key)?.clone();
+            Some(CallMapEntry::Node(Box::new(build_upstream_node(
+                caller_definition,
+                caller.dispatch_class_key.clone(),
+                index,
+                callers,
+                remaining_depth - 1,
+                &next_ancestors,
+                false,
+            ))))
+        })
+        .collect();
+    CallMapNode {
+        definition,
+        entries,
+        dispatch_class_name,
+        cycle: false,
+        truncated: false,
+    }
+}
+
+fn incoming_states<'a>(
+    target: &CallableStateKey,
+    callers: &'a IncomingCallers,
+    aggregate_dispatch: bool,
+) -> Vec<&'a CallableState> {
+    let mut states = BTreeMap::new();
+    if aggregate_dispatch {
+        for ((definition_key, _), incoming) in callers {
+            if definition_key == &target.0 {
+                states.extend(incoming.iter().map(|(key, state)| (key.clone(), state)));
+            }
+        }
+    } else if let Some(incoming) = callers.get(target) {
+        states.extend(incoming.iter().map(|(key, state)| (key.clone(), state)));
+    }
+    states.into_values().collect()
+}
+
+fn incoming_callers(index: &ProjectIndex) -> IncomingCallers {
+    let mut callers = IncomingCallers::new();
+    let mut method_cache = MethodCache::new();
+    for caller in callable_states(index, &mut method_cache) {
+        let Some(definition) = index.functions.get(&caller.definition_key) else {
+            continue;
+        };
+        for entry in call_entries(
+            definition,
+            caller.dispatch_class_key.as_deref(),
+            index,
+            &mut method_cache,
+        ) {
+            let PendingEntry::Resolved(target) = entry else {
+                continue;
+            };
+            let target_key = (target.definition.key(), target.dispatch_class_key);
+            let caller_key = (
+                caller.definition_key.clone(),
+                caller.dispatch_class_key.clone(),
+            );
+            callers
+                .entry(target_key)
+                .or_default()
+                .insert(caller_key, caller.clone());
+        }
+    }
+    callers
+}
+
+fn callable_states(index: &ProjectIndex, method_cache: &mut MethodCache) -> Vec<CallableState> {
+    let descendants = inheritance_descendants(index);
+    let mut states = BTreeMap::new();
+    for definition in index.functions.values() {
+        let Some(owner) = definition.owning_class.as_deref() else {
+            let state = CallableState {
+                definition_key: definition.key(),
+                dispatch_class_key: None,
+            };
+            states.insert((definition.key(), None), state);
+            continue;
+        };
+        let owner_key = build_class_key(&definition.module_name, owner);
+        for class_key in descendants.get(&owner_key).into_iter().flatten() {
+            let Some(class) = index.classes.get(class_key) else {
+                continue;
+            };
+            let resolved = method_definition(
+                class,
+                &definition.name,
+                index,
+                method_cache,
+                &mut BTreeSet::new(),
+                false,
+            );
+            if resolved.as_ref().map(FunctionDefinition::key) != Some(definition.key()) {
+                continue;
+            }
+            let dispatch_class_key = Some(class.key());
+            states.insert(
+                (definition.key(), dispatch_class_key.clone()),
+                CallableState {
+                    definition_key: definition.key(),
+                    dispatch_class_key,
+                },
+            );
+        }
+    }
+    states.into_values().collect()
+}
+
+fn inheritance_descendants(index: &ProjectIndex) -> BTreeMap<String, BTreeSet<String>> {
+    let mut descendants = index
+        .classes
+        .keys()
+        .map(|key| (key.clone(), BTreeSet::from([key.clone()])))
+        .collect::<BTreeMap<_, _>>();
+    for class_key in index.classes.keys() {
+        let mut ancestors = BTreeSet::new();
+        collect_class_ancestors(
+            class_key,
+            index,
+            &mut BTreeSet::new(),
+            &mut ancestors,
+        );
+        for ancestor in ancestors {
+            descendants
+                .entry(ancestor)
+                .or_default()
+                .insert(class_key.clone());
+        }
+    }
+    descendants
+}
+
+fn collect_class_ancestors(
+    class_key: &str,
+    index: &ProjectIndex,
+    active: &mut BTreeSet<String>,
+    ancestors: &mut BTreeSet<String>,
+) {
+    if !active.insert(class_key.to_owned()) {
+        return;
+    }
+    if let Some(class) = index.classes.get(class_key) {
+        for base_key in &class.base_keys {
+            if index.classes.contains_key(base_key) && ancestors.insert(base_key.clone()) {
+                collect_class_ancestors(base_key, index, active, ancestors);
+            }
+        }
+    }
+    active.remove(class_key);
+}
+
 fn build_node(
     definition: FunctionDefinition,
     dispatch_class_key: Option<String>,
@@ -416,7 +634,10 @@ fn method_definition(
 ) -> Option<FunctionDefinition> {
     let cache_key = (class.key(), method_name.to_owned(), exclude_protocol_bases);
     if let Some(cached) = cache.get(&cache_key) {
-        return cached.clone();
+        return cached
+            .as_deref()
+            .and_then(|key| index.functions.get(key))
+            .cloned();
     }
     let active_key = (class.key(), method_name.to_owned());
     if !active.insert(active_key.clone()) {
@@ -424,11 +645,11 @@ fn method_definition(
     }
     let direct_key = build_function_key(&class.module_name, method_name, Some(&class.name));
     if let Some(direct) = index.functions.get(&direct_key).cloned() {
-        cache.insert(cache_key, Some(direct.clone()));
+        cache.insert(cache_key, Some(direct_key));
         active.remove(&active_key);
         return Some(direct);
     }
-    let mut candidates = BTreeMap::new();
+    let mut candidates = BTreeSet::new();
     for base in &class.bases {
         let owner = class_as_function(class);
         let Some(base_class) = resolve_class_expression(base, &owner, index, false) else {
@@ -445,15 +666,15 @@ fn method_definition(
             active,
             exclude_protocol_bases,
         ) {
-            candidates.insert(inherited.key(), inherited);
+            candidates.insert(inherited.key());
         }
     }
     active.remove(&active_key);
-    let result = (candidates.len() == 1)
-        .then(|| candidates.into_values().next())
+    let result_key = (candidates.len() == 1)
+        .then(|| candidates.into_iter().next())
         .flatten();
-    cache.insert(cache_key, result.clone());
-    result
+    cache.insert(cache_key, result_key.clone());
+    result_key.and_then(|key| index.functions.get(&key).cloned())
 }
 
 fn resolve_class_expression(

{fensu_cli-0.4.0 → fensu_cli-0.5.0}/crates/fensu-cli/src/mapping/models.rs

@@ -184,6 +184,13 @@ pub(crate) enum PathMode {
     None,
 }
 
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) enum MapDirection {
+    #[default]
+    Downstream,
+    Upstream,
+}
+
 #[derive(Clone, Copy, Debug, Default)]
 pub(crate) struct MapCacheStats {
     pub(crate) manifest_hit: bool,
@@ -197,6 +204,7 @@ pub(crate) struct MapCacheStats {
 #[derive(Debug)]
 pub(crate) struct MapOptions {
     pub(crate) symbol: String,
+    pub(crate) direction: MapDirection,
     pub(crate) depth: usize,
     pub(crate) roots: Vec<String>,
     pub(crate) path_mode: PathMode,