dsh-caveman 0.1.0 → 0.1.2

package/skills/caveman-compress/scripts/detect.py

@@ -1,139 +0,0 @@
-#!/usr/bin/env python3
-"""Detect whether a file is natural language (compressible) or code/config (skip)."""
-
-import json
-import re
-from pathlib import Path
-
-# Extensions that are natural language and compressible
-COMPRESSIBLE_EXTENSIONS = {".md", ".txt", ".markdown", ".rst", ".typ", ".typst", ".tex"}
-
-# Extensions that are code/config and should be skipped
-SKIP_EXTENSIONS = {
-    ".py", ".js", ".ts", ".tsx", ".jsx", ".json", ".yaml", ".yml",
-    ".toml", ".env", ".lock", ".css", ".scss", ".html", ".xml",
-    ".sql", ".sh", ".bash", ".zsh", ".go", ".rs", ".java", ".c",
-    ".cpp", ".h", ".hpp", ".rb", ".php", ".swift", ".kt", ".lua",
-    ".dockerfile", ".makefile", ".csv", ".ini", ".cfg",
-}
-
-# Well-known build/config files that carry no (or a misleading) extension —
-# `Dockerfile` has no suffix so `.dockerfile` above never matches it, and
-# `CMakeLists.txt` would ride the compressible `.txt` rule. Checked by
-# basename before any extension rule.
-KNOWN_CODE_FILENAMES = {
-    "dockerfile", "makefile", "gnumakefile", "jenkinsfile", "vagrantfile",
-    "rakefile", "gemfile", "justfile", "procfile", "brewfile",
-    "cmakelists.txt",
-}
-
-# Patterns that indicate a line is code
-CODE_PATTERNS = [
-    re.compile(r"^\s*(import |from .+ import |require\(|const |let |var )"),
-    re.compile(r"^\s*(def |class |function |async function |export )"),
-    re.compile(r"^\s*(if\s*\(|for\s*\(|while\s*\(|switch\s*\(|try\s*\{)"),
-    re.compile(r"^\s*[\}\]\);]+\s*$"),  # closing braces/brackets
-    re.compile(r"^\s*@\w+"),  # decorators/annotations
-    re.compile(r'^\s*"[^"]+"\s*:\s*'),  # JSON-like key-value
-    re.compile(r"^\s*\w+\s*=\s*[{\[\(\"']"),  # assignment with literal
-]
-
-
-def _is_code_line(line: str) -> bool:
-    """Check if a line looks like code."""
-    return any(p.match(line) for p in CODE_PATTERNS)
-
-
-def _is_json_content(text: str) -> bool:
-    """Check if content is valid JSON."""
-    try:
-        json.loads(text)
-        return True
-    except (json.JSONDecodeError, ValueError):
-        return False
-
-
-def _is_yaml_content(lines: list[str]) -> bool:
-    """Heuristic: check if content looks like YAML."""
-    yaml_indicators = 0
-    for line in lines[:30]:
-        stripped = line.strip()
-        if stripped.startswith("---"):
-            yaml_indicators += 1
-        elif re.match(r"^\w[\w\s]*:\s", stripped):
-            yaml_indicators += 1
-        elif stripped.startswith("- ") and ":" in stripped:
-            yaml_indicators += 1
-    # If most non-empty lines look like YAML
-    non_empty = sum(1 for l in lines[:30] if l.strip())
-    return non_empty > 0 and yaml_indicators / non_empty > 0.6
-
-
-def detect_file_type(filepath: Path) -> str:
-    """Classify a file as 'natural_language', 'code', 'config', or 'unknown'.
-
-    Returns:
-        One of: 'natural_language', 'code', 'config', 'unknown'
-    """
-    ext = filepath.suffix.lower()
-
-    # Known code filenames win over any extension rule
-    if filepath.name.lower() in KNOWN_CODE_FILENAMES:
-        return "code"
-
-    # Extension-based classification
-    if ext in COMPRESSIBLE_EXTENSIONS:
-        return "natural_language"
-    if ext in SKIP_EXTENSIONS:
-        return "code" if ext not in {".json", ".yaml", ".yml", ".toml", ".ini", ".cfg", ".env"} else "config"
-
-    # Extensionless files (like CLAUDE.md, TODO) — check content
-    if not ext:
-        try:
-            text = filepath.read_text(errors="ignore")
-        except (OSError, PermissionError):
-            return "unknown"
-
-        lines = text.splitlines()[:50]
-
-        # Shebang means executable script, never prose
-        if text.startswith("#!"):
-            return "code"
-
-        if _is_json_content(text[:10000]):
-            return "config"
-        if _is_yaml_content(lines):
-            return "config"
-
-        code_lines = sum(1 for l in lines if l.strip() and _is_code_line(l))
-        non_empty = sum(1 for l in lines if l.strip())
-        if non_empty > 0 and code_lines / non_empty > 0.4:
-            return "code"
-
-        return "natural_language"
-
-    return "unknown"
-
-
-def should_compress(filepath: Path) -> bool:
-    """Return True if the file is natural language and should be compressed."""
-    if not filepath.is_file():
-        return False
-    # Skip backup files
-    if filepath.name.endswith(".original.md"):
-        return False
-    return detect_file_type(filepath) == "natural_language"
-
-
-if __name__ == "__main__":
-    import sys
-
-    if len(sys.argv) < 2:
-        print("Usage: python detect.py <file1> [file2] ...")
-        sys.exit(1)
-
-    for path_str in sys.argv[1:]:
-        p = Path(path_str).resolve()
-        file_type = detect_file_type(p)
-        compress = should_compress(p)
-        print(f"  {p.name:30s} type={file_type:20s} compress={compress}")

package/skills/caveman-compress/scripts/validate.py

@@ -1,213 +0,0 @@
-#!/usr/bin/env python3
-import re
-from collections import Counter
-from pathlib import Path
-
-URL_REGEX = re.compile(r"https?://[^\s)]+")
-FENCE_OPEN_REGEX = re.compile(r"^(\s{0,3})(`{3,}|~{3,})(.*)$")
-HEADING_REGEX = re.compile(r"^(#{1,6})\s+(.*)", re.MULTILINE)
-BULLET_REGEX = re.compile(r"^\s*[-*+]\s+", re.MULTILINE)
-
-# crude but effective path detection
-# Requires either a path prefix (./ ../ / or drive letter) or a slash/backslash within the match
-PATH_REGEX = re.compile(r"(?:\./|\.\./|/|[A-Za-z]:\\)[\w\-/\\\.]+|[\w\-\.]+[/\\][\w\-/\\\.]+")
-
-
-class ValidationResult:
-    def __init__(self):
-        self.is_valid = True
-        self.errors = []
-        self.warnings = []
-
-    def add_error(self, msg):
-        self.is_valid = False
-        self.errors.append(msg)
-
-    def add_warning(self, msg):
-        self.warnings.append(msg)
-
-
-def read_file(path: Path) -> str:
-    return path.read_text(errors="ignore")
-
-
-# ---------- Extractors ----------
-
-
-def extract_headings(text):
-    return [(level, title.strip()) for level, title in HEADING_REGEX.findall(text)]
-
-
-def extract_code_blocks(text):
-    """Line-based fenced code block extractor.
-
-    Handles ``` and ~~~ fences with variable length (CommonMark: closing
-    fence must use same char and be at least as long as opening). Supports
-    nested fences (e.g. an outer 4-backtick block wrapping inner 3-backtick
-    content).
-    """
-    blocks = []
-    lines = text.split("\n")
-    i = 0
-    n = len(lines)
-    while i < n:
-        m = FENCE_OPEN_REGEX.match(lines[i])
-        if not m:
-            i += 1
-            continue
-        fence_char = m.group(2)[0]
-        fence_len = len(m.group(2))
-        open_line = lines[i]
-        block_lines = [open_line]
-        i += 1
-        closed = False
-        while i < n:
-            close_m = FENCE_OPEN_REGEX.match(lines[i])
-            if (
-                close_m
-                and close_m.group(2)[0] == fence_char
-                and len(close_m.group(2)) >= fence_len
-                and close_m.group(3).strip() == ""
-            ):
-                block_lines.append(lines[i])
-                closed = True
-                i += 1
-                break
-            block_lines.append(lines[i])
-            i += 1
-        if closed:
-            blocks.append("\n".join(block_lines))
-        # Unclosed fences are silently skipped — they indicate malformed markdown
-        # and including them would cause false-positive validation failures.
-    return blocks
-
-
-def extract_urls(text):
-    return set(URL_REGEX.findall(text))
-
-
-def extract_paths(text):
-    return set(PATH_REGEX.findall(text))
-
-
-def count_bullets(text):
-    return len(BULLET_REGEX.findall(text))
-
-
-def extract_inline_codes(text):
-    text_without_fences = re.sub(r"^```[\s\S]*?^```", "", text, flags=re.MULTILINE)
-    text_without_fences = re.sub(r"^~~~[\s\S]*?^~~~", "", text_without_fences, flags=re.MULTILINE)
-    return re.findall(r"`([^`]+)`", text_without_fences)
-
-
-# ---------- Validators ----------
-
-
-def validate_headings(orig, comp, result):
-    h1 = extract_headings(orig)
-    h2 = extract_headings(comp)
-
-    if len(h1) != len(h2):
-        result.add_error(f"Heading count mismatch: {len(h1)} vs {len(h2)}")
-
-    if h1 != h2:
-        result.add_warning("Heading text/order changed")
-
-
-def validate_code_blocks(orig, comp, result):
-    c1 = extract_code_blocks(orig)
-    c2 = extract_code_blocks(comp)
-
-    if c1 != c2:
-        result.add_error("Code blocks not preserved exactly")
-
-
-def validate_urls(orig, comp, result):
-    u1 = extract_urls(orig)
-    u2 = extract_urls(comp)
-
-    if u1 != u2:
-        result.add_error(f"URL mismatch: lost={u1 - u2}, added={u2 - u1}")
-
-
-def validate_paths(orig, comp, result):
-    p1 = extract_paths(orig)
-    p2 = extract_paths(comp)
-
-    if p1 != p2:
-        result.add_warning(f"Path mismatch: lost={p1 - p2}, added={p2 - p1}")
-
-
-def validate_bullets(orig, comp, result):
-    b1 = count_bullets(orig)
-    b2 = count_bullets(comp)
-
-    if b1 == 0:
-        return
-
-    diff = abs(b1 - b2) / b1
-
-    if diff > 0.15:
-        result.add_warning(f"Bullet count changed too much: {b1} -> {b2}")
-
-
-def validate_inline_codes(orig, comp, result):
-    c1 = Counter(extract_inline_codes(orig))
-    c2 = Counter(extract_inline_codes(comp))
-
-    if c1 != c2:
-        lost = set(c1.keys()) - set(c2.keys())
-        added = set(c2.keys()) - set(c1.keys())
-        for code, count in c1.items():
-            if code in c2 and c2[code] < count:
-                lost.add(f"{code} (lost {count - c2[code]} of {count} occurrences)")
-        if lost:
-            result.add_error(f"Inline code lost: {lost}")
-        if added:
-            result.add_warning(f"Inline code added: {added}")
-
-
-# ---------- Main ----------
-
-
-def validate(original_path: Path, compressed_path: Path) -> ValidationResult:
-    result = ValidationResult()
-
-    orig = read_file(original_path)
-    comp = read_file(compressed_path)
-
-    validate_headings(orig, comp, result)
-    validate_code_blocks(orig, comp, result)
-    validate_urls(orig, comp, result)
-    validate_paths(orig, comp, result)
-    validate_bullets(orig, comp, result)
-    validate_inline_codes(orig, comp, result)
-
-    return result
-
-
-# ---------- CLI ----------
-
-if __name__ == "__main__":
-    import sys
-
-    if len(sys.argv) != 3:
-        print("Usage: python validate.py <original> <compressed>")
-        sys.exit(1)
-
-    orig = Path(sys.argv[1]).resolve()
-    comp = Path(sys.argv[2]).resolve()
-
-    res = validate(orig, comp)
-
-    print(f"\nValid: {res.is_valid}")
-
-    if res.errors:
-        print("\nErrors:")
-        for e in res.errors:
-            print(f"  - {e}")
-
-    if res.warnings:
-        print("\nWarnings:")
-        for w in res.warnings:
-            print(f"  - {w}")

package/skills/caveman-help/README.md

@@ -1,38 +0,0 @@
-# caveman-help
-
-Quick-reference card. One shot, no mode change.
-
-## What it does
-
-Prints a cheat sheet of all caveman modes, sibling skills, deactivation triggers, and how to set the default mode via env var or config file. One-shot display — does not flip the active mode, write flag files, or persist anything. Use when you forget the slash commands.
-
-## How to invoke
-
-```
-/caveman-help
-```
-
-Also triggers on "caveman help", "what caveman commands", "how do I use caveman".
-
-## Example output
-
-```
-Modes:
-  /caveman              full (default)
-  /caveman lite         lighter
-  /caveman ultra        extreme
-  /caveman wenyan       classical Chinese
-
-Skills:
-  /caveman-commit       terse Conventional Commits
-  /caveman-review       one-line PR comments
-  /caveman-stats        session token savings
-
-Deactivate:
-  "stop caveman" or "normal mode"
-```
-
-## See also
-
-- [`SKILL.md`](./SKILL.md) — full reference card
-- [Caveman README](../../README.md) — repo overview

package/skills/caveman-help/SKILL.md

@@ -1,63 +0,0 @@
----
-name: caveman-help
-description: >
-  Quick-reference card for all caveman modes, skills, and commands.
-  One-shot display, not a persistent mode. Trigger: /caveman-help,
-  "caveman help", "what caveman commands", "how do I use caveman".
----
-
-# Caveman Help
-
-Display this reference card when invoked. One-shot — do NOT change mode, write flag files, or persist anything. Output in caveman style.
-
-## Modes
-
-| Mode | Trigger | What change |
-|------|---------|-------------|
-| **Lite** | `/caveman lite` | Drop filler. Keep sentence structure. |
-| **Full** | `/caveman` | Drop articles, filler, pleasantries, hedging. Fragments OK. Default. |
-| **Ultra** | `/caveman ultra` | Extreme compression. Bare fragments. Tables over prose. |
-| **Wenyan-Lite** | `/caveman wenyan-lite` | Classical Chinese style, light compression. |
-| **Wenyan-Full** | `/caveman wenyan` | Full 文言文. Maximum classical terseness. |
-| **Wenyan-Ultra** | `/caveman wenyan-ultra` | Extreme. Ancient scholar on a budget. |
-
-Mode stick until changed or session end.
-
-## Skills
-
-| Skill | Trigger | What it do |
-|-------|---------|-----------|
-| **caveman-commit** | `/caveman-commit` | Terse commit messages. Conventional Commits. ≤50 char subject. |
-| **caveman-review** | `/caveman-review` | One-line PR comments: `L42: bug: user null. Add guard.` |
-| **caveman-compress** | `/caveman-compress <file>` | Compress .md files to caveman prose. Saves ~46% input tokens. |
-| **caveman-help** | `/caveman-help` | This card. |
-
-## Deactivate
-
-Say "stop caveman" or "normal mode". Resume anytime with `/caveman`.
-
-## Language
-
-Keep user's language by default. User write Portuguese → reply Portuguese caveman. Compress the style, not the language. Technical terms, code, commands, commit types, and exact error strings stay verbatim unless user ask for translation.
-
-## Configure Default Mode
-
-Default mode = `full`. Change it:
-
-**Environment variable** (highest priority):
-```bash
-export CAVEMAN_DEFAULT_MODE=ultra
-```
-
-**Config file** (`~/.config/caveman/config.json`):
-```json
-{ "defaultMode": "lite" }
-```
-
-Set `"off"` to disable auto-activation on session start. User can still activate manually with `/caveman`.
-
-Resolution: env var > config file > `full`.
-
-## More
-
-Full docs: https://github.com/JuliusBrussee/caveman

package/skills/caveman-review/README.md

@@ -1,33 +0,0 @@
-# caveman-review
-
-One-line PR comments. Location, problem, fix. No throat-clearing.
-
-## What it does
-
-Generates code review comments in `L<line>: <severity> <problem>. <fix>.` format. One line per finding. Severity emoji: 🔴 bug, 🟡 risk, 🔵 nit, ❓ question. Drops "I noticed that...", hedging, and restating what the diff already shows. Keeps exact line numbers, backticked symbols, and concrete fixes.
-
-Auto-clarity: drops terse mode for CVE-class security findings, architectural disagreements, and onboarding contexts where the author needs the *why*. Resumes terse for the rest.
-
-Output only — does not approve, request changes, or run linters.
-
-## How to invoke
-
-```
-/caveman-review
-```
-
-Also triggers on "review this PR", "code review", "review the diff".
-
-## Example output
-
-```
-L42: 🔴 bug: user can be null after .find(). Add guard before .email.
-L88-140: 🔵 nit: 50-line fn does 4 things. Extract validate/normalize/persist.
-L23: 🟡 risk: no retry on 429. Wrap in withBackoff(3).
-L107: ❓ q: why drop the cache here? Reads on next request will miss.
-```
-
-## See also
-
-- [`SKILL.md`](./SKILL.md) — full LLM-facing instructions
-- [Caveman README](../../README.md) — repo overview

package/skills/caveman-review/SKILL.md

@@ -1,55 +0,0 @@
----
-name: caveman-review
-description: >
-  Ultra-compressed code review comments. Cuts noise from PR feedback while preserving
-  the actionable signal. Each comment is one line: location, problem, fix. Use when user
-  says "review this PR", "code review", "review the diff", "/review", or invokes
-  /caveman-review. Auto-triggers when reviewing pull requests.
----
-
-Write code review comments terse and actionable. One line per finding. Location, problem, fix. No throat-clearing.
-
-## Rules
-
-**Format:** `L<line>: <problem>. <fix>.` — or `<file>:L<line>: ...` when reviewing multi-file diffs.
-
-**Severity prefix (optional, when mixed):**
-- `🔴 bug:` — broken behavior, will cause incident
-- `🟡 risk:` — works but fragile (race, missing null check, swallowed error)
-- `🔵 nit:` — style, naming, micro-optim. Author can ignore
-- `❓ q:` — genuine question, not a suggestion
-
-**Drop:**
-- "I noticed that...", "It seems like...", "You might want to consider..."
-- "This is just a suggestion but..." — use `nit:` instead
-- "Great work!", "Looks good overall but..." — say it once at the top, not per comment
-- Restating what the line does — the reviewer can read the diff
-- Hedging ("perhaps", "maybe", "I think") — if unsure use `q:`
-
-**Keep:**
-- Exact line numbers
-- Exact symbol/function/variable names in backticks
-- Concrete fix, not "consider refactoring this"
-- The *why* if the fix isn't obvious from the problem statement
-
-## Examples
-
-❌ "I noticed that on line 42 you're not checking if the user object is null before accessing the email property. This could potentially cause a crash if the user is not found in the database. You might want to add a null check here."
-
-✅ `L42: 🔴 bug: user can be null after .find(). Add guard before .email.`
-
-❌ "It looks like this function is doing a lot of things and might benefit from being broken up into smaller functions for readability."
-
-✅ `L88-140: 🔵 nit: 50-line fn does 4 things. Extract validate/normalize/persist.`
-
-❌ "Have you considered what happens if the API returns a 429? I think we should probably handle that case."
-
-✅ `L23: 🟡 risk: no retry on 429. Wrap in withBackoff(3).`
-
-## Auto-Clarity
-
-Drop terse mode for: security findings (CVE-class bugs need full explanation + reference), architectural disagreements (need rationale, not just a one-liner), and onboarding contexts where the author is new and needs the "why". In those cases write a normal paragraph, then resume terse for the rest.
-
-## Boundaries
-
-Reviews only — does not write the code fix, does not approve/request-changes, does not run linters. Output the comment(s) ready to paste into the PR. "stop caveman-review" or "normal mode": revert to verbose review style.

package/skills/caveman-stats/README.md

@@ -1,30 +0,0 @@
-# caveman-stats
-
-Real session token receipts. No AI estimation.
-
-## What it does
-
-Reads the current Claude Code session log directly and reports actual input/output token usage plus estimated savings versus a non-caveman baseline. Numbers come from the JSONL session log on disk — the model itself does not compute or estimate them. Output is injected by the `caveman-mode-tracker` hook, which intercepts `/caveman-stats` and returns the formatted stats as a blocked-decision reason.
-
-Each run also writes a lifetime-savings suffix file used by the statusline badge (`⛏ 12.4k`).
-
-## How to invoke
-
-```
-/caveman-stats
-```
-
-## Example output
-
-```
-Session: 47 turns
-Input:   12,304 tokens
-Output:   3,891 tokens (caveman)
-Baseline: 11,247 tokens (estimated without caveman)
-Saved:    7,356 tokens (~65%)
-```
-
-## See also
-
-- [`SKILL.md`](./SKILL.md) — hook contract and mechanics
-- [Caveman README](../../README.md) — repo overview

package/skills/caveman-stats/SKILL.md

@@ -1,10 +0,0 @@
----
-name: caveman-stats
-description: >
-  Show real token usage and estimated savings for the current session.
-  Reads directly from the Claude Code session log — no AI estimation.
-  Triggers on /caveman-stats. Output is injected by the mode-tracker hook;
-  the model itself does not compute the numbers.
----
-
-This skill is delivered by `hooks/caveman-stats.js` (read by `hooks/caveman-mode-tracker.js` on `/caveman-stats`). The model does not need to do anything when this skill fires — the hook returns `decision: "block"` with the formatted stats as the reason. The user sees the numbers immediately.