syntropy-core 0.1.0__py3-none-any.whl

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/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/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()