gemcode 0.3.95__tar.gz → 0.3.97__tar.gz

{gemcode-0.3.95/src/gemcode.egg-info → gemcode-0.3.97}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.95
+Version: 0.3.97
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License

{gemcode-0.3.95 → gemcode-0.3.97}/pyproject.toml

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

{gemcode-0.3.95 → gemcode-0.3.97}/src/gemcode/agent.py

@@ -934,6 +934,8 @@ 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.
+
+- **`summarise_session(focus="")`** — use this when the active session has become large or noisy and you want to preserve the important work before continuing. It writes a compact session summary, extracts durable facts into memory, and updates notes so a fresh follow-up session can stay lightweight.
 """
 
   # Inject capability-specific strategy sections only when those caps are on.

{gemcode-0.3.95 → gemcode-0.3.97}/src/gemcode/invoke.py

@@ -73,6 +73,10 @@ async def run_turn(
   # Dynamic risk score: updated each user message; later refined by tool outcomes.
   # This is intentionally heuristic but configurable via env knobs.
   if cfg is not None:
+    try:
+      object.__setattr__(cfg, "_active_session_id", session_id)
+    except Exception:
+      pass
     try:
       import re
       p = (prompt or "")[:20_000]

{gemcode-0.3.95 → gemcode-0.3.97}/src/gemcode/repl_commands.py

@@ -254,6 +254,7 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("skills",      "List GemSkills"),
     ("status",      "Model, capabilities, thinking, limits"),
     ("style",       "Output styles  ·  /style <name>|off"),
+    ("summarise",   "Summarise current session, persist key points, then reset  ·  /summarize same"),
     ("thinking",    "Thinking verbose/brief/off, budget, level"),
     ("tools",       "Tool inventory  ·  /tools smoke"),
     ("trust",       "Workspace trust  ·  /trust on|off"),
@@ -364,6 +365,8 @@ def slash_help_lines() -> list[str]:
       "  /clear                Alias for /session new",
       "  /compact              Force context compaction now (summarize history)",
       "  /compact <focus>      Compact with custom focus, e.g. /compact test output",
+      "  /summarise [focus]    Save a durable session summary, persist key facts, then start fresh",
+      "  /summarize [focus]    Alias of /summarise",
       "  /review               Parallel code review: security + style + correctness",
       "  /review <path>        Review a specific file or directory",
       "  /context              Show context pressure + last prompt tokens",

{gemcode-0.3.95 → gemcode-0.3.97}/src/gemcode/repl_slash.py

@@ -36,6 +36,7 @@ from gemcode.slash_commands import parse_slash_command
 from gemcode.skills import discover_skill_metas, expand_skill_text, list_supporting_files, load_skill
 from gemcode.output_styles import discover_output_styles, load_output_style
 from gemcode.rules import load_rules as _load_rules
+from gemcode.session_summariser import summarise_session
 from gemcode.trust import is_trusted_root, trust_json_path, trust_root
 
 
@@ -1556,6 +1557,52 @@ async def process_repl_slash(
         model_prompt=compact_prompt,
     )
 
+  if name in ("summarise", "summarize"):
+    focus = (sc.args or "").strip()
+    out("Summarising current session into durable memory…")
+    if focus:
+      out(f"Focus: {focus}")
+    out()
+    try:
+      model = (
+        getattr(cfg, "adk_compaction_summarizer_model", None)
+        or getattr(cfg, "model", "")
+        or "gemini-2.5-flash"
+      )
+      result = summarise_session(
+        cfg.project_root,
+        session_id=session_id,
+        model=model,
+        focus=focus,
+      )
+    except Exception as e:
+      out(f"[gemcode] session summarise failed: {e}")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    if result.get("error"):
+      out(f"[gemcode] {result['error']}")
+      out()
+      return ReplSlashResult(skip_model_turn=True)
+
+    out(f"Saved summary: {result.get('summary_path')}")
+    mem_saved = len(result.get("memory_facts_saved") or [])
+    user_saved = len(result.get("user_facts_saved") or [])
+    open_items = len(result.get("open_items") or [])
+    out(f"Curated memory saved: project={mem_saved}, user={user_saved}, open_items={open_items}")
+    if result.get("notes_status"):
+      out(f"Notes: {result.get('notes_status')}")
+    out("Starting a fresh session so the next turn stays lightweight.")
+    out()
+    _clear_session_loaded_skills(cfg)
+    cfg.pending_attachment_paths.clear()
+    new_id = str(uuid.uuid4())
+    return ReplSlashResult(
+        skip_model_turn=True,
+        new_session_id=new_id,
+        force_rebuild_runner=True,
+    )
+
   if name in ("exit", "quit"):
     return ReplSlashResult(exit_repl=True)
 

gemcode-0.3.97/src/gemcode/session_summariser.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from google.genai import Client
+from google.genai import types
+
+
+def _session_summary_dir(project_root: Path) -> Path:
+  return project_root / ".gemcode" / "session-summaries"
+
+
+def _session_summary_path(project_root: Path, session_id: str) -> Path:
+  safe_id = (session_id or "unknown").strip().replace("/", "_")
+  return _session_summary_dir(project_root) / f"{safe_id}.md"
+
+
+def _load_session_transcript(project_root: Path, session_id: str, *, max_events: int = 120) -> list[str]:
+  db = project_root / ".gemcode" / "sessions.sqlite"
+  if not db.is_file():
+    return []
+
+  con = sqlite3.connect(str(db), timeout=5)
+  cur = con.cursor()
+  cur.execute(
+    """
+    SELECT event_data
+    FROM events
+    WHERE session_id=?
+    ORDER BY timestamp ASC
+    LIMIT ?
+    """,
+    (session_id, int(max_events)),
+  )
+  rows = cur.fetchall()
+  con.close()
+
+  lines: list[str] = []
+  for (raw,) in rows:
+    try:
+      event = json.loads(raw)
+    except Exception:
+      continue
+    if not isinstance(event, dict):
+      continue
+
+    author = str(event.get("author") or "").strip().lower()
+    content = event.get("content") if isinstance(event.get("content"), dict) else {}
+    parts = content.get("parts") if isinstance(content.get("parts"), list) else []
+    texts: list[str] = []
+    for p in parts:
+      if isinstance(p, dict):
+        t = p.get("text")
+        if isinstance(t, str) and t.strip():
+          texts.append(t.strip())
+    if not texts:
+      continue
+
+    joined = "\n".join(texts)
+    if len(joined) > 4000:
+      joined = joined[:4000].rstrip() + "\n… [truncated]"
+
+    who = "User" if author == "user" else "GemCode"
+    lines.append(f"{who}: {joined}")
+  return lines
+
+
+def _build_prompt(transcript_lines: list[str], *, focus: str = "") -> str:
+  transcript = "\n\n".join(transcript_lines)
+  if len(transcript) > 120_000:
+    transcript = transcript[:120_000] + "\n\n… [older transcript truncated]"
+
+  focus_line = f"- Extra focus: {focus}\n" if focus.strip() else ""
+  return (
+    "You are a session summariser for GemCode.\n"
+    "Summarise the session into compact, reusable memory for future runs.\n"
+    "Return STRICT JSON only with this schema:\n"
+    "{\n"
+    '  "title": "short title",\n'
+    '  "summary_markdown": "markdown summary",\n'
+    '  "memory_facts": ["durable project facts"],\n'
+    '  "user_facts": ["durable user preferences"],\n'
+    '  "notes_markdown": "compact markdown note for .gemcode/notes.md",\n'
+    '  "open_items": ["open tasks or blockers"]\n'
+    "}\n"
+    "Rules:\n"
+    "- Keep summary_markdown concise but high-signal.\n"
+    "- Preserve decisions, file paths, commands, errors, fixes, and next steps.\n"
+    "- memory_facts/user_facts: 0 to 5 each, only durable non-sensitive facts.\n"
+    "- notes_markdown should be compact and useful for the next session.\n"
+    "- Never include secrets, API keys, passwords, or tokens.\n"
+    f"{focus_line}"
+    "\nTranscript:\n"
+    f"{transcript}\n"
+  )
+
+
+def _call_summary_model(*, model: str, prompt: str) -> dict[str, Any]:
+  api_key = os.environ.get("GOOGLE_API_KEY")
+  if not api_key:
+    raise RuntimeError("GOOGLE_API_KEY not set")
+
+  client = Client(api_key=api_key)
+  resp = client.models.generate_content(
+    model=model,
+    contents=[types.Content(role="user", parts=[types.Part(text=prompt)])],
+    config=types.GenerateContentConfig(temperature=0.2),
+  )
+
+  out_parts: list[str] = []
+  try:
+    if resp.candidates:
+      c0 = resp.candidates[0]
+      content = getattr(c0, "content", None)
+      for p in getattr(content, "parts", None) or []:
+        t = getattr(p, "text", None)
+        if isinstance(t, str) and t:
+          out_parts.append(t)
+  except Exception:
+    pass
+
+  text = "".join(out_parts).strip()
+  if not text:
+    raise RuntimeError("session summariser returned empty text")
+
+  try:
+    data = json.loads(text)
+  except Exception as e:
+    raise RuntimeError(f"session summariser returned invalid JSON: {e}") from e
+  if not isinstance(data, dict):
+    raise RuntimeError("session summariser returned non-object JSON")
+  return data
+
+
+def summarise_session(
+  project_root: Path,
+  *,
+  session_id: str,
+  model: str,
+  focus: str = "",
+) -> dict[str, Any]:
+  transcript_lines = _load_session_transcript(project_root, session_id)
+  if not transcript_lines:
+    return {"error": "session transcript is empty", "session_id": session_id}
+
+  prompt = _build_prompt(transcript_lines, focus=focus)
+  data = _call_summary_model(model=model, prompt=prompt)
+
+  title = str(data.get("title") or f"Session {session_id[:8]}").strip()[:120]
+  summary_markdown = str(data.get("summary_markdown") or "").strip()
+  notes_markdown = str(data.get("notes_markdown") or "").strip()
+  memory_facts = [str(x).strip() for x in (data.get("memory_facts") or []) if str(x).strip()][:5]
+  user_facts = [str(x).strip() for x in (data.get("user_facts") or []) if str(x).strip()][:5]
+  open_items = [str(x).strip() for x in (data.get("open_items") or []) if str(x).strip()][:10]
+
+  out_path = _session_summary_path(project_root, session_id)
+  out_path.parent.mkdir(parents=True, exist_ok=True)
+  ts = datetime.now().strftime("%Y-%m-%d %H:%M")
+
+  body_parts = [
+    f"# {title}",
+    "",
+    f"- session_id: `{session_id}`",
+    f"- generated_at: {ts}",
+  ]
+  if focus.strip():
+    body_parts.append(f"- focus: {focus}")
+  body_parts.extend(["", "## Summary", summary_markdown or "- (empty)"])
+
+  if open_items:
+    body_parts.extend(["", "## Open items", *[f"- {x}" for x in open_items]])
+  if memory_facts:
+    body_parts.extend(["", "## Durable project facts", *[f"- {x}" for x in memory_facts]])
+  if user_facts:
+    body_parts.extend(["", "## Durable user facts", *[f"- {x}" for x in user_facts]])
+
+  out_path.write_text("\n".join(body_parts).rstrip() + "\n", encoding="utf-8")
+
+  saved_memory: list[str] = []
+  saved_user: list[str] = []
+  try:
+    from gemcode.curated_memory import append_fact
+    for fact in memory_facts:
+      res = append_fact(project_root, target="memory", text=fact)
+      if "error" not in res:
+        saved_memory.append(fact)
+    for fact in user_facts:
+      res = append_fact(project_root, target="user", text=fact)
+      if "error" not in res:
+        saved_user.append(fact)
+  except Exception:
+    pass
+
+  note_status: str | None = None
+  if notes_markdown:
+    try:
+      from gemcode.tools.notes import build_notes_tools
+      append_note, _read_note = build_notes_tools(project_root)
+      note_text = (
+        f"## Session summary — {title}\n"
+        f"- Session: `{session_id}`\n"
+        f"- Summary file: `{out_path}`\n\n"
+        f"{notes_markdown}"
+      )
+      res = append_note(note_text)
+      if isinstance(res, dict):
+        note_status = str(res.get("status") or "")
+    except Exception:
+      note_status = None
+
+  return {
+    "ok": True,
+    "session_id": session_id,
+    "summary_path": str(out_path),
+    "title": title,
+    "summary_markdown": summary_markdown,
+    "memory_facts_saved": saved_memory,
+    "user_facts_saved": saved_user,
+    "notes_status": note_status,
+    "open_items": open_items,
+  }
+

{gemcode-0.3.95 → gemcode-0.3.97}/src/gemcode/tools/__init__.py

@@ -21,6 +21,7 @@ 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
 from gemcode.tools.veomem_tools import make_veomem_tools
+from gemcode.session_summariser import summarise_session
 
 
 def _get_load_memory_tool():
@@ -92,6 +93,30 @@ def build_function_tools(cfg: GemCodeConfig, *, include_subtask: bool = True) ->
   compress_memory_file = make_compress_memory_tool(cfg)
   list_skills, load_skill, skills_manifest = make_skill_tools(cfg)
 
+  def summarise_session_tool(focus: str = "") -> dict:
+    """
+    Summarise the current session into compact reusable memory.
+
+    Use this when the working session has grown large and you want GemCode to
+    extract key points into durable notes + curated memory before continuing.
+    """
+    session_id = str(getattr(cfg, "_active_session_id", "") or "").strip()
+    if not session_id:
+      return {"error": "no active session id is available"}
+    model = (
+      getattr(cfg, "adk_compaction_summarizer_model", None)
+      or getattr(cfg, "model", "")
+      or "gemini-2.5-flash"
+    )
+    return summarise_session(
+      cfg.project_root,
+      session_id=session_id,
+      model=model,
+      focus=focus,
+    )
+
+  summarise_session_tool.__name__ = "summarise_session"
+
   def checkpoints_list(limit: int = 20) -> dict:
     """List recent checkpoints created by mutating tools."""
     return {"checkpoints": _list_checkpoints(cfg.project_root, limit=limit)}
@@ -154,6 +179,7 @@ def build_function_tools(cfg: GemCodeConfig, *, include_subtask: bool = True) ->
     read_curated_memory,
     # Optional: compress memory files (markdown only; safe guards apply)
     compress_memory_file,
+    summarise_session_tool,
     # Optional: VeoMem recall tools (3-step search/timeline/fetch).
     # Enabled via GEMCODE_VEOMEM=1.
     # GemSkills (on-demand playbooks)

{gemcode-0.3.95 → gemcode-0.3.97/src/gemcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.95
+Version: 0.3.97
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License

{gemcode-0.3.95 → gemcode-0.3.97}/src/gemcode.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ src/gemcode/review_agent.py
 src/gemcode/rules.py
 src/gemcode/session_runtime.py
 src/gemcode/session_store.py
+src/gemcode/session_summariser.py
 src/gemcode/skills.py
 src/gemcode/slash_commands.py
 src/gemcode/thinking.py