dialectical-framework 1.4.0__tar.gz → 1.4.2__tar.gz

{dialectical_framework-1.4.0 → dialectical_framework-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 1.4.0
+Version: 1.4.2
 Summary: A dialectical framework for augmented intelligence. AI reasoning powered with dialectics supports humans in: system optimization (psychology, engineering, business, politics, etc.); dispute resolution (mediation, conflicts, negotiations, etc.); decision-making (dilemmas, challenging situations, win-win, etc.).
 License: MIT
 Keywords: dialectics,dialectical-reasoning,synthesis,thesis-antithesis,ai,artificial-intelligence,llm,reasoning-framework,philosophy,logic,argumentation,conflict-resolution,decision-making,critical-thinking,semantic-graph,mirascope,pydantic,perspectives,polarity-reasoning

{dialectical_framework-1.4.0 → dialectical_framework-1.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "1.4.0"
+version = "1.4.2"
 description = "A dialectical framework for augmented intelligence. AI reasoning powered with dialectics supports humans in: system optimization (psychology, engineering, business, politics, etc.); dispute resolution (mediation, conflicts, negotiations, etc.); decision-making (dilemmas, challenging situations, win-win, etc.)."
 authors = ["Evaldas Taroza <evaldas@dialexity.com>"]
 readme = "README.md"

dialectical_framework-1.4.2/src/dialectical_framework/agents/orchestrator/tools/digest_input.py

@@ -0,0 +1,28 @@
+"""
+digest_input: Tool for generating/refining the living digest of an Input source.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from mirascope import llm
+from pydantic import Field
+
+from dialectical_framework.concerns.source_digest import SourceDigest
+
+
+@llm.tool
+async def digest_input(
+    input_hash: Annotated[str, Field(description="Hash of the Input node to digest")],
+    context: Annotated[
+        str,
+        Field(
+            description="Direction for the digest: user guidance, framework state, or focus instructions"
+        ),
+    ] = "",
+) -> str:
+    """Generate or refine the analytical digest of an input source. Use to build initial understanding of new inputs, or to sharpen the digest with user direction or framework learnings."""
+    concern = SourceDigest()
+    await concern.resolve(input_hash=input_hash, context=context)
+    return str(concern.report)

{dialectical_framework-1.4.0 → dialectical_framework-1.4.2}/src/dialectical_framework/concerns/add_input.py

@@ -28,6 +28,16 @@ class AddInput(ReasonableConcern[Input]):
 
         input_node = Input(content=content)
         input_node.commit()
+
+        already_connected = any(
+            node._id == input_node._id for node, _ in case.inputs.all()
+        )
+        if already_connected:
+            self._report.ok = True
+            self._report.summary = f"Input {input_node.short_hash} already exists"
+            self._report.artifacts["input_hash"] = input_node.short_hash
+            return input_node
+
         case.inputs.connect(input_node)
 
         self._report.node_created(input_node)

{dialectical_framework-1.4.0 → dialectical_framework-1.4.2}/src/dialectical_framework/concerns/source_digest.py

@@ -3,30 +3,39 @@ SourceDigest: Concern for generating and refining the living digest of an Input
 
 The digest is the framework's evolving understanding of a source — not a naked summary,
 but a directed analytical document shaped by both the source material and user/framework
-guidance. It focuses on dialectical material: tensions, oppositions, values, assertions.
+guidance.
 
-Usage:
-    # Initial digest
+Programmatic usage:
     concern = SourceDigest()
-    digest = await concern.resolve(content="Full text of the article...")
+    input_node = await concern.resolve(input_hash="abc123")
 
     # Refine with context
     concern = SourceDigest()
-    digest = await concern.resolve(
-        content="Full text...",
-        existing_digest="Previous understanding...",
+    input_node = await concern.resolve(
+        input_hash="abc123",
         context="User says: focus on regulatory tensions",
     )
 """
 
 from __future__ import annotations
 
+from typing import Union
+
+from dependency_injector.wiring import Provide, inject
+from gqlalchemy import Memgraph, Neo4j
 from pydantic import BaseModel, Field
 
 from dialectical_framework.agents.conversation_facilitator import \
     ConversationFacilitator
 from dialectical_framework.agents.reasonable_concern import ReasonableConcern
+from dialectical_framework.enums.di import DI
+from dialectical_framework.graph.nodes.input import Input
+from dialectical_framework.graph.repositories.node_repository import \
+    NodeRepository
 from dialectical_framework.protocols.has_config import SettingsAware
+from dialectical_framework.protocols.input_resolver import InputResolver
+
+DIGEST_THRESHOLD = 1500
 
 SYSTEM_PROMPT = """You are an analytical reader producing a **digest** — a living document that captures understanding of a source.
 
@@ -50,44 +59,73 @@ class DigestDto(BaseModel):
     """Structured output for digest generation."""
 
     digest: str = Field(
-        description="The analytical digest text — focused on dialectical material"
+        description="The analytical digest text"
     )
     reasoning: str = Field(
         description="Brief explanation of what was emphasized and why"
     )
 
 
-class SourceDigest(ReasonableConcern[str], SettingsAware):
+class SourceDigest(ReasonableConcern[Input], SettingsAware):
     """
-    Generates or refines the analytical digest of an Input source.
+    Generates or refines the analytical digest for an Input node.
 
-    The digest captures the framework's evolving understanding of a source,
-    shaped by both the content itself and any direction from the user or
-    framework state (perspectives discovered, user guidance, etc.).
+    Resolves the full content, applies threshold logic (short content
+    is used as its own digest without an LLM call), then persists the
+    result back to the Input's digest field.
+
+    Programmatic usage:
+        concern = SourceDigest()
+        input_node = await concern.resolve(input_hash="abc123", context="focus on X")
     """
 
     def __init__(self) -> None:
         self._conversation = ConversationFacilitator()
 
+    @inject
     async def resolve(
+        self,
+        input_hash: str,
+        context: str = "",
+        input_resolver: InputResolver = Provide[DI.input_resolver],
+        graph_db: Union[Memgraph, Neo4j] = Provide[DI.graph_db],
+    ) -> Input:
+        repo = NodeRepository()
+        input_node = repo.find_by_hash(input_hash, node_type=Input)
+
+        if not input_node:
+            raise ValueError(f"Input not found: {input_hash}")
+
+        resolved_content = await input_resolver.resolve(input_node)
+        if not resolved_content:
+            raise ValueError(f"Input {input_hash} has no resolvable content")
+
+        if len(resolved_content) <= DIGEST_THRESHOLD and not input_node.digest:
+            new_digest = resolved_content
+            self._report.summary = f"Content compact enough to use as digest for input {input_node.short_hash}"
+        else:
+            new_digest = await self._generate_digest(
+                content=resolved_content,
+                existing_digest=input_node.digest,
+                context=context,
+            )
+            self._report.summary = f"Digest {'refined' if input_node.digest else 'created'} for input {input_node.short_hash}"
+
+        input_node.digest = new_digest
+        input_node.save()
+
+        self._report.ok = True
+        self._report.artifacts["input_hash"] = input_node.short_hash
+        self._report.artifacts["digest"] = new_digest
+
+        return input_node
+
+    async def _generate_digest(
         self,
         content: str,
         existing_digest: str | None = None,
         context: str = "",
     ) -> str:
-        """
-        Generate or refine a digest for source content.
-
-        Args:
-            content: The full resolved source text
-            existing_digest: Current digest if refining (None for initial creation)
-            context: Direction from user or framework state that should shape
-                     the digest (e.g., "focus on ethical arguments",
-                     "we've identified tension between growth and stability")
-
-        Returns:
-            The new digest text
-        """
         self._conversation.set_system_prompt(SYSTEM_PROMPT)
 
         prompt = self._build_prompt(content, existing_digest, context)
@@ -97,13 +135,7 @@ class SourceDigest(ReasonableConcern[str], SettingsAware):
             user_content=prompt,
         )
 
-        self._report.ok = True
         self._report.artifacts["reasoning"] = result.reasoning
-        if existing_digest:
-            self._report.summary = "Refined existing digest"
-        else:
-            self._report.summary = "Generated initial digest"
-
         return result.digest
 
     def _build_prompt(
@@ -112,7 +144,6 @@ class SourceDigest(ReasonableConcern[str], SettingsAware):
         existing_digest: str | None,
         context: str,
     ) -> str:
-        """Build the user prompt based on whether this is creation or refinement."""
         sections = []
 
         if existing_digest:

dialectical_framework-1.4.0/src/dialectical_framework/agents/orchestrator/tools/digest_input.py

@@ -1,92 +0,0 @@
-"""
-DigestInput: Concern + tool for generating/refining the living digest of an Input source.
-"""
-
-from __future__ import annotations
-
-from typing import Annotated, Union
-
-from dependency_injector.wiring import Provide, inject
-from gqlalchemy import Memgraph, Neo4j
-from mirascope import llm
-from pydantic import Field
-
-from dialectical_framework.agents.reasonable_concern import ReasonableConcern
-from dialectical_framework.concerns.source_digest import SourceDigest
-from dialectical_framework.enums.di import DI
-from dialectical_framework.graph.nodes.input import Input
-from dialectical_framework.graph.repositories.node_repository import \
-    NodeRepository
-from dialectical_framework.protocols.input_resolver import InputResolver
-
-
-# Content shorter than this is used as its own digest (no LLM call needed)
-DIGEST_THRESHOLD = 1500
-
-
-class DigestInput(ReasonableConcern[Input]):
-    """
-    Generates or refines the digest for an Input node.
-
-    Resolves the full content, runs SourceDigest with any provided context,
-    and persists the result to the Input's digest field.
-
-    Short content (under ~1500 chars) is used directly as the digest
-    without an LLM call — it's already compact enough.
-    """
-
-    @inject
-    async def resolve(
-        self,
-        input_hash: str,
-        context: str = "",
-        input_resolver: InputResolver = Provide[DI.input_resolver],
-        graph_db: Union[Memgraph, Neo4j] = Provide[DI.graph_db],
-    ) -> Input:
-        repo = NodeRepository()
-        input_node = repo.find_by_hash(input_hash, node_type=Input)
-
-        if not input_node:
-            raise ValueError(f"Input not found: {input_hash}")
-
-        resolved_content = await input_resolver.resolve(input_node)
-        if not resolved_content:
-            raise ValueError(f"Input {input_hash} has no resolvable content")
-
-        if len(resolved_content) <= DIGEST_THRESHOLD and not input_node.digest:
-            new_digest = resolved_content
-            self._report.summary = f"Content compact enough to use as digest for input {input_node.short_hash}"
-        else:
-            concern = SourceDigest()
-            new_digest = await concern.resolve(
-                content=resolved_content,
-                existing_digest=input_node.digest,
-                context=context,
-            )
-            self._report = self._report.merge(concern.report)
-            self._report.summary = f"Digest {'refined' if input_node.digest else 'created'} for input {input_node.short_hash}"
-
-        input_node.digest = new_digest
-        input_node.save()
-
-        self._report.ok = True
-        self._report.artifacts["input_hash"] = input_node.short_hash
-        self._report.artifacts["digest"] = new_digest
-
-        return input_node
-
-
-@llm.tool
-async def digest_input(
-    input_hash: Annotated[str, Field(description="Hash of the Input node to digest")],
-    context: Annotated[
-        str,
-        Field(
-            description="Direction for the digest: user guidance, framework state, or focus instructions"
-        ),
-    ] = "",
-) -> str:
-    """Generate or refine the analytical digest of an input source. Use to build initial understanding of new inputs, or to sharpen the digest with user direction or framework learnings."""
-    concern = DigestInput()
-    await concern.resolve(input_hash=input_hash, context=context)
-    return str(concern.report)