cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/project_stats.py

@@ -0,0 +1,209 @@
+"""
+CCT — project_stats.py: pure functions computing the real, live
+numbers the v0.7.2 roadmap's "Project & Workspace Dashboard" section
+asks for. No Textual here — ui/dashboard.py renders what this returns.
+
+Every function is capped/bounded and wrapped so a huge or unusual
+workspace (a node_modules-sized folder, a symlink loop, a permission-
+denied subdirectory) degrades to a partial/best-effort answer instead
+of hanging the UI thread — these run synchronously on a call from
+ui/dashboard.py's refresh, not in a worker, so a slow scan would
+directly freeze the app.
+
+Honest gaps, not fabricated: CPU% and a real "Workspace Health" score
+need either `psutil` or continuous sampling this app doesn't do
+anywhere else; rather than invent a number, cpu_percent() reports
+`None` (not "0%") when it can't measure something real, and
+callers show that as "unavailable" instead of a fake reading. Same
+for "Indexed Status" — this codebase has no separate file index (the
+Explorer's DirectoryTree reads the filesystem directly), so there's
+nothing genuine to report; ui/dashboard.py says so rather than
+displaying a made-up percentage.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+import os
+import time
+
+_IGNORE_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv",
+                ".mypy_cache", ".pytest_cache", "dist", "build", ".idea", ".vscode"}
+_LANG_BY_EXT = {
+    ".py": "Python", ".js": "JavaScript", ".jsx": "JavaScript", ".ts": "TypeScript",
+    ".tsx": "TypeScript", ".java": "Java", ".c": "C", ".h": "C", ".cpp": "C++",
+    ".hpp": "C++", ".cs": "C#", ".go": "Go", ".rs": "Rust", ".rb": "Ruby",
+    ".php": "PHP", ".swift": "Swift", ".kt": "Kotlin", ".html": "HTML",
+    ".css": "CSS", ".scss": "SCSS", ".json": "JSON", ".yaml": "YAML",
+    ".yml": "YAML", ".md": "Markdown", ".sh": "Shell", ".sql": "SQL",
+    ".r": "R", ".lua": "Lua", ".dart": "Dart",
+}
+MAX_SCAN_FILES = 20000  # bail out past this so a huge workspace can't hang the UI thread
+
+
+def scan_workspace(root):
+    """One bounded os.walk pass computing size/file-count/language
+    histogram/last-modified together, since walking the same tree three
+    separate times for three separate stats would be pure waste.
+    Returns a dict; every count is `None` if `root` isn't a real,
+    readable directory rather than a misleading 0."""
+    if not root or not os.path.isdir(root):
+        return {"total_size": None, "total_files": None, "languages": {},
+                "last_modified": None, "truncated": False}
+    total_size = 0
+    total_files = 0
+    languages = {}
+    last_modified = 0.0
+    truncated = False
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in _IGNORE_DIRS and not d.startswith(".")]
+        for name in filenames:
+            if total_files >= MAX_SCAN_FILES:
+                truncated = True
+                break
+            path = os.path.join(dirpath, name)
+            try:
+                st = os.stat(path)
+            except OSError:
+                continue
+            total_size += st.st_size
+            total_files += 1
+            last_modified = max(last_modified, st.st_mtime)
+            ext = os.path.splitext(name)[1].lower()
+            lang = _LANG_BY_EXT.get(ext)
+            if lang:
+                languages[lang] = languages.get(lang, 0) + 1
+        if truncated:
+            break
+    return {
+        "total_size": total_size, "total_files": total_files,
+        "languages": dict(sorted(languages.items(), key=lambda kv: -kv[1])[:5]),
+        "last_modified": last_modified or None, "truncated": truncated,
+    }
+
+
+def human_size(n):
+    if n is None:
+        return "\u2014"
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if n < 1024 or unit == "TB":
+            return f"{n:.0f} {unit}" if unit == "B" else f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} TB"
+
+
+def human_age(epoch):
+    if not epoch:
+        return "\u2014"
+    delta = time.time() - epoch
+    if delta < 60:
+        return "just now"
+    if delta < 3600:
+        return f"{int(delta // 60)}m ago"
+    if delta < 86400:
+        return f"{int(delta // 3600)}h ago"
+    return f"{int(delta // 86400)}d ago"
+
+
+def git_branch(root):
+    """Reads .git/HEAD directly rather than shelling out to `git` — no
+    subprocess dependency, and it's the one file that answers "what
+    branch" without needing a full git status walk. Returns None if
+    `root` isn't a git repo at all (distinct from "detached HEAD",
+    which returns the short commit hash instead of a branch name)."""
+    head_path = os.path.join(root or "", ".git", "HEAD")
+    try:
+        with open(head_path, "r", encoding="utf-8") as f:
+            content = f.read().strip()
+    except OSError:
+        return None
+    if content.startswith("ref:"):
+        return content.split("/")[-1]
+    return content[:8]  # detached HEAD: short commit hash
+
+
+_DEP_FILES = ("requirements.txt", "package.json", "pyproject.toml", "Pipfile")
+
+
+def dependencies(root):
+    """Best-effort dependency list from whichever manifest exists —
+    real names read from the actual file, not a fabricated guess.
+    package.json is parsed as JSON; the others are read as plain lines/
+    TOML-ish text with a conservative regex rather than pulling in a
+    TOML parser dependency for one dashboard field. Capped at 12 names
+    total so a monorepo's 300-package lockfile doesn't blow out the
+    dashboard layout."""
+    if not root:
+        return []
+    names = []
+    req = os.path.join(root, "requirements.txt")
+    if os.path.isfile(req):
+        try:
+            with open(req, "r", encoding="utf-8", errors="ignore") as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith("#"):
+                        import re
+                        m = re.match(r"^([A-Za-z0-9_.\-]+)", line)
+                        if m:
+                            names.append(m.group(1))
+        except OSError:
+            pass
+    pkg = os.path.join(root, "package.json")
+    if os.path.isfile(pkg):
+        try:
+            import json
+            with open(pkg, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            names.extend(list(data.get("dependencies", {}).keys()))
+            names.extend(list(data.get("devDependencies", {}).keys()))
+        except Exception:
+            pass
+    pyproject = os.path.join(root, "pyproject.toml")
+    if os.path.isfile(pyproject):
+        try:
+            import re
+            with open(pyproject, "r", encoding="utf-8", errors="ignore") as f:
+                text = f.read()
+            for m in re.finditer(r'^\s*"?([A-Za-z0-9_.\-]+)"?\s*=', text, re.MULTILINE):
+                if m.group(1).lower() not in ("name", "version", "description",
+                                               "authors", "readme", "requires-python"):
+                    names.append(m.group(1))
+        except OSError:
+            pass
+    seen, out = set(), []
+    for n in names:
+        if n.lower() not in seen:
+            seen.add(n.lower())
+            out.append(n)
+        if len(out) >= 12:
+            break
+    return out
+
+
+def memory_usage_mb():
+    """Real resident-memory reading for THIS process, via stdlib
+    `resource` on POSIX (no psutil dependency needed for this one
+    number). Returns None on platforms where `resource` doesn't exist
+    (Windows) rather than faking a number — see module docstring."""
+    try:
+        import resource
+        rss_kb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+        # macOS reports bytes, Linux reports KB — ru_maxrss's unit is
+        # platform-specific by design in the POSIX API itself.
+        import sys as _sys
+        if _sys.platform == "darwin":
+            return rss_kb / (1024 * 1024)
+        return rss_kb / 1024
+    except Exception:
+        return None
+
+
+def cpu_percent():
+    """No portable, dependency-free way to sample process CPU% without
+    either `psutil` or maintaining our own two-sample delta over time
+    (which nothing in this app currently does) — returns None rather
+    than a fabricated number. See module docstring."""
+    return None

calc_terminal/projects.py

@@ -0,0 +1,328 @@
+"""
+CCT Recent/Pinned/Favorite Projects (spec v0.7 Sidebar section +
+v0.7.7 Workspace Management Preview, sections 1/4/5).
+
+A small, dedicated JSON store — same pattern as workspace.py and
+config.py rather than growing either of those. Tracks folders opened
+via the IDE's "Open Folder" (ui/sidebar.py), so they can be reopened
+"without restarting" (spec's own phrase) and shown in the Welcome
+Dashboard's "Recent Projects" list.
+
+v0.7.7 additions (all backward-compatible — every pre-existing
+function keeps its exact old behavior):
+  - per-entry labels (rename), favorites, and per-workspace sidebar
+    collapse state;
+  - `workspaces()` — one combined list of every known workspace with
+    all metadata, for the multi-workspace explorer and the history
+    panel;
+  - `search()`, `remove()`, `clear_history()`, `last_opened()`.
+
+Deliberately NOT part of config.py's CCTConfig dataclass: that file's
+own docstring already says new settings should land there going
+forward, but a growing, unbounded list of recent paths is list-shaped
+state, not a scalar setting — mixing the two would make CCTConfig's
+schema noisy for the (many) callers that only care about the scalar
+settings.
+"""
+
+if __name__ == "__main__":
+    print("This is a library file and is not meant to be run directly.")
+    import sys
+    sys.exit(1)
+
+import json
+import os
+import time
+
+STORE_PATH = os.path.join(os.path.expanduser("~"), ".cct_recent_projects.json")
+# v0.7.8.1: Recent Workspaces is now the primary workspace-management
+# surface, so the history cap grows from 12 to 20.
+MAX_RECENT = 20
+
+
+def _load():
+    if not os.path.exists(STORE_PATH):
+        return {"recent": [], "pinned": []}
+    try:
+        with open(STORE_PATH, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        data.setdefault("recent", [])
+        data.setdefault("pinned", [])
+        return data
+    except Exception:
+        return {"recent": [], "pinned": []}
+
+
+def _save(data):
+    try:
+        with open(STORE_PATH, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+        return True
+    except Exception:
+        return False
+
+
+def _norm(path):
+    return os.path.abspath(os.path.expanduser(str(path)))
+
+
+def _get_entry(data, path):
+    for r in data["recent"]:
+        if r.get("path") == path:
+            return r
+    return None
+
+
+def record_opened(path):
+    """Call whenever a folder is opened as the IDE workspace root.
+    Moves `path` to the front of 'recent', de-duplicated, capped at
+    MAX_RECENT so this file doesn't grow forever. Existing metadata
+    (label/favorite/collapsed) on the entry is preserved across
+    reopens."""
+    path = _norm(path)
+    data = _load()
+    old = _get_entry(data, path)
+    meta = {}
+    if old is not None:
+        meta = {k: old[k] for k in ("label", "favorite", "collapsed") if old.get(k) is not None}
+    data["recent"] = [r for r in data["recent"] if r.get("path") != path]
+    entry = {"path": path, "opened_at": time.time()}
+    entry.update(meta)
+    data["recent"].insert(0, entry)
+    data["recent"] = data["recent"][:MAX_RECENT]
+    _save(data)
+    return data
+
+
+def toggle_pin(path):
+    path = _norm(path)
+    data = _load()
+    pinned = data["pinned"]
+    if path in pinned:
+        pinned.remove(path)
+        is_pinned = False
+    else:
+        pinned.insert(0, path)
+        is_pinned = True
+    data["pinned"] = pinned
+    _save(data)
+    return is_pinned
+
+
+def is_pinned(path):
+    path = _norm(path)
+    return path in _load()["pinned"]
+
+
+def remove_recent(path):
+    """Removes a single entry from 'recent' (matched by absolute path) —
+    the per-project delete option in the Explorer's Recent Projects
+    list. Never touches 'pinned' (unpinning is a separate, deliberate
+    action), and never touches any file or folder on disk. Returns
+    True/False the same way _save() does; safe to call for a path
+    that isn't in the list (no-op)."""
+    path = _norm(path)
+    data = _load()
+    data["recent"] = [r for r in data["recent"] if r.get("path") != path]
+    return _save(data)
+
+
+def clear_recent():
+    """Removes every entry from 'recent' (only the stored references in
+    STORE_PATH) — never touches 'pinned', and never touches any actual
+    file or folder on disk. Safe to call even with an empty list
+    already; returns True/False the same way _save() does."""
+    data = _load()
+    data["recent"] = []
+    return _save(data)
+
+
+def forget_protected():
+    """v0.7.9.4 fix: purge any recent/pinned entry that lives inside a
+    protected system root (C:\\Windows, C:\\Program Files, ...). An
+    earlier build could record e.g. C:\\WINDOWS\\System32 as a 'recent
+    project' when `cat` was launched from PowerShell's default cwd;
+    reopening such a directory is never useful (generated-file creation
+    fails with PermissionError there). Runs once at UI startup. Never
+    raises."""
+    try:
+        from . import workspace as _ws
+        data = _load()
+        before = (len(data["recent"]), len(data["pinned"]))
+        data["recent"] = [r for r in data["recent"]
+                          if not _ws.path_is_protected(r.get("path", ""))]
+        data["pinned"] = [p for p in data["pinned"]
+                          if not _ws.path_is_protected(
+                              p.get("path", "") if isinstance(p, dict)
+                              else str(p))]
+        if (len(data["recent"]), len(data["pinned"])) != before:
+            _save(data)
+    except Exception:
+        pass
+
+
+def recent():
+    return [r["path"] for r in _load()["recent"]]
+
+
+def pinned():
+    return list(_load()["pinned"])
+
+
+# ================================================== v0.7.7 workspace mgmt ==
+# (Workspace Management Preview, sections 4/5 — everything below is
+# additive; nothing above changed behavior.)
+
+
+def label_for(path):
+    """The workspace's display label: a user-set custom label, else the
+    folder's base name."""
+    path = _norm(path)
+    entry = _get_entry(_load(), path)
+    if entry and entry.get("label"):
+        return entry["label"]
+    return os.path.basename(path.rstrip(os.sep)) or path
+
+
+def rename(path, label):
+    """Sets a custom display label for a workspace. Empty/None clears
+    it back to the folder-name default. Returns the effective label."""
+    path = _norm(path)
+    label = (label or "").strip()
+    data = _load()
+    entry = _get_entry(data, path)
+    if entry is None:
+        data["recent"].insert(0, {"path": path, "opened_at": time.time(),
+                                  "label": label or None})
+    else:
+        if label:
+            entry["label"] = label
+        else:
+            entry.pop("label", None)
+    _save(data)
+    return label or os.path.basename(path.rstrip(os.sep)) or path
+
+
+def toggle_favorite(path):
+    """Stars/unstars a workspace. Returns the new favorite state."""
+    path = _norm(path)
+    data = _load()
+    entry = _get_entry(data, path)
+    if entry is None:
+        data["recent"].insert(0, {"path": path, "opened_at": time.time(),
+                                  "favorite": True})
+        _save(data)
+        return True
+    favorite = not bool(entry.get("favorite"))
+    entry["favorite"] = favorite
+    _save(data)
+    return favorite
+
+
+def is_favorite(path):
+    path = _norm(path)
+    entry = _get_entry(_load(), path)
+    return bool(entry and entry.get("favorite"))
+
+
+def favorites():
+    data = _load()
+    return [r["path"] for r in data["recent"] if r.get("favorite")]
+
+
+def set_collapsed(path, collapsed):
+    """Stores the explorer collapse state for one workspace (the
+    multi-workspace explorer collapses a workspace's tree without
+    removing it)."""
+    path = _norm(path)
+    data = _load()
+    entry = _get_entry(data, path)
+    if entry is None:
+        data["recent"].insert(0, {"path": path, "opened_at": time.time(),
+                                  "collapsed": bool(collapsed)})
+    else:
+        entry["collapsed"] = bool(collapsed)
+    _save(data)
+
+
+def is_collapsed(path):
+    path = _norm(path)
+    entry = _get_entry(_load(), path)
+    return bool(entry and entry.get("collapsed"))
+
+
+def workspaces():
+    """One combined list of every known workspace — recent + pinned
+    union, each entry {"path", "label", "pinned", "favorite",
+    "collapsed", "opened_at"}. Pinned entries missing from recent are
+    included with their base-name label. Ordered: pinned first, then
+    most-recently-opened."""
+    data = _load()
+    by_path = {}
+    for r in data["recent"]:
+        by_path[r["path"]] = {
+            "path": r["path"],
+            "label": r.get("label") or os.path.basename(r["path"].rstrip(os.sep)) or r["path"],
+            "favorite": bool(r.get("favorite")),
+            "collapsed": bool(r.get("collapsed")),
+            "opened_at": r.get("opened_at", 0),
+            "pinned": False,
+        }
+    for p in data["pinned"]:
+        p = _norm(p)
+        if p in by_path:
+            by_path[p]["pinned"] = True
+        else:
+            by_path[p] = {
+                "path": p,
+                "label": os.path.basename(p.rstrip(os.sep)) or p,
+                "favorite": False,
+                "collapsed": False,
+                "opened_at": 0,
+                "pinned": True,
+            }
+    ordered = sorted(by_path.values(),
+                     key=lambda w: (not w["pinned"], -w.get("opened_at", 0)))
+    return ordered
+
+
+def last_opened():
+    """The most recently opened workspace path, or None."""
+    r = _load()["recent"]
+    return r[0]["path"] if r else None
+
+
+def search(query):
+    """Case-insensitive search across every known workspace's path and
+    label. Empty query returns everything (workspaces())."""
+    q = (query or "").strip().lower()
+    if not q:
+        return workspaces()
+    return [w for w in workspaces()
+            if q in w["path"].lower() or q in w["label"].lower()]
+
+
+def remove(path):
+    """Full removal from the history: recent, pinned, and favorite
+    references (pinned list holds bare paths). Never touches files on
+    disk. Returns True if anything was removed."""
+    path = _norm(path)
+    data = _load()
+    before = (len(data["recent"]), len(data["pinned"]))
+    data["recent"] = [r for r in data["recent"] if r.get("path") != path]
+    data["pinned"] = [p for p in data["pinned"] if p != path]
+    changed = (len(data["recent"]), len(data["pinned"])) != before
+    _save(data)
+    return changed
+
+
+def clear_history():
+    """Removes every stored workspace reference (recent + pinned +
+    favorites) — only the JSON store, never files on disk. Returns
+    True when the store had anything to clear."""
+    data = _load()
+    had = bool(data["recent"] or data["pinned"])
+    data["recent"] = []
+    data["pinned"] = []
+    _save(data)
+    return had

calc_terminal/providers/adapters/__init__.py

@@ -0,0 +1,80 @@
+"""
+calc_terminal/providers/adapters/__init__.py
+===========================================
+Provider Adapter Registry and Factory for CAT.
+"""
+
+from typing import Dict, Type, Optional, Any
+
+from .base import BaseProviderAdapter
+from .openai_adapter import OpenAIAdapter
+from .anthropic_adapter import AnthropicAdapter
+from .gemini_adapter import GeminiAdapter
+from .chinese_adapters import (
+    DeepSeekAdapter,
+    QwenAdapter,
+    MoonshotAdapter,
+    ZhipuGLMAdapter,
+    MiniMaxAdapter,
+    TencentHunyuanAdapter,
+    ByteDanceSeedAdapter,
+    XiaomiMiMoAdapter,
+    BaiduErnieAdapter,
+)
+from .ollama_adapter import OllamaAdapter
+from .other_adapters import (
+    XAIAdapter,
+    MistralAdapter,
+    CohereAdapter,
+    GenericOpenAIAdapter,
+)
+
+_ADAPTER_REGISTRY: Dict[str, Type[BaseProviderAdapter]] = {
+    "openai": OpenAIAdapter,
+    "anthropic": AnthropicAdapter,
+    "gemini": GeminiAdapter,
+    "google": GeminiAdapter,
+    "deepseek": DeepSeekAdapter,
+    "alibaba": QwenAdapter,
+    "qwen": QwenAdapter,
+    "moonshot": MoonshotAdapter,
+    "kimi": MoonshotAdapter,
+    "zhipu": ZhipuGLMAdapter,
+    "glm": ZhipuGLMAdapter,
+    "minimax": MiniMaxAdapter,
+    "tencent": TencentHunyuanAdapter,
+    "hunyuan": TencentHunyuanAdapter,
+    "bytedance": ByteDanceSeedAdapter,
+    "seed": ByteDanceSeedAdapter,
+    "doubao": ByteDanceSeedAdapter,
+    "xiaomi": XiaomiMiMoAdapter,
+    "mimo": XiaomiMiMoAdapter,
+    "baidu": BaiduErnieAdapter,
+    "ernie": BaiduErnieAdapter,
+    "ollama": OllamaAdapter,
+    "xai": XAIAdapter,
+    "grok": XAIAdapter,
+    "mistral": MistralAdapter,
+    "cohere": CohereAdapter,
+}
+
+
+def register_adapter(provider_id: str, adapter_cls: Type[BaseProviderAdapter]):
+    """Allow registering external or custom provider adapters."""
+    _ADAPTER_REGISTRY[provider_id.lower().strip()] = adapter_cls
+
+
+def get_adapter(provider_id: str, config: Optional[Dict[str, Any]] = None) -> BaseProviderAdapter:
+    """Instantiate the appropriate adapter for the given provider."""
+    pid = (provider_id or "").lower().strip()
+    cls = _ADAPTER_REGISTRY.get(pid)
+    if cls is None:
+        adapter = GenericOpenAIAdapter(config)
+        adapter.provider_id = pid
+        adapter.display_name = pid.capitalize()
+        return adapter
+    return cls(config)
+
+
+def list_supported_adapters() -> Dict[str, Type[BaseProviderAdapter]]:
+    return dict(_ADAPTER_REGISTRY)