← Back to Skills Marketplace
nickflach

Kannaka Eye

by Nick Flach · GitHub ↗ · v1.0.1 · MIT-0
cross-platform ⚠ suspicious
359
Downloads
0
Stars
0
Active Installs
2
Versions
Install in OpenClaw
/install kannaka-eye
Description
Glyph viewer that renders the SGA geometric fingerprint of any data as a stunning multi-layer canvas visualization. Takes text, files, or raw bytes and produ...
README (SKILL.md)

\r \r

Kannaka Eye Skill\r

\r See the geometry of information. Every piece of data has an intrinsic\r geometric fingerprint when viewed through the lens of SGA. Kannaka Eye\r makes these hidden patterns visible as living, breathing glyphs.\r \r

Prerequisites\r

\r

  • Node.js 18+ on PATH\r
  • That's it. No npm install, no build step.\r \r

Quick Start\r

\r

# Start the glyph viewer\r
./scripts/eye.sh start\r
\r
# Start on a custom port\r
./scripts/eye.sh start --port 4444\r
\r
# Check status\r
./scripts/eye.sh status\r
\r
# Stop\r
./scripts/eye.sh stop\r
```\r
\r
Open `http://localhost:3333` in your browser.\r
\r
## Input Methods\r
\r
- **Text** — type or paste any text; glyph updates in real-time as you type\r
- **File upload** — drag & drop or click to upload any file (images, audio, code, binaries)\r
- **Preset examples** — built-in samples demonstrating different SGA class signatures\r
- **URL share links** — open a glyph from a URL-encoded share link\r
\r
## Rendering Layers\r
\r
The viewer renders 6 canvas layers, composited in real-time:\r
\r
| Layer | Name | What It Shows |\r
|-------|------|---------------|\r
| 1 | Deep Background | Fano plane skeleton — 7 nodes, 7 lines |\r
| 2 | Fold Path | Primary visual flow via Bezier curves through SGA space |\r
| 3 | Fano Energy Bloom | 7 radiating petals — energy distribution across Fano lines |\r
| 4 | Geometric Core | Dominant SGA class sigil — the glyph's "face" |\r
| 5 | Resonance Rings | Concentric depth distribution across context levels |\r
| 6 | Metadata Overlay | Fano signatures, SGA centroids, musical frequencies (toggleable) |\r
\r
## SGA Mathematics\r
\r
Built on the 84-class system: `Cl₀,₇ ⊗ ℝ[ℤ₄] ⊗ ℝ[ℤ₃]`\r
\r
| Component | Range | Meaning |\r
|-----------|-------|---------|\r
| h₂ | 0–3 | Frequency band (bass, tenor, alto, soprano) |\r
| d | 0–2 | Modality (experienced, learned, imagined) |\r
| ℓ | 0–6 | Context slot — Fano plane line index |\r
\r
**Fano Lines:** 7 oriented triples forming the geometric backbone.\r
Each line connects 3 of the 7 points in the smallest finite projective plane (PG(2,2)).\r
\r
**Fold Sequences:** Paths through the 84-class space showing how data evolves\r
across geometric neighborhoods. Rendered as flowing Bezier curves.\r
\r
### Native Classification\r
\r
When `KANNAKA_BIN` is set (or auto-detected at `../kannaka-memory/target/release/kannaka.exe`), Eye uses the canonical Rust SGA classifier instead of the built-in JS approximation. The API response includes `"classifier": "native"` or `"classifier": "fallback"`.\r
\r
### API Endpoints\r
\r
| Endpoint | Method | Description |\r
|----------|--------|-------------|\r
| `GET /` | GET | Glyph viewer (main UI) |\r
| `POST /api/process` | POST | Classify data → glyph JSON |\r
| `GET /api/radio` | GET | Fetch Radio perception as classifiable bytes |\r
| `GET /api/constellation` | GET | Constellation status (eye, radio, memory) |\r
| `GET /api/constellation.svg` | GET | Fano plane SVG with service dots |\r
| `GET /constellation` | GET | Health dashboard page |\r
\r
### Share Links\r
\r
Compact glyph data encoded as base64 in URL hash: `http://localhost:3333/#glyph=\x3Cbase64>`\r
\r
### Constellation Dashboard\r
\r
`/constellation` serves a live health dashboard showing all three services with auto-refresh every 10 seconds.\r
\r
## Export\r
\r
- **Save as PNG** — 2x resolution canvas export\r
- **Save Glyph Data** — JSON with fold sequence, Fano signature, SGA centroid, frequencies\r
- **Copy Share Link** — URL-encoded glyph for sharing (small data only)\r
\r
## Environment Variables\r
\r
| Variable | Default | Description |\r
|----------|---------|-------------|\r
| `EYE_PORT` | `3333` | HTTP port for the viewer |\r
| `KANNAKA_BIN` | auto-detect | Path to kannaka binary for native classification |\r
| `RADIO_PORT` | `8888` | Radio bridge endpoint port |\r
| `FLUX_URL` | — | Flux instance URL (enables event publishing) |\r
| `FLUX_AGENT_ID` | `kannaka-eye` | Agent ID for Flux events |\r
\r
## Architecture\r
\r
Single-file Node.js server (`server.js`) with inline HTML/CSS/JS — the\r
complete SGA implementation is self-contained. No npm dependencies.\r
The SGA classifier is ported from kannaka-radio and generalized for\r
arbitrary data types.\r
\r
## Notes\r
\r
- All rendering happens client-side — the server only classifies input and serves the page\r
- File uploads are processed in-memory; nothing is persisted server-side\r
- The viewer is designed for local/trusted network use — no authentication\r
- Glyph appearance is deterministic: same input always produces the same glyph\r
- Dark cosmic theme (#050508) with purple accents (#c084fc) and golden-ratio color spacing\r
Usage Guidance
Do not run this skill as-is. The package is missing the server.js implementation the README and SKILL.md describe, so you cannot audit network or file-handling behavior. Ask the publisher for the full server source (server.js) and verify it locally before running. If you do run it, keep FLUX_URL unset unless you trust the remote endpoint (setting it would cause the skill to publish glyph events remotely and could leak processed input). Also verify any native KANNAKA_BIN auto-detection path and review what that binary does before allowing it to be used. If you cannot obtain and review server.js, treat the skill as incomplete/untrusted.
Capability Analysis
Type: OpenClaw Skill Name: kannaka-eye Version: 1.0.1 The kannaka-eye skill is a visualization tool for 'Sigmatics Geometric Algebra' (SGA) fingerprints, providing a Node.js server to render data as geometric glyphs. While the core logic file (server.js) is missing from the provided bundle and the management script (scripts/eye.sh) contains a likely erroneous path calculation (looking three levels above the script directory), there is no evidence of malicious intent. All documented behaviors, such as optional data publishing to a Flux URL and local API bridges, are transparently described in SKILL.md and README.md and align with the stated purpose of the tool.
Capability Assessment
Purpose & Capability
The SKILL.md claims a single-file Node.js server (server.js) that provides upload/processing endpoints, but the package does not include server.js or any JS server source — only a CLI wrapper (scripts/eye.sh), README, SKILL.md and metadata. _meta.json lists a dependency on 'flux' and optional binaries while the actual code implementing network behavior is absent. This mismatch suggests the published bundle is incomplete or altered; you cannot verify the server's behavior from the provided files.
Instruction Scope
The runtime instructions tell the agent/user to run ./scripts/eye.sh which invokes node server.js; since server.js is not present we cannot validate the described endpoints (/api/process, /api/radio, /api/constellation) or confirm claims such as "uploads processed in-memory only". The docs also describe optional publishing of glyph.rendered events to a Flux URL (FLUX_URL) — enabling that would transmit data off-host. The SKILL.md references auto-detection of a native binary at ../kannaka-memory/target/release/kannaka.exe which reaches outside the repo and could cause the service to invoke external binaries if present.
Install Mechanism
No install spec (instruction-only) and a small shell wrapper are provided, which is low-risk in itself. However, because the main server code is missing from the bundle, the claimed "zero dependencies" server cannot be validated; if the real server is fetched or replaced at runtime, that would increase risk. The provided scripts themselves are benign shell wrappers that start/stop node, use lsof/netstat to find a process, and call kill.
Credentials
Declared requirements are minimal (node only) and optional environment variables (KANNAKA_BIN, EYE_PORT, RADIO_PORT, FLUX_URL, FLUX_AGENT_ID) align with the described functionality. The primary proportionality concern is FLUX_URL: if set, the skill would (per its docs) publish events remotely, which could leak processed or uploaded data. The auto-detect path for KANNAKA_BIN points outside the project and could cause the service to execute a local native binary if present.
Persistence & Privilege
The skill is not always-enabled and is user-invocable (defaults). There is no install step that writes persistent system-wide config in the provided files. Nothing in the bundle requests elevated or persistent privileges. Autonomous invocation is allowed by default but not accompanied here by other high-risk signals.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install kannaka-eye
  3. After installation, invoke the skill by name or use /kannaka-eye
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v1.0.1
Kannaka Eye 1.0.1 adds native classifier integration, constellation dashboard, and radio bridge. - Native SGA classifier integration: auto-detects and uses a Rust binary for more accurate glyphs (fallbacks to JS if unavailable) - New constellation dashboard with live health status and SVG at /constellation and /api/constellation.svg - Radio bridge endpoint fetches and classifies audio features from kannaka-radio - Expanded environment variables and API endpoints for constellation status, radio, and SVG export - Added share links via URL hash for exchanging glyphs - Documentation updated and README.md added
v1.0.0
Initial release of Kannaka Eye glyph viewer — visualize the intrinsic geometric signature of any data using SGA and Fano plane. - Single-file Node.js server: no dependencies, no installation required beyond Node.js 18+. - Supports real-time glyph rendering from text, file upload, or preset/example data. - Visualizes SGA (84-class) structure in a multi-layer canvas with Fano plane topology. - Exports glyphs as PNG, JSON data, or shareable URL links. - Publishes glyph render events to Flux if configured. - Everything runs locally in your browser; input data is processed in-memory only.
Metadata
Slug kannaka-eye
Version 1.0.1
License MIT-0
All-time Installs 0
Active Installs 0
Total Versions 2
Frequently Asked Questions

What is Kannaka Eye?

Glyph viewer that renders the SGA geometric fingerprint of any data as a stunning multi-layer canvas visualization. Takes text, files, or raw bytes and produ... It is an AI Agent Skill for Claude Code / OpenClaw, with 359 downloads so far.

How do I install Kannaka Eye?

Run "/install kannaka-eye" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Kannaka Eye free?

Yes, Kannaka Eye is completely free, licensed under MIT-0. You can download, install and use it at no cost.

Which platforms does Kannaka Eye support?

Kannaka Eye is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Kannaka Eye?

It is built and maintained by Nick Flach (@nickflach); the current version is v1.0.1.

💬 Comments