graphrag-codeproperty-graph 0.4.4__tar.gz → 0.5.0__tar.gz

{graphrag_codeproperty_graph-0.4.4 → graphrag_codeproperty_graph-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: graphrag-codeproperty-graph
-Version: 0.4.4
+Version: 0.5.0
 Summary: Code Property Graphs — Joern/Semgrep extraction, AI vulnerability enrichment, risk scoring
 Project-URL: Repository, https://github.com/kanjani-ai-research/codeproperty-graph
 Author-email: Evan Erwee <evan@erwee.com>
@@ -13,7 +13,8 @@ Classifier: Intended Audience :: Developers
 Classifier: Topic :: Security
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.11
-Requires-Dist: graphrag-document-graph>=3.0.9
+Requires-Dist: boto3>=1.28.0
+Requires-Dist: graphrag-document-graph>=3.1.1
 Provides-Extra: dev
 Requires-Dist: black; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'

graphrag_codeproperty_graph-0.5.0/examples/README.md

@@ -0,0 +1,45 @@
+# Code Property Graph Examples
+
+Example notebooks for `codeproperty-graph` — delta-aware code analysis ingestion into Neptune.
+
+## Prerequisites
+
+- Amazon Neptune (DB or Analytics) for production notebooks
+- Python 3.10+
+- Joern (for generating real CPG exports; sample data provided for demos)
+
+## Setup
+
+```bash
+pip install codeproperty-graph
+```
+
+For Neptune integration:
+```bash
+pip install codeproperty-graph graphrag-toolkit-document-graph[graphrag,neptune]
+```
+
+## Notebooks
+
+| Notebook | Description | Neptune Required? |
+|----------|-------------|-------------------|
+| `01-CPG-Models-and-GraphDiff.ipynb` | Core models, method signatures, and diff comparison | No (local only) |
+| `02-Delta-Ingestion-Pipeline.ipynb` | Full pipeline: manifest → diff → skip/ingest decision | Optional (has mock mode) |
+
+## Sample Data
+
+`data/sample_nodes.json` — 8 CPG nodes (3 METHOD, 2 CALL, 2 IDENTIFIER, 1 LITERAL)
+`data/sample_edges.json` — 10 edges (AST, CFG, CALL, ARGUMENT)
+
+Represents a minimal Java project with `Main.main()`, `Parser.parse()`, and `Validator.validate()`.
+
+## Generating Real CPG Data
+
+```bash
+# Install Joern: https://joern.io
+joern-export --repr cpg14 --format json --out cpg-export/ /path/to/source
+
+# Output:
+#   cpg-export/nodes.json
+#   cpg-export/edges.json
+```

graphrag_codeproperty_graph-0.5.0/examples/notebooks/01-CPG-Models-and-GraphDiff.ipynb

@@ -0,0 +1,309 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# CPG Schema, Models, and Graph Diff\n",
+    "\n",
+    "This notebook demonstrates:\n",
+    "- The full Joern CPG schema (20 node types, 14+ edge types, 9 languages)\n",
+    "- Parsing Joern exports with `CPGNode.from_joern()` and `CPGEdge.from_joern()`\n",
+    "- Graph analysis: type distribution, call graph, structure\n",
+    "- Change detection with `GraphDiff`\n",
+    "\n",
+    "**Prerequisites:**\n",
+    "- `pip install graphrag-toolkit-codeproperty-graph`\n",
+    "- No Neptune or AWS credentials required\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. The CPG Schema\n",
+    "\n",
+    "Explore the complete Joern type system.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "from graphrag_toolkit.codeproperty_graph import (\n",
+    "    NodeType, EdgeType, DELTA_RELEVANT_TYPES, SUPPORTED_LANGUAGES,\n",
+    "    joern_export_command\n",
+    ")\n",
+    "\n",
+    "print(f'Node types ({len(NodeType)}):')\n",
+    "for nt in NodeType:\n",
+    "    marker = ' \u2605' if nt in DELTA_RELEVANT_TYPES else ''\n",
+    "    print(f'  {nt.value:20s}{marker}')\n",
+    "\n",
+    "print(f'\\nEdge types ({len(EdgeType)}):')\n",
+    "for et in EdgeType:\n",
+    "    print(f'  {et.value}')\n",
+    "\n",
+    "print(f'\\nSupported languages ({len(SUPPORTED_LANGUAGES)}):')\n",
+    "for lang, desc in SUPPORTED_LANGUAGES.items():\n",
+    "    print(f'  {lang:12s} {desc}')\n",
+    "\n",
+    "print(f'\\n\u2605 = participates in delta comparison')\n"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Joern Export Command\n",
+    "\n",
+    "Generate the CLI command to produce a CPG from source code.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "# Generate export commands for different languages\n",
+    "for lang in ['java', 'python', 'javascript']:\n",
+    "    cmd = joern_export_command('/src/my-service', output_dir='cpg-out', language=lang)\n",
+    "    print(f'{lang:12s} {cmd}')\n",
+    "\n",
+    "# Auto-detect language\n",
+    "print(f'{\"auto\":12s} {joern_export_command(\"/src/my-service\")}')\n"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Parse Joern Export with `from_joern()`\n",
+    "\n",
+    "Load raw Joern JSON and parse into typed CPGNode/CPGEdge objects.\n",
+    "The factory methods handle both UPPER_CASE and camelCase property formats.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "import json\n",
+    "from graphrag_toolkit.codeproperty_graph import CPGNode, CPGEdge\n",
+    "\n",
+    "with open('data/sample_nodes.json') as f:\n",
+    "    raw_nodes = json.load(f)\n",
+    "with open('data/sample_edges.json') as f:\n",
+    "    raw_edges = json.load(f)\n",
+    "\n",
+    "# Parse with from_joern()\n",
+    "nodes = [CPGNode.from_joern(raw) for raw in raw_nodes]\n",
+    "edges = [CPGEdge.from_joern(raw) for raw in raw_edges]\n",
+    "\n",
+    "print(f'Parsed {len(nodes)} nodes, {len(edges)} edges')\n"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Graph Analysis: Type Distribution\n",
+    "\n",
+    "See what node and edge types are in the graph.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "from collections import Counter\n",
+    "\n",
+    "# Node type distribution\n",
+    "node_types = Counter(n.node_type for n in nodes)\n",
+    "print('Node types:')\n",
+    "for ntype, count in node_types.most_common():\n",
+    "    print(f'  {ntype:20s} {count:3d}')\n",
+    "\n",
+    "# Edge type distribution\n",
+    "edge_types = Counter(e.edge_type for e in edges)\n",
+    "print(f'\\nEdge types:')\n",
+    "for etype, count in edge_types.most_common():\n",
+    "    print(f'  {etype:20s} {count:3d}')\n"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Explore Methods (Delta-Relevant Nodes)\n",
+    "\n",
+    "Only METHOD nodes participate in change detection.\n",
+    "Their `full_name \u2192 hash` mapping is the fingerprint for delta comparison.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "methods = [n for n in nodes if n.node_type == NodeType.METHOD]\n",
+    "\n",
+    "print(f'Methods ({len(methods)}):')\n",
+    "for m in methods:\n",
+    "    print(f'  {m.full_name}')\n",
+    "    print(f'    signature:  {m.signature}')\n",
+    "    print(f'    hash:       {m.hash}')\n",
+    "    print(f'    file:       {m.filename}:{m.line_number}-{m.line_number_end}')\n",
+    "    print(f'    external:   {m.is_external}')\n",
+    "    print()\n"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. Explore Structure (Classes, Files, Namespaces)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "from graphrag_toolkit.codeproperty_graph.schema import STRUCTURE_TYPES\n",
+    "\n",
+    "structure_nodes = [n for n in nodes if n.node_type in STRUCTURE_TYPES]\n",
+    "print(f'Structure nodes ({len(structure_nodes)}):')\n",
+    "for n in structure_nodes:\n",
+    "    print(f'  {n.node_type:16s} {n.full_name or n.name}')\n"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7. Call Graph\n",
+    "\n",
+    "Extract the CALL edges to see which methods call which.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "call_edges = [e for e in edges if e.edge_type == EdgeType.CALL]\n",
+    "node_map = {n.id: n for n in nodes}\n",
+    "\n",
+    "print(f'Call graph ({len(call_edges)} edges):')\n",
+    "for e in call_edges:\n",
+    "    src = node_map.get(e.source_id)\n",
+    "    tgt = node_map.get(e.target_id)\n",
+    "    src_name = src.full_name if src else e.source_id\n",
+    "    tgt_name = tgt.full_name if tgt else e.target_id\n",
+    "    print(f'  {src_name} \u2192 {tgt_name}')\n"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 8. Delta Comparison (GraphDiff)\n",
+    "\n",
+    "Compare method signatures between two CPG snapshots.\n",
+    "This is how `DeltaIngestor` decides whether to skip or ingest.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "from graphrag_toolkit.codeproperty_graph import GraphDiff\n",
+    "\n",
+    "# Current state\n",
+    "current_sigs = {m.full_name: m.hash for m in methods}\n",
+    "print(f'Current signatures:')\n",
+    "for name, h in current_sigs.items():\n",
+    "    print(f'  {name}: {h}')\n",
+    "\n",
+    "# Simulate next commit: parse() refactored, validate() deleted, check() added\n",
+    "next_sigs = {\n",
+    "    'com.example.Main.main': 'a1b2c3d4e5',       # unchanged\n",
+    "    'com.example.Parser.parse': 'NEWH4SH999',     # MODIFIED\n",
+    "    'com.example.Checker.check': 'p6q7r8s9t0',    # ADDED\n",
+    "}\n",
+    "\n",
+    "diff = GraphDiff.compare(current_sigs, next_sigs)\n",
+    "print(f'\\nDelta: {diff.summary}')\n",
+    "print(f'  Added:     {list(diff.added.keys())}')\n",
+    "print(f'  Removed:   {list(diff.removed.keys())}')\n",
+    "print(f'  Modified:  {list(diff.modified.keys())}')\n",
+    "print(f'  Unchanged: {diff.unchanged}')\n",
+    "print(f'\\n\u2192 DeltaIngestor would: {\"INGEST\" if diff.has_changes else \"SKIP\"}')\n"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 9. No-Change Case (SKIP)\n",
+    "\n",
+    "When code hasn't changed, `GraphDiff` returns no delta \u2014 zero Neptune writes.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "no_diff = GraphDiff.compare(current_sigs, current_sigs)\n",
+    "print(f'Delta: {no_diff.summary}')\n",
+    "print(f'Has changes: {no_diff.has_changes}')\n",
+    "print(f'\\n\u2192 DeltaIngestor would: SKIP')\n",
+    "print(f'  Zero Neptune writes. Zero cost. <1 second.')\n"
+   ],
+   "outputs": [],
+   "execution_count": null
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "\n",
+    "| Feature | What It Does |\n",
+    "|---------|-------------|\n",
+    "| `NodeType` / `EdgeType` enums | Complete Joern schema (20 + 14 types) |\n",
+    "| `CPGNode.from_joern(raw)` | Parse Joern JSON export \u2192 typed objects |\n",
+    "| `DELTA_RELEVANT_TYPES` | Which types matter for change detection |\n",
+    "| `STRUCTURE_TYPES` | Types for architectural analysis |\n",
+    "| `GraphDiff.compare()` | Method signature delta \u2192 skip or ingest |\n",
+    "| `joern_export_command()` | Generate the CLI command for any language |\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

graphrag_codeproperty_graph-0.5.0/examples/notebooks/02-Delta-Ingestion-Pipeline.ipynb

@@ -0,0 +1,253 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 02 \u2014 Delta Ingestion Pipeline\n",
+    "\n",
+    "This notebook demonstrates the full DeltaIngestor pipeline: manifest comparison, skip-or-ingest decision, and Neptune graph write.\n",
+    "\n",
+    "**What you'll learn:**\n",
+    "- How ManifestManager tracks CPG state in S3\n",
+    "- How DeltaIngestor decides to skip or ingest\n",
+    "- How tenant-based graph replacement works\n",
+    "\n",
+    "**Prerequisites:**\n",
+    "- Neptune Analytics or Neptune Database endpoint\n",
+    "- S3 bucket for manifests\n",
+    "- IAM permissions for Neptune and S3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "# %pip install codeproperty-graph graphrag-toolkit-document-graph[graphrag]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "import json\n",
+    "import asyncio\n",
+    "from codeproperty_graph import DeltaIngestor, ManifestManager, GraphDiff, CPGNode"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Configuration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "# Replace with your values:\n",
+    "BUCKET = \"my-graphrag-artifacts\"  # S3 bucket for manifests\n",
+    "REPO = \"example-service\"          # Repository name\n",
+    "JOB_ID = \"build-001\"             # CI/CD build identifier\n",
+    "NEPTUNE_ENDPOINT = \"neptune-analytics://my-graph-id\"  # or neptune-db://...\n",
+    "\n",
+    "# Tenant ID (auto-generated in production, fixed here for demo)\n",
+    "TENANT_ID = \"demo123\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load Joern Export"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "import json\n",
+    "from graphrag_toolkit.codeproperty_graph import CPGNode, CPGEdge, NodeType\n",
+    "\n",
+    "with open('data/sample_nodes.json') as f:\n",
+    "    nodes = [CPGNode.from_joern(raw) for raw in json.load(f)]\n",
+    "\n",
+    "with open('data/sample_edges.json') as f:\n",
+    "    edges = [CPGEdge.from_joern(raw) for raw in json.load(f)]\n",
+    "\n",
+    "print(f'Parsed {len(nodes)} nodes ({len(set(n.node_type for n in nodes))} types)')\n",
+    "print(f'Parsed {len(edges)} edges ({len(set(e.edge_type for e in edges))} types)')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 1: Extract Method Signatures\n",
+    "\n",
+    "Only METHOD nodes participate in change detection."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "# Only METHOD nodes participate in delta comparison\n",
+    "methods = [n for n in nodes if n.node_type == NodeType.METHOD]\n",
+    "current_sigs = {m.full_name: m.hash for m in methods}\n",
+    "\n",
+    "print(f'Extracted {len(current_sigs)} method signatures (from {len(nodes)} total nodes):')\n",
+    "for name, h in current_sigs.items():\n",
+    "    print(f'  {name}: {h}')\n",
+    "\n",
+    "print(f'\\nOther node types (not in delta): {set(n.node_type for n in nodes if n.node_type != NodeType.METHOD)}')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 2: Check Previous Manifest\n",
+    "\n",
+    "ManifestManager retrieves the last known state from S3."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "manifest_mgr = ManifestManager(bucket=BUCKET)\n",
+    "\n",
+    "# In production this reads from S3. For demo, simulate:\n",
+    "# previous_manifest = manifest_mgr.get(REPO)\n",
+    "\n",
+    "# Simulate: first run (no previous manifest)\n",
+    "previous_manifest = None\n",
+    "\n",
+    "if previous_manifest is None:\n",
+    "    print(\"No previous manifest \u2014 this is a fresh ingestion.\")\n",
+    "    print(\"All methods will be treated as ADDED.\")\n",
+    "else:\n",
+    "    print(f\"Previous manifest: tenant={previous_manifest.tenant_id}, job={previous_manifest.job_id}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 3: Compute Diff"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "previous_sigs = previous_manifest.method_signatures if previous_manifest else {}\n",
+    "\n",
+    "diff = GraphDiff.compare(previous_sigs, current_sigs)\n",
+    "print(f\"Diff: {diff.summary}\")\n",
+    "print(f\"Has changes: {diff.has_changes}\")\n",
+    "\n",
+    "if diff.has_changes:\n",
+    "    print(\"\\n\u2192 Will INGEST to Neptune\")\n",
+    "else:\n",
+    "    print(\"\\n\u2192 Will SKIP (no Neptune writes)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 4: Write to Neptune (if changed)\n",
+    "\n",
+    "In production, this uses the GraphStore. For this demo, we simulate the write."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "# Simulated write function (replace with actual Neptune write in production)\n",
+    "write_log = []\n",
+    "\n",
+    "async def mock_write_fn(query: str, params: dict):\n",
+    "    \"\"\"Simulates a Neptune write \u2014 logs instead of executing.\"\"\"\n",
+    "    write_log.append({'query': query[:80], 'param_count': len(params)})\n",
+    "\n",
+    "if diff.has_changes:\n",
+    "    print(f\"Writing {len(nodes_data)} nodes and {len(edges_data)} edges...\")\n",
+    "    print(f\"Tenant: {TENANT_ID}\")\n",
+    "    print(f\"(Using mock write \u2014 replace with graph_store.execute_query in production)\")\n",
+    "    \n",
+    "    # In production:\n",
+    "    # result = await ingestor.ingest(repo=REPO, job_id=JOB_ID, ...)\n",
+    "    \n",
+    "    # Simulated result:\n",
+    "    result = {\n",
+    "        \"status\": \"INGESTED\",\n",
+    "        \"delta\": diff.summary,\n",
+    "        \"tenant_id\": TENANT_ID,\n",
+    "        \"nodes_written\": len(nodes_data),\n",
+    "        \"edges_written\": len(edges_data),\n",
+    "    }\n",
+    "    print(f\"\\nResult: {json.dumps(result, indent=2)}\")\n",
+    "else:\n",
+    "    result = {\"status\": \"SKIPPED\", \"reason\": \"no changes detected\"}\n",
+    "    print(f\"Result: {json.dumps(result, indent=2)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 5: Simulate Second Run (No Changes)\n",
+    "\n",
+    "On the next CI/CD run with no code changes, the ingestor skips entirely."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "source": [
+    "# Same signatures as before \u2014 simulates \"no code change\" commit\n",
+    "second_run_sigs = current_sigs.copy()\n",
+    "\n",
+    "diff2 = GraphDiff.compare(current_sigs, second_run_sigs)\n",
+    "print(f\"Second run diff: {diff2.summary}\")\n",
+    "print(f\"Has changes: {diff2.has_changes}\")\n",
+    "print()\n",
+    "print(\"\u2192 SKIPPED \u2014 zero Neptune writes, zero cost, <1 second\")\n",
+    "print(\"  This is the common case in CI/CD (most commits don't change method bodies)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "\n",
+    "| Scenario | Action | Neptune Cost | Time |\n",
+    "|----------|--------|-------------|------|\n",
+    "| First run (no manifest) | Full ingest | N nodes + M edges | Seconds |\n",
+    "| Code changed | Full replace (new tenant, purge old) | N nodes + M edges + purge | Seconds |\n",
+    "| No code change | SKIP | Zero | <1s |\n",
+    "\n",
+    "The delta logic ensures you only pay for Neptune writes when code actually changes."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

graphrag_codeproperty_graph-0.5.0/examples/notebooks/data/sample_edges.json

@@ -0,0 +1,25 @@
+[
+  {"src": "5001", "dst": "4001", "label": "CONTAINS", "properties": {}},
+  {"src": "5002", "dst": "4002", "label": "CONTAINS", "properties": {}},
+  {"src": "5003", "dst": "4003", "label": "CONTAINS", "properties": {}},
+  {"src": "4001", "dst": "1001", "label": "CONTAINS", "properties": {}},
+  {"src": "4002", "dst": "1002", "label": "CONTAINS", "properties": {}},
+  {"src": "4003", "dst": "1003", "label": "CONTAINS", "properties": {}},
+  {"src": "1001", "dst": "2001", "label": "AST", "properties": {"ORDER": 1}},
+  {"src": "1001", "dst": "2002", "label": "AST", "properties": {"ORDER": 2}},
+  {"src": "1001", "dst": "3001", "label": "AST", "properties": {"ORDER": 3}},
+  {"src": "2001", "dst": "3001", "label": "ARGUMENT", "properties": {"ORDER": 1}},
+  {"src": "2001", "dst": "3002", "label": "ARGUMENT", "properties": {"ORDER": 2}},
+  {"src": "2002", "dst": "3003", "label": "ARGUMENT", "properties": {"ORDER": 1}},
+  {"src": "1001", "dst": "1002", "label": "CALL", "properties": {}},
+  {"src": "1001", "dst": "1003", "label": "CALL", "properties": {}},
+  {"src": "1001", "dst": "1002", "label": "CFG", "properties": {}},
+  {"src": "1002", "dst": "1003", "label": "CFG", "properties": {}},
+  {"src": "1001", "dst": "6001", "label": "AST", "properties": {"ORDER": 0}},
+  {"src": "1002", "dst": "6002", "label": "AST", "properties": {"ORDER": 0}},
+  {"src": "1003", "dst": "6003", "label": "AST", "properties": {"ORDER": 0}},
+  {"src": "3001", "dst": "6001", "label": "REF", "properties": {}},
+  {"src": "7001", "dst": "4001", "label": "CONTAINS", "properties": {}},
+  {"src": "7001", "dst": "4002", "label": "CONTAINS", "properties": {}},
+  {"src": "7001", "dst": "4003", "label": "CONTAINS", "properties": {}}
+]

graphrag_codeproperty_graph-0.5.0/examples/notebooks/data/sample_nodes.json

@@ -0,0 +1,21 @@
+[
+  {"id": "1001", "label": "METHOD", "properties": {"FULL_NAME": "com.example.Main.main", "SIGNATURE": "void(String[])", "HASH": "a1b2c3d4e5", "FILENAME": "src/Main.java", "LINE_NUMBER": 5, "LINE_NUMBER_END": 12, "CODE": "public static void main(String[] args) { Parser.parse(args[0]); }", "IS_EXTERNAL": false}},
+  {"id": "1002", "label": "METHOD", "properties": {"FULL_NAME": "com.example.Parser.parse", "SIGNATURE": "Document(String)", "HASH": "f6g7h8i9j0", "FILENAME": "src/Parser.java", "LINE_NUMBER": 12, "LINE_NUMBER_END": 18, "CODE": "public Document parse(String input) { return new Document(input); }", "IS_EXTERNAL": false}},
+  {"id": "1003", "label": "METHOD", "properties": {"FULL_NAME": "com.example.Validator.validate", "SIGNATURE": "boolean(Document)", "HASH": "k1l2m3n4o5", "FILENAME": "src/Validator.java", "LINE_NUMBER": 8, "LINE_NUMBER_END": 11, "CODE": "public boolean validate(Document doc) { return doc != null; }", "IS_EXTERNAL": false}},
+  {"id": "2001", "label": "CALL", "properties": {"NAME": "parse", "FULL_NAME": "com.example.Parser.parse", "CODE": "Parser.parse(args[0])", "LINE_NUMBER": 6, "DISPATCH_TYPE": "STATIC_DISPATCH"}},
+  {"id": "2002", "label": "CALL", "properties": {"NAME": "validate", "FULL_NAME": "com.example.Validator.validate", "CODE": "validator.validate(doc)", "LINE_NUMBER": 7, "DISPATCH_TYPE": "DYNAMIC_DISPATCH"}},
+  {"id": "3001", "label": "IDENTIFIER", "properties": {"NAME": "args", "CODE": "args", "LINE_NUMBER": 6, "ORDER": 1}},
+  {"id": "3002", "label": "LITERAL", "properties": {"CODE": "0", "LINE_NUMBER": 6, "ORDER": 2}},
+  {"id": "3003", "label": "IDENTIFIER", "properties": {"NAME": "doc", "CODE": "doc", "LINE_NUMBER": 7, "ORDER": 1}},
+  {"id": "4001", "label": "TYPE_DECL", "properties": {"FULL_NAME": "com.example.Main", "NAME": "Main", "IS_EXTERNAL": false, "ORDER": 1}},
+  {"id": "4002", "label": "TYPE_DECL", "properties": {"FULL_NAME": "com.example.Parser", "NAME": "Parser", "IS_EXTERNAL": false, "ORDER": 2}},
+  {"id": "4003", "label": "TYPE_DECL", "properties": {"FULL_NAME": "com.example.Validator", "NAME": "Validator", "IS_EXTERNAL": false, "ORDER": 3}},
+  {"id": "5001", "label": "FILE", "properties": {"NAME": "src/Main.java", "ORDER": 1}},
+  {"id": "5002", "label": "FILE", "properties": {"NAME": "src/Parser.java", "ORDER": 2}},
+  {"id": "5003", "label": "FILE", "properties": {"NAME": "src/Validator.java", "ORDER": 3}},
+  {"id": "6001", "label": "PARAMETER", "properties": {"NAME": "args", "CODE": "String[] args", "LINE_NUMBER": 5, "ORDER": 1, "TYPE_FULL_NAME": "java.lang.String[]"}},
+  {"id": "6002", "label": "PARAMETER", "properties": {"NAME": "input", "CODE": "String input", "LINE_NUMBER": 12, "ORDER": 1, "TYPE_FULL_NAME": "java.lang.String"}},
+  {"id": "6003", "label": "PARAMETER", "properties": {"NAME": "doc", "CODE": "Document doc", "LINE_NUMBER": 8, "ORDER": 1, "TYPE_FULL_NAME": "com.example.Document"}},
+  {"id": "7001", "label": "NAMESPACE", "properties": {"NAME": "com.example", "ORDER": 1}},
+  {"id": "8001", "label": "META_DATA", "properties": {"LANGUAGE": "java", "VERSION": "1.0"}}
+]