@enrichlayer/el-linear 1.2.0

package/dist/config/issue-validation.js

@@ -0,0 +1,264 @@
+/**
+ * Issue creation validation — Phase 1 of DEV-3708.
+ *
+ * Enforces structural requirements (type labels, description, label normalization)
+ * at the CLI level rather than relying on LLM skill prompts.
+ *
+ * Gated behind `validation.enabled` in config so it can be rolled out per-user
+ * before becoming the default for the team.
+ */
+import { outputWarning } from "../utils/output.js";
+import { loadConfig } from "./config.js";
+/** Canonical type labels. Stored in config so they can be updated without code changes. */
+const DEFAULT_TYPE_LABELS = ["bug", "feature", "refactor", "chore", "spike"];
+/**
+ * Recommended leading verbs for each type label.
+ * Title verb and type label should express the same intent.
+ */
+const TYPE_VERB_MAP = {
+    bug: ["Fix", "Resolve", "Patch", "Handle", "Address", "Correct"],
+    feature: [
+        "Add",
+        "Build",
+        "Create",
+        "Implement",
+        "Enable",
+        "Ship",
+        "Launch",
+        "Design",
+        "Wire",
+        "Integrate",
+        "Expose",
+        "Send",
+        "Track",
+        "Alert",
+        "Automate",
+        "Post",
+    ],
+    chore: [
+        "Update",
+        "Remove",
+        "Clean",
+        "Migrate",
+        "Deploy",
+        "Rotate",
+        "Set up",
+        "Configure",
+        "Document",
+        "Review",
+        "Publish",
+        "Standardize",
+        "Accept",
+        "Consolidate",
+        "Teardown",
+        "Upgrade",
+    ],
+    spike: [
+        "Research",
+        "Investigate",
+        "Explore",
+        "Evaluate",
+        "Audit",
+        "Benchmark",
+        "Test",
+    ],
+    refactor: [
+        "Refactor",
+        "Restructure",
+        "Extract",
+        "Decouple",
+        "Consolidate",
+        "Simplify",
+    ],
+};
+/**
+ * Common misspellings / wrong-case variants → canonical form.
+ * Covers the real mistakes observed in production data.
+ */
+const LABEL_ALIASES = {
+    Bug: "bug",
+    Feature: "feature",
+    Refactor: "refactor",
+    Chore: "chore",
+    Spike: "spike",
+    "feature-request": "feature",
+    "bug-report": "bug",
+    enhancement: "feature",
+};
+function getValidationConfig() {
+    const config = loadConfig();
+    const validation = config.validation;
+    return {
+        enabled: validation?.enabled ?? true,
+        typeLabels: validation?.typeLabels ?? DEFAULT_TYPE_LABELS,
+    };
+}
+/**
+ * Normalize a label name: resolve known aliases and fix casing.
+ * Returns the canonical form if an alias exists, otherwise the original.
+ */
+export function normalizeLabel(label) {
+    // Exact alias match first (case-sensitive for things like "Feature" → "feature")
+    if (label in LABEL_ALIASES) {
+        return LABEL_ALIASES[label];
+    }
+    return label;
+}
+/**
+ * Validate issue creation inputs. Returns errors (block creation) and warnings (informational).
+ *
+ * Only runs when `validation.enabled` is true in config.
+ * Bypass entirely with `--no-validate`.
+ */
+export function validateIssueCreation(input) {
+    const vConfig = getValidationConfig();
+    const result = {
+        errors: [],
+        warnings: [],
+        normalizedLabels: null,
+    };
+    if (!vConfig.enabled) {
+        return result;
+    }
+    // --- Label normalization (always runs when validation is on) ---
+    if (input.labels && input.labels.length > 0) {
+        result.normalizedLabels = input.labels.map((label) => {
+            const normalized = normalizeLabel(label);
+            if (normalized !== label) {
+                result.warnings.push(`Label "${label}" normalized to "${normalized}" (alias)`);
+            }
+            return normalized;
+        });
+    }
+    const effectiveLabels = result.normalizedLabels ?? input.labels ?? [];
+    // --- Required: labels must be provided ---
+    if (effectiveLabels.length === 0) {
+        result.errors.push("Missing --labels. At least one label is required, including a type label.\n" +
+            `  Valid type labels: ${vConfig.typeLabels.join(", ")}\n` +
+            '  Example: --labels "bug,backend"');
+    }
+    else {
+        // --- Required: exactly one type label ---
+        const typeLabelsFound = effectiveLabels.filter((l) => vConfig.typeLabels.includes(l.toLowerCase()));
+        if (typeLabelsFound.length === 0) {
+            result.errors.push("Missing type label. Exactly one required.\n" +
+                `  Valid type labels: ${vConfig.typeLabels.join(", ")}\n` +
+                `  Provided labels: ${effectiveLabels.join(", ")}\n` +
+                `  Example: --labels "${vConfig.typeLabels[0]},${effectiveLabels[0]}"`);
+        }
+        else if (typeLabelsFound.length > 1) {
+            result.errors.push(`Multiple type labels found: ${typeLabelsFound.join(", ")}. Exactly one required.\n` +
+                `  Valid type labels: ${vConfig.typeLabels.join(", ")}`);
+        }
+    }
+    // --- Required: description must be provided ---
+    if (!input.description || input.description.trim().length === 0) {
+        result.errors.push("Missing --description. A description is required for issue creation.");
+    }
+    else {
+        // --- Warning: short description ---
+        if (input.description.trim().length < 50) {
+            result.warnings.push(`Description is only ${input.description.trim().length} characters. Consider adding more context.`);
+        }
+        // --- Warning: no "why" section ---
+        const descLower = input.description.toLowerCase();
+        const hasWhySection = descLower.includes("why we need") ||
+            descLower.includes("## why") ||
+            descLower.includes("**why") ||
+            descLower.includes("background") ||
+            descLower.includes("motivation") ||
+            descLower.includes("context:");
+        if (!hasWhySection) {
+            result.warnings.push('Consider adding a "## Why we need this" section to explain the motivation.');
+        }
+    }
+    // --- Warning: title style ---
+    if (input.title.length > 100) {
+        result.warnings.push(`Title is ${input.title.length} characters. Consider shortening to under 100.`);
+    }
+    if (/^(A|An|The)\s/.test(input.title)) {
+        result.warnings.push("Consider starting the title with an action verb instead of an article.");
+    }
+    // --- Warning: title-verb / type-label alignment ---
+    const typeLabelsFound = effectiveLabels.filter((l) => vConfig.typeLabels.includes(l.toLowerCase()));
+    if (typeLabelsFound.length === 1) {
+        checkTitleVerbAlignment(input.title, typeLabelsFound[0].toLowerCase(), result);
+    }
+    // --- Required: assignee ---
+    if (!input.assignee) {
+        result.errors.push("Missing --assignee. Every issue must have an assignee.\n" +
+            "  Use `el-linear users list --active` to find valid assignees.");
+    }
+    // --- Required: project ---
+    if (!input.project) {
+        result.errors.push("Missing --project. Every issue must belong to a project.\n" +
+            "  Use `el-linear projects list` to find valid projects.");
+    }
+    return result;
+}
+/**
+ * Check whether the title's leading verb aligns with the provided type label.
+ * Only warns when the first word is a recognized verb in any type's set —
+ * titles starting with non-verb words (e.g. "Dashboard auth failing") are left alone.
+ */
+function checkTitleVerbAlignment(title, typeLabel, result) {
+    const verbs = TYPE_VERB_MAP[typeLabel];
+    if (!verbs)
+        return;
+    // Check multi-word verbs first (e.g. "Set up")
+    for (const [type, typeVerbs] of Object.entries(TYPE_VERB_MAP)) {
+        for (const verb of typeVerbs) {
+            if (!verb.includes(" "))
+                continue;
+            if (title.toLowerCase().startsWith(verb.toLowerCase() + " ") ||
+                title.toLowerCase() === verb.toLowerCase()) {
+                if (type === typeLabel)
+                    return; // match — all good
+                result.warnings.push(`Title starts with "${verb}" but type is "${typeLabel}". ` +
+                    `Consider starting with: ${verbs.slice(0, 6).join(", ")}`);
+                result.warnings.push(`"${verb}" is typically associated with "${type}" issues.`);
+                return;
+            }
+        }
+    }
+    // Single-word verb check
+    const firstWord = title.split(/\s/)[0];
+    if (!firstWord)
+        return;
+    // Is the first word in the correct type's verb set?
+    const matchesType = verbs.some((v) => v.toLowerCase() === firstWord.toLowerCase());
+    if (matchesType)
+        return; // match — all good
+    // Is the first word in any OTHER type's verb set?
+    let matchedOtherType = null;
+    for (const [type, typeVerbs] of Object.entries(TYPE_VERB_MAP)) {
+        if (type === typeLabel)
+            continue;
+        if (typeVerbs.some((v) => v.toLowerCase() === firstWord.toLowerCase())) {
+            matchedOtherType = type;
+            break;
+        }
+    }
+    // Only warn if the first word IS a recognized verb (just for the wrong type)
+    if (matchedOtherType) {
+        result.warnings.push(`Title starts with "${firstWord}" but type is "${typeLabel}". ` +
+            `Consider starting with: ${verbs.slice(0, 6).join(", ")}`);
+        result.warnings.push(`"${firstWord}" is typically associated with "${matchedOtherType}" issues.`);
+    }
+}
+/**
+ * Apply validation results: emit warnings, throw on errors.
+ * Called from the create command unless `--no-validate` is set.
+ */
+export function enforceValidation(result) {
+    for (const warning of result.warnings) {
+        outputWarning(warning, "validation");
+    }
+    if (result.errors.length > 0) {
+        const errorMsg = "Issue creation blocked by validation:\n\n" +
+            result.errors.map((e) => `  ✗ ${e}`).join("\n\n") +
+            "\n\nTo skip validation, pass --skip-validation.\n" +
+            "To disable validation permanently, set validation.enabled: false in ~/.config/el-linear/config.json.";
+        throw new Error(errorMsg);
+    }
+}

package/dist/config/paths.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Canonical paths to the el-linear on-disk state. Single source of truth so the
+ * config loader, the auth module, and the init wizard all agree on where to
+ * read and write.
+ */
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_PATH: string;
+export declare const TOKEN_PATH: string;
+export declare const ALIASES_PROGRESS_PATH: string;
+/**
+ * Legacy fallback paths kept for backward compatibility. The CLI was briefly
+ * published as `@enrichlayer/linctl` (binary `linctl`); reverted to el-linear
+ * because of an npm collision with `dorkitude/linctl`. Reads check the new
+ * path first and fall back to these. Writes always go to the new path.
+ */
+export declare const LEGACY_LINCTL_CONFIG_DIR: string;
+export declare const LEGACY_LINCTL_CONFIG_PATH: string;
+export declare const LEGACY_LINCTL_TOKEN_PATH: string;
+/** Even older fallback from before the `~/.config/...` move (one release). */
+export declare const LEGACY_TOKEN_PATH: string;

package/dist/config/paths.js

@@ -0,0 +1,22 @@
+/**
+ * Canonical paths to the el-linear on-disk state. Single source of truth so the
+ * config loader, the auth module, and the init wizard all agree on where to
+ * read and write.
+ */
+import os from "node:os";
+import path from "node:path";
+export const CONFIG_DIR = path.join(os.homedir(), ".config", "el-linear");
+export const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+export const TOKEN_PATH = path.join(CONFIG_DIR, "token");
+export const ALIASES_PROGRESS_PATH = path.join(CONFIG_DIR, ".init-aliases-progress");
+/**
+ * Legacy fallback paths kept for backward compatibility. The CLI was briefly
+ * published as `@enrichlayer/linctl` (binary `linctl`); reverted to el-linear
+ * because of an npm collision with `dorkitude/linctl`. Reads check the new
+ * path first and fall back to these. Writes always go to the new path.
+ */
+export const LEGACY_LINCTL_CONFIG_DIR = path.join(os.homedir(), ".config", "linctl");
+export const LEGACY_LINCTL_CONFIG_PATH = path.join(LEGACY_LINCTL_CONFIG_DIR, "config.json");
+export const LEGACY_LINCTL_TOKEN_PATH = path.join(LEGACY_LINCTL_CONFIG_DIR, "token");
+/** Even older fallback from before the `~/.config/...` move (one release). */
+export const LEGACY_TOKEN_PATH = path.join(os.homedir(), ".linear_api_token");

package/dist/config/resolver.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Resolve a team key/name/alias to its UUID.
+ * Case-insensitive: "fe" → FE UUID, "frontend" → FE UUID via alias.
+ */
+export declare function resolveTeam(input: string): string;
+/**
+ * Resolve a member name/alias/handle to their UUID.
+ * Supports: "bob" → alias, "Alice" → name, "@alice-handle" → gitlab handle. Case-insensitive.
+ */
+export declare function resolveMember(input: string): string;
+/**
+ * Resolve an assignee input to a UUID, supporting "me" to refer to the API token owner.
+ * Falls back to resolveMember for all other inputs.
+ */
+export declare function resolveAssignee(input: string, rootOpts: Record<string, unknown>): Promise<string>;
+/**
+ * Resolve a user's display name from their UUID via config fullNames map.
+ * Returns the full name if found, otherwise returns the original name.
+ */
+export declare function resolveUserDisplayName(id: string, name: string): string;
+/**
+ * Resolve labels for a team, returning UUIDs for known labels.
+ * Unknown labels are returned as-is for API resolution.
+ */
+export declare function resolveLabels(names: string[], teamKey?: string): string[];

package/dist/config/resolver.js

@@ -0,0 +1,183 @@
+import { createGraphQLService } from "../utils/graphql-service.js";
+import { outputWarning } from "../utils/output.js";
+import { isUuid, isUuidPrefix } from "../utils/uuid.js";
+import { loadConfig } from "./config.js";
+/**
+ * Resolve a team key/name/alias to its UUID.
+ * Case-insensitive: "fe" → FE UUID, "frontend" → FE UUID via alias.
+ */
+export function resolveTeam(input) {
+    if (isUuid(input)) {
+        return input;
+    }
+    const config = loadConfig();
+    const upper = input.toUpperCase();
+    const lower = input.toLowerCase();
+    // Check direct key match (case-insensitive)
+    if (config.teams[upper]) {
+        return config.teams[upper];
+    }
+    // Check aliases (case-insensitive) → resolve to team key → then to UUID
+    for (const [alias, teamKey] of Object.entries(config.teamAliases)) {
+        if (alias.toLowerCase() === lower) {
+            const uuid = config.teams[teamKey.toUpperCase()];
+            if (uuid) {
+                return uuid;
+            }
+        }
+    }
+    // Return input as-is for API resolution
+    return input;
+}
+/**
+ * Resolve a member name/alias/handle to their UUID.
+ * Supports: "bob" → alias, "Alice" → name, "@alice-handle" → gitlab handle. Case-insensitive.
+ */
+export function resolveMember(input) {
+    if (isUuid(input)) {
+        return input;
+    }
+    const config = loadConfig();
+    // Strip leading @ (common in git/platform handles)
+    const cleaned = input.startsWith("@") ? input.slice(1) : input;
+    const lower = cleaned.toLowerCase();
+    // Check aliases first (case-insensitive)
+    for (const [alias, name] of Object.entries(config.members.aliases)) {
+        if (alias.toLowerCase() === lower) {
+            const uuid = config.members.uuids[name];
+            if (uuid) {
+                return uuid;
+            }
+        }
+    }
+    // Check platform handles (gitlab, github, etc.)
+    for (const handleMap of Object.values(config.members.handles)) {
+        for (const [handle, name] of Object.entries(handleMap)) {
+            if (handle.toLowerCase() === lower) {
+                const uuid = config.members.uuids[name];
+                if (uuid) {
+                    return uuid;
+                }
+            }
+        }
+    }
+    // Check direct name match (case-insensitive) — e.g., "David"
+    for (const [name, uuid] of Object.entries(config.members.uuids)) {
+        if (name.toLowerCase() === lower) {
+            return uuid;
+        }
+    }
+    // Check full names (case-insensitive) — e.g., "David Doe"
+    if (config.members.fullNames) {
+        for (const [uuid, fullName] of Object.entries(config.members.fullNames)) {
+            if (fullName.toLowerCase() === lower) {
+                return uuid;
+            }
+        }
+        // Partial match on full names — e.g., "doe" matches "David Doe"
+        for (const [uuid, fullName] of Object.entries(config.members.fullNames)) {
+            const parts = fullName.toLowerCase().split(/\s+/);
+            if (parts.some((part) => part === lower)) {
+                return uuid;
+            }
+        }
+    }
+    // Return input as-is for API resolution
+    return input;
+}
+/**
+ * Resolve an assignee input to a UUID, supporting "me" to refer to the API token owner.
+ * Falls back to resolveMember for all other inputs.
+ */
+export async function resolveAssignee(input, rootOpts) {
+    if (input.toLowerCase() === "me") {
+        const graphQLService = createGraphQLService(rootOpts);
+        const result = await graphQLService.rawRequest("{ viewer { id } }");
+        const viewer = result.viewer;
+        if (!viewer?.id) {
+            throw new Error('Could not resolve "me" — viewer query returned no user. Check your API token.');
+        }
+        return viewer.id;
+    }
+    return resolveMember(input);
+}
+/**
+ * Resolve a user's display name from their UUID via config fullNames map.
+ * Returns the full name if found, otherwise returns the original name.
+ */
+export function resolveUserDisplayName(id, name) {
+    const config = loadConfig();
+    return config.members.fullNames[id] || name;
+}
+/**
+ * Look up a label name in a label map (case-insensitive).
+ * Returns the UUID if valid, null if found but invalid/truncated, undefined if not found.
+ */
+function lookupLabel(labelMap, lower, context) {
+    for (const [labelName, uuid] of Object.entries(labelMap)) {
+        if (labelName.toLowerCase() !== lower) {
+            continue;
+        }
+        if (isUuid(uuid)) {
+            return uuid;
+        }
+        if (isUuidPrefix(uuid)) {
+            const scope = context ? ` (${context})` : "";
+            outputWarning(`Config label "${labelName}"${scope} has truncated UUID "${uuid}". Falling back to API resolution.`);
+        }
+        return null;
+    }
+    return undefined;
+}
+/** Common label abbreviations → canonical names */
+const LABEL_ALIASES = {
+    docs: "documentation",
+    doc: "documentation",
+    feat: "feature-request",
+    infra: "infrastructure",
+    fe: "frontend",
+    be: "backend",
+    ci: "ci/cd",
+};
+/**
+ * Resolve a label name to its UUID for a specific team.
+ * Checks workspace-level labels first, then team-scoped labels.
+ * Falls back to alias resolution and prefix matching.
+ */
+function resolveLabel(name, teamKey) {
+    if (isUuid(name)) {
+        return name;
+    }
+    const config = loadConfig();
+    const lower = name.toLowerCase();
+    const workspace = lookupLabel(config.labels.workspace, lower);
+    if (workspace !== undefined) {
+        return workspace;
+    }
+    if (teamKey) {
+        const upper = teamKey.toUpperCase();
+        const teamLabels = config.labels.teams[upper];
+        if (teamLabels) {
+            const team = lookupLabel(teamLabels, lower, `team ${upper}`);
+            if (team !== undefined) {
+                return team;
+            }
+        }
+    }
+    // Try alias resolution — e.g., "docs" → "documentation"
+    const aliased = LABEL_ALIASES[lower];
+    if (aliased) {
+        return resolveLabel(aliased, teamKey);
+    }
+    return null;
+}
+/**
+ * Resolve labels for a team, returning UUIDs for known labels.
+ * Unknown labels are returned as-is for API resolution.
+ */
+export function resolveLabels(names, teamKey) {
+    return names.map((name) => {
+        const resolved = resolveLabel(name, teamKey);
+        return resolved || name;
+    });
+}

package/dist/config/status-defaults.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Determine the default status based on issue attributes.
+ *
+ * Rules:
+ * - Explicit status always wins (return as-is)
+ * - Has assignee + project → "Todo"
+ * - Missing assignee OR project → "Triage"
+ */
+export declare function resolveDefaultStatus(opts: {
+    explicitStatus?: string;
+    hasAssignee: boolean;
+    hasProject: boolean;
+}): string | undefined;

package/dist/config/status-defaults.js

@@ -0,0 +1,20 @@
+import { loadConfig } from "./config.js";
+/**
+ * Determine the default status based on issue attributes.
+ *
+ * Rules:
+ * - Explicit status always wins (return as-is)
+ * - Has assignee + project → "Todo"
+ * - Missing assignee OR project → "Triage"
+ */
+export function resolveDefaultStatus(opts) {
+    // Explicit status always wins
+    if (opts.explicitStatus) {
+        return opts.explicitStatus;
+    }
+    const config = loadConfig();
+    if (opts.hasAssignee && opts.hasProject) {
+        return config.statusDefaults.withAssigneeAndProject;
+    }
+    return config.statusDefaults.noProject;
+}

package/dist/config/term-enforcer.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A single term-enforcement rule. The canonical form is what authors should use;
+ * the reject list contains common misspellings or alternate forms that should be
+ * flagged (and corrected to the canonical form).
+ *
+ * @example
+ *   { canonical: "Enrich Layer", reject: ["EnrichLayer", "enrichlayer", "Enrichlayer"] }
+ *   { canonical: "Linear", reject: ["linear.app", "Linear App"] }
+ *   { canonical: "GitHub", reject: ["Github", "github", "GitHUB"] }
+ */
+export interface TermRule {
+    canonical: string;
+    reject: string[];
+}
+/**
+ * Enforce all configured term rules against the given texts (typically a title
+ * and an optional description). In strict mode, the first violation throws;
+ * otherwise, all violations are buffered as warnings on the JSON output.
+ *
+ * Configure rules in your el-linear config:
+ *   {
+ *     "terms": [
+ *       { "canonical": "Enrich Layer", "reject": ["EnrichLayer", "enrichlayer"] }
+ *     ]
+ *   }
+ *
+ * If no rules are configured, this is a no-op.
+ */
+export declare function enforceTerms(texts: Array<string | null | undefined>, options?: {
+    strict?: boolean;
+}): void;

package/dist/config/term-enforcer.js

@@ -0,0 +1,69 @@
+import { outputWarning } from "../utils/output.js";
+import { loadConfig } from "./config.js";
+/**
+ * Build a regex that matches the rejected form as a standalone token, while
+ * tolerating common URL/file boundaries. The look-arounds prevent us from
+ * flagging `enrichlayer.com` (URL), `myenrichlayer` (compound word), or
+ * `path/to/enrichlayer` (file path).
+ */
+function buildRejectRegex(rejected) {
+    return new RegExp(`(?<!\\w|\\.|/)${escapeRegExp(rejected)}(?!\\w|\\.com|\\.co|\\.io)`, "g");
+}
+function findViolations(text, rules) {
+    const violations = [];
+    for (const rule of rules) {
+        for (const rejected of rule.reject) {
+            const matches = text.match(buildRejectRegex(rejected));
+            if (matches) {
+                violations.push({
+                    rule,
+                    matched: rejected,
+                    occurrences: matches.length,
+                });
+            }
+        }
+    }
+    return violations;
+}
+function formatViolation(v) {
+    const plural = v.occurrences > 1 ? "s" : "";
+    return `Found "${v.matched}" — use "${v.rule.canonical}" instead (${v.occurrences} occurrence${plural})`;
+}
+/**
+ * Enforce all configured term rules against the given texts (typically a title
+ * and an optional description). In strict mode, the first violation throws;
+ * otherwise, all violations are buffered as warnings on the JSON output.
+ *
+ * Configure rules in your el-linear config:
+ *   {
+ *     "terms": [
+ *       { "canonical": "Enrich Layer", "reject": ["EnrichLayer", "enrichlayer"] }
+ *     ]
+ *   }
+ *
+ * If no rules are configured, this is a no-op.
+ */
+export function enforceTerms(texts, options = {}) {
+    const { terms } = loadConfig();
+    if (!terms || terms.length === 0) {
+        return;
+    }
+    const allViolations = [];
+    for (const text of texts) {
+        if (!text) {
+            continue;
+        }
+        allViolations.push(...findViolations(text, terms));
+    }
+    if (allViolations.length === 0) {
+        return;
+    }
+    const warnings = allViolations.map(formatViolation);
+    if (options.strict) {
+        throw new Error(`Term enforcement failed:\n${warnings.map((w) => `  - ${w}`).join("\n")}`);
+    }
+    outputWarning(warnings, "term_enforcement");
+}
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};