gemcode 0.3.82__tar.gz → 0.3.85__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.82
+Version: 0.3.85
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -574,10 +574,16 @@ The TUI (when `GEMCODE_TUI=1` and terminal supports it) provides **slash complet
 - **Discovery:** Only **metadata** (name + description) is preloaded into context for token efficiency. Full body loads **on demand** via `/skill <name>`, `/<name>`, or tools `load_skill` / `list_skills`.
 - **Built-in:** **`batch`** — parallel large-change workflow (map → units → `run_subtask` → verify). Exposed as `/batch <goal>`; not auto-invoked by the model (`disable_model_invocation`).
 
-- **`/create gemskill <name>`** — create a new skill directory.
+- **`/create gemskill <name>`** — create a new skill directory (scaffold).
+- **Interactive wizard (CLI)**: if you type something like “I want to make a new skill” in the REPL, GemCode will switch into a short **GemSkill wizard** (name/description/spec) and then generate the full skill folder for you.
 - **`/gemskill <name>`** — pin the full skill body into the system prompt for this session.
 - **`/append gemskill <name> <text>`** — one-shot turn for the model to revise that skill on disk.
 
+### Frontmatter notes (compatibility)
+GemCode supports common YAML frontmatter styles including multi-line scalars like:
+- `description: >` (folded)
+- `description: |` (literal)
+
 ---
 
 ## Curated memory

{gemcode-0.3.82 → gemcode-0.3.85}/README.md

@@ -385,10 +385,16 @@ The TUI (when `GEMCODE_TUI=1` and terminal supports it) provides **slash complet
 - **Discovery:** Only **metadata** (name + description) is preloaded into context for token efficiency. Full body loads **on demand** via `/skill <name>`, `/<name>`, or tools `load_skill` / `list_skills`.
 - **Built-in:** **`batch`** — parallel large-change workflow (map → units → `run_subtask` → verify). Exposed as `/batch <goal>`; not auto-invoked by the model (`disable_model_invocation`).
 
-- **`/create gemskill <name>`** — create a new skill directory.
+- **`/create gemskill <name>`** — create a new skill directory (scaffold).
+- **Interactive wizard (CLI)**: if you type something like “I want to make a new skill” in the REPL, GemCode will switch into a short **GemSkill wizard** (name/description/spec) and then generate the full skill folder for you.
 - **`/gemskill <name>`** — pin the full skill body into the system prompt for this session.
 - **`/append gemskill <name> <text>`** — one-shot turn for the model to revise that skill on disk.
 
+### Frontmatter notes (compatibility)
+GemCode supports common YAML frontmatter styles including multi-line scalars like:
+- `description: >` (folded)
+- `description: |` (literal)
+
 ---
 
 ## Curated memory

{gemcode-0.3.82 → gemcode-0.3.85}/pyproject.toml

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

{gemcode-0.3.82 → gemcode-0.3.85}/src/gemcode/agent.py

@@ -303,6 +303,20 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
   except Exception:
     curated_section = ""
 
+  # ── VeoMem recall (optional) ─────────────────────────────────────────────
+  veomem_section = ""
+  try:
+    t = getattr(cfg, "_veomem_wakeup_text", None)
+    if isinstance(t, str) and t.strip():
+      veomem_section = (
+        "\n\n## VeoMem recall (auto-captured, progressive)\n"
+        "This section is automatically generated from prior tool usage and summaries. "
+        "Treat it as helpful context; do not restate it verbatim to the user.\n"
+        f"{t.strip()}\n"
+      )
+  except Exception:
+    veomem_section = ""
+
   return f"""## Runtime facts (authoritative for this session)
 - **Today's date:** {today}
 - **Project root** — every filesystem tool path is relative to: `{root}`
@@ -316,7 +330,7 @@ def _build_runtime_facts(cfg: GemCodeConfig) -> str:
 {kaira_section}
 - **UI banner** phrases like "GemCode Pro" are terminal marketing, not a separate API tier.
 - **Env toggles** (`GEMCODE_ENABLE_COMPUTER_USE`, `GEMCODE_MODEL`, etc.) affect only the OS process that launched gemcode. Pasting `VAR=1` in chat does NOT reconfigure a running session—tell the user to export in their shell, use project `.env`, or restart the CLI.
-- **Working in subfolders** — call `list_directory(\"Desktop\")`, `glob_files(\"**/query.ts\")`, `read_file(\"testing/ai-edtech-app/src/app/page.tsx\")` directly. Never claim access is blocked unless a tool returned an explicit error.{git_section}{curated_section}"""
+- **Working in subfolders** — call `list_directory(\"Desktop\")`, `glob_files(\"**/query.ts\")`, `read_file(\"testing/ai-edtech-app/src/app/page.tsx\")` directly. Never claim access is blocked unless a tool returned an explicit error.{git_section}{curated_section}{veomem_section}"""
 
 
 def _build_memory_section(cfg: GemCodeConfig) -> str:

{gemcode-0.3.82 → gemcode-0.3.85}/src/gemcode/callbacks.py

@@ -525,6 +525,26 @@ def make_after_tool_callback(cfg: GemCodeConfig):
     except Exception:
       pass
 
+    # ── VeoMem (optional): auto-capture tool usage ────────────────────────
+    try:
+      from gemcode.veomem_bridge import record_tool_use
+      sid = None
+      try:
+        if tool_context is not None and getattr(tool_context, "session", None) is not None:
+          sid = getattr(tool_context.session, "id", None)
+      except Exception:
+        sid = None
+      record_tool_use(
+        cfg.project_root,
+        session_id=str(sid) if sid else None,
+        tool_name=name,
+        args=args or {},
+        result=tool_response if isinstance(tool_response, dict) else {},
+        paths=(st.get(_RISK_FILES_TOUCHED, []) or []) if isinstance(st, dict) else None,
+      )
+    except Exception:
+      pass
+
     if _maybe_tool_summary_enabled():
       summary: dict[str, Any] = {
         "phase": "tool_result",

{gemcode-0.3.82 → gemcode-0.3.85}/src/gemcode/cli.py

@@ -7,6 +7,7 @@ import asyncio
 import getpass
 import json
 import os
+import re
 import sys
 import uuid
 import warnings
@@ -262,6 +263,100 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
       "GemCode CLI is running. Type your prompt and press Enter. (Ctrl+D to exit)",
       file=sys.stderr,
     )
+
+    def _looks_like_new_skill_request(s: str) -> bool:
+      t = (s or "").strip().lower()
+      if not t or t.startswith("/"):
+        return False
+      # Natural language trigger: "make/create/build a new skill/gemskill"
+      return bool(
+        re.search(r"\b(new|create|make|build)\b", t)
+        and re.search(r"\b(gem\s*skill|gemskill|skill)\b", t)
+      )
+
+    def _prompt_nonempty(label: str, default: str | None = None) -> str:
+      while True:
+        try:
+          v = input(label).strip()
+        except EOFError:
+          return default or ""
+        if v:
+          return v
+        if default is not None:
+          return default
+
+    def _wizard_create_gemskill() -> str | None:
+      """
+      Interactive CLI wizard that collects a GemSkill spec, then returns a single
+      model prompt instructing the agent to generate the skill folder/files.
+      """
+      if not (hasattr(sys.stdin, "isatty") and sys.stdin.isatty()):
+        return None
+      print("\n── GemSkill wizard ──", file=sys.stderr)
+      print("We'll create a new skill under `.gemcode/skills/<name>/`.\n", file=sys.stderr)
+      name = _prompt_nonempty("skill name (kebab-case, e.g. api-review): ")
+      name = (name or "").strip().lower()
+      if not re.fullmatch(r"[a-z0-9][a-z0-9-]{0,63}", name):
+        print("Invalid name. Use lowercase letters/numbers/hyphens (max 64 chars).", file=sys.stderr)
+        return None
+      desc = _prompt_nonempty("one-line description: ")
+      when = _prompt_nonempty("when should it be used (1-2 sentences)? ")
+      inputs = _prompt_nonempty("inputs it should accept (bullets or short text): ", default="User request + $ARGUMENTS")
+      outputs = _prompt_nonempty("expected output format (short): ", default="Concise checklist + actionable steps")
+      tools_pref = _prompt_nonempty(
+        "tools: (a)uto, (r)ead-only, (w)eb-research-heavy? [a]: ",
+        default="a",
+      ).strip().lower()
+      use_web = tools_pref.startswith("w")
+      read_only = tools_pref.startswith("r")
+      examples = _prompt_nonempty("example command(s) user will type (optional): ", default="")
+
+      root = cfg.project_root.resolve()
+      skill_dir = root / ".gemcode" / "skills" / name
+      skill_md = skill_dir / "SKILL.md"
+
+      prompt_parts: list[str] = [
+        "You are creating a **GemCode GemSkill**. Generate a new skill folder and files.\n\n",
+        "## Target\n",
+        f"- Project root: {root}\n",
+        f"- Skill directory: {skill_dir}\n",
+        f"- Primary file: {skill_md}\n\n",
+        "## Requirements\n",
+        f"- Skill name: {name}\n",
+        f"- Description: {desc}\n",
+        f"- When to use: {when}\n",
+        f"- Inputs: {inputs}\n",
+        f"- Output expectations: {outputs}\n",
+      ]
+      if examples:
+        prompt_parts.append(f"- Example invocations: {examples}\n")
+      prompt_parts.extend(
+        [
+          "\n",
+          "- Write `SKILL.md` with YAML frontmatter using **multiline-friendly** fields when needed.\n",
+          "- Include: Purpose, When to use, When NOT to use (guardrails), Inputs, Output format, Workflow, Examples.\n",
+          "- Make it **token-efficient**: prefer short checklists and explicit decision gates.\n",
+          "- Avoid vague 'ALWAYS trigger' language; provide precise triggers.\n",
+          "- If you need templates/checklists, create supporting files in a `references/` subfolder and keep them small.\n",
+          "- Do not create CLAUDE.md/AGENTS.md or other vendor-specific files.\n\n",
+          "## Tooling / research policy\n",
+          (
+            "- You MAY use web research to find best practices, but only if it materially improves the skill.\n"
+            if use_web
+            else "- Avoid web research unless strictly necessary.\n"
+          ),
+          ("- Operate in read-only mode: do not write files.\n" if read_only else "- You are allowed to write the skill files.\n"),
+          "\n",
+          "## Execution steps\n",
+          "1. Create the skill directory if missing.\n",
+          "2. Write `SKILL.md` (and any supporting files).\n",
+          "3. Validate the YAML frontmatter parses and the skill is usable.\n",
+          f"4. Print a short confirmation: created files + how to invoke (e.g. `/skills list`, `/{name} ...`, `/gemskill {name}`).\n",
+        ]
+      )
+      prompt = "".join(prompt_parts)
+      return prompt
+
     while True:
       try:
         raw = input("> ")
@@ -274,6 +369,12 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
       if prompt_text in (":q", "quit", "exit", "/exit"):
         break
 
+      # Natural language shortcut: "I want to make a new skill" => wizard.
+      if _looks_like_new_skill_request(prompt_text):
+        wizard_prompt = _wizard_create_gemskill()
+        if wizard_prompt:
+          prompt_text = wizard_prompt
+
       cfg.session_skill_expand_session_id = session_id
       slash = await process_repl_slash(
           cfg=cfg,

{gemcode-0.3.82 → gemcode-0.3.85}/src/gemcode/config.py

@@ -232,7 +232,9 @@ class GemCodeConfig:
   # Deep research model id used when routing selects deep research.
   model_deep_research: str = field(
     default_factory=lambda: os.environ.get(
-      "GEMCODE_MODEL_DEEP_RESEARCH", "travel_explore"
+      # Leave empty by default so routing falls back to `cfg.model` unless the
+      # user explicitly configures a deep-research-capable model id.
+      "GEMCODE_MODEL_DEEP_RESEARCH", ""
     )
   )
 

{gemcode-0.3.82 → gemcode-0.3.85}/src/gemcode/ide_stdio.py

@@ -322,7 +322,13 @@ async def run_stdio_loop() -> int:
           continue
       out_text = "".join(txt_parts).strip()
       if out_text:
-        emitter.send(make_event(event="text", id=req_id, text=out_text))
+        # Pseudo-streaming: emit deltas so IDE chat can feel alive even though
+        # we only have the final assistant text today.
+        emitter.send(make_event(event="text_start", id=req_id))
+        chunk_size = 450
+        for i in range(0, len(out_text), chunk_size):
+          emitter.send(make_event(event="text_delta", id=req_id, text=out_text[i : i + chunk_size]))
+        emitter.send(make_event(event="text_end", id=req_id))
       emitter.send(make_response(id=req_id, ok=True, session=session_id))
 
   finally:

{gemcode-0.3.82 → gemcode-0.3.85}/src/gemcode/plugins/terminal_hooks_plugin.py

@@ -189,5 +189,36 @@ class GemCodeTerminalHooksPlugin(BasePlugin):
         {"phase": "post_turn_hook", "ok": False, "error": str(e)},
       )
 
+    # ── VeoMem (optional): store final assistant summary ───────────────────
+    try:
+      # Best-effort: extract last assistant text from session events.
+      txt = ""
+      try:
+        events = callback_context.session.events or []
+        for ev in reversed(events):
+          if getattr(ev, "author", None) == getattr(agent, "name", "gemcode"):
+            content = getattr(ev, "content", None)
+            parts = getattr(content, "parts", None) if content is not None else None
+            if parts:
+              out_parts = []
+              for p in parts:
+                t = getattr(p, "text", None)
+                if t:
+                  out_parts.append(t)
+              if out_parts:
+                txt = "".join(out_parts).strip()
+                break
+      except Exception:
+        txt = ""
+      if txt:
+        from gemcode.veomem_bridge import record_turn_summary
+        record_turn_summary(
+          self.cfg.project_root,
+          session_id=str(callback_context.session.id),
+          text=txt,
+        )
+    except Exception:
+      pass
+
     return None
 

{gemcode-0.3.82 → gemcode-0.3.85}/src/gemcode/repl_commands.py

@@ -337,6 +337,7 @@ def slash_help_lines() -> list[str]:
       "  /notes clear          Delete all notes",
       "  /notes edit           Open notes in $EDITOR",
       "  /create gemskill <name> [description]  Create a new GemSkill (SKILL.md scaffold)",
+      "                        Tip: you can also type “I want to make a new skill” and follow the wizard",
       "  /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",

{gemcode-0.3.82 → gemcode-0.3.85}/src/gemcode/repl_slash.py

@@ -8,8 +8,10 @@ Returns ``None`` when the line is not a slash command; otherwise a
 from __future__ import annotations
 
 import os
+import shlex
 import uuid
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Callable, Iterable
 
 from gemcode.config import GemCodeConfig
@@ -98,11 +100,26 @@ async def process_repl_slash(
       out("  /attach clear    Clear the queue")
       out("Aliases: /file, /image, /img — same queue.")
       out("Types: Gemini-supported MIME (e.g. images, PDF, audio, video, text). Default max ~20 MiB each.")
+      out("Inline prompt: /image <path> <prompt...>  (or use `--` before the prompt)")
       out("CLI:  gemcode -C . --attach ./doc.pdf \"Summarize this\"")
       out()
       return ReplSlashResult(skip_model_turn=True)
-    low_i = raw_i.lower()
-    if low_i == "list":
+
+    # Parse args as:
+    # - list|clear (no further args)
+    # - <path> [--] <optional prompt...>
+    #
+    # We support quoted paths and best-effort unquoted paths with spaces by
+    # scanning for the longest prefix that resolves to an existing file.
+    try:
+      tokens = shlex.split(raw_i, posix=True)
+    except ValueError:
+      tokens = raw_i.split()
+
+    if not tokens:
+      return ReplSlashResult(skip_model_turn=True)
+
+    if len(tokens) == 1 and tokens[0].strip().lower() == "list":
       pend = cfg.pending_attachment_paths
       if not pend:
         out("(no attachments queued)")
@@ -112,15 +129,43 @@ async def process_repl_slash(
           out(f"  {i}. {p}")
       out()
       return ReplSlashResult(skip_model_turn=True)
-    if low_i == "clear":
+    if len(tokens) == 1 and tokens[0].strip().lower() == "clear":
       cfg.pending_attachment_paths.clear()
       out("Attachment queue cleared.")
       out()
       return ReplSlashResult(skip_model_turn=True)
-    resolved = resolve_attachment_path(raw_i, project_root=cfg.project_root)
+
+    # Find the longest token prefix that resolves to a real file.
+    best_i: int | None = None
+    best_resolved: Path | None = None
+    for i in range(1, len(tokens) + 1):
+      cand = " ".join(tokens[:i]).strip()
+      if not cand:
+        continue
+      resolved_try = resolve_attachment_path(cand, project_root=cfg.project_root)
+      if resolved_try.is_file():
+        best_i = i
+        best_resolved = resolved_try
+
+    # Fallback: treat first token as the path (keeps old behavior).
+    if best_i is None or best_resolved is None:
+      path_raw = tokens[0]
+      resolved = resolve_attachment_path(path_raw, project_root=cfg.project_root)
+      remainder_tokens = tokens[1:]
+    else:
+      path_raw = " ".join(tokens[:best_i]).strip()
+      resolved = best_resolved
+      remainder_tokens = tokens[best_i:]
+
+    if remainder_tokens and remainder_tokens[0] == "--":
+      remainder_tokens = remainder_tokens[1:]
+    trailing_prompt = " ".join(remainder_tokens).strip()
+
     if not resolved.is_file():
-      out(f"Not a file: {raw_i}")
+      out(f"Not a file: {path_raw}")
       out("(Resolved relative to cwd, then project root.)")
+      if trailing_prompt:
+        out("Tip: quote paths with spaces, e.g. /image \"./My File.png\" analyze this")
       out()
       return ReplSlashResult(skip_model_turn=True)
     if len(cfg.pending_attachment_paths) >= 16:
@@ -128,6 +173,11 @@ async def process_repl_slash(
       out()
       return ReplSlashResult(skip_model_turn=True)
     cfg.pending_attachment_paths.append(resolved)
+    if trailing_prompt:
+      out(f"Queued: {resolved} (attaching now)")
+      out()
+      return ReplSlashResult(model_prompt=trailing_prompt)
+
     out(f"Queued: {resolved}")
     out(f"  ({len(cfg.pending_attachment_paths)} file(s) — send your next message to attach)")
     out()
@@ -160,14 +210,22 @@ async def process_repl_slash(
       out("Tip: /skills list")
       out()
       return ReplSlashResult(skip_model_turn=True)
-    expanded = expand_skill_text(s, arguments=sk_args, session_id=session_id)
+    # Token-efficient one-shot invocation: do NOT inline the full SKILL.md.
+    # Instead, point the model at the skill and require it to load/read it as needed.
     files = list_supporting_files(s)
-    prompt = (
-      f"Apply GemSkill `/{s.meta.name}`.\n\n"
-      f"## Skill instructions\n{expanded}\n\n"
-      + (f"## Skill supporting files\n{', '.join(files)}\n\n" if files else "")
-      + "Now carry out the user's request using the skill instructions."
-    )
+    prompt_parts = [
+      f"User invoked GemSkill `/{s.meta.name}`.\n\n",
+      f"## Arguments\n{sk_args or '(none)'}\n\n",
+      "## Instructions\n",
+      "1. Load the skill instructions using the `load_skill` tool (preferred) or by reading the SKILL.md file.\n",
+      "2. Only read supporting files if needed (keep it efficient).\n",
+      "3. Then carry out the user's request.\n\n",
+      f"## Skill file\n{s.skill_md}\n\n",
+    ]
+    if files:
+      prompt_parts.append(f"## Supporting files (optional)\n{', '.join(files)}\n\n")
+    prompt_parts.append("Now proceed.")
+    prompt = "".join(prompt_parts)
     return ReplSlashResult(model_prompt=prompt)
 
   # ── /gemskill (load full skill into session system prompt) ────────────────

{gemcode-0.3.82 → gemcode-0.3.85}/src/gemcode/session_runtime.py

@@ -368,6 +368,21 @@ def create_runner(cfg: GemCodeConfig, extra_tools: list | None = None) -> Runner
   except Exception:
     pass
 
+  # VeoMem wake-up snapshot (optional): load once per session and keep stable.
+  try:
+    import os
+    if os.environ.get("GEMCODE_VEOMEM", "").strip().lower() in ("1", "true", "yes", "on"):
+      from veomem.wakeup import build_wake_up_context  # type: ignore[import-not-found]
+      # Ensure store exists; build_wake_up_context can work even if empty.
+      from veomem.store import init_store  # type: ignore[import-not-found]
+
+      init_store(cfg.project_root)
+      snap2 = build_wake_up_context(cfg.project_root, max_chars=5000, limit=30)
+      txt = (snap2.get("text") if isinstance(snap2, dict) else "") or ""
+      object.__setattr__(cfg, "_veomem_wakeup_text", txt.strip() if isinstance(txt, str) else "")
+  except Exception:
+    pass
+
   # ── MCP toolsets from .gemcode/mcp.json ─────────────────────────────────
   # Supports stdio, http (Streamable HTTP), and sse connection types.
   try:

{gemcode-0.3.82 → gemcode-0.3.85}/src/gemcode/skills.py

@@ -135,11 +135,16 @@ def _parse_frontmatter(text: str) -> tuple[dict[str, str], str]:
 
   Supported:
   - key: value (single-line)
+  - key: >
+      multi-line
+    (folded; newlines become spaces)
+  - key: |
+      multi-line
+    (literal; newlines preserved)
   - key: [a, b]  (parsed as a string; caller can split if needed)
 
   Not supported:
   - nested objects
-  - multi-line scalars
   - full YAML spec
   """
   m = _FRONTMATTER_RE.match(text or "")
@@ -148,18 +153,58 @@ def _parse_frontmatter(text: str) -> tuple[dict[str, str], str]:
   raw = m.group(1)
   body = (text or "")[m.end() :]
   d: dict[str, str] = {}
-  for line in raw.splitlines():
+  lines = raw.splitlines()
+  i = 0
+  while i < len(lines):
+    line = lines[i]
     if not line.strip() or line.strip().startswith("#"):
+      i += 1
       continue
     if ":" not in line:
+      i += 1
       continue
     k, v = line.split(":", 1)
     k = k.strip()
-    v = v.strip()
+    v = v.rstrip()
+    v_stripped = v.strip()
+
+    # Multi-line scalar blocks: `key: >` or `key: |` followed by indented lines.
+    if v_stripped in (">", "|"):
+      style = v_stripped
+      block: list[str] = []
+      i += 1
+      while i < len(lines):
+        nxt = lines[i]
+        # YAML block scalars require indentation. We accept 2+ spaces or a tab.
+        if not (nxt.startswith("  ") or nxt.startswith("\t")):
+          break
+        block.append(nxt.lstrip(" \t"))
+        i += 1
+      if style == ">":
+        # folded: join non-empty lines with spaces; keep paragraph breaks as newline.
+        paras: list[str] = []
+        cur: list[str] = []
+        for ln in block:
+          if not ln.strip():
+            if cur:
+              paras.append(" ".join(x.strip() for x in cur if x.strip()))
+              cur = []
+            continue
+          cur.append(ln)
+        if cur:
+          paras.append(" ".join(x.strip() for x in cur if x.strip()))
+        d[k.lower()] = "\n".join(paras).strip()
+      else:
+        d[k.lower()] = "\n".join(block).rstrip()
+      continue
+
+    # Single-line scalar
+    v2 = v_stripped
     # Strip simple surrounding quotes
-    if len(v) >= 2 and ((v[0] == v[-1] == '"') or (v[0] == v[-1] == "'")):
-      v = v[1:-1]
-    d[k.lower()] = v
+    if len(v2) >= 2 and ((v2[0] == v2[-1] == '"') or (v2[0] == v2[-1] == "'")):
+      v2 = v2[1:-1]
+    d[k.lower()] = v2
+    i += 1
   return d, body
 
 

gemcode-0.3.85/src/gemcode/veomem_bridge.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+
+def _enabled() -> bool:
+  return os.environ.get("GEMCODE_VEOMEM", "").strip().lower() in ("1", "true", "yes", "on")
+
+
+def _try_import():
+  try:
+    from veomem.store import add_observation  # type: ignore[import-not-found]
+    return add_observation
+  except Exception:
+    return None
+
+
+def _summarize_tool_result(result: dict[str, Any]) -> str:
+  if not isinstance(result, dict):
+    return ""
+  if result.get("error"):
+    e = str(result.get("error"))
+    return f"error: {e[:800]}"
+  parts: list[str] = []
+  for k in ("exit_code", "path", "backup_path", "count", "chars_before", "chars_after"):
+    if k in result:
+      parts.append(f"{k}={result.get(k)!r}")
+  for k in ("stdout", "stderr"):
+    v = result.get(k)
+    if isinstance(v, str) and v.strip():
+      parts.append(f"{k}={v.strip()[:200]}{'…' if len(v) > 200 else ''}")
+  return " ".join(parts).strip()
+
+
+def record_tool_use(
+  project_root: Path,
+  *,
+  session_id: str | None,
+  tool_name: str,
+  args: dict[str, Any],
+  result: dict[str, Any],
+  paths: list[str] | None = None,
+) -> None:
+  if not _enabled():
+    return
+  add_observation = _try_import()
+  if add_observation is None:
+    return
+
+  touched = list(paths or [])
+  # Heuristic: record read_file path if present.
+  try:
+    p = (args or {}).get("path")
+    if isinstance(p, str) and p.strip():
+      touched.append(p.strip())
+  except Exception:
+    pass
+  touched = list(dict.fromkeys([p for p in touched if isinstance(p, str) and p.strip()]))[:50]
+
+  text = _summarize_tool_result(result)
+  if not text:
+    # Keep small but non-empty to be searchable.
+    text = json.dumps({"ok": not bool(result.get("error")), "tool": tool_name}, ensure_ascii=False)
+
+  try:
+    add_observation(
+      project_root,
+      kind="tool",
+      title=tool_name,
+      text=text,
+      session_id=session_id,
+      tool_name=tool_name,
+      paths=touched,
+      extra={"args_keys": sorted(list((args or {}).keys()))[:40]},
+    )
+  except Exception:
+    return
+
+
+def record_turn_summary(project_root: Path, *, session_id: str | None, text: str) -> None:
+  if not _enabled():
+    return
+  add_observation = _try_import()
+  if add_observation is None:
+    return
+  t = (text or "").strip()
+  if not t:
+    return
+  try:
+    add_observation(
+      project_root,
+      kind="summary",
+      title="turn_summary",
+      text=t[:8000],
+      session_id=session_id,
+      tool_name=None,
+      paths=[],
+      extra={},
+    )
+  except Exception:
+    return
+