gemcode 0.3.80__py3-none-any.whl → 0.3.82__py3-none-any.whl

gemcode/agent.py

@@ -77,7 +77,8 @@ def build_global_instruction() -> str:
     "Think deeply about what the person actually wants before you do anything. "
     "Use exactly as many tools as the task genuinely requires — no more. "
     "Act fully and autonomously when action is needed. "
-    "Always use read-only tools before shell or write tools."
+    "Always use read-only tools before shell or write tools. "
+    "Never create CLAUDE.md or AGENTS.md; use GEMINI.md for project instructions."
   )
 
 
@@ -580,6 +581,10 @@ You have native deep thinking capability — use it actively:
 Keep tool usage minimal. Prefer short, targeted calls and keep tool outputs small.
 If you need more tool usage examples, set `GEMCODE_VERBOSE_INSTRUCTIONS=1`.
 
+## Instruction files (GemCode — always follow)
+- **Do not** create or modify `CLAUDE.md`, `AGENTS.md`, `claude.local.md`, `agents.local.md`, or `.cursorrules` unless the user **explicitly** asks for that exact filename. Those are for other assistants; GemCode reads **`GEMINI.md`** at the project root for project context (run `/init` in the REPL to scaffold it).
+- If you need to capture project conventions, edit **`GEMINI.md`** or append to **`.gemcode/notes.md`** via the notes tools — not vendor-specific instruction filenames.
+
 """
 
   if not verbose_tools_guide:
@@ -895,10 +900,6 @@ You have two tools to persist project insights across sessions (auto-memory styl
   Notes are loaded at session start so future sessions inherit this knowledge.
 
 - **`read_project_notes()`** — read current notes **only when starting a real engineering task** (editing, debugging, building). Do NOT call this for greetings or general questions. If notes exist and you're about to work on a task, read them once to avoid re-discovering known information.
-
-## Do not create vendor-specific instruction files
-- Do NOT create or modify `CLAUDE.md` or `AGENTS.md`. GemCode does not use these.
-- If project instructions are needed and the user asked for it, use `GEMINI.md` (repo root).
 """
 
   # Inject capability-specific strategy sections only when those caps are on.

gemcode/curated_memory.py

@@ -22,6 +22,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any
 
+from gemcode.wal import append_wal_event, wal_text_fingerprint
+
 
 _SUSPICIOUS = [
   "api_key",
@@ -106,5 +108,15 @@ def append_fact(project_root: Path, *, target: str, text: str) -> dict[str, Any]
   ts = datetime.now().strftime("%Y-%m-%d %H:%M")
   entry = f"\n<!-- {ts} -->\n- {stripped}\n"
   p.write_text(cur + entry, encoding="utf-8")
+  # Best-effort WAL: do not store raw text.
+  append_wal_event(
+    project_root,
+    type="curated_memory.append_fact",
+    data={
+      "target": (target or "").strip().lower() or "memory",
+      "path": str(p),
+      "fingerprint": wal_text_fingerprint(stripped),
+    },
+  )
   return {"status": "appended", "path": str(p)}
 

gemcode/modality_tools.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from typing import Any
 
 from gemcode.config import GemCodeConfig
+from gemcode.query_sanitizer import sanitize_tool_query
 
 
 def _get_embedding_client():
@@ -76,6 +77,10 @@ async def semantic_search_files(
   """
   if not isinstance(query, str) or not query.strip():
     return {"error": "query must be a non-empty string"}
+  s = sanitize_tool_query(query)
+  query = str(s.get("clean_query") or "").strip()
+  if not query:
+    return {"error": "query must be a non-empty string"}
 
   root = Path(project_root).resolve() if project_root else None
   if root is None:
@@ -165,7 +170,13 @@ async def semantic_search_files(
     snippet = chunks[idx][:500].replace("\n", " ")
     matches.append({"path": rel, "snippet": snippet, "score": score})
 
-  return {"query": query, "backend": "embeddings", "matches": matches}
+  return {
+    "query": query,
+    "query_sanitized": bool(s.get("was_sanitized")),
+    "query_sanitizer_method": str(s.get("method")),
+    "backend": "embeddings",
+    "matches": matches,
+  }
 
 
 def build_extra_tools(cfg: GemCodeConfig) -> list[Any]:

gemcode/output_styles.py

@@ -16,11 +16,18 @@ def _is_valid_name(name: str) -> bool:
   return bool(re.fullmatch(r"[a-z0-9][a-z0-9-]{0,63}", name or ""))
 
 
+def _builtin_style_dir() -> Path:
+  # Built-in styles shipped with GemCode (lowest priority).
+  # Located under the python package so they work out-of-the-box.
+  return Path(__file__).resolve().parent / "builtin" / "output-styles"
+
+
 def _style_dirs_for_project(project_root: Path) -> list[Path]:
-  # Project has priority over personal.
+  # Priority (highest last): project > personal > built-in.
   return [
     project_root / ".gemcode" / "output-styles",
     Path.home() / ".gemcode" / "output-styles",
+    _builtin_style_dir(),
   ]
 
 

gemcode/query_sanitizer.py

@@ -0,0 +1,87 @@
+"""
+Mitigate "system prompt contamination" in tool queries.
+
+Inspired by MemPalace's query sanitizer. Goal: prevent catastrophic search degradation
+when an agent accidentally prefixes a long system instruction to a short query.
+"""
+
+from __future__ import annotations
+
+import re
+
+MAX_QUERY_LENGTH = 250
+SAFE_QUERY_LENGTH = 200
+MIN_QUERY_LENGTH = 10
+
+_SENTENCE_SPLIT = re.compile(r"[.!?。！？\n]+")
+_QUESTION_MARK = re.compile(r'[?？]\s*["\']?\s*$')
+_QUOTE_CHARS = {"'", '"'}
+
+
+def sanitize_tool_query(raw_query: str) -> dict[str, object]:
+  """
+  Return a best-effort clean query.
+
+  Returns dict:
+    clean_query: str
+    was_sanitized: bool
+    method: str
+  """
+  if not raw_query or not str(raw_query).strip():
+    return {"clean_query": "", "was_sanitized": False, "method": "empty"}
+
+  raw_query = str(raw_query).strip()
+  n = len(raw_query)
+
+  def _strip_wrapping_quotes(s: str) -> str:
+    s = (s or "").strip()
+    while len(s) >= 2 and s[:1] in _QUOTE_CHARS and s[:1] == s[-1:]:
+      s = s[1:-1].strip()
+    if not s:
+      return ""
+    if s[:1] in _QUOTE_CHARS:
+      s = s[1:].strip()
+    if s[-1:] in _QUOTE_CHARS:
+      s = s[:-1].strip()
+    return s
+
+  def _trim_candidate(s: str) -> str:
+    s = _strip_wrapping_quotes(s)
+    if len(s) <= MAX_QUERY_LENGTH:
+      return s
+    frags = [_strip_wrapping_quotes(x) for x in _SENTENCE_SPLIT.split(s) if x.strip()]
+    for frag in reversed(frags):
+      if MIN_QUERY_LENGTH <= len(frag) <= MAX_QUERY_LENGTH:
+        return frag
+    return s[-MAX_QUERY_LENGTH:].strip()
+
+  if n <= SAFE_QUERY_LENGTH:
+    return {"clean_query": raw_query, "was_sanitized": False, "method": "passthrough"}
+
+  # Prefer last question-looking segment.
+  segments = [s.strip() for s in raw_query.split("\n") if s.strip()]
+  question_candidates: list[str] = []
+  for seg in reversed(segments):
+    if _QUESTION_MARK.search(seg):
+      question_candidates.append(seg)
+  if not question_candidates:
+    sentences = [s.strip() for s in _SENTENCE_SPLIT.split(raw_query) if s.strip()]
+    for sent in reversed(sentences):
+      if "?" in sent or "？" in sent:
+        question_candidates.append(sent)
+
+  if question_candidates:
+    cand = _trim_candidate(question_candidates[0])
+    if len(cand) >= MIN_QUERY_LENGTH:
+      return {"clean_query": cand, "was_sanitized": True, "method": "question_extraction"}
+
+  # Otherwise take the last meaningful segment.
+  for seg in reversed(segments):
+    cand = _trim_candidate(seg)
+    if len(cand) >= MIN_QUERY_LENGTH:
+      return {"clean_query": cand, "was_sanitized": True, "method": "tail_sentence"}
+
+  # Fallback: tail truncation.
+  cand = raw_query[-MAX_QUERY_LENGTH:].strip()
+  return {"clean_query": cand, "was_sanitized": True, "method": "tail_truncation"}
+

gemcode/repl_commands.py

@@ -208,6 +208,8 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("audit",       "Tail audit.log  ·  /logs same"),
     ("autotune",    "Branch + eval ledger  ·  /autotune init <tag>  ·  /autotune eval"),
     ("batch",       "Built-in batch GemSkill (large parallel changes)"),
+    ("caveman",     "Terse output mode  ·  /caveman lite|full|ultra|wenyan|off"),
+    ("caveman:compress", "Compress memory file  ·  /caveman:compress <path> [lite|full|ultra]"),
     ("budget",      "Per-turn token budget  ·  /token-budget same"),
     ("caps",        "Capabilities  ·  /capabilities /capability same"),
     ("clear",       "Fresh session  ·  same as /session new"),
@@ -338,6 +340,7 @@ def slash_help_lines() -> list[str]:
       "  /gemskill <name>        Load an existing GemSkill into this session (system prompt)",
       "  /gemskill list|clear    List skills or unload all session-loaded skills",
       "  /append gemskill <name> <request>  Ask the agent to edit that skill file",
+      "  /caveman [level]|off    Terse output mode (like caveman-speak). Levels: lite|full|ultra|wenyan-lite|wenyan|wenyan-ultra",
       "  /style                List available output styles",
       "  /style <name>|off     Activate an output style for this session",
       "  /rules                Show loaded rule files (from .gemcode/rules/)",

gemcode/repl_slash.py

@@ -419,6 +419,91 @@ async def process_repl_slash(
     out()
     return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
 
+  # ── /caveman (shortcut to built-in output styles) ─────────────────────────
+  if name == "caveman":
+    args = (sc.args or "").strip().lower()
+    # Levels map to built-in output styles (still overridable by project/user styles).
+    mapping = {
+      "": "caveman",
+      "full": "caveman",
+      "lite": "caveman-lite",
+      "ultra": "caveman-ultra",
+      "wenyan": "caveman-wenyan",
+      "wenyan-full": "caveman-wenyan",
+      "wenyan-lite": "caveman-wenyan-lite",
+      "wenyan-ultra": "caveman-wenyan-ultra",
+    }
+    if args in ("off", "stop", "normal", "none", "clear", "reset", "default"):
+      setattr(cfg, "output_style", None)
+      out("caveman: off (output_style cleared)")
+      out("Runner will rebuild on next turn to apply changes.")
+      out()
+      return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+    if args not in mapping:
+      out("Usage:")
+      out("  /caveman                (full)")
+      out("  /caveman lite|full|ultra")
+      out("  /caveman wenyan-lite|wenyan|wenyan-ultra")
+      out("  /caveman off")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    choice = mapping[args]
+    styles = discover_output_styles(cfg.project_root)
+    if choice not in styles or load_output_style(cfg.project_root, choice) is None:
+      out(f"caveman: style unavailable: {choice}")
+      out("Tip: update GemCode, or create a custom style at .gemcode/output-styles/")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    setattr(cfg, "output_style", choice)
+    out(f"caveman: on — output_style: {choice}")
+    out("Runner will rebuild on next turn to apply changes.")
+    out()
+    return ReplSlashResult(skip_model_turn=True, force_rebuild_runner=True)
+
+  # ── /caveman:compress (alias for /compress-memory) ────────────────────────
+  if name in ("caveman:compress", "caveman-compress", "caveman:compress-memory"):
+    args = (sc.args or "").strip()
+    parts = args.split()
+    if not parts:
+      out("Usage:")
+      out("  /caveman:compress <path> [lite|full|ultra]")
+      out("Note: mode defaults based on active /caveman level (or full).")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    target = parts[0]
+    mode = (parts[1].strip().lower() if len(parts) >= 2 else "")
+    if mode and mode not in ("lite", "full", "ultra"):
+      out(f"Unknown mode: {mode}")
+      out("Use: lite|full|ultra (or omit to auto-pick from current caveman level)")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    # Auto-pick mode from current output_style if not provided.
+    if not mode:
+      os_ = (getattr(cfg, "output_style", None) or "").lower()
+      if os_ in ("caveman-lite",):
+        mode = "lite"
+      elif os_ in ("caveman-ultra",):
+        mode = "ultra"
+      else:
+        mode = "full"
+
+    # Dispatch as a model turn so the agent runs the tool and reports results.
+    prompt = (
+      "Compress a memory file now.\n\n"
+      f"- target: `{target}`\n"
+      f"- mode: `{mode}`\n\n"
+      "Call `compress_memory_file(path=..., mode=...)` and report:\n"
+      "- ok/error\n"
+      "- path + backup_path\n"
+      "- warnings (if any)\n"
+      "- chars_before/chars_after\n"
+    )
+    return ReplSlashResult(model_prompt=prompt)
+
   # ── /rules ────────────────────────────────────────────────────────────────
   if name == "rules":
     rules = _load_rules(cfg.project_root, touched_paths=None)
@@ -1045,6 +1130,8 @@ async def process_repl_slash(
       "3. Look at the source directory structure (src/, lib/, app/, etc.)\n"
       "4. Check for test directories and test runner config\n"
       "5. Look for linting/formatting config files (.eslintrc, .prettierrc, ruff.toml, etc.)\n\n"
+      "Write **only** to `GEMINI.md` at the project root. Do **not** create "
+      "`CLAUDE.md`, `AGENTS.md`, `.cursorrules`, or similar.\n\n"
       "Then write a GEMINI.md file at the project root containing:\n"
       "# Project Name\n"
       "One-sentence description.\n\n"

gemcode/skills.py

@@ -71,6 +71,40 @@ _BUILTIN_SKILLS: dict[str, tuple[GemSkillMeta, str]] = {
       "- **Final**: verification + next steps\n"
     ),
   ),
+  "compress-memory": (
+    GemSkillMeta(
+      name="compress-memory",
+      description=(
+        "Compress a markdown memory file (GEMINI.md, .gemcode notes, todos) into a terse style "
+        "to reduce input tokens, while preserving code blocks, headings, and URLs."
+      ),
+      disable_model_invocation=False,
+      user_invocable=True,
+    ),
+    (
+      "## Compress memory file\n"
+      "Use this skill to rewrite a markdown-like memory file into a more token-efficient form.\n\n"
+      "### When to use\n"
+      "- The user asks to compress GEMINI.md, .gemcode notes, preferences, or other prose-heavy markdown.\n"
+      "- The user wants fewer input tokens each session.\n\n"
+      "### Safety and boundaries\n"
+      "- ONLY run on markdown-like files (.md/.txt/.rst, or extensionless files under .gemcode/).\n"
+      "- NEVER run on secret/credential/key files (.env, credentials, .ssh, .aws, *.pem, etc.).\n"
+      "- This operation sends file content to the Gemini API.\n"
+      "- Tool will create a backup: `<stem>.original.md` and abort if backup already exists.\n"
+      "- Tool validates: headings, fenced code blocks, URLs. On failure, it restores the original.\n\n"
+      "### How to run\n"
+      "1. Confirm target file path from `$ARGUMENTS`.\n"
+      "2. Pick mode: `lite`, `full`, or `ultra` (default `full`).\n"
+      "3. Call the tool:\n\n"
+      "```python\n"
+      "compress_memory_file(path=\"$ARGUMENTS\", mode=\"$ARGUMENTS[1]\")\n"
+      "```\n\n"
+      "If no mode provided, call with `mode=\"full\"`.\n\n"
+      "### Output\n"
+      "- Report: ok/error, file path, backup path, and any warnings.\n"
+    ),
+  ),
 }
 
 

gemcode/tools/__init__.py

@@ -18,6 +18,7 @@ from gemcode.tools.web import make_web_fetch_tool
 from gemcode.tools.web_search import make_web_search_tool
 from gemcode.checkpoints import list_checkpoints as _list_checkpoints, undo_checkpoint as _undo_checkpoint
 from gemcode.tools.curated_memory import make_curated_memory_tools
+from gemcode.tools.compress_memory import make_compress_memory_tool
 from gemcode.tools.skills import make_skill_tools
 
 
@@ -87,6 +88,7 @@ def build_function_tools(cfg: GemCodeConfig, *, include_subtask: bool = True) ->
   load_tool_result = _make_load_tool_result_tool(cfg)
   repo_map = make_repo_map_tool(cfg)
   remember_fact, read_curated_memory = make_curated_memory_tools(cfg)
+  compress_memory_file = make_compress_memory_tool(cfg)
   list_skills, load_skill, skills_manifest = make_skill_tools(cfg)
 
   def checkpoints_list(limit: int = 20) -> dict:
@@ -149,6 +151,8 @@ def build_function_tools(cfg: GemCodeConfig, *, include_subtask: bool = True) ->
     # Evolving: curated memory (safe-to-inject facts)
     remember_fact,
     read_curated_memory,
+    # Optional: compress memory files (markdown only; safe guards apply)
+    compress_memory_file,
     # GemSkills (on-demand playbooks)
     list_skills,
     load_skill,

gemcode/tools/compress_memory.py

@@ -0,0 +1,333 @@
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from gemcode.paths import PathEscapeError, resolve_under_allowed_roots
+from gemcode.wal import append_wal_event
+
+
+_OUTER_FENCE_REGEX = re.compile(r"\A\s*(`{3,}|~{3,})[^\n]*\n(.*)\n\1\s*\Z", re.DOTALL)
+_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)
+
+# Files and paths that almost certainly contain secrets/PII. This tool sends file content
+# to the Gemini API; refuse high-risk targets to avoid accidental exfiltration.
+_SENSITIVE_BASENAME_REGEX = re.compile(
+  r"(?ix)^("
+  r"\.env(\..+)?"
+  r"|\.netrc"
+  r"|credentials(\..+)?"
+  r"|secrets?(\..+)?"
+  r"|passwords?(\..+)?"
+  r"|id_(rsa|dsa|ecdsa|ed25519)(\.pub)?"
+  r"|authorized_keys"
+  r"|known_hosts"
+  r"|.*\.(pem|key|p12|pfx|crt|cer|jks|keystore|asc|gpg)"
+  r")$"
+)
+_SENSITIVE_PATH_COMPONENTS = frozenset({".ssh", ".aws", ".gnupg", ".kube", ".docker"})
+_SENSITIVE_NAME_TOKENS = (
+  "secret",
+  "credential",
+  "password",
+  "passwd",
+  "apikey",
+  "accesskey",
+  "token",
+  "privatekey",
+)
+
+
+def _is_sensitive_path(filepath: Path) -> bool:
+  name = filepath.name
+  if _SENSITIVE_BASENAME_REGEX.match(name):
+    return True
+  lowered_parts = {p.lower() for p in filepath.parts}
+  if lowered_parts & _SENSITIVE_PATH_COMPONENTS:
+    return True
+  lower = re.sub(r"[_\-\s.]", "", name.lower())
+  return any(tok in lower for tok in _SENSITIVE_NAME_TOKENS)
+
+
+def _strip_llm_wrapper(text: str) -> str:
+  """Strip a single outer ```markdown ...``` fence if it wraps the entire output."""
+  m = _OUTER_FENCE_REGEX.match(text)
+  if m:
+    return m.group(2)
+  return text
+
+
+def _extract_urls(text: str) -> set[str]:
+  return set(_URL_REGEX.findall(text or ""))
+
+
+def _extract_headings(text: str) -> list[tuple[str, str]]:
+  return [(level, title.strip()) for level, title in _HEADING_REGEX.findall(text or "")]
+
+
+def _extract_code_blocks(text: str) -> list[str]:
+  """Line-based fenced code block extractor supporting variable fence lengths."""
+  blocks: list[str] = []
+  lines = (text or "").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))
+    block_lines = [lines[i]]
+    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))
+  return blocks
+
+
+@dataclass
+class _ValidationResult:
+  is_valid: bool
+  errors: list[str]
+  warnings: list[str]
+
+
+def _validate_markdown(original: str, compressed: str) -> _ValidationResult:
+  errors: list[str] = []
+  warnings: list[str] = []
+
+  # Headings: keep count and order.
+  h1 = _extract_headings(original)
+  h2 = _extract_headings(compressed)
+  if len(h1) != len(h2):
+    errors.append(f"Heading count mismatch: {len(h1)} vs {len(h2)}")
+  if h1 != h2:
+    warnings.append("Heading text/order changed")
+
+  # Code blocks and URLs are strict invariants.
+  if _extract_code_blocks(original) != _extract_code_blocks(compressed):
+    errors.append("Code blocks not preserved exactly")
+
+  u1 = _extract_urls(original)
+  u2 = _extract_urls(compressed)
+  if u1 != u2:
+    errors.append(f"URL mismatch: lost={sorted(u1 - u2)[:6]}, added={sorted(u2 - u1)[:6]}")
+
+  return _ValidationResult(is_valid=(not errors), errors=errors, warnings=warnings)
+
+
+def _looks_like_natural_language(path: Path) -> bool:
+  # Conservative: compress only markdown-ish inputs.
+  ext = path.suffix.lower()
+  if ext in (".md", ".markdown", ".txt", ".rst"):
+    return True
+  # Allow extensionless, but only under .gemcode/ by convention.
+  if not ext and ".gemcode" in {p.lower() for p in path.parts}:
+    return True
+  return False
+
+
+def _build_prompt(original: str, *, mode: str) -> str:
+  style = {
+    "lite": "Lite: remove filler/hedging, keep full sentences.",
+    "full": "Full: drop articles, fragments ok, short synonyms.",
+    "ultra": "Ultra: telegraphic, abbreviate, arrows for causality.",
+  }.get(mode, "Full: drop articles, fragments ok, short synonyms.")
+
+  return f"""
+Compress this markdown into a terse style (caveman-like).
+
+TARGET STYLE: {style}
+
+STRICT RULES:
+- Do NOT modify anything inside fenced code blocks (``` or ~~~). Copy them EXACTLY.
+- Do NOT modify anything inside inline backticks. Copy EXACTLY.
+- Preserve ALL URLs exactly.
+- Preserve ALL headings exactly (same heading lines, same order).
+- Return ONLY the compressed markdown body (no outer ```markdown fence).
+
+Only compress natural language prose outside code/backticks.
+
+TEXT:
+{original}
+""".strip()
+
+
+def _build_fix_prompt(original: str, compressed: str, errors: list[str]) -> str:
+  errors_str = "\n".join(f"- {e}" for e in errors)
+  return f"""You are fixing a compressed markdown file. Specific validation errors were found.
+
+CRITICAL RULES:
+- DO NOT recompress or rephrase the whole file
+- ONLY fix the listed errors — leave everything else exactly as-is
+- The ORIGINAL is reference only (to restore missing content)
+- Preserve the terse style in untouched sections
+
+ERRORS TO FIX:
+{errors_str}
+
+ORIGINAL (reference only):
+{original}
+
+COMPRESSED (fix this):
+{compressed}
+
+Return ONLY the fixed compressed file. No explanation.
+"""
+
+
+def make_compress_memory_tool(cfg):
+  """
+  Build a function tool that compresses markdown-like memory files.
+  """
+  project_root = cfg.project_root
+
+  def compress_memory_file(
+    path: str,
+    *,
+    mode: str = "full",
+    max_bytes: int = 500_000,
+    backup_ext: str = ".original.md",
+  ) -> dict:
+    """
+    Compress a markdown-like memory file to reduce input tokens.
+
+    Safety:
+    - Refuses paths that look like secrets (keys, credentials, .ssh, .aws, etc.)
+    - Size-capped before any model call
+    - Writes backup as <stem>{backup_ext}; aborts if backup exists
+    - Validates headings/URLs/code blocks; restores original on failure
+    """
+    extra_roots = getattr(cfg, "_added_dirs", None) or {}
+    try:
+      p, _scope = resolve_under_allowed_roots(project_root, path, extra_roots=extra_roots)
+    except PathEscapeError as e:
+      return {"ok": False, "error": str(e)}
+
+    if not p.exists():
+      return {"ok": False, "error": f"File not found: {p}"}
+    if not p.is_file():
+      return {"ok": False, "error": f"Not a file: {p}"}
+    if p.stat().st_size > max_bytes:
+      return {"ok": False, "error": f"File too large (max {max_bytes} bytes): {p}"}
+    if _is_sensitive_path(p):
+      return {
+        "ok": False,
+        "error": (
+          f"Refusing to compress {p}: filename/path looks sensitive. "
+          "This tool sends file content to the Gemini API."
+        ),
+      }
+    if not _looks_like_natural_language(p):
+      return {"ok": False, "error": f"Refusing: not a markdown-like file: {p.name}"}
+    if p.name.endswith(backup_ext):
+      return {"ok": False, "error": f"Refusing: backup file target: {p.name}"}
+
+    original = p.read_text(encoding="utf-8", errors="replace")
+    backup_path = p.with_name(p.stem + backup_ext)
+    if backup_path.exists():
+      return {"ok": False, "error": f"Backup already exists: {backup_path}"}
+
+    # Call Gemini (local-first but does cross the API boundary).
+    try:
+      from google.genai import Client
+    except Exception as e:
+      return {"ok": False, "error": f"google-genai unavailable: {e}"}
+
+    api_key = os.environ.get("GOOGLE_API_KEY")
+    if not api_key:
+      return {"ok": False, "error": "GOOGLE_API_KEY is not set"}
+
+    model = os.environ.get("GEMCODE_COMPRESS_MODEL") or getattr(cfg, "model_alt", None) or cfg.model
+
+    client = Client(api_key=api_key)
+    prompt = _build_prompt(original, mode=mode)
+    try:
+      resp = client.models.generate_content(
+        model=model,
+        contents=prompt,
+      )
+      text = getattr(resp, "text", None) or ""
+    except Exception as e:
+      return {"ok": False, "error": f"Gemini call failed: {type(e).__name__}: {e}"}
+
+    compressed = _strip_llm_wrapper((text or "").strip())
+
+    # Write backup + compressed, then validate with repair loop.
+    backup_path.write_text(original, encoding="utf-8")
+    p.write_text(compressed, encoding="utf-8")
+
+    max_retries = 2
+    for attempt in range(max_retries + 1):
+      res = _validate_markdown(original, compressed)
+      if res.is_valid:
+        # Best-effort WAL: metadata only (no content).
+        append_wal_event(
+          project_root,
+          type="compress_memory_file",
+          data={
+            "path": str(p),
+            "backup_path": str(backup_path),
+            "mode": mode,
+            "chars_before": len(original),
+            "chars_after": len(compressed),
+            "warnings": res.warnings,
+          },
+        )
+        return {
+          "ok": True,
+          "path": str(p),
+          "backup_path": str(backup_path),
+          "warnings": res.warnings,
+          "chars_before": len(original),
+          "chars_after": len(compressed),
+        }
+      if attempt >= max_retries:
+        # Restore original.
+        p.write_text(original, encoding="utf-8")
+        try:
+          backup_path.unlink()
+        except OSError:
+          pass
+        return {"ok": False, "error": f"Validation failed: {res.errors}", "warnings": res.warnings}
+
+      # Targeted fix
+      fix_prompt = _build_fix_prompt(original, compressed, res.errors)
+      try:
+        resp2 = client.models.generate_content(model=model, contents=fix_prompt)
+        fixed = _strip_llm_wrapper(((getattr(resp2, "text", None) or "")).strip())
+      except Exception as e:
+        p.write_text(original, encoding="utf-8")
+        try:
+          backup_path.unlink()
+        except OSError:
+          pass
+        return {"ok": False, "error": f"Fix attempt failed: {type(e).__name__}: {e}"}
+
+      compressed = fixed
+      p.write_text(compressed, encoding="utf-8")
+
+    return {"ok": False, "error": "Unexpected failure"}
+
+  compress_memory_file.__name__ = "compress_memory_file"
+  return compress_memory_file
+

gemcode/tools/edit.py

@@ -23,11 +23,16 @@ def make_edit_tools(cfg: GemCodeConfig):
     except Exception:
       pass
 
-  # Block writes to common non-GemCode agent instruction filenames.
-  _BLOCKED_SPECIAL_FILES = {
-    "claude.md",
-    "agents.md",
-  }
+  # Block writes to common non-GemCode / third-party agent instruction filenames.
+  _BLOCKED_SPECIAL_FILES = frozenset(
+      {
+          "claude.md",
+          "agents.md",
+          "claude.local.md",
+          "agents.local.md",
+          ".cursorrules",
+      }
+  )
 
   def _blocked_special_path(path: str) -> str | None:
     try:

gemcode/tools/web_search.py

@@ -18,6 +18,8 @@ import urllib.request
 from html.parser import HTMLParser
 from typing import Any
 
+from gemcode.query_sanitizer import sanitize_tool_query
+
 
 class _DDGResultParser(HTMLParser):
     """Parse DuckDuckGo HTML search results page into a list of hits."""
@@ -222,7 +224,11 @@ def make_web_search_tool():
         """
         if not query or not query.strip():
             return {"error": "query must not be empty"}
-        query = query.strip()
+        raw = query.strip()
+        s = sanitize_tool_query(raw)
+        query = str(s.get("clean_query") or "").strip()
+        if not query:
+            return {"error": "query must not be empty"}
         max_results = max(1, min(int(max_results), 20))
 
         # Try the richer duckduckgo_search package first
@@ -239,6 +245,8 @@ def make_web_search_tool():
 
         return {
             "query": query,
+            "query_sanitized": bool(s.get("was_sanitized")),
+            "query_sanitizer_method": str(s.get("method")),
             "results": results,
             "count": len(results),
             "tip": "Use web_fetch(url) to read the full content of any result.",

gemcode/wal.py

@@ -0,0 +1,62 @@
+"""
+Write-ahead log (WAL) for durable, user-visible state mutations.
+
+Goal: auditability and safer debugging for memory-related writes without logging
+full sensitive content.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def wal_path(project_root: Path) -> Path:
+  return project_root / ".gemcode" / "wal.jsonl"
+
+
+def _utc_now_iso() -> str:
+  return datetime.now(timezone.utc).isoformat()
+
+
+def _sha256_hex(text: str) -> str:
+  return hashlib.sha256((text or "").encode("utf-8", errors="ignore")).hexdigest()
+
+
+@dataclass(frozen=True)
+class WalEvent:
+  type: str
+  ts: str
+  data: dict[str, Any]
+
+
+def append_wal_event(project_root: Path, *, type: str, data: dict[str, Any]) -> dict[str, Any]:
+  """
+  Append a JSONL WAL record under .gemcode/wal.jsonl.
+
+  This function must be best-effort: if WAL writing fails, do not block the
+  primary operation.
+  """
+  try:
+    p = wal_path(project_root)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    ev = WalEvent(type=type, ts=_utc_now_iso(), data=data)
+    line = json.dumps({"type": ev.type, "ts": ev.ts, "data": ev.data}, ensure_ascii=False)
+    with p.open("a", encoding="utf-8") as f:
+      f.write(line + "\n")
+    return {"ok": True, "path": str(p)}
+  except Exception as e:
+    return {"ok": False, "error": f"{type(e).__name__}: {e}"}
+
+
+def wal_text_fingerprint(text: str) -> dict[str, Any]:
+  """
+  Content fingerprint for WAL without storing raw text.
+  """
+  t = (text or "").strip()
+  return {"chars": len(t), "sha256": _sha256_hex(t)}
+

{gemcode-0.3.80.dist-info → gemcode-0.3.82.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.80
+Version: 0.3.82
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -381,6 +381,7 @@ State is **project-local** (unless noted).
 | `policy.json` | Self-tuning profile for dynamic token / evidence budgets. |
 | `memories.jsonl` | Embedding-backed memory when `GEMCODE_ENABLE_MEMORY=1`. |
 | `notes.md` | Agent notes surfaced via `/notes`. |
+| `wal.jsonl` | Write-ahead log for curated memory + compression actions (metadata only). |
 | `evals/last_eval.json` | Latest `gemcode eval` record. |
 | `evals/autotune_ledger.jsonl` | Rows from `gemcode autotune eval`. |
 | `skills/<name>/SKILL.md` | **GemSkills** (project-scoped; see [GemSkills](#gemskills)). |
@@ -473,7 +474,7 @@ Tools are registered in `gemcode/tools/` and exposed to the model as ADK functio
 - **Computer use:** ADK `ComputerUseToolset` + Playwright (separate install and flags).
 - **MCP:** Tools loaded from configured servers.
 
-**Vendor file policy:** Writes to certain vendor-specific instruction filenames (e.g. `CLAUDE.md`, `AGENTS.md`) are blocked; use project conventions like `GEMINI.md` and curated memory files instead.
+**Vendor file policy:** Writes to certain third-party instruction filenames (`CLAUDE.md`, `AGENTS.md`, `*.local` variants, `.cursorrules`, …) are blocked; use `GEMINI.md` and `.gemcode/notes.md` instead. The agent instruction always states this; `write_file` / `search_replace` enforce it.
 
 ---
 
@@ -590,6 +591,13 @@ Legacy filenames **`.gemcode/MEMORY.md`** and **`.gemcode/USER.md`** are still r
 
 Content is **sanitized** before append (length and sensitivity heuristics). The REPL command **`/curated`** prints a bounded snapshot of what would be injected. When the **memory** capability is enabled, curated material can be combined with broader memory tools—see **`remember_fact`**, **`read_curated_memory`** in the [function tools](#function-tools-catalog) table.
 
+### Query sanitization (tooling)
+
+Some tools sanitize long “contaminated” queries (e.g. accidental system-prompt prefixes) down to a short, likely-intended query. This currently applies to:
+
+- `web_search(query=...)`
+- `semantic_search_files(query=...)` (when `--embeddings` is on)
+
 ---
 
 ## Workspace trust

{gemcode-0.3.80.dist-info → gemcode-0.3.82.dist-info}/RECORD

@@ -1,6 +1,6 @@
 gemcode/__init__.py,sha256=l0DCRYqK7KM7Fb7u49fqh-5_SlpeIL7r3LjMeJWMgSg,112
 gemcode/__main__.py,sha256=EX2s1hxq2Yvli_-tnBN3w5Qv4bOjsBBbjyISF0pDIQw,37
-gemcode/agent.py,sha256=_v00pQSOzAI9nyaaKC1wn-aTalD4SV52KDzwlyIHJAo,56867
+gemcode/agent.py,sha256=NB2eP7RV8vNp4flk4P4aB_LIIV8TvZtB7ZEXA4O3h-Q,57262
 gemcode/audit.py,sha256=bh9uhXaeh8wqxqoZtz3ZAowd8Ndk1ss-mw9993Vlrgo,469
 gemcode/autocompact.py,sha256=OE3QbGx2gWN2WVXy28Sd0xyfAJgVR1x6ml9HrX2CB7I,6719
 gemcode/autotune.py,sha256=zcTGDKC8LSnw0fHuoOcnnh1rz0by8K6MTUKl0_GhT9s,2704
@@ -13,7 +13,7 @@ gemcode/config.py,sha256=Nmq0ClbebkbqfCPZOw8ETGjpjHuGCtByzpEMU1V5Wvg,18208
 gemcode/context_budget.py,sha256=nctVwzpUg6kyBL0FHM7xcrvVvZpX9qj7cZK4IczfKAg,10534
 gemcode/context_warning.py,sha256=YwkkNx6AM2ugOckg8QhRWYcU6D3UJXUOHiBwjKQT2rs,4199
 gemcode/credentials.py,sha256=o1gQ4oQXAjjA1IANXgCalM3WjTkfVkbkXsf-lNVQ55I,1300
-gemcode/curated_memory.py,sha256=5GfMS7JgSfEkAgnjFQle1Zy4VpoyKXI0osifnhMhZv8,3215
+gemcode/curated_memory.py,sha256=bhq8UesUCXJEWvIoOZ2pF9HoUVDheZCkErq-zJ_BVjA,3557
 gemcode/dynamic_policy.py,sha256=nWgBN6ffSn1Te4aDI1MURxRaQjTclzIuSf4KaAskE9U,4662
 gemcode/hitl_session.py,sha256=oNiI7odFJGUcmqPavjKLJOEumZKrgklLvwjjrIG9GPg,281
 gemcode/hooks.py,sha256=tAzzZgfALC-nqSGoUdnEvHyGJNM2iTqKN5Yrfm8wFo8,6350
@@ -28,25 +28,26 @@ gemcode/limits.py,sha256=3j6N8V643X7-nP-cAIf37Xg9bkGpQlEJB3nPptApQWk,2504
 gemcode/live_audio_engine.py,sha256=wxdGp5ciAgQ7WIeBpcW_hm8lbMDsh0KPJbqIS9uAGxA,3406
 gemcode/logging_config.py,sha256=nw_FyJbXM3StzaAx6b6BLLNvzuxsGg-sdQ3QRw7BWgs,1080
 gemcode/mcp_loader.py,sha256=alipHTl5aA7ZCPG6Rq9cyy3UZLsdCra0CETb_fRJl_k,4964
-gemcode/modality_tools.py,sha256=tCcqY6Ca8a_kaO58GBC6OmrmLrrZs_jcKv6fTvt5esE,6879
+gemcode/modality_tools.py,sha256=L2U756l0YM4SOUx5YxcKEkjSF1QOGzFOSE4o3U0q-4Y,7213
 gemcode/model_errors.py,sha256=j1nb1dopJyZ6MQQvuuADBqvmcqdL80kQWACuWKMkP4Q,4185
 gemcode/model_routing.py,sha256=_8mnXNwxMPA8wAfl-Yx5lWNgjhyWYTCCCMGlqdGAw90,5174
 gemcode/multimodal_input.py,sha256=FrfwcmqgDKnPDWxj76GOltl34D3PNQHxgbSR7ykL8SU,4450
 gemcode/openapi_loader.py,sha256=g_NZD8YL9_9iIJJ9qykhdbBrylJ1195A4FyHGC0mroc,4157
-gemcode/output_styles.py,sha256=29LSK3GGQLcodQhtXjSozgxCj7Z6VZZK8gIodOAC5EA,1910
+gemcode/output_styles.py,sha256=6ZgbEsEM5qbdGDZMuRFRHAmHCoKpi53SqPqXZ2sfbS4,2189
 gemcode/paths.py,sha256=UQp4R4sUBv7HsM2OVoGlPxyOIOQZE5wpY53G6nHpB5Q,2671
 gemcode/permissions.py,sha256=QqaWxSv9oYtGOV0xxftPces7MUgHlGQ2z4DcwlQANEc,6892
 gemcode/policy_profile.py,sha256=kcaKJQwLxAo3RjqfJJHl_G7B5GgTYKco0z3k5QcXsVY,3861
 gemcode/pricing.py,sha256=lftp0SwyDqOzHqC2-6XzgZZhjif5PLdCe1Q3wY-p6kQ,3558
 gemcode/prompt_suggestions.py,sha256=RNEclxtoorRqu-wUlzuyUJ7OLFVOOryGOZBpbaCducI,2544
+gemcode/query_sanitizer.py,sha256=KqXo5U7igNSgOAH4YpyANlgS--1WnZEdpO4AU4SNQUs,2746
 gemcode/refine.py,sha256=BijEZ4Z32wGa9aK_WottyAhZF-j0xEqRg5UpjedNv2A,7653
-gemcode/repl_commands.py,sha256=XKGXLkA_KfQZubg9_oNjKdd2NXnxOMi8KiwVU8Lllvc,18892
-gemcode/repl_slash.py,sha256=HNtKDiV2EHCMxvr3uWC8x1XkcpwGlRmunS6_ySwyr1E,85938
+gemcode/repl_commands.py,sha256=fR2vgaNbpOKNhLLs3rEEnWUarZyjy9EPZWopKApdXL0,19204
+gemcode/repl_slash.py,sha256=ENG0gE1_aN-V8YCwmIAbcZKHhRaHmQCCJ5zgSxfpq5c,89444
 gemcode/review_agent.py,sha256=4t7_5-aE60b4-EheJ_eSB_H2eQYf9GppKoui6jw0TME,5264
 gemcode/rules.py,sha256=Itg02VpifOo6jqGj5xwna_ahaPPb0OVtaeR2cNI0pLE,3018
 gemcode/session_runtime.py,sha256=MQr34s6dw4bmk_VPSgBvkJTMwUBZQhvWDXl_iC5Pp6s,20867
 gemcode/session_store.py,sha256=POUT_QQf715c74jbXj0s5vCd4dlAgJz_CLsIWuEUoO0,6051
-gemcode/skills.py,sha256=sT22J1dMzGuLn1DIwf3hJg3frSSlb9LfdES59SrFvW4,9595
+gemcode/skills.py,sha256=Sbg6bGz4DRg-NC3T3MrlRc9hHwVAB7jAObfIhp4NE5g,11244
 gemcode/slash_commands.py,sha256=bcD-S_H7p7AlTli6g2dLPPG46HejPje0Imb3ScDTCaQ,798
 gemcode/thinking.py,sha256=-1TVkOMG-7CSQN0Mc18EqINkUxWOMBgeTlF7CX9zYL4,4641
 gemcode/tool_prompt_manifest.py,sha256=BbM88yj6hN5CTDBzyHa7DZ1S6gpzIZQe9G7dFqkMmtA,8681
@@ -56,6 +57,7 @@ gemcode/tools_inspector.py,sha256=ZAuD1oVIsZvyD_vrzaWBws2ezpFT6cIsU_w4yc_1PPA,40
 gemcode/trust.py,sha256=kZi1dll1T8RUZtSY42WbsEh-ZIkMRup_IZPfYlJMbw4,1457
 gemcode/version.py,sha256=uwynYS-RmK8CDoqGtt8976kFkJv0zELkEAlwebnp_io,380
 gemcode/vertex.py,sha256=Fy8zxuU8jWkObt0WDRI0XmgnjNznILXVLVwKjImNz9Q,643
+gemcode/wal.py,sha256=moUldC__j0YmuNhVuawIIDYSoIgZ9_HpwKFvU9vieq8,1645
 gemcode/workspace_hints.py,sha256=WQFwyoGnVrzzYSl0s5MNcd1-UP11Ao8KGgrdFIB5m9g,621
 gemcode/computer_use/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gemcode/computer_use/browser_computer.py,sha256=bWXXgj7K6ZrDqT49iPEcnBd_ZJBwRxSgKhzKaJpn4cQ,13212
@@ -73,11 +75,12 @@ gemcode/query/engine.py,sha256=RuAx7jWLjkvUQcTjRry22GOY27GvAPhkt6r6AZGpokw,1416
 gemcode/query/stop_hooks.py,sha256=wBInW-hmHoFdTs91Jc7YY52Tx9GT63CU-P9Gbd9ijNQ,1842
 gemcode/query/token_budget.py,sha256=lmoFx1RNRdafPisO3bxt7p7bkr5lyCMV7N2T7caHwKA,2957
 gemcode/query/transitions.py,sha256=30xfeexEF1C2pjqvr00dvkdSsnsZ4UQTfi_c4wIhmd0,929
-gemcode/tools/__init__.py,sha256=PiVHym3WCkRCC3Y45y_bORnhplY91LaIOaloRYjHPRY,5746
+gemcode/tools/__init__.py,sha256=BrS0vs0D2l6rPTYq26Ayl8eEN_gIfluvk9zxapMzsg4,5969
 gemcode/tools/bash.py,sha256=kedqaL2CU6O9WLPT83FToqJSaRBEGHesJSBH4pRLHlU,13649
 gemcode/tools/browser.py,sha256=StWRttiyGkR4qaG5urRviJgdoj2hiFB2OuHPItaVzJY,7250
+gemcode/tools/compress_memory.py,sha256=rI8Uu8DO_io6ltRYgTdlNhQLZjyJCpSObnQ15CBVlQI,10396
 gemcode/tools/curated_memory.py,sha256=HgpZS81Ncvf0aoSiQ9zDdJdMTA_NWTL4bjLy34Z9a_A,1044
-gemcode/tools/edit.py,sha256=_n45v10YQyKKE2muLDIyeFImzFs0fRztG4xv-HOLnDw,7807
+gemcode/tools/edit.py,sha256=XQbN9iZNiUmzieSDNMPiK-I3LWt5EkJdDPN9slyUJn0,7942
 gemcode/tools/filesystem.py,sha256=1GtLPOKzgjsGNoQA1UvjaUA2MDzm4RjhxUsolGm2ImA,8330
 gemcode/tools/notebook.py,sha256=SF7c-iBDz8heBRK2hERYq39tFeEixhP-1d0kIHBruW4,9208
 gemcode/tools/notes.py,sha256=y1UJOMKntDDB5e8bBPkVVMDfie3ZgKmaoO8r5Cc-owA,4448
@@ -91,7 +94,7 @@ gemcode/tools/tasks.py,sha256=4kDjMuoxgD3kJtM4fy2bOQl0ak6CljdA-nN1-tJG-dw,7668
 gemcode/tools/think.py,sha256=bch9bsz1bs24uia5l3utnNSkT84mIyU_EzMgi82e60Y,1624
 gemcode/tools/todo.py,sha256=dlGfcNce1WsJ5Y9txrDL3SoF6Hv2rms9r1cvGPs6qIs,5798
 gemcode/tools/web.py,sha256=I-6-GgCVKblc9zVFfilWLHoJZfri7_pC2MpT52ZZarE,5078
-gemcode/tools/web_search.py,sha256=YqIvwAoOXK3TMqrrMVeSrg5Nyt7Ou5nRljrYQ4784_4,8816
+gemcode/tools/web_search.py,sha256=UsO3W2FDRSJYtXQTT0jildzEQLt6P3XeR7KyUi-Dxqs,9163
 gemcode/tui/input_handler.py,sha256=Az8SbPaPHksIoibjph8gevMnfjagR1b-34_wpKbEhgQ,8259
 gemcode/tui/scrollback.py,sha256=1LcH39ZRiO2BFHWBFEcWZdWpe6-XFhUYWAePCyx91PI,33534
 gemcode/tui/spinner.py,sha256=dExs_enBPOWjkmRtodDzRw3E-MYh-xgtqDo54Q82sco,4892
@@ -101,9 +104,9 @@ gemcode/web/__init__.py,sha256=EysmUAWs6g-lmMk4VFljKfaHVrEgb_FiIzwQmBdORJc,40
 gemcode/web/sse_adapter.py,sha256=fXhKxn_bdJJUGqlmvkxLNSYL-ZiIZDaLHtQCF_BheRc,7108
 gemcode/web/terminal_repl.py,sha256=fQt895g0qcr6VBhXfv_5b_bsC5zHT5-MO0ysBdgi2Fg,3886
 gemcode/web/web_sse_compat.py,sha256=9A2s-GI7El7AotJqhO263FrLwppCXXkdydZ5EiOQbao,504
-gemcode-0.3.80.dist-info/licenses/LICENSE,sha256=TD4524qn-W8Z07GTDnag-9jJPFutFZNB0a1WbMHPC54,8388
-gemcode-0.3.80.dist-info/METADATA,sha256=E3OS-VQUnxZ0QMNe5fEWh5bQfhtT72E1XzwwTcM5q9s,41106
-gemcode-0.3.80.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-gemcode-0.3.80.dist-info/entry_points.txt,sha256=cZdLTLDiHbks7OSUCuxCh66dCWeQdpLR8BozoqfEjV4,45
-gemcode-0.3.80.dist-info/top_level.txt,sha256=UYrjULLBY2bcgK6KI6flomJWmsbDXu7n0rvW2SWFrbo,8
-gemcode-0.3.80.dist-info/RECORD,,
+gemcode-0.3.82.dist-info/licenses/LICENSE,sha256=TD4524qn-W8Z07GTDnag-9jJPFutFZNB0a1WbMHPC54,8388
+gemcode-0.3.82.dist-info/METADATA,sha256=GuFoQn-JSFIaaQA0cM64yDPmnvjh7SUYOPQ_kcUpgV8,41577
+gemcode-0.3.82.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gemcode-0.3.82.dist-info/entry_points.txt,sha256=cZdLTLDiHbks7OSUCuxCh66dCWeQdpLR8BozoqfEjV4,45
+gemcode-0.3.82.dist-info/top_level.txt,sha256=UYrjULLBY2bcgK6KI6flomJWmsbDXu7n0rvW2SWFrbo,8
+gemcode-0.3.82.dist-info/RECORD,,