agent-codinglanguage-mapper 1.0.0__py3-none-any.whl

agent_codinglanguage_mapper/cli.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Sequence
+
+from .integration import install_opencode, install_skill
+from .mapper import CodebaseMapper
+from .models import Language
+from .rendering import layer_data, render_markdown, write_index
+from .worker import serve_worker
+
+
+LAYERS = (
+    "overview",
+    "projects",
+    "languages",
+    "files",
+    "file",
+    "symbols",
+    "symbol",
+    "implementation",
+    "references",
+    "problems",
+)
+
+
+def _root_argument(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--root", type=Path, default=Path("."))
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="codinglanguage-mapper")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    view = subparsers.add_parser("view", help="Render a layered codebase view.")
+    _root_argument(view)
+    view.add_argument("--project-file", type=Path)
+    view.add_argument("--layer", choices=LAYERS, required=True)
+    view.add_argument("--query", default="")
+    view.add_argument("--format", choices=("json", "markdown"), default="markdown")
+    view.add_argument("--language", dest="languages", action="append", choices=[item.value for item in Language])
+
+    index = subparsers.add_parser("index", help="Materialize a codebase index.")
+    _root_argument(index)
+    index.add_argument("--out", type=Path, default=Path(".codinglanguage-mapper/index/index.json"))
+
+    doctor = subparsers.add_parser("doctor", help="Report discovery and parser readiness.")
+    _root_argument(doctor)
+    doctor.add_argument("--format", choices=("json", "text"), default="text")
+
+    lsp = subparsers.add_parser("lsp", help="Start the multi-language LSP server.")
+    _root_argument(lsp)
+
+    worker = subparsers.add_parser("worker", help="Serve Protocol 3 NDJSON requests.")
+    _root_argument(worker)
+    worker.add_argument("--project-file", type=Path)
+
+    skill = subparsers.add_parser("skill", help="Install agent skills.")
+    skill_subparsers = skill.add_subparsers(dest="skill_command", required=True)
+    skill_install = skill_subparsers.add_parser("install")
+    skill_install.add_argument("--target", type=Path, default=Path("."))
+    skill_install.add_argument("--force", action="store_true")
+
+    opencode = subparsers.add_parser("opencode", help="Install OpenCode integration.")
+    opencode_subparsers = opencode.add_subparsers(dest="opencode_command", required=True)
+    opencode_install = opencode_subparsers.add_parser("install")
+    opencode_install.add_argument("--target", type=Path, default=Path("."))
+    opencode_install.add_argument("--python", default=sys.executable)
+    opencode_install.add_argument("--force", action="store_true")
+    opencode_install.add_argument("--write", "--write-config", dest="write_config", action="store_true")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    if args.command == "lsp":
+        from .lsp_server import main as lsp_main
+
+        os.chdir(args.root.expanduser().resolve())
+        lsp_main()
+        return 0
+    if args.command == "worker":
+        return serve_worker(args.root, sys.stdin, sys.stdout)
+    if args.command == "skill":
+        path = install_skill(args.target, force=args.force)
+        print(path)
+        return 0
+    if args.command == "opencode":
+        paths = install_opencode(
+            args.target,
+            python_executable=args.python,
+            force=args.force,
+            write_config=args.write_config,
+        )
+        print(json.dumps({"installed": [str(path) for path in paths]}, sort_keys=True))
+        return 0
+
+    with CodebaseMapper.open(args.root) as mapper:
+        if args.command == "view":
+            languages = tuple(Language(item) for item in (args.languages or ()))
+            data = layer_data(mapper, args.layer, query=args.query, languages=languages)
+            if args.format == "json":
+                print(json.dumps(data, indent=2, sort_keys=True))
+            else:
+                print(render_markdown(data, title=args.layer.replace("_", " ").title()), end="")
+            return 0
+        if args.command == "index":
+            path = write_index(mapper, args.out)
+            print(json.dumps({"path": str(path), "revision": mapper.snapshot.revision}, sort_keys=True))
+            return 0
+        report = _doctor_report(mapper)
+        if args.format == "json":
+            print(json.dumps(report, indent=2, sort_keys=True))
+        else:
+            status = "ready" if report["ok"] else "problems"
+            print(f"status: {status}")
+            print("languages: " + ", ".join(item.value for item in Language))
+            print(f"files: {report['files']}")
+            print(f"errors: {report['errors']}")
+        return 0 if report["ok"] else 1
+
+
+def _doctor_report(mapper: CodebaseMapper) -> dict[str, object]:
+    errors = [item for item in mapper.snapshot.problems if item.severity == "error"]
+    return {
+        "ok": not errors,
+        "workspace": str(mapper.root),
+        "revision": mapper.snapshot.revision,
+        "languages": [item.value for item in Language],
+        "files": len(mapper.snapshot.files),
+        "symbols": len(mapper.snapshot.symbols),
+        "problems": len(mapper.snapshot.problems),
+        "errors": len(errors),
+    }