intentos 0.1.0__py3-none-any.whl

intentos/__init__.py

@@ -0,0 +1,3 @@
+"""IntentOS P1 Runtime Kernel — rapid prototype."""
+
+__version__ = "0.1.0"

intentos/backbone/bus.py

@@ -0,0 +1,114 @@
+"""In-memory Event Bus — RFC-0500 §5.
+
+At-least-once delivery, push subscriptions, dead-letter queue.
+"""
+
+import enum
+import threading
+import time
+from collections import defaultdict
+from typing import Callable
+
+from .event import Event
+
+
+class DeliveryStatus(enum.Enum):
+    PENDING = "pending"
+    DELIVERED = "delivered"
+    DEAD_LETTER = "dead_letter"
+
+
+class DeadLetterEntry:
+    """An event that exhausted delivery retries."""
+    def __init__(self, event: Event, subscriber_id: str, attempts: list[dict]):
+        self.event = event
+        self.subscriber_id = subscriber_id
+        self.attempts = attempts
+        self.moved_at: str = ""
+
+
+_SubCallback = Callable[[Event], bool | None]  # return False to nack
+
+
+class EventBus:
+    """In-memory pub/sub with at-least-once delivery."""
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._subscriptions: dict[str, list[_SubCallback]] = defaultdict(list)
+        self._dead_letter: list[DeadLetterEntry] = []
+        self._sequence = 0
+
+    # ── subscription ────────────────────────────────────────────────
+
+    def subscribe(self, event_type_prefix: str, callback: _SubCallback):
+        """Register a callback for events whose type starts with *prefix*."""
+        with self._lock:
+            self._subscriptions[event_type_prefix].append(callback)
+
+    def unsubscribe(self, event_type_prefix: str, callback: _SubCallback):
+        with self._lock:
+            try:
+                self._subscriptions[event_type_prefix].remove(callback)
+            except ValueError:
+                pass
+
+    # ── publish ─────────────────────────────────────────────────────
+
+    def publish(self, event: Event) -> list[DeadLetterEntry]:
+        """Deliver *event* to all matching subscribers.
+
+        Returns any dead-letter entries created during delivery.
+        """
+        with self._lock:
+            self._sequence += 1
+            event.metadata["sequence_id"] = self._sequence
+
+        dead = []
+        for prefix, callbacks in self._matching(event.event_type):
+            for cb in callbacks:
+                attempts: list[dict] = []
+                ok = False
+                for attempt in range(1, 4):  # max_retries=3
+                    try:
+                        result = cb(event)
+                        if result is False:
+                            raise ValueError("subscriber nack")
+                        ok = True
+                        break
+                    except Exception as exc:
+                        attempts.append({
+                            "attempt": attempt,
+                            "error": str(exc),
+                            "at": time.time(),
+                        })
+                        time.sleep(0.1 * attempt)  # simple backoff
+
+                if not ok:
+                    entry = DeadLetterEntry(event, prefix, attempts)
+                    entry.moved_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+                    self._dead_letter.append(entry)
+                    dead.append(entry)
+        return dead
+
+    def _matching(self, event_type: str) -> list[tuple[str, list]]:
+        with self._lock:
+            return [(p, list(cbs)) for p, cbs in self._subscriptions.items()
+                    if event_type.startswith(p)]
+
+    # ── dead-letter ─────────────────────────────────────────────────
+
+    @property
+    def dead_letter_queue(self) -> list[DeadLetterEntry]:
+        return list(self._dead_letter)
+
+    def replay_dead_letter(self) -> list[DeadLetterEntry]:
+        """Re-attempt delivery of all dead-letter events."""
+        pending = list(self._dead_letter)
+        self._dead_letter.clear()
+        still_dead = []
+        for entry in pending:
+            event = entry.event
+            dead = self.publish(event)
+            still_dead.extend(dead)
+        return still_dead

intentos/backbone/event.py

@@ -0,0 +1,60 @@
+"""Event envelope — RFC-0500 §4."""
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+from uuid import uuid4
+
+
+@dataclass(frozen=True)
+class Event:
+    """Canonical Event envelope per SPEC-0000 §3.9 / RFC-0500 §4."""
+    event_id: str
+    event_type: str
+    version: int = 1
+
+    source: dict = field(default_factory=lambda: {"module": "unknown", "instance_id": ""})
+    payload: dict = field(default_factory=dict)
+
+    metadata: dict = field(default_factory=lambda: {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "sequence_id": 0,
+        "content_type": "application/json",
+        "size_bytes": 0,
+    })
+    context: dict = field(default_factory=dict)
+
+    @classmethod
+    def new(cls, event_type: str, payload: dict, *,
+            source: dict | None = None,
+            context: dict | None = None,
+            sequence_id: int = 0) -> "Event":
+        raw = json.dumps(payload, default=str).encode()
+        return cls(
+            event_id=f"event://ref/{uuid4()}",
+            event_type=event_type,
+            source=source or {"module": "unknown", "instance_id": ""},
+            payload=payload,
+            metadata={
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "sequence_id": sequence_id,
+                "content_type": "application/json",
+                "size_bytes": len(raw),
+            },
+            context=context or {},
+        )
+
+    def to_json(self) -> str:
+        return json.dumps({
+            "event_id": self.event_id,
+            "event_type": self.event_type,
+            "version": self.version,
+            "source": self.source,
+            "payload": self.payload,
+            "metadata": self.metadata,
+            "context": self.context,
+        }, default=str, indent=2)
+
+    def __repr__(self) -> str:
+        return f"Event({self.event_type}, id={self.event_id[:24]}…)"

intentos/backbone/schema.py

@@ -0,0 +1,68 @@
+"""Schema Registry — RFC-0500 §7."""
+
+import json
+from datetime import datetime, timezone
+from typing import Any
+
+
+class SchemaRegistry:
+    """Event type registration and publish-time validation."""
+
+    def __init__(self):
+        self._schemas: dict[str, dict[int, dict]] = {}  # event_type → {version → schema}
+
+    def register(self, event_type: str, version: int, schema: dict[str, Any],
+                 *, description: str = "", producer: str = "",
+                 consumers: list[str] | None = None) -> None:
+        if version in self._schemas.get(event_type, {}):
+            raise ValueError(f"Schema {event_type} v{version} already registered")
+        self._schemas.setdefault(event_type, {})[version] = {
+            "schema": schema,
+            "description": description,
+            "producer": producer,
+            "consumers": consumers or [],
+        }
+
+    def validate(self, event_type: str, version: int, payload: dict) -> None:
+        entry = self._schemas.get(event_type, {}).get(version)
+        if entry is None:
+            raise ValueError(f"Schema not registered: {event_type} v{version}")
+
+        schema = entry["schema"]
+        required = schema.get("required", [])
+        props = schema.get("properties", {})
+
+        for field in required:
+            if field not in payload:
+                raise ValueError(f"Missing required field '{field}' in {event_type} v{version}")
+
+        for field, value in payload.items():
+            if field not in props:
+                continue
+            prop_schema = props[field]
+            self._validate_type(field, value, prop_schema)
+
+    def _validate_type(self, field: str, value: Any, prop_schema: dict):
+        kind = prop_schema.get("type")
+        if kind == "string":
+            if not isinstance(value, str):
+                raise TypeError(f"Field '{field}' should be string, got {type(value).__name__}")
+            if "pattern" in prop_schema:
+                import re
+                if not re.match(prop_schema["pattern"], str(value)):
+                    raise ValueError(f"Field '{field}' does not match pattern {prop_schema['pattern']}")
+        elif kind == "integer":
+            if not isinstance(value, int) or isinstance(value, bool):
+                raise TypeError(f"Field '{field}' should be integer, got {type(value).__name__}")
+        elif kind == "number":
+            if not isinstance(value, (int, float)):
+                raise TypeError(f"Field '{field}' should be number, got {type(value).__name__}")
+        elif kind == "boolean":
+            if not isinstance(value, bool):
+                raise TypeError(f"Field '{field}' should be boolean, got {type(value).__name__}")
+        elif kind == "array":
+            if not isinstance(value, list):
+                raise TypeError(f"Field '{field}' should be array, got {type(value).__name__}")
+        elif kind == "object":
+            if not isinstance(value, dict):
+                raise TypeError(f"Field '{field}' should be object, got {type(value).__name__}")

intentos/backbone/store.py

@@ -0,0 +1,162 @@
+"""SQLite-backed Event Store — RFC-0500 §6.
+
+Append-only log with replay, snapshot, and compaction support.
+"""
+
+import json
+import sqlite3
+import threading
+from collections.abc import Generator
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .event import Event
+
+
+class EventStore:
+    """Append-only Event Store backed by SQLite."""
+
+    def __init__(self, db_path: str | Path):
+        self._path = Path(db_path)
+        self._lock = threading.Lock()
+        self._conn = sqlite3.connect(str(self._path), check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+        self._init_schema()
+
+    def _init_schema(self):
+        self._conn.executescript(f"""
+            CREATE TABLE IF NOT EXISTS events (
+                event_id        TEXT PRIMARY KEY,
+                event_type      TEXT NOT NULL,
+                version         INTEGER NOT NULL DEFAULT 1,
+                source_module   TEXT NOT NULL,
+                execution_id    TEXT,
+                session_id      TEXT,
+                payload         TEXT NOT NULL,
+                metadata        TEXT NOT NULL,
+                context         TEXT NOT NULL DEFAULT '{{}}',
+                published_at    TEXT NOT NULL,
+                ingested_at     TEXT NOT NULL DEFAULT (strftime('%%Y-%%m-%%dT%%H:%%M:%%fZ', 'now'))
+            );
+            CREATE TABLE IF NOT EXISTS snapshots (
+                snapshot_id     TEXT PRIMARY KEY,
+                execution_id    TEXT NOT NULL,
+                at_sequence     INTEGER NOT NULL,
+                state           TEXT NOT NULL,
+                created_at      TEXT NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS idx_events_execution
+                ON events(execution_id, json_extract(metadata, '$.sequence_id'));
+            CREATE INDEX IF NOT EXISTS idx_events_type_time
+                ON events(event_type, published_at);
+            CREATE INDEX IF NOT EXISTS idx_events_source
+                ON events(source_module, published_at);
+            CREATE INDEX IF NOT EXISTS idx_snapshots_execution
+                ON snapshots(execution_id, at_sequence DESC);
+        """)
+        self._conn.commit()
+
+    # ── write ───────────────────────────────────────────────────────
+
+    def append(self, event: Event) -> str:
+        with self._lock:
+            self._conn.execute(
+                """INSERT INTO events
+                   (event_id, event_type, version, source_module,
+                    execution_id, session_id, payload, metadata, context,
+                    published_at)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                (
+                    event.event_id,
+                    event.event_type,
+                    event.version,
+                    event.source.get("module", "unknown"),
+                    event.context.get("execution_id"),
+                    event.context.get("session_id"),
+                    json.dumps(event.payload, default=str),
+                    json.dumps(event.metadata, default=str),
+                    json.dumps(event.context, default=str),
+                    event.metadata.get("timestamp", datetime.now(timezone.utc).isoformat()),
+                ),
+            )
+            self._conn.commit()
+        return event.event_id
+
+    # ── replay ──────────────────────────────────────────────────────
+
+    def replay(self, *, execution_id: str | None = None,
+               event_type: str | None = None,
+               from_sequence: int | None = None,
+               limit: int = 0) -> Generator[dict[str, Any], None, None]:
+        """Yield stored events as dicts matching the filter criteria."""
+        clauses: list[str] = []
+        params: list[Any] = []
+
+        if execution_id:
+            clauses.append("execution_id = ?")
+            params.append(execution_id)
+        if event_type:
+            clauses.append("event_type = ?")
+            params.append(event_type)
+        if from_sequence is not None:
+            clauses.append("CAST(json_extract(metadata, '$.sequence_id') AS INTEGER) >= ?")
+            params.append(from_sequence)
+
+        where = " AND ".join(clauses) if clauses else "1"
+        sql = f"SELECT * FROM events WHERE {where} ORDER BY rowid"
+        if limit:
+            sql += f" LIMIT {limit}"
+
+        with self._lock:
+            # fmt:off
+            rows = self._conn.execute(sql, params).fetchall()
+            # fmt:on
+
+        for row in rows:
+            yield {
+                "event_id": row["event_id"],
+                "event_type": row["event_type"],
+                "version": row["version"],
+                "source": {"module": row["source_module"]},
+                "payload": json.loads(row["payload"]),
+                "metadata": json.loads(row["metadata"]),
+                "context": json.loads(row["context"]),
+                "published_at": row["published_at"],
+            }
+
+    # ── snapshot / compaction (RFC-0500 §6.3) ───────────────────────
+
+    def save_snapshot(self, execution_id: str, at_sequence: int,
+                      state: dict[str, Any]) -> str:
+        snap_id = f"snapshot://ref/{execution_id}/{at_sequence}"
+        self._conn.execute(
+            """INSERT OR REPLACE INTO snapshots
+               (snapshot_id, execution_id, at_sequence, state, created_at)
+               VALUES (?, ?, ?, ?, ?)""",
+            (snap_id, execution_id, at_sequence,
+             json.dumps(state, default=str),
+             datetime.now(timezone.utc).isoformat()),
+        )
+        self._conn.commit()
+        return snap_id
+
+    def load_snapshot(self, execution_id: str) -> dict[str, Any] | None:
+        try:
+            row = self._conn.execute(
+                """SELECT state, at_sequence FROM snapshots
+                   WHERE execution_id = ? ORDER BY at_sequence DESC LIMIT 1""",
+                (execution_id,),
+            ).fetchone()
+            if row:
+                return {"state": json.loads(row["state"]), "at_sequence": row["at_sequence"]}
+        except sqlite3.OperationalError:
+            pass  # table might not exist yet
+        return None
+
+    def count(self) -> int:
+        row = self._conn.execute("SELECT COUNT(*) AS c FROM events").fetchone()
+        return row["c"] if row else 0
+
+    def close(self):
+        self._conn.close()

intentos/capabilities/__init__.py

@@ -0,0 +1,44 @@
+"""Built-in capabilities registry."""
+from ..registry import CapabilityManifest
+from .search import search
+from .llm import llm
+from .review import review
+from .report import report
+
+CAPABILITIES = {
+    "search": search,
+    "llm": llm,
+    "gather": review,
+    "review": review,
+    "report": report,
+}
+
+CAPABILITY_MANIFESTS = [
+    CapabilityManifest(
+        task_type="search", display_name="Web Search",
+        description="Search the web for information",
+        version="0.1.0", tags=["research", "fetch"], fn=search,
+    ),
+    CapabilityManifest(
+        task_type="llm", display_name="LLM Analysis",
+        description="Analyze data using a large language model",
+        version="0.1.0", tags=["analysis", "ai"], fn=llm,
+    ),
+    CapabilityManifest(
+        task_type="gather", display_name="Result Gathering",
+        description="Aggregate and summarize task outputs",
+        version="0.1.0", tags=["aggregation"], fn=review,
+    ),
+    CapabilityManifest(
+        task_type="review", display_name="Quality Review",
+        description="Review task outputs for quality and completeness",
+        version="0.1.0", tags=["quality"], fn=review,
+    ),
+    CapabilityManifest(
+        task_type="report", display_name="Report Generation",
+        description="Compile final Markdown report",
+        version="0.1.0", tags=["output"], fn=report,
+    ),
+]
+
+__all__ = ["search", "llm", "review", "report", "CAPABILITIES", "CAPABILITY_MANIFESTS"]

intentos/capabilities/llm.py

@@ -0,0 +1,25 @@
+"""LLM capability — calls OpenAI-compatible API, falls back to mock."""
+from ..llm_executor import call_llm
+from ..models import PlannedTask
+from typing import Any
+
+def llm(task: PlannedTask, context: dict[str, Any]) -> str:
+    prompt = task.params.get("prompt", str(context))
+    system = task.params.get("system", "You are a helpful financial analyst.")
+    try:
+        return call_llm(prompt, system_prompt=system)
+    except (ConnectionError, ValueError) as e:
+        import logging
+        logging.warning("LLM API call failed, falling back to mock: %s", e)
+        return (
+            f"【LLM 分析结果 — API不可用，使用模拟数据】\n\n"
+            f"输入提示: {prompt[:100]}...\n\n"
+            "## 投资亮点\n"
+            "- 行业领先地位\n"
+            "- 强劲的营收增长\n\n"
+            "## 风险因素\n"
+            "- 市场竞争加剧\n"
+            "- 监管不确定性\n\n"
+            "## 综合评估\n"
+            "建议持续关注。（注: v1 模拟数据）"
+        )

intentos/capabilities/report.py

@@ -0,0 +1,26 @@
+"""Report capability — compiles final Markdown output."""
+from ..models import PlannedTask
+from typing import Any
+import re
+
+def report(task: PlannedTask, context: dict[str, Any]) -> str:
+    sections = task.params.get("sections", [])
+    lines = []
+    for sec in sections:
+        title = sec.get("title", "")
+        content = sec.get("content", "")
+        resolved = _resolve_template(content, context)
+        if title:
+            lines.append(f"## {title}")
+        lines.append(resolved)
+    return "\n\n".join(lines)
+
+
+def _resolve_template(template: str, context: dict[str, Any]) -> str:
+    """Simple {{variable}} replacement from context."""
+    def _replacer(m):
+        key = m.group(1).strip()
+        val = context.get(key, m.group(0))
+        val = context.get(key, "")
+        return str(val) if val is not None else m.group(0)
+    return re.sub(r"\{\{(.+?)\}\}", _replacer, template)

intentos/capabilities/review.py

@@ -0,0 +1,12 @@
+"""Review capability — aggregates previous task outputs."""
+from ..models import PlannedTask
+from typing import Any
+
+def review(task: PlannedTask, context: dict[str, Any]) -> dict:
+    checks = task.params.get("checks", ["non_empty"])
+    outputs = {k: v for k, v in context.items() if isinstance(v, str)}
+    return {
+        "checks": checks,
+        "non_empty_count": sum(1 for v in outputs.values() if v.strip()),
+        "text": "\n\n".join(outputs.values()),
+    }

intentos/capabilities/search.py

@@ -0,0 +1,111 @@
+"""
+Search capability — DuckDuckGo Instant Answer API with mock fallback.
+
+Uses https://api.duckduckgo.com/?q=QUERY&format=json&no_html=1
+No API key required. Falls back to mock data when the API is unreachable.
+"""
+import json
+import urllib.request
+import urllib.error
+import urllib.parse
+from ..models import PlannedTask
+from typing import Any
+
+DDG_API_URL = "https://api.duckduckgo.com/"
+
+def _fetch_ddg(query: str, sources: list[str] | None = None) -> str:
+    """
+    Query DuckDuckGo Instant Answer API.
+    Returns formatted markdown-like text.
+    """
+    params = {
+        "q": query,
+        "format": "json",
+        "no_html": "1",
+        "skip_disambig": "1",
+    }
+    url = DDG_API_URL + "?" + urllib.parse.urlencode(params)
+
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "Agent-OS/1.0"})
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+    except (urllib.error.URLError, urllib.error.HTTPError, OSError, json.JSONDecodeError):
+        return _mock_fallback(query)
+
+    return _format_ddg_response(data, query)
+
+
+def _format_ddg_response(data: dict, query: str) -> str:
+    """Format DuckDuckGo API response into readable text."""
+    lines = [f"【Search Results】\nQuery: {query}\n"]
+
+    # Abstract (Answer)
+    abstract = data.get("Abstract", "") or ""
+    if abstract:
+        lines.append(f"▸ Summary: {abstract}\n")
+
+    # Definition
+    definition = data.get("Definition", "") or ""
+    if definition:
+        lines.append(f"▸ Definition: {definition}\n")
+
+    # Infobox
+    infobox = data.get("Infobox", None)
+    if infobox and isinstance(infobox, dict):
+        content = infobox.get("content", []) or []
+        if content:
+            lines.append("▸ Info:\n")
+            for item in content:
+                label = item.get("label", "") or ""
+                val = item.get("value", "") or ""
+                if label and val:
+                    lines.append(f"   • {label}: {val}\n")
+
+    # Related topics (first 3)
+    related = data.get("RelatedTopics", []) or []
+    if related:
+        lines.append("\n▸ Related Topics:\n")
+        count = 0
+        for topic in related:
+            if count >= 3:
+                break
+            text = topic.get("Text", "") or ""
+            if text:
+                lines.append(f"   • {text}\n")
+                count += 1
+
+    # Results from the API
+    results = data.get("Results", []) or []
+    if results:
+        lines.append("\n▸ Results:\n")
+        for i, r in enumerate(results[:5], 1):
+            text = r.get("Text", "") or ""
+            first_url = r.get("FirstURL", "") or ""
+            if text:
+                lines.append(f"  {i}. {text}\n")
+            if first_url:
+                lines.append(f"     {first_url}\n")
+
+    if not abstract and not definition and not infobox and not related and not results:
+        return _mock_fallback(query)
+
+    return "\n".join(lines).strip()
+
+
+def _mock_fallback(query: str) -> str:
+    """Mock fallback when DuckDuckGo API is unavailable."""
+    return (
+        f"【Search Results】\n"
+        f"Query: {query}\n\n"
+        f"1. {query} — latest developments summary\n"
+        f"2. {query} — industry analysis\n"
+        f"3. Related market data\n\n"
+        "(Note: DuckDuckGo API was unavailable; showing fallback mock data)"
+    )
+
+
+def search(task: PlannedTask, context: dict[str, Any]) -> str:
+    query = task.params.get("query", "")
+    sources = task.params.get("sources", None)
+    return _fetch_ddg(query, sources)