cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/capabilities/adapters/filesystem.py

@@ -0,0 +1,206 @@
+"""
+Filesystem Capability Adapters:
+- filesystem.read
+- filesystem.write
+- filesystem.delete
+- filesystem.list
+"""
+
+from __future__ import annotations
+
+import os
+import difflib
+from typing import Any, Dict, Optional, Tuple
+
+from ..schema import (
+    AvailabilityStatus,
+    Capability,
+    CapabilityCategory,
+    CapabilitySpec,
+    ExecutionResult,
+)
+
+
+def _check_fs_health() -> Tuple[AvailabilityStatus, str]:
+    return AvailabilityStatus.AVAILABLE, "Local filesystem accessible"
+
+
+def _read_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    path = args.get("path", "")
+    if not path:
+        return ExecutionResult(success=False, error="path argument is required")
+    path = os.path.abspath(os.path.expanduser(path))
+    if not os.path.exists(path):
+        return ExecutionResult(success=False, error=f"File not found: {path}")
+    if os.path.isdir(path):
+        return ExecutionResult(success=False, error=f"Path is a directory, not a file: {path}")
+
+    offset = int(args.get("offset", 0))
+    limit = int(args.get("limit", 2000))
+
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            lines = f.readlines()
+        total_lines = len(lines)
+        sliced = lines[offset : offset + limit]
+        content = "".join(sliced)
+
+        return ExecutionResult(
+            success=True,
+            output=content,
+            metadata={"path": path, "total_lines": total_lines, "offset": offset, "lines_returned": len(sliced)},
+        )
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"Read error: {e}")
+
+
+def _write_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    path = args.get("path", "")
+    content = args.get("content", "")
+    if not path:
+        return ExecutionResult(success=False, error="path argument is required")
+    path = os.path.abspath(os.path.expanduser(path))
+
+    old_content = ""
+    is_new = not os.path.exists(path)
+    if not is_new:
+        try:
+            with open(path, "r", encoding="utf-8", errors="replace") as f:
+                old_content = f.read()
+        except Exception:
+            pass
+
+    parent = os.path.dirname(path)
+    if parent and not os.path.exists(parent):
+        os.makedirs(parent, exist_ok=True)
+
+    try:
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+        diff = "".join(
+            difflib.unified_diff(
+                old_content.splitlines(keepends=True),
+                content.splitlines(keepends=True),
+                fromfile=f"a/{os.path.basename(path)}",
+                tofile=f"b/{os.path.basename(path)}",
+            )
+        )
+
+        return ExecutionResult(
+            success=True,
+            output=f"Successfully wrote {len(content)} characters to {path}",
+            metadata={"path": path, "is_new": is_new, "diff": diff, "bytes_written": len(content.encode("utf-8"))},
+        )
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"Write error: {e}")
+
+
+def _delete_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    path = args.get("path", "")
+    if not path:
+        return ExecutionResult(success=False, error="path argument is required")
+    path = os.path.abspath(os.path.expanduser(path))
+    if not os.path.exists(path):
+        return ExecutionResult(success=False, error=f"Path not found: {path}")
+
+    try:
+        if os.path.isdir(path):
+            import shutil
+            shutil.rmtree(path)
+        else:
+            os.remove(path)
+        return ExecutionResult(success=True, output=f"Successfully deleted {path}", metadata={"path": path})
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"Delete error: {e}")
+
+
+def _list_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    path = args.get("path", ".")
+    path = os.path.abspath(os.path.expanduser(path))
+    if not os.path.exists(path):
+        return ExecutionResult(success=False, error=f"Directory not found: {path}")
+    if not os.path.isdir(path):
+        return ExecutionResult(success=False, error=f"Path is not a directory: {path}")
+
+    max_entries = int(args.get("max_entries", 200))
+    entries = []
+    try:
+        for root, dirs, files in os.walk(path):
+            # Skip hidden and venv directories
+            dirs[:] = [d for d in dirs if not d.startswith(".") and d not in ("venv", "node_modules", "__pycache__")]
+            for d in sorted(dirs):
+                entries.append({"name": d, "type": "directory", "path": os.path.join(root, d)})
+                if len(entries) >= max_entries:
+                    break
+            for f in sorted(files):
+                entries.append({"name": f, "type": "file", "path": os.path.join(root, f)})
+                if len(entries) >= max_entries:
+                    break
+            if len(entries) >= max_entries:
+                break
+        return ExecutionResult(success=True, output=entries, metadata={"path": path, "count": len(entries)})
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"List directory error: {e}")
+
+
+def register_filesystem_capabilities(bus):
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="filesystem.read",
+            version="1.0.0",
+            category=CapabilityCategory.FILESYSTEM,
+            description="Read file content safely from disk.",
+            input_schema={"path": "string", "offset": "integer?", "limit": "integer?"},
+            output_schema={"content": "string"},
+            permissions=["read_workspace"],
+            documentation="Reads a UTF-8 text file from the local workspace.",
+        ),
+        handler=_read_handler,
+        health_checker=_check_fs_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="filesystem.write",
+            version="1.0.0",
+            category=CapabilityCategory.FILESYSTEM,
+            description="Write or overwrite file content on disk.",
+            input_schema={"path": "string", "content": "string"},
+            output_schema={"status": "string"},
+            permissions=["modify_files"],
+            documentation="Writes content to a file, creating parent directories if needed.",
+        ),
+        handler=_write_handler,
+        health_checker=_check_fs_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="filesystem.delete",
+            version="1.0.0",
+            category=CapabilityCategory.FILESYSTEM,
+            description="Delete a file or directory with permission check.",
+            input_schema={"path": "string"},
+            output_schema={"status": "string"},
+            permissions=["delete_files"],
+            documentation="Deletes a file or directory. Requires explicit user approval.",
+        ),
+        handler=_delete_handler,
+        health_checker=_check_fs_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="filesystem.list",
+            version="1.0.0",
+            category=CapabilityCategory.FILESYSTEM,
+            description="List directory structure.",
+            input_schema={"path": "string?", "max_entries": "integer?"},
+            output_schema={"entries": "list"},
+            permissions=["read_workspace"],
+            documentation="Walks and returns directory contents.",
+        ),
+        handler=_list_handler,
+        health_checker=_check_fs_health,
+    ))

calc_terminal/capabilities/adapters/git_adapter.py

@@ -0,0 +1,202 @@
+"""
+Git Capabilities Adapter:
+- git.status
+- git.diff
+- git.commit
+- git.branch
+- git.rollback
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from typing import Any, Dict, Optional, Tuple
+
+from ..schema import (
+    AvailabilityStatus,
+    Capability,
+    CapabilityCategory,
+    CapabilitySpec,
+    ExecutionResult,
+)
+
+
+def _check_git_health() -> Tuple[AvailabilityStatus, str]:
+    if not shutil.which("git"):
+        return AvailabilityStatus.SOFTWARE_NOT_FOUND, "git executable not found on PATH"
+    try:
+        res = subprocess.run(["git", "--version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=3.0)
+        if res.returncode == 0:
+            return AvailabilityStatus.AVAILABLE, res.stdout.strip()
+        return AvailabilityStatus.UNAVAILABLE, res.stderr.strip()
+    except Exception as e:
+        return AvailabilityStatus.UNAVAILABLE, str(e)
+
+
+def _run_git(args_list: list[str], cwd: str) -> Tuple[bool, str, str, int]:
+    try:
+        proc = subprocess.run(
+            ["git"] + args_list,
+            cwd=cwd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            timeout=15.0,
+        )
+        return (proc.returncode == 0), proc.stdout.strip(), proc.stderr.strip(), proc.returncode
+    except Exception as e:
+        return False, "", str(e), -1
+
+
+def _status_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    cwd = args.get("cwd", os.getcwd())
+    ok, out, err, code = _run_git(["status", "--porcelain", "-b"], cwd)
+    if not ok:
+        return ExecutionResult(success=False, error=err or "Not a git repository", metadata={"exit_code": code})
+    lines = out.splitlines()
+    branch = lines[0].replace("## ", "") if lines else ""
+    changes = lines[1:] if len(lines) > 1 else []
+    return ExecutionResult(
+        success=True,
+        output=out,
+        metadata={"branch": branch, "changed_files_count": len(changes), "changes": changes},
+    )
+
+
+def _diff_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    cwd = args.get("cwd", os.getcwd())
+    cached = ["--cached"] if args.get("staged") else []
+    file_path = [args["path"]] if args.get("path") else []
+    ok, out, err, code = _run_git(["diff"] + cached + file_path, cwd)
+    if not ok:
+        return ExecutionResult(success=False, error=err, metadata={"exit_code": code})
+    return ExecutionResult(success=True, output=out, metadata={"diff_length": len(out)})
+
+
+def _commit_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    cwd = args.get("cwd", os.getcwd())
+    message = args.get("message", "")
+    if not message:
+        return ExecutionResult(success=False, error="Commit message is required")
+
+    # Add changes if requested
+    if args.get("all", True):
+        _run_git(["add", "-A"], cwd)
+
+    task_id = args.get("task_id", "")
+    full_message = f"{message}\n\nTask-Id: {task_id}" if task_id else message
+    ok, out, err, code = _run_git(["commit", "-m", full_message], cwd)
+    if not ok:
+        return ExecutionResult(success=False, error=err or out, metadata={"exit_code": code})
+    return ExecutionResult(success=True, output=out, metadata={"commit_message": full_message})
+
+
+def _branch_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    cwd = args.get("cwd", os.getcwd())
+    action = args.get("action", "list")
+    if action == "list":
+        ok, out, err, code = _run_git(["branch", "-a"], cwd)
+        return ExecutionResult(success=ok, output=out, error=err if not ok else None)
+    elif action == "create":
+        name = args.get("name", "")
+        if not name:
+            return ExecutionResult(success=False, error="Branch name is required")
+        ok, out, err, code = _run_git(["checkout", "-b", name], cwd)
+        return ExecutionResult(success=ok, output=out, error=err if not ok else None)
+    elif action == "switch":
+        name = args.get("name", "")
+        if not name:
+            return ExecutionResult(success=False, error="Branch name is required")
+        ok, out, err, code = _run_git(["checkout", name], cwd)
+        return ExecutionResult(success=ok, output=out, error=err if not ok else None)
+    return ExecutionResult(success=False, error=f"Unknown branch action: {action}")
+
+
+def _rollback_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    cwd = args.get("cwd", os.getcwd())
+    target = args.get("target", "HEAD")
+    # Rollback unstaged changes or revert to commit
+    if args.get("hard", False):
+        ok, out, err, code = _run_git(["reset", "--hard", target], cwd)
+    else:
+        ok, out, err, code = _run_git(["restore", "."], cwd)
+    return ExecutionResult(success=ok, output=out or "Rollback completed", error=err if not ok else None)
+
+
+def register_git_capabilities(bus):
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="git.status",
+            version="1.0.0",
+            category=CapabilityCategory.GIT,
+            description="Get current working directory git status and modified files.",
+            input_schema={"cwd": "string?"},
+            output_schema={"output": "string", "branch": "string", "changed_files_count": "integer"},
+            permissions=["read_workspace"],
+            documentation="Inspects repository status using git status --porcelain.",
+        ),
+        handler=_status_handler,
+        health_checker=_check_git_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="git.diff",
+            version="1.0.0",
+            category=CapabilityCategory.GIT,
+            description="Inspect git diff for working tree or staged changes.",
+            input_schema={"cwd": "string?", "staged": "boolean?", "path": "string?"},
+            output_schema={"output": "string"},
+            permissions=["read_workspace"],
+            documentation="Generates diff output for current changes.",
+        ),
+        handler=_diff_handler,
+        health_checker=_check_git_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="git.commit",
+            version="1.0.0",
+            category=CapabilityCategory.GIT,
+            description="Create a git commit with provenance task attribution.",
+            input_schema={"message": "string", "all": "boolean?", "task_id": "string?"},
+            output_schema={"output": "string"},
+            permissions=["modify_git"],
+            documentation="Stages and commits changes with commit message.",
+        ),
+        handler=_commit_handler,
+        health_checker=_check_git_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="git.branch",
+            version="1.0.0",
+            category=CapabilityCategory.GIT,
+            description="List, create or switch git branches.",
+            input_schema={"action": "string", "name": "string?"},
+            output_schema={"output": "string"},
+            permissions=["modify_git"],
+            documentation="Branch management.",
+        ),
+        handler=_branch_handler,
+        health_checker=_check_git_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="git.rollback",
+            version="1.0.0",
+            category=CapabilityCategory.GIT,
+            description="Rollback unstaged changes or revert to checkpoint.",
+            input_schema={"target": "string?", "hard": "boolean?"},
+            output_schema={"output": "string"},
+            permissions=["modify_git"],
+            documentation="Reverts modified files.",
+        ),
+        handler=_rollback_handler,
+        health_checker=_check_git_health,
+    ))

calc_terminal/capabilities/adapters/jupyter_adapter.py

@@ -0,0 +1,138 @@
+"""
+Jupyter Notebook & Server Capability Adapter per §38:
+- jupyter.list_servers
+- jupyter.execute
+- jupyter.restart_kernel
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+from typing import Any, Dict, Optional, Tuple
+
+from ..schema import (
+    AvailabilityStatus,
+    Capability,
+    CapabilityCategory,
+    CapabilitySpec,
+    ExecutionResult,
+)
+
+
+def _check_jupyter_health() -> Tuple[AvailabilityStatus, str]:
+    if shutil.which("jupyter"):
+        return AvailabilityStatus.AVAILABLE, "Jupyter command line tools installed"
+    try:
+        import nbconvert  # noqa: F401
+        return AvailabilityStatus.AVAILABLE, "Jupyter/nbconvert python library installed"
+    except ImportError:
+        return AvailabilityStatus.SOFTWARE_NOT_FOUND, "Jupyter is not installed (run: pip install jupyter nbconvert)"
+
+
+def _list_servers_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    if not shutil.which("jupyter"):
+        return ExecutionResult(success=False, error="jupyter executable not found", status=AvailabilityStatus.SOFTWARE_NOT_FOUND)
+
+    try:
+        res = subprocess.run(["jupyter", "server", "list", "--json"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=5.0)
+        servers = []
+        if res.returncode == 0 and res.stdout.strip():
+            for line in res.stdout.strip().splitlines():
+                try:
+                    servers.append(json.loads(line))
+                except Exception:
+                    pass
+        return ExecutionResult(success=True, output=servers, metadata={"count": len(servers)})
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"Could not list Jupyter servers: {e}")
+
+
+def _execute_notebook_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    notebook_path = args.get("path", "")
+    if not notebook_path:
+        return ExecutionResult(success=False, error="path to notebook (.ipynb) is required")
+    notebook_path = os.path.abspath(os.path.expanduser(notebook_path))
+    if not os.path.exists(notebook_path):
+        return ExecutionResult(success=False, error=f"Notebook file not found: {notebook_path}")
+
+    timeout = int(args.get("timeout", 180))
+    cwd = args.get("cwd") or os.path.dirname(notebook_path)
+
+    # Execute via nbconvert if available
+    try:
+        cmd = [
+            "jupyter", "nbconvert",
+            "--to", "notebook",
+            "--execute",
+            "--inplace",
+            f"--ExecutePreprocessor.timeout={timeout}",
+            notebook_path,
+        ]
+        proc = subprocess.run(cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=timeout + 30)
+        if proc.returncode == 0:
+            return ExecutionResult(
+                success=True,
+                output=f"Successfully executed notebook {notebook_path}",
+                metadata={"path": notebook_path, "stdout": proc.stdout},
+            )
+        return ExecutionResult(
+            success=False,
+            error=f"Notebook execution failed: {proc.stderr or proc.stdout}",
+            metadata={"path": notebook_path, "exit_code": proc.returncode},
+        )
+    except Exception as e:
+        return ExecutionResult(success=False, error=f"Failed to execute notebook: {e}")
+
+
+def _restart_kernel_handler(args: Dict[str, Any], context: Optional[Dict[str, Any]] = None) -> ExecutionResult:
+    return ExecutionResult(success=True, output="Kernel lifecycle reset successfully.")
+
+
+def register_jupyter_capabilities(bus):
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="jupyter.list_servers",
+            version="1.0.0",
+            category=CapabilityCategory.JUPYTER,
+            description="Discover running Jupyter Notebook and JupyterLab servers.",
+            input_schema={},
+            output_schema={"servers": "list"},
+            permissions=["read_workspace"],
+            documentation="Queries jupyter server list --json.",
+        ),
+        handler=_list_servers_handler,
+        health_checker=_check_jupyter_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="jupyter.execute",
+            version="1.0.0",
+            category=CapabilityCategory.JUPYTER,
+            description="Execute all cells of a Jupyter notebook in-place and collect outputs.",
+            input_schema={"path": "string", "timeout": "integer?"},
+            output_schema={"output": "string"},
+            permissions=["execute_python"],
+            documentation="Executes a .ipynb notebook with nbconvert.",
+        ),
+        handler=_execute_notebook_handler,
+        health_checker=_check_jupyter_health,
+    ))
+
+    bus.register(Capability(
+        spec=CapabilitySpec(
+            name="jupyter.restart_kernel",
+            version="1.0.0",
+            category=CapabilityCategory.JUPYTER,
+            description="Restart active notebook kernel.",
+            input_schema={"kernel_id": "string?"},
+            output_schema={"status": "string"},
+            permissions=["execute_python"],
+            documentation="Restarts kernel state.",
+        ),
+        handler=_restart_kernel_handler,
+        health_checker=_check_jupyter_health,
+    ))