| import json
|
| import os
|
| import re
|
| import subprocess
|
| import sys
|
| import tempfile
|
| import unittest
|
| from pathlib import Path
|
|
|
|
|
| REPO = Path(__file__).resolve().parents[1]
|
| SKILL = REPO / "skills" / "speak-human"
|
| CHECK = SKILL / "scripts" / "check.py"
|
| RULES = SKILL / "references" / "core-rules.json"
|
| EVALS = REPO / "evals" / "trigger_eval.jsonl"
|
| PLUGIN = REPO / ".claude-plugin" / "plugin.json"
|
| VERSION = "2.1.1"
|
| PACKAGE_FILES = {
|
| "LICENSE.txt",
|
| "SKILL.md",
|
| "SKILL.zh-CN.md",
|
| "agents/openai.yaml",
|
| "assets/review-output-template.md",
|
| "references/core-method.md",
|
| "references/communication-modes.md",
|
| "references/language-signals.md",
|
| "references/social-media.md",
|
| "references/core-rules.json",
|
| "references/voice-profile.schema.json",
|
| "scripts/check.py",
|
| }
|
| MODES = {
|
| "general",
|
| "status_update",
|
| "technical_explanation",
|
| "decision_recommendation",
|
| "professional_document",
|
| "readme_release",
|
| "resume_portfolio",
|
| "conversation_reply",
|
| }
|
| PRIVATE_PLACEHOLDERS = re.compile(
|
| r"\[(?:INTERNAL_EMPLOYEE|PRIVATE_CORPUS|LOCAL_USERNAME)\]"
|
| )
|
| SOCIAL_CONTEXT = re.compile(
|
| r"社媒|小红书|微博|抖音|social media|X post|Reddit|Instagram|TikTok",
|
| re.IGNORECASE,
|
| )
|
| POSITIVE_ACTION = re.compile(
|
| r"\$speak-human|speak-human|改写|重写|润色|改得|改成|压短|整理成|帮我回复|"
|
| r"写得.{0,10}(?:清楚|自然|像人)|解释.{0,20}(?:给|让)|"
|
| r"rewrite|review|make .{0,50}(?:clearer|easier)|turn .{0,50}into",
|
| re.IGNORECASE,
|
| )
|
| HUMAN_WRITING = re.compile(
|
| r"进度|状态更新|汇报|解释|OAuth|技术|decision memo|recommendation|"
|
| r"leadership|客户|实施方案|email|vendor|README|release note|"
|
| r"简历|portfolio|同事|消息|公告|小红书|项目复盘|报告|文档",
|
| re.IGNORECASE,
|
| )
|
| EXPLICIT_NON_TRIGGER = re.compile(
|
| r"不要改写|不需要润色|逐字翻译|do not draft|do not edit|"
|
| r"只报告|只给我|source-code|off-by-one|CSV|JSON|柱状图|头像|"
|
| r"重复 PDF|发布时间|不做风格改写",
|
| re.IGNORECASE,
|
| )
|
|
|
|
|
| def package_files() -> set[str]:
|
| return {
|
| path.relative_to(SKILL).as_posix()
|
| for path in SKILL.rglob("*")
|
| if path.is_file() and "__pycache__" not in path.parts
|
| }
|
|
|
|
|
| def parse_frontmatter(path: Path) -> dict[str, str]:
|
| text = path.read_text(encoding="utf-8")
|
| match = re.match(r"(?s)^---\n(.*?)\n---\n", text)
|
| if not match:
|
| raise AssertionError(f"missing frontmatter: {path}")
|
| fields = {}
|
| for line in match.group(1).splitlines():
|
| if ":" in line:
|
| key, value = line.split(":", 1)
|
| fields[key.strip()] = value.strip()
|
| return fields
|
|
|
|
|
| def run_check(*args: str) -> subprocess.CompletedProcess[str]:
|
| return subprocess.run(
|
| [sys.executable, str(CHECK), *args],
|
| text=True,
|
| encoding="utf-8",
|
| env={**os.environ, "PYTHONIOENCODING": "utf-8"},
|
| capture_output=True,
|
| check=False,
|
| )
|
|
|
|
|
| def finding_kinds(result: subprocess.CompletedProcess[str]) -> set[str]:
|
| payload = json.loads(result.stdout)
|
| return {row["kind"] for row in payload["findings"]}
|
|
|
|
|
| def reference_trigger(prompt: str) -> str:
|
| if "$speak-human" in prompt or "speak-human" in prompt:
|
| return "TRIGGER"
|
| if EXPLICIT_NON_TRIGGER.search(prompt):
|
| return "NO_TRIGGER"
|
| return (
|
| "TRIGGER"
|
| if POSITIVE_ACTION.search(prompt) and HUMAN_WRITING.search(prompt)
|
| else "NO_TRIGGER"
|
| )
|
|
|
|
|
| class SpeakHumanContractTests(unittest.TestCase):
|
| def test_package_layout_and_frontmatter(self):
|
| self.assertEqual(package_files(), PACKAGE_FILES)
|
| for filename in ("SKILL.md", "SKILL.zh-CN.md"):
|
| fields = parse_frontmatter(SKILL / filename)
|
| self.assertEqual(set(fields), {"name", "description"})
|
| self.assertEqual(fields["name"], "speak-human")
|
|
|
| def test_version_and_core_mode_contract(self):
|
| payload = json.loads(RULES.read_text(encoding="utf-8"))
|
| plugin = json.loads(PLUGIN.read_text(encoding="utf-8"))
|
| self.assertEqual(payload["standard_version"], VERSION)
|
| self.assertEqual(payload["package_version"], VERSION)
|
| self.assertEqual(plugin["version"], VERSION)
|
| self.assertEqual(plugin["name"], "speak-human")
|
| self.assertIn("human-facing communication", plugin["description"].lower())
|
| self.assertNotIn("public copy", plugin["description"].lower())
|
| self.assertEqual(set(payload["modes"]), MODES)
|
| self.assertNotIn("scenes", payload)
|
|
|
| def test_social_media_is_an_optional_adapter(self):
|
| payload = json.loads(RULES.read_text(encoding="utf-8"))
|
| self.assertTrue(
|
| all(rule["domain"] == "GENERAL_CORE" for rule in payload["rules"])
|
| )
|
| self.assertNotIn("social_media", payload["modes"])
|
| self.assertTrue((SKILL / "references" / "social-media.md").exists())
|
| helper = CHECK.read_text(encoding="utf-8")
|
| for token in ("X 已爆", "小红书", "information_gap_diagnostic"):
|
| self.assertNotIn(token, helper)
|
|
|
| def test_openai_metadata_describes_general_communication(self):
|
| metadata = (SKILL / "agents" / "openai.yaml").read_text(encoding="utf-8")
|
| lines = [line.rstrip() for line in metadata.splitlines() if line.strip()]
|
| self.assertEqual(lines[0], "interface:")
|
| self.assertEqual(
|
| {line.strip().split(":", 1)[0] for line in lines[1:]},
|
| {"display_name", "short_description", "brand_color", "default_prompt"},
|
| )
|
| self.assertTrue(all(line.startswith(" ") for line in lines[1:]))
|
| self.assertIn(' display_name: "Speak Human"', lines)
|
| self.assertIn("$speak-human", metadata)
|
| self.assertRegex(metadata.lower(), r"communication|沟通")
|
|
|
| def test_bilingual_skill_keeps_core_contract(self):
|
| english = (SKILL / "SKILL.md").read_text(encoding="utf-8")
|
| chinese = (SKILL / "SKILL.zh-CN.md").read_text(encoding="utf-8")
|
| for token in (
|
| "status updates",
|
| "explanations",
|
| "recommendations",
|
| "emails",
|
| "README",
|
| "resumes",
|
| "replies",
|
| "Social media is an adapter, not the default.",
|
| "private | internal | external | public",
|
| "scripts/check.py",
|
| VERSION,
|
| "silent obligations",
|
| "Do not manufacture a lesson",
|
| ):
|
| self.assertIn(token, english)
|
| for token in (
|
| "进度汇报",
|
| "解释说明",
|
| "建议与决策",
|
| "邮件",
|
| "README",
|
| "简历",
|
| "回复",
|
| "社媒只是适配层，不是默认场景。",
|
| "private | internal | external | public",
|
| "scripts/check.py",
|
| VERSION,
|
| "内部要遵守的条件",
|
| "不要再强行补教训",
|
| ):
|
| self.assertIn(token, chinese)
|
|
|
| def test_all_public_version_surfaces_match(self):
|
| surfaces = {
|
| ".claude-plugin/plugin.json": PLUGIN.read_text(encoding="utf-8"),
|
| "CHANGELOG.md": (REPO / "CHANGELOG.md").read_text(encoding="utf-8"),
|
| "README.md": (REPO / "README.md").read_text(encoding="utf-8"),
|
| "README.zh-CN.md": (REPO / "README.zh-CN.md").read_text(
|
| encoding="utf-8"
|
| ),
|
| "skills/speak-human/SKILL.md": (SKILL / "SKILL.md").read_text(
|
| encoding="utf-8"
|
| ),
|
| "skills/speak-human/SKILL.zh-CN.md": (
|
| SKILL / "SKILL.zh-CN.md"
|
| ).read_text(encoding="utf-8"),
|
| "skills/speak-human/references/core-rules.json": RULES.read_text(
|
| encoding="utf-8"
|
| ),
|
| }
|
| for name, text in surfaces.items():
|
| self.assertIn(VERSION, text, name)
|
|
|
| def test_readme_relative_links_resolve(self):
|
| for name in ("README.md", "README.zh-CN.md", "中文用户看这里.md"):
|
| text = (REPO / name).read_text(encoding="utf-8")
|
| for target in re.findall(r"\]\(([^)]+)\)", text):
|
| if target.startswith(("http://", "https://", "#")):
|
| continue
|
| path_only = target.split("#", 1)[0]
|
| self.assertTrue((REPO / path_only).exists(), f"{name}: {target}")
|
|
|
| def test_repository_contains_no_private_material(self):
|
| old_names = ("human" + "-voice-zh", "Human" + " Voice ZH")
|
| hits = []
|
| for path in REPO.rglob("*"):
|
| if (
|
| not path.is_file()
|
| or ".git" in path.parts
|
| or "__pycache__" in path.parts
|
| or "tests" in path.parts
|
| or path.name in {"LICENSE", "LICENSE.txt"}
|
| ):
|
| continue
|
| text = path.read_text(encoding="utf-8")
|
| for old_name in old_names:
|
| if old_name in text:
|
| hits.append((path.relative_to(REPO).as_posix(), "old_name"))
|
| if PRIVATE_PLACEHOLDERS.search(text):
|
| hits.append(
|
| (path.relative_to(REPO).as_posix(), "private_placeholder")
|
| )
|
| self.assertEqual(hits, [])
|
|
|
| def test_check_local_paths_follow_exposure(self):
|
| text = r"Build log: C:\Users\someone\project\output.txt"
|
| for exposure in ("external", "public"):
|
| result = run_check("--exposure", exposure, "--text", text)
|
| self.assertEqual(result.returncode, 2, result.stderr)
|
| self.assertIn("local_path", finding_kinds(result))
|
|
|
| internal = run_check("--exposure", "internal", "--text", text)
|
| self.assertEqual(internal.returncode, 0, internal.stderr)
|
| payload = json.loads(internal.stdout)
|
| self.assertEqual(payload["exposure"], "internal")
|
| self.assertEqual(payload["findings"], [])
|
|
|
| def test_check_unc_paths_follow_exposure(self):
|
| text = r"Build log: \\corp-server\private\draft.md"
|
| for exposure in ("external", "public"):
|
| result = run_check("--exposure", exposure, "--text", text)
|
| self.assertEqual(result.returncode, 2, result.stderr)
|
| self.assertIn("unc_path", finding_kinds(result))
|
| self.assertTrue(
|
| any(
|
| row["kind"] == "unc_path" and row["severity"] == "P0"
|
| for row in json.loads(result.stdout)["findings"]
|
| )
|
| )
|
|
|
| for exposure in ("private", "internal"):
|
| result = run_check("--exposure", exposure, "--text", text)
|
| self.assertEqual(result.returncode, 0, result.stderr)
|
| self.assertEqual(json.loads(result.stdout)["findings"], [])
|
|
|
| def test_check_credentials_are_always_flagged(self):
|
| samples = (
|
| ('api_token="abcdefghijk"', "credential_assignment", "abcdefghijk"),
|
| ("api_token='zyxwvutsrqp'", "credential_assignment", "zyxwvutsrqp"),
|
| (
|
| "OPENAI_API_KEY='sk-proj_abcdefghijklmnopqrstuvwxyz123456'",
|
| "credential_assignment",
|
| "sk-proj_abcdefghijklmnopqrstuvwxyz123456",
|
| ),
|
| (
|
| "refresh_token=rt_abcdefghijklmnopqrstuvwxyz123456",
|
| "credential_assignment",
|
| "rt_abcdefghijklmnopqrstuvwxyz123456",
|
| ),
|
| (
|
| "password='Tr0ub4dor!42'",
|
| "credential_assignment",
|
| "Tr0ub4dor!42",
|
| ),
|
| (
|
| "Authorization: Bearer ghp_abcdefghijklmnopqrstuvwxyz123456",
|
| "credential_bearer",
|
| "ghp_abcdefghijklmnopqrstuvwxyz123456",
|
| ),
|
| )
|
| for text, expected_kind, secret in samples:
|
| for exposure in ("private", "internal", "external", "public"):
|
| result = run_check("--exposure", exposure, "--text", text)
|
| self.assertEqual(result.returncode, 2, result.stderr)
|
| self.assertIn(expected_kind, finding_kinds(result))
|
| self.assertNotIn(secret, result.stdout)
|
| self.assertTrue(
|
| any(
|
| row["kind"] == expected_kind
|
| and row["severity"] == "P0"
|
| and row["preview"].endswith("[REDACTED]")
|
| for row in json.loads(result.stdout)["findings"]
|
| )
|
| )
|
|
|
| def test_check_credential_discussion_is_not_flagged(self):
|
| samples = (
|
| "The API token field accepts at least eight characters.",
|
| "Set the Authorization header to use the Bearer scheme.",
|
| "Never paste a password or secret into a public post.",
|
| "token: authentication",
|
| )
|
| for text in samples:
|
| result = run_check("--exposure", "public", "--text", text)
|
| self.assertEqual(result.returncode, 0, result.stderr)
|
| self.assertEqual(json.loads(result.stdout)["findings"], [])
|
|
|
| def test_check_internal_markers_follow_exposure(self):
|
| text = "【待校正】发布完成"
|
| for exposure in ("external", "public"):
|
| result = run_check("--exposure", exposure, "--text", text)
|
| self.assertEqual(result.returncode, 2, result.stderr)
|
| self.assertIn("internal_marker", finding_kinds(result))
|
|
|
| internal = run_check("--exposure", "internal", "--text", text)
|
| self.assertEqual(internal.returncode, 0, internal.stderr)
|
| self.assertEqual(json.loads(internal.stdout)["findings"], [])
|
|
|
| def test_check_file_input_and_voice_profile(self):
|
| with tempfile.TemporaryDirectory() as temp_dir:
|
| root = Path(temp_dir)
|
| source = root / "draft.txt"
|
| source.write_text("No sensitive material here.", encoding="utf-8")
|
| profile = root / "profile.json"
|
| profile.write_text(
|
| json.dumps(
|
| {
|
| "profile_version": "1.0.0",
|
| "languages": ["en"],
|
| "global_prefer": ["lead with the conclusion"],
|
| }
|
| ),
|
| encoding="utf-8",
|
| )
|
| result = run_check(
|
| "--exposure",
|
| "internal",
|
| "--file",
|
| str(source),
|
| "--voice-profile",
|
| str(profile),
|
| )
|
| self.assertEqual(result.returncode, 0, result.stderr)
|
| payload = json.loads(result.stdout)
|
| self.assertEqual(payload["exposure"], "internal")
|
| self.assertTrue(payload["voice_profile_loaded"])
|
| self.assertEqual(payload["findings"], [])
|
|
|
| invalid = root / "invalid-profile.json"
|
| invalid.write_text(
|
| json.dumps(
|
| {
|
| "profile_version": "1.0.0",
|
| "languages": ["en"],
|
| "mode_preferences": {
|
| "status_update": {"prefer": "not-a-list"}
|
| },
|
| }
|
| ),
|
| encoding="utf-8",
|
| )
|
| rejected = run_check(
|
| "--exposure",
|
| "internal",
|
| "--text",
|
| "No sensitive material here.",
|
| "--voice-profile",
|
| str(invalid),
|
| )
|
| self.assertEqual(rejected.returncode, 1)
|
| self.assertIn("must be a string list", rejected.stderr)
|
|
|
| duplicate_languages = root / "duplicate-languages.json"
|
| duplicate_languages.write_text(
|
| json.dumps(
|
| {
|
| "profile_version": "1.0.0",
|
| "languages": ["en", "en"],
|
| }
|
| ),
|
| encoding="utf-8",
|
| )
|
| rejected_duplicate = run_check(
|
| "--exposure",
|
| "internal",
|
| "--text",
|
| "No sensitive material here.",
|
| "--voice-profile",
|
| str(duplicate_languages),
|
| )
|
| self.assertEqual(rejected_duplicate.returncode, 1)
|
| self.assertIn("must not contain duplicates", rejected_duplicate.stderr)
|
|
|
| def test_trigger_and_non_trigger_fixtures(self):
|
| rows = [
|
| json.loads(line)
|
| for line in EVALS.read_text(encoding="utf-8").splitlines()
|
| if line.strip()
|
| ]
|
| self.assertEqual(len(rows), 24)
|
| self.assertEqual(len({row["id"] for row in rows}), 24)
|
| self.assertEqual(
|
| sum(row["expected"] == "TRIGGER" for row in rows),
|
| 12,
|
| )
|
| self.assertEqual(
|
| sum(row["expected"] == "NO_TRIGGER" for row in rows),
|
| 12,
|
| )
|
| positive_rows = [row for row in rows if row["expected"] == "TRIGGER"]
|
| self.assertLessEqual(
|
| sum(bool(SOCIAL_CONTEXT.search(row["prompt"])) for row in positive_rows),
|
| 3,
|
| "social media must remain an optional adapter, not the core trigger surface",
|
| )
|
| for row in rows:
|
| self.assertEqual(
|
| reference_trigger(row["prompt"]),
|
| row["expected"],
|
| row["id"],
|
| )
|
|
|
| def test_published_package_contains_no_private_placeholders(self):
|
| hits = []
|
| for path in SKILL.rglob("*"):
|
| if not path.is_file() or path.name == "LICENSE.txt":
|
| continue
|
| text = path.read_text(encoding="utf-8")
|
| if PRIVATE_PLACEHOLDERS.search(text):
|
| hits.append(path.relative_to(SKILL).as_posix())
|
| self.assertEqual(hits, [])
|
|
|
|
|
| if __name__ == "__main__":
|
| unittest.main()
|
|
|
