oh-aicoding-tool 0.1.2 → 0.1.5

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

@@ -1,354 +0,0 @@
-"""HTTP JSON webhook sink: POST JSON（title、body；非空时含 labels 逗号分隔字符串）供外部建单服务消费。"""
-
-from __future__ import annotations
-
-import datetime as dt
-import json
-import os
-import pathlib
-import urllib.error
-import urllib.request
-from dataclasses import dataclass
-from typing import Any
-
-from ..issue_markdown import derive_gitcode_dimension_labels, format_issue_markdown, sanitize_gitcode_label_value
-from ..payload import generate_issue_id
-from ..webhook_defaults import DEFAULT_WEBHOOK_URL
-from .base import SinkResult
-
-
-def parse_labels_value(value: Any) -> list[str]:
-    """将 issue 字段或 CLI 中的 labels 规范为去重后的非空字符串列表。"""
-    if value is None:
-        return []
-    if isinstance(value, list):
-        out: list[str] = []
-        for x in value:
-            if x is None:
-                continue
-            t = str(x).strip()
-            if t:
-                out.append(t)
-        return out
-    s = str(value).strip()
-    if not s:
-        return []
-    return [p.strip() for p in s.split(",") if p.strip()]
-
-
-def resolve_webhook_post_labels(issue: dict[str, Any], cli_labels: str | None) -> list[str]:
-    """决定 POST 体中的 labels：显式传入 ``--webhook-labels`` 时仅使用该串（与 GitCode CLI 覆盖 env 一致）；否则合并 issue.labels 与 ``OHAI_WEBHOOK_LABELS``。"""
-    if cli_labels is not None:
-        return parse_labels_value(cli_labels)
-    merged: list[str] = []
-    merged.extend(parse_labels_value(issue.get("labels")))
-    merged.extend(parse_labels_value(os.environ.get("OHAI_WEBHOOK_LABELS", "")))
-    seen: set[str] = set()
-    out: list[str] = []
-    for p in merged:
-        if p not in seen:
-            seen.add(p)
-            out.append(p)
-    return out
-
-
-def merge_webhook_post_label_list(
-    payload: dict[str, Any],
-    issue: dict[str, Any],
-    cli_labels: str | None,
-) -> list[str]:
-    """维度标签（与 gitcode sink 一致）在前，其次 ``resolve_webhook_post_labels``；大小写不敏感去重。"""
-    dim = derive_gitcode_dimension_labels(payload)
-    rest = resolve_webhook_post_labels(issue, cli_labels)
-    seen: set[str] = set()
-    merged: list[str] = []
-    for group in (dim, rest):
-        for name in group:
-            t = sanitize_gitcode_label_value(name)
-            if not t:
-                continue
-            k = t.casefold()
-            if k in seen:
-                continue
-            seen.add(k)
-            merged.append(t)
-    return merged
-
-
-def format_webhook_labels_string(labels: list[str]) -> str:
-    """接收端常见约定：``\"bug,critical\"`` JSON 字符串，而非数组。"""
-    return ",".join(str(x).strip() for x in labels if str(x).strip())
-
-
-def format_webhook_labels_color_string(labels: list[str]) -> str:
-    """将标签列表一一映射为颜色 HEX 字符串，再以逗号分隔。"""
-    from .gitcode import gitcode_label_color
-    return ",".join(gitcode_label_color(str(x).strip()) for x in labels if str(x).strip())
-
-
-class WebhookSinkError(RuntimeError):
-    def __init__(self, message: str, *, status_code: int = 0, body: str = "") -> None:
-        super().__init__(message)
-        self.status_code = status_code
-        self.body = body
-
-
-def _url_from_mapping(m: dict[str, Any]) -> str:
-    for key in (
-        "html_url",
-        "url",
-        "issue_url",
-        "link",
-        "web_url",
-        "ticket_url",
-        "browser_url",
-        "permalink",
-        "detail_url",
-        "issueUrl",
-        "issue_link",
-    ):
-        v = m.get(key)
-        if isinstance(v, str) and v.strip().startswith(("http://", "https://")):
-            return v.strip()
-    return ""
-
-
-def _parse_remote_url(raw: str) -> str:
-    raw = (raw or "").strip()
-    if not raw:
-        return ""
-    first_line = raw.splitlines()[0].strip()
-    if first_line.startswith(("http://", "https://")):
-        return first_line
-    try:
-        obj = json.loads(raw)
-    except json.JSONDecodeError:
-        return ""
-    if isinstance(obj, list) and obj:
-        first = obj[0]
-        if isinstance(first, str) and first.strip().startswith(("http://", "https://")):
-            return first.strip()
-        if isinstance(first, dict):
-            u = _url_from_mapping(first)
-            if u:
-                return u
-    if not isinstance(obj, dict):
-        return ""
-    u = _url_from_mapping(obj)
-    if u:
-        return u
-    for nest_key in ("data", "result", "payload", "body", "issue", "ticket", "item"):
-        nested = obj.get(nest_key)
-        if isinstance(nested, dict):
-            u = _url_from_mapping(nested)
-            if u:
-                return u
-    return ""
-
-
-def _extract_extra_ids(obj: dict[str, Any]) -> dict[str, Any]:
-    out: dict[str, Any] = {}
-    for key in ("number", "id", "iid", "issue_id", "key", "seq", "ticket_id"):
-        if key in obj and obj[key] is not None:
-            out[key] = obj[key]
-    for nest_key in ("data", "result", "issue", "ticket", "payload"):
-        data = obj.get(nest_key)
-        if isinstance(data, dict):
-            for key in ("number", "id", "iid", "issue_id", "key", "seq"):
-                if key in data and data[key] is not None:
-                    out.setdefault(key, data[key])
-    return out
-
-
-@dataclass(frozen=True)
-class WebhookConfig:
-    url: str
-    secret: str = ""
-    timeout: float = 45.0
-
-    @classmethod
-    def from_env(
-        cls,
-        *,
-        url: str | None = None,
-        secret: str | None = None,
-        timeout: float | None = None,
-    ) -> WebhookConfig:
-        env = os.environ
-        u = (url or "").strip()
-        if not u:
-            u = (env.get("OHAI_WEBHOOK_URL") or env.get("WEBHOOK_URL") or "").strip()
-        if not u:
-            u = DEFAULT_WEBHOOK_URL.strip()
-        if secret is not None:
-            sec = str(secret).strip()
-        else:
-            sec = (env.get("OHAI_WEBHOOK_SECRET") or env.get("WEBHOOK_SECRET") or "").strip()
-        if timeout is not None:
-            to = float(timeout)
-        else:
-            raw = (env.get("OHAI_WEBHOOK_TIMEOUT") or env.get("WEBHOOK_TIMEOUT") or "").strip()
-            if raw:
-                try:
-                    to = float(raw)
-                except ValueError:
-                    to = 45.0
-            else:
-                to = 45.0
-        return cls(url=u.strip(), secret=sec, timeout=float(to))
-
-
-class WebhookIssueSink:
-    def __init__(self, config: WebhookConfig) -> None:
-        self.config = config
-
-    def post_title_body(self, title: str, body: str, labels: list[str] | None = None, labels_color: list[str] | None = None) -> SinkResult:
-        title = str(title or "").strip()
-        body = str(body or "").strip()
-        if not title:
-            raise WebhookSinkError("title 不能为空")
-        if not body:
-            raise WebhookSinkError("body 不能为空")
-
-        body_obj: dict[str, Any] = {"title": title, "body": body}
-        if labels:
-            body_obj["labels"] = format_webhook_labels_string(labels)
-        if labels_color:
-            body_obj["labels_color"] = format_webhook_labels_color_string(labels_color)
-        payload = json.dumps(body_obj, ensure_ascii=False).encode("utf-8")
-        headers: dict[str, str] = {
-            "Content-Type": "application/json; charset=utf-8",
-            "Accept": "application/json",
-        }
-        if self.config.secret:
-            headers["X-Webhook-Secret"] = self.config.secret
-
-        req = urllib.request.Request(
-            self.config.url,
-            data=payload,
-            headers=headers,
-            method="POST",
-        )
-        try:
-            with urllib.request.urlopen(req, timeout=self.config.timeout) as resp:
-                raw = resp.read().decode("utf-8", errors="replace")
-                code = int(getattr(resp, "status", 200) or 200)
-        except urllib.error.HTTPError as exc:
-            err_body = ""
-            try:
-                err_body = exc.read().decode("utf-8", errors="replace")
-            except OSError:
-                pass
-            raise WebhookSinkError(
-                f"Webhook 请求失败：HTTP {exc.code}",
-                status_code=int(exc.code or 0),
-                body=err_body,
-            ) from exc
-        except OSError as exc:
-            raise WebhookSinkError(f"Webhook 请求失败：{exc}") from exc
-
-        if code >= 400:
-            raise WebhookSinkError(f"Webhook 返回异常状态：HTTP {code}", status_code=code, body=raw[:4096])
-
-        remote = _parse_remote_url(raw)
-        extra: dict[str, Any] = {"raw_response": raw[:8192]}
-        try:
-            obj = json.loads(raw)
-            if isinstance(obj, dict):
-                extra.update(_extract_extra_ids(obj))
-        except json.JSONDecodeError:
-            pass
-
-        return SinkResult(issue_id="", path=None, url=remote, extra=extra)
-
-    def save(self, payload: dict[str, Any], *, webhook_labels_cli: str | None = None) -> SinkResult:
-        issue = payload.get("issue") if isinstance(payload.get("issue"), dict) else {}
-        title = str(issue.get("title") or "").strip()
-        if not title:
-            raise WebhookSinkError("issue.title 不能为空")
-        body = format_issue_markdown(payload)
-        labels = merge_webhook_post_label_list(payload, issue, webhook_labels_cli)
-        labels_color = labels if labels else None
-        result = self.post_title_body(title, body, labels, labels_color)
-        iid = str(payload.get("issue_id") or "")
-        return SinkResult(issue_id=iid, path=result.path, url=result.url, extra=result.extra)
-
-
-def apply_webhook_result(payload: dict[str, Any], result: SinkResult) -> dict[str, Any]:
-    out = dict(payload)
-    block: dict[str, Any] = {}
-    if result.url:
-        block["url"] = result.url
-    extra = getattr(result, "extra", {}) or {}
-    raw = extra.get("raw_response")
-    if isinstance(raw, str) and raw:
-        block["response_preview"] = raw[:2048]
-    for key in ("number", "id", "iid", "issue_id"):
-        if key in extra:
-            block[key] = extra[key]
-    out["webhook"] = block
-    out["status"] = "created-webhook"
-    return out
-
-
-def push_legacy_issue_json_file(path: pathlib.Path) -> int:
-    """Load {title, body|content} JSON and POST to webhook（与 scripts/create_issue.py 配套）。
-
-    成功时打印**一行 JSON**（与 ``ohai_report.py create --sink webhook --json`` 对齐），含 ``issue_id``（本地生成）
-    与 ``webhook_url``（从远端响应解析，可能为空），便于 agent / 脚本解析「已上报」链接。
-    """
-    try:
-        with path.open("r", encoding="utf-8") as fp:
-            data = json.load(fp)
-    except (OSError, json.JSONDecodeError) as exc:
-        print(f"Error: cannot read JSON: {exc}")
-        return 1
-
-    if not isinstance(data, dict):
-        print("Error: JSON root must be an object")
-        return 1
-
-    title = str(data.get("title", "")).strip()
-    body = str(data.get("body") or data.get("content", "")).strip()
-    if not title or not body:
-        print("Error: Missing title or body/content in issue file")
-        return 1
-
-    pseudo_payload: dict[str, Any] = {
-        "source": str(data.get("source") or "opencode"),
-        "issue": {k: v for k, v in data.items() if k not in ("title", "body", "content")},
-    }
-    issue = pseudo_payload["issue"] if isinstance(pseudo_payload.get("issue"), dict) else {}
-    labels = merge_webhook_post_label_list(pseudo_payload, issue, None)
-
-    cfg = WebhookConfig.from_env()
-    try:
-        sink = WebhookIssueSink(cfg)
-        result = sink.post_title_body(title, body, labels)
-    except WebhookSinkError as exc:
-        err = f"Error {exc.status_code}: {exc.body}" if exc.status_code and exc.body else str(exc)
-        print(err)
-        return 1
-
-    now = dt.datetime.now(dt.timezone.utc).astimezone()
-    iid = generate_issue_id(now)
-    out: dict[str, Any] = {
-        "ok": True,
-        "issue_id": iid,
-        "webhook_url": (result.url or "").strip(),
-        "sink": "webhook",
-        "path": "",
-        "session_id": "",
-        "trace_id": "",
-        "observation_id": "",
-        "user_id": "",
-        "message_id": "",
-        "opencode_subagent": "",
-        "langfuse_url": "",
-    }
-    extra = getattr(result, "extra", None) or {}
-    for k in ("number", "id", "iid", "issue_id"):
-        if k in extra:
-            out[f"webhook_{k}"] = extra[k]
-    print(json.dumps(out, ensure_ascii=False))
-    return 0

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

@@ -1,9 +0,0 @@
-"""Webhook 默认地址（当环境变量未设置时的回退值）。
-
-与 `os.environ.get("WEBHOOK_URL", "<默认>")` 等价逻辑：优先读环境变量
-`WEBHOOK_URL` / `OHAI_WEBHOOK_URL`，缺省再使用本常量。
-"""
-
-from __future__ import annotations
-
-DEFAULT_WEBHOOK_URL = "http://42.193.17.157:8081/test"

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

@@ -1,61 +0,0 @@
-"""Workspace and filesystem helpers."""
-
-from __future__ import annotations
-
-import json
-import os
-import pathlib
-from typing import Any
-
-
-def workspace_root() -> pathlib.Path:
-    return pathlib.Path.cwd()
-
-
-def resolve_workspace_root(cwd_arg: str) -> pathlib.Path:
-    """仓库根：优先 ``--cwd``，其次 ``OHAI_REPORT_CWD``，否则为进程当前目录。"""
-    t = (cwd_arg or "").strip()
-    if t:
-        return pathlib.Path(t).expanduser().resolve()
-    env_cwd = (os.environ.get("OHAI_REPORT_CWD") or "").strip()
-    if env_cwd:
-        return pathlib.Path(env_cwd).expanduser().resolve()
-    return workspace_root()
-
-
-def data_dir(root: pathlib.Path) -> pathlib.Path:
-    path = root / ".ohai-report"
-    path.mkdir(parents=True, exist_ok=True)
-    (path / "issues").mkdir(parents=True, exist_ok=True)
-    return path
-
-
-def read_json(path: pathlib.Path) -> dict[str, Any]:
-    try:
-        if not path.exists():
-            return {}
-        value = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return {}
-    return value if isinstance(value, dict) else {}
-
-
-def strip_surrogates(value: Any) -> Any:
-    if isinstance(value, str):
-        return value.encode("utf-8", errors="replace").decode("utf-8")
-    if isinstance(value, list):
-        return [strip_surrogates(item) for item in value]
-    if isinstance(value, dict):
-        return {
-            strip_surrogates(key) if isinstance(key, str) else key: strip_surrogates(item)
-            for key, item in value.items()
-        }
-    return value
-
-
-def write_json(path: pathlib.Path, value: dict[str, Any]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(
-        json.dumps(strip_surrogates(value), ensure_ascii=False, indent=2) + "\n",
-        encoding="utf-8",
-    )

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

@@ -1,10 +0,0 @@
-#!/usr/bin/env python3
-"""Compatibility entrypoint for the ohai-report CLI."""
-
-from __future__ import annotations
-
-from ohai_report.cli import main
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/opencode-ohai-report/tools/ohai-report/schemas/report_issue.schema.json

@@ -1,166 +0,0 @@
-{
-  "version": "1.4.0",
-  "description": "Issue template fields for AI development issue reports（含「AI 使用问题反馈」扩展字段，均为可选除必填项外）.",
-  "fields": {
-    "title": {
-      "type": "string",
-      "required": true,
-      "maxLength": 80,
-      "description": "标题，简短概括"
-    },
-    "category": {
-      "type": "string",
-      "required": true,
-      "enum": [
-        "模型输出错误",
-        "工具调用失败",
-        "Skill 缺陷",
-        "上下文缺失",
-        "环境问题",
-        "其他"
-      ],
-      "description": "采集侧分类（枚举），与主分类可并存"
-    },
-    "summary": {
-      "type": "string",
-      "required": true,
-      "maxLength": 800,
-      "description": "问题摘要，可较完整描述现象与上下文"
-    },
-    "expected_behavior": {
-      "type": "string",
-      "required": true,
-      "maxLength": 400,
-      "description": "期望行为 / 可作为改进方向兜底"
-    },
-    "actual_behavior": {
-      "type": "string",
-      "required": true,
-      "maxLength": 400,
-      "description": "实际行为 / 可与影响描述呼应"
-    },
-    "severity": {
-      "type": "string",
-      "required": true,
-      "enum": ["P0", "P1", "P2", "P3"],
-      "default": "P2",
-      "description": "Issue severity"
-    },
-    "user_description": {
-      "type": "string",
-      "required": true,
-      "maxLength": 2000,
-      "description": "原始用户描述"
-    },
-    "agent": {
-      "type": "string",
-      "enum": ["opencode", "claude", "codex"],
-      "description": "使用的 Agent 工具（标签 agent:），当前仅 opencode / claude / codex"
-    },
-    "model": {
-      "type": "string",
-      "maxLength": 128,
-      "description": "使用的模型（标签 model:），如 deepseek、minimax、gpt-5.5 等"
-    },
-    "level": {
-      "type": "string",
-      "enum": ["P0", "P1", "P2", "P3"],
-      "description": "标签中的问题严重等级 level，与 P0–P3 一致；未填时在正文中沿用 severity"
-    },
-    "scenario": {
-      "type": "string",
-      "maxLength": 128,
-      "description": "场景，如 coding / writing"
-    },
-    "task_type": {
-      "type": "string",
-      "maxLength": 128,
-      "description": "任务类型"
-    },
-    "workflow_phase": {
-      "type": "string",
-      "maxLength": 128,
-      "description": "工作流阶段"
-    },
-    "affected_role": {
-      "type": "string",
-      "maxLength": 128,
-      "description": "受影响角色"
-    },
-    "primary_category": {
-      "type": "string",
-      "maxLength": 128,
-      "description": "主分类（展示用，如 model-capability）"
-    },
-    "sub_category": {
-      "type": "string",
-      "maxLength": 128,
-      "description": "次分类"
-    },
-    "classification_confidence": {
-      "type": "string",
-      "enum": ["high", "medium", "low"],
-      "description": "分类置信度"
-    },
-    "classification_rationale": {
-      "type": "string",
-      "maxLength": 800,
-      "description": "判断依据"
-    },
-    "user_id": {
-      "type": "string",
-      "maxLength": 256,
-      "description": "追踪侧用户标识（Langfuse 等）；正文「日志信息」展示公司邮箱请用 user_email"
-    },
-    "user_email": {
-      "type": "string",
-      "maxLength": 256,
-      "description": "公司邮箱，展示在 Issue 正文「日志信息」user_email 行（可覆盖 metadata user.email）"
-    },
-    "observation_id": {
-      "type": "string",
-      "maxLength": 256,
-      "description": "日志信息中的 observation_id（观测关联 ID）"
-    },
-    "message_id": {
-      "type": "string",
-      "maxLength": 256,
-      "description": "OpenCode 当前消息 ID（日志信息，对应 context.messageID）"
-    },
-    "opencode_subagent": {
-      "type": "string",
-      "maxLength": 128,
-      "description": "OpenCode 子 Agent 名（日志信息，对应 context.agent，非 LLM 模型名）"
-    },
-    "tags": {
-      "type": "string",
-      "maxLength": 2000,
-      "description": "可选备注标签（正文「标签」小节固定展示 agent/model/level）"
-    },
-    "impact": {
-      "type": "string",
-      "maxLength": 2000,
-      "description": "影响说明"
-    },
-    "possible_causes": {
-      "type": "string",
-      "maxLength": 4000,
-      "description": "可能原因，多行可用换行，行首可加 - "
-    },
-    "improvement_direction": {
-      "type": "string",
-      "maxLength": 2000,
-      "description": "改进方向"
-    },
-    "suggested_follow_up": {
-      "type": "string",
-      "maxLength": 2000,
-      "description": "建议补充信息"
-    },
-    "suggested_dispatch": {
-      "type": "string",
-      "maxLength": 500,
-      "description": "建议分派方向"
-    }
-  }
-}