graphrag-codeproperty-graph 0.4.3__tar.gz → 0.4.5__tar.gz

graphrag_codeproperty_graph-0.4.5/.gitignore

@@ -0,0 +1,31 @@
+# Kiro
+.kiro/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+*.egg
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/

graphrag_codeproperty_graph-0.4.5/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## [0.4.3] - 2026-08-03
+
+### Added
+- Initial public release
+- Joern/Semgrep CPG extraction and ingestion
+- Delta ingestion — skip-or-replace logic to minimize Neptune writes
+- Graph diff comparison between CPG states
+- S3-backed manifest management for repository state tracking
+- AI vulnerability enrichment and risk scoring
+- Tenant lifecycle management (create, purge, replace)
+- CPGNode and CPGEdge Pydantic models (Joern-specific types)
+
+### Dependencies
+- graphrag-document-graph>=3.0.8

graphrag_codeproperty_graph-0.4.5/CONTRIBUTING.md

@@ -0,0 +1,76 @@
+# Contributing
+
+Thank you for your interest in contributing! This project is maintained by [Kanjani AI Research](https://github.com/kanjani-ai-research).
+
+## Development Setup
+
+1. Clone the repository:
+   ```bash
+   git clone <repo-url>
+   cd <project-dir>
+   ```
+
+2. Create a virtual environment and install in editable mode with dev dependencies:
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate
+   pip install -e '.[dev]'
+   ```
+
+## Running Tests
+
+```bash
+pytest tests/
+```
+
+For coverage:
+```bash
+pytest tests/ --cov --cov-report=term-missing
+```
+
+## Code Style
+
+This project uses:
+- **[Black](https://github.com/psf/black)** for code formatting
+- **[Ruff](https://github.com/astral-sh/ruff)** for linting
+
+Before submitting, ensure your code passes:
+```bash
+black .
+ruff check .
+```
+
+## Submitting Pull Requests
+
+1. Fork the repository
+2. Create a feature branch from `main`:
+   ```bash
+   git checkout -b feature/your-feature
+   ```
+3. Make your changes, including tests
+4. Ensure all tests pass and code style checks are clean
+5. Commit with a clear, descriptive message
+6. Push and open a Pull Request against `main`
+
+### PR Guidelines
+
+- Keep PRs focused — one feature or fix per PR
+- Include tests for new functionality
+- Update documentation if behavior changes
+- Reference any related issues in the PR description
+
+## Reporting Issues
+
+Open an issue on GitHub with:
+- A clear description of the problem
+- Steps to reproduce
+- Expected vs actual behavior
+- Python version and OS
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the [MIT License](LICENSE).
+
+## Organization
+
+This project is part of the [Kanjani AI Research](https://github.com/kanjani-ai-research) organization.

{graphrag_codeproperty_graph-0.4.3 → graphrag_codeproperty_graph-0.4.5}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: graphrag-codeproperty-graph
-Version: 0.4.3
+Version: 0.4.5
 Summary: Code Property Graphs — Joern/Semgrep extraction, AI vulnerability enrichment, risk scoring
-Project-URL: Repository, https://github.com/RW-Lab/codeproperty-graph
+Project-URL: Repository, https://github.com/kanjani-ai-research/codeproperty-graph
 Author-email: Evan Erwee <evan@erwee.com>
 License-Expression: MIT
 License-File: LICENSE
@@ -13,30 +13,49 @@ Classifier: Intended Audience :: Developers
 Classifier: Topic :: Security
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.11
-Requires-Dist: boto3>=1.26.0
-Requires-Dist: graphrag-document-graph>=3.0.8
+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'
 Requires-Dist: pytest-cov>=4.0; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
-Provides-Extra: graphrag
-Requires-Dist: graphrag-toolkit-lexical-graph>=3.18.0; extra == 'graphrag'
+Requires-Dist: ruff; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Code Property Graph
 
-Code Property Graphs — Joern/Semgrep extraction, AI vulnerability enrichment, risk scoring.
+[![PyPI version](https://img.shields.io/pypi/v/graphrag-codeproperty-graph.svg)](https://pypi.org/project/graphrag-codeproperty-graph/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-> **This package depends on AWS GraphRAG Toolkit (graphrag-toolkit-lexical-graph) for graph storage, vector indexing, and retrieval.**
+**Code Property Graphs — Joern/Semgrep extraction, AI vulnerability enrichment, risk scoring.**
 
-## Quick Start
+> **This package depends on AWS GraphRAG Toolkit (graphrag-toolkit-lexical-graph) for graph storage, vector indexing, and retrieval.**
 
-### Install
+## Installation
 
 ```bash
-pip install codeproperty-graph
+pip install graphrag-codeproperty-graph
 ```
 
+## Dependencies
+
+- `graphrag-document-graph>=3.0.8` — Document graph infrastructure (typed nodes, Cypher builders, multi-tenancy)
+
+This package does **not** depend on `bona`.
+
+## Dependency Chain
+
+```
+graphrag-codeproperty-graph
+└── graphrag-document-graph>=3.0.8
+    └── graphrag-toolkit-lexical-graph>=3.18.0  (AWS foundation)
+        ├── Neptune graph storage
+        ├── OpenSearch Serverless vector indexing
+        └── Entity resolution & retrieval
+```
+
+## Quick Start
+
 ### Python API Example
 
 ```python
@@ -49,8 +68,8 @@ result = await ingestor.ingest(
     repo="my-service",
     job_id="build-456",
     tenant_id="tenant_abc123",
-    nodes_data=joern_nodes,       # Joern CPG export
-    edges_data=joern_edges,       # Joern CPG export
+    nodes_data=joern_nodes,
+    edges_data=joern_edges,
     nodes_path="s3://bucket/cpg-exports/my-service/build-456/nodes.json",
     edges_path="s3://bucket/cpg-exports/my-service/build-456/edges.json",
     graph_store=neptune_store,
@@ -113,7 +132,7 @@ src/codeproperty_graph/
 │         codeproperty-graph (this package)            │
 │  Joern/Semgrep CPG, delta ingestion, risk scoring   │
 ├─────────────────────────────────────────────────────┤
-│              document-graph (infra)                  │
+│              document-graph                          │
 │  Node, Edge, CypherBuilder, PipelineExecutor        │
 │  Multi-tenancy, batch operations                    │
 ├─────────────────────────────────────────────────────┤
@@ -144,22 +163,9 @@ from graphrag_toolkit.document_graph import Node, Edge
 from codeproperty_graph import CPGNode, CPGEdge
 ```
 
-### AI Vulnerability Enrichment
-
-After CPG ingestion, enrich with AI-powered vulnerability analysis:
-
-```python
-# Query Neptune for high-risk patterns
-# Score methods by complexity, dependency depth, and known CVE proximity
-# Annotate graph with risk scores for downstream consumption
-```
-
-## Requirements
+## Contributing
 
-- Python >= 3.11
-- `document-graph >= 0.1.0`
-- `boto3 >= 1.26.0`
-- Optional: `graphrag-toolkit-lexical-graph >= 3.18.0`
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, testing, and PR guidelines.
 
 ## License
 

{graphrag_codeproperty_graph-0.4.3 → graphrag_codeproperty_graph-0.4.5}/README.md

@@ -1,17 +1,37 @@
 # Code Property Graph
 
-Code Property Graphs — Joern/Semgrep extraction, AI vulnerability enrichment, risk scoring.
+[![PyPI version](https://img.shields.io/pypi/v/graphrag-codeproperty-graph.svg)](https://pypi.org/project/graphrag-codeproperty-graph/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-> **This package depends on AWS GraphRAG Toolkit (graphrag-toolkit-lexical-graph) for graph storage, vector indexing, and retrieval.**
+**Code Property Graphs — Joern/Semgrep extraction, AI vulnerability enrichment, risk scoring.**
 
-## Quick Start
+> **This package depends on AWS GraphRAG Toolkit (graphrag-toolkit-lexical-graph) for graph storage, vector indexing, and retrieval.**
 
-### Install
+## Installation
 
 ```bash
-pip install codeproperty-graph
+pip install graphrag-codeproperty-graph
 ```
 
+## Dependencies
+
+- `graphrag-document-graph>=3.0.8` — Document graph infrastructure (typed nodes, Cypher builders, multi-tenancy)
+
+This package does **not** depend on `bona`.
+
+## Dependency Chain
+
+```
+graphrag-codeproperty-graph
+└── graphrag-document-graph>=3.0.8
+    └── graphrag-toolkit-lexical-graph>=3.18.0  (AWS foundation)
+        ├── Neptune graph storage
+        ├── OpenSearch Serverless vector indexing
+        └── Entity resolution & retrieval
+```
+
+## Quick Start
+
 ### Python API Example
 
 ```python
@@ -24,8 +44,8 @@ result = await ingestor.ingest(
     repo="my-service",
     job_id="build-456",
     tenant_id="tenant_abc123",
-    nodes_data=joern_nodes,       # Joern CPG export
-    edges_data=joern_edges,       # Joern CPG export
+    nodes_data=joern_nodes,
+    edges_data=joern_edges,
     nodes_path="s3://bucket/cpg-exports/my-service/build-456/nodes.json",
     edges_path="s3://bucket/cpg-exports/my-service/build-456/edges.json",
     graph_store=neptune_store,
@@ -88,7 +108,7 @@ src/codeproperty_graph/
 │         codeproperty-graph (this package)            │
 │  Joern/Semgrep CPG, delta ingestion, risk scoring   │
 ├─────────────────────────────────────────────────────┤
-│              document-graph (infra)                  │
+│              document-graph                          │
 │  Node, Edge, CypherBuilder, PipelineExecutor        │
 │  Multi-tenancy, batch operations                    │
 ├─────────────────────────────────────────────────────┤
@@ -119,22 +139,9 @@ from graphrag_toolkit.document_graph import Node, Edge
 from codeproperty_graph import CPGNode, CPGEdge
 ```
 
-### AI Vulnerability Enrichment
-
-After CPG ingestion, enrich with AI-powered vulnerability analysis:
-
-```python
-# Query Neptune for high-risk patterns
-# Score methods by complexity, dependency depth, and known CVE proximity
-# Annotate graph with risk scores for downstream consumption
-```
-
-## Requirements
+## Contributing
 
-- Python >= 3.11
-- `document-graph >= 0.1.0`
-- `boto3 >= 1.26.0`
-- Optional: `graphrag-toolkit-lexical-graph >= 3.18.0`
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, testing, and PR guidelines.
 
 ## License
 

graphrag_codeproperty_graph-0.4.5/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.4.5/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.4.5/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.4.5/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.4.5/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"}}
+]

{graphrag_codeproperty_graph-0.4.3 → graphrag_codeproperty_graph-0.4.5}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["src/codeproperty_graph"]
 
 [project]
 name = "graphrag-codeproperty-graph"
-version = "0.4.3"
+version = "0.4.5"
 description = "Code Property Graphs — Joern/Semgrep extraction, AI vulnerability enrichment, risk scoring"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -22,22 +22,20 @@ classifiers = [
 ]
 
 dependencies = [
-  "graphrag-document-graph>=3.0.8",
-  "boto3>=1.26.0",
+    "graphrag-document-graph>=3.1.1",
 ]
 
 [project.optional-dependencies]
-graphrag = [
-  "graphrag-toolkit-lexical-graph>=3.18.0",
-]
 dev = [
-  "pytest>=7.0",
-  "pytest-cov>=4.0",
-  "pytest-asyncio>=0.21.0",
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "pytest-asyncio>=0.21.0",
+    "black",
+    "ruff",
 ]
 
 [project.urls]
-Repository = "https://github.com/RW-Lab/codeproperty-graph"
+Repository = "https://github.com/kanjani-ai-research/codeproperty-graph"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

graphrag_codeproperty_graph-0.4.3/.gitignore

@@ -1,5 +0,0 @@
-.venv/
-dist/
-*.egg-info/
-__pycache__/
-.pytest_cache/