src.core.adaptive_dependencies module

Adaptive Dependency Inference System for Marcus.

Enhances Marcus’s template-based dependency system with adaptive learning. Works alongside existing templates to: 1. Suggest additional dependencies templates might miss 2. Learn from successful project completions 3. Enable better agent communication through the kanban board

class src.core.adaptive_dependencies.DependencySignal

Bases: object

A signal indicating potential dependency.

signal_type: str

strength: float

reason: str

__init__(signal_type, strength, reason)

Parameters:

• signal_type (str)

• strength (float)

• reason (str)

Return type:

None

class src.core.adaptive_dependencies.RelationshipPattern

Bases: object

A learned pattern of task relationships.

pattern_id: str

feature_weights: Dict[str, float]

confidence: float = 0.5

examples_count: int = 0

last_seen: datetime

__init__(pattern_id, feature_weights=<factory>, confidence=0.5, examples_count=0, last_seen=<factory>)

Parameters:

• pattern_id (str)

• feature_weights (Dict[str, float])

• confidence (float)

• examples_count (int)

• last_seen (datetime)

Return type:

None

class src.core.adaptive_dependencies.DependencyFeedback

Bases: object

User feedback on a dependency inference.

task_a_id: str

task_b_id: str

is_dependency: bool

confidence: float

user_confirmed: bool | None = None

feedback_reason: str | None = None

timestamp: datetime

__init__(task_a_id, task_b_id, is_dependency, confidence, user_confirmed=None, feedback_reason=None, timestamp=<factory>)

Parameters:

• task_a_id (str)

• task_b_id (str)

• is_dependency (bool)

• confidence (float)

• user_confirmed (bool | None)

• feedback_reason (str | None)

• timestamp (datetime)

Return type:

None

class src.core.adaptive_dependencies.UserRelationship

Bases: object

User-defined relationship between tasks.

task_a_id: str

task_b_id: str

relationship_type: str

user_confidence: float

reason: str | None = None

created_by: str | None = None

timestamp: datetime

__init__(task_a_id, task_b_id, relationship_type, user_confidence, reason=None, created_by=None, timestamp=<factory>)

Parameters:

• task_a_id (str)

• task_b_id (str)

• relationship_type (str)

• user_confidence (float)

• reason (str | None)

• created_by (str | None)

• timestamp (datetime)

Return type:

None

class src.core.adaptive_dependencies.WorkflowPattern

Bases: object

User-defined workflow pattern.

pattern_id: str

name: str

description: str

stages: List[Dict[str, Any]]

relationships: List[Dict[str, str]]

domain: str | None = None

examples: List[str]

created_by_user: bool = True

usage_count: int = 0

__init__(pattern_id, name, description, stages, relationships, domain=None, examples=<factory>, created_by_user=True, usage_count=0)

Parameters:

• pattern_id (str)

• name (str)

• description (str)

• stages (List[Dict[str, Any]])

• relationships (List[Dict[str, str]])

• domain (str | None)

• examples (List[str])

• created_by_user (bool)

• usage_count (int)

Return type:

None

class src.core.adaptive_dependencies.DependencyInterface

Bases: object

Defines what a task produces and what dependents need.

task_id: str

produces: List[str]

requires: List[str]

interface_type: str

documentation: str | None = None

__init__(task_id, produces, requires, interface_type, documentation=None)

Parameters:

• task_id (str)

• produces (List[str])

• requires (List[str])

• interface_type (str)

• documentation (str | None)

Return type:

None

class src.core.adaptive_dependencies.AdaptiveDependencyInferer

Bases: object

Adaptive system for inferring task dependencies.

Based on multiple signals and learned patterns rather than hard-coded rules.

__init__(initial_confidence_threshold=0.6)

Initialize the adaptive dependency inferer.

Parameters:

initial_confidence_threshold (float) – Minimum confidence to suggest dependency.

patterns: Dict[str, RelationshipPattern]

feedback_history: List[DependencyFeedback]

user_relationships: List[UserRelationship]

workflow_patterns: Dict[str, WorkflowPattern]

infer_dependency(task_a, task_b)

Infer if task_a depends on task_b using multiple signals.

Return type:

Tuple[bool, float, List[DependencySignal]]

Returns:

Tuple of (is_dependency, confidence, signals)

Parameters:

• task_a (Task)

• task_b (Task)

record_feedback(task_a_id, task_b_id, is_dependency, original_confidence, user_confirmed, reason=None)

Record user feedback on a dependency inference.

This is used to improve future predictions.

Return type:

None

Parameters:

• task_a_id (str)

• task_b_id (str)

• is_dependency (bool)

• original_confidence (float)

• user_confirmed (bool)

• reason (str | None)

get_confidence_explanation(signals)

Generate human-readable explanation of confidence calculation.

Return type:

str

Parameters:

signals (List[DependencySignal])

suggest_dependencies(task, all_tasks, min_confidence=0.5)

Suggest potential dependencies for a task.

Return type:

List[Tuple[Task, float, str]]

Returns:

List of (dependent_task, confidence, explanation) tuples

Parameters:

• task (Task)

• all_tasks (List[Task])

• min_confidence (float)

learn_from_kanban_board(tasks)

Learn dependency patterns from tasks on the kanban board.

The kanban board is the source of truth for user-defined dependencies. We learn from: 1. Explicit dependencies set by users on the board 2. Task ordering and column placement 3. Task completion patterns

Parameters:

tasks (List[Task]) – All tasks from the kanban board with their dependencies.

Return type:

None

get_inference_mode()

Get current inference mode based on user preferences.

Return type:

str

should_require_confirmation(confidence)

Check if user confirmation is needed for this confidence level.

Return type:

bool

Parameters:

confidence (float)