@jairodri/huckleberry-cli 1.0.2 → 1.1.0

package/skills/claw-compactor/tests/test_tokenizer_optimizer.py

@@ -0,0 +1,175 @@
+"""Tests for tokenizer-aware format optimization."""
+
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+from lib.tokenizer_optimizer import (
+    normalize_punctuation, strip_bold_italic, strip_trivial_backticks,
+    minimize_whitespace, compact_bullets, compress_table_to_kv,
+    optimize_tokens, estimate_savings,
+)
+from lib.tokens import estimate_tokens
+
+
+class TestNormalizePunctuation:
+    def test_chinese_punctuation(self):
+        text = "你好，世界。这是：测试！"
+        result = normalize_punctuation(text)
+        assert "，" not in result
+        assert "。" not in result
+        assert "：" not in result
+        assert "！" not in result
+        assert "," in result
+        assert "." in result
+
+    def test_brackets(self):
+        result = normalize_punctuation("（测试）")
+        assert "(" in result
+        assert ")" in result
+
+    def test_no_change_ascii(self):
+        text = "hello, world!"
+        assert normalize_punctuation(text) == text
+
+    def test_mixed(self):
+        text = "IP：192.168.1.1，端口：8080"
+        result = normalize_punctuation(text)
+        assert result == "IP:192.168.1.1,端口:8080"
+
+    def test_token_savings(self):
+        text = "这是一个测试，包含很多中文标点。还有冒号：分号；感叹号！"
+        before = estimate_tokens(text)
+        after = estimate_tokens(normalize_punctuation(text))
+        assert after <= before
+
+
+class TestStripBoldItalic:
+    def test_bold(self):
+        assert strip_bold_italic("**hello**") == "hello"
+
+    def test_italic(self):
+        assert strip_bold_italic("*hello*") == "hello"
+
+    def test_mixed(self):
+        text = "This is **bold** and *italic* text"
+        result = strip_bold_italic(text)
+        assert result == "This is bold and italic text"
+
+
+class TestStripTrivialBackticks:
+    def test_simple_word(self):
+        assert strip_trivial_backticks("`hello`") == "hello"
+
+    def test_keeps_complex(self):
+        # Backticks with spaces should be kept (actual code)
+        text = "`hello world`"
+        assert strip_trivial_backticks(text) == text
+
+
+class TestMinimizeWhitespace:
+    def test_multiple_spaces(self):
+        text = "hello    world"
+        result = minimize_whitespace(text)
+        assert "    " not in result
+
+    def test_deep_indentation(self):
+        text = "        deep indent"
+        result = minimize_whitespace(text)
+        assert len(result) - len(result.lstrip()) <= 4
+
+
+class TestCompressTableToKv:
+    def test_simple_table(self):
+        text = "| Key | Value |\n|-----|-------|\n| Name | Duke |\n| Role | CEO |"
+        result = compress_table_to_kv(text)
+        assert "Name: Duke" in result
+        assert "Role: CEO" in result
+
+    def test_multi_column(self):
+        text = "| A | B | C |\n|---|---|---|\n| 1 | 2 | 3 |"
+        result = compress_table_to_kv(text)
+        # Should convert to compact format
+        assert len(result) < len(text)
+
+    def test_no_table(self):
+        text = "Just normal text without tables"
+        assert compress_table_to_kv(text) == text
+
+    def test_token_savings(self):
+        table = (
+            "| Server | IP | Status |\n"
+            "|--------|-----|--------|\n"
+            "| Gateway | 192.168.1.1 | Online |\n"
+            "| Node1 | 192.168.1.2 | Online |\n"
+            "| Node2 | 192.168.1.3 | Offline |"
+        )
+        before = estimate_tokens(table)
+        after = estimate_tokens(compress_table_to_kv(table))
+        assert after < before
+
+
+class TestCompactBullets:
+    def test_long_bullet_list(self):
+        text = "- item1\n- item2\n- item3\n- item4"
+        result = compact_bullets(text)
+        # Should remove bullet prefixes for 3+ consecutive
+        assert "- " not in result or result.count("- ") < text.count("- ")
+
+    def test_short_list_kept(self):
+        text = "- item1\n- item2"
+        result = compact_bullets(text)
+        assert "- " in result  # Only 2 items, keep bullets
+
+
+class TestOptimizeTokens:
+    def test_basic(self):
+        text = (
+            "**Server Config**\n\n"
+            "| Key | Value |\n|-----|-------|\n| IP | 192.168.1.1 |\n"
+            "状态：正常，端口：8080\n"
+        )
+        result = optimize_tokens(text)
+        assert estimate_tokens(result) <= estimate_tokens(text)
+
+    def test_aggressive(self):
+        text = "**Bold** and *italic* with `backticks`\n- item1\n- item2\n- item3\n- item4"
+        normal = optimize_tokens(text, aggressive=False)
+        aggressive = optimize_tokens(text, aggressive=True)
+        assert len(aggressive) <= len(normal)
+
+    def test_empty(self):
+        assert optimize_tokens("") == ""
+
+    def test_unicode_preserved(self):
+        text = "中文内容 English content 日本語"
+        result = optimize_tokens(text)
+        assert "中文" in result
+        assert "English" in result
+
+
+class TestEstimateSavings:
+    def test_basic(self):
+        original = "**Bold** text，with中文标点。\n| K | V |\n|--|--|\n| a | b |"
+        optimized = optimize_tokens(original, aggressive=True)
+        stats = estimate_savings(original, optimized)
+        assert stats["original_tokens"] > 0
+        assert stats["optimized_tokens"] > 0
+        assert stats["token_reduction_pct"] >= 0
+
+    def test_real_workspace_text(self):
+        text = """## SSH 密钥 (在 ~/.ssh/)
+| 密钥 | 可访问 |
+|------|--------|
+| `id_ed25519_mykey` | remote server, local Linux, worker-1, worker-2 |
+| `server_key.pem` | remote server, local Linux, worker-1, worker-2 |
+| `admin_key.pem` | worker-1.lan, worker-2.lan (user: admin) |
+
+**任意密钥**可登任意节点。
+"""
+        optimized = optimize_tokens(text, aggressive=True)
+        stats = estimate_savings(text, optimized)
+        assert stats["token_reduction_pct"] > 0
+        assert "密钥" in optimized

package/skills/claw-compactor/tests/test_tokenizer_optimizer_comprehensive.py

@@ -0,0 +1,241 @@
+"""Comprehensive tests for lib/tokenizer_optimizer.py."""
+import sys
+import pytest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+from lib.tokenizer_optimizer import (
+    strip_bold_italic, strip_trivial_backticks, normalize_punctuation,
+    compress_table_to_kv, compact_bullets, minimize_whitespace,
+    optimize_tokens, estimate_savings,
+)
+
+
+class TestStripBoldItalic:
+    def test_strips_bold(self):
+        assert "hello" in strip_bold_italic("**hello**")
+        assert "**" not in strip_bold_italic("**hello**")
+
+    def test_strips_italic(self):
+        result = strip_bold_italic("*hello*")
+        assert "hello" in result
+
+    def test_mixed(self):
+        result = strip_bold_italic("**bold** and *italic* text")
+        assert "bold" in result
+        assert "italic" in result
+
+    def test_no_markers(self):
+        assert strip_bold_italic("plain text") == "plain text"
+
+    def test_empty(self):
+        assert strip_bold_italic("") == ""
+
+    def test_nested(self):
+        result = strip_bold_italic("***bold italic***")
+        assert isinstance(result, str)
+
+    def test_preserves_asterisks_in_code(self):
+        # Backtick-wrapped asterisks should ideally be preserved
+        result = strip_bold_italic("use `**kwargs` in Python")
+        assert isinstance(result, str)
+
+    def test_multiline(self):
+        text = "**line1**\n**line2**\n*line3*"
+        result = strip_bold_italic(text)
+        assert "line1" in result
+        assert "line2" in result
+
+
+class TestStripTrivialBackticks:
+    def test_strips_simple_word(self):
+        result = strip_trivial_backticks("`hello`")
+        assert "hello" in result
+
+    def test_keeps_code_content(self):
+        # Content with spaces or special chars should be kept
+        result = strip_trivial_backticks("`ls -la`")
+        assert "ls" in result
+
+    def test_empty(self):
+        assert strip_trivial_backticks("") == ""
+
+    def test_no_backticks(self):
+        assert strip_trivial_backticks("plain") == "plain"
+
+    def test_code_block_preserved(self):
+        text = "```python\ncode here\n```"
+        result = strip_trivial_backticks(text)
+        assert "code here" in result
+
+
+class TestNormalizePunctuation:
+    def test_chinese_comma(self):
+        assert "，" not in normalize_punctuation("你好，世界")
+
+    def test_chinese_period(self):
+        assert "。" not in normalize_punctuation("完成。")
+
+    def test_no_change_english(self):
+        text = "Hello, world."
+        assert normalize_punctuation(text) == text
+
+    def test_empty(self):
+        assert normalize_punctuation("") == ""
+
+    def test_all_chinese_punct(self):
+        text = "测试，内容。问题？回答！"
+        result = normalize_punctuation(text)
+        assert "，" not in result
+        assert "。" not in result
+
+
+class TestCompressTableToKv:
+    def test_basic_table(self):
+        text = "| Key | Value |\n|-----|-------|\n| name | Alice |\n| age | 30 |"
+        result = compress_table_to_kv(text)
+        assert "Alice" in result
+        assert "30" in result
+        assert len(result) <= len(text)
+
+    def test_no_table(self):
+        text = "just text"
+        assert compress_table_to_kv(text) == text
+
+    def test_empty(self):
+        assert compress_table_to_kv("") == ""
+
+    def test_three_columns(self):
+        text = "| A | B | C |\n|---|---|---|\n| 1 | 2 | 3 |"
+        result = compress_table_to_kv(text)
+        assert "1" in result
+
+    def test_table_with_text_around(self):
+        text = "Header:\n| K | V |\n|---|---|\n| x | y |\nFooter"
+        result = compress_table_to_kv(text)
+        assert "Header" in result
+        assert "Footer" in result
+
+    def test_savings_on_real_table(self):
+        text = (
+            "| Setting | Value | Description |\n"
+            "|---------|-------|-------------|\n"
+            "| timeout | 30s | Request timeout |\n"
+            "| retries | 3 | Maximum retry count |\n"
+            "| workers | 8 | Number of workers |\n"
+            "| buffer | 4096 | Buffer size bytes |\n"
+        )
+        result = compress_table_to_kv(text)
+        assert len(result) < len(text)
+
+
+class TestCompactBullets:
+    def test_removes_prefixes(self):
+        text = "- item 1\n- item 2\n- item 3"
+        result = compact_bullets(text)
+        assert isinstance(result, str)
+
+    def test_empty(self):
+        assert compact_bullets("") == ""
+
+    def test_no_bullets(self):
+        text = "paragraph text"
+        assert compact_bullets(text) == text
+
+    def test_nested_bullets(self):
+        text = "- outer\n  - inner\n  - inner2\n- outer2"
+        result = compact_bullets(text)
+        assert isinstance(result, str)
+
+    def test_numbered_list(self):
+        text = "1. first\n2. second\n3. third"
+        result = compact_bullets(text)
+        assert isinstance(result, str)
+
+
+class TestMinimizeWhitespace:
+    def test_collapses_blanks(self):
+        text = "a\n\n\n\nb"
+        result = minimize_whitespace(text)
+        assert "\n\n\n" not in result
+        assert "a" in result and "b" in result
+
+    def test_strips_trailing(self):
+        text = "hello   \nworld   "
+        result = minimize_whitespace(text)
+        assert "   " not in result or result.strip() == result.strip()
+
+    def test_empty(self):
+        assert minimize_whitespace("") == ""
+
+    def test_single_line(self):
+        assert minimize_whitespace("hello") == "hello"
+
+    def test_tabs(self):
+        text = "\thello\t\tworld"
+        result = minimize_whitespace(text)
+        assert isinstance(result, str)
+
+
+class TestOptimizeTokens:
+    def test_basic(self):
+        text = "**Bold** text，中文。And `simple` backticks"
+        result = optimize_tokens(text)
+        assert isinstance(result, str)
+
+    def test_aggressive(self):
+        text = "**Bold** text with | table | data |\n|---|---|\n| a | b |"
+        result = optimize_tokens(text, aggressive=True)
+        assert isinstance(result, str)
+
+    def test_empty(self):
+        assert optimize_tokens("") == ""
+
+    def test_idempotent(self):
+        """Running twice should give same result."""
+        text = "**Some** text，with `stuff`"
+        first = optimize_tokens(text)
+        second = optimize_tokens(first)
+        assert first == second
+
+    def test_never_increases_tokens(self):
+        """Optimization should never make text use more tokens."""
+        from lib.tokens import estimate_tokens
+        texts = [
+            "**Bold** and *italic* markers",
+            "| Table | Here |\n|-------|------|\n| a | b |",
+            "中文，标点。测试！",
+            "- item1\n- item2\n- item3",
+            "   lots   of   spaces   ",
+        ]
+        for text in texts:
+            optimized = optimize_tokens(text)
+            # Token count should not increase (or increase minimally)
+            orig_tokens = estimate_tokens(text)
+            opt_tokens = estimate_tokens(optimized)
+            assert opt_tokens <= orig_tokens + 2, f"Increased tokens for: {text[:50]}"
+
+
+class TestEstimateSavings:
+    def test_basic(self):
+        original = "**Bold** text with redundancy"
+        optimized = "Bold text with redundancy"
+        stats = estimate_savings(original, optimized)
+        assert "original_tokens" in stats
+        assert "optimized_tokens" in stats
+        assert stats["optimized_tokens"] <= stats["original_tokens"]
+
+    def test_no_change(self):
+        text = "plain text"
+        stats = estimate_savings(text, text)
+        assert stats["original_tokens"] == stats["optimized_tokens"]
+
+    def test_empty(self):
+        stats = estimate_savings("", "")
+        assert stats["original_tokens"] == 0
+
+    def test_significant_savings(self):
+        original = "    - item one: the first value    \n    - item two: the second value    \n" * 20
+        optimized = "item one:first value\nitem two:second value\n" * 20
+        stats = estimate_savings(original, optimized)
+        assert stats["optimized_tokens"] < stats["original_tokens"]

package/skills/claw-compactor/tests/test_tokens.py

@@ -0,0 +1,27 @@
+"""Tests for lib.tokens module."""
+
+from lib.tokens import estimate_tokens, using_tiktoken
+
+
+class TestEstimateTokens:
+    def test_empty(self) -> None:
+        assert estimate_tokens("") == 0
+
+    def test_short(self) -> None:
+        assert estimate_tokens("abc") >= 1
+
+    def test_known_length(self) -> None:
+        result = estimate_tokens("a" * 400)
+        assert 50 <= result <= 200
+
+    def test_large(self) -> None:
+        assert estimate_tokens("x" * 400_000) >= 50_000
+
+    def test_unicode_chinese(self) -> None:
+        assert estimate_tokens("你好世界测试" * 100) > 0
+
+    def test_mixed(self) -> None:
+        assert estimate_tokens("Hello 你好 `code` **bold**") > 0
+
+    def test_using_tiktoken_bool(self) -> None:
+        assert isinstance(using_tiktoken(), bool)

package/skills/cmo/CHANGELOG.md

@@ -0,0 +1,61 @@
+# /cmo skill changelog
+
+## 2026-04-21 — D1: Studio-era upgrade
+
+Full audit + upgrade of the /cmo skill surface. Shipped as three passes to keep each commit reviewable.
+
+### Pass 1 — Additive scope (`a6a2a86`, `9af7a2f`, `722cf8d`)
+
+New rule files:
+- `rules/studio-integration.md` — the five studio verbs (schema-fetch, activity, navigate, toast, brand-refresh), mirror-vs-hide decision tree, order-of-operations for combined writes, fire-and-forget failure handling, schema introspection via `/api/schema`.
+- `rules/monorepo.md` — sibling project guidance for marketing-cli, mktg-studio, the marketing site, and optional private notes, pointer to `ORCHESTRATOR.md` as authoritative file-ownership map, cross-sibling `--cwd` protocol, red flags.
+
+New playbooks in `rules/playbooks.md`:
+- #11 Studio Launch Playbook — `mktg init` → `mktg studio` → foundation research → tabs light up → dashboard live.
+- #12 Agent Team Coordination Playbook — parallel sub-agent spawn in a single message, synthesis, learnings compounding.
+
+New command reference rows in `rules/command-reference.md`:
+- `mktg studio`, `mktg studio --open`, `mktg studio --dry-run --json`.
+
+Top-level `SKILL.md` references the two new rule files.
+
+Corrections shipped as separate commits:
+- `9af7a2f` — fixed monorepo sibling names and added `ORCHESTRATOR.md` pointer per team broadcast.
+- `722cf8d` — added schema-fetch as the 5th studio verb (previous draft had 4 POSTs; the read-only GET `/api/schema` is the boot-time handshake).
+
+### Pass 2 — Routing table cross-reference (`6437435`)
+
+Methodology: parsed `skills-manifest.json` programmatically, grep-verified each of the 50 skill names against `skills/cmo/SKILL.md` + `rules/*.md`.
+
+Findings:
+- All 50 manifest skills have surface in cmo rules. No orphans.
+- All playbook skill references resolve (only unknown token was `mktg-studio`, which is the binary name referenced from the new Studio Launch playbook).
+- postiz, brand-kit-playground, content-atomizer triggers all match the manifest.
+
+One gap fixed: `firecrawl` had no positive routing row — only appeared as NOT-THIS in disambiguation. Added a routing row + three disambiguation rows clarifying the `firecrawl` / Exa MCP / `/last30days` decision tree.
+
+### Pass 3 — Error recovery, ecosystem axis, quality gate verification (`e34bfe6`, `95b67e1`, this commit)
+
+`rules/error-recovery.md`: four new rows.
+- Studio offline: revert to standalone mode, skip all studio POSTs, no backfill on reconnect.
+- SSE drop: hashed activity POSTs vs rendered UI lag detection, 60-second backoff, tied to the studio reconnect fix.
+- Postiz rate limit (30/hour): three-tier fallback chain (typefully for the platforms it covers, then file adapter for the rest, then pause + persist + resume). Never silently wait the hour.
+- Postiz instance unreachable (non-rate-limit): degrade with honesty, name the failing base URL.
+
+`rules/progressive-enhancement.md`: added the E0-E4 ecosystem axis as a complement (not replacement) to the existing L0-L4 brand axis.
+- E0 CLI only, E1 +brand, E2 +studio, E3 +postiz, E4 +full ecosystem.
+- Two-axis routing section: L4/E0 ships polished copy to files, L1/E3 distributes thin content loudly, sweet spot is L3+/E2+.
+
+`rules/quality-gate.md`: verified against current skill surface. The 4-gate chain (editorial-first-pass → ai-check → mktg-content-reviewer → mktg-seo-analyst) is current. No new review skills have landed since the rule was written. No edit required.
+
+### Summary by the numbers
+
+- 2 new rule files (studio-integration, monorepo)
+- 2 new playbooks (Studio Launch, Agent Team Coordination)
+- 1 new routing row + 3 disambiguation rows (firecrawl)
+- 4 new error-recovery rows (studio offline, SSE drop, postiz rate limit, postiz unreachable)
+- 1 new progressive-enhancement axis (E0-E4)
+- ~450 lines added across 7 commits
+- 0 destructive rebases, 0 stale skill references, 0 orphan manifest entries
+
+Next: F2 (#20) — cross-check marketing-cli + new studio command against `/agent-dx-cli-scale`.