nomark-engine 0.1.0__tar.gz

nomark_engine-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+.venv-old/
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.pytest_cache/

nomark_engine-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: nomark-engine
+Version: 0.1.0
+Summary: NOMARK Engine — open-core agent outcome quality resolver
+Project-URL: Homepage, https://github.com/nomark-dev/nomark
+Project-URL: Repository, https://github.com/nomark-dev/nomark
+Author: Reece Frazier
+License-Expression: Apache-2.0
+Keywords: agent,ai,intent,nomark,preferences,quality,trust
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: pydantic<3,>=2.0
+Description-Content-Type: text/markdown
+
+# nomark-engine
+
+Open-core agent outcome quality resolver. Understands what a human means from incomplete input by learning preferences across sessions and platforms.
+
+## Install
+
+```bash
+pip install nomark-engine
+```
+
+## Quick start
+
+```python
+from nomark_engine import create_resolver, parse_ledger, ResolverConfig
+
+# Parse a NOMARK ledger
+entries = parse_ledger(open("nomark-ledger.jsonl").read())
+
+# Create resolver
+resolver = create_resolver(ResolverConfig(entries=entries))
+
+# Resolve all preference dimensions
+result = resolver.resolve_all()
+for dim, res in result.dimensions.items():
+    if res.winner:
+        print(f"{dim}: {res.winner.pref.target} (score: {res.winner.score})")
+
+# Resolve intent from natural language
+result = resolver.resolve_input("make it shorter")
+for match in result.meaning_maps:
+    print(f"Matched: {match.trigger} -> {match.intent}")
+```
+
+## Modules
+
+- **Schema** — Pydantic v2 models for all signal types (pref, map, asn, meta, rub)
+- **Classifier** — Input tier classification (pass-through, routing, extraction)
+- **Resolver** — MEE weighted scoring with scope matching and instability detection
+- **Ledger** — JSONL parser/writer with capacity constraints
+- **Decay** — Time-based decay with contradiction acceleration
+- **Utility** — Multi-factor utility scoring and capacity-bounded pruning
+
+## License
+
+Apache 2.0

nomark_engine-0.1.0/README.md

@@ -0,0 +1,45 @@
+# nomark-engine
+
+Open-core agent outcome quality resolver. Understands what a human means from incomplete input by learning preferences across sessions and platforms.
+
+## Install
+
+```bash
+pip install nomark-engine
+```
+
+## Quick start
+
+```python
+from nomark_engine import create_resolver, parse_ledger, ResolverConfig
+
+# Parse a NOMARK ledger
+entries = parse_ledger(open("nomark-ledger.jsonl").read())
+
+# Create resolver
+resolver = create_resolver(ResolverConfig(entries=entries))
+
+# Resolve all preference dimensions
+result = resolver.resolve_all()
+for dim, res in result.dimensions.items():
+    if res.winner:
+        print(f"{dim}: {res.winner.pref.target} (score: {res.winner.score})")
+
+# Resolve intent from natural language
+result = resolver.resolve_input("make it shorter")
+for match in result.meaning_maps:
+    print(f"Matched: {match.trigger} -> {match.intent}")
+```
+
+## Modules
+
+- **Schema** — Pydantic v2 models for all signal types (pref, map, asn, meta, rub)
+- **Classifier** — Input tier classification (pass-through, routing, extraction)
+- **Resolver** — MEE weighted scoring with scope matching and instability detection
+- **Ledger** — JSONL parser/writer with capacity constraints
+- **Decay** — Time-based decay with contradiction acceleration
+- **Utility** — Multi-factor utility scoring and capacity-bounded pruning
+
+## License
+
+Apache 2.0

nomark_engine-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "nomark-engine"
+version = "0.1.0"
+description = "NOMARK Engine — open-core agent outcome quality resolver"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+authors = [
+    { name = "Reece Frazier" },
+]
+keywords = ["nomark", "ai", "agent", "preferences", "intent", "quality", "trust"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "pydantic>=2.0,<3",
+]
+
+[project.urls]
+Homepage = "https://github.com/nomark-dev/nomark"
+Repository = "https://github.com/nomark-dev/nomark"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/nomark_engine"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.pyright]
+include = ["src"]
+pythonVersion = "3.10"

nomark_engine-0.1.0/src/nomark_engine/__init__.py

@@ -0,0 +1,51 @@
+"""NOMARK Engine — open-core agent outcome quality resolver."""
+
+__version__ = "0.1.0"
+
+from .schema import (
+    Context, Outcome, RequestType, PatternType, RubricStage, SignalType, Scope,
+    ContextCounts, OutcomeCounts,
+    SigPref, SigMap, SigAsn, SigMeta, SigRub,
+    LedgerEntryMeta, LedgerEntryPref, LedgerEntryMap, LedgerEntryAsn, LedgerEntryRub,
+    LedgerEntry,
+    parse_ledger_entry,
+)
+from .decay import compute_decay, effective_weight
+from .ledger import (
+    parse_ledger, write_ledger, parse_ledger_line, format_ledger_line,
+    count_by_type, check_capacity, estimate_tokens,
+    ENTRY_CAPS, TOTAL_CAP,
+)
+from .utility import utility_score, is_protected, prune_to_capacity
+from .classifier import classify, ClassificationResult, InputTier
+from .resolver import (
+    scope_specificity, scope_matches, resolver_score,
+    resolve_dimension, match_meaning_maps, find_defaults,
+    create_resolver, Resolver, ResolverConfig, ResolverResult,
+    DimensionResult, MeaningMapMatch, DefaultMatch, ScoredPref, ScoringFactors, ResolverMeta,
+)
+
+__all__ = [
+    # Schema types
+    "Context", "Outcome", "RequestType", "PatternType", "RubricStage", "SignalType", "Scope",
+    "ContextCounts", "OutcomeCounts",
+    "SigPref", "SigMap", "SigAsn", "SigMeta", "SigRub",
+    "LedgerEntryMeta", "LedgerEntryPref", "LedgerEntryMap", "LedgerEntryAsn", "LedgerEntryRub",
+    "LedgerEntry",
+    "parse_ledger_entry",
+    # Decay
+    "compute_decay", "effective_weight",
+    # Ledger
+    "parse_ledger", "write_ledger", "parse_ledger_line", "format_ledger_line",
+    "count_by_type", "check_capacity", "estimate_tokens",
+    "ENTRY_CAPS", "TOTAL_CAP",
+    # Utility
+    "utility_score", "is_protected", "prune_to_capacity",
+    # Classifier
+    "classify", "ClassificationResult", "InputTier",
+    # Resolver
+    "scope_specificity", "scope_matches", "resolver_score",
+    "resolve_dimension", "match_meaning_maps", "find_defaults",
+    "create_resolver", "Resolver", "ResolverConfig", "ResolverResult",
+    "DimensionResult", "MeaningMapMatch", "DefaultMatch", "ScoredPref", "ScoringFactors", "ResolverMeta",
+]

nomark_engine-0.1.0/src/nomark_engine/classifier.py

@@ -0,0 +1,134 @@
+"""Input classification (MEE Spec Section 1.1).
+
+Ports packages/engine/src/classifier.ts.
+
+Tier 0: Pass-through — already resolved. Confirmations, selections, JSON, exit codes.
+Tier 1: Routing — match to established pattern. Skill invocations, continuations, corrections.
+Tier 2: Extraction — full intent reconstruction through resolver + gate.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from typing import Literal, Protocol
+
+
+InputTier = Literal[0, 1, 2]
+
+
+@dataclass(frozen=True)
+class ClassificationResult:
+    tier: InputTier
+    reason: str
+
+
+class ClassifierRule(Protocol):
+    tier: InputTier
+    reason: str
+
+    def test(self, input: str) -> bool: ...
+
+
+@dataclass(frozen=True)
+class _Rule:
+    tier: InputTier
+    reason: str
+    _test: object  # callable
+
+    def test(self, input: str) -> bool:
+        return self._test(input)  # type: ignore[operator]
+
+
+def _is_confirmation(s: str) -> bool:
+    return bool(re.match(
+        r"^(y|yes|no|n|ok|done|skip|cancel|approve|reject|confirm|confirmed)$",
+        s.strip(), re.IGNORECASE,
+    ))
+
+
+def _is_numeric(s: str) -> bool:
+    return bool(re.match(r"^[0-9]+$", s.strip()))
+
+
+def _is_json(s: str) -> bool:
+    t = s.strip()
+    if not (t.startswith("{") or t.startswith("[")):
+        return False
+    try:
+        json.loads(s)
+        return True
+    except (json.JSONDecodeError, ValueError):
+        return False
+
+
+def _is_exit(s: str) -> bool:
+    return bool(re.match(r"^(exit|quit|bye|stop)\s*$", s.strip(), re.IGNORECASE))
+
+
+def _is_hash(s: str) -> bool:
+    return bool(re.match(r"^[a-f0-9]{6,40}$", s.strip(), re.IGNORECASE))
+
+
+def _is_skill(s: str) -> bool:
+    return bool(re.match(r"^/\w", s.strip()))
+
+
+def _is_continuation(s: str) -> bool:
+    return bool(re.match(
+        r"^(continue|go ahead|proceed|next|keep going|resume)\s*$",
+        s.strip(), re.IGNORECASE,
+    ))
+
+
+def _is_correction(s: str) -> bool:
+    t = s.strip()
+    return bool(
+        re.match(r"^(no[,.]?\s+(not that|wrong|different|the other|I meant))", t, re.IGNORECASE)
+        or re.match(r"^(actually|wait|hold on|scratch that|never\s?mind)", t, re.IGNORECASE)
+    )
+
+
+def _is_letter_selection(s: str) -> bool:
+    t = s.strip()
+    return 0 < len(t) <= 3 and bool(re.match(r"^[a-z]$", t, re.IGNORECASE))
+
+
+_TIER_0_RULES: list[_Rule] = [
+    _Rule(0, "confirmation", _is_confirmation),
+    _Rule(0, "numeric_selection", _is_numeric),
+    _Rule(0, "json_data", _is_json),
+    _Rule(0, "exit_signal", _is_exit),
+    _Rule(0, "hash_or_id", _is_hash),
+]
+
+_TIER_1_RULES: list[_Rule] = [
+    _Rule(1, "skill_invocation", _is_skill),
+    _Rule(1, "continuation", _is_continuation),
+    _Rule(1, "correction", _is_correction),
+    _Rule(1, "letter_selection", _is_letter_selection),
+]
+
+
+def classify(input: str, custom_rules: list[_Rule] | None = None) -> ClassificationResult:
+    """Classify input into Tier 0 (pass-through), Tier 1 (routing), or Tier 2 (extraction)."""
+    trimmed = input.strip()
+
+    if not trimmed:
+        return ClassificationResult(tier=0, reason="empty_input")
+
+    if custom_rules:
+        for rule in custom_rules:
+            if rule.test(trimmed):
+                return ClassificationResult(tier=rule.tier, reason=rule.reason)
+
+    for rule in _TIER_0_RULES:
+        if rule.test(trimmed):
+            return ClassificationResult(tier=rule.tier, reason=rule.reason)
+
+    for rule in _TIER_1_RULES:
+        if rule.test(trimmed):
+            return ClassificationResult(tier=rule.tier, reason=rule.reason)
+
+    return ClassificationResult(tier=2, reason="substantive_input")

nomark_engine-0.1.0/src/nomark_engine/decay.py

@@ -0,0 +1,46 @@
+"""Continuous decay computation (MEE Spec Section 8).
+
+Ports packages/engine/src/decay.ts.
+
+Base: max(0.1, 0.98^(days/30))
+Contradiction acceleration: decay * 0.85 when recent_contradictions >= 2
+Reinforcement recovery: decay * 1.1 (capped 1.0) when reinforced within 7 days
+Floor: 0.1 — never total erasure
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+
+def compute_decay(
+    last_date: str,
+    _contradictions: int,
+    recent_contradictions: int,
+    recent_reinforcement: bool,
+    now: datetime | None = None,
+) -> float:
+    if now is None:
+        now = datetime.now(timezone.utc)
+
+    last = datetime.fromisoformat(last_date)
+    if last.tzinfo is None:
+        last = last.replace(tzinfo=timezone.utc)
+    if now.tzinfo is None:
+        now = now.replace(tzinfo=timezone.utc)
+
+    days_since_last = max(0.0, (now - last).total_seconds() / 86400)
+
+    decay = max(0.1, 0.98 ** (days_since_last / 30))
+
+    if recent_contradictions >= 2:
+        decay = max(0.1, decay * 0.85)
+
+    if recent_reinforcement:
+        decay = min(1.0, decay * 1.1)
+
+    return round(decay * 1000) / 1000
+
+
+def effective_weight(w: float, decay: float) -> float:
+    return round(w * decay * 1000) / 1000

nomark_engine-0.1.0/src/nomark_engine/ledger.py

@@ -0,0 +1,91 @@
+"""Ledger JSONL parser/writer with capacity constraints.
+
+Ports packages/engine/src/ledger.ts.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+
+from .schema import LedgerEntry, SignalType, parse_ledger_entry
+
+ENTRY_CAPS: dict[SignalType, int] = {
+    "meta": 1,
+    "pref": 20,
+    "map": 10,
+    "asn": 5,
+    "rub": 4,
+}
+
+TOTAL_CAP = 40
+
+_SIGNAL_PREFIX_RE = re.compile(r"^\[sig:(\w+)\]\s+(.+)$")
+
+
+def parse_ledger_line(line: str) -> LedgerEntry | None:
+    """Parse a single ledger line: `[sig:type] {json}`. Returns None for empty or unparseable lines."""
+    trimmed = line.strip()
+    if not trimmed:
+        return None
+
+    match = _SIGNAL_PREFIX_RE.match(trimmed)
+    if not match:
+        return None
+
+    signal_type = match.group(1)
+    try:
+        data = json.loads(match.group(2))
+    except (json.JSONDecodeError, ValueError):
+        return None
+
+    return parse_ledger_entry(signal_type, data)
+
+
+def format_ledger_line(entry: LedgerEntry) -> str:
+    """Format a ledger entry back to `[sig:type] {json}` string."""
+    return f"[sig:{entry.type}] {json.dumps(entry.data.model_dump(exclude_none=True))}"
+
+
+def parse_ledger(content: str) -> list[LedgerEntry]:
+    """Parse a full ledger JSONL string into typed entries."""
+    results: list[LedgerEntry] = []
+    for line in content.split("\n"):
+        entry = parse_ledger_line(line)
+        if entry is not None:
+            results.append(entry)
+    return results
+
+
+def write_ledger(entries: list[LedgerEntry]) -> str:
+    """Serialize ledger entries to JSONL string with typed prefixes."""
+    return "\n".join(format_ledger_line(e) for e in entries) + "\n"
+
+
+def count_by_type(entries: list[LedgerEntry]) -> dict[SignalType, int]:
+    """Count entries by type."""
+    counts: dict[SignalType, int] = {"meta": 0, "pref": 0, "map": 0, "asn": 0, "rub": 0}
+    for entry in entries:
+        counts[entry.type] += 1
+    return counts
+
+
+def check_capacity(entries: list[LedgerEntry]) -> list[str]:
+    """Check if ledger exceeds capacity constraints. Returns violations or empty list."""
+    violations: list[str] = []
+    counts = count_by_type(entries)
+
+    if len(entries) > TOTAL_CAP:
+        violations.append(f"total {len(entries)} exceeds cap {TOTAL_CAP}")
+
+    for signal_type, cap in ENTRY_CAPS.items():
+        count = counts.get(signal_type, 0)
+        if count > cap:
+            violations.append(f"{signal_type} count {count} exceeds cap {cap}")
+
+    return violations
+
+
+def estimate_tokens(entries: list[LedgerEntry]) -> int:
+    """Estimate token count for ledger entries (~75 tokens per entry)."""
+    return len(entries) * 75