@event4u/agent-config 6.1.0 → 7.0.0

package/src/scripts/ai_council/pricing.py

@@ -1,215 +0,0 @@
-"""Runtime pricing layer for the AI Council.
-
-Reads `agents/runtime/.agent-prices.md` from the repo root, parses YAML
-frontmatter and the Markdown table, and exposes:
-
-- `load_prices()`           — parse `agents/runtime/.agent-prices.md` (bootstraps if missing)
-- `estimate_input_tokens()` — chars / 4 heuristic
-- `estimate_cost()`         — input + output USD for a single member
-- `is_stale()`              — True if `last_updated` is older than the
-                              most recent UTC Monday 00:00
-- `bootstrap_from_defaults()` — write a fresh `agents/runtime/.agent-prices.md`
-                              from `_default_prices.DEFAULT_PRICES`
-
-The orchestrator never reads `_default_prices` directly. It always
-goes through `load_prices()` so user edits to
-`agents/runtime/.agent-prices.md` win.
-"""
-
-from __future__ import annotations
-
-import datetime as _dt
-from dataclasses import dataclass
-from pathlib import Path
-
-from scripts.ai_council._default_prices import DEFAULT_PRICES, LAST_UPDATED, as_rows
-
-REPO_ROOT = Path(__file__).resolve().parents[3]
-PRICES_FILE = REPO_ROOT / "agents" / "runtime" / ".agent-prices.md"
-
-# Heuristic: 1 token ≈ 4 characters of English text. OpenAI's tiktoken
-# is more accurate but pulls in a heavy dep we explicitly avoid.
-_CHARS_PER_TOKEN = 4
-
-
-@dataclass
-class Price:
-    provider: str
-    model: str
-    input_per_1m_usd: float
-    output_per_1m_usd: float
-
-
-@dataclass
-class PriceTable:
-    last_updated: str  # YYYY-MM-DD
-    currency: str
-    unit: str  # "per_1M_tokens"
-    source: str
-    prices: dict[tuple[str, str], Price]
-
-    def lookup(self, provider: str, model: str) -> Price | None:
-        return self.prices.get((provider, model))
-
-
-@dataclass
-class CostEstimate:
-    provider: str
-    model: str
-    input_tokens: int
-    output_tokens: int  # max_tokens budget — worst-case ceiling
-    input_usd: float
-    output_usd: float
-
-    @property
-    def total_usd(self) -> float:
-        return self.input_usd + self.output_usd
-
-
-# ── token + cost arithmetic ────────────────────────────────────────
-
-
-def estimate_input_tokens(text: str) -> int:
-    """chars / 4 heuristic. Always returns ≥ 1 for non-empty strings."""
-    if not text:
-        return 0
-    return max(1, len(text) // _CHARS_PER_TOKEN)
-
-
-def estimate_cost(
-    provider: str,
-    model: str,
-    input_tokens: int,
-    max_output_tokens: int,
-    table: PriceTable,
-) -> CostEstimate:
-    price = table.lookup(provider, model)
-    if price is None:
-        # Unknown model — return zero-cost estimate; caller decides what
-        # to do (warn user, skip, ...). Never silently invent a price.
-        return CostEstimate(provider, model, input_tokens, max_output_tokens, 0.0, 0.0)
-    input_usd = (input_tokens / 1_000_000) * price.input_per_1m_usd
-    output_usd = (max_output_tokens / 1_000_000) * price.output_per_1m_usd
-    return CostEstimate(provider, model, input_tokens, max_output_tokens, input_usd, output_usd)
-
-
-# ── staleness ──────────────────────────────────────────────────────
-
-
-def last_monday_utc(now: _dt.datetime | None = None) -> _dt.date:
-    """Return the most recent Monday 00:00 UTC as a date."""
-    now = now or _dt.datetime.now(_dt.timezone.utc)
-    weekday = now.weekday()  # Mon=0 ... Sun=6
-    return (now - _dt.timedelta(days=weekday)).date()
-
-
-def is_stale(table: PriceTable, now: _dt.datetime | None = None) -> bool:
-    """True if `last_updated` is older than the most recent UTC Monday."""
-    try:
-        last = _dt.date.fromisoformat(table.last_updated)
-    except ValueError:
-        return True
-    return last < last_monday_utc(now)
-
-
-# ── parser + bootstrap ─────────────────────────────────────────────
-
-
-def load_prices(path: Path = PRICES_FILE) -> PriceTable:
-    """Parse `agents/runtime/.agent-prices.md`; bootstrap from defaults if missing."""
-    if not path.exists():
-        bootstrap_from_defaults(path)
-    return _parse(path.read_text(encoding="utf-8"))
-
-
-def bootstrap_from_defaults(path: Path = PRICES_FILE) -> None:
-    """Write a fresh `agents/runtime/.agent-prices.md` from `_default_prices.py`."""
-    path.parent.mkdir(parents=True, exist_ok=True)
-    rows = as_rows()
-    body = _render_markdown(LAST_UPDATED, "shipped-default", rows)
-    path.write_text(body, encoding="utf-8")
-
-
-def _render_markdown(
-    last_updated: str,
-    source: str,
-    rows: list[tuple[str, str, float, float]],
-) -> str:
-    lines = [
-        "---",
-        f"last_updated: {last_updated}",
-        "currency: USD",
-        "unit: per_1M_tokens",
-        f"source: {source}",
-        "---",
-        "",
-        "# Agent prices",
-        "",
-        "| provider  | model               | input  | output |",
-        "|-----------|---------------------|--------|--------|",
-    ]
-    for provider, model, inp, outp in rows:
-        lines.append(f"| {provider:<9} | {model:<19} | {inp:>6.2f} | {outp:>6.2f} |")
-    lines.append("")
-    return "\n".join(lines)
-
-
-def _parse(text: str) -> PriceTable:
-    front, body = _split_frontmatter(text)
-    meta = _parse_frontmatter(front)
-    prices = _parse_table(body)
-    return PriceTable(
-        last_updated=meta.get("last_updated", "1970-01-01"),
-        currency=meta.get("currency", "USD"),
-        unit=meta.get("unit", "per_1M_tokens"),
-        source=meta.get("source", "unknown"),
-        prices=prices,
-    )
-
-
-def _split_frontmatter(text: str) -> tuple[str, str]:
-    if not text.startswith("---"):
-        return "", text
-    parts = text.split("---", 2)
-    if len(parts) < 3:
-        return "", text
-    return parts[1], parts[2]
-
-
-def _parse_frontmatter(front: str) -> dict[str, str]:
-    out: dict[str, str] = {}
-    for line in front.splitlines():
-        line = line.strip()
-        if not line or ":" not in line:
-            continue
-        k, _, v = line.partition(":")
-        out[k.strip()] = v.strip()
-    return out
-
-
-def _parse_table(body: str) -> dict[tuple[str, str], Price]:
-    out: dict[tuple[str, str], Price] = {}
-    for line in body.splitlines():
-        line = line.strip()
-        if not line.startswith("|") or line.startswith("|--") or line.startswith("|-"):
-            continue
-        cells = [c.strip() for c in line.strip("|").split("|")]
-        if len(cells) != 4:
-            continue
-        provider, model, inp, outp = cells
-        if provider == "provider":  # header row
-            continue
-        try:
-            out[(provider, model)] = Price(provider, model, float(inp), float(outp))
-        except ValueError:
-            continue
-    return out
-
-
-__all__ = [
-    "Price", "PriceTable", "CostEstimate",
-    "PRICES_FILE", "DEFAULT_PRICES",
-    "load_prices", "bootstrap_from_defaults",
-    "estimate_input_tokens", "estimate_cost",
-    "last_monday_utc", "is_stale",
-]

package/src/scripts/ai_council/probation_gate.py

@@ -1,152 +0,0 @@
-"""Probation promote-and-prune for ``agents/decisions/low-impact-decisions.md``.
-
-Phase 12 § Step 3. Runs at council startup AND after every intake
-append. Idempotent — a second run on an unchanged corpus is a no-op.
-
-Rules:
-
-- **Prune.** For each ``## On Probation`` entry, drop any ``seen``
-  timestamp older than ``WINDOW_DAYS`` (default 30) from ``today``
-  (UTC). If the ``seen`` array empties, drop the whole entry.
-- **Promote.** If the trimmed ``seen`` array has ≥ ``PROMOTION_THRESHOLD``
-  entries (default 3), move the entry to ``## Validated`` — strip the
-  ``seen`` array, add ``validated <today>`` marker. One-way: a
-  Validated entry never falls back.
-- **Log.** Returns :class:`GateRun` with the counts, suitable for
-  one-line session-artefact logging.
-"""
-
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-
-WINDOW_DAYS = 30
-PROMOTION_THRESHOLD = 3
-
-_PROBATION_HEADER = "## On Probation"
-_VALIDATED_HEADER = "## Validated"
-_TERMINAL_HEADERS = (
-    "## Anti-Examples",
-    "## Security",
-    "## Provenance",
-)
-
-
-@dataclass(frozen=True)
-class GateRun:
-    pruned_timestamps: int
-    dropped_entries: int
-    promoted_entries: int
-
-    def log_line(self) -> str:
-        return (
-            f"probation-gate: pruned {self.pruned_timestamps} stale "
-            f"timestamps; promoted {self.promoted_entries} entries; "
-            f"dropped {self.dropped_entries} expired entries"
-        )
-
-    @property
-    def is_noop(self) -> bool:
-        return (self.pruned_timestamps == 0
-                and self.dropped_entries == 0
-                and self.promoted_entries == 0)
-
-
-def _today() -> datetime:
-    return datetime.now(timezone.utc)
-
-
-def _section_span(text: str, header: str) -> tuple[int, int] | None:
-    i = text.find(header)
-    if i < 0:
-        return None
-    body_start = text.find("\n", i) + 1
-    end = len(text)
-    for other in (_PROBATION_HEADER, _VALIDATED_HEADER) + _TERMINAL_HEADERS:
-        if other == header:
-            continue
-        j = text.find("\n" + other, body_start)
-        if 0 <= j < end:
-            end = j
-    return body_start, end
-
-
-def _parse_probation_line(line: str) -> tuple[str, str, list[str]] | None:
-    m = re.match(
-        r'^(\s*-\s*"[^"]+")\s*—\s*first-seen\s+(\d{4}-\d{2}-\d{2})'
-        r'\s*·\s*seen\s*\[([^\]]*)\]\s*$',
-        line,
-    )
-    if not m:
-        return None
-    prefix = m.group(1)
-    first_seen = m.group(2)
-    seen_raw = m.group(3).strip()
-    seen = [s.strip() for s in seen_raw.split(",") if s.strip()] if seen_raw else []
-    return prefix, first_seen, seen
-
-
-def _parse_date(s: str) -> datetime | None:
-    try:
-        return datetime.strptime(s, "%Y-%m-%d").replace(tzinfo=timezone.utc)
-    except ValueError:
-        return None
-
-
-def run_gate(corpus_path: Path, *, today: datetime | None = None) -> GateRun:
-    """Promote-and-prune pass. Writes corpus only when state changes."""
-    today = today or _today()
-    cutoff = today - timedelta(days=WINDOW_DAYS)
-    text = corpus_path.read_text(encoding="utf-8")
-    prob = _section_span(text, _PROBATION_HEADER)
-    val = _section_span(text, _VALIDATED_HEADER)
-    if not prob or not val:
-        return GateRun(0, 0, 0)
-
-    prob_body = text[prob[0]:prob[1]]
-    promoted: list[str] = []
-    pruned_ts = 0
-    dropped = 0
-    out_lines: list[str] = []
-    for line in prob_body.splitlines():
-        parsed = _parse_probation_line(line)
-        if parsed is None:
-            out_lines.append(line)
-            continue
-        prefix, first_seen, seen = parsed
-        original_len = len(seen)
-        fresh = [
-            s for s in seen
-            if (d := _parse_date(s)) is not None and d >= cutoff
-        ]
-        pruned_ts += original_len - len(fresh)
-        if len(fresh) >= PROMOTION_THRESHOLD:
-            today_str = today.strftime("%Y-%m-%d")
-            promoted.append(
-                f'{prefix} — domain: low-impact · validated {today_str}'
-            )
-            continue
-        if not fresh:
-            dropped += 1
-            continue
-        out_lines.append(
-            f'{prefix} — first-seen {first_seen} · seen [{", ".join(fresh)}]'
-        )
-
-    new_prob_body = "\n".join(out_lines)
-    if not new_prob_body.endswith("\n"):
-        new_prob_body += "\n"
-
-    new_text = text[:prob[0]] + new_prob_body + text[prob[1]:]
-    if promoted:
-        v_start, v_end = _section_span(new_text, _VALIDATED_HEADER)  # type: ignore[misc]
-        insertion = "\n".join(promoted) + "\n"
-        new_text = new_text[:v_end].rstrip() + "\n\n" + insertion + new_text[v_end:]
-
-    result = GateRun(pruned_ts, dropped, len(promoted))
-    if not result.is_noop:
-        corpus_path.write_text(new_text, encoding="utf-8")
-    return result

package/src/scripts/ai_council/project_context.py

@@ -1,159 +0,0 @@
-"""Lightweight project-context detector for the council handoff preamble.
-
-Council members do better critique when they know what the project IS,
-not just what the artefact looks like. This module reads the bare
-minimum from the repo root — `composer.json`, `package.json`, root
-`README.md` — and returns a neutral `ProjectContext`. All fields are
-optional; missing data is `None` and the preamble silently omits the
-line.
-
-Iron law of neutrality (`ai-council` skill): nothing here may carry
-host-agent identity, prior reasoning, or framing. Manifest fields and
-README prose only.
-
-Truncation strategy (locked by council review, 2026-05-02): the
-``repo_purpose`` field is capped at ``REPO_PURPOSE_MAX_CHARS`` by
-stopping at the **last full sentence ≤ 400 chars**, with an ellipsis
-when truncation occurred. We never cut mid-sentence — a half-sentence
-reads as broken and adds noise to the council preamble.
-"""
-
-from __future__ import annotations
-
-import json
-import re
-from dataclasses import dataclass
-from pathlib import Path
-
-REPO_PURPOSE_MAX_CHARS = 400
-_HEADING_RE = re.compile(r"^\s*#")
-_BADGE_RE = re.compile(r"^\s*(\[!\[|!\[|<).*")
-_HTML_RE = re.compile(r"<[^>]+>")
-
-
-@dataclass
-class ProjectContext:
-    """Neutral project description for the council handoff preamble."""
-
-    name: str | None = None
-    stack: str | None = None
-    repo_purpose: str | None = None
-
-    def is_empty(self) -> bool:
-        return self.name is None and self.stack is None and self.repo_purpose is None
-
-
-def _read_json(path: Path) -> dict | None:
-    if not path.exists():
-        return None
-    try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-    except (json.JSONDecodeError, OSError):
-        return None
-    return data if isinstance(data, dict) else None
-
-
-def _name_from(composer: dict | None, package: dict | None, root: Path) -> str | None:
-    for src in (composer, package):
-        if src and isinstance(src.get("name"), str) and src["name"].strip():
-            return src["name"].strip()
-    # Fall back to the directory name; useful for repos without manifests.
-    try:
-        return root.resolve().name or None
-    except OSError:
-        return None
-
-
-def _stack_from(composer: dict | None, package: dict | None) -> str | None:
-    parts: list[str] = []
-    if composer:
-        php_v = (composer.get("require") or {}).get("php")
-        if isinstance(php_v, str):
-            parts.append(f"PHP {php_v}")
-        # Detect well-known frameworks without claiming the project IS one.
-        require = {**(composer.get("require") or {}), **(composer.get("require-dev") or {})}
-        for needle, label in (
-            ("laravel/framework", "Laravel"),
-            ("symfony/framework-bundle", "Symfony"),
-            ("laminas/laminas-mvc", "Laminas"),
-        ):
-            if needle in require:
-                parts.append(label)
-                break
-    if package:
-        engines = package.get("engines") or {}
-        if isinstance(engines, dict) and isinstance(engines.get("node"), str):
-            parts.append(f"Node {engines['node']}")
-        deps = {**(package.get("dependencies") or {}), **(package.get("devDependencies") or {})}
-        for needle, label in (
-            ("next", "Next.js"),
-            ("react", "React"),
-            ("vue", "Vue"),
-            ("@angular/core", "Angular"),
-        ):
-            if needle in deps:
-                parts.append(label)
-                break
-    if not parts:
-        return None
-    return " · ".join(parts)
-
-
-def _purpose_from_readme(path: Path) -> str | None:
-    if not path.exists():
-        return None
-    try:
-        text = path.read_text(encoding="utf-8")
-    except OSError:
-        return None
-    paragraph: list[str] = []
-    for raw in text.splitlines():
-        line = raw.rstrip()
-        stripped = line.strip()
-        if not stripped:
-            if paragraph:
-                break
-            continue
-        if _HEADING_RE.match(stripped) or _BADGE_RE.match(stripped):
-            if paragraph:
-                break
-            continue
-        paragraph.append(stripped)
-    if not paragraph:
-        return None
-    joined = " ".join(paragraph)
-    joined = _HTML_RE.sub("", joined).strip()
-    if not joined:
-        return None
-    if len(joined) > REPO_PURPOSE_MAX_CHARS:
-        joined = _truncate_at_sentence(joined, REPO_PURPOSE_MAX_CHARS)
-    return joined
-
-
-def _truncate_at_sentence(text: str, limit: int) -> str:
-    """Truncate at the last full sentence ≤ limit chars; append an ellipsis.
-
-    Total return length is always ≤ ``limit`` (ellipsis included).
-    """
-    budget = max(1, limit - 2)
-    head = text[:budget]
-    cut = max(head.rfind(". "), head.rfind("! "), head.rfind("? "))
-    if cut >= 0:
-        return head[: cut + 1].rstrip() + " …"
-    return head.rstrip() + " …"
-
-
-def detect_project_context(root: Path | None = None) -> ProjectContext:
-    """Return a `ProjectContext` for `root` (default: cwd).
-
-    Always returns — never raises. Missing manifest files / README → the
-    matching field is `None`, and `handoff_preamble()` will omit the line.
-    """
-    root = (root or Path.cwd()).resolve()
-    composer = _read_json(root / "composer.json")
-    package = _read_json(root / "package.json")
-    return ProjectContext(
-        name=_name_from(composer, package, root),
-        stack=_stack_from(composer, package),
-        repo_purpose=_purpose_from_readme(root / "README.md"),
-    )