gemcode 0.3.78__tar.gz → 0.3.80__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.78
+Version: 0.3.80
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -330,6 +330,18 @@ Non-interactive environments (CI, pipes) must set `GOOGLE_API_KEY` explicitly an
 | `gemcode kaira` | Stdin-line → queued jobs scheduler (see [Kaira](#kaira-scheduler)). |
 | `gemcode ide --stdio` | **JSONL IDE protocol** on stdin/stdout for editor extensions (hidden entry; used by VS Code). |
 
+**Files with a prompt (multimodal):** attach one or more files Gemini can read (images, **PDF**, audio, video, plain text, etc.) for that message only:
+
+```bash
+gemcode -C . --attach ./screenshot.png "Why does this UI look wrong?"
+gemcode -C . --attach ./report.pdf "What are the main conclusions?"
+gemcode -C . --image a.png --image b.png "Compare these two layouts"
+```
+
+(`--image` is an alias of `--attach`.)
+
+In the **REPL / TUI**, queue files for the **next** message: `/attach path/to.pdf` (repeat for multiple), then type your question. Use `/attach list`, `/attach clear`. Aliases: `/image`, `/img`, `/file`.
+
 ---
 
 ## Main CLI flags
@@ -349,6 +361,7 @@ Non-interactive environments (CI, pipes) must set `GOOGLE_API_KEY` explicitly an
 | `--tool-combination-mode` | Gemini 3 **tool context circulation**: `deep_research\|always\|never\|auto`. |
 | `--mcp` | Load MCP toolsets from `.gemcode/mcp.json` (requires `pip install -e ".[mcp]"`). |
 | `--max-llm-calls` | Cap model↔tool iterations (`RunConfig.max_llm_calls`). |
+| `--attach PATH` | Attach file(s) for **this** CLI message only (repeat flag). Gemini-supported MIME (e.g. images, PDF, audio, video). Default max ~20 MiB each (`GEMCODE_MAX_ATTACHMENT_BYTES`). Alias: `--image`. |
 
 Kaira and `live-audio` accept overlapping options (project root, `--yes`, research/embeddings, etc.); run `gemcode kaira -h` / `gemcode live-audio -h` for full lists.
 
@@ -472,6 +485,7 @@ In interactive mode, lines starting with `/` are **slash commands** (see `repl_c
 
 | Command | Purpose |
 |---------|---------|
+| `/attach <path>`, `/attach list`, `/attach clear` | Queue file(s) for the **next** message (Gemini multimodal). Aliases: **`/image`**, **`/img`**, **`/file`**. |
 | `/trust`, `/trust on`, `/trust off` | Show, grant, or revoke **workspace trust** for the project root (stored in `~/.gemcode/trust.json`; required for file/shell/git tools). |
 | `/init` \| `/init force` | Analyze the repo and generate or overwrite `GEMINI.md`. |
 | `/cost` | Token usage and estimated cost for the session. |

{gemcode-0.3.78 → gemcode-0.3.80}/README.md

@@ -141,6 +141,18 @@ Non-interactive environments (CI, pipes) must set `GOOGLE_API_KEY` explicitly an
 | `gemcode kaira` | Stdin-line → queued jobs scheduler (see [Kaira](#kaira-scheduler)). |
 | `gemcode ide --stdio` | **JSONL IDE protocol** on stdin/stdout for editor extensions (hidden entry; used by VS Code). |
 
+**Files with a prompt (multimodal):** attach one or more files Gemini can read (images, **PDF**, audio, video, plain text, etc.) for that message only:
+
+```bash
+gemcode -C . --attach ./screenshot.png "Why does this UI look wrong?"
+gemcode -C . --attach ./report.pdf "What are the main conclusions?"
+gemcode -C . --image a.png --image b.png "Compare these two layouts"
+```
+
+(`--image` is an alias of `--attach`.)
+
+In the **REPL / TUI**, queue files for the **next** message: `/attach path/to.pdf` (repeat for multiple), then type your question. Use `/attach list`, `/attach clear`. Aliases: `/image`, `/img`, `/file`.
+
 ---
 
 ## Main CLI flags
@@ -160,6 +172,7 @@ Non-interactive environments (CI, pipes) must set `GOOGLE_API_KEY` explicitly an
 | `--tool-combination-mode` | Gemini 3 **tool context circulation**: `deep_research\|always\|never\|auto`. |
 | `--mcp` | Load MCP toolsets from `.gemcode/mcp.json` (requires `pip install -e ".[mcp]"`). |
 | `--max-llm-calls` | Cap model↔tool iterations (`RunConfig.max_llm_calls`). |
+| `--attach PATH` | Attach file(s) for **this** CLI message only (repeat flag). Gemini-supported MIME (e.g. images, PDF, audio, video). Default max ~20 MiB each (`GEMCODE_MAX_ATTACHMENT_BYTES`). Alias: `--image`. |
 
 Kaira and `live-audio` accept overlapping options (project root, `--yes`, research/embeddings, etc.); run `gemcode kaira -h` / `gemcode live-audio -h` for full lists.
 
@@ -283,6 +296,7 @@ In interactive mode, lines starting with `/` are **slash commands** (see `repl_c
 
 | Command | Purpose |
 |---------|---------|
+| `/attach <path>`, `/attach list`, `/attach clear` | Queue file(s) for the **next** message (Gemini multimodal). Aliases: **`/image`**, **`/img`**, **`/file`**. |
 | `/trust`, `/trust on`, `/trust off` | Show, grant, or revoke **workspace trust** for the project root (stored in `~/.gemcode/trust.json`; required for file/shell/git tools). |
 | `/init` \| `/init force` | Analyze the repo and generate or overwrite `GEMINI.md`. |
 | `/cost` | Token usage and estimated cost for the session. |

{gemcode-0.3.78 → gemcode-0.3.80}/pyproject.toml

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

{gemcode-0.3.78 → gemcode-0.3.80}/src/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:
@@ -296,6 +302,8 @@ async def _run_repl(cfg: GemCodeConfig, session_id: str, *, use_mcp: bool) -> No
 
       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",
@@ -303,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:
@@ -795,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()
@@ -846,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-0.3.78 → gemcode-0.3.80}/src/gemcode/config.py

@@ -218,6 +218,9 @@ class GemCodeConfig:
   # 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-0.3.78 → gemcode-0.3.80}/src/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-0.3.78 → gemcode-0.3.80}/src/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-0.3.78 → gemcode-0.3.80}/src/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

gemcode-0.3.80/src/gemcode/multimodal_input.py

@@ -0,0 +1,144 @@
+"""
+Build multimodal user Content (text + inline files) for Gemini.
+
+Paths may be absolute or relative to the current working directory, then project root.
+MIME types are inferred from the filename (``mimetypes``) and optionally from file
+headers (PDF, common images, some audio/video) so PDFs and other Gemini-supported
+types work—not only images.
+"""
+
+from __future__ import annotations
+
+import mimetypes
+import os
+from pathlib import Path
+from typing import Sequence
+
+from google.genai import types
+
+_MAX_ATTACHMENTS = 16
+
+
+def _max_attachment_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 resolve_attachment_path(p: Path | str, *, project_root: Path) -> Path:
+  path = Path(p).expanduser()
+  if path.is_absolute():
+    return path.resolve()
+  cwd_try = (Path.cwd() / path).resolve()
+  if cwd_try.is_file():
+    return cwd_try
+  root_try = (project_root / path).resolve()
+  if root_try.is_file():
+    return root_try
+  return (Path.cwd() / path).resolve()
+
+
+# Backward-compatible name from the images-only era.
+resolve_image_path = resolve_attachment_path
+
+
+def _sniff_mime(head: bytes) -> str | None:
+  if len(head) >= 5 and head[:5] == b"%PDF-":
+    return "application/pdf"
+  if len(head) >= 8 and head[:8] == b"\x89PNG\r\n\x1a\n":
+    return "image/png"
+  if len(head) >= 3 and head[:3] == b"\xff\xd8\xff":
+    return "image/jpeg"
+  if len(head) >= 6 and head[:6] in (b"GIF87a", b"GIF89a"):
+    return "image/gif"
+  if len(head) >= 12 and head[:4] == b"RIFF" and head[8:12] == b"WEBP":
+    return "image/webp"
+  if len(head) >= 2 and head[:2] == b"BM":
+    return "image/bmp"
+  if len(head) >= 12 and head[4:8] == b"ftyp":
+    return "video/mp4"
+  if len(head) >= 4 and head[:4] == b"\x1a\x45\xdf\xa3":
+    return "video/webm"
+  if len(head) >= 4 and head[:4] == b"OggS":
+    return "audio/ogg"
+  if len(head) >= 12 and head[:4] == b"RIFF" and head[8:12] == b"WAVE":
+    return "audio/wav"
+  if len(head) >= 4 and head[:4] == b"fLaC":
+    return "audio/flac"
+  if len(head) >= 3 and head[:3] in (b"ID3", b"\xff\xfb", b"\xff\xf3", b"\xff\xf2"):
+    return "audio/mpeg"
+  return None
+
+
+def _infer_mime(path: Path, data: bytes) -> tuple[str, list[str]]:
+  warnings: list[str] = []
+  head = data[:512]
+  guess, _ = mimetypes.guess_type(path.name, strict=False)
+  sniff = _sniff_mime(head)
+
+  if sniff and (not guess or guess == "application/octet-stream"):
+    return sniff, warnings
+  if guess and guess != "application/octet-stream":
+    return guess, warnings
+  if sniff:
+    return sniff, warnings
+  if guess:
+    return guess, warnings
+  warnings.append(
+      f"could not infer MIME type for {path}; using application/octet-stream "
+      "(Gemini may reject unsupported types)"
+  )
+  return "application/octet-stream", warnings
+
+
+def build_user_content(
+  prompt: str,
+  attachment_paths: Sequence[Path | str] | None,
+  *,
+  project_root: Path,
+) -> tuple[types.Content, list[str]]:
+  """
+  Build ``Content`` with inline file parts first, then the text part.
+
+  Returns ``(content, warnings)`` — warnings are non-fatal skips or hints (stderr them).
+  """
+  warnings: list[str] = []
+  parts: list[types.Part] = []
+  max_b = _max_attachment_bytes()
+  if attachment_paths:
+    for raw in list(attachment_paths)[:_MAX_ATTACHMENTS]:
+      p = resolve_attachment_path(raw, project_root=project_root)
+      if not p.is_file():
+        warnings.append(f"attachment not found: {raw}")
+        continue
+      try:
+        size = p.stat().st_size
+      except OSError as e:
+        warnings.append(f"attachment stat failed {p}: {e}")
+        continue
+      if size > max_b:
+        warnings.append(
+            f"attachment too large ({size} bytes, max {max_b}): {p} "
+            "(set GEMCODE_MAX_ATTACHMENT_BYTES or use a smaller file)"
+        )
+        continue
+      try:
+        data = p.read_bytes()
+      except OSError as e:
+        warnings.append(f"attachment read failed {p}: {e}")
+        continue
+      mime, mw = _infer_mime(p, data)
+      warnings.extend(mw)
+      parts.append(types.Part(inline_data=types.Blob(data=data, mime_type=mime)))
+
+  text = (prompt or "").strip() or (
+      "(User attached file(s) only — describe or analyze them.)" if parts else ""
+  )
+  parts.append(types.Part(text=text))
+  return types.Content(role="user", parts=parts), warnings

{gemcode-0.3.78 → gemcode-0.3.80}/src/gemcode/repl_commands.py

@@ -227,7 +227,11 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("exit",        "Leave the REPL  ·  /quit same"),
     ("help",        "Short help  ·  /? same"),
     ("hooks",       "Post-turn hook configuration"),
+    ("attach",      "Queue file(s) for next message (PDF, images, …)  ·  /image /file /img  ·  list  ·  clear"),
     ("init",        "Generate GEMINI.md project instructions"),
+    ("file",        "Alias of /attach"),
+    ("image",       "Alias of /attach (same queue)"),
+    ("img",         "Alias of /attach"),
     ("kaira",       "Background job scheduler — how to run gemcode kaira"),
     ("limits",      "Execution limits (calls, context, …)"),
     ("live-audio",  "How to run gemcode live-audio  ·  /liveaudio same"),
@@ -320,6 +324,8 @@ def slash_help_lines() -> list[str]:
       "  (CLI) gemcode login   Save or change API key (~/.gemcode/credentials.json)",
       "",
       "  Project setup:",
+      "  /attach <path>        Queue file(s) for the **next** message (PDF, images, …); /attach list|clear",
+      "                        Aliases: /image /img /file",
       "  /trust                Show workspace trust status (file/shell tools)",
       "  /trust on|off         Trust or revoke trust for this project root (~/.gemcode/trust.json)",
       "  /init                 Analyze project structure and generate GEMINI.md",