jusi-gigacode 0.1.0__tar.gz

jusi_gigacode-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.venv/
+dist/
+build/
+*.egg-info/

jusi_gigacode-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 notawhaleble
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jusi_gigacode-0.1.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.5
+Name: jusi-gigacode
+Version: 0.1.0
+Summary: GigaCode exact-provider plugin for the Jusi ACP family
+Project-URL: Repository, https://github.com/notawhaleble/jusi-gigacode
+Author: notawhaleble
+License: MIT License
+        
+        Copyright (c) 2026 notawhaleble
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: acp,agent,gigacode,jupyter,jusi
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Jupyter
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: jusi-acp<0.2,>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# jusi-gigacode
+
+`jusi-gigacode` is the exact GigaCode provider for the shared Jusi ACP family.
+It launches GigaCode over Agent Client Protocol while `jusi-acp` supplies the
+`%%acp` magic, interactive VisiData application, permission choices, durable
+follow-ups, cancellation, session controls, completion, and editor actions.
+
+## Installation
+
+Install this package, `jusi-acp`, and Jusi in the Python environment used by the
+target Jupyter kernel. The `gigacode` executable must be available on that
+target's `PATH`.
+
+```bash
+pip install jusi-gigacode
+```
+
+For development from sibling checkouts:
+
+```bash
+python3.12 -m venv .venv
+.venv/bin/pip install -e ../jusi-acp -e '.[dev]'
+.venv/bin/pytest
+```
+
+## Configuration
+
+Add an ACP alias to `~/.jusi/jusi.toml` on the kernel target:
+
+```toml
+[acp.work]
+provider = "gigacode"
+path = "/path/to/project"
+additional_directories = ["../shared"]
+model = "provider-owned-model-name"
+```
+
+Then run:
+
+```python
+%%acp work
+Inspect the project and implement the requested change.
+```
+
+The provider launches `gigacode --acp`. A live GigaCode handshake has confirmed
+ACP protocol version 1, the browser-backed `gigacode` authentication method,
+session load/resume support, and HTTP/SSE MCP support.
+
+Provider-specific alias options are:
+
+- `executable`: executable name or path; defaults to `gigacode`.
+- `model`: passed as `--model VALUE`.
+- `approval_mode`: passed as `--approval-mode VALUE`. Leaving it unset allows
+  ACP permission requests to reach the interactive Jusi client.
+- `arguments`: an array of additional command-line arguments.
+- `environment`: environment-variable overrides for the GigaCode process.
+- `auth_method`: ACP authentication method ID. It defaults to `gigacode`, as
+  advertised by GigaCode, or may be set to an empty string to skip the proactive
+  authentication call.
+
+The executable inherits the target environment, including desktop/session
+variables used by browser launchers. With the default authentication method,
+`jusi-acp` calls ACP `authenticate` before creating the session. GigaCode owns
+opening its authorization URL and waiting for the callback; after it completes,
+the original cell body is submitted automatically.
+
+Session controls and family commands include:
+
+```python
+%%acp work --load SESSION_ID
+Replay and continue a stored session.
+```
+
+```python
+%%acp work --resume SESSION_ID
+Continue a stored session without replay.
+```
+
+Follow-up cells can use `/mode ID`, `/config ID VALUE`, `/auth METHOD_ID`, and
+`/cancel`. Slash commands advertised by GigaCode are also completed and sent as
+ordinary ACP prompts.
+
+## Verified ACP handshake
+
+GigaCode identifies its agent implementation as `qwen-code` with the title
+`GigaCode`. It advertises authentication method ID `gigacode`; authentication is
+handled by the GigaCode backend through its browser flow. The initialize call
+waits for that flow to finish, after which `jusi-acp` completes ACP
+authentication, establishes the session, and submits the original cell body
+without requiring the user to repeat it.

jusi_gigacode-0.1.0/README.md

@@ -0,0 +1,90 @@
+# jusi-gigacode
+
+`jusi-gigacode` is the exact GigaCode provider for the shared Jusi ACP family.
+It launches GigaCode over Agent Client Protocol while `jusi-acp` supplies the
+`%%acp` magic, interactive VisiData application, permission choices, durable
+follow-ups, cancellation, session controls, completion, and editor actions.
+
+## Installation
+
+Install this package, `jusi-acp`, and Jusi in the Python environment used by the
+target Jupyter kernel. The `gigacode` executable must be available on that
+target's `PATH`.
+
+```bash
+pip install jusi-gigacode
+```
+
+For development from sibling checkouts:
+
+```bash
+python3.12 -m venv .venv
+.venv/bin/pip install -e ../jusi-acp -e '.[dev]'
+.venv/bin/pytest
+```
+
+## Configuration
+
+Add an ACP alias to `~/.jusi/jusi.toml` on the kernel target:
+
+```toml
+[acp.work]
+provider = "gigacode"
+path = "/path/to/project"
+additional_directories = ["../shared"]
+model = "provider-owned-model-name"
+```
+
+Then run:
+
+```python
+%%acp work
+Inspect the project and implement the requested change.
+```
+
+The provider launches `gigacode --acp`. A live GigaCode handshake has confirmed
+ACP protocol version 1, the browser-backed `gigacode` authentication method,
+session load/resume support, and HTTP/SSE MCP support.
+
+Provider-specific alias options are:
+
+- `executable`: executable name or path; defaults to `gigacode`.
+- `model`: passed as `--model VALUE`.
+- `approval_mode`: passed as `--approval-mode VALUE`. Leaving it unset allows
+  ACP permission requests to reach the interactive Jusi client.
+- `arguments`: an array of additional command-line arguments.
+- `environment`: environment-variable overrides for the GigaCode process.
+- `auth_method`: ACP authentication method ID. It defaults to `gigacode`, as
+  advertised by GigaCode, or may be set to an empty string to skip the proactive
+  authentication call.
+
+The executable inherits the target environment, including desktop/session
+variables used by browser launchers. With the default authentication method,
+`jusi-acp` calls ACP `authenticate` before creating the session. GigaCode owns
+opening its authorization URL and waiting for the callback; after it completes,
+the original cell body is submitted automatically.
+
+Session controls and family commands include:
+
+```python
+%%acp work --load SESSION_ID
+Replay and continue a stored session.
+```
+
+```python
+%%acp work --resume SESSION_ID
+Continue a stored session without replay.
+```
+
+Follow-up cells can use `/mode ID`, `/config ID VALUE`, `/auth METHOD_ID`, and
+`/cancel`. Slash commands advertised by GigaCode are also completed and sent as
+ordinary ACP prompts.
+
+## Verified ACP handshake
+
+GigaCode identifies its agent implementation as `qwen-code` with the title
+`GigaCode`. It advertises authentication method ID `gigacode`; authentication is
+handled by the GigaCode backend through its browser flow. The initialize call
+waits for that flow to finish, after which `jusi-acp` completes ACP
+authentication, establishes the session, and submits the original cell body
+without requiring the user to repeat it.

jusi_gigacode-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "jusi-gigacode"
+version = "0.1.0"
+description = "GigaCode exact-provider plugin for the Jusi ACP family"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { file = "LICENSE" }
+authors = [{ name = "notawhaleble" }]
+keywords = ["acp", "gigacode", "jusi", "jupyter", "agent"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Framework :: Jupyter",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+  "jusi-acp>=0.1.0,<0.2",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+
+[project.urls]
+Repository = "https://github.com/notawhaleble/jusi-gigacode"
+
+[project.entry-points."jusi.plugins.v1"]
+gigacode = "jusi_gigacode.catalog:catalog_entry"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/jusi_gigacode"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src", "../jusi-acp/src"]
+

jusi_gigacode-0.1.0/src/jusi_gigacode/__init__.py

@@ -0,0 +1,11 @@
+"""GigaCode exact-provider plugin for Jusi ACP."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("jusi-gigacode")
+except PackageNotFoundError:  # source checkout
+    __version__ = "0.1.0"
+
+__all__ = ["__version__"]
+

jusi_gigacode-0.1.0/src/jusi_gigacode/catalog.py

@@ -0,0 +1,27 @@
+"""Side-effect-free Jusi catalog entry for the exact GigaCode provider."""
+from __future__ import annotations
+
+from typing import Any
+
+from . import __version__
+
+
+def catalog_entry() -> dict[str, Any]:
+    # Keep this claim byte-for-byte compatible with jusi_acp.family_claim().
+    # Discovery must not import the worker or start the ACP application.
+    return {
+        "plugin_id": "gigacode",
+        "plugin_version": __version__,
+        "distribution": "jusi-gigacode",
+        "families": [{
+            "family_id": "acp",
+            "magic_name": "acp",
+            "capabilities": ["execute", "followup", "complete", "interrupt", "editor_actions"],
+            "presentation": {"syntax": "markdown", "indent": "markdown"},
+        }],
+        "kernel_extensions": ["jusi_gigacode.kernel"],
+        "worker_entry_point": "jusi_gigacode.worker:create_worker",
+        "media_types": ["text/x-ansi"],
+        "interaction": "terminal_interactive",
+    }
+

jusi_gigacode-0.1.0/src/jusi_gigacode/kernel.py

@@ -0,0 +1,12 @@
+"""Exact-provider attestation backed by the shared ACP kernel dispatcher."""
+
+from jusi_acp import KernelProviderAdapter
+
+from . import __version__
+
+_adapter = KernelProviderAdapter("gigacode", __version__)
+
+jusi_kernel_adapter_v1 = _adapter.manifest
+configure_jusi_runtime_v1 = _adapter.configure
+load_ipython_extension = _adapter.load_ipython_extension
+

jusi_gigacode-0.1.0/src/jusi_gigacode/worker.py

@@ -0,0 +1,93 @@
+"""GigaCode launch validation and shared ACP worker construction."""
+from __future__ import annotations
+
+from collections.abc import Mapping
+import os
+from pathlib import Path
+import shutil
+from typing import Any
+
+from jusi_acp import ACPWorker, AgentLaunch, ProviderSpec
+
+from . import __version__
+
+_COMMON_KEYS = {"provider", "path", "additional_directories", "mcp_servers"}
+_PROVIDER_KEYS = {
+    "executable", "arguments", "model", "approval_mode", "environment", "auth_method",
+}
+
+
+def resolve_launch(configuration: Mapping[str, Any], cwd: Path) -> AgentLaunch:
+    """Validate one alias and construct a GigaCode ACP invocation."""
+    unknown = sorted(set(configuration) - _COMMON_KEYS - _PROVIDER_KEYS)
+    if unknown:
+        raise ValueError(f"unsupported GigaCode option(s): {', '.join(unknown)}")
+
+    executable = _string(configuration.get("executable", "gigacode"), "executable")
+    resolved_executable = _resolve_executable(executable or "gigacode")
+    arguments = _string_list(configuration.get("arguments", []), "arguments")
+
+    argv = [resolved_executable, "--acp"]
+    model = _string(configuration.get("model", ""), "model")
+    if model:
+        argv.extend(("--model", model))
+    approval_mode = _string(configuration.get("approval_mode", ""), "approval_mode")
+    if approval_mode:
+        argv.extend(("--approval-mode", approval_mode))
+    argv.extend(arguments)
+
+    environment = configuration.get("environment", {})
+    if not isinstance(environment, Mapping):
+        raise TypeError("environment must be a table of string values")
+    clean_environment: dict[str, str] = {}
+    for key, value in environment.items():
+        clean_key = _string(key, "environment name")
+        clean_value = _string(value, f"environment value for {clean_key!r}", allow_empty=True)
+        if not clean_key or "=" in clean_key:
+            raise ValueError("environment names must be non-empty and cannot contain '='")
+        clean_environment[clean_key] = clean_value
+
+    # GigaCode advertises this browser-backed method in its ACP v1 initialize
+    # response. Set auth_method = "" only when proactive authentication should
+    # be skipped for an already authenticated or specially configured install.
+    auth_method = _string(configuration.get("auth_method", "gigacode"), "auth_method")
+    return AgentLaunch(tuple(argv), cwd, clean_environment, auth_method)
+
+
+def _resolve_executable(value: str) -> str:
+    expanded = os.path.expanduser(value)
+    if os.path.sep in expanded:
+        path = Path(expanded).resolve()
+        if not path.is_file():
+            raise ValueError(f"GigaCode executable does not exist: {path}")
+        if not os.access(path, os.X_OK):
+            raise ValueError(f"GigaCode executable is not executable: {path}")
+        return str(path)
+    found = shutil.which(expanded)
+    if found is None:
+        raise ValueError(f"GigaCode executable {expanded!r} was not found on PATH")
+    return found
+
+
+def _string(value: Any, label: str, *, allow_empty: bool = True) -> str:
+    if not isinstance(value, str):
+        raise TypeError(f"{label} must be a string")
+    if any(character in value for character in ("\x00", "\n", "\r")):
+        raise ValueError(f"{label} contains an invalid control character")
+    result = value.strip()
+    if not allow_empty and not result:
+        raise ValueError(f"{label} cannot be empty")
+    return result
+
+
+def _string_list(value: Any, label: str) -> list[str]:
+    if not isinstance(value, list):
+        raise TypeError(f"{label} must be an array of strings")
+    return [_string(item, f"{label} item", allow_empty=False) for item in value]
+
+
+PROVIDER = ProviderSpec("gigacode", __version__, resolve_launch)
+
+
+def create_worker(context: Any) -> ACPWorker:
+    return ACPWorker(context, PROVIDER)

jusi_gigacode-0.1.0/tests/test_catalog.py

@@ -0,0 +1,30 @@
+from importlib.metadata import entry_points
+
+from jusi.plugin_api import validate_catalog_claims
+from jusi_acp import family_claim
+
+from jusi_gigacode import __version__
+from jusi_gigacode.catalog import catalog_entry
+
+
+def test_catalog_is_an_exact_compatible_acp_provider() -> None:
+    entry = catalog_entry()
+    assert entry["plugin_id"] == "gigacode"
+    assert entry["plugin_version"] == __version__
+    assert entry["distribution"] == "jusi-gigacode"
+    assert entry["families"] == [family_claim()]
+    assert entry["kernel_extensions"] == ["jusi_gigacode.kernel"]
+    assert entry["worker_entry_point"] == "jusi_gigacode.worker:create_worker"
+    validate_catalog_claims({
+        "protocol_version": 1,
+        "catalog_version": 1,
+        "discovery_id": "jusi_gigacode_tests",
+        "plugins": [entry],
+    })
+
+
+def test_installed_distribution_exposes_exact_entry_point() -> None:
+    matches = [item for item in entry_points(group="jusi.plugins.v1") if item.name == "gigacode"]
+    if matches:
+        assert matches[0].value == "jusi_gigacode.catalog:catalog_entry"
+

jusi_gigacode-0.1.0/tests/test_kernel.py

@@ -0,0 +1,11 @@
+from jusi_gigacode import __version__
+from jusi_gigacode.kernel import jusi_kernel_adapter_v1
+
+
+def test_kernel_attests_exact_provider_and_family() -> None:
+    assert jusi_kernel_adapter_v1() == {
+        "plugin_id": "gigacode",
+        "plugin_version": __version__,
+        "families": [{"family_id": "acp", "magic_name": "acp"}],
+    }
+

jusi_gigacode-0.1.0/tests/test_worker.py

@@ -0,0 +1,97 @@
+import json
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from jusi_acp import ACPWorker
+from jusi_gigacode.worker import create_worker, resolve_launch
+
+
+def test_default_launch_uses_acp_and_browser_auth(tmp_path: Path, monkeypatch) -> None:  # type: ignore[no-untyped-def]
+    monkeypatch.setattr("jusi_gigacode.worker.shutil.which", lambda command: "/tools/gigacode")
+    launch = resolve_launch({"provider": "gigacode", "path": str(tmp_path)}, tmp_path)
+    assert launch.argv == ("/tools/gigacode", "--acp")
+    assert launch.cwd == tmp_path
+    assert launch.auth_method == "gigacode"
+
+
+def test_launch_maps_provider_options(tmp_path: Path, monkeypatch) -> None:  # type: ignore[no-untyped-def]
+    monkeypatch.setattr("jusi_gigacode.worker.shutil.which", lambda command: "/tools/custom")
+    launch = resolve_launch({
+        "executable": "custom",
+        "model": "coder-model",
+        "approval_mode": "default",
+        "arguments": ["--debug"],
+        "environment": {"GIGACODE_PROFILE": "work"},
+        "auth_method": "gigacode-login",
+    }, tmp_path)
+    assert launch.argv == (
+        "/tools/custom", "--acp", "--model", "coder-model",
+        "--approval-mode", "default", "--debug",
+    )
+    assert launch.environment == {"GIGACODE_PROFILE": "work"}
+    assert launch.auth_method == "gigacode-login"
+
+
+def test_auth_can_be_disabled_for_an_already_authenticated_install(tmp_path: Path, monkeypatch) -> None:  # type: ignore[no-untyped-def]
+    monkeypatch.setattr("jusi_gigacode.worker.shutil.which", lambda command: "/tools/gigacode")
+    assert resolve_launch({"auth_method": ""}, tmp_path).auth_method == ""
+
+
+@pytest.mark.parametrize("configuration, message", [
+    ({"unknown": True}, "unsupported GigaCode option"),
+    ({"arguments": "--debug"}, "arguments must be an array"),
+    ({"environment": []}, "environment must be a table"),
+    ({"model": 7}, "model must be a string"),
+])
+def test_invalid_provider_configuration_is_rejected(
+    tmp_path: Path, monkeypatch, configuration: dict, message: str
+) -> None:  # type: ignore[no-untyped-def]
+    monkeypatch.setattr("jusi_gigacode.worker.shutil.which", lambda command: "/tools/gigacode")
+    with pytest.raises((TypeError, ValueError), match=message):
+        resolve_launch(configuration, tmp_path)
+
+
+def test_missing_executable_is_rejected(tmp_path: Path, monkeypatch) -> None:  # type: ignore[no-untyped-def]
+    monkeypatch.setattr("jusi_gigacode.worker.shutil.which", lambda command: None)
+    with pytest.raises(ValueError, match="not found on PATH"):
+        resolve_launch({}, tmp_path)
+
+
+def test_factory_returns_shared_worker_for_exact_provider() -> None:
+    worker = create_worker(SimpleNamespace(plugin_id="gigacode"))
+    try:
+        assert isinstance(worker, ACPWorker)
+        assert worker.provider.plugin_id == "gigacode"
+    finally:
+        worker.close()
+
+
+def test_exact_worker_hands_authenticated_launch_to_shared_application(
+    tmp_path: Path, monkeypatch
+) -> None:  # type: ignore[no-untyped-def]
+    monkeypatch.setattr("jusi_gigacode.worker.shutil.which", lambda command: "/tools/gigacode")
+    worker = create_worker(SimpleNamespace(plugin_id="gigacode"))
+    try:
+        result = worker.handle("execute", {
+            "alias": "work",
+            "body": "continue after login",
+            "cwd": str(tmp_path),
+            "configuration": {"auth_method": "gigacode-login"},
+            "additional_directories": [],
+            "mcp_servers": [],
+            "session_action": "new",
+            "session_id": "",
+        })
+        surface = result.core_requests[0]
+        payload = json.loads(Path(surface.argv[3]).read_text(encoding="utf-8"))
+        assert payload["launch"] == {
+            "argv": ["/tools/gigacode", "--acp"],
+            "cwd": str(tmp_path),
+            "environment": {},
+            "auth_method": "gigacode-login",
+        }
+        assert payload["submission"]["body"] == "continue after login"
+    finally:
+        worker.close()