sourcecode 1.33.5__py3-none-any.whl → 1.33.7__py3-none-any.whl

sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Deterministic codebase context maps for AI coding agents."""
 
-__version__ = "1.33.5"
+__version__ = "1.33.7"

sourcecode/mcp/orchestrator.py

@@ -0,0 +1,708 @@
+"""Agent Runtime Layer — session state machine, intent detection, workflow orchestrators.
+
+Converts the MCP from a flat tool collection into a guided agent operating system:
+- start_session: single entry point that determines state and tool sequence
+- analyze_task: intent detection and targeted tool sequence recommendation
+- run_pr_review_flow: auto-chains delta + review_pr + blast radius
+- run_bug_investigation_flow: auto-chains fix_bug + impact + IR context
+- run_feature_flow: auto-chains context + endpoints + delta + structural awareness
+"""
+from __future__ import annotations
+
+import re
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+from sourcecode.mcp.runner import run_command
+
+# ---------------------------------------------------------------------------
+# Session state constants
+# ---------------------------------------------------------------------------
+
+SESSION_INIT = "INIT"                          # no RIS, no context
+SESSION_CONTEXT_LOADED = "CONTEXT_LOADED"      # RIS fresh + complete
+SESSION_STALE_CONTEXT = "STALE_CONTEXT"        # RIS exists but HEAD changed
+SESSION_INCOMPLETE_CONTEXT = "INCOMPLETE_CONTEXT"  # RIS missing critical sections
+SESSION_TASK_INTENT_DETECTED = "TASK_INTENT_DETECTED"
+SESSION_READY_FOR_REVIEW = "READY_FOR_REVIEW"  # flow complete
+
+# ---------------------------------------------------------------------------
+# Intent constants
+# ---------------------------------------------------------------------------
+
+INTENT_PR_REVIEW = "pr_review"
+INTENT_BUG_INVESTIGATION = "bug_investigation"
+INTENT_FEATURE_IMPLEMENTATION = "feature_implementation"
+INTENT_REFACTOR = "refactor"
+INTENT_TEST_GENERATION = "test_generation"
+INTENT_ORIENTATION = "orientation"
+
+# ---------------------------------------------------------------------------
+# Workflow sequences: intent → ordered tool names the agent should call
+# ---------------------------------------------------------------------------
+
+WORKFLOW_SEQUENCES: dict[str, list[str]] = {
+    INTENT_PR_REVIEW: ["get_delta", "review_pr_context", "get_impact_context"],
+    INTENT_BUG_INVESTIGATION: ["fix_bug_context", "get_impact_context"],
+    INTENT_FEATURE_IMPLEMENTATION: ["get_compact_context", "get_endpoints", "get_delta"],
+    INTENT_REFACTOR: ["get_agent_context", "modernize_context", "get_ir_summary"],
+    INTENT_TEST_GENERATION: ["generate_tests_context"],
+    INTENT_ORIENTATION: ["get_compact_context"],
+}
+
+WORKFLOW_DESCRIPTIONS: dict[str, str] = {
+    INTENT_PR_REVIEW: "PR review: delta → execution paths → blast radius of changed classes",
+    INTENT_BUG_INVESTIGATION: "Bug investigation: risk-ranked files → impact of suspect class",
+    INTENT_FEATURE_IMPLEMENTATION: "Feature implementation: context → API surface → recent changes",
+    INTENT_REFACTOR: "Refactor: deep context → modernization opportunities → IR coupling",
+    INTENT_TEST_GENERATION: "Test generation: untested files ranked by risk",
+    INTENT_ORIENTATION: "Orientation: compact context overview",
+}
+
+FLOW_RUNNERS: dict[str, str] = {
+    INTENT_PR_REVIEW: "run_pr_review_flow",
+    INTENT_BUG_INVESTIGATION: "run_bug_investigation_flow",
+    INTENT_FEATURE_IMPLEMENTATION: "run_feature_flow",
+    INTENT_REFACTOR: "run_feature_flow",
+    INTENT_TEST_GENERATION: "generate_tests_context",
+    INTENT_ORIENTATION: "get_compact_context",
+}
+
+# ---------------------------------------------------------------------------
+# Intent detection
+# ---------------------------------------------------------------------------
+
+_INTENT_PATTERNS: list[tuple[str, list[str]]] = [
+    (INTENT_PR_REVIEW, [
+        r"\bpr\b", r"pull request", r"review pr", r"\bdiff\b", r"merge request",
+        r"code review", r"changes in branch", r"review.*branch", r"branch.*review",
+    ]),
+    (INTENT_BUG_INVESTIGATION, [
+        r"\bbug\b", r"\berror\b", r"\bexception\b", r"\bcrash\b", r"\bnpe\b",
+        r"\bfix\b", r"\bbroken\b", r"\bfail(s|ing)?\b", r"stack.?trace",
+        r"null.?pointer", r"wrong.?behav", r"\bincident\b", r"not.?work",
+    ]),
+    (INTENT_FEATURE_IMPLEMENTATION, [
+        r"\bfeature\b", r"\bimplement\b", r"\bdevelop\b", r"new endpoint",
+        r"new service", r"add.*(endpoint|service|api|feature)", r"create.*class",
+        r"\bbuild\b.*new",
+    ]),
+    (INTENT_REFACTOR, [
+        r"\brefactor\b", r"\bmodernize\b", r"clean.?up", r"technical.?debt",
+        r"\bdebt\b", r"\brewrite\b", r"\brestructure\b", r"\bclean.*code\b",
+    ]),
+    (INTENT_TEST_GENERATION, [
+        r"\btest(s|ing)?\b", r"\bcoverage\b", r"unit.?test", r"\bspec\b",
+        r"write.?test", r"add.?test",
+    ]),
+]
+
+
+def detect_intent(task_description: str) -> tuple[str, float]:
+    """Return (intent, confidence). Confidence 1.0 = explicit match, 0.5 = fallback."""
+    t = task_description.lower()
+    for intent, patterns in _INTENT_PATTERNS:
+        for pat in patterns:
+            if re.search(pat, t):
+                return intent, 1.0
+    return INTENT_ORIENTATION, 0.5
+
+
+def _extract_symptom(task_description: str) -> str:
+    """Heuristic: extract error class or quoted string from task description."""
+    # Quoted string
+    m = re.search(r'"([^"]+)"', task_description)
+    if m:
+        return m.group(1)
+    # Exception/Error class name
+    m = re.search(r'\b(\w+(?:Exception|Error|Fault))\b', task_description)
+    if m:
+        return m.group(1)
+    # "in ClassName"
+    m = re.search(r'\bin\s+(\w+(?:Service|Controller|Repository|Handler|Manager|Rest))\b', task_description)
+    if m:
+        return m.group(1)
+    return ""
+
+
+# ---------------------------------------------------------------------------
+# Orchestration rules (executable, not docs)
+# ---------------------------------------------------------------------------
+
+def apply_orchestration_rules(
+    freshness: str,
+    is_java: bool,
+    api_surface_complete: bool,
+    repo_class_count: int,
+    intent: str,
+    sequence: list[str],
+) -> tuple[list[str], list[str]]:
+    """Return (adjusted_sequence, rules_applied).
+
+    Rules applied in priority order:
+      R1 stale_cache → prepend get_delta (always sync before deep analysis)
+      R2 java_no_endpoints → prepend get_endpoints (api_surface must exist first)
+      R3 large_repo (>1000) → note RIS path preferred (informational, no seq change)
+      R4 no_symptom_bug_flow → quality warning issued by caller (not a seq change)
+    """
+    seq = list(sequence)
+    rules: list[str] = []
+
+    # R1: stale cache + any flow → prepend delta refresh
+    if freshness == "stale" and "get_delta" not in seq:
+        seq.insert(0, "get_delta")
+        rules.append("R1:stale_cache→prepend_delta")
+
+    # R2: Java + no endpoint index → prepend get_endpoints
+    if is_java and not api_surface_complete and "get_endpoints" not in seq:
+        seq.insert(0, "get_endpoints")
+        rules.append("R2:java_no_endpoints→prepend_get_endpoints")
+
+    # R3: large repo informational flag
+    if repo_class_count > 1000:
+        rules.append("R3:large_repo→RIS_path_preferred")
+
+    return seq, rules
+
+
+# ---------------------------------------------------------------------------
+# Internal execute helper
+# ---------------------------------------------------------------------------
+
+def _exec(args: list[str]) -> dict[str, Any]:
+    """Call run_command, return result dict. On error returns dict with 'error' key."""
+    try:
+        result = run_command(args)
+        if isinstance(result, dict):
+            return result
+        return {"raw": result}
+    except Exception as exc:
+        return {"_exec_error": f"{type(exc).__name__}: {exc}"}
+
+
+# ---------------------------------------------------------------------------
+# RIS helpers
+# ---------------------------------------------------------------------------
+
+def _cold_start(repo_path: str) -> dict[str, Any]:
+    from sourcecode.ris import get_cold_start_context as _gcs
+    return _gcs(Path(repo_path))
+
+
+def _freshness(ris_status: str) -> str:
+    if ris_status == "cold_start_ready":
+        return "fresh"
+    if ris_status in ("cold_start_stale", "cold_start_incomplete"):
+        return "stale"
+    return "missing"
+
+
+def _status_to_session_state(ris_status: str) -> str:
+    return {
+        "cold_start_ready": SESSION_CONTEXT_LOADED,
+        "cold_start_stale": SESSION_STALE_CONTEXT,
+        "cold_start_incomplete": SESSION_INCOMPLETE_CONTEXT,
+        "no_ris": SESSION_INIT,
+    }.get(ris_status, SESSION_INIT)
+
+
+def _is_java_repo(repo_path: str) -> bool:
+    p = Path(repo_path)
+    return (p / "pom.xml").exists() or (p / "build.gradle").exists() or (p / "build.gradle.kts").exists()
+
+
+def _default_sequence_for_state(
+    session_state: str, is_java: bool, api_complete: bool,
+) -> list[str]:
+    if session_state == SESSION_INIT:
+        return ["get_compact_context"]
+    if session_state == SESSION_STALE_CONTEXT:
+        return ["get_delta", "analyze_task"]
+    if session_state == SESSION_INCOMPLETE_CONTEXT and is_java:
+        return ["get_endpoints", "analyze_task"]
+    if session_state == SESSION_CONTEXT_LOADED:
+        return ["analyze_task"]
+    return ["get_compact_context"]
+
+
+def _risk_level(freshness: str, stale: bool, class_count: int) -> str:
+    if freshness == "missing":
+        return "unknown"
+    if stale or freshness == "stale":
+        return "medium"
+    if class_count > 2000:
+        return "high"
+    if class_count > 500:
+        return "medium"
+    return "low"
+
+
+# ---------------------------------------------------------------------------
+# start_session
+# ---------------------------------------------------------------------------
+
+def start_session_impl(repo_path: str, task_description: str = "") -> dict[str, Any]:
+    """Core logic for start_session MCP tool."""
+    t0 = time.monotonic()
+
+    cold = _cold_start(repo_path)
+    ris_status = cold.get("status", "no_ris")
+    freshness = _freshness(ris_status)
+    session_state = _status_to_session_state(ris_status)
+
+    is_java = _is_java_repo(repo_path)
+    api_surface_complete = cold.get("api_surface_complete", True)
+    validation = cold.get("validation", {})
+    spring_detected = validation.get("spring_detected", False)
+    endpoints_count = validation.get("endpoints_found", len(cold.get("endpoints", [])))
+
+    summary = cold.get("summary", {})
+    repo_class_count: int = (
+        summary.get("class_count")
+        or summary.get("total_classes")
+        or 0
+    )
+
+    # Intent detection
+    intent: Optional[str] = None
+    intent_confidence = 0.5
+    flow_runner: Optional[str] = None
+    if task_description.strip():
+        intent, intent_confidence = detect_intent(task_description)
+        flow_runner = FLOW_RUNNERS.get(intent)
+        base_seq = list(WORKFLOW_SEQUENCES.get(intent, ["get_compact_context"]))
+    else:
+        base_seq = _default_sequence_for_state(session_state, is_java, api_surface_complete)
+
+    # Apply orchestration rules
+    seq, rules_applied = apply_orchestration_rules(
+        freshness=freshness,
+        is_java=is_java,
+        api_surface_complete=api_surface_complete,
+        repo_class_count=repo_class_count,
+        intent=intent or INTENT_ORIENTATION,
+        sequence=base_seq,
+    )
+
+    # Recommended next action
+    next_tool = seq[0] if seq else "get_compact_context"
+    if task_description.strip() and intent and flow_runner:
+        next_tool = flow_runner
+        next_reason = WORKFLOW_DESCRIPTIONS.get(intent, "")
+    elif freshness == "missing":
+        next_reason = "No RIS found — build context first (~8s for large repos, instant after)"
+    elif freshness == "stale":
+        next_reason = "RIS outdated — refresh delta before deeper analysis"
+    elif session_state == SESSION_INCOMPLETE_CONTEXT and is_java:
+        next_reason = "Java repo with no endpoint index — populate API surface first"
+    else:
+        next_reason = "RIS fresh — describe your task to get a targeted tool sequence"
+
+    recommended_args: dict[str, Any] = {"repo_path": repo_path}
+    if task_description.strip() and intent == INTENT_BUG_INVESTIGATION:
+        symptom = _extract_symptom(task_description)
+        if symptom:
+            recommended_args["symptom"] = symptom
+
+    ttfca_ms = int((time.monotonic() - t0) * 1000)
+
+    effective_state = SESSION_TASK_INTENT_DETECTED if (task_description.strip() and intent) else session_state
+
+    result: dict[str, Any] = {
+        "session_state": effective_state,
+        "repo_type": "java_spring" if spring_detected else ("java" if is_java else "unknown"),
+        "cache_freshness": freshness,
+        "recommended_next_action": {
+            "tool": next_tool,
+            "reason": next_reason,
+            "args": recommended_args,
+        },
+        "required_tools_sequence": seq,
+        "risk_level": _risk_level(freshness, cold.get("stale", False), repo_class_count),
+        "entrypoint_candidates": cold.get("entrypoints", []),
+        "endpoints_count": endpoints_count,
+        "affected_modules": [],
+        "session_meta": {
+            "ttfca_ms": ttfca_ms,
+            "tools_suggested": len(seq),
+            "agent_decision_reduction": f"{len(seq)}/18 tools exposed",
+            "orchestration_rules_applied": rules_applied,
+        },
+    }
+
+    if intent:
+        result["intent"] = intent
+        result["intent_confidence"] = intent_confidence
+        result["workflow_description"] = WORKFLOW_DESCRIPTIONS.get(intent, "")
+
+    # Include lightweight context when available
+    if session_state in (SESSION_CONTEXT_LOADED, SESSION_STALE_CONTEXT, SESSION_INCOMPLETE_CONTEXT):
+        result["ris_summary"] = {
+            "git_head": cold.get("git_head", ""),
+            "last_updated_at": cold.get("last_updated_at", ""),
+            "has_uncommitted_changes": cold.get("has_uncommitted_changes", False),
+            "hotspots": cold.get("hotspots", [])[:5],
+        }
+
+    if is_java and not api_surface_complete:
+        result["missing_data_hint"] = (
+            "Java repo detected but endpoint index is empty. "
+            "Call get_endpoints to populate API surface."
+        )
+
+    if freshness == "missing":
+        result["bootstrap_hint"] = (
+            "No RIS found. Call get_compact_context to bootstrap "
+            "(~8s for large repos; subsequent calls instant via RIS)."
+        )
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# analyze_task
+# ---------------------------------------------------------------------------
+
+def analyze_task_impl(repo_path: str, task_description: str) -> dict[str, Any]:
+    """Core logic for analyze_task MCP tool."""
+    t0 = time.monotonic()
+
+    intent, confidence = detect_intent(task_description)
+    symptom = _extract_symptom(task_description) if intent == INTENT_BUG_INVESTIGATION else ""
+
+    cold = _cold_start(repo_path)
+    freshness = _freshness(cold.get("status", "no_ris"))
+    is_java = _is_java_repo(repo_path)
+    api_surface_complete = cold.get("api_surface_complete", True)
+
+    base_seq = list(WORKFLOW_SEQUENCES.get(intent, ["get_compact_context"]))
+    flow_runner = FLOW_RUNNERS.get(intent)
+
+    seq, rules = apply_orchestration_rules(
+        freshness=freshness,
+        is_java=is_java,
+        api_surface_complete=api_surface_complete,
+        repo_class_count=0,
+        intent=intent,
+        sequence=base_seq,
+    )
+
+    extracted_params: dict[str, Any] = {}
+    if symptom:
+        extracted_params["symptom"] = symptom
+
+    recommended_args: dict[str, Any] = {"repo_path": repo_path}
+    if symptom and intent == INTENT_BUG_INVESTIGATION:
+        recommended_args["symptom"] = symptom
+
+    ttfca_ms = int((time.monotonic() - t0) * 1000)
+
+    result: dict[str, Any] = {
+        "session_state": SESSION_TASK_INTENT_DETECTED,
+        "intent": intent,
+        "intent_confidence": confidence,
+        "workflow_description": WORKFLOW_DESCRIPTIONS.get(intent, ""),
+        "required_tools_sequence": seq,
+        "recommended_next_action": {
+            "tool": flow_runner or (seq[0] if seq else "get_compact_context"),
+            "reason": WORKFLOW_DESCRIPTIONS.get(intent, ""),
+            "args": recommended_args,
+        },
+        "extracted_params": extracted_params,
+        "session_meta": {
+            "ttfca_ms": ttfca_ms,
+            "orchestration_rules_applied": rules,
+        },
+    }
+
+    if intent == INTENT_BUG_INVESTIGATION and not symptom:
+        result["quality_warning"] = (
+            "No error class or message extracted from task description. "
+            "Pass symptom= to fix_bug_context for focused file ranking."
+        )
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Flow: PR Review
+# ---------------------------------------------------------------------------
+
+def run_pr_review_flow_impl(repo_path: str, since: str = "") -> dict[str, Any]:
+    """PR Review Flow: delta → execution paths → blast radius of top changed classes.
+
+    Auto-detects merge-base with origin/main or origin/master when since is omitted.
+    Runs get_impact_context for up to 3 changed Java classes automatically.
+    Returns consolidated output — agent makes zero sequencing decisions.
+    """
+    t0 = time.monotonic()
+    steps: list[str] = []
+    quality_warnings: list[str] = []
+    output: dict[str, Any] = {}
+
+    # Check freshness
+    cold = _cold_start(repo_path)
+    if _freshness(cold.get("status", "no_ris")) == "stale":
+        quality_warnings.append("RIS_stale—snapshot_may_not_reflect_current_HEAD")
+
+    # Auto-detect since
+    if not since:
+        import subprocess as _sp
+        for base in ("origin/main", "origin/master"):
+            try:
+                r = _sp.run(
+                    ["git", "-C", repo_path, "merge-base", "HEAD", base],
+                    capture_output=True, text=True, timeout=5,
+                )
+                if r.returncode == 0 and r.stdout.strip():
+                    since = r.stdout.strip()
+                    break
+            except Exception:
+                pass
+        if not since:
+            since = "HEAD~1"
+
+    # Step 1: delta
+    delta = _exec(["prepare-context", "delta", repo_path, "--since", since])
+    steps.append(f"get_delta(since={since[:12]})")
+    if "_exec_error" not in delta:
+        output["delta_context"] = delta
+    else:
+        quality_warnings.append(f"delta_failed: {delta['_exec_error']}")
+
+    # Step 2: PR context
+    pr_args = ["prepare-context", "review-pr", repo_path, "--since", since]
+    pr = _exec(pr_args)
+    steps.append("review_pr_context")
+    if "_exec_error" not in pr:
+        output["pr_context"] = pr
+    else:
+        quality_warnings.append(f"review_pr_failed: {pr['_exec_error']}")
+
+    # Step 3: impact for top changed classes (up to 3)
+    changed_classes = _extract_changed_classes_from_delta(delta)
+    impact_results: list[dict[str, Any]] = []
+    for cls in changed_classes[:3]:
+        imp = _exec(["impact", cls, repo_path, "--depth", "3"])
+        steps.append(f"get_impact_context({cls})")
+        if "_exec_error" not in imp:
+            impact_results.append({"target": cls, "result": imp})
+        else:
+            quality_warnings.append(f"impact_failed({cls}): {imp['_exec_error']}")
+    if impact_results:
+        output["impact_analysis"] = impact_results
+
+    ttfca_ms = int((time.monotonic() - t0) * 1000)
+
+    return {
+        "session_state": SESSION_READY_FOR_REVIEW,
+        "flow": "pr_review",
+        "since": since,
+        "steps_executed": steps,
+        "quality_warnings": quality_warnings,
+        "consolidated_output": output,
+        "session_meta": {
+            "ttfca_ms": ttfca_ms,
+            "steps_auto_executed": len(steps),
+            "tools_suggested_to_agent": 0,
+        },
+    }
+
+
+def _extract_changed_classes_from_delta(delta: dict[str, Any]) -> list[str]:
+    if "_exec_error" in delta:
+        return []
+    changed_files: list[Any] = (
+        delta.get("changed_files")
+        or delta.get("files")
+        or delta.get("data", {}).get("changed_files", [])
+        or []
+    )
+    classes: list[str] = []
+    for f in changed_files:
+        if isinstance(f, dict):
+            path = f.get("path") or f.get("file") or ""
+        elif isinstance(f, str):
+            path = f
+        else:
+            continue
+        if isinstance(path, str) and path.endswith(".java"):
+            name = path.split("/")[-1].replace(".java", "")
+            if name and name not in classes:
+                classes.append(name)
+    return classes
+
+
+# ---------------------------------------------------------------------------
+# Flow: Bug Investigation
+# ---------------------------------------------------------------------------
+
+def run_bug_investigation_flow_impl(repo_path: str, symptom: str = "") -> dict[str, Any]:
+    """Bug Investigation Flow: risk-ranked files → impact of top suspect → IR context.
+
+    symptom should be an error message, exception class, or affected class name.
+    Without symptom, ranking is generic (not focused) — quality_warnings will note this.
+    """
+    t0 = time.monotonic()
+    steps: list[str] = []
+    quality_warnings: list[str] = []
+    output: dict[str, Any] = {}
+
+    if not symptom:
+        quality_warnings.append(
+            "no_symptom_provided: file ranking is generic, not focused. "
+            "Pass symptom= with error message or class name for targeted analysis."
+        )
+
+    # Step 1: fix-bug context
+    fix_args = ["prepare-context", "fix-bug", repo_path]
+    if symptom:
+        fix_args.extend(["--symptom", symptom])
+    fix = _exec(fix_args)
+    steps.append(f"fix_bug_context(symptom={symptom!r})" if symptom else "fix_bug_context(no_symptom)")
+    if "_exec_error" not in fix:
+        output["risk_ranked_files"] = fix
+    else:
+        quality_warnings.append(f"fix_bug_failed: {fix['_exec_error']}")
+
+    # Step 2: impact for top suspect class
+    suspect = _extract_class_from_symptom(symptom) or _top_class_from_fix(fix)
+    if suspect:
+        imp = _exec(["impact", suspect, repo_path, "--depth", "4"])
+        steps.append(f"get_impact_context({suspect})")
+        if "_exec_error" not in imp:
+            output["impact_analysis"] = {"target": suspect, "result": imp}
+        else:
+            quality_warnings.append(f"impact_failed({suspect}): {imp['_exec_error']}")
+
+    # Step 3: IR summary for Java (dependency context)
+    if _is_java_repo(repo_path):
+        ir = _exec(["repo-ir", repo_path, "--summary-only"])
+        steps.append("get_ir_summary")
+        if "_exec_error" not in ir:
+            output["ir_summary"] = ir
+        else:
+            quality_warnings.append(f"ir_summary_failed: {ir['_exec_error']}")
+
+    ttfca_ms = int((time.monotonic() - t0) * 1000)
+
+    return {
+        "session_state": SESSION_READY_FOR_REVIEW,
+        "flow": "bug_investigation",
+        "symptom": symptom,
+        "suspect_class": suspect,
+        "steps_executed": steps,
+        "quality_warnings": quality_warnings,
+        "consolidated_output": output,
+        "session_meta": {
+            "ttfca_ms": ttfca_ms,
+            "steps_auto_executed": len(steps),
+            "tools_suggested_to_agent": 0,
+        },
+    }
+
+
+def _extract_class_from_symptom(symptom: str) -> str:
+    if not symptom:
+        return ""
+    m = re.search(
+        r'\b([A-Z][a-zA-Z0-9]+(?:Service|Controller|Repository|Handler|Manager|Util|Helper|DAO|Rest|Api)?)\b',
+        symptom,
+    )
+    return m.group(1) if m else ""
+
+
+def _top_class_from_fix(fix: dict[str, Any]) -> str:
+    if "_exec_error" in fix:
+        return ""
+    files: list[Any] = (
+        fix.get("files")
+        or fix.get("ranked_files")
+        or fix.get("top_files")
+        or fix.get("data", {}).get("files", [])
+        or []
+    )
+    for f in files:
+        if isinstance(f, dict):
+            path = str(f.get("path") or f.get("file") or "")
+        elif isinstance(f, str):
+            path = f
+        else:
+            continue
+        if path.endswith(".java"):
+            return path.split("/")[-1].replace(".java", "")
+    return ""
+
+
+# ---------------------------------------------------------------------------
+# Flow: Feature Implementation
+# ---------------------------------------------------------------------------
+
+def run_feature_flow_impl(repo_path: str, feature_description: str = "") -> dict[str, Any]:
+    """Feature Implementation Flow: context → API surface → recent changes → structural awareness.
+
+    Provides everything an agent needs to implement a new feature:
+    structural context, existing API surface, what changed recently, and coupling hotspots.
+    """
+    t0 = time.monotonic()
+    steps: list[str] = []
+    quality_warnings: list[str] = []
+    output: dict[str, Any] = {}
+
+    is_java = _is_java_repo(repo_path)
+
+    # Step 1: compact context (use RIS fast path if available)
+    cold = _cold_start(repo_path)
+    freshness = _freshness(cold.get("status", "no_ris"))
+    if freshness == "fresh" and cold.get("summary"):
+        output["context_summary"] = cold["summary"]
+        steps.append("get_context(RIS_fast_path)")
+    else:
+        ctx = _exec([repo_path, "--compact"])
+        steps.append("get_compact_context")
+        if "_exec_error" not in ctx:
+            output["context_summary"] = ctx
+        else:
+            quality_warnings.append(f"compact_context_failed: {ctx['_exec_error']}")
+
+    # Step 2: API surface (Java only)
+    if is_java:
+        ep = _exec(["endpoints", repo_path])
+        steps.append("get_endpoints")
+        if "_exec_error" not in ep:
+            output["api_surface"] = ep
+        else:
+            quality_warnings.append(f"endpoints_failed: {ep['_exec_error']}")
+
+    # Step 3: recent delta (last 3 commits for context on active areas)
+    delta = _exec(["prepare-context", "delta", repo_path, "--since", "HEAD~3"])
+    steps.append("get_delta(HEAD~3)")
+    if "_exec_error" not in delta:
+        output["recent_changes"] = delta
+    else:
+        quality_warnings.append(f"delta_failed: {delta['_exec_error']}")
+
+    # Step 4: structural context (coupling, hotspots, refactor opportunities)
+    refactor = _exec(["prepare-context", "refactor", repo_path])
+    steps.append("refactor_context")
+    if "_exec_error" not in refactor:
+        output["structural_context"] = refactor
+    else:
+        quality_warnings.append(f"refactor_context_failed: {refactor['_exec_error']}")
+
+    ttfca_ms = int((time.monotonic() - t0) * 1000)
+
+    return {
+        "session_state": SESSION_READY_FOR_REVIEW,
+        "flow": "feature_implementation",
+        "feature_description": feature_description,
+        "steps_executed": steps,
+        "quality_warnings": quality_warnings,
+        "consolidated_output": output,
+        "session_meta": {
+            "ttfca_ms": ttfca_ms,
+            "steps_auto_executed": len(steps),
+            "tools_suggested_to_agent": 0,
+        },
+    }

sourcecode/mcp/server.py

@@ -109,12 +109,242 @@ def _check_repo_path(path: str) -> "CallToolResult | None":
     return None
 
 
+@mcp.tool()
+def start_session(repo_path: str = ".", task_description: str = "") -> dict:
+    """PRIMARY ENTRY POINT — call this first on every new MCP session.
+
+    Single entry point that replaces manual tool selection. Determines session state,
+    checks RIS freshness, detects repo type, and returns a ready-to-execute tool
+    sequence. Agent never has to guess which tool to call next.
+
+    With task_description: detects intent (pr_review, bug_investigation,
+    feature_implementation, refactor, test_generation) and returns the exact
+    flow runner to call with pre-filled args. Zero sequencing decisions for agent.
+
+    Without task_description: returns session state + recommended_next_action
+    based on RIS freshness and repo type (java_spring, java, etc.).
+
+    Returns:
+      session_state        — INIT | CONTEXT_LOADED | STALE_CONTEXT |
+                             INCOMPLETE_CONTEXT | TASK_INTENT_DETECTED
+      repo_type            — java_spring | java | nodejs | python | unknown
+      cache_freshness      — fresh | stale | missing
+      recommended_next_action — {tool, reason, args} — call this next, no guessing
+      required_tools_sequence — ordered list of tools the agent should call
+      risk_level           — low | medium | high | unknown
+      entrypoint_candidates — top entry points from RIS
+      endpoints_count      — Java endpoint count from RIS api_surface
+      session_meta         — {ttfca_ms, tools_suggested, agent_decision_reduction,
+                              orchestration_rules_applied}
+      intent               — detected intent when task_description provided
+      intent_confidence    — detection confidence (1.0 = explicit match)
+      ris_summary          — lightweight RIS snapshot when context loaded
+      missing_data_hint    — what to build next when critical data absent
+      bootstrap_hint       — how to build RIS when missing
+
+    Orchestration rules applied automatically:
+      R1: stale cache → prepend get_delta to any tool sequence
+      R2: Java + no endpoint index → prepend get_endpoints
+      R3: repo > 1000 classes → RIS path flagged as preferred
+
+    KPIs tracked in session_meta:
+      ttfca_ms                — time_to_first_correct_action in milliseconds
+      tools_suggested         — agent decision reduction (1-3 vs 18 free tools)
+      orchestration_rules_applied — which rules fired
+
+    repo_path: absolute path to the repository (default: current working directory).
+    task_description: optional natural language task description for intent detection.
+      Examples: "review the PR on the auth module",
+                "NullPointerException in UserService.findById",
+                "implement a new endpoint for password reset"
+    """
+    _raw = repo_path
+    try:
+        if not isinstance(repo_path, str):
+            return _err("repo_path must be a string", "INVALID_ARGUMENT")
+        repo_path = _normalize_repo_path(repo_path)
+        _path_err = _check_repo_path(repo_path)
+        if _path_err is not None:
+            return _path_err
+        from sourcecode.mcp.orchestrator import start_session_impl
+        return _ok(start_session_impl(repo_path, task_description or ""))
+    except Exception as exc:
+        return _err(
+            f"Internal error: {type(exc).__name__}: {exc} — repo_path: {_raw}",
+            "INTERNAL_ERROR",
+        )
+
+
+@mcp.tool()
+def analyze_task(repo_path: str = ".", task_description: str = "") -> dict:
+    """Detect task intent and return targeted tool sequence. No tool guessing needed.
+
+    Given a natural language description of what you need to do, returns:
+      - Detected intent (pr_review, bug_investigation, feature_implementation, etc.)
+      - Ordered tool sequence to execute
+      - Recommended flow runner to call with pre-filled args
+      - Extracted parameters (symptom for bugs, etc.)
+      - Orchestration rules that were applied
+
+    Prefer start_session(task_description=...) for combined bootstrap + intent detection.
+    Use analyze_task standalone when session is already loaded and you have a new task.
+
+    Quality warnings included when:
+      - Bug intent detected but no error class/message found in description
+        (ranking will be generic, not focused)
+
+    repo_path: absolute path to the repository (default: current working directory).
+    task_description: natural language task description (required for meaningful output).
+      Examples: "fix the NPE in PaymentService",
+                "review PR changes in the billing module",
+                "add new REST endpoint for user preferences"
+    """
+    _raw = repo_path
+    try:
+        if not isinstance(repo_path, str):
+            return _err("repo_path must be a string", "INVALID_ARGUMENT")
+        if not isinstance(task_description, str) or not task_description.strip():
+            return _err("task_description must be a non-empty string", "INVALID_ARGUMENT")
+        repo_path = _normalize_repo_path(repo_path)
+        _path_err = _check_repo_path(repo_path)
+        if _path_err is not None:
+            return _path_err
+        from sourcecode.mcp.orchestrator import analyze_task_impl
+        return _ok(analyze_task_impl(repo_path, task_description))
+    except Exception as exc:
+        return _err(
+            f"Internal error: {type(exc).__name__}: {exc} — repo_path: {_raw}",
+            "INTERNAL_ERROR",
+        )
+
+
+@mcp.tool()
+def run_pr_review_flow(repo_path: str = ".", since: str = "") -> dict:
+    """PR Review Flow — auto-chains 3 tools: delta → execution paths → blast radius.
+
+    Auto-executes the complete PR review pipeline in one call:
+      1. get_delta(since) — changed files and context since merge base
+      2. review_pr_context — execution paths and hotspots for changed files
+      3. get_impact_context — blast radius for up to 3 changed Java classes
+
+    Auto-detects merge base with origin/main or origin/master when since is omitted.
+    Falls back to HEAD~1 when no remote branch found.
+
+    Returns consolidated_output with all three results merged.
+    session_meta.ttfca_ms shows total wall-clock time.
+    quality_warnings list any partial failures (steps still return partial output).
+
+    Use this instead of calling get_delta + review_pr_context + get_impact_context
+    separately — agent makes zero sequencing decisions.
+
+    JAVA ONLY for blast-radius step. Delta and execution paths work on all repos.
+
+    repo_path: absolute path to the repository (default: current working directory).
+    since: git ref to diff against. Auto-detected from origin/main if omitted.
+    """
+    _raw = repo_path
+    try:
+        if not isinstance(repo_path, str):
+            return _err("repo_path must be a string", "INVALID_ARGUMENT")
+        repo_path = _normalize_repo_path(repo_path)
+        _path_err = _check_repo_path(repo_path)
+        if _path_err is not None:
+            return _path_err
+        from sourcecode.mcp.orchestrator import run_pr_review_flow_impl
+        return _ok(run_pr_review_flow_impl(repo_path, since or ""))
+    except Exception as exc:
+        return _err(
+            f"Internal error: {type(exc).__name__}: {exc} — repo_path: {_raw}",
+            "INTERNAL_ERROR",
+        )
+
+
+@mcp.tool()
+def run_bug_investigation_flow(repo_path: str = ".", symptom: str = "") -> dict:
+    """Bug Investigation Flow — auto-chains 3 tools: risk-rank → impact → IR context.
+
+    Auto-executes the complete bug investigation pipeline in one call:
+      1. fix_bug_context(symptom) — files ranked by risk, focused on symptom
+      2. get_impact_context — blast radius of the top suspect class
+      3. get_ir_summary — Java IR dependency context (Java repos only)
+
+    symptom should be: error message, exception class name, or affected class.
+    Without symptom: ranking is generic (not focused). quality_warnings will note this.
+
+    Returns consolidated_output with all results plus suspect_class (auto-extracted
+    from symptom or top ranked file). session_meta.ttfca_ms shows total wall time.
+
+    Use this instead of calling fix_bug_context + get_impact_context + get_ir_summary
+    separately — agent makes zero sequencing decisions.
+
+    repo_path: absolute path to the repository (default: current working directory).
+    symptom: error message, exception class, or class name.
+      Examples: "NullPointerException in UserService.findById",
+                "PaymentController", "AuthenticationException"
+    """
+    _raw = repo_path
+    try:
+        if not isinstance(repo_path, str):
+            return _err("repo_path must be a string", "INVALID_ARGUMENT")
+        repo_path = _normalize_repo_path(repo_path)
+        _path_err = _check_repo_path(repo_path)
+        if _path_err is not None:
+            return _path_err
+        from sourcecode.mcp.orchestrator import run_bug_investigation_flow_impl
+        return _ok(run_bug_investigation_flow_impl(repo_path, symptom or ""))
+    except Exception as exc:
+        return _err(
+            f"Internal error: {type(exc).__name__}: {exc} — repo_path: {_raw}",
+            "INTERNAL_ERROR",
+        )
+
+
+@mcp.tool()
+def run_feature_flow(repo_path: str = ".", feature_description: str = "") -> dict:
+    """Feature Implementation Flow — auto-chains 4 tools: context → API → delta → structure.
+
+    Auto-executes the complete feature planning pipeline in one call:
+      1. get_compact_context (or RIS fast-path if fresh) — project orientation
+      2. get_endpoints — existing API surface (Java repos only)
+      3. get_delta(HEAD~3) — what changed recently (active development areas)
+      4. refactor_context — structural coupling and hotspot awareness
+
+    Returns consolidated_output with all four results. Use feature_description to
+    help the agent understand what you are building (stored in output for traceability).
+
+    Use this instead of calling the four tools separately — agent makes zero
+    sequencing decisions. Typical wall time: 2-10s depending on repo size and cache.
+
+    repo_path: absolute path to the repository (default: current working directory).
+    feature_description: optional description of the feature to implement.
+      Example: "add password reset flow with email verification"
+    """
+    _raw = repo_path
+    try:
+        if not isinstance(repo_path, str):
+            return _err("repo_path must be a string", "INVALID_ARGUMENT")
+        repo_path = _normalize_repo_path(repo_path)
+        _path_err = _check_repo_path(repo_path)
+        if _path_err is not None:
+            return _path_err
+        from sourcecode.mcp.orchestrator import run_feature_flow_impl
+        return _ok(run_feature_flow_impl(repo_path, feature_description or ""))
+    except Exception as exc:
+        return _err(
+            f"Internal error: {type(exc).__name__}: {exc} — repo_path: {_raw}",
+            "INTERNAL_ERROR",
+        )
+
+
 @mcp.tool()
 def get_cold_start_context(repo_path: str = ".") -> dict:
     """Instant session bootstrap from persisted Repository Intelligence Snapshot (RIS).
 
-    CALL THIS FIRST at the start of every MCP session.  Returns cached structural
-    context built from prior analysis runs — zero re-analysis cost.
+    PREFER start_session over this tool — it provides orchestration guidance on top
+    of the same RIS data. Use get_cold_start_context when you only need the raw
+    RIS bootstrap object without tool sequencing recommendations.
+
+    Returns cached structural context built from prior analysis runs — zero re-analysis cost.
 
     status values:
       "cold_start_ready"  — RIS exists and matches the current git HEAD.
@@ -368,6 +598,11 @@ def get_ir_summary(repo_path: str = ".") -> dict:
     on large repos), use the CLI: sourcecode repo-ir <path> --output ir.json
     Use get_compact_context or get_agent_context for non-Java repos.
 
+    IR access paths (for full IR via CLI):
+      nodes  →  result["graph"]["nodes"]   (list of {fqn, type, ...})
+      edges  →  result["graph"]["edges"]   (list of {source, target, type})
+    Summary mode omits nodes/edges entirely (graph._omitted explains why).
+
     repo_path: absolute path to the Java repository (default: current working directory).
     """
     _raw = repo_path
@@ -378,7 +613,14 @@ def get_ir_summary(repo_path: str = ".") -> dict:
         _path_err = _check_repo_path(repo_path)
         if _path_err is not None:
             return _path_err
-        return _execute(["repo-ir", repo_path, "--summary-only"])
+        result = _execute(["repo-ir", repo_path, "--summary-only"])
+        if isinstance(result, dict) and "error" not in result:
+            result["_ir_access"] = {
+                "nodes_path": "result['graph']['nodes']",
+                "edges_path": "result['graph']['edges']",
+                "note": "nodes/edges omitted in summary mode — use CLI repo-ir --output ir.json for full graph",
+            }
+        return result
     except Exception as exc:
         return _err(
             f"Internal error: {type(exc).__name__}: {exc} — repo_path recibido: {_raw}",

sourcecode/prepare_context.py

@@ -1237,6 +1237,10 @@ class TaskContextBuilder:
                         limitations=[], confidence="low",
                         error_code="no_diff_source",
                         error_message=_no_diff_msg,
+                        error_hints=[
+                            "Add --since <ref> to specify a base commit.",
+                            "Examples: --since origin/main  |  --since HEAD~3  |  --since main",
+                        ],
                         gaps=[_no_diff_msg],
                         ci_decision="no_diff_source",
                         scope_source=_pr_scope_source,

sourcecode/repository_ir.py

@@ -2993,7 +2993,7 @@ def extract_java_endpoints(root: Path) -> "dict[str, Any]":
         # Use security_annotations already extracted by _build_route_surface
         # via the canonical _route_security_from_sym extractor.
         security_info = route.get("security_annotations")
-        entry["security"] = security_info  # always present; None = no security signal
+        entry["security"] = security_info if security_info is not None else {"policy": "none_detected"}
         if security_info:
             # Backward compat: keep required_permission for custom annotation
             if isinstance(security_info, dict) and security_info.get("policy") == "custom_permission":
@@ -3708,9 +3708,15 @@ def _resolve_target(
     """
     # Normalize: strip .java suffix if given a path
     t = target.strip()
+    _is_path_like = "/" in t or "\\" in t or t.endswith(".java")
     if t.endswith(".java"):
         t = t[:-5]
-    # Convert file path separators to class name
+    # When given a file path (e.g. src/main/java/org/foo/Bar), extract the class
+    # name (basename) so suffix matching resolves it to the correct FQN.
+    # Path-to-dot conversion (src.main.java.org.foo.Bar) never matches an IR FQN.
+    if _is_path_like and ("/" in t or "\\" in t):
+        import os.path as _osp
+        t = _osp.basename(t.replace("\\", "/"))
     t_class = t.replace("/", ".").replace("\\", ".")
 
     # 1. Exact match

{sourcecode-1.33.5.dist-info → sourcecode-1.33.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.33.5
+Version: 1.33.7
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm
@@ -39,7 +39,7 @@ Description-Content-Type: text/markdown
 
 **Persistent structural context and ultra-fast repeated analysis for AI coding agents.**
 
-![Version](https://img.shields.io/badge/version-1.33.4-blue)
+![Version](https://img.shields.io/badge/version-1.33.7-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---

{sourcecode-1.33.5.dist-info → sourcecode-1.33.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sourcecode/__init__.py,sha256=1rtjkdHP6M265Dvjzw_Pe1-jjy13_C_oBKGBnxQCbUk,103
+sourcecode/__init__.py,sha256=1FxY3ofkdwrV8K_gc9aQqAWEepqXfZm-yAQCuPW5nBo,103
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/architecture_analyzer.py,sha256=qh749a7ykPtGmQI1MR9y6j8TtL_jBdVYFx9YRsLqOMw,44121
 sourcecode/architecture_summary.py,sha256=z34_6v7cSwy98cof2UVciGho7SCrZ93tiqMmq5WNzRQ,20405
@@ -29,13 +29,13 @@ sourcecode/metrics_analyzer.py,sha256=m0ENgtqKeBL17kUIK3fmGkgo7UfXBNHxCMj0H_Y5K7
 sourcecode/output_budget.py,sha256=43307mJEyUPU3MI-QEQoVxrcAvNyUzdzF_SAPgisBQE,6603
 sourcecode/path_filters.py,sha256=ROFRQ8eSLBEMiixK9f45-RO7um4VEEcjoD5AA4I427I,3739
 sourcecode/pr_comment_renderer.py,sha256=smHslxiG14lrytCkq5nFrFu-qTHgA-t-LFYfdrfjz2o,14423
-sourcecode/prepare_context.py,sha256=aL4WS62wozw9iG_v3UrU00Qc7lGgckUB5RY5ApPblo8,205618
+sourcecode/prepare_context.py,sha256=5TgEEhH7wkwup9ibdGhDNvQRwBpL3BrpqFHaJxRG6NQ,205855
 sourcecode/progress.py,sha256=qn30sWaHOkjTgXsSBmiPkz7Rsbwc5oSlIe6JNEMYp_k,3149
 sourcecode/ranking_engine.py,sha256=ZAucq_YX2KkWUuAZf4P0lhtQ_38vEFnUhuGtSZd1S0E,12970
 sourcecode/redactor.py,sha256=SB4hwIvg8h-hvcqKcDWaZvA-aSyn-at-BIRwa0tUv5E,3227
 sourcecode/relevance_scorer.py,sha256=MYF4FFkveAQps9SmTeTlh6ODiBz2F--_hWNeHMLtUHQ,8405
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
-sourcecode/repository_ir.py,sha256=WtUPRVrvJju6Lrvm_7iTDk57qJFCAh-LJalLtX8jzIk,155595
+sourcecode/repository_ir.py,sha256=n3QYeCC4VjgVupjTxK3cJ6T6d0xcn-GOTR18tMhT0qg,155993
 sourcecode/ris.py,sha256=vkIe_v-jjceeb0Adhn-Kw5eFXE_nIkGHflOnQYPycTk,17411
 sourcecode/runtime_classifier.py,sha256=uTAD6BDCiBLUZEDRfqk718kM4RTT_vAbfkcOI2_Xx58,18432
 sourcecode/scanner.py,sha256=WdOQ78mMzjR1NjmKTlbxdgwinnCTfAhxCVLBEFQiFHU,8899
@@ -67,8 +67,9 @@ sourcecode/detectors/systems.py,sha256=nYaKbGDFu0EOXFcd_1doWFT3tTUdkbxc2DjHUF5Tc
 sourcecode/detectors/terraform.py,sha256=cxORPR_zVLOJpHlh4e9JnFpkQsn_UnqMMom5yG65hZ4,1693
 sourcecode/detectors/tooling.py,sha256=8CKbtxwQoABP-WyBRNmdAmHDOvAH57AR1cF4UKuWEdQ,2074
 sourcecode/mcp/__init__.py,sha256=XU4HfRGbdid8wdUA0x_4f7uKZD1z3mv_XUY_WU_T9Mw,179
+sourcecode/mcp/orchestrator.py,sha256=BMi1D6liJHI3DXiaC8yeBLLP0wXajpCP3-vnRGqrvnw,26850
 sourcecode/mcp/runner.py,sha256=YSw2DXEICau6mCBr3Gfia3D_tKxMbRvIIXEh4cHC1SY,1390
-sourcecode/mcp/server.py,sha256=dAmoUbnu4kPPWeRH2tcOn9WJPG8Zfzvlu0nRmyiok70,27925
+sourcecode/mcp/server.py,sha256=m_C0LJVQzxlSe0e_gjN5wqzXH-j7TBSpNNQnWM8Ra4g,39648
 sourcecode/mcp/onboarding/__init__.py,sha256=sj2PWqEBmMc4zBNkomg89WtL0M6S7A9yb7_wAuSWNP4,66
 sourcecode/mcp/onboarding/applier.py,sha256=B9CneieWTpaDSDIyW3S5nrlRlBpvfqUcgi93-mm_ApQ,2135
 sourcecode/mcp/onboarding/backup.py,sha256=ihqGOR8QTX8HASRSEDyfFyXr5bkXrygPHamv4p9KTmk,1452
@@ -80,8 +81,8 @@ sourcecode/telemetry/consent.py,sha256=wLMvGNJeSSyZoNkQXpoUioY6mMv4Qdvuw7S9jAEWn
 sourcecode/telemetry/events.py,sha256=oEvvulfsv5GIDWG2174gSS6tNB95w38AIYiYeifGKlE,2294
 sourcecode/telemetry/filters.py,sha256=Asa71oRl7q3Wt_FMwuufIZJFzSYdgRNKS8LHCIyFeYE,4805
 sourcecode/telemetry/transport.py,sha256=KJeIPCPWMdmbCP3ySGs2iUlia34U6vWne2dZsUezesw,1560
-sourcecode-1.33.5.dist-info/METADATA,sha256=0CKSD6Q2_A9noOoPyeC4I0A-JuYA8bo3aIAu-kxtm1A,16440
-sourcecode-1.33.5.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.33.5.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.33.5.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.33.5.dist-info/RECORD,,
+sourcecode-1.33.7.dist-info/METADATA,sha256=AOgEqdDTfYhRdBee0gHEvfr_hicz4N8Ex5hH0NTMAKc,16440
+sourcecode-1.33.7.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.33.7.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.33.7.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.33.7.dist-info/RECORD,,