@roll-agent/octopus-agent 0.1.2 → 0.2.0

package/src/octopus_skill/result_renderer.py

@@ -1,367 +0,0 @@
-from __future__ import annotations
-
-import html
-import json
-import re
-from typing import Any
-
-
-SUPPORTED_RESULT_FORMATS = {"text", "json", "yaml", "md", "markdown", "html"}
-RESULT_ROW_DISPLAY_LIMIT = 500
-
-
-def normalize_result_format(question: str, result_format: str | None = None) -> str:
-    if result_format:
-        normalized = result_format.lower().strip()
-        if normalized not in SUPPORTED_RESULT_FORMATS:
-            raise ValueError(f"Unsupported resultFormat: {result_format}")
-        return "markdown" if normalized == "md" else normalized
-    lowered = question.lower()
-    if "json" in lowered:
-        return "json"
-    if "yaml" in lowered:
-        return "yaml"
-    if "html" in lowered:
-        return "html"
-    if "markdown" in lowered or " md" in lowered or "表格" in question:
-        return "markdown"
-    if _is_detail_table_question(question):
-        return "markdown"
-    if _is_match_effect_report_question(question):
-        return "markdown"
-    return "text"
-
-
-def render_result(question: str, result: dict[str, Any], result_format: str | None = None) -> str:
-    output_format = normalize_result_format(question, result_format)
-    if not result.get("success", True):
-        return _format_failure(output_format)
-    row_count = int(result.get("rowCount", len(result.get("rows", []))))
-    rows = result.get("rows", [])
-    columns = result.get("columns", [])
-    if row_count == 0:
-        return _format_empty(output_format)
-    sample = rows[:RESULT_ROW_DISPLAY_LIMIT] if isinstance(rows, list) else []
-    if output_format == "json":
-        return _render_json(row_count, bool(result.get("limited", False)), sample)
-    if output_format == "yaml":
-        return _render_yaml(question, row_count, bool(result.get("limited", False)), sample)
-    if output_format == "markdown":
-        if _is_match_effect_report_question(question):
-            return _render_match_effect_report(question, row_count, bool(result.get("limited", False)), sample, columns)
-        return _render_markdown(question, row_count, bool(result.get("limited", False)), sample, columns)
-    if output_format == "html":
-        return _render_html(question, row_count, bool(result.get("limited", False)), sample, columns)
-    return _render_text(question, row_count, bool(result.get("limited", False)), sample, columns)
-
-
-def _format_failure(output_format: str) -> str:
-    if output_format == "json":
-        return json.dumps({"success": False, "message": "查询失败。"}, ensure_ascii=False, indent=2) + "\n"
-    if output_format == "yaml":
-        return "success: false\nmessage: 查询失败。\n"
-    if output_format == "markdown":
-        return "查询失败。"
-    if output_format == "html":
-        return "<p>查询失败。</p>"
-    return "查询失败。"
-
-
-def _format_empty(output_format: str) -> str:
-    if output_format == "json":
-        return json.dumps(
-            {"success": True, "rowCount": 0, "rows": [], "message": "没有查询到符合条件的数据。"},
-            ensure_ascii=False,
-            indent=2,
-        ) + "\n"
-    if output_format == "yaml":
-        return "success: true\nrowCount: 0\nrows: []\nmessage: 没有查询到符合条件的数据。\n"
-    if output_format == "markdown":
-        return "返回 0 行。\n\n没有查询到符合条件的数据。"
-    if output_format == "html":
-        return "<p>没有查询到符合条件的数据。</p>"
-    return "没有查询到符合条件的数据。"
-
-
-def _is_match_effect_report_question(question: str) -> bool:
-    return bool(
-        ("匹配效果" in question or "分析报告" in question)
-        and "岗位" in question
-        and any(term in question for term in ("候选人", "报名", "入职", "上岗"))
-    )
-
-
-def _is_detail_table_question(question: str) -> bool:
-    if any(term in question for term in ("明细", "列表", "清单")):
-        return True
-    if "对应" not in question:
-        return False
-    return any(term in question for term in ("项目", "品牌", "门店", "岗位", "城市", "日期", "时间"))
-
-
-def _render_match_effect_report(
-    question: str,
-    row_count: int,
-    limited: bool,
-    rows: list[Any],
-    columns: Any,
-) -> str:
-    table_columns = _column_names(columns, rows)
-    display_count = len(rows)
-    period = _extract_report_period(question)
-    lines = [
-        f"# {period}岗位与候选人匹配效果分析报告",
-        "",
-        "## 完整分析报告",
-        "",
-        f"数据范围：{period}；维度：品牌、项目、城市；口径：入职按上岗结果近似统计。",
-        _display_row_count_line(row_count, display_count),
-        f"limited: {str(limited).lower()}",
-    ]
-    if table_columns:
-        display_columns = ["序号"] + table_columns
-        lines.extend(["", "|" + "|".join(_escape_markdown(column) for column in display_columns) + "|"])
-        lines.append("|" + "|".join("---" for _ in display_columns) + "|")
-        for index, row in enumerate(rows, start=1):
-            values = [str(index)] + [_cell_value(row, column) for column in table_columns]
-            lines.append("|" + "|".join(_escape_markdown(value) for value in values) + "|")
-    else:
-        lines.extend(["", "```json", json.dumps(rows, ensure_ascii=False, indent=2), "```"])
-    lines.extend(["", "## 总结关键发现", ""])
-    findings = _match_effect_findings(rows)
-    lines.extend(findings or ["- 暂未发现明显异常组合。"])
-    return "\n".join(lines)
-
-
-def _extract_report_period(question: str) -> str:
-    relative_month = re.search(r"(今年|去年|前年|明年|后年)\s*(\d{1,2})\s*月", question)
-    if relative_month is not None:
-        return f"{relative_month.group(1)}{int(relative_month.group(2))}月"
-    explicit_month = re.search(r"(20\d{2})\s*年\s*(\d{1,2})\s*月", question)
-    if explicit_month is not None:
-        return f"{explicit_month.group(1)}年{int(explicit_month.group(2))}月"
-    return "本期"
-
-
-def _match_effect_findings(rows: list[Any]) -> list[str]:
-    if not rows:
-        return []
-    buckets = {
-        "报名多但入职少": [],
-        "在招多但报名少": [],
-        "候选人多但岗位少": [],
-    }
-    for row in rows:
-        if not isinstance(row, dict):
-            continue
-        issue = str(row.get("问题类型", ""))
-        label = _dimension_label(row)
-        for bucket in buckets:
-            if bucket in issue:
-                buckets[bucket].append(label)
-    findings: list[str] = []
-    for bucket, labels in buckets.items():
-        if labels:
-            findings.append(f"- {bucket}：{_join_limited(labels)}。")
-    return findings
-
-
-def _dimension_label(row: dict[str, Any]) -> str:
-    parts = [
-        str(row.get("品牌名称") or "未知品牌"),
-        str(row.get("项目名称") or "未知项目"),
-        str(row.get("城市名称") or "未知城市"),
-    ]
-    return " / ".join(parts)
-
-
-def _join_limited(values: list[str], limit: int = 3) -> str:
-    visible = values[:limit]
-    suffix = f"等 {len(values)} 项" if len(values) > limit else ""
-    return "、".join(visible + ([suffix] if suffix else []))
-
-
-def _render_json(row_count: int, limited: bool, rows: list[Any]) -> str:
-    return json.dumps(
-        {
-            "rowCount": row_count,
-            "limited": limited,
-            "rows": rows,
-        },
-        ensure_ascii=False,
-        indent=2,
-    ) + "\n"
-
-
-def _render_yaml(question: str, row_count: int, limited: bool, rows: list[Any]) -> str:
-    lines = [
-        f"rowCount: {row_count}",
-        f"limited: {_yaml_bool(limited)}",
-        "rows:",
-    ]
-    for row in rows:
-        lines.append("  -")
-        if isinstance(row, dict):
-            for key, value in row.items():
-                lines.append(f"    {key}: {json.dumps(value, ensure_ascii=False)}")
-        else:
-            lines.append(f"    value: {json.dumps(row, ensure_ascii=False)}")
-    return "\n".join(lines) + "\n"
-
-
-def _render_markdown(
-    question: str,
-    row_count: int,
-    limited: bool,
-    rows: list[Any],
-    columns: Any,
-) -> str:
-    table_columns = _column_names(columns, rows)
-    lines = [_display_row_count_line(row_count, len(rows)), f"limited: {str(limited).lower()}"]
-    if not table_columns:
-        lines.extend(["", "```json", json.dumps(rows, ensure_ascii=False, indent=2), "```"])
-        return "\n".join(lines)
-    display_columns = ["序号"] + table_columns
-    lines.extend(["", "|" + "|".join(_escape_markdown(column) for column in display_columns) + "|"])
-    lines.append("|" + "|".join("---" for _ in display_columns) + "|")
-    for index, row in enumerate(rows, start=1):
-        values = [str(index)] + [_cell_value(row, column) for column in table_columns]
-        lines.append("|" + "|".join(_escape_markdown(value) for value in values) + "|")
-    return "\n".join(lines)
-
-
-def _render_html(
-    question: str,
-    row_count: int,
-    limited: bool,
-    rows: list[Any],
-    columns: Any,
-) -> str:
-    table_columns = _column_names(columns, rows)
-    parts = [
-        "<section>",
-        f"<p>{html.escape(_display_row_count_line(row_count, len(rows)))} limited: {str(limited).lower()}</p>",
-    ]
-    if table_columns:
-        display_columns = ["序号"] + table_columns
-        parts.append("<table>")
-        parts.append("<thead><tr>" + "".join(f"<th>{html.escape(column)}</th>" for column in display_columns) + "</tr></thead>")
-        parts.append("<tbody>")
-        for index, row in enumerate(rows, start=1):
-            values = [str(index)] + [_cell_value(row, column) for column in table_columns]
-            parts.append("<tr>" + "".join(f"<td>{html.escape(value)}</td>" for value in values) + "</tr>")
-        parts.append("</tbody></table>")
-    else:
-        parts.append(f"<pre>{html.escape(json.dumps(rows, ensure_ascii=False, indent=2))}</pre>")
-    parts.append("</section>")
-    return "".join(parts)
-
-
-def _display_row_count_line(row_count: int, display_count: int) -> str:
-    if row_count == display_count:
-        return f"返回 {row_count} 行。"
-    return f"当前展示 {display_count} 行。"
-
-
-def _render_text(
-    question: str,
-    row_count: int,
-    limited: bool,
-    rows: list[Any],
-    columns: Any,
-) -> str:
-    visible_columns = _text_columns(question, columns, rows)
-    if not visible_columns:
-        return f"查询到 {row_count} 条结果。"
-
-    noun = _result_noun(question)
-    lines = [f"查询到 {row_count} 个{noun}：", ""]
-    include_id = _question_requests_id(question)
-    for index, row in enumerate(rows, start=1):
-        text = _format_text_row(row, visible_columns, include_id)
-        if text:
-            lines.append(f"{index}. {text}")
-    if limited:
-        lines.append("")
-        lines.append("结果较多，已按当前限制返回部分数据。")
-    return "\n".join(lines)
-
-
-def _text_columns(question: str, columns: Any, rows: list[Any]) -> list[str]:
-    names = _column_names(columns, rows)
-    if not names:
-        return []
-    allow_id = _question_requests_id(question)
-    visible = [name for name in names if allow_id or not _is_id_column(name)]
-    name_columns = [name for name in visible if _is_name_column(name)]
-    if allow_id:
-        return visible
-    return name_columns or visible
-
-
-def _format_text_row(row: Any, columns: list[str], include_id: bool) -> str:
-    if not isinstance(row, dict):
-        return str(row)
-    name_column = next((column for column in columns if _is_name_column(column)), None)
-    id_column = next((column for column in columns if _is_id_column(column)), None)
-    name_value = _cell_value(row, name_column) if name_column else ""
-    id_value = _cell_value(row, id_column) if id_column else ""
-    if include_id and name_value and id_value:
-        return f"{name_value}（ID：{id_value}）"
-    values = [_cell_value(row, column) for column in columns]
-    values = [value for value in values if value]
-    return "，".join(values)
-
-
-def _question_requests_id(question: str) -> bool:
-    lowered = question.lower()
-    return "id" in lowered or "编号" in question or "主键" in question
-
-
-def _is_id_column(column: str) -> bool:
-    lowered = column.lower()
-    return lowered == "id" or lowered.endswith("_id") or lowered.endswith(".id")
-
-
-def _is_name_column(column: str) -> bool:
-    lowered = column.lower()
-    return lowered == "name" or lowered.endswith("_name") or lowered.endswith(".name") or "名称" in column
-
-
-def _result_noun(question: str) -> str:
-    if "品牌" in question:
-        return "品牌"
-    if "岗位" in question:
-        return "岗位"
-    if "门店" in question:
-        return "门店"
-    if "项目" in question:
-        return "项目"
-    return "结果"
-
-
-def _column_names(columns: Any, rows: list[Any]) -> list[str]:
-    names: list[str] = []
-    if isinstance(columns, list):
-        for column in columns:
-            if isinstance(column, dict) and column.get("name"):
-                names.append(str(column["name"]))
-            elif isinstance(column, str):
-                names.append(column)
-    if not names and rows and isinstance(rows[0], dict):
-        names = [str(key) for key in rows[0].keys()]
-    return names
-
-
-def _cell_value(row: Any, column: str) -> str:
-    if isinstance(row, dict):
-        return str(row.get(column, ""))
-    return str(row)
-
-
-def _escape_markdown(value: str) -> str:
-    return value.replace("\\", "\\\\").replace("|", "\\|").replace("\n", " ")
-
-
-def _yaml_bool(value: bool) -> str:
-    return "true" if value else "false"

package/src/octopus_skill/schema_cache.py

@@ -1,49 +0,0 @@
-from __future__ import annotations
-
-import json
-import time
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-
-class SchemaCacheError(RuntimeError):
-    """Raised when the persisted schema cache cannot be used."""
-
-
-@dataclass
-class SchemaCache:
-    path: Path
-
-    def load(self) -> dict[str, Any] | None:
-        if not self.path.exists():
-            return None
-        try:
-            data = json.loads(self.path.read_text(encoding="utf-8"))
-        except json.JSONDecodeError as exc:
-            raise SchemaCacheError(f"Invalid schema cache JSON: {self.path}") from exc
-        if not isinstance(data, dict):
-            raise SchemaCacheError(f"Schema cache must be a JSON object: {self.path}")
-        return data
-
-    def save(self, schema: dict[str, Any]) -> None:
-        if not isinstance(schema, dict):
-            raise TypeError("schema must be a dict")
-        self.path.parent.mkdir(parents=True, exist_ok=True)
-        self.path.write_text(
-            json.dumps(schema, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
-            encoding="utf-8",
-        )
-
-    def version(self) -> str | None:
-        schema = self.load()
-        if schema is None:
-            return None
-        version = schema.get("schemaVersion")
-        return str(version) if version is not None else None
-
-    def is_fresh(self, max_age_minutes: int) -> bool:
-        if max_age_minutes <= 0 or not self.path.exists():
-            return False
-        age_seconds = time.time() - self.path.stat().st_mtime
-        return age_seconds <= max_age_minutes * 60