attocode-code-intel 0.1.0__py3-none-any.whl

attocode_intel/tools/query_constraints_tools.py

@@ -0,0 +1,262 @@
+"""Query constraints MCP tools.
+
+Supports fff-style query constraints for filtering search results:
+- git:modified, git:staged, git:deleted, git:renamed, git:untracked, git:ignored
+- !pattern - exclude files matching pattern
+- path/ - filter by directory
+- ./**/*.py - glob patterns
+- *.py - extension filters
+
+Example queries:
+  "git:modified *.py" - Modified Python files
+  "!test/ src/**/*.rs" - Rust files not in test directories
+  "git:staged !vendor/" - Staged files excluding vendor
+"""
+
+from __future__ import annotations
+
+import subprocess
+from typing import TYPE_CHECKING
+
+from attocode_intel._shared import _get_project_dir, mcp
+
+if TYPE_CHECKING:
+    from attocode_intel._internal.integrations.context.query_constraints import QueryConstraintProcessor
+
+
+def _get_constraint_processor() -> QueryConstraintProcessor:
+    """Get the constraint processor."""
+    from attocode_intel._internal.integrations.context.query_constraints import (
+        QueryConstraintProcessor,
+    )
+
+    project_dir = _get_project_dir()
+    return QueryConstraintProcessor(project_dir=project_dir)
+
+
+def _run_git_status() -> dict[str, str]:
+    """Run git status --porcelain to get all file statuses.
+
+    Returns:
+        Dict mapping file path to status code.
+    """
+    project_dir = _get_project_dir()
+
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        statuses: dict[str, str] = {}
+        for line in result.stdout.splitlines():
+            if len(line) < 3:
+                continue
+            x_status = line[0]  # index (staging area)
+            y_status = line[1]  # worktree
+            file_path = line[3:].strip()
+            # Prefer index status if meaningful, otherwise use worktree
+            if x_status not in (" ", "?"):
+                statuses[file_path] = x_status
+            elif y_status != " ":
+                statuses[file_path] = y_status
+            else:
+                statuses[file_path] = x_status  # handles '??' etc.
+
+        return statuses
+
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        return {}
+
+
+@mcp.tool()
+def parse_query_with_constraints(query: str) -> str:
+    """Parse a query with fff-style constraints.
+
+    Shows how the query is decomposed into the main search term
+    and any constraints.
+
+    Supported constraints:
+    - git:modified, git:staged, git:deleted, git:renamed, git:untracked, git:ignored
+    - !pattern - exclude files matching pattern
+    - path/ - filter by directory
+    - ./**/*.py - glob patterns
+    - *.py - extension filters
+
+    Args:
+        query: Query string to parse.
+
+    Returns:
+        Parsed constraint breakdown.
+    """
+    from attocode_intel._internal.integrations.context.query_constraints import parse_query_constraints
+
+    parsed = parse_query_constraints(query)
+
+    lines = [
+        f"Query: '{query}'",
+        "\nParsed components:",
+        f"  Main query: '{parsed.query}'" if parsed.query else "  Main query: (empty)",
+        f"\n  Constraints ({len(parsed.constraints)}):",
+    ]
+
+    if not parsed.constraints:
+        lines.append("    (none)")
+    else:
+        for i, c in enumerate(parsed.constraints, 1):
+            neg_str = " (negated)" if c.negated else ""
+            lines.append(f"    {i}. [{c.type}] '{c.value}'{neg_str}")
+
+    lines.append("\nExamples of valid queries:")
+    lines.append('  "git:modified *.py" - Find modified Python files')
+    lines.append('  "!test/ src/**/*.rs" - Rust files not in test/')
+    lines.append('  "git:staged !vendor/" - Staged files except vendor')
+
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def filter_files_with_constraints(
+    query: str,
+    files: str,
+) -> str:
+    """Filter a list of files using query constraints.
+
+    Takes a query with constraints and a list of files, then returns
+    only the files that match all constraints.
+
+    Args:
+        query: Query with constraints (e.g., "git:modified *.py")
+        files: Newline-separated list of file paths to filter.
+
+    Returns:
+        Filtered list of files.
+    """
+    from attocode_intel._internal.integrations.context.query_constraints import (
+        GitStatus,
+        matches_constraints,
+        parse_query_constraints,
+    )
+
+    file_list = [f.strip() for f in files.splitlines() if f.strip()]
+
+    if not file_list:
+        return "No files provided."
+
+    parsed = parse_query_constraints(query)
+
+    if not parsed.constraints:
+        return f"No constraints found in query '{query}'."
+
+    # Get git statuses
+    git_statuses_raw = _run_git_status()
+    git_statuses: dict[str, GitStatus] = {}
+
+    status_map = {
+        "M": GitStatus.MODIFIED,
+        "A": GitStatus.STAGED,
+        "D": GitStatus.DELETED,
+        "R": GitStatus.RENAMED,
+        "?": GitStatus.UNTRACKED,
+        "!": GitStatus.IGNORED,
+    }
+
+    for file_path, status_char in git_statuses_raw.items():
+        git_statuses[file_path] = status_map.get(status_char, GitStatus.MODIFIED)
+
+    # Filter files
+    filtered = []
+    for file_path in file_list:
+        git_status = git_statuses.get(file_path)
+        if matches_constraints(file_path, parsed.constraints, git_status):
+            filtered.append(file_path)
+
+    if not filtered:
+        return (
+            f"No files matched constraints from query '{query}'.\n"
+            f"Tried to filter {len(file_list)} files."
+        )
+
+    lines = [
+        f"Filtered {len(filtered)} files (from {len(file_list)} input files):",
+        f"Query: '{query}'\n",
+    ]
+    lines.extend(filtered)
+
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def list_modified_files() -> str:
+    """List all git-modified files in the project.
+
+    Returns:
+        List of modified files with their status.
+    """
+    project_dir = _get_project_dir()
+
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        files_by_status: dict[str, list[str]] = {}
+
+        status_map = {
+            "M": "modified",
+            "A": "staged",
+            "D": "deleted",
+            "R": "renamed",
+            "?": "untracked",
+            "!": "ignored",
+        }
+
+        for line in result.stdout.splitlines():
+            if len(line) < 3:
+                continue
+
+            x_status = line[0]  # index (staging area)
+            y_status = line[1]  # worktree
+            file_path = line[3:].strip()
+
+            # Add file under each applicable status
+            statuses_to_add: list[str] = []
+            if x_status not in (" ", "?", "!"):
+                statuses_to_add.append(
+                    status_map.get(x_status, f"unknown({x_status})")
+                )
+            if y_status not in (" ", "?", "!"):
+                name = status_map.get(y_status, f"unknown({y_status})")
+                if name not in statuses_to_add:
+                    statuses_to_add.append(name)
+            # Handle untracked/ignored (both columns are the same char)
+            if x_status == "?":
+                statuses_to_add.append("untracked")
+            elif x_status == "!":
+                statuses_to_add.append("ignored")
+
+            for status_name in statuses_to_add:
+                if status_name not in files_by_status:
+                    files_by_status[status_name] = []
+                files_by_status[status_name].append(file_path)
+
+        if not files_by_status:
+            return "No modified files."
+
+        lines = ["Modified files:"]
+        for status_name, files in files_by_status.items():
+            lines.append(f"\n{status_name.upper()}:")
+            for f in sorted(files):
+                lines.append(f"  {f}")
+
+        return "\n".join(lines)
+
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError) as e:
+        return f"Error running git: {e}"

attocode_intel/tools/query_history_tools.py

@@ -0,0 +1,158 @@
+"""Query history MCP tools for tracking search-result selections.
+
+Tracks which files are selected after which queries, enabling
+combo boosting to prioritize commonly co-occurring results.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from attocode_intel._shared import _get_project_dir, mcp
+from attocode_intel.tools.pin_tools import pin_stamped
+
+if TYPE_CHECKING:
+    from attocode_intel._internal.integrations.context.query_history import QueryHistoryTracker
+
+
+def _get_query_tracker() -> QueryHistoryTracker:
+    """Get the query history tracker instance."""
+    from attocode_intel._internal.integrations.context.query_history import get_query_tracker
+
+    project_dir = _get_project_dir()
+    db_path = Path(project_dir) / ".attocode" / "query_history"
+    return get_query_tracker(db_path=db_path)
+
+
+@mcp.tool()
+def track_query_result(query: str, file_path: str) -> str:
+    """Track that a user selected a file after searching.
+
+    Call this whenever a user searches for something and then opens
+    a file from the results. This builds up combo boosting to help
+    prioritize commonly selected files for future searches.
+
+    Args:
+        query: The search query that led to the selection.
+        file_path: The file that was selected/opened.
+
+    Returns:
+        Confirmation message.
+    """
+    tracker = _get_query_tracker()
+    tracker.track_selection(query, file_path)
+
+    # Check if this triggers combo boost
+    boost = tracker.get_combo_boost(query, file_path)
+    if boost > 0:
+        return (
+            f"Tracked: '{query}' -> {file_path}\n"
+            f"Combo boost activated: +{boost:.0f}"
+        )
+    return f"Tracked: '{query}' -> {file_path}"
+
+
+@mcp.tool()
+def get_query_combo_boost(query: str, file_path: str) -> str:
+    """Get the combo boost score for a query+file pair.
+
+    Args:
+        query: The search query.
+        file_path: The file path to check.
+
+    Returns:
+        Combo boost score and metadata.
+    """
+    tracker = _get_query_tracker()
+    boost = tracker.get_combo_boost(query, file_path)
+
+    if boost == 0:
+        return (
+            f"No combo boost for '{query}' -> {file_path}\n"
+            f"(Need 3+ selections to activate boost)"
+        )
+
+    return (
+        f"Combo boost: +{boost:.0f}\n"
+        f"Query: '{query}'\n"
+        f"File: {file_path}"
+    )
+
+
+@mcp.tool()
+@pin_stamped
+def get_top_results_for_query(query: str, limit: int = 10) -> str:
+    """Get the top files commonly selected for a query.
+
+    Args:
+        query: The search query.
+        limit: Maximum number of results to return.
+
+    Returns:
+        Top files for this query with selection counts.
+    """
+    tracker = _get_query_tracker()
+    top_files = tracker.get_top_files_for_query(query, limit=limit)
+
+    if not top_files:
+        return f"No history for query: '{query}'"
+
+    lines = [
+        f"Top results for: '{query}'",
+        f"(Based on {limit} historical selections)\n",
+    ]
+
+    for i, (file_path, count, combo_score) in enumerate(top_files, 1):
+        boost_str = f" (+{combo_score:.0f} boost)" if combo_score > 0 else ""
+        lines.append(f"{i}. [{count}x] {file_path}{boost_str}")
+
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def get_query_history_stats() -> str:
+    """Get overall query history statistics.
+
+    Returns:
+        Statistics about tracked queries and selections.
+    """
+    tracker = _get_query_tracker()
+    stats = tracker.get_stats()
+
+    lines = [
+        "Query History Statistics",
+        "=" * 40,
+        f"Total selections tracked: {stats.total_selections}",
+        f"Total query entries: {stats.total_queries}",
+        f"Unique queries: {stats.unique_queries}",
+        f"Unique files: {stats.unique_files}",
+        f"Files with combo boost: {stats.combo_boosts}",
+    ]
+
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def clear_query_history(query: str | None = None, file_path: str | None = None) -> str:
+    """Clear query history.
+
+    Args:
+        query: Optional specific query to clear. If None, clears all.
+        file_path: Optional specific file to clear (requires query).
+
+    Returns:
+        Confirmation message.
+    """
+    tracker = _get_query_tracker()
+
+    if query is None:
+        tracker.clear()
+        return "All query history cleared."
+
+    count = tracker.clear(query, file_path)
+    if count > 0:
+        if file_path:
+            return f"Cleared history for '{query}' -> {file_path}"
+        return f"Cleared {count} entries for query: '{query}'"
+    return f"No history found for query: '{query}'"

attocode_intel/tools/readiness_tools.py

@@ -0,0 +1,44 @@
+"""Readiness report tool for the code-intel MCP server.
+
+Tools: readiness_report.
+"""
+
+from __future__ import annotations
+
+from attocode_intel._shared import (
+    _get_service,
+    mcp,
+)
+
+
+@mcp.tool()
+def readiness_report(
+    phases: list[int] | None = None,
+    scope: str = "",
+    tracer_bullets: bool = True,
+    min_severity: str = "info",
+) -> str:
+    """Run a comprehensive readiness audit of the codebase.
+
+    Executes 8 analysis phases covering baseline health, API completeness,
+    frontend flows, data layer, test coverage, security, observability,
+    and deployability. Orchestrates existing tools (security_scan, dead_code,
+    hotspots, conventions, etc.) plus new phase-specific analysis.
+
+    Returns severity-tagged findings with file:line evidence and an overall
+    readiness grade (A-F).
+
+    Args:
+        phases: List of phase numbers to run (0-7). None = all phases.
+            0=Baseline, 1=API/Logic, 2=Frontend, 3=Data, 4=Tests,
+            5=Security, 6=Observability, 7=Deployability.
+        scope: Restrict analysis to files under this directory prefix.
+        tracer_bullets: Whether to run tracer bullet analysis (default True).
+        min_severity: Minimum severity to include: "pass", "info", "warning", "critical".
+    """
+    return _get_service().readiness_report(
+        phases=phases,
+        scope=scope,
+        tracer_bullets=tracer_bullets,
+        min_severity=min_severity,
+    )