dsh-spell-check 0.0.0-stage → 0.2.2

package/cordis.patch.yml

@@ -0,0 +1,13 @@
+# dsh-spell-check bundle patch: mount the host half as a NEW loader row.
+#
+# This must be an `insert:` list, not a top-level `- id:` entry. A top-level
+# entry with an `id` targets an EXISTING row to override it, so dsh aborts with
+# `patch: entry "spell-check" not found` before the plugin ever loads.
+#
+# `name` MUST equal the package name: the loader imports that specifier, and
+# `id` is the plugin's storage/prompt/effect key (keep it stable once released).
+- insert:
+    - id: spell-check
+      name: 'dsh-spell-check'
+      config:
+        enabled: true

package/dsh.plugin.json

@@ -0,0 +1,9 @@
+{
+  "id": "spell-check",
+  "version": "0.2.2",
+  "main": "src/index.js",
+  "description": "Chrome-style local spell check for the dsh composer",
+  "engines": {
+    "dsh": ">=0.2.1-rc.3"
+  }
+}

package/package.json

@@ -1,6 +1,90 @@
 {
   "name": "dsh-spell-check",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.2",
+  "description": "Chrome-style spell check for the dsh composer: the misspelled word under the caret gets a suggestion strip, and Tab accepts it. Local only — no network, no LLM, no telemetry.",
+  "icon": "assets/icon.png",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./engine": "./src/engine.js",
+    "./client": "./src/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src/index.js",
+    "src/engine.js",
+    "src/client.js",
+    "assets/words.txt",
+    "assets/banner-light.png",
+    "assets/strip.gif",
+    "assets/strip.png",
+    "assets/menu.png",
+    "assets/banner-dark.png",
+    "assets/icon.png",
+    "cordis.patch.yml",
+    "dsh.plugin.json",
+    "scripts/test-engine.mjs",
+    "scripts/test-host.mjs",
+    "scripts/test-client.mjs",
+    "scripts/build-client.mjs",
+    "scripts/check-styles.mjs",
+    "scripts/make-banner.py",
+    "scripts/make-media.py",
+    "README.md",
+    "LICENSE",
+    "screenshots.json"
+  ],
+  "scripts": {
+    "build": "node scripts/build-client.mjs",
+    "test": "node scripts/check-styles.mjs && node scripts/test-engine.mjs && node scripts/test-host.mjs && node scripts/test-client.mjs",
+    "test:engine": "node scripts/test-engine.mjs",
+    "test:host": "node scripts/test-host.mjs",
+    "test:client": "node scripts/test-client.mjs",
+    "test:styles": "node scripts/check-styles.mjs"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "main": "./src/client.js"
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "dsh-plugin",
+    "dsh",
+    "deepseek-harness",
+    "spellcheck",
+    "spell-check",
+    "autocorrect",
+    "typo",
+    "offline"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/adithyanraj03/dsh-spell-check.git"
+  },
+  "homepage": "https://adithyanraj03.github.io/dsh-spell-check/",
+  "bugs": {
+    "url": "https://github.com/adithyanraj03/dsh-spell-check/issues"
+  },
+  "author": "Adithya N Raj (adithyanraj03)",
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/dsh-typert-protocol": ">=0.1.0-rc.6"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-typert-protocol": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-typert-protocol": "0.2.2-rc.1"
+  }
+}

package/screenshots.json

@@ -0,0 +1,4 @@
+[
+  "assets/strip.png",
+  "assets/menu.png"
+]

package/scripts/build-client.mjs

@@ -0,0 +1,102 @@
+/**
+ * Generate the browser half's embedded engine + dictionary.
+ *
+ * WHY THIS EXISTS
+ *
+ * The client half runs in the browser and cannot read files, so to correct
+ * without a round trip it needs the dictionary INSIDE its bundle. Embedding it
+ * by hand would mean a second copy of the rules that drifts from src/engine.js
+ * — the exact failure this avoids.
+ *
+ * So src/engine.js stays the single source of truth: this script strips its
+ * `export` keywords into a plain script block, prepends the word list, and
+ * splices both into the marked region of src/client.js. The host half imports
+ * src/engine.js directly, so both halves run the SAME code.
+ *
+ * Run with `node scripts/build-client.mjs` (also `npm run build`).
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const root = join(here, '..')
+
+const BEGIN = '/* >>> GENERATED ENGINE BLOCK'
+const END = '/* <<< GENERATED ENGINE BLOCK <<< */'
+
+const words = readFileSync(join(root, 'assets', 'words.txt'), 'utf8')
+  .split(/\r?\n/)
+  .map((line) => line.trim())
+  .filter(Boolean)
+
+/**
+ * An OPTIONAL second word list, for swapping in a different dictionary.
+ *
+ * SCOWL, a Hunspell `en_US.dic`, or a wordfreq export all reduce to "one word
+ * per line", so dropping a file here is enough to change the dictionary without
+ * touching this plugin. It goes AFTER the shipped list, which keeps the common
+ * words ahead of it in the ranking.
+ */
+const EXTRA = join(root, 'assets', 'words-extra.txt')
+let extra = []
+if (existsSync(EXTRA)) {
+  extra = readFileSync(EXTRA, 'utf8')
+    .split(/\r?\n/)
+    .map((line) => line.trim().toLowerCase())
+    // Hunspell dictionaries carry an affix marker after a slash (walk/ed) and
+    // SCOWL uses a similar suffix; only the plain headword is a word here.
+    .map((line) => line.split(/[/\s]/)[0])
+    .filter((line) => /^[a-z][a-z'-]{1,24}$/.test(line))
+  console.log(`build: extra dictionary ${extra.length} words from assets/words-extra.txt`)
+}
+
+const all = [...new Set([...words, ...extra])]
+
+if (words.length === 0) {
+  console.error('build: assets/words.txt is empty — refusing to write a bundle with no dictionary')
+  process.exit(1)
+}
+
+/**
+ * src/engine.js as a plain script fragment.
+ *
+ * Only three export shapes are used in that file, and all three are line-initial
+ * by convention, so this stays a formatting rule rather than a parser.
+ */
+const engineSource = readFileSync(join(root, 'src', 'engine.js'), 'utf8')
+  .split(/\r?\n/)
+  .filter((line) => !line.startsWith('export default'))
+  .map((line) => (line.startsWith('export ') ? line.slice('export '.length) : line))
+  .join('\n')
+
+const block = [
+  BEGIN + ' — run `npm run build`. Do not edit between the markers. >>> */',
+  '',
+  '    /* The ranked word list, most frequent first. Index is the frequency rank. */',
+  '    const WORD_LIST = ' + JSON.stringify(all.join('\n')) + ';',
+  '',
+  engineSource,
+  '',
+  '    /* The one engine instance this page uses. */',
+  '    const ENGINE = createEngine(WORD_LIST.split("\\n").filter(Boolean), TYPO_MAP);',
+  '',
+  '    ' + END,
+].join('\n')
+
+const clientPath = join(root, 'src', 'client.js')
+const client = readFileSync(clientPath, 'utf8')
+
+const start = client.indexOf(BEGIN)
+const finish = client.indexOf(END)
+if (start === -1 || finish === -1 || finish < start) {
+  console.error('build: generated markers not found in src/client.js')
+  process.exit(1)
+}
+
+const next = client.slice(0, start) + block + client.slice(finish + END.length)
+writeFileSync(clientPath, next, 'utf8')
+
+const bytes = Buffer.byteLength(next, 'utf8')
+console.log(`build: embedded ${all.length} words into src/client.js (${(bytes / 1024).toFixed(1)} KB)`)

package/scripts/check-styles.mjs

@@ -0,0 +1,70 @@
+/**
+ * Stylesheet sanity check: `node scripts/check-styles.mjs`.
+ *
+ * The client half builds one CSS string from an array of literals. A rule whose
+ * selector line is removed leaves its declarations behind, and those orphans
+ * break the parse of every rule after them — which is exactly how the
+ * right-click menu lost its positioning and rendered as raw text at the bottom
+ * of the page. This asserts the string is structurally composed of real rules.
+ */
+
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const source = readFileSync(join(here, '..', 'src', 'client.js'), 'utf8')
+
+const start = source.indexOf('function styles()')
+const end = source.indexOf('].join', start)
+if (start === -1 || end === -1) {
+  console.error('check-styles: could not locate styles()')
+  process.exit(1)
+}
+
+const block = source.slice(start, end)
+const css = block
+  .split('\n')
+  .map((line) => line.trim())
+  .filter((line) => line.startsWith('"'))
+  .map((line) => line.replace(/^"/, '').replace(/",?$/, ''))
+  .join('')
+
+let passed = 0
+const failures = []
+const check = (name, ok, detail) => {
+  if (ok) passed += 1
+  else failures.push(name + (detail === undefined ? '' : ` — ${detail}`))
+}
+
+const open = (css.match(/\{/g) ?? []).length
+const close = (css.match(/\}/g) ?? []).length
+check('braces balance', open === close, `${open} open vs ${close} close`)
+
+// Every top-level statement must start with a selector, an at-rule, or a
+// comment. A bare declaration at the start of a statement is the orphan shape.
+const statements = css.split('}')
+for (const statement of statements) {
+  const trimmed = statement.trim()
+  if (trimmed === '') continue
+  check(
+    'statement starts with a selector',
+    /^(\.|@|:root|html|body|\/\*)/.test(trimmed),
+    trimmed.slice(0, 60),
+  )
+}
+
+// The rules that carry the two visible surfaces must survive.
+check('strip rule present', css.includes('.sp-strip{'))
+check('menu rule present', css.includes('.sp-menu{'))
+check('menu open state present', css.includes('.sp-menu.sp-open{'))
+check('menu positions itself', /\.sp-menu\{[^}]*position:fixed/.test(css))
+
+// The chip was removed from the UI; nothing should reference it any more.
+check('no chip rules left', css.includes('.sp-chip') === false)
+
+console.log(`${passed} passed, ${failures.length} failed`)
+if (failures.length > 0) {
+  for (const failure of failures) console.log('  FAIL ' + failure)
+  process.exitCode = 1
+}

package/scripts/make-banner.py

@@ -0,0 +1,191 @@
+"""
+Generate the README banners.
+
+Deliberately scripted rather than image-generated: a banner is a logo, a
+wordmark, a tagline and the real screenshots, and a diffusion model renders text
+and UI chrome badly. Pillow gives crisp type and exact colours.
+
+    python scripts/make-banner.py                     # the default variant, both themes
+    python scripts/make-banner.py --variant A         # one variant, both themes
+    python scripts/make-banner.py --variant B --theme dark --suffix=-B
+
+The variants differ only in how the screenshots are arranged:
+
+    A  stacked   — two cards, one above the other, with a clear gap
+    B  hero      — one large card, the whole right half
+    C  layered   — two cards offset and overlapping, like the sibling repos
+
+Nothing is rotated: a tilted screenshot reads as a mock-up, and the point of
+putting a screenshot in the banner is that it is the real thing.
+"""
+
+import argparse
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFilter, ImageFont
+
+ROOT = Path(__file__).resolve().parent.parent
+ICON = ROOT / "assets" / "icon.png"
+MENU = ROOT / "assets" / "menu.png"
+STRIP = ROOT / "assets" / "strip.png"
+OUT = ROOT / "assets"
+
+W, H = 1400, 460
+
+LIGHT = {
+    "bg": (247, 246, 250),
+    "glow": (232, 229, 242),
+    "title": (26, 22, 36),
+    "tag": (92, 86, 108),
+    "accent": (232, 72, 77),
+    "edge": (0, 0, 0, 30),
+    "shadow": (24, 20, 36, 64),
+}
+DARK = {
+    "bg": (18, 18, 22),
+    "glow": (32, 30, 42),
+    "title": (245, 244, 248),
+    "tag": (152, 148, 168),
+    "accent": (255, 106, 110),
+    "edge": (255, 255, 255, 32),
+    "shadow": (0, 0, 0, 140),
+}
+
+FONT_CANDIDATES = [
+    r"C:\Windows\Fonts\segoeuib.ttf",
+    r"C:\Windows\Fonts\SegoeUI.ttf",
+    r"C:\Windows\Fonts\arialbd.ttf",
+]
+MONO_CANDIDATES = [
+    r"C:\Windows\Fonts\consola.ttf",
+    r"C:\Windows\Fonts\cour.ttf",
+]
+
+# Tighter than the raw stills: the interesting part of each capture is the popup
+# plus the line it belongs to, and cropping to that makes a card twice as tall at
+# the same width — which is the whole point of the banner.
+CROPS = {
+    "menu": (400, 0, 1350, 314),   # 950 x 314
+    "strip": (150, 0, 1150, 260),  # 1000 x 260
+}
+
+LAYOUTS = {
+    # name: (width, x, y). Top-left of each card; every right edge stays inside
+    # 1400 with a margin, and no card is ever clipped by the canvas.
+    "A": {"menu": (690, 690, 10), "strip": (700, 690, 248)},
+    "B": {"strip": (900, 470, 126)},
+    "C": {"menu": (700, 676, 16), "strip": (700, 700, 234)},
+}
+
+DEFAULT_VARIANT = "A"
+
+
+def font(candidates, size):
+    for candidate in candidates:
+        if Path(candidate).exists():
+            return ImageFont.truetype(candidate, size)
+    return ImageFont.load_default()
+
+
+def rounded_glow(size, colour):
+    glow = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(glow)
+    for step in range(size // 2, 0, -2):
+        alpha = int(26 * (1 - step / (size / 2)))
+        draw.ellipse(
+            (size // 2 - step, size // 2 - step, size // 2 + step, size // 2 + step),
+            fill=colour + (alpha,),
+        )
+    return glow
+
+
+def rounded_mask(size, radius):
+    mask = Image.new("L", size, 0)
+    ImageDraw.Draw(mask).rounded_rectangle((0, 0, size[0] - 1, size[1] - 1), radius=radius, fill=255)
+    return mask
+
+
+def pad_top(image, amount):
+    """
+    Give a crop headroom above its content.
+
+    The strip still was captured tight to the popup's rounded top, so pasting it
+    straight into a card clipped those corners and the popup read as flush with
+    the card edge rather than floating over the composer. The filler is the
+    crop's own corner colour, which is the page background behind the composer.
+    """
+    if amount <= 0:
+        return image
+    filler = image.getpixel((0, 0))
+    padded = Image.new("RGBA", (image.width, image.height + amount), filler)
+    padded.paste(image, (0, amount))
+    return padded
+
+
+def card(path, crop, width, theme, radius=18, headroom=0):
+    """A screenshot as a rounded card with its own hairline edge."""
+    source = Image.open(path).convert("RGBA").crop(crop)
+    source = pad_top(source, headroom)
+    height = round(source.height * width / source.width)
+    image = source.resize((width, height), Image.LANCZOS)
+
+    mask = rounded_mask((width, height), radius)
+    image.putalpha(mask)
+    ImageDraw.Draw(image).rounded_rectangle(
+        (0, 0, width - 1, height - 1), radius=radius, outline=theme["edge"], width=1
+    )
+    return image
+
+
+def place(canvas, art, x, y, theme):
+    """Composite a card with a soft shadow behind it."""
+    silhouette = Image.new("RGBA", art.size, (0, 0, 0, 0))
+    silhouette.paste(Image.new("RGBA", art.size, theme["shadow"]), (0, 0), art.split()[3])
+    silhouette = silhouette.filter(ImageFilter.GaussianBlur(18))
+    canvas.alpha_composite(silhouette, (x + 2, y + 12))
+    canvas.alpha_composite(art, (x, y))
+
+
+def build(theme, name, variant):
+    layout = LAYOUTS[variant]
+    canvas = Image.new("RGB", (W, H), theme["bg"]).convert("RGBA")
+    canvas.alpha_composite(rounded_glow(460, theme["glow"]), (40, -30))
+
+    # Screenshots before the wordmark, so no card can ever cover the text.
+    for key, path in (("menu", MENU), ("strip", STRIP)):
+        if key not in layout:
+            continue  # a single-card layout simply omits the other
+        width, x, y = layout[key]
+        headroom = 26 if key == "strip" else 0
+        place(canvas, card(path, CROPS[key], width, theme, headroom=headroom), x, y, theme)
+
+    icon = Image.open(ICON).convert("RGBA")
+    icon.thumbnail((168, 168), Image.LANCZOS)
+    canvas.alpha_composite(icon, (46, (H - icon.height) // 2 - 4))
+
+    draw = ImageDraw.Draw(canvas)
+
+    title_font = font(FONT_CANDIDATES, 74)
+    draw.text((232, 156), "spell check", font=title_font, fill=theme["title"])
+    caret_x = 232 + draw.textlength("spell check", font=title_font) + 10
+    draw.rectangle((caret_x, 168, caret_x + 6, 232), fill=theme["accent"])
+
+    tag_font = font(MONO_CANDIDATES, 21)
+    for index, line in enumerate(["Tab accepts the fix.", "Right-click for every option.", "100% local."]):
+        draw.text((236, 258 + index * 29), line, font=tag_font, fill=theme["tag"])
+
+    path = OUT / name
+    canvas.convert("RGB").save(path, "PNG", optimize=True)
+    print(f"wrote {path.relative_to(ROOT)} ({path.stat().st_size // 1024} KB)")
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--variant", default=DEFAULT_VARIANT, choices=sorted(LAYOUTS))
+parser.add_argument("--theme", default="both", choices=["both", "light", "dark"])
+parser.add_argument("--suffix", default="", help="appended to the filename, for comparisons")
+args = parser.parse_args()
+
+if args.theme in ("both", "dark"):
+    build(DARK, f"banner-dark{args.suffix}.png", args.variant)
+if args.theme in ("both", "light"):
+    build(LIGHT, f"banner-light{args.suffix}.png", args.variant)

package/scripts/make-media.py

@@ -0,0 +1,120 @@
+"""
+Clean the recorded demo and build the README media.
+
+The recording is made by the harness's own computer-use driver, which paints a
+small blue cursor pill labelled "DSH" wherever it clicks. That pill lands on the
+composer, exactly where the demo needs to be legible, so each frame is patched:
+the pill is found by colour, and the rectangle is filled with the background
+sampled just beside it. It sits on flat paint, so the repair is invisible.
+
+    python scripts/make-media.py
+
+Inputs  media/demo2.mp4            the raw recording
+Outputs assets/strip.gif           typing -> suggestion strip -> Tab accepts
+        assets/strip.png           still, for the README
+        assets/menu.png            still, the right-click menu
+"""
+
+from pathlib import Path
+import shutil
+import subprocess
+
+from PIL import Image
+
+ROOT = Path(__file__).resolve().parent.parent
+MEDIA = ROOT / "media"
+ASSETS = ROOT / "assets"
+FRAMES = MEDIA / "frames"
+
+FFMPEG = shutil.which("ffmpeg") or (
+    r"C:\Users\adith\AppData\Local\Microsoft\WinGet\Packages"
+    r"\Gyan.FFmpeg_Microsoft.Winget.Source_8wekyb3d8bbwe\ffmpeg-6.1-full_build\bin\ffmpeg.exe"
+)
+
+# Crop of the full recording: composer + the strip above it.
+CROP = "crop=900:130:340:840"
+START, DURATION, FPS = 9.6, 10.5, 10
+
+
+def run(*args):
+    subprocess.run([FFMPEG, "-hide_banner", "-loglevel", "error", "-y", *args], check=True)
+
+
+def patch_pill(path):
+    """Erase the blue cursor pill from one frame.
+
+    The search window matters: the composer also contains a blue send button,
+    and a whole-frame sweep merged the two into one enormous rectangle that
+    painted over the entire row. The pill lives just right of the composer text
+    and just above the control row, so the search is confined to that band.
+    """
+    image = Image.open(path).convert("RGB")
+    pixels = image.load()
+    width, height = image.size
+
+    xs, ys = [], []
+    for y in range(40, min(height, 100)):
+        for x in range(240, min(width, 640)):
+            r, g, b = pixels[x, y]
+            if b > 140 and b - r > 60 and b - g > 40:
+                xs.append(x)
+                ys.append(y)
+    if not xs:
+        image.save(path)
+        return
+
+    left, right = min(xs) - 2, max(xs) + 2
+    top, bottom = min(ys) - 2, max(ys) + 2
+    # A cursor pill is small; anything larger is not the pill and is left alone.
+    if right - left > 70 or bottom - top > 40:
+        image.save(path)
+        return
+
+    for y in range(max(0, top), min(height, bottom + 1)):
+        # Per-row sample of the flat composer paint, taken clear of the pill.
+        fill = pixels[max(0, left - 10), y]
+        for x in range(max(0, left), min(width, right + 1)):
+            pixels[x, y] = fill
+    image.save(path)
+
+
+def main():
+    if FRAMES.exists():
+        shutil.rmtree(FRAMES)
+    FRAMES.mkdir(parents=True)
+
+    ASSETS.mkdir(parents=True, exist_ok=True)
+
+    # 1. Frames, cropped to the composer.
+    run(
+        "-ss", str(START), "-t", str(DURATION), "-i", str(MEDIA / "demo2.mp4"),
+        "-vf", f"{CROP},fps={FPS}",
+        str(FRAMES / "f%03d.png"),
+    )
+
+    # 2. Repair every frame.
+    frames = sorted(FRAMES.glob("f*.png"))
+    for frame in frames:
+        patch_pill(frame)
+    print(f"patched {len(frames)} frames")
+
+    # 3. Reassemble as an animated GIF with one shared palette.
+    run(
+        # The input framerate MUST be declared: without it ffmpeg assumes 25 fps
+        # for an image sequence and a 10 fps capture comes back playing 2.5x fast.
+        "-framerate", str(FPS), "-i", str(FRAMES / "f%03d.png"),
+        "-vf", "split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=sierra2_4a",
+        "-loop", "0",
+        str(ASSETS / "strip.gif"),
+    )
+
+    # 4. A still for the README, taken mid-strip.
+    still = Image.open(frames[min(len(frames) - 1, int(FPS * 3.4))]).convert("RGB")
+    still = still.resize((still.width * 2, still.height * 2), Image.LANCZOS)
+    still.save(ASSETS / "strip.png")
+
+    size = (ASSETS / "strip.gif").stat().st_size // 1024
+    print(f"wrote assets/strip.gif ({size} KB) and assets/strip.png")
+
+
+main()