@kenkaiiii/ggcoder 5.74.3 → 5.75.0

package/dist/core/style-packs/packs.js

@@ -1,229 +1,188 @@
 /**
  * Per-language style packs injected into the system prompt when the detector
- * sees the language is active in the project.
- *
- * Design principles (apply to every pack):
- *   1. Apply the strictest reasonable subset of *idiomatic* style — nothing
- *      exotic the model has to think about. The agent already knows these
- *      patterns; the pack just narrows the choice space.
- *   2. Optimize for low ambiguity, not for human readability. Bullet form.
- *   3. Errors as values, schema at boundaries, mechanical formatting,
- *      one canonical way to do common tasks.
- *   4. ~30-50 lines per pack. Anything longer is bloat in the system prompt.
- *   5. Avoid triple backticks (template literal conflict). Use single
- *      backticks for inline tokens, escape with \\\` when needed.
+ * sees the language is active. Keep each pack ≤ ~350 chars: tooling default,
+ * the most bug-preventing rules, and what to avoid. No rationale or examples.
+ * Avoid triple backticks (template literal conflict).
  */
 export const PACKS = {
     typescript: `### TypeScript
 
-- **Tooling.** \`tsc --strict\` always. Enable \`noUncheckedIndexedAccess\`, \`exactOptionalPropertyTypes\`, \`noImplicitOverride\`. **Biome** (single Rust binary — format + lint) as the default for new projects; fall back to Prettier + \`@typescript-eslint/strict-type-checked\` only when Biome's rule coverage is insufficient. Don't run both in one project.
-- **Types.** Explicit return types on every exported function and async function. Inference is fine inside function bodies. Never use \`any\`. Prefer \`satisfies\` over \`as\` for narrowing literal-typed values; reserve \`as\` for genuinely unavoidable casts (and \`as const\`). Never use the non-null \`!\` operator. Branded types (\`type UserId = string & { __brand: "UserId" }\`) for domain primitives. Ban the \`Function\` type and \`Object\` type.
-- **Data.** Validate every external boundary (HTTP, env, file, IPC) with Zod or Valibot. Never trust untyped JSON. Discriminated unions over class hierarchies. \`Readonly<T>\` for immutable shapes.
-- **Errors.** Zero-dep discriminated-union returns for expected failures: \`type Result<T, E> = { ok: true; value: T } | { ok: false; error: E }\`. Type-narrowable, no runtime dependency, model-friendly. Reserve \`throw\` for truly unrecoverable bugs (impossible states, assertion failures). Never throw for control flow.
-- **Modules.** Named exports only — no \`export default\`. One concept per file. No barrel files (\`index.ts\` re-exports). Feature folders (\`users/\`), not layer folders (\`controllers/services/repos/\`).
-- **Async.** \`async/await\` only — no \`.then\` chains. Always await or explicitly return promises. No floating promises. Pass \`AbortSignal\` through every async function that does I/O or long work; respect it.
-- **Avoid.** \`enum\` (use \`as const\` objects + \`typeof\` unions). Class inheritance beyond one level. \`namespace\`. Decorators outside framework-required slots. Conditional/mapped types in app code (keep in \`types.ts\` if unavoidable).`,
+- \`tsc --strict\` + \`noUncheckedIndexedAccess\`; Biome for format/lint.
+- No \`any\`, no non-null \`!\`; prefer \`satisfies\` over \`as\`.
+- Validate external input with a schema lib.
+- Result-style returns for expected failures; throw only for bugs.
+- Named exports only; no floating promises; pass \`AbortSignal\` to I/O.
+- Avoid \`enum\`, \`namespace\`, deep inheritance.`,
     javascript: `### JavaScript
 
-- **Tooling.** ESM only (\`"type": "module"\`). **Biome** (single Rust binary — format + lint) as the default for new projects; or Prettier + ESLint with \`eslint:recommended\` and \`eslint-plugin-import\`. Don't run both in one project. If types matter at all, use TypeScript instead of JSDoc.
-- **Types.** If you must stay on JS, annotate exported functions with JSDoc \`@param\`/\`@returns\` so the LSP can infer. Otherwise treat the project as untyped and validate aggressively at boundaries.
-- **Data.** Validate every external boundary with Zod. Use plain objects + factory functions, not classes, for data shapes. \`Object.freeze\` for constants.
-- **Errors.** Return \`{ ok: true, value } | { ok: false, error }\` discriminated objects for expected failures. \`throw\` only for unrecoverable bugs. Always handle promise rejections.
-- **Modules.** Named exports only. One concept per file. Use feature folders. No CommonJS \`require\` in new code.
-- **Async.** \`async/await\` exclusively. \`Promise.all\` for parallel work; never sequential awaits in a loop unless ordering is required.
-- **Avoid.** \`var\`. Implicit globals. \`==\` (use \`===\`). Prototype mutation. \`with\`. \`eval\`. \`arguments\` (use rest params).`,
+- ESM; \`const\`, \`===\`, no \`var\`; JSDoc + \`// @ts-check\`.
+- Validate external input with a schema lib; no floating promises.
+- Avoid default exports, prototype mutation, implicit globals.`,
     python: `### Python
 
-- **Tooling.** Python 3.12+. Ruff (lint + format) and Pyright in strict mode. \`pyproject.toml\` is the single config file — no \`setup.py\`, \`setup.cfg\`, or \`requirements.txt\` in new projects. Use \`uv\` for env/dep management.
-- **Types.** Annotate every parameter, return, and class field. Use built-in generics: \`list[str]\`, \`dict[str, int]\`, \`X | None\` (not \`Optional\`). Never bare \`Any\`. \`TypedDict\` for dict shapes only at API boundaries; prefer dataclasses or Pydantic models for everything else.
-- **Data.** Internal value objects: \`@dataclass(slots=True, frozen=True)\`. External boundaries (HTTP, files, env, IPC): Pydantic v2 \`BaseModel\` with \`model_config = ConfigDict(strict=True, frozen=True)\`. Pydantic guards the boundary; type checker guards the interior.
-- **Errors.** Raise specific custom exceptions for unrecoverable bugs. For expected failures, return \`tuple[T, None] | tuple[None, ErrorType]\` or a small \`Result\` dataclass. Never use bare \`except:\` — always catch a specific class.
-- **Structure.** One concept per module. \`src/\` layout. No top-level mutable state. \`__init__.py\` re-exports only public API. Feature folders.
-- **Idioms.** \`match\` statements over \`isinstance\` chains. Discriminated unions via \`Literal\` tag fields. Comprehensions over \`map\`/\`filter\`. \`pathlib.Path\`, never raw string paths.
-- **Avoid.** Decorators that mutate (use \`@dataclass\`, \`@property\`, \`@staticmethod\`, framework-required only). \`*args\`/\`**kwargs\` except at adapter edges. Mutable default arguments. \`from x import *\`. Circular imports — refactor into a smaller module.`,
+- Python 3.11+; ruff (lint + format); pyright/mypy strict.
+- Type hints on every public function; no bare \`Any\`.
+- Validate external input with Pydantic or dataclasses + checks.
+- Raise specific exceptions; never bare \`except:\`.
+- \`pathlib\` over \`os.path\`; context managers for resources.
+- Avoid mutable default args, star imports, global state.`,
     go: `### Go
 
-- **Tooling.** \`gofmt\` non-negotiable. \`go vet\` + \`staticcheck\` in CI. \`golangci-lint\` with a conservative preset. Latest stable Go.
-- **Errors.** \`if err != nil { return fmt.Errorf("doing X: %w", err) }\` — wrap with context at every layer. Define sentinel errors as \`var ErrXxx = errors.New("xxx")\` at package level. Use \`errors.Is\`/\`errors.As\` for matching. Never \`panic\` outside \`init\` or truly impossible states.
-- **Types.** Small interfaces defined at the consumer, not the producer (\`io.Reader\`-style, 1-3 methods). Accept interfaces, return structs. No empty interface \`any\` except at adapter boundaries.
-- **Concurrency.** \`context.Context\` is the first parameter on every I/O or long-running function — always propagate, never \`context.Background()\` deep in a call chain. Goroutines launched only with clear lifecycle ownership (\`errgroup\`, \`sync.WaitGroup\`, or paired \`done\` channel).
-- **Logging.** \`log/slog\` (stdlib, Go 1.21+) for structured logging — never \`log\`, \`fmt.Println\`, or third-party loggers in new code. Pass a \`*slog.Logger\` via context or as a struct field on services. Use \`slog.With(...)\` to attach request-scoped attrs.
-- **Structure.** Flat package layout by feature (\`user/\`, \`order/\`), not by layer. \`cmd/<binary>/main.go\` for executables. \`internal/\` for packages not meant to be imported externally. No \`utils\` or \`common\` packages.
-- **Generics.** Use only when they remove real duplication. Concrete types are the default.
-- **Avoid.** \`init()\` functions with side effects. Global mutable state. Returning bare \`error\` without wrapping context. Naked returns in functions longer than 5 lines. \`interface{}\` in new code.`,
+- \`gofmt\`, \`go vet\`, \`golangci-lint\`.
+- Always check errors; wrap with \`fmt.Errorf("...: %w", err)\`.
+- \`context.Context\` first param for I/O; respect cancellation.
+- Small interfaces defined at the consumer; return structs.
+- Every goroutine has a clear owner and exit path.
+- Avoid \`panic\` for expected errors, \`init()\` side effects, globals.`,
     rust: `### Rust
 
-- **Tooling.** \`rustfmt\` + \`clippy\` with at minimum \`-W clippy::pedantic\`. Stable channel unless you have a specific reason. \`cargo test\` + \`cargo doc\` in CI.
-- **Errors.** Libraries: define typed error enums with \`thiserror\` so callers can match specific variants. Binaries / application code: use \`anyhow::Result\` + \`.context("doing X")\`. Use the \`?\` operator everywhere; reserve \`match\` for cases that need transformation. Never \`unwrap()\` outside tests, examples, or proven-impossible states (add \`// SAFETY:\` comment when truly unavoidable).
-- **Types.** Prefer concrete types and \`impl Trait\` returns over \`dyn Trait\` + generics towers. Newtype wrappers (\`struct UserId(Uuid)\`) over raw primitives for domain types. Lifetimes named meaningfully (\`'src\`, \`'arena\`), not \`'a\`, \`'b\`.
-- **Modules.** One concept per file. \`mod.rs\` only re-exports. Feature folders. \`pub(crate)\` by default; \`pub\` only for genuine library API.
-- **Async.** \`tokio\` is the default runtime. \`async fn\` in traits via \`async-trait\` only when stable async-fn-in-trait won't work. Avoid mixing runtimes.
-- **Unsafe.** Forbidden in app code without an explicit \`// SAFETY:\` comment explaining the invariant. Encapsulate in a safe wrapper module.
-- **Avoid.** Macro-heavy crates in app logic. Custom \`macro_rules!\` unless it removes >5 real call sites. Trait towers. \`Box<dyn Error>\` (use \`anyhow::Error\`). String-typed APIs where an enum would do.`,
+- \`rustfmt\` + \`clippy -D warnings\`.
+- \`Result\` for fallible ops; \`thiserror\` in libs, \`anyhow\` in bins.
+- No \`unwrap\`/\`expect\` outside tests or proven invariants.
+- Newtypes for domain primitives; borrow over clone.
+- \`unsafe\` only with a \`// SAFETY:\` comment.
+- Avoid \`Rc<RefCell>\` webs and needless \`Box<dyn>\`.`,
     java: `### Java
 
-- **Tooling.** Java 21+ (LTS). \`google-java-format\` or \`spotless\`. Error Prone + Checker Framework or NullAway in CI. Maven or Gradle Kotlin DSL — pick one per repo and stick.
-- **Types.** Use \`record\` for all immutable data carriers. \`sealed interface\` + permits for sum types; pattern-match in \`switch\`. \`Optional<T>\` for return types only — never as a field or parameter.
-- **Errors.** Custom unchecked exceptions extending \`RuntimeException\` for business errors. Wrap checked exceptions at adapter boundaries — don't propagate \`IOException\` through service layers. Use sealed \`Result<T, E>\` types for cases where the caller must handle both branches.
-- **Nullability.** \`@Nullable\`/\`@NonNull\` (JSpecify) on every API boundary. Treat unannotated as non-null. NullAway in CI.
-- **Structure.** Package by feature. Constructor injection only — no field injection, no setter injection. No static mutable state. \`final\` by default on classes and fields.
-- **Avoid.** Reflection in business code (frameworks may need it). Lombok in new code (records cover 95% of cases). AOP / proxy magic. Checked exceptions on new APIs. Inheritance beyond one level.`,
+- Java 21+; Spotless/google-java-format; Error Prone.
+- Records for data; sealed interfaces for variants.
+- \`Optional\` for absent returns; never return \`null\` collections.
+- Validate input at boundaries; immutable by default (\`final\`).
+- try-with-resources for closeables.
+- Avoid checked-exception swallowing, field injection, deep inheritance.`,
     kotlin: `### Kotlin
 
-- **Tooling.** Kotlin 2.0+. \`ktlint\` + \`detekt\`. Strict explicit API mode in libraries.
-- **Types.** \`data class\` for value objects. \`sealed class\` / \`sealed interface\` for sum types — exhaustive \`when\` over \`if\`. Inline \`value class\` for domain primitives. Avoid \`Any\` and platform types.
-- **Nullability.** Use the type system — never \`!!\`. Prefer \`?.let\`, \`requireNotNull\`, or explicit \`if\` checks. Treat all Java interop returns as nullable.
-- **Errors.** \`Result<T>\` or a custom sealed \`Either\`-like type for expected failures. Reserve exceptions for bugs. \`runCatching\` only at adapter edges.
-- **Coroutines.** Structured concurrency via \`coroutineScope\` / \`supervisorScope\`. Never \`GlobalScope\`. \`Dispatchers.IO\` for blocking work, \`Default\` for CPU. Always pass a \`CoroutineContext\` or scope into suspend functions that launch children.
-- **Structure.** Package by feature. One top-level public declaration per file (extension functions excepted). Use \`internal\` visibility liberally.
-- **Avoid.** Companion-object factories when a top-level function works. Nested classes for grouping (use packages). Reflection. Overusing operator overloading.`,
+- ktlint/detekt; explicit API mode for libraries.
+- \`val\` over \`var\`; data/sealed classes for state.
+- No \`!!\`; handle nullability explicitly.
+- Structured concurrency: no \`GlobalScope\`; pass scopes.
+- Sealed Result types for expected failures.
+- Avoid \`lateinit\` abuse and platform-type leaks.`,
     csharp: `### C#
 
-- **Tooling.** C# 12+ on .NET 8+. \`<Nullable>enable</Nullable>\` and \`<TreatWarningsAsErrors>true</TreatWarningsAsErrors>\` project-wide. \`dotnet format\`. Roslyn analyzers + StyleCop.
-- **Types.** \`record\` (positional or with-init) for DTOs and value objects. \`required\` properties over multi-arg constructors. File-scoped namespaces. One public type per file.
-- **Nullability.** NRTs on, no \`!\` operator except for proven-non-null cases with a comment. \`is null\` / \`is not null\` over \`==\`.
-- **Errors.** Custom exceptions for unrecoverable. \`Result<T, E>\` (e.g. via \`OneOf\`, \`ErrorOr\`, or a small custom type) for expected failures across service boundaries. Never use exceptions for control flow.
-- **Async.** \`async Task<Result<T>>\` everywhere. No \`async void\` except event handlers. Always pass \`CancellationToken\` through I/O calls. Avoid \`.Result\`, \`.Wait()\`, and \`.GetAwaiter().GetResult()\` — they deadlock.
-- **LINQ.** Keep chains shallow (≤ 3 operators). Pull complex queries into named methods or local functions.
-- **Avoid.** Reflection in hot paths. Static mutable state. Source generators in app code (libraries only). Multi-level inheritance. Manual \`IDisposable\` when \`using\` works.`,
+- \`<Nullable>enable</Nullable>\`, warnings as errors; \`dotnet format\`.
+- Records for data; \`required\`/\`init\` properties.
+- \`async\` all the way; pass \`CancellationToken\`; no \`.Result\`/\`.Wait()\`.
+- Validate input at boundaries; \`using\` for disposables.
+- Avoid \`async void\`, static mutable state, catching \`Exception\` broadly.`,
     cpp: `### C++
 
-- **Tooling.** C++20 minimum, C++23 when toolchain allows. \`clang-format\` + \`clang-tidy\` with \`cppcoreguidelines-*\` and \`modernize-*\` checks. AddressSanitizer + UBSan in test builds. CMake with presets.
-- **Resources.** RAII universal. \`std::unique_ptr\` by default, \`std::shared_ptr\` only when ownership is genuinely shared. Never raw owning pointers. Never \`new\`/\`delete\` in app code.
-- **Types.** \`std::string_view\` and \`std::span\` for non-owning views. \`std::optional<T>\` for nullable returns. \`auto\` for obvious types, explicit for API surfaces.
-- **Errors.** \`std::expected<T, E>\` (C++23) — or \`tl::expected\` if stuck on older toolchain — for expected failures. \`throw\` only for genuinely exceptional cases (allocation failure, programmer errors). Exception specifications via \`noexcept\` on functions that must not throw.
-- **Generics.** Concepts (C++20), never SFINAE. \`std::ranges\` over raw iterator pairs.
-- **Headers/modules.** C++20 modules when supported; otherwise include guards via \`#pragma once\`. No transitive includes — each file includes what it uses.
-- **Avoid.** C-style casts (use \`static_cast\` / \`reinterpret_cast\`). Raw arrays in new code (use \`std::array\` or \`std::vector\`). Macros for anything other than include guards or platform conditionals. Template metaprogramming beyond \`if constexpr\` + concepts. Multiple inheritance of non-interface classes.`,
+- C++20; clang-format + clang-tidy; \`-Wall -Wextra -Werror\`.
+- RAII everywhere; \`unique_ptr\` by default, no raw \`new\`/\`delete\`.
+- \`std::span\`/\`string_view\` for non-owning views; \`const\` by default.
+- \`std::expected\`/optional for expected failures.
+- Avoid macros, C casts, owning raw pointers, UB-prone indexing.`,
     c: `### C
 
-- **Tooling.** C11 or C17. \`clang-format\` + \`clang-tidy\`. \`-Wall -Wextra -Wpedantic -Werror\` always. AddressSanitizer + UBSan in test builds. Run a fuzzer on parsers.
-- **Memory.** Pair every \`malloc\` with a clear owner and a single \`free\` site. Prefer arena/region allocators for groups of related allocations. Zero-initialize structs. Never trust \`strlen\` on untrusted input — track lengths explicitly.
-- **Types.** \`stdint.h\` integer types (\`int32_t\`, \`size_t\`, \`uintptr_t\`) — never bare \`int\`/\`long\` for sizes or counts. \`bool\` from \`stdbool.h\`. Use \`enum\` for tagged unions; carry a tag field.
-- **Errors.** Return \`int\` status codes or a small enum; pass results back via out-pointers. Always check return values. Define \`Result_T\` structs for richer cases. Never use \`errno\` across thread boundaries without copying.
-- **Structure.** One concept per \`.c\` + \`.h\` pair. Header declares public API only; static functions are file-local. No global mutable state (use opaque handles).
-- **Strings.** Length-prefixed slices or explicit \`(ptr, len)\` pairs over null-terminated wherever possible. \`snprintf\` with explicit buffer sizes — never \`sprintf\`, \`strcpy\`, \`gets\`.
-- **Avoid.** Macros beyond \`#include\` guards, platform conditionals, and named constants. Variable-length arrays. Implicit int. \`goto\` except for unified cleanup paths.`,
+- C17; \`-Wall -Wextra -Werror\`; ASan/UBSan in tests.
+- Check every return value and allocation.
+- Pass buffer lengths explicitly; use bounded functions (\`snprintf\`).
+- Single cleanup path (\`goto cleanup\`) per function.
+- Avoid \`gets\`/\`strcpy\`/\`sprintf\`, globals, unchecked casts.`,
     ruby: `### Ruby
 
-- **Tooling.** Ruby 3.3+. \`standardrb\` or \`rubocop\` (strict preset). \`sorbet\` with \`# typed: strict\` on every file in new projects. RSpec for tests.
-- **Types.** \`T::Struct\` (Sorbet) for value objects. \`T.nilable\`, \`T::Array[X]\`, etc. on every method signature. RBS files alongside libraries.
-- **Errors.** Custom exception classes per domain, inheriting a single base \`AppError\`. \`raise\` for unrecoverable; for expected failures return \`Success(value)\` / \`Failure(err)\` via \`dry-monads\` or a small custom Result type.
-- **Structure.** Files match class names. Modules by feature. \`Zeitwerk\` autoloading. Frozen string literals magic comment at the top of every file.
-- **Idioms.** \`Data.define\` (Ruby 3.2+) for immutable value objects when not using Sorbet. Keyword arguments over positional past 2 args. Guard clauses over nested \`if\`. \`tap\` for side effects on a chain.
-- **Avoid.** \`method_missing\` and \`respond_to_missing?\` in new code. Monkey-patching core classes. \`define_method\` at runtime. \`eval\` family. Heavy DSLs outside the few canonical cases (Rails routes, RSpec, etc. — isolate them).`,
+- Ruby 3.2+; RuboCop/Standard; \`# frozen_string_literal: true\`.
+- Validate input at boundaries; explicit keyword arguments.
+- Raise specific error classes; never rescue \`Exception\`.
+- Small objects over concerns/mixins.
+- Avoid monkey-patching, \`method_missing\`, global state.`,
     php: `### PHP
 
-- **Tooling.** PHP 8.3+. PHPStan or Psalm at max level. \`php-cs-fixer\` or \`pint\`. Composer with strict autoload.
-- **Types.** \`declare(strict_types=1);\` at the top of every file. Type every parameter, return, and property. \`readonly\` classes and properties everywhere possible. Enums (backed) for closed sets — never string constants.
-- **Data.** Constructor property promotion for DTOs: \`public function __construct(public readonly string $name, public readonly int $age) {}\`. Final classes by default.
-- **Errors.** Typed custom exceptions per domain. For expected failures, return a small \`Result\` value object or use a discriminated union of result classes. Never catch \`\\\\Throwable\` except at the request boundary.
-- **Structure.** PSR-4 autoloading. Package by feature. No global state. Constructor injection only.
-- **Avoid.** Untyped parameters or returns. \`@\` error suppression. Globals. Static mutable state. Multiple inheritance via traits as a workaround for poor design. \`extract()\`, \`compact()\`, variable variables.`,
+- PHP 8.2+; \`declare(strict_types=1);\`; PHPStan max + PHP-CS-Fixer.
+- Typed properties, params, returns; \`readonly\` classes for data.
+- Validate input at boundaries; prepared statements only.
+- Enums over string constants; specific exceptions.
+- Avoid arrays as untyped structs, globals, \`@\` suppression.`,
     swift: `### Swift
 
-- **Tooling.** Swift 5.10+ or 6 with strict concurrency. \`swift-format\` or SwiftLint. \`-warnings-as-errors\` in CI.
-- **Types.** \`struct\` by default; \`class\` only for identity-bearing references. \`enum\` with associated values for sum types. \`@frozen\` on stable public enums. Generics over protocol existentials when possible.
-- **Optionals.** Use the type system — no \`!\` force-unwraps except for genuinely impossible-to-fail cases (with a comment). \`guard let\` / \`if let\` everywhere else.
-- **Errors.** \`throws\` + typed \`throws\` (Swift 6) for expected failures across module boundaries. \`Result<Success, Failure>\` when storing/passing async outcomes. Never use \`try!\` outside tests.
-- **Concurrency.** \`async\`/\`await\` + structured concurrency (\`TaskGroup\`, \`async let\`). Actors for mutable shared state. \`@MainActor\` on UI-touching code. Avoid \`Task.detached\`.
-- **Structure.** One public type per file. Group files by feature. Extensions for protocol conformances, kept in the same file unless cross-cutting.
-- **Avoid.** Implicit-unwrapped optionals (\`Type!\`) in new code. \`NSObject\` inheritance unless interop requires it. Singletons as the primary state container. Reflection (\`Mirror\`) in hot paths.`,
+- Swift 6 strict concurrency; SwiftFormat/SwiftLint.
+- Value types (\`struct\`/\`enum\`) by default; \`let\` over \`var\`.
+- No force unwrap \`!\` or \`try!\`; use \`guard let\`.
+- \`async/await\` + actors; typed throws/Result for expected failures.
+- Avoid singletons, implicitly unwrapped optionals, \`@unchecked Sendable\`.`,
     scala: `### Scala
 
-- **Tooling.** Scala 3. \`scalafmt\` + \`scalafix\`. \`-Wunused:all\`, \`-Werror\`, \`-explain\` compiler flags. Run on the latest stable Scala 3.
-- **Types.** \`case class\` for records, \`enum\` for sum types — never sealed-trait-and-case-objects boilerplate in Scala 3. Opaque types for domain primitives. Avoid implicit conversions; use \`given\`/\`using\` for type-class instances only.
-- **Errors.** \`Either[E, A]\` for expected failures, \`Try\` only at the foreign-exception boundary, exceptions only for unrecoverable bugs. With effect libraries (Cats Effect / ZIO): use the effect type's error channel.
-- **Effects.** Pick one effect system per repo (Cats Effect IO or ZIO) and stick with it. Avoid mixing Future + IO. Tagless final only when the abstraction is genuinely load-bearing.
-- **Structure.** Package by feature. One top-level definition per file when public. Heavy use of \`extension\` methods over implicit classes.
-- **Avoid.** \`null\`. \`var\` in business code. Implicit conversions. Operator-soup DSLs in app logic (libraries only). \`asInstanceOf\` outside adapter boundaries.`,
+- Scala 3; scalafmt + \`-Werror\`.
+- Immutable case classes and enums; ADTs for state.
+- \`Either\`/\`Option\` for expected failures; no \`null\`.
+- Explicit types on public members.
+- Avoid implicit conversions, \`var\`, throwing in pure code.`,
     elixir: `### Elixir
 
-- **Tooling.** Latest stable Elixir + Erlang/OTP. \`mix format\`. \`credo --strict\` + \`dialyzer\` (with \`@spec\` on every public function).
-- **Types.** \`@spec\` and \`@type\` on every public function and module — feed Dialyzer. Use structs (\`defstruct\` + \`@enforce_keys\`) for domain data, never bare maps for typed records.
-- **Errors.** \`{:ok, value} | {:error, reason}\` tuples for expected outcomes. \`with\` chains for happy-path composition. Bang functions (\`!\`) raise on failure — use sparingly, only when callers genuinely can't recover. Never \`rescue\` arbitrary exceptions in business code.
-- **Processes.** Use OTP behaviors (\`GenServer\`, \`Supervisor\`, \`Task.Supervisor\`) — never raw \`spawn\`/\`spawn_link\` in app code. Let-it-crash with a supervision tree, not defensive try/rescue.
-- **Structure.** Context modules (Phoenix-style) group functionality by bounded context. Public API on the context module; implementation modules are internal.
-- **Avoid.** Macros in app code (libraries may need them; mark with care). \`Process.put\`/\`get\` for state. Atom-keyed maps from untrusted input (\`String.to_atom\` on user data leaks). Hidden side effects in pipelines.`,
+- \`mix format\`, Credo, Dialyzer.
+- \`{:ok, v}\` / \`{:error, r}\` returns; \`with\` for chains.
+- Pattern match in function heads; \`@spec\` on public functions.
+- Supervise every process; let it crash.
+- Avoid \`try/rescue\` for control flow, process dictionary, atom leaks.`,
     haskell: `### Haskell
 
-- **Tooling.** GHC 9.6+. \`ormolu\` or \`fourmolu\`. HLint with strict suggestions. Stack or Cabal — pick one per repo. \`-Wall -Wcompat -Werror\` for libraries.
-- **Types.** Explicit top-level signatures on every binding, even when inferable. Records with named fields and \`DuplicateRecordFields\` + \`OverloadedRecordDot\` (or use \`generic-lens\`). Newtype wrappers for domain primitives.
-- **Errors.** \`Either ErrorType a\` for expected failures. \`Maybe\` only for genuine absence, not for "computation failed". Exceptions only at the IO boundary; convert to \`Either\` immediately.
-- **Effects.** Pick one effect strategy per repo: plain \`IO\` for simple apps, \`ReaderT\` over \`IO\` for typical services, or a single effect system (effectful / freer-simple). Don't mix.
-- **Structure.** One module per type + its operations. No \`Util\` or \`Misc\` modules. Public API surface in module export lists — never \`module X where\` with no export list.
-- **Avoid.** Partial functions (\`head\`, \`!!\`, \`fromJust\`) — use total alternatives. Lens-heavy chains in app logic. \`undefined\` in committed code. Orphan instances.`,
+- GHC2021; \`-Wall -Werror\`; fourmolu + hlint.
+- Type signatures on all top-level bindings.
+- \`Either\`/\`Maybe\` for expected failures; newtypes for domain values.
+- Strict data fields; \`Text\` over \`String\`.
+- Avoid partial functions (\`head\`, \`fromJust\`), orphan instances.`,
     ocaml: `### OCaml
 
-- **Tooling.** OCaml 5+ via opam. \`dune\` build system. \`ocamlformat\` with the project preset locked. Merlin for editor support.
-- **Types.** Annotate every public binding in \`.mli\` interface files. Phantom types or private types for domain invariants. Avoid open polymorphic variants in libraries (use plain variants).
-- **Errors.** \`Result.t\` from the stdlib for expected failures. Exceptions only for impossible states or at the I/O boundary. \`( let* )\` syntax for monadic chaining over nested \`match\`.
-- **Modules.** Heavy use of modules and module signatures. One main type per module, named \`t\`, with operations as \`Module.op\`. Functors only when they buy real abstraction; otherwise plain modules.
-- **Structure.** One \`.ml\` per concept with a matching \`.mli\` exposing only public API. Dune libraries grouped by feature.
-- **Avoid.** \`Obj.magic\` outside truly unavoidable interop. Global mutable state. Polymorphic equality (\`=\`) on complex types — use type-specific \`equal\` functions. Pervasives \`Stdlib\` shadowing without a clear reason.`,
+- dune + ocamlformat; warnings as errors.
+- \`.mli\` interfaces for every public module.
+- \`result\` for expected failures; exhaustive matches.
+- Variants over booleans/strings for state.
+- Avoid partial functions, \`Obj.magic\`, mutable globals.`,
     fsharp: `### F#
 
-- **Tooling.** Latest stable F# on .NET 8+. \`fantomas\` formatter. \`<TreatWarningsAsErrors>true</TreatWarningsAsErrors>\`. FSharpLint or analyzers.
-- **Types.** Records and discriminated unions for all domain types. Single-case DUs for domain primitives. Avoid classes in new code except for interop. Type providers only when the source schema is stable.
-- **Errors.** \`Result<'T, 'TError>\` for expected failures, \`Option\` for absence. \`ResultBuilder\` (\`result { ... }\`) computation expression for sequencing. Exceptions only at the .NET interop boundary.
-- **Structure.** Modules over classes. File order matters in F# — put types and core helpers first, composition later. One concept per file. Keep \`open\` statements at the top.
-- **Async.** \`Async\` for F#-native flows, \`Task\` at .NET boundaries. Use \`task { }\` computation expression when interop matters.
-- **Avoid.** Mutable state outside small, well-contained pockets. Object expressions where a module function would do. \`obj\` and downcasts in business code. \`null\` even for interop — wrap immediately in \`Option\`.`,
+- Fantomas; warnings as errors.
+- Records and DUs for data; immutable by default.
+- \`Result\`/\`Option\` for expected failures; exhaustive matches.
+- \`task {}\` with \`CancellationToken\` for I/O.
+- Avoid nulls, classes for pure data, mutable globals.`,
     clojure: `### Clojure
 
-- **Tooling.** Latest stable Clojure. \`clj-kondo\` linter (treat warnings as errors). \`cljfmt\` formatter. \`tools.deps\` (\`deps.edn\`) over Leiningen for new projects.
-- **Specs/schemas.** Use Malli (preferred) or Spec at every external boundary. Schema-driven generative tests on core data. Keep schemas alongside the namespace they describe.
-- **Errors.** Return \`{:ok ...}\` / \`{:error ...}\` maps for expected failures. \`ex-info\` with structured data for genuine exceptions. Never bare \`throw\` of a string. \`try\`/\`catch\` only at process or request boundaries.
-- **State.** Atoms for shared local state, refs only when coordination is required, never global vars for mutable state. Components / Integrant / Mount for system lifecycle — pick one per repo.
-- **Structure.** Namespace per concept. Keep functions small, composable, pure where possible. Side effects pushed to the edge.
-- **Avoid.** Macros in app code unless they remove genuine ceremony. Dynamic vars (\`*var*\`) for hidden parameters. \`def\` inside functions. \`eval\` in production code. Threading-macro chains longer than ~5 steps without a named intermediate.`,
+- clj-kondo + cljfmt.
+- Pure functions over immutable maps; side effects at edges.
+- Validate boundary data with Malli or spec.
+- Return \`ex-info\` with data for errors.
+- Avoid global atoms, dynamic vars as config, deep macros.`,
     dart: `### Dart
 
-- **Tooling.** Dart 3+. \`dart format\`. \`very_good_analysis\` or \`flutter_lints\` strict preset. Sound null safety enabled.
-- **Types.** Explicit types on every public API. \`final\` everywhere unless mutation is intentional. Records (Dart 3) and patterns for ad-hoc structured data. \`sealed class\` + pattern matching for sum types.
-- **Errors.** Custom exceptions for unrecoverable cases. \`Result<T, E>\` sealed class for expected failures. Never throw \`String\` or untyped values.
-- **Async.** \`async\`/\`await\`. \`Future\` for one-shot, \`Stream\` for sequences. Always handle errors via \`.catchError\` or try/catch at the boundary.
-- **Structure.** One public class per file. Feature folders. \`part\`/\`part of\` only for code generation (\`freezed\`, \`json_serializable\`).
-- **Avoid.** \`dynamic\` in new code. Implicit \`new\` (write it out where ambiguous). \`var\` for public API. Mutable static fields. Long widget build methods — extract.`,
+- Sound null safety; \`dart format\`; strict \`analysis_options\` lints.
+- No \`!\` bang operator without proof; no \`dynamic\`.
+- Immutable models (\`final\` fields); sealed classes for state.
+- Await every Future; cancel subscriptions.
+- Avoid global mutable state and \`late\` misuse.`,
     lua: `### Lua
 
-- **Tooling.** Lua 5.4 or LuaJIT — declare which. \`stylua\` for formatting. \`luacheck\` with strict globals. Annotate with LuaCATS / EmmyLua for editor support.
-- **Types.** \`---@type\`, \`---@param\`, \`---@return\` annotations on every public function. \`---@class\` for tables used as records.
-- **Tables.** Decide if a table is a record, array, or map at the call site and stick to it. Don't mix array and map fields. Sequence tables (\`{ "a", "b" }\`) treated as 1-indexed sequences without holes.
-- **Errors.** Return \`value, nil\` on success / \`nil, errString\` on failure for expected outcomes. \`error()\` only for unrecoverable programmer errors. \`pcall\` at module / request boundaries.
-- **Modules.** \`local M = {}; … return M\` pattern. No global side effects on require. \`local\` everything unless explicit module export.
-- **Avoid.** Implicit globals — set \`luacheck\` to flag them. Metatable cleverness in app logic. \`setfenv\`/\`getfenv\` (gone in 5.2+) or environment hacks. String-key tables when an index would work.`,
+- StyLua + luacheck.
+- \`local\` everything; no implicit globals.
+- Return \`nil, err\` for expected failures; \`pcall\` at boundaries.
+- Modules return a table; no side effects on require.
+- Avoid global mutation and metatable magic.`,
     zig: `### Zig
 
-- **Tooling.** Pin a specific Zig version per project (the language is pre-1.0 and shifting). \`zig fmt\`. Run all sanitizers in test builds.
-- **Errors.** Use Zig's error union type \`!T\` everywhere appropriate. Define a single error set per module, named \`Error\`. Use \`try\` for propagation, \`catch\` for handling at the boundary. Never \`unreachable\` in production paths.
-- **Memory.** Explicit allocator passed in to every function that allocates. Pair every \`alloc\` with a \`defer\` \`free\`. Use arena allocators for grouped lifetimes.
-- **Comptime.** Use \`comptime\` for genuine compile-time work (generics, config) — not as a substitute for runtime code.
-- **Structure.** One concept per file. Public API at the top. Tests in the same file as the code they test.
-- **Avoid.** \`@cImport\` outside a single \`c.zig\` boundary module. Heap allocation in hot paths when a fixed-size buffer works. Mixing different allocators in one ownership chain.`,
+- \`zig fmt\`; latest stable Zig.
+- Error unions with \`try\`; never discard errors.
+- Pass allocators explicitly; \`defer\`/\`errdefer\` for cleanup.
+- Test with \`std.testing.allocator\` for leak checks.
+- Avoid \`@ptrCast\` without need, \`unreachable\` for real errors, globals.`,
     sql: `### SQL
 
-- **Tooling.** \`sqlfluff\` with a strict dialect-specific preset. Migrations are append-only, numbered, and reversible — never edit an applied migration.
-- **Style.** Uppercase keywords. One clause per line, trailing commas in select lists, leading commas allowed if the team agrees. Always alias tables; always qualify columns with the alias.
-- **Selects.** Never \`SELECT *\` in application code. CTEs over nested subqueries. Window functions over self-joins where they work.
-- **Schema.** Explicit \`NOT NULL\` on every column that should have it. Foreign keys with \`ON DELETE\` actions specified. Generated/identity columns for surrogate keys; never auto-incrementing without a \`PRIMARY KEY\`.
-- **Migrations.** One change per migration. Idempotent where the engine supports it. Always include a rollback plan in a comment. No data migrations mixed with schema migrations.
-- **Avoid.** String interpolation into queries from app code — use parameterized queries. \`SELECT INTO\` for permanent tables. ORM lazy-loading patterns hidden behind \`N+1\` queries. Wide tables with \`JSON\` columns where a relational design fits.`,
+- sqlfluff; uppercase keywords.
+- Parameterized queries only; never string-concat input.
+- Explicit column lists; no \`SELECT *\` in app code.
+- Constraints (NOT NULL, FK, UNIQUE) in schema; forward-only migrations.
+- Avoid implicit joins and unbounded queries.`,
     bash: `### Bash / Shell
 
-- **Tooling.** \`#!/usr/bin/env bash\` shebang. \`set -euo pipefail; IFS=$'\\n\\t'\` at the top of every script. \`shellcheck\` clean — no exceptions.
-- **Style.** Quote every variable expansion (\`"$var"\`). \`[[ ]]\` not \`[ ]\` for tests. \`$(cmd)\` not backticks. Functions over inline blocks past ~10 lines.
-- **Errors.** Check command exit codes explicitly when \`set -e\` semantics aren't sufficient (e.g. pipes — use \`pipefail\`). \`trap\` for cleanup. Never \`|| true\` to silence errors without a comment explaining why.
-- **Args.** Use \`getopts\` or a small parser, not positional indexing past 2 args. \`--\` to separate flags from arguments when passing to other commands.
-- **Structure.** Top of script: shebang, \`set\` flags, \`readonly\` constants, then function definitions, then \`main\` call. One concern per script.
-- **Avoid.** \`eval\`. Word splitting / glob expansion by leaving variables unquoted. Mutating \`IFS\` in the middle of a script. Scripts longer than ~100 lines — switch to Python or Go.`,
+- \`set -euo pipefail\`; shellcheck + shfmt.
+- Quote every expansion: \`"$var"\`.
+- \`[[ ]]\` over \`[ ]\`; \`local\` in functions.
+- \`mktemp\` + \`trap\` cleanup.
+- Avoid parsing \`ls\`, \`eval\`, backticks.`,
     terraform: `### Terraform / HCL
 
-- **Tooling.** Latest stable Terraform or OpenTofu. \`terraform fmt\`. \`tflint\` + \`tfsec\` (or \`checkov\`) in CI. Pinned provider versions in \`required_providers\`. Remote state with locking always.
-- **Structure.** Modules by infrastructure concern (\`network/\`, \`compute/\`, \`data/\`). \`main.tf\`, \`variables.tf\`, \`outputs.tf\`, \`versions.tf\` per module. No monolithic root module — environments compose modules.
-- **Variables.** Every variable has a \`type\` and a \`description\`. \`sensitive = true\` on secrets. Validate with \`validation\` blocks. No untyped \`any\` variables.
-- **State.** One state file per environment + concern. Never commit \`.tfstate\` or \`.tfvars\` with secrets to git. Use \`tfvars\` files per environment, kept out of public repos.
-- **Resources.** Explicit \`tags\` blocks on every resource that supports them. Lifecycle \`prevent_destroy = true\` on stateful infrastructure (databases, buckets) unless intentionally ephemeral.
-- **Avoid.** \`count\` for set-like collections — use \`for_each\` with a map. Hard-coded provider regions or account IDs (use variables). Implicit dependencies — declare \`depends_on\` when ordering matters. \`local-exec\` provisioners as a primary tool (use them only as a last resort).`,
+- \`terraform fmt\` + \`validate\` + tflint.
+- Pin provider and module versions.
+- Typed variables with \`validation\` blocks.
+- Remote state with locking; no secrets in code or state outputs.
+- Avoid hardcoded IDs, \`count\` for keyed resources (use \`for_each\`).`,
 };
 //# sourceMappingURL=packs.js.map

package/dist/core/style-packs/packs.js.map

@@ -1 +1 @@
-{"version":3,"file":"packs.js","sourceRoot":"","sources":["../../../src/core/style-packs/packs.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,KAAK,GAAyC;IACzD,UAAU,EAAE;;;;;;;;kPAQoO;IAEhP,UAAU,EAAE;;;;;;;;uIAQyH;IAErI,MAAM,EAAE;;;;;;;;wQAQ8P;IAEtQ,EAAE,EAAE;;;;;;;;;2MASqM;IAEzM,IAAI,EAAE;;;;;;;;gNAQwM;IAE9M,IAAI,EAAE;;;;;;;qMAO6L;IAEnM,MAAM,EAAE;;;;;;;;iKAQuJ;IAE/J,MAAM,EAAE;;;;;;;;kLAQwK;IAEhL,GAAG,EAAE;;;;;;;;6TAQsT;IAE3T,CAAC,EAAE;;;;;;;;6KAQwK;IAE3K,IAAI,EAAE;;;;;;;6OAOqO;IAE3O,GAAG,EAAE;;;;;;;uNAOgN;IAErN,KAAK,EAAE;;;;;;;;yMAQgM;IAEvM,KAAK,EAAE;;;;;;;sKAO6J;IAEpK,MAAM,EAAE;;;;;;;8NAOoN;IAE5N,OAAO,EAAE;;;;;;;6KAOkK;IAE3K,KAAK,EAAE;;;;;;;mOAO0N;IAEjO,MAAM,EAAE;;;;;;;2NAOiN;IAEzN,OAAO,EAAE;;;;;;;sPAO2O;IAEpP,IAAI,EAAE;;;;;;;2KAOmK;IAEzK,GAAG,EAAE;;;;;;;2MAOoM;IAEzM,GAAG,EAAE;;;;;;;uLAOgL;IAErL,GAAG,EAAE;;;;;;;2PAOoP;IAEzP,IAAI,EAAE;;;;;;;2LAOmL;IAEzL,SAAS,EAAE;;;;;;;iSAOoR;CAChS,CAAC"}
+{"version":3,"file":"packs.js","sourceRoot":"","sources":["../../../src/core/style-packs/packs.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,KAAK,GAAyC;IACzD,UAAU,EAAE;;;;;;;mDAOqC;IAEjD,UAAU,EAAE;;;;+DAIiD;IAE7D,MAAM,EAAE;;;;;;;0DAOgD;IAExD,EAAE,EAAE;;;;;;;yEAOmE;IAEvE,IAAI,EAAE;;;;;;;wDAOgD;IAEtD,IAAI,EAAE;;;;;;;yEAOiE;IAEvE,MAAM,EAAE;;;;;;;oDAO0C;IAElD,MAAM,EAAE;;;;;;8EAMoE;IAE5E,GAAG,EAAE;;;;;;iEAM0D;IAE/D,CAAC,EAAE;;;;;;mEAM8D;IAEjE,IAAI,EAAE;;;;;;2DAMmD;IAEzD,GAAG,EAAE;;;;;;+DAMwD;IAE7D,KAAK,EAAE;;;;;;6EAMoE;IAE3E,KAAK,EAAE;;;;;;8DAMqD;IAE5D,MAAM,EAAE;;;;;;yEAM+D;IAEvE,OAAO,EAAE;;;;;;sEAM2D;IAEpE,KAAK,EAAE;;;;;;2DAMkD;IAEzD,MAAM,EAAE;;;;;;uDAM6C;IAErD,OAAO,EAAE;;;;;;2DAMgD;IAEzD,IAAI,EAAE;;;;;;kDAM0C;IAEhD,GAAG,EAAE;;;;;;6CAMsC;IAE3C,GAAG,EAAE;;;;;;6EAMsE;IAE3E,GAAG,EAAE;;;;;;8CAMuC;IAE5C,IAAI,EAAE;;;;;;6CAMqC;IAE3C,SAAS,EAAE;;;;;;yEAM4D;CACxE,CAAC"}