opencode-skills-collection 3.1.23 → 4.0.1

package/bundled-skills/product-decision-agent/scripts/quality_gate.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""Quality checks for Maoxuan Product Agent sample outputs.
+
+Usage:
+  quality_gate.py output1.md output2.md ...
+
+The script catches common regressions:
+- source/theory leakage
+- English-dominant answers in Chinese work scenes
+- vague advice without concrete next actions
+- excessive question dumping in the "需要确认" section
+- missing judgment, risk, or decision signal
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+
+HARD_BANNED = [
+    r"毛泽东",
+    r"毛选",
+    r"矛盾论",
+    r"实践论",
+    r"教员",
+    r"毛主席",
+    r"同志",
+    r"阶级",
+    r"革命",
+    r"斗争",
+    r"主席指出",
+    r"《[^》]+》认为",
+]
+
+SOFT_BANNED = [
+    r"辩证",
+    r"唯物",
+    r"经典",
+    r"原文",
+]
+
+VAGUE_PATTERNS = [
+    r"提升用户体验",
+    r"加强沟通",
+    r"多看数据",
+    r"深入了解用户",
+    r"持续优化",
+    r"形成闭环",
+    r"赋能",
+    r"抓手",
+    r"打透认知",
+]
+
+JUDGMENT_HINTS = [
+    "问题判断",
+    "核心是",
+    "关键是",
+    "不是",
+    "当前最",
+    "先不要",
+]
+
+ACTION_HINTS = [
+    "行动建议",
+    "下一步",
+    "今天",
+    "本周",
+    "24 小时",
+    "48 小时",
+    "2 天",
+    "一周",
+    "两周",
+    "负责人",
+    "指标",
+    "验证",
+    "实验",
+    "灰度",
+    "拆",
+    "砍",
+    "暂停",
+    "停止",
+]
+
+DECISION_HINTS = [
+    "成功指标",
+    "失败指标",
+    "主指标",
+    "影响指标",
+    "护栏",
+    "全量",
+    "停止",
+    "暂停",
+    "复盘",
+    "监控",
+    "达标",
+    "不达标",
+    "决策",
+    "上线",
+    "回滚",
+    "留存",
+    "转化",
+    "回复率",
+    "复访",
+    "D7",
+    "7 日",
+    "7日",
+]
+
+RISK_HINTS = [
+    "风险提醒",
+    "不要",
+    "先不要",
+    "暂时不要",
+    "不建议",
+]
+
+
+def count_questions(text: str) -> int:
+    """Count questions in the "需要确认" section only."""
+    match = re.search(
+        r"(?:^|\n)(?:#{1,3}\s*)?(?:\*\*)?需要确认(?:\*\*)?[^\n]*\n"
+        r"(?P<section>.*?)(?=\n(?:#{1,3}\s+|\*\*[^*\n]+?\*\*)|\Z)",
+        text,
+        re.DOTALL,
+    )
+    if not match:
+        return 0
+
+    section = match.group("section")
+    questions = 0
+    for line in section.splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        # Count sentence-ending question marks. This ignores URL query strings
+        # such as https://example.com?a=1 while still catching two questions
+        # written on the same line.
+        questions += len(
+            re.findall(r"？|\?(?=[\s\u4e00-\u9fff]|$)", stripped)
+        )
+    return questions
+
+
+def chinese_ratio(text: str) -> float:
+    zh = len(re.findall(r"[\u4e00-\u9fff]", text))
+    en = len(re.findall(r"[A-Za-z]", text))
+    if zh + en == 0:
+        return 0.0
+    return zh / (zh + en)
+
+
+def check_file(path: Path) -> tuple[list[str], list[str]]:
+    text = path.read_text(encoding="utf-8")
+    errors: list[str] = []
+    warnings: list[str] = []
+
+    for pattern in HARD_BANNED:
+        if re.search(pattern, text, re.IGNORECASE):
+            errors.append(f"exposes hard-banned source/style term: {pattern}")
+
+    for pattern in SOFT_BANNED:
+        if re.search(pattern, text, re.IGNORECASE):
+            warnings.append(f"contains review-needed term: {pattern}")
+
+    vague_hits = [p for p in VAGUE_PATTERNS if re.search(p, text)]
+    if vague_hits:
+        errors.append(f"contains vague phrase(s): {', '.join(vague_hits)}")
+
+    if chinese_ratio(text) < 0.72:
+        errors.append("answer is not Chinese-dominant enough")
+
+    if not any(hint in text for hint in JUDGMENT_HINTS):
+        errors.append("missing problem judgment")
+
+    if not any(hint in text for hint in ACTION_HINTS):
+        errors.append("missing concrete action hints")
+
+    if not any(hint in text for hint in DECISION_HINTS):
+        errors.append("missing metric/decision/review signal")
+
+    if not any(hint in text for hint in RISK_HINTS):
+        errors.append("missing risk or stop-doing guidance")
+
+    if count_questions(text) > 3:
+        errors.append("asks too many questions")
+
+    stripped_len = len(text.strip())
+    if stripped_len < 120:
+        errors.append("output is likely too thin")
+    if stripped_len > 2200:
+        errors.append("output is likely too verbose")
+
+    return errors, warnings
+
+
+def main(argv: list[str]) -> int:
+    if not argv:
+        print("Usage: quality_gate.py output1.md output2.md ...", file=sys.stderr)
+        return 2
+
+    failed = False
+    for item in argv:
+        path = Path(item)
+        errors, warnings = check_file(path)
+        if errors:
+            failed = True
+            print(f"FAIL {path}")
+            for err in errors:
+                print(f"  - {err}")
+        else:
+            print(f"PASS {path}")
+        for warning in warnings:
+            print(f"  WARN {warning}")
+
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/bundled-skills/product-decision-agent/scripts/test_quality_gate.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Regression tests for the sample-output quality gate."""
+
+from __future__ import annotations
+
+import importlib.util
+import tempfile
+import unittest
+from pathlib import Path
+
+
+MODULE_PATH = Path(__file__).with_name("quality_gate.py")
+SPEC = importlib.util.spec_from_file_location("quality_gate", MODULE_PATH)
+if SPEC is None or SPEC.loader is None:
+    raise RuntimeError(f"Cannot load {MODULE_PATH}")
+quality_gate = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(quality_gate)
+
+
+VALID_OUTPUT = """# 测试回答
+
+**问题判断**
+当前最关键的是先拆清楚留存下降来自哪个用户群体。
+
+**原因分析**
+- 总量变化可能掩盖渠道和版本差异。
+
+**行动建议**
+1. 今天按渠道和版本拆 D7 留存，并用结果决定是否回滚。
+
+**风险提醒**
+不要在口径不清时直接全量回滚。
+"""
+
+
+class QuestionCountingTests(unittest.TestCase):
+    def test_counts_only_confirmation_section(self) -> None:
+        text = VALID_OUTPUT + "\n前文的问题是什么？\n"
+        self.assertEqual(quality_gate.count_questions(text), 0)
+
+    def test_counts_multiple_questions_on_one_line(self) -> None:
+        text = VALID_OUTPUT + """
+
+**需要确认**
+1. 掉的是新用户吗？集中在哪个版本？
+2. 埋点改过吗？是否有发布事故？
+"""
+        self.assertEqual(quality_gate.count_questions(text), 4)
+
+    def test_ignores_url_query_string(self) -> None:
+        text = VALID_OUTPUT + """
+
+**需要确认**
+1. 请确认看板 https://example.com/report?cohort=new 是否采用同一口径。
+"""
+        self.assertEqual(quality_gate.count_questions(text), 0)
+
+
+class FileCheckingTests(unittest.TestCase):
+    def check(self, text: str) -> tuple[list[str], list[str]]:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            path = Path(temp_dir) / "sample.md"
+            path.write_text(text, encoding="utf-8")
+            return quality_gate.check_file(path)
+
+    def test_valid_output_passes(self) -> None:
+        errors, warnings = self.check(VALID_OUTPUT)
+        self.assertEqual(errors, [])
+        self.assertEqual(warnings, [])
+
+    def test_hard_source_leak_fails(self) -> None:
+        errors, _ = self.check(VALID_OUTPUT + "\n毛泽东认为应该这样做。\n")
+        self.assertTrue(any("hard-banned" in error for error in errors))
+
+    def test_soft_term_warns_without_failing(self) -> None:
+        errors, warnings = self.check(VALID_OUTPUT + "\n这是一个经典案例。\n")
+        self.assertEqual(errors, [])
+        self.assertTrue(any("review-needed" in warning for warning in warnings))
+
+    def test_more_than_three_confirmation_questions_fails(self) -> None:
+        text = VALID_OUTPUT + """
+
+**需要确认**
+1. 指标是什么？
+2. 持续多久？
+3. 哪类用户？
+4. 试过什么？
+"""
+        errors, _ = self.check(text)
+        self.assertIn("asks too many questions", errors)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/bundled-skills/pytest-skill/reference/playbook.md

@@ -0,0 +1,358 @@
+# pytest — Advanced Implementation Playbook
+
+## §1 — Production Configuration
+
+```ini
+# pytest.ini
+[pytest]
+testpaths = tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+addopts = -v --strict-markers --tb=short -q
+markers =
+    slow: marks tests as slow (deselect with '-m "not slow"')
+    integration: marks integration tests
+    smoke: marks smoke tests
+    api: marks API tests
+filterwarnings =
+    error
+    ignore::DeprecationWarning
+```
+
+```toml
+# pyproject.toml (alternative)
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-v --strict-markers --tb=short"
+markers = [
+    "slow: marks tests as slow",
+    "integration: integration tests",
+    "smoke: smoke tests",
+]
+
+[tool.coverage.run]
+source = ["src"]
+omit = ["tests/*", "*/migrations/*"]
+
+[tool.coverage.report]
+fail_under = 80
+show_missing = true
+```
+
+## §2 — Fixtures (Scoping, Factories, Teardown)
+
+```python
+# conftest.py — shared fixtures
+import pytest
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session
+
+# Session-scoped: created once per test session
+@pytest.fixture(scope="session")
+def engine():
+    engine = create_engine("sqlite:///test.db")
+    Base.metadata.create_all(engine)
+    yield engine
+    Base.metadata.drop_all(engine)
+
+# Function-scoped: created per test (default), auto-cleanup
+@pytest.fixture
+def db_session(engine):
+    connection = engine.connect()
+    transaction = connection.begin()
+    session = Session(bind=connection)
+    yield session
+    session.close()
+    transaction.rollback()
+    connection.close()
+
+# Factory fixture — create multiple instances
+@pytest.fixture
+def user_factory(db_session):
+    created = []
+    def _create_user(name="Test User", email=None, role="viewer"):
+        email = email or f"{name.lower().replace(' ', '.')}@test.com"
+        user = User(name=name, email=email, role=role)
+        db_session.add(user)
+        db_session.commit()
+        created.append(user)
+        return user
+    yield _create_user
+    for user in created:
+        db_session.delete(user)
+    db_session.commit()
+
+# Autouse fixture — runs for every test in module
+@pytest.fixture(autouse=True)
+def reset_cache():
+    cache.clear()
+    yield
+    cache.clear()
+
+# tmp_path for file operations (built-in)
+def test_writes_output(tmp_path):
+    output_file = tmp_path / "result.json"
+    generate_report(output_file)
+    assert output_file.exists()
+    data = json.loads(output_file.read_text())
+    assert data["status"] == "complete"
+```
+
+## §3 — Parameterized Tests
+
+```python
+import pytest
+
+# Basic parametrize
+@pytest.mark.parametrize("input,expected", [
+    ("hello", "HELLO"),
+    ("world", "WORLD"),
+    ("", ""),
+    ("123", "123"),
+])
+def test_uppercase(input, expected):
+    assert input.upper() == expected
+
+# Multiple parameters with IDs
+@pytest.mark.parametrize("email,valid", [
+    ("user@test.com", True),
+    ("invalid", False),
+    ("", False),
+    ("user@.com", False),
+], ids=["valid_email", "no_at_sign", "empty", "missing_domain"])
+def test_validate_email(email, valid):
+    assert validate_email(email) == valid
+
+# Combine parametrize (cartesian product)
+@pytest.mark.parametrize("browser", ["chrome", "firefox", "edge"])
+@pytest.mark.parametrize("resolution", ["1920x1080", "1366x768", "375x667"])
+def test_responsive_layout(browser, resolution):
+    assert render_page(browser, resolution).is_valid()
+
+# Indirect parametrize (pass to fixture)
+@pytest.fixture
+def user(request):
+    return create_user(role=request.param)
+
+@pytest.mark.parametrize("user", ["admin", "editor", "viewer"], indirect=True)
+def test_permissions(user):
+    assert user.can_view()
+```
+
+## §4 — Mocking with pytest-mock
+
+```python
+# pip install pytest-mock
+
+def test_send_email(mocker):
+    mock_smtp = mocker.patch("myapp.email.smtplib.SMTP")
+    send_email("test@example.com", "Hello", "Body")
+    mock_smtp.return_value.sendmail.assert_called_once()
+
+def test_api_call(mocker):
+    mock_get = mocker.patch("myapp.api.requests.get")
+    mock_get.return_value.json.return_value = {"id": 1, "name": "Alice"}
+    mock_get.return_value.status_code = 200
+    user = get_user(1)
+    assert user["name"] == "Alice"
+    mock_get.assert_called_once_with("https://api.example.com/users/1")
+
+def test_database_error(mocker):
+    mocker.patch("myapp.db.session.commit", side_effect=IntegrityError("duplicate"))
+    with pytest.raises(DuplicateError):
+        create_user("Alice", "alice@test.com")
+
+# Spy — track calls without replacing
+def test_logging(mocker):
+    spy = mocker.spy(logger, "info")
+    process_order(order)
+    spy.assert_called_with("Order processed: %s", order.id)
+
+# Mock environment variables
+def test_config(monkeypatch):
+    monkeypatch.setenv("API_KEY", "test-key-123")
+    monkeypatch.setenv("DEBUG", "true")
+    config = load_config()
+    assert config.api_key == "test-key-123"
+    assert config.debug is True
+```
+
+## §5 — Async Testing
+
+```python
+# pip install pytest-asyncio
+
+import pytest
+
+@pytest.mark.asyncio
+async def test_async_fetch():
+    result = await fetch_data("https://api.example.com/data")
+    assert result["status"] == "ok"
+
+@pytest.mark.asyncio
+async def test_async_exception():
+    with pytest.raises(ConnectionError):
+        await fetch_data("https://invalid.example.com")
+
+# Async fixtures
+@pytest.fixture
+async def async_client():
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        yield client
+
+@pytest.mark.asyncio
+async def test_api_endpoint(async_client):
+    response = await async_client.get("/api/users")
+    assert response.status_code == 200
+    assert len(response.json()) > 0
+```
+
+## §6 — Testing Exceptions & Warnings
+
+```python
+# Exception testing
+def test_division_by_zero():
+    with pytest.raises(ZeroDivisionError):
+        1 / 0
+
+def test_error_message():
+    with pytest.raises(ValueError, match=r".*invalid email.*"):
+        validate_email("not-an-email")
+
+def test_raises_with_info():
+    with pytest.raises(PermissionError) as exc_info:
+        delete_file("/protected/file.txt")
+    assert "permission denied" in str(exc_info.value).lower()
+    assert exc_info.value.errno == 13
+
+# Warning testing
+def test_deprecation_warning():
+    with pytest.warns(DeprecationWarning, match="use new_func"):
+        old_func()
+```
+
+## §7 — Markers & Custom Plugins
+
+```python
+# Custom marker usage
+@pytest.mark.slow
+def test_full_data_processing():
+    result = process_large_dataset()
+    assert result.row_count > 1_000_000
+
+@pytest.mark.integration
+def test_database_connection():
+    assert db.is_connected()
+
+# Run by marker: pytest -m "not slow"
+# Run by marker: pytest -m "smoke and not integration"
+
+# Custom plugin — conftest.py
+def pytest_collection_modifyitems(config, items):
+    """Auto-mark tests in integration/ directory"""
+    for item in items:
+        if "integration" in str(item.fspath):
+            item.add_marker(pytest.mark.integration)
+
+# Custom report header
+def pytest_report_header(config):
+    return f"Environment: {os.getenv('ENV', 'local')}"
+```
+
+## §8 — Class-Based Test Organization
+
+```python
+class TestUserService:
+    @pytest.fixture(autouse=True)
+    def setup(self, db_session, user_factory):
+        self.db = db_session
+        self.create_user = user_factory
+        self.service = UserService(db_session)
+
+    def test_create_user(self):
+        user = self.service.create("Alice", "alice@test.com")
+        assert user.id is not None
+        assert user.name == "Alice"
+
+    def test_find_by_email(self):
+        self.create_user(name="Bob", email="bob@test.com")
+        user = self.service.find_by_email("bob@test.com")
+        assert user.name == "Bob"
+
+    def test_delete_nonexistent(self):
+        with pytest.raises(NotFoundError):
+            self.service.delete(999)
+
+    class TestPermissions:
+        """Nested class for permission-related tests"""
+        def test_admin_can_delete(self, user_factory):
+            admin = user_factory(role="admin")
+            assert admin.can_delete()
+
+        def test_viewer_cannot_delete(self, user_factory):
+            viewer = user_factory(role="viewer")
+            assert not viewer.can_delete()
+```
+
+## §9 — CI/CD Integration
+
+```yaml
+# GitHub Actions
+name: Python Tests
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.10', '3.11', '3.12']
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with: { python-version: '${{ matrix.python-version }}' }
+      - name: Install deps
+        run: pip install -r requirements-test.txt
+      - name: Run tests
+        run: pytest --cov=src --cov-report=xml --junitxml=results.xml -v
+      - name: Upload coverage
+        uses: codecov/codecov-action@v4
+        with: { files: coverage.xml }
+      - name: Upload results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with: { name: test-results-${{ matrix.python-version }}, path: results.xml }
+```
+
+## §10 — Debugging Quick-Reference
+
+| Problem | Cause | Fix |
+|---------|-------|-----|
+| Fixture not found | Wrong scope or missing conftest.py | Check conftest.py location, fixture name |
+| `ScopeMismatch` | Function fixture depends on session fixture | Match scope: session → module → function |
+| Tests interfere | Shared mutable state | Use function-scoped fixtures, `autouse` cleanup |
+| Parametrize fails | Wrong number of params | Ensure tuple count matches parameter names |
+| Slow collection | Too many test paths | Set `testpaths` in pytest.ini |
+| Async test hangs | Missing `@pytest.mark.asyncio` | Add marker or set `asyncio_mode = "auto"` |
+| Coverage wrong | Source path mismatch | Set `source` in `[tool.coverage.run]` |
+| Import errors | Missing `__init__.py` or bad path | Add `__init__.py` or use `src` layout with `--import-mode=importlib` |
+| Monkeypatch not reverting | Using at module scope | Only use in function-scoped fixtures |
+| Marker warnings | Marker not registered | Add to `markers` in pytest.ini |
+
+## §11 — Best Practices Checklist
+
+- ✅ Use fixtures over setup/teardown methods
+- ✅ Use `conftest.py` for shared fixtures (auto-discovered)
+- ✅ Use `tmp_path` for file operations (built-in, auto-cleanup)
+- ✅ Use `monkeypatch` for env vars and attribute patching
+- ✅ Use `pytest-mock` (mocker fixture) over `unittest.mock`
+- ✅ Use `@pytest.mark.parametrize` for data-driven tests
+- ✅ Register all custom markers in `pytest.ini`
+- ✅ Use `--strict-markers` to catch typos in marker names
+- ✅ Use `pytest-cov` for coverage with `--cov-fail-under=80`
+- ✅ Use `pytest-xdist` for parallel execution: `pytest -n auto`
+- ✅ Use `--tb=short` for concise tracebacks in CI
+- ✅ Structure: `tests/unit/`, `tests/integration/`, `conftest.py`
+- ✅ Name files `test_*.py` and functions `test_*`
+- ✅ Use factory fixtures for creating test objects
+- ✅ Use `pytest.raises(match=...)` for precise error checking