delphi-team 0.1.0__tar.gz

delphi_team-0.1.0/.gitignore

@@ -0,0 +1,18 @@
+node_modules/
+dist/
+dist-artifacts/
+dist-binaries/
+coverage/
+*.tsbuildinfo
+
+# Compiled binaries are staged into the wheel at build time, never committed.
+python/src/delphi_team/bin/*
+!python/src/delphi_team/bin/.gitkeep
+python/dist/
+python/build/
+*.egg-info/
+__pycache__/
+
+.delphi/logs/
+.delphi/tmp/
+.build/tmp/

delphi_team-0.1.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.5
+Name: delphi-team
+Version: 0.1.0
+Summary: Run Claude Code as a department. Unofficial; works with Claude Code.
+License-Expression: MIT
+Keywords: agents,claude-code,cli,orchestration
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# delphi-team (Python distribution)
+
+Run Claude Code as a department. Unofficial; works with Claude Code.
+
+This wheel carries a compiled binary of the `delphi` CLI, so nothing here needs Node.
+All logic lives in the TypeScript core — this package is a shim that hands over argv,
+stdio and the exit code. See the project README for what the tool does.
+
+```
+pipx install delphi-team
+uvx delphi-team --help
+pip install delphi-team
+```
+
+Platforms without a published binary fail with an instruction to use `npm install -g delphi-team`
+rather than silently downloading a Node runtime.

delphi_team-0.1.0/README.md

@@ -0,0 +1,16 @@
+# delphi-team (Python distribution)
+
+Run Claude Code as a department. Unofficial; works with Claude Code.
+
+This wheel carries a compiled binary of the `delphi` CLI, so nothing here needs Node.
+All logic lives in the TypeScript core — this package is a shim that hands over argv,
+stdio and the exit code. See the project README for what the tool does.
+
+```
+pipx install delphi-team
+uvx delphi-team --help
+pip install delphi-team
+```
+
+Platforms without a published binary fail with an instruction to use `npm install -g delphi-team`
+rather than silently downloading a Node runtime.

delphi_team-0.1.0/hatch_build.py

@@ -0,0 +1,20 @@
+"""Mark the wheel as platform-specific so it can carry a compiled binary.
+
+The wheel holds no Python C extension, so the ABI tag stays ``none``; only the platform
+tag changes. ``DELPHI_WHEEL_TAG`` is set by CI per target; building locally without it
+infers the tag from the host.
+"""
+
+import os
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+
+class CustomBuildHook(BuildHookInterface):
+    def initialize(self, version, build_data):
+        build_data["pure_python"] = False
+        tag = os.environ.get("DELPHI_WHEEL_TAG")
+        if tag:
+            build_data["tag"] = tag
+        else:
+            build_data["infer_tag"] = True

delphi_team-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling>=1.32"]
+build-backend = "hatchling.build"
+
+[project]
+name = "delphi-team"
+version = "0.1.0"
+description = "Run Claude Code as a department. Unofficial; works with Claude Code."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+keywords = ["claude-code", "agents", "orchestration", "cli"]
+classifiers = [
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: MacOS",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3",
+]
+
+[project.scripts]
+delphi-team = "delphi_team._shim:main"
+delphi = "delphi_team._shim:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/delphi_team"]
+# Without this, hatchling's VCS-aware file selection silently drops the gitignored binary.
+artifacts = ["src/delphi_team/bin/*"]
+
+[tool.hatch.build.targets.wheel.hooks.custom]
+path = "hatch_build.py"

delphi_team-0.1.0/src/delphi_team/__init__.py

@@ -0,0 +1,7 @@
+"""Thin Python distribution for the delphi-team CLI.
+
+All logic lives in the TypeScript core; this package only carries a compiled binary and
+hands control to it. See docs/spec/PACKAGING_SPEC.md section 1.
+"""
+
+__version__ = "0.1.0"

delphi_team-0.1.0/src/delphi_team/__main__.py

@@ -0,0 +1,3 @@
+from delphi_team._shim import main
+
+main()

delphi_team-0.1.0/src/delphi_team/_shim.py

@@ -0,0 +1,78 @@
+"""Hand argv, stdin, stdout, stderr and the exit code to the bundled delphi binary.
+
+On POSIX the process is replaced outright, so streams and signals are inherited and the
+exit code is the binary's own. Windows has no real ``execv``, so the binary is run as a
+child and its return code is propagated.
+
+There is deliberately no fallback to ``npx`` (ADR-0005): it would reintroduce a Node
+requirement for exactly the pip and uv users these wheels exist to serve. A platform with
+no binary gets a clear message instead of a silent download.
+"""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+_BIN_DIR = Path(__file__).resolve().parent / "bin"
+
+
+def binary_path() -> Path:
+    """Where the compiled CLI lives inside the installed wheel."""
+    return _BIN_DIR / ("delphi.exe" if os.name == "nt" else "delphi")
+
+
+def _machine() -> str:
+    if hasattr(os, "uname"):
+        return os.uname().machine
+    return os.environ.get("PROCESSOR_ARCHITECTURE", "unknown")
+
+
+def _missing_binary_message(exe: Path) -> str:
+    return (
+        f"delphi-team has no compiled binary for this platform "
+        f"({sys.platform}, {_machine()}).\n"
+        f"Expected it at: {exe}\n\n"
+        "Install the Node distribution instead:\n"
+        "    npm install -g delphi-team\n\n"
+        "If you believe this platform should be supported, please open an issue."
+    )
+
+
+def _unrunnable_binary_message(exe: Path, error: OSError) -> str:
+    return (
+        f"delphi-team found its binary but could not run it: {error}\n"
+        f"    {exe}\n\n"
+        "The file is usually not executable, or the install is incomplete. Try reinstalling:\n"
+        "    pipx reinstall delphi-team\n\n"
+        "Or use the Node distribution instead:\n"
+        "    npm install -g delphi-team"
+    )
+
+
+def _fail(message: str) -> "NoReturn":  # noqa: F821 - quoted so Python 3.9 needs no import
+    sys.stderr.write(message + "\n")
+    raise SystemExit(1)
+
+
+def main() -> None:
+    exe = binary_path()
+    if not exe.is_file():
+        _fail(_missing_binary_message(exe))
+
+    args = [str(exe), *sys.argv[1:]]
+    try:
+        if os.name == "nt":
+            # Windows has no execv that replaces the process, so run the binary as a child.
+            raise SystemExit(subprocess.run(args).returncode)
+        sys.stdout.flush()
+        sys.stderr.flush()
+        os.execv(str(exe), args)
+    except KeyboardInterrupt:
+        # On Windows the console delivers Ctrl+C to both processes; without this the child
+        # exits cleanly and the parent then dies with a traceback. 130 is the shell convention.
+        raise SystemExit(130) from None
+    except OSError as error:
+        # A present but unrunnable binary: no execute bit, wrong architecture, truncated file.
+        # Report it the way the missing case is reported rather than raising a traceback.
+        _fail(_unrunnable_binary_message(exe, error))

delphi_team-0.1.0/test_shim.py

@@ -0,0 +1,97 @@
+"""Self-check for the delphi-team shim. Run it directly: `python python/test_shim.py`.
+
+Plain asserts, no test framework — the Python side is a shim, not a codebase, and a
+dependency here would have to be installed on every runner just to check three branches.
+"""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent / "src"))
+
+from delphi_team import _shim  # noqa: E402
+
+
+def _run_main(tmp_bin: Path, monkey_argv=("delphi",)):
+    """Call main() with the shim pointed at tmp_bin, returning (exit_code, stderr)."""
+    original_binary_path = _shim.binary_path
+    original_argv = sys.argv
+    original_stderr = sys.stderr
+
+    class Capture:
+        def __init__(self):
+            self.text = ""
+
+        def write(self, s):
+            self.text += s
+
+        def flush(self):
+            pass
+
+    captured = Capture()
+    _shim.binary_path = lambda: tmp_bin
+    sys.argv = list(monkey_argv)
+    sys.stderr = captured
+    try:
+        _shim.main()
+    except SystemExit as exc:
+        return exc.code, captured.text
+    finally:
+        _shim.binary_path = original_binary_path
+        sys.argv = original_argv
+        sys.stderr = original_stderr
+    raise AssertionError("main() returned instead of exiting")
+
+
+def test_missing_binary_refuses_loudly(tmp: Path):
+    """ADR-0005: no npx fallback. A platform with no binary gets an install hint."""
+    code, err = _run_main(tmp / "nope")
+    assert code == 1, code
+    assert "no compiled binary for this platform" in err, err
+    assert "npm install -g delphi-team" in err, err
+    assert "npx" not in err, "the shim must not suggest or use npx"
+
+
+def test_unrunnable_binary_reports_instead_of_crashing(tmp: Path):
+    """A present-but-unrunnable binary must not surface as a traceback."""
+    if os.name == "nt":
+        # Windows has no execute bit; an empty .exe is rejected by CreateProcess instead.
+        fake = tmp / "delphi.exe"
+    else:
+        fake = tmp / "delphi"
+    fake.write_bytes(b"not an executable")
+    if os.name != "nt":
+        fake.chmod(0o644)
+
+    code, err = _run_main(fake)
+    assert code == 1, code
+    assert "could not run it" in err, err
+    assert "pipx reinstall delphi-team" in err, err
+
+
+def test_real_binary_passes_through_argv_and_exit_code():
+    """The happy path, using this Python interpreter as a stand-in for the compiled CLI."""
+    script = "import sys; sys.stdout.write(' '.join(sys.argv[1:])); sys.exit(7)"
+    result = subprocess.run(
+        [sys.executable, "-c", script, "alpha", "beta"], capture_output=True, text=True
+    )
+    assert result.stdout == "alpha beta", result.stdout
+    assert result.returncode == 7, result.returncode
+
+
+def main():
+    import tempfile
+
+    tmp = Path(tempfile.mkdtemp())
+    for name, fn in sorted(globals().items()):
+        if not name.startswith("test_"):
+            continue
+        fn(tmp) if fn.__code__.co_argcount else fn()
+        print(f"ok  {name}")
+    print("\nall shim checks passed")
+
+
+if __name__ == "__main__":
+    main()