dsh-model-arena 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 (2026-09-18)
+
+Initial release.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hj01857655
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+# dsh-model-arena
+
+Run the same prompt through every model you have, and see the difference without squinting.
+
+## Install
+
+```sh
+dsh plugin --profile web add dsh-model-arena
+```
+
+## What it does
+
+- **Run a prompt through N models.** Same prompt, identical parameters, outputs collected side by side.
+- **Compare.** Line-level diff between any two model outputs.
+- **Score.** Auto-scorer (length, latency, reference match) + manual user ratings (1-5).
+- **Benchmark suites.** Save a named set of prompts + models, re-run after changes, get a regression report.
+- **Panel.** Settings page listing recent runs with drill-down to comparison view.
+
+## CLI
+
+```sh
+dsh-model-arena list                              # list recent runs
+dsh-model-arena compare <run> <modelA> <modelB>   # diff two models in a run
+dsh-model-arena rate <run> --model M --rating 4   # rate a model output
+```
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# cordis patch for dsh-model-arena
+insert:
+  - id: dsh-model-arena
+    from: ./lib/index.js

package/lib/arena-view.d.ts

@@ -0,0 +1,6 @@
+import type { PanelPayload, ArenaRun } from './types.js';
+/** Route paths shared between host and client. */
+export declare const ARENA_PANEL_PATH = "/api/arena.panel";
+export declare const ARENA_RUN_PATH = "/api/arena.run";
+export declare const ARENA_RATE_PATH = "/api/arena.rate";
+export declare function panelState(runs: ArenaRun[]): PanelPayload;

package/lib/arena-view.js

@@ -0,0 +1,17 @@
+/** Route paths shared between host and client. */
+export const ARENA_PANEL_PATH = '/api/arena.panel';
+export const ARENA_RUN_PATH = '/api/arena.run';
+export const ARENA_RATE_PATH = '/api/arena.rate';
+export function panelState(runs) {
+    return {
+        recentRuns: runs
+            .sort((a, b) => b.timestamp - a.timestamp)
+            .slice(0, 20)
+            .map((r) => ({
+            id: r.id,
+            prompt: r.prompt,
+            timestamp: r.timestamp,
+            modelCount: r.results.length,
+        })),
+    };
+}

package/lib/arena.d.ts

@@ -0,0 +1,36 @@
+import type { ArenaRun, ModelResult, Suite, RegressionReport, Score } from './types.js';
+export declare class Arena {
+    private projectDir;
+    private store;
+    constructor(projectDir: string);
+    /** Save a completed run (results already collected from model calls). */
+    saveRun(prompt: string, results: ModelResult[], reference?: string): ArenaRun;
+    getRun(id: string): ArenaRun | null;
+    listRuns(): {
+        id: string;
+        prompt: string;
+        timestamp: number;
+        modelCount: number;
+    }[];
+    /** Compare two models' outputs within a run. */
+    compare(runId: string, modelA: string, modelB: string): {
+        modelA: string;
+        modelB: string;
+        outputA: string;
+        outputB: string;
+        diff: import("./diff.js").DiffLine[];
+        summary: {
+            added: number;
+            removed: number;
+            changed: number;
+        };
+        scoreA: Score;
+        scoreB: Score;
+    } | null;
+    /** Set a user rating for a model in a run. */
+    rate(runId: string, model: string, rating: number): ArenaRun | null;
+    /** Save a benchmark suite. */
+    saveSuite(suite: Suite): void;
+    /** Generate a regression report between two runs of the same suite. */
+    regression(suiteName: string, baselineRunId: string, currentRunId: string): RegressionReport | null;
+}

package/lib/arena.js

@@ -0,0 +1,87 @@
+import { ArenaStore } from './store.js';
+import { autoScore } from './scoring.js';
+import { lineDiff, diffSummary } from './diff.js';
+export class Arena {
+    projectDir;
+    store;
+    constructor(projectDir) {
+        this.projectDir = projectDir;
+        this.store = new ArenaStore(projectDir);
+    }
+    /** Save a completed run (results already collected from model calls). */
+    saveRun(prompt, results, reference) {
+        const models = results.map((r) => r.model);
+        const id = ArenaStore.generateId(prompt, models);
+        const scores = autoScore(results, reference);
+        const run = { id, prompt, timestamp: Date.now(), results, scores };
+        this.store.saveRun(run);
+        return run;
+    }
+    getRun(id) {
+        return this.store.getRun(id);
+    }
+    listRuns() {
+        return this.store.listRuns().map((r) => ({
+            id: r.id,
+            prompt: r.prompt,
+            timestamp: r.timestamp,
+            modelCount: r.results.length,
+        }));
+    }
+    /** Compare two models' outputs within a run. */
+    compare(runId, modelA, modelB) {
+        const run = this.store.getRun(runId);
+        if (!run)
+            return null;
+        const a = run.results.find((r) => r.model === modelA);
+        const b = run.results.find((r) => r.model === modelB);
+        if (!a || !b)
+            return null;
+        return {
+            modelA: a.model,
+            modelB: b.model,
+            outputA: a.output,
+            outputB: b.output,
+            diff: lineDiff(a.output, b.output),
+            summary: diffSummary(a.output, b.output),
+            scoreA: run.scores[modelA],
+            scoreB: run.scores[modelB],
+        };
+    }
+    /** Set a user rating for a model in a run. */
+    rate(runId, model, rating) {
+        const run = this.store.getRun(runId);
+        if (!run)
+            return null;
+        if (!run.scores[model])
+            run.scores[model] = {};
+        run.scores[model].userRating = rating;
+        this.store.saveRun(run);
+        return run;
+    }
+    /** Save a benchmark suite. */
+    saveSuite(suite) {
+        this.store.saveSuite(suite);
+    }
+    /** Generate a regression report between two runs of the same suite. */
+    regression(suiteName, baselineRunId, currentRunId) {
+        const baseline = this.store.getRun(baselineRunId);
+        const current = this.store.getRun(currentRunId);
+        if (!baseline || !current)
+            return null;
+        const changes = [];
+        for (const cr of current.results) {
+            const br = baseline.results.find((r) => r.model === cr.model);
+            if (br && br.output !== cr.output) {
+                changes.push({
+                    model: cr.model,
+                    prompt: current.prompt,
+                    improved: (current.scores[cr.model]?.referenceMatch ?? 0) > (baseline.scores[cr.model]?.referenceMatch ?? 0),
+                    baselineOutput: br.output,
+                    currentOutput: cr.output,
+                });
+            }
+        }
+        return { suiteName, baselineRunId, currentRunId, changes };
+    }
+}

package/lib/arena.web.js

@@ -0,0 +1,29 @@
+// src/client/view.tsx
+function renderPanel(payload) {
+  const runRows = payload.recentRuns.map((r) => `<tr><td>${r.id}</td><td>${r.modelCount}</td><td>${new Date(r.timestamp).toLocaleString()}</td><td>${r.prompt.slice(0, 60)}...</td></tr>`).join("");
+  return `<div class="arena-panel">
+    <h2>Model Arena</h2>
+    ${runRows ? `<table class="arena-table"><thead><tr><th>Run</th><th>Models</th><th>Date</th><th>Prompt</th></tr></thead><tbody>${runRows}</tbody></table>` : "<p>No runs yet.</p>"}
+  </div>`;
+}
+
+// src/client/index.tsx
+var inject = ["@deepseek-ai/dsh-client-ui-settings", "@deepseek-ai/dsh-client-connection"];
+function apply(ctx) {
+  ctx.inject(inject, (settings, connection) => {
+    const s = settings;
+    const c = connection;
+    s.section("arena", {
+      title: "Model Arena",
+      render: async () => {
+        const res = await c.fetch("/api/arena.panel");
+        const payload = await res.json();
+        return renderPanel(payload);
+      }
+    });
+  });
+}
+export {
+  apply,
+  inject
+};

package/lib/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { run } from './cli.js';
+process.exitCode = run(process.argv.slice(2));

package/lib/cli.d.ts

@@ -0,0 +1 @@
+export declare function run(argv: string[]): number;

package/lib/cli.js

@@ -0,0 +1,70 @@
+import { parseArgs } from 'node:util';
+import { Arena } from './arena.js';
+export function run(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: {
+            'models': { type: 'string' },
+            'reference': { type: 'string' },
+            'rating': { type: 'string' },
+            'model': { type: 'string' },
+            'suite': { type: 'string' },
+        },
+        allowPositionals: true,
+    });
+    const projectDir = process.cwd();
+    const arena = new Arena(projectDir);
+    const cmd = positionals[0] ?? 'list';
+    switch (cmd) {
+        case 'list': {
+            const runs = arena.listRuns();
+            if (runs.length === 0) {
+                console.log('No arena runs found.');
+            }
+            else {
+                for (const r of runs) {
+                    console.log(`${r.id}  ${r.modelCount} models  ${new Date(r.timestamp).toLocaleString()}  ${r.prompt.slice(0, 60)}...`);
+                }
+            }
+            return 0;
+        }
+        case 'compare': {
+            const runId = positionals[1] ?? '';
+            const modelA = positionals[2] ?? '';
+            const modelB = positionals[3] ?? '';
+            const result = arena.compare(runId, modelA, modelB);
+            if (!result) {
+                console.log('Run or models not found.');
+                return 1;
+            }
+            console.log(`Comparing ${result.modelA} vs ${result.modelB}:`);
+            console.log(`Diff: +${result.summary.added} -${result.summary.removed} lines`);
+            for (const d of result.diff) {
+                const prefix = d.type === 'added' ? '+' : d.type === 'removed' ? '-' : ' ';
+                console.log(`${prefix} ${d.text}`);
+            }
+            return 0;
+        }
+        case 'rate': {
+            const runId = positionals[1] ?? '';
+            const model = values.model ?? '';
+            const rating = values.rating ? parseInt(values.rating, 10) : 0;
+            const result = arena.rate(runId, model, rating);
+            if (!result) {
+                console.log('Run not found.');
+                return 1;
+            }
+            console.log(`Rated ${model} as ${rating}/5 in run ${runId}`);
+            return 0;
+        }
+        case 'help':
+        default:
+            console.log('Usage: dsh-model-arena <command> [options]');
+            console.log('');
+            console.log('Commands:');
+            console.log('  list                     List recent runs');
+            console.log('  compare <run> <modelA> <modelB>  Compare two models in a run');
+            console.log('  rate <run> --model M --rating N  Rate a model output (1-5)');
+            return 0;
+    }
+}

package/lib/client/index.d.ts

@@ -0,0 +1,4 @@
+export declare const inject: string[];
+export declare function apply(ctx: {
+    inject: (deps: string[], fn: (...services: unknown[]) => void) => void;
+}): void;

package/lib/client/index.js

@@ -0,0 +1,16 @@
+import { renderPanel } from './view.js';
+export const inject = ['@deepseek-ai/dsh-client-ui-settings', '@deepseek-ai/dsh-client-connection'];
+export function apply(ctx) {
+    ctx.inject(inject, (settings, connection) => {
+        const s = settings;
+        const c = connection;
+        s.section('arena', {
+            title: 'Model Arena',
+            render: async () => {
+                const res = await c.fetch('/api/arena.panel');
+                const payload = await res.json();
+                return renderPanel(payload);
+            },
+        });
+    });
+}

package/lib/client/view.d.ts

@@ -0,0 +1,2 @@
+import type { PanelPayload } from '../types.js';
+export declare function renderPanel(payload: PanelPayload): string;

package/lib/client/view.js

@@ -0,0 +1,9 @@
+export function renderPanel(payload) {
+    const runRows = payload.recentRuns
+        .map((r) => `<tr><td>${r.id}</td><td>${r.modelCount}</td><td>${new Date(r.timestamp).toLocaleString()}</td><td>${r.prompt.slice(0, 60)}...</td></tr>`)
+        .join('');
+    return `<div class="arena-panel">
+    <h2>Model Arena</h2>
+    ${runRows ? `<table class="arena-table"><thead><tr><th>Run</th><th>Models</th><th>Date</th><th>Prompt</th></tr></thead><tbody>${runRows}</tbody></table>` : '<p>No runs yet.</p>'}
+  </div>`;
+}

package/lib/diff.d.ts

@@ -0,0 +1,11 @@
+/** Simple line-level diff for comparing model outputs. */
+export interface DiffLine {
+    type: 'same' | 'added' | 'removed';
+    text: string;
+}
+export declare function lineDiff(a: string, b: string): DiffLine[];
+export declare function diffSummary(a: string, b: string): {
+    added: number;
+    removed: number;
+    changed: number;
+};

package/lib/diff.js

@@ -0,0 +1,32 @@
+export function lineDiff(a, b) {
+    const linesA = a.split('\n');
+    const linesB = b.split('\n');
+    const result = [];
+    const maxLen = Math.max(linesA.length, linesB.length);
+    for (let i = 0; i < maxLen; i++) {
+        const la = linesA[i];
+        const lb = linesB[i];
+        if (la === lb) {
+            result.push({ type: 'same', text: la ?? '' });
+        }
+        else {
+            if (la !== undefined)
+                result.push({ type: 'removed', text: la });
+            if (lb !== undefined)
+                result.push({ type: 'added', text: lb });
+        }
+    }
+    return result;
+}
+export function diffSummary(a, b) {
+    const diff = lineDiff(a, b);
+    let added = 0;
+    let removed = 0;
+    for (const d of diff) {
+        if (d.type === 'added')
+            added++;
+        if (d.type === 'removed')
+            removed++;
+    }
+    return { added, removed, changed: added + removed };
+}

package/lib/index.d.ts

@@ -0,0 +1,24 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { Arena } from './arena.js';
+export declare const name = "dsh-model-arena";
+export interface ArenaService {
+    saveRun(prompt: string, results: {
+        model: string;
+        output: string;
+        promptTokens: number;
+        completionTokens: number;
+        latencyMs: number;
+        error?: string;
+    }[], reference?: string): ReturnType<Arena['saveRun']>;
+    getRun(id: string): ReturnType<Arena['getRun']>;
+    listRuns(): ReturnType<Arena['listRuns']>;
+    compare(runId: string, modelA: string, modelB: string): ReturnType<Arena['compare']>;
+    rate(runId: string, model: string, rating: number): ReturnType<Arena['rate']>;
+    saveSuite(suite: {
+        name: string;
+        prompts: string[];
+        models: string[];
+    }): void;
+    regression(suiteName: string, baselineRunId: string, currentRunId: string): ReturnType<Arena['regression']>;
+}
+export declare function apply(ctx: Context): void;

package/lib/index.js

@@ -0,0 +1,19 @@
+import { resolve } from 'node:path';
+import { Arena } from './arena.js';
+import { registerArenaRoutes } from './routes.js';
+export const name = 'dsh-model-arena';
+export function apply(ctx) {
+    const root = resolve(process.cwd());
+    const arena = new Arena(root);
+    const service = {
+        saveRun: (prompt, results, reference) => arena.saveRun(prompt, results, reference),
+        getRun: (id) => arena.getRun(id),
+        listRuns: () => arena.listRuns(),
+        compare: (runId, modelA, modelB) => arena.compare(runId, modelA, modelB),
+        rate: (runId, model, rating) => arena.rate(runId, model, rating),
+        saveSuite: (suite) => arena.saveSuite(suite),
+        regression: (suiteName, baselineRunId, currentRunId) => arena.regression(suiteName, baselineRunId, currentRunId),
+    };
+    ctx.provide('arena', service);
+    registerArenaRoutes(ctx, service);
+}

package/lib/routes.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ArenaService } from './index.js';
+import { ARENA_PANEL_PATH, ARENA_RUN_PATH, ARENA_RATE_PATH } from './arena-view.js';
+export { ARENA_PANEL_PATH, ARENA_RUN_PATH, ARENA_RATE_PATH };
+export declare function registerArenaRoutes(ctx: Context, arena: ArenaService): void;

package/lib/routes.js

@@ -0,0 +1,51 @@
+import { ARENA_PANEL_PATH, ARENA_RUN_PATH, ARENA_RATE_PATH } from './arena-view.js';
+export { ARENA_PANEL_PATH, ARENA_RUN_PATH, ARENA_RATE_PATH };
+export function registerArenaRoutes(ctx, arena) {
+    ctx.inject(['connection'], (connectionCtx) => {
+        const connection = connectionCtx.connection;
+        connection.fetch.register({
+            path: ARENA_PANEL_PATH,
+            methods: ['GET'],
+            requestBody: 'buffered',
+            fetch: () => Promise.resolve(Response.json(arena.listRuns(), {
+                headers: { 'cache-control': 'no-store' },
+            })),
+        });
+        connection.fetch.register({
+            path: ARENA_RUN_PATH,
+            methods: ['GET'],
+            requestBody: 'buffered',
+            fetch: async (request) => {
+                const url = new URL(request.url);
+                const id = url.searchParams.get('id');
+                if (!id)
+                    return Response.json({ error: 'missing id' }, { status: 400 });
+                const run = arena.getRun(id);
+                if (!run)
+                    return Response.json({ error: 'run not found' }, { status: 404 });
+                return Response.json(run, { headers: { 'cache-control': 'no-store' } });
+            },
+        });
+        connection.fetch.register({
+            path: ARENA_RATE_PATH,
+            methods: ['POST'],
+            requestBody: 'buffered',
+            fetch: async (request) => {
+                let body;
+                try {
+                    body = await request.json();
+                }
+                catch {
+                    return Response.json({ error: 'request body must be JSON' }, { status: 400 });
+                }
+                if (!body.runId || !body.model || body.rating === undefined) {
+                    return Response.json({ error: 'missing runId, model, or rating' }, { status: 400 });
+                }
+                const run = arena.rate(body.runId, body.model, body.rating);
+                if (!run)
+                    return Response.json({ error: 'run not found' }, { status: 404 });
+                return Response.json(run, { headers: { 'cache-control': 'no-store' } });
+            },
+        });
+    });
+}

package/lib/scoring.d.ts

@@ -0,0 +1,5 @@
+import type { ModelResult, Score } from './types.js';
+/** Score outputs automatically based on simple metrics. */
+export declare function autoScore(results: ModelResult[], reference?: string): Record<string, Score>;
+/** Simple character-level similarity (Jaccard on character bigrams). */
+export declare function similarity(a: string, b: string): number;

package/lib/scoring.js

@@ -0,0 +1,35 @@
+/** Score outputs automatically based on simple metrics. */
+export function autoScore(results, reference) {
+    const scores = {};
+    const maxLen = Math.max(...results.map((r) => r.output.length), 1);
+    const minLatency = Math.min(...results.map((r) => r.latencyMs), 1);
+    for (const r of results) {
+        const score = {
+            lengthScore: r.output.length / maxLen,
+            latencyScore: minLatency / r.latencyMs,
+        };
+        if (reference) {
+            score.referenceMatch = similarity(r.output, reference);
+        }
+        scores[r.model] = score;
+    }
+    return scores;
+}
+/** Simple character-level similarity (Jaccard on character bigrams). */
+export function similarity(a, b) {
+    if (a === b)
+        return 1;
+    if (a.length < 2 || b.length < 2)
+        return 0;
+    const bigramsA = new Set();
+    for (let i = 0; i < a.length - 1; i++)
+        bigramsA.add(a.slice(i, i + 2));
+    const bigramsB = new Set();
+    for (let i = 0; i < b.length - 1; i++)
+        bigramsB.add(b.slice(i, i + 2));
+    let intersection = 0;
+    for (const bg of bigramsA)
+        if (bigramsB.has(bg))
+            intersection++;
+    return intersection / (bigramsA.size + bigramsB.size - intersection);
+}

package/lib/store.d.ts

@@ -0,0 +1,13 @@
+import type { ArenaRun, Suite } from './types.js';
+export declare class ArenaStore {
+    private readonly projectDir;
+    private readonly arenaDir;
+    constructor(projectDir: string);
+    private ensureDir;
+    saveRun(run: ArenaRun): void;
+    getRun(id: string): ArenaRun | null;
+    listRuns(): ArenaRun[];
+    saveSuite(suite: Suite): void;
+    getSuite(name: string): Suite | null;
+    static generateId(prompt: string, models: string[]): string;
+}

package/lib/store.js

@@ -0,0 +1,50 @@
+import { writeFileSync, readFileSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+export class ArenaStore {
+    projectDir;
+    arenaDir;
+    constructor(projectDir) {
+        this.projectDir = projectDir;
+        this.arenaDir = join(projectDir, '.arena');
+    }
+    ensureDir() {
+        if (!existsSync(this.arenaDir))
+            mkdirSync(this.arenaDir, { recursive: true });
+    }
+    saveRun(run) {
+        this.ensureDir();
+        writeFileSync(join(this.arenaDir, `${run.id}.json`), JSON.stringify(run, null, 2), 'utf8');
+    }
+    getRun(id) {
+        const path = join(this.arenaDir, `${id}.json`);
+        if (!existsSync(path))
+            return null;
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    listRuns() {
+        if (!existsSync(this.arenaDir))
+            return [];
+        return readdirSync(this.arenaDir)
+            .filter((f) => f.endsWith('.json'))
+            .map((f) => JSON.parse(readFileSync(join(this.arenaDir, f), 'utf8')))
+            .sort((a, b) => b.timestamp - a.timestamp);
+    }
+    saveSuite(suite) {
+        this.ensureDir();
+        writeFileSync(join(this.arenaDir, `suite-${suite.name}.json`), JSON.stringify(suite, null, 2), 'utf8');
+    }
+    getSuite(name) {
+        const path = join(this.arenaDir, `suite-${name}.json`);
+        if (!existsSync(path))
+            return null;
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    static generateId(prompt, models) {
+        const hash = createHash('sha256');
+        hash.update(prompt);
+        hash.update(models.join(','));
+        hash.update(Date.now().toString());
+        return hash.digest('hex').slice(0, 12);
+    }
+}

package/lib/types.d.ts

@@ -0,0 +1,46 @@
+export interface ModelResult {
+    model: string;
+    output: string;
+    promptTokens: number;
+    completionTokens: number;
+    latencyMs: number;
+    error?: string;
+}
+export interface Score {
+    userRating?: number;
+    lengthScore?: number;
+    latencyScore?: number;
+    referenceMatch?: number;
+}
+export interface ArenaRun {
+    id: string;
+    prompt: string;
+    timestamp: number;
+    results: ModelResult[];
+    scores: Record<string, Score>;
+}
+export interface Suite {
+    name: string;
+    prompts: string[];
+    models: string[];
+}
+export interface RegressionReport {
+    suiteName: string;
+    baselineRunId: string;
+    currentRunId: string;
+    changes: {
+        model: string;
+        prompt: string;
+        improved: boolean;
+        baselineOutput: string;
+        currentOutput: string;
+    }[];
+}
+export interface PanelPayload {
+    recentRuns: {
+        id: string;
+        prompt: string;
+        timestamp: number;
+        modelCount: number;
+    }[];
+}

package/lib/types.js

@@ -0,0 +1,2 @@
+// Types for dsh-model-arena
+export {};

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "dsh-model-arena",
+  "version": "0.1.0",
+  "description": "Run the same prompt through every model you have, and see the difference without squinting.",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "bin": {
+    "dsh-model-arena": "lib/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/client.d.ts",
+      "default": "./lib/arena.web.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "model",
+    "comparison",
+    "arena",
+    "benchmark"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-connection"
+      ]
+    }
+  },
+  "license": "MIT",
+  "author": "hj01857655",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hj01857655/dsh-model-arena.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hj01857655/dsh-model-arena/issues"
+  },
+  "homepage": "https://github.com/hj01857655/dsh-model-arena#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@types/node": "^22.20.3",
+    "@types/react": "^19.3.0",
+    "esbuild": "^0.28.2",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "typescript": "^5.6.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/bundle-client.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json",
+    "test": "tsc -p tsconfig.json && node --test tests/*.test.mjs",
+    "prepublishOnly": "npm run build && npm test"
+  }
+}