code-context-control 2.28.0__py3-none-any.whl

cli/tools/shell.py

@@ -0,0 +1,193 @@
+"""c3_shell — structured shell execution with filter/log/timeout.
+
+Wraps subprocess.Popen with the Windows-safe pattern from
+services/edit_ledger.py::_git_combined (Popen + taskkill /F /T + stdin=DEVNULL).
+Auto-filters long stdout via handle_filter, auto-logs git mutations
+to the edit ledger, and accounts stdout tokens against session budget.
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from cli.tools.filter import handle_filter
+from core import count_tokens
+
+# Commands that mutate repo state — trigger edit-ledger refresh after success.
+_GIT_MUTATING = re.compile(
+    r"^\s*git\s+(commit|add|mv|rm|merge|rebase|cherry-pick|revert|reset|restore|checkout)\b"
+)
+# Hard deny — fork bombs, rm -rf on root/home. Escape hatch: native Bash.
+_BLOCKED = re.compile(
+    r"(\brm\s+-rf\s+(/|~|\$HOME)(\s|$)|:\(\)\s*\{\s*:\s*\|\s*:)"
+)
+# Soft warn — run but prepend a caveat to the response.
+# `(?<!\w)` / `(?!\w)` anchor against word chars, so `--force` (which starts
+# with a non-word `-`) still matches at word/space boundaries.
+_SOFT_WARN = re.compile(
+    r"(?<!\w)(rm\s+-rf|--force|--no-verify|reset\s+--hard|DROP\s+(TABLE|DATABASE)|TRUNCATE)(?!\w)",
+    re.IGNORECASE,
+)
+
+_DEFAULT_TIMEOUT = 60
+_MAX_TIMEOUT = 600
+_FILTER_THRESHOLD_LINES = 30
+
+
+def _popen_kwargs() -> dict:
+    kw: dict = {"stdin": subprocess.DEVNULL}
+    if sys.platform == "win32":
+        kw["creationflags"] = subprocess.CREATE_NO_WINDOW
+    return kw
+
+
+def _kill_tree(proc: subprocess.Popen) -> None:
+    if sys.platform == "win32":
+        subprocess.run(
+            ["taskkill", "/F", "/T", "/PID", str(proc.pid)],
+            capture_output=True,
+            creationflags=subprocess.CREATE_NO_WINDOW,
+        )
+    else:
+        try:
+            os.killpg(os.getpgid(proc.pid), 9)
+        except (ProcessLookupError, PermissionError, OSError):
+            proc.kill()
+
+
+def _run_sync(cmd: str, cwd: str, timeout: int) -> dict:
+    """Blocking subprocess run with hard kill on timeout. Returns structured dict."""
+    start = time.time()
+    proc = subprocess.Popen(
+        cmd, shell=True, cwd=cwd,
+        stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        text=True, errors="replace",
+        **_popen_kwargs(),
+    )
+    timed_out = False
+    try:
+        stdout, stderr = proc.communicate(timeout=timeout)
+    except subprocess.TimeoutExpired:
+        _kill_tree(proc)
+        try:
+            stdout, stderr = proc.communicate(timeout=2)
+        except Exception:
+            stdout, stderr = "", ""
+        timed_out = True
+
+    return {
+        "exit_code": -1 if timed_out else (proc.returncode or 0),
+        "stdout": stdout or "",
+        "stderr": stderr or "",
+        "duration_ms": round((time.time() - start) * 1000),
+        "timed_out": timed_out,
+    }
+
+
+def _maybe_refresh_ledger(cmd: str, result: dict, svc) -> list[str]:
+    """If git mutated state, capture affected files for the edit ledger."""
+    if result["exit_code"] != 0 or not _GIT_MUTATING.match(cmd):
+        return []
+    if not getattr(svc, "edit_ledger", None):
+        return []
+    try:
+        probe = _run_sync("git diff --name-only HEAD~1..HEAD", svc.project_path, timeout=5)
+        files = [f.strip() for f in probe["stdout"].splitlines() if f.strip()]
+        for f in files[:20]:
+            try:
+                svc.edit_ledger.log_edit(
+                    file=f,
+                    change_type="shell_git",
+                    summary=f"via c3_shell: {cmd[:80]}",
+                    include_git=True,
+                )
+            except Exception:
+                pass
+        return files
+    except Exception:
+        return []
+
+
+async def handle_shell(cmd: str, cwd: str, timeout: int, filter_output: bool,
+                       log: bool, svc, finalize) -> str:
+    if not cmd or not cmd.strip():
+        return "[c3_shell:error] empty command"
+    if _BLOCKED.search(cmd):
+        return (
+            "[c3_shell:error] blocked pattern — use native Bash with explicit "
+            "approval if this is truly intended"
+        )
+
+    timeout = max(1, min(int(timeout or _DEFAULT_TIMEOUT), _MAX_TIMEOUT))
+    work_cwd = cwd or svc.project_path
+    work_cwd = str(Path(work_cwd).resolve())
+
+    result = await asyncio.to_thread(_run_sync, cmd, work_cwd, timeout)
+
+    raw_stdout = result["stdout"]
+    filtered_note = ""
+    if filter_output and raw_stdout.count("\n") > _FILTER_THRESHOLD_LINES:
+        try:
+            filtered = await asyncio.to_thread(
+                handle_filter,
+                "", raw_stdout, "", 50, "smart", True,
+                svc, lambda *a, **kw: a[2],
+            )
+            result["stdout_raw_bytes"] = len(raw_stdout)
+            result["stdout"] = filtered
+            filtered_note = " [stdout filtered]"
+        except Exception:
+            pass
+
+    touched_files: list[str] = []
+    if log:
+        touched_files = _maybe_refresh_ledger(cmd, result, svc)
+        if getattr(svc, "activity_log", None):
+            try:
+                svc.activity_log.log("shell_exec", {
+                    "cmd": cmd[:200],
+                    "cwd": work_cwd,
+                    "exit_code": result["exit_code"],
+                    "duration_ms": result["duration_ms"],
+                    "timed_out": result["timed_out"],
+                    "touched_files": touched_files,
+                })
+            except Exception:
+                pass
+
+    warn = ""
+    if _SOFT_WARN.search(cmd):
+        warn = "[c3_shell:warn] destructive pattern detected — verify before re-running\n"
+
+    if result["timed_out"]:
+        status = "TIMEOUT"
+    elif result["exit_code"] == 0:
+        status = "OK"
+    else:
+        status = f"FAIL({result['exit_code']})"
+
+    body = (
+        f"{warn}"
+        f"[c3_shell:{status}] {result['duration_ms']}ms{filtered_note}\n"
+        f"$ {cmd}\n"
+        f"--- stdout ---\n{result['stdout'].rstrip()}\n"
+    )
+    if result["stderr"].strip():
+        body += f"--- stderr ---\n{result['stderr'].rstrip()}\n"
+    if touched_files:
+        body += f"--- ledger ---\nlogged {len(touched_files)} file(s)\n"
+
+    summary = f"shell {status} in {result['duration_ms']}ms"
+    resp_tokens = count_tokens(body) if body else 0
+    return finalize(
+        "c3_shell",
+        {"cmd": cmd[:120], "cwd": work_cwd},
+        body,
+        summary,
+        response_tokens=resp_tokens,
+    )

cli/tools/status.py

@@ -0,0 +1,306 @@
+"""c3_status — Budget, health, notifications, and ghost-file sweep (4+ views).
+
+Removed views (available via REST API/CLI):
+  'why', 'raw', 'optimize' — use `c3 status <view>` CLI command instead.
+  'tokens', 'memory' — merged into 'budget' (detailed=True) and 'health' respectively.
+"""
+
+import json
+import time
+from pathlib import Path
+
+from cli.hook_ghost_files import cleanup_ghost_files, scan_ghost_files
+from core import format_token_count
+
+
+def handle_status(view: str, detailed: bool, svc, finalize) -> str:
+    if view == "budget":
+        return _budget_view(svc, detailed, finalize)
+
+    if view == "health":
+        return _health_view(svc, finalize)
+
+    if view == "notifications":
+        return _notifications_view(svc, finalize)
+
+    if view == "sessions":
+        return _sessions_view(svc, finalize)
+
+    if view == "ghost_files":
+        return _ghost_files_view(svc, finalize)
+
+    # Graceful migration for removed views
+    removed = {
+        "tokens": "Merged into 'budget'. Use c3_status(view='budget', detailed=True).",
+        "memory": "Merged into 'health'. Use c3_status(view='health').",
+        "why": "Available via CLI: `c3 status why`",
+        "raw": "Available via CLI: `c3 status raw`",
+        "optimize": "Available via CLI: `c3 status optimize`",
+    }
+    if view in removed:
+        return finalize("c3_status", {"view": view},
+                        f"[status:moved] '{view}' view removed from MCP. {removed[view]}", "moved")
+
+    return f"[status:error] Unknown view: {view}. Available: budget, health, notifications, sessions, ghost_files"
+
+
+def _budget_view(svc, detailed, finalize):
+    snap = svc.session_mgr.get_budget_snapshot()
+    if "error" in snap:
+        return f"[ctx_status] {snap['error']}"
+
+    tokens = snap["response_tokens"]
+    threshold = snap["threshold"]
+    pct = round(tokens / threshold * 100) if threshold > 0 else 0
+
+    # Session age
+    age_str = ""
+    sess = svc.session_mgr.current_session
+    if sess:
+        started = sess.get("started", "")
+        try:
+            start_ts = time.mktime(time.strptime(started, "%Y-%m-%dT%H:%M:%S"))
+            age_str = f" age:{round((time.time() - start_ts) / 60)}min"
+        except Exception:
+            pass
+
+    content = snap.get("content_tokens", tokens)
+    infra = snap.get("infra_tokens", 0)
+    infra_note = f" (content:{content} infra:{infra})" if infra > 0 else ""
+    lines = [
+        f"[ctx_status] {tokens}tok/{snap['call_count']}calls "
+        f"avg:{snap['avg_tokens_per_call']} ({pct}% of {threshold}tok threshold){age_str}{infra_note}"
+    ]
+
+    # File memory coverage
+    try:
+        tracked = svc.file_memory.list_tracked()
+        idx_stats = svc.indexer.get_stats()
+        total_files = idx_stats.get("files_indexed", 0)
+        lines.append(f"[file_memory] {len(tracked)}/{total_files} files indexed")
+    except Exception as e:
+        lines.append(f"[file_memory] error: {e}")
+
+    # C3 adoption ratio
+    c3_calls = snap.get("c3_calls", 0)
+    native_calls = snap.get("native_calls", 0)
+    adoption = snap.get("c3_adoption_pct", 100)
+    if c3_calls + native_calls > 0:
+        lines.append(f"[c3_adoption] {adoption}% ({c3_calls}c3/{native_calls}native)")
+
+    # Per-tool token breakdown
+    by_tool = snap.get("by_tool", {})
+    if by_tool:
+        sorted_tools = sorted(by_tool.items(), key=lambda x: -x[1])
+        shown = sorted_tools[:6]
+        breakdown = " | ".join(f"{n}:{t}tok" for n, t in shown)
+        if len(sorted_tools) > 6:
+            breakdown += f" (+{len(sorted_tools) - 6} more)"
+        lines.append(f"[breakdown] {breakdown}")
+
+    if detailed:
+        stats = svc.indexer.get_stats()
+        lines.append(f"[index] files:{stats['files_indexed']} "
+                      f"tok:{format_token_count(stats['total_tokens_in_codebase'])}")
+
+    # Single warning when over threshold
+    if pct >= 100:
+        lines.append(f"[warn] Budget exceeded ({pct}%). Consider compact + /clear.")
+
+    return finalize("c3_status", {"view": "budget"}, "\n".join(lines), f"{pct}%")
+
+
+def _health_view(svc, finalize):
+    parts = []
+    ollama_ok = svc.ollama_client and svc.ollama_client.is_available()
+    models = svc.ollama_client.list_models() if ollama_ok else []
+    parts.append(f"[ollama] {'up (' + str(len(models)) + ' models)' if ollama_ok else 'unavailable'}")
+    stats = svc.indexer.get_stats()
+    parts.append(f"[index] {stats.get('files_indexed', 0)} files indexed")
+    sess = svc.session_mgr.current_session
+    if sess:
+        started = sess.get("started", "")
+        try:
+            start_ts = time.mktime(time.strptime(started, "%Y-%m-%dT%H:%M:%S"))
+            age_min = round((time.time() - start_ts) / 60)
+            parts.append(f"[session] {sess.get('id', '?')[:12]} age:{age_min}min "
+                          f"calls:{len(sess.get('tool_calls', []))}")
+        except Exception:
+            parts.append(f"[session] {sess.get('id', '?')[:12]}")
+    else:
+        parts.append("[session] none active")
+    pending = svc.notifications.get_unacknowledged(limit=5)  # actionable only
+    info_n = svc.notifications.get_suppressed_info_count()
+    info_tail = f" (+{info_n} info)" if info_n else ""
+    parts.append(f"[notifications] {len(pending)} actionable{info_tail}")
+    if svc.vector_store:
+        try:
+            vs = svc.vector_store.get_stats()
+            parts.append(f"[sltm] {vs.get('total_records', 0)} records "
+                          f"ollama={vs.get('ollama_available', False)}")
+        except Exception as e:
+            parts.append(f"[sltm] error: {e}")
+    else:
+        parts.append("[sltm] disabled")
+    all_facts = getattr(svc.memory, 'facts', []) or []
+    active_facts = [f for f in all_facts if f.get("lifecycle") != "archived"]
+    parts.append(f"[memory] {len(active_facts)} active / {len(all_facts)} total")
+    # Doc index (Local RAG Pipeline)
+    if hasattr(svc, "doc_index") and svc.doc_index:
+        di_stats = svc.doc_index.get_stats()
+        parts.append(f"[doc_index] {di_stats['total_chunks']} chunks "
+                      f"({di_stats['files_tracked']} files)")
+    else:
+        parts.append("[doc_index] disabled")
+    # Validation cache stats
+    vcache = getattr(svc, "validation_cache", None)
+    if vcache:
+        vs = vcache.summary()
+        err_note = f" ({vs['errors']} errors)" if vs["errors"] else ""
+        parts.append(f"[validation] {vs['cached_files']} cached, {vs['clean']} clean{err_note}")
+    else:
+        parts.append("[validation] disabled")
+    # Agent workflows
+    wf_cfg = (svc.hybrid_config or {}).get("agent_workflows", {})
+    wf_enabled = wf_cfg.get("enabled", True)
+    if wf_enabled:
+        parts.append(f"[workflows] enabled prefetch_max={wf_cfg.get('prefetch_max_files', 3)} "
+                      f"batch_max={wf_cfg.get('batch_validate_max_files', 10)} "
+                      f"compound_max={wf_cfg.get('compound_max_compress', 5)} "
+                      f"delegate={'on' if wf_cfg.get('delegate_in_workflows', True) else 'off'}")
+    else:
+        parts.append("[workflows] disabled")
+    # Background agents
+    agents = getattr(svc, "agents", None) or []
+    if agents:
+        enabled = sum(1 for a in agents if getattr(a, "enabled", False))
+        running = sum(
+            1 for a in agents
+            if getattr(a, "_thread", None) and a._thread.is_alive()
+        )
+        backed_off = [
+            a.name for a in agents
+            if getattr(a, "_idle_multiplier", 1) > 1
+        ]
+        line = f"[agents] {len(agents)} total, {enabled} enabled, {running} running"
+        if backed_off:
+            line += f" (idle-backoff: {', '.join(backed_off)})"
+        parts.append(line)
+    else:
+        parts.append("[agents] none")
+
+    # .c3/ directory disk usage
+    try:
+        c3_dir = Path(svc.project_path) / ".c3"
+        if c3_dir.exists():
+            total_bytes = sum(f.stat().st_size for f in c3_dir.rglob("*") if f.is_file())
+            if total_bytes < 1024 * 1024:
+                size_str = f"{total_bytes / 1024:.0f}KB"
+            else:
+                size_str = f"{total_bytes / (1024 * 1024):.1f}MB"
+            parts.append(f"[storage] .c3/ {size_str}")
+    except Exception as e:
+        parts.append(f"[storage] error: {e}")
+    # Ghost-file scan
+    try:
+        ghosts = scan_ghost_files(Path(svc.project_path))
+        if ghosts:
+            names = ", ".join(g["name"] for g in ghosts)
+            parts.append(f"[ghost_files] {len(ghosts)} found: {names}  "
+                         f"(run c3_status(view='ghost_files') to clean)")
+        else:
+            parts.append("[ghost_files] clean")
+    except Exception:
+        pass
+    return finalize("c3_status", {"view": "health"}, "\n".join(parts), "ok")
+
+
+def _sessions_view(svc, finalize):
+    """Show recent session token/cost stats from .c3/session_stats.jsonl."""
+    stats_path = Path(svc.project_path) / ".c3" / "session_stats.jsonl"
+    if not stats_path.exists():
+        return finalize(
+            "c3_status", {"view": "sessions"},
+            "[sessions] No data yet. Run c3 install-mcp to enable the Stop hook that captures stats.",
+            "empty",
+        )
+
+    entries = []
+    try:
+        with open(stats_path, encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    entries.append(json.loads(line))
+    except Exception as exc:
+        return f"[sessions:error] Could not read {stats_path}: {exc}"
+
+    if not entries:
+        return finalize("c3_status", {"view": "sessions"}, "[sessions] No sessions recorded yet.", "empty")
+
+    recent = entries[-20:]  # last 20 sessions
+    total_cost = sum(e.get("cost_usd") or 0 for e in recent)
+    total_in = sum(e.get("input_tokens") or 0 for e in recent)
+    total_out = sum(e.get("output_tokens") or 0 for e in recent)
+    total_cache_read = sum(e.get("cache_read_tokens") or 0 for e in recent)
+
+    lines = [f"# Session Stats (last {len(recent)} of {len(entries)} sessions)"]
+    lines.append(f"Total cost: ${total_cost:.4f}  |  In: {total_in:,}  Out: {total_out:,}  Cache-read: {total_cache_read:,}")
+    lines.append("")
+    lines.append(f"{'Date':<22} {'Cost':>8} {'In':>8} {'Out':>6} {'Cache-rd':>9} Stop")
+    lines.append("-" * 64)
+    for e in reversed(recent):
+        ts = (e.get("ts") or "")[:19].replace("T", " ")
+        cost = f"${e.get('cost_usd') or 0:.4f}"
+        inp = f"{e.get('input_tokens') or 0:,}"
+        out = f"{e.get('output_tokens') or 0:,}"
+        cr = f"{e.get('cache_read_tokens') or 0:,}"
+        reason = e.get("stop_reason") or ""
+        lines.append(f"{ts:<22} {cost:>8} {inp:>8} {out:>6} {cr:>9} {reason}")
+
+    resp = "\n".join(lines)
+    return finalize("c3_status", {"view": "sessions"}, resp, f"{len(recent)}sess")
+
+
+def _notifications_view(svc, finalize):
+    """Actionable warnings + critical only. Info events are archived,
+    not surfaced here — 'File maps updated' is not news worth paging on.
+    Use the web UI activity log or the REST API with severities='info'
+    to inspect them.
+    """
+    pending = svc.notifications.get_unacknowledged(limit=20)  # actionable by default
+    info_count = svc.notifications.get_suppressed_info_count()
+    if not pending:
+        tail = f" ({info_count} info events archived)" if info_count else ""
+        return f"No actionable notifications.{tail}"
+    lines = [f"# Actionable ({len(pending)})"]
+    for n in pending:
+        lines.append(f"[{n['severity']}] {n['agent']}: {n['title']}")
+    if info_count:
+        lines.append(f"\n(+{info_count} info events archived — not shown)")
+    return finalize("c3_status", {"view": "notifications"},
+                    "\n".join(lines), f"{len(pending)}p")
+
+
+def _ghost_files_view(svc, finalize):
+    """Scan project root for ghost files, report details, and auto-clean them."""
+    project_root = Path(svc.project_path)
+    ghosts = scan_ghost_files(project_root)
+
+    if not ghosts:
+        return finalize("c3_status", {"view": "ghost_files"},
+                        "[ghost_files] Project root is clean — no ghost files detected.", "clean")
+
+    lines = [f"# Ghost Files ({len(ghosts)} found)"]
+    for g in ghosts:
+        lines.append(f"  {g['name']} ({g['size']}B) — {g['reason']}")
+
+    # Auto-clean
+    deleted = cleanup_ghost_files(ghosts)
+    if deleted:
+        lines.append(f"\nDeleted {len(deleted)}: {', '.join(deleted)}")
+    else:
+        lines.append("\nCould not delete any ghost files (permission error?).")
+
+    resp = "\n".join(lines)
+    return finalize("c3_status", {"view": "ghost_files"}, resp, f"{len(deleted)} cleaned")