codingest 0.1.2__tar.gz → 0.1.3__tar.gz

{codingest-0.1.2 → codingest-0.1.3}/Cargo.lock

@@ -313,7 +313,7 @@ dependencies = [
 
 [[package]]
 name = "codingest"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "aho-corasick",
  "base64",
@@ -345,7 +345,7 @@ dependencies = [
 
 [[package]]
 name = "codingest-cli"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "anyhow",
  "clap",
@@ -357,7 +357,7 @@ dependencies = [
 
 [[package]]
 name = "codingest-mcp"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "anyhow",
  "codingest",
@@ -366,10 +366,11 @@ dependencies = [
 
 [[package]]
 name = "codingest-py"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "codingest",
  "codingest-cli",
+ "codingest-mcp",
  "kglite",
  "pyo3",
  "tempfile",

{codingest-0.1.2 → codingest-0.1.3}/Cargo.toml

@@ -1,9 +1,9 @@
 [workspace]
-members = ["crates/codingest", "crates/codingest-cli", "crates/codingest-py"]
+members = ["crates/codingest", "crates/codingest-cli", "crates/codingest-mcp", "crates/codingest-py"]
 resolver = "2"
 
 [workspace.package]
-version = "0.1.2"
+version = "0.1.3"
 edition = "2021"
 rust-version = "1.88"
 license = "MIT"

{codingest-0.1.2 → codingest-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codingest
-Version: 0.1.2
+Version: 0.1.3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -70,10 +70,13 @@ a real `kglite.KnowledgeGraph`, ready for Cypher queries.
 - **Revision-aware:** analyse a tag, branch, commit, or multiple revisions in
   one graph and query what changed.
 
+AGC assembly receives architecture-aware control and data relationships rather
+than a generic text-level call graph; see the [AGC graph model](https://codingest.readthedocs.io/en/latest/agc-assembly.html).
+
 ## Give your agent a code-review MCP server
 
 ```bash
-cargo install codingest-mcp
+pip install codingest
 codingest-mcp --watch /absolute/path/to/repo
 ```
 
@@ -172,14 +175,18 @@ for direct Cypher analysis.
 ## Install options
 
 ```bash
-pip install codingest          # Python API + codingest CLI + KGLite runtime
-cargo install codingest-cli    # pure-Rust builder CLI
-cargo install codingest-mcp    # MCP server for agents
+pip install codingest          # Python API + CLI + MCP server + KGLite runtime
 codingest skill install        # code-review Agent Skill
 ```
 
-The wheel bundles every grammar and the `codingest` command. KGLite ≥0.14.5 is
-installed automatically as the query/storage engine.
+The wheel bundles every grammar plus the `codingest` and `codingest-mcp`
+commands. KGLite ≥0.14.5 is installed automatically as the query/storage
+engine; its MCP server and the transitive `mcp-methods` framework power the
+builder-aware Codingest server. Nothing else needs to be installed.
+
+Rust-only environments can instead use `cargo install codingest-cli
+codingest-mcp`; these are alternative distributions of the same commands, not
+Python prerequisites.
 
 ### Rust crate
 

{codingest-0.1.2 → codingest-0.1.3}/README.md

@@ -43,10 +43,13 @@ a real `kglite.KnowledgeGraph`, ready for Cypher queries.
 - **Revision-aware:** analyse a tag, branch, commit, or multiple revisions in
   one graph and query what changed.
 
+AGC assembly receives architecture-aware control and data relationships rather
+than a generic text-level call graph; see the [AGC graph model](https://codingest.readthedocs.io/en/latest/agc-assembly.html).
+
 ## Give your agent a code-review MCP server
 
 ```bash
-cargo install codingest-mcp
+pip install codingest
 codingest-mcp --watch /absolute/path/to/repo
 ```
 
@@ -145,14 +148,18 @@ for direct Cypher analysis.
 ## Install options
 
 ```bash
-pip install codingest          # Python API + codingest CLI + KGLite runtime
-cargo install codingest-cli    # pure-Rust builder CLI
-cargo install codingest-mcp    # MCP server for agents
+pip install codingest          # Python API + CLI + MCP server + KGLite runtime
 codingest skill install        # code-review Agent Skill
 ```
 
-The wheel bundles every grammar and the `codingest` command. KGLite ≥0.14.5 is
-installed automatically as the query/storage engine.
+The wheel bundles every grammar plus the `codingest` and `codingest-mcp`
+commands. KGLite ≥0.14.5 is installed automatically as the query/storage
+engine; its MCP server and the transitive `mcp-methods` framework power the
+builder-aware Codingest server. Nothing else needs to be installed.
+
+Rust-only environments can instead use `cargo install codingest-cli
+codingest-mcp`; these are alternative distributions of the same commands, not
+Python prerequisites.
 
 ### Rust crate
 

codingest-0.1.3/codingest/mcp_server.py

@@ -0,0 +1,38 @@
+"""Console-script shim for the Rust ``codingest-mcp`` server in the wheel.
+
+Codingest supplies the source-builder hooks; KGlite supplies graph/Cypher
+serving and pulls the generic MCP lifecycle from ``mcp-methods``. All three are
+linked into the wheel's existing native extension, so users need only
+``pip install codingest``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run the bundled MCP server with ``argv`` or ``sys.argv[1:]``."""
+    from codingest.codingest import _run_mcp_server
+
+    args = list(sys.argv[1:] if argv is None else argv)
+    # In a wheel console script, current_exe() is Python rather than the Rust
+    # server. Give KGlite's selftest the exact command needed to re-enter this
+    # module with the same interpreter and environment.
+    os.environ["KGLITE_MCP_RESPAWN"] = json.dumps(
+        [sys.executable, "-m", "codingest.mcp_server"]
+    )
+    try:
+        _run_mcp_server(args)
+    except KeyboardInterrupt:
+        return 130
+    except RuntimeError as exc:
+        print(f"codingest-mcp: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{codingest-0.1.2 → codingest-0.1.3}/crates/codingest/src/builder/call_edges.rs

@@ -19,6 +19,12 @@ pub struct CallEdge {
     /// Comma-separated sorted unique line numbers.
     pub call_lines: String,
     pub call_count: i64,
+    /// Optional parser-preserved transfer spelling/mechanism. Empty for the
+    /// ordinary language call resolver, populated by typed semantic sites.
+    pub raw_targets: Option<String>,
+    pub offsets: Option<String>,
+    pub via: Option<String>,
+    pub address_lines: Option<String>,
 }
 
 /// Aggregate counters describing how the resolver classified every call
@@ -48,6 +54,18 @@ pub struct CallResolutionStats {
     pub resolved_via_inheritance: u64,
 }
 
+impl CallResolutionStats {
+    pub(crate) fn merge(&mut self, other: Self) {
+        self.total_calls += other.total_calls;
+        self.excluded_noise += other.excluded_noise;
+        self.no_candidate += other.no_candidate;
+        self.ambiguous_dropped += other.ambiguous_dropped;
+        self.resolved_call_sites += other.resolved_call_sites;
+        self.resolved_edges += other.resolved_edges;
+        self.resolved_via_inheritance += other.resolved_via_inheritance;
+    }
+}
+
 /// Per-function scratch counters, summed into [`CallResolutionStats`] after
 /// the parallel match loop. Kept `Copy` so the rayon reduce stays alloc-free.
 #[derive(Debug, Clone, Copy, Default)]
@@ -495,6 +513,10 @@ pub fn build_call_edges(
                 callee: callee.to_string(),
                 call_lines,
                 call_count: count,
+                raw_targets: None,
+                offsets: None,
+                via: None,
+                address_lines: None,
             }
         })
         .collect();

{codingest-0.1.2 → codingest-0.1.3}/crates/codingest/src/builder/load/edge_frames.rs

@@ -88,11 +88,100 @@ pub(super) fn call_edges_df(edges: &[super::super::call_edges::CallEdge]) -> Dat
     let callee: Vec<Option<String>> = edges.iter().map(|e| Some(e.callee.clone())).collect();
     let lines: Vec<Option<String>> = edges.iter().map(|e| Some(e.call_lines.clone())).collect();
     let count: Vec<Option<i64>> = edges.iter().map(|e| Some(e.call_count)).collect();
-    build_df(vec![
+    let mut columns = vec![
         ("caller", ColumnType::String, str_col(caller)),
         ("callee", ColumnType::String, str_col(callee)),
         ("call_lines", ColumnType::String, str_col(lines)),
         ("call_count", ColumnType::Int64, int_col(count)),
+    ];
+    if edges.iter().any(|edge| edge.raw_targets.is_some()) {
+        columns.push((
+            "raw_targets",
+            ColumnType::String,
+            str_col(edges.iter().map(|edge| edge.raw_targets.clone()).collect()),
+        ));
+    }
+    if edges.iter().any(|edge| edge.offsets.is_some()) {
+        columns.push((
+            "offsets",
+            ColumnType::String,
+            str_col(edges.iter().map(|edge| edge.offsets.clone()).collect()),
+        ));
+    }
+    if edges.iter().any(|edge| edge.via.is_some()) {
+        columns.push((
+            "via",
+            ColumnType::String,
+            str_col(edges.iter().map(|edge| edge.via.clone()).collect()),
+        ));
+    }
+    if edges.iter().any(|edge| edge.address_lines.is_some()) {
+        columns.push((
+            "address_lines",
+            ColumnType::String,
+            str_col(
+                edges
+                    .iter()
+                    .map(|edge| edge.address_lines.clone())
+                    .collect(),
+            ),
+        ));
+    }
+    build_df(columns)
+}
+
+pub(super) fn control_edges_df(edges: &[super::super::semantic_edges::ControlEdge]) -> DataFrame {
+    build_df(vec![
+        (
+            "caller",
+            ColumnType::String,
+            str_col(edges.iter().map(|edge| Some(edge.caller.clone())).collect()),
+        ),
+        (
+            "target",
+            ColumnType::String,
+            str_col(edges.iter().map(|edge| Some(edge.target.clone())).collect()),
+        ),
+        (
+            "transfer_lines",
+            ColumnType::String,
+            str_col(
+                edges
+                    .iter()
+                    .map(|edge| Some(edge.transfer_lines.clone()))
+                    .collect(),
+            ),
+        ),
+        (
+            "transfer_count",
+            ColumnType::Int64,
+            int_col(edges.iter().map(|edge| Some(edge.transfer_count)).collect()),
+        ),
+        (
+            "raw_targets",
+            ColumnType::String,
+            str_col(edges.iter().map(|edge| edge.raw_targets.clone()).collect()),
+        ),
+        (
+            "offsets",
+            ColumnType::String,
+            str_col(edges.iter().map(|edge| edge.offsets.clone()).collect()),
+        ),
+        (
+            "via",
+            ColumnType::String,
+            str_col(edges.iter().map(|edge| edge.via.clone()).collect()),
+        ),
+        (
+            "address_lines",
+            ColumnType::String,
+            str_col(
+                edges
+                    .iter()
+                    .map(|edge| edge.address_lines.clone())
+                    .collect(),
+            ),
+        ),
     ])
 }
 
@@ -144,10 +233,95 @@ pub(super) fn references_edges_df(
     let fns: Vec<Option<String>> = edges.iter().map(|e| Some(e.function.clone())).collect();
     let consts: Vec<Option<String>> = edges.iter().map(|e| Some(e.constant.clone())).collect();
     let lines: Vec<Option<i64>> = edges.iter().map(|e| Some(e.line as i64)).collect();
-    build_df(vec![
+    let mut columns = vec![
         ("function", ColumnType::String, str_col(fns)),
         ("constant", ColumnType::String, str_col(consts)),
         ("line", ColumnType::Int64, int_col(lines)),
+    ];
+    if edges.iter().any(|edge| edge.reference_lines.is_some()) {
+        columns.push((
+            "reference_lines",
+            ColumnType::String,
+            str_col(
+                edges
+                    .iter()
+                    .map(|edge| edge.reference_lines.clone())
+                    .collect(),
+            ),
+        ));
+    }
+    if edges.iter().any(|edge| edge.reference_count.is_some()) {
+        columns.push((
+            "reference_count",
+            ColumnType::Int64,
+            int_col(edges.iter().map(|edge| edge.reference_count).collect()),
+        ));
+    }
+    if edges.iter().any(|edge| edge.opcodes.is_some()) {
+        columns.push((
+            "opcodes",
+            ColumnType::String,
+            str_col(edges.iter().map(|edge| edge.opcodes.clone()).collect()),
+        ));
+    }
+    if edges.iter().any(|edge| edge.accesses.is_some()) {
+        columns.push((
+            "accesses",
+            ColumnType::String,
+            str_col(edges.iter().map(|edge| edge.accesses.clone()).collect()),
+        ));
+    }
+    if edges.iter().any(|edge| edge.has_read.is_some()) {
+        columns.push((
+            "has_read",
+            ColumnType::Boolean,
+            bool_col(edges.iter().map(|edge| edge.has_read).collect()),
+        ));
+    }
+    if edges.iter().any(|edge| edge.has_write.is_some()) {
+        columns.push((
+            "has_write",
+            ColumnType::Boolean,
+            bool_col(edges.iter().map(|edge| edge.has_write).collect()),
+        ));
+    }
+    if edges.iter().any(|edge| edge.has_address.is_some()) {
+        columns.push((
+            "has_address",
+            ColumnType::Boolean,
+            bool_col(edges.iter().map(|edge| edge.has_address).collect()),
+        ));
+    }
+    build_df(columns)
+}
+
+pub(super) fn symbol_edges_df(edges: &[super::super::semantic_edges::SymbolEdge]) -> DataFrame {
+    build_df(vec![
+        (
+            "source",
+            ColumnType::String,
+            str_col(edges.iter().map(|edge| Some(edge.source.clone())).collect()),
+        ),
+        (
+            "target",
+            ColumnType::String,
+            str_col(edges.iter().map(|edge| Some(edge.target.clone())).collect()),
+        ),
+        (
+            "line",
+            ColumnType::Int64,
+            int_col(edges.iter().map(|edge| Some(edge.line as i64)).collect()),
+        ),
+        (
+            "raw_target",
+            ColumnType::String,
+            str_col(
+                edges
+                    .iter()
+                    .map(|edge| Some(edge.raw_target.clone()))
+                    .collect(),
+            ),
+        ),
     ])
 }
 

{codingest-0.1.2 → codingest-0.1.3}/crates/codingest/src/builder/load/entity_frames.rs

@@ -169,7 +169,7 @@ pub(super) fn functions_df(
     file_is_test: &HashMap<&str, bool>,
     file_to_module: &HashMap<&str, &str>,
 ) -> DataFrame {
-    build_df(vec![
+    let mut columns = vec![
         (
             "qualified_name",
             ColumnType::String,
@@ -462,7 +462,33 @@ pub(super) fn functions_df(
                     .collect(),
             ),
         ),
-    ])
+    ];
+    for key in ["symbol_kind", "role_hint"] {
+        if fns.iter().any(|function| {
+            function
+                .metadata
+                .get(key)
+                .and_then(|value| value.as_str())
+                .is_some()
+        }) {
+            columns.push((
+                key,
+                ColumnType::String,
+                str_col(
+                    fns.iter()
+                        .map(|function| {
+                            function
+                                .metadata
+                                .get(key)
+                                .and_then(|value| value.as_str())
+                                .map(str::to_string)
+                        })
+                        .collect(),
+                ),
+            ));
+        }
+    }
+    build_df(columns)
 }
 
 pub(super) fn classes_df(
@@ -814,7 +840,7 @@ pub(super) fn constants_df(
     consts: &[ConstantInfo],
     file_to_module: &HashMap<&str, &str>,
 ) -> DataFrame {
-    build_df(vec![
+    let mut columns = vec![
         (
             "qualified_name",
             ColumnType::String,
@@ -875,7 +901,35 @@ pub(super) fn constants_df(
             ColumnType::Int64,
             int_col(consts.iter().map(|c| Some(c.line_number as i64)).collect()),
         ),
-    ])
+    ];
+    if consts.iter().any(|constant| constant.kind == "agc_erase") {
+        columns.push((
+            "is_mutable",
+            ColumnType::Boolean,
+            bool_col(
+                consts
+                    .iter()
+                    .map(|constant| {
+                        constant
+                            .kind
+                            .starts_with("agc_")
+                            .then_some(constant.kind == "agc_erase")
+                    })
+                    .collect(),
+            ),
+        ));
+        columns.push((
+            "storage",
+            ColumnType::String,
+            str_col(
+                consts
+                    .iter()
+                    .map(|constant| (constant.kind == "agc_erase").then(|| "erasable".to_string()))
+                    .collect(),
+            ),
+        ));
+    }
+    build_df(columns)
 }
 
 pub(super) fn elements_df(elements: &[crate::models::ElementInfo]) -> DataFrame {

{codingest-0.1.2 → codingest-0.1.3}/crates/codingest/src/builder/load.rs

@@ -120,6 +120,7 @@ pub fn load_into_graph(
     run_stage!(type_relationship_edges, "implements+extends+has_method");
     run_stage!(uses_type_edges, "uses_type");
     run_stage!(reference_edges, "references");
+    run_stage!(symbol_relationship_edges, "alias_of+points_to");
     run_stage!(function_reference_edges, "references_fn");
     run_stage!(decorator_edges, "decorates");
     run_stage!(ffi_edges, "ffi_exposes");
@@ -826,13 +827,19 @@ impl<'a> LoadPipeline<'a> {
         let graph = &mut self.graph;
         // Function CALLS Function (5-tier resolution).
         let noise = super::call_edges::noise_names_for_files(&result.files);
-        let (call_edges, call_stats) = super::call_edges::build_call_edges(
+        let (mut call_edges, mut call_stats) = super::call_edges::build_call_edges(
             &result.functions,
             &result.files,
             &noise,
             5,
             &result.type_relationships,
         );
+        let semantic = super::semantic_edges::build_control_edges(
+            &result.control_transfers,
+            &result.functions,
+        );
+        call_edges.extend(semantic.calls);
+        call_stats.merge(semantic.call_stats);
         if !call_edges.is_empty() {
             maintain::add_connections(
                 graph,
@@ -848,6 +855,36 @@ impl<'a> LoadPipeline<'a> {
             )
             .map_err(py_err)?;
         }
+        if !semantic.jumps.is_empty() {
+            maintain::add_connections(
+                graph,
+                control_edges_df(&semantic.jumps),
+                "JUMPS_TO".into(),
+                "Function".into(),
+                "caller".into(),
+                "Function".into(),
+                "target".into(),
+                None,
+                None,
+                None,
+            )
+            .map_err(py_err)?;
+        }
+        if !semantic.branches.is_empty() {
+            maintain::add_connections(
+                graph,
+                control_edges_df(&semantic.branches),
+                "BRANCHES_TO".into(),
+                "Function".into(),
+                "caller".into(),
+                "Function".into(),
+                "target".into(),
+                None,
+                None,
+                None,
+            )
+            .map_err(py_err)?;
+        }
 
         self.call_stats = call_stats;
         Ok(())
@@ -1099,7 +1136,13 @@ impl<'a> LoadPipeline<'a> {
         let result = self.result;
         let graph = &mut self.graph;
         // REFERENCES (Function → Constant) — name-keyed identifier resolution.
-        let refs = super::other_edges::build_references_edges(&result.functions, &result.constants);
+        let mut refs =
+            super::other_edges::build_references_edges(&result.functions, &result.constants);
+        refs.extend(super::semantic_edges::build_reference_site_edges(
+            &result.reference_sites,
+            &result.functions,
+            &result.constants,
+        ));
         if !refs.is_empty() {
             maintain::add_connections(
                 graph,
@@ -1119,6 +1162,32 @@ impl<'a> LoadPipeline<'a> {
         Ok(())
     }
 
+    fn symbol_relationship_edges(&mut self) -> Result<(), String> {
+        let result = self.result;
+        let graph = &mut self.graph;
+        let batches = super::semantic_edges::build_symbol_edges(
+            &result.symbol_relationships,
+            &result.functions,
+            &result.constants,
+        );
+        for batch in batches {
+            maintain::add_connections(
+                graph,
+                symbol_edges_df(&batch.edges),
+                batch.relationship.into(),
+                "Constant".into(),
+                "source".into(),
+                batch.target_node_type.into(),
+                "target".into(),
+                None,
+                None,
+                None,
+            )
+            .map_err(py_err)?;
+        }
+        Ok(())
+    }
+
     fn function_reference_edges(&mut self) -> Result<(), String> {
         let result = self.result;
         let graph = &mut self.graph;

{codingest-0.1.2 → codingest-0.1.3}/crates/codingest/src/builder/mod.rs

@@ -4,6 +4,7 @@ pub mod call_edges;
 pub mod load;
 pub mod other_edges;
 pub mod routes;
+pub mod semantic_edges;
 pub mod type_edges;
 
 use crate::models::{ParseResult, ProjectInfo, SourceRoot};
@@ -257,6 +258,39 @@ fn retain_non_test_entities(result: &mut ParseResult) {
         .selectors
         .retain(|item| !test_paths.contains(&item.file_path));
 
+    let retained_functions: HashSet<&str> = result
+        .functions
+        .iter()
+        .map(|item| item.qualified_name.as_str())
+        .collect();
+    let retained_constants: HashSet<&str> = result
+        .constants
+        .iter()
+        .map(|item| item.qualified_name.as_str())
+        .collect();
+    result.control_transfers.retain(|site| {
+        retained_functions.contains(site.caller.as_str())
+            && site
+                .target
+                .as_deref()
+                .is_none_or(|target| retained_functions.contains(target))
+    });
+    result.reference_sites.retain(|site| {
+        retained_functions.contains(site.caller.as_str())
+            && retained_constants.contains(site.target.as_str())
+    });
+    result.symbol_relationships.retain(|relationship| {
+        retained_constants.contains(relationship.source.as_str())
+            && match relationship.target_kind {
+                crate::models::SymbolTargetKind::Constant => {
+                    retained_constants.contains(relationship.target.as_str())
+                }
+                crate::models::SymbolTargetKind::Function => {
+                    retained_functions.contains(relationship.target.as_str())
+                }
+            }
+    });
+
     let retained_types: HashSet<&str> = result
         .classes
         .iter()
@@ -524,6 +558,12 @@ fn finalize_and_load(
     dedup_by_key(&mut combined.enums, |e| e.qualified_name.clone());
     dedup_by_key(&mut combined.interfaces, |i| i.qualified_name.clone());
     dedup_by_key(&mut combined.constants, |c| c.qualified_name.clone());
+    combined.control_transfers.sort();
+    combined.control_transfers.dedup();
+    combined.reference_sites.sort();
+    combined.reference_sites.dedup();
+    combined.symbol_relationships.sort();
+    combined.symbol_relationships.dedup();
     if verbose {
         eprintln!("[timing] dedup: {:.3}s", t_dedup.elapsed().as_secs_f64());
     }
@@ -615,6 +655,12 @@ pub fn run(src_dir: &Path, verbose: bool) -> Result<Arc<DirGraph>, String> {
     dedup_by_key(&mut combined.enums, |e| e.qualified_name.clone());
     dedup_by_key(&mut combined.interfaces, |i| i.qualified_name.clone());
     dedup_by_key(&mut combined.constants, |c| c.qualified_name.clone());
+    combined.control_transfers.sort();
+    combined.control_transfers.dedup();
+    combined.reference_sites.sort();
+    combined.reference_sites.dedup();
+    combined.symbol_relationships.sort();
+    combined.symbol_relationships.dedup();
 
     if verbose {
         eprintln!(