@el-j/magic-helix-plugins 4.0.0-beta.6 → 4.0.0-beta.7

package/dist/index.mjs

@@ -1,24 +1,577 @@
-import { B as p } from "./BasePlugin-6wv0hYJ9.js";
-import { NodeJSPlugin as P } from "./nodejs/index.mjs";
-import { GoPlugin as u } from "./go/index.mjs";
-import { PythonPlugin as i } from "./python/index.mjs";
-import { RustPlugin as g } from "./rust/index.mjs";
-import { JavaPlugin as m } from "./java/index.mjs";
-import { RubyPlugin as a } from "./ruby/index.mjs";
-import { PHPPlugin as S } from "./php/index.mjs";
-import { CSharpPlugin as y } from "./csharp/index.mjs";
-import { CppPlugin as C } from "./cpp/index.mjs";
-import { SwiftPlugin as R } from "./swift/index.mjs";
+import { B as r } from "./BasePlugin-6wv0hYJ9.js";
+import { NodeJSPlugin as k } from "./nodejs/index.mjs";
+import { GoPlugin as U } from "./go/index.mjs";
+import { PythonPlugin as S } from "./python/index.mjs";
+import { RustPlugin as M } from "./rust/index.mjs";
+import { JavaPlugin as N } from "./java/index.mjs";
+import { RubyPlugin as L } from "./ruby/index.mjs";
+import { PHPPlugin as C } from "./php/index.mjs";
+import { CSharpPlugin as G } from "./csharp/index.mjs";
+import { CppPlugin as K } from "./cpp/index.mjs";
+import { SwiftPlugin as I } from "./swift/index.mjs";
+import * as l from "node:path";
+class d extends r {
+  constructor() {
+    super(...arguments), this.name = "elixir", this.displayName = "Elixir", this.version = "1.0.0", this.priority = 80;
+  }
+  async detect(e) {
+    if (!this.fileExists(e, "mix.exs"))
+      return null;
+    const t = this.readFile(e, "mix.exs"), i = ["elixir"], s = {};
+    if (t) {
+      const n = t.match(/app:\s*:(\w+)/), a = t.match(/version:\s*"([^"]+)"/);
+      return t.includes(":phoenix") && (i.push("phoenix"), s.phoenix = "*"), t.includes(":ecto") && (i.push("ecto"), s.ecto = "*"), {
+        language: "Elixir",
+        name: n?.[1] || this.getProjectName(e),
+        version: a?.[1] || "0.1.0",
+        dependencies: s,
+        manifestFile: "mix.exs",
+        projectPath: e,
+        tags: i
+      };
+    }
+    return {
+      language: "Elixir",
+      name: this.getProjectName(e),
+      dependencies: {},
+      manifestFile: "mix.exs",
+      projectPath: e,
+      tags: i
+    };
+  }
+  getTemplates() {
+    return [
+      {
+        name: "elixir-core",
+        tags: ["elixir"],
+        content: () => this.loadTemplateFromFile(
+          l.join(__dirname, "templates/lang-elixir.md")
+        ).then((e) => e || this.getElixirFallbackTemplate())
+      }
+    ];
+  }
+  getDependencyTagMap() {
+    return {
+      phoenix: "phoenix",
+      ecto: "ecto",
+      absinthe: "graphql",
+      plug: "plug"
+    };
+  }
+  getElixirFallbackTemplate() {
+    return `# Elixir Development Guidelines
+
+## Language-Specific Rules
+- Use pattern matching and guards extensively
+- Prefer immutable data structures
+- Use pipe operator |> for data transformations
+- Follow OTP principles for concurrent systems
+- Use GenServer for stateful processes
+
+## Code Style
+- Follow Elixir formatter conventions
+- Use snake_case for functions and variables
+- Use PascalCase for module names
+- Keep functions small and focused
+- Use \`with\` for complex case matching
+
+## Common Patterns
+- Supervision trees for fault tolerance
+- GenServer for state management
+- Phoenix contexts for domain logic
+- Ecto changesets for data validation
+`;
+  }
+}
+class p extends r {
+  constructor() {
+    super(...arguments), this.name = "dart", this.displayName = "Dart", this.version = "1.0.0", this.priority = 80;
+  }
+  async detect(e) {
+    if (!this.fileExists(e, "pubspec.yaml"))
+      return null;
+    const t = this.readFile(e, "pubspec.yaml"), i = ["dart"], s = {};
+    if (t) {
+      const n = t.match(/name:\s*(.+)/), a = t.match(/version:\s*(.+)/);
+      return (t.includes("flutter:") || t.includes("flutter_test:")) && (i.push("flutter"), s.flutter = "*"), (t.includes("flutter_riverpod:") || t.includes("riverpod:")) && i.push("riverpod"), (t.includes("flutter_bloc:") || t.includes("bloc:")) && i.push("bloc"), {
+        language: "Dart",
+        name: n?.[1]?.trim() || this.getProjectName(e),
+        version: a?.[1]?.trim() || "1.0.0",
+        dependencies: s,
+        manifestFile: "pubspec.yaml",
+        projectPath: e,
+        tags: i
+      };
+    }
+    return {
+      language: "Dart",
+      name: this.getProjectName(e),
+      dependencies: {},
+      manifestFile: "pubspec.yaml",
+      projectPath: e,
+      tags: i
+    };
+  }
+  getTemplates() {
+    return [
+      {
+        name: "dart-core",
+        tags: ["dart"],
+        content: () => this.loadTemplateFromFile(
+          l.join(__dirname, "templates/lang-dart.md")
+        ).then((e) => e || this.getDartFallbackTemplate())
+      },
+      {
+        name: "flutter-core",
+        tags: ["flutter"],
+        content: () => this.loadTemplateFromFile(
+          l.join(__dirname, "templates/flutter.md")
+        ).then((e) => e || this.getFlutterFallbackTemplate())
+      }
+    ];
+  }
+  getDependencyTagMap() {
+    return {
+      flutter: "flutter",
+      flutter_riverpod: "riverpod",
+      riverpod: "riverpod",
+      flutter_bloc: "bloc",
+      bloc: "bloc",
+      provider: "provider"
+    };
+  }
+  getDartFallbackTemplate() {
+    return `# Dart Development Guidelines
+
+## Language-Specific Rules
+- Use strong typing throughout
+- Leverage null safety features
+- Prefer const constructors where possible
+- Use named parameters for clarity
+- Follow effective Dart guidelines
+
+## Code Style
+- Use dartfmt for formatting
+- Follow Dart style guide
+- Use camelCase for variables/functions
+- Use PascalCase for classes
+`;
+  }
+  getFlutterFallbackTemplate() {
+    return `# Flutter Development Guidelines
+
+## Widget Best Practices
+- Keep widgets small and focused
+- Use StatelessWidget when possible
+- Implement proper dispose() methods
+- Use const constructors for performance
+
+## State Management
+- Choose appropriate state solution (Riverpod, Bloc, Provider)
+- Keep business logic separate from UI
+- Use ValueNotifier for simple state
+`;
+  }
+}
+class g extends r {
+  constructor() {
+    super(...arguments), this.name = "scala", this.displayName = "Scala", this.version = "1.0.0", this.priority = 80;
+  }
+  async detect(e) {
+    return this.fileExists(e, "build.sbt") ? this.detectFromSbt(e) : this.fileExists(e, "build.sc") ? this.detectFromMill(e) : null;
+  }
+  getTemplates() {
+    return [
+      {
+        name: "scala-core",
+        tags: ["scala"],
+        content: () => this.loadTemplateFromFile(
+          l.join(__dirname, "templates/lang-scala.md")
+        ).then((e) => e || this.getScalaFallbackTemplate())
+      }
+    ];
+  }
+  getDependencyTagMap() {
+    return {
+      akka: "akka",
+      "akka-http": "akka-http",
+      play: "play",
+      "cats-effect": "cats",
+      zio: "zio",
+      scalatest: "scalatest"
+    };
+  }
+  detectFromSbt(e) {
+    const t = this.readFile(e, "build.sbt"), i = ["scala"], s = {};
+    if (t) {
+      const n = t.match(/name\s*:=\s*"([^"]+)"/), a = t.match(/version\s*:=\s*"([^"]+)"/);
+      return (t.includes("akka-actor") || t.includes("com.typesafe.akka")) && (i.push("akka"), s.akka = "*"), (t.includes("play") || t.includes("com.typesafe.play")) && (i.push("play"), s.play = "*"), t.includes("zio") && i.push("zio"), (t.includes("cats-effect") || t.includes("cats-core")) && i.push("cats"), {
+        language: "Scala",
+        name: n?.[1] || this.getProjectName(e),
+        version: a?.[1] || "0.1.0",
+        dependencies: s,
+        manifestFile: "build.sbt",
+        projectPath: e,
+        tags: i
+      };
+    }
+    return {
+      language: "Scala",
+      name: this.getProjectName(e),
+      dependencies: {},
+      manifestFile: "build.sbt",
+      projectPath: e,
+      tags: i
+    };
+  }
+  detectFromMill(e) {
+    return {
+      language: "Scala",
+      name: this.getProjectName(e),
+      dependencies: {},
+      manifestFile: "build.sc",
+      projectPath: e,
+      tags: ["scala"]
+    };
+  }
+  getScalaFallbackTemplate() {
+    return `# Scala Development Guidelines
+
+## Functional Programming
+- Prefer immutable data structures
+- Use case classes for data models
+- Leverage pattern matching
+- Use for-comprehensions for sequential operations
+
+## Collections
+- Use immutable collections by default
+- Leverage map, flatMap, filter, fold
+- Understand lazy vs strict evaluation
+
+## Type System
+- Use type inference where appropriate
+- Leverage sealed traits for ADTs
+- Use implicit conversions sparingly
+`;
+  }
+}
+class f extends r {
+  constructor() {
+    super(...arguments), this.name = "kotlin", this.displayName = "Kotlin", this.version = "1.0.0", this.priority = 85;
+  }
+  async detect(e) {
+    if (!(this.fileExists(e, "build.gradle.kts") || this.fileExists(e, "settings.gradle.kts")))
+      return null;
+    const i = this.readFile(e, "build.gradle.kts"), s = ["kotlin"], n = {};
+    return i && (i.includes("ktor") && (s.push("ktor"), n.ktor = "*"), i.includes("spring-boot") && (s.push("spring-boot"), n["spring-boot"] = "*"), i.includes("exposed") && s.push("exposed"), i.includes("kotlinx-coroutines") && s.push("coroutines")), {
+      language: "Kotlin",
+      name: this.getProjectName(e),
+      dependencies: n,
+      manifestFile: "build.gradle.kts",
+      projectPath: e,
+      tags: s
+    };
+  }
+  getTemplates() {
+    return [
+      {
+        name: "kotlin-core",
+        tags: ["kotlin"],
+        content: () => this.loadTemplateFromFile(
+          l.join(__dirname, "templates/lang-kotlin.md")
+        ).then((e) => e || this.getKotlinFallbackTemplate())
+      }
+    ];
+  }
+  getDependencyTagMap() {
+    return {
+      ktor: "ktor",
+      "spring-boot": "spring-boot",
+      exposed: "exposed",
+      "kotlinx-coroutines": "coroutines"
+    };
+  }
+  getKotlinFallbackTemplate() {
+    return `# Kotlin Development Guidelines
+
+## Language Features
+- Use data classes for simple data holders
+- Leverage null safety with ?
+- Use scope functions (let, apply, run, with, also)
+- Prefer extension functions over utility classes
+
+## Coroutines
+- Use suspend functions for async operations
+- Leverage Flow for reactive streams
+- Understand structured concurrency
+
+## Collections
+- Use collection builders and operations
+- Leverage sequences for large datasets
+- Understand the difference between List/MutableList
+`;
+  }
+}
+class h extends r {
+  constructor() {
+    super(...arguments), this.name = "lua", this.displayName = "Lua", this.version = "1.0.0", this.priority = 75;
+  }
+  async detect(e) {
+    const i = this.listFiles(e)?.find((s) => s.endsWith(".rockspec"));
+    if (i || this.fileExists(e, "lua_modules")) {
+      const s = ["lua"];
+      return {
+        language: "Lua",
+        name: this.getProjectName(e),
+        dependencies: {},
+        manifestFile: i || "lua_modules",
+        projectPath: e,
+        tags: s
+      };
+    }
+    return null;
+  }
+  getTemplates() {
+    return [
+      {
+        name: "lua-core",
+        tags: ["lua"],
+        content: () => this.loadTemplateFromFile(
+          l.join(__dirname, "templates/lang-lua.md")
+        ).then((e) => e || this.getLuaFallbackTemplate())
+      }
+    ];
+  }
+  getDependencyTagMap() {
+    return {
+      lapis: "lapis",
+      openresty: "openresty",
+      busted: "busted"
+    };
+  }
+  getLuaFallbackTemplate() {
+    return `# Lua Development Guidelines
+
+## Tables
+- Tables are the primary data structure
+- Use them for arrays, dictionaries, objects
+- Arrays are 1-indexed
+
+## Metatables
+- Use metatables for OOP patterns
+- Implement __index for inheritance
+- Leverage metamethods
+
+## Best Practices
+- Keep functions small
+- Use local variables for performance
+- Understand upvalues and closures
+`;
+  }
+}
+class y extends r {
+  constructor() {
+    super(...arguments), this.name = "r", this.displayName = "R", this.version = "1.0.0", this.priority = 75;
+  }
+  async detect(e) {
+    const i = this.listFiles(e)?.some((s) => s.endsWith(".Rproj"));
+    if (this.fileExists(e, "DESCRIPTION") || i) {
+      const s = ["r"], n = {}, a = this.readFile(e, "DESCRIPTION");
+      if (a) {
+        const c = a.match(/Package:\s*(.+)/), u = a.match(/Version:\s*(.+)/);
+        return (a.includes("tidyverse") || a.includes("dplyr")) && s.push("tidyverse"), a.includes("shiny") && (s.push("shiny"), n.shiny = "*"), {
+          language: "R",
+          name: c?.[1]?.trim() || this.getProjectName(e),
+          version: u?.[1]?.trim() || "0.1.0",
+          dependencies: n,
+          manifestFile: "DESCRIPTION",
+          projectPath: e,
+          tags: s
+        };
+      }
+      return {
+        language: "R",
+        name: this.getProjectName(e),
+        dependencies: {},
+        manifestFile: i ? ".Rproj" : "DESCRIPTION",
+        projectPath: e,
+        tags: s
+      };
+    }
+    return null;
+  }
+  getTemplates() {
+    return [
+      {
+        name: "r-core",
+        tags: ["r"],
+        content: () => this.loadTemplateFromFile(
+          l.join(__dirname, "templates/lang-r.md")
+        ).then((e) => e || this.getRFallbackTemplate())
+      }
+    ];
+  }
+  getDependencyTagMap() {
+    return {
+      tidyverse: "tidyverse",
+      shiny: "shiny",
+      ggplot2: "ggplot2",
+      "data.table": "data-table"
+    };
+  }
+  getRFallbackTemplate() {
+    return `# R Development Guidelines
+
+## Tidyverse Principles
+- Use pipes (%>% or |>) for data transformations
+- Prefer dplyr verbs (select, filter, mutate, summarize)
+- Use ggplot2 for visualization
+
+## Vectorization
+- Operate on entire vectors, not loops
+- Use apply family functions
+- Leverage data.table for performance
+
+## Best Practices
+- Document functions with roxygen2
+- Write unit tests with testthat
+- Use consistent naming (snake_case)
+`;
+  }
+}
+class b extends r {
+  constructor() {
+    super(...arguments), this.name = "perl", this.displayName = "Perl", this.version = "1.0.0", this.priority = 70;
+  }
+  async detect(e) {
+    if (this.fileExists(e, "Makefile.PL") || this.fileExists(e, "Build.PL") || this.fileExists(e, "cpanfile")) {
+      const t = this.fileExists(e, "Makefile.PL") ? "Makefile.PL" : this.fileExists(e, "Build.PL") ? "Build.PL" : "cpanfile";
+      return {
+        language: "Perl",
+        name: this.getProjectName(e),
+        dependencies: {},
+        manifestFile: t,
+        projectPath: e,
+        tags: ["perl"]
+      };
+    }
+    return null;
+  }
+  getTemplates() {
+    return [
+      {
+        name: "perl-core",
+        tags: ["perl"],
+        content: () => this.loadTemplateFromFile(
+          l.join(__dirname, "templates/lang-perl.md")
+        ).then((e) => e || this.getPerlFallbackTemplate())
+      }
+    ];
+  }
+  getDependencyTagMap() {
+    return {
+      Mojolicious: "mojolicious",
+      Dancer2: "dancer",
+      Catalyst: "catalyst"
+    };
+  }
+  getPerlFallbackTemplate() {
+    return `# Perl Development Guidelines
+
+## Modern Perl
+- Use strict and warnings
+- Leverage Moose/Moo for OOP
+- Use Try::Tiny for exception handling
+
+## CPAN Modules
+- Use cpanm for installation
+- Declare dependencies in cpanfile
+- Test with prove
+
+## Best Practices
+- Follow PBP (Perl Best Practices)
+- Use perlcritic for linting
+- Write tests with Test::More
+`;
+  }
+}
+class v extends r {
+  constructor() {
+    super(...arguments), this.name = "shell", this.displayName = "Shell", this.version = "1.0.0", this.priority = 60;
+  }
+  async detect(e) {
+    const t = this.listFiles(e);
+    if (t?.some(
+      (s) => s.endsWith(".sh") || s === "Makefile" || s.endsWith(".bash") || s.endsWith(".zsh")
+    )) {
+      const s = ["shell"];
+      if ((t?.filter(
+        (a) => a.endsWith(".sh") || a.endsWith(".bash") || a.endsWith(".zsh")
+      ).length || 0) >= 2 || t?.includes("install.sh") || t?.includes("setup.sh"))
+        return {
+          language: "Shell",
+          name: this.getProjectName(e),
+          dependencies: {},
+          manifestFile: "scripts",
+          projectPath: e,
+          tags: s
+        };
+    }
+    return null;
+  }
+  getTemplates() {
+    return [
+      {
+        name: "shell-core",
+        tags: ["shell"],
+        content: () => this.loadTemplateFromFile(
+          l.join(__dirname, "templates/lang-shell.md")
+        ).then((e) => e || this.getShellFallbackTemplate())
+      }
+    ];
+  }
+  getDependencyTagMap() {
+    return {};
+  }
+  getShellFallbackTemplate() {
+    return `# Shell Script Development Guidelines
+
+## Best Practices
+- Use #!/usr/bin/env bash for portability
+- Always quote variables: "$var"
+- Use set -euo pipefail for safety
+- Check command existence with command -v
+
+## Error Handling
+- Use trap for cleanup
+- Check exit codes: if ! command; then
+- Provide meaningful error messages
+
+## Functions
+- Keep functions focused
+- Use local variables
+- Return meaningful exit codes
+`;
+  }
+}
 export {
-  p as BasePlugin,
-  y as CSharpPlugin,
-  C as CppPlugin,
-  u as GoPlugin,
-  m as JavaPlugin,
-  P as NodeJSPlugin,
-  S as PHPPlugin,
-  i as PythonPlugin,
-  a as RubyPlugin,
-  g as RustPlugin,
-  R as SwiftPlugin
+  r as BasePlugin,
+  G as CSharpPlugin,
+  K as CppPlugin,
+  p as DartPlugin,
+  d as ElixirPlugin,
+  U as GoPlugin,
+  N as JavaPlugin,
+  f as KotlinPlugin,
+  h as LuaPlugin,
+  k as NodeJSPlugin,
+  C as PHPPlugin,
+  b as PerlPlugin,
+  S as PythonPlugin,
+  y as RPlugin,
+  L as RubyPlugin,
+  M as RustPlugin,
+  g as ScalaPlugin,
+  v as ShellPlugin,
+  I as SwiftPlugin
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@el-j/magic-helix-plugins",
-  "version": "4.0.0-beta.6",
+  "version": "4.0.0-beta.7",
   "description": "Official language detection plugins for MagicAgentHelix",
   "type": "module",
   "main": "./dist/index.js",