@jairodri/huckleberry-cli 1.0.2 → 1.1.0

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

@@ -0,0 +1,122 @@
+"""Tests for the benchmark command output."""
+import argparse
+import json
+import sys
+import pytest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+from mem_compress import cmd_benchmark
+
+
+class TestBenchmarkOutput:
+    """Test benchmark report format and content."""
+
+    def _make_workspace(self, tmp_path):
+        (tmp_path / "MEMORY.md").write_text(
+            "# Memory\n\n## Important Decisions\n"
+            "- Decided to use Python 3.11 for all scripts\n"
+            "- Decided to use pytest for testing framework\n"
+            "- Decided to use tiktoken for token estimation\n\n"
+            "## Configuration Notes\n"
+            "| Setting | Value | Description |\n"
+            "|---------|-------|-------------|\n"
+            "| timeout | 30s | Request timeout |\n"
+            "| retries | 3 | Max retries |\n"
+            "| workers | 8 | Parallel workers |\n\n"
+            "## Daily Log\n"
+            "- 2026-01-01: Set up project\n"
+            "- 2026-01-02: Added compression\n"
+            "- 2026-01-03: Added dedup\n"
+        )
+        (tmp_path / "TOOLS.md").write_text(
+            "# Tools Reference\n\n"
+            "| Tool | Path | Notes |\n"
+            "|------|------|-------|\n"
+            "| python3 | /usr/bin/python3 | Main interpreter |\n"
+            "| node | /usr/bin/node | JavaScript runtime |\n"
+        )
+        mem = tmp_path / "memory"
+        mem.mkdir()
+        (mem / "2026-01-01.md").write_text("# January 1\n- Started project setup\n- Installed dependencies\n")
+        return tmp_path
+
+    def test_benchmark_has_header(self, tmp_path, capsys):
+        ws = self._make_workspace(tmp_path)
+        args = argparse.Namespace(json=False)
+        cmd_benchmark(ws, args)
+        out = capsys.readouterr().out
+        assert "claw-compactor Performance Report" in out
+
+    def test_benchmark_has_all_steps(self, tmp_path, capsys):
+        ws = self._make_workspace(tmp_path)
+        args = argparse.Namespace(json=False)
+        cmd_benchmark(ws, args)
+        out = capsys.readouterr().out
+        assert "Rule Engine" in out
+        assert "Dictionary Compress" in out
+        assert "RLE Patterns" in out
+        assert "Tokenizer Optimize" in out
+        assert "TOTAL (memory)" in out
+
+    def test_benchmark_has_savings_headline(self, tmp_path, capsys):
+        ws = self._make_workspace(tmp_path)
+        args = argparse.Namespace(json=False)
+        cmd_benchmark(ws, args)
+        out = capsys.readouterr().out
+        assert "Total savings:" in out
+        assert "💰" in out
+
+    def test_benchmark_has_session_info(self, tmp_path, capsys):
+        ws = self._make_workspace(tmp_path)
+        args = argparse.Namespace(json=False)
+        cmd_benchmark(ws, args)
+        out = capsys.readouterr().out
+        assert "Session Transcripts:" in out
+
+    def test_benchmark_has_recommendations(self, tmp_path, capsys):
+        ws = self._make_workspace(tmp_path)
+        args = argparse.Namespace(json=False)
+        cmd_benchmark(ws, args)
+        out = capsys.readouterr().out
+        assert "Recommendations:" in out
+
+    def test_benchmark_json_structure(self, tmp_path, capsys):
+        ws = self._make_workspace(tmp_path)
+        args = argparse.Namespace(json=True)
+        cmd_benchmark(ws, args)
+        data = json.loads(capsys.readouterr().out)
+        assert "steps" in data
+        assert len(data["steps"]) == 4
+        assert "total_before" in data
+        assert "total_after" in data
+        assert "total_saved" in data
+        assert "total_pct" in data
+        assert data["total_before"] >= data["total_after"]
+
+    def test_benchmark_step_names(self, tmp_path, capsys):
+        ws = self._make_workspace(tmp_path)
+        args = argparse.Namespace(json=True)
+        cmd_benchmark(ws, args)
+        data = json.loads(capsys.readouterr().out)
+        names = [s["name"] for s in data["steps"]]
+        assert names == ["Rule Engine", "Dictionary Compress", "RLE Patterns", "Tokenizer Optimize"]
+
+    def test_benchmark_saved_non_negative(self, tmp_path, capsys):
+        ws = self._make_workspace(tmp_path)
+        args = argparse.Namespace(json=True)
+        cmd_benchmark(ws, args)
+        data = json.loads(capsys.readouterr().out)
+        assert data["total_saved"] >= 0
+
+    def test_benchmark_empty_workspace(self, tmp_path):
+        args = argparse.Namespace(json=False)
+        result = cmd_benchmark(tmp_path, args)
+        assert result == 1  # No files found
+
+    def test_benchmark_date_in_output(self, tmp_path, capsys):
+        ws = self._make_workspace(tmp_path)
+        args = argparse.Namespace(json=False)
+        cmd_benchmark(ws, args)
+        out = capsys.readouterr().out
+        assert "Date:" in out

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

@@ -0,0 +1,228 @@
+"""CLI tests — every subcommand via subprocess, covering exit codes and output."""
+import json
+import subprocess
+import sys
+import pytest
+from pathlib import Path
+
+SCRIPT = str(Path(__file__).resolve().parent.parent / "scripts" / "mem_compress.py")
+PYTHON = sys.executable
+
+
+def run_cmd(workspace, command, *extra, timeout=30):
+    """Run mem_compress.py and return (exit_code, stdout, stderr)."""
+    args = [PYTHON, SCRIPT, str(workspace), command] + list(extra)
+    result = subprocess.run(args, capture_output=True, text=True, timeout=timeout)
+    return result.returncode, result.stdout, result.stderr
+
+
+@pytest.fixture
+def workspace(tmp_path):
+    """Create a realistic test workspace."""
+    (tmp_path / "MEMORY.md").write_text(
+        "# Memory\n\n## Decisions\n- Use Python 3.11\n- Use pytest\n- Use tiktoken\n\n"
+        "## Notes\n- Server IP: 192.168.1.100\n- Server IP: 192.168.1.100\n"
+        "- Backup runs at 3am\n\n"
+        "## Empty Section\n\n"
+    )
+    (tmp_path / "TOOLS.md").write_text(
+        "# Tools\n\n| Tool | Version | Path |\n|------|---------|------|\n"
+        "| Python | 3.11 | /usr/bin/python3 |\n| Node | 20 | /usr/bin/node |\n"
+        "| Docker | 24.0 | /usr/bin/docker |\n"
+    )
+    (tmp_path / "AGENTS.md").write_text(
+        "# Agents\n\nThis is the agents file.\n\n## Rules\n- Be helpful\n- Be concise\n"
+    )
+    mem = tmp_path / "memory"
+    mem.mkdir()
+    (mem / "2026-01-01.md").write_text("# Jan 1\n- Set up project\n- Installed deps\n")
+    (mem / "2026-01-02.md").write_text("# Jan 2\n- Added compression\n- Fixed bug #42\n")
+    return tmp_path
+
+
+class TestEstimateCLI:
+    def test_exit_code_0(self, workspace):
+        code, out, err = run_cmd(workspace, "estimate")
+        assert code == 0
+
+    def test_json_output(self, workspace):
+        code, out, err = run_cmd(workspace, "estimate", "--json")
+        assert code == 0
+        data = json.loads(out)
+        assert "files" in data
+
+    def test_threshold(self, workspace):
+        code, out, err = run_cmd(workspace, "estimate", "--threshold", "99999")
+        assert code == 0
+
+    def test_nonexistent_workspace(self, tmp_path):
+        code, out, err = run_cmd(tmp_path / "nope", "estimate")
+        assert code != 0
+
+
+class TestCompressCLI:
+    def test_exit_code_0(self, workspace):
+        code, out, err = run_cmd(workspace, "compress")
+        assert code == 0
+        assert "token" in out.lower() or "compress" in out.lower()
+
+    def test_dry_run(self, workspace):
+        original = (workspace / "MEMORY.md").read_text()
+        code, out, err = run_cmd(workspace, "compress", "--dry-run")
+        assert code == 0
+        assert (workspace / "MEMORY.md").read_text() == original
+
+    def test_json(self, workspace):
+        code, out, err = run_cmd(workspace, "compress", "--json")
+        assert code == 0
+        data = json.loads(out)
+        assert isinstance(data, list)
+
+    def test_shows_saved(self, workspace):
+        code, out, err = run_cmd(workspace, "compress")
+        assert code == 0
+        assert "saved" in out.lower()
+
+
+class TestDedupCLI:
+    def test_exit_code_0(self, workspace):
+        code, out, err = run_cmd(workspace, "dedup")
+        assert code == 0
+
+    def test_json(self, workspace):
+        code, out, err = run_cmd(workspace, "dedup", "--json")
+        assert code == 0
+        data = json.loads(out)
+        assert isinstance(data, dict)
+
+
+class TestTiersCLI:
+    def test_exit_code_0(self, workspace):
+        code, out, err = run_cmd(workspace, "tiers")
+        assert code == 0
+
+    def test_json(self, workspace):
+        code, out, err = run_cmd(workspace, "tiers", "--json")
+        assert code == 0
+        data = json.loads(out)
+        assert isinstance(data, dict)
+
+    def test_shows_levels(self, workspace):
+        code, out, err = run_cmd(workspace, "tiers")
+        assert "Level 0" in out or "level" in out.lower()
+
+
+class TestAuditCLI:
+    def test_exit_code_0(self, workspace):
+        code, out, err = run_cmd(workspace, "audit")
+        assert code == 0
+
+    def test_json(self, workspace):
+        code, out, err = run_cmd(workspace, "audit", "--json")
+        assert code == 0
+        data = json.loads(out)
+        assert isinstance(data, dict)
+
+    def test_stale_days(self, workspace):
+        code, out, err = run_cmd(workspace, "audit", "--stale-days", "1")
+        assert code == 0
+
+
+class TestDictCLI:
+    def test_exit_code_0(self, workspace):
+        code, out, err = run_cmd(workspace, "dict")
+        assert code == 0
+
+    def test_json(self, workspace):
+        code, out, err = run_cmd(workspace, "dict", "--json")
+        assert code == 0
+        data = json.loads(out)
+        assert isinstance(data, dict)
+
+    def test_creates_codebook(self, workspace):
+        run_cmd(workspace, "dict")
+        assert (workspace / "memory" / ".codebook.json").exists()
+
+
+class TestOptimizeCLI:
+    def test_exit_code_0(self, workspace):
+        code, out, err = run_cmd(workspace, "optimize")
+        assert code == 0
+        assert "token" in out.lower() or "optimiz" in out.lower()
+
+    def test_dry_run(self, workspace):
+        original = (workspace / "MEMORY.md").read_text()
+        code, out, err = run_cmd(workspace, "optimize", "--dry-run")
+        assert code == 0
+        assert (workspace / "MEMORY.md").read_text() == original
+
+    def test_json(self, workspace):
+        code, out, err = run_cmd(workspace, "optimize", "--json")
+        assert code == 0
+        data = json.loads(out)
+        assert "before" in data and "after" in data
+
+
+class TestBenchmarkCLI:
+    def test_exit_code_0(self, workspace):
+        code, out, err = run_cmd(workspace, "benchmark")
+        assert code == 0
+
+    def test_has_report_header(self, workspace):
+        code, out, err = run_cmd(workspace, "benchmark")
+        assert "Performance Report" in out
+
+    def test_has_savings_headline(self, workspace):
+        code, out, err = run_cmd(workspace, "benchmark")
+        assert "Total savings:" in out
+
+    def test_has_steps(self, workspace):
+        code, out, err = run_cmd(workspace, "benchmark")
+        assert "Rule Engine" in out
+        assert "TOTAL" in out
+
+    def test_json(self, workspace):
+        code, out, err = run_cmd(workspace, "benchmark", "--json")
+        assert code == 0
+        data = json.loads(out)
+        assert data["total_saved"] >= 0
+
+    def test_empty_workspace(self, tmp_path):
+        code, out, err = run_cmd(tmp_path, "benchmark")
+        assert code == 1  # No files
+
+
+class TestObserveCLI:
+    def test_no_sessions(self, workspace):
+        code, out, err = run_cmd(workspace, "observe")
+        # Should handle missing sessions dir
+        assert code in (0, 1)
+
+    def test_since_filter(self, workspace):
+        code, out, err = run_cmd(workspace, "observe", "--since", "2099-01-01")
+        assert code in (0, 1)
+
+
+class TestInvalidInputs:
+    def test_unknown_command(self, workspace):
+        result = subprocess.run(
+            [PYTHON, SCRIPT, str(workspace), "bogus"],
+            capture_output=True, text=True
+        )
+        assert result.returncode != 0
+
+    def test_missing_workspace(self):
+        result = subprocess.run(
+            [PYTHON, SCRIPT], capture_output=True, text=True
+        )
+        assert result.returncode != 0
+
+    def test_missing_command(self, workspace):
+        result = subprocess.run(
+            [PYTHON, SCRIPT, str(workspace)], capture_output=True, text=True
+        )
+        assert result.returncode != 0
+
+    def test_verbose_flag(self, workspace):
+        code, out, err = run_cmd(workspace, "estimate", "-v")
+        assert code == 0

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

@@ -0,0 +1,109 @@
+"""Tests for compress_memory.py."""
+
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+from compress_memory import rule_compress, generate_llm_prompt, compress_file, _collect_files
+
+
+class TestRuleCompress:
+    def test_removes_duplicate_lines(self):
+        result = rule_compress("# Title\n\n- item one\n- item one\n- item two\n")
+        assert result.count("item one") == 1
+        assert "item two" in result
+
+    def test_strips_redundant_blanks(self):
+        result = rule_compress("# Title\n\n\n\n\n\nContent\n\n\n\nMore")
+        assert "\n\n\n" not in result
+
+    def test_empty(self):
+        assert rule_compress("") == ""
+
+    def test_preserves_headers(self):
+        result = rule_compress("# Title\n\n## Section\n\nContent")
+        assert "# Title" in result
+        assert "## Section" in result
+
+    def test_unicode(self):
+        result = rule_compress("# 笔记\n\n- 你好世界\n- 你好世界\n- 独特内容\n")
+        assert result.count("你好世界") == 1
+
+    def test_large_input(self):
+        text = "# Large\n" + "".join("- Entry {}: content\n".format(i) for i in range(5000))
+        result = rule_compress(text)
+        assert len(result) <= len(text)
+
+    def test_broken_markdown(self):
+        assert isinstance(rule_compress("##NoSpace\n- \n```\nunclosed\n"), str)
+
+    def test_single_line(self):
+        assert rule_compress("Just one line.") == "Just one line."
+
+
+class TestGenerateLlmPrompt:
+    def test_contains_content(self):
+        prompt = generate_llm_prompt("some text")
+        assert "some text" in prompt
+
+    def test_target_pct(self):
+        assert "30%" in generate_llm_prompt("text", target_pct=30)
+
+    def test_empty(self):
+        assert isinstance(generate_llm_prompt(""), str)
+
+
+class TestCompressFile:
+    def test_dry_run(self, tmp_workspace):
+        mem = tmp_workspace / "MEMORY.md"
+        original = mem.read_text()
+        result = compress_file(mem, dry_run=True)
+        assert result["dry_run"] is True
+        assert mem.read_text() == original
+
+    def test_writes_output(self, tmp_path):
+        f = tmp_path / "test.md"
+        f.write_text("# Title\n\n- item\n- item\n- item\n\n\n\n")
+        result = compress_file(f, dry_run=False)
+        assert "written_to" in result
+        assert f.read_text().count("item") == 1
+
+    def test_output_file(self, tmp_path):
+        f = tmp_path / "src.md"
+        f.write_text("# Test\n\nContent\n")
+        out = tmp_path / "out.md"
+        compress_file(f, output=str(out))
+        assert out.exists()
+
+    def test_no_llm(self, tmp_path):
+        f = tmp_path / "t.md"
+        f.write_text("# Test\n\n" + "- Entry\n" * 100)
+        assert "llm_prompt" not in compress_file(f, dry_run=True, no_llm=True)
+
+    def test_stats(self, tmp_workspace):
+        result = compress_file(tmp_workspace / "MEMORY.md", dry_run=True)
+        assert result["original_tokens"] >= result["rule_compressed_tokens"]
+
+    def test_empty_file(self, empty_file):
+        assert compress_file(empty_file, dry_run=True)["original_tokens"] == 0
+
+    def test_unicode(self, unicode_file):
+        assert compress_file(unicode_file, dry_run=True)["original_tokens"] > 0
+
+
+class TestCollectFiles:
+    def test_directory(self, tmp_workspace):
+        assert len(_collect_files(str(tmp_workspace))) > 0
+
+    def test_single_file(self, tmp_workspace):
+        assert len(_collect_files(str(tmp_workspace / "MEMORY.md"))) == 1
+
+    def test_nonexistent(self):
+        with pytest.raises(Exception):
+            _collect_files("/nonexistent/xyz")
+
+    def test_older_than(self, tmp_workspace):
+        assert len(_collect_files(str(tmp_workspace), older_than=1)) == 0
+        assert len(_collect_files(str(tmp_workspace), older_than=0)) > 0

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

@@ -0,0 +1,191 @@
+"""Comprehensive tests for compress_memory.py."""
+import sys
+import pytest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+from compress_memory import (
+    rule_compress, compress_file, generate_llm_prompt,
+    _collect_files, _file_age_days,
+)
+from lib.tokens import estimate_tokens
+
+
+class TestRuleCompress:
+    def test_basic(self):
+        text = "# Title\n\nSome text\n\n## Section\n\nMore text"
+        result = rule_compress(text)
+        assert isinstance(result, str)
+
+    def test_empty(self):
+        assert rule_compress("") == ""
+
+    def test_duplicate_lines(self):
+        text = "- item one\n- item one\n- item two"
+        result = rule_compress(text)
+        assert result.count("item one") == 1
+
+    def test_emoji_stripping(self):
+        text = "🎉 Celebration! 🎊 Party!"
+        result = rule_compress(text)
+        assert "🎉" not in result
+
+    def test_emoji_stripping_disabled(self):
+        text = "🎉 Celebration!"
+        result = rule_compress(text, enable_emoji_strip=False)
+        assert "Celebration" in result
+
+    def test_chinese_punctuation(self):
+        text = "测试，内容。重要！"
+        result = rule_compress(text)
+        assert "，" not in result
+
+    def test_empty_section_removal(self):
+        text = "# Has content\nfoo\n# Empty\n\n# Also content\nbar"
+        result = rule_compress(text)
+        assert "foo" in result and "bar" in result
+
+    def test_table_compression(self):
+        text = "| Key | Value |\n|-----|-------|\n| a | 1 |\n| b | 2 |"
+        result = rule_compress(text)
+        assert "a" in result and "1" in result
+
+    def test_never_loses_data(self):
+        """All key data should survive compression."""
+        text = "# Config\nServer: 192.168.1.100\nPort: 8080\nUser: admin\nDate: 2026-01-01"
+        result = rule_compress(text)
+        assert "192.168.1.100" in result
+        assert "8080" in result
+        assert "admin" in result
+        assert "2026-01-01" in result
+
+    def test_idempotent(self):
+        text = "# Title\n- item 1\n- item 2\n- item 3"
+        first = rule_compress(text)
+        second = rule_compress(first)
+        assert first == second
+
+    def test_large_text(self):
+        text = "# Header\n" + "\n".join(f"- Item {i}: value {i}" for i in range(1000))
+        result = rule_compress(text)
+        assert len(result) <= len(text)
+
+    def test_mixed_language(self):
+        text = "# 标题 Title\n- English item\n- 中文项目\n- 日本語アイテム"
+        result = rule_compress(text)
+        assert "English" in result
+        assert "中文" in result
+
+    def test_bullet_merging(self):
+        text = "- Updated module A config\n- Updated module B config\n- Updated module C config"
+        result = rule_compress(text)
+        assert isinstance(result, str)
+
+    def test_short_bullet_merging(self):
+        text = "- Yes\n- No\n- OK\n- Done\n- Fine"
+        result = rule_compress(text)
+        assert isinstance(result, str)
+
+    def test_savings_positive(self):
+        """Rule compression should not increase token count."""
+        text = (
+            "# Configuration Notes\n\n"
+            "| Setting | Value | Description |\n"
+            "|---------|-------|-------------|\n"
+            "| timeout | 30 | Request timeout |\n"
+            "| retries | 3 | Max retries |\n\n"
+            "## Empty Section\n\n"
+            "## Notes\n"
+            "- Hello world 🎉\n"
+            "- Hello world 🎉\n"
+            "- Testing，内容。\n"
+        )
+        original_tokens = estimate_tokens(text)
+        compressed = rule_compress(text)
+        compressed_tokens = estimate_tokens(compressed)
+        assert compressed_tokens <= original_tokens
+
+
+class TestCompressFile:
+    def test_basic(self, tmp_path):
+        f = tmp_path / "test.md"
+        f.write_text("# Test\n\nContent here\n\n## Section\n\nMore content\n")
+        result = compress_file(f, dry_run=True, no_llm=True)
+        assert "original_tokens" in result
+        assert "rule_compressed_tokens" in result
+
+    def test_dry_run_no_change(self, tmp_path):
+        f = tmp_path / "test.md"
+        original = "# Test\nHello world\nHello world\n"
+        f.write_text(original)
+        compress_file(f, dry_run=True, no_llm=True)
+        assert f.read_text() == original
+
+    def test_writes_when_not_dry_run(self, tmp_path):
+        f = tmp_path / "test.md"
+        f.write_text("# Test\n\nHello world 🎉\nHello world 🎉\n\n## Empty\n\n")
+        compress_file(f, dry_run=False, no_llm=True)
+        result = f.read_text()
+        assert result.count("Hello world") >= 1
+
+    def test_output_file(self, tmp_path):
+        f = tmp_path / "input.md"
+        f.write_text("# Test\nContent\n")
+        out = str(tmp_path / "output.md")
+        compress_file(f, output=out, no_llm=True)
+        assert Path(out).exists()
+
+    def test_empty_file(self, tmp_path):
+        f = tmp_path / "empty.md"
+        f.write_text("")
+        result = compress_file(f, dry_run=True, no_llm=True)
+        assert isinstance(result, dict)
+
+
+class TestGenerateLlmPrompt:
+    def test_basic(self):
+        prompt = generate_llm_prompt("Some content to compress", target_pct=50)
+        assert isinstance(prompt, str)
+        assert "50" in prompt
+        assert "compress" in prompt.lower()
+
+    def test_includes_content(self):
+        prompt = generate_llm_prompt("UNIQUE_STRING_12345")
+        assert "UNIQUE_STRING_12345" in prompt
+
+    def test_custom_target(self):
+        prompt = generate_llm_prompt("text", target_pct=30)
+        assert "30" in prompt
+
+
+class TestCollectFiles:
+    def test_directory(self, tmp_path):
+        (tmp_path / "a.md").write_text("hello")
+        (tmp_path / "b.md").write_text("world")
+        files = _collect_files(str(tmp_path))
+        assert len(files) >= 2
+
+    def test_single_file(self, tmp_path):
+        f = tmp_path / "test.md"
+        f.write_text("content")
+        files = _collect_files(str(f))
+        assert len(files) == 1
+
+    def test_nonexistent(self):
+        from lib.exceptions import FileNotFoundError_
+        with pytest.raises(FileNotFoundError_):
+            _collect_files("/nonexistent/xyz")
+
+    def test_older_than(self, tmp_path):
+        f = tmp_path / "test.md"
+        f.write_text("content")
+        # File was just created, so older_than=1 should exclude it
+        files = _collect_files(str(tmp_path), older_than=1)
+        assert len(files) == 0
+
+    def test_skips_non_md(self, tmp_path):
+        (tmp_path / "test.md").write_text("md")
+        (tmp_path / "test.txt").write_text("txt")
+        (tmp_path / "test.py").write_text("py")
+        files = _collect_files(str(tmp_path))
+        assert all(str(f).endswith(".md") for f in files)