Interface 4.0 + stacking

Author: gigiodelchiaro

WONT_FIX.md

@@ -0,0 +1,14 @@
+# Won't Fix List
+
+This file tracks limitations, design constraints, and bug reports that are classified as "Won't Fix" because they are deeply rooted in the architecture of Augustinus or represent intentional trade-offs.
+
+## 1. The use of `@` and `#` characters in the text treatment
+- **Description**: The core lyric-to-music processing engine uses `@` as a syllable boundary/GABC note placeholder and `#` as a marker for tonic (stressed) syllables.
+- **Consequence**: If the input lyrics contain literal `@` or `#` characters, they will be treated as control characters. They will be stripped or replaced, potentially breaking the musical mapping logic.
+- **Workaround**: Avoid using literal `@` or `#` characters in the source text, or pre-process them/escape them before submitting to Augustinus.
+- **Reason**: The app expects liturgical text as input, which shouldn't have these characters anyways.
+
+## 2. Debounced Auto-Generation of GABC (Live Updates)
+- **Description**: Automatically generating the score in real-time as the user types.
+- **Reason for Won't Fix**: Keeping score generation manual (requiring a click on the "Gerar" button) is preferred to avoid constant recalculations/rendering lag while typing large chants, ensuring a more stable user editing experience.
+

package.json

@@ -6,6 +6,7 @@
   "scripts": {
     "test": "bun test",
     "test:visual": "bun test/visual-report.ts",
+    "build:cli": "bun run --filter=@augustinus/cli build",
     "start:frontend": "bun run --filter=augustinus-frontend dev",
     "start:cli": "bun run --filter=@augustinus/cli start",
     "start:api": "bun run --filter=@augustinus/api start"

packages/cli/out.txt

@@ -10,6 +10,7 @@
   },
   "scripts": {
     "start": "bun run src/cli.ts",
+    "build": "tsc && chmod +x dist/cli.js",
     "prepublishOnly": "tsc"
   },
   "dependencies": {

packages/cli/package.json

@@ -15,36 +15,66 @@ const yargsOptions: any = {
     text: { type: 'string', alias: 't', description: 'Texto de entrada para converter para GABC' },
     input: { type: 'string', alias: 'i', description: 'Caminho do arquivo de entrada' },
     output: { type: 'string', alias: 'o', description: 'Caminho do arquivo de saída' },
-    model: { type: 'string', demandOption: true, alias: 'm', description: 'Nome do modelo a ser usado' },
+    model: { type: 'string', alias: 'm', description: 'Nome do modelo a ser usado' },
+    'list-models': { type: 'boolean', description: 'Lista todos os modelos disponíveis' },
 };
 
 // Automatically add all parameters from core schema
 parameterDefinitions.forEach(param => {
-    if (param.group === 'hidden') return;
-    
-    yargsOptions[param.key] = {
+    const option: any = {
         type: param.type === 'boolean' ? 'boolean' : 'string',
         default: param.defaultValue,
         description: param.label
     };
+
+    yargsOptions[param.key] = option;
 });
 
-const argv: any = yargs(hideBin(process.argv))
+const yargsInstance = yargs(hideBin(process.argv))
     .options(yargsOptions)
     .check((argv: any) => {
+        if (argv['list-models']) return true;
+        if (!argv.model) {
+            throw new Error('É necessário fornecer --model.');
+        }
         if (!argv.text && !argv.input) {
             throw new Error('É necessário fornecer --text ou --input.');
         }
         return true;
     })
+    .group(['text', 'input', 'output', 'model', 'list-models'], 'Opções Principais');
+
+// Add groups from parameter definitions
+const groups = [...new Set(parameterDefinitions.map(p => p.group))];
+groups.forEach(groupName => {
+    const keys = parameterDefinitions
+        .filter(p => p.group === groupName)
+        .map(p => p.key);
+    
+    // Capitalize group name for display
+    const displayName = groupName.charAt(0).toUpperCase() + groupName.slice(1);
+    yargsInstance.group(keys, displayName);
+});
+
+const argv: any = yargsInstance
     .help()
     .alias('help', 'h')
     .parseSync();
 
-const modelObject = defaultModels.find((m: Model) => m.name === argv.model);
+if (argv['list-models']) {
+    console.log('Modelos disponíveis:');
+    defaultModels.forEach((m: Model) => {
+        console.log(` - ${m.name} (${m.type}${m.tom ? ', ' + m.tom : ''})`);
+    });
+    process.exit(0);
+}
+
+const modelName = argv.model.toLowerCase();
+const modelObject = defaultModels.find((m: Model) => m.name.toLowerCase() === modelName);
 
 if (!modelObject) {
     console.error(`Modelo '${argv.model}' não encontrado.`);
+    console.log('Use --list-models para ver os modelos disponíveis.');
     process.exit(1);
 }
 

packages/cli/src/cli.ts

@@ -1,9 +1,10 @@
-import { Model, Parameters } from "./types/index.js";
+import { Model, Parameters, getDefaultParameters } from "./types/index.js";
 import { preprocessInput, handleCustomModel } from "./core/parameters.js";
 import { applyModel } from "./modules/apply-model.js";
 import defaultModels from '../assets/models.json' with { type: 'json' };
 
-export default function generateGabc(input: string, modelObject: Model, parametersObject: Parameters): string {
+export default function generateGabc(input: string, modelObject: Model, partialParameters: Partial<Parameters> = {}): string {
+    const parametersObject = { ...getDefaultParameters(), ...partialParameters };
     let model = handleCustomModel(modelObject, parametersObject);
     let psalm = model.type === "salmo" ? true : false;
 

packages/core/src/augustinus.ts

@@ -24,6 +24,16 @@ export function applyModel(lyrics: string, gabcModel: string, psalm: boolean, do
         return placeholder;
     });
 
+    const stackedParts: string[] = [];
+    const stackedPlaceholder = "||STACKEDPART||";
+
+    deTaggedLyrics = deTaggedLyrics.replace(/\[([^\]]+)\]/g, (match, content) => {
+        const lines = content.split('/');
+        const stackedContent = lines.map(line => `\\vphantom{dp}${line}`).join('&');
+        stackedParts.push(`<v>\\stacktext{${stackedContent}}</v>`);
+        return stackedPlaceholder;
+    });
+
     let wordsWithNotePlaceholders: string[] = deTaggedLyrics.split(/\s+/).filter(w => w).map(word => {
         const processToken = (token: string) => {
             if (token === placeholder) {
@@ -32,13 +42,17 @@ export function applyModel(lyrics: string, gabcModel: string, psalm: boolean, do
             if (token === specialPlaceholder) {
                 return specialTaggedParts.shift() || "";
             }
+            if (token === stackedPlaceholder) {
+                return (stackedParts.shift() || "") + "@";
+            }
             if (!/[a-zA-Z\u00C0-\u00FF]/i.test(token)) {
                 return token;
             }
             const syllableArray = syllable(token).split(/(?<=@)/);
             const tonicIndex = syllableArray.length - tonic(syllableArray);
             const result = syllableArray.map((s, i) => {
-                const isUnstressed = unstressedMonosyllables.includes(s);
+                const cleanSyllable = s.replace(/[^a-zA-Z\u00C0-\u00FF]/g, "").toLowerCase();
+                const isUnstressed = unstressedMonosyllables.includes(cleanSyllable);
                 let processedSyllable = (i === tonicIndex && !isUnstressed) ? "#" + s : s;
                 if (curlyDiphthongs) {
                     processedSyllable = processedSyllable.replace(diphthongRegex, "{$1$2}");
@@ -48,8 +62,8 @@ export function applyModel(lyrics: string, gabcModel: string, psalm: boolean, do
             return result;
         }
 
-        if (word.includes(placeholder) || word.includes(specialPlaceholder)) {
-            return word.split(/(\|\|TAGGEDPART\|\||\|\|SPECIALTAGGEDPART\|\|)/).filter(t => t).map(processToken).join("");
+        if (word.includes(placeholder) || word.includes(specialPlaceholder) || word.includes(stackedPlaceholder)) {
+            return word.split(/(\|\|TAGGEDPART\|\||\|\|SPECIALTAGGEDPART\|\||\|\|STACKEDPART\|\|)/).filter(t => t).map(processToken).join("");
         }
         return processToken(word);
     });

packages/core/src/modules/apply-model.ts

@@ -23,14 +23,14 @@ export type ParameterType = 'boolean' | 'string' | 'select';
 export const parameterDefinitions = [
     // GENERAL - OBLIGATORY/COMMON FIRST
     { key: 'separator', label: 'Separador', type: 'string', group: 'general', defaultValue: '.' },
-    { key: 'addOptionalStart', label: 'Adicionar começo', type: 'boolean', group: 'general', defaultValue: true },
-    { key: 'addOptionalEnd', label: 'Adicionar final', type: 'boolean', group: 'general', defaultValue: true },
+    { key: 'addOptionalStart', label: 'Adicionar começo', type: 'boolean', group: 'general', defaultValue: false },
+    { key: 'addOptionalEnd', label: 'Adicionar final', type: 'boolean', group: 'general', defaultValue: false },
     { key: 'removeNumbers', label: 'Remover números', type: 'boolean', group: 'general', defaultValue: true },
     { key: 'removeParenthesis', label: 'Remover parênteses', type: 'boolean', group: 'general', defaultValue: true },
     { key: 'removeSeparator', label: 'Remover separador', type: 'boolean', group: 'general', defaultValue: false },
     { key: 'quelisma', label: 'Quelisma no prefácio (experimental)', type: 'boolean', group: 'general', defaultValue: false },
     { key: 'includeBarredVParenthesis', label: 'Incluir () após o ℣ barrado', type: 'boolean', group: 'general', defaultValue: false },
-    { key: 'curlyDiphthongs', label: 'Incluir {} em ditongos', type: 'boolean', group: 'general', defaultValue: true },
+    { key: 'curlyDiphthongs', label: 'Incluir {} em ditongos', type: 'boolean', group: 'general', defaultValue: false },
 
     // PSALMS
     { key: 'repeatIntonation', label: 'Repetir entonação', type: 'boolean', group: 'psalm', defaultValue: true },