From db0997f9346e77f698bce99cb50c7ec456bf4c64 Mon Sep 17 00:00:00 2001 From: Simon the Coder Date: Sat, 3 Oct 2026 03:44:04 +0300 Subject: [PATCH] feat(sec): initial release v1.0.0-alpha - ergonomic query routing engine --- NOTES.md | 28 +++ README.md | 58 ++++++ __main__.py | 16 ++ catalog/strings.json | 23 +++ data/cache.db | Bin 0 -> 24576 bytes main.py | 16 ++ manifest.json | 35 ++++ sample.txt | 40 +++++ src/__init__.py | 1 + src/__pycache__/__init__.cpython-313.pyc | Bin 0 -> 217 bytes src/__pycache__/catalog.cpython-313.pyc | Bin 0 -> 3030 bytes src/__pycache__/cli.cpython-313.pyc | Bin 0 -> 4714 bytes src/__pycache__/client.cpython-313.pyc | Bin 0 -> 6307 bytes src/__pycache__/clipboard.cpython-313.pyc | Bin 0 -> 5108 bytes src/__pycache__/manifest.cpython-313.pyc | Bin 0 -> 1260 bytes src/__pycache__/renderer.cpython-313.pyc | Bin 0 -> 3162 bytes src/__pycache__/router.cpython-313.pyc | Bin 0 -> 8805 bytes src/catalog.py | 47 +++++ src/cli.py | 118 ++++++++++++ src/client.py | 131 ++++++++++++++ src/clipboard.py | 118 ++++++++++++ src/manifest.py | 22 +++ src/renderer.py | 43 +++++ src/router.py | 209 ++++++++++++++++++++++ 24 files changed, 905 insertions(+) create mode 100644 NOTES.md create mode 100644 README.md create mode 100644 __main__.py create mode 100644 catalog/strings.json create mode 100644 data/cache.db create mode 100644 main.py create mode 100644 manifest.json create mode 100644 sample.txt create mode 100644 src/__init__.py create mode 100644 src/__pycache__/__init__.cpython-313.pyc create mode 100644 src/__pycache__/catalog.cpython-313.pyc create mode 100644 src/__pycache__/cli.cpython-313.pyc create mode 100644 src/__pycache__/client.cpython-313.pyc create mode 100644 src/__pycache__/clipboard.cpython-313.pyc create mode 100644 src/__pycache__/manifest.cpython-313.pyc create mode 100644 src/__pycache__/renderer.cpython-313.pyc create mode 100644 src/__pycache__/router.cpython-313.pyc create mode 100644 src/catalog.py create mode 100644 src/cli.py create mode 100644 src/client.py create mode 100644 src/clipboard.py create mode 100644 src/manifest.py create mode 100644 src/renderer.py create mode 100644 src/router.py diff --git a/NOTES.md b/NOTES.md new file mode 100644 index 0000000..8b7d456 --- /dev/null +++ b/NOTES.md @@ -0,0 +1,28 @@ +# SEC - Quick CLI Cheat Sheet & Code Snippet Assistant + +## Project Purpose +A lightweight, lightning-fast CLI cheat sheet and code snippet assistant powered by the `cheat.sh` engine, ergonomic sol-el keyboard layout, smart query routing, and optional clipboard integration. + +--- + +## Architectural Decisions +1. **Name & Ergonomics:** `sec` (optimized for left-hand QWERTY reachability in dropdown/Quake terminals). +2. **Backend & Engine:** Direct live queries to the `cheat.sh` API with smart multi-token routing. +3. **Smart Query Router:** + - Strategy 1: Targeted language/tool lookup (`cht.sh//`). + - Strategy 2: Global semantic fallback search (`cht.sh/~`). +4. **Offline Exact-Query Cache:** Lightweight SQLite or file-based cache for previously fetched queries so repeated lookups work offline. +5. **Clipboard Integration:** Optional `-c` / `--copy` flag to automatically extract and copy executable code blocks to the clipboard. +6. **Centralized UI/String Catalog:** Centralized JSON string catalog (`catalog/strings.json`). No hardcoded UI strings in code. +7. **Code Standards:** Professional English in all code, comments, catalogs, and documentation. No emojis in terminal UI or codebase. +8. **Manifest & Versioning:** `manifest.json` tracking semver, dependencies, and changelog, wired to `-V` / `--version`. + +--- + +## Pending Topics & Decisions +- [x] **1. Live API Client & Multi-token Routing:** Tilde-based search, candidates fallback chain, error/index suppression. +- [x] **2. Clipboard Dual Mode:** `-c` for executable code only, `-c a` for full response. +- [x] **3. Offline SQLite Cache:** Automatic caching of valid queries in `data/cache.db`. +- [ ] **4. Deterministic Non-AI Keyword & Intent Engine:** Build a purely offline, algorithmic keyword classifier (trie/inverted-index/alias table) that parses freeform user prompts into exact `cheat.sh` canonical topics and flags without external AI APIs. +- [ ] **5. ANSI Rendering & Paging:** Optional terminal paging for multi-page cheat sheets. +- [ ] **6. Cache Expiration & Invalidation:** TTL or explicit cache refresh flags (`--refresh`). diff --git a/README.md b/README.md new file mode 100644 index 0000000..69055f6 --- /dev/null +++ b/README.md @@ -0,0 +1,58 @@ +# SEC - Structured Ergonomic Cheatsheet & Code Assistant + +```text + ____ _____ ____ + / ___|| ____/ ___| + \___ \| _|| | + ___) | |__| |___ + |____/|_____\____| +``` + +> **Author:** Simon the Coder `` +> **Specification Version:** 1.0.0-alpha +> **Runtime Environment:** Python 3.10+ / Gravitiny Applet Platform +> **License:** MIT Open Source License + +--- + +## 1. Abstract & Motivation + +Developers in drop-down/modal terminal environments frequently execute queries under tight spatial and temporal constraints. `sec` is designed to minimize motor latency by constraining command naming to the left-hand QWERTY region (`s`, `e`, `c`) while providing deterministic query routing and semantic AST-style snippet extraction. + +--- + +## 2. Mathematical & Heuristic Routing Architecture + +The `QueryRouter` class decomposes freeform CLI tokens $T = \{t_1, t_2, \dots, t_n\}$ through prioritized candidate generation: + +1. **Programming Language Scoping:** Maps $t_1 \in \mathcal{L}$ to canonical StackOverflow question endpoints. +2. **Deterministic Synonym Permutation:** Dynamically expands programmatic verbs ($\text{serialize} \to \{\text{dump}, \text{dumps}, \text{write}, \text{stringify}\}$). +3. **Dual-Mode Clipboard Pipeline:** + - `-c` (Code Extraction): Strips commentary and markdown headers, isolating executable syntax trees. + - `-c a` (Full Context): Captures complete documentation cards. + +--- + +## 3. Invocation Examples + +```bash +# Language-scoped snippet retrieval +sec python json serialize -c + +# System utility lookup +sec tar extract + +# Diagnostic query +sec linux memory usage + +# Full context clipboard copy +sec docker container prune -c a +``` + +--- + +## 4. Technical Invariants + +- **Asynchronous & Offline Fallback:** Persistent SQLite response cache (`data/cache.db`). +- **Zero ANSI Pollution:** Strict stream sanitization on pipeline redirection. +- **Pure Dependency Decoupling:** Fully compliant with Gravitiny specification v0.1.0. diff --git a/__main__.py b/__main__.py new file mode 100644 index 0000000..fc51482 --- /dev/null +++ b/__main__.py @@ -0,0 +1,16 @@ +import sys +from pathlib import Path + +BASE_DIR = Path(__file__).resolve().parent +if str(BASE_DIR) not in sys.path: + sys.path.insert(0, str(BASE_DIR)) +if str(BASE_DIR.parent) not in sys.path: + sys.path.insert(0, str(BASE_DIR.parent)) + +try: + from sec.src.cli import run_cli +except ImportError: + from src.cli import run_cli + +if __name__ == "__main__": + sys.exit(run_cli(sys.argv[1:])) diff --git a/catalog/strings.json b/catalog/strings.json new file mode 100644 index 0000000..c624297 --- /dev/null +++ b/catalog/strings.json @@ -0,0 +1,23 @@ +{ + "app": { + "name": "SEC", + "description": "CLI Cheat Sheet & Code Snippet Assistant", + "version": "1.0.0", + "version_output": "{name} v{version} [{stage}] - {description}" + }, + "status": { + "fetching": "Querying cheat sheet for: \"{query}\"...", + "not_found": "No cheat sheet found for: \"{query}\".", + "offline_cached": "[Cached Result - Offline Mode]", + "copied_code": "Copied executable code to clipboard.", + "copied_all": "Copied full response to clipboard.", + "clipboard_error": "Unable to copy to clipboard.", + "network_error": "Unable to connect to cheat.sh. Please check your internet connection." + }, + "labels": { + "usage_title": "Usage:", + "examples_title": "Examples:", + "query_header": "CHEAT SHEET: {title}", + "source_badge": "cheat.sh" + } +} diff --git a/data/cache.db b/data/cache.db new file mode 100644 index 0000000000000000000000000000000000000000..ccb1644e748a2219cd0dea4d8f69379cdbd2c07a GIT binary patch literal 24576 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 literal 0 HcmV?d00001 diff --git a/main.py b/main.py new file mode 100644 index 0000000..fc51482 --- /dev/null +++ b/main.py @@ -0,0 +1,16 @@ +import sys +from pathlib import Path + +BASE_DIR = Path(__file__).resolve().parent +if str(BASE_DIR) not in sys.path: + sys.path.insert(0, str(BASE_DIR)) +if str(BASE_DIR.parent) not in sys.path: + sys.path.insert(0, str(BASE_DIR.parent)) + +try: + from sec.src.cli import run_cli +except ImportError: + from src.cli import run_cli + +if __name__ == "__main__": + sys.exit(run_cli(sys.argv[1:])) diff --git a/manifest.json b/manifest.json new file mode 100644 index 0000000..5222671 --- /dev/null +++ b/manifest.json @@ -0,0 +1,35 @@ +{ + "id": "sec", + "name": "Sec", + "display_name": "SEC - Ergonomic CLI Cheat Sheet & Code Snippet Assistant", + "description": "Ergonomic, heuristic-routed CLI cheat sheet and code snippet assistant powered by cheat.sh.", + "version": "1.0.0", + "stage": "Alpha", + "author": "Simon the Coder ", + "license": "MIT", + "runtime": "python", + "entrypoint": "main.py", + "shims": ["sec"], + "network": "live", + "dependencies": [ + "requests>=2.28.0", + "rich>=13.0.0" + ], + "tags": [ + "cheatsheet", + "snippets", + "cheat.sh", + "routing", + "clipboard", + "productivity", + "python", + "bash" + ], + "features": [ + "Ergonomic left-hand QWERTY command invocation (optimized for dropdown terminals)", + "Deterministic multi-token candidate URL permutation and developer synonym expansion", + "Dual-mode native Win32/POSIX clipboard integration (-c for code only, -c a for full snippet)", + "Offline query caching in local SQLite database", + "Centralized JSON UI and interaction catalog" + ] +} diff --git a/sample.txt b/sample.txt new file mode 100644 index 0000000..f5cad36 --- /dev/null +++ b/sample.txt @@ -0,0 +1,40 @@ +class Student(object): + name = "" + age = 0 + major = "" + + # The class "constructor" - It's actually an initializer + def __init__(self, name, age, major): + self.name = name + self.age = age + self.major = major + + def make_student(name, age, major): + student = Student(name, age, major) + return student + +# Note that even though one of the principles in Python's philosophy is +# *"there should be one—and preferably only one—obvious way to do it"*, +# there are still multiple ways to do this. You can also use the two +# following snippets of code to take advantage of Python's dynamic +# capabilities: + + class Student(object): + name = "" + age = 0 + major = "" + + def make_student(name, age, major): + student = Student() + student.name = name + student.age = age + student.major = major + # Note: I didn't need to create a variable in the class definition before doing +this. + student.gpa = float(4.0) + return student + +# I prefer the former, but there are instances where the latter can be +# useful – one being when working with document databases like MongoDB. +# +# [Wulfram] [so/q/15081542] [cc by-sa 3.0] diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..16fe4f7 --- /dev/null +++ b/src/__init__.py @@ -0,0 +1 @@ +"""SEC - Quick CLI Cheat Sheet & Code Snippet Assistant.""" diff --git a/src/__pycache__/__init__.cpython-313.pyc b/src/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d9750ee5d544d3173c9a20d1590c048215eb907 GIT binary patch literal 217 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 literal 0 HcmV?d00001 diff --git a/src/__pycache__/client.cpython-313.pyc b/src/__pycache__/client.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5923f513114d43f8fe28df1222922a72a35deafb GIT binary patch literal 6307 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 literal 0 HcmV?d00001 diff --git a/src/__pycache__/manifest.cpython-313.pyc b/src/__pycache__/manifest.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..929b8727203f8e1227313a9aeeb22fe67ea17e27 GIT binary patch literal 1260 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 literal 0 HcmV?d00001 diff --git a/src/__pycache__/router.cpython-313.pyc b/src/__pycache__/router.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..33792516e7707f174c8d60ee81f61d0d2d21a7f8 GIT binary patch literal 8805 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 c None: + base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + catalog_path = os.path.join(base_dir, "catalog", "strings.json") + if os.path.exists(catalog_path): + with open(catalog_path, "r", encoding="utf-8") as f: + self._catalog = json.load(f) + else: + self._catalog = {} + + def get(self, key_path: str, default: str = "") -> str: + """Retrieve a string from the catalog using dot notation.""" + parts = key_path.split(".") + current = self._catalog + for part in parts: + if isinstance(current, dict) and part in current: + current = current[part] + else: + return default + return str(current) if current is not None else default + + def format(self, key_path: str, **kwargs: Any) -> str: + """Retrieve a template string and interpolate keyword arguments.""" + template = self.get(key_path, "") + try: + return template.format(**kwargs) + except KeyError: + return template + + +catalog = StringCatalog() diff --git a/src/cli.py b/src/cli.py new file mode 100644 index 0000000..baf266d --- /dev/null +++ b/src/cli.py @@ -0,0 +1,118 @@ +import sys +from typing import List, Optional, Tuple + +try: + from sec.src.catalog import catalog + from sec.src.client import CheatClient + from sec.src.clipboard import copy_to_clipboard, extract_code_only, strip_ansi + from sec.src.manifest import load_manifest + from sec.src.renderer import SnippetRenderer + from sec.src.router import QueryRouter +except ImportError: + from src.catalog import catalog + from src.client import CheatClient + from src.clipboard import copy_to_clipboard, extract_code_only, strip_ansi + from src.manifest import load_manifest + from src.renderer import SnippetRenderer + from src.router import QueryRouter + + +def parse_arguments(raw_args: List[str]) -> Tuple[List[str], Optional[str], bool]: + """Parse raw arguments into (query_tokens, copy_mode, is_version_flag).""" + copy_mode = None + is_version = False + query_tokens: List[str] = [] + + i = 0 + while i < len(raw_args): + arg = raw_args[i] + + if arg in ["-V", "-v", "--version"]: + is_version = True + i += 1 + continue + + if arg in ["-c", "--copy"]: + # Check if next token is 'a' or 'all' + if i + 1 < len(raw_args) and raw_args[i + 1].lower() in ["a", "all"]: + copy_mode = "all" + i += 2 + continue + else: + copy_mode = "code" + i += 1 + continue + + if arg in ["--copy-all", "-ca"]: + copy_mode = "all" + i += 1 + continue + + query_tokens.append(arg) + i += 1 + + return query_tokens, copy_mode, is_version + + +def run_cli(args: Optional[List[str]] = None) -> int: + if hasattr(sys.stdout, "reconfigure"): + try: + sys.stdout.reconfigure(encoding="utf-8", errors="replace") + sys.stderr.reconfigure(encoding="utf-8", errors="replace") + except Exception: + pass + + raw_args = args if args is not None else sys.argv[1:] + query_tokens, copy_mode, is_version = parse_arguments(raw_args) + + if is_version: + manifest = load_manifest() + version_text = catalog.format( + "app.version_output", + name=manifest.get("name", "SEC"), + version=manifest.get("version", "1.0.0"), + stage=manifest.get("stage", "Alpha"), + description=manifest.get("description", ""), + ) + print(version_text) + return 0 + + if not query_tokens: + manifest = load_manifest() + print(f"{manifest.get('name', 'SEC')} v{manifest.get('version', '1.0.0')} [{manifest.get('stage', 'Alpha')}] - {manifest.get('description', '')}") + print("Usage: sec [-c] [-c a]") + print("Examples:") + print(" sec python read json") + print(" sec tar extract") + print(" sec linux memory usage") + print(" sec git undo commit -c # Copy code only to clipboard") + print(" sec docker build -c a # Copy full response to clipboard") + return 0 + + raw_query = " ".join(query_tokens) + router = QueryRouter() + routed = router.route(query_tokens) + + client = CheatClient() + renderer = SnippetRenderer() + + result = client.fetch(routed) + if not result: + renderer.render_not_found(raw_query) + return 0 + + copied = False + is_all_copy = False + if copy_mode: + if copy_mode == "all": + text_to_copy = strip_ansi(result.content) + is_all_copy = True + else: + text_to_copy = extract_code_only(result.content) + is_all_copy = False + + if text_to_copy: + copied = copy_to_clipboard(text_to_copy) + + renderer.render_result(result, copied=copied, is_all_copy=is_all_copy) + return 0 diff --git a/src/client.py b/src/client.py new file mode 100644 index 0000000..a5c47c1 --- /dev/null +++ b/src/client.py @@ -0,0 +1,131 @@ +import os +import sqlite3 +import time +from dataclasses import dataclass +from pathlib import Path +from typing import Optional +import requests + +from sec.src.router import RoutedQuery + + +@dataclass +class FetchResult: + query: str + url: str + content: str + is_cached: bool + is_fallback: bool + + +class CheatClient: + """Handles HTTP requests to cheat.sh and manages the local query cache.""" + + def __init__(self, cache_db_path: Optional[str] = None, timeout: int = 6): + if cache_db_path is None: + base_dir = Path(__file__).resolve().parent.parent + data_dir = base_dir / "data" + data_dir.mkdir(parents=True, exist_ok=True) + cache_db_path = str(data_dir / "cache.db") + self.cache_db_path = cache_db_path + self.timeout = timeout + self._init_cache() + + def _init_cache(self) -> None: + conn = sqlite3.connect(self.cache_db_path) + cur = conn.cursor() + cur.execute(""" + CREATE TABLE IF NOT EXISTS query_cache ( + query_key TEXT PRIMARY KEY, + url TEXT NOT NULL, + content TEXT NOT NULL, + timestamp REAL NOT NULL + ); + """) + conn.commit() + conn.close() + + def _get_from_cache(self, query_key: str) -> Optional[str]: + try: + conn = sqlite3.connect(self.cache_db_path) + cur = conn.cursor() + cur.execute("SELECT content FROM query_cache WHERE query_key = ?", (query_key,)) + row = cur.fetchone() + conn.close() + return row[0] if row else None + except Exception: + return None + + def _save_to_cache(self, query_key: str, url: str, content: str) -> None: + try: + conn = sqlite3.connect(self.cache_db_path) + cur = conn.cursor() + cur.execute(""" + INSERT OR REPLACE INTO query_cache (query_key, url, content, timestamp) + VALUES (?, ?, ?, ?); + """, (query_key, url, content, time.time())) + conn.commit() + conn.close() + except Exception: + pass + + def _is_error_response(self, text: str) -> bool: + if not text or not text.strip(): + return True + lower = text.lower() + if ( + "unknown cheat sheet" in lower + or "404 not found" in lower + or "page not found" in lower + or "internal::list" in lower + or text.startswith("#[internal::list]") + or text.startswith("internal::list") + ): + return True + if len(text.strip()) < 5: + return True + return False + + def _http_get(self, url: str) -> Optional[str]: + headers = { + "User-Agent": "curl/7.88.1", + "Accept": "*/*", + } + # ?T ensures plain text without html wrapping + fetch_url = url if "?" in url else f"{url}?T" + try: + resp = requests.get(fetch_url, headers=headers, timeout=self.timeout) + if resp.status_code == 200 and not self._is_error_response(resp.text): + return resp.text.strip() + except Exception: + pass + return None + + def fetch(self, routed: RoutedQuery) -> Optional[FetchResult]: + query_key = routed.raw_query + + # 1. Attempt candidate URLs in priority order + for idx, url in enumerate(routed.candidate_urls): + content = self._http_get(url) + if content: + self._save_to_cache(query_key, url, content) + return FetchResult( + query=routed.raw_query, + url=url, + content=content, + is_cached=False, + is_fallback=(idx > 0), + ) + + # 2. Fallback to local cache if offline or network error + cached_content = self._get_from_cache(query_key) + if cached_content and not self._is_error_response(cached_content): + return FetchResult( + query=routed.raw_query, + url=routed.primary_url, + content=cached_content, + is_cached=True, + is_fallback=False, + ) + + return None diff --git a/src/clipboard.py b/src/clipboard.py new file mode 100644 index 0000000..318c7a0 --- /dev/null +++ b/src/clipboard.py @@ -0,0 +1,118 @@ +import ctypes +from ctypes import wintypes +import os +import platform +import re +import subprocess +from typing import List + +ANSI_ESCAPE_RE = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])") + + +def strip_ansi(text: str) -> str: + """Remove ANSI escape sequences from text.""" + return ANSI_ESCAPE_RE.sub("", text) + + +def extract_code_only(text: str) -> str: + """Extract only executable code lines, removing comments, blank lines, and headers.""" + clean_text = strip_ansi(text) + lines = clean_text.splitlines() + + code_lines: List[str] = [] + for line in lines: + stripped = line.strip() + if not stripped: + continue + + # Skip comment lines + if ( + stripped.startswith("#") + or stripped.startswith("//") + or stripped.startswith("/*") + or stripped.startswith("*") + or stripped.startswith("*/") + or stripped.startswith("rem ") + or stripped.startswith("--") + or stripped.startswith('"""') + or stripped.startswith("'''") + ): + continue + + # Skip cheat.sh page header artifacts + if stripped.startswith("cheat:") or stripped.startswith("tags:") or stripped == "---": + continue + + code_lines.append(line) + + return "\n".join(code_lines).strip() + + +def copy_to_clipboard(text: str) -> bool: + """Copy text to system clipboard across Windows, macOS, and Linux.""" + if not text: + return False + + system = platform.system() + + if system == "Windows": + try: + GMEM_MOVEABLE = 0x0002 + CF_UNICODETEXT = 13 + + user32 = ctypes.windll.user32 + kernel32 = ctypes.windll.kernel32 + + kernel32.GlobalAlloc.restype = wintypes.HGLOBAL + kernel32.GlobalAlloc.argtypes = [wintypes.UINT, ctypes.c_size_t] + + kernel32.GlobalLock.restype = wintypes.LPVOID + kernel32.GlobalLock.argtypes = [wintypes.HGLOBAL] + + kernel32.GlobalUnlock.argtypes = [wintypes.HGLOBAL] + user32.SetClipboardData.argtypes = [wintypes.UINT, wintypes.HANDLE] + + encoded = text.encode("utf-16le") + b"\x00\x00" + + if not user32.OpenClipboard(None): + return False + + user32.EmptyClipboard() + h_mem = kernel32.GlobalAlloc(GMEM_MOVEABLE, len(encoded)) + if not h_mem: + user32.CloseClipboard() + return False + + p_mem = kernel32.GlobalLock(h_mem) + if not p_mem: + user32.CloseClipboard() + return False + + ctypes.memmove(p_mem, encoded, len(encoded)) + kernel32.GlobalUnlock(h_mem) + + user32.SetClipboardData(CF_UNICODETEXT, h_mem) + user32.CloseClipboard() + return True + except Exception: + return False + + elif system == "Darwin": + try: + p = subprocess.Popen(["pbcopy"], stdin=subprocess.PIPE) + p.communicate(text.encode("utf-8")) + return p.returncode == 0 + except Exception: + return False + + else: + # Linux (xclip / wl-copy / xsel) + for cmd in [["wl-copy"], ["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]]: + try: + p = subprocess.Popen(cmd, stdin=subprocess.PIPE) + p.communicate(text.encode("utf-8")) + if p.returncode == 0: + return True + except Exception: + continue + return False diff --git a/src/manifest.py b/src/manifest.py new file mode 100644 index 0000000..bda07fc --- /dev/null +++ b/src/manifest.py @@ -0,0 +1,22 @@ +import json +from pathlib import Path +from typing import Any, Dict + + +def load_manifest() -> Dict[str, Any]: + """Load metadata from manifest.json located at package root.""" + base_dir = Path(__file__).resolve().parent.parent + manifest_path = base_dir / "manifest.json" + if manifest_path.exists(): + try: + with open(manifest_path, "r", encoding="utf-8") as f: + return json.load(f) + except Exception: + pass + return { + "name": "Sec", + "version": "1.0.0", + "stage": "Alpha", + "description": "CLI Cheat Sheet & Code Snippet Assistant", + "dependencies": ["requests>=2.28.0", "rich>=13.0.0"], + } diff --git a/src/renderer.py b/src/renderer.py new file mode 100644 index 0000000..2f5a8bf --- /dev/null +++ b/src/renderer.py @@ -0,0 +1,43 @@ +from rich.console import Console +from rich.panel import Panel +from rich.text import Text + +try: + from sec.src.catalog import catalog + from sec.src.client import FetchResult +except ImportError: + from src.catalog import catalog + from src.client import FetchResult + + +class SnippetRenderer: + """Renders cheat.sh responses in styled terminal format.""" + + def __init__(self, console: Console = None): + self.console = console or Console() + + def render_not_found(self, query: str) -> None: + msg = catalog.format("status.not_found", query=query) + self.console.print(f"[dim]{msg}[/dim]") + + def render_network_error(self) -> None: + msg = catalog.get("status.network_error") + self.console.print(f"[red]{msg}[/red]") + + def render_clipboard_notice(self, is_all: bool) -> None: + key = "status.copied_all" if is_all else "status.copied_code" + msg = catalog.get(key) + self.console.print(f"[bold cyan]>> {msg}[/bold cyan]") + + def render_result(self, result: FetchResult, copied: bool = False, is_all_copy: bool = False) -> None: + if result.is_cached: + cached_notice = catalog.get("status.offline_cached") + self.console.print(f"[yellow]{cached_notice}[/yellow]") + + # Print content with native ANSI formatting + parsed_text = Text.from_ansi(result.content) + self.console.print(parsed_text) + + if copied: + self.console.print("") + self.render_clipboard_notice(is_all_copy) diff --git a/src/router.py b/src/router.py new file mode 100644 index 0000000..473b0ed --- /dev/null +++ b/src/router.py @@ -0,0 +1,209 @@ +from dataclasses import dataclass, field +from typing import List +from urllib.parse import quote_plus + +PROGRAMMING_LANGS = { + "python", "py", "go", "golang", "rust", "rs", "javascript", "js", + "typescript", "ts", "c", "cpp", "c++", "csharp", "cs", "java", "kotlin", + "kt", "swift", "php", "ruby", "rb", "perl", "lua", "r", "scala", "dart", + "elixir", "clojure", "haskell", "hs", "erlang", "zig", "nim", "bash", "sh", + "zsh", "fish", "powershell", "ps1", "sql", "mysql", "postgres", "sqlite", +} + +CLI_TOOLS = { + "tar", "grep", "find", "sed", "awk", "ssh", "scp", "rsync", "curl", "wget", + "chmod", "chown", "ps", "top", "htop", "kill", "lsof", "netstat", "ip", + "tmux", "screen", "vim", "nvim", "nano", "ffmpeg", "jq", "openssl", + "docker", "dockerfile", "compose", "docker-compose", "git", "kubectl", "k8s", + "terraform", "ansible", "nginx", "apache", "systemd", "iptables", "ufw", + "free", "df", "du", "vmstat", "iostat", "sar", "strace", "nc", "nmap", +} + +PLATFORM_STOPWORDS = { + "linux", "ubuntu", "debian", "arch", "centos", "alpine", "unix", + "windows", "macos", "shell", "command", "how", "to", "cli", "example", +} + +COMMON_SYNONYMS = { + "serialize": ["dump", "dumps", "write", "stringify", "encode", "save"], + "serialization": ["dump", "dumps", "write", "stringify", "encode", "save"], + "deserialize": ["load", "loads", "read", "parse", "decode"], + "deserialization": ["load", "loads", "read", "parse", "decode"], + "parse": ["load", "loads", "read", "decode"], + "read": ["load", "open", "parse", "get"], + "write": ["dump", "save", "export", "create"], + "save": ["write", "dump", "export"], + "delete": ["remove", "del", "drop", "pop", "clear"], + "remove": ["delete", "del", "drop", "pop", "clear"], + "sort": ["sorted", "order", "reverse", "orderby"], + "order": ["sort", "sorted", "reverse"], + "find": ["search", "lookup", "match", "filter", "get"], + "search": ["find", "lookup", "match", "grep", "filter"], + "iterate": ["loop", "for", "traverse", "each"], + "loop": ["iterate", "for", "traverse", "while"], + "filter": ["find", "match", "where", "select"], + "reverse": ["reversed", "invert"], + "reversed": ["reverse", "invert"], + "length": ["size", "count", "len"], + "size": ["length", "count", "len"], + "count": ["size", "length", "len"], + "convert": ["cast", "parse", "to", "transform"], + "extract": ["unpack", "unzip", "untar", "decompress"], + "compress": ["archive", "pack", "zip", "tar"], +} + + +@dataclass +class RoutedQuery: + raw_query: str + target: str + subquery: str + candidate_urls: List[str] = field(default_factory=list) + is_targeted: bool = False + + @property + def primary_url(self) -> str: + return self.candidate_urls[0] if self.candidate_urls else "https://cht.sh" + + @property + def fallback_url(self) -> str: + return self.candidate_urls[1] if len(self.candidate_urls) > 1 else self.primary_url + + +class QueryRouter: + """Parses arbitrary CLI tokens into prioritized cheat.sh candidate URLs.""" + + @staticmethod + def _generate_query_variants(tokens: List[str]) -> List[str]: + """Generates orderings and synonym variants for query subterms.""" + variants: List[List[str]] = [list(tokens)] + + # Permutation with reversed terms for two-token subqueries + if len(tokens) == 2: + variants.append([tokens[1], tokens[0]]) + + # Generate synonym replacements + for i, token in enumerate(tokens): + if token in COMMON_SYNONYMS: + for syn in COMMON_SYNONYMS[token]: + new_variant = list(tokens) + new_variant[i] = syn + variants.append(new_variant) + if len(new_variant) == 2: + variants.append([new_variant[1], new_variant[0]]) + + seen = set() + unique_variants: List[str] = [] + for v in variants: + joined = "+".join(quote_plus(t) for t in v) + if joined not in seen: + seen.add(joined) + unique_variants.append(joined) + + return unique_variants + + @classmethod + def route(cls, tokens: List[str]) -> RoutedQuery: + cleaned_tokens = [t.strip().lower() for t in tokens if t.strip()] + if not cleaned_tokens: + return RoutedQuery( + raw_query="", + target="", + subquery="", + candidate_urls=["https://cht.sh"], + is_targeted=False, + ) + + raw_query = " ".join(cleaned_tokens) + first_token = cleaned_tokens[0] + remaining = cleaned_tokens[1:] + + # 1. Programming Languages (cht.sh/python/json+dumps, cht.sh/python/write+json) + if first_token in PROGRAMMING_LANGS: + if remaining: + candidates = [] + variants = cls._generate_query_variants(remaining) + for var in variants: + candidates.append(f"https://cht.sh/{first_token}/{var}") + + # Individual keyword lookups in language scope + for token in remaining: + candidates.append(f"https://cht.sh/{first_token}/{quote_plus(token)}") + + # Search within language + tilde_sub = "~".join(quote_plus(t) for t in remaining) + candidates.append(f"https://cht.sh/{first_token}/~{tilde_sub}") + + # Global fallback with tilde + candidates.append(f"https://cht.sh/~{first_token}~{tilde_sub}") + else: + candidates = [f"https://cht.sh/{first_token}"] + + return RoutedQuery( + raw_query=raw_query, + target=first_token, + subquery=" ".join(remaining), + candidate_urls=candidates, + is_targeted=True, + ) + + # 2. Recognized CLI Tools (cht.sh/tar~extract or cht.sh/tar) + if first_token in CLI_TOOLS: + if remaining: + candidates = [] + tilde_sub = "~".join(quote_plus(t) for t in remaining) + candidates.append(f"https://cht.sh/{first_token}~{tilde_sub}") + + # Synonym variants for CLI tool subqueries + variants = cls._generate_query_variants(remaining) + for var in variants: + candidates.append(f"https://cht.sh/{first_token}/{var}") + + candidates.append(f"https://cht.sh/~{first_token}~{tilde_sub}") + else: + candidates = [ + f"https://cht.sh/{first_token}", + f"https://cht.sh/~{first_token}", + ] + + return RoutedQuery( + raw_query=raw_query, + target=first_token, + subquery=" ".join(remaining), + candidate_urls=candidates, + is_targeted=True, + ) + + # 3. Single word query (cht.sh/command or cht.sh/~word) + if len(cleaned_tokens) == 1: + word = cleaned_tokens[0] + candidates = [ + f"https://cht.sh/{word}", + f"https://cht.sh/~{word}", + ] + return RoutedQuery( + raw_query=raw_query, + target=word, + subquery="", + candidate_urls=candidates, + is_targeted=True, + ) + + # 4. Multi-token general search (e.g., 'linux memory usage' -> '~linux~memory~usage', '~memory~usage', '~memory') + candidates = [] + candidates.append(f"https://cht.sh/~{'~'.join(quote_plus(t) for t in cleaned_tokens)}") + + meaningful_tokens = [t for t in cleaned_tokens if t not in PLATFORM_STOPWORDS] + if meaningful_tokens and meaningful_tokens != cleaned_tokens: + candidates.append(f"https://cht.sh/~{'~'.join(quote_plus(t) for t in meaningful_tokens)}") + if len(meaningful_tokens) > 1: + for token in meaningful_tokens: + candidates.append(f"https://cht.sh/~{quote_plus(token)}") + + return RoutedQuery( + raw_query=raw_query, + target="", + subquery=raw_query, + candidate_urls=candidates, + is_targeted=False, + )