codegraph-ai 0.2.2__tar.gz → 0.3.0__tar.gz

{codegraph_ai-0.2.2 → codegraph_ai-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraph-ai
-Version: 0.2.2
+Version: 0.3.0
 Summary: Hybrid graph + vector code intelligence powered by NeuG and zvec
 Requires-Python: >=3.10
 Requires-Dist: neug
@@ -8,6 +8,9 @@ Requires-Dist: zvec
 Requires-Dist: tree-sitter-language-pack
 Requires-Dist: sentence-transformers
 Requires-Dist: numpy
+Requires-Dist: jinja2
+Requires-Dist: pyyaml
+Requires-Dist: click
 Provides-Extra: server
 Requires-Dist: fastmcp; extra == "server"
 Provides-Extra: dev

{codegraph_ai-0.2.2 → codegraph_ai-0.3.0}/codegraph/cli.py

@@ -164,6 +164,7 @@ def cmd_init(args: argparse.Namespace) -> None:
         print()
         print(f"Use 'codegraph status' to see detailed state.")
         print(f"Use 'codegraph query \"<question>\"' to ask questions.")
+        print(f"Use 'codegraph pr-review prepare' to review pull requests.")
     finally:
         cs.close()
 
@@ -522,6 +523,192 @@ def cmd_server(args: argparse.Namespace) -> None:
     mcp.run()
 
 
+def cmd_pr_review(args: argparse.Namespace) -> None:
+    """Dispatch to pr-review prepare or pr-review label."""
+    action = getattr(args, 'pr_action', None)
+    if action == 'label':
+        cmd_pr_review_label(args)
+    elif action == 'prepare':
+        cmd_pr_review_prepare(args)
+    else:
+        # No subcommand given
+        print("Error: 'pr-review' requires a subcommand: 'prepare' for analysis or 'label' for labeling. Note that 'prepare' must be run before 'label'.")
+        print("  Usage: codegraph pr-review prepare --db .codegraph")
+        print("         codegraph pr-review label --db .codegraph")
+        sys.exit(1)
+
+
+def cmd_pr_review_prepare(args: argparse.Namespace) -> None:
+    """Analyze PRs + detect conflicts + write to graph DB (full rebuild)."""
+    from codegraph.pr_review import run_prepare
+
+    repo_dir = _derive_repo_dir(args.db)
+
+    # Use explicit --repo or auto-detect from git remote
+    repo_name = args.repo
+    if not repo_name:
+        repo_name = _auto_detect_repo(None, repo_dir)
+        if not repo_name:
+            print("Error: Cannot auto-detect GitHub repo from git remote. Specify --repo owner/repo")
+            return
+
+    run_prepare(
+        db_dir=args.db,
+        repo_dir=repo_dir,
+        repo=repo_name,
+        author=getattr(args, 'author', ''),
+        output_dir=getattr(args, 'output', None),
+        skip_single_pr=getattr(args, 'skip_single_pr', False),
+    )
+
+
+def cmd_pr_review_label(args: argparse.Namespace) -> None:
+    """Apply GitHub labels + post conflict comments from graph DB."""
+    from codegraph.pr_review import run_label
+
+    repo_dir = _derive_repo_dir(args.db)
+
+    # Use explicit --repo or auto-detect from git remote
+    repo_name = args.repo
+    if not repo_name:
+        repo_name = _auto_detect_repo(None, repo_dir)
+        if not repo_name:
+            print("Error: Cannot auto-detect GitHub repo from git remote. Specify --repo owner/repo")
+            return
+
+    run_label(
+        db_dir=args.db,
+        repo_dir=repo_dir,
+        repo=repo_name,
+        dry_run=getattr(args, 'dry_run', False),
+    )
+
+
+def _auto_detect_repo(repo_arg, repo_dir: str) -> str | None:
+    """Auto-detect GitHub repo (owner/repo) from git remote if not specified."""
+    if repo_arg:
+        return repo_arg
+    import subprocess
+    try:
+        result = subprocess.run(
+            ['git', 'remote', 'get-url', 'origin'],
+            cwd=repo_dir, capture_output=True, text=True
+        )
+        if result.returncode == 0:
+            remote_url = result.stdout.strip()
+            import re
+            m = re.match(r'(?:https?://github\.com/|git@github\.com:)([^/]+/[^/]+?)(?:\.git)?$', remote_url)
+            if m:
+                detected = m.group(1)
+                print(f"[auto] --repo not specified, detected from remote: {detected}")
+                return detected
+    except Exception:
+        pass
+    return None
+
+
+def _derive_repo_dir(db_path: str) -> str:
+    """Derive the local repository path from the --db directory.
+
+    When --db points to ``<repo>/.codegraph``, returns ``<repo>``;
+    otherwise falls back to the current working directory.
+    """
+    abs_db = os.path.abspath(db_path)
+    if os.path.basename(abs_db) == '.codegraph':
+        return os.path.dirname(abs_db)
+    return os.getcwd()
+
+
+def cmd_explore(args: argparse.Namespace) -> None:
+    """Run guided exploration with interactive question answering."""
+    db_dir = _find_db(args.db)
+
+    if not os.path.isdir(db_dir):
+        print(f"Error: database not found at {db_dir}", file=sys.stderr)
+        print(f"Run 'codegraph init' first.", file=sys.stderr)
+        sys.exit(1)
+
+    cs = _open_cs(db_dir)
+    try:
+        from codegraph.guided_explorer import (
+            InteractiveExplorer,
+            PatternDetector,
+            QuestionGenerator,
+        )
+
+        # ── General exploration mode ───────────────────────────────────────
+        print("\nDetecting code patterns...")
+        detector = PatternDetector(neug_conn=cs.conn)
+        patterns = detector.detect_all_patterns(cs.conn)
+
+        if not patterns:
+            print("\nNo significant patterns detected. Your codebase appears healthy!")
+            return
+
+        print(f"Found {len(patterns)} patterns")
+
+        # Pre-filter patterns by --type before question generation,
+        # so that rare categories (e.g. pr-review) aren't truncated by top_n
+        if args.type != 'all':
+            from codegraph.models import PatternType
+            _TYPE_TO_PATTERN_TYPES = {
+                'architecture': {PatternType.CYCLIC_DEPENDENCY, PatternType.HIGH_COUPLING,
+                                 PatternType.ISOLATED_MODULE, PatternType.STABLE_CORE},
+                'risk': {PatternType.HIGH_FAN_IN, PatternType.HIGH_IMPACT_PR,
+                         PatternType.PR_NO_TEST, PatternType.PR_INTERFACE_CHANGE,
+                         PatternType.PR_DEAD_CODE},
+                'evolution': {PatternType.EVOLUTION_HOTSPOT, PatternType.STABLE_CORE},
+                'hotspot': {PatternType.HIGH_FAN_IN, PatternType.EVOLUTION_HOTSPOT},
+                'pr-review': {PatternType.HIGH_IMPACT_PR, PatternType.PR_CONFLICT,
+                                PatternType.PR_NO_TEST, PatternType.PR_INTERFACE_CHANGE,
+                                PatternType.PR_CROSS_MODULE, PatternType.PR_DEAD_CODE},
+            }
+            target_types = _TYPE_TO_PATTERN_TYPES.get(args.type)
+            if target_types:
+                patterns = [p for p in patterns if p.pattern_type in target_types]
+
+        # Generate questions
+        print("\nGenerating guided questions...")
+        generator = QuestionGenerator()
+        questions = generator.generate_questions(
+            patterns,
+            role=args.role,
+            top_n=args.top if args.top else 10,
+        )
+
+        # Filter by --type (based on question category) — secondary filter
+        if args.type != 'all' and questions:
+            from codegraph.models import QuestionCategory
+            _TYPE_TO_CATEGORY = {
+                'architecture': QuestionCategory.ARCHITECTURE,
+                'risk': QuestionCategory.RISK,
+                'evolution': QuestionCategory.EVOLUTION,
+                'hotspot': QuestionCategory.HOTSPOT,
+                'pr-review': QuestionCategory.PR_IMPACT,
+            }
+            target_cat = _TYPE_TO_CATEGORY[args.type]
+            questions = [q for q in questions if q.category == target_cat]
+
+        if not questions:
+            print(f"\nNo {args.type} questions generated from detected patterns.")
+            return
+
+        print(f"Generated {len(questions)} questions (type={args.type})")
+
+        # Run exploration
+        explorer = InteractiveExplorer(codescope_instance=cs, neug_conn=cs.conn)
+
+        if args.top:
+            # Non-interactive mode: just show top N questions
+            explorer.run_non_interactive(questions, top_n=args.top)
+        else:
+            # Interactive mode
+            explorer.run_interactive_session(questions)
+
+    finally:
+        cs.close()
+
+
 # =========================================================================
 # Main
 # =========================================================================
@@ -611,6 +798,35 @@ def main() -> None:
     p_server.add_argument("--db", default=None, help=f"Database directory (default: {DB_DEFAULT})")
     p_server.add_argument("--repo", default=None, help="Path to repository")
 
+    # -- pr-review --
+    p_pr = sub.add_parser("pr-review", help="PR review: prepare (analyze + write to DB) or label (apply labels + comments)")
+    p_pr_sub = p_pr.add_subparsers(dest="pr_action")
+
+    # pr-review prepare
+    p_pr_prepare = p_pr_sub.add_parser("prepare", help="Analyze PRs + detect conflicts + write to graph DB (full rebuild)")
+    p_pr_prepare.add_argument("--db", required=True, help="Path to the codegraph database directory")
+    p_pr_prepare.add_argument("--repo", default=None, help="GitHub repository in owner/repo format (default: auto-detect from git remote)")
+    p_pr_prepare.add_argument('--author', default="", help="Filter PRs by GitHub login")
+    p_pr_prepare.add_argument('--output', default=None, help="Output directory for HTML/MD files")
+    p_pr_prepare.add_argument('--skip-single-pr', action='store_true',
+                              help="Skip per-PR risk scoring; only cross-PR conflict analysis")
+
+    # pr-review label
+    p_pr_label = p_pr_sub.add_parser("label", help="Apply GitHub labels + post conflict comments from graph DB")
+    p_pr_label.add_argument("--db", required=True, help="Path to the codegraph database directory")
+    p_pr_label.add_argument("--repo", default=None, help="GitHub repository in owner/repo format (default: auto-detect from git remote)")
+    p_pr_label.add_argument('--dry-run', action='store_true', help="Preview labels and comments without making API calls")
+
+    # -- explore --
+    p_explore = sub.add_parser("explore", help="Guided exploration with interactive questions (incl. PR follow-ups)")
+    p_explore.add_argument("--db", default=None, help=f"Database directory (default: {DB_DEFAULT})")
+    p_explore.add_argument("--role", default="architect",
+                          help="User role: architect, maintainer, reviewer (default: architect)")
+    p_explore.add_argument("--top", type=int, default=None,
+                          help="Show top N questions (non-interactive mode)")
+    p_explore.add_argument("--type", choices=['all', 'architecture', 'risk', 'evolution', 'hotspot', 'pr-review'], default='all',
+                          help="Question type filter: all (default), architecture, risk, evolution, hotspot, pr-review")
+
     args = parser.parse_args()
 
     if not args.command:
@@ -629,6 +845,8 @@ def main() -> None:
         "analyze-bug": cmd_analyze_bug,
         "analyze-bugs": cmd_analyze_bugs,
         "server": cmd_server,
+        "pr-review": cmd_pr_review,
+        "explore": cmd_explore,
     }
     dispatch[args.command](args)