Merge pull request #5 from logos-co/improve_lm_binary

Supressed debug outputs when running LM command; improve default behaviour and experience

Author: iurimatias

README.md

@@ -32,13 +32,20 @@ nix build .#all
 
 ## Using the `lm` Binary
 
-Show plugin metadata:
+Show both metadata and methods (default):
+```bash
+lm /path/to/plugin.dylib
+lm /path/to/plugin.dylib --json
+lm /path/to/plugin.dylib --debug
+```
+
+Show plugin metadata only:
 ```bash
 lm metadata /path/to/plugin.dylib
 lm metadata /path/to/plugin.dylib --json
 ```
 
-Show plugin methods:
+Show plugin methods only:
 ```bash
 lm methods /path/to/plugin.dylib
 lm methods /path/to/plugin.dylib --json

cmd/main.cpp

@@ -7,6 +7,8 @@
 #include <iostream>
 #include <vector>
 #include <string>
+#include <unistd.h>
+#include <fcntl.h>
 
 #include "logos_module.h"
 #include "module_metadata.h"
@@ -18,29 +20,67 @@ QTextStream err(stderr);
 
 const char* VERSION = "0.1.0";
 
+// Global flag for debug mode
+static bool g_debugMode = false;
+
+// Custom Qt message handler to suppress debug/info messages unless in debug mode
+void customMessageHandler(QtMsgType type, const QMessageLogContext& context, const QString& msg) {
+    if (!g_debugMode && (type == QtDebugMsg || type == QtInfoMsg)) {
+        // Suppress debug and info messages when not in debug mode
+        return;
+    }
+    
+    // For warnings and errors, or when in debug mode, use default handling
+    QByteArray localMsg = msg.toLocal8Bit();
+    const char* file = context.file ? context.file : "";
+    const char* function = context.function ? context.function : "";
+    
+    switch (type) {
+    case QtDebugMsg:
+        fprintf(stderr, "Debug: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
+        break;
+    case QtInfoMsg:
+        fprintf(stderr, "Info: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
+        break;
+    case QtWarningMsg:
+        fprintf(stderr, "Warning: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
+        break;
+    case QtCriticalMsg:
+        fprintf(stderr, "Critical: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
+        break;
+    case QtFatalMsg:
+        fprintf(stderr, "Fatal: %s (%s:%u, %s)\n", localMsg.constData(), file, context.line, function);
+        abort();
+    }
+}
+
 void printVersion() {
     out << "lm (Logos Module) version " << VERSION << Qt::endl;
 }
 
 void printUsage() {
     out << "lm - Logos Module Inspector\n"
         << "\n"
-        << "Usage: lm <command> [options] <plugin-path>\n"
+        << "Usage: lm [command] [options] <plugin-path>\n"
         << "\n"
         << "Commands:\n"
+        << "  (default)   Show both metadata and methods (when no command specified)\n"
         << "  metadata    Show plugin metadata (name, version, description, etc.)\n"
         << "  methods     Show plugin methods and signatures\n"
         << "\n"
         << "Options:\n"
         << "  --json      Output in JSON format\n"
+        << "  --debug     Show debug output from plugin loading\n"
         << "  --help, -h  Show help information\n"
         << "  --version, -v  Show version information\n"
         << "\n"
         << "Examples:\n"
+        << "  lm /path/to/plugin.so\n"
+        << "  lm /path/to/plugin.so --json\n"
         << "  lm metadata /path/to/plugin.so\n"
         << "  lm methods /path/to/plugin.so\n"
         << "  lm metadata /path/to/plugin.so --json\n"
-        << "  lm methods /path/to/plugin.so --json\n";
+        << "  lm methods /path/to/plugin.so --json --debug\n";
 }
 
 void printCommandHelp(const QString& command) {
@@ -51,15 +91,17 @@ void printCommandHelp(const QString& command) {
             << "type, and dependencies.\n"
             << "\n"
             << "Options:\n"
-            << "  --json  Output in JSON format\n";
+            << "  --json   Output in JSON format\n"
+            << "  --debug  Show debug output from plugin loading\n";
     } else if (command == "methods") {
         out << "Usage: lm methods [options] <plugin-path>\n"
             << "\n"
             << "Show all methods exposed by the plugin via Qt's meta-object system.\n"
             << "Displays method name, signature, return type, and parameters.\n"
             << "\n"
             << "Options:\n"
-            << "  --json  Output in JSON format\n";
+            << "  --json   Output in JSON format\n"
+            << "  --debug  Show debug output from plugin loading\n";
     }
 }
 
@@ -137,26 +179,22 @@ int cmdMetadata(const QString& pluginPath, bool jsonOutput) {
         return 1;
     }
 
-    QString errorString;
-    LogosModule plugin = LogosModule::loadFromPath(absolutePath, &errorString);
-    
-    if (!plugin.isValid()) {
-        err << "Error: Failed to load plugin: " << errorString << Qt::endl;
+    auto metadata = LogosModule::extractMetadata(absolutePath);
+    if (!metadata) {
+        err << "Error: Failed to extract metadata from: " << pluginPath << Qt::endl;
         return 1;
     }
 
-    const ModuleMetadata& metadata = plugin.metadata();
-    
     if (jsonOutput) {
-        printMetadataJson(metadata);
+        printMetadataJson(*metadata);
     } else {
-        printMetadataHuman(metadata);
+        printMetadataHuman(*metadata);
     }
 
     return 0;
 }
 
-int cmdMethods(const QString& pluginPath, bool jsonOutput) {
+int cmdMethods(const QString& pluginPath, bool jsonOutput, bool debugOutput) {
     QFileInfo fileInfo(pluginPath);
     QString absolutePath = fileInfo.absoluteFilePath();
 
@@ -166,7 +204,36 @@ int cmdMethods(const QString& pluginPath, bool jsonOutput) {
     }
 
     QString errorString;
-    LogosModule plugin = LogosModule::loadFromPath(absolutePath, &errorString);
+    LogosModule plugin;
+    
+    if (!debugOutput) {
+        // Redirect stdout and stderr to /dev/null during plugin loading
+        int stdout_copy = dup(STDOUT_FILENO);
+        int stderr_copy = dup(STDERR_FILENO);
+        
+        int devnull = open("/dev/null", O_WRONLY);
+        if (devnull != -1) {
+            dup2(devnull, STDOUT_FILENO);
+            dup2(devnull, STDERR_FILENO);
+            close(devnull);
+        }
+        
+        // Load the plugin (this may trigger constructor output)
+        plugin = LogosModule::loadFromPath(absolutePath, &errorString);
+        
+        // Restore stdout and stderr
+        if (stdout_copy != -1) {
+            dup2(stdout_copy, STDOUT_FILENO);
+            close(stdout_copy);
+        }
+        if (stderr_copy != -1) {
+            dup2(stderr_copy, STDERR_FILENO);
+            close(stderr_copy);
+        }
+    } else {
+        // Debug mode: load normally without suppression
+        plugin = LogosModule::loadFromPath(absolutePath, &errorString);
+    }
 
     if (!plugin.isValid()) {
         err << "Error: Failed to load plugin: " << errorString << Qt::endl;
@@ -188,9 +255,100 @@ int cmdMethods(const QString& pluginPath, bool jsonOutput) {
     return 0;
 }
 
+int cmdInfo(const QString& pluginPath, bool jsonOutput, bool debugOutput) {
+    QFileInfo fileInfo(pluginPath);
+    QString absolutePath = fileInfo.absoluteFilePath();
+    
+    if (!fileInfo.exists()) {
+        err << "Error: Plugin file not found: " << pluginPath << Qt::endl;
+        return 1;
+    }
+    
+    if (jsonOutput) {
+        // For JSON output, combine metadata and methods into a single object
+        auto metadata = LogosModule::extractMetadata(absolutePath);
+        if (!metadata) {
+            err << "Error: Failed to extract metadata from: " << pluginPath << Qt::endl;
+            return 1;
+        }
+        
+        // Load plugin for methods
+        QString errorString;
+        LogosModule plugin;
+        
+        if (!debugOutput) {
+            // Suppress output during loading
+            int stdout_copy = dup(STDOUT_FILENO);
+            int stderr_copy = dup(STDERR_FILENO);
+            
+            int devnull = open("/dev/null", O_WRONLY);
+            if (devnull != -1) {
+                dup2(devnull, STDOUT_FILENO);
+                dup2(devnull, STDERR_FILENO);
+                close(devnull);
+            }
+            
+            plugin = LogosModule::loadFromPath(absolutePath, &errorString);
+            
+            if (stdout_copy != -1) {
+                dup2(stdout_copy, STDOUT_FILENO);
+                close(stdout_copy);
+            }
+            if (stderr_copy != -1) {
+                dup2(stderr_copy, STDERR_FILENO);
+                close(stderr_copy);
+            }
+        } else {
+            plugin = LogosModule::loadFromPath(absolutePath, &errorString);
+        }
+        
+        if (!plugin.isValid()) {
+            err << "Error: Failed to load plugin: " << errorString << Qt::endl;
+            return 1;
+        }
+        
+        // Build combined JSON object
+        QJsonObject combined;
+        
+        QJsonObject metadataObj;
+        metadataObj["name"] = metadata->name;
+        metadataObj["version"] = metadata->version;
+        metadataObj["description"] = metadata->description;
+        metadataObj["author"] = metadata->author;
+        metadataObj["type"] = metadata->type;
+        
+        QJsonArray deps;
+        for (const QString& dep : metadata->dependencies) {
+            deps.append(dep);
+        }
+        metadataObj["dependencies"] = deps;
+        
+        combined["metadata"] = metadataObj;
+        combined["methods"] = LogosModule::getMethodsAsJson(plugin.instance());
+        
+        QJsonDocument doc(combined);
+        out << doc.toJson(QJsonDocument::Indented);
+    } else {
+        // For human-readable output, print metadata then methods with a separator
+        int result = cmdMetadata(pluginPath, false);
+        if (result != 0) {
+            return result;
+        }
+        
+        out << "\n";
+        
+        return cmdMethods(pluginPath, false, debugOutput);
+    }
+    
+    return 0;
+}
+
 int main(int argc, char* argv[]) {
     QCoreApplication app(argc, argv);
 
+    // Install custom message handler to suppress debug output by default
+    qInstallMessageHandler(customMessageHandler);
+    
     std::vector<std::string> args;
     for (int i = 1; i < argc; ++i) {
         args.push_back(argv[i]);
@@ -213,24 +371,40 @@ int main(int argc, char* argv[]) {
         return 0;
     }
 
-    std::string command = firstArg;
+    std::string command;
+    bool defaultMode = false;
     bool jsonOutput = false;
+    bool debugOutput = false;
     QString pluginPath;
 
-    if (command != "metadata" && command != "methods") {
-        err << "Error: Unknown command '" << QString::fromStdString(command) << "'\n"
-            << "\nRun 'lm --help' to see available commands.\n";
+    // Check if first arg is a command or a plugin path
+    if (firstArg == "metadata" || firstArg == "methods") {
+        command = firstArg;
+    } else if (firstArg[0] != '-') {
+        // First arg is not a command and not an option, treat as plugin path
+        defaultMode = true;
+        pluginPath = QString::fromStdString(firstArg);
+    } else {
+        err << "Error: Unknown option '" << QString::fromStdString(firstArg) << "'" << Qt::endl;
         return 1;
     }
 
-    for (size_t i = 1; i < args.size(); ++i) {
+    // Parse remaining arguments
+    size_t startIdx = defaultMode ? 1 : 1;  // Start after command or plugin path
+    for (size_t i = startIdx; i < args.size(); ++i) {
         std::string arg = args[i];
 
         if (arg == "--help" || arg == "-h") {
-            printCommandHelp(QString::fromStdString(command));
+            if (defaultMode) {
+                printUsage();
+            } else {
+                printCommandHelp(QString::fromStdString(command));
+            }
             return 0;
         } else if (arg == "--json") {
             jsonOutput = true;
+        } else if (arg == "--debug") {
+            debugOutput = true;
         } else if (arg[0] == '-') {
             err << "Error: Unknown option '" << QString::fromStdString(arg) << "'" << Qt::endl;
             return 1;
@@ -246,14 +420,23 @@ int main(int argc, char* argv[]) {
 
     if (pluginPath.isEmpty()) {
         err << "Error: Missing plugin path" << Qt::endl;
-        err << "\nUsage: lm " << QString::fromStdString(command) << " [options] <plugin-path>" << Qt::endl;
+        if (defaultMode) {
+            err << "\nUsage: lm [options] <plugin-path>" << Qt::endl;
+        } else {
+            err << "\nUsage: lm " << QString::fromStdString(command) << " [options] <plugin-path>" << Qt::endl;
+        }
         return 1;
     }
 
-    if (command == "metadata") {
+    // Set global debug flag
+    g_debugMode = debugOutput;
+    
+    if (defaultMode) {
+        return cmdInfo(pluginPath, jsonOutput, debugOutput);
+    } else if (command == "metadata") {
         return cmdMetadata(pluginPath, jsonOutput);
     } else if (command == "methods") {
-        return cmdMethods(pluginPath, jsonOutput);
+        return cmdMethods(pluginPath, jsonOutput, debugOutput);
     }
 
     return 0;

flake.nix

@@ -37,6 +37,11 @@
           # lm binary package
           lm = bin;
 
+          # Additional aliases for the binary
+          cli = bin;
+          bin = bin;
+          cmd = bin;
+
           # logos-module library
           lib = lib;