@litfamily/lithermes 1.0.0

package/assets/lithermes-plugin/core_recap_state.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+try:
+    from .core_runtime import _clamp_task, lithermes_dir
+except (ImportError, ModuleNotFoundError):
+    from core_runtime import _clamp_task, lithermes_dir
+
+# ---------------------------------------------------------------------------
+# /lit-recap — read-only recap of durable LitHermes state. Mirrors the
+# korean-prose-cleanup contract: {display, agent_message} only, no run state,
+# no goal binding, and every ledger/goal byte enters the message escaped.
+# ---------------------------------------------------------------------------
+
+RECAP_TITLE_KO = "# 작업 리캡 (lit-recap)"
+RECAP_TITLE_EN = "# Work Recap (lit-recap)"
+RECAP_HEADERS_KO = (
+    "## ✅ 완료된 작업",
+    "## 🔄 진행 중",
+    "## ⛔ 블로커",
+    "## 📁 증거 경로",
+    "## ➡️ 다음 단계",
+)
+RECAP_HEADERS_EN = (
+    "## ✅ Completed",
+    "## 🔄 In Progress",
+    "## ⛔ Blockers",
+    "## 📁 Evidence Paths",
+    "## ➡️ Next Steps",
+)
+RECAP_BRIEF_HEADER_KO = "## ⚡ 요약"
+RECAP_BRIEF_HEADER_EN = "## ⚡ Summary"
+RECAP_BRIEF_WORDS = frozenset({"짧게"})
+RECAP_ENGLISH_WORDS = frozenset({"english", "영어"})
+_RECAP_OPTION_TOKENS = frozenset({"--brief", "--en", "--english"}) | RECAP_BRIEF_WORDS | RECAP_ENGLISH_WORDS
+_RECAP_UNSAFE_VALUE_CHARS = frozenset("\"'\\")
+_RECAP_MAX_ITEMS = 8
+_RECAP_MAX_LEDGER_LINES = 200
+# Standalone-only recognizer: `recap`/`litrecap`/`lit-recap`/`리캡` (optionally after a bare
+# `lit`) at message start, followed by nothing but known recap option tokens.
+_LIT_RECAP_LEAD_RE = re.compile(
+    r"^\s*(?:lit\s+)?(?:lit-recap|litrecap|recap|리캡)(?![\w/-])(?P<rest>.*)$",
+    re.IGNORECASE | re.DOTALL,
+)
+_RECAP_TECH_KINDS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("[test]", ("test_", ".test.", "/test/", "scenario")),
+    ("[Python]", (".py", "python", "pytest", "unittest")),
+    ("[npm]", ("package.json", "npm", ".js", ".ts", "node")),
+    ("[docs]", (".md", "readme", "docs", "changelog")),
+)
+
+
+@dataclass(frozen=True)
+class RecapDigest:
+    objective: str
+    completed: tuple[str, ...]
+    in_progress: tuple[str, ...]
+    blockers: tuple[str, ...]
+    evidence: tuple[str, ...]
+    next_steps: tuple[str, ...]
+
+
+def _recap_tech_kind(text: str) -> str:
+    """Deterministically tag a digest item from its refs/paths."""
+    lowered = str(text or "").lower()
+    for tag, needles in _RECAP_TECH_KINDS:
+        if any(needle in lowered for needle in needles):
+            return tag
+    return "[work]"
+
+
+def _recap_item(text: str) -> str:
+    """One digest line: redacted, whitespace-flattened, length-bounded."""
+    return _clamp_task(re.sub(r"\s+", " ", str(text or "")))
+
+
+def _recap_run_completions(ledger: Path) -> list[str]:
+    """criterion_complete events from a run ledger (bounded pure read)."""
+    try:
+        lines = ledger.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        return []
+    out: list[str] = []
+    for line in lines[-_RECAP_MAX_LEDGER_LINES:]:
+        try:
+            event = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(event, dict) and event.get("event") == "criterion_complete":
+            tag = _recap_tech_kind(" ".join(str(v) for v in event.values()))
+            out.append(_recap_item(f"{event.get('criterion_id') or '?'} {tag} criterion_complete"))
+    return out
+
+
+def read_recap_digest(workspace: Path) -> RecapDigest:
+    """Pure read of the durable litgoal state + the latest run. Never writes:
+    litgoal reads go through store.load_or_create (in-memory default when the
+    file is absent) and run discovery is glob+read only."""
+    try:
+        from .litgoal import runtime as litgoal_runtime
+        from .litgoal import store as litgoal_store
+    except (ImportError, ModuleNotFoundError):  # standalone test import via PYTHONPATH
+        from litgoal import runtime as litgoal_runtime  # type: ignore
+        from litgoal import store as litgoal_store  # type: ignore
+
+    objective = ""
+    completed: list[str] = []
+    in_progress: list[str] = []
+    blockers: list[str] = []
+    evidence: list[str] = []
+    next_steps: list[str] = []
+
+    try:
+        goal = litgoal_runtime.get_active(workspace)
+    except (ValueError, OSError):  # malformed/unreadable durable state stays inert
+        goal = None
+    if goal is not None:
+        objective = _recap_item(goal.objective)
+        for crit in goal.criteria:
+            tag = _recap_tech_kind(" ".join([crit.test_ref, *(e.ref for e in crit.evidence)]))
+            item = _recap_item(f"{crit.id} {tag} {crit.scenario}")
+            match crit.status:
+                case "pass":
+                    completed.append(item)
+                case "in_progress":
+                    in_progress.append(item)
+                case "blocked":
+                    blockers.append(item)
+                case _:  # pending / fail / unknown-from-disk stay open work
+                    next_steps.append(item)
+            evidence.extend(_recap_item(e.ref) for e in crit.evidence if e.ref)
+        for blocker in goal.review_blockers:
+            if not blocker.resolved:
+                blockers.append(_recap_item(f"{blocker.id} {blocker.detail}"))
+        evidence.append(str(litgoal_store.evidence_dir(workspace)))
+        try:
+            gate = litgoal_runtime.quality_gate(workspace)
+        except (ValueError, OSError):
+            gate = {"reasons": []}
+        next_steps.extend(_recap_item(reason) for reason in gate.get("reasons", []))
+
+    runs_root = lithermes_dir(workspace) / "runs"
+    state_files = (
+        sorted(runs_root.glob("*/state.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+        if runs_root.is_dir()
+        else []
+    )
+    if state_files:
+        latest = state_files[0]
+        try:
+            state = json.loads(latest.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            state = None
+        if isinstance(state, dict):
+            rid = state.get("run_id") or latest.parent.name
+            in_progress.append(_recap_item(f"{rid} [{state.get('command') or '?'}] {state.get('task') or ''}"))
+            if state.get("evidence_dir"):
+                evidence.append(_recap_item(str(state.get("evidence_dir"))))
+            completed.extend(_recap_run_completions(latest.parent / "ledger.jsonl"))
+
+    def cap(items: list[str]) -> tuple[str, ...]:
+        return tuple(items[:_RECAP_MAX_ITEMS])
+
+    return RecapDigest(
+        objective=objective,
+        completed=cap(completed),
+        in_progress=cap(in_progress),
+        blockers=cap(blockers),
+        evidence=cap(evidence),
+        next_steps=cap(next_steps),
+    )

package/assets/lithermes-plugin/core_review.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+try:
+    from .core_contract import (
+        _skill_body_block,
+        conditional_uiux_skill_blocks,
+        contract_route_block,
+        reader_facing_contract_block,
+    )
+    from .core_reader_args import parse_reader_facing_command_args
+    from .core_runtime import parse_args, record_delegate_batch_intent, workspace_from_option
+except (ImportError, ModuleNotFoundError):
+    from core_contract import (
+        _skill_body_block,
+        conditional_uiux_skill_blocks,
+        contract_route_block,
+        reader_facing_contract_block,
+    )
+    from core_reader_args import parse_reader_facing_command_args
+    from core_runtime import parse_args, record_delegate_batch_intent, workspace_from_option
+
+def _run_git(workspace: Path, args: list[str]) -> str:
+    import subprocess
+
+    try:
+        out = subprocess.run(
+            ["git", *args],
+            cwd=str(workspace),
+            capture_output=True,
+            text=True,
+            timeout=20,
+        )
+        return out.stdout if out.returncode == 0 else ""
+    except Exception:
+        return ""
+
+
+def _run_git_bytes(workspace: Path, args: list[str]) -> bytes:
+    import subprocess
+
+    try:
+        out = subprocess.run(
+            ["git", *args],
+            cwd=str(workspace),
+            capture_output=True,
+            timeout=20,
+        )
+        return out.stdout if out.returncode == 0 else b""
+    except Exception:
+        return b""
+
+
+def _decode_git_path(value: bytes) -> str:
+    return value.decode("utf-8", errors="surrogateescape")
+
+
+def _changed_paths(workspace: Path, base: str) -> list[str]:
+    paths = {
+        _decode_git_path(value)
+        for value in _run_git_bytes(workspace, ["diff", "--name-only", "-z", base]).split(b"\0")
+        if value
+    }
+    records = _run_git_bytes(
+        workspace,
+        ["status", "--porcelain=v1", "-z", "--untracked-files=all"],
+    ).split(b"\0")
+    index = 0
+    while index < len(records):
+        record = records[index]
+        index += 1
+        if not record:
+            continue
+        if len(record) < 4 or record[2:3] != b" ":
+            continue
+        status = record[:2]
+        paths.add(_decode_git_path(record[3:]))
+        if b"R" in status or b"C" in status:
+            index += 1
+    return sorted(paths)
+
+
+def detect_run_command(workspace: Path) -> str:
+    pkg = workspace / "package.json"
+    if pkg.exists():
+        try:
+            data = json.loads(pkg.read_text(encoding="utf-8"))
+            scripts = data.get("scripts", {}) if isinstance(data, dict) else {}
+            for key in ("dev", "start", "serve"):
+                if key in scripts:
+                    return f"npm run {key}"
+        except Exception:
+            pass
+    if (workspace / "Makefile").exists():
+        return "make (see Makefile targets)"
+    if (workspace / "docker-compose.yml").exists() or (workspace / "compose.yaml").exists():
+        return "docker compose up"
+    return "(detect manually — no dev/start script found)"
+
+
+REVIEW_LANES = [
+    ("goal", "Goal & constraint verification — does the diff achieve the stated goal within every constraint; flag missed requirements, over-engineering, edge cases. Verdict PASS/FAIL + confidence."),
+    ("qa", "QA by execution — brainstorm 15+ scenarios (happy/boundary/error/regression), then actually run the app/surface and capture evidence; tests alone are insufficient. Verdict PASS/FAIL with per-scenario results."),
+    ("code-quality", "Code quality — staff-engineer review across correctness, patterns, naming, error handling, types, perf, tests, API design. Severity CRITICAL/MAJOR/MINOR/NITPICK. Verdict PASS/FAIL."),
+    ("security", "Security/safety (supplementary) — input validation, authz, secrets, data exposure, deps/CVEs, path/file ops, destructive actions. Severity CRITICAL/HIGH/MEDIUM/LOW. Verdict PASS/FAIL."),
+    ("context", "Context/docs/package readiness — git history, issues/PRs, docs, changelog/release checklist, package dry-run/payload guard, cleanup receipts, TODO/warnings the diff may have missed. Verdict PASS/FAIL + discovered context."),
+]
+
+
+def command_review_work(raw_args: str) -> dict[str, str]:
+    reader_args = parse_reader_facing_command_args(raw_args)
+    args = parse_args(reader_args.command_args)
+    workspace = workspace_from_option(args.options.get("worktree"))
+    base = str(args.options.get("base") or "HEAD~1")
+    changed_paths = _changed_paths(workspace, base)
+    diff = _run_git(workspace, ["diff", base])
+    if len(diff) > 60000:
+        diff = diff[:60000] + "\n... [diff truncated at 60k chars — lanes should read full files as needed]"
+    run_cmd = detect_run_command(workspace)
+    files_block = (
+        "\n".join(f"- {json.dumps(file, ensure_ascii=False)}" for file in changed_paths)
+        or "(no changed files detected vs " + base + ")"
+    )
+    batch_event = record_delegate_batch_intent(
+        workspace=workspace,
+        mode="review-work",
+        lanes=[key for key, _ in REVIEW_LANES],
+        context={
+            "base": base,
+            "changed_file_count": len(changed_paths),
+            "run_command": run_cmd,
+        },
+    )
+
+    lane_lines = []
+    for key, brief in REVIEW_LANES:
+        lane_lines.append(f"- lane[{key}]: {brief}")
+    conditional_uiux = conditional_uiux_skill_blocks(
+        "\n".join(f"{file}/" for file in changed_paths) + "\n" + diff
+    )
+    child_return_contract = reader_facing_contract_block(
+        "audit",
+        authority="explicit_parent_to_child_return_mode",
+        boundary="subagent_to_parent_return",
+    )
+    parent_synthesis_contract = reader_facing_contract_block(
+        reader_args.requested_mode,
+        authority=reader_args.authority,
+        boundary="parent_synthesis"
+    )
+
+    agent_lines = [
+        "Run the LitHermes 5-lane review orchestrator on the current changes.",
+        "",
+        "<lithermes-review-work>",
+        contract_route_block("review-work", surface="slash-command"),
+        f"workspace: {workspace}",
+        f"base: {base}",
+        f"run command (for QA lane): {run_cmd}",
+        f"delegate batch evidence: {batch_event.get('artifact_dir', '')}",
+        "",
+        "Changed files:",
+        files_block,
+        "",
+        "Dispatch ALL FIVE lanes IN ONE delegate_task call — pass a `tasks` array of 5 entries,",
+        "each {goal: <lane brief>, context: <diff + changed files>}; top-level dispatch returns",
+        "immediately; per-child re-entry receipts then arrive as separate messages:",
+        *lane_lines,
+        "",
+        "Each lane returns: verdict (PASS|FAIL), confidence, and findings with file:line.",
+        "Do not synthesize in the dispatching turn. The parent tracks and merges each receipt; there is no combined wait.",
+        "Decide batch completion only after all five lanes are returned, failed, timed out, or unavailable; then dedupe findings. Gate is ALL-OR-NOTHING:",
+        "ANY lane FAIL => REVIEW FAILED (list blocking issues, prioritised by severity);",
+        "all five PASS => REVIEW PASSED (non-blocking suggestions only).",
+        "Load the lithermes:review-work skill for the full lane prompts and output contract.",
+        _skill_body_block("review-work"),
+        conditional_uiux,
+        "",
+        "Diff under review:",
+        "```diff",
+        diff.strip() or "(empty diff)",
+        "```",
+        "The audit child-return packet stays detailed for review; it cannot elevate the parent response:",
+        child_return_contract,
+        "Project the completed review through the parent synthesis contract:",
+        parent_synthesis_contract,
+        "</lithermes-review-work>",
+    ]
+    return {
+        "display": (
+            f"LitHermes review-work: 5 lanes over {base} "
+            f"({len(changed_paths)} changed files). "
+            "Dispatching parallel review now."
+        ),
+        "agent_message": "\n".join(agent_lines),
+    }