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

attocode_intel/entrypoint.py

@@ -0,0 +1,185 @@
+"""Standalone CLI; importing it does not load the agent or analysis engines."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+import threading
+import time
+
+COMMANDS = """commands:
+  init                Add the server to Codex, Claude Code or Cursor (--client)
+  doctor              Start the configured server and check that it answers
+  install <target>    Add the server to another client, for example vscode or zed
+  share               Send a learning to a team server
+  query <text>        Search the code
+  symbols <file>      List the symbols of a file, or find one with --search <name>
+  impact <file>...    Show the files that a change to these files can affect
+  hotspots            Show the files with the most risk or complexity
+  deps <file>         Show what a file imports and what imports it
+  commands            Show all commands, with maintenance commands and targets
+"""
+
+
+def exit_when_client_exits(interval: float = 5.0) -> None:
+    """Stop a stdio server when the client process that started it is gone.
+
+    At end of input the MCP SDK still waits for running tool calls. A call
+    that never ended kept an orphaned server alive, at full CPU, for days.
+    SQLite indexes stay consistent after an abrupt exit. The watchdog does not
+    write a message: stderr usually goes to the closed client, and a write
+    error would stop the thread before the exit.
+    """
+    parent = os.getppid()
+
+    def watch() -> None:
+        while os.getppid() == parent:
+            time.sleep(interval)
+        os._exit(0)
+
+    threading.Thread(target=watch, name="client-watchdog", daemon=True).start()
+
+
+def main(argv=None):
+    args = list(sys.argv[1:] if argv is None else argv)
+    if args and args[0] == "share":
+        from attocode_intel.sharing import share
+
+        share(args[1:])
+        return
+    if args and args[0] in {"init", "doctor"}:
+        command = args.pop(0)
+        parser = argparse.ArgumentParser(prog=f"attocode-code-intel {command}")
+        parser.add_argument("--client", choices=["codex", "claude", "cursor", "all"], default="all")
+        parser.add_argument("--project", default=".")
+        parser.add_argument("--global", dest="global_scope", action="store_true")
+        parser.add_argument("--profile", choices=["daily", "full"], default="daily")
+        parser.add_argument("--dry-run", action="store_true")
+        parser.add_argument("--remove", action="store_true")
+        parser.add_argument("--server", default="")
+        parser.add_argument("--repo", default="")
+        parser.add_argument(
+            "--remote", action="store_true", help="Doctor/remove: select the remote integration"
+        )
+        parser.add_argument("--token-env", default="ATTOCODE_API_KEY")
+        opts = parser.parse_args(args)
+        from attocode_intel.onboarding import configure_client, diagnose
+
+        clients = ["codex", "claude", "cursor"] if opts.client == "all" else [opts.client]
+        failed, ready = False, 0
+        for client in clients:
+            try:
+                if command == "init":
+                    result = configure_client(
+                        client,
+                        opts.project,
+                        global_scope=opts.global_scope,
+                        profile=opts.profile,
+                        dry_run=opts.dry_run,
+                        remove=opts.remove,
+                        server=opts.server,
+                        token_env=opts.token_env,
+                        repo=opts.repo or ("remote" if opts.remote else ""),
+                    )
+                else:
+                    result = asyncio.run(
+                        diagnose(
+                            client,
+                            opts.project,
+                            global_scope=opts.global_scope,
+                            remote=bool(opts.remote or opts.server or opts.repo),
+                        )
+                    )
+                print(json.dumps(result, indent=2))
+                ready += result.get("status") != "not configured"
+            except Exception as exc:
+                # A timeout has no message of its own.
+                reason = "the server did not answer in 30 s" if isinstance(exc, TimeoutError) else exc
+                print(f"{client}: {reason}", file=sys.stderr)
+                failed = True
+        # With --client all, a client without configuration is not a failure, but one client must be ready.
+        if failed or not ready:
+            raise SystemExit(1)
+        return
+    if args and args[0] not in {"serve", "help"} and not args[0].startswith("-"):
+        from attocode_intel.cli import dispatch_code_intel
+
+        dispatch_code_intel(args)
+        return
+    if args and args[0] == "serve":
+        args.pop(0)
+    if args == ["help"]:
+        args = ["--help"]
+    parser = argparse.ArgumentParser(
+        prog="attocode-code-intel",
+        description="Code search and navigation for coding agents and for people. "
+        "Without a command, it runs the MCP server.",
+        epilog=COMMANDS,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--project", default=os.environ.get("ATTOCODE_PROJECT_DIR", ""))
+    parser.add_argument(
+        "--profile", choices=["daily", "full"], default="daily",
+        help="daily: a short tool list for agents (default); full: all tools",
+    )
+    parser.add_argument(
+        "--transport", choices=["stdio", "sse", "http", "streamable-http"], default="stdio"
+    )
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8080)
+    parser.add_argument(
+        "--local-only", action="store_true", help="Accepted for old configurations; it has no effect"
+    )
+    parser.add_argument("--no-watch", action="store_true")
+    parser.add_argument("--watch-debounce", type=int, default=500)
+    from attocode_intel import __version__
+
+    parser.add_argument("--version", action="version", version=f"attocode-code-intel {__version__}")
+    opts = parser.parse_args(args)
+    if opts.transport in {"http", "streamable-http"}:
+        from attocode_intel.cli import _serve_http
+
+        os.environ["ATTOCODE_MCP_PROFILE"] = opts.profile
+        os.environ["ATTOCODE_INTEL_WATCH"] = "0" if opts.no_watch else "1"
+        os.environ["ATTOCODE_INTEL_WATCH_DEBOUNCE"] = str(opts.watch_debounce)
+        _serve_http(opts.project, host=opts.host, port=opts.port, debug=False)
+    elif opts.transport == "sse":
+        from attocode_intel.config import is_loopback
+
+        if not is_loopback(opts.host):
+            # SSE has no sign-in, so any computer that reaches the port could read the index.
+            raise SystemExit("Error: SSE serves only this computer. For other hosts, use "
+                             "--transport http with ATTOCODE_API_KEY.")
+        # ponytail: SSE runs the older server, which lists all tools. Use stdio or http for profiles.
+        from attocode_intel.server import mcp
+
+        mcp.settings.host, mcp.settings.port = opts.host, opts.port
+        if opts.project:
+            os.environ["ATTOCODE_PROJECT_DIR"] = opts.project
+        mcp.run(transport="sse")
+    else:
+        asyncio.run(_stdio(opts))
+
+
+async def _stdio(opts):
+    from mcp.server.stdio import stdio_server
+
+    from attocode_intel.gateway import OperationGateway, create_mcp_server
+
+    gateway = OperationGateway(
+        opts.project, opts.profile, watch=not opts.no_watch, watch_debounce=opts.watch_debounce
+    )
+    server = create_mcp_server(gateway)
+    exit_when_client_exits()
+    try:
+        async with stdio_server() as (read, write):
+            await server.run(read, write, server.create_initialization_options())
+    finally:
+        await gateway.close()
+
+
+if __name__ == "__main__":
+    main()

attocode_intel/focused_evidence.py

@@ -0,0 +1,130 @@
+"""Deterministic lexical evidence selection; excerpts are never stitched together."""
+from __future__ import annotations
+
+import io
+import re
+import tokenize
+from collections import Counter
+
+STOP_WORDS = frozenset({"a", "an", "and", "are", "as", "at", "be", "by", "code", "def", "do", "does", "for", "from", "function", "get", "how", "in", "is", "it", "method", "of", "on", "or", "return", "self", "test", "tests", "the", "this", "to", "use", "value", "with"})
+_EXCLUSION = re.compile(r"\b(?:without|excluding|exclude|except|avoid)\b", re.IGNORECASE)
+_EXCLUSION_END = re.compile(r"[,;.!?]|\b(?:but|instead|rather|while)\b", re.IGNORECASE)
+_EXCLUSION_MODIFIERS = frozenset({"unrelated", "irrelevant", "unwanted", "other"})
+
+
+def terms(text, fold=True):
+    """Query or evidence words; ``fold`` cuts a plural "s", so both sides must use the same rule."""
+    text = re.sub(r"([a-z0-9])([A-Z])", r"\1 \2", text)
+    words = re.findall(r"[a-zA-Z][a-zA-Z0-9]*", text.lower())
+    return {word[:-1] if fold and word.endswith("s") and not word.endswith("ss") and len(word) > 4 else word
+            for word in words if len(word) > 2 and word not in STOP_WORDS}
+
+
+def task_terms(text: str, fold: bool = True) -> tuple[set[str], set[str]]:
+    """Separate explicit exclusions from positive task terms.
+
+    The negative set is a *ranking hint*, never a hard filter. Deliberately
+    recognize only explicit exclusion words: ordinary negation such as
+    ``not found`` often describes the bug rather than irrelevant code.
+    """
+    positive_parts: list[str] = []
+    negative_parts: list[str] = []
+    remaining = text
+    while match := _EXCLUSION.search(remaining):
+        positive_parts.append(remaining[:match.start()])
+        tail = remaining[match.end():]
+        end = _EXCLUSION_END.search(tail)
+        if end is None:
+            negative_parts.append(tail)
+            remaining = ""
+            break
+        negative_parts.append(tail[:end.start()])
+        remaining = tail[end.end():]
+    positive_parts.append(remaining)
+    positive = terms(" ".join(positive_parts), fold) - _EXCLUSION_MODIFIERS
+    negative = terms(" ".join(negative_parts), fold) - _EXCLUSION_MODIFIERS
+    return positive, negative
+
+
+def file_excerpt(lines: list[str], path: str, query: str) -> str:
+    """Query-focused file evidence for a shortlist decision.
+
+    The product reranker and the eval trials show a model this same text. It
+    has up to two numbered windows around the lines with the most task terms.
+    """
+    if not lines:
+        return f"File: {path}\n(empty file)"
+    positive, _ = task_terms(query)
+    centers: list[int] = []
+    scored = sorted(((len(terms(line) & positive), -index, index)
+                     for index, line in enumerate(lines)), reverse=True)
+    for overlap, _order, index in scored:
+        if overlap == 0 and centers:
+            break
+        if all(abs(index - old) > 24 for old in centers):
+            centers.append(index)
+        if len(centers) == 2:
+            break
+    windows = []
+    for center in sorted(centers or [0]):
+        start, end = max(0, center - 8), min(len(lines), center + 9)
+        windows.append("\n".join(f"{number + 1}: {lines[number]}"
+                                 for number in range(start, end)))
+    return (f"File: {path}\n" + "\n...\n".join(windows))[:1350]
+
+
+def source_excerpts(source, definition, task_hint, *, preview_end=0):
+    """Rank code identifiers, favor branches/assignments, and return disjoint ranges.
+
+    This is a lexical aid, not semantic relevance or complete control-flow coverage.
+    Python strings/comments do not become evidence just by repeating query words.
+    """
+    from attocode_intel.structural_evidence import structural_excerpts
+    structured = structural_excerpts(source, definition, task_hint, preview_end)
+    if structured is not None:
+        return structured
+    query, _ = task_terms(task_hint)
+    if not query:
+        return []
+    first, last = definition.start_line, min(definition.end_line, len(source))
+    identifiers = {}
+    if definition.file_path.endswith(".py"):
+        try:
+            for token in tokenize.generate_tokens(io.StringIO("\n".join(source)).readline):
+                if token.type == tokenize.NAME and first <= token.start[0] <= last:
+                    identifiers.setdefault(token.start[0], []).append(token.string)
+        except (tokenize.TokenError, IndentationError, SyntaxError):
+            pass  # Only retain tokens actually read; do not invent coverage.
+    else:
+        for number in range(first, last + 1):
+            line = source[number - 1].strip()
+            if line.startswith(("#", "//", "/*", "*")):
+                continue
+            code = re.sub(r"(['\"]).*?\1", "", line).split("//", 1)[0]
+            identifiers[number] = re.findall(r"[A-Za-z_][A-Za-z_0-9]*", code)
+    candidates = []
+    for number, names in identifiers.items():
+        if number <= preview_end:
+            continue  # The caller already supplies this source verbatim.
+        hits = Counter(term for name in names for term in terms(name) if term in query)
+        if not hits:
+            continue
+        code = source[number - 1].strip()
+        # Guards and stores often express behavior more directly than annotations.
+        action = bool(re.match(r"(?:if|elif|else|return|case|throw|raise)\b", code) or
+                      (not code.endswith(",") and re.search(r"(?<![=!<>])=(?!=)", code)))
+        # Multiple participating identifiers help distinguish access from simple
+        # initialization, but repetition is capped so annotations cannot dominate.
+        score = sum(min(count, 2) for count in hits.values()) + 2 * int(action)
+        candidates.append((number, score, set(hits)))
+    selected, covered = [], set()
+    while candidates and len(selected) < 3:
+        number, _, hits = max(candidates, key=lambda row: (row[1] + len(row[2] - covered), -row[0]))
+        start, end = max(first, preview_end + 1, number - 1), min(last, number + 3)
+        selected.append({"file_path": definition.file_path, "start_line": start, "end_line": end,
+                         "text": "\n".join(source[start - 1:end]), "matched_terms": sorted(hits), "context_ranges": [],
+                         "context_incomplete": True, "context_relation": "structural context unavailable"})
+        covered.update(hits)
+        candidates = [row for row in candidates if min(last, row[0] + 3) < start or max(first, row[0] - 1) > end]
+    # Keep relevance ordering, so output budgeting drops lower ranked whole excerpts.
+    return selected

attocode_intel/freshness.py

@@ -0,0 +1,154 @@
+"""Incremental invalidation based on filesystem identity, including import-only edits."""
+
+from __future__ import annotations
+
+import logging
+import os
+import threading
+from pathlib import Path
+
+from attocode_intel._internal.integrations.utilities.ignore import IgnoreManager
+
+
+class FreshnessTracker:
+    def __init__(self, root: str):
+        self.root = root
+        self.manifest = None
+        self.generation = 0
+        self._ignore = None
+        self._ignore_identity = None
+        self._eligibility = {}
+
+    def scan_manifest(self):
+        """Stat every eligible file, reusing only path-filter decisions.
+
+        No time window or watcher delivery is required for edit detection.
+        DirEntry avoids allocating/resolving a Path for each file on each call.
+        """
+        from attocode_intel._internal.integrations.context.codebase_context import (
+            SKIP_EXTENSIONS,
+            SKIP_FILENAMES,
+        )
+
+        try:
+            stat = os.stat(os.path.join(self.root, ".gitignore"))
+            ignore_identity = (stat.st_mtime_ns, stat.st_ctime_ns, stat.st_size)
+        except OSError:
+            ignore_identity = None
+        if self._ignore is None or ignore_identity != self._ignore_identity:
+            self._ignore = IgnoreManager(self.root)
+            self._ignore_identity = ignore_identity
+            self._eligibility.clear()
+        ignore = self._ignore
+        manifest = {}
+        eligibility = {}
+        pending = [(self.root, "")]
+        while pending:
+            directory, prefix = pending.pop()
+            try:
+                with os.scandir(directory) as entries:
+                    for entry in entries:
+                        name = entry.name
+                        if name.startswith("."):
+                            continue
+                        rel = prefix + name
+                        try:
+                            is_dir = entry.is_dir()
+                            key = rel + "/" if is_dir else rel
+                            allowed = self._eligibility.get(key)
+                            if allowed is None:
+                                allowed = (is_dir or (
+                                    name not in SKIP_FILENAMES
+                                    and os.path.splitext(name)[1].lower() not in SKIP_EXTENSIONS
+                                )) and not ignore.is_ignored(key)
+                            eligibility[key] = allowed
+                            if not allowed:
+                                continue
+                            if is_dir:
+                                if not entry.is_symlink():
+                                    pending.append((entry.path, key))
+                            else:
+                                stat = entry.stat()
+                                if stat.st_size <= 1_000_000:
+                                    manifest[rel] = (stat.st_mtime_ns, stat.st_ctime_ns, stat.st_size)
+                        except OSError:
+                            continue
+            except OSError:
+                continue
+        self._eligibility = eligibility
+        return manifest
+
+    def refresh(self, service):
+        manifest = self.scan_manifest()
+        previous = self.manifest
+        if previous is None or service._ast_service is None:
+            self.manifest = manifest
+            return
+        changed = {
+            p for p in previous.keys() | manifest.keys() if previous.get(p) != manifest.get(p)
+        }
+        if not changed:
+            self.manifest = manifest
+            return
+        self.generation += 1
+        from attocode_intel.request_context import current_request
+        request = current_request.get()
+        if request and (precision := request.stores.get("precision")):
+            precision.invalidate(changed)
+        if request:
+            request.stores.pop("reference_pages", None)
+        ast = service._ast_service
+        if not ast.repair_changed_files(expected_manifest=manifest):
+            ast.stop_hydration()
+            if previous.keys() != manifest.keys():
+                ast._context_mgr.discover_files()
+            for path in changed:
+                if path not in manifest:
+                    ast._store.set_meta("structural_snapshot_v1", "")
+                    ast._snapshot_start = None
+                    ast._index.remove_file(path)
+                    ast._ast_cache.pop(path, None)
+                    ast._reference_indexed_files.discard(path)
+                else:
+                    ast.notify_file_changed(path)
+            graph = ast._context_mgr.dependency_graph
+            if graph:
+                ast._index.file_dependencies.clear()
+                ast._index.file_dependents.clear()
+                for source, targets in graph.forward.items():
+                    for target in targets:
+                        ast._index.add_file_dependency(source, target)
+            if ast._hydration_state and ast._hydration_state.phase != "ready":
+                ast.start_hydration()
+        for path in changed:
+            if service._semantic_search:
+                service._semantic_search.invalidate_file(str(Path(self.root) / path))
+                service._semantic_search._kw_index_built = False
+        self.manifest = manifest
+
+
+class WorkspaceWatcher:
+    """Watch only; refreshes run on the workspace's serial worker."""
+
+    def __init__(self, root, callback, debounce=500):
+        self.stop_event = threading.Event()
+        self.thread = threading.Thread(
+            target=self._run, args=(root, callback, debounce), daemon=True, name="intel-watch"
+        )
+        self.thread.start()
+
+    def _run(self, root, callback, debounce):
+        try:
+            from watchfiles import watch
+
+            for changes in watch(root, stop_event=self.stop_event, debounce=max(debounce, 50)):
+                if any(".attocode" not in Path(path).parts for _, path in changes):
+                    callback()
+        except Exception:
+            logging.getLogger(__name__).warning(
+                "File watcher unavailable; per-operation stat checks remain active", exc_info=True
+            )
+
+    def close(self):
+        self.stop_event.set()
+        self.thread.join(timeout=2)