gemcode 0.3.80__tar.gz → 0.3.82__tar.gz

{gemcode-0.3.80/src/gemcode.egg-info → gemcode-0.3.82}/PKG-INFO

@@ -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 → gemcode-0.3.82}/README.md

@@ -192,6 +192,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)). |
@@ -284,7 +285,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.
 
 ---
 
@@ -401,6 +402,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 → gemcode-0.3.82}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gemcode"
-version = "0.3.80"
+version = "0.3.82"
 description = "Local-first coding agent on Google Gemini + ADK"
 readme = "README.md"
 requires-python = ">=3.11"

{gemcode-0.3.80 → gemcode-0.3.82}/src/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-0.3.80 → gemcode-0.3.82}/src/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-0.3.80 → gemcode-0.3.82}/src/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-0.3.80 → gemcode-0.3.82}/src/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-0.3.82/src/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-0.3.80 → gemcode-0.3.82}/src/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-0.3.80 → gemcode-0.3.82}/src/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-0.3.80 → gemcode-0.3.82}/src/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-0.3.80 → gemcode-0.3.82}/src/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,