How do I install the Mysword Module Manager skill?

Run npx skillmds@latest add welitonevoc/mysword-module-manager in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

What does the Mysword Module Manager skill do?

MySword Module Manager — Gerenciamento Completo de Módulos It is listed under Coding & Dev Tools on SkillMD.

Is Mysword Module Manager safe to use?

This skill has not completed SkillMD's automated safety review yet. Independent scanners report: SkillSpector: PASS, Skill Scanner: PASS. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Mysword Module Manager?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Mysword Module Manager free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Mysword Module Manager?

welitonevoc (@welitonevoc) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Mysword Module Manager by welitonevoc

Name: Mysword Module Manager
Author: welitonevoc

MySword Module Manager — Gerenciamento Completo de Módulos

Formatos suportados: MySword (.bbl.mybible etc.), MyBible (.SQLite3 com 7 subtipos), e-Sword v9/v11, TheWord (.ont/.ot/.nt), USFM (.zip)

📁 Diretórios Padrão de Scan

object MySwordDirectories {
    fun getDefaultScanDirs(context: Context): List<File> = buildList {
        // Raiz padrão MySword
        File(Environment.getExternalStorageDirectory(), "mysword").also { root ->
            if (root.exists()) {
                listOf("bibles", "commentaries", "dictionaries", "books", "journals", "journalsbig")
                    .map { File(root, it) }.filter { it.exists() }.forEach { add(it) }
            }
        }
        // Storage externo do app
        context.getExternalFilesDir(null)?.let { add(it) }
        context.getExternalFilesDirs(null).forEach { add(it) }
        // Downloads (usuários baixam pelo browser)
        Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)?.let { add(it) }
        // Interoperabilidade com MyBible
        File(Environment.getExternalStorageDirectory(), "MyBible").takeIf { it.exists() }?.let { add(it) }
        context.getExternalFilesDir(null)?.parentFile?.parentFile
            ?.let { File(it, "ua.mybible/files/MyBible") }
            ?.takeIf { it.exists() }?.let { add(it) }
    }.filter { it.exists() && it.isDirectory }
}

🔍 Detecção de Tipo

enum class ModuleType { BIBLE, COMMENTARY, DICTIONARY, BOOK, JOURNAL, UNKNOWN }

enum class ModuleFormat {
    MYSWORD,            // .bbl.mybible, .cmt.mybible, .dct.mybible, .bok.mybible, .jor.mybible
    MYBIBLE_BIBLE,      // .SQLite3 (sem sufixo)
    MYBIBLE_COMMENTARY, // .commentaries.SQLite3
    MYBIBLE_DICTIONARY, // .dictionary.SQLite3
    MYBIBLE_SUBHEADINGS,// .subheadings.SQLite3
    MYBIBLE_CROSSREFS,  // .crossreferences.SQLite3
    MYBIBLE_PLAN,       // .plan.SQLite3
    MYBIBLE_DEVOTIONS,  // .devotions.SQLite3
    ESWORD_LEGACY,      // .bblx, .cmtx, .dctx, .topx, .devx
    ESWORD_MODERN,      // .bbli, .cmti, .dcti, .refi, .devi
    THEWORD,            // .ont, .ot, .nt
    USFM,               // .zip com "usfm" no nome
    UNKNOWN
}

object ModuleDetector {
    fun detect(file: File): Pair<ModuleType, ModuleFormat>? {
        val lower = file.name.lowercase()
        return when {
            // MySword nativo — por extensão composta
            lower.endsWith(".bbl.mybible")     -> ModuleType.BIBLE       to ModuleFormat.MYSWORD
            lower.endsWith(".cmt.mybible")     -> ModuleType.COMMENTARY  to ModuleFormat.MYSWORD
            lower.endsWith(".dct.mybible")     -> ModuleType.DICTIONARY  to ModuleFormat.MYSWORD
            lower.endsWith(".bok.mybible")     -> ModuleType.BOOK        to ModuleFormat.MYSWORD
            lower.endsWith(".jor.mybible")     -> ModuleType.JOURNAL     to ModuleFormat.MYSWORD
            lower.endsWith(".mybible")         -> detectMyswordGeneric(file)

            // MyBible — sufixo antes de .sqlite3 (com 'S' maiúsculo na extensão real)
            // Detecção case-insensitive aqui para robustez
            lower.endsWith(".commentaries.sqlite3")  -> ModuleType.COMMENTARY  to ModuleFormat.MYBIBLE_COMMENTARY
            lower.endsWith(".dictionary.sqlite3")     -> ModuleType.DICTIONARY  to ModuleFormat.MYBIBLE_DICTIONARY
            lower.endsWith(".subheadings.sqlite3")    -> ModuleType.BIBLE       to ModuleFormat.MYBIBLE_SUBHEADINGS
            lower.endsWith(".crossreferences.sqlite3")-> ModuleType.BIBLE       to ModuleFormat.MYBIBLE_CROSSREFS
            lower.endsWith(".plan.sqlite3")           -> ModuleType.BOOK        to ModuleFormat.MYBIBLE_PLAN
            lower.endsWith(".devotions.sqlite3")      -> ModuleType.JOURNAL     to ModuleFormat.MYBIBLE_DEVOTIONS
            lower.endsWith(".sqlite3") && !lower.contains(".markup.") ->
                detectMyBibleBible(file)

            // e-Sword
            lower.endsWith(".bblx") || lower.endsWith(".bbli") -> ModuleType.BIBLE       to if (lower.endsWith("x")) ModuleFormat.ESWORD_LEGACY else ModuleFormat.ESWORD_MODERN
            lower.endsWith(".cmtx") || lower.endsWith(".cmti") -> ModuleType.COMMENTARY  to if (lower.endsWith("x")) ModuleFormat.ESWORD_LEGACY else ModuleFormat.ESWORD_MODERN
            lower.endsWith(".dctx") || lower.endsWith(".dcti") -> ModuleType.DICTIONARY  to if (lower.endsWith("x")) ModuleFormat.ESWORD_LEGACY else ModuleFormat.ESWORD_MODERN

            // The Word
            lower.endsWith(".ont") -> ModuleType.BIBLE to ModuleFormat.THEWORD
            lower.endsWith(".ot")  -> ModuleType.BIBLE to ModuleFormat.THEWORD
            lower.endsWith(".nt")  -> ModuleType.BIBLE to ModuleFormat.THEWORD

            // USFM zip
            lower.endsWith(".zip") && lower.contains("usfm") -> ModuleType.BIBLE to ModuleFormat.USFM

            else -> null
        }
    }

    private fun detectMyswordGeneric(file: File): Pair<ModuleType, ModuleFormat>? =
        detectByTables(file)?.let { it to ModuleFormat.MYSWORD }

    private fun detectMyBibleBible(file: File): Pair<ModuleType, ModuleFormat>? {
        // Verificar se é um Bible válido ou outro tipo pelo conteúdo
        val type = detectByTables(file) ?: return ModuleType.BIBLE to ModuleFormat.MYBIBLE_BIBLE
        return type to when (type) {
            ModuleType.COMMENTARY  -> ModuleFormat.MYBIBLE_COMMENTARY
            ModuleType.DICTIONARY  -> ModuleFormat.MYBIBLE_DICTIONARY
            else                   -> ModuleFormat.MYBIBLE_BIBLE
        }
    }

    fun detectByTables(file: File): ModuleType? = runCatching {
        SQLiteDatabase.openDatabase(file.absolutePath, null, SQLiteDatabase.OPEN_READONLY).use { db ->
            val tables = db.rawQuery(
                "SELECT name FROM sqlite_master WHERE type='table'", null
            ).use { c -> buildSet { while (c.moveToNext()) add(c.getString(0).uppercase()) } }
            when {
                "BIBLE"      in tables -> ModuleType.BIBLE
                "VERSES"     in tables -> ModuleType.BIBLE       // MyBible
                "COMMENTARY" in tables -> ModuleType.COMMENTARY
                "COMMENTARIES" in tables -> ModuleType.COMMENTARY  // MyBible
                "DICTIONARY" in tables -> ModuleType.DICTIONARY
                "BOOKS"      in tables -> ModuleType.BOOK
                "JOURNAL"    in tables -> ModuleType.JOURNAL
                else -> null
            }
        }
    }.getOrNull()
}

🗄️ Room Entity Universal

@Entity(
    tableName = "modules",
    indices = [
        Index(value = ["type"]),
        Index(value = ["format"]),
        Index(value = ["language"]),
        Index(value = ["isEnabled"]),
        Index(value = ["abbreviation"], unique = true)
    ]
)
data class ModuleEntity(
    @PrimaryKey val filePath: String,
    val fileName: String,
    val type: ModuleType,
    val format: ModuleFormat,
    val abbreviation: String,   // ⚠️ Para MyBible: extraído do nome do arquivo
    val title: String,
    val description: String? = null,
    val language: String = "und",    // ISO 3-letter para MySword, 2-letter para MyBible
    val isRightToLeft: Boolean = false,
    val hasOT: Boolean = false,
    val hasNT: Boolean = false,
    val hasStrong: Boolean = false,
    val isInterlinear: Boolean = false,
    val versionDate: String? = null, // YYYY-MM-DD
    val customCss: String? = null,
    val verseRules: String? = null,  // ⚠️ Só MySword — MyBible não tem VerseRules
    val isEnabled: Boolean = true,
    val displayOrder: Int = 0,
    val fileSize: Long = 0L,
    val lastModified: Long = 0L,
    val installedAt: Long = System.currentTimeMillis()
)

🗄️ ModuleDao

@Dao interface ModuleDao {
    @Query("SELECT * FROM modules WHERE isEnabled=1 ORDER BY displayOrder, title")
    fun observeEnabled(): Flow<List<ModuleEntity>>

    @Query("SELECT * FROM modules WHERE type=:type AND isEnabled=1 ORDER BY displayOrder, title")
    fun observeByType(type: ModuleType): Flow<List<ModuleEntity>>

    @Query("SELECT * FROM modules WHERE type='BIBLE' AND isEnabled=1 ORDER BY displayOrder")
    fun observeEnabledBibles(): Flow<List<ModuleEntity>>

    @Query("SELECT * FROM modules WHERE filePath=:path LIMIT 1")
    suspend fun getByPath(path: String): ModuleEntity?

    @Query("SELECT * FROM modules WHERE abbreviation=:abbr LIMIT 1")
    suspend fun getByAbbreviation(abbr: String): ModuleEntity?

    @Query("SELECT * FROM modules WHERE type='DICTIONARY' AND hasStrong=1 AND language LIKE :langPfx||'%' AND isEnabled=1 LIMIT 1")
    suspend fun findStrongsDictionary(langPfx: String): ModuleEntity?

    @Query("SELECT * FROM modules WHERE abbreviation=:abbr AND versionDate<:newDate LIMIT 1")
    suspend fun findOutdated(abbr: String, newDate: String): ModuleEntity?

    @Insert(onConflict = OnConflictStrategy.REPLACE) suspend fun upsert(m: ModuleEntity)
    @Delete suspend fun delete(m: ModuleEntity)
    @Query("DELETE FROM modules WHERE filePath=:path") suspend fun deleteByPath(path: String)
    @Query("SELECT filePath FROM modules") suspend fun getAllFilePaths(): List<String>
    @Query("UPDATE modules SET isEnabled=:e WHERE filePath=:p") suspend fun setEnabled(p: String, e: Boolean)
    @Query("UPDATE modules SET displayOrder=:o WHERE filePath=:p") suspend fun setOrder(p: String, o: Int)
    @Query("SELECT COUNT(*) FROM modules WHERE type=:type AND isEnabled=1") suspend fun countByType(type: ModuleType): Int
    @Query("SELECT SUM(fileSize) FROM modules") suspend fun totalStorageUsed(): Long?
}

🔄 Scanner Assíncrono

class ModuleScanner(private val context: Context, private val dao: ModuleDao) {

    sealed class ScanProgress {
        object Discovering : ScanProgress()
        data class Found(val count: Int) : ScanProgress()
        data class Progress(val current: Int, val total: Int, val name: String) : ScanProgress()
        data class FileError(val fileName: String, val error: String) : ScanProgress()
        data class Complete(val processed: Int, val newModules: Int) : ScanProgress()
    }

    fun scanFlow(dirs: List<File> = MySwordDirectories.getDefaultScanDirs(context)):
        Flow<ScanProgress> = flow {
        emit(ScanProgress.Discovering)
        val files = dirs.flatMap { it.walkTopDown()
            .filter { f -> f.isFile && ModuleDetector.detect(f) != null }.toList() }
        emit(ScanProgress.Found(files.size))

        val existing = dao.getAllFilePaths().toSet()
        var processed = 0; var newCount = 0

        files.forEach { file ->
            runCatching {
                val entity = extractEntity(file)
                if (entity != null) {
                    if (file.absolutePath !in existing) newCount++
                    dao.upsert(entity)
                }
            }.onFailure { emit(ScanProgress.FileError(file.name, it.message ?: "Error")) }
            emit(ScanProgress.Progress(++processed, files.size,
                file.nameWithoutExtension.take(30)))
        }

        // Remover entradas de arquivos deletados
        existing.filter { !File(it).exists() }.forEach { dao.deleteByPath(it) }
        emit(ScanProgress.Complete(processed, newCount))
    }.flowOn(Dispatchers.IO)

    fun extractEntity(file: File): ModuleEntity? {
        val (type, format) = ModuleDetector.detect(file) ?: return null
        return runCatching {
            SQLiteDatabase.openDatabase(file.absolutePath, null,
                SQLiteDatabase.OPEN_READONLY or SQLiteDatabase.NO_LOCALIZED_COLLATORS).use { db ->
                when {
                    format == ModuleFormat.MYSWORD            -> readMySwordDetails(db, file, type, format)
                    format.name.startsWith("MYBIBLE")         -> readMyBibleInfo(db, file, type, format)
                    format == ModuleFormat.ESWORD_LEGACY ||
                    format == ModuleFormat.ESWORD_MODERN      -> readESwordDetails(db, file, type, format)
                    else -> buildFallbackEntity(file, type, format)
                }
            }
        }.getOrNull()
    }

    private fun readMySwordDetails(db: SQLiteDatabase, file: File, type: ModuleType, fmt: ModuleFormat): ModuleEntity? {
        if (!tableExists(db, "Details")) return null
        val c = db.rawQuery("SELECT Abbreviation,Title,Language,OT,NT,Strong,RightToLeft,Interlinear,VersionDate,CustomCSS,VerseRules FROM Details LIMIT 1", null)
        return c.use {
            if (!it.moveToFirst()) return null
            ModuleEntity(filePath=file.absolutePath, fileName=file.name, type=type, format=fmt,
                abbreviation = it.getString(0) ?: file.nameWithoutExtension,
                title        = it.getString(1) ?: file.nameWithoutExtension,
                language     = it.getString(2) ?: "und",
                hasOT        = it.getInt(3) == 1, hasNT = it.getInt(4) == 1,
                hasStrong    = it.getInt(5) == 1, isRightToLeft = it.getInt(6) == 1,
                isInterlinear = it.getInt(7) == 1, versionDate = it.getString(8),
                customCss = it.getString(9), verseRules = it.getString(10),
                fileSize = file.length(), lastModified = file.lastModified())
        }
    }

    private fun readMyBibleInfo(db: SQLiteDatabase, file: File, type: ModuleType, fmt: ModuleFormat): ModuleEntity? {
        val tableName = listOf("info", "INFO").firstOrNull { tableExists(db, it) } ?: return null
        val info = db.rawQuery("SELECT name, value FROM $tableName", null)
            .use { c -> buildMap { while (c.moveToNext()) put(c.getString(0), c.getString(1) ?: "") } }
        // MyBible: abreviação = nome do arquivo, sem extensões de sufixo
        val abbr = file.name
            .removeSuffix(".SQLite3").removeSuffix(".sqlite3")
            .removeSuffix(".commentaries").removeSuffix(".dictionary")
            .removeSuffix(".subheadings").removeSuffix(".crossreferences")
            .removeSuffix(".plan").removeSuffix(".devotions")
        val lang2 = info["language"] ?: "und"
        // Converter 2-letter → 3-letter para normalização interna
        val lang3 = mapOf("en" to "eng", "pt" to "por", "ru" to "rus",
            "de" to "deu", "es" to "spa", "fr" to "fra",
            "el" to "grk", "iw" to "heb", "he" to "heb")[lang2] ?: lang2
        return ModuleEntity(filePath=file.absolutePath, fileName=file.name, type=type, format=fmt,
            abbreviation = abbr, title = info["description"] ?: abbr,
            language = lang3, hasOT = true, hasNT = true,
            hasStrong = info["strong_numbers"] == "true",
            isRightToLeft = info["right_to_left"] == "true",
            customCss = info["html_style"],
            fileSize = file.length(), lastModified = file.lastModified())
    }

    private fun readESwordDetails(db: SQLiteDatabase, file: File, type: ModuleType, fmt: ModuleFormat): ModuleEntity? {
        if (!tableExists(db, "Details")) return buildFallbackEntity(file, type, fmt)
        val c = db.rawQuery("SELECT Abbreviation, Description, Language, OT, NT, Strong FROM Details LIMIT 1", null)
        return c.use {
            if (!it.moveToFirst()) return buildFallbackEntity(file, type, fmt)
            ModuleEntity(filePath=file.absolutePath, fileName=file.name, type=type, format=fmt,
                abbreviation = it.getString(0) ?: file.nameWithoutExtension,
                title        = it.getString(1) ?: file.nameWithoutExtension,
                language     = it.getString(2) ?: "und",
                hasOT = it.getInt(3) == 1, hasNT = it.getInt(4) == 1,
                hasStrong = it.getInt(5) == 1,
                fileSize = file.length(), lastModified = file.lastModified())
        }
    }

    private fun buildFallbackEntity(file: File, type: ModuleType, fmt: ModuleFormat) = ModuleEntity(
        filePath = file.absolutePath, fileName = file.name, type = type, format = fmt,
        abbreviation = file.nameWithoutExtension, title = file.nameWithoutExtension,
        fileSize = file.length(), lastModified = file.lastModified()
    )

    private fun tableExists(db: SQLiteDatabase, name: String): Boolean =
        db.rawQuery("SELECT name FROM sqlite_master WHERE type='table' AND name=?",
            arrayOf(name)).use { it.count > 0 }
}

📚 66 Livros Canônicos PT-BR com Numeração Completa

data class BookInfo(val mySword: Int, val myBible: Int, val ptName: String, val abbr: String, val chapters: Int)

object BibleBooks {
    val ALL = listOf(
        BookInfo(1,  10,  "Gênesis",            "Gn",   50),
        BookInfo(2,  20,  "Êxodo",              "Êx",   40),
        BookInfo(3,  30,  "Levítico",           "Lv",   27),
        BookInfo(4,  40,  "Números",            "Nm",   36),
        BookInfo(5,  50,  "Deuteronômio",       "Dt",   34),
        BookInfo(6,  60,  "Josué",              "Js",   24),
        BookInfo(7,  70,  "Juízes",             "Jz",   21),
        BookInfo(8,  80,  "Rute",               "Rt",    4),
        BookInfo(9,  90,  "1 Samuel",           "1Sm",  31),
        BookInfo(10, 100, "2 Samuel",           "2Sm",  24),
        BookInfo(11, 110, "1 Reis",             "1Rs",  22),
        BookInfo(12, 120, "2 Reis",             "2Rs",  25),
        BookInfo(13, 130, "1 Crônicas",         "1Cr",  29),
        BookInfo(14, 140, "2 Crônicas",         "2Cr",  36),
        BookInfo(15, 150, "Esdras",             "Ed",   10),
        BookInfo(16, 160, "Neemias",            "Ne",   13),
        BookInfo(17, 190, "Ester",              "Et",   10),
        BookInfo(18, 220, "Jó",                 "Jó",   42),
        BookInfo(19, 230, "Salmos",             "Sl",  150),
        BookInfo(20, 240, "Provérbios",         "Pv",   31),
        BookInfo(21, 250, "Eclesiastes",        "Ec",   12),
        BookInfo(22, 260, "Cânticos",           "Ct",    8),
        BookInfo(23, 290, "Isaías",             "Is",   66),
        BookInfo(24, 300, "Jeremias",           "Jr",   52),
        BookInfo(25, 310, "Lamentações",        "Lm",    5),
        BookInfo(26, 330, "Ezequiel",           "Ez",   48),
        BookInfo(27, 340, "Daniel",             "Dn",   12),
        BookInfo(28, 350, "Oséias",             "Os",   14),
        BookInfo(29, 360, "Joel",               "Jl",    3),
        BookInfo(30, 370, "Amós",               "Am",    9),
        BookInfo(31, 380, "Obadias",            "Ob",    1),
        BookInfo(32, 390, "Jonas",              "Jn",    4),
        BookInfo(33, 400, "Miquéias",           "Mq",    7),
        BookInfo(34, 410, "Naum",               "Na",    3),
        BookInfo(35, 420, "Habacuque",          "Hc",    3),
        BookInfo(36, 430, "Sofonias",           "Sf",    3),
        BookInfo(37, 440, "Ageu",               "Ag",    2),
        BookInfo(38, 450, "Zacarias",           "Zc",   14),
        BookInfo(39, 460, "Malaquias",          "Ml",    4),
        BookInfo(40, 470, "Mateus",             "Mt",   28),
        BookInfo(41, 480, "Marcos",             "Mc",   16),
        BookInfo(42, 490, "Lucas",              "Lc",   24),
        BookInfo(43, 500, "João",               "Jo",   21),
        BookInfo(44, 510, "Atos",               "At",   28),
        BookInfo(45, 520, "Romanos",            "Rm",   16),
        BookInfo(46, 530, "1 Coríntios",        "1Co",  16),
        BookInfo(47, 540, "2 Coríntios",        "2Co",  13),
        BookInfo(48, 550, "Gálatas",            "Gl",    6),
        BookInfo(49, 560, "Efésios",            "Ef",    6),
        BookInfo(50, 570, "Filipenses",         "Fp",    4),
        BookInfo(51, 580, "Colossenses",        "Cl",    4),
        BookInfo(52, 590, "1 Tessalonicenses",  "1Ts",   5),
        BookInfo(53, 600, "2 Tessalonicenses",  "2Ts",   3),
        BookInfo(54, 610, "1 Timóteo",          "1Tm",   6),
        BookInfo(55, 620, "2 Timóteo",          "2Tm",   4),
        BookInfo(56, 630, "Tito",               "Tt",    3),
        BookInfo(57, 640, "Filemon",            "Fm",    1),
        BookInfo(58, 650, "Hebreus",            "Hb",   13),
        BookInfo(59, 660, "Tiago",              "Tg",    5),
        BookInfo(60, 670, "1 Pedro",            "1Pe",   5),
        BookInfo(61, 680, "2 Pedro",            "2Pe",   3),
        BookInfo(62, 690, "1 João",             "1Jo",   5),
        BookInfo(63, 700, "2 João",             "2Jo",   1),
        BookInfo(64, 710, "3 João",             "3Jo",   1),
        BookInfo(65, 720, "Judas",              "Jd",    1),
        BookInfo(66, 730, "Apocalipse",         "Ap",   22)
    )

    private val byMySword  = ALL.associateBy { it.mySword }
    private val byMyBible  = ALL.associateBy { it.myBible }

    fun getName(mySwordNum: Int): String = byMySword[mySwordNum]?.ptName ?: "Livro $mySwordNum"
    fun getAbbr(mySwordNum: Int): String = byMySword[mySwordNum]?.abbr ?: "L$mySwordNum"
    fun getChapters(mySwordNum: Int): Int = byMySword[mySwordNum]?.chapters ?: 1
    fun myBibleToMySword(myBibleNum: Int): Int = byMyBible[myBibleNum]?.mySword ?: myBibleNum
    fun mySwordToMyBible(mySwordNum: Int): Int = byMySword[mySwordNum]?.myBible ?: (mySwordNum * 10)
    fun isNewTestament(mySwordNum: Int): Boolean = mySwordNum >= 40
}

✅ Checklist

.bbl.mybible, .cmt.mybible, .dct.mybible, .bok.mybible, .jor.mybible por extensão
.SQLite3 MyBible detectado por tabela verses + info
.commentaries.SQLite3, .dictionary.SQLite3 etc. por sufixo no nome
.mybible genérico detectado por tabelas (Commentary = notas pessoais)
.bblx/.bbli = e-Sword legacy/modern
.ont/.ot/.nt = The Word
.zip com "usfm" = USFM
MyBible: abreviação do nome do arquivo, não de campo interno
MyBible: book_number convertido via BibleBooks.myBibleToMySword() ao persistir
Scan em Dispatchers.IO com Flow de progresso
Scan incremental: só reprocessa arquivos novos ou com lastModified diferente
Limpeza de módulos deletados implementada
uniqueIndex em abbreviation previne duplicatas
isNewTestament passado ao MyBibleTagParser.parse() para Strong's H vs G

Mysword Module Manager

File contents

MySword Module Manager — Gerenciamento Completo de Módulos

📁 Diretórios Padrão de Scan

🔍 Detecção de Tipo

🗄️ Room Entity Universal

🗄️ ModuleDao

🔄 Scanner Assíncrono

📚 66 Livros Canônicos PT-BR com Numeração Completa

✅ Checklist

Frequently asked questions

Mysword Module Manager

File contents

MySword Module Manager — Gerenciamento Completo de Módulos

📁 Diretórios Padrão de Scan

🔍 Detecção de Tipo

🗄️ Room Entity Universal

🗄️ ModuleDao

🔄 Scanner Assíncrono

📚 66 Livros Canônicos PT-BR com Numeração Completa

✅ Checklist

Related skills

Frequently asked questions

How do I install the Mysword Module Manager skill?

What does the Mysword Module Manager skill do?

Is Mysword Module Manager safe to use?

Which AI agents work with Mysword Module Manager?

Is Mysword Module Manager free to use?

Who published Mysword Module Manager?