oh-aicoding-tool 0.1.0

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

@@ -0,0 +1,354 @@
+"""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

@@ -0,0 +1,9 @@
+"""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

@@ -0,0 +1,61 @@
+"""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

@@ -0,0 +1,10 @@
+#!/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

@@ -0,0 +1,166 @@
+{
+  "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": "建议分派方向"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "oh-aicoding-tool",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "Configure AI coding tools with Langfuse tracing and install the oh-ai-report issue feedback plugin.",
+  "bin": {
+    "oh-aicoding-tool": "bin/cli.js",
+    "code-tool-langfuse": "bin/langfuse-cli.js",
+    "opencode-ohai-report": "opencode-ohai-report/bin/cli.js",
+    "ohai-report": "opencode-ohai-report/bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "opencode-ohai-report/.opencode",
+    "opencode-ohai-report/.claude",
+    "opencode-ohai-report/bin",
+    "opencode-ohai-report/docs",
+    "opencode-ohai-report/examples",
+    "opencode-ohai-report/scripts/*.py",
+    "opencode-ohai-report/scripts/*.ps1",
+    "opencode-ohai-report/scripts/*.sh",
+    "opencode-ohai-report/tools/ohai-report/ohai_report.py",
+    "opencode-ohai-report/tools/ohai-report/ohai_report/**/*.py",
+    "opencode-ohai-report/tools/ohai-report/schemas",
+    "opencode-ohai-report/tools/ohai-report/examples",
+    "opencode-ohai-report/tools/ohai-report/README.md",
+    "opencode-ohai-report/README.md",
+    "opencode-ohai-report/package.json",
+    "langfuse_hook.py",
+    "codex_langfuse_notify.py",
+    "README.md",
+    "CODEX_LANGFUSE_PLAN.md",
+    "setup-langfuse.bat",
+    "setup-langfuse.sh"
+  ],
+  "scripts": {
+    "start": "node bin/cli.js",
+    "report": "node opencode-ohai-report/bin/cli.js",
+    "report:check": "node opencode-ohai-report/bin/cli.js doctor",
+    "report:test": "cd opencode-ohai-report && npm test",
+    "claude:setup": "node scripts/langfuse-setup.mjs",
+    "claude:check": "node scripts/langfuse-check.mjs",
+    "langfuse:setup": "node scripts/langfuse-setup.mjs",
+    "langfuse:check": "node scripts/langfuse-check.mjs",
+    "opencode:run": "node scripts/opencode-langfuse-run.mjs",
+    "opencode:setup": "node scripts/opencode-langfuse-setup.mjs",
+    "opencode:check": "node scripts/opencode-langfuse-check.mjs",
+    "opencode:langfuse:setup": "node scripts/opencode-langfuse-setup.mjs",
+    "opencode:langfuse:check": "node scripts/opencode-langfuse-check.mjs",
+    "opencode:langfuse:run": "node scripts/opencode-langfuse-run.mjs",
+    "codex:setup": "node scripts/codex-langfuse-setup.mjs",
+    "codex:check": "node scripts/codex-langfuse-check.mjs",
+    "codex:langfuse:setup": "node scripts/codex-langfuse-setup.mjs",
+    "codex:langfuse:check": "node scripts/codex-langfuse-check.mjs"
+  },
+  "dependencies": {}
+}