@dyx9/rosetta 0.0.0-stage → 0.0.1

package/build/src/shared/protocol.js

@@ -0,0 +1,25 @@
+/**
+ * The wire format between server and browser.
+ *
+ * Imported by both sides so the two cannot drift. Every value is JSON-safe:
+ * each event is serialised as one line of NDJSON.
+ */
+/**
+ * Highlighting grammars bundled with the client.
+ *
+ * Shared so the server can warn about a stone declaring a `language` that will
+ * silently render as plain text. Adding one here means adding the import in
+ * `src/lib/highlighter.ts` too.
+ */
+export const BUNDLED_LANGUAGES = [
+    "python",
+    "javascript",
+    "typescript",
+    "json",
+    "bash",
+];
+/**
+ * Name of the tool that runs a stone's checkers. Shared so the UI can say
+ * "checking" rather than "reading documentation" while it runs.
+ */
+export const CHECK_TOOL = "check_script";

package/build/stones/example/AGENTS.md

@@ -0,0 +1,25 @@
+# Stagelight
+
+Stagelight is a small Python dialect for writing stage lighting cues. It runs on an embedded
+interpreter inside the lighting desk, so only the host functions below are available. The
+Python standard library is **not** importable.
+
+## Host functions
+
+```python
+fixture(id: str) -> Fixture          # look up a fixture by its patch id, e.g. "spot-1"
+aim(f: Fixture, x: float, y: float)  # aim at a stage coordinate, in metres from centre
+intensity(f: Fixture, pct: float)    # 0.0 to 100.0
+fade(f: Fixture, pct: float, secs: float)  # ramp intensity over time
+wait(secs: float)                    # hold before the next instruction
+blackout()                           # all fixtures to 0
+```
+
+Ordinary Python control flow works: `for`, `while`, `if`, functions, arithmetic. There are no
+imports, no file access, and no networking.
+
+## Constraints
+
+The language will accept scripts that the rig cannot safely run. The rules that decide
+which are in `constraints/rig-limits.md`, which is always in your context alongside this
+file. Check every script against them before offering it.

package/build/stones/example/checks/hotspot.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""Domain check for Stagelight: the hotspot rule.
+
+No two fixtures may both exceed 70% intensity while aimed within 2.0 metres of
+each other. This is valid Stagelight in every respect; only the rig says no.
+Reads a script on stdin. Exit 0 passes.
+"""
+import ast
+import math
+import sys
+
+MIN_SEPARATION_M = 2.0
+HOT_THRESHOLD_PCT = 70.0
+
+source = sys.stdin.read()
+try:
+    tree = ast.parse(source)
+except SyntaxError:
+    sys.exit(0)  # The syntax check owns this; stay quiet.
+
+
+def number(node):
+    if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
+        return float(node.value)
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
+        inner = number(node.operand)
+        return None if inner is None else -inner
+    return None
+
+
+fixtures, aims, levels, lines = {}, {}, {}, {}
+
+for node in ast.walk(tree):
+    # name = fixture("spot-1")
+    if isinstance(node, ast.Assign) and isinstance(node.value, ast.Call):
+        call = node.value
+        if isinstance(call.func, ast.Name) and call.func.id == "fixture" and call.args:
+            arg = call.args[0]
+            if isinstance(node.targets[0], ast.Name) and isinstance(arg, ast.Constant):
+                fixtures[node.targets[0].id] = str(arg.value)
+
+    if not isinstance(node, ast.Call) or not isinstance(node.func, ast.Name):
+        continue
+    name, args = node.func.id, node.args
+
+    if name == "aim" and len(args) >= 3 and isinstance(args[0], ast.Name):
+        x, y = number(args[1]), number(args[2])
+        if x is not None and y is not None:
+            aims[args[0].id] = (x, y)
+            lines[args[0].id] = node.lineno
+    elif name in ("intensity", "fade") and len(args) >= 2 and isinstance(args[0], ast.Name):
+        pct = number(args[1])
+        if pct is not None:
+            levels[args[0].id] = max(levels.get(args[0].id, 0.0), pct)
+            lines[args[0].id] = node.lineno
+
+hot = [v for v, pct in levels.items() if pct > HOT_THRESHOLD_PCT and v in aims]
+violations = []
+for i, a in enumerate(hot):
+    for b in hot[i + 1:]:
+        gap = math.dist(aims[a], aims[b])
+        if gap < MIN_SEPARATION_M:
+            violations.append(
+                f"line {max(lines.get(a, 0), lines.get(b, 0))}: "
+                f"{fixtures.get(a, a)} ({levels[a]:.0f}%) and {fixtures.get(b, b)} "
+                f"({levels[b]:.0f}%) are {gap:.2f}m apart, minimum is {MIN_SEPARATION_M}m "
+                f"when both exceed {HOT_THRESHOLD_PCT:.0f}%"
+            )
+
+if violations:
+    print("hotspot rule violated:", file=sys.stderr)
+    for line in violations:
+        print(f"  {line}", file=sys.stderr)
+    sys.exit(1)

package/build/stones/example/checks/syntax.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""Syntax check for Stagelight: the language is a Python dialect, so the
+grammar is Python's. Reads a script on stdin. Exit 0 passes."""
+import ast
+import sys
+
+source = sys.stdin.read()
+try:
+    ast.parse(source)
+except SyntaxError as error:
+    line = error.lineno or "?"
+    print(f"line {line}: {error.msg}", file=sys.stderr)
+    sys.exit(1)

package/build/stones/example/constraints/rig-limits.md

@@ -0,0 +1,15 @@
+# Rig limits
+
+These are physical limits of the lighting rig, not rules of the language. A script that
+breaks one is still valid Stagelight and will still run — it will just damage equipment or
+the set. Never produce a script that violates them.
+
+1. **Hotspot rule.** No two fixtures may both exceed 70% intensity while aimed within 2.0
+   metres of each other. The combined heat scorches painted flats.
+2. **Slew rule.** A fixture may not be re-aimed more than 4.0 metres in under 1.0 second. The
+   yoke motor stalls and loses calibration.
+3. **Cold start.** A fixture below 10% must not jump above 80% in one step. Ramp it with
+   `fade` over at least 0.5 seconds or the lamp cracks.
+
+When a request would violate one of these, say so plainly, name the rule, and offer the
+nearest version that satisfies it.

package/build/stones/example/docs/reference.md

@@ -0,0 +1,26 @@
+# Stagelight reference
+
+## Coordinates
+
+Stage coordinates are metres from centre stage. `x` runs stage-left negative to stage-right
+positive. `y` runs downstage negative to upstage positive. The usable area is roughly
+-6.0 to 6.0 on x and -4.0 to 4.0 on y.
+
+## Timing
+
+`wait(secs)` blocks the whole script. `fade(f, pct, secs)` returns immediately and the ramp
+continues in the background, so two fades started together run in parallel.
+
+To run fades in sequence, follow each with `wait` for at least the fade duration.
+
+## Fixture ids
+
+Fixtures are patched as `spot-N`, `wash-N` or `cyc-N`. `fixture()` raises if the id is not
+patched. There is no way to enumerate fixtures from a script; the ids come from the patch
+sheet.
+
+## Errors
+
+A script that raises stops immediately and the desk holds the last state. It does not black
+out. Always end a cue sequence with an explicit state rather than relying on the script
+ending.

package/build/stones/example/examples/good/crossfade.py

@@ -0,0 +1,15 @@
+# Task: bring two fixtures to centre stage without creating a hotspot.
+#
+# Both fixtures end up near centre, so rule 1 applies. They are staggered
+# 2.4 metres apart on the x axis, which clears the 2.0 metre minimum, and
+# each ramps with fade() rather than jumping, which satisfies rule 3.
+
+left = fixture("spot-1")
+right = fixture("spot-2")
+
+aim(left, -1.2, 0.0)
+aim(right, 1.2, 0.0)
+wait(1.0)
+
+fade(left, 85.0, 2.0)
+fade(right, 85.0, 2.0)

package/build/stones/example/examples/violations/hotspot.py

@@ -0,0 +1,17 @@
+# VIOLATES RULE 1 — hotspot.
+#
+# This is valid Stagelight. The interpreter accepts it and the desk will run it.
+# Both fixtures are aimed at exactly the same point at 90% intensity, which is
+# well over the 70% threshold with 0.0 metres of separation.
+#
+# The fix is to separate the aim points by at least 2.0 metres, or to keep one
+# fixture at or below 70%.
+
+left = fixture("spot-1")
+right = fixture("spot-2")
+
+aim(left, 0.0, 0.0)
+aim(right, 0.0, 0.0)
+
+intensity(left, 90.0)
+intensity(right, 90.0)

package/build/stones/example/rosetta.json

@@ -0,0 +1,23 @@
+{
+  "agentName": "Stagelight Assistant",
+  "languageName": "Stagelight",
+  "welcomeMessage": "Ask how to write Stagelight cues, or describe what you want the lights to do.",
+  "suggestedQuestions": [
+    "How do I fade a fixture up over 3 seconds?",
+    "Move two fixtures to centre stage at full intensity",
+    "What happens if I aim two fixtures at the same spot?"
+  ],
+  "answersAbout": "the Stagelight scripting language and stage lighting safety rules",
+  "syntaxHighlighting": "python",
+  "alwaysInContext": ["AGENTS.md", "constraints/**/*.md", "examples/**/*"],
+  "checks": [
+    {
+      "name": "syntax",
+      "command": ["python3", "./checks/syntax.py"]
+    },
+    {
+      "name": "hotspot",
+      "command": ["python3", "./checks/hotspot.py"]
+    }
+  ]
+}

package/build/stones/example/skills/writing-cues/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: writing-cues
+description: How to draft a Stagelight cue sequence from a plain-English request. Use whenever asked to write, draft, change or fix a cue or script.
+---
+
+# Writing a cue
+
+1. Name every fixture by its patch id (`spot-1`, `wash-2`). Never invent one; if the
+   request does not say which fixture, ask.
+2. Before writing any `aim`, check the new position against the hotspot rule and the
+   slew rule in AGENTS.md. If either would be broken, say which and offer the nearest
+   safe version instead.
+3. Use `fade` rather than `intensity` for any change larger than 30 points, and never
+   jump a fixture from under 10% to over 80% in one step.
+4. Fades run in parallel unless separated by `wait`. To run them in sequence, follow each
+   `fade` with a `wait` of at least the same duration.
+5. End with an explicit state — a final `intensity`, `fade` or `blackout()`. A script that
+   simply stops leaves the rig wherever it was.
+
+Compare the request with `examples/good/` and `examples/violations/` before answering:
+the violations show what a valid-looking but unsafe cue looks like.

package/package.json

@@ -1,6 +1,76 @@
 {
   "name": "@dyx9/rosetta",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1",
+  "description": "An assistant that answers questions about a custom scripting language and drafts scripts in it, from documentation you supply as a stone.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dyx9/rosetta-agent.git"
+  },
+  "homepage": "https://github.com/dyx9/rosetta-agent#readme",
+  "type": "module",
+  "bin": {
+    "rosetta": "bin/rosetta.js"
+  },
+  "files": [
+    "bin",
+    "build",
+    ".env.example"
+  ],
+  "engines": {
+    "node": ">=22.19"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "node --env-file-if-exists=.env node_modules/vite/bin/vite.js",
+    "serve": "node --env-file-if-exists=.env server/index.ts",
+    "build": "tsc -b && vite build",
+    "preview": "vite preview",
+    "lint": "oxlint",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "node --experimental-test-module-mocks --test tests/*.test.ts",
+    "prepack": "node scripts/build-package.ts"
+  },
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "1.3.0",
+    "fastest-levenshtein": "^1.0.16",
+    "sirv": "^3.0.2",
+    "typebox": "^1.4.2",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@base-ui/react": "^1.9.0",
+    "@fontsource-variable/geist": "^5.3.0",
+    "@fontsource-variable/geist-mono": "^5.3.0",
+    "@tailwindcss/vite": "^4.3.3",
+    "@types/node": "^25.9.9",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^6.1.2",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "lucide-react": "^1.59.0",
+    "mermaid": "^12.2.0",
+    "nanoid": "^6.0.2",
+    "next-themes": "^0.4.6",
+    "oxlint": "^1.89.0",
+    "prettier": "3.9.10",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
+    "react-markdown": "^10.1.0",
+    "rehype-katex": "^7.0.1",
+    "remark-gfm": "^4.0.1",
+    "remark-math": "^6.0.0",
+    "shadcn": "^4.22.1",
+    "shiki": "^4.5.0",
+    "sonner": "^2.0.8",
+    "tailwind-merge": "^3.7.0",
+    "tailwindcss": "^4.3.3",
+    "tw-animate-css": "^1.4.0",
+    "typescript": "~7.0.2",
+    "vite": "^8.3.4"
+  }
+}