omninode-intelligence 0.16.1__tar.gz → 0.16.2__tar.gz

omninode_intelligence-0.16.2/.github/workflows/check-handshake.yml

@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
+# SPDX-License-Identifier: MIT
+name: Check Architecture Handshake
+
+on:
+  push:
+    branches: [main, develop]
+    paths:
+      - '.claude/architecture-handshake.md'
+      - '.github/workflows/check-handshake.yml'
+  pull_request:
+    branches: [main, develop]
+    paths:
+      - '.claude/architecture-handshake.md'
+      - '.github/workflows/check-handshake.yml'
+  merge_group:
+  workflow_dispatch:
+
+jobs:
+  check-handshake:
+    name: Check architecture handshake
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v6
+
+      - name: Checkout omnibase_core
+        uses: actions/checkout@v6
+        with:
+          repository: OmniNode-ai/omnibase_core
+          # Pinned to omnibase_core main as of 2026-03-22.
+          # Update by running: gh api repos/OmniNode-ai/omnibase_core/commits/main --jq '.sha'
+          ref: 330a344cdb9c5dedd04a46dfbb0b63dae0baccfb
+          path: omnibase_core
+
+      - name: Verify omnibase_core checkout
+        run: |
+          if [ ! -f omnibase_core/architecture-handshakes/check-handshake.sh ]; then
+            echo "::error::Failed to checkout omnibase_core or check-handshake.sh not found."
+            exit 1
+          fi
+
+      - name: Check architecture handshake
+        run: bash omnibase_core/architecture-handshakes/check-handshake.sh

{omninode_intelligence-0.16.1 → omninode_intelligence-0.16.2}/.github/workflows/security-scan.yml

@@ -1,9 +1,9 @@
 # SPDX-FileCopyrightText: 2025 OmniNode.ai Inc.
 # SPDX-License-Identifier: MIT
 #
-# CodeQL security and quality analysis for omniintelligence.
+# CodeQL security and quality analysis for omnibase_core.
 # Calls the reusable workflow in onex_change_control.
-# OMN-5423
+# OMN-5421
 
 name: Security Scan
 

{omninode_intelligence-0.16.1 → omninode_intelligence-0.16.2}/.secrets.baseline

@@ -496,5 +496,5 @@
       }
     ]
   },
-  "generated_at": "2026-03-03T23:38:25Z"
+  "generated_at": "2026-03-22T18:30:49Z"
 }

{omninode_intelligence-0.16.1 → omninode_intelligence-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omninode-intelligence
-Version: 0.16.1
+Version: 0.16.2
 Summary: Intelligence, indexing, and pattern services as first-class Omninode nodes
 Project-URL: Homepage, https://github.com/OmniNode-ai/omniintelligence
 Project-URL: Repository, https://github.com/OmniNode-ai/omniintelligence

{omninode_intelligence-0.16.1 → omninode_intelligence-0.16.2}/pyproject.toml

@@ -17,7 +17,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "omninode-intelligence"
-version = "0.16.1"
+version = "0.16.2"
 description = "Intelligence, indexing, and pattern services as first-class Omninode nodes"
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
@@ -92,7 +92,7 @@ core = [
     # ONEX private ecosystem dependencies (NOT on public PyPI)
     # Installed via editable installs from sibling repos or private registry.
     # Version bounds match Poetry caret syntax above.
-    "omnibase-core==0.29.0",
+    "omnibase-core>=0.30.1",
     "omnibase-spi==0.18.0",
     "omnibase-infra==0.22.0",
     "pydantic>=2.12.5,<3.0.0",
@@ -356,3 +356,10 @@ markers = [
     "intent_graph: marks tests for intent graph accumulation logic",
     "transition: marks tests for intent transition edge accumulation",
 ]
+
+[tool.uv]
+# Override omnibase-infra's transitive pins on core/spi so our direct pins win.
+override-dependencies = [
+    "omnibase-core>=0.30.1",
+    "omnibase-spi==0.18.0",
+]

{omninode_intelligence-0.16.1 → omninode_intelligence-0.16.2}/src/omniintelligence/api/model_pattern_query_response.py

@@ -58,6 +58,10 @@ class ModelPatternQueryResponse(BaseModel):
         description="Whether this is the current version",
     )
     version: int = Field(default=1, ge=1, description="Pattern version number")
+    project_scope: str | None = Field(
+        default=None,
+        description="Optional project scope for pattern isolation (OMN-1607)",
+    )
     created_at: datetime = Field(..., description="Row creation timestamp")
 
 

{omninode_intelligence-0.16.1 → omninode_intelligence-0.16.2}/src/omniintelligence/nodes/node_ast_extraction_compute/handlers/handler_extract_ast.py

@@ -8,9 +8,18 @@ from Python source using the stdlib ast module. All entities have
 confidence=1.0 (AST is authoritative for Python source).
 
 Trust tiers:
-- conservative: INHERITS, IMPORTS (syntactically certain)
+- strong: INHERITS, IMPORTS (syntactically certain)
 - moderate: CONTAINS, DEFINES (structural)
 - weak: CALLS (behavioral, best-effort)
+
+Field mapping (aligned with ModelCodeEntity contract):
+- id: UUID string
+- entity_name: simple name
+- entity_type: class/function/import/constant/module
+- qualified_name: dotted module path
+- source_path: file path relative to repo
+- line_number: starting line
+- file_hash: SHA256 of source content
 """
 
 from __future__ import annotations
@@ -18,10 +27,9 @@ from __future__ import annotations
 import ast
 import hashlib
 import logging
+import uuid
 from dataclasses import dataclass, field
-from uuid import uuid4
 
-from omniintelligence.enums import EnumEntityType, EnumRelationshipType
 from omniintelligence.nodes.node_ast_extraction_compute.models.model_code_entity import (
     ModelCodeEntity,
 )
@@ -32,13 +40,9 @@ from omniintelligence.nodes.node_ast_extraction_compute.models.model_code_relati
 logger = logging.getLogger(__name__)
 
 
-def _make_entity_id(prefix: str, name: str) -> str:
-    """Generate a deterministic entity ID."""
-    return f"{prefix}_{name}"
-
-
-def _make_rel_id() -> str:
-    return f"rel_{uuid4().hex[:12]}"
+def _make_id() -> str:
+    """Generate a UUID string."""
+    return str(uuid.uuid4())
 
 
 def _get_docstring(node: ast.AST) -> str | None:
@@ -64,6 +68,22 @@ def _get_decorators(
     return decorators
 
 
+def _file_path_to_module(file_path: str) -> str:
+    """Convert a file path to a dotted module path.
+
+    ``src/omniintelligence/nodes/foo/node.py``
+    becomes ``omniintelligence.nodes.foo.node``.
+    """
+    path = file_path.replace("\\", "/")
+    if path.startswith("src/"):
+        path = path[4:]
+    if path.endswith(".py"):
+        path = path[:-3]
+    if path.endswith("/__init__"):
+        path = path[: -len("/__init__")]
+    return path.replace("/", ".")
+
+
 @dataclass
 class AstExtractionResult:
     """Result of AST extraction for a single file."""
@@ -100,39 +120,48 @@ def extract_entities_from_source(
         return AstExtractionResult()
 
     result = AstExtractionResult()
+    module_path = _file_path_to_module(file_path)
 
     # Module-level entity
-    module_name = file_path.replace("/", ".").removesuffix(".py")
-    module_id = _make_entity_id("mod", module_name)
     result.entities.append(
         ModelCodeEntity(
-            entity_id=module_id,
-            entity_type=EnumEntityType.MODULE,
-            name=module_name,
-            file_path=file_path,
-            file_hash=file_hash,
+            id=_make_id(),
+            entity_name=module_path,
+            entity_type="module",
+            qualified_name=module_path,
             source_repo=source_repo,
-            line_start=0,
-            line_end=len(source_code.splitlines()),
+            source_path=file_path,
+            line_number=1,
+            file_hash=file_hash,
         )
     )
 
     for node in ast.iter_child_nodes(tree):
         if isinstance(node, ast.ClassDef):
             _extract_class(
-                node, result, file_path, file_hash, source_repo, module_id, source_code
+                node,
+                result,
+                file_path,
+                file_hash,
+                source_repo,
+                module_path,
+                source_code,
             )
         elif isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
             _extract_function(
-                node, result, file_path, file_hash, source_repo, module_id, source_code
+                node, result, file_path, file_hash, source_repo, module_path
             )
         elif isinstance(node, ast.Import):
-            _extract_import(node, result, module_id)
+            _extract_import(
+                node, result, module_path, source_repo, file_path, file_hash
+            )
         elif isinstance(node, ast.ImportFrom):
-            _extract_import_from(node, result, module_id)
+            _extract_import_from(
+                node, result, module_path, source_repo, file_path, file_hash
+            )
         elif isinstance(node, ast.Assign):
             _extract_constant(
-                node, result, file_path, file_hash, source_repo, module_id
+                node, result, file_path, file_hash, source_repo, module_path
             )
 
     return result
@@ -144,11 +173,11 @@ def _extract_class(
     file_path: str,
     file_hash: str,
     source_repo: str,
-    module_id: str,
+    module_path: str,
     source_code: str,
 ) -> None:
-    class_id = _make_entity_id("cls", node.name)
     bases = [ast.unparse(b) for b in node.bases]
+    qualified = f"{module_path}.{node.name}"
     methods: list[str] = []
 
     for item in node.body:
@@ -157,76 +186,80 @@ def _extract_class(
 
     result.entities.append(
         ModelCodeEntity(
-            entity_id=class_id,
-            entity_type=EnumEntityType.CLASS,
-            name=node.name,
-            file_path=file_path,
-            file_hash=file_hash,
+            id=_make_id(),
+            entity_name=node.name,
+            entity_type="class",
+            qualified_name=qualified,
             source_repo=source_repo,
-            line_start=node.lineno - 1,
-            line_end=node.end_lineno or node.lineno,
+            source_path=file_path,
+            line_number=node.lineno,
             bases=bases,
-            methods=methods,
+            methods=[{"name": m} for m in methods],
             decorators=_get_decorators(node),
             docstring=_get_docstring(node),
-            source_code=ast.get_source_segment(source_code, node),
+            file_hash=file_hash,
         )
     )
 
     # CONTAINS: module -> class
     result.relationships.append(
         ModelCodeRelationship(
-            relationship_id=_make_rel_id(),
-            source_entity_id=module_id,
-            target_entity_id=class_id,
-            relationship_type=EnumRelationshipType.CONTAINS,
+            id=_make_id(),
+            source_entity=module_path,
+            target_entity=qualified,
+            relationship_type="contains",
             trust_tier="moderate",
+            confidence=1.0,
+            evidence=[f"module contains class {node.name}"],
         )
     )
 
     # INHERITS: class -> each base
     for base_name in bases:
-        base_id = _make_entity_id("cls", base_name)
         result.relationships.append(
             ModelCodeRelationship(
-                relationship_id=_make_rel_id(),
-                source_entity_id=class_id,
-                target_entity_id=base_id,
-                relationship_type=EnumRelationshipType.EXTENDS,
-                trust_tier="conservative",
+                id=_make_id(),
+                source_entity=qualified,
+                target_entity=base_name,
+                relationship_type="inherits",
+                trust_tier="strong",
+                confidence=1.0,
+                evidence=[f"class {node.name}({base_name})"],
             )
         )
 
     # DEFINES: class -> method (extract methods as entities too)
     for item in node.body:
         if isinstance(item, ast.FunctionDef | ast.AsyncFunctionDef):
-            method_id = _make_entity_id("fn", f"{node.name}.{item.name}")
+            method_qualified = f"{qualified}.{item.name}"
             result.entities.append(
                 ModelCodeEntity(
-                    entity_id=method_id,
-                    entity_type=EnumEntityType.FUNCTION,
-                    name=f"{node.name}.{item.name}",
-                    file_path=file_path,
-                    file_hash=file_hash,
+                    id=_make_id(),
+                    entity_name=f"{node.name}.{item.name}",
+                    entity_type="function",
+                    qualified_name=method_qualified,
                     source_repo=source_repo,
-                    line_start=item.lineno - 1,
-                    line_end=item.end_lineno or item.lineno,
+                    source_path=file_path,
+                    line_number=item.lineno,
                     decorators=_get_decorators(item),
                     docstring=_get_docstring(item),
+                    file_hash=file_hash,
                 )
             )
             result.relationships.append(
                 ModelCodeRelationship(
-                    relationship_id=_make_rel_id(),
-                    source_entity_id=class_id,
-                    target_entity_id=method_id,
-                    relationship_type=EnumRelationshipType.DEFINES,
+                    id=_make_id(),
+                    source_entity=qualified,
+                    target_entity=method_qualified,
+                    relationship_type="defines",
                     trust_tier="moderate",
+                    confidence=1.0,
+                    evidence=[f"class {node.name} defines method {item.name}"],
                 )
             )
 
             # CALLS: best-effort extraction from method body
-            _extract_calls(item, result, method_id)
+            _extract_calls(item, result, method_qualified)
 
 
 def _extract_function(
@@ -235,56 +268,72 @@ def _extract_function(
     file_path: str,
     file_hash: str,
     source_repo: str,
-    module_id: str,
-    source_code: str,
+    module_path: str,
 ) -> None:
-    fn_id = _make_entity_id("fn", node.name)
+    qualified = f"{module_path}.{node.name}"
 
     result.entities.append(
         ModelCodeEntity(
-            entity_id=fn_id,
-            entity_type=EnumEntityType.FUNCTION,
-            name=node.name,
-            file_path=file_path,
-            file_hash=file_hash,
+            id=_make_id(),
+            entity_name=node.name,
+            entity_type="function",
+            qualified_name=qualified,
             source_repo=source_repo,
-            line_start=node.lineno - 1,
-            line_end=node.end_lineno or node.lineno,
+            source_path=file_path,
+            line_number=node.lineno,
             decorators=_get_decorators(node),
             docstring=_get_docstring(node),
-            source_code=ast.get_source_segment(source_code, node),
+            file_hash=file_hash,
         )
     )
 
     # CONTAINS: module -> function
     result.relationships.append(
         ModelCodeRelationship(
-            relationship_id=_make_rel_id(),
-            source_entity_id=module_id,
-            target_entity_id=fn_id,
-            relationship_type=EnumRelationshipType.CONTAINS,
+            id=_make_id(),
+            source_entity=module_path,
+            target_entity=qualified,
+            relationship_type="contains",
             trust_tier="moderate",
+            confidence=1.0,
+            evidence=[f"module contains function {node.name}"],
         )
     )
 
     # CALLS: best-effort extraction
-    _extract_calls(node, result, fn_id)
+    _extract_calls(node, result, qualified)
 
 
 def _extract_import(
     node: ast.Import,
     result: AstExtractionResult,
-    module_id: str,
+    module_path: str,
+    source_repo: str,
+    file_path: str,
+    file_hash: str,
 ) -> None:
     for alias in node.names:
-        target_id = _make_entity_id("mod", alias.name)
+        result.entities.append(
+            ModelCodeEntity(
+                id=_make_id(),
+                entity_name=alias.name,
+                entity_type="import",
+                qualified_name=alias.name,
+                source_repo=source_repo,
+                source_path=file_path,
+                line_number=node.lineno,
+                file_hash=file_hash,
+            )
+        )
         result.relationships.append(
             ModelCodeRelationship(
-                relationship_id=_make_rel_id(),
-                source_entity_id=module_id,
-                target_entity_id=target_id,
-                relationship_type=EnumRelationshipType.IMPORTS,
-                trust_tier="conservative",
+                id=_make_id(),
+                source_entity=module_path,
+                target_entity=alias.name,
+                relationship_type="imports",
+                trust_tier="strong",
+                confidence=1.0,
+                evidence=[f"import {alias.name}"],
             )
         )
 
@@ -292,19 +341,37 @@ def _extract_import(
 def _extract_import_from(
     node: ast.ImportFrom,
     result: AstExtractionResult,
-    module_id: str,
+    module_path: str,
+    source_repo: str,
+    file_path: str,
+    file_hash: str,
 ) -> None:
     if node.module:
-        target_id = _make_entity_id("mod", node.module)
-        result.relationships.append(
-            ModelCodeRelationship(
-                relationship_id=_make_rel_id(),
-                source_entity_id=module_id,
-                target_entity_id=target_id,
-                relationship_type=EnumRelationshipType.IMPORTS,
-                trust_tier="conservative",
+        for alias in node.names:
+            target = node.module if alias.name == "*" else f"{node.module}.{alias.name}"
+            result.entities.append(
+                ModelCodeEntity(
+                    id=_make_id(),
+                    entity_name=alias.name,
+                    entity_type="import",
+                    qualified_name=target,
+                    source_repo=source_repo,
+                    source_path=file_path,
+                    line_number=node.lineno,
+                    file_hash=file_hash,
+                )
+            )
+            result.relationships.append(
+                ModelCodeRelationship(
+                    id=_make_id(),
+                    source_entity=module_path,
+                    target_entity=target,
+                    relationship_type="imports",
+                    trust_tier="strong",
+                    confidence=1.0,
+                    evidence=[f"from {node.module} import {alias.name}"],
+                )
             )
-        )
 
 
 def _extract_constant(
@@ -313,30 +380,32 @@ def _extract_constant(
     file_path: str,
     file_hash: str,
     source_repo: str,
-    module_id: str,
+    module_path: str,
 ) -> None:
     for target in node.targets:
         if isinstance(target, ast.Name) and target.id.isupper():
-            const_id = _make_entity_id("const", target.id)
+            qualified = f"{module_path}.{target.id}"
             result.entities.append(
                 ModelCodeEntity(
-                    entity_id=const_id,
-                    entity_type=EnumEntityType.CONSTANT,
-                    name=target.id,
-                    file_path=file_path,
-                    file_hash=file_hash,
+                    id=_make_id(),
+                    entity_name=target.id,
+                    entity_type="constant",
+                    qualified_name=qualified,
                     source_repo=source_repo,
-                    line_start=node.lineno - 1,
-                    line_end=node.end_lineno or node.lineno,
+                    source_path=file_path,
+                    line_number=node.lineno,
+                    file_hash=file_hash,
                 )
             )
             result.relationships.append(
                 ModelCodeRelationship(
-                    relationship_id=_make_rel_id(),
-                    source_entity_id=module_id,
-                    target_entity_id=const_id,
-                    relationship_type=EnumRelationshipType.DEFINES,
+                    id=_make_id(),
+                    source_entity=module_path,
+                    target_entity=qualified,
+                    relationship_type="defines",
                     trust_tier="moderate",
+                    confidence=1.0,
+                    evidence=[f"module defines constant {target.id}"],
                 )
             )
 
@@ -344,7 +413,7 @@ def _extract_constant(
 def _extract_calls(
     node: ast.FunctionDef | ast.AsyncFunctionDef,
     result: AstExtractionResult,
-    source_id: str,
+    source_qualified: str,
 ) -> None:
     """Best-effort extraction of function calls from a function body."""
     for child in ast.walk(node):
@@ -356,14 +425,16 @@ def _extract_calls(
                 callee_name = child.func.attr
 
             if callee_name:
-                target_id = _make_entity_id("fn", callee_name)
                 result.relationships.append(
                     ModelCodeRelationship(
-                        relationship_id=_make_rel_id(),
-                        source_entity_id=source_id,
-                        target_entity_id=target_id,
-                        relationship_type=EnumRelationshipType.CALLS,
+                        id=_make_id(),
+                        source_entity=source_qualified,
+                        target_entity=callee_name,
+                        relationship_type="calls",
                         trust_tier="weak",
+                        confidence=0.5,
+                        evidence=[f"calls {callee_name}"],
+                        inject_into_context=False,
                     )
                 )
 

{omninode_intelligence-0.16.1 → omninode_intelligence-0.16.2}/src/omniintelligence/review_pairing/adapters/__init__.py

@@ -13,12 +13,22 @@ Supported sources (Phase 1 — deterministic):
     eslint     — ESLint JSON output (``eslint --format json``)
     github     — GitHub Checks API annotations (via REST API)
 
-Stub sources (documented interface, not yet implemented):
-    ai_reviewer — AI reviewer comments (interface contract only)
+AI-backed sources (Phase 2 -- probabilistic):
+    ai_reviewer — LLM-backed adversarial review (OMN-5790)
+    codex_reviewer -- Codex CLI adversarial review (OMN-5792)
 
 Reference: OMN-2542
 """
 
+from omniintelligence.review_pairing.adapters.adapter_ai_reviewer import (
+    async_parse_raw as async_parse_ai_reviewer,
+)
+from omniintelligence.review_pairing.adapters.adapter_ai_reviewer import (
+    parse_raw as parse_ai_reviewer,
+)
+from omniintelligence.review_pairing.adapters.adapter_codex_reviewer import (
+    async_parse_raw as async_parse_codex_reviewer,
+)
 from omniintelligence.review_pairing.adapters.adapter_eslint import (
     parse_raw as parse_eslint,
 )
@@ -33,6 +43,9 @@ from omniintelligence.review_pairing.adapters.adapter_ruff import (
 )
 
 __all__ = [
+    "async_parse_ai_reviewer",
+    "async_parse_codex_reviewer",
+    "parse_ai_reviewer",
     "parse_eslint",
     "parse_github_checks",
     "parse_mypy",