strange-loops 0.1.0__tar.gz

strange_loops-0.1.0/.gitignore

@@ -0,0 +1,27 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+.uv-cache/
+uv.lock
+*.jsonl
+.coverage
+.pytest_cache/
+.subtask/
+.tadpole/
+.claude/todos/
+.obsidian/
+.DS_Store
+/data/
+*.db
+*.db-shm
+*.db-wal
+*.gif
+*.tape
+check.vertex
+session.vertex
+!config/**/session.vertex
+!config/**/check.vertex
+.ruff_cache/

strange_loops-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: strange-loops
+Version: 0.1.0
+Summary: A system for focusing attention
+Author-email: Kyle Gruel <kylegruel@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: ckdl>=1.0
+Requires-Dist: painted>=0.1.1
+Requires-Dist: sqlite-ulid
+Description-Content-Type: text/markdown
+
+# strange-loops
+
+A system for focusing attention. Observations flow in, accumulate into state,
+boundaries resolve, conclusions flow out. The conclusions re-enter as new
+observations. The loop closes through the observer.
+
+# Caveat
+This is AI slop. It exists here because I was asked to share it, not because it is in a state to share and faffing about making it non-public seemed silly.

strange_loops-0.1.0/README.md

@@ -0,0 +1,8 @@
+# strange-loops
+
+A system for focusing attention. Observations flow in, accumulate into state,
+boundaries resolve, conclusions flow out. The conclusions re-enter as new
+observations. The loop closes through the observer.
+
+# Caveat
+This is AI slop. It exists here because I was asked to share it, not because it is in a state to share and faffing about making it non-public seemed silly.

strange_loops-0.1.0/apps/loops/src/loops/__main__.py

@@ -0,0 +1,7 @@
+"""Allow running as python -m loops."""
+
+import sys
+
+from .main import main
+
+sys.exit(main())

strange_loops-0.1.0/apps/loops/src/loops/commands/__init__.py

@@ -0,0 +1 @@
+"""Store commands — data fetch layer."""

strange_loops-0.1.0/apps/loops/src/loops/commands/fetch.py

@@ -0,0 +1,207 @@
+"""Data retrieval — fold (collapsed state) and stream (event history).
+
+Supports key drill-down via ``kind/key`` syntax on the ``--kind`` flag:
+``--kind thread/fold-state-types`` filters to the single folded item
+(fold) or facts matching the key field value (stream).
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from atoms import FoldItem, FoldState
+
+
+def _parse_duration(s: str) -> float:
+    """Parse duration string like '7d', '24h', '1h' to seconds."""
+    m = re.match(r"^(\d+)([dhms])$", s)
+    if not m:
+        raise ValueError(f"Invalid duration: {s!r} (expected e.g. '7d', '24h', '1h')")
+    value = int(m.group(1))
+    unit = m.group(2)
+    multipliers = {"d": 86400, "h": 3600, "m": 60, "s": 1}
+    return value * multipliers[unit]
+
+
+def _split_kind_key(kind: str | None) -> tuple[str | None, str | None]:
+    """Split ``kind/key`` into (kind, key). Plain kind returns (kind, None)."""
+    if kind is None:
+        return None, None
+    if "/" in kind:
+        k, v = kind.split("/", 1)
+        return k, v
+    return kind, None
+
+
+def _get_key_field(vertex_path: Path, kind: str) -> str | None:
+    """Look up the key field for a kind from the vertex's fold declarations."""
+    from lang import parse_vertex_file
+    from lang.ast import FoldBy
+
+    ast = parse_vertex_file(vertex_path)
+    loop_def = ast.loops.get(kind)
+    if loop_def and loop_def.folds:
+        fold_decl = loop_def.folds[0]
+        if isinstance(fold_decl.op, FoldBy):
+            return fold_decl.op.key_field
+    return None
+
+
+def fetch_fold(
+    vertex_path: Path,
+    kind: str | None = None,
+    observer: str | None = None,
+) -> "FoldState":
+    """Fetch fold state, with optional key drill-down.
+
+    Supports ``kind/key`` syntax: ``thread/fold-state-types`` filters
+    to the single item whose key field matches. The fold section is
+    preserved (one item instead of many) so lenses render normally.
+    """
+    from atoms import FoldSection, FoldState
+    from engine import vertex_fold
+
+    kind_filter, key_filter = _split_kind_key(kind)
+    state = vertex_fold(vertex_path, observer=observer, kind=kind_filter)
+
+    if key_filter is None:
+        return state
+
+    # Filter sections to items matching the key value
+    filtered: list[FoldSection] = []
+    for section in state.sections:
+        if section.kind != kind_filter:
+            continue
+        matches = tuple(
+            item for item in section.items
+            if _item_matches_key(item, section.key_field, key_filter)
+        )
+        if matches:
+            filtered.append(FoldSection(
+                kind=section.kind,
+                items=matches,
+                sections=section.sections,
+                fold_type=section.fold_type,
+                key_field=section.key_field,
+            ))
+
+    return FoldState(sections=tuple(filtered), vertex=state.vertex)
+
+
+def _item_matches_key(item: "FoldItem", key_field: str | None, key: str) -> bool:
+    """Check if a fold item matches a key value.
+
+    Tries key_field first, then common label fields. Case-insensitive.
+    """
+    candidates = [key_field] if key_field else []
+    candidates.extend(["topic", "name", "title", "summary"])
+
+    for field in candidates:
+        if field and field in item.payload:
+            val = str(item.payload[field])
+            if val.lower() == key.lower():
+                return True
+    return False
+
+
+def fetch_stream(
+    vertex_path: Path,
+    *,
+    query: str | None = None,
+    kind: str | None = None,
+    since: str | None = None,
+    observer: str | None = None,
+) -> dict:
+    """Fetch event stream with three orthogonal filters.
+
+    Unifies log + search into a single fetch. When *query* is provided,
+    uses FTS5 search; otherwise returns raw facts in reverse-chrono order.
+
+    Supports ``kind/key`` drill-down: ``--kind thread/fold-state-types``
+    returns only facts whose key field payload matches. When drilling down,
+    time window defaults to all history (not 7d).
+
+    Returns ``{"facts": list[dict], "fold_meta": dict, "vertex": str}``.
+    """
+    from engine import vertex_facts, vertex_search
+    from lang import parse_vertex_file
+    from lang.ast import FoldBy
+
+    kind_filter, key_filter = _split_kind_key(kind)
+
+    # When drilling into a specific item, default to all history
+    default_since = "7d" if key_filter is None else "3650d"
+    since_secs = _parse_duration(since or default_since)
+    now = datetime.now(timezone.utc)
+    since_ts = (now - timedelta(seconds=since_secs)).timestamp()
+
+    if query:
+        facts = vertex_search(
+            vertex_path, query, kind=kind_filter, since=since_ts, limit=100,
+            observer=observer,
+        )
+    else:
+        facts = vertex_facts(
+            vertex_path, since_ts, now.timestamp(), kind=kind_filter,
+            observer=observer,
+        )
+
+    # Key drill-down: filter facts by payload key field value
+    if key_filter is not None:
+        key_field = _get_key_field(vertex_path, kind_filter) if kind_filter else None
+        facts = [
+            f for f in facts
+            if _fact_matches_key(f, key_field, key_filter)
+        ]
+
+    facts.sort(key=lambda f: f["ts"], reverse=True)
+
+    # Normalize timestamps for JSON serialization
+    for f in facts:
+        if isinstance(f["ts"], datetime):
+            f["ts"] = f["ts"].isoformat()
+
+    # Get fold declarations for rendering hints
+    ast = parse_vertex_file(vertex_path)
+    fold_meta: dict[str, dict] = {}
+    for k, loop_def in ast.loops.items():
+        key_field = None
+        if loop_def.folds:
+            fold_decl = loop_def.folds[0]
+            if isinstance(fold_decl.op, FoldBy):
+                key_field = fold_decl.op.key_field
+        fold_meta[k] = {"key_field": key_field}
+
+    return {"facts": facts, "fold_meta": fold_meta, "vertex": ast.name}
+
+
+def _fact_matches_key(fact: dict, key_field: str | None, key: str) -> bool:
+    """Check if a raw fact's payload matches a key value."""
+    payload = fact.get("payload", {})
+    candidates = [key_field] if key_field else []
+    candidates.extend(["topic", "name", "title", "summary"])
+
+    for field in candidates:
+        if field and field in payload:
+            val = str(payload[field])
+            if val.lower() == key.lower():
+                return True
+    return False
+
+
+def fetch_fact_by_id(
+    vertex_path: Path,
+    fact_id: str,
+) -> dict | None:
+    """Fetch a single fact by ID or ID prefix.
+
+    Returns the full fact dict with id, kind, ts, observer, origin, payload.
+    Returns None if not found. Raises ValueError on ambiguous prefix.
+    """
+    from engine import vertex_fact_by_id
+
+    return vertex_fact_by_id(vertex_path, fact_id)

strange_loops-0.1.0/apps/loops/src/loops/commands/identity.py

@@ -0,0 +1,222 @@
+"""Observer identity — who you are, workspace root, emit validation."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def _loops_home() -> Path:
+    """Resolve the loops config directory (delegates to main.loops_home)."""
+    from loops.main import loops_home
+
+    return loops_home()
+
+
+def find_workspace_root(start: Path | None = None) -> Path | None:
+    """Find .vertex workspace root walking up from start (default: cwd).
+
+    1. .loops/.vertex in start or ancestor dirs
+    2. ~/.config/loops/.vertex (global)
+    Returns None if not found.
+    """
+    current = (start or Path.cwd()).resolve()
+    # Walk up from start
+    for d in [current, *current.parents]:
+        candidate = d / ".loops" / ".vertex"
+        if candidate.exists():
+            return candidate
+    # Global fallback
+    home = _loops_home()
+    global_root = home / ".vertex"
+    if global_root.exists():
+        return global_root
+    return None
+
+
+def _read_observers(vertex_path: Path) -> tuple:
+    """Parse a .vertex file and return its observers tuple (or empty)."""
+    from lang import parse_vertex_file
+
+    try:
+        ast = parse_vertex_file(vertex_path)
+        return ast.observers or ()
+    except Exception:
+        return ()
+
+
+def resolve_observer(explicit: str | None = None, start: Path | None = None) -> str:
+    """Resolve observer identity.
+
+    Priority chain:
+    1. explicit (from --observer flag)
+    2. LOOPS_OBSERVER env var
+    3. Project .vertex observers block (walking up from start)
+    4. Global .vertex observers block
+    Returns "" if nothing resolves.
+    """
+    # 1. Explicit flag
+    if explicit is not None:
+        return explicit
+
+    # 2. Env var
+    env = os.environ.get("LOOPS_OBSERVER")
+    if env is not None:
+        return env
+
+    # 3. Project-level .vertex (walk up)
+    current = (start or Path.cwd()).resolve()
+    for d in [current, *current.parents]:
+        candidate = d / ".loops" / ".vertex"
+        if candidate.exists():
+            observers = _read_observers(candidate)
+            if len(observers) == 1:
+                return observers[0].name
+            if observers:
+                # Multiple observers declared, can't auto-pick
+                return ""
+            break  # found .vertex but no observers — fall through to global
+
+    # 4. Global .vertex
+    home = _loops_home()
+    global_path = home / ".vertex"
+    if global_path.exists():
+        observers = _read_observers(global_path)
+        if len(observers) == 1:
+            return observers[0].name
+
+    return ""
+
+
+def _collect_combine_observers(vertex_path: Path) -> list:
+    """Collect observer declarations from combine/discover source vertices.
+
+    For aggregation vertices, follows the combine chain to source vertices
+    and collects their observer declarations. Same pattern as combine
+    auto-inherit for fold specs — the aggregation vertex accepts the
+    same observers as its sources.
+    """
+    from lang import parse_vertex_file, resolve_vertex
+
+    try:
+        ast = parse_vertex_file(vertex_path)
+    except Exception:
+        return []
+
+    observers: list = []
+    home = _loops_home()
+
+    if ast.combine is not None:
+        for entry in ast.combine:
+            vpath = resolve_vertex(entry.name, home)
+            if not vpath.is_absolute():
+                vpath = (vertex_path.parent / vpath).resolve()
+            if vpath.exists():
+                observers.extend(_read_observers(vpath))
+                # Also check the source vertex's workspace root
+                for d in [vpath.parent, *vpath.parent.parents]:
+                    candidate = d / ".loops" / ".vertex"
+                    if candidate.exists() and candidate.resolve() != vpath.resolve():
+                        observers.extend(_read_observers(candidate))
+                        break
+
+    elif ast.discover is not None:
+        base_dir = vertex_path.parent
+        for match in sorted(base_dir.glob(ast.discover)):
+            if match.suffix != ".vertex" or match.resolve() == vertex_path.resolve():
+                continue
+            observers.extend(_read_observers(match))
+
+    return observers
+
+
+def validate_emit(vertex_path: Path, observer: str, kind: str) -> str | None:
+    """Validate observer + kind against vertex declaration chain.
+
+    Returns error message if rejected, None if allowed.
+    Checks:
+    1. Observer is declared in the vertex itself, .vertex chain, or
+       combine/discover source vertices (cascade)
+    2. Kind is in observer's grant.potential (if grant is declared)
+    """
+    if not observer:
+        return None  # No observer to validate
+
+    # Check the vertex file itself first
+    vertex_observers = _read_observers(vertex_path)
+
+    # Collect observers from project-level .vertex
+    project_observers: tuple = ()
+    project_root = vertex_path.parent
+    for d in [project_root, *project_root.parents]:
+        candidate = d / ".loops" / ".vertex"
+        if candidate.exists() and candidate.resolve() != vertex_path.resolve():
+            project_observers = _read_observers(candidate)
+            break
+
+    # Collect observers from global .vertex
+    home = _loops_home()
+    global_observers: tuple = ()
+    global_path = home / ".vertex"
+    if global_path.exists() and global_path.resolve() != vertex_path.resolve():
+        global_observers = _read_observers(global_path)
+
+    # Collect observers from combine/discover source vertices (cascade)
+    combine_observers = _collect_combine_observers(vertex_path)
+
+    all_observers = (
+        list(vertex_observers)
+        + list(project_observers)
+        + list(global_observers)
+        + combine_observers
+    )
+
+    # No observers declared anywhere -> no validation (open system)
+    if not all_observers:
+        return None
+
+    # Find the observer declaration (supports namespaced observers)
+    from engine.observer import observer_matches
+
+    decl = None
+    for obs in all_observers:
+        if observer_matches(obs.name, observer):
+            decl = obs
+            break
+
+    if decl is None:
+        names = sorted({o.name for o in all_observers})
+        return f"Observer {observer!r} not declared. Known: {', '.join(names)}"
+
+    # Check grant.potential if declared
+    if decl.grant is not None and kind not in decl.grant.potential:
+        allowed = sorted(decl.grant.potential)
+        return f"Observer {observer!r} cannot emit kind {kind!r}. Allowed: {', '.join(allowed)}"
+
+    return None
+
+
+def resolve_local_vertex(start: Path | None = None) -> Path:
+    """Find a vertex file via workspace root walk-up or session fallback.
+
+    Resolution order:
+    1. Local vertex in cwd (*.vertex)
+    2. LOOPS_HOME/session/session.vertex
+
+    Raises FileNotFoundError if neither found.
+    """
+    from loops.main import _find_local_vertex
+
+    # 1. Local vertex in cwd
+    local = _find_local_vertex()
+    if local is not None:
+        return local
+
+    # 2. LOOPS_HOME session fallback
+    session_vertex = _loops_home() / "session" / "session.vertex"
+    if session_vertex.exists():
+        return session_vertex
+
+    raise FileNotFoundError(
+        "No vertex found. Run 'loops init --template session' or 'loops emit <kind> ...' first."
+    )