patchr 0.1.0__py3-none-any.whl

picux/signals/community/rules.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from picux.signals.community.models import SignalEntity
+
+
+@dataclass(frozen=True)
+class EntityRule:
+    entity: SignalEntity
+    label: str
+    aliases: tuple[str, ...]
+    canonical: str
+
+
+CANONICAL_QUERIES = (
+    "Picux Protocol",
+    "Picux Pay",
+    "Picux agentic infrastructure",
+    "Picux agent deployment",
+    "Picux MCP",
+)
+
+ENTITY_RULES = (
+    EntityRule(
+        entity=SignalEntity.PICUX,
+        label="Picux",
+        canonical="Picux Protocol",
+        aliases=("picux", "picux protocol", "picux pay", "picux.io", "picux.network"),
+    ),
+    EntityRule(
+        entity=SignalEntity.EXTERNAL_APP,
+        label="External App",
+        canonical="External App",
+        aliases=("external app", "external service", "external agent", "powered by picux"),
+    ),
+    EntityRule(
+        entity=SignalEntity.LEGACY_SWARM,
+        label="The Swarm",
+        canonical="The Swarm",
+        aliases=("the swarm", "the swarm core", "swarm core"),
+    ),
+    EntityRule(
+        entity=SignalEntity.HARNESS,
+        label="Harness",
+        canonical="Harness",
+        aliases=("harness", "harness ai", "harness swarm", "harness agents", "harness.io"),
+    ),
+)
+
+PLATFORM_WEIGHTS = {
+    "reddit": 0.12,
+    "web": 0.10,
+    "shopify": 0.08,
+}
+
+LAUNCH_DOMAINS = ("hunt", "resolve", "bridge")
+
+
+def normalizeText(value: str) -> str:
+    lowered = str(value or "").lower()
+    normalized = re.sub(r"[^a-z0-9]+", " ", lowered)
+    compact = re.sub(r"\s+", " ", normalized).strip()
+    return f" {compact} "
+
+
+def phraseHits(text: str, phrases: tuple[str, ...] | list[str]) -> tuple[str, ...]:
+    normalized = normalizeText(text)
+    hits: list[str] = []
+    for phrase in phrases:
+        normalizedPhrase = normalizeText(phrase).strip()
+        if not normalizedPhrase:
+            continue
+        pattern = rf"(?<![a-z0-9]){re.escape(normalizedPhrase)}(?![a-z0-9])"
+        if re.search(pattern, normalized):
+            hits.append(str(phrase))
+    return tuple(dict.fromkeys(hits))
+
+
+def entityCatalog() -> list[dict[str, object]]:
+    return [
+        {
+            "entity": rule.entity.value,
+            "label": rule.label,
+            "canonical": rule.canonical,
+            "aliases": list(rule.aliases),
+            "external": rule.entity == SignalEntity.HARNESS,
+        }
+        for rule in ENTITY_RULES
+    ]

picux/signals/community/scoring.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from picux.signals.community.disambiguation import inspectSignalEntity
+from picux.signals.community.models import CommunitySignal, SignalAnalysis, SignalEntity
+from picux.signals.community.rules import CANONICAL_QUERIES, LAUNCH_DOMAINS, PLATFORM_WEIGHTS, phraseHits
+
+
+ENTITY_BASE = {
+    SignalEntity.PICUX: 0.55,
+    SignalEntity.EXTERNAL_APP: 0.45,
+    SignalEntity.LEGACY_SWARM: 0.25,
+    SignalEntity.HARNESS: 0.0,
+    SignalEntity.UNKNOWN: 0.05,
+}
+
+
+def scoreSignal(signal: CommunitySignal | dict[str, object]) -> SignalAnalysis:
+    item = signal if isinstance(signal, CommunitySignal) else CommunitySignal.fromObj(signal)
+    sourceText = " ".join([item.text, item.query, item.source.url, item.source.community])
+    detail = inspectSignalEntity(sourceText)
+    entity = detail["entity"]
+    queryHits = phraseHits(sourceText, CANONICAL_QUERIES)
+    reasons: list[str] = [f"entity:{entity.value}"]
+    matches = tuple(dict.fromkeys([*detail["matches"], *queryHits]))
+    negativeMatches = tuple(detail["harnessMatches"])
+
+    confidence = ENTITY_BASE[entity]
+    platform = item.source.platform.lower()
+    sourceBoost = PLATFORM_WEIGHTS.get(platform, 0.04 if platform else 0.0)
+    if entity != SignalEntity.HARNESS:
+        confidence += sourceBoost
+        if platform:
+            reasons.append(f"source:{platform}")
+        if queryHits:
+            confidence += min(0.20, 0.05 * len(queryHits))
+            reasons.append("canonicalQueryMatch")
+        if "picux" in item.source.url.lower():
+            confidence += 0.12
+            reasons.append("officialSource")
+        if negativeMatches:
+            confidence -= 0.35
+            reasons.append("harnessMention")
+    else:
+        confidence = 0.0
+        reasons.append("harnessCollision")
+
+    confidence = max(0.0, min(1.0, round(confidence, 3)))
+    launchable = LAUNCH_DOMAINS if entity in {SignalEntity.PICUX, SignalEntity.EXTERNAL_APP, SignalEntity.LEGACY_SWARM} else ()
+    return SignalAnalysis(
+        signalId=item.signalId,
+        entity=entity,
+        confidence=confidence,
+        matches=matches,
+        negativeMatches=negativeMatches,
+        reasons=tuple(dict.fromkeys(reasons)),
+        query=item.query,
+        source=item.source,
+        launchableDomains=launchable,
+        approvalRequired=True,
+    )
+
+
+def score_signal(signal: CommunitySignal | dict[str, object]) -> SignalAnalysis:
+    return scoreSignal(signal)

picux/storage/__init__.py

@@ -0,0 +1,41 @@
+"""Storage primitives."""
+
+from .agents import AgentBook
+from .cases import CaseBook
+from .channels import ChannelBook
+from .connectors import ConnectorBook
+from .envelopes import EnvelopeBook
+from .events import EventBook, EventDeliveryBook, EventSubscriptionBook
+from .escrows import EscrowBook
+from .keyspace import Keyspace
+from .mandates import MandateBook
+from .portals import PortalBook
+from .postgres import PicuxPostgresStore
+from .providers import LocalProviderBook
+from .proxy import ProxyBook
+from .receipts import ReceiptBook
+from .signals import SignalBook
+from .tasks import TaskBook, taskFromObj, taskView
+
+__all__ = [
+    "AgentBook",
+    "CaseBook",
+    "ChannelBook",
+    "ConnectorBook",
+    "EnvelopeBook",
+    "EventBook",
+    "EventDeliveryBook",
+    "EventSubscriptionBook",
+    "EscrowBook",
+    "Keyspace",
+    "MandateBook",
+    "PortalBook",
+    "PicuxPostgresStore",
+    "LocalProviderBook",
+    "ProxyBook",
+    "ReceiptBook",
+    "SignalBook",
+    "TaskBook",
+    "taskFromObj",
+    "taskView",
+]

picux/storage/agents.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+
+class AgentBook:
+    """Agent capability registry storage with optional durable backing."""
+
+    def __init__(self, *, backing: Any | None = None) -> None:
+        self.backing = backing
+        self._agents: dict[str, dict[str, Any]] = {}
+
+    def saveAgent(self, agent: dict[str, Any]) -> dict[str, Any]:
+        agentId = str(agent.get("agentId", "") or "")
+        if not agentId:
+            return {"ok": False, "error": "missing:agentId"}
+        stored = copy.deepcopy(agent)
+        self._agents[agentId] = stored
+        if self._backingEnabled() and hasattr(self.backing, "upsertAgent"):
+            self.backing.upsertAgent(stored)
+        return {"ok": True, "agentId": agentId}
+
+    def getAgent(self, agentId: str) -> dict[str, Any]:
+        agentId = str(agentId or "")
+        agent = self._agents.get(agentId)
+        if agent is None and self._backingEnabled() and hasattr(self.backing, "fetchAgent"):
+            agent = self.backing.fetchAgent(agentId)
+            if agent:
+                self._agents[agentId] = copy.deepcopy(agent)
+        if not agent:
+            return {"ok": False, "error": "agentNotFound", "agentId": agentId}
+        return {"ok": True, "agent": copy.deepcopy(agent)}
+
+    def listAgents(self) -> dict[str, Any]:
+        if self._backingEnabled() and hasattr(self.backing, "listAgents"):
+            for agent in self.backing.listAgents():
+                agentId = str(agent.get("agentId", "") or "")
+                if agentId:
+                    self._agents[agentId] = copy.deepcopy(agent)
+        agents = [
+            copy.deepcopy(agent)
+            for agent in sorted(self._agents.values(), key=lambda item: str(item.get("agentId", "")))
+        ]
+        return {"ok": True, "agents": agents}
+
+    def _backingEnabled(self) -> bool:
+        if self.backing is None:
+            return False
+        return bool(getattr(self.backing, "enabled", True))