agentforge-graph 0.3.2__py3-none-any.whl

agentforge_graph/ingest/incremental/indexer.py

@@ -0,0 +1,218 @@
+"""``IncrementalIndexer`` — apply a ``ChangeSet`` to an existing index.
+
+Cost is proportional to the diff and its import-graph neighbourhood, not the
+repo. The sequence (spec §4.3):
+
+1. record the symbols about to disappear (for dirty propagation);
+2. delete removed files (graph + vectors);
+3. re-extract + upsert the touched files (scoped ``IngestPipeline``);
+4. clear resolved edges in the re-resolve *scope* and re-resolve just that
+   scope — ``scope = changed ∪ importers(changed)`` out to
+   ``resolve_scope_hops`` import-graph hops;
+5. append the dirtied symbols (changed + 1-hop neighbours) to the ``DirtySet``.
+
+Correctness is asserted by the equivalence property test
+(``refresh(diff) == full_reindex``); this module's scope heuristics are the
+performance knob, the property test is the safety net.
+"""
+
+from __future__ import annotations
+
+from pathlib import PurePosixPath
+
+from agentforge_graph.core import GraphQuery, Node, NodeKind, SymbolID
+from agentforge_graph.frameworks import FrameworkExtractor
+from agentforge_graph.store import Store
+
+from ..pack import PackRegistry
+from ..report import IndexReport
+from ..resolver import ImportResolver
+from ..source import RepoSource, read_go_module
+from .detect import ChangeSet
+from .dirty import DirtySet
+from .ports import TemporalRecorder
+
+_ALL = 10_000_000
+
+
+class IncrementalIndexer:
+    def __init__(
+        self,
+        store: Store,
+        source: RepoSource,
+        registry: PackRegistry,
+        repo: str,
+        commit: str = "",
+        resolve_scope_hops: int = 1,
+        dirty: DirtySet | None = None,
+        frameworks: FrameworkExtractor | None = None,
+        recorder: TemporalRecorder | None = None,
+        commit_ts: int = 0,
+    ) -> None:
+        self.store = store
+        self.source = source
+        self.registry = registry
+        self.repo = repo
+        self.commit = commit
+        self.resolve_scope_hops = resolve_scope_hops
+        self.dirty = dirty
+        self.frameworks = frameworks
+        # feat-009: optional evolution-log recorder (None when temporal off).
+        self.recorder = recorder
+        self.commit_ts = commit_ts
+
+    async def refresh(self, changes: ChangeSet) -> IndexReport:
+        if changes.is_empty():
+            return IndexReport()
+
+        # avoid an import cycle (pipeline imports nothing incremental)
+        from ..pipeline import IngestPipeline
+
+        removed = changes.removed_paths()
+        touched = set(changes.touched_paths())
+
+        # (0) feat-009: snapshot the symbols of every file the diff touches
+        # (removed + touched) *before* any mutation — diffing against the
+        # post-upsert set yields exactly the opened/closed lifecycle events.
+        before_symbols: set[str] = set()
+        if self.recorder is not None:
+            before_symbols = await self._symbols_in(sorted({*removed, *touched}))
+
+        # (1) symbols that will vanish with the removed files — dirty them now
+        dirty_ids: set[str] = await self._symbols_in(removed)
+
+        # (2) delete removed files from both stores
+        for path in removed:
+            await self.store.graph.delete_file(path)
+            await self.store.vectors.delete_where({"path": path})
+
+        # (3) re-extract + upsert the touched files (resolve deferred to (4));
+        # active framework packs re-emit their facts into the touched subgraphs.
+        report = await IngestPipeline(self.repo, self.commit, frameworks=self.frameworks).run(
+            self.source, self.store.graph, self.registry, paths=touched
+        )
+
+        # (4) scoped re-resolve: clear the scope's resolved edges, rebuild them
+        scope = await self._resolve_scope(changes)
+        await self.store.graph.clear_resolved(sorted(scope))
+        stats = await ImportResolver(
+            self.registry, self.commit, go_module=read_go_module(self.source.root)
+        ).resolve(self.store.graph, changed_files=sorted(scope))
+        report.resolve = stats
+        imports = stats.imports_resolved + stats.imports_external
+        report.by_edge_kind["IMPORTS"] = report.by_edge_kind.get("IMPORTS", 0) + imports
+        report.by_edge_kind["CALLS"] = report.by_edge_kind.get("CALLS", 0) + stats.refs_resolved
+        if stats.inherits_resolved:
+            report.by_edge_kind["INHERITS"] = (
+                report.by_edge_kind.get("INHERITS", 0) + stats.inherits_resolved
+            )
+        report.edges += imports + stats.refs_resolved + stats.inherits_resolved
+
+        # feat-011 pass-2: ORM RELATES_TO is globally idempotent (clear all +
+        # rebuild from the whole-repo model set), so a scoped refresh converges
+        # to the same edges a full re-index would produce.
+        if self.frameworks is not None and self.frameworks.active:
+            resolved, unresolved = await self.frameworks.resolve(self.store.graph, self.commit)
+            if resolved:
+                report.relations_resolved = resolved
+                report.by_edge_kind["RELATES_TO"] = (
+                    report.by_edge_kind.get("RELATES_TO", 0) + resolved
+                )
+                report.edges += resolved
+            report.framework_unresolved += unresolved
+
+        # (5) dirty propagation: touched symbols + 1-hop neighbours of all dirty
+        after_symbols = await self._symbols_in(sorted(touched))
+        dirty_ids |= after_symbols
+        dirty_ids |= await self._neighbours_of(dirty_ids)
+        if self.dirty is not None:
+            await self.dirty.add(sorted(dirty_ids))
+
+        # (6) feat-009: record lifecycle. opened = now present, weren't before;
+        # closed = were present, now gone (deleted files + symbols dropped from a
+        # modified file). Written in one transaction at flush.
+        if self.recorder is not None:
+            self.recorder.open(sorted(after_symbols - before_symbols), self.commit, self.commit_ts)
+            self.recorder.close(sorted(before_symbols - after_symbols), self.commit, self.commit_ts)
+            # churn/authorship for the touched files → aggregates + denormalised
+            # onto node attrs (feat-009 chunk 2).
+            await self.recorder.record_churn(
+                self.store.graph,
+                str(self.source.root),
+                sorted(touched),
+                self.commit,
+                self.commit_ts,
+            )
+            await self.recorder.flush()
+        return report
+
+    # --- helpers ----------------------------------------------------------
+
+    async def _all_nodes(self) -> list[Node]:
+        return (await self.store.graph.query(GraphQuery(limit=_ALL))).nodes
+
+    async def _symbols_in(self, paths: list[str]) -> set[str]:
+        """Code-symbol ids (Class/Function/Method) whose file is in ``paths``."""
+        if not paths:
+            return set()
+        want = set(paths)
+        kinds = {NodeKind.CLASS, NodeKind.FUNCTION, NodeKind.METHOD}
+        return {
+            n.id
+            for n in await self._all_nodes()
+            if n.kind in kinds and SymbolID.parse(n.id).path in want
+        }
+
+    async def _neighbours_of(self, ids: set[str]) -> set[str]:
+        out: set[str] = set()
+        for nid in ids:
+            for nb in await self.store.graph.neighbors(nid, None, depth=1):
+                out.add(nb.id)
+        return out
+
+    async def _resolve_scope(self, changes: ChangeSet) -> set[str]:
+        """``changed ∪ importers(changed)`` out to ``resolve_scope_hops`` hops
+        in the import graph. Importers are matched by *module key* (not by edge)
+        so added, deleted and modified files are handled uniformly — an importer
+        of an added file resolves to it now; an importer of a deleted file falls
+        back to an external package, exactly as a full re-index would."""
+        scope = set(changes.changed_paths())
+        # per-file imports as module keys, read from the current graph
+        file_imports = await self._file_import_keys()
+        frontier = self._module_keys(scope)
+        for _ in range(max(self.resolve_scope_hops, 0)):
+            importers = {
+                path for path, keys in file_imports.items() if keys & frontier and path not in scope
+            }
+            if not importers:
+                break
+            scope |= importers
+            frontier = self._module_keys(importers)
+        return scope
+
+    async def _file_import_keys(self) -> dict[str, set[str]]:
+        """For every FILE node, the set of module keys it imports (resolved the
+        same way the resolver resolves them)."""
+        out: dict[str, set[str]] = {}
+        for n in await self._all_nodes():
+            if n.kind is not NodeKind.FILE:
+                continue
+            path = SymbolID.parse(n.id).path
+            pack = self.registry.for_extension(PurePosixPath(path).suffix)
+            if pack is None:
+                continue
+            keys = {
+                pack.resolve_import(path, imp.get("module", ""))
+                for imp in n.attrs.get("imports", [])
+                if imp.get("module")
+            }
+            out[path] = keys
+        return out
+
+    def _module_keys(self, paths: set[str]) -> set[str]:
+        keys: set[str] = set()
+        for path in paths:
+            pack = self.registry.for_extension(PurePosixPath(path).suffix)
+            if pack is not None:
+                keys.add(pack.module_path(path))
+        return keys

agentforge_graph/ingest/incremental/meta.py

@@ -0,0 +1,72 @@
+"""``IndexMeta`` — the persisted ``.ckg/meta.json`` manifest (feat-004).
+
+Extends the minimal ``{schema_version, indexed_commit}`` that ``Store.open``
+writes on first open into the full state the next diff needs: the git commit
+the index was built at, a per-language pack fingerprint, and a per-file
+content-hash manifest. Saved atomically (temp + ``os.replace``) and **last**
+in a refresh, so a crash leaves the previous, consistent manifest in place and
+the refresh simply re-runs from the old commit.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from agentforge_graph.ingest.pack import LanguagePack
+from agentforge_graph.store.facade import STORE_SCHEMA_VERSION
+
+_META = "meta.json"
+
+
+def pack_fingerprint(pack: LanguagePack) -> str:
+    """A content fingerprint of everything about a pack that changes its
+    output: the two query files, the module style, and the descriptor map.
+    Bumping a ``.scm`` therefore changes the fingerprint and forces a full
+    re-index (correctness over speed) — no manual version bookkeeping."""
+    rules = ",".join(f"{k}={v.value}" for k, v in sorted(pack.descriptor_rules.kinds.items()))
+    blob = " ".join([pack.structure_queries, pack.reference_queries, pack.module_style, rules])
+    return hashlib.sha256(blob.encode("utf-8")).hexdigest()[:16]
+
+
+class IndexMeta(BaseModel):
+    """The on-disk index manifest. Unknown keys are ignored on load, so an
+    older ``meta.json`` (just ``schema_version`` + ``indexed_commit``) upgrades
+    cleanly — the missing fields default and repopulate on the next index."""
+
+    schema_version: int = STORE_SCHEMA_VERSION
+    indexed_commit: str = ""  # git HEAD at last index ("" if non-git)
+    pack_versions: dict[str, str] = Field(default_factory=dict)  # lang_slug -> fingerprint
+    files: dict[str, str] = Field(default_factory=dict)  # repo-rel path -> content_hash
+
+    @classmethod
+    def load(cls, root: str | Path) -> IndexMeta:
+        p = Path(root) / _META
+        if not p.exists():
+            return cls()
+        return cls.model_validate(json.loads(p.read_text()))
+
+    def save(self, root: str | Path) -> None:
+        p = Path(root) / _META
+        p.parent.mkdir(parents=True, exist_ok=True)
+        tmp = p.with_name(_META + ".tmp")
+        tmp.write_text(json.dumps(self.model_dump(), indent=2, sort_keys=True))
+        os.replace(tmp, p)  # atomic on POSIX; the manifest is never half-written
+
+    def is_indexed(self) -> bool:
+        """True once a real index exists (files recorded or a commit pinned)."""
+        return bool(self.files) or bool(self.indexed_commit)
+
+    def packs_changed(self, packs: list[LanguagePack]) -> bool:
+        """A pack fingerprint changed (or a new pack appeared) since last index
+        → extraction semantics differ, force a full rebuild."""
+        current = {p.lang_slug: pack_fingerprint(p) for p in packs}
+        return any(self.pack_versions.get(slug) != fp for slug, fp in current.items())
+
+    @staticmethod
+    def fingerprints(packs: list[LanguagePack]) -> dict[str, str]:
+        return {p.lang_slug: pack_fingerprint(p) for p in packs}

agentforge_graph/ingest/incremental/ports.py

@@ -0,0 +1,39 @@
+"""Ports the incremental indexer depends on but does not own (feat-009).
+
+The ``IncrementalIndexer`` records symbol lifecycle (opened/closed) as it
+applies a diff, but the deterministic ``ingest`` layer must not import the
+higher ``temporal`` layer (ADR-0001 spirit). So it depends on this structural
+``Protocol``; the concrete ``temporal.SqliteTemporalRecorder`` satisfies it.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from agentforge_graph.core import GraphStore
+
+
+@runtime_checkable
+class TemporalRecorder(Protocol):
+    """Write port for the evolution log. ``open``/``close`` buffer; ``flush``
+    persists in one transaction at end-of-refresh."""
+
+    def open(self, symbol_ids: Iterable[str], at: str, ts: int) -> None: ...
+
+    def close(self, symbol_ids: Iterable[str], at: str, ts: int) -> None: ...
+
+    async def record_churn(
+        self,
+        graph: GraphStore,
+        repo_root: str,
+        paths: Iterable[str],
+        commit: str,
+        commit_ts: int,
+    ) -> None:
+        """Mine churn/authorship for ``paths`` over a window, store the bounded
+        aggregates, and denormalise ``introduced/last_changed/churn_*/top_authors``
+        onto the matching node ``attrs`` (feat-009 §4.5). No-op off the git path."""
+
+    async def flush(self) -> None: ...

agentforge_graph/ingest/pack.py

@@ -0,0 +1,160 @@
+"""Language packs: everything language-specific about extraction, behind one
+shape so the extractor (extractor.py) stays language-agnostic.
+
+A pack pairs a tree-sitter grammar with two ``.scm`` query files and a small
+rule set mapping capture names to node kinds. The capture-name vocabulary is
+shared across packs (``def.class``, ``def.function``, ``def.method``,
+``name``, ``import``, ``import.module``, ``call``, ``call.callee``) so an
+edge kind means the same thing in every language.
+"""
+
+from __future__ import annotations
+
+import posixpath
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from agentforge_graph.core import NodeKind
+
+_INIT_BASENAMES = ("__init__.py", "__init__.pyi")  # a file that *is* its package
+
+
+class DescriptorRules(BaseModel):
+    """Maps a structure-query capture name (e.g. ``def.class``) to the node
+    kind it produces. Capture names prefixed ``def.`` mark definitions that
+    nest descriptors and own a ``CONTAINS`` subtree."""
+
+    kinds: dict[str, NodeKind] = Field(default_factory=dict)
+
+    def kind_for(self, capture: str) -> NodeKind | None:
+        return self.kinds.get(capture)
+
+
+class LanguagePack(BaseModel):
+    """A language's grammar + queries + descriptor rules."""
+
+    language: str  # human name, e.g. "python"
+    lang_slug: str  # symbol-ID language slug, e.g. "py"
+    grammar: str  # tree-sitter-language-pack grammar name
+    extensions: tuple[str, ...]  # file extensions, e.g. (".py",)
+    structure_queries: str  # .scm: defs/classes/imports
+    reference_queries: str  # .scm: calls/attribute refs
+    descriptor_rules: DescriptorRules = Field(default_factory=DescriptorRules)
+    # How imports name modules: "dotted" (Python `a.b.c`), "relative" (TS/JS path
+    # specifiers like `./util`), or "go" (a package is a *directory*; import paths
+    # are full module paths the resolver suffix-matches to a repo dir). Drives
+    # module_path + resolve_import.
+    module_style: Literal["dotted", "relative", "go"] = "dotted"
+    # When True, an in-repo import that names no symbols (e.g. Ruby
+    # `require_relative "./x"`) binds *all* of the target file's top-level defs
+    # into the importer's scope — a wildcard import. Off for explicit-name
+    # languages (Python/TS/JS) where a bare import is side-effect-only.
+    wildcard_import: bool = False
+    # When True (with module_style="relative"), a *bare* specifier (no `./`) is
+    # still resolved against the importer's directory rather than treated as an
+    # external package — Ruby `require_relative "thor/command"` is file-relative
+    # regardless of a leading `./`. Off for TS/JS where bare = npm package.
+    relative_bare: bool = False
+    # Separator for namespace/package FQN imports (PHP `\`, Java/C# `.`). When set,
+    # the resolver maps an FQN import (`use App\Foo\Bar`) to the file declaring that
+    # class via the file's namespace declaration + symbol name. "" = no FQN model.
+    namespace_sep: str = ""
+    # When True (C#), an import names a *namespace* (`using App.Geo`), not a class:
+    # resolve it to every in-repo file declaring that namespace and bind all their
+    # symbols. When False (PHP/Java), an import is a single class FQN.
+    namespace_import_prefix: bool = False
+    # When True (Rust), the file's "namespace" is derived from its path (the
+    # crate-relative module path, `src/a/b.rs` -> `a/b`) rather than a declaration,
+    # and a leading `crate::` is stripped from imports. Used with namespace_sep="::".
+    namespace_from_path: bool = False
+
+    def _strip_ext(self, path: str) -> str:
+        for ext in self.extensions:
+            if path.endswith(ext):
+                return path[: -len(ext)]
+        return path
+
+    def module_path(self, repo_relative_path: str) -> str:
+        """The module key a file is imported as. ``dotted``: ``a/b/c.py`` ->
+        ``a.b.c`` (drops a trailing ``__init__``). ``relative``: the
+        extension-stripped path, ``a/b/c.ts`` -> ``a/b/c``. ``go``: a package is
+        a directory, so the key is the file's *directory*, ``a/b/c.go`` ->
+        ``a/b`` (every ``.go`` file in a dir shares one package key)."""
+        no_ext = self._strip_ext(repo_relative_path)
+        if self.module_style == "go":
+            return posixpath.dirname(repo_relative_path)
+        if self.module_style == "relative":
+            return no_ext
+        segs = [s for s in no_ext.split("/") if s]
+        if segs and segs[-1] == "__init__":
+            segs = segs[:-1]
+        return ".".join(segs)
+
+    def resolve_import(self, importer_path: str, raw_module: str, importer_module: str = "") -> str:
+        """Map an import as written in ``importer_path`` to a module key
+        comparable to ``module_path``.
+
+        ``relative`` (TS/JS): a ``./``/``../`` specifier is resolved against the
+        importer's directory; a bare specifier (``react``) stays as-is (external).
+
+        ``dotted`` (Python): an absolute import (``a.b.c``) is identity; a
+        **relative** import (leading dots, e.g. ``.utils`` / ``..pkg.mod`` / ``.``)
+        is resolved against ``importer_module`` — the importer's own (source-root
+        stripped) module key — to an absolute key (BUG-004). One leading dot is the
+        importer's package; each extra dot ascends one level."""
+        if self.module_style == "go":
+            # A Go import is a full module path ("example.com/m/internal/bar").
+            # We can't know the go.mod module prefix here, so return it as-is;
+            # the resolver suffix-matches it against in-repo package dirs.
+            return raw_module
+        if self.module_style == "relative":
+            target = self._strip_ext(raw_module)
+            if target.startswith("./") or target.startswith("../") or self.relative_bare:
+                base = posixpath.dirname(importer_path)
+                return posixpath.normpath(posixpath.join(base, target))
+            return target
+        # dotted
+        dots = len(raw_module) - len(raw_module.lstrip("."))
+        if not dots:
+            return raw_module  # absolute dotted import: identity
+        remainder = raw_module[dots:]  # name after the dots: "utils", "pkg.mod", ""
+        segs = [s for s in importer_module.split(".") if s]
+        # a regular module file lives *in* its package; an __init__ file *is* it
+        if posixpath.basename(importer_path) not in _INIT_BASENAMES and segs:
+            segs = segs[:-1]
+        up = dots - 1  # the first dot is the importer's package; extras ascend
+        if up:
+            segs = segs[:-up] if up <= len(segs) else []
+        base = ".".join(segs)
+        if remainder:
+            return f"{base}.{remainder}" if base else remainder
+        return base
+
+
+class PackRegistry:
+    """Resolves a file to the pack that handles it, by extension."""
+
+    def __init__(self, packs: list[LanguagePack]) -> None:
+        self._packs = list(packs)
+        self._by_ext: dict[str, LanguagePack] = {}
+        self._by_lang: dict[str, LanguagePack] = {}
+        self._by_slug: dict[str, LanguagePack] = {}
+        for pack in packs:
+            self._by_lang[pack.language] = pack
+            self._by_slug[pack.lang_slug] = pack
+            for ext in pack.extensions:
+                self._by_ext[ext] = pack
+
+    @property
+    def packs(self) -> list[LanguagePack]:
+        return list(self._packs)
+
+    def for_extension(self, suffix: str) -> LanguagePack | None:
+        return self._by_ext.get(suffix)
+
+    def for_language(self, name: str) -> LanguagePack | None:
+        return self._by_lang.get(name)
+
+    def for_slug(self, slug: str) -> LanguagePack | None:
+        return self._by_slug.get(slug)

agentforge_graph/ingest/packs/__init__.py

@@ -0,0 +1,34 @@
+"""Built-in language packs. v0.1 ships Python/TypeScript/JavaScript/Go (Tier A);
+the rest of the top-10 languages land as follow-up packs over this same harness."""
+
+from __future__ import annotations
+
+from agentforge_graph.ingest.pack import PackRegistry
+
+from .cpp import CPP_PACK
+from .csharp import CSHARP_PACK
+from .go import GO_PACK
+from .java import JAVA_PACK
+from .javascript import JAVASCRIPT_PACK
+from .php import PHP_PACK
+from .python import PYTHON_PACK
+from .ruby import RUBY_PACK
+from .rust import RUST_PACK
+from .typescript import TYPESCRIPT_PACK
+
+BUILTIN_PACKS = [
+    PYTHON_PACK,
+    TYPESCRIPT_PACK,
+    JAVASCRIPT_PACK,
+    GO_PACK,
+    RUBY_PACK,
+    PHP_PACK,
+    JAVA_PACK,
+    CSHARP_PACK,
+    CPP_PACK,
+    RUST_PACK,
+]
+
+
+def builtin_registry() -> PackRegistry:
+    return PackRegistry(BUILTIN_PACKS)

agentforge_graph/ingest/packs/cpp/__init__.py

@@ -0,0 +1,35 @@
+"""The C++ language pack (Tier B — structure + heuristic refs).
+
+Tier B per the language scope: comprehensive symbol extraction (classes, structs,
+enums, free functions, methods) + quoted `#include` resolution, but reference
+resolution is heuristic — C++'s overloading, templates, and `obj.method()` /
+`ns::fn()` member access keep most calls unresolved (ADR-0004). Quoted includes
+(`#include "geo/shape.h"`) are resolved relative to the including file (a bare
+path, like Ruby); `<system>` includes are skipped.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from agentforge_graph.core import NodeKind
+from agentforge_graph.ingest.pack import DescriptorRules, LanguagePack
+
+_HERE = Path(__file__).parent
+
+CPP_PACK = LanguagePack(
+    language="cpp",
+    lang_slug="cpp",
+    grammar="cpp",
+    extensions=(".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx", ".h"),
+    structure_queries=(_HERE / "structure.scm").read_text(encoding="utf-8"),
+    reference_queries=(_HERE / "references.scm").read_text(encoding="utf-8"),
+    descriptor_rules=DescriptorRules(
+        kinds={
+            "def.class": NodeKind.CLASS,  # class + struct + enum
+            "def.function": NodeKind.FUNCTION,  # free fn + method (promoted in a class)
+        }
+    ),
+    module_style="relative",  # `#include "geo/shape.h"` resolved relative to the file
+    relative_bare=True,  # includes have no leading `./`
+)

agentforge_graph/ingest/packs/cpp/references.scm

@@ -0,0 +1,15 @@
+; C++ reference queries (feat-002, pack-cpp; Tier B — heuristic).
+; Plain call `f(...)`; member/arrow calls (`this->f()`, `obj.f()`, `ptr->f()`)
+; capture the receiver so `this->f()` binds to a method of the enclosing class;
+; any other receiver is left unresolved (member access, ADR-0004). `ns::f()`
+; qualified calls are not captured here.
+
+(call_expression
+  function: (identifier) @call.callee) @call
+
+; `this->f()` / `obj.f()` / `ptr->f()` — the receiver is the field_expression's
+; argument (`this` is a named node, captured by `(_)`).
+(call_expression
+  function: (field_expression
+    argument: (_) @call.recv
+    field: (field_identifier) @call.callee)) @call

agentforge_graph/ingest/packs/cpp/structure.scm

@@ -0,0 +1,49 @@
+; C++ structure queries (feat-002, pack-cpp; Tier B — structure + heuristic refs).
+; Namespaces are scopes, not captured as defs (so free functions inside them stay
+; Function, not Method). Header/impl split: methods are declared in the class body
+; and may be defined out-of-line as `Type::method`.
+
+; --- definitions ---
+(class_specifier
+  name: (type_identifier) @name) @def.class
+
+(struct_specifier
+  name: (type_identifier) @name) @def.class
+
+(enum_specifier
+  name: (type_identifier) @name) @def.class
+
+; free function definition: `double compute(double x) { … }`
+(function_definition
+  declarator: (function_declarator
+    declarator: (identifier) @name)) @def.function
+
+; out-of-line method definition: `double Circle::area() const { … }`
+(function_definition
+  declarator: (function_declarator
+    declarator: (qualified_identifier
+      name: (identifier) @name))) @def.function
+
+; in-class method declaration: `double area() const;`
+(field_declaration
+  declarator: (function_declarator
+    declarator: (field_identifier) @name)) @def.function
+
+; in-class *inline* method definition: `double area() const { … }`. The name is a
+; field_identifier (unlike a free function's plain identifier), so this is a
+; distinct pattern; the extractor promotes it to METHOD because its enclosing
+; scope is the class body. Without this the inline method — and any `this->f()`
+; calls in its body — had no symbol to attach to (BUG-006 residual).
+(function_definition
+  declarator: (function_declarator
+    declarator: (field_identifier) @name)) @def.function
+
+; constructor/destructor declaration: `Circle(double r);`
+(declaration
+  declarator: (function_declarator
+    declarator: (identifier) @name)) @def.function
+
+; --- imports ---
+; `#include "geo/shape.h"` (quoted -> in-repo, relative). `<system>` is skipped.
+(preproc_include
+  (string_literal (string_content) @import.module)) @import

agentforge_graph/ingest/packs/csharp/__init__.py

@@ -0,0 +1,35 @@
+"""The C# language pack (Tier A — structure + namespace-prefix resolution).
+
+C# differs from PHP/Java: `using App.Geo` imports a *namespace* (not a class), so
+it resolves to every in-repo file declaring that namespace (and binds all their
+symbols), rather than to one class FQN. Extracts class/struct/enum/record
+(→Class), interface (→Interface), methods + constructors. Member calls
+(`obj.M()`) stay unresolved (ADR-0004).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from agentforge_graph.core import NodeKind
+from agentforge_graph.ingest.pack import DescriptorRules, LanguagePack
+
+_HERE = Path(__file__).parent
+
+CSHARP_PACK = LanguagePack(
+    language="csharp",
+    lang_slug="cs",
+    grammar="csharp",
+    extensions=(".cs",),
+    structure_queries=(_HERE / "structure.scm").read_text(encoding="utf-8"),
+    reference_queries=(_HERE / "references.scm").read_text(encoding="utf-8"),
+    descriptor_rules=DescriptorRules(
+        kinds={
+            "def.class": NodeKind.CLASS,  # class + struct + enum + record
+            "def.interface": NodeKind.INTERFACE,
+            "def.function": NodeKind.FUNCTION,  # method + constructor (promoted)
+        }
+    ),
+    namespace_sep=".",
+    namespace_import_prefix=True,  # `using App.Geo` = a namespace, not a class
+)

agentforge_graph/ingest/packs/csharp/references.scm

@@ -0,0 +1,12 @@
+; C# reference queries (feat-002, pack-csharp).
+; Plain call `F(...)` and member call `obj.F(...)`. @call.recv captures the
+; receiver so `this.F()` binds to the enclosing class's method (BUG-006); other
+; receivers stay unresolved (member access, ADR-0004).
+
+(invocation_expression
+  function: (identifier) @call.callee) @call
+
+(invocation_expression
+  function: (member_access_expression
+    expression: _ @call.recv
+    name: (identifier) @call.callee)) @call