symgrep-codesearch 0.6.2__tar.gz → 0.6.3__tar.gz

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symgrep-codesearch
-Version: 0.6.2
+Version: 0.6.3
 Summary: Code search with honest recall — structure-aware grep that tells you what it does not know, plus search by meaning
 License-Expression: MIT
 Project-URL: Repository, https://github.com/ashdamle/symgrep

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.3}/pyproject.toml

@@ -7,6 +7,9 @@ build-backend = "setuptools.build_meta"
 # Semgrep team. The IMPORT name is unchanged — `import symgrep` — so consumers (honestreview, spendguard,
 # 7thsense, warden) are unaffected by the distribution rename. The package dir stays src/symgrep.
 name = "symgrep-codesearch"
+# 0.6.3: MCP surface completeness — TOOL_DESCRIPTION now documents structural=/lang= (the last undescribed
+# params), and a new `symgrep install-mcp` subcommand self-registers the server via `claude mcp add`. No API
+# change; keeps PyPI current with the capability descriptions pip-installed MCP clients see.
 # 0.6.2: ripgrep is a system binary and cannot be a normal pip dependency, but the new `[rg]` extra pulls
 # `ripgrep-bin` (a wheel bundling the rg binary) for a self-contained install; rg_binary() now also finds an
 # rg next to the interpreter (venv bin), so the pip-only path works even under `.venv/bin/python -m …`.
@@ -17,7 +20,7 @@ name = "symgrep-codesearch"
 # semantic search. Minor bump (dependency surface changed; no breaking import/CLI/MCP change).
 # 0.5.0: added the public `file_structure` library API (+ its MCP tool and `symgrep structure` CLI), import
 # module-name normalization, and the FileStructure `connects` list (structure schema v2).
-version = "0.6.2"
+version = "0.6.3"
 description = "Code search with honest recall — structure-aware grep that tells you what it does not know, plus search by meaning"
 readme = "README.md"
 # 3.11+ : the maintained grammar pack (tree-sitter-language-pack, a CORE dep below) ships abi3 wheels for

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.3}/src/symgrep/cli.py

@@ -409,10 +409,70 @@ def _cmd_structure(rest) -> int:
     return 0
 
 
+def _resolve_mcp_entrypoint() -> "Optional[str]":
+    """Absolute path to symgrep's MCP stdio entrypoint for THIS install, resolved — never hardcoded. The
+    `symgrep-mcp` console script sits next to the interpreter (venv bin) for a pip OR editable install; a bare
+    checkout with no install falls back to the repo's bin/symgrep-mcp wrapper. None if neither is found."""
+    import shutil
+    exe_dir = os.path.dirname(sys.executable or "")
+    cand = os.path.join(exe_dir, "symgrep-mcp")
+    if os.path.isfile(cand) and os.access(cand, os.X_OK):
+        return cand
+    on_path = shutil.which("symgrep-mcp")
+    if on_path:
+        return on_path
+    repo_bin = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+                            "bin", "symgrep-mcp")
+    if os.path.isfile(repo_bin) and os.access(repo_bin, os.X_OK):
+        return repo_bin
+    return None
+
+
+def _cmd_install_mcp(rest) -> int:
+    """`symgrep install-mcp [--scope user|local|project] [--name NAME] [--dry-run]` — register symgrep's own
+    MCP server with Claude Code, so a fresh install advertises itself as a tool. It does NOT write
+    ~/.claude.json itself (one shared file must have ONE writer); it shells to `claude mcp add`, the safe
+    single writer that ships with the client — so this command carries no config-mutation logic to drift."""
+    import shutil
+    import subprocess
+    sp = argparse.ArgumentParser(prog="symgrep install-mcp")
+    sp.add_argument("--scope", default="user", choices=["local", "user", "project"],
+                    help="Claude Code config scope to register in (default: user)")
+    sp.add_argument("--name", default="symgrep", help="server name to register under (default: symgrep)")
+    sp.add_argument("--dry-run", action="store_true", help="print the exact `claude mcp add` command, write nothing")
+    a = sp.parse_args(rest)
+    claude = shutil.which("claude")
+    if not claude:
+        print("install-mcp: the `claude` CLI is not on PATH. symgrep delegates registration to it rather than "
+              "writing ~/.claude.json itself — install Claude Code, then re-run.", file=sys.stderr)
+        return 2
+    entry = _resolve_mcp_entrypoint()
+    if not entry:
+        print("install-mcp: could not locate symgrep's MCP entrypoint (`symgrep-mcp` console script or "
+              "bin/symgrep-mcp). Install symgrep in this interpreter (`pip install symgrep-codesearch`) first.",
+              file=sys.stderr)
+        return 2
+    cmd = [claude, "mcp", "add", "--scope", a.scope, a.name, "--", entry]
+    if a.dry_run:
+        print("DRY RUN — would run:\n  " + " ".join(cmd))
+        return 0
+    print("registering symgrep's MCP server:\n  " + " ".join(cmd))
+    rc = subprocess.run(cmd).returncode
+    if rc == 0:
+        # MCP servers are read at client START: a just-registered server is callable in the NEXT session, not
+        # this one — say so rather than imply a live pickup this cannot deliver.
+        print(f"registered '{a.name}' at scope '{a.scope}'. It becomes callable in the NEXT Claude session "
+              "(MCP servers load at client start). `claude mcp add` leaves an existing entry intact, so this "
+              "is safe to re-run.")
+    return rc
+
+
 def main(argv=None) -> int:
     _argv = list(sys.argv[1:] if argv is None else argv)
     if _argv and _argv[0] == "structure":       # `symgrep structure <path>` — a subcommand over the flag CLI
         return _cmd_structure(_argv[1:])
+    if _argv and _argv[0] == "install-mcp":      # `symgrep install-mcp` — self-register as an MCP server
+        return _cmd_install_mcp(_argv[1:])
     ap = argparse.ArgumentParser(prog="symgrep", description=__doc__)
     ap.add_argument("pattern", nargs="?", default=None,
                     help="regex to search (omit with --index: then every positional is a ROOT)")

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.3}/src/symgrep/mcp_server.py

@@ -55,7 +55,30 @@ TOOL_DESCRIPTION = (
     "nothing is CALLED that, never that nothing DOES it. That gap is how duplicate implementations get "
     "written — measured in one codebase: `share.scrub` beside `share._scrub_text`, `adapters.call_complete` "
     "beside `adapters.call`, `_save_state` in three files. Requires an index (symgrep --index <root>); if "
-    "there is none it says so rather than returning an empty result."
+    "there is none it says so rather than returning an empty result.\n\n"
+    "THREE MORE MODES, each a different question:\n"
+    "  usage=true    — is this name DEFINED, REFERENCED, both, or neither? Returns a verdict in\n"
+    "                  {defined_referenced, defined_unused, undefined_referenced, absent}. LEXICAL,\n"
+    "                  by name: 'defined_unused' is a possibly-unused HINT, never proof of dead code.\n"
+    "  resolve=true  — cross-file candidate resolution: {resolved_unique, ambiguous, external, absent}.\n"
+    "                  When >1 definition shares a name it reports AMBIGUOUS with candidates rather\n"
+    "                  than picking a winner. Use this before trusting any single definition of a\n"
+    "                  name that occurs more than once — import order decides it at runtime.\n"
+    "  structured=true — machine-readable JSON with a mechanical `status` (ok | no_index | unavailable)\n"
+    "                  instead of prose. Use whenever a program, not a human, reads the result.\n\n"
+    "unit= sets --semantic GRANULARITY: 'symbol' (default, a whole function) | 'block' (a sub-function\n"
+    "AST block — Type-4 clone retrieval, finds copy-pasted fragments whole-function search misses) |\n"
+    "'data' (a schema/config/proto/sql definition) | 'both'/'all'. block and data hits need\n"
+    "structured=true to read their span. kind= filters within a unit, e.g. 'data_schema', 'sql_table',\n"
+    "'proto_message'.\n\n"
+    "structural=true SWITCHES FROM REGEX TO AST-PATTERN MATCH — `pattern` becomes a code snippet with\n"
+    "metavariables ($NAME matches one node, $$$ is variadic), matched by syntactic SHAPE, so it finds forms a\n"
+    "regex cannot express (e.g. `$A == $A` for self-comparisons) without tripping on whitespace or naming. It\n"
+    "REQUIRES lang= to pick the grammar the pattern is parsed in (lang= one of the tree-sitter languages:\n"
+    "'python' | 'go' | 'javascript' | 'typescript' | 'tsx' | 'rust' | 'java' | 'c' | 'cpp' | 'ruby' | 'php' |\n"
+    "'c_sharp' | 'kotlin' | 'scala' | 'bash'); with no usable grammar it reports UNAVAILABLE rather than\n"
+    "silently falling back to text. Use it for structural queries a name/regex search cannot express; use\n"
+    "plain regex or semantic=true for everything else."
 )
 
 
@@ -131,6 +154,11 @@ def _run_fastmcp(http=None) -> bool:
         definitions, references, resolution_basis:"candidate-name"}. verdict ∈ resolved_unique | ambiguous |
         external | absent. When >1 definition shares the name it is AMBIGUOUS (candidates, not one winner).
 
+        structural=True: match by AST SHAPE, not regex — `pattern` is a code snippet with metavariables
+        ($NAME matches one node, $$$ is variadic). Requires lang= (the tree-sitter grammar the pattern parses
+        in, e.g. "python"/"go"/"rust"); reports UNAVAILABLE when no grammar is usable rather than falling back
+        to text. lang is used ONLY by structural search.
+
         unit: --semantic granularity — "symbol" (default; a whole function/method, the only pre-v6 behaviour,
         byte-stable) | "block" (a sub-function AST block, Type-4 clone retrieval) | "data" (a schema/data/config
         symbol — a data_schema file unit or a proto/sql definition) | "both"/"all". block/data hits need

{symgrep_codesearch-0.6.2 → symgrep_codesearch-0.6.3}/src/symgrep_codesearch.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symgrep-codesearch
-Version: 0.6.2
+Version: 0.6.3
 Summary: Code search with honest recall — structure-aware grep that tells you what it does not know, plus search by meaning
 License-Expression: MIT
 Project-URL: Repository, https://github.com/ashdamle/symgrep