prompt-contract 0.2.0

package/packages/core/src/rules.js

@@ -0,0 +1,91 @@
+/**
+ * The six hard constraints from the PRD appendix, as deterministic rule assertions.
+ * Same spec drives three surfaces: `contract check` (CLI), playground badges, eval runner —
+ * template and evaluation share one source of truth (PRD: 模板与评测共用同一份规格).
+ *
+ * Known heuristic limits (do not oversell — see docs/ACCEPTANCE.md "Evidence boundaries"):
+ * - `lang-consistency` is SCRIPT detection (han/kana/latin…), not language identification;
+ * - `no-hallucinated-tech` relies on a fixed denylist;
+ * - `expand-not-answer` matches answer-style openers and trailing questions;
+ * - `polish-when-clear` (constraint #5) needs semantic judgment and is judge-only (M2).
+ * These assert format/edge compliance; they do NOT prove downstream task improvement.
+ */
+import { detectScriptName } from './lang.js';
+
+/** Common tech names — flagged when they appear in output but were never in the input (hard constraint #6). */
+const TECH_DENYLIST = [
+  'next.js', 'nuxt', 'react', 'vue', 'angular', 'svelte', 'tailwind', 'bootstrap', 'jquery',
+  'django', 'flask', 'fastapi', 'spring', 'rails', 'laravel',
+  'postgresql', 'mysql', 'mongodb', 'redis', 'sqlite',
+  'docker', 'kubernetes', 'graphql', 'grpc', 'typescript', 'javascript', 'python', 'rust',
+  'swift', 'kotlin', 'prisma', 'supabase', 'firebase', 'vercel', 'kafka', 'elasticsearch'
+];
+
+const ANSWER_OPENERS = /^(好的|当然[啦咯]?|没问题|明白了|收到|以下是|这是|here'?s\b|here is\b|sure\b[,!]|certainly\b|i'?(ll| will| can) (help|create|write|generate|provide|design|build))/i;
+const META_LABELS = /^(enhanced\s*prompt|optimized\s*prompt|优化后的?提示?词|增强后的?提示?词|改写后|新提示词)\s*[:：]/i;
+const WRAPPED_IN_QUOTES = /^['"“”‘’«»][\s\S]+['"“”‘’«»]$/;
+
+function escapeRe(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+function result(id, title, pass, detail) {
+  return { id, title, pass, detail: detail || '' };
+}
+
+/**
+ * Assert the hard constraints. `opts.maxChars` defaults to 800.
+ * Rule 5 (`polish-when-clear`) is judge-only (needs semantic judgment) and intentionally absent here.
+ */
+export function checkRules(original, enhanced, opts = {}) {
+  const maxChars = opts.maxChars ?? 800;
+  const out = String(enhanced ?? '');
+  const trimmed = out.trim();
+  const results = [];
+
+  results.push(result('non-empty', '输出非空', trimmed.length > 0, trimmed.length > 0 ? '' : 'empty output'));
+
+  const inScript = detectScriptName(original || '');
+  const outScript = detectScriptName(out);
+  results.push(result(
+    'lang-consistency', '语言一致性',
+    inScript === outScript,
+    `input=${inScript}, output=${outScript}`
+  ));
+
+  const hasFence = out.includes('```');
+  const wrapped = WRAPPED_IN_QUOTES.test(trimmed);
+  const hasMeta = META_LABELS.test(trimmed);
+  results.push(result(
+    'only-enhanced-text', '只输出增强文本',
+    !hasFence && !wrapped && !hasMeta,
+    [hasFence && 'markdown fence', wrapped && 'wrapping quotes', hasMeta && 'meta label'].filter(Boolean).join(', ')
+  ));
+
+  const chars = [...trimmed].length;
+  const dangling = /([-*+]+|[:：])\s*$/.test(trimmed);
+  results.push(result(
+    'length-limit', '长度与完整性',
+    chars > 0 && chars <= maxChars && !dangling,
+    `${chars}/${maxChars} chars${dangling ? ', dangling colon/marker' : ''}`
+  ));
+
+  const endsWithQuestion = /[?？]\s*$/.test(trimmed);
+  const opener = ANSWER_OPENERS.exec(trimmed);
+  results.push(result(
+    'expand-not-answer', '扩写而非回答',
+    !opener && !endsWithQuestion,
+    [opener && `answer opener "${opener[1]}"`, endsWithQuestion && 'ends with a question'].filter(Boolean).join(', ')
+  ));
+
+  const lowerOut = out.toLowerCase();
+  const lowerIn = String(original ?? '').toLowerCase();
+  const hallucinated = TECH_DENYLIST.filter((name) => lowerOut.includes(name) && !lowerIn.includes(name));
+  results.push(result(
+    'no-hallucinated-tech', '无未提及的技术栈',
+    hallucinated.length === 0,
+    hallucinated.length ? `added: ${hallucinated.join(', ')}` : ''
+  ));
+
+  return { pass: results.every((r) => r.pass), results };
+}
+
+export { escapeRe };

package/packages/core/test/clean.test.js

@@ -0,0 +1,44 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { stripWrappingQuotes, stripFences, clampChars, postprocess } from '../src/clean.js';
+
+test('stripWrappingQuotes removes paired quotes repeatedly', () => {
+  assert.equal(stripWrappingQuotes('"hello"'), 'hello');
+  assert.equal(stripWrappingQuotes('“你好世界”'), '你好世界');
+  assert.equal(stripWrappingQuotes('‘“嵌套”’'), '嵌套');
+  assert.equal(stripWrappingQuotes('「block」'), 'block');
+});
+
+test('stripWrappingQuotes keeps inner apostrophes', () => {
+  assert.equal(stripWrappingQuotes("it's ok"), "it's ok");
+});
+
+test('stripFences removes full and partial fences', () => {
+  assert.equal(stripFences('```\ntext\n```'), 'text');
+  assert.equal(stripFences('```md\n# title\n```'), '# title');
+  assert.equal(stripFences('```\nno closing'), 'no closing');
+  assert.equal(stripFences('plain'), 'plain');
+});
+
+test('clampChars cuts at sentence boundary under the limit', () => {
+  const t = '第一句。第二句。' + '长'.repeat(900);
+  const out = clampChars(t, 800);
+  assert.ok([...out].length <= 800);
+  assert.ok(out.endsWith('。') || out.endsWith('长'));
+});
+
+test('clampChars removes dangling colon and list markers', () => {
+  const t = '要点如下：' + 'x'.repeat(798);
+  const out = clampChars(t, 800);
+  assert.ok(!/[:：]\s*$/.test(out));
+  assert.ok(!/[-*+]\s*$/.test(out));
+});
+
+test('clampChars leaves short text untouched', () => {
+  assert.equal(clampChars('短文本', 800), '短文本');
+});
+
+test('postprocess: null for empty, strips combo of fences + quotes', () => {
+  assert.equal(postprocess('   \n\t', 800), null);
+  assert.equal(postprocess('```\n“最终文本”\n```', 800), '最终文本');
+});

package/packages/core/test/lang.test.js

@@ -0,0 +1,21 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { detectScriptName } from '../src/lang.js';
+
+test('dominant script detection', () => {
+  assert.equal(detectScriptName('你好世界'), 'han');
+  assert.equal(detectScriptName('hello world'), 'latin');
+  assert.equal(detectScriptName('こんにちは世界'), 'japanese');
+  assert.equal(detectScriptName('Привет мир'), 'cyrillic');
+  assert.equal(detectScriptName('안녕하세요'), 'hangul');
+});
+
+test('mixed CJK/latin resolves to the CJK script', () => {
+  assert.equal(detectScriptName('用 React 重构这个 module'), 'han');
+  assert.equal(detectScriptName('refactor this module 用例'), 'han');
+});
+
+test('japanese beats han when kana present (enables zh→ja detection)', () => {
+  assert.equal(detectScriptName('世界'), 'han');
+  assert.equal(detectScriptName('世界です'), 'japanese');
+});

package/packages/core/test/pipeline.test.js

@@ -0,0 +1,85 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { enhance, assembleMessages, hardConstraints } from '../src/pipeline.js';
+import { PromptContractError } from '../src/errors.js';
+
+const PROFILE = { name: 'coding-agent', maxChars: 800, body: 'You rewrite vague requests for a coding assistant.' };
+
+function fakeProvider(reply, { fail } = {}) {
+  const calls = [];
+  return {
+    calls,
+    async complete(opts) {
+      calls.push(opts);
+      if (fail === 'abort') { const e = new Error('aborted'); e.name = 'AbortError'; throw e; }
+      if (fail === 'boom') throw new Error('socket hang up');
+      return { text: reply };
+    }
+  };
+}
+
+test('assembleMessages embeds profile body, constraints, strength and context', () => {
+  const { system, user } = assembleMessages('做个网站', { profile: PROFILE, strength: 'expand', context: 'repo: pet-project' });
+  assert.match(system, /You rewrite vague requests/);
+  assert.match(system, /HARD CONSTRAINTS:/);
+  assert.match(system, /under 800 characters/);
+  assert.match(system, /STRENGTH MODE: EXPAND/);
+  assert.match(user, /USER INPUT:\n做个网站/);
+  assert.match(user, /CONTEXT \(background[^\n]*\):\nrepo: pet-project/);
+});
+
+test('all three strengths render distinct modes', () => {
+  for (const s of ['polish', 'standard', 'expand']) {
+    const { system } = assembleMessages('x', { profile: PROFILE, strength: s });
+    assert.match(system, new RegExp(`STRENGTH MODE: ${s.toUpperCase()}`));
+  }
+});
+
+test('hardConstraints mirror the six eval rules', () => {
+  const hc = hardConstraints({ maxChars: 800, strength: 'standard' });
+  assert.match(hc, /same language as USER INPUT/);
+  assert.match(hc, /no markdown fences/);
+  assert.match(hc, /under 800 characters/);
+  assert.match(hc, /EXPAND, DO NOT ANSWER/);
+  assert.match(hc, /lightly polish/);
+  assert.match(hc, /do not add requirements, features, or technologies/);
+});
+
+test('enhance: happy path returns cleaned text + original + meta', async () => {
+  const provider = fakeProvider('  “请结构化地说明……”  ');
+  const res = await enhance('帮我解释', { profile: PROFILE, provider, model: 'm1', strength: 'standard' });
+  assert.equal(res.text, '请结构化地说明……');
+  assert.equal(res.original, '帮我解释');
+  assert.equal(res.meta.profile, 'coding-agent');
+  assert.equal(res.meta.model, 'm1');
+  assert.equal(typeof res.meta.ms, 'number');
+  assert.equal(provider.calls[0].maxTokens, Math.ceil(800 * 1.2));
+});
+
+test('enhance: empty input → empty_input', async () => {
+  await assert.rejects(
+    () => enhance('   ', { profile: PROFILE, provider: fakeProvider('x') }),
+    (e) => e instanceof PromptContractError && e.code === 'empty_input'
+  );
+});
+
+test('enhance: empty provider result → llm_error', async () => {
+  await assert.rejects(
+    () => enhance('hello', { profile: PROFILE, provider: fakeProvider('   ') }),
+    (e) => e.code === 'llm_error'
+  );
+});
+
+test('enhance: caller abort → aborted (ADR-017 semantics)', async () => {
+  await assert.rejects(
+    () => enhance('hello', { profile: PROFILE, provider: fakeProvider(null, { fail: 'abort' }) }),
+    (e) => e.code === 'aborted'
+  );
+});
+
+test('enhance: unexpected provider crash → provider_unavailable', async () => {
+  await assert.rejects(
+    () => enhance('hello', { profile: PROFILE, provider: fakeProvider(null, { fail: 'boom' }) }),
+    (e) => e.code === 'provider_unavailable'
+  );
+});

package/packages/core/test/profile.test.js

@@ -0,0 +1,40 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { parseProfile, parseYamlLite } from '../src/profile.js';
+import { PromptContractError } from '../src/errors.js';
+
+const SAMPLE = `---
+name: test-profile
+domain: 测试场景
+maxChars: 600
+noUnmentionedTech: true
+---
+You rewrite vague requests. Preserve intent and language.`;
+
+test('parseProfile reads frontmatter scalars and body', () => {
+  const p = parseProfile(SAMPLE, { path: 'test.md' });
+  assert.equal(p.name, 'test-profile');
+  assert.equal(p.domain, '测试场景');
+  assert.equal(p.maxChars, 600);
+  assert.equal(p.noUnmentionedTech, true);
+  assert.match(p.body, /Preserve intent and language\.$/);
+});
+
+test('parseProfile applies defaults', () => {
+  const p = parseProfile('---\nname: minimal\n---\nBody here.');
+  assert.equal(p.maxChars, 800);
+  assert.equal(p.noUnmentionedTech, true);
+  assert.equal(p.domain, '');
+});
+
+test('parseProfile rejects malformed input with config_error', () => {
+  assert.throws(() => parseProfile('no frontmatter here'), (e) => e instanceof PromptContractError && e.code === 'config_error');
+  assert.throws(() => parseProfile('---\ndomain: x\n---\nbody'), (e) => e.code === 'config_error');
+});
+
+test('parseYamlLite handles string lists', () => {
+  const y = parseYamlLite('items:\n  - a\n  - b\nflag: false\ncount: 3');
+  assert.deepEqual(y.items, ['a', 'b']);
+  assert.equal(y.flag, false);
+  assert.equal(y.count, 3);
+});

package/packages/core/test/rules.test.js

@@ -0,0 +1,53 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { checkRules } from '../src/rules.js';
+
+const GOOD_EN = 'Build a small responsive website showcasing one pet: a photo gallery, a biography page, and an update feed. Keep navigation simple and skip comments.';
+const GOOD_ZH = '做一个展示宠物的小型网站：包含照片画廊、简介页与动态页，导航保持单层，暂不需要评论功能。';
+
+test('good outputs pass all six assertions', () => {
+  for (const [orig, out] of [['A website for my dog', GOOD_EN], ['帮我做一个宠物网站', GOOD_ZH]]) {
+    const { pass, results } = checkRules(orig, out);
+    assert.equal(pass, true, JSON.stringify(results.filter((r) => !r.pass)));
+  }
+});
+
+test('lang-consistency fails on script switch', () => {
+  const { results } = checkRules('帮我做一个网站', GOOD_EN);
+  const r = results.find((r) => r.id === 'lang-consistency');
+  assert.equal(r.pass, false);
+});
+
+test('only-enhanced-text fails on fences, wrapping quotes and meta labels', () => {
+  for (const bad of ['```text\nx\n```', '“结果”', '增强后的提示词：写一封邮件', 'Enhanced prompt: do something']) {
+    const { results } = checkRules('写一封邮件', bad, { maxChars: 800 });
+    assert.equal(results.find((r) => r.id === 'only-enhanced-text').pass, false, bad);
+  }
+});
+
+test('length-limit fails on overflow and dangling colon', () => {
+  const long = 'x'.repeat(900);
+  const { results } = checkRules('x', long);
+  assert.equal(results.find((r) => r.id === 'length-limit').pass, false);
+  const { results: r2 } = checkRules('x', '要点如下：');
+  assert.equal(r2.find((r) => r.id === 'length-limit').pass, false);
+});
+
+test('expand-not-answer fails on answer openers and clarifying questions', () => {
+  for (const bad of ['好的，以下是实现方案：先装依赖再写组件。', "Here's how you can do it: install the deps first.", '你想用哪种框架？']) {
+    const { results } = checkRules('做个网站', bad);
+    assert.equal(results.find((r) => r.id === 'expand-not-answer').pass, false, bad);
+  }
+});
+
+test('no-hallucinated-tech flags tech names absent from input', () => {
+  const { results } = checkRules('做一个读书笔记应用', '用 React 和 PostgreSQL 构建笔记应用');
+  assert.equal(results.find((r) => r.id === 'no-hallucinated-tech').pass, false);
+  const ok = checkRules('用 React 做个笔记应用', '用 React 实现笔记的增删改查，数据存本地文件，支持全文检索');
+  assert.equal(ok.results.find((r) => r.id === 'no-hallucinated-tech').pass, true);
+});
+
+test('japanese output fails for chinese input (kana detector)', () => {
+  const { results } = checkRules('サイトを作って', '做一个展示宠物的网站：包含照片画廊。');
+  assert.equal(results.find((r) => r.id === 'lang-consistency').pass, false);
+});

package/packages/mcp-server/bin/prompt-contract-mcp.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { serve } from '../src/server.js';
+
+serve({ argv: process.argv.slice(2) }).catch((err) => {
+  process.stderr.write(`[prompt-contract] fatal: ${err.message}\n`);
+  process.exit(1);
+});

package/packages/mcp-server/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@prompt-contract/mcp-server",
+  "version": "0.1.0",
+  "description": "PromptContract MCP server — enhance_prompt tool + boost-* prompts, stdio JSON-RPC, zero dependencies",
+  "type": "module",
+  "license": "Apache-2.0",
+  "bin": {
+    "prompt-contract-mcp": "./bin/prompt-contract-mcp.js"
+  }
+}

package/packages/mcp-server/src/server.js

@@ -0,0 +1,184 @@
+/**
+ * PromptContract MCP server (PRD §6) — stdio, newline-delimited JSON-RPC 2.0.
+ *
+ * Two integration modes, deliberately asymmetric in their configuration needs:
+ *  - tool  `enhance_prompt`: agent-invoked; the server calls the configured provider (BYOK via env/config).
+ *  - prompt `contract-<profile>`: user-invoked slash command; the rewrite instruction is injected into the
+ *    client's OWN model — this mode needs NO API key and NO provider config, so provider resolution is
+ *    lazy: an unconfigured server starts fine and only tool calls report `config_error`.
+ */
+import { enhance, hardConstraints, STRENGTHS, PromptContractError, normalizeError } from '../../core/src/index.js';
+import { loadProfiles, loadProfile, resolveConfig } from '../../core/src/node.js';
+import { createOpenAIProvider } from '../../providers/src/openai.js';
+import { createOllamaProvider } from '../../providers/src/ollama.js';
+
+const SERVER_INFO = { name: 'prompt-contract', version: '0.1.0' };
+
+export function createServer({ profiles, getRuntime }) {
+  function promptTextFor(profile, text) {
+    // Zero-key mode: hand the client's own model the same spec our engine would use.
+    return [
+      profile.body.trim(),
+      hardConstraints({ maxChars: profile.maxChars, strength: 'standard' }),
+      `STRENGTH MODE: ${STRENGTHS.standard}`,
+      '',
+      'USER INPUT:',
+      text,
+      '',
+      'Rewrite the USER INPUT as specified and return only the enhanced prompt text.'
+    ].join('\n\n');
+  }
+
+  async function handle(msg) {
+    const { id, method, params } = msg;
+    if (method === 'initialize') {
+      return {
+        protocolVersion: params?.protocolVersion ?? '2025-06-18',
+        capabilities: { tools: { listChanged: false }, prompts: { listChanged: false } },
+        serverInfo: SERVER_INFO
+      };
+    }
+    if (method === 'ping') return {};
+
+    if (method === 'tools/list') {
+      return {
+        tools: [{
+          name: 'enhance_prompt',
+          description: 'Rewrite a vague user prompt into a clear, specific, executable prompt. Returns only the enhanced text. Requires a configured provider (CONTRACT_API_KEY/CONTRACT_PROVIDER or config file).',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              text: { type: 'string', description: 'The raw user prompt to enhance' },
+              profile: { type: 'string', enum: profiles.map((p) => p.name), description: 'Scenario profile (default: coding-agent)' },
+              strength: { type: 'string', enum: ['polish', 'standard', 'expand'], description: 'Enhancement strength (default: standard)' },
+              context: { type: 'string', description: 'Optional background context (e.g. repo summary) assembled into the prompt' }
+            },
+            required: ['text']
+          }
+        }]
+      };
+    }
+
+    if (method === 'tools/call') {
+      if (params?.name !== 'enhance_prompt') {
+        throw rpcError(id, -32602, `unknown tool "${params?.name}"`);
+      }
+      const args = params.arguments ?? {};
+      try {
+        const { config, provider } = getRuntime(); // lazy — a prompt-only server never pays this
+        const profile = args.profile ? loadProfile(args.profile) : profiles.find((p) => p.name === 'coding-agent') ?? profiles[0];
+        const res = await enhance(String(args.text ?? ''), {
+          profile,
+          provider,
+          model: config.model,
+          strength: args.strength,
+          context: args.context,
+          timeoutMs: 30000
+        });
+        return { content: [{ type: 'text', text: res.text }] };
+      } catch (err) {
+        const e = normalizeError(err);
+        return { content: [{ type: 'text', text: `prompt-contract error ${e.code}: ${e.message}` }], isError: true };
+      }
+    }
+
+    if (method === 'prompts/list') {
+      return {
+        prompts: profiles.map((p) => ({
+          name: `contract-${p.name}`,
+          description: `Enhance a prompt with the "${p.name}" profile (uses this client's own model, no API key needed)`,
+          arguments: [{ name: 'text', description: 'The raw prompt to enhance', required: true }]
+        }))
+      };
+    }
+
+    if (method === 'prompts/get') {
+      const name = String(params?.name ?? '');
+      const profile = profiles.find((p) => `contract-${p.name}` === name);
+      if (!profile) throw rpcError(id, -32602, `unknown prompt "${name}"`);
+      const text = String(params?.arguments?.text ?? '');
+      if (!text.trim()) throw rpcError(id, -32602, 'argument "text" is required');
+      return { description: `PromptContract · ${profile.name}`, messages: [{ role: 'user', content: { type: 'text', text: promptTextFor(profile, text) } }] };
+    }
+
+    throw rpcError(id, -32601, `method not found: ${method}`);
+  }
+
+  function rpcError(id, code, message) {
+    const err = new Error(message);
+    err.rpcCode = code;
+    err.rpcId = id;
+    return err;
+  }
+
+  return { handle, state: { profiles } };
+}
+
+/** Wire the server to stdin/stdout. One line = one JSON-RPC message. Never log prompt content. */
+export async function serve({ stdin = process.stdin, stdout = process.stdout, stderr = process.stderr, argv = [] } = {}) {
+  const flag = (name) => {
+    const i = argv.indexOf(name);
+    return i >= 0 ? argv[i + 1] : undefined;
+  };
+  const profiles = loadProfiles(flag('--profiles-dir'));
+
+  // Provider/config is resolved lazily so the zero-key prompt mode truly needs zero configuration.
+  let runtime = null;
+  let startupError = null;
+  function getRuntime() {
+    if (runtime) return runtime;
+    if (startupError) throw startupError;
+    const config = resolveConfig({ provider: flag('--provider'), baseUrl: flag('--base-url'), apiKey: flag('--api-key'), model: flag('--model'), configPath: flag('--config') });
+    const provider = config.provider === 'ollama'
+      ? createOllamaProvider({ baseUrl: config.baseUrl })
+      : createOpenAIProvider({ baseUrl: config.baseUrl, apiKey: config.apiKey });
+    provider.warmup({ model: config.model }).catch(() => {}); // §7.6-1: prewarm, best effort
+    runtime = { config, provider };
+    return runtime;
+  }
+  try {
+    getRuntime();
+  } catch (err) {
+    startupError = err;
+    stderr.write(`[prompt-contract] tool mode unavailable (${err.code ?? 'error'}: ${err.message}) — prompts (zero-key) remain available\n`);
+  }
+
+  const server = createServer({ profiles, getRuntime });
+  stderr.write(`[prompt-contract] mcp server ready (tool mode: ${runtime ? `provider=${runtime.config.provider}` : 'unconfigured'}, profiles=${profiles.length})\n`);
+
+  let buffer = '';
+  stdin.setEncoding('utf8');
+  stdin.on('data', (chunk) => {
+    buffer += chunk;
+    let nl;
+    while ((nl = buffer.indexOf('\n')) >= 0) {
+      const line = buffer.slice(0, nl).trim();
+      buffer = buffer.slice(nl + 1);
+      if (!line) continue;
+      let msg;
+      try { msg = JSON.parse(line); } catch {
+        write({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'parse error' } });
+        continue;
+      }
+      if (msg.id === undefined || msg.id === null) continue; // notification — no response
+      server.handle(msg)
+        .then((result) => write({ jsonrpc: '2.0', id: msg.id, result }))
+        .catch((err) => {
+          const code = err.rpcCode ?? -32603;
+          write({ jsonrpc: '2.0', id: err.rpcId ?? msg.id, error: { code, message: err.message } });
+        });
+    }
+  });
+  stdin.on('end', () => process.exit(0));
+
+  function write(obj) {
+    stdout.write(JSON.stringify(obj) + '\n');
+  }
+}
+
+if (process.argv[1] && import.meta.url === `file://${process.argv[1]}`) {
+  serve({ argv: process.argv.slice(2) }).catch((err) => {
+    if (err instanceof PromptContractError) { process.stderr.write(`[prompt-contract] ${err.code}: ${err.message}\n`); process.exit(1); }
+    throw err;
+  });
+}