syntropy-core 0.1.0__tar.gz

syntropy_core-0.1.0/.gitignore

@@ -0,0 +1,38 @@
+# OS / editor
+.DS_Store
+.idea/
+.vscode/
+
+# Internal documentation and references
+AGENTS.md
+CLAUDE.md
+prompts/
+_reference/
+skills-guide/
+
+# Python
+__pycache__/
+.hypothesis/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+python/.venv/
+python/.pytest_cache/
+python/.hypothesis/
+
+# Elixir
+elixir/_build/
+elixir/deps/
+elixir/.elixir_ls/
+elixir/cover/
+
+# Next.js
+website/.next/
+website/node_modules/
+website/tsconfig.tsbuildinfo
+
+# Env files
+.env
+.env.*
+!.env.example

syntropy_core-0.1.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: syntropy-core
+Version: 0.1.0
+Summary: Contract-first scaffold for the Syntropy Python reference implementation.
+Requires-Python: >=3.12
+Requires-Dist: httpx<1.0,>=0.28
+Requires-Dist: pydantic-settings<3.0,>=2.9
+Requires-Dist: pydantic<3.0,>=2.11
+Requires-Dist: typer<1.0,>=0.12
+Provides-Extra: dev
+Requires-Dist: bandit<2.0,>=1.8; extra == 'dev'
+Requires-Dist: hypothesis<7.0,>=6.140; extra == 'dev'
+Requires-Dist: mypy<2.0,>=1.17; extra == 'dev'
+Requires-Dist: pytest-asyncio<2.0,>=1.1; extra == 'dev'
+Requires-Dist: pytest-cov<7.0,>=6.3; extra == 'dev'
+Requires-Dist: pytest<9.0,>=8.4; extra == 'dev'
+Requires-Dist: ruff<0.14,>=0.13; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Syntropy Python
+
+This package is the Python reference runtime for Syntropy.
+
+Current capabilities:
+
+- immutable lattice join and meet operations
+- deterministic ordering and shared axiom parity with Syntropy
+- semantic task routing with `single`, `parallel`, `all`, and `auto`
+- explicit-agent overrides for manual control
+- contribution-aware EMA position recomputation
+- symmetric connection tracking with interaction counts
+- retained observation events, task history, structural recommendations, and
+  replay snapshots
+- approval-gated persistent join/meet recommendations
+- mock, OpenAI, and Ollama provider adapters through the runtime settings
+- a flagship architecture decision review example at
+  `examples/01_basic_lattice.py`
+
+Current limits:
+
+- memory is local/in-memory in the current implementation
+- Syntropy is the operational control plane for replay, approval, graph
+  playback, API access, and optional durability

syntropy_core-0.1.0/README.md

@@ -0,0 +1,24 @@
+# Syntropy Python
+
+This package is the Python reference runtime for Syntropy.
+
+Current capabilities:
+
+- immutable lattice join and meet operations
+- deterministic ordering and shared axiom parity with Syntropy
+- semantic task routing with `single`, `parallel`, `all`, and `auto`
+- explicit-agent overrides for manual control
+- contribution-aware EMA position recomputation
+- symmetric connection tracking with interaction counts
+- retained observation events, task history, structural recommendations, and
+  replay snapshots
+- approval-gated persistent join/meet recommendations
+- mock, OpenAI, and Ollama provider adapters through the runtime settings
+- a flagship architecture decision review example at
+  `examples/01_basic_lattice.py`
+
+Current limits:
+
+- memory is local/in-memory in the current implementation
+- Syntropy is the operational control plane for replay, approval, graph
+  playback, API access, and optional durability

syntropy_core-0.1.0/pyproject.toml

@@ -0,0 +1,63 @@
+[project]
+name = "syntropy-core"
+version = "0.1.0"
+description = "Contract-first scaffold for the Syntropy Python reference implementation."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+  "httpx>=0.28,<1.0",
+  "pydantic>=2.11,<3.0",
+  "pydantic-settings>=2.9,<3.0",
+  "typer>=0.12,<1.0",
+]
+
+[project.scripts]
+syntropy = "syntropy.cli:cli_main"
+
+[project.optional-dependencies]
+dev = [
+  "bandit>=1.8,<2.0",
+  "hypothesis>=6.140,<7.0",
+  "mypy>=1.17,<2.0",
+  "pytest>=8.4,<9.0",
+  "pytest-asyncio>=1.1,<2.0",
+  "pytest-cov>=6.3,<7.0",
+  "ruff>=0.13,<0.14",
+]
+
+[build-system]
+requires = ["hatchling>=1.27,<2.0"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["syntropy"]
+
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "syntropy/**/*.py",
+  "syntropy/resources/shared/*.json",
+  "tests/**/*.py",
+  "README.md",
+  "pyproject.toml",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+markers = [
+  "axiom(id): shared lattice axiom identifier",
+  "runtime_event(id): shared runtime event identifier",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "UP", "B", "A", "C4", "SIM", "PL", "RUF"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+packages = ["syntropy"]

syntropy_core-0.1.0/syntropy/__init__.py

@@ -0,0 +1,39 @@
+"""Public API for the Syntropy Python scaffold."""
+
+from .agent import Agent, AgentConnection, AgentScoreVector
+from .interfaces import Embedder, EventExporter, LLMAdapter, MemoryStore
+from .lattice import Lattice
+from .llm import MockLLMAdapter, OllamaAdapter, OpenAIAdapter
+from .recommendation import RecommendationEvidence, StructuralRecommendation
+from .replay import LatticeSnapshot, ReplayAgentState, ReplayBundle, ReplayRecord
+from .runtime import Runtime
+from .settings import SyntropySettings
+from .task import SelectionTraceEntry, Task, TaskResult, Thought
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Agent",
+    "AgentConnection",
+    "AgentScoreVector",
+    "Embedder",
+    "EventExporter",
+    "LLMAdapter",
+    "Lattice",
+    "SyntropySettings",
+    "LatticeSnapshot",
+    "MemoryStore",
+    "MockLLMAdapter",
+    "OllamaAdapter",
+    "OpenAIAdapter",
+    "RecommendationEvidence",
+    "ReplayAgentState",
+    "ReplayBundle",
+    "ReplayRecord",
+    "Runtime",
+    "SelectionTraceEntry",
+    "StructuralRecommendation",
+    "Task",
+    "TaskResult",
+    "Thought",
+]

syntropy_core-0.1.0/syntropy/agent.py

@@ -0,0 +1,75 @@
+"""Agent data structures for the Syntropy Python scaffold."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+def _clamp_score(value: float) -> float:
+    return max(0.0, min(1.0, value))
+
+
+@dataclass(frozen=True, slots=True)
+class AgentConnection:
+    """Represents a weighted connection to another agent."""
+
+    target_agent_id: str
+    weight: float
+    interactions: int = 0
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "weight", _clamp_score(self.weight))
+        object.__setattr__(self, "interactions", max(0, self.interactions))
+
+
+@dataclass(frozen=True, slots=True)
+class AgentScoreVector:
+    """Stores component scores used to compute lattice position."""
+
+    knowledge: float = 0.0
+    synthesis: float = 0.0
+    connections: float = 0.0
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "knowledge", _clamp_score(self.knowledge))
+        object.__setattr__(self, "synthesis", _clamp_score(self.synthesis))
+        object.__setattr__(self, "connections", _clamp_score(self.connections))
+
+
+@dataclass(frozen=True, slots=True)
+class Agent:
+    """Immutable agent state for lattice operations."""
+
+    id: str
+    name: str
+    perspective: str
+    knowledge_items: tuple[str, ...] = ()
+    score_vector: AgentScoreVector = field(default_factory=AgentScoreVector)
+    connections: tuple[AgentConnection, ...] = ()
+    position: float = 0.0
+    temporary: bool = False
+    parent_ids: tuple[str, ...] = ()
+    lineage_ids: tuple[str, ...] = ()
+    source_names: tuple[str, ...] = ()
+    perspective_labels: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "knowledge_items", tuple(self.knowledge_items))
+        object.__setattr__(self, "connections", tuple(self.connections))
+        object.__setattr__(self, "parent_ids", tuple(self.parent_ids))
+        object.__setattr__(
+            self,
+            "lineage_ids",
+            tuple(self.lineage_ids) if self.lineage_ids or self.parent_ids else (self.id,),
+        )
+        object.__setattr__(
+            self,
+            "source_names",
+            tuple(self.source_names) if self.source_names else (self.name,),
+        )
+        object.__setattr__(
+            self,
+            "perspective_labels",
+            tuple(self.perspective_labels) if self.perspective_labels else (self.perspective,),
+        )
+        object.__setattr__(self, "position", _clamp_score(self.position))

syntropy_core-0.1.0/syntropy/cli.py

@@ -0,0 +1,151 @@
+import json
+
+import httpx
+import typer
+
+from syntropy import __version__
+from syntropy.scanner import scan_local_path
+from syntropy.settings import load_settings
+
+app = typer.Typer(
+    name="syntropy",
+    help="Syntropy: Observable multi-agent execution runtime.",
+    add_completion=False,
+)
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"Syntropy CLI version: {__version__}")
+        raise typer.Exit()
+
+@app.callback()
+def main(
+    version: bool | None = typer.Option(
+        None,
+        "--version",
+        callback=version_callback,
+        is_eager=True,
+        help="Show the version and exit.",
+    )
+) -> None:
+    """
+    Syntropy CLI
+    """
+    pass
+
+@app.command()
+def info() -> None:
+    """
+    Show current environment configuration and active providers.
+    """
+    settings = load_settings()
+    typer.echo("Syntropy Environment Info:")
+    typer.echo(f"  LLM Provider: {settings.llm_provider}")
+    typer.echo(f"  Effective Model: {settings.effective_model}")
+    typer.echo(f"  Effective Base URL: {settings.effective_base_url}")
+
+
+@app.command()
+def review(
+    path_or_url: str = typer.Argument(..., help="Local path or GitHub URL to review."),
+    goal: str = typer.Option(
+        "Find the safest next architecture move",
+        "--goal",
+        help="The review goal.",
+    ),
+    output_format: str = typer.Option(
+        "markdown",
+        "--format",
+        help="Output format (markdown or json).",
+    ),
+) -> None:
+    """
+    Review a codebase and produce a source-grounded recommendation.
+    """
+    
+    # 1. Ingest
+    if path_or_url.startswith("http://") or path_or_url.startswith("https://"):
+        if output_format != "json":
+            typer.echo(f"[✓] Validating GitHub URL: {path_or_url}")
+        # Note: The platform does GitHub URL fetching. For the CLI communicating with Elixir,
+        # we might just pass repoUrl, but Elixir currently expects a source_review object.
+        # We will mock the context packet for the URL for now, or just raise NotImplementedError
+        # if the Python CLI strictly handles local.
+        typer.echo("Error: GitHub URL ingestion via CLI is delegated to the web platform for now.")
+        raise typer.Exit(code=1)
+    else:
+        if output_format != "json":
+            typer.echo(f"[✓] Scanning local repository: {path_or_url}")
+        
+        try:
+            packet = scan_local_path(path_or_url, goal)
+        except Exception as e:
+            typer.echo(f"Error scanning local path: {e}")
+            raise typer.Exit(code=1) from e
+            
+        if output_format != "json":
+            typer.echo(f"[✓] Context packet built ({len(packet.file_inventory)} files indexed)")
+
+    # 2. Execute Local Review
+    if output_format != "json":
+        typer.echo("[*] Spinning up local Syntropy Lattice...")
+        
+    from syntropy import Lattice, AgentScoreVector
+    import asyncio
+    
+    lattice = Lattice()
+    lattice.add_agent(
+        "Architecture Reviewer",
+        perspective="architecture",
+        knowledge_items=("design patterns", "code organization", "dependencies"),
+        score_vector=AgentScoreVector(knowledge=0.8, synthesis=0.8, connections=0.5),
+    )
+    lattice.add_agent(
+        "Security Analyst",
+        perspective="security",
+        knowledge_items=("vulnerabilities", "auth", "data safety"),
+        score_vector=AgentScoreVector(knowledge=0.8, synthesis=0.7, connections=0.4),
+    )
+    lattice.add_agent(
+        "Performance Engineer",
+        perspective="performance",
+        knowledge_items=("efficiency", "hot paths", "resource usage"),
+        score_vector=AgentScoreVector(knowledge=0.7, synthesis=0.8, connections=0.4),
+    )
+    
+    prompt = f"Goal: {goal}\n\nRepository Snippets:\n"
+    for snippet in packet.evidence_snippets[:15]:
+        prompt += f"--- {snippet.path} ---\n{snippet.excerpt}\n\n"
+    prompt += "\nBased on the snippets above, provide a synthesis addressing the review goal."
+
+    if output_format != "json":
+        typer.echo("[*] Routing to agents and synthesizing...")
+
+    try:
+        result = asyncio.run(lattice.submit(prompt, strategy="parallel", agent_count=3))
+    except Exception as e:
+        typer.echo(f"Error executing local Lattice: {e}")
+        raise typer.Exit(code=1) from e
+        
+    if output_format == "json":
+        typer.echo(json.dumps({
+            "goal": goal,
+            "synthesis": result.synthesis,
+            "recommendation_ids": result.recommendation_ids,
+            "perspectives_used": [entry.agent_name for entry in result.selection_trace if entry.selected]
+        }, indent=2))
+    else:
+        typer.echo("\n[✓] Review complete!\n")
+        typer.echo("=== SYNTHESIS ===")
+        typer.echo(result.synthesis)
+        typer.echo("\n=== PERSPECTIVES USED ===")
+        for entry in result.selection_trace:
+            if entry.selected:
+                typer.echo(f"- {entry.agent_name}")
+
+
+def cli_main() -> None:
+    app()
+
+if __name__ == "__main__":
+    cli_main()