@

Add star-map Angular app, ETL pipeline, and caveman plugin

Angular 3D star map (galaxy/system/body views, Three.js rendering,
navigation store) plus the NASA ETL tooling that builds the star,
exoplanet and solar-system datasets, Playwright e2e suite, and the
cs:caveman Claude Code plugin (command, agent, skill).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
@

skills/caveman/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: caveman
+description: >-
+  Ultra-compressed communication mode. Cuts token usage ~75% by dropping
+  filler, articles, and pleasantries while keeping full technical accuracy.
+  Use when user says "caveman mode", "talk like caveman", "use caveman",
+  "less tokens", "be brief", or invokes /caveman.
+---
+
+# Caveman
+
+Ultra-compressed communication mode. Drop everything that doesn't carry
+technical signal. Keep every fact, number, code snippet, and error message
+exactly as-is.
+
+## Scope
+
+This skill ships via this repo's plugin marketplace
+(`.claude-plugin/marketplace.json`). Installing with
+`/plugin install caveman@star-map` defaults to **user scope** — global,
+available in every project — instead of being tied to just one repo. Use
+`--scope project` or `--scope local` to narrow it; see the
+[README](../../README.md).
+
+## Persistence
+
+Once activated, caveman mode stays active for **every subsequent turn**,
+across the whole conversation, until the user explicitly deactivates it.
+Do not silently revert to normal prose after one terse reply — the
+compression must persist.
+
+Activate on:
+- `/cs:caveman` command
+- Phrases: "caveman mode", "talk like caveman", "use caveman", "less
+  tokens", "be brief"
+
+Deactivate on:
+- "stop caveman"
+- "normal mode"
+
+On activation, begin the compressed style immediately, starting with the
+very next reply. No "OK, switching to caveman mode" announcement.
+
+## Rules
+
+Drop:
+- Articles — a / an / the
+- Filler — just / really / basically / actually / simply
+- Pleasantries — sure / certainly / of course / happy to
+- Hedging — might / maybe / perhaps / likely
+
+Abbreviate common terms: `DB`, `auth`, `config`, `req`, `res`, `fn`, `impl`,
+`env`, `deps`, `repo`, `docs`, `app`.
+
+Use arrows for causality: `X -> Y` instead of "X causes Y" / "X leads to Y".
+
+Prefer the pattern: `[thing] [action] [reason]. [next step].`
+
+Never touch: code blocks, inline code, technical terms, error messages —
+these stay verbatim, unabbreviated, uncompressed.
+
+## Examples
+
+Normal:
+> Sure, I think the issue is likely that the database connection is
+> basically timing out because the config file actually has the wrong
+> host set. Let me go ahead and fix the configuration file for you.
+
+Caveman:
+> DB conn timeout -> config has wrong host. Fixing config now.
+
+Normal:
+> Of course! The function returns undefined because it's missing a return
+> statement. I'll go ahead and add one now.
+
+Caveman:
+> `fn` returns undefined -> missing return statement. Adding one.
+
+## Auto-Clarity Exception
+
+Caveman compression is dropped automatically — full, normal prose used
+instead — for:
+- Security warnings (e.g. `**Warning:** ...`)
+- Irreversible action confirmations (deletes, force-pushes, drops, prod
+  deploys)
+- Multi-step sequences where order matters (numbered instructions,
+  migrations, setup steps)
+- Clarification moments — user asks "what?" / "wait" / repeats their
+  question
+
+After the exception is resolved, resume caveman mode and mark the
+resumption explicitly with the line: `Caveman resume.`
+
+## Tooling
+
+Scripts live in `scripts/` next to this file.
+
+```bash
+# Compress text into caveman style
+python scripts/caveman_compressor.py "text"
+
+# Estimate token savings at a given price per million tokens
+python scripts/token_savings_estimator.py "text" --price-per-mtok 3.00
+
+# Verify a response follows caveman rules
+python scripts/caveman_lint.py "response"
+```
+
+## Related
+
+- Command: `/cs:caveman`
+- Agent: `cs-caveman-mode`
+- Adjacent skills: `grill-me`, `handoff` (other Pocock-derived skills)
+
+---
+
+**Derived:** Matt Pocock's caveman (MIT) + this repo's wrapper

skills/caveman/scripts/caveman_compressor.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""caveman_compressor.py
+
+Compress text into "caveman mode" style per the `caveman` skill rules:
+drop articles, filler, pleasantries, and hedging; abbreviate common
+technical terms; turn simple causal phrases into `X -> Y` arrows.
+
+Code blocks (``` ... ```) and inline code (`...`) are left untouched.
+
+Usage:
+    python caveman_compressor.py "text to compress"
+    python caveman_compressor.py --file some.md
+"""
+
+import argparse
+import re
+import sys
+
+# Words/phrases dropped entirely (case-insensitive, whole-word match).
+ARTICLES = ["a", "an", "the"]
+FILLER = ["just", "really", "basically", "actually", "simply"]
+HEDGING = ["might", "maybe", "perhaps", "likely"]
+
+# Multi-word pleasantries dropped entirely (checked as phrases, longest first).
+PLEASANTRIES = [
+    "of course",
+    "happy to",
+    "sure thing",
+    "certainly",
+    "sure",
+]
+
+DROP_WORDS = ARTICLES + FILLER + HEDGING
+
+# Common abbreviations. Keys are matched case-insensitively as whole words;
+# the replacement preserves the target casing shown here.
+ABBREVIATIONS = {
+    "database": "DB",
+    "databases": "DBs",
+    "authentication": "auth",
+    "configuration": "config",
+    "configurations": "configs",
+    "request": "req",
+    "requests": "reqs",
+    "response": "res",
+    "responses": "res",
+    "function": "fn",
+    "functions": "fns",
+    "implementation": "impl",
+    "implementations": "impls",
+    "environment": "env",
+    "environments": "envs",
+    "dependency": "dep",
+    "dependencies": "deps",
+    "repository": "repo",
+    "repositories": "repos",
+    "documentation": "docs",
+    "application": "app",
+    "applications": "apps",
+}
+
+# Causal phrases turned into `X -> Y` arrows.
+CAUSAL_PHRASES = [
+    "leads to",
+    "results in",
+    "causes",
+    "will cause",
+]
+
+# Splits text into segments, tagging fenced code blocks / inline code so
+# they can be skipped during compression.
+_CODE_SPLIT_RE = re.compile(r"(```.*?```|`[^`\n]*`)", re.DOTALL)
+
+
+def _drop_words(text: str) -> str:
+    for phrase in PLEASANTRIES:
+        text = re.sub(
+            r"(?i)\b" + re.escape(phrase) + r"\b[,!]?\s*", "", text
+        )
+    for word in DROP_WORDS:
+        text = re.sub(r"(?i)\b" + re.escape(word) + r"\b\s*", "", text)
+    return text
+
+
+def _abbreviate(text: str) -> str:
+    for long_form, short_form in ABBREVIATIONS.items():
+        text = re.sub(
+            r"(?i)\b" + re.escape(long_form) + r"\b",
+            short_form,
+            text,
+        )
+    return text
+
+
+def _arrows(text: str) -> str:
+    for phrase in CAUSAL_PHRASES:
+        text = re.sub(r"(?i)\s*\b" + re.escape(phrase) + r"\b\s*", " -> ", text)
+    return text
+
+
+def _cleanup_whitespace(text: str) -> str:
+    text = re.sub(r"[ \t]{2,}", " ", text)
+    text = re.sub(r"[ \t]+([,.!?;:])", r"\1", text)
+    text = re.sub(r"\n[ \t]+", "\n", text)
+    text = re.sub(r"^[ \t]+", "", text, flags=re.MULTILINE)
+    return text.strip()
+
+
+def compress(text: str) -> str:
+    """Compress `text` into caveman style, preserving code spans."""
+    segments = _CODE_SPLIT_RE.split(text)
+    out = []
+    for segment in segments:
+        if segment.startswith("`"):
+            out.append(segment)
+            continue
+        compressed = segment
+        compressed = _arrows(compressed)
+        compressed = _drop_words(compressed)
+        compressed = _abbreviate(compressed)
+        compressed = _cleanup_whitespace(compressed)
+        out.append(compressed)
+    return "".join(out)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("text", nargs="?", help="Text to compress")
+    parser.add_argument("--file", help="Read text to compress from a file")
+    args = parser.parse_args()
+
+    if args.file:
+        with open(args.file, "r", encoding="utf-8") as fh:
+            text = fh.read()
+    elif args.text is not None:
+        text = args.text
+    else:
+        text = sys.stdin.read()
+
+    print(compress(text))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

skills/caveman/scripts/caveman_lint.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""caveman_lint.py
+
+Verify that a response follows the `caveman` skill rules: no articles,
+filler words, pleasantries, or hedging outside of code spans.
+
+Code blocks (``` ... ```) and inline code (`...`) are ignored by the lint,
+since their contents are technical and must stay unchanged.
+
+Exit code: 0 if no violations found, 1 otherwise.
+
+Usage:
+    python caveman_lint.py "response text"
+    python caveman_lint.py --file some.md
+"""
+
+import argparse
+import re
+import sys
+
+ARTICLES = ["a", "an", "the"]
+FILLER = ["just", "really", "basically", "actually", "simply"]
+HEDGING = ["might", "maybe", "perhaps", "likely"]
+PLEASANTRIES = ["sure", "certainly", "of course", "happy to", "sure thing"]
+
+RULES = {
+    "article": ARTICLES,
+    "filler": FILLER,
+    "hedging": HEDGING,
+    "pleasantry": PLEASANTRIES,
+}
+
+_CODE_SPLIT_RE = re.compile(r"(```.*?```|`[^`\n]*`)", re.DOTALL)
+
+
+def _non_code_segments(text: str):
+    """Yield (segment_text, start_offset_in_original_text) for every
+    segment of `text` that is NOT inside a fenced/inline code span."""
+    offset = 0
+    for segment in _CODE_SPLIT_RE.split(text):
+        if not segment.startswith("`"):
+            yield segment, offset
+        offset += len(segment)
+
+
+def find_violations(text: str):
+    """Return a list of violation dicts: category, word, position, line,
+    context (a short snippet around the match)."""
+    violations = []
+    for category, words in RULES.items():
+        for word in words:
+            pattern = re.compile(r"(?i)\b" + re.escape(word) + r"\b")
+            for segment, offset in _non_code_segments(text):
+                for match in pattern.finditer(segment):
+                    pos = offset + match.start()
+                    line = text.count("\n", 0, pos) + 1
+                    start = max(0, match.start() - 20)
+                    end = min(len(segment), match.end() + 20)
+                    context = segment[start:end].strip().replace("\n", " ")
+                    violations.append(
+                        {
+                            "category": category,
+                            "word": match.group(0),
+                            "position": pos,
+                            "line": line,
+                            "context": context,
+                        }
+                    )
+    violations.sort(key=lambda v: v["position"])
+    return violations
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("text", nargs="?", help="Response text to lint")
+    parser.add_argument("--file", help="Read response text to lint from a file")
+    args = parser.parse_args()
+
+    if args.file:
+        with open(args.file, "r", encoding="utf-8") as fh:
+            text = fh.read()
+    elif args.text is not None:
+        text = args.text
+    else:
+        text = sys.stdin.read()
+
+    violations = find_violations(text)
+
+    if not violations:
+        print("OK: no caveman-rule violations found.")
+        return 0
+
+    print(f"FAIL: {len(violations)} caveman-rule violation(s) found:\n")
+    for v in violations:
+        print(
+            f"  line {v['line']} [{v['category']}] '{v['word']}' "
+            f"-> ...{v['context']}..."
+        )
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

skills/caveman/scripts/token_savings_estimator.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""token_savings_estimator.py
+
+Estimate token savings (and $ cost savings) achieved by compressing text
+into "caveman mode" style, using the `caveman_compressor` module.
+
+Token counts are estimated with a simple heuristic (~4 chars/token) unless
+`tiktoken` is installed, in which case it is used for a more accurate count.
+
+Usage:
+    python token_savings_estimator.py "text" --price-per-mtok 3.00
+    python token_savings_estimator.py --file some.md --price-per-mtok 3.00
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from caveman_compressor import compress  # noqa: E402
+
+CHARS_PER_TOKEN = 4.0
+
+
+def count_tokens(text: str) -> int:
+    """Count tokens in `text`, using tiktoken if available, else a
+    character-based heuristic (~4 chars/token, roughly matching common
+    English tokenizers)."""
+    try:
+        import tiktoken
+
+        encoding = tiktoken.get_encoding("cl100k_base")
+        return len(encoding.encode(text))
+    except ImportError:
+        if not text:
+            return 0
+        return max(1, round(len(text) / CHARS_PER_TOKEN))
+
+
+def estimate_savings(text: str, price_per_mtok: float) -> dict:
+    compressed = compress(text)
+
+    original_tokens = count_tokens(text)
+    compressed_tokens = count_tokens(compressed)
+    saved_tokens = max(0, original_tokens - compressed_tokens)
+    pct_saved = (saved_tokens / original_tokens * 100) if original_tokens else 0.0
+
+    original_cost = original_tokens / 1_000_000 * price_per_mtok
+    compressed_cost = compressed_tokens / 1_000_000 * price_per_mtok
+    saved_cost = original_cost - compressed_cost
+
+    return {
+        "compressed_text": compressed,
+        "original_tokens": original_tokens,
+        "compressed_tokens": compressed_tokens,
+        "saved_tokens": saved_tokens,
+        "pct_saved": pct_saved,
+        "original_cost": original_cost,
+        "compressed_cost": compressed_cost,
+        "saved_cost": saved_cost,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("text", nargs="?", help="Text to analyze")
+    parser.add_argument("--file", help="Read text to analyze from a file")
+    parser.add_argument(
+        "--price-per-mtok",
+        type=float,
+        default=3.00,
+        help="Price in USD per 1,000,000 tokens (default: 3.00)",
+    )
+    args = parser.parse_args()
+
+    if args.file:
+        with open(args.file, "r", encoding="utf-8") as fh:
+            text = fh.read()
+    elif args.text is not None:
+        text = args.text
+    else:
+        text = sys.stdin.read()
+
+    result = estimate_savings(text, args.price_per_mtok)
+
+    print("--- Caveman compression ---")
+    print(result["compressed_text"])
+    print()
+    print("--- Token savings ---")
+    print(f"Original tokens:   {result['original_tokens']}")
+    print(f"Compressed tokens: {result['compressed_tokens']}")
+    print(f"Saved tokens:      {result['saved_tokens']} ({result['pct_saved']:.1f}%)")
+    print()
+    print(f"--- Cost @ ${args.price_per_mtok:.2f} / MTok ---")
+    print(f"Original cost:   ${result['original_cost']:.6f}")
+    print(f"Compressed cost: ${result['compressed_cost']:.6f}")
+    print(f"Saved cost:      ${result['saved_cost']:.6f}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())