cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/core/checkpoint.py

@@ -0,0 +1,156 @@
+"""
+CAT Checkpoint & Rollback System per §14:
+- Automated snapshot of targeted files before agent modifications
+- Precise git-style unified diff computation
+- One-click safe rollback restoring previous workspace states
+"""
+
+from __future__ import annotations
+
+import difflib
+import json
+import os
+import shutil
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+
+@dataclass
+class FileSnapshot:
+    path: str
+    content: str
+    existed: bool
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "path": self.path,
+            "content": self.content,
+            "existed": self.existed,
+        }
+
+
+@dataclass
+class Checkpoint:
+    id: str
+    description: str
+    timestamp: float = field(default_factory=time.time)
+    snapshots: Dict[str, FileSnapshot] = field(default_factory=dict)
+    applied: bool = True
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "description": self.description,
+            "timestamp": self.timestamp,
+            "files": list(self.snapshots.keys()),
+            "applied": self.applied,
+        }
+
+
+class CheckpointManager:
+    """Manages workspace snapshots, diffs, and rollbacks."""
+
+    def __init__(self, storage_dir: Optional[str] = None):
+        self.storage_dir = storage_dir or os.path.join(os.path.expanduser("~"), ".cct_checkpoints")
+        self.checkpoints: Dict[str, Checkpoint] = {}
+        os.makedirs(self.storage_dir, exist_ok=True)
+
+    def create_checkpoint(self, description: str, files: List[str]) -> Checkpoint:
+        """Capture pre-modification state of specified files."""
+        cid = f"chk_{int(time.time())}_{uuid.uuid4().hex[:6]}"
+        snapshots = {}
+        for f in files:
+            norm = os.path.abspath(os.path.expanduser(f))
+            if os.path.exists(norm) and os.path.isfile(norm):
+                try:
+                    with open(norm, "r", encoding="utf-8", errors="ignore") as fp:
+                        content = fp.read()
+                    snapshots[norm] = FileSnapshot(path=norm, content=content, existed=True)
+                except Exception:
+                    pass
+            else:
+                snapshots[norm] = FileSnapshot(path=norm, content="", existed=False)
+
+        chk = Checkpoint(id=cid, description=description, snapshots=snapshots)
+        self.checkpoints[cid] = chk
+        self._persist_checkpoint(chk)
+        return chk
+
+    def get_diff(self, checkpoint_id: str) -> Dict[str, str]:
+        """Compute unified diff for each file in checkpoint against current workspace."""
+        chk = self.checkpoints.get(checkpoint_id)
+        if not chk:
+            return {}
+
+        diffs = {}
+        for path, snap in chk.snapshots.items():
+            orig_lines = snap.content.splitlines(keepends=True) if snap.existed else []
+            curr_lines = []
+            if os.path.exists(path) and os.path.isfile(path):
+                try:
+                    with open(path, "r", encoding="utf-8", errors="ignore") as f:
+                        curr_lines = f.readlines()
+                except Exception:
+                    pass
+
+            diff = list(
+                difflib.unified_diff(
+                    orig_lines,
+                    curr_lines,
+                    fromfile=f"a/{os.path.basename(path)} (checkpoint)",
+                    tofile=f"b/{os.path.basename(path)} (current)",
+                )
+            )
+            if diff:
+                diffs[path] = "".join(diff)
+
+        return diffs
+
+    def rollback(self, checkpoint_id: str) -> Tuple[bool, List[str]]:
+        """Restore workspace files to their exact checkpoint state."""
+        chk = self.checkpoints.get(checkpoint_id)
+        if not chk:
+            return False, ["Checkpoint not found"]
+
+        restored_files = []
+        errors = []
+        for path, snap in chk.snapshots.items():
+            try:
+                if snap.existed:
+                    os.makedirs(os.path.dirname(path), exist_ok=True)
+                    with open(path, "w", encoding="utf-8") as f:
+                        f.write(snap.content)
+                    restored_files.append(path)
+                else:
+                    # File was newly created after checkpoint, so remove it
+                    if os.path.exists(path):
+                        os.remove(path)
+                        restored_files.append(f"Deleted {path}")
+            except Exception as ex:
+                errors.append(f"Failed to restore {path}: {ex}")
+
+        chk.applied = False
+        return len(errors) == 0, restored_files
+
+    def list_checkpoints(self) -> List[Checkpoint]:
+        return sorted(self.checkpoints.values(), key=lambda c: c.timestamp, reverse=True)
+
+    def _persist_checkpoint(self, chk: Checkpoint):
+        try:
+            path = os.path.join(self.storage_dir, f"{chk.id}.json")
+            data = {
+                "id": chk.id,
+                "description": chk.description,
+                "timestamp": chk.timestamp,
+                "applied": chk.applied,
+                "snapshots": {p: s.to_dict() for p, s in chk.snapshots.items()},
+            }
+            with open(path, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2)
+        except Exception:
+            pass
+
+
+checkpoint_manager = CheckpointManager()

calc_terminal/core/input/__init__.py

@@ -0,0 +1,45 @@
+"""
+CAT Core Input Package — proxy re-export of calc_terminal.input.
+"""
+
+from ...input import (
+    DeviceType,
+    InputCapabilities,
+    detect_capabilities,
+    get_input_capabilities,
+    set_touch_mode,
+    toggle_touch_mode,
+    register_listener,
+    unregister_listener,
+    TouchTapRecognizer,
+    TouchScrollHandler,
+    TAP_MAX_DISTANCE,
+    TAP_MAX_DURATION,
+    DOUBLE_TAP_MAX_DELAY,
+    LONG_PRESS_DURATION,
+    TouchHitZone,
+    RESIZER_TOUCH_PADDING,
+    TouchFocusManager,
+    GestureBridge,
+)
+
+__all__ = [
+    "DeviceType",
+    "InputCapabilities",
+    "detect_capabilities",
+    "get_input_capabilities",
+    "set_touch_mode",
+    "toggle_touch_mode",
+    "register_listener",
+    "unregister_listener",
+    "TouchTapRecognizer",
+    "TouchScrollHandler",
+    "TAP_MAX_DISTANCE",
+    "TAP_MAX_DURATION",
+    "DOUBLE_TAP_MAX_DELAY",
+    "LONG_PRESS_DURATION",
+    "TouchHitZone",
+    "RESIZER_TOUCH_PADDING",
+    "TouchFocusManager",
+    "GestureBridge",
+]

calc_terminal/core/mode_registry.py

@@ -0,0 +1,300 @@
+"""
+CAT Custom Mode Engine & Registry per §2, §3, §55:
+- Preserves the default AI modes (Notebook, Research, Plan, Build, Debugger, Agent)
+- Supports user-created custom modes (e.g. BioLab, QuantumResearch, MLTrainer)
+- Modes request capabilities from Capability Bus, never duplicating tool logic.
+- Modes are installable, removable, editable, exportable, importable, validated, and permission-controlled.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from dataclasses import dataclass, field, asdict
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+
+CUSTOM_MODES_PATH = os.path.join(os.path.expanduser("~"), ".cct_custom_modes.json")
+
+# Default immutable modes per §2
+DEFAULT_MODE_KEYS = ("notebook", "research", "plan", "build", "debugger", "agent")
+
+
+@dataclass
+class ModeBehavior:
+    planning: str = "standard"  # standard, high, adaptive
+    verification: str = "standard"  # standard, strict, relaxed
+    citations: str = "optional"  # required, optional, none
+    experiment_tracking: bool = False
+    coding: str = "standard"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class ModeSpec:
+    name: str
+    description: str = ""
+    inherits: List[str] = field(default_factory=lambda: ["notebook"])
+    capabilities: List[str] = field(default_factory=list)
+    behavior: ModeBehavior = field(default_factory=ModeBehavior)
+    permissions: List[str] = field(default_factory=list)
+    preferred_models: List[str] = field(default_factory=list)
+    backup_models: List[str] = field(default_factory=list)
+    accent_hex: str = "#38bdf8"
+    icon: str = "●"
+    system_prompt: str = ""
+    enabled: bool = True
+    custom: bool = True
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "inherits": self.inherits,
+            "capabilities": self.capabilities,
+            "behavior": self.behavior.to_dict() if isinstance(self.behavior, ModeBehavior) else self.behavior,
+            "permissions": self.permissions,
+            "preferred_models": self.preferred_models,
+            "backup_models": self.backup_models,
+            "accent_hex": self.accent_hex,
+            "icon": self.icon,
+            "system_prompt": self.system_prompt,
+            "enabled": self.enabled,
+            "custom": self.custom,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> ModeSpec:
+        beh_data = data.get("behavior", {})
+        if isinstance(beh_data, dict):
+            behavior = ModeBehavior(
+                planning=beh_data.get("planning", "standard"),
+                verification=beh_data.get("verification", "standard"),
+                citations=beh_data.get("citations", "optional"),
+                experiment_tracking=bool(beh_data.get("experiment_tracking", False)),
+                coding=beh_data.get("coding", "standard"),
+            )
+        else:
+            behavior = ModeBehavior()
+
+        return cls(
+            name=data["name"],
+            description=data.get("description", ""),
+            inherits=data.get("inherits", ["notebook"]),
+            capabilities=data.get("capabilities", []),
+            behavior=behavior,
+            permissions=data.get("permissions", []),
+            preferred_models=data.get("preferred_models", []),
+            backup_models=data.get("backup_models", []),
+            accent_hex=data.get("accent_hex", "#38bdf8"),
+            icon=data.get("icon", "●"),
+            system_prompt=data.get("system_prompt", ""),
+            enabled=bool(data.get("enabled", True)),
+            custom=bool(data.get("custom", True)),
+        )
+
+
+class ModeRegistry:
+    """Registry managing custom user modes alongside project default modes."""
+
+    def __init__(self, storage_path: str = CUSTOM_MODES_PATH):
+        self.storage_path = storage_path
+        self._custom_modes: Dict[str, ModeSpec] = {}
+        self.load()
+
+    def is_default_mode(self, name: str) -> bool:
+        return name.strip().lower() in DEFAULT_MODE_KEYS
+
+    def validate_mode(self, data: Dict[str, Any]) -> Tuple[bool, List[str]]:
+        errors = []
+        name = data.get("name", "").strip()
+        if not name:
+            errors.append("Mode name cannot be empty")
+        elif not re.match(r"^[A-Za-z0-9_\-]+$", name):
+            errors.append("Mode name must be alphanumeric with dashes or underscores only")
+        elif self.is_default_mode(name):
+            errors.append(f"Cannot overwrite default mode '{name}'")
+        return (len(errors) == 0), errors
+
+    def register_mode(
+        self,
+        spec: Optional[ModeSpec] = None,
+        persist: bool = True,
+        name: str = "",
+        description: str = "",
+        system_prompt: str = "",
+        icon: str = "●",
+        capabilities: Optional[List[str]] = None,
+        inherits: Optional[str] = "agent",
+    ) -> Tuple[bool, str]:
+        if spec is None:
+            spec = ModeSpec(
+                name=name,
+                description=description,
+                system_prompt=system_prompt,
+                icon=icon,
+                capabilities=capabilities or [],
+                inherits=inherits,
+            )
+
+        canonical = spec.name.strip().lower()
+        if self.is_default_mode(canonical):
+            return False, f"Cannot overwrite default mode '{spec.name}'"
+
+        ok, errs = self.validate_mode(spec.to_dict())
+        if not ok:
+            return False, "; ".join(errs)
+
+        self._custom_modes[canonical] = spec
+        if persist:
+            self.save()
+        self._sync_with_ai_modes()
+        return True, f"Mode '{spec.name}' registered successfully"
+
+    def unregister_mode(self, name: str) -> Tuple[bool, str]:
+        canonical = name.strip().lower()
+        if self.is_default_mode(canonical):
+            return False, f"Cannot delete default mode '{name}'"
+        if canonical not in self._custom_modes:
+            return False, f"Custom mode '{name}' not found"
+
+        del self._custom_modes[canonical]
+        self.save()
+        self._sync_with_ai_modes()
+        return True, f"Mode '{name}' removed successfully"
+
+    def get_mode(self, name: str) -> Optional[ModeSpec]:
+        """Lookup mode by exact or case-insensitive name."""
+        canonical = (name or "").strip().lower()
+        return self._custom_modes.get(canonical)
+
+    def resolve_mode_name(self, query: str) -> Optional[str]:
+        """Resolve a mode name from typed command or natural language (e.g., 'Use BioLab mode')."""
+        if not query:
+            return None
+        clean = query.strip()
+        # Direct check
+        low = clean.lower().lstrip("/")
+        if low in DEFAULT_MODE_KEYS:
+            return low
+        if low in self._custom_modes:
+            return self._custom_modes[low].name
+
+        # Natural language pattern check: e.g. "Use BioLab mode", "switch to Quantum mode"
+        m = re.search(r"(?:use|switch to|enter|mode)\s+([A-Za-z0-9_\-]+)", clean, re.IGNORECASE)
+        if m:
+            cand = m.group(1).lower()
+            if cand in DEFAULT_MODE_KEYS:
+                return cand
+            if cand in self._custom_modes:
+                return self._custom_modes[cand].name
+
+        return None
+
+    def list_modes(self, include_defaults: bool = True) -> List[Dict[str, Any]]:
+        modes = []
+        if include_defaults:
+            try:
+                from .. import ai_modes
+                for k in ai_modes.MODE_ORDER:
+                    m = ai_modes.meta(k)
+                    modes.append({
+                        "name": m.get("label", k.title()),
+                        "key": k,
+                        "description": m.get("purpose", ""),
+                        "icon": m.get("icon", "●"),
+                        "default": True,
+                        "enabled": True,
+                    })
+            except Exception:
+                for k in DEFAULT_MODE_KEYS:
+                    modes.append({"name": k.title(), "key": k, "default": True, "enabled": True})
+
+        for spec in self._custom_modes.values():
+            modes.append({
+                "name": spec.name,
+                "key": spec.name.lower(),
+                "description": spec.description,
+                "icon": spec.icon,
+                "default": False,
+                "enabled": spec.enabled,
+                "capabilities": spec.capabilities,
+                "inherits": spec.inherits,
+            })
+        return modes
+
+    def export_mode(self, name: str, output_path: str) -> Tuple[bool, str]:
+        spec = self.get_mode(name)
+        if not spec:
+            return False, f"Mode '{name}' not found"
+        try:
+            with open(output_path, "w", encoding="utf-8") as f:
+                json.dump(spec.to_dict(), f, indent=2)
+            return True, f"Exported mode '{name}' to {output_path}"
+        except Exception as e:
+            return False, f"Export failed: {e}"
+
+    def import_mode(self, source: Union[str, Dict[str, Any]]) -> Tuple[bool, str]:
+        try:
+            if isinstance(source, str):
+                if os.path.exists(source):
+                    with open(source, "r", encoding="utf-8") as f:
+                        data = json.load(f)
+                else:
+                    data = json.loads(source)
+            else:
+                data = source
+            spec = ModeSpec.from_dict(data)
+            return self.register_mode(spec)
+        except Exception as e:
+            return False, f"Import failed: {e}"
+
+    def save(self) -> None:
+        try:
+            data = {k: spec.to_dict() for k, spec in self._custom_modes.items()}
+            with open(self.storage_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2)
+        except Exception:
+            pass
+
+    def load(self) -> None:
+        if not os.path.exists(self.storage_path):
+            return
+        try:
+            with open(self.storage_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            if isinstance(data, dict):
+                for k, v in data.items():
+                    if not self.is_default_mode(k):
+                        self._custom_modes[k.lower()] = ModeSpec.from_dict(v)
+            self._sync_with_ai_modes()
+        except Exception:
+            pass
+
+    def _sync_with_ai_modes(self) -> None:
+        """Dynamically synchronize registered custom modes into ai_modes.MODE_META."""
+        try:
+            from .. import ai_modes
+            for spec in self._custom_modes.values():
+                if not spec.enabled:
+                    continue
+                k = spec.name.lower()
+                rgb = ai_modes._hex_to_rgb(spec.accent_hex) or (140, 140, 240)
+                ai_modes.MODE_META[k] = {
+                    "label": spec.name,
+                    "icon": spec.icon,
+                    "accent": rgb,
+                    "purpose": spec.description or f"Custom mode {spec.name}",
+                    "gradient": ai_modes._auto_gradient(rgb),
+                    "custom_spec": spec,
+                }
+                if k not in ai_modes.MODE_ORDER:
+                    ai_modes.MODE_ORDER.append(k)
+        except Exception:
+            pass
+
+
+mode_registry = ModeRegistry()

calc_terminal/core/project_graph.py

@@ -0,0 +1,172 @@
+"""
+CAT Project Graph & Workspace Intelligence per §13:
+- Module dependency graph, symbol definitions, call hierarchies, external imports, test mappings
+- AST-based parsing for Python source files
+- Incrementally updated symbol and dependency index
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Set
+
+
+@dataclass
+class SymbolInfo:
+    name: str
+    kind: str  # function, class, method, variable, import
+    file_path: str
+    line_number: int
+    docstring: Optional[str] = None
+    parameters: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "kind": self.kind,
+            "file_path": self.file_path,
+            "line_number": self.line_number,
+            "docstring": self.docstring,
+            "parameters": self.parameters,
+        }
+
+
+@dataclass
+class FileNode:
+    file_path: str
+    symbols: List[SymbolInfo] = field(default_factory=list)
+    imports: List[str] = field(default_factory=list)
+    imported_by: List[str] = field(default_factory=list)
+    is_test_file: bool = False
+    associated_sources: List[str] = field(default_factory=list)
+
+
+class ProjectGraph:
+    """Incrementally updated semantic graph of project codebase."""
+
+    def __init__(self, workspace_root: Optional[str] = None):
+        self.workspace_root = os.path.abspath(workspace_root or os.getcwd())
+        self.files: Dict[str, FileNode] = {}
+        self.symbol_index: Dict[str, List[SymbolInfo]] = {}
+
+    def scan_directory(self, root_dir: Optional[str] = None, max_files: int = 500):
+        """Scan workspace and construct symbol and dependency graph."""
+        scan_root = os.path.abspath(root_dir or self.workspace_root)
+        count = 0
+        for dirpath, dirnames, filenames in os.walk(scan_root):
+            # Skip hidden and cache dirs
+            dirnames[:] = [d for d in dirnames if not d.startswith((".", "__pycache__", "node_modules", "venv", ".venv"))]
+            for fname in filenames:
+                if fname.endswith(".py"):
+                    full_path = os.path.join(dirpath, fname)
+                    self.index_file(full_path)
+                    count += 1
+                    if count >= max_files:
+                        break
+            if count >= max_files:
+                break
+        self._resolve_dependencies()
+
+    def index_file(self, file_path: str):
+        """Parse file via AST and extract symbols and imports."""
+        norm_path = os.path.normpath(file_path)
+        rel_path = os.path.relpath(norm_path, self.workspace_root) if norm_path.startswith(self.workspace_root) else norm_path
+        is_test = "test" in os.path.basename(norm_path).lower()
+
+        node = FileNode(file_path=norm_path, is_test_file=is_test)
+        try:
+            with open(norm_path, "r", encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+            tree = ast.parse(content, filename=norm_path)
+        except Exception:
+            self.files[norm_path] = node
+            return
+
+        for stmt in ast.walk(tree):
+            if isinstance(stmt, ast.FunctionDef) or isinstance(stmt, ast.AsyncFunctionDef):
+                params = [a.arg for a in stmt.args.args]
+                doc = ast.get_docstring(stmt)
+                sym = SymbolInfo(
+                    name=stmt.name,
+                    kind="function",
+                    file_path=norm_path,
+                    line_number=stmt.lineno,
+                    docstring=doc,
+                    parameters=params,
+                )
+                node.symbols.append(sym)
+                self.symbol_index.setdefault(sym.name, []).append(sym)
+            elif isinstance(stmt, ast.ClassDef):
+                doc = ast.get_docstring(stmt)
+                sym = SymbolInfo(
+                    name=stmt.name,
+                    kind="class",
+                    file_path=norm_path,
+                    line_number=stmt.lineno,
+                    docstring=doc,
+                )
+                node.symbols.append(sym)
+                self.symbol_index.setdefault(sym.name, []).append(sym)
+            elif isinstance(stmt, ast.Import):
+                for alias in stmt.names:
+                    node.imports.append(alias.name)
+            elif isinstance(stmt, ast.ImportFrom):
+                if stmt.module:
+                    node.imports.append(stmt.module)
+
+        self.files[norm_path] = node
+
+    def _resolve_dependencies(self):
+        """Cross-reference imports to determine internal file dependencies."""
+        for path, node in self.files.items():
+            for imp in node.imports:
+                for target_path in self.files.keys():
+                    # Check if imported module matches target file path
+                    mod_name = os.path.splitext(os.path.basename(target_path))[0]
+                    if imp.endswith(mod_name) and target_path != path:
+                        if path not in self.files[target_path].imported_by:
+                            self.files[target_path].imported_by.append(path)
+                        if node.is_test_file and target_path not in node.associated_sources:
+                            node.associated_sources.append(target_path)
+
+    def find_symbols(self, name_query: str) -> List[SymbolInfo]:
+        """Find symbols matching name query."""
+        results = []
+        q = name_query.lower()
+        for sym_name, syms in self.symbol_index.items():
+            if q in sym_name.lower():
+                results.extend(syms)
+        return results
+
+    def get_file_dependencies(self, file_path: str) -> List[str]:
+        norm = os.path.normpath(file_path)
+        node = self.files.get(norm)
+        return node.imports if node else []
+
+    def get_file_dependents(self, file_path: str) -> List[str]:
+        norm = os.path.normpath(file_path)
+        node = self.files.get(norm)
+        return node.imported_by if node else []
+
+    def get_test_files_for_source(self, source_path: str) -> List[str]:
+        norm = os.path.normpath(source_path)
+        base = os.path.splitext(os.path.basename(norm))[0]
+        matching_tests = []
+        for path, node in self.files.items():
+            if node.is_test_file:
+                test_base = os.path.basename(path).lower()
+                if base.lower() in test_base or norm in node.associated_sources:
+                    matching_tests.append(path)
+        return matching_tests
+
+    def summarize(self) -> Dict[str, Any]:
+        return {
+            "total_files_indexed": len(self.files),
+            "total_symbols": sum(len(s) for s in self.symbol_index.values()),
+            "test_files_count": sum(1 for n in self.files.values() if n.is_test_file),
+        }
+
+
+project_graph = ProjectGraph()