oh-aicoding-tool 0.1.2 → 0.1.4

package/opencode-ohai-report/tools/ohai-report/ohai_report/metadata.py

@@ -1,360 +0,0 @@
-"""Metadata resolution for agent/session/Langfuse indexes."""
-
-from __future__ import annotations
-
-import datetime as dt
-import os
-import pathlib
-from typing import Any
-
-from .git_context import git_context
-from .observability.langfuse import trace_url_from_env
-from .schema import MetadataUpdateInput
-from .workspace import data_dir, read_json, write_json
-
-
-DEFAULT_STORED_SESSION_MAX_AGE_SECONDS = 30 * 60
-
-
-def _home_dir() -> pathlib.Path:
-    raw = (os.environ.get("USERPROFILE") or os.environ.get("HOME") or "").strip()
-    if raw:
-        return pathlib.Path(raw)
-    try:
-        return pathlib.Path.home()
-    except RuntimeError:
-        return pathlib.Path.cwd()
-
-
-def opencode_global_config_dir() -> pathlib.Path:
-    """与 OpenCode 安装脚本一致：优先 ``XDG_CONFIG_HOME/opencode``，否则 Windows ``%USERPROFILE%\\.config\\opencode``，再否则 ``~/.config/opencode``。"""
-    xdg = (os.environ.get("XDG_CONFIG_HOME") or "").strip()
-    if xdg:
-        return pathlib.Path(xdg) / "opencode"
-    return _home_dir() / ".config" / "opencode"
-
-
-def _user_email_from_json_dict(data: dict[str, Any]) -> str:
-    raw = data.get("user_email", data.get("userEmail"))
-    if isinstance(raw, str):
-        t = raw.strip()
-        if t and "@" in t:
-            return t
-    return ""
-
-
-def read_user_email_from_sidecar_json_files(workspace_root: pathlib.Path) -> str:
-    """独立 JSON 中的公司邮箱（便于用户直接编辑）。
-
-    读取顺序（后者不覆盖前者已读到的值）：
-
-    1. ``<workspace>/.ohai-report/user_email.json`` — 按仓库覆盖
-    2. ``~/.config/opencode/ohai-report/email.json`` — 安装脚本写入的全局默认
-    3. ``~/.config/opencode/ohai-report-user.json`` — 旧版安装脚本，仍兼容
-    """
-    candidates = [
-        workspace_root / ".ohai-report" / "user_email.json",
-        opencode_global_config_dir() / "ohai-report" / "email.json",
-        opencode_global_config_dir() / "ohai-report-user.json",
-    ]
-    for path in candidates:
-        em = _user_email_from_json_dict(read_json(path))
-        if em:
-            return em
-    return ""
-
-
-def is_placeholder_tracing_user_id(value: str) -> bool:
-    """排除明显非业务用户的占位（如环境里的 USER_ID=000000）。"""
-    t = (value or "").strip()
-    if not t:
-        return True
-    low = t.lower()
-    if low in ("unknown", "null", "undefined", "none", "n/a", "na"):
-        return True
-    if len(t) <= 12 and all(c == "0" for c in t):
-        return True
-    return False
-
-
-def tracing_user_id_from_env(env: dict[str, str]) -> str:
-    """仅使用显式追踪相关变量，不把 OS 登录名当作 user_id（避免误显示）。"""
-    for key in ("OHAI_USER_ID", "OHAI_EMPLOYEE_ID", "OPENCODE_EMPLOYEE_ID", "LANGFUSE_USER_ID", "USER_ID"):
-        raw = (env.get(key) or "").strip()
-        if raw and not is_placeholder_tracing_user_id(raw):
-            return raw
-    return ""
-
-
-def tracing_user_email_from_env(env: dict[str, str]) -> str:
-    """公司/上报邮箱：显式邮箱变量优先；否则若追踪类 user id 形如邮箱则复用。"""
-    for key in ("OHAI_USER_EMAIL", "USER_EMAIL", "GIT_AUTHOR_EMAIL"):
-        raw = (env.get(key) or "").strip()
-        if raw and "@" in raw:
-            return raw
-    for key in ("OHAI_USER_ID", "LANGFUSE_USER_ID"):
-        raw = (env.get(key) or "").strip()
-        if raw and "@" in raw and "." in raw.split("@", 1)[-1]:
-            return raw
-    return ""
-
-
-def _traceparent_from_env(env: dict[str, str]) -> tuple[str, str]:
-    """解析 W3C traceparent（00-<trace32>-<parent16>-<flags>），补全 trace / span 关联。"""
-    tp = (env.get("TRACEPARENT") or env.get("traceparent") or "").strip()
-    if not tp:
-        return "", ""
-    parts = tp.split("-")
-    if len(parts) < 4:
-        return "", ""
-    ver, trace, span = parts[0], parts[1], parts[2]
-    if len(ver) != 2 or any(c not in "0123456789abcdefABCDEF" for c in ver):
-        return "", ""
-    if len(trace) != 32 or any(c not in "0123456789abcdefABCDEF" for c in trace):
-        return "", ""
-    if len(span) != 16 or any(c not in "0123456789abcdefABCDEF" for c in span):
-        return trace.lower(), ""
-    return trace.lower(), span.lower()
-
-
-def env_metadata() -> dict[str, Any]:
-    """Read correlation IDs from env (Langfuse / OpenCode / OHAI 桥接).
-
-    Langfuse 或宿主进程可将当前 trace 上下文写入下列变量，子进程执行
-    ``ohai_report.py create --metadata auto`` 时即可带入 Issue「日志信息」。
-    """
-    env = os.environ
-    session_id = (
-        env.get("OHAI_SESSION_ID")
-        or env.get("OPENCODE_SESSION_ID")
-        or env.get("LANGFUSE_SESSION_ID")
-        or env.get("SESSION_ID")
-        or ""
-    )
-    trace_id = env.get("LANGFUSE_TRACE_ID") or env.get("TRACE_ID") or env.get("OTEL_TRACE_ID") or ""
-    observation_id = (
-        env.get("LANGFUSE_OBSERVATION_ID")
-        or env.get("OHAI_OBSERVATION_ID")
-        or env.get("OBSERVATION_ID")
-        or env.get("OTEL_SPAN_ID")
-        or ""
-    )
-    tp_trace, tp_span = _traceparent_from_env(dict(env))
-    if not trace_id and tp_trace:
-        trace_id = tp_trace
-    if not observation_id and tp_span:
-        observation_id = tp_span
-    message_id = env.get("OPENCODE_MESSAGE_ID") or env.get("OHAI_MESSAGE_ID") or ""
-    opencode_subagent = env.get("OHAI_OPENCODE_SUBAGENT") or env.get("OPENCODE_SUBAGENT") or ""
-    model = env.get("OPENCODE_MODEL") or env.get("OHAI_MODEL") or ""
-    return {
-        "session_id": session_id,
-        "trace_id": trace_id,
-        "observation_id": observation_id,
-        "message_id": message_id,
-        "opencode_subagent": opencode_subagent,
-        "model": model,
-        "langfuse_url": env.get("LANGFUSE_URL") or env.get("LANGFUSE_TRACE_URL") or "",
-        "user": {
-            "id": tracing_user_id_from_env(env),
-            "email": tracing_user_email_from_env(env),
-            "name": (
-                env.get("OHAI_USER_NAME")
-                or env.get("OHAI_EMPLOYEE_ID")
-                or env.get("OPENCODE_EMPLOYEE_ID")
-                or env.get("USERNAME")
-                or env.get("USER")
-                or ""
-            ),
-            "team": env.get("OHAI_TEAM") or env.get("TEAM") or "",
-        },
-    }
-
-
-def _prefer_env_then_stored(env: dict[str, Any], stored: dict[str, Any], key: str) -> str:
-    """进程内 Langfuse 注入优先于磁盘上可能过期的快照。"""
-    ev = str(env.get(key) or "").strip()
-    if ev:
-        return ev
-    return str(stored.get(key) or "").strip()
-
-
-def _stored_session_max_age() -> dt.timedelta:
-    raw = (os.environ.get("OHAI_STORED_SESSION_MAX_AGE_SECONDS") or "").strip()
-    if raw:
-        try:
-            seconds = int(raw)
-        except ValueError:
-            seconds = DEFAULT_STORED_SESSION_MAX_AGE_SECONDS
-        if seconds > 0:
-            return dt.timedelta(seconds=seconds)
-    return dt.timedelta(seconds=DEFAULT_STORED_SESSION_MAX_AGE_SECONDS)
-
-
-def _parse_metadata_time(value: Any) -> dt.datetime | None:
-    if not isinstance(value, str) or not value.strip():
-        return None
-    try:
-        parsed = dt.datetime.fromisoformat(value.strip())
-    except ValueError:
-        return None
-    if parsed.tzinfo is None:
-        return parsed.astimezone()
-    return parsed
-
-
-def _same_stored_workspace(root: pathlib.Path, stored: dict[str, Any]) -> bool:
-    context = stored.get("context") if isinstance(stored.get("context"), dict) else {}
-    cwd = str(context.get("cwd") or "").strip()
-    if not cwd:
-        return True
-    try:
-        return pathlib.Path(cwd).resolve() == root.resolve()
-    except OSError:
-        return pathlib.Path(cwd) == root
-
-
-def _fresh_stored_session_id(root: pathlib.Path, stored: dict[str, Any]) -> str:
-    sid = str(stored.get("session_id") or "").strip()
-    if not sid or not _same_stored_workspace(root, stored):
-        return ""
-
-    updated_at = _parse_metadata_time(stored.get("updated_at"))
-    if updated_at is None:
-        return ""
-    age = dt.datetime.now(updated_at.tzinfo).astimezone(updated_at.tzinfo) - updated_at
-    if age < dt.timedelta(0) or age > _stored_session_max_age():
-        return ""
-    return sid
-
-
-def resolve_metadata(root: pathlib.Path, source: str, mode: str) -> dict[str, Any]:
-    base: dict[str, Any] = {
-        "source": source,
-        "agent": source,
-        "session_id": "",
-        "trace_id": "",
-        "observation_id": "",
-        "message_id": "",
-        "opencode_subagent": "",
-        "model": "",
-        "langfuse_url": "",
-        "user": {"id": "", "name": "", "team": "", "email": ""},
-        "context": git_context(root),
-    }
-    if mode != "auto":
-        return base
-
-    stored = read_json(data_dir(root) / "metadata.json")
-    env = env_metadata()
-
-    stored_session_id = _fresh_stored_session_id(root, stored) if source == "opencode" else ""
-    base["session_id"] = str(env.get("session_id") or "").strip() or stored_session_id
-    for key in ("trace_id", "observation_id", "message_id", "opencode_subagent", "model"):
-        base[key] = _prefer_env_then_stored(env, stored, key)
-
-    lu_stored = str(stored.get("langfuse_url") or "").strip()
-    lu_env = str(env.get("langfuse_url") or "").strip()
-    base["langfuse_url"] = lu_stored or lu_env
-
-    if base.get("trace_id") and not (base.get("langfuse_url") or "").strip():
-        built_url = trace_url_from_env(str(base["trace_id"]))
-        if built_url:
-            base["langfuse_url"] = built_url
-
-    stored_user = stored.get("user") if isinstance(stored.get("user"), dict) else {}
-    env_user = env.get("user") if isinstance(env.get("user"), dict) else {}
-    e_uid = str(env_user.get("id") or "").strip()
-    if e_uid and is_placeholder_tracing_user_id(e_uid):
-        e_uid = ""
-    s_uid = str(stored_user.get("id") or "").strip()
-    if s_uid and is_placeholder_tracing_user_id(s_uid):
-        s_uid = ""
-    e_mail = str(env_user.get("email") or "").strip()
-    s_mail = str(stored_user.get("email") or "").strip()
-    base["user"] = {
-        "id": e_uid or s_uid,
-        "name": str(stored_user.get("name") or env_user.get("name") or "").strip(),
-        "team": str(stored_user.get("team") or env_user.get("team") or "").strip(),
-        "email": e_mail or s_mail,
-    }
-
-    if not str(base["user"].get("email") or "").strip():
-        fe = read_user_email_from_sidecar_json_files(root)
-        if fe:
-            base["user"]["email"] = fe
-
-    stored_context = stored.get("context") if isinstance(stored.get("context"), dict) else {}
-    base["context"].update({k: v for k, v in stored_context.items() if v})
-    return base
-
-
-def update_metadata(root: pathlib.Path, value: MetadataUpdateInput) -> pathlib.Path:
-    path = data_dir(root) / "metadata.json"
-    stored = read_json(path)
-    context = stored.get("context") if isinstance(stored.get("context"), dict) else {}
-    context.update(git_context(root))
-    if value.cwd:
-        context["cwd"] = value.cwd
-
-    env_meta = env_metadata()
-
-    user = stored.get("user") if isinstance(stored.get("user"), dict) else {}
-    env_user = env_meta["user"]
-    user.update({k: v for k, v in env_user.items() if v})
-    if (value.user_id or "").strip():
-        tid = str(value.user_id).strip()
-        user["id"] = tid
-        if "@" in tid and "." in tid.split("@", 1)[-1]:
-            user["email"] = tid
-
-    sid = (value.session_id or "").strip() or str(env_meta.get("session_id") or "").strip()
-    if not sid and value.source == "opencode":
-        sid = _fresh_stored_session_id(root, stored)
-    tid = (value.trace_id or "").strip() or str(env_meta.get("trace_id") or "").strip()
-    if not tid:
-        tid = str(stored.get("trace_id") or "").strip()
-    oid = (value.observation_id or "").strip() or str(env_meta.get("observation_id") or "").strip()
-    if not oid:
-        oid = str(stored.get("observation_id") or "").strip()
-    if value.clear_message_subagent:
-        mid = ""
-        sub = ""
-    else:
-        mid = (value.message_id or "").strip() or str(env_meta.get("message_id") or "").strip()
-        if not mid:
-            mid = str(stored.get("message_id") or "").strip()
-        sub = (value.opencode_subagent or "").strip() or str(env_meta.get("opencode_subagent") or "").strip()
-        if not sub:
-            sub = str(stored.get("opencode_subagent") or "").strip()
-
-    mdl_cli = (value.model or "").strip()
-    if mdl_cli:
-        mdl = mdl_cli
-    else:
-        mdl = str(env_meta.get("model") or "").strip()
-        if not mdl:
-            mdl = str(stored.get("model") or "").strip()
-
-    if not str(user.get("email") or "").strip():
-        fe = read_user_email_from_sidecar_json_files(root)
-        if fe:
-            user["email"] = fe
-
-    next_value = {
-        **stored,
-        "source": value.source,
-        "agent": value.source,
-        "session_id": sid,
-        "trace_id": tid,
-        "observation_id": oid,
-        "message_id": mid,
-        "opencode_subagent": sub,
-        "model": mdl,
-        "langfuse_url": (value.langfuse_url or "").strip() or stored.get("langfuse_url", ""),
-        "user": user,
-        "context": context,
-        "updated_at": dt.datetime.now(dt.timezone.utc).astimezone().isoformat(timespec="seconds"),
-    }
-    write_json(path, next_value)
-    return path

package/opencode-ohai-report/tools/ohai-report/ohai_report/observability/__init__.py

@@ -1 +0,0 @@
-"""Observability helpers (Langfuse URL generation, trace hints)."""

package/opencode-ohai-report/tools/ohai-report/ohai_report/observability/langfuse.py

@@ -1,38 +0,0 @@
-"""Langfuse URL helpers — trace links without embedding logs in Issues."""
-
-from __future__ import annotations
-
-import os
-import urllib.parse
-
-
-def build_trace_url(base_url: str, project_id: str, trace_id: str) -> str:
-    """Return a canonical Langfuse trace URL for typical Cloud / self-hosted UI paths."""
-    root = base_url.strip().rstrip("/")
-    if not root or not project_id or not trace_id:
-        return ""
-    enc_trace = urllib.parse.quote(trace_id, safe="")
-    return f"{root}/project/{project_id}/traces/{enc_trace}"
-
-
-def trace_url_from_env(trace_id: str) -> str:
-    """If LANGFUSE_BASE_URL (or HOST) and LANGFUSE_PROJECT_ID are set, derive trace URL."""
-    if not trace_id:
-        return ""
-    raw_base = (
-        os.environ.get("LANGFUSE_BASE_URL")
-        or os.environ.get("LANGFUSE_HOST")
-        or os.environ.get("LANGFUSE_ORIGIN")
-        or ""
-    )
-    project_id = (
-        os.environ.get("LANGFUSE_PROJECT_ID")
-        or os.environ.get("LANGFUSE_PUBLIC_KEY")
-        or ""
-    ).strip()
-    if not raw_base.strip() or not project_id:
-        return ""
-    root = raw_base.strip().rstrip("/")
-    if root.endswith("/traces"):
-        return f"{root}/{urllib.parse.quote(trace_id, safe='')}"
-    return build_trace_url(root, project_id, trace_id)

package/opencode-ohai-report/tools/ohai-report/ohai_report/payload.py

@@ -1,64 +0,0 @@
-"""Payload assembly for issue reports."""
-
-from __future__ import annotations
-
-import datetime as dt
-import pathlib
-from typing import Any
-
-from .metadata import resolve_metadata
-from .schema import CreateIssueInput
-
-
-def generate_issue_id(now: dt.datetime) -> str:
-    return f"AI-DEV-{now.strftime('%Y%m%d%H%M%S%f')}"
-
-
-def build_issue_payload(root: pathlib.Path, value: CreateIssueInput) -> dict[str, Any]:
-    now = dt.datetime.now(dt.timezone.utc).astimezone()
-    metadata = resolve_metadata(root, value.source, value.metadata)
-    issue = dict(value.issue)
-    if value.metadata == "auto":
-        om = str(metadata.get("model") or "").strip()
-        if om:
-            issue["model"] = om
-    user = metadata["user"] if isinstance(metadata.get("user"), dict) else {}
-    uid = str(user.get("id") or "").strip()
-    if not uid:
-        uid = str(issue.get("user_id") or "").strip()
-    uem = str(user.get("email") or "").strip()
-    if not uem:
-        uem = str(issue.get("user_email") or "").strip()
-    if not uem and uid and "@" in uid and "." in uid.split("@", 1)[-1]:
-        uem = uid
-    obs = str(metadata.get("observation_id") or "").strip()
-    mid = str(metadata.get("message_id") or "").strip()
-    sub = str(metadata.get("opencode_subagent") or "").strip()
-    user_out = dict(user)
-    user_out.setdefault("email", "")
-    if uem:
-        user_out["email"] = uem
-    return {
-        "issue_id": generate_issue_id(now),
-        "created_at": now.isoformat(timespec="seconds"),
-        "source": metadata["source"],
-        "agent": metadata["agent"],
-        "session_id": metadata["session_id"],
-        "trace_id": metadata["trace_id"],
-        "observation_id": obs,
-        "message_id": mid,
-        "opencode_subagent": sub,
-        "user_id": uid,
-        "user_email": uem,
-        "langfuse_url": metadata["langfuse_url"],
-        "user": user_out,
-        "issue": issue,
-        "context": metadata["context"],
-        "privacy": {
-            "uploads_logs": False,
-            "uploads_diff": False,
-            "uploads_transcript": False,
-            "note": "Issue only stores template fields and correlation IDs in the log section.",
-        },
-        "status": "created-local",
-    }

package/opencode-ohai-report/tools/ohai-report/ohai_report/schema.py

@@ -1,80 +0,0 @@
-"""Data contracts and validation for ohai-report."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import json
-import pathlib
-from typing import Any
-
-
-def schema_path() -> pathlib.Path:
-    return pathlib.Path(__file__).resolve().parents[1] / "schemas" / "report_issue.schema.json"
-
-
-def load_issue_schema() -> dict[str, Any]:
-    with schema_path().open("r", encoding="utf-8") as fp:
-        value = json.load(fp)
-    if not isinstance(value, dict) or not isinstance(value.get("fields"), dict):
-        raise ValueError("invalid issue schema: missing fields object")
-    return value
-
-
-def issue_fields() -> dict[str, dict[str, Any]]:
-    schema = load_issue_schema()
-    return schema["fields"]
-
-
-@dataclass(frozen=True)
-class CreateIssueInput:
-    source: str
-    issue: dict[str, Any]
-    metadata: str
-
-
-@dataclass(frozen=True)
-class MetadataUpdateInput:
-    source: str
-    session_id: str = ""
-    trace_id: str = ""
-    langfuse_url: str = ""
-    observation_id: str = ""
-    user_id: str = ""
-    message_id: str = ""
-    opencode_subagent: str = ""
-    model: str = ""
-    clear_message_subagent: bool = False
-    cwd: str = ""
-
-
-def validate_issue(issue: dict[str, Any]) -> list[str]:
-    errors: list[str] = []
-
-    for name, spec in issue_fields().items():
-        item = issue.get(name)
-        if spec.get("required") and not item:
-            errors.append(f"missing required field: {name}")
-            continue
-        if not item:
-            continue
-
-        if spec.get("type") == "string" and not isinstance(item, str):
-            errors.append(f"invalid type for field {name}: expected string")
-            continue
-        enum = spec.get("enum")
-        if enum and item not in enum:
-            errors.append(f"invalid value for field {name}: {item}")
-        max_length = spec.get("maxLength")
-        if isinstance(max_length, int) and isinstance(item, str) and len(item) > max_length:
-            errors.append(f"field too long: {name} maxLength={max_length}")
-    return errors
-
-
-def validate_create_input(value: CreateIssueInput) -> list[str]:
-    errors: list[str] = []
-    if not value.source:
-        errors.append("missing required field: source")
-    errors.extend(validate_issue(value.issue))
-    if value.metadata not in {"auto", "none"}:
-        errors.append(f"invalid metadata mode: {value.metadata}")
-    return errors

package/opencode-ohai-report/tools/ohai-report/ohai_report/sinks/__init__.py

@@ -1 +0,0 @@
-"""Issue sinks."""

package/opencode-ohai-report/tools/ohai-report/ohai_report/sinks/base.py

@@ -1,15 +0,0 @@
-"""Sink result type for issue persistence backends."""
-
-from __future__ import annotations
-
-import pathlib
-from dataclasses import dataclass, field
-from typing import Any
-
-
-@dataclass(frozen=True)
-class SinkResult:
-    issue_id: str
-    path: pathlib.Path | None = None
-    url: str = ""
-    extra: dict[str, Any] = field(default_factory=dict)