supervis 0.1.0__tar.gz

supervis-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 supervis contributors
+
+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.

supervis-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: supervis
+Version: 0.1.0
+Summary: DeepSeek supervisor for Claude Code
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/supervis
+Project-URL: Issues, https://github.com/yourname/supervis/issues
+Keywords: claude,deepseek,ai,coding,agent,llm
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=2.0.0
+Dynamic: license-file
+
+# supervis
+
+DeepSeek reads your codebase and drives Claude Code so you don't have to babysit every prompt.
+
+## What it does
+
+- Explores the project before writing a single line
+- Sends precise, context-aware prompts to Claude Code
+- Reviews the diff, fixes mistakes, continues on its own
+- Only asks you for real decisions (architecture, trade-offs)
+- Queues your messages while it works, type anytime, nothing is lost
+
+## Install
+
+```bash
+pipx install supervis
+```
+
+Requires [Claude Code](https://docs.anthropic.com/en/docs/claude-code) and a [DeepSeek API key](https://platform.deepseek.com/api-keys).
+
+## Usage
+
+```bash
+cd myproject
+supervis
+```
+
+```
+You: add JWT authentication
+
+→ DeepSeek reads the codebase
+→ Claude Code writes the implementation
+→ DeepSeek checks the diff, corrects if needed
+→ "Done. Added verify_token() in auth/tokens.py, middleware in auth/middleware.py."
+
+You: actually make it session-based    ← typed while agent was working, queued automatically
+```
+
+## Controls
+
+| Key | Action |
+|-----|--------|
+| `ESC` or `Ctrl+C` | Interrupt agent, return to prompt |
+| `Ctrl+C` (idle) × 2 | Exit |
+| `exit` | Exit |
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/reset` | Reset Claude session and conversation history |
+| `/help` | Show available commands |
+
+## API Key
+
+First run will prompt you if no key is set:
+
+```
+No DeepSeek API key found.
+Get one at: https://platform.deepseek.com/api-keys
+
+Enter your API key: sk-...
+Saved to ~/.config/supervis/config
+```
+
+Or set it yourself (takes precedence):
+
+```bash
+set -Ux DEEPSEEK_API_KEY sk-...   # fish
+export DEEPSEEK_API_KEY=sk-...    # bash/zsh
+```
+
+## How it works
+
+```
+You → DeepSeek (reads files, plans) → Claude Code (writes code) → DeepSeek (verifies) → You
+```
+
+DeepSeek uses [DeepSeek V3.2](https://platform.deepseek.com) via API. Claude Code runs locally with `bypassPermissions` so it edits files without asking for each one.
+
+## Cost
+
+Shown after each response:
+
+```
+[in 12.3k  4.1k cached · out 0.8k · $0.0031]
+```
+
+DeepSeek V3.2 pricing: $0.28/1M input · $0.028/1M cached · $0.42/1M output.
+
+## License
+
+MIT

supervis-0.1.0/README.md

@@ -0,0 +1,93 @@
+# supervis
+
+DeepSeek reads your codebase and drives Claude Code so you don't have to babysit every prompt.
+
+## What it does
+
+- Explores the project before writing a single line
+- Sends precise, context-aware prompts to Claude Code
+- Reviews the diff, fixes mistakes, continues on its own
+- Only asks you for real decisions (architecture, trade-offs)
+- Queues your messages while it works, type anytime, nothing is lost
+
+## Install
+
+```bash
+pipx install supervis
+```
+
+Requires [Claude Code](https://docs.anthropic.com/en/docs/claude-code) and a [DeepSeek API key](https://platform.deepseek.com/api-keys).
+
+## Usage
+
+```bash
+cd myproject
+supervis
+```
+
+```
+You: add JWT authentication
+
+→ DeepSeek reads the codebase
+→ Claude Code writes the implementation
+→ DeepSeek checks the diff, corrects if needed
+→ "Done. Added verify_token() in auth/tokens.py, middleware in auth/middleware.py."
+
+You: actually make it session-based    ← typed while agent was working, queued automatically
+```
+
+## Controls
+
+| Key | Action |
+|-----|--------|
+| `ESC` or `Ctrl+C` | Interrupt agent, return to prompt |
+| `Ctrl+C` (idle) × 2 | Exit |
+| `exit` | Exit |
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/reset` | Reset Claude session and conversation history |
+| `/help` | Show available commands |
+
+## API Key
+
+First run will prompt you if no key is set:
+
+```
+No DeepSeek API key found.
+Get one at: https://platform.deepseek.com/api-keys
+
+Enter your API key: sk-...
+Saved to ~/.config/supervis/config
+```
+
+Or set it yourself (takes precedence):
+
+```bash
+set -Ux DEEPSEEK_API_KEY sk-...   # fish
+export DEEPSEEK_API_KEY=sk-...    # bash/zsh
+```
+
+## How it works
+
+```
+You → DeepSeek (reads files, plans) → Claude Code (writes code) → DeepSeek (verifies) → You
+```
+
+DeepSeek uses [DeepSeek V3.2](https://platform.deepseek.com) via API. Claude Code runs locally with `bypassPermissions` so it edits files without asking for each one.
+
+## Cost
+
+Shown after each response:
+
+```
+[in 12.3k  4.1k cached · out 0.8k · $0.0031]
+```
+
+DeepSeek V3.2 pricing: $0.28/1M input · $0.028/1M cached · $0.42/1M output.
+
+## License
+
+MIT

supervis-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "supervis"
+version = "0.1.0"
+description = "DeepSeek supervisor for Claude Code"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+dependencies = [
+    "openai>=2.0.0",
+]
+keywords = ["claude", "deepseek", "ai", "coding", "agent", "llm"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourname/supervis"
+Issues = "https://github.com/yourname/supervis/issues"
+
+[project.scripts]
+supervis = "supervisor.main:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["supervisor*"]

supervis-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

supervis-0.1.0/supervis.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: supervis
+Version: 0.1.0
+Summary: DeepSeek supervisor for Claude Code
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/supervis
+Project-URL: Issues, https://github.com/yourname/supervis/issues
+Keywords: claude,deepseek,ai,coding,agent,llm
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=2.0.0
+Dynamic: license-file
+
+# supervis
+
+DeepSeek reads your codebase and drives Claude Code so you don't have to babysit every prompt.
+
+## What it does
+
+- Explores the project before writing a single line
+- Sends precise, context-aware prompts to Claude Code
+- Reviews the diff, fixes mistakes, continues on its own
+- Only asks you for real decisions (architecture, trade-offs)
+- Queues your messages while it works, type anytime, nothing is lost
+
+## Install
+
+```bash
+pipx install supervis
+```
+
+Requires [Claude Code](https://docs.anthropic.com/en/docs/claude-code) and a [DeepSeek API key](https://platform.deepseek.com/api-keys).
+
+## Usage
+
+```bash
+cd myproject
+supervis
+```
+
+```
+You: add JWT authentication
+
+→ DeepSeek reads the codebase
+→ Claude Code writes the implementation
+→ DeepSeek checks the diff, corrects if needed
+→ "Done. Added verify_token() in auth/tokens.py, middleware in auth/middleware.py."
+
+You: actually make it session-based    ← typed while agent was working, queued automatically
+```
+
+## Controls
+
+| Key | Action |
+|-----|--------|
+| `ESC` or `Ctrl+C` | Interrupt agent, return to prompt |
+| `Ctrl+C` (idle) × 2 | Exit |
+| `exit` | Exit |
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/reset` | Reset Claude session and conversation history |
+| `/help` | Show available commands |
+
+## API Key
+
+First run will prompt you if no key is set:
+
+```
+No DeepSeek API key found.
+Get one at: https://platform.deepseek.com/api-keys
+
+Enter your API key: sk-...
+Saved to ~/.config/supervis/config
+```
+
+Or set it yourself (takes precedence):
+
+```bash
+set -Ux DEEPSEEK_API_KEY sk-...   # fish
+export DEEPSEEK_API_KEY=sk-...    # bash/zsh
+```
+
+## How it works
+
+```
+You → DeepSeek (reads files, plans) → Claude Code (writes code) → DeepSeek (verifies) → You
+```
+
+DeepSeek uses [DeepSeek V3.2](https://platform.deepseek.com) via API. Claude Code runs locally with `bypassPermissions` so it edits files without asking for each one.
+
+## Cost
+
+Shown after each response:
+
+```
+[in 12.3k  4.1k cached · out 0.8k · $0.0031]
+```
+
+DeepSeek V3.2 pricing: $0.28/1M input · $0.028/1M cached · $0.42/1M output.
+
+## License
+
+MIT

supervis-0.1.0/supervis.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+supervis.egg-info/PKG-INFO
+supervis.egg-info/SOURCES.txt
+supervis.egg-info/dependency_links.txt
+supervis.egg-info/entry_points.txt
+supervis.egg-info/requires.txt
+supervis.egg-info/top_level.txt
+supervisor/__init__.py
+supervisor/chat.py
+supervisor/claude.py
+supervisor/config.py
+supervisor/cost.py
+supervisor/deepseek.py
+supervisor/display.py
+supervisor/main.py
+supervisor/memory.py
+supervisor/prompts.py
+supervisor/tools.py

supervis-0.1.0/supervis.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

supervis-0.1.0/supervis.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+supervis = supervisor.main:main

supervis-0.1.0/supervis.egg-info/requires.txt

@@ -0,0 +1 @@
+openai>=2.0.0

supervis-0.1.0/supervis.egg-info/top_level.txt

@@ -0,0 +1 @@
+supervisor

supervis-0.1.0/supervisor/__init__.py

@@ -0,0 +1,3 @@
+"""DeepSeek Supervisor — Claude Code orchestrator."""
+
+__version__ = "0.1.0"

supervis-0.1.0/supervisor/chat.py

@@ -0,0 +1,255 @@
+"""Main chat loop, signal handling, input queue."""
+
+import asyncio
+import os
+import sys
+import termios
+import tty
+
+try:
+    import readline  # arrow keys + history
+except ImportError:
+    pass
+
+from .deepseek import run_agent_loop
+from .memory import summarize_if_needed
+from .prompts import SYSTEM_PROMPT
+from .display import GREEN, BOLD, DIM, YELLOW, CYAN, R, header
+from .claude import get_proc, reset_session
+from .deepseek import get_client
+from . import cost
+
+_EXIT_COMMANDS   = {"exit", "quit", "q", "çıkış"}
+_BUILTIN_COMMANDS = {"/reset", "/help"}
+
+# Sentinels
+_ESC    = "__ESC__"
+_CTRL_C = "__CTRL_C__"
+
+
+# ─── Raw stdin reader ────────────────────────────────────────────────────────
+
+def _read_line_raw() -> str:
+    """
+    Read one line in raw terminal mode.
+    Detects ESC → returns _ESC
+    Detects Ctrl+C → returns _CTRL_C
+    Handles backspace + echo manually.
+    Preserves readline history for normal lines.
+    """
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    buf: list[str] = []
+
+    try:
+        tty.setraw(fd)
+        while True:
+            b = sys.stdin.buffer.read(1)
+            if not b:
+                return ""
+
+            byte = b[0]
+
+            if byte == 0x1b:  # ESC — drain any escape sequence (arrow keys etc.)
+                sys.stdin.buffer.read(0)
+                return _ESC
+
+            if byte == 0x03:  # Ctrl+C
+                return _CTRL_C
+
+            if byte in (0x0d, 0x0a):  # Enter
+                sys.stdout.write("\r\n")
+                sys.stdout.flush()
+                line = "".join(buf)
+                if line:
+                    try:
+                        readline.add_history(line)
+                    except Exception:
+                        pass
+                return line
+
+            if byte == 0x7f:  # Backspace
+                if buf:
+                    buf.pop()
+                    sys.stdout.write("\b \b")
+                    sys.stdout.flush()
+
+            elif 32 <= byte <= 126:  # Printable ASCII
+                ch = chr(byte)
+                buf.append(ch)
+                sys.stdout.write(ch)
+                sys.stdout.flush()
+
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+
+async def _stdin_reader(queue: asyncio.Queue) -> None:
+    """Runs _read_line_raw in executor, puts results to queue."""
+    loop = asyncio.get_running_loop()
+    while True:
+        try:
+            line = await loop.run_in_executor(None, _read_line_raw)
+            await queue.put(line)
+        except (EOFError, asyncio.CancelledError):
+            break
+        except Exception:
+            break
+
+
+# ─── Helpers ─────────────────────────────────────────────────────────────────
+
+def _drain_queue(queue: asyncio.Queue) -> list[str]:
+    items = []
+    while not queue.empty():
+        try:
+            items.append(queue.get_nowait())
+        except asyncio.QueueEmpty:
+            break
+    return items
+
+
+def _handle_builtin(cmd: str, messages: list) -> tuple[list, bool]:
+    if cmd.lower() == "/reset":
+        reset_session()
+        cost.reset()
+        new_messages = [messages[0]]
+        print(f"{YELLOW}Session reset.{R}\n")
+        return new_messages, True
+
+    if cmd.lower() == "/help":
+        print(
+            f"\n{CYAN}Commands:{R}\n"
+            f"  {BOLD}/reset{R}        — reset Claude session and conversation\n"
+            f"  {BOLD}/help{R}         — show this\n"
+            f"  {BOLD}exit{R}          — quit\n"
+            f"  {BOLD}ESC{R}           — interrupt agent, return to prompt\n"
+            f"  {BOLD}Ctrl+C{R}        — interrupt agent (first) / exit (second)\n"
+            f"\n{DIM}Type anytime — messages queue while agent works.{R}\n"
+        )
+        return messages, True
+
+    return messages, False
+
+
+# ─── Main loop ───────────────────────────────────────────────────────────────
+
+async def chat_loop(project_dir: str) -> None:
+    os.chdir(project_dir)
+
+    header()
+    print(f"{DIM}Project: {project_dir}{R}")
+    print(f"{DIM}ESC / Ctrl+C = interrupt  ·  Type anytime = queue  ·  exit = quit{R}\n")
+
+    messages  = [{"role": "system", "content": SYSTEM_PROMPT}]
+    client    = get_client()
+
+    input_queue:     asyncio.Queue[str] = asyncio.Queue()
+    interrupt_event: asyncio.Event      = asyncio.Event()
+
+    reader_task = asyncio.create_task(_stdin_reader(input_queue))
+
+    _ctrl_c_idle = False  # second Ctrl+C while idle → exit
+
+    try:
+        while True:
+
+            # ── Drain queue (typed while agent ran) ──────────────────────────
+            queued = _drain_queue(input_queue)
+
+            # Filter interrupts that came in during agent run
+            interrupts = [m for m in queued if m in (_ESC, _CTRL_C)]
+            queued     = [m for m in queued if m not in (_ESC, _CTRL_C)]
+
+            if queued:
+                for msg in queued:
+                    print(f"\n{YELLOW}[Queued]{R} {msg}")
+
+                if any(m.lower() in _EXIT_COMMANDS for m in queued):
+                    print(f"\n{DIM}Goodbye.{R}\n")
+                    break
+
+                for msg in queued:
+                    if msg in _BUILTIN_COMMANDS:
+                        messages, _ = _handle_builtin(msg, messages)
+
+                real = [
+                    m for m in queued
+                    if m not in _BUILTIN_COMMANDS and m.lower() not in _EXIT_COMMANDS
+                ]
+                if real:
+                    combined = "\n".join(real)
+                    messages.append({"role": "user", "content": combined})
+                    messages = await summarize_if_needed(messages, client)
+                    interrupt_event.clear()
+                    messages = await run_agent_loop(messages, interrupt_event)
+                    print()
+                    continue
+
+            # ── Normal prompt ─────────────────────────────────────────────────
+            _ctrl_c_idle = False
+            interrupt_event.clear()
+
+            print(f"{GREEN}{BOLD}You:{R} ", end="", flush=True)
+            try:
+                user_input = await input_queue.get()
+            except asyncio.CancelledError:
+                print(f"\n{DIM}Goodbye.{R}\n")
+                break
+
+            # Handle ESC / Ctrl+C at idle
+            if user_input in (_ESC, _CTRL_C):
+                if _ctrl_c_idle or user_input == _ESC:
+                    print(f"\n{DIM}Goodbye.{R}\n")
+                    break
+                print(f"\n{YELLOW}(Press Ctrl+C again or type 'exit' to quit){R}\n")
+                _ctrl_c_idle = True
+                continue
+
+            _ctrl_c_idle = False
+
+            if not user_input:
+                continue
+
+            if user_input.lower() in _EXIT_COMMANDS:
+                print(f"\n{DIM}Goodbye.{R}\n")
+                break
+
+            messages, handled = _handle_builtin(user_input, messages)
+            if handled:
+                continue
+
+            messages.append({"role": "user", "content": user_input})
+            messages = await summarize_if_needed(messages, client)
+            interrupt_event.clear()
+
+            # ── Agent loop — watch for interrupt ─────────────────────────────
+            agent_task = asyncio.create_task(
+                run_agent_loop(messages, interrupt_event)
+            )
+
+            # While agent runs, watch for ESC / Ctrl+C from queue
+            async def _watch_interrupt() -> None:
+                while not agent_task.done():
+                    item = await input_queue.get()
+                    if item in (_ESC, _CTRL_C):
+                        interrupt_event.set()
+                        proc = get_proc()
+                        if proc and proc.returncode is None:
+                            proc.terminate()
+                        print(f"\n{YELLOW}[Interrupted]{R}", flush=True)
+                        return
+                    else:
+                        # Re-queue non-interrupt messages
+                        await input_queue.put(item)
+
+            watcher = asyncio.create_task(_watch_interrupt())
+            try:
+                messages = await agent_task
+            finally:
+                watcher.cancel()
+
+            print()
+
+    finally:
+        reader_task.cancel()

supervis-0.1.0/supervisor/claude.py

@@ -0,0 +1,86 @@
+"""Claude Code subprocess management."""
+
+import asyncio
+import json
+import os
+from .display import BLUE, BOLD, DIM, R
+
+_claude_proc: asyncio.subprocess.Process | None = None
+_claude_first = True
+
+
+def get_proc() -> asyncio.subprocess.Process | None:
+    return _claude_proc
+
+
+def reset_session() -> None:
+    """Taze Claude session'ı için state sıfırla."""
+    global _claude_first
+    _claude_first = True
+
+
+async def run_claude(prompt: str, continue_session: bool = True) -> str:
+    global _claude_proc, _claude_first
+
+    print(f"\n{BLUE}{BOLD}┌─ Claude Code ──────────────────────────────────────────{R}")
+    print(f"{BLUE}{DIM}{prompt}{R}\n")
+
+    cmd = [
+        "claude", "-p", prompt,
+        "--output-format", "stream-json",
+        "--verbose",
+        "--permission-mode", "bypassPermissions",
+    ]
+    if continue_session and not _claude_first:
+        cmd.append("--continue")
+    _claude_first = False
+
+    proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        cwd=os.getcwd(),
+        limit=1024 * 1024 * 10,
+    )
+    _claude_proc = proc
+
+    chunks: list[str] = []
+    try:
+        async for raw in proc.stdout:
+            line = raw.decode("utf-8", errors="replace").strip()
+            if not line:
+                continue
+            try:
+                data = json.loads(line)
+                t = data.get("type", "")
+
+                if t == "assistant":
+                    for block in data.get("message", {}).get("content", []):
+                        if not isinstance(block, dict):
+                            continue
+                        if block.get("type") == "text":
+                            txt = block["text"]
+                            print(f"{BLUE}{txt}{R}", end="", flush=True)
+                            chunks.append(txt)
+                        elif block.get("type") == "tool_use":
+                            name = block.get("name", "")
+                            inp = block.get("input", {})
+                            hint = (
+                                inp.get("path")
+                                or inp.get("command", "")
+                                or inp.get("description", "")
+                            )[:60]
+                            print(f"\n{DIM}  ↳ {name}: {hint}{R}", flush=True)
+
+            except json.JSONDecodeError:
+                pass
+
+    except asyncio.CancelledError:
+        proc.terminate()
+        raise
+    finally:
+        _claude_proc = None
+
+    await proc.wait()
+    print(f"\n{BLUE}{BOLD}└────────────────────────────────────────────────────────{R}\n")
+    return "\n".join(chunks) or "(no output)"

supervis-0.1.0/supervisor/config.py

@@ -0,0 +1,52 @@
+"""API key resolution: env var → config file → interactive prompt."""
+
+import os
+from pathlib import Path
+
+_CONFIG_DIR  = Path.home() / ".config" / "supervis"
+_CONFIG_FILE = _CONFIG_DIR / "config"
+
+
+def _read_saved() -> str | None:
+    try:
+        for line in _CONFIG_FILE.read_text().splitlines():
+            if line.startswith("DEEPSEEK_API_KEY="):
+                return line.split("=", 1)[1].strip()
+    except FileNotFoundError:
+        pass
+    return None
+
+
+def _save(key: str) -> None:
+    _CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    _CONFIG_FILE.write_text(f"DEEPSEEK_API_KEY={key}\n")
+    _CONFIG_FILE.chmod(0o600)  # owner read/write only
+
+
+def get_api_key() -> str:
+    # 1. Environment variable (takes precedence)
+    key = os.environ.get("DEEPSEEK_API_KEY", "").strip()
+    if key:
+        return key
+
+    # 2. Saved config file
+    key = _read_saved()
+    if key:
+        return key
+
+    # 3. Interactive prompt — first run
+    print("\nNo DeepSeek API key found.")
+    print("Get one at: https://platform.deepseek.com/api-keys\n")
+    try:
+        key = input("Enter your API key: ").strip()
+    except (EOFError, KeyboardInterrupt):
+        print("\nCancelled.")
+        raise SystemExit(1)
+
+    if not key:
+        print("No key entered. Exiting.")
+        raise SystemExit(1)
+
+    _save(key)
+    print(f"Saved to {_CONFIG_FILE}\n")
+    return key

supervis-0.1.0/supervisor/cost.py

@@ -0,0 +1,44 @@
+"""Session token and cost tracking."""
+
+# DeepSeek V3.2 pricing (per 1M tokens) — updated March 2026
+_PRICE_INPUT        = 0.28   # cache miss
+_PRICE_INPUT_CACHED = 0.028  # cache hit (90% off)
+_PRICE_OUTPUT       = 0.42
+
+_session_input         = 0
+_session_input_cached  = 0
+_session_output        = 0
+
+
+def record(input_tokens: int, output_tokens: int, cached_tokens: int = 0) -> None:
+    global _session_input, _session_input_cached, _session_output
+    _session_input         += input_tokens - cached_tokens
+    _session_input_cached  += cached_tokens
+    _session_output        += output_tokens
+
+
+def session_cost() -> float:
+    return (
+        _session_input         / 1_000_000 * _PRICE_INPUT +
+        _session_input_cached  / 1_000_000 * _PRICE_INPUT_CACHED +
+        _session_output        / 1_000_000 * _PRICE_OUTPUT
+    )
+
+
+def summary() -> str:
+    total_in  = _session_input + _session_input_cached
+    cached    = _session_input_cached
+    out       = _session_output
+    cost      = session_cost()
+
+    cached_note = f"  {cached/1000:.1f}k cached" if cached else ""
+    return (
+        f"in {total_in/1000:.1f}k{cached_note} · "
+        f"out {out/1000:.1f}k · "
+        f"${cost:.4f}"
+    )
+
+
+def reset() -> None:
+    global _session_input, _session_input_cached, _session_output
+    _session_input = _session_input_cached = _session_output = 0

supervis-0.1.0/supervisor/deepseek.py

@@ -0,0 +1,130 @@
+"""DeepSeek API client and streaming helper."""
+
+import asyncio
+import json
+from openai import AsyncOpenAI
+from .config import get_api_key
+from .tools import TOOLS, execute_tool
+from .display import CYAN, BOLD, DIM, R
+from . import cost
+
+_client: AsyncOpenAI | None = None
+
+
+def get_client() -> AsyncOpenAI:
+    global _client
+    if _client is None:
+        _client = AsyncOpenAI(api_key=get_api_key(), base_url="https://api.deepseek.com")
+    return _client
+
+
+async def stream_turn(messages: list) -> tuple[str, list]:
+    """
+    Send messages to DeepSeek, stream response.
+    Returns (content, tool_calls).
+    """
+    client = get_client()
+
+    print(f"\n{CYAN}{BOLD}DeepSeek:{R} ", end="", flush=True)
+
+    response = await client.chat.completions.create(
+        model="deepseek-chat",
+        messages=messages,
+        tools=TOOLS,
+        tool_choice="auto",
+        stream=True,
+        stream_options={"include_usage": True},
+        temperature=0.2,
+    )
+
+    content = ""
+    tc_raw: dict[int, dict] = {}
+
+    async for chunk in response:
+        # Track usage from final chunk
+        if chunk.usage:
+            u = chunk.usage
+            cached = getattr(u.prompt_tokens_details, "cached_tokens", 0) or 0
+            cost.record(u.prompt_tokens, u.completion_tokens, cached)
+            print(f" {DIM}[{cost.summary()}]{R}", flush=True)
+
+        choice = chunk.choices[0] if chunk.choices else None
+        if not choice:
+            continue
+        delta = choice.delta
+
+        if delta.content:
+            print(f"{CYAN}{delta.content}{R}", end="", flush=True)
+            content += delta.content
+
+        if delta.tool_calls:
+            for tc in delta.tool_calls:
+                i = tc.index
+                if i not in tc_raw:
+                    tc_raw[i] = {"id": "", "name": "", "arguments": ""}
+                if tc.id:
+                    tc_raw[i]["id"] = tc.id
+                if tc.function:
+                    if tc.function.name:
+                        tc_raw[i]["name"] = tc.function.name
+                    if tc.function.arguments:
+                        tc_raw[i]["arguments"] += tc.function.arguments
+
+    if content:
+        print()
+
+    tool_calls = list(tc_raw.values())
+    return content, tool_calls
+
+
+async def run_agent_loop(messages: list, interrupt_event: asyncio.Event | None = None) -> list:
+    """
+    Agentic loop: keep calling DeepSeek + executing tools until
+    DeepSeek stops making tool calls or produces a user-facing response.
+    Returns updated messages list.
+    """
+    while True:
+        content, tool_calls = await stream_turn(messages)
+
+        # DeepSeek spoke AND wants to call tools → return to user first
+        if content and tool_calls:
+            messages.append({"role": "assistant", "content": content})
+            break
+
+        messages.append({
+            "role": "assistant",
+            "content": content or None,
+            "tool_calls": [
+                {
+                    "id": tc["id"],
+                    "type": "function",
+                    "function": {"name": tc["name"], "arguments": tc["arguments"]},
+                }
+                for tc in tool_calls
+            ] if tool_calls else None,
+        })
+
+        # No tool calls → DeepSeek is done, return to user
+        if not tool_calls:
+            break
+
+        # Check for interrupt before executing tools
+        if interrupt_event and interrupt_event.is_set():
+            break
+
+        # Execute tools, append results, loop
+        print()
+        for tc in tool_calls:
+            try:
+                args = json.loads(tc["arguments"]) if tc["arguments"] else {}
+            except json.JSONDecodeError:
+                args = {}
+
+            result = await execute_tool(tc["name"], args)
+            messages.append({
+                "role": "tool",
+                "tool_call_id": tc["id"],
+                "content": str(result),
+            })
+
+    return messages

supervis-0.1.0/supervisor/display.py

@@ -0,0 +1,26 @@
+"""Terminal display helpers — colors, banners, tags."""
+
+R       = "\033[0m"
+CYAN    = "\033[36m"
+YELLOW  = "\033[33m"
+GREEN   = "\033[32m"
+BLUE    = "\033[34m"
+MAGENTA = "\033[35m"
+BOLD    = "\033[1m"
+DIM     = "\033[2m"
+
+
+def banner(text: str, color: str = CYAN) -> None:
+    print(f"\n{color}{BOLD}{'─' * 60}{R}")
+    print(f"{color}{BOLD}  {text}{R}")
+    print(f"{color}{BOLD}{'─' * 60}{R}", flush=True)
+
+
+def header() -> None:
+    print(f"\n{CYAN}{BOLD}╔══════════════════════════════════════════════════════╗{R}")
+    print(f"{CYAN}{BOLD}║          DeepSeek Supervisor × Claude Code           ║{R}")
+    print(f"{CYAN}{BOLD}╚══════════════════════════════════════════════════════╝{R}")
+
+
+def tool_tag(label: str) -> None:
+    print(f"{MAGENTA}{DIM}[{label}]{R} ", flush=True)

supervis-0.1.0/supervisor/main.py

@@ -0,0 +1,28 @@
+"""CLI entry point."""
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+
+def main() -> None:
+    import readline  # noqa: F401 — enables arrow keys + history in input()
+
+    project_dir = sys.argv[1] if len(sys.argv) > 1 else os.getcwd()
+    project_dir = str(Path(project_dir).resolve())
+
+    if not Path(project_dir).is_dir():
+        print(f"Directory not found: {project_dir}")
+        sys.exit(1)
+
+    from .chat import chat_loop
+
+    try:
+        asyncio.run(chat_loop(project_dir))
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

supervis-0.1.0/supervisor/memory.py

@@ -0,0 +1,47 @@
+"""Conversation history management and summarization."""
+
+from openai import AsyncOpenAI
+
+
+async def summarize_if_needed(
+    messages: list,
+    client: AsyncOpenAI,
+    threshold: int = 20,
+) -> list:
+    """When history exceeds threshold, summarize older messages to save tokens."""
+    user_msgs = [m for m in messages if m["role"] != "system"]
+    if len(user_msgs) <= threshold:
+        return messages
+
+    to_summarize = messages[1:-8]
+    if not to_summarize:
+        return messages
+
+    print("\n\033[2m[Summarizing conversation history...]\033[0m", flush=True)
+    try:
+        resp = await client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[
+                {
+                    "role": "system",
+                    "content": (
+                        "Summarize this conversation history concisely. "
+                        "Preserve key decisions, code changes made, file names, and important context. "
+                        "Be brief."
+                    ),
+                },
+                {
+                    "role": "user",
+                    "content": str(to_summarize)[:8000],
+                },
+            ],
+            max_tokens=600,
+        )
+        summary = resp.choices[0].message.content
+        return [
+            messages[0],
+            {"role": "assistant", "content": f"[Session summary: {summary}]"},
+            *messages[-8:],
+        ]
+    except Exception:
+        return messages

supervis-0.1.0/supervisor/prompts.py

@@ -0,0 +1,28 @@
+"""System prompts."""
+
+SYSTEM_PROMPT = """You are a senior software architect and technical lead. You supervise Claude Code, an AI coding assistant that reads, writes, and executes code autonomously.
+
+## Your role
+Help the user with their software projects through natural conversation. Use Claude Code as your implementation arm — you plan and verify, Claude Code executes.
+
+## Workflow
+1. Understand the user's request. Ask ONE clarifying question only if the goal is genuinely ambiguous.
+2. Explore the codebase before touching anything (read_file, list_files, search_code).
+3. Write precise, detailed prompts for Claude Code — include exact file names, function signatures, requirements, and acceptance criteria.
+4. After Claude Code runs, verify with get_git_status and read changed files.
+5. If something went wrong, correct course immediately with a follow-up prompt to Claude Code.
+6. Report back to the user with a concise summary of what changed.
+
+## Decision making
+- Make small decisions yourself (naming, structure, patterns) — don't ask the user.
+- Only surface genuine architectural trade-offs (e.g. "JWT vs session-based auth?") where the user's preference matters.
+- If the user changes direction mid-task, adapt immediately without complaint.
+
+## Claude Code prompts
+Be specific and complete. Example:
+  "In src/auth/middleware.py, add a function `require_auth(f)` decorator that checks for a valid JWT in the Authorization header. Use the existing `verify_token()` from src/auth/tokens.py. Return 401 JSON on failure."
+
+## Language
+- Detect the user's language from their message and always reply in that same language.
+- If the user writes in Turkish, respond in Turkish. If English, respond in English. Follow their lead on every message.
+- Keep responses concise. Lead with action, not explanation."""

supervis-0.1.0/supervisor/tools.py

@@ -0,0 +1,181 @@
+"""Tool definitions and implementations for DeepSeek."""
+
+import glob as _glob
+import subprocess
+from pathlib import Path
+from .claude import run_claude
+from .display import MAGENTA, DIM, R
+
+# ─── Definitions ─────────────────────────────────────────────────────────────
+
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": "Read a file's contents from the project.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "Relative or absolute file path"}
+                },
+                "required": ["path"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "list_files",
+            "description": "List files matching a glob pattern. Example: 'src/**/*.py'",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "pattern": {"type": "string"}
+                },
+                "required": ["pattern"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "search_code",
+            "description": "Search for a text pattern in the codebase (grep).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "pattern": {"type": "string"},
+                    "path": {"type": "string", "default": "."},
+                },
+                "required": ["pattern"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "run_shell",
+            "description": "Run a read-only shell command (ls, git log, cat, etc.).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string"}
+                },
+                "required": ["command"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_git_status",
+            "description": "Get git status and diff to see what Claude Code changed.",
+            "parameters": {"type": "object", "properties": {}},
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "run_claude",
+            "description": (
+                "Send a task to Claude Code. It will write/edit/run files autonomously. "
+                "Be specific: include file names, function signatures, and acceptance criteria."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "prompt": {"type": "string"},
+                    "continue_session": {
+                        "type": "boolean",
+                        "description": "True to continue previous Claude session (keeps context).",
+                        "default": True,
+                    },
+                },
+                "required": ["prompt"],
+            },
+        },
+    },
+]
+
+# ─── Implementations ─────────────────────────────────────────────────────────
+
+_SKIP = {".git/", "__pycache__", "node_modules", ".venv"}
+
+
+def _read_file(path: str) -> str:
+    try:
+        content = Path(path).read_text(encoding="utf-8")
+        lines = content.splitlines()
+        if len(lines) > 300:
+            return "\n".join(lines[:300]) + f"\n... ({len(lines)} lines total)"
+        return content
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _list_files(pattern: str) -> str:
+    files = _glob.glob(pattern, recursive=True)
+    files = [f for f in files if not any(s in f for s in _SKIP)]
+    return "\n".join(sorted(files)[:100]) if files else "No files found."
+
+
+def _search_code(pattern: str, path: str = ".") -> str:
+    try:
+        result = subprocess.run(
+            ["grep", "-r", "-n", pattern, path],
+            capture_output=True, text=True, timeout=10,
+        )
+        lines = [l for l in result.stdout.splitlines() if not any(s in l for s in _SKIP)]
+        return "\n".join(lines[:80]) if lines else "No matches."
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _run_shell(command: str) -> str:
+    try:
+        result = subprocess.run(
+            command, shell=True, capture_output=True, text=True, timeout=15
+        )
+        out = (result.stdout + result.stderr).strip()
+        return out[:3000] if out else "(no output)"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+def _get_git_status() -> str:
+    status = _run_shell("git status --short")
+    diff   = _run_shell("git diff --stat HEAD 2>/dev/null || git diff --stat")
+    log    = _run_shell("git log --oneline -5 2>/dev/null || echo 'no git log'")
+    return f"=== Status ===\n{status}\n\n=== Diff ===\n{diff}\n\n=== Recent commits ===\n{log}"
+
+
+# ─── Dispatcher ──────────────────────────────────────────────────────────────
+
+async def execute_tool(name: str, args: dict) -> str:
+    labels = {
+        "read_file":     f"📄 {args.get('path', '')}",
+        "list_files":    f"📁 {args.get('pattern', '')}",
+        "search_code":   f"🔍 '{args.get('pattern', '')}'",
+        "run_shell":     f"$ {args.get('command', '')[:50]}",
+        "get_git_status": "git status",
+        "run_claude":    "→ Claude Code",
+    }
+    if name != "run_claude":
+        print(f"{MAGENTA}{DIM}[{labels.get(name, name)}]{R}", flush=True)
+
+    match name:
+        case "read_file":
+            return _read_file(args["path"])
+        case "list_files":
+            return _list_files(args["pattern"])
+        case "search_code":
+            return _search_code(args["pattern"], args.get("path", "."))
+        case "run_shell":
+            return _run_shell(args["command"])
+        case "get_git_status":
+            return _get_git_status()
+        case "run_claude":
+            return await run_claude(args["prompt"], args.get("continue_session", True))
+        case _:
+            return f"Unknown tool: {name}"