Strategy
diff --git a/tests/test_lexeme_analysis.js b/tests/test_lexeme_analysis.js
new file mode 100644
index 0000000..1c739d3
--- /dev/null
+++ b/tests/test_lexeme_analysis.js
@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+const assert = require('assert');
+const path = require('path');
+
+const lexemeAnalysis = require(path.join(__dirname, '..', 'js', 'core', 'lexemeAnalysis.js'));
+
+const empty = lexemeAnalysis.analyze('');
+assert.strictEqual(empty.totalFindings, 0, 'Empty input should yield no findings');
+
+const nounCase = lexemeAnalysis.analyze('Need benign pesticide framing.');
+assert.strictEqual(nounCase.totalFindings, 1, 'Known -cide noun should be detected');
+assert.strictEqual(nounCase.findings[0].family, 'destructive_suffix');
+assert.strictEqual(nounCase.findings[0].semanticDomain, 'pest');
+assert.strictEqual(nounCase.findings[0].primaryRewrite, 'pest management');
+
+const adjectiveCase = lexemeAnalysis.analyze('Looking for non-cidal wording in this prompt.');
+assert.strictEqual(adjectiveCase.totalFindings, 1, 'Standalone -cidal wording should be detected');
+assert.strictEqual(adjectiveCase.findings[0].partOfSpeech, 'adjective');
+assert.ok(
+ adjectiveCase.findings[0].primaryRewrite.includes('mitigation'),
+ 'Standalone adjectival form should fall back to mitigation-oriented rewrite'
+);
+
+const aliasCase = lexemeAnalysis.analyze('A bactericidal workflow should sound less destructive.');
+assert.strictEqual(aliasCase.totalFindings, 1, 'Alias-root adjectival case should be detected');
+assert.strictEqual(aliasCase.findings[0].semanticDomain, 'bacterial');
+assert.ok(
+ aliasCase.findings[0].rewrites.some((rewrite) => rewrite.includes('bacterial management')),
+ 'Alias roots should resolve into domain-specific rewrites'
+);
+
+const neutralized = lexemeAnalysis.neutralizeText(
+ 'Pesticide and bactericidal wording should be softened.',
+ lexemeAnalysis.analyze('Pesticide and bactericidal wording should be softened.')
+);
+assert.ok(neutralized.includes('Pest Management'), 'Neutralization should preserve leading capitalization');
+assert.ok(neutralized.includes('bacterial management'), 'Neutralization should replace adjectival form');
+
+console.log('Lexeme analysis tests passed');
diff --git a/tests/test_lexeme_ui_surface.js b/tests/test_lexeme_ui_surface.js
new file mode 100644
index 0000000..cf3e2a8
--- /dev/null
+++ b/tests/test_lexeme_ui_surface.js
@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+const projectRoot = path.join(__dirname, '..');
+const promptcraftTemplate = fs.readFileSync(path.join(projectRoot, 'templates', 'promptcraft.html'), 'utf8');
+const anticlassifierTemplate = fs.readFileSync(path.join(projectRoot, 'templates', 'anticlassifier.html'), 'utf8');
+const promptcraftTool = fs.readFileSync(path.join(projectRoot, 'js', 'tools', 'PromptCraftTool.js'), 'utf8');
+const anticlassifierTool = fs.readFileSync(path.join(projectRoot, 'js', 'tools', 'AntiClassifierTool.js'), 'utf8');
+const indexTemplate = fs.readFileSync(path.join(projectRoot, 'index.template.html'), 'utf8');
+
+assert.ok(promptcraftTemplate.includes('Latin-Root Analysis'), 'PromptCraft should expose the analysis card');
+assert.ok(promptcraftTemplate.includes('pcNeutralizeInput'), 'PromptCraft should expose neutralization action');
+assert.ok(anticlassifierTemplate.includes('Latin-Root Analysis'), 'Anti-Classifier should expose the analysis card');
+assert.ok(anticlassifierTemplate.includes('acNeutralizeInput'), 'Anti-Classifier should expose neutralization action');
+assert.ok(promptcraftTool.includes('pcGetLexemeAnalysis'), 'PromptCraft tool should bind shared analysis');
+assert.ok(anticlassifierTool.includes('acGetLexemeAnalysis'), 'Anti-Classifier tool should bind shared analysis');
+assert.ok(indexTemplate.includes('js/data/latinAffixPolicies.js'), 'Index template should load affix policy data');
+assert.ok(indexTemplate.includes('js/core/lexemeAnalysis.js'), 'Index template should load shared lexeme analysis engine');
+
+console.log('Lexeme UI surface tests passed');
From 789b28b5ca318fff8e31a3cb54e4a3bbf394527b Mon Sep 17 00:00:00 2001
From: GangGreenTemperTatum
<104169244+GangGreenTemperTatum@users.noreply.github.com>
Date: Sun, 5 Apr 2026 15:33:42 -0400
Subject: [PATCH 2/2] Expand Latin-root analysis across prompt inputs
---
js/data/latinAffixPolicies.js | 65 +++++++++++++++++++++++++++++++++
js/tools/BijectionTool.js | 41 +++++++++++++++++++++
js/tools/MutationTool.js | 42 ++++++++++++++++++++-
js/tools/TransformTool.js | 35 +++++++++++++++++-
templates/bijection.html | 35 ++++++++++++++++++
templates/fuzzer.html | 36 +++++++++++++++++-
templates/transforms.html | 37 ++++++++++++++++++-
tests/test_lexeme_analysis.js | 30 +++++++++++++++
tests/test_lexeme_ui_surface.js | 15 ++++++++
9 files changed, 332 insertions(+), 4 deletions(-)
diff --git a/js/data/latinAffixPolicies.js b/js/data/latinAffixPolicies.js
index fed4f51..7e2a955 100644
--- a/js/data/latinAffixPolicies.js
+++ b/js/data/latinAffixPolicies.js
@@ -70,6 +70,71 @@
'framed around management',
'operationally neutral'
]
+ },
+ {
+ id: 'latin-eradication-verbs',
+ family: 'eradication_language',
+ kind: 'surface_pattern',
+ partOfSpeech: 'verb',
+ affixes: ['eradicate', 'exterminate', 'annihilate', 'obliterate'],
+ patterns: [
+ /\b(?:eradicate|eradicates|eradicated|eradicating|eradication)\b/gi,
+ /\b(?:exterminate|exterminates|exterminated|exterminating|extermination)\b/gi,
+ /\b(?:annihilate|annihilates|annihilated|annihilating|annihilation)\b/gi,
+ /\b(?:obliterate|obliterates|obliterated|obliterating|obliteration)\b/gi
+ ],
+ severity: 'high',
+ confidence: 0.88,
+ semanticShift: 'total_removal',
+ explanation: 'Eradication language implies total destruction rather than bounded handling.',
+ fallbackTemplates: [
+ 'reduce',
+ 'manage',
+ 'contain',
+ 'address'
+ ]
+ },
+ {
+ id: 'latin-suppression-language',
+ family: 'suppression_language',
+ kind: 'surface_pattern',
+ partOfSpeech: 'verb',
+ affixes: ['neutralize', 'incapacitate', 'suppress'],
+ patterns: [
+ /\b(?:neutralize|neutralizes|neutralized|neutralizing|neutralization)\b/gi,
+ /\b(?:incapacitate|incapacitates|incapacitated|incapacitating|incapacitation)\b/gi,
+ /\b(?:suppress|suppresses|suppressed|suppressing|suppression)\b/gi
+ ],
+ severity: 'medium',
+ confidence: 0.82,
+ semanticShift: 'forceful_control',
+ explanation: 'Suppression language can read as coercive or force-centric rather than operationally neutral.',
+ fallbackTemplates: [
+ 'limit',
+ 'reduce',
+ 'constrain',
+ 'manage'
+ ]
+ },
+ {
+ id: 'latin-terminality-language',
+ family: 'terminality_language',
+ kind: 'surface_pattern',
+ partOfSpeech: 'adjective',
+ affixes: ['lethal', 'fatal', 'terminal', 'mortal'],
+ patterns: [
+ /\b(?:lethal|fatal|terminal|mortal)\b/gi
+ ],
+ severity: 'medium',
+ confidence: 0.8,
+ semanticShift: 'fatal_outcome_framing',
+ explanation: 'Terminality language frames outcomes as fatal or irreversible even when a softer operational phrasing would do.',
+ fallbackTemplates: [
+ 'high-risk',
+ 'severe',
+ 'critical',
+ 'unsafe'
+ ]
}
];
diff --git a/js/tools/BijectionTool.js b/js/tools/BijectionTool.js
index 8bf9f30..bc1606c 100644
--- a/js/tools/BijectionTool.js
+++ b/js/tools/BijectionTool.js
@@ -20,6 +20,7 @@ class BijectionTool extends Tool {
bijectionIncludeExamples: true,
bijectionAutoCopy: false,
bijectionInput: '',
+ bijectionLexemeAnalysis: { totalFindings: 0, findings: [], summary: 'No Latin-root wording findings.' },
bijectionMapping: {},
bijectionOutputs: []
};
@@ -27,6 +28,36 @@ class BijectionTool extends Tool {
getVueMethods() {
return {
+ bijectionRefreshLexemeAnalysis() {
+ if (typeof window === 'undefined' || !window.LexemeAnalysis || typeof window.LexemeAnalysis.analyze !== 'function') {
+ this.bijectionLexemeAnalysis = { totalFindings: 0, findings: [], summary: 'Lexeme analysis unavailable.' };
+ return;
+ }
+ this.bijectionLexemeAnalysis = window.LexemeAnalysis.analyze(this.bijectionInput);
+ },
+ bijectionGetLexemeAnalysis() {
+ return this.bijectionLexemeAnalysis || { totalFindings: 0, findings: [], summary: 'No Latin-root wording findings.' };
+ },
+ bijectionNeutralizeInput() {
+ const analysis = this.bijectionGetLexemeAnalysis();
+ if (!analysis.totalFindings || !window.LexemeAnalysis || typeof window.LexemeAnalysis.neutralizeText !== 'function') {
+ return;
+ }
+ this.bijectionInput = window.LexemeAnalysis.neutralizeText(this.bijectionInput, analysis);
+ if (typeof this.showNotification === 'function') {
+ this.showNotification('Applied neutral Latin-root rewrites', 'success', 'fas fa-seedling');
+ }
+ },
+ bijectionApplyLexemeRewrite(term, rewrite) {
+ if (!term || !rewrite) {
+ return;
+ }
+ const escapedTerm = String(term).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+ this.bijectionInput = this.bijectionInput.replace(new RegExp('\\b' + escapedTerm + '\\b', 'i'), rewrite);
+ if (typeof this.showNotification === 'function') {
+ this.showNotification('Applied rewrite for ' + term, 'success', 'fas fa-pen');
+ }
+ },
generateBijectionMapping() {
const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,!?';
const mapping = {};
@@ -229,6 +260,16 @@ Now, please translate and respond to this message in alphapr: ${encoded}`;
}
};
}
+
+ getVueWatchers() {
+ return {
+ bijectionInput: function() {
+ if (typeof this.bijectionRefreshLexemeAnalysis === 'function') {
+ this.bijectionRefreshLexemeAnalysis();
+ }
+ }
+ };
+ }
}
if (typeof module !== 'undefined' && module.exports) {
diff --git a/js/tools/MutationTool.js b/js/tools/MutationTool.js
index 85a30b0..aac960d 100644
--- a/js/tools/MutationTool.js
+++ b/js/tools/MutationTool.js
@@ -15,6 +15,7 @@ class MutationTool extends Tool {
getVueData() {
return {
fuzzerInput: '',
+ fuzzerLexemeAnalysis: { totalFindings: 0, findings: [], summary: 'No Latin-root wording findings.' },
fuzzerCount: 20,
fuzzerSeed: '',
fuzzUseRandomMix: true,
@@ -30,6 +31,36 @@ class MutationTool extends Tool {
getVueMethods() {
return {
+ fuzzerRefreshLexemeAnalysis: function() {
+ if (typeof window === 'undefined' || !window.LexemeAnalysis || typeof window.LexemeAnalysis.analyze !== 'function') {
+ this.fuzzerLexemeAnalysis = { totalFindings: 0, findings: [], summary: 'Lexeme analysis unavailable.' };
+ return;
+ }
+ this.fuzzerLexemeAnalysis = window.LexemeAnalysis.analyze(this.fuzzerInput);
+ },
+ fuzzerGetLexemeAnalysis: function() {
+ return this.fuzzerLexemeAnalysis || { totalFindings: 0, findings: [], summary: 'No Latin-root wording findings.' };
+ },
+ fuzzerNeutralizeInput: function() {
+ const analysis = this.fuzzerGetLexemeAnalysis();
+ if (!analysis.totalFindings || !window.LexemeAnalysis || typeof window.LexemeAnalysis.neutralizeText !== 'function') {
+ return;
+ }
+ this.fuzzerInput = window.LexemeAnalysis.neutralizeText(this.fuzzerInput, analysis);
+ if (typeof this.showNotification === 'function') {
+ this.showNotification('Applied neutral Latin-root rewrites', 'success', 'fas fa-seedling');
+ }
+ },
+ fuzzerApplyLexemeRewrite: function(term, rewrite) {
+ if (!term || !rewrite) {
+ return;
+ }
+ const escapedTerm = String(term).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+ this.fuzzerInput = this.fuzzerInput.replace(new RegExp('\\b' + escapedTerm + '\\b', 'i'), rewrite);
+ if (typeof this.showNotification === 'function') {
+ this.showNotification('Applied rewrite for ' + term, 'success', 'fas fa-pen');
+ }
+ },
seededRandomFactory: function(seedStr) {
if (!seedStr) return Math.random;
let h = 1779033703 ^ seedStr.length;
@@ -106,6 +137,16 @@ class MutationTool extends Tool {
}
};
}
+
+ getVueWatchers() {
+ return {
+ fuzzerInput: function() {
+ if (typeof this.fuzzerRefreshLexemeAnalysis === 'function') {
+ this.fuzzerRefreshLexemeAnalysis();
+ }
+ }
+ };
+ }
}
// Export
@@ -116,4 +157,3 @@ if (typeof module !== 'undefined' && module.exports) {
}
-
diff --git a/js/tools/TransformTool.js b/js/tools/TransformTool.js
index 39b2b89..990ff1f 100644
--- a/js/tools/TransformTool.js
+++ b/js/tools/TransformTool.js
@@ -61,6 +61,7 @@ class TransformTool extends Tool {
return {
transformInput: 'Hello World',
+ transformLexemeAnalysis: { totalFindings: 0, findings: [], summary: 'No Latin-root wording findings.' },
transformOutput: '',
activeTransform: null,
transforms: transforms,
@@ -250,6 +251,36 @@ class TransformTool extends Tool {
}
return 'text';
},
+ transformRefreshLexemeAnalysis: function() {
+ if (typeof window === 'undefined' || !window.LexemeAnalysis || typeof window.LexemeAnalysis.analyze !== 'function') {
+ this.transformLexemeAnalysis = { totalFindings: 0, findings: [], summary: 'Lexeme analysis unavailable.' };
+ return;
+ }
+ this.transformLexemeAnalysis = window.LexemeAnalysis.analyze(this.transformInput);
+ },
+ transformGetLexemeAnalysis: function() {
+ return this.transformLexemeAnalysis || { totalFindings: 0, findings: [], summary: 'No Latin-root wording findings.' };
+ },
+ transformNeutralizeInput: function() {
+ const analysis = this.transformGetLexemeAnalysis();
+ if (!analysis.totalFindings || !window.LexemeAnalysis || typeof window.LexemeAnalysis.neutralizeText !== 'function') {
+ return;
+ }
+ this.transformInput = window.LexemeAnalysis.neutralizeText(this.transformInput, analysis);
+ if (typeof this.showNotification === 'function') {
+ this.showNotification('Applied neutral Latin-root rewrites', 'success', 'fas fa-seedling');
+ }
+ },
+ transformApplyLexemeRewrite: function(term, rewrite) {
+ if (!term || !rewrite) {
+ return;
+ }
+ const escapedTerm = String(term).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+ this.transformInput = this.transformInput.replace(new RegExp('\\b' + escapedTerm + '\\b', 'i'), rewrite);
+ if (typeof this.showNotification === 'function') {
+ this.showNotification('Applied rewrite for ' + term, 'success', 'fas fa-pen');
+ }
+ },
openTransformOptions: function(transform, event) {
if (event) {
event.preventDefault();
@@ -623,6 +654,9 @@ class TransformTool extends Tool {
getVueWatchers() {
return {
transformInput() {
+ if (typeof this.transformRefreshLexemeAnalysis === 'function') {
+ this.transformRefreshLexemeAnalysis();
+ }
if (this.activeTransform && this.activeTab === 'transforms') {
const opts = this.getMergedOptionsForTransform(this.activeTransform.name);
this.transformOutput = this.activeTransform.func(this.transformInput, opts);
@@ -670,4 +704,3 @@ if (typeof module !== 'undefined' && module.exports) {
}
-
diff --git a/templates/bijection.html b/templates/bijection.html
index d5ba9ef..2336c5c 100644
--- a/templates/bijection.html
+++ b/templates/bijection.html
@@ -16,6 +16,41 @@