calliope-ts 0.0.1

package/dist/tagfix.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Correct a sentence's tags in place-safe fashion (returns a new array).
+ * `tokens` and `tags` are the en-pos outputs, index-aligned.
+ */
+export declare function correctTags(tokens: string[], tags: string[]): string[];
+//# sourceMappingURL=tagfix.d.ts.map

package/dist/tagfix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tagfix.d.ts","sourceRoot":"","sources":["../src/tagfix.ts"],"names":[],"mappings":"AAwCA;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CA2DtE"}

package/dist/tagfix.js

@@ -0,0 +1,101 @@
+// tagfix.ts — Pre-parse POS-tag correction layer.
+//
+// FinNLP's en-pos tagger is structurally sound but carries a small tail of
+// SYSTEMATIC tag errors that matter enormously for verse analysis, because a
+// wrong tag flips a word's content/function status (→ its stress tier) and
+// derails the en-parse dependency tree built from the tags.  This pass runs
+// BETWEEN en-pos and en-parse (see parseDocument in parser.ts), so corrected
+// tags repair both the tagging AND the resulting dependency structure — a
+// post-hoc fix of the parse could never do that.
+//
+// Every rule below targets an error class actually observed in this repo's
+// trials; rules are deliberately narrow (anti-gaming: each must be justified
+// by the error it fixes, not by benchmark deltas).
+/** Zero-derived irregular past participles that en-pos tags NN/VBP after a
+ *  have-auxiliary ("had quit", "has put", "have read").  Only forms whose
+ *  participle is identical to the base/noun spelling — the -en/-ed forms tag
+ *  fine on their own. */
+const ZERO_PARTICIPLES = new Set([
+    'quit', 'put', 'set', 'cut', 'hit', 'let', 'shut', 'cast', 'cost', 'hurt',
+    'burst', 'split', 'spread', 'bet', 'wed', 'read', 'rid', 'shed', 'thrust',
+    'slit', 'bid', 'broadcast', 'upset', 'sunburst',
+]);
+const HAVE_FORMS = new Set(['have', 'has', 'had', 'having', "'ve", "'d"]);
+/** Archaic / Early-Modern-English forms en-pos has no lexicon entries for —
+ *  ubiquitous in the verse this toolkit exists to scan. */
+const ARCHAIC_TAGS = {
+    thou: 'PRP', thee: 'PRP', ye: 'PRP',
+    thy: 'PRP$', thine: 'PRP$',
+    art: 'VBP', wert: 'VBD', wast: 'VBD',
+    doth: 'VBZ', hath: 'VBZ', dost: 'VBZ', hast: 'VBZ', saith: 'VBZ',
+    didst: 'VBD', hadst: 'VBD', wouldst: 'MD', couldst: 'MD', shouldst: 'MD',
+    shalt: 'MD', wilt: 'MD', canst: 'MD', mayst: 'MD', 'mightst': 'MD',
+    wherefore: 'WRB', whither: 'WRB', whence: 'WRB',
+    hither: 'RB', thither: 'RB', yon: 'JJ', yonder: 'RB',
+    ere: 'IN', oft: 'RB', anon: 'RB',
+};
+/**
+ * Correct a sentence's tags in place-safe fashion (returns a new array).
+ * `tokens` and `tags` are the en-pos outputs, index-aligned.
+ */
+export function correctTags(tokens, tags) {
+    const out = tags.slice();
+    for (let i = 0; i < tokens.length; i++) {
+        const w = tokens[i].toLowerCase();
+        // 1. The pronoun "I".  en-norm lowercases sentence-initial "I" → "i",
+        //    which en-pos then reads as a foreign word / letter name (FW).
+        if (w === 'i' && out[i] === 'FW')
+            out[i] = 'PRP';
+        // 2. Archaic forms (thou/thy/doth/shalt/wherefore…): en-pos guesses
+        //    NN/JJ/FW for these, wrecking both stress class and the parse.
+        //    Guard "art": only when a pronoun precedes ("thou art"), since the
+        //    noun reading ("the art of…") is the modern default.
+        const archaic = ARCHAIC_TAGS[w];
+        if (archaic && !/^(NNP|NNPS)$/.test(out[i])) {
+            if (w === 'art') {
+                const prev = i > 0 ? tokens[i - 1].toLowerCase() : '';
+                if (prev === 'thou' || prev === 'ye' || prev === 'you')
+                    out[i] = 'VBP';
+            }
+            else {
+                out[i] = archaic;
+            }
+        }
+        // 3. Perfect-tense zero participles: have-form + ("quit"/"put"/"read"…)
+        //    tagged as NN/VBP/VBD → VBN, so en-parse builds the verb chain
+        //    instead of treating the participle as a direct-object noun
+        //    ("I had quit the programming paradigm").  An intervening adverb
+        //    ("had just quit") is allowed.
+        if (ZERO_PARTICIPLES.has(w) && /^(NN|NNS|VBP|VBD|VB)$/.test(out[i])) {
+            const prev1 = i > 0 ? tokens[i - 1].toLowerCase() : '';
+            const prev2 = i > 1 ? tokens[i - 2].toLowerCase() : '';
+            const prev1IsAdv = i > 0 && /^RB/.test(out[i - 1]);
+            if (HAVE_FORMS.has(prev1) || (prev1IsAdv && HAVE_FORMS.has(prev2))) {
+                out[i] = 'VBN';
+            }
+        }
+        // 4. Impossible gerunds: a VBG tag on a token that does not end in
+        //    -ing/-in' cannot be a gerund/present participle — it is an en-pos
+        //    lexicon glitch.  The right tag depends on context: before a noun it
+        //    is a noun modifier ("wisdom"/VBG teeth → NN); after a subject
+        //    pronoun it is a finite verb ("as they bicycle/VBG through" → VBP,
+        //    which keeps "through" a phrasal particle in the parse).  With no
+        //    deciding context, leave the tag alone (en-parse treats VBG
+        //    verb-ishly, the safer default).
+        if (out[i] === 'VBG' && !/in[g'’]?$/.test(w)) {
+            const prevTag = i > 0 ? out[i - 1] : '';
+            const nextTag = i + 1 < tokens.length ? out[i + 1] : '';
+            if (/^NNS?$/.test(nextTag))
+                out[i] = 'NN';
+            else if (prevTag === 'PRP')
+                out[i] = 'VBP';
+        }
+        // 5. Vocative "O" ("O wild West Wind"): en-pos gives NNP/JJ; it is an
+        //    interjection (and must not become a content word with a beat by
+        //    default).  Only the bare capital O — "o'er" etc. are handled by the
+        //    aphaeresis lexicon in stress.ts.
+        if (tokens[i] === 'O' && i + 1 < tokens.length && out[i] !== 'UH')
+            out[i] = 'UH';
+    }
+    return out;
+}

package/dist/types.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Stress levels in McAleese’s relative system, in ascending order
+ * `x < w < n < m < s`.  `x` is the "Zero Provision" tier (Hayes; Lerdahl &
+ * Jackendoff 1983): a level *weaker than a stressless overt syllable*, borne by
+ * maximally-reduced clitics (the/a/of/and…) and unfilled positions.
+ */
+export type StressLevel = 'x' | 'w' | 'n' | 'm' | 's';
+/** A single syllable within a word, with phonetic and stress information */
+export interface Syllable {
+    text: string;
+    phones: string;
+    weight?: 'H' | 'L';
+    stress: number;
+    lexicalStress?: number;
+    relativeStress?: StressLevel;
+    extrametrical?: 'morphological' | 'light_noun' | 'derivational';
+}
+/** Represents a word in the dependency‑parse graph */
+export interface ClsWord {
+    index: number;
+    lexicalClass: string;
+    lexicalDetails: string;
+    lexicalPlural: boolean;
+    position: string;
+    word: string;
+    absoluteIndex: number;
+    isContent: boolean;
+    syllables: Syllable[];
+    morphSuffix?: string;
+    phraseStress: number;
+    dependency?: ClsDependency;
+    node?: ClsNode;
+}
+/** A typed dependency edge between two words (as in Antelope’s XML) */
+export interface ClsDependency {
+    index: number;
+    governorIndex: number;
+    dependentIndex: number;
+    dependentType: string;
+    governorName: string;
+    dependentName: string;
+    governor: ClsWord;
+    dependent: ClsWord;
+}
+/** A constituent node in the parse tree (mirrors Figure 14) */
+export interface ClsNode {
+    index: string;
+    nodeName: string;
+    parent: ClsNode | null;
+    contains: (ClsNode | ClsWord)[];
+}
+/** A single parsed sentence */
+export interface ClsSentence {
+    index: number;
+    nodes: ClsNode | null;
+    dependencies: ClsDependency[];
+    words: ClsWord[];
+    xml: string;
+}
+/** Top‑level document containing parsed sentences */
+export interface ClsDocument {
+    sentences: ClsSentence[];
+    xml: string;
+}
+/** A clitic group: one content word plus its attached function words */
+export interface CliticGroup {
+    tokens: ClsWord[];
+}
+/** A phonological phrase: one or more clitic groups related syntactically */
+export interface PhonologicalPhrase {
+    cliticGroups: CliticGroup[];
+}
+/** An intonational unit: one or more phonological phrases bounded by punctuation/line‑end */
+export interface IntonationalUnit {
+    phonologicalPhrases: PhonologicalPhrase[];
+}
+/** Recognised metre names */
+export type MetreName = 'iambic' | 'trochaic' | 'spondaic' | 'pyrrhic' | 'anapestic' | 'dactylic' | 'amphibrachic' | 'bacchic';
+/** Definition of a metre candidate: its foot shape and syllable count per foot */
+export interface MetreCandidate {
+    name: MetreName;
+    foot: string;
+    syllableCount: number;
+}
+/** A key‑stress pattern extracted from one unit of the phonological hierarchy */
+export interface KeyStress {
+    unitType: 'PW' | 'CP' | 'PP' | 'IU';
+    pattern: string;
+    weight: number;
+    positions: number[];
+}
+/** Result of scansion for a single line */
+export interface ScansionResult {
+    meter: MetreName | 'free verse';
+    scansion: string;
+    certainty: number;
+    weightScore: number;
+    maxPossibleWeight: number;
+    algorithm?: string;
+}
+/** One candidate meter's overall fit score (internal composite, not a probability) */
+export interface MeterScore {
+    meter: MetreName | 'free verse';
+    score: number;
+}
+/** Detailed phonological scansion for a single line */
+export interface PhonologicalScansionDetail {
+    all: string;
+    keyStresses: string;
+    meter: string;
+    meterName: MetreName | 'free verse';
+    footCount: number;
+    summary: string;
+    scansion: string;
+    certainty: number;
+    weightScore: number;
+    maxPossibleWeight: number;
+    ranking?: MeterScore[];
+    consensusMeter?: string;
+    standaloneMeter?: string;
+    rhythmNote?: string;
+    rhyme?: {
+        endWord: string;
+        letter: string;
+        type?: string;
+        matchedLine?: number;
+    };
+    formNote?: string;
+}
+/** Complete per‑line result from the pipeline */
+export interface LineResult {
+    sentence: ClsSentence;
+    phonologicalHierarchy: IntonationalUnit[];
+    keyStresses: KeyStress[];
+    phonologicalScansion: PhonologicalScansionDetail;
+    scandroidCorral?: ScansionResult;
+    scandroidMaximise?: ScansionResult;
+}
+/** Per-syllable information for display rendering */
+export interface SyllableDisplayEntry {
+    wordText: string;
+    sylText: string;
+    sylIndex: number;
+    sylCount: number;
+    relativeStress: StressLevel;
+    globalIndex: number;
+    wordIndex: number;
+}
+/** A single foot in the display, mapping scansion pattern to its syllables */
+export interface FootDisplayEntry {
+    footIndex: number;
+    footPattern: string;
+    syllables: SyllableDisplayEntry[];
+}
+/** All formatted display representations for a single line */
+export interface FormattedDisplay {
+    originalText: string;
+    diacriticText: string;
+    uppercaseText: string;
+    ansiText: string;
+    sylColoredText: string;
+    footAligned: string;
+    syllableBreakdown: string;
+}
+/** Options controlling display formatting */
+export interface DisplayOptions {
+    ansi: boolean;
+    diacritics: boolean;
+    footAligned: boolean;
+    verbose: boolean;
+    phrasal: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,4 @@
+// types.ts — Complete type declarations for Calliope_TS pipeline
+// Reflects McAleese’s class diagrams (Figure 14) and additional phonological /
+// metrical types required by stress, phonological hierarchy, scansion, and Scandroid modules.
+export {};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "calliope-ts",
+  "version": "0.0.1",
+  "description": "A phonological poetry scansion framework in TypeScript, attempting to retrace and extend the works of G. McAleese (Calliope, 2008) and the makers of Scandroid (2005)",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "calliope-ts": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node --esm src/index.ts",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "nlp",
+    "scansion",
+    "meter",
+    "metre",
+    "analysis",
+    "poetics",
+    "verse",
+    "poetic",
+    "literature",
+    "prosody",
+    "prosodic",
+    "scandroid",
+    "typescript",
+    "javascript",
+    "syntax",
+    "morphology",
+    "calliope",
+    "calliope_ts",
+    "poetry",
+    "silveragepoets",
+    "parser",
+    "ud"
+  ],
+  "author": "Aleksey Calvin Tsukanov",
+  "license": "apache-2.0",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "depedits": "^0.0.1",
+    "en-norm": "0.0.2",
+    "en-parse": "^1.1.0",
+    "en-pos": "^1.0.13",
+    "finnlp": "^1.0.0",
+    "lexed": "^1.0.10",
+    "nounsing-pro": "0.0.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.0",
+    "@types/prompts": "^2.4.9",
+    "ts-node": "^10.9.0",
+    "typescript": "~5.8.2",
+    "vitest": "^2.1.0"
+  }
+}

package/src/depfix.ts

@@ -0,0 +1,88 @@
+// depfix.ts — Post-parse dependency repair via DepEdit rules (the `depedits`
+// npm package, the maintainer's TypeScript port of DepEdit).
+//
+// Runs AFTER en-parse, complementing the pre-parse tag corrections in
+// tagfix.ts: tagfix repairs what the tagger got wrong before the tree is
+// built; this pass repairs systematic attachment errors en-parse makes even
+// with correct tags.  Rules are written in DepEdit's declarative format
+// (definitions ⟶ relations ⟶ actions, tab-separated) over en-parse's own
+// label space (DOBJ/NSUBJ/DEP/…), so the round-trip is lossless and every
+// rule is independently testable.
+//
+// The rule set is deliberately small and evidence-based — each rule cites the
+// observed failure it corrects.  `depedits` is ESM-only; it is loaded lazily
+// and failures degrade gracefully (the unrepaired parse is still a parse).
+
+import { createRequire } from 'module';
+
+interface FinDepNode {
+  label: string;      // dependency label, e.g. "NSUBJ", "ROOT"
+  type: string;       // phrase type, e.g. "NP", "VP"
+  parent: number;     // 0-based index of governor token; -1 for root
+}
+
+// Observed failure (probe: "I had quit the programming paradigm"): en-parse
+// attaches BOTH nouns of a noun compound to the verb as parallel objects
+// ("programming ←DOBJ← quit", "paradigm ←DOBJ← quit"), and leaves the
+// determiner dangling on the first noun as generic DEP.  The repairs:
+//   1. Two adjacent common nouns sharing a governor with the same object
+//      relation → the first is a compound modifier (AMOD) of the second.
+//   2. A determiner left as DEP on a noun that has become a modifier →
+//      re-attach it as DET to that noun's head (the true NP head).
+const CALLIOPE_DEP_FIXES = [
+  'xpos=/NNS?/&func=/DOBJ|IOBJ/;xpos=/NNS?/&func=/DOBJ|IOBJ/;xpos=/VB.*/\t#3>#1;#3>#2;#1.#2\t#2>#1;#1:func=AMOD',
+  'xpos=/DT/&func=/DEP|EXT/;xpos=/NNS?/&func=/AMOD/;xpos=/NNS?.*/\t#2>#1;#3>#2\t#3>#1;#1:func=DET',
+].join('\n');
+
+let engine: { process(conllu: string): string } | null | undefined;
+
+function loadEngine(): typeof engine {
+  if (engine !== undefined) return engine;
+  try {
+    // This package compiles to ESM, where bare `require` does not exist, and
+    // the parse path is synchronous, so dynamic import() is not an option:
+    // createRequire gives a sync loader, and since `depedits` is itself
+    // ESM-only this resolves via Node's require(esm) (≥20.17 / ≥22.12).  On
+    // older runtimes it throws and the repair pass degrades to a no-op (the
+    // unrepaired parse is still a parse).
+    const req = createRequire(import.meta.url);
+    const { DepEditEngine } = req('depedits');
+    const e = new DepEditEngine();
+    e.loadIniString(CALLIOPE_DEP_FIXES);
+    engine = e;
+  } catch {
+    engine = null;
+  }
+  return engine;
+}
+
+/**
+ * Repair systematic en-parse attachment errors.  Returns a new deps array
+ * (same shape as en-parse's `toArray` output); on any failure returns the
+ * input unchanged.
+ */
+export function applyDepFixes(tokens: string[], tags: string[], deps: FinDepNode[]): FinDepNode[] {
+  const e = loadEngine();
+  if (!e || tokens.length === 0 || deps.length !== tokens.length) return deps;
+  try {
+    const conllu = tokens.map((tok, i) => {
+      const head = deps[i].parent >= 0 ? deps[i].parent + 1 : 0;
+      const safe = tok.replace(/\s/g, '_') || '_';
+      return `${i + 1}\t${safe}\t${safe}\t_\t${tags[i] || '_'}\t_\t${head}\t${deps[i].label || 'DEP'}\t_\t_`;
+    }).join('\n') + '\n\n';
+    const out = e.process(conllu);
+    const fixed: FinDepNode[] = deps.map(d => ({ ...d }));
+    for (const row of out.split('\n')) {
+      const cols = row.split('\t');
+      if (cols.length < 10) continue;
+      const idx = parseInt(cols[0], 10) - 1;
+      if (!(idx >= 0 && idx < fixed.length)) continue;
+      const head = parseInt(cols[6], 10);
+      fixed[idx].parent = Number.isFinite(head) ? head - 1 : fixed[idx].parent;
+      if (cols[7] && cols[7] !== '_') fixed[idx].label = cols[7];
+    }
+    return fixed;
+  } catch {
+    return deps;
+  }
+}