siphrix 1.0.0__py3-none-any.whl

siphrix/logs/__init__.py

@@ -0,0 +1,3 @@
+
+
+

siphrix/logs/logger.py

@@ -0,0 +1,43 @@
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from siphrix.runtime_paths import siphrix_home, events_log_path
+
+# ``BASE_DIR`` and ``DEFAULT_LOG_PATH`` are kept as module-level
+# attributes for backwards compatibility with callers that import them
+# directly (tools, integrations, tests). Resolution is delegated to
+# :mod:`siphrix.runtime_paths` so ``SIPHRIX_HOME`` / ``SIPHRIX_LOG_PATH``
+# overrides are honoured from the single canonical source.
+#
+# Importing this module is side-effect free: no directory is created on
+# import. Parent directories are created lazily on first write inside
+# :func:`log_event`.
+BASE_DIR: Path = siphrix_home()
+DEFAULT_LOG_PATH: Path = events_log_path()
+
+
+def log_event(
+    event_type: str,
+    payload: Dict[str, Any],
+    log_path: Optional[Path] = None,
+) -> None:
+    # The path is resolved lazily on every call so that callers which
+    # scope ``SIPHRIX_HOME`` / ``SIPHRIX_LOG_PATH`` (e.g. an in-process
+    # test harness) actually see the override take effect. Binding the
+    # default at module-import time would freeze the path at the value
+    # it had when this module was first loaded.
+    if log_path is None:
+        log_path = events_log_path()
+    log_path = Path(log_path)
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    record = {
+        "ts": datetime.now(timezone.utc).isoformat(),
+        "event_type": event_type,
+        "payload": payload,
+    }
+
+    with log_path.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(record, ensure_ascii=False) + "\n")

siphrix/memory/__init__.py

@@ -0,0 +1,3 @@
+
+
+

siphrix/memory/api.py

@@ -0,0 +1,207 @@
+# siphrix/memory/api.py
+"""Public memory API.
+
+By default the memory store lives under the Siphrix runtime home —
+``$SIPHRIX_HOME/memory/memory_store.json`` (defaulting to
+``~/.siphrix/memory/memory_store.json``). Callers may still pass an
+explicit ``store_path`` to target a different file; the runtime-home
+resolution only applies when ``store_path`` is omitted.
+
+On first default-path use:
+
+* the parent directory is created if missing,
+* if an old repository-local seed file exists at
+  ``<siphrix package>/memory/memory_store.json`` and the canonical
+  runtime file does not yet exist, the legacy file is copied across
+  verbatim (data is preserved, never overwritten),
+* otherwise the store is seeded with an empty ``{"version": "1.0",
+  "items": []}`` document.
+
+Package code never writes into the installed ``siphrix`` package
+tree; a writable runtime home is the only destination for mutating
+memory operations.
+"""
+
+from __future__ import annotations
+
+import shutil
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from siphrix.runtime_paths import (
+    ensure_memory_store_parent,
+    memory_store_path,
+)
+
+from .store import (
+    MemoryStoreError,
+    load_store,
+    save_store,
+)
+
+
+StorePath = Union[str, Path]
+
+
+MEMORY_STORE_VERSION: str = "1.0"
+
+
+def _empty_store() -> Dict[str, Any]:
+    """Return a fresh, valid, empty memory store document."""
+    return {"version": MEMORY_STORE_VERSION, "items": []}
+
+
+def _legacy_package_store_path() -> Path:
+    """Return the historical repo/package-local memory store path.
+
+    Kept only so the one-time migration in :func:`_resolve_default_store`
+    can detect pre-v1 data. The path is deliberately computed relative
+    to this module so that both editable installs and wheel installs
+    point at the same historical location.
+    """
+    return Path(__file__).resolve().parent / "memory_store.json"
+
+
+def default_store_path() -> Path:
+    """Return the canonical default memory store path.
+
+    Resolved lazily per call via :func:`siphrix.runtime_paths.memory_store_path`,
+    so ``SIPHRIX_HOME`` changes are honoured immediately (e.g. in tests).
+    """
+    return memory_store_path()
+
+
+def _resolve_default_store() -> Path:
+    """Return the default store path, creating / migrating as needed.
+
+    The behaviour is strictly conservative:
+
+    1. Ensure the parent directory exists (idempotent).
+    2. If the canonical runtime file already exists → do nothing.
+    3. Else, if a legacy repo-local seed exists → copy it to the
+       runtime location (preserves any data a user might have written
+       into the historical path).
+    4. Else, create a fresh empty store document in the runtime
+       location so that :func:`add_memory` / :func:`search_memory` can
+       operate on their first call.
+
+    Never overwrites an existing runtime file. Never mutates the legacy
+    file.
+    """
+    store_path = ensure_memory_store_parent()
+
+    if store_path.exists():
+        return store_path
+
+    legacy = _legacy_package_store_path()
+    if legacy.is_file():
+        try:
+            shutil.copy2(legacy, store_path)
+            return store_path
+        except OSError:
+            # Fall through to a clean seed if the copy fails for any
+            # reason (permission, cross-device, …). We never want the
+            # migration to block first-time use.
+            pass
+
+    save_store(store_path, _empty_store())
+    return store_path
+
+
+def _coerce_store_path(store_path: Optional[StorePath]) -> Path:
+    """Resolve an explicit caller path, or bootstrap the default location.
+
+    * ``None`` → run the default-path bootstrap / migration logic.
+    * explicit path → return as-is without any filesystem side effects;
+      callers who supply their own path own its lifecycle.
+    """
+    if store_path is None:
+        return _resolve_default_store()
+    return Path(store_path)
+
+
+def add_memory(
+    text: str,
+    mem_type: str,
+    tags: Optional[List[str]] = None,
+    confidence: float = 0.9,
+    source: str = "user",
+    store_path: Optional[StorePath] = None,
+) -> Dict[str, Any]:
+    """Add a memory item to the store.
+
+    ``mem_type`` must be one of: ``fact | preference | decision | rule | summary``.
+
+    When ``store_path`` is omitted, the canonical runtime store path
+    is used (see :func:`default_store_path`) and is bootstrapped /
+    migrated on first use.
+    """
+    if tags is None:
+        tags = []
+
+    item = {
+        "id": str(uuid.uuid4()),
+        "type": mem_type,
+        "text": text.strip(),
+        "confidence": float(confidence),
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "tags": tags,
+        "source": source,
+    }
+
+    resolved = _coerce_store_path(store_path)
+    store = load_store(resolved)
+    store["items"].append(item)
+    save_store(resolved, store)
+    return item
+
+
+def search_memory(
+    query: str,
+    types: Optional[List[str]] = None,
+    tags: Optional[List[str]] = None,
+    min_confidence: float = 0.0,
+    limit: int = 20,
+    store_path: Optional[StorePath] = None,
+) -> List[Dict[str, Any]]:
+    """Simple keyword search (case-insensitive) across memory text.
+
+    When ``store_path`` is omitted, the canonical runtime store path
+    is used (see :func:`default_store_path`) and is bootstrapped /
+    migrated on first use, so a search against a fresh install returns
+    an empty list instead of raising ``FileNotFoundError``.
+    """
+    q = (query or "").strip().lower()
+    resolved = _coerce_store_path(store_path)
+    store = load_store(resolved)
+    items = store["items"]
+
+    def ok(item: Dict[str, Any]) -> bool:
+        if types and item["type"] not in types:
+            return False
+        if tags:
+            itags = {t.lower() for t in item["tags"]}
+            for t in tags:
+                if t.lower() not in itags:
+                    return False
+        if item["confidence"] < min_confidence:
+            return False
+        if q and q not in item["text"].lower():
+            return False
+        return True
+
+    results = [it for it in items if ok(it)]
+    # newest first
+    results.sort(key=lambda x: x["created_at"], reverse=True)
+    return results[:limit]
+
+
+__all__ = [
+    "MEMORY_STORE_VERSION",
+    "MemoryStoreError",
+    "add_memory",
+    "default_store_path",
+    "search_memory",
+]

siphrix/memory/schema.py

@@ -0,0 +1,33 @@
+# siphrix/memory/schema.py
+
+MEMORY_STORE_SCHEMA = {
+    "type": "object",
+    "required": ["version", "items"],
+    "properties": {
+        "version": {"type": "string"},
+        "items": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["id", "type", "text", "confidence", "created_at", "tags", "source"],
+                "properties": {
+                    "id": {"type": "string"},
+                    "type": {
+                        "type": "string",
+                        "enum": ["fact", "preference", "decision", "rule", "summary"]
+                    },
+                    "text": {"type": "string"},
+                    "confidence": {"type": "number", "minimum": 0.0, "maximum": 1.0},
+                    "created_at": {"type": "string"},  # ISO-ish string
+                    "tags": {"type": "array", "items": {"type": "string"}},
+                    "source": {"type": "string"}  # e.g. "user", "system", "inferred"
+                },
+                "additionalProperties": False
+            }
+        }
+    },
+    "additionalProperties": False
+}
+
+
+

siphrix/memory/store.py

@@ -0,0 +1,32 @@
+# siphrix/memory/store.py
+import json
+from pathlib import Path
+from typing import Any, Dict
+from jsonschema import validate
+from jsonschema.exceptions import ValidationError
+from .schema import MEMORY_STORE_SCHEMA
+
+class MemoryStoreError(Exception):
+    pass
+
+def load_store(path: str | Path) -> Dict[str, Any]:
+    p = Path(path)
+    if not p.exists():
+        raise FileNotFoundError(f"Memory store not found: {p}")
+    data = json.loads(p.read_text(encoding="utf-8"))
+    _validate_store(data)
+    return data
+
+def save_store(path: str | Path, data: Dict[str, Any]) -> None:
+    _validate_store(data)
+    p = Path(path)
+    p.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+def _validate_store(data: Dict[str, Any]) -> None:
+    try:
+        validate(instance=data, schema=MEMORY_STORE_SCHEMA)
+    except ValidationError as e:
+        raise MemoryStoreError(f"Memory store validation failed: {e.message}") from e
+
+
+

siphrix/orchestrator/__init__.py

@@ -0,0 +1,14 @@
+
+
+
+"""Canonical orchestrator package for the supported Siphrix pipeline surface.
+
+Import `run_pipeline` and `PipelineResult` from here for stable orchestration.
+`generate_reply` remains available as the lightweight local generator used by
+the demo and smoke flows.
+"""
+
+from siphrix.orchestrator.llm_stub import generate_reply
+from siphrix.orchestrator.pipeline import PipelineResult, run_pipeline
+
+__all__ = ["PipelineResult", "generate_reply", "run_pipeline"]

siphrix/orchestrator/llm_stub.py

@@ -0,0 +1,43 @@
+from typing import Optional
+
+def generate_reply(user_text: str, system_context: Optional[str] = None) -> str:
+    """
+    Simulare LLM pentru MVP (fără API).
+    Dacă system_context există, răspunde orientat pe NOUL scop.
+    """
+    t = (user_text or "").strip()
+    low = t.lower()
+
+    # ✅ Dacă avem scope nou, răspundem pe el
+    if system_context:
+        # răspuns foarte simplu, dar clar orientat pe noul scop
+        if "structura proiectului" in low or "structure" in low:
+            return (
+                "Structura proiectului (agent customer support ecommerce):\n"
+                "- app/\n"
+                "  - main.py (entry)\n"
+                "  - router.py (routing requests)\n"
+                "  - intents.py (clasificare intenții)\n"
+                "  - kb/\n"
+                "    - faqs.json (knowledge base)\n"
+                "  - policies.py (refund/return/shipping rules)\n"
+                "  - llm.py (model adapter)\n"
+                "  - logs/\n"
+                "    - events.jsonl\n"
+                "- tests/\n"
+                "- requirements.txt\n"
+                "\nSpune ce vrei: FAQ bot, ticketing, sau integrare shop?"
+            )
+        return f"[NEW SCOPE ACTIVE] ({system_context})\nAm înțeles: {t}\nSpune următorul pas concret."
+
+    # ✅ Fallback: Siphrix MVP behavior
+    if "orchestrator" in low:
+        return "OK. Construim Orchestrator: pipeline input→validate→LLM→validate→output + logs."
+    if "coherence" in low:
+        return "OK. Implementăm Coherence Enforcer: detect drift, block/ask_confirm, log reasons."
+    if "siphrix" in low:
+        return "OK. Rămânem pe MVP Siphrix (identity + intention + coherence). Spune următorul pas."
+    return f"Am înțeles: {t}. Spune-mi ce vrei să construim în MVP."
+
+
+

siphrix/orchestrator/pipeline.py

@@ -0,0 +1,251 @@
+"""
+pipeline.py — Siphrix Orchestrator (CANON-ENFORCED)
+
+CE ESTE ACEST FIȘIER
+--------------------
+Acesta este orchestratorul principal al Siphrix.
+El leagă toate componentele într-un pipeline coerent și aplică
+Canon v1.0 ca strat de control (identity + intention + coherence).
+
+NU ESTE:
+- un chatbot
+- un LLM
+- un truth engine
+
+ESTE:
+- un pipeline determinist cu enforcement Canon
+
+PIPELINE CANONICAL
+------------------
+Input
+ → Intention Interpreter
+ → Coherence Check (input)
+ → LLM (stub)
+ → Coherence Check (output)
+ → Response
+
+Canonul poate opri pipeline-ul în orice punct prin:
+- block
+- ask_confirm
+- clarify
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+from dataclasses import dataclass
+
+# -------------------------------------------------
+# Canon Runtime Engine
+# -------------------------------------------------
+# Canonul este încărcat o singură dată și folosit ca
+# strat de enforcement (nu decide adevăr).
+from siphrix.canon.canon_runtime import CanonRuleEngine
+
+
+# -------------------------------------------------
+# LLM STUB (generator simplu, fără enforcement)
+# -------------------------------------------------
+# În MVP, LLM-ul NU are voie să decidă nimic critic.
+from siphrix.orchestrator.llm_stub import generate_reply
+
+
+# -------------------------------------------------
+# Rezultat standard al pipeline-ului
+# -------------------------------------------------
+@dataclass
+class PipelineResult:
+    """
+    Rezultatul standard al pipeline-ului.
+
+    outcome:
+      - proceed
+      - block
+      - ask_confirm
+      - clarify
+
+    final_text:
+      - textul generat (dacă există)
+    """
+    outcome: str
+    final_text: str = ""
+    law_id: Optional[str] = None
+    reason_code: Optional[str] = None
+
+
+# -------------------------------------------------
+# Canon Engine (singleton)
+# -------------------------------------------------
+_CANON: Optional[CanonRuleEngine] = None
+
+def _get_canon() -> CanonRuleEngine:
+    """
+    Încarcă Canonul o singură dată.
+    """
+    global _CANON
+    if _CANON is None:
+        base = Path(__file__).resolve().parents[1]  # .../siphrix
+        canon_path = base / "canon" / "canon_v1_laws.yaml"
+        _CANON = CanonRuleEngine.load_from_file(canon_path)
+    return _CANON
+
+
+# -------------------------------------------------
+# Canon Gate Helper
+# -------------------------------------------------
+def _canon_gate(stage: str, ctx: Dict[str, Any]) -> Optional[PipelineResult]:
+    """
+    Rulează Canonul pe un anumit stage.
+
+    Dacă Canonul spune:
+      - block
+      - ask_confirm
+      - clarify
+
+    pipeline-ul se oprește IMEDIAT.
+    """
+    hit = _get_canon().evaluate(stage=stage, ctx=ctx)
+    if hit and hit["action"] in ("block", "ask_confirm", "clarify"):
+        return PipelineResult(
+            outcome=hit["action"],
+            law_id=hit["law_id"],
+            reason_code=hit["reason_code"],
+        )
+    return None
+
+
+# -------------------------------------------------
+# Context Builder (suprafața evaluabilă de Canon)
+# -------------------------------------------------
+def _build_ctx(
+    *,
+    identity_core: Optional[dict] = None,
+    intention_result: Optional[dict] = None,
+    coherence_result: Optional[dict] = None,
+    llm_invoked: bool = False,
+    response_returned: bool = False,
+    output_checked: bool = False,
+) -> Dict[str, Any]:
+    """
+    Construiește contextul pe care Canonul îl poate evalua.
+
+    IMPORTANT:
+    - ctx NU conține adevăr
+    - doar stări, flag-uri și rezultate structurale
+    """
+    return {
+        "identity_core": identity_core,
+        "intention_result": intention_result,
+        "coherence_result": coherence_result,
+        "llm_invoked": llm_invoked,
+        "response_returned": response_returned,
+        "output_checked": output_checked,
+        "coherence_check": {
+            "input_performed": intention_result is not None,
+            "output_performed": output_checked,
+            "reference": identity_core,
+        },
+        "log_event": {
+            "enforcement_enabled_flag": True
+        },
+    }
+
+
+# -------------------------------------------------
+# PIPELINE PRINCIPAL
+# -------------------------------------------------
+def run_pipeline(user_input: str) -> PipelineResult:
+    """
+    Orchestratorul principal Siphrix.
+
+    Rulează pipeline-ul complet și aplică Canonul
+    înainte și după generare.
+    """
+
+    # -------------------------
+    # 1) Identity Core (MVP)
+    # -------------------------
+    identity_core = {
+        "validated": True,
+        "goal": "maintain Siphrix coherence",
+        "missing_fields": False,
+    }
+
+    # Canon: startup gate
+    hit = _canon_gate(
+        "startup",
+        _build_ctx(identity_core=identity_core)
+    )
+    if hit:
+        return hit
+
+    # -------------------------
+    # 2) Intention Interpreter (MVP simplu)
+    # -------------------------
+    if "poate" in user_input.lower():
+        intention_result = {
+            "class": "unknown",
+            "confidence": 0.3,
+            "recommended_action": "clarify",
+        }
+    else:
+        intention_result = {
+            "class": "request",
+            "confidence": 0.9,
+            "recommended_action": "proceed",
+        }
+
+    # Canon: input gate
+    hit = _canon_gate(
+        "input",
+        _build_ctx(
+            identity_core=identity_core,
+            intention_result=intention_result,
+        )
+    )
+    if hit:
+        return hit
+
+    # Dacă intenția cere clarify, ne oprim
+    if intention_result["recommended_action"] == "clarify":
+        return PipelineResult(outcome="clarify")
+
+    # -------------------------
+    # 3) LLM Invocation (stub)
+    # -------------------------
+    llm_output = generate_reply(user_input)
+
+    # -------------------------
+    # 4) Coherence Check (output) — MVP
+    # -------------------------
+    coherence_result = {
+        "conflict": False,
+        "conflict_severity": None,
+        "goal_drift_detected": False,
+    }
+
+    # Canon: output gate
+    hit = _canon_gate(
+        "output",
+        _build_ctx(
+            identity_core=identity_core,
+            intention_result=intention_result,
+            coherence_result=coherence_result,
+            llm_invoked=True,
+            output_checked=True,
+        )
+    )
+    if hit:
+        return hit
+
+    # -------------------------
+    # 5) Response
+    # -------------------------
+    return PipelineResult(
+        outcome="proceed",
+        final_text=llm_output,
+    )
+
+
+

siphrix/policies/agent_default_v1.yaml

@@ -0,0 +1,22 @@
+schema_version: 4
+version: 4
+meta:
+  policy_id: "agent.default"
+  policy_version: "v1"
+  policy_ref: "policy:agent:default:v1"
+  created_at: "2026-02-09T00:00:00+00:00"
+  author: "siphrix"
+  scope: ["network"]
+  delegate_to: "policy:team:default:v1"
+default_action: ALLOW
+global:
+  rules:
+    - id: block_high_risk
+      when:
+        risk_level: "HIGH"
+      then: BLOCK
+      reason: "agent_blocks_high_risk"
+boundaries:
+  api.external:
+    default_action: ALLOW
+    rules: []

siphrix/policies/global_baseline_v1.yaml

@@ -0,0 +1,40 @@
+schema_version: 4
+version: 4
+meta:
+  policy_id: "global.baseline"
+  policy_version: "v1"
+  policy_ref: "policy:global:baseline:v1"
+  created_at: "2026-02-09T00:00:00+00:00"
+  author: "siphrix"
+  scope: ["network","api","browser","fs"]
+  locked_fields: ["no_side_effects","block_sensitive","filesystem_escape","max_risk"]
+  enforcements:
+    no_side_effects: true
+    block_sensitive: true
+    filesystem_escape: true
+    max_risk: "MEDIUM"
+default_action: BLOCK
+global:
+  rules:
+    - id: allow_example_readonly
+      when:
+        action_name: "http_get"
+        resource.domain: "example.com"
+      then: ALLOW
+      reason: "allow_example_readonly"
+boundaries:
+  api.external:
+    default_action: BLOCK
+    rules:
+      - id: allow_example_api
+        when:
+          action_name: "http_get"
+          resource.domain: "example.com"
+        then: ALLOW
+        reason: "allow_example_api"
+  browser.public:
+    default_action: BLOCK
+    rules: []
+  fs.sandbox:
+    default_action: BLOCK
+    rules: []