Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /ViperJuice_Code-Index-MCP /scripts /development /scaffold_code.py
| # Save this as scaffold_code.py and run it inside your Codespace | |
| import os | |
| BASE = "mcp_server" | |
| plugin_base = f"""{BASE}/plugin_base.py""" | |
| dispatcher = f"""{BASE}/dispatcher.py""" | |
| gateway = f"""{BASE}/gateway.py""" | |
| watcher = f"""{BASE}/watcher.py""" | |
| sync = f"""{BASE}/sync.py""" | |
| treesitter = f"""{BASE}/utils/treesitter_wrapper.py""" | |
| plugins = ["python", "dart", "js", "c", "cpp", "html_css"] | |
| os.makedirs(f"{BASE}/utils", exist_ok=True) | |
| with open(plugin_base, "w") as f: | |
| f.write('''from abc import ABC, abstractmethod | |
| from dataclasses import dataclass | |
| from typing import TypedDict, Iterable | |
| from pathlib import Path | |
| class IndexShard(TypedDict): | |
| file: str | |
| symbols: list[dict] | |
| language: str | |
| @dataclass(frozen=True) | |
| class Reference: | |
| file: str | |
| line: int | |
| class SymbolDef(TypedDict): | |
| symbol: str | |
| kind: str | |
| language: str | |
| signature: str | |
| doc: str | None | |
| defined_in: str | |
| line: int | |
| span: tuple[int, int] | |
| class SearchResult(TypedDict): | |
| file: str | |
| line: int | |
| snippet: str | |
| class SearchOpts(TypedDict, total=False): | |
| semantic: bool | |
| limit: int | |
| class IPlugin(ABC): | |
| lang: str | |
| @abstractmethod | |
| def supports(self, path: str | Path) -> bool: ... | |
| @abstractmethod | |
| def indexFile(self, path: str | Path, content: str) -> IndexShard: ... | |
| @abstractmethod | |
| def getDefinition(self, symbol: str) -> SymbolDef | None: ... | |
| @abstractmethod | |
| def findReferences(self, symbol: str) -> Iterable[Reference]: ... | |
| @abstractmethod | |
| def search(self, query: str, opts: SearchOpts | None = None) -> Iterable[SearchResult]: ... | |
| ''') | |
| with open(dispatcher, "w") as f: | |
| f.write('''from pathlib import Path | |
| from typing import Iterable | |
| from .plugin_base import IPlugin, SymbolDef, SearchResult | |
| class Dispatcher: | |
| def __init__(self, plugins: list[IPlugin]): | |
| self._plugins = plugins | |
| self._by_lang = {p.lang: p for p in plugins} | |
| def _match_plugin(self, path: Path) -> IPlugin: | |
| for p in self._plugins: | |
| if p.supports(path): | |
| return p | |
| raise RuntimeError(f"No plugin for {path}") | |
| def lookup(self, symbol: str) -> SymbolDef | None: | |
| for p in self._plugins: | |
| res = p.getDefinition(symbol) | |
| if res: | |
| return res | |
| return None | |
| def search(self, query: str, semantic=False, limit=20) -> Iterable[SearchResult]: | |
| opts = {"semantic": semantic, "limit": limit} | |
| for p in self._plugins: | |
| yield from p.search(query, opts) | |
| ''') | |
| with open(gateway, "w") as f: | |
| f.write('''from fastapi import FastAPI, HTTPException | |
| from .dispatcher import Dispatcher | |
| from .plugin_base import SymbolDef, SearchResult | |
| app = FastAPI(title="MCP Server") | |
| dispatcher: Dispatcher | None = None | |
| @app.get("/symbol", response_model=SymbolDef | None) | |
| def symbol(symbol: str): | |
| if dispatcher is None: | |
| raise HTTPException(503, "Dispatcher not ready") | |
| return dispatcher.lookup(symbol) | |
| @app.get("/search", response_model=list[SearchResult]) | |
| def search(q: str, semantic: bool = False, limit: int = 20): | |
| if dispatcher is None: | |
| raise HTTPException(503, "Dispatcher not ready") | |
| return list(dispatcher.search(q, semantic=semantic, limit=limit)) | |
| ''') | |
| with open(watcher, "w") as f: | |
| f.write('''from pathlib import Path | |
| from watchdog.observers import Observer | |
| from watchdog.events import FileSystemEventHandler | |
| from .dispatcher import Dispatcher | |
| class _Handler(FileSystemEventHandler): | |
| def __init__(self, dispatcher: Dispatcher): | |
| self.dispatcher = dispatcher | |
| def on_modified(self, event): | |
| if event.is_directory: | |
| return | |
| path = Path(event.src_path) | |
| # TODO: dispatcher._match_plugin(path).indexFile(path.read_text()) | |
| class FileWatcher: | |
| def __init__(self, root: Path, dispatcher: Dispatcher): | |
| self._observer = Observer() | |
| self._observer.schedule(_Handler(dispatcher), str(root), recursive=True) | |
| def start(self): self._observer.start() | |
| def stop(self): self._observer.stop() | |
| ''') | |
| with open(sync, "w") as f: | |
| f.write('''class CloudSync: | |
| def push_shard(self, shard_id: str): ... | |
| def pull_shard(self, shard_id: str): ... | |
| ''') | |
| with open(treesitter, "w") as f: | |
| f.write('''"""Thin wrapper for Tree-sitter (stub).""" | |
| class TreeSitterWrapper: | |
| def parse_file(self, path): | |
| ... | |
| ''') | |
| # Plugins | |
| for lang in plugins: | |
| dir_path = f"{BASE}/plugins/{lang}_plugin" | |
| os.makedirs(dir_path, exist_ok=True) | |
| with open(f"{dir_path}/plugin.py", "w") as f: | |
| f.write(f'''from pathlib import Path | |
| from ...plugin_base import IPlugin, IndexShard, SymbolDef, Reference, SearchResult, SearchOpts | |
| class Plugin(IPlugin): | |
| lang = "{lang}" | |
| def supports(self, path: str | Path) -> bool: | |
| """Return True if file extension matches plugin.""" | |
| ... | |
| def indexFile(self, path: str | Path, content: str) -> IndexShard: | |
| """Parse the file and return an index shard.""" | |
| ... | |
| def getDefinition(self, symbol: str) -> SymbolDef | None: | |
| """Return the definition of a symbol, if known.""" | |
| ... | |
| def findReferences(self, symbol: str) -> list[Reference]: | |
| """List all references to a symbol.""" | |
| ... | |
| def search(self, query: str, opts: SearchOpts | None = None) -> list[SearchResult]: | |
| """Search for code snippets matching a query.""" | |
| ... | |
| ''') | |
| print("✅ Code scaffold complete. You can now commit your work.") |
Xet Storage Details
- Size:
- 5.51 kB
- Xet hash:
- 55d4ada2764b5f4b5d1825294dd6f402c7a379c840b9f412be1265ed2a1011c6
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.