gemcode 0.3.99__tar.gz → 0.3.101__tar.gz

{gemcode-0.3.99/src/gemcode.egg-info → gemcode-0.3.101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.99
+Version: 0.3.101
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -185,6 +185,9 @@ Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.24.0; extra == "dev"
 Provides-Extra: mcp
 Requires-Dist: mcp>=1.0.0; extra == "mcp"
+Provides-Extra: live
+Requires-Dist: numpy>=1.26.0; extra == "live"
+Requires-Dist: sounddevice>=0.5.0; extra == "live"
 Dynamic: license-file
 
 # GemCode User Manual

{gemcode-0.3.99 → gemcode-0.3.101}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gemcode"
-version = "0.3.99"
+version = "0.3.101"
 description = "Local-first coding agent on Google Gemini + ADK"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -42,6 +42,7 @@ Issues = "https://github.com/spiderdev27/GemCode/issues"
 [project.optional-dependencies]
 dev = ["pytest>=8.0.0", "pytest-asyncio>=0.24.0"]
 mcp = ["mcp>=1.0.0"]
+live = ["numpy>=1.26.0", "sounddevice>=0.5.0"]
 
 [project.scripts]
 gemcode = "gemcode.cli:main"

{gemcode-0.3.99 → gemcode-0.3.101}/src/gemcode/cli.py

@@ -705,6 +705,11 @@ def main() -> None:
       action="store_true",
       help="Enable embeddings-based semantic retrieval",
     )
+    audio_parser.add_argument(
+      "--no-playback",
+      action="store_true",
+      help="Do not play model audio to speakers (still prints text if any)",
+    )
 
     args = audio_parser.parse_args(sys.argv[2:])
     load_cli_environment()
@@ -725,15 +730,108 @@ def main() -> None:
     session_id = args.session or str(uuid.uuid4())
     from gemcode.live_audio_engine import run_live_audio
 
-    asyncio.run(
-      run_live_audio(
-        cfg,
-        session_id=session_id,
-        seconds=args.seconds,
-        input_rate=args.rate,
-        language_code=args.language,
+    # One-time explicit permission prompt (HITL) for mic/speaker use.
+    if hasattr(sys.stdin, "isatty") and sys.stdin.isatty():
+      try:
+        ask = os.environ.get("GEMCODE_LIVE_AUDIO_ASK", "1").lower() not in ("0", "false", "no", "off")
+        if ask and not args.yes:
+          print(
+            "\n[gemcode live-audio] Permissions\n"
+            "GemCode will access your microphone"
+            + (" and play audio to your speakers" if not args.no_playback else "")
+            + ".\n"
+            "Allow this now? [y/N] ",
+            file=sys.stderr,
+            end="",
+          )
+          ans = input().strip().lower()
+          if ans not in ("y", "yes"):
+            raise SystemExit("live-audio cancelled by user.")
+      except EOFError:
+        raise SystemExit("live-audio cancelled (no TTY input).")
+
+    try:
+      # Suppress non-actionable serialization warning seen in some SDK versions.
+      try:
+        import warnings as _warnings
+        _warnings.filterwarnings(
+          "ignore",
+          message=r".*Pydantic serializer warnings.*",
+          category=UserWarning,
+        )
+      except Exception:
+        pass
+
+      # Some SDK builds print a close-1000 traceback directly to stderr even when it's benign.
+      # Capture stderr during the run and suppress that specific known noise.
+      _hide = os.environ.get("GEMCODE_LIVE_AUDIO_HIDE_SDK_TRACE", "1").lower() not in (
+        "0",
+        "false",
+        "no",
+        "off",
       )
-    )
+      if _hide:
+        import io
+        from contextlib import redirect_stderr
+
+        buf = io.StringIO()
+        with redirect_stderr(buf):
+          asyncio.run(
+            run_live_audio(
+              cfg,
+              session_id=session_id,
+              seconds=args.seconds,
+              input_rate=args.rate,
+              language_code=args.language,
+              playback=(not args.no_playback),
+            )
+          )
+        captured = buf.getvalue()
+        if captured and "An unexpected error occurred in live flow: 1000" not in captured:
+          # Re-emit unexpected stderr.
+          print(captured, file=sys.stderr, end="")
+      else:
+        asyncio.run(
+          run_live_audio(
+            cfg,
+            session_id=session_id,
+            seconds=args.seconds,
+            input_rate=args.rate,
+            language_code=args.language,
+            playback=(not args.no_playback),
+          )
+        )
+    except Exception as e:
+      # Some SDK/ADK versions surface a normal websocket close (1000 OK) as an exception.
+      try:
+        from google.genai.errors import APIError  # type: ignore
+        if isinstance(e, APIError) and (getattr(e, "status_code", None) == 1000 or "1000" in str(e)):
+          print("\n[gemcode live-audio] Session ended.", file=sys.stderr)
+          raise SystemExit(0)
+      except Exception:
+        pass
+      # websockets can also surface a close directly.
+      if "ConnectionClosedOK" in repr(e) or "sent 1000 (OK)" in str(e):
+        print("\n[gemcode live-audio] Session ended.", file=sys.stderr)
+        raise SystemExit(0)
+      raise
+    except RuntimeError as e:
+      msg = str(e or "")
+      if "Mic capture requires `sounddevice` and `numpy`" in msg:
+        print(
+          "\n[gemcode live-audio] Microphone capture dependencies are missing.\n\n"
+          "Install:\n"
+          "  python3 -m pip install -U \"gemcode[live]\"\n\n"
+          "If that fails on your system, try:\n"
+          "  python3 -m pip install -U numpy sounddevice\n\n"
+          "Then re-run:\n"
+          f"  gemcode live-audio -C {cfg.project_root}\n\n"
+          "If the mic is still blocked, enable Microphone access for your terminal app in:\n"
+          "  System Settings → Privacy & Security → Microphone\n",
+          file=sys.stderr,
+        )
+        raise SystemExit(2)
+      raise
     print(f"\n[gemcode live-audio] session_id={session_id}", file=sys.stderr)
     return
 

gemcode-0.3.101/src/gemcode/live_audio_engine.py

@@ -0,0 +1,252 @@
+"""
+Live audio engine (Gemini Live API via ADK).
+
+This wires GemCode's existing outer session + callbacks into ADK's
+`Runner.run_live()` path for real-time audio input/output.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+import sys
+from dataclasses import dataclass
+from typing import Optional
+
+from google.adk.agents.live_request_queue import LiveRequestQueue
+from google.adk.agents.run_config import RunConfig
+from google.genai import types
+
+from gemcode.config import GemCodeConfig
+from gemcode.session_runtime import create_runner
+
+
+def _mime_type_for_rate(rate: int) -> str:
+  # ADK/examples commonly use this mime type.
+  return f"audio/pcm;rate={rate}"
+
+
+def _require_audio_deps():
+  """
+  Import audio deps (sounddevice + numpy). Raised error is caught by CLI to show friendly instructions.
+  """
+  try:
+    import sounddevice as sd  # type: ignore
+    import numpy as np  # type: ignore
+  except ImportError as e:
+    raise RuntimeError(
+      "Mic capture requires `sounddevice` and `numpy`. Install them to use `gemcode live-audio`."
+    ) from e
+  return sd, np
+
+
+def _parse_pcm_rate(mime_type: str | None) -> int | None:
+  mt = (mime_type or "").lower()
+  if "audio/pcm" not in mt:
+    return None
+  # e.g. audio/pcm;rate=24000
+  for part in mt.split(";"):
+    p = part.strip()
+    if p.startswith("rate="):
+      try:
+        return int(p.split("=", 1)[1])
+      except Exception:
+        return None
+  return None
+
+
+@dataclass
+class _AudioIO:
+  sd: object
+  np: object
+  input_rate: int
+  output_rate: int
+  playback: bool
+  _out_stream: object | None = None
+
+  def ensure_output(self) -> None:
+    if not self.playback:
+      return
+    if self._out_stream is not None:
+      return
+    # RawOutputStream writes bytes directly.
+    self._out_stream = self.sd.RawOutputStream(  # type: ignore[attr-defined]
+      samplerate=int(self.output_rate),
+      channels=1,
+      dtype="int16",
+    )
+    self._out_stream.start()
+
+  def write_audio(self, pcm_bytes: bytes) -> None:
+    if not self.playback:
+      return
+    self.ensure_output()
+    try:
+      self._out_stream.write(pcm_bytes)  # type: ignore[union-attr]
+    except Exception:
+      pass
+
+  def close(self) -> None:
+    try:
+      if self._out_stream is not None:
+        self._out_stream.stop()
+        self._out_stream.close()
+    except Exception:
+      pass
+    self._out_stream = None
+
+
+async def run_live_audio(
+  cfg: GemCodeConfig,
+  *,
+  session_id: str,
+  user_id: str = "local",
+  seconds: int = 10,
+  input_rate: int = 24_000,
+  language_code: Optional[str] = None,
+  playback: bool = True,
+) -> None:
+  """
+  Realtime microphone streaming to Gemini Live + realtime model audio playback.
+
+  Behavior:
+  - streams mic audio in small PCM chunks for up to `seconds`
+  - prints model-authored text parts (if any)
+  - plays model audio parts live when `playback=True`
+  """
+
+  sd, np = _require_audio_deps()
+
+  runner = create_runner(cfg)
+  live_queue = LiveRequestQueue()
+
+  speech_config = None
+  if language_code:
+    speech_config = types.SpeechConfig(language_code=language_code)
+
+  run_config = RunConfig(
+    # Prefer the enum value (avoids pydantic serializer warnings in some SDK versions).
+    response_modalities=[types.Modality.AUDIO],
+    speech_config=speech_config,
+    # Keep SDK defaults for STT/TTS transcription configs.
+  )
+
+  agen = runner.run_live(
+    user_id=user_id,
+    session_id=session_id,
+    live_request_queue=live_queue,
+    run_config=run_config,
+  )
+
+  printed_any = False
+  audio_io = _AudioIO(sd=sd, np=np, input_rate=input_rate, output_rate=input_rate, playback=playback)
+
+  async def _consume_events() -> None:
+    nonlocal printed_any
+    try:
+      async for event in agen:
+        if not event.content or not event.content.parts:
+          continue
+        for part in event.content.parts:
+          part_text = getattr(part, "text", None)
+          # We only print model-authored text to avoid echoing user input.
+          if part_text and getattr(event, "author", None) != "user":
+            sys.stdout.write(part_text)
+            sys.stdout.flush()
+            printed_any = True
+          # Play audio responses when present.
+          inline = getattr(part, "inline_data", None)
+          if inline is not None and getattr(event, "author", None) != "user":
+            try:
+              mime = getattr(inline, "mime_type", None)
+              data = getattr(inline, "data", None)
+              if isinstance(data, (bytes, bytearray)) and _parse_pcm_rate(mime) is not None:
+                r = _parse_pcm_rate(mime) or input_rate
+                audio_io.output_rate = int(r)
+                audio_io.write_audio(bytes(data))
+            except Exception:
+              pass
+    except Exception as e:
+      # Some SDK/ADK versions surface a normal websocket close (1000 OK) as an exception.
+      # Treat it as a clean end-of-session (no error).
+      try:
+        from google.genai.errors import APIError  # type: ignore
+        if isinstance(e, APIError) and (
+          getattr(e, "status_code", None) == 1000 or "1000" in str(e)
+        ):
+          return
+      except Exception:
+        pass
+      if "sent 1000 (OK)" in str(e) or "ConnectionClosedOK" in repr(e) or "1000 None" in str(e):
+        return
+      # Runner/live failures are expected to be surfaced as terminal errors
+      # in session state + audit logs; don't crash the CLI.
+      raise
+
+  consumer_task = asyncio.create_task(_consume_events())
+
+  # Mic capture → async queue (threaded producer).
+  pcm_q: asyncio.Queue[bytes] = asyncio.Queue(maxsize=50)
+  stop_at = time.time() + max(1, int(seconds))
+
+  def _mic_thread() -> None:
+    # ~20ms frames is a good latency/overhead balance.
+    blocksize = max(120, int(input_rate // 50))
+    try:
+      stream = sd.RawInputStream(  # type: ignore[attr-defined]
+        samplerate=int(input_rate),
+        channels=1,
+        dtype="int16",
+        blocksize=int(blocksize),
+      )
+    except Exception:
+      # Let the consumer surface this as empty audio.
+      return
+    with stream:
+      while time.time() < stop_at:
+        try:
+          data, _overflow = stream.read(blocksize)
+          if not data:
+            continue
+          # Push into asyncio queue safely.
+          try:
+            asyncio.get_running_loop().call_soon_threadsafe(pcm_q.put_nowait, bytes(data))
+          except Exception:
+            # If the loop isn't available, just drop.
+            pass
+        except Exception:
+          break
+
+  # Send "user started speaking" signal and start streaming.
+  live_queue.send_activity_start()
+  mic_task = asyncio.create_task(asyncio.to_thread(_mic_thread))
+
+  try:
+    while time.time() < stop_at:
+      try:
+        chunk = await asyncio.wait_for(pcm_q.get(), timeout=0.25)
+      except asyncio.TimeoutError:
+        continue
+      live_queue.send_realtime(
+        types.Blob(data=chunk, mime_type=_mime_type_for_rate(input_rate))
+      )
+  finally:
+    # End speech activity and close the queue regardless of failures.
+    live_queue.send_activity_end()
+    live_queue.close()
+    try:
+      await mic_task
+    except Exception:
+      pass
+
+  # Wait for event stream to drain.
+  try:
+    await consumer_task
+  finally:
+    audio_io.close()
+
+  if not printed_any:
+    print("\n[gemcode live-audio] No model text received (audio may have been silent).")
+
+  await runner.close()
+

{gemcode-0.3.99 → gemcode-0.3.101}/src/gemcode/repl_slash.py

@@ -618,9 +618,6 @@ async def process_repl_slash(
 
   # ── /add-dir (safe multi-root access) ──────────────────────────────────────
   if name in ("add-dir", "add_dir", "adddir"):
-    import os
-    from pathlib import Path
-
     args = (sc.args or "").strip()
     added: dict[str, Path] = getattr(cfg, "_added_dirs", None) or {}
     setattr(cfg, "_added_dirs", added)

{gemcode-0.3.99 → gemcode-0.3.101/src/gemcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.99
+Version: 0.3.101
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -185,6 +185,9 @@ Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.24.0; extra == "dev"
 Provides-Extra: mcp
 Requires-Dist: mcp>=1.0.0; extra == "mcp"
+Provides-Extra: live
+Requires-Dist: numpy>=1.26.0; extra == "live"
+Requires-Dist: sounddevice>=0.5.0; extra == "live"
 Dynamic: license-file
 
 # GemCode User Manual

{gemcode-0.3.99 → gemcode-0.3.101}/src/gemcode.egg-info/requires.txt

@@ -8,5 +8,9 @@ prompt_toolkit>=3.0.0
 pytest>=8.0.0
 pytest-asyncio>=0.24.0
 
+[live]
+numpy>=1.26.0
+sounddevice>=0.5.0
+
 [mcp]
 mcp>=1.0.0

gemcode-0.3.99/src/gemcode/live_audio_engine.py

@@ -1,124 +0,0 @@
-"""
-Live audio engine (Gemini Live API via ADK).
-
-This wires GemCode's existing outer session + callbacks into ADK's
-`Runner.run_live()` path for real-time audio input/output.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import sys
-from typing import Optional
-
-from google.adk.agents.live_request_queue import LiveRequestQueue
-from google.adk.agents.run_config import RunConfig
-from google.genai import types
-
-from gemcode.config import GemCodeConfig
-from gemcode.session_runtime import create_runner
-
-
-def _mime_type_for_rate(rate: int) -> str:
-  # ADK/examples commonly use this mime type.
-  return f"audio/pcm;rate={rate}"
-
-
-def _record_mic_pcm_blocking(*, rate: int, seconds: int) -> bytes:
-  try:
-    import sounddevice as sd
-    import numpy as np
-  except ImportError as e:
-    raise RuntimeError(
-      "Mic capture requires `sounddevice` and `numpy`. Install them to use `gemcode live-audio`."
-    ) from e
-
-  frames = int(rate * seconds)
-  # mono int16
-  audio = sd.rec(frames, samplerate=rate, channels=1, dtype="int16")
-  sd.wait()
-  pcm = np.asarray(audio).astype("int16", copy=False)
-  return pcm.tobytes()
-
-
-async def run_live_audio(
-  cfg: GemCodeConfig,
-  *,
-  session_id: str,
-  user_id: str = "local",
-  seconds: int = 10,
-  input_rate: int = 24_000,
-  language_code: Optional[str] = None,
-) -> None:
-  """
-  Record microphone audio for `seconds` and send it to Gemini Live.
-
-  MVP behavior:
-  - sends the entire recorded buffer as a single audio blob
-  - prints any model text parts it returns (typically transcriptions)
-  """
-
-  runner = create_runner(cfg)
-  live_queue = LiveRequestQueue()
-
-  speech_config = None
-  if language_code:
-    speech_config = types.SpeechConfig(language_code=language_code)
-
-  run_config = RunConfig(
-    response_modalities=["AUDIO"],
-    speech_config=speech_config,
-    # Keep SDK defaults for STT/TTS transcription configs.
-  )
-
-  agen = runner.run_live(
-    user_id=user_id,
-    session_id=session_id,
-    live_request_queue=live_queue,
-    run_config=run_config,
-  )
-
-  printed_any = False
-
-  async def _consume_events() -> None:
-    nonlocal printed_any
-    try:
-      async for event in agen:
-        if not event.content or not event.content.parts:
-          continue
-        for part in event.content.parts:
-          part_text = getattr(part, "text", None)
-          # We only print model-authored text to avoid echoing user input.
-          if part_text and getattr(event, "author", None) != "user":
-            sys.stdout.write(part_text)
-            sys.stdout.flush()
-            printed_any = True
-    except Exception:
-      # Runner/live failures are expected to be surfaced as terminal errors
-      # in session state + audit logs; don't crash the CLI.
-      raise
-
-  consumer_task = asyncio.create_task(_consume_events())
-
-  # Send "user started speaking" signal.
-  live_queue.send_activity_start()
-
-  pcm_bytes = await asyncio.to_thread(
-    _record_mic_pcm_blocking, rate=input_rate, seconds=seconds
-  )
-  live_queue.send_realtime(
-    types.Blob(data=pcm_bytes, mime_type=_mime_type_for_rate(input_rate))
-  )
-
-  # Send "user finished speaking" signal and close the queue.
-  live_queue.send_activity_end()
-  live_queue.close()
-
-  # Wait for event stream to drain.
-  await consumer_task
-
-  if not printed_any:
-    print("\n[gemcode live-audio] No model text received (audio may have been silent).")
-
-  await runner.close()
-