carthagent 0.0.0-stage → 1.0.7

package/tests/test_starter.py

@@ -0,0 +1,78 @@
+"""Import-safe tests for the verified starter's nonblank framebuffer assertion.
+
+Runs without any graphics context: assert_nonblank works on plain image files.
+"""
+import importlib.util
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+from PIL import Image
+
+STARTER = Path(__file__).resolve().parents[1] / 'skills' / 'game-development' / 'assets' / 'ursina_starter.py'
+
+
+def load_starter():
+    spec = importlib.util.spec_from_file_location('ursina_starter_under_test', STARTER)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def image_file(colors):
+    """Write a small PNG whose top rows hold the given distinct colors."""
+    width, height = 64, 64
+    band = max(1, height // len(colors))
+    image = Image.new('RGB', (width, height))
+    for y in range(height):
+        image.paste(Image.new('RGB', (width, 1), colors[min(y // band, len(colors) - 1)]), (0, y))
+    handle = tempfile.NamedTemporaryFile(prefix='nonblank-', suffix='.png', delete=False)
+    image.save(handle, format='PNG')
+    handle.close()
+    return Path(handle.name)
+
+
+class NonblankAssertionTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.starter = load_starter()
+
+    def track(self, path):
+        self.addCleanup(lambda: path.unlink(missing_ok=True))
+        return path
+
+    def test_importing_starter_never_opens_a_window(self):
+        self.assertTrue(hasattr(self.starter, 'assert_nonblank'))
+        self.assertNotIn('Ursina', sys.modules, 'starter import must not load the graphics stack')
+
+    def test_color_varied_image_passes_and_reports_color_count(self):
+        path = self.track(image_file([(10, 40, 90), (200, 180, 60), (255, 255, 255), (0, 0, 0)]))
+        colors = self.starter.assert_nonblank(path, min_colors=3)
+        self.assertGreaterEqual(colors, 3)
+
+    def test_flat_single_color_image_is_rejected_as_blank(self):
+        path = self.track(image_file([(120, 120, 120)]))
+        with self.assertRaises(AssertionError) as caught:
+            self.starter.assert_nonblank(path)
+        self.assertIn('sampled colors', str(caught.exception))
+
+    def test_pure_black_image_is_rejected(self):
+        path = self.track(image_file([(0, 0, 0)]))
+        with self.assertRaises(AssertionError):
+            self.starter.assert_nonblank(path)
+
+    def test_two_colors_fail_the_default_three_color_bar(self):
+        path = self.track(image_file([(20, 20, 20), (240, 240, 240)]))
+        with self.assertRaises(AssertionError):
+            self.starter.assert_nonblank(path)
+        # The threshold is an argument, matching the external probe's coarse bar.
+        self.assertGreaterEqual(self.starter.assert_nonblank(path, min_colors=2), 2)
+
+    def test_missing_image_file_raises(self):
+        with self.assertRaises(Exception):
+            self.starter.assert_nonblank(Path(tempfile.gettempdir()) / 'definitely-not-rendered-9x7.png')
+
+
+if __name__ == '__main__':
+    unittest.main()

package/tests/theme.test.mjs

@@ -0,0 +1,175 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { THEMES, flattenTheme, detectTermMode } from '../lib/tui/theme.mjs';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..');
+const html = readFileSync(join(root, 'public', 'index.html'), 'utf8');
+
+const TOKENS = [
+  'bg', 'chrome', 'panel', 'panel-2', 'sunken',
+  'border', 'border-strong', 'border-hover', 'control-border',
+  'text', 'muted', 'faint', 'code',
+  'accent', 'accent-ink', 'accent-bg', 'hover-bg',
+  'success', 'warning', 'error',
+];
+
+// Normal text (AA 4.5:1): role color -> the surfaces it renders on.
+const TEXT_PAIRS = [
+  ['text', 'bg'], ['text', 'panel'], ['text', 'panel-2'], ['text', 'sunken'], ['text', 'chrome'],
+  ['muted', 'bg'], ['muted', 'panel'], ['muted', 'sunken'], ['muted', 'chrome'],
+  ['faint', 'bg'], ['faint', 'panel'], ['faint', 'chrome'],
+  ['code', 'sunken'], ['code', 'panel'],
+  ['accent', 'bg'], ['accent', 'panel'], ['accent', 'panel-2'], ['accent', 'chrome'], ['accent', 'accent-bg'],
+  ['accent-ink', 'accent'],
+  ['success', 'panel'], ['success', 'sunken'],
+  ['warning', 'panel'], ['warning', 'sunken'],
+  ['error', 'panel'], ['error', 'sunken'], ['error', 'panel-2'],
+];
+
+// Non-text UI elements (AA 3:1): control outlines, status dots, nav underline.
+const UI_PAIRS = [
+  ['control-border', 'sunken'], ['control-border', 'panel'],
+  ['success', 'chrome'], ['warning', 'chrome'], ['error', 'chrome'],
+];
+
+function luminance(hex) {
+  const [r, g, b] = [1, 3, 5].map(i => {
+    const v = parseInt(hex.slice(i, i + 2), 16) / 255;
+    return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+
+const contrast = (a, b) => {
+  const [l1, l2] = [luminance(a), luminance(b)].sort((x, y) => y - x);
+  return (l1 + 0.05) / (l2 + 0.05);
+};
+
+// Collect theme blocks: ':root, [data-theme="x"] { --token: #hex; ... }'.
+const themes = {};
+for (const match of html.matchAll(/([^{}]+)\{([^}]*--[a-z-]+\s*:[^}]*)\}/g)) {
+  const [, selector, body] = match;
+  const vars = {};
+  for (const decl of body.matchAll(/(--[a-z0-9-]+)\s*:\s*(#[0-9a-fA-F]{6})\b/g)) vars[decl[1]] = decl[2].toLowerCase();
+  for (const name of selector.split(',').map(s => s.trim())) {
+    const theme = name === ':root' ? 'carthage' : name.match(/^\[data-theme="([^"]+)"\]$/)?.[1];
+    if (theme) themes[theme] = { ...themes[theme], ...vars };
+  }
+}
+
+test('every theme picker option has a matching theme block', () => {
+  const options = [...html.matchAll(/data-theme-value="([^"]+)"/g)].map(m => m[1]).filter(v => v !== 'system');
+  assert.deepEqual(options.sort(), Object.keys(themes).sort());
+});
+
+for (const [name, vars] of Object.entries(themes)) {
+  test(`theme "${name}" defines the full token set`, () => {
+    const missing = TOKENS.filter(t => !vars[`--${t}`]);
+    assert.deepEqual(missing, []);
+  });
+
+  test(`theme "${name}" meets WCAG AA contrast`, () => {
+    const failures = [];
+    for (const [fg, bg] of TEXT_PAIRS) {
+      const r = contrast(vars[`--${fg}`], vars[`--${bg}`]);
+      if (r < 4.5) failures.push(`${fg}/${bg} = ${r.toFixed(2)}`);
+    }
+    for (const [fg, bg] of UI_PAIRS) {
+      const r = contrast(vars[`--${fg}`], vars[`--${bg}`]);
+      if (r < 3.0) failures.push(`${fg}/${bg} = ${r.toFixed(2)} (UI)`);
+    }
+    assert.deepEqual(failures, []);
+  });
+}
+
+// ---------------------------------------------------------------- TUI
+
+// Normal text (AA 4.5:1) for the TUI token set.
+const TUI_TEXT_PAIRS = [
+  ['text', 'background'], ['text', 'backgroundPanel'], ['text', 'backgroundElement'],
+  ['textMuted', 'background'], ['textMuted', 'backgroundPanel'], ['textMuted', 'backgroundElement'],
+  ['primary', 'backgroundPanel'], ['secondary', 'backgroundPanel'], ['accent', 'backgroundPanel'],
+  ['info', 'backgroundPanel'], ['error', 'backgroundPanel'], ['warning', 'backgroundPanel'],
+  ['success', 'backgroundPanel'],
+  ['markdownText', 'backgroundPanel'], ['markdownBlockQuote', 'backgroundPanel'],
+  ['markdownCode', 'backgroundPanel'], ['markdownCodeBlock', 'backgroundPanel'],
+  ['markdownLink', 'backgroundPanel'], ['markdownLinkText', 'backgroundPanel'],
+  ['markdownEmph', 'backgroundPanel'], ['markdownHeading', 'backgroundPanel'],
+  ['markdownStrong', 'backgroundPanel'],
+  ['syntaxComment', 'background'], ['syntaxKeyword', 'background'],
+  ['syntaxFunction', 'background'], ['syntaxVariable', 'background'],
+  ['syntaxString', 'background'], ['syntaxNumber', 'background'],
+  ['syntaxType', 'background'], ['syntaxOperator', 'background'],
+  ['syntaxPunctuation', 'background'],
+  ['diffAdded', 'diffAddedBg'], ['diffRemoved', 'diffRemovedBg'],
+  ['diffContext', 'diffContextBg'], ['diffHunkHeader', 'backgroundPanel'],
+  ['diffHighlightAdded', 'diffAddedBg'], ['diffHighlightRemoved', 'diffRemovedBg'],
+  ['diffLineNumber', 'diffAddedLineNumberBg'], ['diffLineNumber', 'diffRemovedLineNumberBg'],
+];
+
+// Non-text UI elements (AA 3:1): focused-pane border.
+const TUI_UI_PAIRS = [['borderActive', 'backgroundPanel']];
+
+// Decorative separators: visible but intentionally subtle.
+const TUI_DECO_PAIRS = [
+  ['border', 'backgroundPanel'],
+  ['borderSubtle', 'backgroundPanel'],
+  ['markdownHorizontalRule', 'backgroundPanel'],
+];
+
+for (const [name, raw] of Object.entries(THEMES)) {
+  for (const mode of ['dark', 'light']) {
+    test(`tui theme "${name}" (${mode}) meets WCAG AA contrast`, () => {
+      const t = flattenTheme(raw, mode);
+      const failures = [];
+      for (const [fgC, bgC] of TUI_TEXT_PAIRS) {
+        if (t[fgC] === 'none' || t[bgC] === 'none') continue;
+        const r = contrast(t[fgC], t[bgC]);
+        if (r < 4.5) failures.push(`${fgC}/${bgC} = ${r.toFixed(2)}`);
+      }
+      for (const [fgC, bgC] of TUI_UI_PAIRS) {
+        const r = contrast(t[fgC], t[bgC]);
+        if (r < 3.0) failures.push(`${fgC}/${bgC} = ${r.toFixed(2)} (UI)`);
+      }
+      for (const [fgC, bgC] of TUI_DECO_PAIRS) {
+        const r = contrast(t[fgC], t[bgC]);
+        if (r < 1.2) failures.push(`${fgC}/${bgC} = ${r.toFixed(2)} (deco)`);
+      }
+      assert.deepEqual(failures, []);
+    });
+  }
+}
+
+test('detectTermMode reads COLORFGBG / CARTHAGENT_THEME_MODE', () => {
+  assert.equal(detectTermMode({}), 'dark');
+  assert.equal(detectTermMode({ COLORFGBG: '15;0' }), 'dark');
+  assert.equal(detectTermMode({ COLORFGBG: '0;15' }), 'light');
+  assert.equal(detectTermMode({ COLORFGBG: '0;7' }), 'light');
+  assert.equal(detectTermMode({ COLORFGBG: '0;15', CARTHAGENT_THEME_MODE: 'dark' }), 'dark');
+});
+
+// Light themes: the d2 graph renderer uses the plain panel as the node fill
+// (state carried by the border). Verify that text/label/glyph colors have
+// ≥4.5:1 contrast against the panel — the surface text actually renders on.
+for (const name of ['paper', 'daylight', 'solarized-light', 'contrast-light', 'okabe-light']) {
+  test(`tui light theme "${name}" text is readable on the panel fill`, () => {
+    const t = flattenTheme(THEMES[name], 'light');
+    const panelBg = t.backgroundPanel || t.background;
+    const ok = t.diffAdded || t.success;
+    const err = t.diffRemoved || t.error;
+    const warn = t.warning;
+    const accent = t.primary || t.accent;
+    const pairs = [
+      [t.text, panelBg], [t.textMuted, panelBg],
+      [ok, panelBg], [err, panelBg], [warn, panelBg], [accent, panelBg],
+      [t.borderActive, panelBg],
+    ];
+    for (const [fg, bg] of pairs) {
+      const r = contrast(fg, bg);
+      assert.ok(r >= 4.5, `${fg} on ${bg} = ${r.toFixed(2)} < 4.5`);
+    }
+  });
+}

package/tests/tui-copy-paste.test.mjs

@@ -0,0 +1,54 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { makeKeyParser, matchSlash, selectionText } from '../lib/tui/app.mjs';
+
+test('/copy is discoverable in command autocomplete', () => {
+  assert.ok(matchSlash('/cop').some(c => c.name === '/copy'));
+});
+
+test('bracketed paste survives every byte boundary, Unicode and CRLF', () => {
+  const text = 'first\r\n日本語 😀\rlast\n' + 'long text '.repeat(10000);
+  const bytes = Buffer.from(`a\x1b[200~${text}\x1b[201~b\r`);
+  const keys = [];
+  const parse = makeKeyParser(k => keys.push(k));
+  for (const byte of bytes) parse(Buffer.from([byte]));
+  assert.deepEqual(keys, [
+    { key: 'char', ch: 'a' },
+    { key: 'paste', text: text.replace(/\r\n?/g, '\n') },
+    { key: 'char', ch: 'b' },
+    { key: 'enter' },
+  ]);
+});
+
+test('mixed mouse, plain input and consecutive pastes are all consumed', () => {
+  const keys = [];
+  const parse = makeKeyParser(k => keys.push(k));
+  parse('a\x1b[<0;10;8M\x1b[<32;4;2M\x1b[<0;4;2m\x1b[200~one\x1b[201~\x1b[200~two\x1b[201~');
+  assert.deepEqual(keys.map(k => k.key), ['char', 'mousedown', 'mousedrag', 'mouseup', 'paste', 'paste']);
+  assert.deepEqual(keys.slice(-2).map(k => k.text), ['one', 'two']);
+});
+
+test('split paste end marker never leaks into pasted text', () => {
+  for (let split = 1; split < 6; split++) {
+    const keys = [];
+    const parse = makeKeyParser(k => keys.push(k));
+    parse('\x1b[200~content' + '\x1b[201~'.slice(0, split));
+    parse('\x1b[201~'.slice(split));
+    assert.deepEqual(keys, [{ key: 'paste', text: 'content' }]);
+  }
+});
+
+test('upward and downward selections copy identical text and preserve Unicode', () => {
+  const lines = ['hello', '日本語 😀', 'last line'];
+  const forward = { ax: 2, ay: 1, bx: 4, by: 3 };
+  const reverse = { ax: 4, ay: 3, bx: 2, by: 1 };
+  assert.equal(selectionText(lines, forward, 20), 'ello\n日本語 😀\nlast');
+  assert.equal(selectionText(lines, reverse, 20), selectionText(lines, forward, 20));
+});
+
+test('logical selection includes offscreen rows without truncation', () => {
+  const lines = Array.from({ length: 1000 }, (_, i) => `${i}: ${'x'.repeat(80)}`);
+  const text = selectionText(lines, { ax: 90, ay: 1000, bx: 1, by: 1 }, 90);
+  assert.equal(text, lines.join('\n'));
+  assert.ok(Buffer.byteLength(text) > 50000);
+});