claudetan 1.0.0__tar.gz

claudetan-1.0.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.3
+Name: claudetan
+Version: 1.0.0
+Summary: Voice-driven Claude Code assistant with an anime avatar overlay
+Keywords: claude,claude-code,voice-assistant,avatar,overlay,whisper,pyside6
+Author: Stoupy51
+Author-email: Stoupy51 <stoupy51@gmail.com>
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Typing :: Typed
+Requires-Dist: faster-whisper>=1.2
+Requires-Dist: numpy
+Requires-Dist: pyside6>=6.9
+Requires-Dist: pyte>=0.8.2
+Requires-Dist: pywinpty>=2.0
+Requires-Dist: sounddevice
+Requires-Dist: soundfile
+Requires-Dist: stouputils>=26.10.1
+Requires-Python: >=3.14
+Project-URL: Issues, https://github.com/Stoupy51/ClaudeTan/issues
+Project-URL: Repository, https://github.com/Stoupy51/ClaudeTan

claudetan-1.0.0/claudetan/__main__.py

@@ -0,0 +1,4 @@
+from claudetan.app import main
+
+main()
+

claudetan-1.0.0/claudetan/app.py

@@ -0,0 +1,310 @@
+""" ClaudeTan: Claude-tan reacting to what she hears and to the hidden Claude Code session, through its hook events. """
+# Imports
+import logging
+import signal
+import subprocess
+import sys
+import threading
+from collections import deque
+from pathlib import Path
+from urllib.parse import urlparse
+
+import stouputils as stp
+from PySide6.QtCore import QObject, QPoint, QTimer, Signal
+from PySide6.QtNetwork import QLocalServer, QLocalSocket
+from PySide6.QtWidgets import QApplication
+
+from claudetan.avatar import Avatar, Pill, chime, shorten
+from claudetan.config import APP_DATA, LOG_FILE, Config
+from claudetan.console import enable_colors
+from claudetan.session import HookServer, JsonDict, Session
+from claudetan.tray import Tray
+from claudetan.voice import FOLLOW_UP_S, Listener, microphone
+
+# Constants
+LOG: logging.Logger = logging.getLogger("claudetan")
+""" The app's own log, kept at INFO while the libraries stay at WARNING. """
+WAKE_NOTES: tuple[float, ...] = (880.0, 1318.5)
+DONE_NOTES: tuple[float, ...] = (1046.5, 1318.5, 1568.0)
+LONG_TASK_MS: int = 20_000
+""" How long a turn runs before she shrinks to the pill. """
+HEARD_MS: int = 4000
+""" How long the sentence she understood stays up when the session does not start on it right away. """
+STARTUP_S: float = 60.0
+""" How long the session and Whisper may take to start before the app reports them as failed. """
+INSTANCE_NAME: str = "ClaudeTan"
+""" Local server of the running app: a new one connects to it to have it quit. """
+READY: str = "ready\n"
+""" Last line the background app writes to `main`, which returns on it: the venv's launcher keeps the pipe open after it. """
+
+
+# Classes
+class Assistant(QObject):
+	""" What Claude-tan shows at each step of a request, and when the next command may be typed into the session. """
+	send = Signal(str)
+	""" A command to type, emitted only between turns: keys typed while a dialog is open would answer it. """
+
+	def __init__(self, avatar: Avatar, pill: Pill) -> None:
+		super().__init__()
+		self.avatar = avatar
+		self.pill = pill
+		self.commands: deque[str] = deque()
+		self.busy = False
+		self.agents: set[str] = set()
+		self.asking = False
+		self.worked = False
+		""" Whether the turn used a tool, which makes her present the result rather than smile. """
+		self.activity = ""
+		self.message_id = ""
+		self.message = ""
+
+		self.long_task = QTimer(self)
+		self.long_task.setSingleShot(True)
+		self.long_task.setInterval(LONG_TASK_MS)
+		self.long_task.timeout.connect(self.shrink)
+		self.dismiss = QTimer(self)
+		self.dismiss.setSingleShot(True)
+		self.dismiss.timeout.connect(self.leave)
+
+	def on_wake(self) -> None:
+		chime(*WAKE_NOTES)
+		self.appear("hello", bubble="Oui ?")
+		self.dismiss.start(round(FOLLOW_UP_S * 1000))
+
+	def on_command(self, text: str) -> None:
+		LOG.info("Heard: %s", text)
+		self.appear("idle", bubble=f"« {text} »" + (" Je m'en occupe juste après." if self.busy else ""))
+		self.dismiss.start(HEARD_MS)
+		self.commands.append(text)
+		self.flush()
+
+	def on_hook(self, event: JsonDict) -> None:
+		match event["hook_event_name"]:
+			case "UserPromptSubmit":
+				self.on_prompt(event["prompt"])
+			case "PreToolUse":
+				self.on_tool(describe_tool(event["tool_name"], event["tool_input"]))
+			case "PostToolUse" if self.asking:
+				self.settle_permission()
+				self.appear("thanks", bubble="Merci !")
+			case "PermissionRequest":
+				self.on_permission(describe_tool(event["tool_name"], event["tool_input"]))
+			case "Notification" if event["notification_type"] == "permission_prompt":
+				self.on_permission(event["message"])
+			case "MessageDisplay":
+				self.on_text(event["message_id"], event["delta"], streaming=not event["final"])
+			case "SubagentStart":
+				self.agents.add(event["agent_id"])
+				self.shrink()
+			case "SubagentStop":
+				self.agents.discard(event["agent_id"])
+			case "Stop":
+				self.on_stop(event["last_assistant_message"])
+			case "StopFailure":
+				self.on_failure(event["error"])
+			case _:
+				pass
+
+	def on_prompt(self, prompt: str) -> None:
+		""" A turn starts, typed by the app, sent from the Remote Control, or started by Claude Code itself. """
+		LOG.info("Prompt: %s", prompt)
+		self.busy = True
+		self.worked = False
+		self.activity = ""
+		self.dismiss.stop()
+		self.long_task.start()
+		if not self.pill.isVisible():
+			self.appear("point", bubble=prompt)
+
+	def on_tool(self, activity: str) -> None:
+		LOG.info("Action: %s", activity)
+		self.worked = True
+		self.settle_permission()
+		if activity != self.activity and not self.pill.isVisible():
+			self.activity = activity
+			self.appear("point", bubble=activity)
+
+	def on_permission(self, request: str) -> None:
+		if self.asking:
+			return
+		LOG.info("Permission asked: %s", request)
+		self.asking = True
+		self.long_task.stop()
+		self.appear("please", bubble=f"J'ai besoin de ton accord : {request}. Clique sur moi pour répondre.")
+
+	def settle_permission(self) -> None:
+		""" Closes a pending permission prompt, allowed or not, and restarts the countdown to the pill. """
+		if self.asking:
+			self.asking = False
+			self.long_task.start()
+
+	def on_text(self, message_id: str, delta: str, *, streaming: bool) -> None:
+		self.message = self.message + delta if message_id == self.message_id else delta
+		self.message_id = message_id
+		if not self.pill.isVisible():
+			self.appear("idle", bubble=self.message, talking=streaming)
+
+	def on_stop(self, reply: str) -> None:
+		LOG.info("Reply: %s", reply)
+		self.end_turn()
+		if not self.agents:
+			chime(*DONE_NOTES)
+		self.appear("present" if self.worked else "happy", bubble=reply)
+		self.dismiss.start(reading_ms(reply))
+		self.flush()
+
+	def on_failure(self, error: str) -> None:
+		LOG.warning("Request failed: %s", error)
+		self.end_turn()
+		self.appear("surprised", bubble=f"Oups, la requête a échoué ({error}).")
+		self.dismiss.start(reading_ms(error))
+		self.flush()
+
+	def end_turn(self) -> None:
+		self.busy = False
+		self.asking = False
+		self.long_task.stop()
+
+	def flush(self) -> None:
+		if self.commands and not self.busy:
+			self.send.emit(self.commands.popleft())
+
+	def appear(self, expression: str, bubble: str, *, talking: bool = False) -> None:
+		self.pill.hide()
+		self.avatar.set_expression(expression, talking=talking, bubble=bubble)
+		self.avatar.pop_in()
+
+	def shrink(self) -> None:
+		self.avatar.pop_out()
+		self.pill.show_at(self.avatar.home() + QPoint(self.avatar.width(), self.avatar.height()))
+
+	def leave(self) -> None:
+		""" Out of the way once nothing needs her: the pill while work goes on, hidden otherwise. """
+		if self.busy or self.agents:
+			self.shrink()
+			return
+		self.pill.hide()
+		self.avatar.pop_out()
+
+
+# Functions
+def describe_tool(name: str, tool_input: JsonDict) -> str:
+	""" What a tool call does, in a few words for the bubble.
+
+	>>> describe_tool("Edit", {"file_path": "D:/repo/claudetan/app.py", "old_string": "a", "new_string": "b"})
+	'modifie app.py'
+	>>> describe_tool("Bash", {"command": "git status", "description": "Show working tree status"})
+	'Show working tree status'
+	>>> describe_tool("mcp__claudetan__screenshot", {"screen": 2})
+	'screenshot'
+	"""
+	match name:
+		case "Read":
+			return f"lit {Path(tool_input['file_path']).name}"
+		case "Write":
+			return f"écrit {Path(tool_input['file_path']).name}"
+		case "Edit" | "MultiEdit":
+			return f"modifie {Path(tool_input['file_path']).name}"
+		case "Bash" | "PowerShell":
+			return tool_input.get("description") or f"lance {tool_input['command'][:60]}"
+		case "Grep" | "Glob":
+			return f"cherche {tool_input['pattern']}"
+		case "WebSearch":
+			return f"cherche « {tool_input['query']} » sur le web"
+		case "WebFetch":
+			return f"lit {urlparse(str(tool_input['url'])).netloc}"
+		case "Agent" | "Task":
+			return f"confie une tâche : {tool_input['description']}"
+		case "AskUserQuestion":
+			return tool_input["questions"][0]["question"]
+		case _:
+			return name.rsplit("__", 1)[-1]
+
+
+def reading_ms(text: str) -> int:
+	""" How long a text stays up: 4 s, plus 50 ms per character the bubble shows, 20 s at most. """
+	return min(4000 + 50 * len(shorten(text)), 20_000)
+
+
+def main() -> None:
+	""" Starts the app in the background and returns once it reports it is ready, so no console window stays open. """
+	enable_colors()
+	stp.progress("Starting ClaudeTan, which takes about 15 s...")
+	# A gui-script would not do: uv makes the venv's pythonw.exe a copy of the console python.exe, which opens a window
+	app = subprocess.Popen(
+		[sys.executable, "-m", "claudetan.app"], stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+		text=True, creationflags=subprocess.CREATE_NO_WINDOW,
+	)
+	assert app.stdout
+	for line in app.stdout:
+		if line == READY:
+			stp.info('Say "Hey Claude, ..." to ask her something, and quit her from her tray icon.')
+			return
+		print(line, end="", flush=True)
+	stp.error(f"ClaudeTan stopped while starting, see {stp.CYAN}{LOG_FILE}")
+
+
+def report_ready(session: Session, listener: Listener) -> None:
+	""" Tells `main`, through stdout, how the session and Whisper started. """
+	if session.started.wait(STARTUP_S):
+		stp.info(f"Claude Code session {'resumed' if session.id else 'started'}: {stp.CYAN}{session.url}")
+		stp.info(f"Plan usage: {session.plan_usage()}")
+	else:
+		stp.warning("Claude Code did not start Remote Control: run uv run claudetan-setup, then start the app again", file=sys.stdout)
+	if listener.loaded.wait(STARTUP_S):
+		stp.info("Whisper runs on the GPU")
+	else:
+		stp.warning("Whisper did not load", file=sys.stdout)
+	stp.info(f"Log: {stp.CYAN}{LOG_FILE}")
+	print(READY, end="", flush=True)
+
+def replace_running_app() -> None:
+	""" Has the app already running quit, and waits until it has, so that starting the app again applies new code and settings. """
+	running = QLocalSocket()
+	running.connectToServer(INSTANCE_NAME)
+	if running.waitForConnected(1000):
+		running.waitForDisconnected(30_000)
+
+
+def run() -> None:
+	APP_DATA.mkdir(parents=True, exist_ok=True)
+	logging.basicConfig(
+		filename=LOG_FILE, encoding="utf-8", level=logging.WARNING, format="%(asctime)s %(levelname)s %(message)s",
+	)
+	LOG.setLevel(logging.INFO)
+	# Without a console the default hooks print tracebacks nowhere
+	sys.excepthook = lambda _kind, exception, _trace: logging.critical("Uncaught error", exc_info=exception)
+	threading.excepthook = lambda hook: logging.critical("Uncaught error in %s", hook.thread, exc_info=hook.exc_value)
+	# Qt's event loop never hands control back to Python's KeyboardInterrupt, so let Ctrl+C end the process directly
+	signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+	app = QApplication(sys.argv)
+	app.setQuitOnLastWindowClosed(False)
+	replace_running_app()
+	instance = QLocalServer()
+	instance.listen(INSTANCE_NAME)
+	instance.newConnection.connect(app.quit)
+	config = Config.load()
+	avatar, pill = Avatar(), Pill()
+	assistant = Assistant(avatar, pill)
+	tray = Tray()
+	tray.show()
+	hooks = HookServer()
+	session = Session(hooks.url, config.prompt)
+	for clicked in (avatar.clicked, pill.clicked, tray.open_session):
+		clicked.connect(session.open)
+	hooks.posted.connect(session.on_hook)
+	hooks.posted.connect(assistant.on_hook)
+	assistant.send.connect(session.send)
+	app.aboutToQuit.connect(session.close)
+	listener = Listener(config.language, config.wake)
+	listener.woke.connect(assistant.on_wake)
+	listener.heard.connect(assistant.on_command)
+	threading.Thread(target=listener.run, args=(microphone(),), daemon=True).start()
+	report_ready(session, listener)
+	sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+	run()
+

claudetan-1.0.0/claudetan/avatar.py

@@ -0,0 +1,299 @@
+""" Claude-tan on screen: the sprite overlay with her speech bubble, the pill she shrinks to during long tasks, and her chimes.
+
+A click on her or on the pill opens the Remote Control session, a long press on her lets you drag her somewhere else.
+"""
+# Imports
+import random
+import re
+from pathlib import Path
+from typing import override
+
+import numpy as np
+import sounddevice as sd
+from PySide6.QtCore import (
+	QEasingCurve,
+	QParallelAnimationGroup,
+	QPoint,
+	QPropertyAnimation,
+	QRect,
+	QRectF,
+	QSettings,
+	Qt,
+	QTimer,
+	Signal,
+)
+from PySide6.QtGui import QColor, QFont, QGuiApplication, QHideEvent, QMouseEvent, QPainter, QPainterPath, QPaintEvent, QPen, QPixmap
+from PySide6.QtWidgets import QWidget
+
+from claudetan.config import ROOT
+
+# Constants
+ASSETS: Path = ROOT / "assets" / "claude"
+SPRITE_HEIGHT: int = 400
+""" Display height of the sprites, which all share one canvas with her eyes on the same pixels. """
+BUBBLE_WIDTH: int = 250
+BUBBLE_CHARS: int = 220
+""" Longest text the bubble shows, the full reply staying readable in the session. """
+SPRITE_TOP: int = 24
+FACE_Y: float = 0.49
+""" Vertical position of the face center in the sprites, as a fraction of the sprite height. """
+FACE: QRect = QRect(300, 160, 240, 240)
+""" Square around her face on the sprite canvas, cropped for the pill and the tray icon. """
+PILL_SIZE: int = 64
+ACCENT: QColor = QColor(217, 119, 87)
+LONG_PRESS_MS: int = 200
+CLICK_SLOP: int = 6
+""" Pixels the cursor may travel during a press that still counts as a click. """
+TALK_FRAMES: dict[str, tuple[str, ...]] = {
+	"idle": ("idle", "idle_talk_open", "idle_talk_o", "idle_talk_wide"),
+	"hello": ("hello", "hello_talk_open", "hello_talk_o", "hello_talk_wide"),
+}
+""" Mouth frames of the poses that can talk. """
+CHIME_RATE: int = 44100
+
+
+# Classes
+class Avatar(QWidget):
+	clicked = Signal()
+
+	def __init__(self) -> None:
+		super().__init__(None, Qt.WindowType.FramelessWindowHint | Qt.WindowType.WindowStaysOnTopHint | Qt.WindowType.Tool)
+		self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+		self.setAttribute(Qt.WidgetAttribute.WA_ShowWithoutActivating)
+		ratio = QGuiApplication.primaryScreen().devicePixelRatio()
+		self.sprites: dict[str, QPixmap] = {}
+		for path in ASSETS.glob("*.png"):
+			pixmap = QPixmap(str(path)).scaledToHeight(round(SPRITE_HEIGHT * ratio), Qt.TransformationMode.SmoothTransformation)
+			pixmap.setDevicePixelRatio(ratio)
+			self.sprites[path.stem] = pixmap
+		self.sprite_width = round(self.sprites["idle"].width() / ratio)
+		self.sprite_left = BUBBLE_WIDTH - round(0.3 * self.sprite_width)
+		self.resize(self.sprite_left + self.sprite_width, SPRITE_TOP + SPRITE_HEIGHT)
+
+		self.expression = "idle"
+		self.frame = "idle"
+		self.bubble = ""
+		self.press_offset: QPoint | None = None
+		self.press_origin = QPoint()
+		self.dragging = False
+		self.settings = QSettings("ClaudeTan", "overlay")
+
+		self.motion = QPropertyAnimation(self, b"pos")
+		self.fade = QPropertyAnimation(self, b"windowOpacity")
+		self.slide = QParallelAnimationGroup(self)
+		for animation in (self.motion, self.fade):
+			animation.setDuration(260)
+			animation.setEasingCurve(QEasingCurve.Type.OutCubic)
+			self.slide.addAnimation(animation)
+		self.slide.finished.connect(self.hide_if_faded)
+
+		self.long_press = QTimer(self)
+		self.long_press.setSingleShot(True)
+		self.long_press.setInterval(LONG_PRESS_MS)
+		self.long_press.timeout.connect(self.start_drag)
+		self.blink = QTimer(self)
+		self.blink.setSingleShot(True)
+		self.blink.timeout.connect(self.close_eyes)
+		self.mouth = QTimer(self)
+		self.mouth.setInterval(110)
+		self.mouth.timeout.connect(self.flap)
+		self.schedule_blink()
+
+	def set_expression(self, expression: str, *, talking: bool = False, bubble: str = "") -> None:
+		self.expression = expression
+		self.frame = expression
+		self.bubble = shorten(bubble)
+		if talking and expression in TALK_FRAMES:
+			self.mouth.start()
+		else:
+			self.mouth.stop()
+		self.update()
+
+	def pop_in(self) -> None:
+		if not self.isVisible():
+			self.setWindowOpacity(0)
+			self.move(self.home() + QPoint(0, 40))
+			self.show()
+		self.slide_to(self.home(), 1.0)
+
+	def pop_out(self) -> None:
+		if self.isVisible():
+			self.slide_to(self.home() + QPoint(0, 40), 0.0)
+
+	def home(self) -> QPoint:
+		""" Where she stands: where she was last dropped while that screen is plugged in, else the main screen's bottom-right corner.
+
+		The fallback is never saved, so she goes back to the other screen as soon as it returns.
+		"""
+		saved = self.settings.value("pos")
+		if isinstance(saved, QPoint) and QGuiApplication.screenAt(saved + self.rect().center()):
+			return saved
+		area = QGuiApplication.primaryScreen().availableGeometry()
+		return QPoint(area.right() - self.width(), area.bottom() - self.height())
+
+	def slide_to(self, position: QPoint, opacity: float) -> None:
+		self.slide.stop()
+		self.motion.setEndValue(position)
+		self.fade.setEndValue(opacity)
+		self.slide.start()
+
+	def hide_if_faded(self) -> None:
+		if self.fade.endValue() == 0.0:
+			self.hide()
+
+	def schedule_blink(self) -> None:
+		self.blink.start(random.randint(2500, 6000))
+
+	def close_eyes(self) -> None:
+		if self.frame == "idle" and not self.mouth.isActive():
+			self.frame = "idle_blink"
+			self.update()
+			QTimer.singleShot(130, self.open_eyes)
+		self.schedule_blink()
+
+	def open_eyes(self) -> None:
+		if self.frame == "idle_blink":
+			self.frame = "idle"
+			self.update()
+
+	def flap(self) -> None:
+		self.frame = random.choice([f for f in TALK_FRAMES[self.expression] if f != self.frame])
+		self.update()
+
+	@override
+	def paintEvent(self, event: QPaintEvent) -> None:
+		painter = QPainter(self)
+		painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+		painter.drawPixmap(QPoint(self.sprite_left, SPRITE_TOP), self.sprites[self.frame])
+		if self.bubble:
+			self.paint_bubble(painter)
+
+	def paint_bubble(self, painter: QPainter) -> None:
+		painter.setFont(QFont("Segoe UI", 11))
+		text = painter.boundingRect(QRectF(0, 0, BUBBLE_WIDTH - 48, 400), Qt.TextFlag.TextWordWrap, self.bubble)
+		# Growing upward from just above her hands keeps the finger of `point` and the wave of `hello` in sight
+		bottom = SPRITE_TOP + FACE_Y * SPRITE_HEIGHT - 26
+		box = QRectF(8, max(4.0, bottom - text.height() - 24), BUBBLE_WIDTH - 20, text.height() + 24)
+		path = QPainterPath()
+		path.addRoundedRect(box, 14, 14)
+		tail = QPainterPath()
+		tail.moveTo(box.right() - 4, box.bottom() - 34)
+		tail.lineTo(box.right() + 18, box.bottom() - 22)
+		tail.lineTo(box.right() - 4, box.bottom() - 18)
+		painter.setPen(ACCENT)
+		painter.setBrush(QColor(255, 250, 244, 240))
+		painter.drawPath(path.united(tail))
+		painter.setPen(QColor(40, 30, 25))
+		painter.drawText(box.adjusted(14, 12, -14, -12), Qt.TextFlag.TextWordWrap, self.bubble)
+
+	@override
+	def mousePressEvent(self, event: QMouseEvent) -> None:
+		self.press_origin = event.globalPosition().toPoint()
+		self.press_offset = self.press_origin - self.pos()
+		self.long_press.start()
+
+	@override
+	def mouseMoveEvent(self, event: QMouseEvent) -> None:
+		cursor = event.globalPosition().toPoint()
+		if self.dragging and self.press_offset is not None:
+			self.move(cursor - self.press_offset)
+		elif self.long_press.isActive() and (cursor - self.press_origin).manhattanLength() > CLICK_SLOP:
+			self.long_press.stop()
+
+	@override
+	def mouseReleaseEvent(self, event: QMouseEvent) -> None:
+		if self.long_press.isActive():
+			self.long_press.stop()
+			self.clicked.emit()
+		elif self.dragging:
+			self.dragging = False
+			self.unsetCursor()
+			self.settings.setValue("pos", self.pos())
+		self.press_offset = None
+
+	def start_drag(self) -> None:
+		self.dragging = True
+		self.setCursor(Qt.CursorShape.ClosedHandCursor)
+
+
+class Pill(QWidget):
+	""" Her face in a disc ringed by a spinning arc, shown in her place while a long task runs. """
+	clicked = Signal()
+
+	def __init__(self) -> None:
+		super().__init__(None, Qt.WindowType.FramelessWindowHint | Qt.WindowType.WindowStaysOnTopHint | Qt.WindowType.Tool)
+		self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+		self.setAttribute(Qt.WidgetAttribute.WA_ShowWithoutActivating)
+		self.resize(PILL_SIZE, PILL_SIZE)
+		self.face = face(PILL_SIZE)
+		self.angle = 0
+		self.spin = QTimer(self)
+		self.spin.setInterval(30)
+		self.spin.timeout.connect(self.turn)
+
+	def show_at(self, corner: QPoint) -> None:
+		""" Shows the pill with its bottom-right corner on `corner`. """
+		self.move(corner - QPoint(PILL_SIZE, PILL_SIZE))
+		self.show()
+		self.spin.start()
+
+	def turn(self) -> None:
+		self.angle = (self.angle - 8) % 360
+		self.update()
+
+	@override
+	def hideEvent(self, event: QHideEvent) -> None:
+		self.spin.stop()
+
+	@override
+	def paintEvent(self, event: QPaintEvent) -> None:
+		painter = QPainter(self)
+		painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+		ring = QRectF(4, 4, PILL_SIZE - 8, PILL_SIZE - 8)
+		disc = QPainterPath()
+		disc.addEllipse(ring)
+		painter.setClipPath(disc)
+		painter.drawPixmap(ring.toRect(), self.face)
+		painter.setClipping(False)
+		painter.setPen(QPen(QColor(255, 250, 244), 4))
+		painter.drawEllipse(ring)
+		painter.setPen(QPen(ACCENT, 4, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap))
+		painter.drawArc(ring, self.angle * 16, 110 * 16)
+
+	@override
+	def mouseReleaseEvent(self, event: QMouseEvent) -> None:
+		self.clicked.emit()
+
+
+# Functions
+def face(size: int) -> QPixmap:
+	""" Her face cropped from `idle`, `size` device-independent pixels wide. """
+	ratio = QGuiApplication.primaryScreen().devicePixelRatio()
+	pixels = round(size * ratio)
+	cropped = QPixmap(str(ASSETS / "idle.png")).copy(FACE)
+	pixmap = cropped.scaled(pixels, pixels, Qt.AspectRatioMode.IgnoreAspectRatio, Qt.TransformationMode.SmoothTransformation)
+	pixmap.setDevicePixelRatio(ratio)
+	return pixmap
+
+
+def shorten(text: str) -> str:
+	""" The text as the bubble shows it: Markdown marks dropped, whitespace collapsed, cut at a word past `BUBBLE_CHARS`.
+
+	>>> shorten("**Done**: edited `app.py`.\\n\\n- one\\n- two")
+	'Done: edited app.py. one two'
+	>>> shorten("word " * 100)[-12:]
+	'word word...'
+	"""
+	plain = " ".join(re.sub(r"[*`#]|^\s*[-+] ", "", text, flags=re.MULTILINE).split())
+	return plain if len(plain) <= BUBBLE_CHARS else plain[:BUBBLE_CHARS].rsplit(" ", 1)[0] + "..."
+
+
+def chime(*notes: float) -> None:
+	""" A short bell arpeggio of the given frequencies in Hz, played without blocking. """
+	t = np.arange(int(0.4 * CHIME_RATE)) / CHIME_RATE
+	step = int(0.08 * CHIME_RATE)
+	wave = np.zeros(step * (len(notes) - 1) + len(t), np.float32)
+	for i, note in enumerate(notes):
+		wave[i * step:i * step + len(t)] += np.sin(2 * np.pi * note * t) * np.exp(-8 * t)
+	sd.play(0.15 * wave, CHIME_RATE)
+

claudetan-1.0.0/claudetan/config.py

@@ -0,0 +1,41 @@
+""" User settings: the defaults shipped next to this module, overridden by the keys set in the user's copy. """
+# Imports
+import os
+import re
+import shutil
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Self
+
+# Constants
+ROOT: Path = Path(__file__).resolve().parent.parent
+""" The ClaudeTan repository, which the app runs from. """
+APP_DATA: Path = Path(os.environ["APPDATA"]) / "ClaudeTan"
+DEFAULTS: Path = Path(__file__).with_name("config.toml")
+USER_CONFIG: Path = APP_DATA / "config.toml"
+LOG_FILE: Path = APP_DATA / "claudetan.log"
+
+
+# Classes
+@dataclass(frozen=True)
+class Config:
+	language: str | None
+	""" Whisper language code, None to detect it on each sentence. """
+	wake: re.Pattern[str]
+	prompt: str
+	""" The user's additions to the system prompt of the hidden session. """
+
+	@classmethod
+	def load(cls) -> Self:
+		""" The settings, after copying the defaults to `USER_CONFIG` on the first run so the user has a file to edit. """
+		if not USER_CONFIG.exists():
+			APP_DATA.mkdir(parents=True, exist_ok=True)
+			shutil.copyfile(DEFAULTS, USER_CONFIG)
+		values = tomllib.loads(DEFAULTS.read_text(encoding="utf-8")) | tomllib.loads(USER_CONFIG.read_text(encoding="utf-8"))
+		return cls(
+			language=None if values["language"] == "auto" else values["language"],
+			wake=re.compile(values["wake"], re.IGNORECASE),
+			prompt=values["prompt"],
+		)
+

claudetan-1.0.0/claudetan/config.toml

@@ -0,0 +1,14 @@
+# ClaudeTan settings. Quit the app from its tray icon and start it again to apply a change.
+
+# Language of the speech recognition: "fr", "en", or "auto" to detect it on each sentence
+language = "auto"
+
+# Wake phrase, matched ignoring case at the start of each sentence as Whisper spells it ("Hé Claude" often comes out as "Et Claude").
+# Its first group is the command said in the same breath.
+wake = '^\W*(?:hey|hé|he|eh|et|dis|ok|okay)\W+(?:claude|clode|clod|clodo|clown)\b[\s,.!?]*(.*)'
+
+# Your additions to the system prompt of the hidden Claude session, after what the app writes there itself:
+# where ClaudeTan is installed and how it started the session. Write them between the two ''' lines, for example:
+# Mes projets sont dans D:\advanced_desktop, mes captures d'écran dans D:\Captures.
+prompt = '''
+'''

claudetan-1.0.0/claudetan/console.py

@@ -0,0 +1,18 @@
+""" The terminal the command-line entry points print to. """
+# Imports
+import ctypes
+
+# Constants
+STD_OUTPUT_HANDLE: int = -11
+ENABLE_VIRTUAL_TERMINAL_PROCESSING: int = 0x4
+
+
+# Functions
+def enable_colors() -> None:
+	""" Turns on color codes in the console, which Windows' classic console prints as text otherwise. """
+	kernel32 = ctypes.windll.kernel32
+	console = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+	mode = ctypes.c_uint32()
+	if kernel32.GetConsoleMode(console, ctypes.byref(mode)):
+		kernel32.SetConsoleMode(console, mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+

claudetan-1.0.0/claudetan/session.py

@@ -0,0 +1,169 @@
+""" The hidden Claude Code session: `claude --remote-control` in a pseudo terminal, and the hook events it posts to the app. """
+# Imports
+import json
+import os
+import re
+import subprocess
+import threading
+import time
+import uuid
+import webbrowser
+from functools import partial
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Any, override
+
+import pyte
+from PySide6.QtCore import QObject, QTimer, Signal
+from winpty import PtyProcess
+
+from claudetan.config import APP_DATA, ROOT, USER_CONFIG
+
+# Constants
+type JsonDict = dict[str, Any]
+SYSTEM_PROMPT: str = (
+	f"You are Claude-tan, the voice assistant of ClaudeTan, an app installed in {ROOT} that keeps its settings in {USER_CONFIG}.\n"
+	"ClaudeTan started this Claude Code session hidden in a pseudo-terminal, with Remote Control and the auto permission mode, "
+	"resumes it each time the app starts, and follows it through hooks to animate your avatar on the screen.\n"
+	"Prompts come from the user's voice, transcribed by Whisper, which can mishear words, "
+	"or from the Remote Control on claude.ai or in the Claude app on their iPhone.\n"
+	"Your replies appear in a speech bubble next to your avatar, which only shows the start of long ones.\n"
+)
+""" What the app tells the session about itself, before the user's additions from the config. """
+HOOK_EVENTS: tuple[str, ...] = (
+	"UserPromptSubmit", "PreToolUse", "PostToolUse", "PermissionRequest", "Notification", "MessageDisplay",
+	"SubagentStart", "SubagentStop", "Stop", "StopFailure",
+)
+SESSION_ID: Path = APP_DATA / "session_id"
+""" The conversation the app resumes, saved once a hook reports it, so a session that never got a prompt is not resumed. """
+SESSION_URL: re.Pattern[str] = re.compile(r"https://claude\.ai/code/session_\w+")
+PLAN_USAGE: re.Pattern[str] = re.compile(
+	r"Current session\W+(?P<window>\d+)% used\s+Resets (?P<window_reset>[^)]*\)).*?"
+	r"Current week \(all models\)\W+(?P<week>\d+)% used\s+Resets (?P<week_reset>[^)]*\))",
+	re.DOTALL,
+)
+""" The two limits of the `/usage` panel, each followed by when it resets, such as "Resets Oct 12, 12am (Europe/Paris)". """
+NESTED_SESSION_VARS: tuple[str, ...] = (
+	"CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT", "CLAUDE_CODE_SESSION_ID", "CLAUDE_CODE_CHILD_SESSION",
+	"CLAUDE_CODE_MESSAGING_SOCKET", "CLAUDE_CODE_MESSAGING_TOKEN", "CLAUDE_PID",
+)
+""" Set when the app runs inside another Claude Code session; the hosted `claude` refuses to start nested while they are present. """
+PASTE_DELAY_MS: int = 400
+""" Pause between the text and Enter, so the TUI takes the text as one paste before submitting it. """
+
+
+# Classes
+class HookServer(QObject):
+	""" Local endpoint for the session's `type: "http"` hooks, relaying each payload to the Qt thread. """
+	posted = Signal(dict)
+
+	def __init__(self) -> None:
+		super().__init__()
+		relay = self.posted
+
+		class Handler(BaseHTTPRequestHandler):
+			def do_POST(self) -> None:
+				relay.emit(json.loads(self.rfile.read(int(self.headers["Content-Length"]))))
+				self.send_response(200)
+				self.end_headers()
+
+			@override
+			def log_message(self, format: str, *args: Any) -> None:
+				pass
+
+		server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+		self.url = f"http://127.0.0.1:{server.server_port}"
+		threading.Thread(target=server.serve_forever, daemon=True).start()
+
+
+class Session:
+	""" Claude Code started in the repo, resuming the saved conversation, with its hooks posting to `hooks_url`. """
+
+	def __init__(self, hooks_url: str, additions: str) -> None:
+		settings = APP_DATA / "session_settings.json"
+		hooks = {name: [{"hooks": [{"type": "http", "url": hooks_url, "timeout": 5}]}] for name in HOOK_EVENTS}
+		settings.write_text(json.dumps({"hooks": hooks}), encoding="utf-8")
+		prompt = APP_DATA / "session_prompt.md"
+		prompt.write_text(system_prompt(additions), encoding="utf-8")
+
+		self.id = SESSION_ID.read_text() if SESSION_ID.exists() else ""
+		resume = ["--resume", self.id] if self.id else ["--session-id", str(uuid.uuid4())]
+		claude = [
+			"claude", "--remote-control", "ClaudeTan", "--permission-mode", "auto",
+			"--settings", str(settings), "--append-system-prompt-file", str(prompt), *resume,
+		]
+		# chcp 65001: without it the pseudo console feeds Claude Code accented letters in cp850
+		argv = ["cmd.exe", "/c", "chcp", "65001", ">nul", "&&", *claude]
+		env = {name: value for name, value in os.environ.items() if name not in NESTED_SESSION_VARS}
+		self.pty = PtyProcess.spawn(argv, cwd=str(ROOT), env=env, dimensions=(50, 200))
+		self.screen = pyte.Screen(200, 50)
+		""" What the terminal shows, rebuilt from its output: Claude Code only redraws the characters that change. """
+		self.screen_lock = threading.Lock()
+		self.url = "https://claude.ai/code"
+		self.started = threading.Event()
+		""" Set once Remote Control prints the session's URL, when the session is ready for prompts. """
+		threading.Thread(target=self.read_output, daemon=True).start()
+
+	def read_output(self) -> None:
+		""" Renders the terminal's output, read continuously so the session never blocks on a full pipe. """
+		stream = pyte.Stream(self.screen)
+		while self.pty.isalive():
+			try:
+				output = self.pty.read(4096)
+			except EOFError:
+				return
+			with self.screen_lock:
+				stream.feed(output)
+			if not self.started.is_set() and (match := SESSION_URL.search(self.text())):
+				self.url = match.group()
+				self.started.set()
+
+	def plan_usage(self) -> str:
+		""" The plan's limits as `/usage` shows them, read before any prompt since keys typed while its panel is open land in it. """
+		self.pty.write("/usage")
+		time.sleep(PASTE_DELAY_MS / 1000)
+		self.pty.write("\r")
+		deadline = time.monotonic() + 15
+		while not (match := PLAN_USAGE.search(self.text())) and time.monotonic() < deadline:
+			time.sleep(0.2)
+		self.pty.write("\x1b")
+		if not match:
+			return "unknown, /usage did not show it"
+		return (
+			f"{match['window']}% of the 5-hour window, resets {match['window_reset']}; "
+			f"{match['week']}% of the week, resets {match['week_reset']}"
+		)
+
+	def text(self) -> str:
+		with self.screen_lock:
+			return "\n".join(self.screen.display)
+
+	def on_hook(self, event: JsonDict) -> None:
+		if event["session_id"] != self.id:
+			self.id = event["session_id"]
+			SESSION_ID.write_text(self.id)
+
+	def send(self, prompt: str) -> None:
+		self.pty.write(prompt)
+		QTimer.singleShot(PASTE_DELAY_MS, partial(self.pty.write, "\r"))
+
+	def open(self) -> None:
+		webbrowser.open(self.url)
+
+	def close(self) -> None:
+		""" Kills Claude Code outright: on a clean exit, Remote Control archives the session, which drops it from claude.ai's list. """
+		kill = ["taskkill", "/F", "/T", "/PID", str(self.pty.pid)]
+		subprocess.run(kill, capture_output=True, creationflags=subprocess.CREATE_NO_WINDOW)
+
+
+# Functions
+def system_prompt(additions: str) -> str:
+	""" Text for `--append-system-prompt-file`: `SYSTEM_PROMPT`, then the user's additions when there are any.
+
+	>>> system_prompt("\\n") == SYSTEM_PROMPT
+	True
+	>>> system_prompt("Mes jeux sont dans E:/Games.\\n").removeprefix(SYSTEM_PROMPT)
+	'\\nMes jeux sont dans E:/Games.'
+	"""
+	return f"{SYSTEM_PROMPT}\n{additions.strip()}" if additions.strip() else SYSTEM_PROMPT
+

claudetan-1.0.0/claudetan/setup.py

@@ -0,0 +1,51 @@
+""" One-time setup, run with `uv run claudetan-setup`: prepares Whisper, then signs in to Claude Code and has it trust the repo. """
+# Imports
+import json
+import shutil
+import subprocess
+from pathlib import Path
+
+import numpy as np
+import stouputils as stp
+
+from claudetan.config import ROOT
+from claudetan.console import enable_colors
+from claudetan.voice import RATE, load_whisper
+
+
+# Functions
+def main() -> None:
+	enable_colors()
+	stp.progress("Downloading Whisper (1.6 GB the first time) and running it once on the GPU...")
+	segments, _ = load_whisper().transcribe(np.zeros(RATE, np.float32), language="en")
+	list(segments)
+	stp.info("Whisper runs on the GPU")
+
+	if not shutil.which("claude"):
+		stp.warning(f"Install Claude Code, then run this setup again: {stp.CYAN}https://code.claude.com/docs/en/setup")
+		return
+	if not signed_in():
+		stp.progress("Claude Code opens its sign-in page: sign in with your Claude Pro or Max account.")
+		subprocess.run(["claude", "auth", "login"])
+	# The decision stays with the user: Claude Code shows its own dialog, and records the answer in a file it keeps rewriting
+	if not trusted():
+		stp.progress('Claude Code opens and asks whether you trust this folder: pick "Yes, I trust this folder", then type /exit')
+		subprocess.run(["claude"], cwd=ROOT)
+
+	if signed_in() and trusted():
+		stp.info(f"Claude Code is ready. Start the app with: {stp.CYAN}uv run claudetan")
+	else:
+		stp.warning("Claude Code is not signed in or does not trust this folder yet: run this setup again.")
+
+
+def signed_in() -> bool:
+	""" Whether Claude Code is signed in with a Claude subscription, which the app needs instead of an API key. """
+	status = json.loads(subprocess.run(["claude", "auth", "status"], capture_output=True, text=True).stdout)
+	return status.get("authMethod") == "claude.ai"
+
+
+def trusted() -> bool:
+	""" Whether the user has told Claude Code it may work in this repository. """
+	projects = json.loads((Path.home() / ".claude.json").read_text(encoding="utf-8")).get("projects", {})
+	return bool(projects.get(ROOT.as_posix(), {}).get("hasTrustDialogAccepted"))
+

claudetan-1.0.0/claudetan/tray.py

@@ -0,0 +1,65 @@
+""" The tray icon: its menu, and starting the app with Windows. """
+# Imports
+import os
+import sys
+import winreg
+from pathlib import Path
+
+from PySide6.QtCore import Signal
+from PySide6.QtGui import QCursor, QIcon
+from PySide6.QtWidgets import QApplication, QMenu, QSystemTrayIcon
+
+from claudetan.avatar import face
+from claudetan.config import APP_DATA, LOG_FILE, USER_CONFIG
+
+# Constants
+RUN_KEY: str = r"Software\Microsoft\Windows\CurrentVersion\Run"
+""" Registry key, under HKEY_CURRENT_USER, of the programs Windows starts at logon. """
+LAUNCHER: Path = Path(sys.prefix) / "Scripts" / "claudetan.exe"
+""" Entry point that `uv sync` installs in the project environment, which starts the app in the background. """
+
+
+# Classes
+class Tray(QSystemTrayIcon):
+	open_session = Signal()
+
+	def __init__(self) -> None:
+		super().__init__(QIcon(face(64)))
+		self.setToolTip("Claude-tan")
+		self.menu = QMenu()
+		self.menu.addAction("Ouvrir la session", self.open_session.emit)
+		self.menu.addAction("Ouvrir la config", lambda: os.startfile(USER_CONFIG))
+		self.menu.addAction("Voir le journal", lambda: os.startfile(LOG_FILE))
+		self.menu.addAction("Ouvrir le dossier", lambda: os.startfile(APP_DATA))
+		startup = self.menu.addAction("Démarrer avec Windows")
+		startup.setCheckable(True)
+		startup.setChecked(starts_with_windows())
+		startup.toggled.connect(start_with_windows)
+		self.menu.addSeparator()
+		self.menu.addAction("Quitter", QApplication.quit)
+		self.setContextMenu(self.menu)
+		self.activated.connect(self.on_activated)
+
+	def on_activated(self, reason: QSystemTrayIcon.ActivationReason) -> None:
+		""" Opens the menu on a left click too, Windows only showing it on a right click. """
+		if reason == QSystemTrayIcon.ActivationReason.Trigger:
+			self.menu.popup(QCursor.pos())
+
+
+# Functions
+def starts_with_windows() -> bool:
+	with winreg.OpenKey(winreg.HKEY_CURRENT_USER, RUN_KEY) as key:
+		try:
+			winreg.QueryValueEx(key, "ClaudeTan")
+		except FileNotFoundError:
+			return False
+		return True
+
+
+def start_with_windows(enabled: bool) -> None:
+	with winreg.OpenKey(winreg.HKEY_CURRENT_USER, RUN_KEY, access=winreg.KEY_SET_VALUE) as key:
+		if enabled:
+			winreg.SetValueEx(key, "ClaudeTan", 0, winreg.REG_SZ, f'"{LAUNCHER}"')
+		else:
+			winreg.DeleteValue(key, "ClaudeTan")
+

claudetan-1.0.0/claudetan/voice.py

@@ -0,0 +1,108 @@
+""" The microphone, cut into sentences by Silero VAD and transcribed by Whisper, reduced to the commands spoken to her. """
+# Imports
+import queue
+import re
+import threading
+import time
+from collections.abc import Iterator
+from dataclasses import dataclass
+
+import numpy as np
+import sounddevice as sd
+from faster_whisper import WhisperModel
+from faster_whisper.vad import get_vad_model
+from PySide6.QtCore import QObject, Signal
+
+# Constants
+type Audio = np.ndarray[tuple[int], np.dtype[np.float32]]
+RATE: int = 16000
+FRAME: int = 512
+""" Samples per VAD step, the window Silero expects at 16 kHz (32 ms). """
+EARLY_CHECK_FRAMES: int = 40
+""" Length (1.3 s) at which a sentence still being spoken is transcribed once, so she reacts to the wake phrase before it ends. """
+FOLLOW_UP_S: float = 8.0
+""" How long a lone wake phrase keeps her listening for the command. """
+
+
+# Classes
+@dataclass(frozen=True)
+class Speech:
+	audio: Audio
+	ended: bool
+	""" False for the opening of a sentence still being spoken. """
+
+
+class Listener(QObject):
+	""" Runs the microphone pipeline on its own thread and reports to the Qt thread through its signals. """
+	woke = Signal()
+	heard = Signal(str)
+	""" A command, said after the wake phrase or alone within `FOLLOW_UP_S` of it. """
+
+	def __init__(self, language: str | None, wake: re.Pattern[str]) -> None:
+		super().__init__()
+		self.language = language
+		self.wake = wake
+		self.loaded = threading.Event()
+
+	def run(self, frames: Iterator[Audio]) -> None:
+		whisper = load_whisper()
+		self.loaded.set()
+		awake_until = 0.0
+		for speech in utterances(frames):
+			segments, _ = whisper.transcribe(speech.audio, language=self.language, beam_size=1, condition_on_previous_text=False)
+			text = " ".join(segment.text.strip() for segment in segments)
+			match = self.wake.match(text)
+			if match:
+				if time.monotonic() > awake_until:
+					self.woke.emit()
+				awake_until = time.monotonic() + FOLLOW_UP_S
+
+			command = match.group(1) if match else text
+			if speech.ended and command and time.monotonic() < awake_until:
+				self.heard.emit(command)
+				awake_until = 0.0
+
+
+# Functions
+def load_whisper() -> WhisperModel:
+	""" Whisper on the GPU, downloaded from Hugging Face on the first call (1.6 GB). """
+	return WhisperModel("large-v3-turbo", device="cuda", compute_type="int8_float16")
+
+
+def microphone() -> Iterator[Audio]:
+	frames: queue.Queue[Audio] = queue.Queue()
+	with sd.InputStream(
+		samplerate=RATE, channels=1, dtype="float32", blocksize=FRAME,
+		callback=lambda data, _count, _time, _status: frames.put(data[:, 0].copy()),
+	):
+		while True:
+			yield frames.get()
+
+
+def utterances(frames: Iterator[Audio]) -> Iterator[Speech]:
+	""" Sentences cut out of the frames: one starts after 250 ms above the threshold and ends after 800 ms of silence or 15 s.
+
+	Each sentence reaching `EARLY_CHECK_FRAMES` is also yielded once before it ends.
+	"""
+	vad = get_vad_model()
+	window: list[Audio] = []
+	speech: list[Audio] = []
+	voiced = silent = 0
+	for frame in frames:
+		window = [*window[-15:], frame]
+		probability = float(vad(np.concatenate(window))[-1])
+		voiced = voiced + 1 if probability > 0.5 else 0
+		silent = silent + 1 if probability < 0.35 else 0
+		if speech:
+			speech.append(frame)
+		elif voiced >= 8:
+			speech = list(window)
+		else:
+			continue
+
+		ended = silent >= 25 or len(speech) >= 15 * RATE // FRAME
+		if ended or len(speech) == EARLY_CHECK_FRAMES:
+			yield Speech(audio=np.concatenate(speech), ended=ended)
+		if ended:
+			speech = []
+

claudetan-1.0.0/pyproject.toml

@@ -0,0 +1,114 @@
+[build-system]
+requires = ["uv_build>=0.12.0,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = ""
+
+[tool.pyright]
+typeCheckingMode = "strict"
+exclude = ["tools/sprites"]
+
+[tool.complexipy]
+paths = ["."]
+max-complexity-allowed = 15
+sort = "desc"
+
+[tool.ruff]
+exclude = [
+    ".git",
+    ".ruff_cache",
+    ".venv",
+    ".vscode",
+    "build",
+    "dist",
+    "*.pyi",
+]
+line-length = 135
+src = [
+    ".",
+    "tools/sprites",
+]
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "W",
+    "F",
+    "I",
+    "N",
+    "UP",
+    "B",
+    "C4",
+    "T20",
+    "RUF",
+    "RET",
+    "SIM",
+    "PIE",
+    "PERF401",
+    "PGH003",
+    "FBT003",
+    "TRY203",
+    "S110",
+    "PLR5501",
+]
+ignore = [
+    "T201",
+    "W191",
+    "N803",
+    "N806",
+]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+
+[project]
+name = "claudetan"
+version = "1.0.0"
+description = "Voice-driven Claude Code assistant with an anime avatar overlay"
+keywords = [
+    "claude",
+    "claude-code",
+    "voice-assistant",
+    "avatar",
+    "overlay",
+    "whisper",
+    "pyside6",
+]
+requires-python = ">=3.14"
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: Microsoft :: Windows",
+    "Typing :: Typed",
+]
+dependencies = [
+    "faster-whisper>=1.2",
+    "numpy",
+    "pyside6>=6.9",
+    "pyte>=0.8.2",
+    "pywinpty>=2.0",
+    "sounddevice",
+    "soundfile",
+    "stouputils>=26.10.1",
+]
+
+[[project.authors]]
+name = "Stoupy51"
+email = "stoupy51@gmail.com"
+
+[project.scripts]
+claudetan = "claudetan.app:main"
+claudetan-setup = "claudetan.setup:main"
+
+[project.urls]
+Issues = "https://github.com/Stoupy51/ClaudeTan/issues"
+Repository = "https://github.com/Stoupy51/ClaudeTan"
+
+[dependency-groups]
+dev = [
+    "pyright",
+    "pytest",
+    "ruff",
+]

claudetan-1.0.0/pyproject.toml.orig

@@ -0,0 +1,106 @@
+[build-system]
+requires = ["uv_build>=0.12.0,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = ""
+
+[project]
+name = "claudetan"
+version = "1.0.0"
+description = "Voice-driven Claude Code assistant with an anime avatar overlay"
+keywords = ["claude", "claude-code", "voice-assistant", "avatar", "overlay", "whisper", "pyside6"]
+requires-python = ">=3.14"
+classifiers = [
+	"Development Status :: 2 - Pre-Alpha",
+	"Programming Language :: Python :: 3",
+	"Programming Language :: Python :: 3.14",
+	"Operating System :: Microsoft :: Windows",
+	"Typing :: Typed",
+]
+dependencies = [
+	"faster-whisper>=1.2",
+	"numpy",
+	"pyside6>=6.9",
+	"pyte>=0.8.2",
+	"pywinpty>=2.0",
+	"sounddevice",
+	"soundfile",
+	"stouputils>=26.10.1",
+]
+authors = [
+	{ name = "Stoupy51", email = "stoupy51@gmail.com" },
+]
+
+[project.scripts]
+claudetan = "claudetan.app:main"
+claudetan-setup = "claudetan.setup:main"
+
+[project.urls]
+Issues = "https://github.com/Stoupy51/ClaudeTan/issues"
+Repository = "https://github.com/Stoupy51/ClaudeTan"
+
+[dependency-groups]
+dev = [
+	"pyright",
+	"pytest",
+	"ruff",
+]
+
+[tool.pyright]
+typeCheckingMode = "strict"
+# The sprite pipeline is its own uv project, checked with its own environment
+exclude = ["tools/sprites"]
+
+[tool.complexipy]
+paths = ["."]
+max-complexity-allowed = 15
+sort = "desc"
+
+[tool.ruff]
+exclude = [
+	".git",
+	".ruff_cache",
+	".venv",
+	".vscode",
+	"build",
+	"dist",
+	"*.pyi",
+]
+line-length = 135
+# The sprite modules import each other by plain name, as scripts run from their folder
+src = [".", "tools/sprites"]
+
+[tool.ruff.lint.isort]
+# Keeps the "name as name" re-exports of a package grouped in a single statement
+combine-as-imports = true
+
+[tool.ruff.lint]
+select = [
+	"E",
+	"W",
+	"F",
+	"I",
+	"N",
+	"UP",
+	"B",
+	"C4",
+	"T20",
+	"RUF",
+	"RET",
+	"SIM",
+	"PIE",
+	"PERF401",
+	"PGH003",
+	"FBT003",
+	"TRY203",
+	"S110",
+	"PLR5501",
+]
+ignore = [
+	"T201",
+	"W191",
+	"N803",
+	"N806",
+]
+