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

package/dist/dart/templates/lang-dart.md

@@ -0,0 +1,233 @@
+# Dart Development Guidelines
+
+## Language Overview
+Dart is a client-optimized language for fast apps on any platform. It's the programming language behind Flutter and supports strong typing with null safety.
+
+## Code Style & Conventions
+
+### Naming
+- **Classes/Enums/Typedefs**: PascalCase (`UserModel`, `ColorState`)
+- **Functions/Variables**: camelCase (`getUserData`, `userName`)
+- **Constants**: lowerCamelCase (`defaultTimeout`, `maxRetries`)
+- **Private members**: Prefix with underscore (`_privateMethod`, `_internalState`)
+
+### Null Safety
+```dart
+// Non-nullable by default
+String name;  // Must be initialized
+String? optionalName;  // Can be null
+
+// Null-aware operators
+String? maybeValue;
+final length = maybeValue?.length ?? 0;  // Default value
+final value = maybeValue!;  // Null assertion (use carefully)
+```
+
+### Collections
+```dart
+// Use const for immutable collections
+const colors = ['red', 'green', 'blue'];
+
+// Type-safe collections
+final List<User> users = [];
+final Map<String, int> scores = {};
+final Set<String> uniqueNames = {};
+
+// Collection operators
+final adults = users.where((u) => u.age >= 18).toList();
+final names = users.map((u) => u.name).toList();
+```
+
+## Object-Oriented Programming
+
+### Classes
+```dart
+class User {
+  final String id;
+  final String name;
+  final int age;
+
+  // Constructor with named parameters
+  const User({
+    required this.id,
+    required this.name,
+    required this.age,
+  });
+
+  // Named constructor
+  User.guest() : this(id: 'guest', name: 'Guest', age: 0);
+
+  // Factory constructor
+  factory User.fromJson(Map<String, dynamic> json) {
+    return User(
+      id: json['id'],
+      name: json['name'],
+      age: json['age'],
+    );
+  }
+
+  // Copyhold
+  User copyWith({String? name, int? age}) {
+    return User(
+      id: id,
+      name: name ?? this.name,
+      age: age ?? this.age,
+    );
+  }
+}
+```
+
+### Mixins
+```dart
+mixin LoggerMixin {
+  void log(String message) {
+    print('[${DateTime.now()}] $message');
+  }
+}
+
+class MyService with LoggerMixin {
+  void doSomething() {
+    log('Doing something');
+  }
+}
+```
+
+## Async Programming
+
+### Futures
+```dart
+Future<User> fetchUser(String id) async {
+  final response = await http.get(Uri.parse('/users/$id'));
+  return User.fromJson(json.decode(response.body));
+}
+
+// Error handling
+try {
+  final user = await fetchUser('123');
+} catch (e) {
+  print('Error: $e');
+}
+```
+
+### Streams
+```dart
+Stream<int> countStream(int max) async* {
+  for (int i = 1; i <= max; i++) {
+    await Future.delayed(Duration(seconds: 1));
+    yield i;
+  }
+}
+
+// Usage
+await for (final count in countStream(5)) {
+  print(count);
+}
+```
+
+## Testing
+
+### Unit Tests
+```dart
+import 'package:test/test.dart';
+
+void main() {
+  group('User', () {
+    test('creates from JSON', () {
+      final json = {'id': '1', 'name': 'John', 'age': 30};
+      final user = User.fromJson(json);
+      
+      expect(user.id, '1');
+      expect(user.name, 'John');
+      expect(user.age, 30);
+    });
+
+    test('copyWith preserves unchanged fields', () {
+      final user = User(id: '1', name: 'John', age: 30);
+      final updated = user.copyWith(name: 'Jane');
+      
+      expect(updated.id, user.id);
+      expect(updated.name, 'Jane');
+      expect(updated.age, user.age);
+    });
+  });
+}
+```
+
+## Best Practices
+
+### Performance
+- Use `const` constructors when possible
+- Prefer `final` over `var` for immutability
+- Use collection literals instead of constructors
+- Avoid unnecessary rebuilds
+
+### Code Organization
+- One class per file (generally)
+- Group related files in directories
+- Use barrel files (index.dart) for clean exports
+- Separate models, services, and utilities
+
+### Error Handling
+- Use exceptions for exceptional cases
+- Return `Result<T, E>` types for expected failures
+- Validate input early
+- Provide meaningful error messages
+
+## Common Patterns
+
+### Singleton
+```dart
+class ApiService {
+  static final ApiService _instance = ApiService._internal();
+  factory ApiService() => _instance;
+  ApiService._internal();
+}
+```
+
+### Factory Pattern
+```dart
+abstract class Shape {
+  factory Shape(String type) {
+    switch (type) {
+      case 'circle':
+        return Circle();
+      case 'square':
+        return Square();
+      default:
+        throw ArgumentError('Unknown shape: $type');
+    }
+  }
+}
+```
+
+### Repository Pattern
+```dart
+abstract class UserRepository {
+  Future<User> getUser(String id);
+  Future<void> saveUser(User user);
+}
+
+class ApiUserRepository implements UserRepository {
+  @override
+  Future<User> getUser(String id) async {
+    // Implementation
+  }
+}
+```
+
+## Tools & Commands
+```bash
+# Format code
+dart format .
+
+# Analyze code
+dart analyze
+
+# Run tests
+dart test
+
+# Pub commands
+dart pub get
+dart pub upgrade
+dart pub outdated
+```

package/dist/elixir/templates/lang-elixir.md

@@ -0,0 +1,147 @@
+# Elixir Development Guidelines
+
+## Language Overview
+Elixir is a functional, concurrent programming language built on the Erlang VM (BEAM). It's designed for building scalable, maintainable applications with excellent support for distributed systems.
+
+## Code Style & Conventions
+
+### Naming
+- **Modules**: PascalCase (`MyApp.UserController`)
+- **Functions/Variables**: snake_case (`create_user`, `user_id`)
+- **Atoms**: snake_case (`:ok`, `:error`, `:user_not_found`)
+- **Constants**: snake_case module attributes (`@default_timeout`)
+
+### Pattern Matching
+```elixir
+# Use pattern matching extensively
+def process({:ok, result}), do: result
+def process({:error, reason}), do: Logger.error(reason)
+
+# Guards for additional constraints
+def divide(a, b) when b != 0, do: {:ok, a / b}
+def divide(_, 0), do: {:error, :division_by_zero}
+```
+
+### Pipe Operator
+```elixir
+# Chain operations with |>
+user
+|> validate_user()
+|> create_record()
+|> send_welcome_email()
+```
+
+## OTP Patterns
+
+### GenServer
+```elixir
+defmodule MyApp.Worker do
+  use GenServer
+
+  def start_link(opts) do
+    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
+  end
+
+  def init(state) do
+    {:ok, state}
+  end
+
+  def handle_call({:get, key}, _from, state) do
+    {:reply, Map.get(state, key), state}
+  end
+end
+```
+
+### Supervision
+```elixir
+children = [
+  {MyApp.Repo, []},
+  {MyApp.Worker, []},
+  {Phoenix.PubSub, name: MyApp.PubSub}
+]
+
+Supervisor.start_link(children, strategy: :one_for_one)
+```
+
+## Phoenix Framework
+
+### Controllers
+```elixir
+defmodule MyAppWeb.UserController do
+  use MyAppWeb, :controller
+
+  def create(conn, %{"user" => user_params}) do
+    case Accounts.create_user(user_params) do
+      {:ok, user} ->
+        conn
+        |> put_status(:created)
+        |> render("show.json", user: user)
+
+      {:error, changeset} ->
+        conn
+        |> put_status(:unprocessable_entity)
+        |> render("error.json", changeset: changeset)
+    end
+  end
+end
+```
+
+### Contexts
+- Group related functionality in contexts
+- Keep controllers thin, business logic in contexts
+- Use Ecto changesets for validation
+
+## Ecto Database
+
+### Schemas
+```elixir
+defmodule MyApp.User do
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema "users" do
+    field :email, :string
+    field :name, :string
+    has_many :posts, MyApp.Post
+
+    timestamps()
+  end
+
+  def changeset(user, attrs) do
+    user
+    |> cast(attrs, [:email, :name])
+    |> validate_required([:email])
+    |> validate_format(:email, ~r/@/)
+    |> unique_constraint(:email)
+  end
+end
+```
+
+## Testing
+
+### ExUnit
+```elixir
+defmodule MyApp.UserTest do
+  use MyApp.DataCase
+
+  test "creates user with valid attrs" do
+    attrs = %{email: "test@example.com", name: "Test"}
+    assert {:ok, user} = Accounts.create_user(attrs)
+    assert user.email == "test@example.com"
+  end
+end
+```
+
+## Error Handling
+- Use tagged tuples: `{:ok, result}`, `{:error, reason}`
+- Pattern match on results
+- Use `with` for complex error handling
+- Leverage supervisor restart strategies
+
+## Best Practices
+- Keep functions pure when possible
+- Use immutable data structures
+- Leverage concurrency with Task and GenServer
+- Follow "let it crash" philosophy
+- Use telemetry for observability
+- Run `mix format` before committing

package/dist/go/index.cjs

@@ -1,5 +1,5 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("node:path"),g=require("../BasePlugin-odQJAKA-.cjs");function m(o){const e=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(o){for(const t in o)if(t!=="default"){const s=Object.getOwnPropertyDescriptor(o,t);Object.defineProperty(e,t,s.get?s:{enumerable:!0,get:()=>o[t]})}}return e.default=o,Object.freeze(e)}const u=m(c);class d extends g.BasePlugin{constructor(){super(...arguments),this.name="go",this.displayName="Go",this.version="3.0.0",this.priority=90}async detect(e){if(!this.fileExists(e,"go.mod"))return null;const t=this.readFile(e,"go.mod");if(!t)return{language:"Go",name:this.getProjectName(e),dependencies:{},manifestFile:"go.mod",projectPath:e};const s=t.match(/module\s+([^\s\n]+)/),r={},l=t.split(`
-`);let a=!1;for(const i of l){if(i.trim().startsWith("require (")){a=!0;continue}if(a){if(i.trim()===")")break;const n=i.match(/^\s*([^\s]+)\s+v([^\s]+)/);n&&(r[n[1]]=n[2])}else if(i.trim().startsWith("require ")){const n=i.match(/require\s+([^\s]+)\s+v([^\s]+)/);n&&(r[n[1]]=n[2])}}return{language:"Go",name:s?.[1]||this.getProjectName(e),dependencies:r,manifestFile:"go.mod",projectPath:e}}getTemplates(){return[{name:"go-core",tags:["go"],content:()=>this.loadTemplateFromFile(u.join(__dirname,"templates/lang-go.md")).then(e=>e||this.getGoFallbackTemplate())}]}getDependencyTagMap(){return{"github.com/gin-gonic/gin":"gin","github.com/gofiber/fiber":"fiber","github.com/labstack/echo":"echo","gorm.io/gorm":"gorm"}}getGoFallbackTemplate(){return`# Go Development Guidelines
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const m=require("node:path"),d=require("../BasePlugin-Be6rLq9o.cjs");var c=typeof document<"u"?document.currentScript:null;function u(s){const e=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(s){for(const t in s)if(t!=="default"){const n=Object.getOwnPropertyDescriptor(s,t);Object.defineProperty(e,t,n.get?n:{enumerable:!0,get:()=>s[t]})}}return e.default=s,Object.freeze(e)}const f=u(m);class p extends d.BasePlugin{constructor(){super(...arguments),this.name="go",this.displayName="Go",this.version="3.0.0",this.priority=90}async detect(e){if(!this.fileExists(e,"go.mod"))return null;const t=this.readFile(e,"go.mod");if(!t){const i=await this.enrichTags(e,{});return{language:"Go",name:this.getProjectName(e),dependencies:{},manifestFile:"go.mod",projectPath:e,tags:Array.from(i)}}const n=t.match(/module\s+([^\s\n]+)/),o={},a=t.split(`
+`);let g=!1;for(const i of a){if(i.trim().startsWith("require (")){g=!0;continue}if(g){if(i.trim()===")")break;const r=i.match(/^\s*([^\s]+)\s+v([^\s]+)/);r&&(o[r[1]]=r[2])}else if(i.trim().startsWith("require ")){const r=i.match(/require\s+([^\s]+)\s+v([^\s]+)/);r&&(o[r[1]]=r[2])}}const l=await this.enrichTags(e,o);return{language:"Go",name:n?.[1]||this.getProjectName(e),dependencies:o,manifestFile:"go.mod",projectPath:e,tags:Array.from(l)}}async enrichTags(e,t){const n=new Set(["go"]),o=this.getDependencyTagMap();for(const a in t)o[a]&&n.add(o[a]);return n}getTemplates(){const e=this.getDirname(typeof document>"u"?require("url").pathToFileURL(__filename).href:c&&c.tagName.toUpperCase()==="SCRIPT"&&c.src||new URL("go/index.cjs",document.baseURI).href);return[{name:"go-core",tags:["go"],content:()=>this.loadTemplateFromFile(f.join(e,"templates/lang-go.md")).then(t=>t||this.getGoFallbackTemplate())}]}getDependencyTagMap(){return{"github.com/gin-gonic/gin":"gin","github.com/gofiber/fiber":"fiber","github.com/labstack/echo":"echo","gorm.io/gorm":"gorm"}}getGoFallbackTemplate(){return`# Go Development Guidelines
 
 This project uses Go.
 
@@ -26,4 +26,4 @@ This project uses Go.
 ## Dependencies
 - Use Go modules (\`go.mod\`)
 - Keep dependencies minimal
-- Review dependency licenses`}}exports.GoPlugin=d;
+- Review dependency licenses`}}exports.GoPlugin=p;

package/dist/go/index.mjs

@@ -1,54 +1,69 @@
 import * as m from "node:path";
-import { B as g } from "../BasePlugin-6wv0hYJ9.js";
-class d extends g {
+import { B as c } from "../BasePlugin-BXz3Zpy5.js";
+class u extends c {
   constructor() {
     super(...arguments), this.name = "go", this.displayName = "Go", this.version = "3.0.0", this.priority = 90;
   }
   async detect(e) {
     if (!this.fileExists(e, "go.mod"))
       return null;
-    const i = this.readFile(e, "go.mod");
-    if (!i)
+    const t = this.readFile(e, "go.mod");
+    if (!t) {
+      const i = await this.enrichTags(e, {});
       return {
         language: "Go",
         name: this.getProjectName(e),
         dependencies: {},
         manifestFile: "go.mod",
-        projectPath: e
+        projectPath: e,
+        tags: Array.from(i)
       };
-    const r = i.match(/module\s+([^\s\n]+)/), n = {}, a = i.split(`
+    }
+    const o = t.match(/module\s+([^\s\n]+)/), s = {}, r = t.split(`
 `);
-    let s = !1;
-    for (const o of a) {
-      if (o.trim().startsWith("require (")) {
-        s = !0;
+    let a = !1;
+    for (const i of r) {
+      if (i.trim().startsWith("require (")) {
+        a = !0;
         continue;
       }
-      if (s) {
-        if (o.trim() === ")") break;
-        const t = o.match(/^\s*([^\s]+)\s+v([^\s]+)/);
-        t && (n[t[1]] = t[2]);
-      } else if (o.trim().startsWith("require ")) {
-        const t = o.match(/require\s+([^\s]+)\s+v([^\s]+)/);
-        t && (n[t[1]] = t[2]);
+      if (a) {
+        if (i.trim() === ")") break;
+        const n = i.match(/^\s*([^\s]+)\s+v([^\s]+)/);
+        n && (s[n[1]] = n[2]);
+      } else if (i.trim().startsWith("require ")) {
+        const n = i.match(/require\s+([^\s]+)\s+v([^\s]+)/);
+        n && (s[n[1]] = n[2]);
       }
     }
+    const g = await this.enrichTags(e, s);
     return {
       language: "Go",
-      name: r?.[1] || this.getProjectName(e),
-      dependencies: n,
+      name: o?.[1] || this.getProjectName(e),
+      dependencies: s,
       manifestFile: "go.mod",
-      projectPath: e
+      projectPath: e,
+      tags: Array.from(g)
     };
   }
+  /**
+   * Enrich tags from dependencies
+   */
+  async enrichTags(e, t) {
+    const o = /* @__PURE__ */ new Set(["go"]), s = this.getDependencyTagMap();
+    for (const r in t)
+      s[r] && o.add(s[r]);
+    return o;
+  }
   getTemplates() {
+    const e = this.getDirname(import.meta.url);
     return [
       {
         name: "go-core",
         tags: ["go"],
         content: () => this.loadTemplateFromFile(
-          m.join(__dirname, "templates/lang-go.md")
-        ).then((e) => e || this.getGoFallbackTemplate())
+          m.join(e, "templates/lang-go.md")
+        ).then((t) => t || this.getGoFallbackTemplate())
       }
     ];
   }
@@ -92,5 +107,5 @@ This project uses Go.
   }
 }
 export {
-  d as GoPlugin
+  u as GoPlugin
 };

package/dist/index.cjs

@@ -1 +1,147 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./BasePlugin-odQJAKA-.cjs"),n=require("./nodejs/index.cjs"),e=require("./go/index.cjs"),u=require("./python/index.cjs"),r=require("./rust/index.cjs"),P=require("./java/index.cjs"),g=require("./ruby/index.cjs"),l=require("./php/index.cjs"),t=require("./csharp/index.cjs"),o=require("./cpp/index.cjs"),s=require("./swift/index.cjs");exports.BasePlugin=i.BasePlugin;exports.NodeJSPlugin=n.NodeJSPlugin;exports.GoPlugin=e.GoPlugin;exports.PythonPlugin=u.PythonPlugin;exports.RustPlugin=r.RustPlugin;exports.JavaPlugin=P.JavaPlugin;exports.RubyPlugin=g.RubyPlugin;exports.PHPPlugin=l.PHPPlugin;exports.CSharpPlugin=t.CSharpPlugin;exports.CppPlugin=o.CppPlugin;exports.SwiftPlugin=s.SwiftPlugin;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=require("./BasePlugin-Be6rLq9o.cjs"),d=require("./nodejs/index.cjs"),m=require("./go/index.cjs"),p=require("./python/index.cjs"),g=require("./rust/index.cjs"),f=require("./java/index.cjs"),h=require("./ruby/index.cjs"),y=require("./php/index.cjs"),b=require("./csharp/index.cjs"),x=require("./cpp/index.cjs"),F=require("./swift/index.cjs"),P=require("node:path");var i=typeof document<"u"?document.currentScript:null;function v(a){const e=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(a){for(const t in a)if(t!=="default"){const n=Object.getOwnPropertyDescriptor(a,t);Object.defineProperty(e,t,n.get?n:{enumerable:!0,get:()=>a[t]})}}return e.default=a,Object.freeze(e)}const o=v(P);class T extends c.BasePlugin{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"),n=["elixir"],s={};if(t){const l=t.match(/app:\s*:(\w+)/),r=t.match(/version:\s*"([^"]+)"/);return t.includes(":phoenix")&&(n.push("phoenix"),s.phoenix="*"),t.includes(":ecto")&&(n.push("ecto"),s.ecto="*"),{language:"Elixir",name:l?.[1]||this.getProjectName(e),version:r?.[1]||"0.1.0",dependencies:s,manifestFile:"mix.exs",projectPath:e,tags:n}}return{language:"Elixir",name:this.getProjectName(e),dependencies:{},manifestFile:"mix.exs",projectPath:e,tags:n}}getTemplates(){const e=this.getDirname(typeof document>"u"?require("url").pathToFileURL(__filename).href:i&&i.tagName.toUpperCase()==="SCRIPT"&&i.src||new URL("index.cjs",document.baseURI).href);return[{name:"elixir-core",tags:["elixir"],content:()=>this.loadTemplateFromFile(o.join(e,"templates/lang-elixir.md")).then(t=>t||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 U extends c.BasePlugin{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"),n=["dart"],s={};if(t){const l=t.match(/name:\s*(.+)/),r=t.match(/version:\s*(.+)/);return(t.includes("flutter:")||t.includes("flutter_test:"))&&(n.push("flutter"),s.flutter="*"),(t.includes("flutter_riverpod:")||t.includes("riverpod:"))&&n.push("riverpod"),(t.includes("flutter_bloc:")||t.includes("bloc:"))&&n.push("bloc"),{language:"Dart",name:l?.[1]?.trim()||this.getProjectName(e),version:r?.[1]?.trim()||"1.0.0",dependencies:s,manifestFile:"pubspec.yaml",projectPath:e,tags:n}}return{language:"Dart",name:this.getProjectName(e),dependencies:{},manifestFile:"pubspec.yaml",projectPath:e,tags:n}}getTemplates(){const e=this.getDirname(typeof document>"u"?require("url").pathToFileURL(__filename).href:i&&i.tagName.toUpperCase()==="SCRIPT"&&i.src||new URL("index.cjs",document.baseURI).href);return[{name:"dart-core",tags:["dart"],content:()=>this.loadTemplateFromFile(o.join(e,"templates/lang-dart.md")).then(t=>t||this.getDartFallbackTemplate())},{name:"flutter-core",tags:["flutter"],content:()=>this.loadTemplateFromFile(o.join(e,"templates/flutter.md")).then(t=>t||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 k extends c.BasePlugin{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(){const e=this.getDirname(typeof document>"u"?require("url").pathToFileURL(__filename).href:i&&i.tagName.toUpperCase()==="SCRIPT"&&i.src||new URL("index.cjs",document.baseURI).href);return[{name:"scala-core",tags:["scala"],content:()=>this.loadTemplateFromFile(o.join(e,"templates/lang-scala.md")).then(t=>t||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"),n=["scala"],s={};if(t){const l=t.match(/name\s*:=\s*"([^"]+)"/);return(t.includes("akka-actor")||t.includes("com.typesafe.akka"))&&(n.push("akka"),s.akka="*"),(t.includes("play")||t.includes("com.typesafe.play"))&&(n.push("play"),s.play="*"),t.includes("zio")&&n.push("zio"),(t.includes("cats-effect")||t.includes("cats-core"))&&n.push("cats"),{language:"Scala",name:l?.[1]||this.getProjectName(e),dependencies:s,manifestFile:"build.sbt",projectPath:e,tags:n}}return{language:"Scala",name:this.getProjectName(e),dependencies:{},manifestFile:"build.sbt",projectPath:e,tags:n}}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 R extends c.BasePlugin{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 n=this.readFile(e,"build.gradle.kts"),s=["kotlin"],l={};return n&&(n.includes("ktor")&&(s.push("ktor"),l.ktor="*"),n.includes("spring-boot")&&(s.push("spring-boot"),l["spring-boot"]="*"),n.includes("exposed")&&s.push("exposed"),n.includes("kotlinx-coroutines")&&s.push("coroutines")),{language:"Kotlin",name:this.getProjectName(e),dependencies:l,manifestFile:"build.gradle.kts",projectPath:e,tags:s}}getTemplates(){const e=this.getDirname(typeof document>"u"?require("url").pathToFileURL(__filename).href:i&&i.tagName.toUpperCase()==="SCRIPT"&&i.src||new URL("index.cjs",document.baseURI).href);return[{name:"kotlin-core",tags:["kotlin"],content:()=>this.loadTemplateFromFile(o.join(e,"templates/lang-kotlin.md")).then(t=>t||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 S extends c.BasePlugin{constructor(){super(...arguments),this.name="lua",this.displayName="Lua",this.version="1.0.0",this.priority=75}async detect(e){const n=this.listFiles(e)?.find(s=>s.endsWith(".rockspec"));if(n||this.fileExists(e,"lua_modules")){const s=["lua"];return{language:"Lua",name:this.getProjectName(e),dependencies:{},manifestFile:n||"lua_modules",projectPath:e,tags:s}}return null}getTemplates(){const e=this.getDirname(typeof document>"u"?require("url").pathToFileURL(__filename).href:i&&i.tagName.toUpperCase()==="SCRIPT"&&i.src||new URL("index.cjs",document.baseURI).href);return[{name:"lua-core",tags:["lua"],content:()=>this.loadTemplateFromFile(o.join(e,"templates/lang-lua.md")).then(t=>t||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 D extends c.BasePlugin{constructor(){super(...arguments),this.name="r",this.displayName="R",this.version="1.0.0",this.priority=75}async detect(e){const n=this.listFiles(e)?.some(s=>s.endsWith(".Rproj"));if(this.fileExists(e,"DESCRIPTION")||n){const s=["r"],l={},r=this.readFile(e,"DESCRIPTION");if(r){const u=r.match(/Package:\s*(.+)/);return(r.includes("tidyverse")||r.includes("dplyr"))&&s.push("tidyverse"),r.includes("shiny")&&(s.push("shiny"),l.shiny="*"),{language:"R",name:u?.[1]?.trim()||this.getProjectName(e),dependencies:l,manifestFile:"DESCRIPTION",projectPath:e,tags:s}}return{language:"R",name:this.getProjectName(e),dependencies:{},manifestFile:n?".Rproj":"DESCRIPTION",projectPath:e,tags:s}}return null}getTemplates(){const e=this.getDirname(typeof document>"u"?require("url").pathToFileURL(__filename).href:i&&i.tagName.toUpperCase()==="SCRIPT"&&i.src||new URL("index.cjs",document.baseURI).href);return[{name:"r-core",tags:["r"],content:()=>this.loadTemplateFromFile(o.join(e,"templates/lang-r.md")).then(t=>t||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 L extends c.BasePlugin{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(){const e=this.getDirname(typeof document>"u"?require("url").pathToFileURL(__filename).href:i&&i.tagName.toUpperCase()==="SCRIPT"&&i.src||new URL("index.cjs",document.baseURI).href);return[{name:"perl-core",tags:["perl"],content:()=>this.loadTemplateFromFile(o.join(e,"templates/lang-perl.md")).then(t=>t||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 C extends c.BasePlugin{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(r=>r.endsWith(".sh")||r.endsWith(".bash")||r.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(){const e=this.getDirname(typeof document>"u"?require("url").pathToFileURL(__filename).href:i&&i.tagName.toUpperCase()==="SCRIPT"&&i.src||new URL("index.cjs",document.baseURI).href);return[{name:"shell-core",tags:["shell"],content:()=>this.loadTemplateFromFile(o.join(e,"templates/lang-shell.md")).then(t=>t||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
+`}}exports.BasePlugin=c.BasePlugin;exports.NodeJSPlugin=d.NodeJSPlugin;exports.GoPlugin=m.GoPlugin;exports.PythonPlugin=p.PythonPlugin;exports.RustPlugin=g.RustPlugin;exports.JavaPlugin=f.JavaPlugin;exports.RubyPlugin=h.RubyPlugin;exports.PHPPlugin=y.PHPPlugin;exports.CSharpPlugin=b.CSharpPlugin;exports.CppPlugin=x.CppPlugin;exports.SwiftPlugin=F.SwiftPlugin;exports.DartPlugin=U;exports.ElixirPlugin=T;exports.KotlinPlugin=R;exports.LuaPlugin=S;exports.PerlPlugin=L;exports.RPlugin=D;exports.ScalaPlugin=k;exports.ShellPlugin=C;