@event4u/agent-config 6.0.0 → 7.0.0

package/dist/agent-src/templates/scripts/work_engine/input_builders.py

@@ -1,163 +0,0 @@
-"""File-based input builders and the load-or-build dispatch helper.
-
-Extracted from ``cli.py`` in P2.3 of
-``road-to-post-pr29-optimize.md``. Owns the CLI's "first run" path:
-when no state file exists, build a fresh :class:`WorkState` from
-``--ticket-file``, ``--prompt-file``, ``--diff-file`` or
-``--file-file``. Every builder is byte-identical in behaviour to the
-pre-split version — the resolvers it calls and the persona / routing
-post-processing did not move.
-"""
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-
-from .cli_args import _FMT_V0, _FMT_V1
-from .errors import _CLIError
-from .intent import populate_routing
-from .resolvers.diff import DiffResolverError, build_envelope as _build_diff_envelope
-from .resolvers.file import FileResolverError, build_envelope as _build_file_envelope
-from .resolvers.prompt import PromptResolverError, build_envelope as _build_prompt_envelope
-from .state import Input, WorkState
-from .state_io import _load, _maybe_raise_legacy_hint, _read_json
-
-
-def _load_or_build(
-    state_file: Path,
-    args: argparse.Namespace,
-) -> tuple[WorkState, str]:
-    """Return the WorkState to dispatch against plus its wire format.
-
-    Either loaded from ``state_file`` (format-preserving) or freshly
-    built from ``--ticket-file`` (R1), ``--prompt-file`` (R2),
-    ``--diff-file`` (R3) or ``--file-file`` (R3). Fresh ticket files
-    default to v0 wire format so that newly captured Goldens stay
-    byte-equal with the pre-Phase-4 baseline; the prompt / diff / file
-    paths emit v1 directly (v0 has no envelope concept for these
-    kinds). v1 round-trips for state files already on disk in v1 shape.
-    """
-    if state_file.exists():
-        return _load(state_file)
-    _maybe_raise_legacy_hint(state_file)
-    inputs = [
-        ("--ticket-file", args.ticket_file),
-        ("--prompt-file", args.prompt_file),
-        ("--diff-file", args.diff_file),
-        ("--file-file", args.file_file),
-    ]
-    supplied = [name for name, value in inputs if value is not None]
-    if len(supplied) > 1:
-        raise _CLIError(
-            f"{', '.join(supplied)} are mutually exclusive; pass exactly "
-            "one when building an initial state.",
-        )
-    if not supplied:
-        raise _CLIError(
-            f"No state file at {state_file} and no --ticket-file, "
-            "--prompt-file, --diff-file, or --file-file given; cannot "
-            "build an initial state.",
-        )
-    if args.prompt_file is not None:
-        return _build_from_prompt_file(args), _FMT_V1
-    if args.diff_file is not None:
-        return _build_from_diff_file(args), _FMT_V1
-    if args.file_file is not None:
-        return _build_from_file_file(args), _FMT_V1
-    ticket = _read_json(args.ticket_file)
-    if not isinstance(ticket, dict):
-        raise _CLIError(
-            f"--ticket-file must carry a JSON object; got {type(ticket).__name__}.",
-        )
-    work = WorkState(input=Input(kind="ticket", data=ticket))
-    if args.persona:
-        work.persona = args.persona
-    populate_routing(work)
-    return work, _FMT_V0
-
-
-def _build_from_prompt_file(args: argparse.Namespace) -> WorkState:
-    """Read ``--prompt-file`` as raw text and wrap it in a prompt envelope.
-
-    The file is read verbatim (UTF-8) and handed to the prompt resolver,
-    which validates non-emptiness and returns the canonical
-    ``Input(kind="prompt", data={raw, reconstructed_ac, assumptions})``
-    envelope. Persona is honoured the same way as the ticket path.
-    """
-    try:
-        raw = args.prompt_file.read_text(encoding="utf-8")
-    except OSError as exc:
-        raise _CLIError(f"Cannot read {args.prompt_file}: {exc}") from exc
-    try:
-        envelope = _build_prompt_envelope(raw)
-    except PromptResolverError as exc:
-        raise _CLIError(f"--prompt-file is not a valid prompt: {exc}") from exc
-    work = WorkState(input=envelope)
-    if args.persona:
-        work.persona = args.persona
-    populate_routing(work)
-    return work
-
-
-def _build_from_diff_file(args: argparse.Namespace) -> WorkState:
-    """Read ``--diff-file`` as raw text and wrap it in a diff envelope.
-
-    The file is read verbatim (UTF-8) and handed to the diff resolver,
-    which validates the unified-diff header heuristic and returns the
-    canonical
-    ``Input(kind="diff", data={raw, reconstructed_ac, assumptions})``
-    envelope. ``populate_routing`` then routes the envelope to the
-    UI-improve directive set without running the prose classifier — see
-    :mod:`work_engine.intent.classify` for the routing contract.
-    """
-    try:
-        raw = args.diff_file.read_text(encoding="utf-8")
-    except OSError as exc:
-        raise _CLIError(f"Cannot read {args.diff_file}: {exc}") from exc
-    try:
-        envelope = _build_diff_envelope(raw)
-    except DiffResolverError as exc:
-        raise _CLIError(f"--diff-file is not a valid diff: {exc}") from exc
-    work = WorkState(input=envelope)
-    if args.persona:
-        work.persona = args.persona
-    populate_routing(work)
-    return work
-
-
-def _build_from_file_file(args: argparse.Namespace) -> WorkState:
-    """Read ``--file-file`` as a single-line path and wrap it in a file envelope.
-
-    The file is read verbatim (UTF-8); the first non-empty line is taken
-    as the path reference and handed to the file resolver, which
-    validates path shape (non-empty, NUL-free, not a URL) and returns
-    the canonical
-    ``Input(kind="file", data={path, reconstructed_ac, assumptions})``
-    envelope. Trailing whitespace and additional lines are ignored —
-    the resolver treats the file's content as the path itself, not as
-    structured payload.
-    """
-    try:
-        raw = args.file_file.read_text(encoding="utf-8")
-    except OSError as exc:
-        raise _CLIError(f"Cannot read {args.file_file}: {exc}") from exc
-    path = raw.strip().splitlines()[0] if raw.strip() else ""
-    try:
-        envelope = _build_file_envelope(path)
-    except FileResolverError as exc:
-        raise _CLIError(
-            f"--file-file does not carry a valid path: {exc}",
-        ) from exc
-    work = WorkState(input=envelope)
-    if args.persona:
-        work.persona = args.persona
-    populate_routing(work)
-    return work
-
-
-__all__ = [
-    "_build_from_diff_file",
-    "_build_from_file_file",
-    "_build_from_prompt_file",
-    "_load_or_build",
-]

package/dist/agent-src/templates/scripts/work_engine/intent/__init__.py

@@ -1,47 +0,0 @@
-"""Intent classification for the universal engine (R3 Phase 1 Step 2).
-
-The :mod:`work_engine.intent.classify` module turns a raw user prompt
-(or a ticket's title + body) into one of the five labels the dispatcher
-routes against:
-
-- ``ui-build`` — new screen, page, or component.
-- ``ui-improve`` — change to an existing screen / component.
-- ``ui-trivial`` — single-file, single-concern micro-edit (color, copy,
-  one class, one prop). Hard preconditions are enforced again at apply
-  time; the classifier only labels the *intent*, not the safety floor.
-- ``mixed`` — both UI and backend signals; routes to the mixed track.
-- ``backend-coding`` — default; no UI signal.
-
-The classifier is intentionally heuristic-only — it consumes nothing
-beyond the prompt text and optional ticket title. Confidence-band
-gating, AC reconstruction, and assumption surfacing all stay in
-``directives/backend/refine.py`` (R2). This module only owns the
-*label*; the dispatcher owns the routing.
-"""
-from __future__ import annotations
-
-from . import classify
-from .classify import (
-    INTENT_BACKEND,
-    INTENT_MIXED,
-    INTENT_UI_BUILD,
-    INTENT_UI_IMPROVE,
-    INTENT_UI_TRIVIAL,
-    KNOWN_INTENTS,
-    classify_intent,
-    directive_set_for,
-    populate_routing,
-)
-
-__all__ = [
-    "INTENT_BACKEND",
-    "INTENT_MIXED",
-    "INTENT_UI_BUILD",
-    "INTENT_UI_IMPROVE",
-    "INTENT_UI_TRIVIAL",
-    "KNOWN_INTENTS",
-    "classify",
-    "classify_intent",
-    "directive_set_for",
-    "populate_routing",
-]

package/dist/agent-src/templates/scripts/work_engine/intent/classify.py

@@ -1,280 +0,0 @@
-"""Heuristic intent classifier — see :mod:`work_engine.intent` for context.
-
-The classifier walks a small priority ladder against the lower-cased
-prompt + optional ticket title. First match wins; ``backend-coding`` is
-the fall-through default so every prompt always lands on a known label.
-
-Priority order (deliberately fixed):
-
-1. **Trivial-UI** — UI signal AND a trivial-edit verb pattern (``change
-   color``, ``make … red``, ``rename label``, ``fix copy``) AND no
-   structural verb (``add``, ``build``, ``create``, ``introduce``).
-2. **Mixed** — UI signal AND a backend signal (``endpoint``, ``API``,
-   ``migration``, ``schema``, ``query``, ``job``, ``queue``).
-3. **UI-Improve** — UI signal AND an improve/redesign/refactor verb,
-   OR explicit "existing" surface markers.
-4. **UI-Build** — UI signal AND a build/create/add verb, OR new-screen
-   markers (``new page``, ``new screen``, ``new component``).
-5. **Backend-Coding** — default.
-
-The label is the dispatcher's *only* input for routing. Confidence
-band, ``ui_intent`` flag from the scorer, and AC reconstruction stay
-the resolution surface — the classifier does not look at them.
-"""
-from __future__ import annotations
-
-import re
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ..state import WorkState
-
-INTENT_UI_BUILD = "ui-build"
-INTENT_UI_IMPROVE = "ui-improve"
-INTENT_UI_TRIVIAL = "ui-trivial"
-INTENT_MIXED = "mixed"
-INTENT_BACKEND = "backend-coding"
-
-KNOWN_INTENTS: frozenset[str] = frozenset(
-    {
-        INTENT_UI_BUILD,
-        INTENT_UI_IMPROVE,
-        INTENT_UI_TRIVIAL,
-        INTENT_MIXED,
-        INTENT_BACKEND,
-    },
-)
-"""All labels the classifier can return.
-
-Locked here so the dispatcher's mapping table and the test suite share
-one source of truth."""
-
-_UI_NOUNS: frozenset[str] = frozenset(
-    {
-        "ui", "screen", "page", "view", "form", "modal", "dialog",
-        "button", "card", "tile",
-        "header", "footer", "nav", "navigation", "sidebar", "menu",
-        "dropdown", "tab", "panel", "layout", "component", "icon",
-        "tooltip", "toast", "banner", "badge", "avatar", "label",
-        "checkbox", "radio", "toggle", "switch", "stepper", "wizard",
-    },
-)
-"""Strong UI nouns — exclusive UI meaning.
-
-Deliberately omits ``table``, ``list``, ``input``, and ``field``:
-``table``/``list`` collide with database tables and Python/PHP lists;
-``input``/``field`` collide with function inputs, command inputs, and
-JSON/DB fields. Genuine UI prompts that mean form inputs always come
-with a strong-UI noun nearby (``form``, ``page``, ``component``)."""
-
-_UI_STYLE: frozenset[str] = frozenset(
-    {
-        "color", "colour", "css", "tailwind", "padding", "margin",
-        "spacing", "font", "typography", "responsive", "mobile",
-        "dark mode", "light mode", "theme", "shadow", "border",
-        "rounded", "radius",
-    },
-)
-
-_BACKEND_SIGNALS: frozenset[str] = frozenset(
-    {
-        "endpoint", "api", "route", "controller", "service",
-        "migration", "schema", "table", "column", "index", "query",
-        "queue", "job", "worker", "webhook", "policy", "gate",
-        "command", "cron", "broadcast", "event", "listener",
-    },
-)
-
-_TRIVIAL_VERBS: frozenset[str] = frozenset(
-    {
-        "rename", "relabel", "tweak", "adjust", "swap", "change",
-    },
-)
-
-_IMPROVE_VERBS: frozenset[str] = frozenset(
-    {
-        "improve", "polish", "redesign", "rework", "refine",
-        "refactor", "tighten", "clean", "fix", "update", "tune",
-    },
-)
-
-_BUILD_VERBS: frozenset[str] = frozenset(
-    {
-        "add", "build", "create", "introduce", "implement", "ship",
-        "draft", "scaffold", "wire",
-    },
-)
-
-_NEW_SURFACE: re.Pattern[str] = re.compile(
-    r"\b(new|fresh|blank)\s+(page|screen|view|component|form|modal|tile|dashboard)\b",
-)
-
-_EXISTING_SURFACE: re.Pattern[str] = re.compile(
-    r"\b(existing|current|the)\s+(page|screen|view|component|form|modal)\b",
-)
-
-_TRIVIAL_PATTERN: re.Pattern[str] = re.compile(
-    r"\b(make|change|update|set|swap)\b[^.]{0,40}\b("
-    r"red|blue|green|yellow|black|white|primary|secondary"
-    r"|color|colour|copy|text|label|wording|class|prop)\b",
-)
-
-
-def classify_intent(raw: str, *, title: str | None = None) -> str:
-    """Return one of :data:`KNOWN_INTENTS` for the supplied text.
-
-    Parameters
-    ----------
-    raw:
-        The user prompt or ticket body. Whitespace is normalised
-        internally; ``""`` and ``None`` resolve to ``backend-coding``.
-    title:
-        Optional ticket title. Concatenated with ``raw`` before
-        scanning so single-line ticket headlines (`"Add CSV export"`)
-        produce the same label whether they arrive in the body or the
-        title slot.
-    """
-    text = " ".join(filter(None, (title, raw))).strip().lower()
-    if not text:
-        return INTENT_BACKEND
-
-    has_ui = _has_ui_signal(text)
-    has_backend = _has_backend_signal(text)
-
-    if has_ui and _is_trivial(text):
-        return INTENT_UI_TRIVIAL
-    if has_ui and has_backend:
-        return INTENT_MIXED
-    if has_ui and _is_improve(text):
-        return INTENT_UI_IMPROVE
-    if has_ui and _is_build(text):
-        return INTENT_UI_BUILD
-    if has_ui:
-        # UI signal but no clear verb — default to ui-improve so the
-        # full audit gate engages. ui-build would skip the existing-
-        # surface check, which is the wrong default when the prompt
-        # is ambiguous.
-        return INTENT_UI_IMPROVE
-    return INTENT_BACKEND
-
-
-def directive_set_for(intent: str) -> str:
-    """Map an intent label to a directive-set name.
-
-    Centralised here so the dispatcher and the refine step share one
-    routing table; a future intent (``infra``, ``security-review``)
-    only needs a single edit. Unknown labels raise ``ValueError`` —
-    silently falling back to ``backend`` would mask classifier bugs.
-    """
-    if intent not in KNOWN_INTENTS:
-        raise ValueError(
-            f"unknown intent {intent!r}; "
-            f"expected one of {sorted(KNOWN_INTENTS)}",
-        )
-    if intent in (INTENT_UI_BUILD, INTENT_UI_IMPROVE):
-        return "ui"
-    if intent == INTENT_UI_TRIVIAL:
-        return "ui-trivial"
-    if intent == INTENT_MIXED:
-        return "mixed"
-    return "backend"
-
-
-# --- helpers ----------------------------------------------------------
-
-def _has_ui_signal(text: str) -> bool:
-    if any(re.search(rf"\b{re.escape(w)}\b", text) for w in _UI_NOUNS):
-        return True
-    return any(s in text for s in _UI_STYLE)
-
-
-def _has_backend_signal(text: str) -> bool:
-    return any(re.search(rf"\b{re.escape(w)}\b", text) for w in _BACKEND_SIGNALS)
-
-
-def _is_trivial(text: str) -> bool:
-    if _TRIVIAL_PATTERN.search(text):
-        return True
-    return any(re.search(rf"\b{re.escape(v)}\b", text) for v in _TRIVIAL_VERBS) and len(
-        text.split()
-    ) <= 14
-
-
-def _is_improve(text: str) -> bool:
-    if _EXISTING_SURFACE.search(text):
-        return True
-    return any(re.search(rf"\b{re.escape(v)}\b", text) for v in _IMPROVE_VERBS)
-
-
-def _is_build(text: str) -> bool:
-    if _NEW_SURFACE.search(text):
-        return True
-    return any(re.search(rf"\b{re.escape(v)}\b", text) for v in _BUILD_VERBS)
-
-
-def populate_routing(state: "WorkState") -> None:
-    """Classify ``state.input`` and write ``intent`` + ``directive_set`` in place.
-
-    Idempotent and override-safe: if ``state.intent`` is already a
-    UI-track or mixed label (``ui-build``, ``ui-improve``, ``ui-trivial``,
-    ``mixed``), the routing is left untouched. Only freshly-built states
-    carrying the construction default ``backend-coding`` are reclassified.
-    Loaded state files round-trip without losing a previously-recorded
-    intent — including a manual user override in the JSON.
-
-    The text fed to the classifier depends on the input envelope:
-
-    - ``prompt`` → ``state.input.data["raw"]``
-    - ``ticket`` → ``state.input.data["title"]`` + first non-empty
-      acceptance criterion, falling back to ``description`` when AC is
-      missing. Title is passed separately so single-line ticket
-      headlines (``"Add CSV export"``) classify identically whether
-      they arrive in the body or the title slot.
-    - ``diff`` / ``file`` → routed directly to ``ui-improve`` without
-      running the heuristic. Both envelopes are R3 Phase 1 inputs that
-      describe an existing UI surface ("improve this screen"); the
-      classifier's prose-oriented signals do not apply, and the audit +
-      design directives downstream are the right place to read the
-      diff/file contents.
-    """
-    if state.intent != INTENT_BACKEND:
-        return
-
-    if state.input.kind in {"diff", "file"}:
-        state.intent = INTENT_UI_IMPROVE
-        state.directive_set = directive_set_for(INTENT_UI_IMPROVE)
-        return
-
-    text, title = _extract_text(state)
-    intent = classify_intent(text, title=title)
-    state.intent = intent
-    state.directive_set = directive_set_for(intent)
-
-
-def _extract_text(state: "WorkState") -> tuple[str, str | None]:
-    data = state.input.data or {}
-    if state.input.kind == "prompt":
-        return str(data.get("raw") or ""), None
-    title = data.get("title")
-    title_str = str(title) if isinstance(title, str) and title.strip() else None
-    body_parts: list[str] = []
-    ac = data.get("acceptance_criteria")
-    if isinstance(ac, list):
-        body_parts.extend(str(item) for item in ac if isinstance(item, str))
-    description = data.get("description")
-    if isinstance(description, str) and description.strip():
-        body_parts.append(description)
-    return " ".join(body_parts), title_str
-
-
-__all__ = [
-    "INTENT_BACKEND",
-    "INTENT_MIXED",
-    "INTENT_UI_BUILD",
-    "INTENT_UI_IMPROVE",
-    "INTENT_UI_TRIVIAL",
-    "KNOWN_INTENTS",
-    "classify_intent",
-    "directive_set_for",
-    "populate_routing",
-]

package/dist/agent-src/templates/scripts/work_engine/migration/__init__.py

@@ -1,8 +0,0 @@
-"""State-file migrations for the universal engine.
-
-Each module in this package owns one direction of one schema bump. The
-historical bumps must remain runnable so a freshly-cloned repository
-that finds a v0 state file from a long-running branch can catch up
-without manual intervention.
-"""
-from __future__ import annotations