omnish 1.6.6 → 2.0.0

package/dist/omnish-cursor/hooks/omnish-notify.py

@@ -0,0 +1,563 @@
+#!/usr/bin/env python3
+"""Cursor stop hook: send curated Omnish briefs when agent work is worth notifying."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+CONFIG_PATH = Path.home() / ".cursor" / "omnish-notify.json"
+LOG_PATH = Path.home() / ".cursor" / "hooks" / "omnish-notify.log"
+STATE_PATH = Path.home() / ".cursor" / "hooks" / "omnish-notify-state.json"
+CHATS_ROOT = Path.home() / ".cursor" / "chats"
+
+# Only edits/deliverables count as substantive — Shell/Grep/Read alone should not ping.
+WRITE_TOOLS = {
+    "Write",
+    "StrReplace",
+    "Delete",
+    "EditNotebook",
+    "ApplyPatch",
+    "GenerateImage",
+}
+
+ACTION_TOOLS = WRITE_TOOLS | {
+    "Shell",
+    "Task",
+}
+
+SENTENCE_END = re.compile(r"(?<=[.!?])\s+")
+
+
+def log(message: str) -> None:
+    try:
+        LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
+        with LOG_PATH.open("a", encoding="utf-8") as handle:
+            handle.write(message.rstrip() + "\n")
+    except OSError:
+        pass
+
+
+def load_config() -> dict[str, Any]:
+    defaults: dict[str, Any] = {
+        "enabled": True,
+        "peer": os.environ.get("OMNISH_CURSOR_NOTIFY_PEER", "*"),
+        "min_assistant_chars": 120,
+        "notify_on_error": True,
+        "skip_aborted": True,
+        "include_full_chat_id": True,
+        "summary_max_chars": 300,
+        "followup_max_chars": 1000,
+        "max_followup_messages": 0,
+        "send_followups": False,
+        "dedupe_minutes": 45,
+    }
+    if CONFIG_PATH.exists():
+        try:
+            defaults.update(json.loads(CONFIG_PATH.read_text(encoding="utf-8")))
+        except (OSError, json.JSONDecodeError) as exc:
+            log(f"config read failed: {exc}")
+    return defaults
+
+
+def strip_user_query(text: str) -> str:
+    cleaned = re.sub(r"</?user_query>", "", text, flags=re.IGNORECASE)
+    lines = [re.sub(r"\s+", " ", line).strip() for line in cleaned.splitlines()]
+    return "\n".join(line for line in lines if line).strip()
+
+
+def normalize_notify_text(text: str) -> str:
+    text = re.sub(r"\[REDACTED\]", "", text)
+    lines = [re.sub(r"[ \t]+", " ", line).strip() for line in text.splitlines()]
+    compact = "\n".join(line for line in lines if line).strip()
+    return re.sub(r"\n{3,}", "\n\n", compact)
+
+
+def truncate_at_sentence(text: str, max_chars: int) -> tuple[str, bool]:
+    compact = normalize_notify_text(text)
+    if len(compact) <= max_chars:
+        return compact, False
+
+    window = compact[: max_chars + 1]
+    last_break = -1
+    for match in SENTENCE_END.finditer(window):
+        if match.start() <= max_chars:
+            last_break = match.start()
+
+    if last_break > max_chars // 2:
+        return compact[:last_break].rstrip(), True
+
+    trimmed = compact[:max_chars].rstrip()
+    if " " in trimmed:
+        trimmed = trimmed.rsplit(" ", 1)[0].rstrip()
+    return trimmed + "…", True
+
+
+def extract_summary(text: str, max_chars: int) -> str:
+    compact = normalize_notify_text(text)
+    if not compact:
+        return ""
+
+    sentences: list[str] = []
+    for part in SENTENCE_END.split(compact):
+        piece = part.strip()
+        if not piece:
+            continue
+        if not piece.endswith((".", "!", "?")):
+            piece += "."
+        sentences.append(piece)
+        joined = " ".join(sentences)
+        if len(joined) > max_chars:
+            sentences.pop()
+            break
+
+    if sentences:
+        summary = " ".join(sentences).strip()
+        if len(summary) <= max_chars:
+            return summary
+
+    return truncate_at_sentence(compact, max_chars)[0]
+
+
+def chunk_text(text: str, max_chars: int) -> list[str]:
+    compact = normalize_notify_text(text)
+    if not compact:
+        return []
+    if len(compact) <= max_chars:
+        return [compact]
+
+    chunks: list[str] = []
+    remaining = compact
+    while remaining:
+        if len(remaining) <= max_chars:
+            chunks.append(remaining)
+            break
+        piece, truncated = truncate_at_sentence(remaining, max_chars)
+        if not piece:
+            chunks.append(remaining[:max_chars].rstrip() + "…")
+            break
+        chunks.append(piece)
+        if not truncated:
+            break
+        core = piece[:-1].rstrip() if piece.endswith("…") else piece
+        idx = remaining.find(core)
+        if idx == -1:
+            remaining = remaining[max_chars:].lstrip()
+        else:
+            remaining = remaining[idx + len(core) :].lstrip()
+    return chunks
+
+
+def flatten_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content.strip()
+    if isinstance(content, list):
+        parts: list[str] = []
+        for item in content:
+            if isinstance(item, dict):
+                if item.get("type") == "text" and isinstance(item.get("text"), str):
+                    parts.append(item["text"])
+                elif isinstance(item.get("text"), str):
+                    parts.append(item["text"])
+            elif isinstance(item, str):
+                parts.append(item)
+        return "\n".join(part.strip() for part in parts if part.strip()).strip()
+    return ""
+
+
+def parse_transcript(path: str | None) -> dict[str, Any]:
+    result: dict[str, Any] = {
+        "user_query": "",
+        "assistant_summary": "",
+        "tool_count": 0,
+        "action_tool_count": 0,
+        "write_tool_count": 0,
+        "assistant_chars": 0,
+        "turns": 0,
+    }
+    if not path:
+        return result
+
+    transcript_path = Path(path)
+    if not transcript_path.is_file():
+        return result
+
+    try:
+        lines = transcript_path.read_text(encoding="utf-8", errors="replace").splitlines()
+    except OSError as exc:
+        log(f"transcript read failed: {exc}")
+        return result
+
+    last_user = ""
+    last_assistant = ""
+    last_assistant_nonempty = ""
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            entry = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        role = entry.get("role")
+        message = entry.get("message") or {}
+        content = message.get("content")
+
+        if role == "user":
+            text = flatten_text(content)
+            query = strip_user_query(text)
+            if query:
+                last_user = query
+                result["turns"] += 1
+        elif role == "assistant":
+            if isinstance(content, list):
+                for item in content:
+                    if not isinstance(item, dict):
+                        continue
+                    if item.get("type") == "tool_use":
+                        result["tool_count"] += 1
+                        tool_name = item.get("name") or item.get("tool_name")
+                        if tool_name in ACTION_TOOLS:
+                            result["action_tool_count"] += 1
+                        if tool_name in WRITE_TOOLS:
+                            result["write_tool_count"] += 1
+                    elif item.get("type") == "text":
+                        text = item.get("text", "")
+                        if text.strip():
+                            last_assistant = text.strip()
+                            cleaned = re.sub(r"\[REDACTED\]", "", text).strip()
+                            if cleaned:
+                                last_assistant_nonempty = cleaned
+            elif isinstance(content, str) and content.strip():
+                last_assistant = content.strip()
+                cleaned = re.sub(r"\[REDACTED\]", "", content).strip()
+                if cleaned:
+                    last_assistant_nonempty = cleaned
+
+    result["user_query"] = last_user
+    result["assistant_summary"] = last_assistant_nonempty or last_assistant
+    result["assistant_chars"] = len(last_assistant)
+    return result
+
+
+def find_chat_title(conversation_id: str) -> str:
+    if not conversation_id or not CHATS_ROOT.is_dir():
+        return ""
+
+    try:
+        for workspace_dir in CHATS_ROOT.iterdir():
+            meta_path = workspace_dir / conversation_id / "meta.json"
+            if not meta_path.is_file():
+                continue
+            meta = json.loads(meta_path.read_text(encoding="utf-8"))
+            title = str(meta.get("title") or "").strip()
+            if title:
+                return title
+    except (OSError, json.JSONDecodeError):
+        pass
+    return ""
+
+
+def should_notify(payload: dict[str, Any], transcript: dict[str, Any], cfg: dict[str, Any]) -> bool:
+    status = payload.get("status", "completed")
+    if cfg.get("skip_aborted") and status == "aborted":
+        return False
+
+    if status == "error" and cfg.get("notify_on_error"):
+        return True
+
+    # Substantive = repo/file changes. Read-only Shell/Grep turns stay silent.
+    if transcript.get("write_tool_count", 0) > 0:
+        return True
+
+    return False
+
+
+def notify_fingerprint(conversation_id: str, user_query: str) -> str:
+    normalized = re.sub(r"\s+", " ", (user_query or "").lower().strip())[:500]
+    raw = f"{conversation_id}|{normalized}".encode("utf-8")
+    return hashlib.sha256(raw).hexdigest()[:20]
+
+
+def load_notify_state() -> dict[str, Any]:
+    if not STATE_PATH.is_file():
+        return {"entries": {}}
+    try:
+        data = json.loads(STATE_PATH.read_text(encoding="utf-8"))
+        if isinstance(data, dict) and isinstance(data.get("entries"), dict):
+            return data
+    except (OSError, json.JSONDecodeError):
+        pass
+    return {"entries": {}}
+
+
+def save_notify_state(state: dict[str, Any]) -> None:
+    try:
+        STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
+        entries = state.get("entries") or {}
+        if len(entries) > 200:
+            sorted_keys = sorted(
+                entries.keys(),
+                key=lambda k: float((entries[k] or {}).get("ts") or 0),
+            )
+            for key in sorted_keys[: len(entries) - 200]:
+                entries.pop(key, None)
+        STATE_PATH.write_text(json.dumps(state, indent=2) + "\n", encoding="utf-8")
+    except OSError as exc:
+        log(f"state write failed: {exc}")
+
+
+def is_duplicate_notify(
+    conversation_id: str,
+    user_query: str,
+    cfg: dict[str, Any],
+) -> bool:
+    cooldown_min = int(cfg.get("dedupe_minutes") or 45)
+    if cooldown_min <= 0 or not conversation_id:
+        return False
+
+    fp = notify_fingerprint(conversation_id, user_query)
+    state = load_notify_state()
+    entries = state.setdefault("entries", {})
+    prev = entries.get(fp)
+    now = time.time()
+    if prev and now - float(prev.get("ts") or 0) < cooldown_min * 60:
+        return True
+
+    entries[fp] = {"ts": now}
+    save_notify_state(state)
+    return False
+
+
+def build_title(payload: dict[str, Any], cfg: dict[str, Any]) -> str:
+    conversation_id = str(payload.get("conversation_id") or "").strip()
+    status = str(payload.get("status") or "completed")
+    chat_title = find_chat_title(conversation_id)
+
+    if status == "error":
+        base = "Cursor Error"
+    elif status == "aborted":
+        base = "Cursor Aborted"
+    else:
+        base = "Cursor Done"
+
+    if chat_title:
+        short_title, _ = truncate_at_sentence(chat_title, 48)
+        return f"{base}: {short_title}"
+    return base
+
+
+def build_main_brief(
+    payload: dict[str, Any],
+    transcript: dict[str, Any],
+    cfg: dict[str, Any],
+) -> str:
+    conversation_id = str(payload.get("conversation_id") or "").strip()
+    short_id = conversation_id[:8] if conversation_id else "unknown"
+    status = str(payload.get("status") or "completed")
+    workspace_roots = payload.get("workspace_roots") or []
+    workspace = workspace_roots[0] if workspace_roots else ""
+
+    summary_limit = int(cfg.get("summary_max_chars") or 300)
+    user_query = normalize_notify_text(transcript.get("user_query") or "")
+    assistant_summary = normalize_notify_text(transcript.get("assistant_summary") or "")
+
+    lines: list[str] = []
+
+    if status == "error":
+        lines.append("Status: Error")
+    elif status == "aborted":
+        lines.append("Status: Aborted")
+    else:
+        lines.append("Status: Done")
+
+    if cfg.get("include_full_chat_id", True) and conversation_id:
+        lines.append(f"Chat: {conversation_id}")
+    else:
+        lines.append(f"Chat: {short_id}")
+
+    if workspace:
+        lines.append(f"Workspace: {Path(workspace).name}")
+
+    if user_query:
+        preview, truncated = truncate_at_sentence(user_query, min(summary_limit, 220))
+        lines.append("")
+        lines.append("You asked:")
+        lines.append(preview)
+        if truncated:
+            lines.append("(see follow-up for full request)")
+
+    lines.append("")
+    lines.append("Outcome:")
+    if assistant_summary:
+        lines.append(extract_summary(assistant_summary, summary_limit))
+    elif status == "error":
+        lines.append("Agent ended with an error.")
+    else:
+        lines.append("Agent finished.")
+
+    if transcript["action_tool_count"] > 0:
+        lines.append("")
+        lines.append(f"Tools: {transcript['action_tool_count']} action(s)")
+
+    return "\n".join(lines).strip()
+
+
+def build_followups(
+    payload: dict[str, Any],
+    transcript: dict[str, Any],
+    cfg: dict[str, Any],
+) -> list[tuple[str, str]]:
+    if not cfg.get("send_followups", True):
+        return []
+
+    max_followups = max(0, int(cfg.get("max_followup_messages") or 2))
+    if max_followups == 0:
+        return []
+
+    followup_limit = int(cfg.get("followup_max_chars") or 1000)
+    summary_limit = int(cfg.get("summary_max_chars") or 300)
+    conversation_id = str(payload.get("conversation_id") or "").strip()
+    short_id = conversation_id[:8] if conversation_id else "unknown"
+    chat_ref = conversation_id if cfg.get("include_full_chat_id", True) and conversation_id else short_id
+
+    user_query = normalize_notify_text(transcript.get("user_query") or "")
+    assistant_summary = normalize_notify_text(transcript.get("assistant_summary") or "")
+
+    followups: list[tuple[str, str]] = []
+
+    if user_query:
+        preview, was_truncated = truncate_at_sentence(user_query, min(summary_limit, 220))
+        if was_truncated or len(user_query) > len(preview) + 20:
+            for index, chunk in enumerate(chunk_text(user_query, followup_limit), start=1):
+                if len(followups) >= max_followups:
+                    break
+                suffix = f" ({index})" if len(chunk_text(user_query, followup_limit)) > 1 else ""
+                body = f"Chat: {chat_ref}\n\nYou asked:\n{chunk}"
+                followups.append((f"Cursor · Request{suffix}", body))
+
+    if assistant_summary and len(followups) < max_followups:
+        summary = extract_summary(assistant_summary, summary_limit)
+        summary_core = summary.rstrip("…")
+        tail = assistant_summary
+        if summary_core and tail.startswith(summary_core):
+            tail = tail[len(summary_core) :].lstrip(" .,;:-")
+        if len(tail) >= 40:
+            parts = chunk_text(tail, followup_limit)
+            for index, chunk in enumerate(parts, start=1):
+                if len(followups) >= max_followups:
+                    break
+                suffix = f" ({index})" if len(parts) > 1 else ""
+                body = f"Chat: {chat_ref}\n\nDetails:\n{chunk}"
+                followups.append((f"Cursor · Outcome{suffix}", body))
+
+    return followups[:max_followups]
+
+
+def build_messages(
+    payload: dict[str, Any],
+    transcript: dict[str, Any],
+    cfg: dict[str, Any],
+) -> list[tuple[str, str]]:
+    title = build_title(payload, cfg)
+    main_brief = build_main_brief(payload, transcript, cfg)
+    if not main_brief.strip():
+        return []
+
+    messages = [(title, main_brief)]
+    messages.extend(build_followups(payload, transcript, cfg))
+    return messages
+
+
+def send_notification(title: str, brief: str, peer: str) -> None:
+    destination = (peer or "*").strip() or "*"
+    env = os.environ.copy()
+    if destination != "*":
+        env["OMNISH_PEER_KEY"] = destination
+
+    inner = f"/sendto {destination} -t {title} -- {brief}"
+    subprocess.run(
+        ["omnish", "i", "-c", inner],
+        check=False,
+        env=env,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        timeout=30,
+    )
+
+
+def which(name: str) -> str | None:
+    for directory in os.environ.get("PATH", "").split(os.pathsep):
+        candidate = Path(directory) / name
+        if candidate.is_file() and os.access(candidate, os.X_OK):
+            return str(candidate)
+    return None
+
+
+def main() -> int:
+    try:
+        payload = json.load(sys.stdin)
+    except json.JSONDecodeError as exc:
+        log(f"invalid hook payload: {exc}")
+        print("{}")
+        return 0
+
+    cfg = load_config()
+    if not cfg.get("enabled", True):
+        print("{}")
+        return 0
+
+    transcript = parse_transcript(payload.get("transcript_path"))
+    if not should_notify(payload, transcript, cfg):
+        log(f"skip notify chat={payload.get('conversation_id')} status={payload.get('status')}")
+        print("{}")
+        return 0
+
+    conversation_id = str(payload.get("conversation_id") or "").strip()
+    user_query = transcript.get("user_query") or ""
+    if is_duplicate_notify(conversation_id, user_query, cfg):
+        log(f"skip duplicate chat={conversation_id}")
+        print("{}")
+        return 0
+
+    messages = build_messages(payload, transcript, cfg)
+    if not messages:
+        print("{}")
+        return 0
+
+    peer = str(cfg.get("peer") or "*").strip() or "*"
+
+    if not which("omnish"):
+        log("omnish not found on PATH")
+        print("{}")
+        return 0
+
+    try:
+        for index, (title, brief) in enumerate(messages):
+            if index > 0:
+                time.sleep(0.4)
+            send_notification(title, brief, peer)
+        log(
+            f"sent chat={payload.get('conversation_id')} dest={peer!r} "
+            f"messages={len(messages)} title={messages[0][0]!r}"
+        )
+    except subprocess.TimeoutExpired:
+        log(f"notify timeout chat={payload.get('conversation_id')}")
+    except OSError as exc:
+        log(f"notify failed: {exc}")
+
+    print("{}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/omnish-cursor/hooks/omnish-notify.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# stop hook: send curated Omnish brief when Cursor agent work is worth notifying.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PYTHON="${OMNISH_NOTIFY_PYTHON:-python3}"
+
+if ! command -v "$PYTHON" >/dev/null 2>&1; then
+  echo '{}'
+  exit 0
+fi
+
+exec "$PYTHON" "$SCRIPT_DIR/omnish-notify.py"

package/dist/omnish-cursor/hooks/omnish-session-start.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# sessionStart hook: inject Omnish notification guidance into every agent session.
+set -euo pipefail
+
+read -r _input
+
+python3 - <<'PY'
+import json
+import os
+from pathlib import Path
+
+cfg_path = Path.home() / ".cursor" / "omnish-notify.json"
+enabled = True
+peer = os.environ.get("OMNISH_CURSOR_NOTIFY_PEER", "*")
+if cfg_path.is_file():
+    try:
+        cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+        enabled = bool(cfg.get("enabled", True))
+        peer = str(cfg.get("peer") or peer)
+    except Exception:
+        pass
+
+if not enabled:
+    print("{}")
+    raise SystemExit(0)
+
+dest = peer if peer and peer != "peer" else "*"
+notify_cmd = f"omnish i -c '/sendto {dest} -t <title> -- <brief>'"
+
+context = f"""Omnish mobile notifications (global user policy):
+- When you finish useful work, or hit a blocker that needs human input, send a concise status via Omnish.
+- Command: {notify_cmd}
+- Always include the Cursor chat id (conversation_id) in the brief when notifying.
+- Send only when the update is actionable: Done, Progress, Question, or Blocked. Skip trivial Q&A, pure exploration with no outcome, or duplicate "still working" pings.
+- Prefer one Done notification at completion; use Progress sparingly on major milestones.
+- Default destination is {dest!r} (all allowlisted peers on this gateway). Requires omnish run with platform token or local WhatsApp/Telegram."""
+
+out = {
+    "additional_context": context,
+    "env": {
+        "OMNISH_NOTIFY_CMD": f"omnish i -c '/sendto {dest} -t <title> -- <brief>'",
+    },
+}
+if dest != "*":
+    out["env"]["OMNISH_PEER_KEY"] = dest
+
+print(json.dumps(out))
+PY