@holdyourvoice/hyv 2.9.28 → 3.0.1

package/dist/mcp.js

@@ -0,0 +1,69 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { analyzeForMcp, buildProfileForMcp, patternsForMcp, rewritePromptForMcp, verifyForMcp } from './mcp-tools.js';
+const writing = z.string().min(1).max(100_000);
+const profileJson = z.string().min(1).max(50_000);
+const samples = z.array(writing).min(2).max(20);
+const avoid = z.array(z.string().min(1).max(200)).max(50).optional();
+function json(value) {
+    return { content: [{ type: 'text', text: JSON.stringify(value, null, 2) }] };
+}
+function failure(error) {
+    return { content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }], isError: true };
+}
+const server = new McpServer({ name: 'hold-your-voice', version: '3.0.1' });
+server.registerTool('hyv_build_profile', {
+    description: 'Build a portable VoiceDNA profile from at least two writing samples. The samples stay in memory and are not saved.',
+    inputSchema: { samples, avoid },
+    annotations: { readOnlyHint: true },
+}, async ({ samples: writingSamples, avoid: phrases }) => {
+    try {
+        return json(buildProfileForMcp(writingSamples, phrases));
+    }
+    catch (error) {
+        return failure(error);
+    }
+});
+server.registerTool('hyv_analyze', {
+    description: 'Run the separate VoiceDNA and AI Editor checks against a draft using a portable profile JSON string.',
+    inputSchema: { draft: writing, profile_json: profileJson },
+    annotations: { readOnlyHint: true },
+}, async ({ draft, profile_json }) => {
+    try {
+        return json(analyzeForMcp(draft, profile_json));
+    }
+    catch (error) {
+        return failure(error);
+    }
+});
+server.registerTool('hyv_rewrite_prompt', {
+    description: 'Create a constrained editing brief. It does not rewrite the draft or call a model.',
+    inputSchema: { draft: writing, profile_json: profileJson },
+    annotations: { readOnlyHint: true },
+}, async ({ draft, profile_json }) => {
+    try {
+        return json(rewritePromptForMcp(draft, profile_json));
+    }
+    catch (error) {
+        return failure(error);
+    }
+});
+server.registerTool('hyv_verify', {
+    description: 'Verify a revised candidate against an original draft and portable profile. Reports regressions and preservation without saving either text.',
+    inputSchema: { original: writing, candidate: writing, profile_json: profileJson },
+    annotations: { readOnlyHint: true },
+}, async ({ original, candidate, profile_json }) => {
+    try {
+        return json(verifyForMcp(original, candidate, profile_json));
+    }
+    catch (error) {
+        return failure(error);
+    }
+});
+server.registerTool('hyv_patterns', {
+    description: 'List the exact AI Editor rules that run in this extension.',
+    inputSchema: {},
+    annotations: { readOnlyHint: true },
+}, async () => json(patternsForMcp()));
+await server.connect(new StdioServerTransport());

package/dist/mcp.test.js

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import test from 'node:test';
+test('serves the read-only Claude tools over stdio', async () => {
+    const server = spawn(process.execPath, [new URL('./mcp.js', import.meta.url).pathname], { stdio: ['pipe', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    server.stdout.on('data', (chunk) => { stdout += chunk; });
+    server.stderr.on('data', (chunk) => { stderr += chunk; });
+    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'test', version: '1.0.0' } } })}\n`);
+    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized', params: {} })}\n`);
+    server.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} })}\n`);
+    server.stdin.end();
+    const [code] = await once(server, 'close');
+    assert.equal(stderr, '');
+    assert.equal(code, 0);
+    const responses = stdout.trim().split('\n').map((line) => JSON.parse(line));
+    const tools = responses.find((response) => response.id === 2)?.result?.tools;
+    assert.deepEqual(tools?.map((tool) => tool.name), ['hyv_build_profile', 'hyv_analyze', 'hyv_rewrite_prompt', 'hyv_verify', 'hyv_patterns']);
+    assert.ok(tools?.every((tool) => tool.annotations?.readOnlyHint));
+});

package/dist/pipeline.js

@@ -0,0 +1,64 @@
+import { analyzeAiEditor } from './ai-editor.js';
+import { analyzeVoiceDna } from './voice-dna.js';
+import { words } from './text.js';
+export function analyze(text, profile) {
+    const voiceDna = analyzeVoiceDna(text, profile);
+    const aiEditor = analyzeAiEditor(text);
+    return { version: '2', voiceDna, aiEditor, passed: voiceDna.passed && aiEditor.passed };
+}
+function formatFindings(findings) {
+    return findings.map((finding) => `- Sentence ${finding.sentence} [${finding.engine}/${finding.id}]: ${finding.reason} Repair: ${finding.suggestion}`);
+}
+export function rewritePrompt(draft, profile) {
+    const result = analyze(draft, profile);
+    const allFindings = [...result.voiceDna.findings, ...result.aiEditor.findings];
+    const redFindings = allFindings.filter((finding) => finding.severity === 'red');
+    const yellowFindings = allFindings.filter((finding) => finding.severity === 'yellow');
+    const metrics = profile.metrics;
+    return [
+        '# Tier 0 — non-negotiable preservation',
+        'Preserve facts, names, numbers, claims, and every unflagged sentence exactly. Do not add claims, examples, sections, hooks, or CTAs.',
+        '',
+        '# Tier 1 — release blockers',
+        `VoiceDNA: ${result.voiceDna.score}/100 (${result.voiceDna.passed ? 'pass' : 'fail'}).`,
+        `AI Editor: ${result.aiEditor.score}/100 (${result.aiEditor.passed ? 'pass' : 'fail'}).`,
+        ...profile.avoid.map((phrase) => `- Never use: ${phrase}`),
+        ...(redFindings.length ? formatFindings(redFindings) : ['- None.']),
+        '',
+        '# Tier 2 — VoiceDNA fidelity',
+        `- Sentence length: ${metrics.sentenceLength}; sentence variation: ${metrics.sentenceVariation}; sentence structure: ${metrics.sentenceStructure.join(', ') || 'none recorded'}; rhythm: ${metrics.rhythm}.`,
+        `- Paragraph length: ${metrics.paragraphLength}; lexical density: ${metrics.lexicalDensity}; point of view: ${metrics.pointOfView}; punctuation: ${Object.entries(metrics.punctuation).map(([mark, count]) => `${mark} ${count}`).join(', ')}; case style: ${metrics.caseStyle}; question rate: ${metrics.questionRate}.`,
+        `- Openings: ${metrics.openingMoves.join(', ') || 'none recorded'}.`,
+        `- Vocabulary: ${metrics.vocabulary.join(', ') || 'none recorded'}.`,
+        `- Transitions: ${metrics.transitions.join(', ') || 'none recorded'}.`,
+        '',
+        '# Tier 3 — AI Editor improvements',
+        ...(yellowFindings.length ? formatFindings(yellowFindings) : ['- None.']),
+        '',
+        '# Tier 4 — output contract',
+        'Return only replacement sentences keyed by sentence number. Do not rewrite clean sentences. The candidate will be checked again by both engines.',
+        '',
+        '# Draft',
+        draft,
+    ].join('\n');
+}
+function preservationScore(original, candidate) {
+    const baseline = new Set(words(original.toLowerCase()).filter((word) => word.length > 4));
+    const rewritten = new Set(words(candidate.toLowerCase()));
+    return baseline.size ? Math.round([...baseline].filter((word) => rewritten.has(word)).length / baseline.size * 100) : 100;
+}
+export function verify(original, candidate, profile) {
+    const baseline = analyze(original, profile);
+    const checked = analyze(candidate, profile);
+    const known = new Set([...baseline.voiceDna.findings, ...baseline.aiEditor.findings].map((finding) => `${finding.engine}:${finding.id}:${finding.sentence}`));
+    const regressions = [...checked.voiceDna.findings, ...checked.aiEditor.findings].filter((finding) => !known.has(`${finding.engine}:${finding.id}:${finding.sentence}`));
+    const preservation = preservationScore(original, candidate);
+    return {
+        version: '2',
+        original: baseline,
+        candidate: checked,
+        preservationScore: preservation,
+        regressions,
+        passed: checked.passed && !regressions.some((finding) => finding.severity === 'red') && preservation >= 70,
+    };
+}

package/dist/pipeline.test.js

@@ -0,0 +1,36 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { analyze, rewritePrompt, verify } from './pipeline.js';
+import { buildProfile } from './voice-dna.js';
+const profile = buildProfile([
+    'I ship clear ideas. The details stay concrete. I explain the mechanism without fuss.',
+    'I write short sentences. Then I explain the mechanism. My work stays plain and specific.',
+], ['leverage']);
+test('keeps the two engine scores independent', () => {
+    const result = analyze('Firstly, we leverage a holistic strategy.', profile);
+    assert.equal(result.aiEditor.passed, false);
+    assert.equal(typeof result.voiceDna.score, 'number');
+});
+test('builds all thirteen VoiceDNA measurements', () => {
+    assert.deepEqual(Object.keys(profile.metrics), ['sentenceLength', 'sentenceVariation', 'sentenceStructure', 'rhythm', 'paragraphLength', 'openingMoves', 'vocabulary', 'lexicalDensity', 'pointOfView', 'punctuation', 'caseStyle', 'questionRate', 'transitions']);
+});
+test('orders rewrite instructions by importance tier', () => {
+    const prompt = rewritePrompt('Firstly, we leverage a holistic strategy.', profile);
+    assert.ok(prompt.indexOf('# Tier 0') < prompt.indexOf('# Tier 1'));
+    assert.ok(prompt.indexOf('# Tier 1') < prompt.indexOf('# Tier 2'));
+    assert.ok(prompt.indexOf('# Tier 2') < prompt.indexOf('# Tier 3'));
+    assert.ok(prompt.indexOf('# Tier 3') < prompt.indexOf('# Tier 4'));
+});
+test('post gate reports a new AI regression', () => {
+    const result = verify('I ship clear ideas.', 'I ship clear ideas — a game-changer.', profile);
+    assert.equal(result.passed, false);
+    assert.ok(result.regressions.length > 0);
+    assert.equal(result.original.aiEditor.passed, true);
+    assert.equal(result.candidate.aiEditor.passed, false);
+});
+test('puts all thirteen VoiceDNA elements in the rewrite brief', () => {
+    const prompt = rewritePrompt('I ship clear ideas.', profile);
+    for (const element of ['Sentence length', 'sentence variation', 'sentence structure', 'rhythm', 'Paragraph length', 'lexical density', 'point of view', 'punctuation', 'case style', 'question rate', 'Openings', 'Vocabulary', 'Transitions']) {
+        assert.match(prompt, new RegExp(element));
+    }
+});

package/dist/profile.js

@@ -0,0 +1,31 @@
+function isNumberRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype
+        && Object.values(value).every((item) => typeof item === 'number' && Number.isFinite(item));
+}
+function isPunctuation(value) {
+    const marks = ['!', '?', ';', ':', '—'];
+    return isNumberRecord(value) && Object.values(value).every((item) => item >= 0) && Object.keys(value).length === marks.length && marks.every((mark) => mark in value);
+}
+function isMetrics(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const metrics = value;
+    const numbers = [metrics.sentenceLength, metrics.sentenceVariation, metrics.rhythm, metrics.paragraphLength, metrics.lexicalDensity, metrics.questionRate];
+    const stringArrays = [metrics.sentenceStructure, metrics.openingMoves, metrics.vocabulary, metrics.transitions];
+    return numbers.every((item) => typeof item === 'number' && Number.isFinite(item) && item >= 0)
+        && typeof metrics.lexicalDensity === 'number' && metrics.lexicalDensity <= 1
+        && typeof metrics.questionRate === 'number' && metrics.questionRate <= 1
+        && ['first_person', 'second_person', 'third_person', 'mixed'].includes(metrics.pointOfView ?? '')
+        && ['lowercase', 'standard', 'mixed'].includes(metrics.caseStyle ?? '')
+        && stringArrays.every((items) => Array.isArray(items) && items.every((item) => typeof item === 'string'))
+        && isPunctuation(metrics.punctuation);
+}
+export function parseProfile(value) {
+    if (!value || typeof value !== 'object')
+        throw new Error('Profile must be a JSON object.');
+    const profile = value;
+    if (profile.version !== '2' || typeof profile.sampleCount !== 'number' || !Number.isInteger(profile.sampleCount) || profile.sampleCount < 2 || !isMetrics(profile.metrics) || !Array.isArray(profile.avoid) || !profile.avoid.every((item) => typeof item === 'string' && item.trim().length > 0)) {
+        throw new Error('Profile is not a valid Hold Your Voice version 2 profile. Rebuild it with the profile command.');
+    }
+    return profile;
+}

package/dist/release-audit.test.js

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { execFileSync, spawnSync } from 'node:child_process';
+import test from 'node:test';
+const audit = new URL('../scripts/release-audit.mjs', import.meta.url).pathname;
+function fixture(files) {
+    const directory = mkdtempSync(join(tmpdir(), 'holdyourvoice-audit-'));
+    execFileSync('git', ['init', '--quiet'], { cwd: directory });
+    const defaults = {
+        'package.json': JSON.stringify({ license: 'MIT', files: ['LICENSE'] }),
+        LICENSE: [
+            'Permission is hereby granted, free of charge, to any person obtaining a copy',
+            'The above copyright notice and this permission notice shall be included in all',
+            'THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND',
+        ].join('\n'),
+    };
+    for (const [file, text] of Object.entries({ ...defaults, ...files })) {
+        const path = join(directory, file);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, text);
+    }
+    execFileSync('git', ['add', 'README.md'], { cwd: directory });
+    return directory;
+}
+test('rejects unquoted credentials in an untracked source file', () => {
+    const directory = fixture({ 'README.md': '# public', 'src/unsafe.ts': ['const ', 'API_KEY', '=topsecret;'].join('') });
+    try {
+        const result = spawnSync(process.execPath, [audit], { cwd: directory, encoding: 'utf8' });
+        assert.notEqual(result.status, 0);
+        assert.match(result.stderr, /credential marker: src\/unsafe\.ts/);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+});

package/dist/text.js

@@ -0,0 +1,42 @@
+export const words = (text) => text.match(/\p{L}[\p{L}\p{M}'’-]*/gu) ?? [];
+export const mean = (values) => values.length ? values.reduce((total, value) => total + value, 0) / values.length : 0;
+export const deviation = (values, average = mean(values)) => values.length ? Math.sqrt(mean(values.map((value) => (value - average) ** 2))) : 0;
+export function sentences(text) {
+    const output = [];
+    const abbreviations = new Set(['dr', 'mr', 'mrs', 'ms', 'prof', 'sr', 'jr', 'vs', 'etc', 'fig', 'no', 'inc', 'ltd', 'co', 'jan', 'feb', 'mar', 'apr', 'jun', 'jul', 'aug', 'sep', 'sept', 'oct', 'nov', 'dec']);
+    let start = 0;
+    const add = (end) => {
+        const raw = text.slice(start, end);
+        const value = raw.trim();
+        if (!words(value).length)
+            return;
+        const offset = start + raw.indexOf(value);
+        output.push({ index: output.length + 1, start: offset, end: offset + value.length, text: value });
+    };
+    for (let index = 0; index < text.length; index += 1) {
+        const character = text[index];
+        if (character === '\n') {
+            add(index);
+            start = index + 1;
+            continue;
+        }
+        if (!'.!?'.includes(character))
+            continue;
+        if (character === '.') {
+            const previous = text[index - 1] ?? '';
+            const next = text[index + 1] ?? '';
+            const previousWord = text.slice(start, index).match(/(\p{L}+)$/u)?.[1]?.toLowerCase();
+            if ((/\d/.test(previous) && /\d/.test(next)) || /\p{L}/u.test(next) || (previousWord && abbreviations.has(previousWord)))
+                continue;
+        }
+        let end = index + 1;
+        while (end < text.length && '.!?'.includes(text[end]))
+            end += 1;
+        add(end);
+        start = end;
+        index = end - 1;
+    }
+    add(text.length);
+    return output;
+}
+export const paragraphs = (text) => text.split(/\n\s*\n/).map((part) => part.trim()).filter(Boolean);

package/dist/text.test.js

@@ -0,0 +1,16 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { sentences, words } from './text.js';
+test('keeps decimals and common abbreviations inside a sentence', () => {
+    assert.deepEqual(sentences('Dr. Shah raised $3.5m. It funded the work.').map((sentence) => sentence.text), ['Dr. Shah raised $3.5m.', 'It funded the work.']);
+});
+test('records exact sentence offsets across newlines', () => {
+    const text = 'First line\nSecond line.';
+    assert.deepEqual(sentences(text), [
+        { index: 1, start: 0, end: 10, text: 'First line' },
+        { index: 2, start: 11, end: 23, text: 'Second line.' },
+    ]);
+});
+test('counts Unicode writing as words', () => {
+    assert.deepEqual(words('café नमस्ते दुनिया'), ['café', 'नमस्ते', 'दुनिया']);
+});

package/dist/voice-dna.js

@@ -0,0 +1,77 @@
+import { deviation, mean, paragraphs, sentences, words } from './text.js';
+const STOP_WORDS = new Set(['the', 'and', 'that', 'with', 'this', 'from', 'your', 'have', 'were', 'they', 'will', 'into', 'about', 'what', 'when', 'where']);
+const TRANSITIONS = ['but', 'because', 'instead', 'then', 'still', 'so', 'yet', 'therefore'];
+function top(items, limit) {
+    const counts = new Map();
+    for (const item of items.filter(Boolean))
+        counts.set(item, (counts.get(item) ?? 0) + 1);
+    return [...counts].sort((left, right) => right[1] - left[1]).slice(0, limit).map(([item]) => item);
+}
+function profileMetrics(text) {
+    const draftSentences = sentences(text);
+    const draftWords = words(text);
+    const lengths = draftSentences.map((sentence) => words(sentence.text).length);
+    const starters = draftSentences.map((sentence) => words(sentence.text)[0]?.toLowerCase() ?? '');
+    const structures = draftSentences.map((sentence) => words(sentence.text).slice(0, 3).map((word) => word.toLowerCase()).join(' '));
+    const lowerWords = draftWords.map((word) => word.toLowerCase());
+    const nonStop = lowerWords.filter((word) => word.length > 3 && !STOP_WORDS.has(word));
+    const first = lowerWords.filter((word) => ['i', 'we', 'my', 'our', 'us'].includes(word)).length;
+    const second = lowerWords.filter((word) => ['you', 'your', 'yours'].includes(word)).length;
+    const third = lowerWords.filter((word) => ['he', 'she', 'they', 'their', 'them'].includes(word)).length;
+    const pov = first > second && first > third ? 'first_person' : second > first && second > third ? 'second_person' : third > first && third > second ? 'third_person' : 'mixed';
+    const paragraphSizes = paragraphs(text).map((paragraph) => sentences(paragraph).length);
+    const punctuation = Object.fromEntries(['!', '?', ';', ':', '—'].map((mark) => [mark, (text.match(new RegExp(mark.replace(/[?*+^$.[\]\\(){}|-]/g, '\\$&'), 'g')) ?? []).length]));
+    const sentenceLength = mean(lengths);
+    const sentenceVariation = deviation(lengths, sentenceLength);
+    const rhythm = lengths.length > 1 ? mean(lengths.slice(1).map((length, index) => Math.abs(length - lengths[index]))) : 0;
+    const uppercaseStarts = draftSentences.filter((sentence) => /^\p{Lu}/u.test(sentence.text)).length;
+    const caseStyle = uppercaseStarts / Math.max(1, draftSentences.length) > 0.8 ? 'standard' : uppercaseStarts === 0 ? 'lowercase' : 'mixed';
+    return {
+        sentenceLength: Number(sentenceLength.toFixed(2)),
+        sentenceVariation: Number(sentenceVariation.toFixed(2)),
+        sentenceStructure: top(structures, 8),
+        rhythm: Number(rhythm.toFixed(2)),
+        paragraphLength: Number(mean(paragraphSizes).toFixed(2)),
+        openingMoves: top(starters, 8),
+        vocabulary: top(nonStop, 20),
+        lexicalDensity: Number((nonStop.length / Math.max(1, lowerWords.length)).toFixed(3)),
+        pointOfView: pov,
+        punctuation,
+        caseStyle,
+        questionRate: Number((draftSentences.filter((sentence) => sentence.text.endsWith('?')).length / Math.max(1, draftSentences.length)).toFixed(3)),
+        transitions: top(lowerWords.filter((word) => TRANSITIONS.includes(word)), 8),
+    };
+}
+export function buildProfile(samples, avoid = []) {
+    if (samples.length < 2)
+        throw new Error('Provide at least two local writing samples.');
+    if (samples.some((sample) => !words(sample).length))
+        throw new Error('Every local writing sample must contain writing.');
+    return { version: '2', sampleCount: samples.length, metrics: profileMetrics(samples.join('\n\n')), avoid };
+}
+function finding(id, severity, sentence, excerpt, reason, suggestion) {
+    return { engine: 'voice_dna', id, severity, sentence, excerpt, reason, suggestion };
+}
+export function analyzeVoiceDna(text, profile) {
+    const metrics = profileMetrics(text);
+    const findings = [];
+    const tolerance = Math.max(8, profile.metrics.sentenceVariation * 2.2);
+    for (const sentence of sentences(text)) {
+        const count = words(sentence.text).length;
+        if (Math.abs(count - profile.metrics.sentenceLength) > tolerance)
+            findings.push(finding('dna.sentence-length', 'yellow', sentence.index, sentence.text, `Sentence length (${count}) is outside the profile band around ${profile.metrics.sentenceLength}.`, 'Restore the writer’s usual sentence length where it improves clarity.'));
+        for (const banned of profile.avoid)
+            if (sentence.text.toLowerCase().includes(banned.toLowerCase()))
+                findings.push(finding('dna.avoid-list', 'red', sentence.index, sentence.text, `Uses profile avoid-list phrase: ${banned}.`, 'Replace it with the writer’s natural language.'));
+    }
+    if (Math.abs(metrics.questionRate - profile.metrics.questionRate) > 0.25)
+        findings.push(finding('dna.question-rate', 'yellow', 1, text.slice(0, 160), 'Question frequency differs materially from the profile.', 'Match the writer’s usual use of questions.'));
+    if (metrics.caseStyle !== profile.metrics.caseStyle)
+        findings.push(finding('dna.case-style', 'yellow', 1, text.slice(0, 160), `Draft uses ${metrics.caseStyle} casing; profile uses ${profile.metrics.caseStyle}.`, 'Use the profile’s normal casing.'));
+    if (metrics.pointOfView !== profile.metrics.pointOfView && profile.metrics.pointOfView !== 'mixed')
+        findings.push(finding('dna.point-of-view', 'yellow', 1, text.slice(0, 160), `Draft point of view is ${metrics.pointOfView}; profile is ${profile.metrics.pointOfView}.`, 'Restore the writer’s normal narrative distance.'));
+    const red = findings.filter((item) => item.severity === 'red').length;
+    const yellow = findings.length - red;
+    const score = Math.max(0, 100 - red * 25 - yellow * 7);
+    return { engine: 'voice_dna', version: '2', score, passed: red === 0, findings };
+}

package/dist/voice-dna.test.js

@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { analyzeVoiceDna, buildProfile } from './voice-dna.js';
+test('requires two local samples before creating a profile', () => {
+    assert.throws(() => buildProfile(['One sample is not enough.']), /at least two local writing samples/);
+});
+test('requires every local sample to contain writing', () => {
+    assert.throws(() => buildProfile(['', '   ']), /must contain writing/);
+});
+test('reports local avoid-list matches as red sentence findings', () => {
+    const profile = buildProfile(['i write plainly. i name the work.', 'i keep the mechanism clear. i avoid filler.'], ['unlock']);
+    const report = analyzeVoiceDna('i unlock the answer. i name the work.', profile);
+    assert.deepEqual(report.findings.filter((finding) => finding.id === 'dna.avoid-list').map((finding) => [finding.severity, finding.sentence]), [['red', 1]]);
+    assert.equal(report.passed, false);
+});
+test('keeps a case-style mismatch as a yellow review cue', () => {
+    const profile = buildProfile(['i write plainly. i name the work.', 'i keep the mechanism clear. i avoid filler.']);
+    const report = analyzeVoiceDna('This sentence starts in standard case.', profile);
+    assert.ok(report.findings.some((finding) => finding.id === 'dna.case-style' && finding.severity === 'yellow'));
+    assert.equal(report.passed, true);
+});
+test('keeps the documented VoiceDNA review checks as yellow findings', () => {
+    const profile = buildProfile([
+        'i write short sentences. i ask no questions. i name the mechanism.',
+        'i keep the language plain. i explain the work. i use first person.',
+    ]);
+    const report = analyzeVoiceDna('You explain a much longer sentence with several extra words so the reader can follow the full mechanism in detail. Do you agree?', profile);
+    for (const id of ['dna.sentence-length', 'dna.question-rate', 'dna.point-of-view']) {
+        assert.ok(report.findings.some((finding) => finding.id === id && finding.severity === 'yellow'), id);
+    }
+    assert.equal(report.passed, true);
+});

package/package.json

@@ -1,77 +1,18 @@
 {
   "name": "@holdyourvoice/hyv",
-  "version": "2.9.28",
-  "description": "Free local AI writing scan for cursor & claude. MCP server, 220+ pattern detection, voice profiles. npx @holdyourvoice/hyv welcome",
-  "main": "dist/index.js",
-  "bin": {
-    "hyv": "dist/index.js",
-    "hyvoice": "dist/index.js"
-  },
-  "scripts": {
-    "build": "esbuild src/index.ts --bundle --platform=node --target=node18 --outfile=dist/index.js --format=cjs --external:canvas --banner:js='#!/usr/bin/env node'",
-    "build:debug": "esbuild src/index.ts --bundle --platform=node --target=node18 --outfile=dist/index.js --format=cjs --sourcemap --banner:js='#!/usr/bin/env node'",
-    "dev": "npm run build && node dist/index.js",
-    "validate:publish": "npm run build && node scripts/validate-publish.js",
-    "prepublishOnly": "npm run validate:publish",
-    "postinstall": "node scripts/postinstall.js",
-    "prepare": "npm run build",
-    "test": "npm run build && vitest run",
-    "test:smoke": "npm run build && bash scripts/smoke-test.sh",
-    "test:watch": "vitest",
-    "release:patch": "npm version patch && npm publish --access public",
-    "release:minor": "npm version minor && npm publish --access public",
-    "release:major": "npm version major && npm publish --access public"
-  },
-  "keywords": [
-    "voice",
-    "writing",
-    "ai",
-    "cli",
-    "brand-voice",
-    "content-gate",
-    "hyv",
-    "cursor",
-    "claude",
-    "mcp",
-    "ai-agent",
-    "ai-writing",
-    "voice-profile"
-  ],
-  "author": "Hold Your Voice",
-  "license": "UNLICENSED",
-  "private": false,
-  "dependencies": {
-    "canvas": "^3.2.3",
-    "chalk": "^4.1.2",
-    "commander": "^12.1.0",
-    "glob": "^13.0.6",
-    "open": "^8.4.2"
-  },
-  "devDependencies": {
-    "@types/node": "^20.19.42",
-    "esbuild": "^0.20.0",
-    "typescript": "^5.3.3",
-    "vitest": "^2.0.0"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "files": [
-    "dist/",
-    "scripts/postinstall.js",
-    "scripts/postinstall-lib.js",
-    "scripts/install.sh",
-    "scripts/install.ps1",
-    "scripts/check-no-duplicates.js",
-    "assets/",
-    "skills/",
-    "agents/",
-    "README.md",
-    "CHANGELOG.md",
-    "LICENSE"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/shashank-sn/hold-your-voice-app.git"
-  }
+  "version": "3.0.1",
+  "description": "A local-first dual-engine writing gate that protects voice and catches generic AI patterns.",
+  "type": "module",
+  "bin": { "hyv": "dist/cli.js" },
+  "files": ["dist", "Readme.md", "LICENSE"],
+  "scripts": { "build": "tsc -p tsconfig.json", "bundle:claude": "esbuild src/mcp.ts --bundle --platform=node --format=esm --target=node20 --outfile=mcpb/server/index.js", "build:claude": "npm run build && npm run bundle:claude", "pack:claude": "npm run build:claude && node scripts/pack-claude.mjs", "test": "npm run build && node --test dist/**/*.test.js", "check:release": "node scripts/release-audit.mjs", "prepack": "npm run check:release && npm test" },
+  "engines": { "node": ">=20" },
+  "license": "MIT",
+  "keywords": ["ai-writing", "cli", "editing", "voice", "writing"],
+  "repository": { "type": "git", "url": "git+https://github.com/shashank-sn/holdyourvoice.git" },
+  "bugs": { "url": "https://github.com/shashank-sn/holdyourvoice/issues" },
+  "homepage": "https://github.com/shashank-sn/holdyourvoice#readme",
+  "publishConfig": { "access": "public" },
+  "devDependencies": { "@types/node": "^22.0.0", "@types/yazl": "^3.3.1", "esbuild": "^0.28.1", "typescript": "^5.7.0", "yazl": "^3.3.1" },
+  "dependencies": { "@modelcontextprotocol/sdk": "^1.30.0", "zod": "^4.4.3" }
 }