code-graph-builder 0.2.0__py3-none-any.whl

code_graph_builder/examples/graph_export_example.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from loguru import logger
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from codebase_rag import cli_help as ch
+from codebase_rag import logs
+from codebase_rag.constants import (
+    DEFAULT_NAME,
+    KEY_EXPORTED_AT,
+    KEY_METADATA,
+    KEY_NAME,
+    KEY_NODE_LABELS,
+    KEY_RELATIONSHIP_TYPES,
+    KEY_TOTAL_NODES,
+    KEY_TOTAL_RELATIONSHIPS,
+    NodeLabel,
+)
+from codebase_rag.graph_loader import GraphLoader, load_graph
+from codebase_rag.types_defs import GraphSummary
+
+
+def log_summary(summary: GraphSummary) -> None:
+    logger.info(logs.GRAPH_SUMMARY)
+    logger.info(logs.GRAPH_TOTAL_NODES.format(count=summary.get(KEY_TOTAL_NODES, 0)))
+    logger.info(
+        logs.GRAPH_TOTAL_RELS.format(count=summary.get(KEY_TOTAL_RELATIONSHIPS, 0))
+    )
+    if KEY_METADATA in summary and KEY_EXPORTED_AT in summary[KEY_METADATA]:
+        logger.info(
+            logs.GRAPH_EXPORTED_AT.format(
+                timestamp=summary[KEY_METADATA][KEY_EXPORTED_AT]
+            )
+        )
+
+
+def log_node_and_relationship_types(summary: GraphSummary) -> None:
+    logger.info(logs.GRAPH_NODE_TYPES)
+    for label, count in summary.get(KEY_NODE_LABELS, {}).items():
+        logger.info(logs.GRAPH_NODE_COUNT.format(label=label, count=count))
+
+    logger.info(logs.GRAPH_REL_TYPES)
+    for rel_type, count in summary.get(KEY_RELATIONSHIP_TYPES, {}).items():
+        logger.info(logs.GRAPH_REL_COUNT.format(rel_type=rel_type, count=count))
+
+
+def log_example_nodes(graph: GraphLoader, node_label: str, limit: int = 5) -> None:
+    nodes = graph.find_nodes_by_label(node_label)
+    logger.info(logs.GRAPH_FOUND_NODES.format(count=len(nodes), label=node_label))
+
+    if nodes:
+        logger.info(logs.GRAPH_EXAMPLE_NAMES.format(label=node_label))
+        for node in nodes[:limit]:
+            name = node.properties.get(KEY_NAME, DEFAULT_NAME)
+            logger.info(logs.GRAPH_EXAMPLE_NAME.format(name=name))
+        if len(nodes) > limit:
+            logger.info(logs.GRAPH_MORE_NODES.format(count=len(nodes) - limit))
+
+
+def analyze_graph(graph_file: str) -> None:
+    logger.info(logs.GRAPH_ANALYZING.format(path=graph_file))
+
+    try:
+        _perform_graph_analysis(graph_file)
+    except Exception as e:
+        logger.error(logs.GRAPH_ANALYSIS_ERROR.format(error=e))
+        sys.exit(1)
+
+
+def _perform_graph_analysis(graph_file: str) -> None:
+    graph = load_graph(graph_file)
+    summary = graph.summary()
+
+    log_summary(summary)
+    log_node_and_relationship_types(summary)
+
+    log_example_nodes(graph, NodeLabel.FUNCTION)
+    log_example_nodes(graph, NodeLabel.CLASS)
+
+    logger.success(logs.GRAPH_ANALYSIS_COMPLETE)
+
+
+def main(
+    graph_file: Annotated[Path, typer.Argument(help=ch.HELP_EXPORTED_GRAPH_FILE)],
+) -> None:
+    if not graph_file.exists():
+        logger.error(logs.GRAPH_FILE_NOT_FOUND.format(path=graph_file))
+        raise typer.Exit(1)
+
+    analyze_graph(str(graph_file))
+
+
+if __name__ == "__main__":
+    typer.run(main)

code_graph_builder/examples/rag_example.py

@@ -0,0 +1,206 @@
+"""Example usage of the RAG module for code analysis.
+
+This example demonstrates how to use the RAG module to:
+1. Query code using natural language
+2. Explain specific code entities
+3. Analyze module architecture
+4. Use CAMEL agents for specialized analysis
+
+Prerequisites:
+    - Set MOONSHOT_API_KEY environment variable
+    - Have a code graph built with code_graph_builder
+    - Have embeddings generated in vector store
+
+Example:
+    export MOONSHOT_API_KEY="sk-xxxxx"
+    uv run examples/rag_example.py
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from code_graph_builder.embeddings import create_embedder, create_vector_store
+from code_graph_builder.rag import (
+    RAGConfig,
+    RAGEngine,
+    create_rag_engine,
+)
+from code_graph_builder.rag.camel_agent import CamelAgent, MultiAgentRAG
+from code_graph_builder.services import MemgraphIngestor
+
+
+def setup_rag_engine() -> RAGEngine:
+    """Set up the RAG engine with configuration."""
+    # Load configuration from environment
+    config = RAGConfig.from_env()
+    config.validate()
+
+    print(f"Using model: {config.moonshot.model}")
+    print(f"Semantic top-k: {config.retrieval.semantic_top_k}")
+
+    # Create embedder and vector store
+    embedder = create_embedder()
+    vector_store = create_vector_store(
+        backend="memory",
+        dimension=embedder.get_embedding_dimension(),
+    )
+
+    # Connect to graph database
+    graph_service = MemgraphIngestor(
+        host=os.getenv("MEMGRAPH_HOST", "localhost"),
+        port=int(os.getenv("MEMGRAPH_PORT", "7687")),
+    )
+
+    # Create RAG engine
+    engine = create_rag_engine(
+        config=config,
+        embedder=embedder,
+        vector_store=vector_store,
+        graph_service=graph_service,
+    )
+
+    return engine
+
+
+def example_natural_language_query(engine: RAGEngine) -> None:
+    """Example: Query code using natural language."""
+    print("\n" + "=" * 60)
+    print("Example 1: Natural Language Query")
+    print("=" * 60)
+
+    query = "How does the authentication system work?"
+    print(f"\nQuery: {query}")
+
+    result = engine.query(query, top_k=5)
+
+    print(f"\nResponse:\n{result.response}")
+    print(f"\nSources used:")
+    for source in result.sources:
+        print(f"  - {source.qualified_name} ({source.file_path})")
+
+    # Save result to file
+    output_path = engine.save_result(result)
+    print(f"\nSaved to: {output_path}")
+
+
+def example_explain_code(engine: RAGEngine) -> None:
+    """Example: Explain a specific code entity."""
+    print("\n" + "=" * 60)
+    print("Example 2: Explain Code Entity")
+    print("=" * 60)
+
+    # Example qualified name - adjust to your codebase
+    qualified_name = "code_graph_builder.rag.rag_engine.RAGEngine.query"
+    print(f"\nExplaining: {qualified_name}")
+
+    result = engine.explain_code(qualified_name, include_related=True)
+
+    print(f"\nExplanation:\n{result.response}")
+
+
+def example_architecture_analysis(engine: RAGEngine) -> None:
+    """Example: Analyze module architecture."""
+    print("\n" + "=" * 60)
+    print("Example 3: Architecture Analysis")
+    print("=" * 60)
+
+    module_name = "code_graph_builder.rag"
+    print(f"\nAnalyzing module: {module_name}")
+
+    result = engine.analyze_architecture(module_name)
+
+    print(f"\nArchitecture Analysis:\n{result.response}")
+
+
+def example_camel_agent() -> None:
+    """Example: Use CAMEL agent for code review."""
+    print("\n" + "=" * 60)
+    print("Example 4: CAMEL Agent Code Review")
+    print("=" * 60)
+
+    # Create a specialized agent
+    agent = CamelAgent(
+        role="Senior Python Developer",
+        goal="Review code for best practices and potential issues",
+        backstory="10+ years of Python development experience, expert in clean code",
+    )
+
+    # Code to review
+    code = """
+def process_data(data):
+    result = []
+    for i in range(len(data)):
+        if data[i] > 0:
+            result.append(data[i] * 2)
+    return result
+"""
+
+    print("\nCode to review:")
+    print(code)
+
+    # Run review
+    response = agent.review_code(code, review_type="general")
+    print(f"\nReview:\n{response.content}")
+
+    # Get improvement suggestions
+    suggestions = agent.suggest_improvements(
+        code,
+        focus_areas=["readability", "performance"],
+    )
+    print(f"\nSuggestions:\n{suggestions.content}")
+
+
+def example_multi_agent_analysis(engine: RAGEngine) -> None:
+    """Example: Multi-agent comprehensive analysis."""
+    print("\n" + "=" * 60)
+    print("Example 5: Multi-Agent Analysis")
+    print("=" * 60)
+
+    # Create multi-agent system
+    multi_agent = MultiAgentRAG(engine)
+
+    query = "Explain the RAG engine implementation"
+    print(f"\nQuery: {query}")
+
+    # Run multi-agent analysis
+    results = multi_agent.analyze(
+        query=query,
+        analysis_types=["architecture", "docs"],
+    )
+
+    for agent_type, response in results.items():
+        print(f"\n--- {agent_type.upper()} ANALYSIS ---")
+        print(response.content[:500] + "..." if len(response.content) > 500 else response.content)
+
+
+def main() -> None:
+    """Run all examples."""
+    print("RAG Module Examples")
+    print("===================")
+
+    # Check API key
+    if not os.getenv("MOONSHOT_API_KEY"):
+        print("\nError: MOONSHOT_API_KEY environment variable not set")
+        print("Please set it before running: export MOONSHOT_API_KEY='your-key'")
+        return
+
+    try:
+        # Set up RAG engine
+        engine = setup_rag_engine()
+
+        # Run examples
+        example_natural_language_query(engine)
+        example_explain_code(engine)
+        example_architecture_analysis(engine)
+        example_camel_agent()
+        example_multi_agent_analysis(engine)
+
+    except Exception as e:
+        print(f"\nError: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    main()

code_graph_builder/examples/test_cli_demo.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""Demonstration of Code Graph Builder CLI.
+
+This script shows all CLI commands without actually running them.
+For actual usage, run the commands directly in your terminal.
+"""
+
+import subprocess
+import sys
+
+
+def run_command(cmd: str, description: str) -> None:
+    """Print command description and the command itself."""
+    print("=" * 80)
+    print(f"{description}")
+    print("=" * 80)
+    print(f"$ {cmd}")
+    print()
+
+
+def main():
+    """Show CLI examples."""
+    repo_path = "/Users/jiaojeremy/CodeFile/tinycc"
+    db_path = "/tmp/demo_graph.db"
+
+    print("Code Graph Builder - CLI 演示")
+    print()
+    print("注意: 以下只是命令示例，不会实际执行")
+    print("在实际终端中运行这些命令来体验完整功能")
+    print()
+
+    # 1. Help
+    run_command(
+        "code-graph-builder --help",
+        "1. 查看帮助信息"
+    )
+
+    # 2. Scan
+    run_command(
+        f"code-graph-builder scan {repo_path} --db-path {db_path} --clean",
+        "2. 扫描代码仓库"
+    )
+
+    run_command(
+        f"code-graph-builder scan {repo_path} \\\n"
+        f"  --db-path {db_path} \\\n"
+        f"  --exclude tests,win32,examples \\\n"
+        f"  --language c \\\n"
+        f"  --clean",
+        "3. 扫描（带过滤选项）"
+    )
+
+    # 3. Query
+    run_command(
+        f"code-graph-builder query \\\n"
+        f'  "MATCH (f:Function) RETURN f.name LIMIT 10" \\\n'
+        f"  --db-path {db_path}",
+        "4. 查询函数"
+    )
+
+    run_command(
+        f"code-graph-builder query \\\n"
+        f'  "MATCH (caller:Function)-[:CALLS]->(callee:Function) \\\n'
+        f'   WHERE callee.name = \\\'parse_expr\\\' \\\n'
+        f'   RETURN caller.name" \\\n'
+        f"  --db-path {db_path}",
+        "5. 查询调用关系"
+    )
+
+    # 4. Stats
+    run_command(
+        f"code-graph-builder stats --db-path {db_path}",
+        "6. 查看统计信息"
+    )
+
+    # 5. Export
+    run_command(
+        f"code-graph-builder export {repo_path} \\\n"
+        f"  --output /tmp/graph.json \\\n"
+        f"  --build \\\n"
+        f"  --exclude tests",
+        "7. 导出为 JSON"
+    )
+
+    # 6. Using config file
+    run_command(
+        f"code-graph-builder scan {repo_path} \\\n"
+        f"  --config code-graph-builder.example.yaml",
+        "8. 使用配置文件"
+    )
+
+    print("=" * 80)
+    print("实际运行测试")
+    print("=" * 80)
+    print()
+
+    # Actually run a quick test
+    print("运行: code-graph-builder --version")
+    result = subprocess.run(
+        [sys.executable, "-m", "code_graph_builder.cli", "--version"],
+        capture_output=True,
+        text=True
+    )
+    print(result.stdout or result.stderr)
+
+    print("运行: code-graph-builder stats --help")
+    result = subprocess.run(
+        [sys.executable, "-m", "code_graph_builder.cli", "stats", "--help"],
+        capture_output=True,
+        text=True
+    )
+    print(result.stdout)
+    print()
+
+    print("=" * 80)
+    print("CLI 演示完成!")
+    print("=" * 80)
+    print()
+    print("快速参考:")
+    print("  code-graph-builder scan <repo> --db-path <path>  # 扫描代码")
+    print("  code-graph-builder query '<cypher>'               # 查询")
+    print("  code-graph-builder stats                          # 统计")
+    print("  code-graph-builder export <repo> -o <file>        # 导出")
+    print()
+    print("详细文档: CLI.md")
+
+
+if __name__ == "__main__":
+    main()

code_graph_builder/examples/test_embedding_api.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""Example: Test Qwen3 Embedding via Alibaba Cloud Bailian API.
+
+This script demonstrates how to use the API-based Qwen3 embedder.
+
+Prerequisites:
+    1. Set your API key:
+       export DASHSCOPE_API_KEY="sk-xxxxx"
+
+    2. Or create a .env file in the project root with:
+       DASHSCOPE_API_KEY=sk-xxxxx
+
+Usage:
+    python examples/test_embedding_api.py
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from dotenv import load_dotenv
+from loguru import logger
+
+# Load environment variables from .env file
+load_dotenv(Path(__file__).parent.parent / ".env")
+
+
+def test_embedder() -> None:
+    """Test the Qwen3 embedder with API."""
+    from code_graph_builder.embeddings.qwen3_embedder import Qwen3Embedder, create_embedder
+
+    # Check API key
+    api_key = os.getenv("DASHSCOPE_API_KEY")
+    if not api_key:
+        logger.error("DASHSCOPE_API_KEY not set!")
+        logger.info("Please set your API key:")
+        logger.info("  export DASHSCOPE_API_KEY='sk-xxxxx'")
+        sys.exit(1)
+
+    logger.info(f"API Key found: {api_key[:10]}...")
+
+    # Create embedder
+    logger.info("Creating Qwen3 embedder...")
+    embedder = create_embedder()
+
+    # Health check
+    logger.info("Running health check...")
+    if embedder.health_check():
+        logger.success("✓ API is accessible")
+    else:
+        logger.error("✗ API health check failed")
+        sys.exit(1)
+
+    # Test single embedding
+    logger.info("\nTesting single code embedding...")
+    code = """
+def fibonacci(n):
+    if n <= 1:
+        return n
+    return fibonacci(n-1) + fibonacci(n-2)
+"""
+
+    try:
+        embedding = embedder.embed_code(code)
+        logger.success(f"✓ Generated embedding with {len(embedding)} dimensions")
+        logger.info(f"  First 5 values: {embedding[:5]}")
+    except Exception as e:
+        logger.error(f"✗ Failed to generate embedding: {e}")
+        sys.exit(1)
+
+    # Test batch embedding
+    logger.info("\nTesting batch embedding...")
+    codes = [
+        "def add(a, b): return a + b",
+        "class Calculator:\n    def multiply(self, x, y):\n        return x * y",
+        "import os\nprint(os.getcwd())",
+    ]
+
+    try:
+        embeddings = embedder.embed_batch(codes, show_progress=True)
+        logger.success(f"✓ Generated {len(embeddings)} embeddings")
+        for i, emb in enumerate(embeddings):
+            logger.info(f"  Code {i+1}: {len(emb)} dimensions")
+    except Exception as e:
+        logger.error(f"✗ Failed to generate batch embeddings: {e}")
+        sys.exit(1)
+
+    # Test query embedding (with instruction)
+    logger.info("\nTesting query embedding (with instruction)...")
+    query = "functions that calculate Fibonacci numbers"
+
+    try:
+        query_embedding = embedder.embed_query(query)
+        logger.success(f"✓ Generated query embedding with {len(query_embedding)} dimensions")
+    except Exception as e:
+        logger.error(f"✗ Failed to generate query embedding: {e}")
+        sys.exit(1)
+
+    logger.info("\n" + "=" * 50)
+    logger.success("All tests passed! ✓")
+    logger.info("=" * 50)
+
+
+def test_vector_store() -> None:
+    """Test the vector store with embeddings."""
+    from code_graph_builder.embeddings.qwen3_embedder import create_embedder
+    from code_graph_builder.embeddings.vector_store import create_vector_store
+
+    logger.info("\nTesting Vector Store...")
+
+    # Create embedder and vector store
+    embedder = create_embedder()
+    vector_store = create_vector_store(backend="memory", dimension=1536)
+
+    # Store some embeddings
+    codes = [
+        (1, "def add(a, b): return a + b"),
+        (2, "def subtract(a, b): return a - b"),
+        (3, "class Calculator:\n    def multiply(self, x, y): return x * y"),
+    ]
+
+    logger.info("Storing embeddings...")
+    for node_id, code in codes:
+        embedding = embedder.embed_code(code)
+        vector_store.store_embedding(
+            node_id=node_id,
+            qualified_name=f"module.function_{node_id}",
+            embedding=embedding,
+        )
+
+    stats = vector_store.get_stats()
+    logger.success(f"✓ Stored {stats['count']} embeddings")
+
+    # Search
+    logger.info("\nSearching for similar code...")
+    query = "addition function"
+    query_embedding = embedder.embed_query(query)
+
+    results = vector_store.search_similar(query_embedding, top_k=3)
+
+    logger.success(f"✓ Found {len(results)} results:")
+    for i, result in enumerate(results, 1):
+        logger.info(f"  {i}. {result.qualified_name} (score: {result.score:.4f})")
+
+
+if __name__ == "__main__":
+    test_embedder()
+    test_vector_store()