Db to markdown migration

Author: SimonSchubert

android/src/main/java/com/inspiredandroid/linuxcommandbibliotheca/data/BasicModels.kt

@@ -0,0 +1,17 @@
+package com.inspiredandroid.linuxcommandbibliotheca.data
+
+data class BasicCategory(
+    val id: String,    // filename without .md (e.g., "filesfolders")
+    val title: String  // from H1 (e.g., "Files & Folders")
+)
+
+data class BasicGroup(
+    val id: Long,            // hash of categoryId+description
+    val description: String  // from H2 (e.g., "Create file")
+)
+
+data class BasicCommand(
+    val id: Long,       // hash for stable ID
+    val command: String, // e.g., "$ touch [fileName]"
+    val mans: String     // e.g., "touch"
+)

android/src/main/java/com/inspiredandroid/linuxcommandbibliotheca/data/BasicsRepository.kt

@@ -0,0 +1,97 @@
+package com.inspiredandroid.linuxcommandbibliotheca.data
+
+import android.content.Context
+
+class BasicsRepository(private val context: Context) {
+
+    fun getCategories(): List<BasicCategory> {
+        val assetManager = context.assets
+        val files = assetManager.list("basics") ?: return emptyList()
+
+        return files
+            .filter { it.endsWith(".md") }
+            .mapNotNull { filename ->
+                val id = filename.removeSuffix(".md")
+                val title = readCategoryTitle(filename)
+                if (title != null) {
+                    BasicCategory(id = id, title = title)
+                } else {
+                    null
+                }
+            }
+            .sortedBy { it.title }
+    }
+
+    private fun readCategoryTitle(filename: String): String? {
+        return try {
+            context.assets.open("basics/$filename").bufferedReader().useLines { lines ->
+                lines.firstOrNull { it.startsWith("# ") }?.removePrefix("# ")?.trim()
+            }
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    fun getGroupsAndCommands(categoryId: String): Pair<List<BasicGroup>, Map<Long, List<BasicCommand>>> {
+        val groups = mutableListOf<BasicGroup>()
+        val commandsByGroupId = mutableMapOf<Long, MutableList<BasicCommand>>()
+
+        try {
+            val content = context.assets.open("basics/$categoryId.md").bufferedReader().readText()
+            val lines = content.lines()
+
+            var currentGroupId: Long? = null
+            var commandIndex = 0
+
+            for (line in lines) {
+                when {
+                    line.startsWith("## ") -> {
+                        val description = line.removePrefix("## ").trim()
+                        val groupId = (categoryId + description).hashCode().toLong()
+                        groups.add(BasicGroup(id = groupId, description = description))
+                        currentGroupId = groupId
+                        commandsByGroupId[groupId] = mutableListOf()
+                        commandIndex = 0
+                    }
+                    line.contains("<code>") && currentGroupId != null -> {
+                        val (command, mans) = parseCommandLine(line)
+                        val commandId = (categoryId + currentGroupId + commandIndex).hashCode().toLong()
+                        commandsByGroupId[currentGroupId]?.add(
+                            BasicCommand(id = commandId, command = command, mans = mans)
+                        )
+                        commandIndex++
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            // Return empty on error
+        }
+
+        return Pair(groups, commandsByGroupId)
+    }
+
+    private fun parseCommandLine(line: String): Pair<String, String> {
+        // Extract command from <code>...</code>
+        val codeRegex = Regex("<code>(.*?)</code>")
+        val codeMatch = codeRegex.find(line)
+        val codeContent = codeMatch?.groupValues?.get(1) ?: ""
+
+        // Extract man links from <a href="/man/xxx">
+        val manRegex = Regex("""<a href="/man/([^"]+)">""")
+        val mans = manRegex.findAll(codeContent)
+            .map { it.groupValues[1] }
+            .distinct()
+            .joinToString(",")
+
+        // Remove HTML tags to get clean command text
+        val command = codeContent
+            .replace(Regex("""<a href="[^"]*">"""), "")
+            .replace("</a>", "")
+            .replace("&gt;", ">")
+            .replace("&lt;", "<")
+            .replace("&amp;", "&")
+            .trim()
+
+        return Pair(command, mans)
+    }
+}

android/src/main/java/com/inspiredandroid/linuxcommandbibliotheca/data/CommandModels.kt

@@ -0,0 +1,20 @@
+package com.inspiredandroid.linuxcommandbibliotheca.data
+
+data class CommandInfo(
+    val id: Long,      // name.hashCode().toLong() for stable ID
+    val name: String,  // filename without .md
+)
+
+data class CommandSectionInfo(
+    val id: Long,      // (commandName + title).hashCode().toLong()
+    val title: String, // "TLDR", "SYNOPSIS", etc.
+    val content: String,
+)
+
+fun CommandSectionInfo.getSortPriority(): Int = when (title) {
+    "TLDR" -> 0
+    "SYNOPSIS" -> 10
+    "SEE ALSO" -> 90
+    "AUTHOR" -> 100
+    else -> 50
+}

android/src/main/java/com/inspiredandroid/linuxcommandbibliotheca/data/CommandsRepository.kt

@@ -0,0 +1,100 @@
+package com.inspiredandroid.linuxcommandbibliotheca.data
+
+import android.content.Context
+
+class CommandsRepository(private val context: Context) {
+
+    private var cachedCommands: List<CommandInfo>? = null
+
+    fun getCommands(): List<CommandInfo> {
+        cachedCommands?.let { return it }
+
+        val assetManager = context.assets
+        val files = assetManager.list("commands") ?: return emptyList()
+
+        val commands = files
+            .filter { it.endsWith(".md") }
+            .map { filename ->
+                val name = filename.removeSuffix(".md")
+                CommandInfo(
+                    id = name.hashCode().toLong(),
+                    name = name,
+                )
+            }
+            .sortedBy { it.name }
+
+        cachedCommands = commands
+        return commands
+    }
+
+    fun getCommandsByQuery(query: String): List<CommandInfo> {
+        val commands = getCommands()
+        val lowerQuery = query.lowercase()
+
+        return commands
+            .filter { it.name.lowercase().contains(lowerQuery) }
+            .sortedWith(compareBy(
+                // Exact match first
+                { it.name.lowercase() != lowerQuery },
+                // Starts with query second
+                { !it.name.lowercase().startsWith(lowerQuery) },
+                // Then alphabetically
+                { it.name }
+            ))
+    }
+
+    fun getCommand(name: String): CommandInfo? {
+        return getCommands().find { it.name == name }
+    }
+
+    fun hasCommand(name: String): Boolean {
+        return getCommands().any { it.name == name }
+    }
+
+    fun getSections(commandName: String): List<CommandSectionInfo> {
+        val sections = mutableListOf<CommandSectionInfo>()
+
+        try {
+            val content = context.assets.open("commands/$commandName.md").bufferedReader().readText()
+            val lines = content.lines()
+
+            var currentTitle: String? = null
+            val currentContent = StringBuilder()
+
+            for (line in lines) {
+                if (line.startsWith("# ")) {
+                    // Save previous section if exists
+                    if (currentTitle != null) {
+                        sections.add(
+                            CommandSectionInfo(
+                                id = (commandName + currentTitle).hashCode().toLong(),
+                                title = currentTitle,
+                                content = currentContent.toString().trim(),
+                            )
+                        )
+                    }
+                    // Start new section
+                    currentTitle = line.removePrefix("# ").trim()
+                    currentContent.clear()
+                } else if (currentTitle != null) {
+                    currentContent.appendLine(line)
+                }
+            }
+
+            // Save the last section
+            if (currentTitle != null) {
+                sections.add(
+                    CommandSectionInfo(
+                        id = (commandName + currentTitle).hashCode().toLong(),
+                        title = currentTitle,
+                        content = currentContent.toString().trim(),
+                    )
+                )
+            }
+        } catch (e: Exception) {
+            // Return empty on error
+        }
+
+        return sections.sortedBy { it.getSortPriority() }
+    }
+}