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

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

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

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

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

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

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

fensu_cli-0.4.1/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.4.1}/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.4.1/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.4.1}/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.4.1}/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.4.1}/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.4.1}/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,

{fensu_cli-0.4.0 → fensu_cli-0.4.1}/crates/fensu-cli/src/skills/helpers/content/rendering.rs

@@ -47,7 +47,7 @@ pub(crate) fn generate(context: &SkillContext) -> Result<String, String> {
         String::new(),
         "- Run `fensu check` after architecture-relevant changes.".to_owned(),
         "- Run `fensu rule <CODE>` to inspect a diagnostic and its remediation.".to_owned(),
-        "- Run `fensu map <SYMBOL>` for a conservative downstream project call tree.".to_owned(),
+        "- Run `fensu map <SYMBOL>` for proven callees, or add `--direction upstream` for proven callers.".to_owned(),
         "- Run `fensu skills` after changing rule selection or custom rules.".to_owned(),
         String::new(),
     ];

{fensu_cli-0.4.0 → fensu_cli-0.4.1}/crates/fensu-cli/tests/mapping/commands.inc

@@ -1,6 +1,9 @@
 use std::fs;
 
-use crate::helpers::{basic_project, method_project, run, run_colored, text, write, write_bytes};
+use crate::helpers::{
+    ambiguous_protocol_project, basic_project, method_project, run, run_colored,
+    sibling_method_project, text, write, write_bytes,
+};
 
 #[test]
 fn given_native_map_when_python_is_missing_then_direct_calls_cycles_and_depth_are_deterministic() {
@@ -15,16 +18,163 @@ fn given_native_map_when_python_is_missing_then_direct_calls_cycles_and_depth_ar
         repository.path(),
         &["pkg.entry.run", "--depth", "3", "--no-cache"],
     );
+    let explicit = run(
+        repository.path(),
+        &[
+            "pkg.entry.run",
+            "--direction",
+            "downstream",
+            "--depth",
+            "3",
+            "--no-cache",
+        ],
+    );
     let stdout = text(&first.stdout);
 
     assert_eq!(first.status.code(), Some(0), "{}", text(&first.stderr));
     assert_eq!(first.stdout, second.stdout);
+    assert_eq!(first.stdout, explicit.stdout);
     assert!(stdout.ends_with('\n'));
     assert!(stdout.contains("step(...)  src/pkg/steps.py:3"));
     assert!(stdout.contains("callback(...)  src/pkg/entry.py:5  (unresolved parameter call)"));
     assert!(stdout.contains("run(...)  src/pkg/entry.py:3  (cycle)"));
 }
 
+#[test]
+fn given_upstream_direction_when_mapping_then_proven_callers_cycles_and_depth_are_deterministic() {
+    let repository = tempfile::tempdir().expect("temporary repository");
+    basic_project(repository.path());
+
+    let output = run(
+        repository.path(),
+        &[
+            "pkg.steps.step",
+            "--direction",
+            "upstream",
+            "--depth",
+            "3",
+            "--no-cache",
+        ],
+    );
+    let stdout = text(&output.stdout);
+
+    assert_eq!(output.status.code(), Some(0), "{}", text(&output.stderr));
+    assert_eq!(
+        stdout,
+        "step(...)  src/pkg/steps.py:3\n└── run(...)  src/pkg/entry.py:3\n    └── finish(...)  src/pkg/finish.py:3\n        └── step(...)  src/pkg/steps.py:3  (cycle)\n"
+    );
+    assert!(!stdout.contains("callback"));
+
+    let limited = run(
+        repository.path(),
+        &[
+            "pkg.steps.step",
+            "--direction",
+            "upstream",
+            "--depth",
+            "1",
+            "--no-cache",
+        ],
+    );
+    assert!(text(&limited.stdout).contains("run(...)  src/pkg/entry.py:3  (depth limit)"));
+}
+
+#[test]
+fn given_inherited_method_dispatch_when_mapping_upstream_then_concrete_callers_are_preserved() {
+    let repository = tempfile::tempdir().expect("temporary repository");
+    method_project(repository.path());
+
+    let output = run(
+        repository.path(),
+        &[
+            "methods.workers.Worker.hook",
+            "--direction",
+            "upstream",
+            "--depth",
+            "3",
+            "--no-cache",
+        ],
+    );
+    let stdout = text(&output.stdout);
+
+    assert_eq!(output.status.code(), Some(0), "{}", text(&output.stderr));
+    assert!(stdout.contains("Worker.hook(...)"));
+    assert!(stdout.contains("Worker.run(...)"));
+    assert!(stdout.contains("Worker.execute(...)"));
+    assert!(stdout.contains("run(...)  src/methods/entry.py:4"));
+    assert!(!stdout.contains("dynamic.execute"));
+}
+
+#[test]
+fn given_sibling_method_dispatch_when_mapping_upstream_then_callers_do_not_cross_subclasses() {
+    let repository = tempfile::tempdir().expect("temporary repository");
+    sibling_method_project(repository.path());
+
+    let output = run(
+        repository.path(),
+        &[
+            "siblings.workers.ChildA.hook",
+            "--direction",
+            "upstream",
+            "--depth",
+            "2",
+            "--no-cache",
+        ],
+    );
+    let stdout = text(&output.stdout);
+
+    assert_eq!(output.status.code(), Some(0), "{}", text(&output.stderr));
+    assert!(stdout.contains("ChildA.run(...)"));
+    assert!(stdout.contains("call_a(...)"));
+    assert!(!stdout.contains("ChildB.run(...)"));
+    assert!(!stdout.contains("call_b(...)"));
+}
+
+#[test]
+fn given_unique_protocol_dispatch_when_mapping_upstream_then_proven_protocol_caller_is_included() {
+    let repository = tempfile::tempdir().expect("temporary repository");
+    method_project(repository.path());
+
+    let output = run(
+        repository.path(),
+        &[
+            "methods.workers.Worker.execute",
+            "--direction",
+            "upstream",
+            "--depth",
+            "1",
+            "--no-cache",
+        ],
+    );
+
+    assert_eq!(output.status.code(), Some(0), "{}", text(&output.stderr));
+    assert!(text(&output.stdout).contains("run_protocol(...)"));
+}
+
+#[test]
+fn given_ambiguous_protocol_dispatch_when_mapping_upstream_then_caller_is_not_invented() {
+    let repository = tempfile::tempdir().expect("temporary repository");
+    ambiguous_protocol_project(repository.path());
+
+    let output = run(
+        repository.path(),
+        &[
+            "protocols.workers.First.execute",
+            "--direction",
+            "upstream",
+            "--depth",
+            "2",
+            "--no-cache",
+        ],
+    );
+
+    assert_eq!(output.status.code(), Some(0), "{}", text(&output.stderr));
+    assert_eq!(
+        text(&output.stdout),
+        "First.execute(...)  src/protocols/workers.py:4\n"
+    );
+}
+
 #[test]
 fn given_selector_forms_when_mapping_then_full_partial_path_and_ambiguity_match_contract() {
     let repository = tempfile::tempdir().expect("temporary repository");
@@ -239,10 +389,11 @@ fn given_map_help_and_invalid_arguments_when_parsing_then_argparse_surface_is_pr
     let help = run(repository.path(), &["--help"]);
     assert_eq!(help.status.code(), Some(0));
     assert!(text(&help.stdout).contains("--cache | --no-cache"));
+    assert!(text(&help.stdout).contains("--direction {downstream,upstream}"));
     for arguments in [
         vec![],
         vec!["run", "--depth", "-1"],
-        vec!["run", "--direction", "upstream"],
+        vec!["run", "--direction", "sideways"],
         vec!["run", "--cache", "--no-cache"],
     ] {
         let output = run(repository.path(), &arguments);

{fensu_cli-0.4.0 → fensu_cli-0.4.1}/crates/fensu-cli/tests/mapping/helpers.rs

@@ -66,7 +66,35 @@ pub(crate) fn method_project(root: &Path) {
     );
     write(
         root.join("src/methods/entry.py"),
-        "from methods.contracts import Runner\nfrom methods.workers import Worker, make\n\ndef run(runner: Runner, dynamic) -> None:\n    worker = Worker()\n    worker.execute()\n    make().execute()\n    runner.execute()\n    dynamic.execute()\n",
+        "from methods.contracts import Runner\nfrom methods.workers import Worker, make\n\ndef run(runner: Runner, dynamic) -> None:\n    worker = Worker()\n    worker.execute()\n    make().execute()\n    runner.execute()\n    dynamic.execute()\n\ndef run_protocol(runner: Runner) -> None:\n    runner.execute()\n",
+    );
+}
+
+pub(crate) fn sibling_method_project(root: &Path) {
+    write(root.join("fensu.toml"), "roots = [\"src/siblings\"]\n");
+    write(
+        root.join("src/siblings/workers.py"),
+        "class Base:\n    def run(self) -> None:\n        self.hook()\n\nclass ChildA(Base):\n    def hook(self) -> None:\n        return None\n\nclass ChildB(Base):\n    def hook(self) -> None:\n        return None\n",
+    );
+    write(
+        root.join("src/siblings/entry.py"),
+        "from siblings.workers import ChildA, ChildB\n\ndef call_a() -> None:\n    ChildA().run()\n\ndef call_b() -> None:\n    ChildB().run()\n",
+    );
+}
+
+pub(crate) fn ambiguous_protocol_project(root: &Path) {
+    write(root.join("fensu.toml"), "roots = [\"src/protocols\"]\n");
+    write(
+        root.join("src/protocols/contracts.py"),
+        "from typing import Protocol\n\nclass Runner(Protocol):\n    def execute(self) -> None:\n        ...\n",
+    );
+    write(
+        root.join("src/protocols/workers.py"),
+        "from protocols.contracts import Runner\n\nclass First(Runner):\n    def execute(self) -> None:\n        return None\n\nclass Second(Runner):\n    def execute(self) -> None:\n        return None\n",
+    );
+    write(
+        root.join("src/protocols/entry.py"),
+        "from protocols.contracts import Runner\n\ndef run(runner: Runner) -> None:\n    runner.execute()\n",
     );
 }
 

{fensu_cli-0.4.0 → fensu_cli-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "fensu-cli"
-version = "0.4.0" # x-release-please-version
+version = "0.4.1" # x-release-please-version
 description = "Native command-line executable for fensu"
 readme = "README.md"
 requires-python = ">=3.12"