linthis 0.2.0__tar.gz → 0.2.1__tar.gz

{linthis-0.2.0 → linthis-0.2.1}/Cargo.lock

@@ -1330,7 +1330,7 @@ dependencies = [
 
 [[package]]
 name = "linthis"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "anyhow",
  "async-trait",

{linthis-0.2.0 → linthis-0.2.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "linthis"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 authors = ["zhlinh"]
 description = "A fast, cross-platform multi-language linter and formatter"

{linthis-0.2.0 → linthis-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linthis
-Version: 0.2.0
+Version: 0.2.1
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{linthis-0.2.0 → linthis-0.2.1}/jetbrains-linthis/src/main/kotlin/com/mojeter/linthis/plugin/LinthisStreamConnectionProvider.kt

@@ -7,6 +7,7 @@
 package com.mojeter.linthis.plugin
 
 import com.intellij.openapi.project.Project
+import com.mojeter.linthis.plugin.settings.LinthisSettings
 import com.redhat.devtools.lsp4ij.server.ProcessStreamConnectionProvider
 import java.io.File
 
@@ -31,8 +32,22 @@ class LinthisStreamConnectionProvider(private val project: Project) : ProcessStr
     }
 
     private fun buildCommand(): List<String> {
-        val linthisPath = findLinthisExecutable()
-        return listOf(linthisPath, "lsp")
+        val settings = LinthisSettings.getInstance(project)
+        val linthisPath = if (settings.linthisPath.isNotBlank()) {
+            settings.linthisPath
+        } else {
+            findLinthisExecutable()
+        }
+
+        val commands = mutableListOf(linthisPath, "lsp")
+
+        // Add --use-plugin if configured
+        if (settings.usePlugin.isNotBlank()) {
+            commands.add("--use-plugin")
+            commands.add(settings.usePlugin)
+        }
+
+        return commands
     }
 
     /**

{linthis-0.2.0 → linthis-0.2.1}/jetbrains-linthis/src/main/kotlin/com/mojeter/linthis/plugin/actions/LinthisFormatAction.kt

@@ -49,7 +49,7 @@ class LinthisFormatAction : AnAction(), DumbAware {
         // Run linthis format
         ApplicationManager.getApplication().executeOnPooledThread {
             LOG.warn("Running format on file: ${file.path}")
-            val result = LinthisExecutor.format(file.path, project.basePath, settings.linthisPath)
+            val result = LinthisExecutor.format(file.path, project.basePath, settings.linthisPath, settings.usePlugin)
 
             ApplicationManager.getApplication().invokeLater {
                 if (result.success) {

{linthis-0.2.0 → linthis-0.2.1}/jetbrains-linthis/src/main/kotlin/com/mojeter/linthis/plugin/listeners/LinthisDocumentListener.kt

@@ -81,7 +81,7 @@ class LinthisDocumentListener : FileDocumentManagerListener {
                     LOG.warn("Running format on save for: ${file.path}")
 
                     // Format the file in-place (file is already saved to disk)
-                    val result = LinthisExecutor.format(file.path, project.basePath, settings.linthisPath)
+                    val result = LinthisExecutor.format(file.path, project.basePath, settings.linthisPath, settings.usePlugin)
 
                     if (result.success) {
                         LOG.warn("Format on save successful, reloading document")

{linthis-0.2.0 → linthis-0.2.1}/jetbrains-linthis/src/main/kotlin/com/mojeter/linthis/plugin/settings/LinthisSettings.kt

@@ -28,6 +28,7 @@ class LinthisSettings : PersistentStateComponent<LinthisSettings.State> {
         var lintOnSave: Boolean = true
         var formatOnSave: Boolean = false
         var linthisPath: String = ""
+        var usePlugin: String = ""
         var additionalArgs: String = ""
     }
 
@@ -53,6 +54,10 @@ class LinthisSettings : PersistentStateComponent<LinthisSettings.State> {
         get() = myState.linthisPath
         set(value) { myState.linthisPath = value }
 
+    var usePlugin: String
+        get() = myState.usePlugin
+        set(value) { myState.usePlugin = value }
+
     var additionalArgs: String
         get() = myState.additionalArgs
         set(value) { myState.additionalArgs = value }

{linthis-0.2.0 → linthis-0.2.1}/jetbrains-linthis/src/main/kotlin/com/mojeter/linthis/plugin/settings/LinthisSettingsConfigurable.kt

@@ -28,6 +28,7 @@ class LinthisSettingsConfigurable(private val project: Project) : Configurable {
     private var lintOnSaveCheckbox: JBCheckBox? = null
     private var formatOnSaveCheckbox: JBCheckBox? = null
     private var linthisPathField: TextFieldWithBrowseButton? = null
+    private var usePluginField: JBTextField? = null
     private var additionalArgsField: JBTextField? = null
 
     override fun getDisplayName(): String = "Linthis"
@@ -47,6 +48,7 @@ class LinthisSettingsConfigurable(private val project: Project) : Configurable {
         }
 
         additionalArgsField = JBTextField()
+        usePluginField = JBTextField()
 
         settingsPanel = FormBuilder.createFormBuilder()
             .addComponent(JBLabel("<html><b>Behavior</b></html>"))
@@ -59,6 +61,14 @@ class LinthisSettingsConfigurable(private val project: Project) : Configurable {
                 JBLabel("Linthis path (leave empty for auto-detect):"),
                 linthisPathField!!
             )
+            .addSeparator()
+            .addComponent(JBLabel("<html><b>Plugin</b></html>"))
+            .addLabeledComponent(
+                JBLabel("<html>Use plugin (e.g., https://github.com/zhlinh/linthis-plugin-template):</html>"),
+                usePluginField!!
+            )
+            .addSeparator()
+            .addComponent(JBLabel("<html><b>Advanced</b></html>"))
             .addLabeledComponent(
                 JBLabel("Additional arguments:"),
                 additionalArgsField!!
@@ -75,6 +85,7 @@ class LinthisSettingsConfigurable(private val project: Project) : Configurable {
                lintOnSaveCheckbox?.isSelected != settings.lintOnSave ||
                formatOnSaveCheckbox?.isSelected != settings.formatOnSave ||
                linthisPathField?.text != settings.linthisPath ||
+               usePluginField?.text != settings.usePlugin ||
                additionalArgsField?.text != settings.additionalArgs
     }
 
@@ -84,6 +95,7 @@ class LinthisSettingsConfigurable(private val project: Project) : Configurable {
         settings.lintOnSave = lintOnSaveCheckbox?.isSelected ?: true
         settings.formatOnSave = formatOnSaveCheckbox?.isSelected ?: false
         settings.linthisPath = linthisPathField?.text ?: ""
+        settings.usePlugin = usePluginField?.text ?: ""
         settings.additionalArgs = additionalArgsField?.text ?: ""
     }
 
@@ -93,6 +105,7 @@ class LinthisSettingsConfigurable(private val project: Project) : Configurable {
         lintOnSaveCheckbox?.isSelected = settings.lintOnSave
         formatOnSaveCheckbox?.isSelected = settings.formatOnSave
         linthisPathField?.text = settings.linthisPath
+        usePluginField?.text = settings.usePlugin
         additionalArgsField?.text = settings.additionalArgs
     }
 
@@ -102,6 +115,7 @@ class LinthisSettingsConfigurable(private val project: Project) : Configurable {
         lintOnSaveCheckbox = null
         formatOnSaveCheckbox = null
         linthisPathField = null
+        usePluginField = null
         additionalArgsField = null
     }
 }

{linthis-0.2.0 → linthis-0.2.1}/jetbrains-linthis/src/main/kotlin/com/mojeter/linthis/plugin/util/LinthisExecutor.kt

@@ -36,19 +36,25 @@ object LinthisExecutor {
      * @param filePath Path to the file to format
      * @param workingDir Working directory for the command
      * @param customLinthisPath Custom path to linthis executable (empty for auto-detect)
+     * @param usePlugin Plugin URL to use (empty for none)
      * @return ExecutionResult with success status and any error messages
      */
-    fun format(filePath: String, workingDir: String?, customLinthisPath: String?): ExecutionResult {
+    fun format(filePath: String, workingDir: String?, customLinthisPath: String?, usePlugin: String? = null): ExecutionResult {
         val linthisPath = if (customLinthisPath.isNullOrBlank()) {
             findLinthisExecutable()
         } else {
             customLinthisPath
         }
 
-        LOG.warn("Format file: $filePath, linthisPath: $linthisPath, workingDir: $workingDir")
+        LOG.warn("Format file: $filePath, linthisPath: $linthisPath, workingDir: $workingDir, usePlugin: $usePlugin")
 
         return try {
-            val processBuilder = ProcessBuilder(linthisPath, "-f", "-i", filePath)
+            val commands = mutableListOf(linthisPath, "-f", "-i", filePath)
+            if (!usePlugin.isNullOrBlank()) {
+                commands.add("--use-plugin")
+                commands.add(usePlugin)
+            }
+            val processBuilder = ProcessBuilder(commands)
 
             if (workingDir != null) {
                 processBuilder.directory(File(workingDir))
@@ -101,13 +107,15 @@ object LinthisExecutor {
      * @param originalFilePath Original file path (used to determine file extension)
      * @param workingDir Working directory for the command
      * @param customLinthisPath Custom path to linthis executable
+     * @param usePlugin Plugin URL to use (empty for none)
      * @return FormatResult with formatted content or error message
      */
     fun formatContent(
         content: String,
         originalFilePath: String,
         workingDir: String?,
-        customLinthisPath: String?
+        customLinthisPath: String?,
+        usePlugin: String? = null
     ): FormatResult {
         val linthisPath = if (customLinthisPath.isNullOrBlank()) {
             findLinthisExecutable()
@@ -119,14 +127,19 @@ object LinthisExecutor {
         val extension = originalFilePath.substringAfterLast('.', "")
         val tempFile = File.createTempFile("linthis_format_", if (extension.isNotEmpty()) ".$extension" else "")
 
-        LOG.info("FormatContent: originalPath=$originalFilePath, linthisPath=$linthisPath, tempFile=${tempFile.absolutePath}")
+        LOG.info("FormatContent: originalPath=$originalFilePath, linthisPath=$linthisPath, tempFile=${tempFile.absolutePath}, usePlugin=$usePlugin")
 
         return try {
             // Write content to temp file
             tempFile.writeText(content)
             LOG.info("FormatContent: wrote ${content.length} chars to temp file")
 
-            val processBuilder = ProcessBuilder(linthisPath, "-f", "-i", tempFile.absolutePath)
+            val commands = mutableListOf(linthisPath, "-f", "-i", tempFile.absolutePath)
+            if (!usePlugin.isNullOrBlank()) {
+                commands.add("--use-plugin")
+                commands.add(usePlugin)
+            }
+            val processBuilder = ProcessBuilder(commands)
 
             if (workingDir != null) {
                 processBuilder.directory(File(workingDir))

{linthis-0.2.0 → linthis-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "linthis"
-version = "0.2.0"
+version = "0.2.1"
 description = "A fast, cross-platform multi-language linter and formatter"
 readme = "README.md"
 requires-python = ">=3.8"

{linthis-0.2.0 → linthis-0.2.1}/src/checkers/python.rs

@@ -198,6 +198,9 @@ impl Checker for PythonChecker {
         // Try to find ruff config
         if let Some(config_path) = Self::find_ruff_config(path) {
             cmd.arg("--config").arg(&config_path);
+        } else {
+            // No config found - use sensible defaults (E=pycodestyle errors, W=warnings, F=pyflakes)
+            cmd.args(["--select", "E,W,F"]);
         }
 
         let output = cmd
@@ -212,7 +215,8 @@ impl Checker for PythonChecker {
         if output.status.code() == Some(2) && stdout.is_empty() && stderr.contains("Failed to parse") {
             let mut retry_cmd = Command::new("ruff");
             retry_cmd.args(["check", "--output-format", "json"]);
-            // Don't use config - let ruff use defaults
+            // Use default rules instead of broken config
+            retry_cmd.args(["--select", "E,W,F"]);
             let retry_output = retry_cmd
                 .arg(path)
                 .output()

{linthis-0.2.0 → linthis-0.2.1}/src/cli/commands.rs

@@ -122,6 +122,17 @@ pub struct Cli {
     #[arg(long)]
     pub no_plugin: bool,
 
+    /// Use specific plugin(s) directly, bypassing config files
+    /// Useful for debugging plugins or CI integration
+    ///
+    /// Formats:
+    ///   --use-plugin https://github.com/org/plugin.git
+    ///   --use-plugin https://github.com/org/plugin.git@v1.0
+    ///   --use-plugin /path/to/local/plugin
+    ///   --use-plugin plugin1,plugin2  (comma-separated)
+    #[arg(long, value_delimiter = ',')]
+    pub use_plugin: Option<Vec<String>>,
+
     /// Hook mode: enable compact output format for git hooks
     /// Shows summary at top, lists errors with file:line, and provides fix commands
     /// Optional value specifies hook type: pre-commit (default), pre-push, commit-msg
@@ -387,6 +398,7 @@ pub enum Commands {
     /// Example usage:
     ///   linthis lsp              # Start in stdio mode (default)
     ///   linthis lsp --mode tcp   # Start in TCP mode on port 9257
+    ///   linthis lsp --use-plugin https://github.com/org/plugin.git
     Lsp {
         /// Communication mode: stdio (default) or tcp
         #[arg(long, default_value = "stdio")]
@@ -395,6 +407,12 @@ pub enum Commands {
         /// TCP port (only used when mode is tcp)
         #[arg(long, default_value = "9257")]
         port: u16,
+
+        /// Use specific plugin(s) directly, bypassing config files
+        ///
+        /// Example: --use-plugin https://github.com/zhlinh/linthis-plugin-template
+        #[arg(long, value_delimiter = ',')]
+        use_plugin: Option<Vec<String>>,
     },
     /// Generate reports and analyze lint results
     ///

{linthis-0.2.0 → linthis-0.2.1}/src/main.rs

@@ -176,7 +176,60 @@ fn main() -> ExitCode {
     }
 
     // Handle lsp subcommand
-    if let Some(Commands::Lsp { mode, port }) = cli.command {
+    if let Some(Commands::Lsp { mode, port, use_plugin }) = cli.command {
+        // Load plugins before starting LSP (same logic as main command)
+        if let Some(ref plugin_specs) = use_plugin {
+            use linthis::plugin::{PluginLoader, PluginSource};
+
+            for spec in plugin_specs {
+                // Parse plugin spec: URL[@ref] or local path
+                let (url_or_path, git_ref) = if spec.contains('@') && !spec.starts_with('/') {
+                    let parts: Vec<&str> = spec.rsplitn(2, '@').collect();
+                    if parts.len() == 2 {
+                        (parts[1].to_string(), Some(parts[0].to_string()))
+                    } else {
+                        (spec.clone(), None)
+                    }
+                } else {
+                    (spec.clone(), None)
+                };
+
+                let name = url_or_path
+                    .rsplit('/')
+                    .next()
+                    .unwrap_or(&url_or_path)
+                    .trim_end_matches(".git")
+                    .to_string();
+
+                let source = if let Some(ref r) = git_ref {
+                    PluginSource::new(&url_or_path).with_ref(r)
+                } else {
+                    PluginSource::new(&url_or_path)
+                };
+
+                if let Ok(loader) = PluginLoader::new() {
+                    if let Ok(configs) = loader.load_configs(&[source], false) {
+                        // Copy plugin configs to .linthis/configs/
+                        let linthis_dir = std::env::current_dir()
+                            .unwrap_or_default()
+                            .join(".linthis");
+                        let config_dir = linthis_dir.join("configs");
+
+                        for config in &configs {
+                            if let Some(filename) = config.config_path.file_name() {
+                                let lang_dir = config_dir.join(&config.language);
+                                if std::fs::create_dir_all(&lang_dir).is_ok() {
+                                    let target = lang_dir.join(filename);
+                                    let _ = std::fs::copy(&config.config_path, &target);
+                                }
+                            }
+                        }
+                        eprintln!("[lsp] Loaded {} config(s) from plugin '{}'", configs.len(), name);
+                    }
+                }
+            }
+        }
+
         let lsp_mode = match mode.parse::<LspMode>() {
             Ok(m) => m,
             Err(e) => {
@@ -285,31 +338,53 @@ fn main() -> ExitCode {
     // Track loaded plugins for display
     let mut loaded_plugins: Vec<String> = Vec::new();
 
-    // Load plugins from config files (project first, then global)
+    // Load plugins: --use-plugin takes priority, then config files
     if !cli.no_plugin {
         use linthis::plugin::{PluginConfigManager, PluginLoader, PluginSource};
 
         let mut plugins_to_load: Vec<(String, PluginSource)> = Vec::new();
 
-        // Check project config first
-        if let Ok(project_manager) = PluginConfigManager::project() {
-            if let Ok(project_plugins) = project_manager.list_plugins() {
-                for (name, url, git_ref) in project_plugins {
-                    let source = if let Some(ref r) = git_ref {
-                        PluginSource::new(&url).with_ref(r)
+        // Check --use-plugin first (takes priority over config files)
+        if let Some(ref plugin_specs) = cli.use_plugin {
+            for spec in plugin_specs {
+                // Parse plugin spec: URL[@ref] or local path
+                let (url_or_path, git_ref) = if spec.contains('@') && !spec.starts_with('/') {
+                    // URL with ref: https://github.com/org/plugin.git@v1.0
+                    let parts: Vec<&str> = spec.rsplitn(2, '@').collect();
+                    if parts.len() == 2 {
+                        (parts[1].to_string(), Some(parts[0].to_string()))
                     } else {
-                        PluginSource::new(&url)
-                    };
-                    plugins_to_load.push((name, source));
+                        (spec.clone(), None)
+                    }
+                } else {
+                    (spec.clone(), None)
+                };
+
+                // Generate plugin name from URL/path
+                let name = url_or_path
+                    .rsplit('/')
+                    .next()
+                    .unwrap_or(&url_or_path)
+                    .trim_end_matches(".git")
+                    .to_string();
+
+                let source = if let Some(ref r) = git_ref {
+                    PluginSource::new(&url_or_path).with_ref(r)
+                } else {
+                    PluginSource::new(&url_or_path)
+                };
+
+                if cli.verbose {
+                    eprintln!("Using plugin from CLI: {} ({})", name, url_or_path);
                 }
+                plugins_to_load.push((name, source));
             }
-        }
-
-        // If no project plugins, check global config
-        if plugins_to_load.is_empty() {
-            if let Ok(global_manager) = PluginConfigManager::global() {
-                if let Ok(global_plugins) = global_manager.list_plugins() {
-                    for (name, url, git_ref) in global_plugins {
+        } else {
+            // No --use-plugin, load from config files (project first, then global)
+            // Check project config first
+            if let Ok(project_manager) = PluginConfigManager::project() {
+                if let Ok(project_plugins) = project_manager.list_plugins() {
+                    for (name, url, git_ref) in project_plugins {
                         let source = if let Some(ref r) = git_ref {
                             PluginSource::new(&url).with_ref(r)
                         } else {
@@ -319,6 +394,22 @@ fn main() -> ExitCode {
                     }
                 }
             }
+
+            // If no project plugins, check global config
+            if plugins_to_load.is_empty() {
+                if let Ok(global_manager) = PluginConfigManager::global() {
+                    if let Ok(global_plugins) = global_manager.list_plugins() {
+                        for (name, url, git_ref) in global_plugins {
+                            let source = if let Some(ref r) = git_ref {
+                                PluginSource::new(&url).with_ref(r)
+                            } else {
+                                PluginSource::new(&url)
+                            };
+                            plugins_to_load.push((name, source));
+                        }
+                    }
+                }
+            }
         }
 
         if !plugins_to_load.is_empty() {

{linthis-0.2.0 → linthis-0.2.1}/src/plugin/fetcher.rs

@@ -55,18 +55,16 @@ impl PluginFetcher {
         }
     }
 
-    /// Fetch a plugin from Git repository
+    /// Fetch a plugin from Git repository or use local path
     ///
     /// If already cached, returns the cached version unless force_update is true.
+    /// For local paths, directly uses the path without cloning.
     pub fn fetch(
         &self,
         source: &PluginSource,
         cache: &PluginCache,
         force_update: bool,
     ) -> Result<CachedPlugin> {
-        // Check Git availability first
-        Self::check_git_available()?;
-
         let url = source
             .url
             .as_ref()
@@ -75,6 +73,14 @@ impl PluginFetcher {
                 message: "No URL provided for plugin".to_string(),
             })?;
 
+        // Check if this is a local path
+        if source.is_local_path() {
+            return self.fetch_local(source, url);
+        }
+
+        // Check Git availability first (only needed for remote URLs)
+        Self::check_git_available()?;
+
         let cache_path = cache.url_to_cache_path(url);
 
         // Check if already cached
@@ -114,6 +120,56 @@ impl PluginFetcher {
         Ok(plugin)
     }
 
+    /// Fetch a plugin from a local path (no cloning needed)
+    fn fetch_local(&self, source: &PluginSource, path: &str) -> Result<CachedPlugin> {
+        // Resolve the path (handle relative paths)
+        let local_path = std::path::PathBuf::from(path);
+        let resolved_path = if local_path.is_relative() {
+            std::env::current_dir()
+                .map_err(|e| PluginError::CacheError {
+                    message: format!("Failed to get current directory: {}", e),
+                })?
+                .join(&local_path)
+        } else {
+            local_path
+        };
+
+        // Canonicalize to get absolute path
+        let canonical_path =
+            std::fs::canonicalize(&resolved_path).map_err(|e| PluginError::CacheError {
+                message: format!("Local plugin path '{}' not found: {}", path, e),
+            })?;
+
+        // Check if manifest exists
+        let manifest_path = canonical_path.join("linthis-plugin.toml");
+        if !manifest_path.exists() {
+            return Err(PluginError::InvalidManifest {
+                path: manifest_path,
+                message: "linthis-plugin.toml not found in local plugin directory".to_string(),
+            });
+        }
+
+        log_plugin_operation(
+            "local",
+            &format!("Using local plugin at {}", canonical_path.display()),
+            self.verbose,
+        );
+
+        // Get commit hash if it's a git repo
+        let commit_hash = self.get_local_commit_hash(&canonical_path);
+
+        let now = Utc::now();
+        Ok(CachedPlugin {
+            name: source.name.clone(),
+            url: path.to_string(),
+            git_ref: source.git_ref.clone(),
+            commit_hash,
+            cached_at: now,
+            last_updated: now,
+            cache_path: canonical_path,
+        })
+    }
+
     /// Clone a plugin repository with shallow clone
     fn clone_plugin(&self, url: &str, target_path: &Path, git_ref: Option<&str>) -> Result<()> {
         // Ensure parent directory exists

{linthis-0.2.0 → linthis-0.2.1}/src/plugin/mod.rs

@@ -168,7 +168,7 @@ pub struct PluginSource {
 }
 
 impl PluginSource {
-    /// Create a new plugin source from a name (registry lookup) or URL
+    /// Create a new plugin source from a name (registry lookup), URL, or local path
     pub fn new(name_or_url: &str) -> Self {
         if name_or_url.contains("://") || name_or_url.starts_with("git@") {
             // It's a URL
@@ -178,6 +178,17 @@ impl PluginSource {
                 git_ref: None,
                 enabled: true,
             }
+        } else if name_or_url.starts_with('/')
+            || name_or_url.starts_with("./")
+            || name_or_url.starts_with("../")
+        {
+            // It's a local path
+            Self {
+                name: Self::name_from_url(name_or_url),
+                url: Some(name_or_url.to_string()),
+                git_ref: None,
+                enabled: true,
+            }
         } else {
             // It's a registry name
             Self {
@@ -189,6 +200,15 @@ impl PluginSource {
         }
     }
 
+    /// Check if this is a local path source
+    pub fn is_local_path(&self) -> bool {
+        if let Some(ref url) = self.url {
+            url.starts_with('/') || url.starts_with("./") || url.starts_with("../")
+        } else {
+            false
+        }
+    }
+
     /// Extract a short name from a URL
     fn name_from_url(url: &str) -> String {
         url.trim_end_matches(".git")
@@ -268,6 +288,39 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_plugin_source_new_from_local_path_absolute() {
+        let source = PluginSource::new("/path/to/local/plugin");
+        assert_eq!(source.name, "plugin");
+        assert_eq!(source.url, Some("/path/to/local/plugin".to_string()));
+        assert!(source.is_local_path());
+    }
+
+    #[test]
+    fn test_plugin_source_new_from_local_path_relative() {
+        let source = PluginSource::new("./my-plugin");
+        assert_eq!(source.name, "my-plugin");
+        assert_eq!(source.url, Some("./my-plugin".to_string()));
+        assert!(source.is_local_path());
+    }
+
+    #[test]
+    fn test_plugin_source_new_from_local_path_parent() {
+        let source = PluginSource::new("../parent-plugin");
+        assert_eq!(source.name, "parent-plugin");
+        assert_eq!(source.url, Some("../parent-plugin".to_string()));
+        assert!(source.is_local_path());
+    }
+
+    #[test]
+    fn test_plugin_source_is_not_local_path() {
+        let source = PluginSource::new("https://github.com/org/plugin.git");
+        assert!(!source.is_local_path());
+
+        let source2 = PluginSource::new("official");
+        assert!(!source2.is_local_path());
+    }
+
     // ==================== PluginSource::with_ref tests ====================
 
     #[test]

{linthis-0.2.0 → linthis-0.2.1}/vscode-linthis/.vscodeignore

@@ -13,6 +13,8 @@ webpack.config.js
 *.vsix
 .DS_Store
 .linthis.toml
+.linthis/**
+.ruff_cache/**
 PUBLISHING.md
 PUBLISHING.zh.md
 !dist/**