calliope-ts 0.0.2 → 0.0.4

package/dist/clio/phrasestress.d.ts

@@ -0,0 +1,6 @@
+import { ClsWord } from '../types.js';
+/**
+ * Populate `word.phraseStress` for every word of a parsed sentence.
+ */
+export declare function computePhraseStress(words: ClsWord[]): void;
+//# sourceMappingURL=phrasestress.d.ts.map

package/dist/clio/phrasestress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phrasestress.d.ts","sourceRoot":"","sources":["../../src/clio/phrasestress.ts"],"names":[],"mappings":"AAgCA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAyBtC;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,IAAI,CAkB1D"}

package/dist/clio/phrasestress.js

@@ -0,0 +1,106 @@
+// phrasestress.ts — McAleese's Phrase-Stress phase (previously SKIPPED).
+//
+// The pipeline used to map lexical stress straight to relative stress (plus a
+// single "+1 on the rightmost content word"), leaving `ClsWord.phraseStress`
+// a vestigial field stuck at 0.  This module restores the genuine phase that
+// sits BETWEEN lexical and relative stress in McAleese's procedure (thesis
+// Appendix A; Chomsky & Halle's Nuclear + Compound Stress Rules):
+//
+//   1. every word starts at 1;
+//   2. the Compound Stress Rule pins a compound's subordinate element at the
+//      floor while its principal stays in the ramp;
+//   3. the recursive Nuclear Stress Rule ramps the principal stress of each
+//      successive *stressed* word left-to-right, so prominence rises to the
+//      phrase's nuclear (rightmost) peak.
+//
+// For the right-branching structure of English declaratives the recursive NSR
+// reduces to a monotone ramp over the stressed words — function words and
+// compound-subordinates pinned at 1.  NOTE the convention: here 1 is the FLOOR
+// and the ramp climbs RIGHTWARD to the nuclear peak (the "If hairs…" example
+// below).  McAleese's "Mary ate sweet ice cream" worked example uses the
+// OPPOSITE (SPE) numbering — 1 = PRIMARY/strongest, weakened outward — so his
+// ICE cream (primary on "ice") is reproduced here as ice=PEAK, cream=floor
+// (the compound's HEAD "cream" is the subordinate, pinned at 1):
+//
+//   "Mary ate sweet ice cream"  -> Mary2 ate3 sweet4 ice5 cream1  (ICE cream: head subordinate)
+//   "If hairs be wires, black wires grow on her head" -> 1 2 3 4 5 6 7 1 1 8
+//
+// (Marked / left-branching structures are approximated by the same ramp; a
+// constituent-tree-driven refinement over `sentence.nodes` is a flagged
+// follow-up.  This module reads only POS / content flags and surface order,
+// and writes only the previously-unused phraseStress field — purely additive.)
+import { isPunctuation } from './parser.js';
+import { compoundStressSide } from './stress.js';
+/** Sentence-final punctuation resets the nuclear ramp (the NSR is
+ *  sentence-bounded).  A comma / colon / dash does NOT — the ramp runs across
+ *  an internal intonational break (cf. "If hairs…, black wires…" → 1234…5,678). */
+const SENTENCE_FINAL = new Set(['.', '!', '?', '…']);
+/** Common-/proper-noun POS tags, gating which compounds floor an element. */
+const NOUN_TAGS = new Set(['NN', 'NNS', 'NNP', 'NNPS']);
+/**
+ * Proclitic POS tags pinned at the phrase-stress floor: the NSR ramp applies to
+ * *stressed words* (nouns, adjectives, adverbs, and VERBS — including the
+ * copula/auxiliary "be" and modals, which bear lexical stress even though they
+ * reduce in the contour), while pure clitics carry none.  Verbs are NOT here,
+ * so McAleese's "if hairs BE wires…" keeps `be` in the ramp (=3).  A word the
+ * earlier pipeline promoted to content (a phrasal-verb particle, a focus
+ * demonstrative — `isContent === true`) is un-pinned and ramps.
+ */
+const PINNED_POS = new Set([
+    'IN', 'TO', 'DT', 'CC', 'PRP', 'PRP$', 'WP', 'WP$', 'WDT', 'EX', 'POS',
+]);
+/**
+ * Populate `word.phraseStress` for every word of a parsed sentence.
+ */
+export function computePhraseStress(words) {
+    const subordinate = compoundSubordinates(words);
+    let ramp = 1; // running nuclear ramp; the floor for pinned words is 1
+    for (const w of words) {
+        if (isPunctuation(w.lexicalClass)) {
+            w.phraseStress = 0;
+            if (SENTENCE_FINAL.has(w.word))
+                ramp = 1;
+            continue;
+        }
+        // Pinned at the floor: a proclitic function word bears no nuclear ramp, and
+        // a compound's subordinate element is demoted by the Compound Stress Rule.
+        const isClitic = PINNED_POS.has(w.lexicalClass) && !w.isContent;
+        if (isClitic || subordinate.has(w)) {
+            w.phraseStress = 1;
+            continue;
+        }
+        w.phraseStress = ++ramp;
+    }
+}
+/**
+ * Identify the subordinate (pinned) element of each surface-adjacent compound,
+ * delegating the direction to `compoundStressSide` (the shared rule, so phrase
+ * stress and the lexical compound pass cannot disagree).
+ *   - fore-stress ('left') → the HEAD (right) element is subordinate: SEA·shore,
+ *     ICE cream, KITCHen table — the Compound Stress Rule default for N+N;
+ *   - right-stress ('right') → the MODIFIER (left) is subordinate: apple PIE,
+ *     and proper-name pairs (New YORK);
+ *   - Adjective+noun ("sweet cream") is phrasal, not a compound (`side` is
+ *     'right' there too, so the modifier "sweet" is pinned and "cream" ramps —
+ *     i.e. end-stress, as desired).
+ */
+function compoundSubordinates(words) {
+    const subs = new Set();
+    for (let i = 0; i + 1 < words.length; i++) {
+        const a = words[i], b = words[i + 1];
+        if (isPunctuation(a.lexicalClass) || isPunctuation(b.lexicalClass))
+            continue;
+        if (!a.isContent || !b.isContent)
+            continue;
+        const side = compoundStressSide(a.word, a.lexicalClass, b.word, b.lexicalClass);
+        // Floor an element only for a genuine N+N compound; an Adj+N ("sweet ice",
+        // "red car") is phrasal — its end-stress emerges from the ramp itself, so we
+        // pin nothing and let the adjective ramp (McAleese: sweet=4, above cream).
+        const bothNouns = NOUN_TAGS.has(a.lexicalClass) && NOUN_TAGS.has(b.lexicalClass);
+        if (side === 'left')
+            subs.add(b); // fore-stress compound: head subordinate (ICE cream)
+        else if (side === 'right' && bothNouns)
+            subs.add(a); // right-stress N+N: modifier subordinate (apple PIE)
+    }
+    return subs;
+}

package/dist/clio/pipeline.d.ts

@@ -0,0 +1,11 @@
+import { type ReadingStanza } from './display.js';
+import type { LineResult } from '../types.js';
+export type { ReadingStanza } from './display.js';
+export { renderUnifiedDisplay, renderReadingView, renderFullLegend } from './display.js';
+export { parseDocument, isPunctuation } from './parser.js';
+export { renderHierarchy, renderKeyStresses } from './phonological.js';
+export { clioEngine } from './engine.js';
+export declare function analyzeStanzasClio(text: string): LineResult[][];
+export declare function analyzeTextClio(text: string): LineResult[];
+export declare function analyzeReadingDocumentClio(text: string): ReadingStanza[];
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/clio/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/clio/pipeline.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAC6D,UAAU,EAClF,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAGlD,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACzF,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAkEzC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,EAAE,CAyB/D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,CAE1D;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CAyBxE"}

package/dist/clio/pipeline.js

@@ -0,0 +1,147 @@
+// clio/pipeline.ts — the FROZEN Clio analysis pipeline (the "control group").
+//
+// This is a verbatim snapshot of index.ts's orchestration (processLine +
+// applyContinuityRename + analyzeStanzas/analyzeText/analyzeReadingDocument) as it
+// stood at the structure-first rebuild, wired EXCLUSIVELY to clio-local frozen
+// modules (clio/parser, clio/scansion, clio/rhyme, clio/scandroid, clio/phonological,
+// clio/display) and hard-wired to clioEngine.  Nothing here imports the live
+// top-level pipeline, so changes to the regular (Calliope) pipeline — including the
+// shared scorer — CANNOT affect Clio's output.  Clio is grounded in this tree alone.
+//
+// DO NOT evolve this file or any clio/* module with the Calliope rebuild.
+import { parseDocument } from './parser.js';
+import { renderHierarchy, renderKeyStresses } from './phonological.js';
+import { extractKeyStresses, scoreMeters, applyStanzaConsensus, applyRhythmLayer, applyMetricalityLayer, } from './scansion.js';
+import { applyRhymeAndForm } from './rhyme.js';
+import { scandroidCorralWeird, scandroidMaximizeNormal, stressToMarks } from './scandroid.js';
+import { clioEngine } from './engine.js';
+// Frozen Clio renderers + parse entry, so the CLI can render Clio output entirely
+// from the clio/ tree (live display.ts changes cannot reach Clio).
+export { renderUnifiedDisplay, renderReadingView, renderFullLegend } from './display.js';
+export { parseDocument, isPunctuation } from './parser.js';
+export { renderHierarchy, renderKeyStresses } from './phonological.js';
+export { clioEngine } from './engine.js';
+/** Scan one verse line (which may parse into several grammatical sentences). */
+function processLine(sents) {
+    if (sents.length === 0)
+        return null;
+    const iusPerSent = [];
+    for (const sent of sents) {
+        iusPerSent.push(clioEngine.analyzeSentence(sent));
+    }
+    const words = sents.flatMap(s => s.words);
+    const ius = iusPerSent.flat();
+    let merged;
+    if (sents.length === 1) {
+        merged = sents[0];
+    }
+    else {
+        words.forEach((w, i) => { w.index = i + 1; });
+        merged = {
+            index: sents[0].index, nodes: null,
+            dependencies: sents.flatMap(s => s.dependencies), words, xml: '',
+        };
+    }
+    const keyStresses = extractKeyStresses(ius, words);
+    const phonoDetail = scoreMeters(keyStresses, words, ius);
+    phonoDetail.all = renderHierarchy(ius, words);
+    phonoDetail.keyStresses = renderKeyStresses(ius, words, keyStresses);
+    const stressPattern = words.flatMap(w => w.syllables.map(s => s.relativeStress ?? 'w'));
+    const marks = stressToMarks(stressPattern);
+    const actualFeet = phonoDetail.footCount > 0 ? phonoDetail.footCount : 5;
+    const corral = scandroidCorralWeird(marks, actualFeet);
+    const max = scandroidMaximizeNormal(marks, actualFeet);
+    const corralResult = corral.footlist.length
+        ? { meter: 'iambic', scansion: corral.footlist.map(f => f.replace(/[()]/g, '')).join(' | '),
+            certainty: 0, weightScore: 0, maxPossibleWeight: 0, algorithm: 'Scandroid Corral the Weird' }
+        : undefined;
+    const maxResult = max.footlist.length
+        ? { meter: 'iambic', scansion: max.footlist.map(f => f.replace(/[()]/g, '')).join(' | '),
+            certainty: 0, weightScore: 0, maxPossibleWeight: 0, algorithm: 'Scandroid Maximise the Normal' }
+        : undefined;
+    return {
+        sentence: merged, phonologicalHierarchy: ius, keyStresses,
+        phonologicalScansion: phonoDetail, scandroidCorral: corralResult, scandroidMaximise: maxResult,
+    };
+}
+function applyContinuityRename(results) {
+    const noted = results.filter(r => r.phonologicalScansion.rhythmNote).length;
+    if (results.length > 0 && noted >= results.length / 2)
+        return;
+    for (const res of results) {
+        const d = res.phonologicalScansion;
+        if (!d.consensusMeter)
+            continue;
+        const family = d.consensusMeter.split(' ')[0];
+        const forced = scoreMeters(res.keyStresses, res.sentence.words, res.phonologicalHierarchy, family);
+        if (!forced || forced.meterName === 'free verse' || forced.footCount <= 0)
+            continue;
+        d.standaloneMeter = d.meter;
+        d.meter = forced.meter;
+        d.meterName = forced.meterName;
+        d.footCount = forced.footCount;
+        d.scansion = forced.scansion;
+        d.certainty = forced.certainty;
+        d.summary = forced.summary;
+        d.consensusMeter = undefined;
+    }
+}
+export function analyzeStanzasClio(text) {
+    const stanzas = text.split(/\n\s*\n/);
+    const results = [];
+    for (const stanza of stanzas) {
+        const lines = stanza.split('\n').filter(l => l.trim() !== '');
+        const stanzaResults = [];
+        for (const line of lines) {
+            const doc = parseDocument(line);
+            const res = processLine(doc.sentences);
+            if (res)
+                stanzaResults.push(res);
+        }
+        applyStanzaConsensus(stanzaResults.map(r => r.phonologicalScansion));
+        applyRhythmLayer(stanzaResults.map(r => r.phonologicalScansion));
+        applyContinuityRename(stanzaResults);
+        results.push(stanzaResults);
+    }
+    if (results.length > 1) {
+        const all = results.flat();
+        applyStanzaConsensus(all.map(r => r.phonologicalScansion));
+        applyContinuityRename(all);
+        for (const st of results)
+            applyRhythmLayer(st.map(r => r.phonologicalScansion));
+    }
+    applyMetricalityLayer(results.flatMap(st => st.map(r => r.phonologicalScansion)));
+    applyRhymeAndForm(results);
+    return results;
+}
+export function analyzeTextClio(text) {
+    return analyzeStanzasClio(text).flat();
+}
+export function analyzeReadingDocumentClio(text) {
+    const stanzas = text.split(/\n\s*\n/);
+    const out = [];
+    for (const stanza of stanzas) {
+        const rawLines = stanza.split('\n').filter(l => l.trim() !== '');
+        if (rawLines.length === 0)
+            continue;
+        const lines = rawLines.map(raw => {
+            const doc = parseDocument(raw);
+            const res = processLine(doc.sentences);
+            return { raw, results: res ? [res] : [] };
+        });
+        applyStanzaConsensus(lines.flatMap(l => l.results.map(r => r.phonologicalScansion)));
+        applyRhythmLayer(lines.flatMap(l => l.results.map(r => r.phonologicalScansion)));
+        applyContinuityRename(lines.flatMap(l => l.results));
+        out.push({ lines });
+    }
+    if (out.length > 1) {
+        const all = out.flatMap(st => st.lines.flatMap(l => l.results));
+        applyStanzaConsensus(all.map(r => r.phonologicalScansion));
+        applyContinuityRename(all);
+        for (const st of out)
+            applyRhythmLayer(st.lines.flatMap(l => l.results.map(r => r.phonologicalScansion)));
+    }
+    applyMetricalityLayer(out.flatMap(st => st.lines.flatMap(l => l.results.map(r => r.phonologicalScansion))));
+    applyRhymeAndForm(out.map(st => st.lines.flatMap(l => l.results)));
+    return out;
+}

package/dist/clio/rhyme.d.ts

@@ -0,0 +1,65 @@
+import { LineResult, StressLevel } from '../types.js';
+export type RhymeTypeName = 'identical' | 'rich' | 'perfect' | 'family' | 'assonant' | 'consonant' | 'augmented' | 'diminished' | 'wrenched' | 'eye';
+export interface RhymePair {
+    type: RhymeTypeName;
+    /** masculine (stress on final syllable) / feminine (penult) / dactylic (antepenult) */
+    structure?: 'masculine' | 'feminine' | 'dactylic';
+}
+/** Classify the rhyme relation between two line-end words (or null). */
+export declare function classifyRhymePair(a: string, b: string): RhymePair | null;
+export interface LineRhyme {
+    endWord: string;
+    letter: string;
+    type?: RhymeTypeName;
+    matchedLine?: number;
+}
+/** Detect a stanza's rhyme scheme from its line-end words.  Strong rhymes
+ *  bind; slant-tier rhymes bind only when no strong candidate exists. */
+export declare function detectScheme(endWords: string[]): LineRhyme[];
+/**
+ * Annotate rhyme letters/types (`detail.rhyme`) and form verdicts
+ * (`detail.formNote`) across a poem.  Stanza forms are per-stanza; a poem-level
+ * form (sonnet, terza rima) overrides stanza notes.  Annotation-only — no
+ * meter/scansion/certainty is touched.
+ */
+export declare function applyRhymeAndForm(stanzas: LineResult[][]): void;
+export interface RhymeRel {
+    fromWord: string;
+    fromLabel: string;
+    toWord: string;
+    toLabel: string;
+    letter: string;
+    type?: RhymeTypeName;
+    kind: 'end' | 'caesural' | 'head';
+    topStress: StressLevel;
+}
+export interface Phonopoetics {
+    endScheme: string;
+    end: RhymeRel[];
+    caesural: RhymeRel[];
+    head: RhymeRel[];
+    alliteration: {
+        label: string;
+        words: string[];
+    }[];
+    acrostics: {
+        labels: string[];
+        firsts: string[];
+        word: string;
+    }[];
+}
+/** Whole-poem phonopoetic analysis: structured data for the Phonopoetics
+ *  synopsis section.  Read-only — never mutates the per-line scansion. */
+export declare function analyzePhonopoetics(stanzas: LineResult[][]): Phonopoetics;
+/** A labelled line of the poem synopsis (display renders each). */
+export interface SynopsisRow {
+    label: string;
+    value: string;
+}
+/**
+ * Build the cumulative poem synopsis: top meter(s)/mixed meters (accentual forms
+ * reported in beats), the poem-wide rhyme scheme (with internal rhymes), and the
+ * poetic-form alignment.  Reads only existing per-line determinations.
+ */
+export declare function summarizePoem(stanzas: LineResult[][]): SynopsisRow[];
+//# sourceMappingURL=rhyme.d.ts.map

package/dist/clio/rhyme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rhyme.d.ts","sourceRoot":"","sources":["../../src/clio/rhyme.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAW,UAAU,EAA8B,WAAW,EAAE,MAAM,aAAa,CAAC;AAK3F,MAAM,MAAM,aAAa,GACrB,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAC3C,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,YAAY,GACrD,UAAU,GAAG,KAAK,CAAC;AAEvB,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,aAAa,CAAC;IACpB,uFAAuF;IACvF,SAAS,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC;CACnD;AA6DD,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAkDxE;AAQD,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;yEACyE;AACzE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CA6C5D;AAqMD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,IAAI,CAkB/D;AAsCD,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IACpC,MAAM,EAAE,MAAM,CAAC;IAAG,OAAO,EAAE,MAAM,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,KAAK,GAAG,UAAU,GAAG,MAAM,CAAC;IAClC,SAAS,EAAE,WAAW,CAAC;CACxB;AACD,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,QAAQ,EAAE,CAAC;IAChB,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,IAAI,EAAE,QAAQ,EAAE,CAAC;IACjB,YAAY,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IACnD,SAAS,EAAE;QAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACnE;AAED;0EAC0E;AAC1E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,YAAY,CAsIzE;AAgCD,mEAAmE;AACnE,MAAM,WAAW,WAAW;IAAG,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;CAAE;AA2B9D;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,GAAG,WAAW,EAAE,CA0DpE"}