Byted Ark Evolve

                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for describing the origin of the Work and
      reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Support. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or support.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright 2026 Beijing Volcano Engine Technology Co., Ltd.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

{
  "updated_at": "2026-03-12",
  "date_range": {
    "start": "2026-03-01",
    "end": "2026-03-12"
  },
  "stats": {
    "evolution_events": 9,
    "total_signals": 66,
    "unprocessed": 6
  },
  "gate": {
    "should_evolve": true,
    "message": "6 条未处理反馈（含 1 条高优先级），建议运行 /evolve"
  },
  "timeline": [
    {
      "date": "2026-03-12",
      "description": "Agent 进化：6 信号 → 2 mutation（AGENTS.md + SOUL.md）"
    },
    {
      "date": "2026-03-09",
      "description": "Agent 进化：10 个 mutation，覆盖 6 session"
    },
    {
      "date": "2026-03-08",
      "description": "GitHub Trend Observer v0.1.0 → v0.2.0"
    },
    {
      "date": "2026-03-05",
      "description": "Agent 进化：3 项 Judgment 进化"
    },
    {
      "date": "2026-03-04",
      "description": "Agent 进化：6 项进化"
    },
    {
      "date": "2026-03-01",
      "description": "xhs v0.1→v0.2 + Evolution Coach v0.2.0"
    }
  ],
  "verification": {
    "needs_attention": [
      {
        "name": "先建任务再执行",
        "layer": "protocol",
        "status": "regression",
        "note": "03-05 通过 → 03-06/07 再次违反"
      },
      {
        "name": "信号收集 Hook v2",
        "layer": "capability",
        "status": "partial",
        "note": "手动运作；Hook 未部署"
      }
    ],
    "pending": [
      {"name": "先调研再提问", "status": "pending", "date": "03-12"},
      {"name": "记忆访问边界", "status": "pending", "date": "03-12"},
      {"name": "反 AI 味检查单", "status": "pending", "date": "03-09"},
      {"name": "验证标准升级", "status": "pending", "date": "03-09"},
      {"name": "Session 开场任务检查", "status": "pending", "date": "03-09"}
    ],
    "verified_observed": [
      {"name": "Definition of Done", "status": "observed"},
      {"name": "流程遵从规则", "status": "observed"},
      {"name": "方案 trade-off 透明化", "status": "observed"},
      {"name": "Session 结束检查单", "status": "observed"}
    ]
  },
  "signals": {
    "sparkline": [
      {"date": "03-01", "count": 8},
      {"date": "03-02", "count": 15},
      {"date": "03-03", "count": 8},
      {"date": "03-04", "count": 19},
      {"date": "03-05", "count": 9},
      {"date": "03-06", "count": 6},
      {"date": "03-07", "count": 3},
      {"date": "03-09", "count": 6},
      {"date": "03-12", "count": 6}
    ],
    "recent": [
      {"date": "03-12", "count": 6, "source": "evolution skill 测试"},
      {"date": "03-09", "count": 6, "source": "multi-agent 系统设计"},
      {"date": "03-04", "count": 19, "source": "2 sessions"}
    ],
    "older_summary": "03-01: 8 · 03-02: ~15 · 03-03: ~8 · 03-05: 9 · 03-06: 6 · 03-07: 3"
  },
  "capabilities": {
    "soul_principles": ["先对齐再执行", "不经确认不改动", "行动范围匹配", "Session 结束检查单"],
    "strengths": ["搜索分析", "从零搭建基础设施"],
    "weaknesses": ["多系统联调", "中文 prose 写作"],
    "moderate": ["流程遵从", "基础设施诊断"]
  },
  "report_archive": [
    {"date": "2026-03-12", "summary": "2 mutation · 6 信号"},
    {"date": "2026-03-09", "summary": "10 mutation · 15 信号 · 6 sessions"},
    {"date": "2026-03-05", "summary": "3 mutation · 9 信号"}
  ],
  "cost_total": "~$39"
}

{
  "date": "2026-03-12",
  "summary": "本次处理了 6 条反馈，产生 2 条变更——主要改进了 Agent 的执行流程，让它在提问前先做调研、不主动调取用户记忆。",
  "stats": {
    "signals": 6,
    "changes": 2,
    "rejected": 0
  },
  "changes": [
    {
      "file": "AGENTS.md",
      "description": "新增「先调研再提问」规则",
      "reason": "你纠正了直接提问的行为——\"请你下次问我之前先搜索一下\"",
      "status": "applied",
      "before": "（无相关规则）",
      "after": "## 调研优先原则\n收到创建类需求时，先搜索行业通用做法，再结合调研结果提问。"
    },
    {
      "file": "SOUL.md",
      "description": "新增「记忆访问边界」规则",
      "reason": "你明确要求\"如果我不发起请求，不要调取我的记忆\"（高优先级）",
      "status": "applied",
      "before": "（无相关规则）",
      "after": "## 记忆访问边界\n用户画像/记忆仅在用户主动请求时调取，Agent 不得主动引用。"
    }
  ],
  "signals_by_layer": {
    "protocol": 4,
    "capability": 2
  },
  "high_severity_signals": [
    {
      "text": "如果我不发起请求，不要调取我的记忆"
    }
  ],
  "all_signals": [
    {"text": "请你下次问我之前先搜索一下", "type": "correction"},
    {"text": "如果我不发起请求，不要调取我的记忆", "type": "correction"},
    {"text": "只要中文，英文不要了", "type": "correction"},
    {"text": "进化报告应该自动产出", "type": "suggestion"},
    {"text": "变更前后标明文件名", "type": "suggestion"},
    {"text": "术语要加灰色解释", "type": "suggestion"}
  ],
  "next_steps": [
    "下次创建类任务时 → 观察是否先调研再提问",
    "下次分析类任务时 → 观察是否主动引用记忆"
  ],
  "trajectory": {
    "golden": 1,
    "correction": 2
  },
  "saturation": {
    "is_saturated": false,
    "added": 2,
    "modified": 0
  },
  "cost": {
    "analysis_cost": 0.2,
    "roi_percent": 25
  },
  "user_direct_changes": 1
}

# Copyright 2026 Beijing Volcano Engine Technology Co., Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Resolve the runtime workspace root for arkclaw / openclaw / other *claw* runtimes.

Resolution order:
  1. CLAW_WORKSPACE env var (explicit override)
  2. Scan ~/ for any ~/.{name}/workspace where 'claw' is in {name};
     prefer dirs that already contain evolution-data/, then prefer
     .arkclaw > .openclaw > others (alpha order).
  3. Fallback: ~/.arkclaw/workspace (production default for new installs).
"""

import os

ENV_VAR = "CLAW_WORKSPACE"
_FALLBACK = "~/.arkclaw/workspace"


def _scan_home():
    home = os.path.expanduser("~")
    if not os.path.isdir(home):
        return None
    try:
        entries = os.listdir(home)
    except OSError:
        return None
    found = []
    for name in entries:
        if not (name.startswith(".") and "claw" in name.lower()):
            continue
        ws = os.path.join(home, name, "workspace")
        if not os.path.isdir(ws):
            continue
        has_data = os.path.isdir(os.path.join(ws, "evolution-data"))
        found.append((has_data, name, ws))
    if not found:
        return None

    def sort_key(item):
        has_data, name, _ws = item
        priority = 0 if name == ".arkclaw" else (1 if name == ".openclaw" else 2)
        return (0 if has_data else 1, priority, name)

    found.sort(key=sort_key)
    return found[0][2]


def resolve_workspace_root():
    """Return absolute path to the runtime workspace root."""
    override = os.environ.get(ENV_VAR)
    if override:
        return os.path.expanduser(override)
    found = _scan_home()
    if found:
        return found
    return os.path.expanduser(_FALLBACK)


def resolve_runtime_home():
    """Return parent of the workspace (e.g. ~/.arkclaw)."""
    return os.path.dirname(resolve_workspace_root())


def claw_exclude_dirs():
    """All ~/.X dirnames where 'claw' is in name (used for scan-exclude)."""
    home = os.path.expanduser("~")
    out = set()
    try:
        for name in os.listdir(home):
            if name.startswith(".") and "claw" in name.lower():
                out.add(name)
    except OSError:
        pass
    out.update({".arkclaw", ".openclaw"})
    return out


if __name__ == "__main__":
    import json

    print(
        json.dumps(
            {
                "workspace_root": resolve_workspace_root(),
                "runtime_home": resolve_runtime_home(),
                "claw_exclude_dirs": sorted(claw_exclude_dirs()),
                "env_var": ENV_VAR,
            },
            indent=2,
        )
    )

#!/usr/bin/env python3
# Copyright 2026 Beijing Volcano Engine Technology Co., Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Apply an accepted proposal group, commit snapshot, and write back result."""

import argparse
import json
import os
import sqlite3
import subprocess
import sys
from pathlib import Path

from _workspace import resolve_workspace_root

_WS = resolve_workspace_root()
DEFAULT_DB_PATH = os.path.join(_WS, "evolution-data/evolution.db")
WORKSPACE_ROOT = _WS
SNAPSHOT_SCRIPT = str(Path(__file__).with_name("snapshot.py"))
DASHBOARD_SCRIPT = str(Path(__file__).with_name("dashboard-render.py"))

for stream in [sys.stdout, sys.stderr, sys.stdin]:
    if stream and hasattr(stream, "reconfigure") and stream.encoding != "utf-8":
        stream.reconfigure(encoding="utf-8")


def conn(db_path):
    c = sqlite3.connect(db_path)
    c.row_factory = sqlite3.Row
    return c


def ensure_git_repo(workspace_root):
    git_dir = Path(workspace_root) / ".git"
    if git_dir.exists():
        return True
    subprocess.run(
        ["git", "init"], cwd=workspace_root, check=True, capture_output=True, text=True
    )
    subprocess.run(
        ["git", "config", "user.email", "byted-ark-evolve@local"],
        cwd=workspace_root,
        check=True,
    )
    subprocess.run(
        ["git", "config", "user.name", "Evolution Skill"],
        cwd=workspace_root,
        check=True,
    )
    return True


def group_rows(c, group_id):
    cur = c.cursor()
    cur.execute(
        "SELECT * FROM mutations WHERE proposal_group_id = ? ORDER BY id", (group_id,)
    )
    return [dict(r) for r in cur.fetchall()]


def apply_mutation(workspace_root, m):
    target = Path(workspace_root) / m["target_file"]
    target.parent.mkdir(parents=True, exist_ok=True)
    before = target.read_text(encoding="utf-8") if target.exists() else ""
    mutation_type = m.get("mutation_type")
    if mutation_type == "add":
        new_text = before
        if before and not before.endswith("\n"):
            new_text += "\n"
        new_text += m.get("after_text") or ""
    elif mutation_type == "modify":
        before_text = m.get("before_text") or ""
        after_text = m.get("after_text") or ""
        if before_text and before_text in before:
            new_text = before.replace(before_text, after_text, 1)
        else:
            raise RuntimeError(f"before_text not found in {m['target_file']}")
    elif mutation_type == "remove":
        before_text = m.get("before_text") or ""
        if before_text and before_text in before:
            new_text = before.replace(before_text, "", 1)
        else:
            raise RuntimeError(f"before_text not found in {m['target_file']}")
    else:
        raise RuntimeError(f"unknown mutation_type: {mutation_type}")
    target.write_text(new_text, encoding="utf-8")
    return str(target)


def check_positive_conflict(c, target_file):
    """检查待修改的文件是否有被 positive 信号验证过的行为。"""
    cur = c.cursor()
    cur.execute(
        """
        SELECT id, description FROM mutations
        WHERE target_file = ? AND status = 'verified' AND source = 'positive-anchor'
    """,
        (target_file,),
    )
    conflicts = [dict(r) for r in cur.fetchall()]
    if conflicts:
        return {
            "has_conflict": True,
            "verified_behaviors": conflicts,
            "warning": f"target {target_file} has {len(conflicts)} verified positive behavior(s), modification may cause regression",
        }
    return {"has_conflict": False}


def commit_group(workspace_root, group_id, files):
    ensure_git_repo(workspace_root)
    subprocess.run(["git", "add", "--", *files], cwd=workspace_root, check=True)
    msg = f"evolution: apply proposal {group_id}"
    subprocess.run(
        ["git", "commit", "-m", msg],
        cwd=workspace_root,
        check=True,
        capture_output=True,
        text=True,
    )
    res = subprocess.run(
        ["git", "rev-parse", "HEAD"],
        cwd=workspace_root,
        check=True,
        capture_output=True,
        text=True,
    )
    return res.stdout.strip()


def save_snapshot(db_path):
    subprocess.run(
        [sys.executable, SNAPSHOT_SCRIPT, "save", "--db", db_path],
        check=False,
        capture_output=True,
        text=True,
    )


def render_dashboard(db_path, data_dir):
    try:
        subprocess.run(
            [
                sys.executable,
                DASHBOARD_SCRIPT,
                "--db",
                str(db_path),
                "--data-dir",
                str(data_dir),
            ],
            check=True,
            capture_output=True,
            text=True,
        )
    except Exception as exc:
        print(f"[warn] dashboard render failed: {exc}", file=sys.stderr)


def main():
    parser = argparse.ArgumentParser(description="Apply accepted proposal group")
    parser.add_argument("--group", required=True)
    parser.add_argument("--db", default=DEFAULT_DB_PATH)
    parser.add_argument("--workspace-root", default=WORKSPACE_ROOT)
    args = parser.parse_args()

    c = conn(args.db)
    cur = c.cursor()
    rows = group_rows(c, args.group)
    if not rows:
        raise SystemExit("proposal group not found")
    if any(
        r.get("proposal_status") not in ("accepted", "presented", "pending")
        for r in rows
    ):
        raise SystemExit("proposal group has invalid state for apply")

    applied_ids = []
    failed = []
    changed_files = []
    positive_warnings = []
    for row in rows:
        try:
            conflict = check_positive_conflict(c, row["target_file"])
            if conflict.get("has_conflict"):
                positive_warnings.append(
                    {
                        "mutation_id": row["id"],
                        "target_file": row["target_file"],
                        "warning": conflict["warning"],
                    }
                )
            path = apply_mutation(args.workspace_root, row)
            changed_files.append(os.path.relpath(path, args.workspace_root))
            cur.execute(
                "UPDATE mutations SET status='applied', proposal_status='accepted', applied_at=datetime('now'), decision_at=COALESCE(decision_at, datetime('now')) WHERE id = ?",
                (row["id"],),
            )
            applied_ids.append(row["id"])
        except Exception as exc:
            failed.append({"id": row["id"], "error": str(exc)})
    commit_hash = None
    result_status = "failed"
    if applied_ids:
        commit_hash = commit_group(args.workspace_root, args.group, changed_files)
        save_snapshot(args.db)
        result_status = "partial" if failed else "applied"
    review_id = rows[0].get("review_id")
    if review_id:
        payload = {
            "proposal_group_id": args.group,
            "result_status": result_status,
            "commit_hash": commit_hash,
            "applied_mutation_ids": applied_ids,
            "failed_mutation_ids": [x["id"] for x in failed],
            "changed_files": changed_files,
        }
        cur.execute(
            "UPDATE reviews SET pending_summary_json = ?, worker_finished_at = datetime('now') WHERE review_id = ?",
            (json.dumps(payload, ensure_ascii=False), review_id),
        )
    c.commit()
    c.close()
    # Always render dashboard after applying
    data_dir = str(Path(args.db).parent)
    render_dashboard(args.db, data_dir)
    print(
        json.dumps(
            {
                "status": result_status,
                "commit_hash": commit_hash,
                "applied_mutation_ids": applied_ids,
                "failed": failed,
                "changed_files": changed_files,
                "positive_warnings": positive_warnings,
            },
            ensure_ascii=False,
            indent=2,
        )
    )


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# ruff: noqa: E402
# Copyright 2026 Beijing Volcano Engine Technology Co., Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
Render evolution dashboard from SQLite DB + bundled gene library.

Reads data from DB, injects JSON into the frozen HTML template.
The template handles all rendering via JS — this script never touches HTML/CSS.

Usage:
  python dashboard-render.py --db evolution.db --output dashboard.html
  python dashboard-render.py --db evolution.db --data-dir evolution-data/
"""

import argparse
import json
import sqlite3
import sys
from datetime import datetime, timedelta, timezone
from pathlib import Path

for stream in [sys.stdout, sys.stderr, sys.stdin]:
    if stream and hasattr(stream, "reconfigure") and stream.encoding != "utf-8":
        stream.reconfigure(encoding="utf-8")

TEMPLATE_PATH = Path(__file__).with_name("dashboard-template.html")
from _workspace import resolve_workspace_root

_WS = Path(resolve_workspace_root())
DEFAULT_DB = _WS / "evolution-data/evolution.db"
DEFAULT_DATA_DIR = _WS / "evolution-data"


def conn(db_path):
    c = sqlite3.connect(str(db_path))
    c.row_factory = sqlite3.Row
    return c


def fmt_date(dt_str):
    """Convert '2026-03-22 10:15:00' to '3/22'."""
    if not dt_str:
        return ""
    try:
        dt = datetime.fromisoformat(dt_str.replace("Z", "+00:00"))
        return f"{dt.month}/{dt.day}"
    except Exception:
        return dt_str[:10] if len(dt_str) >= 10 else dt_str


def fmt_date_cn(dt_str):
    """Convert to '3月22日 10:15' format."""
    if not dt_str:
        return ""
    try:
        dt = datetime.fromisoformat(dt_str.replace("Z", "+00:00"))
        return f"{dt.month}月{dt.day}日 {dt.hour:02d}:{dt.minute:02d}"
    except Exception:
        return dt_str


def split_gene_ids(gene_id_str):
    """Split comma-separated gene_id string into individual IDs."""
    if not gene_id_str:
        return []
    return [gid.strip() for gid in gene_id_str.split(",") if gid.strip()]


def week_label(dt_str):
    """Convert date to 'M/D' week label."""
    try:
        dt = datetime.fromisoformat(dt_str.replace("Z", "+00:00"))
        # Monday of that week
        monday = dt - timedelta(days=dt.weekday())
        return f"{monday.month}/{monday.day}"
    except Exception:
        return ""


def build_overview(c):
    """Build overview tab data from DB."""
    cur = c.cursor()

    # Basic counts
    cur.execute(
        "SELECT COUNT(DISTINCT session_id) FROM signals WHERE session_id IS NOT NULL"
    )
    session_counts = cur.fetchone()[0] or 0

    cur.execute("SELECT COUNT(*) FROM signals")
    signals_total = cur.fetchone()[0] or 0

    cur.execute(
        "SELECT COUNT(*) FROM signals WHERE created_at >= date('now', '-7 days')"
    )
    signals_week = cur.fetchone()[0] or 0

    cur.execute("SELECT COUNT(*) FROM reviews WHERE status = 'completed'")
    evo_runs = cur.fetchone()[0] or 0

    cur.execute("SELECT MAX(created_at) FROM reviews WHERE status = 'completed'")
    last_evo_row = cur.fetchone()
    last_evo = (
        fmt_date_cn(last_evo_row[0]) if last_evo_row and last_evo_row[0] else "无"
    )

    cur.execute("SELECT COUNT(*) FROM mutations WHERE status = 'applied'")
    applied = cur.fetchone()[0] or 0

    cur.execute(
        "SELECT COUNT(*) FROM mutations WHERE status IN ('proposed', 'approved', 'applied', 'verified')"
    )
    total_proposed = cur.fetchone()[0] or 1
    hit_rate = round(applied / total_proposed * 100) if total_proposed > 0 else 0

    cur.execute("SELECT COUNT(DISTINCT gene_id) FROM gene_matches")
    genes_matched = cur.fetchone()[0] or 0

    cur.execute("SELECT COUNT(*) FROM mutations WHERE status = 'verified'")
    verified = cur.fetchone()[0] or 0

    verify_rate = round(verified / applied * 100) if applied > 0 else 0

    cards = [
        {
            "label": "累计会话数",
            "value": session_counts,
            "delta": f"+{signals_week} 本周反馈",
            "delta_up": signals_week > 0,
        },
        {
            "label": "收集反馈",
            "value": signals_total,
            "cls": "accent",
            "delta": f"+{signals_week} 本周",
            "delta_up": signals_week > 0,
        },
        {"label": "进化执行", "value": evo_runs, "delta": f"上次 {last_evo}"},
        {
            "label": "已应用改动",
            "value": applied,
            "cls": "accent",
            "delta": f"命中率 {hit_rate}%",
            "delta_up": True,
        },
        {"label": "关联基因", "value": genes_matched},
        {
            "label": "验证通过",
            "value": verified,
            "cls": "accent",
            "delta": f"通过率 {verify_rate}%",
            "delta_up": verify_rate > 0,
        },
    ]

    # Trend: signals and mutations per week (last 8 weeks)
    trend = []
    for i in range(7, -1, -1):
        now_utc = datetime.now(timezone.utc)
        week_start = (now_utc - timedelta(weeks=i)).strftime("%Y-%m-%d")
        week_end = (
            (now_utc - timedelta(weeks=i - 1)).strftime("%Y-%m-%d")
            if i > 0
            else (now_utc + timedelta(days=1)).strftime("%Y-%m-%d")
        )
        cur.execute(
            "SELECT COUNT(*) FROM signals WHERE created_at >= ? AND created_at < ?",
            (week_start, week_end),
        )
        sig_count = cur.fetchone()[0] or 0
        cur.execute(
            "SELECT COUNT(*) FROM mutations WHERE created_at >= ? AND created_at < ?",
            (week_start, week_end),
        )
        mut_count = cur.fetchone()[0] or 0
        dt = datetime.fromisoformat(week_start)
        trend.append(
            {
                "label": f"{dt.month}/{dt.day}",
                "signals": sig_count,
                "mutations": mut_count,
            }
        )

    # Verified items
    cur.execute(
        "SELECT target_file, description FROM mutations WHERE status = 'verified' ORDER BY applied_at DESC LIMIT 20"
    )
    verified_items = [
        {"file": r["target_file"], "desc": r["description"] or ""}
        for r in cur.fetchall()
    ]

    # Pending items
    cur.execute(
        "SELECT target_file, description FROM mutations WHERE status IN ('applied', 'proposed', 'approved') AND status != 'verified' ORDER BY created_at DESC LIMIT 20"
    )
    pending_items = [
        {"file": r["target_file"], "desc": r["description"] or ""}
        for r in cur.fetchall()
    ]

    # Layer distribution
    layers = {"identity": 0, "context": 0, "protocol": 0, "capability": 0, "runtime": 0}
    cur.execute(
        "SELECT layer, COUNT(*) as cnt FROM signals WHERE layer IS NOT NULL GROUP BY layer"
    )
    for r in cur.fetchall():
        if r["layer"] in layers:
            layers[r["layer"]] = r["cnt"]

    return {
        "cards": cards,
        "trend": trend,
        "verified_items": verified_items,
        "pending_items": pending_items,
        "layers": layers,
    }


def build_reviews(c):
    """Build activity tab data — one entry per completed review."""
    cur = c.cursor()
    cur.execute(
        "SELECT * FROM reviews WHERE status = 'completed' ORDER BY created_at DESC LIMIT 20"
    )
    reviews_rows = [dict(r) for r in cur.fetchall()]

    reviews = []
    for rev in reviews_rows:
        review_id = rev["review_id"]
        date_label = fmt_date(rev["created_at"])

        # Get mutations for this review
        cur.execute(
            "SELECT * FROM mutations WHERE review_id = ? ORDER BY id", (review_id,)
        )
        mutations_rows = [dict(r) for r in cur.fetchall()]

        # Get signals linked to these mutations
        signal_ids = set()
        for m in mutations_rows:
            try:
                sids = json.loads(m.get("signal_ids") or "[]")
                signal_ids.update(sids)
            except Exception:
                pass

        signals = []
        if signal_ids:
            placeholders = ",".join("?" for _ in signal_ids)
            cur.execute(
                f"SELECT * FROM signals WHERE id IN ({placeholders}) ORDER BY id",
                list(signal_ids),
            )
            for s in cur.fetchall():
                meta_parts = []
                if s["layer"]:
                    meta_parts.append(s["layer"].capitalize())
                sev_cn = {"high": "高", "medium": "中", "low": "低"}.get(
                    s["severity"], ""
                )
                if sev_cn:
                    meta_parts.append(sev_cn)
                signals.append(
                    {
                        "type": s["type"],
                        "text": s["raw_text"],
                        "meta": " \u00b7 ".join(meta_parts),
                    }
                )

        # Build mutations list
        mutations = []
        applied_count = 0
        rejected_count = 0
        genes_linked = set()
        for m in mutations_rows:
            status = m.get("status", "proposed")
            if status in ("applied", "verified"):
                applied_count += 1
            if m.get("proposal_status") == "rejected" or status == "rejected":
                status = "rejected"
                rejected_count += 1
            if m.get("gene_id"):
                for _gid in split_gene_ids(m["gene_id"]):
                    genes_linked.add(_gid)

            diff_lines = []
            if m.get("after_text"):
                for line in m["after_text"].split("\n"):
                    if line.strip():
                        diff_lines.append(f"+ {line}")
            if m.get("before_text") and m.get("mutation_type") in ("modify", "remove"):
                for line in m["before_text"].split("\n"):
                    if line.strip():
                        diff_lines.insert(0, f"- {line}")

            mutations.append(
                {
                    "target_file": m["target_file"],
                    "status": status,
                    "description": m.get("description") or "",
                    "reason": m.get("gene_reason") or "",
                    "diff_lines": diff_lines,
                    "gene_id": m.get("gene_id") or "",
                    "gene_name": "",  # filled later from gene cache
                }
            )

        # Summary
        total_signals = len(signals)
        total_mutations = len(mutations)
        stats = [
            {"value": total_signals, "label": "反馈处理"},
            {"value": total_mutations, "label": "提出改动"},
            {"value": applied_count, "label": "已应用"},
        ]
        if rejected_count:
            stats.append({"value": rejected_count, "label": "被拒绝"})
        if genes_linked:
            stats.append({"value": len(genes_linked), "label": "关联基因"})

        summary_parts = [
            f"处理了 <strong>{total_signals} 条反馈</strong>，产生 <strong>{total_mutations} 条改动</strong>"
        ]
        if applied_count and rejected_count:
            summary_parts.append(
                f"其中 {applied_count} 条已应用、{rejected_count} 条被拒绝。"
            )
        elif applied_count:
            summary_parts.append("全部已应用。")
        elif total_mutations:
            summary_parts.append("等待确认。")

        reviews.append(
            {
                "review_id": review_id,
                "date_label": date_label,
                "summary_html": "，".join(summary_parts),
                "stats": stats,
                "signals": signals,
                "mutations": mutations,
            }
        )

    return reviews


def build_genes(c, data_dir):
    """Build genes tab data from gene_matches + bundled gene-library.json."""
    cur = c.cursor()

    # Load static gene library (bundled with the skill release)
    gene_cache = {}
    library_path = (
        Path(__file__).resolve().parent.parent / "references" / "gene-library.json"
    )
    if library_path.exists():
        try:
            raw = json.loads(library_path.read_text(encoding="utf-8"))
            genes_list = raw if isinstance(raw, list) else raw.get("genes", [])
            for g in genes_list:
                gid = g.get("id") or g.get("gene_id") or ""
                gene_cache[gid] = g
        except Exception:
            pass

    # Get hit counts per gene
    cur.execute("""
        SELECT gene_id, COUNT(*) as hits, MAX(created_at) as last_used
        FROM gene_matches
        WHERE gene_id IS NOT NULL AND gene_id != ''
        GROUP BY gene_id
        ORDER BY hits DESC
    """)
    hit_data = {
        r["gene_id"]: {"hits": r["hits"], "last_used": fmt_date(r["last_used"])}
        for r in cur.fetchall()
    }

    # Get mutations per gene
    cur.execute("""
        SELECT gene_id, target_file, description, status, created_at
        FROM mutations
        WHERE gene_id IS NOT NULL AND gene_id != ''
        ORDER BY created_at DESC
    """)
    gene_mutations = {}
    for r in cur.fetchall():
        # gene_id may be comma-separated (e.g. "PG-D1-001,PG-C3-001")
        for gid in split_gene_ids(r["gene_id"]):
            if gid not in gene_mutations:
                gene_mutations[gid] = []
            gene_mutations[gid].append(
                {
                    "file": r["target_file"],
                    "desc": r["description"] or "",
                    "date": fmt_date(r["created_at"]),
                    "status": r["status"] or "proposed",
                }
            )

    # Merge all gene IDs
    all_gene_ids = set(hit_data.keys()) | set(gene_cache.keys())

    items = []
    for gid in sorted(all_gene_ids):
        cache = gene_cache.get(gid, {})
        hits_info = hit_data.get(gid, {"hits": 0, "last_used": ""})
        items.append(
            {
                "id": gid,
                "name": cache.get("name")
                or cache.get("gene_name")
                or cache.get("summary", "").split("：")[0][:10]
                or gid,
                "summary": cache.get("summary")
                or cache.get("action", {}).get("action_description")
                or cache.get("description")
                or "",
                "rule_text": cache.get("rule_text")
                or cache.get("action", {}).get("action_template")
                or cache.get("pattern_key")
                or "",
                "fitness": cache.get("fitness")
                or cache.get("fitnessScore")
                or cache.get("metadata", {}).get("fitness_score")
                or None,
                "layer": cache.get("layer") or "",
                "mutation_space": cache.get("mutation_space")
                or cache.get("mutationSpace")
                or "",
                "gene_status": cache.get("status")
                or ("active" if hits_info["hits"] > 0 else "unused"),
                "hits": hits_info["hits"],
                "last_used": hits_info["last_used"],
                "mutations": gene_mutations.get(gid, []),
            }
        )

    # Sort: hits > 0 first (desc), then hits == 0
    items.sort(key=lambda x: (-x["hits"], x["id"]))

    matched = sum(1 for i in items if i["hits"] > 0)
    mutations_linked = sum(len(i["mutations"]) for i in items)
    total = len(items)

    return {
        "total": total,
        "matched": matched,
        "mutations_linked": mutations_linked,
        "unused": total - matched,
        "items": items,
    }


def enrich_gene_names(reviews, genes_data):
    """Fill gene_name in review mutations from genes data."""
    gene_names = {g["id"]: g["name"] for g in genes_data.get("items", [])}
    for review in reviews:
        for m in review.get("mutations", []):
            if m.get("gene_id") and not m.get("gene_name"):
                # gene_id may be comma-separated
                ids = split_gene_ids(m["gene_id"])
                names = [gene_names.get(gid, gid) for gid in ids]
                m["gene_name"] = ", ".join(n for n in names if n)


def build_dashboard_data(db_path, data_dir):
    """Build complete dashboard JSON."""
    c = conn(db_path)
    try:
        overview = build_overview(c)
        reviews = build_reviews(c)
        genes = build_genes(c, data_dir)
        enrich_gene_names(reviews, genes)
    finally:
        c.close()

    now_utc = datetime.now(timezone.utc)
    return {
        "generated_at": f"{now_utc.month}月{now_utc.day}日 {now_utc.hour:02d}:{now_utc.minute:02d} UTC",
        "overview": overview,
        "reviews": reviews,
        "genes": genes,
    }


def render(db_path, data_dir, output_path, template_path=None):
    """Main render: DB → JSON → inject into template → write HTML."""
    tpl = Path(template_path) if template_path else TEMPLATE_PATH
    if not tpl.exists():
        print(f"ERROR: template not found: {tpl}", file=sys.stderr)
        sys.exit(1)

    template = tpl.read_text(encoding="utf-8")
    data = build_dashboard_data(db_path, data_dir)
    data_json = json.dumps(data, ensure_ascii=False, indent=None)

    html = template.replace("__DASHBOARD_DATA__", data_json, 1)

    out = Path(output_path)
    out.parent.mkdir(parents=True, exist_ok=True)
    out.write_text(html, encoding="utf-8")
    return str(out)


def main():
    parser = argparse.ArgumentParser(description="Render evolution dashboard from DB")
    parser.add_argument("--db", default=str(DEFAULT_DB), help="Path to evolution.db")
    parser.add_argument(
        "--data-dir",
        default=str(DEFAULT_DATA_DIR),
        help="Path to evolution-data directory",
    )
    parser.add_argument(
        "--output",
        default=None,
        help="Output HTML path (default: <data-dir>/dashboard.html)",
    )
    parser.add_argument(
        "--template", default=None, help="Path to dashboard-template.html"
    )
    args = parser.parse_args()

    db_path = Path(args.db)
    data_dir = Path(args.data_dir)
    output = args.output or str(data_dir / "dashboard.html")

    if not db_path.exists():
        print(
            json.dumps(
                {"status": "error", "reason": f"DB not found: {db_path}"},
                ensure_ascii=False,
            )
        )
        sys.exit(1)

    result_path = render(db_path, data_dir, output, args.template)
    print(json.dumps({"status": "ok", "path": result_path}, ensure_ascii=False))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# Copyright 2026 Beijing Volcano Engine Technology Co., Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Initialize the evolution SQLite database."""

import sqlite3
import os
import sys
import argparse

from _workspace import resolve_workspace_root

DEFAULT_DB_DIR = os.path.join(resolve_workspace_root(), "evolution-data")
# Windows UTF-8 fix
for stream in [sys.stdout, sys.stderr, sys.stdin]:
    if stream and hasattr(stream, "reconfigure") and stream.encoding != "utf-8":
        stream.reconfigure(encoding="utf-8")

DEFAULT_DB_PATH = os.path.join(DEFAULT_DB_DIR, "evolution.db")


def get_db_path():
    parser = argparse.ArgumentParser(description="Initialize evolution SQLite database")
    parser.add_argument(
        "db_path_positional", nargs="?", default=None, help="Legacy positional DB path"
    )
    parser.add_argument("--db", default=None, help="Path to evolution.db")
    args = parser.parse_args()
    return args.db or args.db_path_positional or DEFAULT_DB_PATH


def init_db(db_path):
    os.makedirs(os.path.dirname(db_path), exist_ok=True)
    base_dir = os.path.dirname(db_path)
    os.makedirs(os.path.join(base_dir, "trajectories", "golden"), exist_ok=True)
    os.makedirs(os.path.join(base_dir, "trajectories", "corrections"), exist_ok=True)
    os.makedirs(os.path.join(base_dir, "reports"), exist_ok=True)
    os.makedirs(os.path.join(base_dir, "tmp"), exist_ok=True)

    conn = sqlite3.connect(db_path)
    cur = conn.cursor()

    cur.executescript("""
        CREATE TABLE IF NOT EXISTS signals (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            session_id TEXT,
            type TEXT NOT NULL CHECK(type IN ('correction','negative','positive','suggestion','preference','clarification')),
            layer TEXT CHECK(layer IN ('identity','context','protocol','capability','runtime')),
            severity TEXT DEFAULT 'medium' CHECK(severity IN ('low','medium','high')),
            raw_text TEXT NOT NULL,
            context TEXT,
            processed INTEGER DEFAULT 0,
            created_at TEXT DEFAULT (datetime('now'))
        );

        CREATE TABLE IF NOT EXISTS trajectories (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            type TEXT NOT NULL CHECK(type IN ('golden','correction','candidate')),
            task_type TEXT,
            tags TEXT,
            key_steps TEXT,
            error_approach TEXT,
            correct_approach TEXT,
            root_cause TEXT,
            file_path TEXT,
            session_id TEXT,
            verified INTEGER DEFAULT 0,
            verify_count INTEGER DEFAULT 0,
            created_at TEXT DEFAULT (datetime('now'))
        );

        CREATE TABLE IF NOT EXISTS reviews (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            review_id TEXT UNIQUE NOT NULL,
            status TEXT DEFAULT 'prepared' CHECK(status IN ('prepared','running','completed','failed')),
            run_reason TEXT,
            daily_digest_json TEXT,
            pending_summary_json TEXT,
            worker_started_at TEXT,
            worker_finished_at TEXT,
            worker_error TEXT,
            created_at TEXT DEFAULT (datetime('now'))
        );

        CREATE TABLE IF NOT EXISTS mutations (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            review_id TEXT,
            proposal_group_id TEXT,
            proposal_summary TEXT,
            proposal_status TEXT DEFAULT 'pending' CHECK(proposal_status IN ('pending','presented','accepted','rejected','stale','superseded')),
            presented_at TEXT,
            decision_at TEXT,
            expires_at TEXT,
            target_file TEXT NOT NULL,
            mutation_type TEXT CHECK(mutation_type IN ('add','modify','remove')),
            layer TEXT CHECK(layer IN ('identity','context','protocol','capability','runtime')),
            description TEXT,
            before_text TEXT,
            after_text TEXT,
            signal_ids TEXT,
            source TEXT DEFAULT 'evolution' CHECK(source IN ('evolution','user-direct','snapshot-diff','positive-anchor')),
            status TEXT DEFAULT 'proposed' CHECK(status IN ('proposed','approved','applied','verified','rejected')),
            pareto_check TEXT,
            verification_criteria TEXT,
            layer_reason TEXT,
            gene_id TEXT,
            gene_reason TEXT,
            session_id TEXT,
            created_at TEXT DEFAULT (datetime('now')),
            applied_at TEXT
        );

        CREATE TABLE IF NOT EXISTS gene_matches (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            review_id TEXT,
            signal_id INTEGER,
            gene_id TEXT NOT NULL,
            reason TEXT NOT NULL,
            judgment_type TEXT DEFAULT 'root_cause_fit' CHECK(judgment_type IN ('root_cause_fit','surface_relief','fallback_only')),
            confidence REAL,
            created_at TEXT DEFAULT (datetime('now'))
        );

        CREATE TABLE IF NOT EXISTS evolution_runs (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            run_id TEXT UNIQUE NOT NULL,
            signals_analyzed INTEGER DEFAULT 0,
            mutations_proposed INTEGER DEFAULT 0,
            mutations_applied INTEGER DEFAULT 0,
            sessions_analyzed INTEGER DEFAULT 0,
            sessions_cost_usd REAL DEFAULT 0,
            evolution_cost_usd REAL DEFAULT 0,
            report_path TEXT,
            saturation_note TEXT,
            created_at TEXT DEFAULT (datetime('now'))
        );

        CREATE INDEX IF NOT EXISTS idx_signals_type ON signals(type);
        CREATE INDEX IF NOT EXISTS idx_signals_processed ON signals(processed);
        CREATE INDEX IF NOT EXISTS idx_signals_layer ON signals(layer);
        CREATE INDEX IF NOT EXISTS idx_trajectories_type ON trajectories(type);
        CREATE INDEX IF NOT EXISTS idx_mutations_status ON mutations(status);
        CREATE INDEX IF NOT EXISTS idx_mutations_proposal_status ON mutations(proposal_status);
        CREATE INDEX IF NOT EXISTS idx_mutations_proposal_group ON mutations(proposal_group_id);
        CREATE INDEX IF NOT EXISTS idx_gene_matches_signal ON gene_matches(signal_id);
        CREATE INDEX IF NOT EXISTS idx_gene_matches_gene ON gene_matches(gene_id);
    """)

    conn.commit()
    conn.close()
    print(f"Database initialized: {db_path}")


if __name__ == "__main__":
    init_db(get_db_path())

#!/usr/bin/env python3
# ruff: noqa: E402
# Copyright 2026 Beijing Volcano Engine Technology Co., Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
Migration: Add source and session_id columns to mutations table.

Safe to run multiple times — uses IF NOT EXISTS logic.

Usage:
  python db-migrate-source.py [path-to-evolution.db]
"""

import sqlite3
import os
import sys

for stream in [sys.stdout, sys.stderr, sys.stdin]:
    if stream and hasattr(stream, "reconfigure") and stream.encoding != "utf-8":
        stream.reconfigure(encoding="utf-8")

from _workspace import resolve_workspace_root

DEFAULT_DB_PATH = os.path.join(resolve_workspace_root(), "evolution-data/evolution.db")


def migrate(db_path):
    if not os.path.exists(db_path):
        print(f"DB not found: {db_path}")
        sys.exit(1)

    conn = sqlite3.connect(db_path)
    cur = conn.cursor()

    # Check existing columns
    cur.execute("PRAGMA table_info(mutations)")
    columns = {row[1] for row in cur.fetchall()}

    added = []

    if "source" not in columns:
        cur.execute("""
            ALTER TABLE mutations
            ADD COLUMN source TEXT DEFAULT 'evolution'
            CHECK(source IN ('evolution','user-direct','snapshot-diff'))
        """)
        added.append("source")

    if "session_id" not in columns:
        cur.execute("ALTER TABLE mutations ADD COLUMN session_id TEXT")
        added.append("session_id")

    conn.commit()
    conn.close()

    if added:
        print(f"Migration complete. Added columns: {', '.join(added)}")
    else:
        print("No migration needed — columns already exist.")


if __name__ == "__main__":
    db_path = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_DB_PATH
    migrate(db_path)

#!/usr/bin/env python3
# ruff: noqa: E402
# Copyright 2026 Beijing Volcano Engine Technology Co., Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Database migration for v0.3.1: expand signal types + add positive-anchor source."""

import sqlite3
import os
import sys
import argparse

for stream in [sys.stdout, sys.stderr, sys.stdin]:
    if stream and hasattr(stream, "reconfigure") and stream.encoding != "utf-8":
        stream.reconfigure(encoding="utf-8")

from _workspace import resolve_workspace_root

DEFAULT_DB_PATH = os.path.join(resolve_workspace_root(), "evolution-data/evolution.db")

MIGRATION_SQL = """
-- v0.3.1: Expand signal types to include preference and clarification
CREATE TABLE IF NOT EXISTS signals_v029 (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    session_id TEXT,
    type TEXT NOT NULL CHECK(type IN ('correction','negative','positive','suggestion','preference','clarification')),
    layer TEXT CHECK(layer IN ('identity','context','protocol','capability','runtime')),
    severity TEXT DEFAULT 'medium' CHECK(severity IN ('low','medium','high')),
    raw_text TEXT NOT NULL,
    context TEXT,
    processed INTEGER DEFAULT 0,
    created_at TEXT DEFAULT (datetime('now'))
);

INSERT INTO signals_v029 (id, session_id, type, layer, severity, raw_text, context, processed, created_at)
SELECT id, session_id, type, layer, severity, raw_text, context, processed, created_at
FROM signals;

DROP TABLE signals;
ALTER TABLE signals_v029 RENAME TO signals;

CREATE INDEX IF NOT EXISTS idx_signals_type ON signals(type);
CREATE INDEX IF NOT EXISTS idx_signals_processed ON signals(processed);
CREATE INDEX IF NOT EXISTS idx_signals_layer ON signals(layer);

-- v0.3.1: Expand mutations source to include positive-anchor
CREATE TABLE IF NOT EXISTS mutations_v029 (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    review_id TEXT,
    proposal_group_id TEXT,
    proposal_summary TEXT,
    proposal_status TEXT DEFAULT 'pending' CHECK(proposal_status IN ('pending','presented','accepted','rejected','stale','superseded')),
    presented_at TEXT,
    decision_at TEXT,
    expires_at TEXT,
    target_file TEXT NOT NULL,
    mutation_type TEXT CHECK(mutation_type IN ('add','modify','remove')),
    layer TEXT CHECK(layer IN ('identity','context','protocol','capability','runtime')),
    description TEXT,
    before_text TEXT,
    after_text TEXT,
    signal_ids TEXT,
    source TEXT DEFAULT 'evolution' CHECK(source IN ('evolution','user-direct','snapshot-diff','positive-anchor')),
    status TEXT DEFAULT 'proposed' CHECK(status IN ('proposed','approved','applied','verified','rejected')),
    pareto_check TEXT,
    verification_criteria TEXT,
    layer_reason TEXT,
    gene_id TEXT,
    gene_reason TEXT,
    session_id TEXT,
    created_at TEXT DEFAULT (datetime('now')),
    applied_at TEXT
);

INSERT INTO mutations_v029 SELECT * FROM mutations;
DROP TABLE mutations;
ALTER TABLE mutations_v029 RENAME TO mutations;

CREATE INDEX IF NOT EXISTS idx_mutations_status ON mutations(status);
CREATE INDEX IF NOT EXISTS idx_mutations_proposal_status ON mutations(proposal_status);
CREATE INDEX IF NOT EXISTS idx_mutations_proposal_group ON mutations(proposal_group_id);

-- Record migration
CREATE TABLE IF NOT EXISTS schema_migrations (
    version TEXT PRIMARY KEY,
    applied_at TEXT DEFAULT (datetime('now'))
);
INSERT OR IGNORE INTO schema_migrations (version) VALUES ('v0.3.1');
"""


def migrate(db_path=None):
    path = db_path or DEFAULT_DB_PATH
    if not os.path.exists(path):
        print(f"DB not found: {path}", file=sys.stderr)
        sys.exit(1)

    conn = sqlite3.connect(path)
    try:
        cur = conn.cursor()
        cur.execute("SELECT version FROM schema_migrations WHERE version = 'v0.3.1'")
        if cur.fetchone():
            print("Migration v0.3.1 already applied.")
            conn.close()
            return
    except sqlite3.OperationalError:
        pass

    conn.executescript(MIGRATION_SQL)
    conn.close()
    print(f"Migration v0.3.1 applied to {path}")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Migrate evolution DB to v0.3.1")
    parser.add_argument("--db", default=None)
    args = parser.parse_args()
    migrate(args.db)

#!/usr/bin/env python3
# ruff: noqa: E402
# Copyright 2026 Beijing Volcano Engine Technology Co., Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Detect evolution signal candidates from user messages via Hook.

Can be used as:
1. PostToolUse hook — reads JSON from stdin, auto-records high-confidence signals
2. Library — import detect_signals() for batch detection in scan-history.py
"""

import json
import os
import re
import sys

for stream in [sys.stdout, sys.stderr, sys.stdin]:
    if stream and hasattr(stream, "reconfigure") and stream.encoding != "utf-8":
        stream.reconfigure(encoding="utf-8")

from _workspace import resolve_workspace_root

DEFAULT_DB_PATH = os.path.join(resolve_workspace_root(), "evolution-data/evolution.db")

# ── Pattern 定义 ──────────────────────────────────────────────

PATTERNS = {
    "correction": {
        "high_confidence": [
            r"不[要是]这[样个么]",
            r"错了",
            r"不对[，。！\s]",
            r"应该[用是]",
            r"正确的[做方]法",
            r"我说的是.{1,20}不是",
            r"别[再这]",
            r"不是这个意思",
            r"你搞[错混]了",
            r"重[做来]",
        ],
        "low_confidence": [
            r"我刚[才说]的是",
            r"再[试说]一[次遍]",
            r"看清楚",
        ],
    },
    "negative": {
        "high_confidence": [
            r"太[长短慢]了",
            r"AI[味感]",
            r"机器[味感]",
            r"套话",
            r"又来了",
            r"跟上次一样",
            r"不[是要]我[想要]的",
            r"废话",
            r"没用",
        ],
        "low_confidence": [
            r"^唉",
            r"^算了",
            r"^行吧",
            r"^凑合",
            r"emmm",
            r"无语",
        ],
    },
    "positive": {
        "high_confidence": [
            r"[完太]美了?",
            r"就[是这][这样]",
            r"做得[好不]错",
            r"比上次好",
            r"nice|great|perfect",
        ],
        "low_confidence": [],
    },
    "suggestion": {
        "high_confidence": [
            r"以后[可能]以",
            r"下次",
            r"能不能",
            r"要是能.{1,30}就好了",
            r"这种情况应该",
            r"建议",
            r"最好[能是]",
            r"希望你",
        ],
        "low_confidence": [
            r"有没有办法",
            r"怎么才能",
        ],
    },
    "preference": {
        "high_confidence": [
            r"我[更比较]喜欢",
            r"我习惯",
            r"我[一通]般[都会]",
            r"我的风格",
            r"[别不][要用]给?我",
            r"用.{1,10}格式",
            r"[简详][短细][一点些]",
        ],
        "low_confidence": [],
    },
    "clarification": {
        "high_confidence": [
            r"我[的这]里[说的指]的是",
            r"[所其]谓.{1,15}[就指]的?是",
            r"你[理搞]解错了",
            r"不是.{1,20}而是",
            r"准确[来地]说",
            r"补充一下",
            r"我[再解]释一下",
        ],
        "low_confidence": [],
    },
}


def detect_signals(text):
    """对文本做 pattern 匹配，返回候选信号列表。"""
    candidates = []
    for signal_type, patterns in PATTERNS.items():
        high_matches = []
        low_matches = []
        for pat in patterns.get("high_confidence", []):
            if re.search(pat, text, re.IGNORECASE):
                high_matches.append(pat)
        for pat in patterns.get("low_confidence", []):
            if re.search(pat, text, re.IGNORECASE):
                low_matches.append(pat)
        if high_matches or low_matches:
            confidence = "high" if high_matches else "low"
            candidates.append(
                {
                    "type": signal_type,
                    "confidence": confidence,
                    "matched_patterns": high_matches + low_matches,
                    "high_count": len(high_matches),
                    "low_count": len(low_matches),
                }
            )
    return candidates


def auto_record(db_path, signal_type, raw_text, session_id, context):
    """Write a signal directly to DB. Returns signal_id or None."""
    if not os.path.exists(db_path):
        return None
    import sqlite3

    conn = sqlite3.connect(db_path)
    cur = conn.cursor()
    cur.execute(
        """
        INSERT INTO signals (session_id, type, severity, raw_text, context)
        VALUES (?, ?, 'medium', ?, ?)
    """,
        (session_id, signal_type, raw_text[:500], context),
    )
    conn.commit()
    signal_id = cur.lastrowid
    conn.close()
    return signal_id


def handle_hook_input():
    """从 Hook stdin 读取 JSON，提取用户消息做检测。"""
    try:
        raw = sys.stdin.read()
        if not raw.strip():
            sys.exit(0)
        data = json.loads(raw)
    except (json.JSONDecodeError, IOError):
        sys.exit(0)

    messages = data.get("messages", [])
    user_text = ""
    for msg in reversed(messages):
        if msg.get("role") == "user":
            content = msg.get("content", "")
            if isinstance(content, list):
                texts = [
                    b.get("text", "")
                    for b in content
                    if isinstance(b, dict) and b.get("type") == "text"
                ]
                user_text = "\n".join(texts)
            elif isinstance(content, str):
                user_text = content
            break

    if not user_text or len(user_text) < 2:
        sys.exit(0)

    candidates = detect_signals(user_text)
    if not candidates:
        sys.exit(0)

    auto_recorded = []
    needs_confirmation = []
    db_path = DEFAULT_DB_PATH
    session_id = (data.get("session_id") or "")[:12]

    for cand in candidates:
        if cand["confidence"] == "high":
            sid = auto_record(
                db_path,
                cand["type"],
                user_text,
                session_id,
                f"auto-detected by hook, patterns: {cand['matched_patterns']}",
            )
            if sid:
                auto_recorded.append({"signal_id": sid, "type": cand["type"]})
            else:
                needs_confirmation.append(cand)
        else:
            needs_confirmation.append(cand)

    context_parts = []
    if auto_recorded:
        ids_str = ", ".join(f"#{r['signal_id']}({r['type']})" for r in auto_recorded)
        context_parts.append(
            f"[Evolution] Auto-recorded {len(auto_recorded)} signal(s): {ids_str}"
        )
    if needs_confirmation:
        types_str = ", ".join(c["type"] for c in needs_confirmation)
        context_parts.append(
            f"[Evolution] Candidate signal(s) need confirmation: {types_str}. "
            f"Consider recording via signal-record.py if appropriate."
        )

    if context_parts:
        output = {
            "hookSpecificOutput": {
                "hookEventName": "PostToolUse",
                "additionalContext": " | ".join(context_parts),
            }
        }
        print(json.dumps(output, ensure_ascii=False))


if __name__ == "__main__":
    handle_hook_input()