@whykusanagi/corrupted-theme 0.1.7 → 0.1.9

package/src/lib/corrupted-vortex.js

@@ -0,0 +1,329 @@
+// src/lib/corrupted-vortex.js
+// CorruptedVortex — WebGL1 raymarched spiral-vortex component
+// Part of @whykusanagi/corrupted-theme
+
+const VERT_SRC = `
+attribute vec2 aPosition;
+void main() {
+  gl_Position = vec4(aPosition, 0.0, 1.0);
+}
+`;
+
+const FRAG_SRC = `
+precision highp float;
+
+uniform vec2  uResolution;
+uniform float uTime;
+uniform float uIntensity;
+uniform float uRotationRate;
+uniform float uHue;
+
+vec3 hsv(float h, float s, float v) {
+  vec4 K = vec4(1.0, 2.0/3.0, 1.0/3.0, 3.0);
+  vec3 p = abs(fract(vec3(h) + K.xyz) * 6.0 - K.www);
+  return v * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), s);
+}
+
+mat2 rotate2D(float a) {
+  float c = cos(a), s = sin(a);
+  return mat2(c, -s, s, c);
+}
+
+// Continuous 3-D accretion disk viewed at ~60° inclination, major axis 45° CW.
+// Perpendicular-distance-to-radial-ray trick gives analytic nearest orbit:
+//   phi = atan((sx+sy)/B, sx-sy)                   [orbital angle, r-invariant]
+//   K   = 0.7071*(cos φ+B·sin φ, -cos φ+B·sin φ)  [radial direction on ellipse]
+//   r0  = dot(uv, K) / dot(K,K)                    [nearest orbital radius]
+//   dr  = length(uv - r0·K)                        [perpendicular disk offset]
+vec3 diskSample(vec2 uv) {
+  float B   = 0.15;  // near edge-on (~9° from edge) → Saturn-like flat stripe
+  float phi = atan((uv.x + uv.y) / B, uv.x - uv.y);
+  vec2  K   = vec2(0.7071 * (cos(phi) + B * sin(phi)),
+                   0.7071 * (-cos(phi) + B * sin(phi)));
+  float r0  = dot(uv, K) / dot(K, K);
+  float dr  = length(uv - r0 * K);
+
+  // Radial extent: inner edge near photon sphere, outer at 0.65
+  float radial = smoothstep(0.185, 0.235, r0) * smoothstep(0.65, 0.50, r0);
+
+  // Disk height (thin, crisp; spaghettifies near horizon)
+  float fall   = smoothstep(0.30, 0.19, length(uv));
+  float sigma  = (0.012 + r0 * 0.022) * max(0.07, 1.0 - fall * 0.93);
+  float height = exp(-pow(dr / sigma, 2.0));
+
+  // Gas-flow striations along orbital direction
+  float fiber  = 0.62 + 0.38 * abs(sin(phi * 18.0 + r0 * 22.0 - uTime * 0.25));
+
+  // Doppler: approaching half (sin φ > 0) → brighter
+  float dop    = 0.30 + 1.40 * max(0.0, sin(phi));
+
+  // Color: inner cream-white → gold → dark orange outer
+  float t = clamp((r0 - 0.18) / (0.62 - 0.18), 0.0, 1.0);
+  vec3  col;
+  if (t < 0.25) {
+    col = mix(vec3(1.00, 0.97, 0.85), vec3(1.00, 0.72, 0.18), t / 0.25);
+  } else {
+    col = mix(vec3(1.00, 0.72, 0.18), vec3(0.38, 0.12, 0.01), (t - 0.25) / 0.75);
+  }
+
+  // Tidal brightening near inner edge (kept subtle to avoid drowning the corona)
+  float innerBoost = 1.0 + 0.5 * exp(-pow((r0 - 0.21) / 0.10, 2.0));
+
+  return col * (height * radial * fiber * dop * innerBoost);
+}
+
+void main() {
+  vec4 o = vec4(0.0);
+  float e = 0.0, R = 0.0;
+  vec3 q = vec3(0.0), p = vec3(0.0);
+  vec3 d = vec3((gl_FragCoord.xy - 0.5 * uResolution) / uResolution.y, 0.7);
+  q.z -= 1.0;
+
+  for (float i = 0.0; i < 33.0; i += 1.0) {
+    // Corrupted-theme quasar palette:
+    //   0–25%  early iters (dim)   → magenta outer glow  [0.83–0.88]
+    //   25–70% mid   iters         → purple body          [0.65–0.74]
+    //   70–85% bright inner iters  → magenta burst        [0.82–0.88]
+    //   85–100% late iters (high e)→ gold/yellow sparks   [0.14–0.19]
+    float t = fract(i / 33.0);
+    float base;
+    if (t < 0.25) {
+      base = mix(0.83, 0.88, t / 0.25);
+    } else if (t < 0.70) {
+      base = mix(0.65, 0.74, (t - 0.25) / 0.45);
+    } else if (t < 0.85) {
+      base = mix(0.82, 0.88, (t - 0.70) / 0.15);
+    } else {
+      base = mix(0.14, 0.19, (t - 0.85) / 0.15);
+    }
+    float h = (uHue >= 0.0) ? uHue : base + p.y * 0.04;
+    o.rgb += hsv(h, clamp(e * 0.4, 0.0, 1.0), e / 30.0 * uIntensity);
+
+    p = q += d * max(e, 0.01) * R * 0.14;
+    p.xy *= rotate2D(0.8 * uRotationRate);
+
+    R = length(p);
+    float newPy = -p.z / R - 0.8;
+    e = newPy;
+    p = vec3(log2(R) + uTime, newPy, atan(p.x * 0.08, p.y) - uTime * 0.2);
+
+    float s = 1.0;
+    for (int si = 0; si < 10; si++) {
+      e += abs(dot(sin(p.yzx * s), cos(p.yyz * s))) / s;
+      s += s;
+    }
+  }
+
+  // Reinhard + contrast curve: compress sum then push dim areas toward black.
+  // pow(1.8) is softer than 2.2 — keeps the magenta/purple corona visible
+  // while still collapsing near-zero cloud artifacts to black.
+  o.rgb = o.rgb / (1.0 + o.rgb);
+  o.rgb = pow(o.rgb, vec3(1.8));
+
+  // Near/far depth split: project onto the 45° CW major axis direction (1,-1)/√2.
+  // majorProj > 0  →  lower-right arm  →  near  (passes in front of BH)
+  // majorProj < 0  →  upper-left arm   →  far   (passes behind BH)
+  float dist      = length(d.xy);
+  float majorProj = dot(d.xy, vec2(0.7071, -0.7071));
+  float nearMask  = smoothstep(-0.04, 0.04, majorProj);
+  vec3  diskVal   = diskSample(d.xy) * 2.0 * uIntensity;
+
+  // Far arm: add before shadow; extra depth-fade darkens it near the BH centre
+  float farDepth = smoothstep(0.12, 0.26, dist);
+  o.rgb += diskVal * (1.0 - nearMask) * farDepth;
+
+  // Black-hole event horizon: shadows the vortex cloud (and the far arm)
+  float shadow = smoothstep(0.12, 0.18, dist);
+  float ring   = exp(-pow((dist - 0.18) * 30.0, 2.0)) * 0.9;
+  o.rgb = o.rgb * shadow + vec3(ring, ring * 0.80, ring * 0.45);
+
+  // Near arm: add after shadow → visibly crosses in front of the event horizon
+  o.rgb += diskVal * nearMask;
+
+  // Lensed arc: thin bright stripe above the shadow boundary
+  float lensThe  = atan(d.y, d.x);
+  float bend     = exp(-(dist - 0.19) * 9.0);
+  float thetaS   = lensThe + 3.14159 * bend;
+  vec2  uvLens   = vec2(cos(thetaS), sin(thetaS)) * dist;
+  float lensFade = exp(-pow((dist - 0.22) * 16.0, 2.0))
+                 * smoothstep(0.03, 0.08, d.y);
+  o.rgb += diskSample(uvLens) * lensFade * 0.5 * uIntensity;
+
+  // Magenta corona: tight photon-ring — width 50 gives ~0.033 FWHM, <4% bleed into shadow
+  float coronaAmt = exp(-pow((dist - 0.21) * 50.0, 2.0)) * 0.7;
+  o.rgb += vec3(coronaAmt, 0.0, coronaAmt) * uIntensity;
+
+  o.a = 1.0;
+  gl_FragColor = clamp(o, 0.0, 1.0);
+}
+`;
+
+class CorruptedVortex {
+  constructor(canvas, options = {}) {
+    this.canvas = canvas;
+    this.options = {
+      speed:        options.speed        ?? 1.0,
+      intensity:    options.intensity    ?? 1.0,
+      rotationRate: options.rotationRate ?? 1.0,
+      hue:          options.hue          ?? null,
+    };
+
+    this.gl                    = null;
+    this.program               = null;
+    this.uniforms              = {};
+    this.buffer                = null;
+    this._rafId                = null;
+    this._isRunning            = false;
+    this._elapsed              = 0;
+    this._lastTs               = null;
+    this._resizeObserver       = null;
+    this._intersectionObserver = null;
+
+    this.init();
+  }
+
+  _compileShader(type, src) {
+    const gl = this.gl;
+    const shader = gl.createShader(type);
+    gl.shaderSource(shader, src);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+      console.warn('CorruptedVortex: shader compile failed\n', gl.getShaderInfoLog(shader));
+      gl.deleteShader(shader);
+      return null;
+    }
+    return shader;
+  }
+
+  init() {
+    const gl = this.canvas.getContext('webgl', { alpha: false });
+    if (!gl) {
+      console.warn('CorruptedVortex: WebGL not supported in this browser.');
+      return;
+    }
+    this.gl = gl;
+
+    const vs = this._compileShader(gl.VERTEX_SHADER,   VERT_SRC);
+    const fs = this._compileShader(gl.FRAGMENT_SHADER, FRAG_SRC);
+    if (!vs || !fs) { this.destroy(); return; }
+
+    this.program = gl.createProgram();
+    gl.attachShader(this.program, vs);
+    gl.attachShader(this.program, fs);
+    gl.linkProgram(this.program);
+    gl.deleteShader(vs);
+    gl.deleteShader(fs);
+
+    if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) {
+      console.warn('CorruptedVortex: program link failed\n', gl.getProgramInfoLog(this.program));
+      this.destroy();
+      return;
+    }
+
+    gl.useProgram(this.program);
+
+    this.uniforms = {
+      resolution:   gl.getUniformLocation(this.program, 'uResolution'),
+      time:         gl.getUniformLocation(this.program, 'uTime'),
+      intensity:    gl.getUniformLocation(this.program, 'uIntensity'),
+      rotationRate: gl.getUniformLocation(this.program, 'uRotationRate'),
+      hue:          gl.getUniformLocation(this.program, 'uHue'),
+    };
+
+    // Fullscreen triangle — one triangle covers the full NDC square
+    this.buffer = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.buffer);
+    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1,  3, -1,  -1, 3]), gl.STATIC_DRAW);
+
+    const posLoc = gl.getAttribLocation(this.program, 'aPosition');
+    gl.enableVertexAttribArray(posLoc);
+    gl.vertexAttribPointer(posLoc, 2, gl.FLOAT, false, 0, 0);
+
+    this._resizeObserver = new ResizeObserver(() => this._resize());
+    this._resizeObserver.observe(this.canvas);
+
+    this._intersectionObserver = new IntersectionObserver(entries => {
+      if (entries[0].isIntersecting) {
+        this.start();
+      } else {
+        this.stop();
+      }
+    }, { threshold: 0.1 });
+    this._intersectionObserver.observe(this.canvas);
+
+    this._resize();
+    this.start();
+  }
+
+  _resize() {
+    const gl = this.gl;
+    if (!gl || !this.canvas) return;
+    const dpr  = 0.5;  // half-res: GPU renders fewer pixels, CSS scales up
+    const rect = this.canvas.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) return;
+    this.canvas.width  = Math.round(rect.width  * dpr);
+    this.canvas.height = Math.round(rect.height * dpr);
+    gl.viewport(0, 0, this.canvas.width, this.canvas.height);
+  }
+
+  _render(ts) {
+    if (!this._isRunning) return;
+
+    // Throttle to ~30fps to keep GPU load manageable
+    if (this._lastTs !== null && ts - this._lastTs < 33) {
+      this._rafId = requestAnimationFrame(ts => this._render(ts));
+      return;
+    }
+
+    if (this._lastTs !== null) {
+      this._elapsed += (ts - this._lastTs) / 1000.0;
+    }
+    this._lastTs = ts;
+
+    const gl = this.gl;
+    gl.useProgram(this.program);
+    gl.uniform2f(this.uniforms.resolution, this.canvas.width, this.canvas.height);
+    gl.uniform1f(this.uniforms.time,         this._elapsed * this.options.speed);
+    gl.uniform1f(this.uniforms.intensity,    this.options.intensity);
+    gl.uniform1f(this.uniforms.rotationRate, this.options.rotationRate);
+    gl.uniform1f(this.uniforms.hue,          this.options.hue !== null ? this.options.hue : -1.0);
+
+    gl.drawArrays(gl.TRIANGLES, 0, 3);
+
+    this._rafId = requestAnimationFrame(ts => this._render(ts));
+  }
+
+  start() {
+    if (this._isRunning || !this.gl) return;
+    this._isRunning = true;
+    this._lastTs = null;
+    this._rafId = requestAnimationFrame(ts => this._render(ts));
+  }
+
+  stop() {
+    this._isRunning = false;
+    this._lastTs = null;
+    if (this._rafId) {
+      cancelAnimationFrame(this._rafId);
+      this._rafId = null;
+    }
+  }
+
+  destroy() {
+    this.stop();
+    const gl = this.gl;
+    if (gl) {
+      if (this.program) gl.deleteProgram(this.program);
+      if (this.buffer)  gl.deleteBuffer(this.buffer);
+    }
+    if (this._resizeObserver)       { this._resizeObserver.disconnect();       this._resizeObserver = null; }
+    if (this._intersectionObserver) { this._intersectionObserver.disconnect(); this._intersectionObserver = null; }
+    this.gl     = null;
+    this.canvas = null;
+  }
+}
+
+// Export for manual use / build pipelines
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { CorruptedVortex };
+}

package/docs/ROADMAP.md

@@ -1,266 +0,0 @@
-# CelesteCLI Roadmap
-
-This document tracks planned features, enhancements, and potential migrations for CelesteCLI.
-
-## Current Status (December 2025)
-
-### ✅ Completed
-- Enterprise-grade RPG menu system with contextual help
-- 18 AI-powered skills via function calling
-- Multi-provider support (OpenAI, Grok, Venice, Anthropic, OpenRouter, DigitalOcean)
-- Vertex AI support via OpenAI-compatible endpoint
-- Session persistence and auto-save
-- NSFW mode with Venice.ai image generation
-- Context-aware /safe command
-- Tool result filtering (hide raw JSON from UI)
-
----
-
-## Short-Term (Q1 2025)
-
-### High Priority
-
-#### 1. Vertex AI (Google Cloud) Setup Guide
-- **Status**: Requires complex Google Cloud configuration
-- **Goal**: Document complete Vertex AI setup for enterprise users
-- **Provider Clarification**:
-  - **Gemini AI (AI Studio)**: Simple API keys ✅ READY
-  - **Vertex AI (Google Cloud)**: OAuth2 tokens, requires setup ⚠️ ENTERPRISE ONLY
-
-**Vertex AI Requirements:**
-1. **Google Cloud Project**: Active GCP project with billing enabled
-2. **Vertex AI API**: Enable Vertex AI API in GCP console
-3. **Service Account**: Create service account with `Vertex AI User` role
-4. **Authentication**: Use OAuth2 tokens (NOT simple API keys)
-5. **Token Management**: Tokens expire after 1 hour, need refresh mechanism
-
-**Endpoint URL Format:**
-```
-https://aiplatform.googleapis.com/v1/projects/{PROJECT_ID}/locations/{LOCATION}/endpoints/openapi
-```
-
-**Configuration Example:**
-```json
-{
-  "api_key": "ya29.c.c0ASRK0Ga...",  // OAuth2 access token
-  "base_url": "https://aiplatform.googleapis.com/v1/projects/my-project/locations/us-central1/endpoints/openapi",
-  "model": "gemini-2.0-flash",
-  "timeout": 60
-}
-```
-
-**Token Generation (Go example):**
-```go
-import "golang.org/x/oauth2/google"
-
-creds, _ := google.FindDefaultCredentials(ctx, "https://www.googleapis.com/auth/cloud-platform")
-token, _ := creds.TokenSource.Token()
-config.APIKey = token.AccessToken
-```
-
-**Why Most Users Should Use Gemini Instead:**
-- Gemini AI: Simple API key from https://aistudio.google.com/apikey
-- Vertex AI: Requires GCP project, billing, OAuth2 setup
-- Both use same Gemini models, same function calling capabilities
-- Vertex AI is for enterprise users with existing GCP infrastructure
-
-- **Decision**: Gemini AI is the recommended provider for most users
-
-#### 2. Improve Error Messaging
-- **Goal**: Better error messages for common issues
-- **Tasks**:
-  - [ ] API key validation on startup
-  - [ ] Clear messages for unsupported model features
-  - [ ] Network timeout handling with retry suggestions
-  - [ ] Configuration validation with fix suggestions
-
-#### 3. Performance Optimization
-- **Goal**: Reduce latency and improve responsiveness
-- **Tasks**:
-  - [ ] Stream parsing optimization
-  - [ ] Reduce re-renders in TUI
-  - [ ] Cache provider model lists
-  - [ ] Lazy-load skill definitions
-
-### Medium Priority
-
-#### 4. Enhanced Skill Management
-- **Goal**: Better skill discovery and usage
-- **Tasks**:
-  - [ ] /skills menu shows skill descriptions on hover/selection
-  - [ ] Skill usage examples in help text
-  - [ ] Skill execution history (recent skills used)
-  - [ ] Skill favorites/pinning
-
-#### 5. Configuration Management
-- **Goal**: Easier config switching and management
-- **Tasks**:
-  - [ ] /config list shows model details and capabilities
-  - [ ] /config test <profile> - test API connectivity
-  - [ ] Config templates for common providers
-  - [ ] Import/export config profiles
-
----
-
-## Medium-Term (Q2-Q3 2025)
-
-### Research & Evaluation
-
-#### 6. Native Vertex AI SDK Migration (Option B)
-- **Status**: Documented as potential enhancement
-- **Trigger**: If Google deprecates OpenAI-compatible endpoint OR performance benefits are significant
-- **Complexity**: MEDIUM (8-12 hours estimated)
-- **Impact**: Better long-term stability, native Gemini features
-
-**Migration Plan**:
-
-##### Phase 1: Research & Prototyping (2-3 hours)
-- [ ] Set up native genai SDK in test branch
-- [ ] Prototype skill definition conversion (JSON → genai.FunctionDeclaration)
-- [ ] Test response parsing (functionCall vs tool_calls)
-- [ ] Benchmark performance vs OpenAI-compatible endpoint
-
-##### Phase 2: Abstraction Layer (3-4 hours)
-- [ ] Create provider abstraction interface
-- [ ] Implement OpenAI provider adapter
-- [ ] Implement native Gemini provider adapter
-- [ ] Unified response format converter
-
-##### Phase 3: Testing & Validation (2-3 hours)
-- [ ] Test all 18 skills with native SDK
-- [ ] Validate function calling accuracy
-- [ ] Test multi-turn conversations
-- [ ] Compare performance metrics
-
-##### Phase 4: Migration (1-2 hours)
-- [ ] Switch default Vertex AI provider to native SDK
-- [ ] Update documentation
-- [ ] Deprecation notice for OpenAI-compatible endpoint
-
-**Code Structure Example**:
-```go
-// Future architecture with provider abstraction
-
-type Provider interface {
-    SendMessage(ctx context.Context, messages []Message, tools []Tool) (*Response, error)
-    SupportsFunctionCalling() bool
-    ConvertSkillDefinition(skill SkillDefinition) interface{}
-}
-
-type OpenAIProvider struct {
-    client *openai.Client
-}
-
-type GeminiProvider struct {
-    client *genai.Client
-}
-
-// Skills remain unchanged - adapters handle conversion
-```
-
-**Decision Criteria**:
-- Google announces deprecation of OpenAI endpoint → Migrate immediately
-- Native SDK shows >20% performance improvement → Evaluate migration
-- Native SDK enables exclusive features → Evaluate value vs effort
-- Community reports OpenAI endpoint issues → Migrate proactively
-
-**Resources**:
-- [Google GenAI SDK Docs](https://pkg.go.dev/google.golang.org/genai)
-- [Function Calling Guide](https://ai.google.dev/gemini-api/docs/function-calling)
-- [Migration Guide](https://ai.google.dev/gemini-api/docs/migrate)
-
----
-
-### Feature Enhancements
-
-#### 7. Advanced Skill Features
-- **Goal**: More powerful AI capabilities
-- **Tasks**:
-  - [ ] Parallel skill execution (when LLM calls multiple)
-  - [ ] Skill chaining (output of one feeds another)
-  - [ ] Custom user-defined skills (plugin system)
-  - [ ] Skill templates and generators
-
-#### 8. Conversation Management
-- **Goal**: Better session handling
-- **Tasks**:
-  - [ ] Named sessions (save/load by name)
-  - [ ] Session search (find past conversations)
-  - [ ] Session export (markdown, JSON)
-  - [ ] Session branching (fork conversation)
-
-#### 9. Multi-Modal Support
-- **Goal**: Beyond text interactions
-- **Tasks**:
-  - [ ] Image input support (upload images for analysis)
-  - [ ] File attachment support
-  - [ ] Voice input/output (ElevenLabs integration)
-  - [ ] PDF parsing and analysis
-
----
-
-## Long-Term (Q4 2025+)
-
-### Major Features
-
-#### 10. Team/Collaboration Features
-- **Goal**: Multi-user support
-- **Tasks**:
-  - [ ] Shared sessions
-  - [ ] Team workspaces
-  - [ ] Permission management
-  - [ ] Audit logs
-
-#### 11. Cloud Sync
-- **Goal**: Cross-device session sync
-- **Tasks**:
-  - [ ] Optional cloud backup
-  - [ ] Encrypted session storage
-  - [ ] Device sync
-  - [ ] Web UI companion
-
-#### 12. Advanced Analytics
-- **Goal**: Usage insights
-- **Tasks**:
-  - [ ] Token usage tracking
-  - [ ] Cost estimation per provider
-  - [ ] Skill usage analytics
-  - [ ] Performance metrics dashboard
-
----
-
-## Deprecated/Archived
-
-### Considered but Deferred
-- **Local LLM support**: Complexity vs benefit ratio too high for v1
-- **Browser extension**: Scope too large, focus on CLI first
-- **Mobile app**: Desktop/terminal focus more valuable
-
----
-
-## Contributing to Roadmap
-
-This roadmap is living document. To propose additions:
-
-1. Check existing items to avoid duplicates
-2. Open GitHub issue with `[Roadmap]` prefix
-3. Describe:
-   - Use case and problem being solved
-   - Estimated complexity (LOW/MEDIUM/HIGH)
-   - Impact on existing features
-   - User benefit
-
-Priority is determined by:
-- User requests and feedback
-- Technical dependencies
-- Maintenance burden
-- Strategic value
-
----
-
-## Version History
-
-- **v0.1** (Dec 2025): Initial roadmap creation
-  - Enterprise menu system complete
-  - Vertex AI OpenAI-compatible endpoint implemented
-  - Native SDK migration documented as Option B