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

gemcode/agent.py

@@ -27,11 +27,49 @@ from gemcode.limits import make_before_model_limits_callback, make_before_model_
 from gemcode.thinking import build_thinking_config
 from gemcode.tools import build_function_tools
 from gemcode.tool_prompt_manifest import build_tool_manifest
-from gemcode.skills import build_skill_manifest_text
+from gemcode.skills import (
+  build_skill_manifest_text,
+  expand_skill_text,
+  list_supporting_files,
+  load_skill,
+)
 from gemcode.output_styles import build_output_style_section
 from gemcode.rules import build_rules_section
 
 
+def _build_session_loaded_skills_section(cfg: GemCodeConfig) -> str:
+  """Full bodies for GemSkills the user loaded with /gemskill (session-scoped)."""
+  names = list(getattr(cfg, "session_loaded_skill_names", None) or [])
+  if not names:
+    return ""
+  sid = getattr(cfg, "session_skill_expand_session_id", None) or ""
+  chunks: list[str] = []
+  seen: set[str] = set()
+  for raw in names:
+    sk_name = (raw or "").strip().lower()
+    if not sk_name or sk_name in seen:
+      continue
+    seen.add(sk_name)
+    s = load_skill(cfg.project_root, sk_name)
+    if s is None:
+      continue
+    expanded = expand_skill_text(s, arguments="", session_id=sid)
+    files = list_supporting_files(s)
+    head = f"### GemSkill: `/{s.meta.name}` (loaded for this session)\n\n"
+    chunk = head + expanded
+    if files:
+      chunk += f"\n\nSupporting files: {', '.join(files)}"
+    chunks.append(chunk)
+  if not chunks:
+    return ""
+  return (
+      "## Loaded GemSkills (this session)\n"
+      "The user explicitly loaded these skills with `/gemskill`. Follow their workflows "
+      "when the task matches their purpose; do not force them on unrelated requests.\n\n"
+      + "\n\n---\n\n".join(chunks)
+  )
+
+
 def build_global_instruction() -> str:
   """Global instruction applied to the entire agent tree (via ADK plugin)."""
   return (
@@ -888,6 +926,9 @@ You have two tools to persist project insights across sessions (auto-memory styl
   skill_manifest = build_skill_manifest_text(cfg.project_root)
   if skill_manifest:
     base = f"{base}\n\n{skill_manifest}"
+  loaded_skills = _build_session_loaded_skills_section(cfg)
+  if loaded_skills:
+    base = f"{base}\n\n{loaded_skills}"
   extra = _load_gemini_md(cfg.project_root)
   if extra.strip():
     return f"{base}\n\n## Project instructions (GEMINI.md)\n{extra}"

gemcode/autotune.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 import subprocess
 import time
 from pathlib import Path
-from typing import Any
+from typing import Any, Iterable
 
+from gemcode.config import GemCodeConfig
 from gemcode.evals.harness import run_eval_suite, write_eval_record
 
 
@@ -47,11 +48,24 @@ def init_autotune(*, project_root: Path, tag: str) -> dict[str, Any]:
   return {"status": "created", "branch": branch}
 
 
-def run_autotune_eval(*, project_root: Path, include_llm: bool, model: str | None = None) -> dict[str, Any]:
+def run_autotune_eval(
+  *,
+  project_root: Path,
+  include_llm: bool,
+  model: str | None = None,
+  session_cfg: GemCodeConfig | None = None,
+  extra_tools: Iterable[Any] | None = None,
+) -> dict[str, Any]:
   """
   Run eval suite and persist last result to .gemcode/evals/last_eval.json.
   """
-  res = run_eval_suite(project_root=project_root, include_llm=include_llm, model=model)
+  res = run_eval_suite(
+    project_root=project_root,
+    include_llm=include_llm,
+    model=model,
+    session_cfg=session_cfg,
+    extra_tools=extra_tools,
+  )
   meta = {
     "ts": time.time(),
     "git_sha": _git_head_sha(project_root),

gemcode/cli.py

@@ -147,7 +147,12 @@ def _initialize_gemcode_project(cfg: GemCodeConfig) -> None:
 
 
 async def _run_prompt(
-  cfg: GemCodeConfig, prompt: str, session_id: str, *, use_mcp: bool
+  cfg: GemCodeConfig,
+  prompt: str,
+  session_id: str,
+  *,
+  use_mcp: bool,
+  attachment_paths: list[Path] | None = None,
 ) -> str:
   load_cli_environment()
   _maybe_prompt_trust(cfg)
@@ -164,6 +169,7 @@ async def _run_prompt(
         prompt=prompt,
         max_llm_calls=cfg.max_llm_calls,
         cfg=cfg,
+        attachment_paths=attachment_paths,
     )
     return _events_to_text(collected)
   finally:
@@ -245,6 +251,13 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
               file=sys.stderr,
           )
 
+    try:
+      from gemcode.repl_commands import install_readline_slash_completion
+
+      install_readline_slash_completion()
+    except Exception:
+      pass
+
     print(
       "GemCode CLI is running. Type your prompt and press Enter. (Ctrl+D to exit)",
       file=sys.stderr,
@@ -261,6 +274,7 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
       if prompt_text in (":q", "quit", "exit", "/exit"):
         break
 
+      cfg.session_skill_expand_session_id = session_id
       slash = await process_repl_slash(
           cfg=cfg,
           runner=runner,
@@ -273,12 +287,23 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
           break
         if slash.new_session_id is not None:
           session_id = slash.new_session_id
+          cfg.session_skill_expand_session_id = session_id
         if slash.skip_model_turn:
+          if slash.force_rebuild_runner:
+            try:
+              _c = runner.close()
+              if asyncio.iscoroutine(_c):
+                await _c
+            except Exception:
+              pass
+            runner = create_runner(cfg, extra_tools=None)
           continue
         prompt_text = slash.model_prompt or prompt_text
 
       apply_capability_routing(cfg, prompt_text, context="prompt")
       cfg.model = pick_effective_model(cfg, prompt_text)
+      _repl_attach = list(cfg.pending_attachment_paths)
+      cfg.pending_attachment_paths.clear()
       collected = await run_turn(
         runner,
         user_id="local",
@@ -286,6 +311,7 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
         prompt=prompt_text,
         max_llm_calls=cfg.max_llm_calls,
         cfg=cfg,
+        attachment_paths=_repl_attach if _repl_attach else None,
       )
       out = _events_to_text(collected)
       if out:
@@ -778,6 +804,17 @@ def main() -> None:
       metavar="N",
       help="Cap model↔tool iterations for this message (maps to ADK RunConfig.max_llm_calls)",
   )
+  parser.add_argument(
+      "--attach",
+      "--image",
+      dest="attachments",
+      action="append",
+      default=[],
+      metavar="PATH",
+      help="Attach file(s) for this message (repeatable): images, PDF, audio, video, text, etc. "
+      "(Gemini-supported MIME). Default max ~20 MiB each (GEMCODE_MAX_ATTACHMENT_BYTES). "
+      "REPL: /attach or /image <path>.",
+  )
   args = parser.parse_args()
 
   load_cli_environment()
@@ -829,7 +866,16 @@ def main() -> None:
   prompt_text = prompt.strip()
   apply_capability_routing(cfg, prompt_text, context="prompt")
   cfg.model = pick_effective_model(cfg, prompt_text)
-  out = asyncio.run(_run_prompt(cfg, prompt_text, session_id, use_mcp=args.mcp))
+  _cli_attach = list(args.attachments) if getattr(args, "attachments", None) else []
+  out = asyncio.run(
+      _run_prompt(
+          cfg,
+          prompt_text,
+          session_id,
+          use_mcp=args.mcp,
+          attachment_paths=_cli_attach if _cli_attach else None,
+      )
+  )
   if out:
     print(out)
   print(f"\n[gemcode] session_id={session_id}", file=sys.stderr)

gemcode/config.py

@@ -212,6 +212,15 @@ class GemCodeConfig:
     default_factory=lambda: os.environ.get("GEMCODE_OUTPUT_STYLE") or None
   )
 
+  # GemSkills explicitly loaded via /gemskill — full bodies injected into the
+  # system instruction until cleared or the session is reset/resumed.
+  session_loaded_skill_names: list[str] = field(default_factory=list)
+  # Substitutes ${GEMCODE_SESSION_ID} when expanding loaded skills for prompts.
+  session_skill_expand_session_id: str | None = None
+
+  # REPL/TUI: paths queued with /attach (or /image …), sent on the next message then cleared.
+  pending_attachment_paths: list[Path] = field(default_factory=list)
+
   # Modality toggles (tool injection + routing).
   enable_deep_research: bool = field(
     default_factory=lambda: _truthy_env("GEMCODE_ENABLE_DEEP_RESEARCH", default=False)

gemcode/evals/harness.py

@@ -3,14 +3,17 @@ from __future__ import annotations
 import asyncio
 import json
 import os
+import subprocess
+import sys
 import time
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any, Iterable
 
 from gemcode.config import GemCodeConfig, load_cli_environment
 from gemcode.invoke import run_turn
 from gemcode.session_runtime import create_runner
+from gemcode.tools_inspector import inspect_tools, smoke_tools
 
 
 @dataclass
@@ -21,11 +24,25 @@ class EvalResult:
   details: str = ""
 
 
-def _run_cmd(cmd: str, *, cwd: Path) -> tuple[int, str]:
-  import subprocess
-  p = subprocess.run(cmd, cwd=str(cwd), shell=True, capture_output=True, text=True)
-  out = (p.stdout or "") + (p.stderr or "")
-  return int(p.returncode), out
+def _discover_pytest_cwd(project_root: Path) -> tuple[Path, dict[str, str] | None] | None:
+  """
+  Return (cwd, env) for running pytest, or None if no tests tree found.
+
+  ``env`` is ``None`` to inherit the process environment; otherwise a full env dict.
+
+  Supports:
+  - Monorepo layout: <root>/gemcode/tests → cwd gemcode, PYTHONPATH=src
+  - Single-package layout: <root>/tests → cwd root
+  """
+  if (project_root / "tests").is_dir():
+    return project_root, None
+  gc = project_root / "gemcode"
+  if (gc / "tests").is_dir():
+    env = os.environ.copy()
+    prev = env.get("PYTHONPATH", "")
+    env["PYTHONPATH"] = "src" + (os.pathsep + prev if prev else "")
+    return gc, env
+  return None
 
 
 def _events_to_text(events: list) -> str:
@@ -72,28 +89,65 @@ def run_eval_suite(
   project_root: Path,
   include_llm: bool,
   model: str | None = None,
+  session_cfg: GemCodeConfig | None = None,
+  extra_tools: Iterable[Any] | None = None,
 ) -> dict[str, Any]:
   """
   Fixed evaluation harness (AutoResearch-style): deterministic gates + optional LLM golden prompts.
+
+  When ``session_cfg`` is set (e.g. from the REPL), tool smoke uses that config so flags match the live session.
   """
   t0 = time.time()
   load_cli_environment()
-  cfg = GemCodeConfig(project_root=project_root)
-  if model:
-    cfg.model = model
-    cfg.model_overridden = True
+  root = session_cfg.project_root if session_cfg is not None else project_root.resolve()
+  if session_cfg is not None:
+    cfg = replace(session_cfg, model=model, model_overridden=True) if model else session_cfg
+  else:
+    cfg = GemCodeConfig(project_root=project_root.resolve())
+    if model:
+      cfg.model = model
+      cfg.model_overridden = True
 
   results: list[EvalResult] = []
 
-  # Gate 1: tool schema smoke
-  rc, out = _run_cmd("PYTHONPATH=src python3 -m gemcode tools smoke", cwd=project_root / "gemcode")
-  results.append(EvalResult(name="tools_smoke", ok=(rc == 0), score=1.0 if rc == 0 else 0.0, details=out[-800:]))
-
-  # Gate 2: pytest if present
-  tests_dir = project_root / "gemcode" / "tests"
-  if tests_dir.is_dir():
-    rc2, out2 = _run_cmd("PYTHONPATH=src python3 -m pytest -q", cwd=project_root / "gemcode")
-    results.append(EvalResult(name="pytest", ok=(rc2 == 0), score=1.0 if rc2 == 0 else 0.0, details=out2[-1200:]))
+  # Gate 1: tool declaration smoke (in-process; matches REPL config when session_cfg is passed)
+  inspections = inspect_tools(cfg, extra_tools=extra_tools)
+  failures = smoke_tools(inspections)
+  ok_smoke = len(failures) == 0
+  smoke_details = ""
+  if failures:
+    smoke_details = "\n".join(
+      f"{f.name}: {f.declaration_error}" for f in failures[:40]
+    )
+  results.append(
+    EvalResult(
+      name="tools_smoke",
+      ok=ok_smoke,
+      score=1.0 if ok_smoke else 0.0,
+      details=smoke_details[-1200:],
+    )
+  )
+
+  # Gate 2: pytest if a tests/ tree exists under root or root/gemcode
+  pytest_target = _discover_pytest_cwd(root)
+  if pytest_target is not None:
+    cwd, env = pytest_target
+    p = subprocess.run(
+      [sys.executable, "-m", "pytest", "-q"],
+      cwd=str(cwd),
+      env=env,
+      capture_output=True,
+      text=True,
+    )
+    out2 = (p.stdout or "") + (p.stderr or "")
+    results.append(
+      EvalResult(
+        name="pytest",
+        ok=(p.returncode == 0),
+        score=1.0 if p.returncode == 0 else 0.0,
+        details=out2[-1200:],
+      )
+    )
 
   if include_llm:
     goldens = [

gemcode/ide_protocol.py

@@ -8,6 +8,14 @@ Design goals:
 - Human-readable JSONL (easy to debug)
 - Streaming (token deltas + progress)
 - Safe editing (engine proposes; IDE applies via WorkspaceEdit)
+
+Attachments on ``action: turn`` may include:
+
+- Textual: ``type: selection`` / ``file`` (appended into the prompt as fenced blocks).
+- Binary / multimodal: ``type: inline`` | ``binary`` | ``blob`` with ``data`` or ``base64``
+  (standard base64), plus optional ``filename`` / ``name`` and ``mimeType`` / ``mime_type``.
+  The engine writes bytes to a temp file and passes them to Gemini as inline parts
+  (same limits as CLI ``--attach``).
 """
 
 from __future__ import annotations

gemcode/ide_stdio.py

@@ -16,8 +16,13 @@ GemCode is responsible for:
 from __future__ import annotations
 
 import asyncio
+import base64
+import binascii
+import mimetypes
 import os
 import sys
+import tempfile
+from pathlib import Path
 from typing import Any
 
 from gemcode.config import GemCodeConfig, load_cli_environment
@@ -38,6 +43,107 @@ def _truthy(v: Any, default: bool = False) -> bool:
   return default
 
 
+def _max_ide_inline_bytes() -> int:
+  raw = os.environ.get("GEMCODE_MAX_ATTACHMENT_BYTES")
+  if raw:
+    try:
+      v = int(raw, 10)
+      if v > 0:
+        return v
+    except ValueError:
+      pass
+  return 20 * 1024 * 1024
+
+
+def _suffix_for_inline_attachment(name: str, mime: str) -> str:
+  p = Path(name or "")
+  if p.suffix and len(p.suffix) <= 12:
+    return p.suffix
+  m = (mime or "").strip().lower().split(";")[0].strip()
+  if m:
+    ext = mimetypes.guess_extension(m, strict=False)
+    if ext == ".jpe":
+      ext = ".jpeg"
+    if ext:
+      return ext
+  return ".bin"
+
+
+def prepare_inline_attachment_paths(
+  attachments: list[Any] | None,
+  *,
+  max_bytes: int | None = None,
+  max_count: int = 16,
+) -> tuple[list[Path], list[str]]:
+  """
+  Materialize IDE ``inline`` / ``binary`` / ``blob`` attachment dicts as temp files.
+
+  Expected keys (camelCase accepted): ``data`` or ``base64``, optional ``name`` /
+  ``filename``, ``mime_type`` / ``mimeType``.
+
+  Returns ``(paths, errors)``. Caller must unlink paths when done.
+  """
+  cap = max_bytes if max_bytes is not None else _max_ide_inline_bytes()
+  max_b64 = int(cap * 4 / 3) + 32
+  paths: list[Path] = []
+  errors: list[str] = []
+  if not attachments:
+    return paths, errors
+
+  for a in attachments:
+    if len(paths) >= max_count:
+      errors.append(f"inline attachments: max {max_count} files")
+      break
+    if not isinstance(a, dict):
+      continue
+    at = str(a.get("type") or "").strip().lower()
+    if at not in ("inline", "binary", "blob"):
+      continue
+    b64 = a.get("data") if isinstance(a.get("data"), str) else None
+    if b64 is None:
+      b64 = a.get("base64") if isinstance(a.get("base64"), str) else None
+    if not b64:
+      errors.append("inline attachment missing base64 data")
+      continue
+    if len(b64) > max_b64:
+      errors.append("inline attachment too large (base64)")
+      continue
+    try:
+      raw = base64.b64decode(b64, validate=True)
+    except (binascii.Error, ValueError) as e:
+      errors.append(f"inline attachment: invalid base64 ({e})")
+      continue
+    if len(raw) > cap:
+      errors.append(f"inline attachment exceeds max {cap} bytes")
+      continue
+    name = str(a.get("name") or a.get("filename") or "attachment")
+    mime = str(a.get("mime_type") or a.get("mimeType") or "")
+    suffix = _suffix_for_inline_attachment(name, mime)
+    try:
+      fd, fspath = tempfile.mkstemp(prefix="gemcode_ide_", suffix=suffix)
+      with os.fdopen(fd, "wb") as f:
+        f.write(raw)
+      paths.append(Path(fspath))
+    except OSError as e:
+      errors.append(f"inline attachment temp file failed: {e}")
+
+  return paths, errors
+
+
+def _textual_attachments_only(attachments: list[dict] | None) -> list[dict]:
+  if not attachments:
+    return []
+  out: list[dict] = []
+  for a in attachments:
+    if not isinstance(a, dict):
+      continue
+    at = str(a.get("type") or "").strip().lower()
+    if at in ("inline", "binary", "blob"):
+      continue
+    out.append(a)
+  return out
+
+
 def _build_prompt(prompt: str, attachments: list[dict] | None) -> str:
   # Keep it simple: attachments are appended as fenced blocks.
   if not attachments:
@@ -47,6 +153,8 @@ def _build_prompt(prompt: str, attachments: list[dict] | None) -> str:
     if not isinstance(a, dict):
       continue
     at = (a.get("type") or "").strip().lower()
+    if at in ("inline", "binary", "blob"):
+      continue
     if at == "selection":
       txt = a.get("text") or ""
       path = a.get("path") or ""
@@ -139,7 +247,6 @@ async def run_stdio_loop() -> int:
       if cfg is None:
         root = msg.get("project_root") or os.getcwd()
         model = msg.get("model") or os.environ.get("GEMCODE_MODEL") or ""
-        from pathlib import Path
         cfg = GemCodeConfig(project_root=Path(str(root)), model=str(model))
         # Attach emitter + proposal mode flags (used by tool wrappers).
         object.__setattr__(cfg, "_ide_emitter", emitter)
@@ -151,7 +258,25 @@ async def run_stdio_loop() -> int:
 
       prompt = str(msg.get("prompt") or "")
       attachments = msg.get("attachments") if isinstance(msg.get("attachments"), list) else None
-      full_prompt = _build_prompt(prompt, attachments)
+      att_dicts = [a for a in (attachments or []) if isinstance(a, dict)]
+      inline_paths, inline_err = prepare_inline_attachment_paths(attachments)
+      if inline_err:
+        for p in inline_paths:
+          try:
+            p.unlink()
+          except OSError:
+            pass
+        emitter.send(
+            make_response(
+                id=req_id,
+                ok=False,
+                error="; ".join(inline_err),
+                session=session_id,
+            )
+        )
+        continue
+
+      full_prompt = _build_prompt(prompt, _textual_attachments_only(att_dicts))
 
       # Per-turn allow flags (the engine still only proposes in IDE mode; the IDE applies).
       allow_write = _truthy(msg.get("allowWrite"), default=False)
@@ -161,14 +286,22 @@ async def run_stdio_loop() -> int:
 
       emitter.send(make_event(event="turn_start", id=req_id, session=session_id))
       try:
-        events = await run_turn(
-          runner,
-          user_id="local",
-          session_id=session_id,
-          prompt=full_prompt,
-          max_llm_calls=cfg.max_llm_calls,
-          cfg=cfg,
-        )
+        try:
+          events = await run_turn(
+              runner,
+              user_id="local",
+              session_id=session_id,
+              prompt=full_prompt,
+              max_llm_calls=cfg.max_llm_calls,
+              cfg=cfg,
+              attachment_paths=inline_paths if inline_paths else None,
+          )
+        finally:
+          for p in inline_paths:
+            try:
+              p.unlink()
+            except OSError:
+              pass
       except Exception as e:
         emitter.send(make_response(id=req_id, ok=False, error=f"{type(e).__name__}: {e}", session=session_id))
         continue

gemcode/invoke.py

@@ -9,8 +9,9 @@ from __future__ import annotations
 import asyncio
 import os
 import sys
-from typing import Any
+from pathlib import Path
 from threading import Lock
+from typing import Any, Sequence
 
 from google.adk.agents.run_config import RunConfig
 from google.adk.runners import Runner
@@ -66,6 +67,7 @@ async def run_turn(
     prompt: str,
     max_llm_calls: int | None = None,
     cfg: "GemCodeConfig | None" = None,
+    attachment_paths: Sequence[Path | str] | None = None,
 ) -> list:
   """Execute one user message; collect all Events (caller aggregates text)."""
   # Dynamic risk score: updated each user message; later refined by tool outcomes.
@@ -86,6 +88,8 @@ async def run_turn(
         risk += 0.2
       if re.search(r"\\b(test|pytest|ci|build|deploy|release)\\b", p, re.I):
         risk += 0.1
+      if attachment_paths:
+        risk = min(1.0, risk + 0.12)
       # Multi-file hints
       if p.count("/") >= 6 or p.count(".py") + p.count(".ts") + p.count(".tsx") >= 3:
         risk += 0.1
@@ -167,10 +171,22 @@ async def run_turn(
 
         state_delta = token_budget_invocation_reset()
 
-      # The first message is plain user text.
-      current_message = types.Content(
-        role="user", parts=[types.Part(text=prompt)]
-      )
+      # First message: optional inline files + text (Gemini multimodal).
+      if attachment_paths:
+        from gemcode.multimodal_input import build_user_content
+
+        root = cfg.project_root if cfg is not None else Path.cwd()
+        current_message, attach_warn = build_user_content(
+            prompt,
+            attachment_paths,
+            project_root=root,
+        )
+        for w in attach_warn:
+          print(f"[gemcode] {w}", file=sys.stderr)
+      else:
+        current_message = types.Content(
+            role="user", parts=[types.Part(text=prompt)]
+        )
 
       async def _await_runner_events(
         *, next_message: types.Content, do_reset: bool