@makefinks/daemon 0.4.0 → 0.6.0

package/src/avatar/rig/core/rig-engine.ts

@@ -0,0 +1,202 @@
+import { THREE } from "@opentui/core/3d";
+import type { AvatarColorTheme } from "src/types";
+import { type SceneElements, createSceneElements } from "../scene/create-scene-elements";
+import { type RigState, createInitialState } from "../state/rig-state";
+import { updateThemeColors } from "../theme/rig-theme";
+import { TOOL_CATEGORY_COLORS, type ToolCategory } from "../tools/rig-tools";
+import { updateCore } from "../update/update-core";
+import { updateEye } from "../update/update-eye";
+import { updateFragments } from "../update/update-fragments";
+import { updateGlitchBehavior } from "../update/update-glitch";
+import { updateIdleAmbience } from "../update/update-idle";
+import { updateIntensityAndAudio } from "../update/update-intensity";
+import { updateMainAnchor } from "../update/update-main-anchor";
+import { updateParticles } from "../update/update-particles";
+import { updateRings } from "../update/update-rings";
+import { updateSigils } from "../update/update-sigils";
+import { advanceSpawn, applySpawn, resetSpawnState, skipSpawnAnimation } from "../update/update-spawn";
+import { clamp01 } from "../utils/math";
+import type { RigEngineOptions, RigEvent } from "./rig-types";
+
+export class RigEngine {
+	public readonly scene: THREE.Scene;
+	public readonly camera: THREE.PerspectiveCamera;
+	private readonly elements: SceneElements;
+	private readonly state: RigState;
+	private readonly disposables: Array<{ dispose(): void }> = [];
+
+	constructor(options: RigEngineOptions) {
+		this.scene = new THREE.Scene();
+		this.camera = new THREE.PerspectiveCamera(28, options.aspectRatio, 0.1, 100);
+		this.camera.position.set(0, 0, 8);
+		this.camera.lookAt(0, 0, 0);
+
+		const trackGeo = <T extends THREE.BufferGeometry>(g: T): T => {
+			this.disposables.push(g);
+			return g;
+		};
+		const trackMat = <T extends THREE.Material>(m: T): T => {
+			this.disposables.push(m);
+			return m;
+		};
+
+		this.elements = createSceneElements(this.scene, trackGeo, trackMat);
+		this.state = createInitialState();
+	}
+
+	public getScene(): THREE.Scene {
+		return this.scene;
+	}
+
+	public getCamera(): THREE.PerspectiveCamera {
+		return this.camera;
+	}
+
+	public update(deltaS: number): void {
+		const dt = Math.min(0.1, deltaS);
+		this.state.glitch.timer += dt;
+
+		const spawnProgress = advanceSpawn(this.state, dt);
+		const isSpawning = spawnProgress < 1;
+
+		const intensity = updateIntensityAndAudio(this.state, dt);
+		const isIdle = intensity < 0.1;
+
+		// Allow glitch during spawn for effect, or during high intensity
+		const allowGlitch =
+			(intensity > 0.4 && !this.state.reasoning.active) ||
+			(isSpawning && this.state.spawn.glitchIntensity > 0.3);
+
+		updateMainAnchor(this.elements, this.state, dt, intensity);
+		updateCore(this.elements, this.state, dt, intensity);
+		updateEye(this.elements, this.state, dt, intensity);
+		updateRings(this.elements, this.state, dt, intensity);
+		updateFragments(this.elements, this.state, dt, intensity);
+		updateSigils(this.elements, this.state, dt, intensity);
+		updateParticles(this.elements, this.state, dt, intensity, allowGlitch);
+		updateGlitchBehavior(this.elements, this.state, dt, intensity, allowGlitch);
+		updateIdleAmbience(this.elements, this.state, dt, isIdle);
+		updateThemeColors(this.elements, this.state, dt);
+		applySpawn(this.elements, this.state);
+	}
+
+	public handle(event: RigEvent): void {
+		switch (event.type) {
+			case "theme":
+				this.setTheme(event.theme);
+				break;
+			case "intensity":
+				this.setIntensity(event.intensity, { immediate: event.immediate });
+				break;
+			case "audio":
+				this.setAudioLevel(event.level, { immediate: event.immediate });
+				break;
+			case "tool-active":
+				this.setToolActive(event.active, event.category);
+				break;
+			case "tool-flash":
+				this.triggerToolFlash(event.category);
+				break;
+			case "tool-complete":
+				this.triggerToolComplete();
+				break;
+			case "reasoning":
+				this.setReasoningMode(event.active);
+				break;
+			case "typing":
+				this.setTypingMode(event.active);
+				break;
+			case "typing-pulse":
+				this.triggerTypingPulse();
+				break;
+			default:
+				break;
+		}
+	}
+
+	public setTheme(theme: AvatarColorTheme): void {
+		this.state.theme.target = { ...theme };
+	}
+
+	public setColors(theme: AvatarColorTheme): void {
+		this.setTheme(theme);
+	}
+
+	public setIntensity(intensity: number, options?: { immediate?: boolean }): void {
+		const next = clamp01(intensity);
+		if (options?.immediate) {
+			this.state.intensity.target = next;
+			this.state.intensity.current = next;
+		} else {
+			if (next > this.state.intensity.target + 0.1) {
+				this.state.intensity.spinBoost = 12.0;
+			}
+			this.state.intensity.target = next;
+		}
+	}
+
+	public setAudioLevel(level: number, options?: { immediate?: boolean }): void {
+		const next = clamp01(level);
+		if (options?.immediate) {
+			this.state.audio.target = next;
+			this.state.audio.current = next;
+		} else {
+			this.state.audio.target = next;
+		}
+	}
+
+	public setToolActive(active: boolean, category?: ToolCategory): void {
+		this.state.tool.active = active;
+		if (active && category) {
+			this.elements.sigilMat.color.setHex(TOOL_CATEGORY_COLORS[category]);
+		} else {
+			this.elements.sigilMat.color.setHex(this.state.theme.current.primary);
+		}
+	}
+
+	public triggerToolFlash(category?: ToolCategory): void {
+		this.state.tool.flashColor = category ? TOOL_CATEGORY_COLORS[category] : 0xffffff;
+		this.state.tool.flashTimer = 0.15;
+		this.state.tool.fragmentScatterBoost = 0.3;
+		this.state.intensity.spinBoost = Math.max(this.state.intensity.spinBoost, 8);
+	}
+
+	public triggerToolComplete(): void {
+		this.state.tool.settleTimer = 0.2;
+	}
+
+	public setReasoningMode(active: boolean): void {
+		this.state.reasoning.active = active;
+	}
+
+	public setTypingMode(active: boolean): void {
+		this.state.typing.active = active;
+	}
+
+	public triggerTypingPulse(): void {
+		this.state.typing.pulse = Math.min(1.0, this.state.typing.pulse + 0.3);
+		this.state.intensity.spinBoost = Math.max(this.state.intensity.spinBoost, 1.5);
+	}
+
+	public resetSpawn(): void {
+		resetSpawnState(this.state);
+	}
+
+	public skipSpawn(): void {
+		skipSpawnAnimation(this.state);
+	}
+
+	/** Returns the current spawn progress (0-1, where 1 = fully spawned) */
+	public getSpawnProgress(): number {
+		return this.state.spawn.progress;
+	}
+
+	/** Returns true if spawn animation is complete */
+	public isSpawnComplete(): boolean {
+		return this.state.spawn.complete;
+	}
+
+	public dispose(): void {
+		this.disposables.forEach((d) => d.dispose());
+	}
+}

package/src/avatar/rig/core/rig-types.ts

@@ -0,0 +1,17 @@
+import type { AvatarColorTheme } from "src/types";
+import type { ToolCategory } from "../tools/rig-tools";
+
+export interface RigEngineOptions {
+	aspectRatio: number;
+}
+
+export type RigEvent =
+	| { type: "theme"; theme: AvatarColorTheme }
+	| { type: "intensity"; intensity: number; immediate?: boolean }
+	| { type: "audio"; level: number; immediate?: boolean }
+	| { type: "tool-active"; active: boolean; category?: ToolCategory }
+	| { type: "tool-flash"; category?: ToolCategory }
+	| { type: "tool-complete" }
+	| { type: "reasoning"; active: boolean }
+	| { type: "typing"; active: boolean }
+	| { type: "typing-pulse" };

package/src/avatar/rig/scene/create-scene-elements.ts

@@ -0,0 +1,298 @@
+import { THREE } from "@opentui/core/3d";
+
+export interface RingData {
+	mesh: THREE.Line;
+	material: THREE.LineBasicMaterial;
+	speed: number;
+	axis: THREE.Vector3;
+	phase: number;
+	wobblePhase: number;
+}
+
+export interface FragmentData {
+	mesh: THREE.Mesh;
+	material: THREE.MeshBasicMaterial;
+	orbitRadius: number;
+	orbitSpeed: number;
+	orbitAngle: number;
+	bobSpeed: number;
+	bobPhase: number;
+}
+
+export interface ParticleVelocity {
+	x: number;
+	y: number;
+	z: number;
+	phase: number;
+}
+
+export interface SceneElements {
+	mainAnchor: THREE.Group;
+	coreGroup: THREE.Group;
+	orbitGroup: THREE.Group;
+	fragmentGroup: THREE.Group;
+	coreMesh: THREE.Mesh;
+	glowMesh: THREE.Mesh;
+	glowMat: THREE.MeshBasicMaterial;
+	eye: THREE.Mesh;
+	eyeMat: THREE.MeshBasicMaterial;
+	pupil: THREE.Mesh;
+	pupilMat: THREE.MeshBasicMaterial;
+	rings: RingData[];
+	fragments: FragmentData[];
+	particleSystem: THREE.Points;
+	particleMat: THREE.PointsMaterial;
+	particlePos: THREE.BufferAttribute;
+	particleVelocities: ParticleVelocity[];
+	sigilLines: THREE.LineSegments;
+	sigilMat: THREE.LineBasicMaterial;
+	sigilPos: THREE.BufferAttribute;
+	pointLight: THREE.PointLight;
+}
+
+type TrackGeometry = <T extends THREE.BufferGeometry>(g: T) => T;
+type TrackMaterial = <T extends THREE.Material>(m: T) => T;
+
+export function createSceneElements(
+	scene: THREE.Scene,
+	trackGeo: TrackGeometry,
+	trackMat: TrackMaterial
+): SceneElements {
+	const mainAnchor = new THREE.Group();
+	scene.add(mainAnchor);
+
+	const coreGroup = new THREE.Group();
+	mainAnchor.add(coreGroup);
+
+	const orbitGroup = new THREE.Group();
+	mainAnchor.add(orbitGroup);
+
+	const fragmentGroup = new THREE.Group();
+	mainAnchor.add(fragmentGroup);
+
+	// Core mesh and glow
+	const coreGeo = trackGeo(new THREE.IcosahedronGeometry(0.35, 0));
+	const coreMat = trackMat(
+		new THREE.MeshBasicMaterial({
+			color: 0x000000,
+			transparent: true,
+			opacity: 0.95,
+		})
+	);
+	const coreMesh = new THREE.Mesh(coreGeo, coreMat);
+	coreGroup.add(coreMesh);
+
+	const glowGeo = trackGeo(new THREE.IcosahedronGeometry(0.38, 1));
+	const glowMat = trackMat<THREE.MeshBasicMaterial>(
+		new THREE.MeshBasicMaterial({
+			color: 0x666666,
+			wireframe: true,
+			transparent: true,
+			opacity: 0.6,
+			blending: THREE.AdditiveBlending,
+		})
+	);
+	const glowMesh = new THREE.Mesh(glowGeo, glowMat);
+	coreGroup.add(glowMesh);
+
+	// Eye and pupil
+	const eyeGeo = trackGeo(new THREE.RingGeometry(0.08, 0.16, 6));
+	const eyeMat = trackMat<THREE.MeshBasicMaterial>(
+		new THREE.MeshBasicMaterial({
+			color: 0xffffff,
+			side: THREE.DoubleSide,
+			transparent: true,
+			opacity: 1.0,
+			blending: THREE.AdditiveBlending,
+		})
+	);
+	const eye = new THREE.Mesh(eyeGeo, eyeMat);
+	eye.position.set(0, 0, 0.36);
+	coreGroup.add(eye);
+
+	const pupilGeo = trackGeo(new THREE.CircleGeometry(0.06, 6));
+	const pupilMat = trackMat<THREE.MeshBasicMaterial>(
+		new THREE.MeshBasicMaterial({
+			color: 0xffffff,
+			transparent: true,
+			opacity: 1.0,
+			blending: THREE.AdditiveBlending,
+		})
+	);
+	const pupil = new THREE.Mesh(pupilGeo, pupilMat);
+	pupil.position.set(0, 0, 0.37);
+	coreGroup.add(pupil);
+
+	// Orbiting rings
+	const rings: RingData[] = [];
+	for (let i = 0; i < 3; i++) {
+		const radius = 0.7 + i * 0.25;
+		const segments = 32;
+		const points: THREE.Vector3[] = [];
+		for (let j = 0; j <= segments; j++) {
+			const theta = (j / segments) * Math.PI * 2;
+			if (j % 8 < 6 || i === 1) {
+				points.push(new THREE.Vector3(Math.cos(theta) * radius, Math.sin(theta) * radius, 0));
+			}
+		}
+
+		const geo = trackGeo(new THREE.BufferGeometry().setFromPoints(points));
+		const mat = trackMat<THREE.LineBasicMaterial>(
+			new THREE.LineBasicMaterial({
+				color: 0x888888,
+				transparent: true,
+				opacity: 0.5 + i * 0.15,
+				blending: THREE.AdditiveBlending,
+			})
+		);
+
+		const ring = new THREE.Line(geo, mat);
+		ring.rotation.x = (i * Math.PI) / 3 + Math.random() * 0.3;
+		ring.rotation.y = (i * Math.PI) / 4;
+
+		rings.push({
+			mesh: ring,
+			material: mat,
+			speed: 0.3 + i * 0.15,
+			axis: new THREE.Vector3(Math.random() - 0.5, Math.random() - 0.5, Math.random() - 0.5).normalize(),
+			phase: Math.random() * Math.PI * 2,
+			wobblePhase: Math.random() * Math.PI * 2,
+		});
+		orbitGroup.add(ring);
+	}
+
+	// Floating fragments
+	const fragments: FragmentData[] = [];
+	const fragmentCount = 12;
+	for (let i = 0; i < fragmentCount; i++) {
+		let geo: THREE.BufferGeometry;
+		const shapeType = i % 4;
+		const size = 0.08 + Math.random() * 0.06;
+
+		switch (shapeType) {
+			case 0:
+				geo = trackGeo(new THREE.TetrahedronGeometry(size));
+				break;
+			case 1:
+				geo = trackGeo(new THREE.OctahedronGeometry(size));
+				break;
+			case 2:
+				geo = trackGeo(new THREE.BoxGeometry(size, size * 0.3, size * 0.3));
+				break;
+			default:
+				geo = trackGeo(new THREE.IcosahedronGeometry(size * 0.7, 0));
+		}
+
+		const mat = trackMat<THREE.MeshBasicMaterial>(
+			new THREE.MeshBasicMaterial({
+				color: 0x666666,
+				wireframe: Math.random() > 0.5,
+				transparent: true,
+				opacity: 0.6 + Math.random() * 0.3,
+				blending: THREE.AdditiveBlending,
+			})
+		);
+
+		const mesh = new THREE.Mesh(geo, mat);
+		const orbitRadius = 1.6;
+		const orbitOffset = (i / fragmentCount) * Math.PI * 2;
+		mesh.position.set(
+			Math.cos(orbitOffset) * orbitRadius,
+			(Math.random() - 0.5) * 0.4,
+			Math.sin(orbitOffset) * orbitRadius
+		);
+		mesh.rotation.set(Math.random() * Math.PI, Math.random() * Math.PI, Math.random() * Math.PI);
+
+		fragments.push({
+			mesh,
+			material: mat,
+			orbitRadius,
+			orbitSpeed: 0.4,
+			orbitAngle: orbitOffset,
+			bobSpeed: 1 + Math.random() * 1.5,
+			bobPhase: Math.random() * Math.PI * 2,
+		});
+		fragmentGroup.add(mesh);
+	}
+
+	// Particle system
+	const particleCount = 60;
+	const pGeo = trackGeo(new THREE.BufferGeometry());
+	const pPos = new Float32Array(particleCount * 3);
+	const particleVelocities: ParticleVelocity[] = [];
+	for (let i = 0; i < particleCount; i++) {
+		const r = 1.5 + Math.random() * 2.5;
+		const theta = Math.random() * Math.PI * 2;
+		const phi = Math.acos(Math.random() * 2 - 1);
+		pPos[i * 3] = r * Math.sin(phi) * Math.cos(theta);
+		pPos[i * 3 + 1] = r * Math.sin(phi) * Math.sin(theta);
+		pPos[i * 3 + 2] = r * Math.cos(phi);
+
+		particleVelocities.push({
+			x: (Math.random() - 0.5) * 0.15,
+			y: (Math.random() - 0.5) * 0.15,
+			z: (Math.random() - 0.5) * 0.15,
+			phase: Math.random() * Math.PI * 2,
+		});
+	}
+
+	pGeo.setAttribute("position", new THREE.BufferAttribute(pPos, 3));
+	const particleMat = trackMat<THREE.PointsMaterial>(
+		new THREE.PointsMaterial({
+			color: 0x888888,
+			size: 0.025,
+			transparent: true,
+			opacity: 0.5,
+			blending: THREE.AdditiveBlending,
+		})
+	);
+	const particleSystem = new THREE.Points(pGeo, particleMat);
+	scene.add(particleSystem);
+	const particlePos = particleSystem.geometry.attributes.position as THREE.BufferAttribute;
+
+	// Sigil lines connecting fragments
+	const sigilGeo = trackGeo(new THREE.BufferGeometry());
+	const sigilPositions = new Float32Array(fragmentCount * 2 * 3);
+	sigilGeo.setAttribute("position", new THREE.BufferAttribute(sigilPositions, 3));
+
+	const sigilMat = trackMat<THREE.LineBasicMaterial>(
+		new THREE.LineBasicMaterial({
+			color: 0x444444,
+			transparent: true,
+			opacity: 0.3,
+			blending: THREE.AdditiveBlending,
+		})
+	);
+	const sigilLines = new THREE.LineSegments(sigilGeo, sigilMat);
+	scene.add(sigilLines);
+	const sigilPos = sigilLines.geometry.attributes.position as THREE.BufferAttribute;
+
+	// Central light
+	const pointLight = new THREE.PointLight(0xffffff, 0.8, 6);
+	pointLight.position.set(0, 0, 0.5);
+	coreGroup.add(pointLight);
+
+	return {
+		mainAnchor,
+		coreGroup,
+		orbitGroup,
+		fragmentGroup,
+		coreMesh,
+		glowMesh,
+		glowMat,
+		eye,
+		eyeMat,
+		pupil,
+		pupilMat,
+		rings,
+		fragments,
+		particleSystem,
+		particleMat,
+		particlePos,
+		particleVelocities,
+		sigilLines,
+		sigilMat,
+		sigilPos,
+		pointLight,
+	};
+}

package/src/avatar/rig/state/rig-state.ts

@@ -0,0 +1,193 @@
+import type { AvatarColorTheme } from "src/types";
+
+export interface PhaseState {
+	drift: number;
+	corePulse: number;
+	eyePulse: number;
+	pupilPulse: number;
+	sigilPulse: number;
+}
+
+export interface IntensityState {
+	current: number;
+	target: number;
+	spinBoost: number;
+}
+
+export interface AudioState {
+	current: number;
+	target: number;
+}
+
+export interface GlitchState {
+	timer: number;
+	isActive: boolean;
+	duration: number;
+}
+
+export interface ToolState {
+	active: boolean;
+	flashTimer: number;
+	flashColor: number;
+	fragmentScatterBoost: number;
+	sigilBrightnessBoost: number;
+	settleTimer: number;
+}
+
+export interface ReasoningState {
+	active: boolean;
+	blend: number;
+}
+
+export interface TypingState {
+	active: boolean;
+	pulse: number;
+	eyeScanTimer: number;
+	eyeScanInterval: number;
+}
+
+export interface IdleMicroGlitchState {
+	timer: number;
+	cooldown: number;
+	active: boolean;
+	duration: number;
+}
+
+export interface EyeDriftState {
+	x: number;
+	y: number;
+	targetX: number;
+	targetY: number;
+	timer: number;
+	interval: number;
+}
+
+export interface ParticlePulseState {
+	timer: number;
+	interval: number;
+	brightness: number;
+}
+
+export interface CoreDriftState {
+	x: number;
+	y: number;
+	z: number;
+	phaseX: number;
+	phaseY: number;
+	phaseZ: number;
+}
+
+export interface SpawnState {
+	progress: number;
+	elapsed: number;
+	complete: boolean;
+	glitchIntensity: number;
+}
+
+export interface ThemeState {
+	current: AvatarColorTheme;
+	target: AvatarColorTheme;
+}
+
+export interface RigState {
+	phase: PhaseState;
+	intensity: IntensityState;
+	audio: AudioState;
+	glitch: GlitchState;
+	tool: ToolState;
+	reasoning: ReasoningState;
+	typing: TypingState;
+	idleMicroGlitch: IdleMicroGlitchState;
+	eyeDrift: EyeDriftState;
+	particlePulse: ParticlePulseState;
+	coreDrift: CoreDriftState;
+	spawn: SpawnState;
+	theme: ThemeState;
+}
+
+export const DEFAULT_THEME: AvatarColorTheme = {
+	primary: 0x9ca3af,
+	glow: 0x67e8f9,
+	eye: 0xff0000,
+};
+
+export function createInitialState(): RigState {
+	return {
+		phase: {
+			drift: 0,
+			corePulse: 0,
+			eyePulse: 0,
+			pupilPulse: 0,
+			sigilPulse: 0,
+		},
+		intensity: {
+			current: 0,
+			target: 0,
+			spinBoost: 0,
+		},
+		audio: {
+			current: 0,
+			target: 0,
+		},
+		glitch: {
+			timer: 0,
+			isActive: false,
+			duration: 0,
+		},
+		tool: {
+			active: false,
+			flashTimer: 0,
+			flashColor: 0xffffff,
+			fragmentScatterBoost: 0,
+			sigilBrightnessBoost: 0,
+			settleTimer: 0,
+		},
+		reasoning: {
+			active: false,
+			blend: 0,
+		},
+		typing: {
+			active: false,
+			pulse: 0,
+			eyeScanTimer: 0,
+			eyeScanInterval: 0.5,
+		},
+		idleMicroGlitch: {
+			timer: 0,
+			cooldown: 3 + Math.random() * 5,
+			active: false,
+			duration: 0,
+		},
+		eyeDrift: {
+			x: 0,
+			y: 0,
+			targetX: 0,
+			targetY: 0,
+			timer: 0,
+			interval: 1.5 + Math.random() * 2,
+		},
+		particlePulse: {
+			timer: 0,
+			interval: 1 + Math.random() * 2,
+			brightness: 0,
+		},
+		coreDrift: {
+			x: 0,
+			y: 0,
+			z: 0,
+			phaseX: Math.random() * Math.PI * 2,
+			phaseY: Math.random() * Math.PI * 2,
+			phaseZ: Math.random() * Math.PI * 2,
+		},
+		spawn: {
+			progress: 0,
+			elapsed: 0,
+			complete: false,
+			glitchIntensity: 1,
+		},
+		theme: {
+			current: { ...DEFAULT_THEME },
+			target: { ...DEFAULT_THEME },
+		},
+	};
+}