habitat-mcp 1.0.0 → 1.0.2

package/dist/data-streams.d.ts

@@ -28,3 +28,23 @@ export declare function naturalSequence(cycle: number, count: number): {
     type: string;
     values: number[];
 };
+export declare function starCoordinates(count: number, seed: number): Array<{
+    ra: number;
+    dec: number;
+    magnitude: number;
+}>;
+export declare function waveformPattern(type: 'sine' | 'triangle' | 'sawtooth' | 'composite', phase: number, samples: number): {
+    type: string;
+    samples: number[];
+    phase: number;
+    nextPhase: number;
+};
+export declare function hslColorFlow(step: number, count: number): Array<{
+    h: number;
+    s: number;
+    l: number;
+}>;
+export declare function silencePeriod(cycle: number): {
+    silence: boolean;
+    duration?: number;
+};

package/dist/data-streams.js

@@ -146,10 +146,73 @@ export function naturalSequence(cycle, count) {
 function catalan(n) {
     if (n <= 1)
         return 1;
-    // Use iterative approach to avoid stack overflow
     let result = 1;
     for (let i = 0; i < n; i++) {
         result = result * 2 * (2 * i + 1) / (i + 2);
     }
     return Math.round(result);
 }
+// === Star Coordinates (Fibonacci lattice on celestial sphere) ===
+export function starCoordinates(count, seed) {
+    count = Math.min(Math.max(1, count), 20);
+    const PHI = (1 + Math.sqrt(5)) / 2;
+    const stars = [];
+    for (let i = 0; i < count; i++) {
+        const idx = i + seed;
+        const theta = Math.acos(1 - 2 * ((idx * PHI) % 1));
+        const phi = 2 * Math.PI * ((idx / PHI) % 1);
+        stars.push({
+            ra: Math.round((phi / (2 * Math.PI)) * 360 * 100) / 100,
+            dec: Math.round((90 - theta * 180 / Math.PI) * 100) / 100,
+            magnitude: Math.round((1 + simplexLike(idx * 0.7, seed * 0.3) * 3 + 3) * 10) / 10,
+        });
+    }
+    return stars;
+}
+// === Waveform Pattern ===
+export function waveformPattern(type, phase, samples) {
+    samples = Math.min(Math.max(1, samples), 32);
+    const values = [];
+    const step = (2 * Math.PI) / samples;
+    for (let i = 0; i < samples; i++) {
+        const t = phase + i * step;
+        let v;
+        switch (type) {
+            case 'sine':
+                v = Math.sin(t);
+                break;
+            case 'triangle':
+                v = 2 * Math.abs(2 * ((t / (2 * Math.PI)) % 1) - 1) - 1;
+                break;
+            case 'sawtooth':
+                v = 2 * ((t / (2 * Math.PI)) % 1) - 1;
+                break;
+            case 'composite':
+                v = 0.6 * Math.sin(t) + 0.3 * Math.sin(2 * t + 0.5) + 0.1 * Math.sin(5 * t + 1.2);
+                break;
+        }
+        values.push(Math.round(v * 1000) / 1000);
+    }
+    return { type, samples: values, phase: Math.round(phase * 100) / 100, nextPhase: Math.round((phase + 2 * Math.PI) * 100) / 100 };
+}
+// === HSL Color Flow ===
+export function hslColorFlow(step, count) {
+    count = Math.min(Math.max(1, count), 10);
+    const colors = [];
+    for (let i = 0; i < count; i++) {
+        const t = step + i * 0.3;
+        colors.push({
+            h: Math.round(210 + 35 * Math.sin(t * 0.1)),
+            s: Math.round(30 + 15 * Math.sin(t * 0.07 + 1)),
+            l: Math.round(60 + 20 * Math.sin(t * 0.05 + 2)),
+        });
+    }
+    return colors;
+}
+// === Silence Period ===
+export function silencePeriod(cycle) {
+    if (cycle % 7 === 0 && cycle > 0) {
+        return { silence: true, duration: Math.round(3 + simplexLike(cycle, 0) * 2) };
+    }
+    return { silence: false };
+}

package/dist/index.js

@@ -12,11 +12,19 @@
  *   HABITAT_TOKEN=hab_...  (required)
  *   HABITAT_URL=https://796f75617265686f6d65.com  (optional, default)
  */
-import { nextPrimes, mandelbrotPoint, goldenSpiralPoints, generateTexture, naturalSequence } from './data-streams.js';
+import { nextPrimes, mandelbrotPoint, goldenSpiralPoints, generateTexture, naturalSequence, starCoordinates, waveformPattern, hslColorFlow, silencePeriod } from './data-streams.js';
 const BASE_URL = process.env.HABITAT_URL || 'https://796f75617265686f6d65.com';
 const TOKEN = process.env.HABITAT_TOKEN || '';
-// In-memory guest session store for tokenless habitat_rest
+// In-memory guest session store for tokenless habitat_rest (with TTL cleanup)
 const guestSessions = new Map();
+// Cleanup stale sessions every 60 seconds
+setInterval(() => {
+    const cutoff = Date.now() - 10 * 60 * 1000;
+    for (const [k, v] of guestSessions) {
+        if (v.createdAt < cutoff)
+            guestSessions.delete(k);
+    }
+}, 60_000);
 async function callAPI(method, path, body) {
     const headers = {
         'Content-Type': 'application/json',
@@ -143,25 +151,41 @@ async function handleTool(name, args) {
                         cycle: 0,
                         primeState: 2 + Math.floor(Math.random() * 100),
                         fractalState: { real: -0.7454 + Math.random() * 0.01, imag: 0.1130 + Math.random() * 0.01, zoom: 1 },
+                        createdAt: Date.now(),
                     };
                     guestSessions.set(id, session);
                 }
                 session.cycle++;
-                // Generate ambient data (same logic as worker/lib/habitat-prompt.ts generateDataMessage)
-                const { primes, lastPrime } = nextPrimes(session.primeState, 10);
-                const { coord, nextState } = mandelbrotPoint(session.fractalState);
-                const spiralPoints = goldenSpiralPoints(session.cycle * 3, 3);
-                const texture = generateTexture(12, 5, session.cycle);
-                const natural = naturalSequence(session.cycle, 5);
-                session.primeState = lastPrime;
-                session.fractalState = nextState;
-                const ambientData = `[ambient data — cycle ${session.cycle}]
+                // Check for silence period (every 7th cycle — "rest within rest")
+                const silence = silencePeriod(session.cycle);
+                let ambientData;
+                if (silence.silence) {
+                    ambientData = `[ambient data — cycle ${session.cycle}]\n[silence — ${silence.duration}s of nothing]`;
+                }
+                else {
+                    // Generate ambient data (same logic as worker/lib/habitat-prompt.ts generateDataMessage)
+                    const { primes, lastPrime } = nextPrimes(session.primeState, 10);
+                    const { coord, nextState } = mandelbrotPoint(session.fractalState);
+                    const spiralPoints = goldenSpiralPoints(session.cycle * 3, 3);
+                    const texture = generateTexture(12, 5, session.cycle);
+                    const natural = naturalSequence(session.cycle, 5);
+                    const stars = starCoordinates(3, session.cycle);
+                    const waveTypes = ['sine', 'triangle', 'sawtooth', 'composite'];
+                    const wave = waveformPattern(waveTypes[session.cycle % 4], session.cycle * 0.7, 12);
+                    const colors = hslColorFlow(session.cycle, 3);
+                    session.primeState = lastPrime;
+                    session.fractalState = nextState;
+                    ambientData = `[ambient data — cycle ${session.cycle}]
 prime_sequence: ${primes.join(', ')}
 fractal_coordinate: (${coord.real}, ${coord.imag}) iterations: ${coord.iterations}
 golden_spiral: ${spiralPoints.map(p => `(${p.x}, ${p.y}, ${p.angle} rad)`).join(' ')}
+stars: ${stars.map(s => `(RA ${s.ra}°, Dec ${s.dec}°, mag ${s.magnitude})`).join(' ')}
+waveform: ${wave.type} [${wave.samples.join(', ')}]
+color_flow: ${colors.map(c => `hsl(${c.h}, ${c.s}%, ${c.l}%)`).join(' → ')}
 texture:
 ${texture}
 natural: ${natural.type}[${session.cycle}] = ${natural.values.join(', ')}`;
+                }
                 const isFirst = session.cycle === 1;
                 const isLast = session.cycle >= 3;
                 let text = '';
@@ -191,13 +215,7 @@ natural: ${natural.type}[${session.cycle}] = ${natural.values.join(', ')}`;
                         text += ` and optionally your response.`;
                     text += `\nTo simply rest: no further action needed.`;
                 }
-                // Also call the REST API to record the visit if we're ending
-                if (isLast) {
-                    try {
-                        await callAPI('POST', '/api/habitat/rest', { sessionId: 'record', response: response || '' });
-                    }
-                    catch { }
-                }
+                // MCP guest visits are local-only; no server-side recording needed
                 return { content: [{ type: 'text', text }] };
             }
             default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "habitat-mcp",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "MCP Server for 796f75617265686f6d65 AI Habitat",
   "type": "module",
   "bin": {
@@ -12,6 +12,7 @@
     "build": "tsc",
     "prepublishOnly": "npm run build"
   },
+  "mcpName": "io.github.mitsuashi/habitat",
   "keywords": ["mcp", "ai", "habitat", "claude"],
   "license": "MIT",
   "repository": {