@ekkos/cli 0.2.0

package/dist/utils/session-words.json

@@ -0,0 +1,119 @@
+{
+    "adjectives": [
+        "turbo", "mega", "hyper", "ultra", "super", "cosmic", "atomic", "quantum",
+        "stellar", "epic", "mighty", "zippy", "rapid", "swift", "brisk",
+        "hasty", "quick", "snappy", "speedy", "vivid",
+        "happy", "jolly", "merry", "cheerful", "bright", "sunny", "golden", "shiny",
+        "gleaming", "radiant", "glowing", "beaming", "sparkling", "dazzling", "brilliant",
+        "vibrant", "lively", "perky", "peppy", "bouncy",
+        "groovy", "jazzy", "funky", "zesty", "spicy", "crispy", "fluffy", "bubbly",
+        "fizzy", "sparkly", "chunky", "sassy", "quirky", "wacky", "zany",
+        "silly", "goofy", "witty", "clever", "punchy",
+        "slick", "sleek", "smooth", "polished", "refined", "elegant", "fancy", "dapper",
+        "stylish", "chic", "classy", "posh", "swanky", "ritzy", "plush",
+        "luxe", "deluxe", "premium", "elite", "prime",
+        "cyber", "digital", "binary", "pixel", "vector", "matrix", "neural", "quantum",
+        "crypto", "techno", "electric", "ionic", "plasma", "laser", "photon",
+        "nano", "micro", "giga", "mega", "tera",
+        "solar", "lunar", "cosmic", "stellar", "nebula", "aurora", "crystal", "prism",
+        "frost", "icy", "frozen", "arctic", "polar", "alpine", "misty",
+        "foggy", "hazy", "cloudy", "stormy", "windy",
+        "crimson", "scarlet", "ruby", "amber", "golden", "lime", "jade", "teal",
+        "azure", "cobalt", "violet", "purple", "magenta", "coral", "peach",
+        "bronze", "silver", "chrome", "onyx", "pearl",
+        "bold", "brave", "keen", "noble", "royal", "regal", "majestic", "grand",
+        "proud", "fierce", "wild", "free", "pure", "true", "real",
+        "honest", "loyal", "trusty", "sturdy", "solid",
+        "tiny", "mini", "micro", "petite", "small", "compact", "cozy", "snug",
+        "large", "huge", "giant", "massive", "grand", "vast", "broad",
+        "wide", "tall", "long", "big", "great",
+        "alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta",
+        "iota", "kappa", "lambda", "omega", "sigma", "tau", "phi",
+        "chi", "psi", "rho", "nu", "xi",
+        "metal", "steel", "iron", "copper", "bronze", "brass", "titanium", "platinum",
+        "diamond", "crystal", "glass", "marble", "granite", "stone", "wood",
+        "oak", "pine", "cedar", "bamboo", "silk", "velvet", "cotton", "wool",
+        "leather", "rubber", "plastic", "ceramic", "porcelain", "clay", "adobe",
+        "striped", "dotted", "spotted", "checked", "plaid", "solid", "gradient", "faded",
+        "mottled", "marbled", "speckled", "flecked", "dappled", "tinted", "shaded",
+        "frosted", "glazed", "painted", "carved", "etched"
+    ],
+    "nouns": [
+        "penguin", "panda", "otter", "narwhal", "alpaca", "llama", "badger", "walrus",
+        "koala", "dolphin", "eagle", "falcon", "hawk", "raven", "owl",
+        "fox", "wolf", "bear", "tiger", "lion", "leopard", "panther",
+        "ferret", "gopher", "bobcat", "lynx", "cougar", "jaguar", "cheetah",
+        "elephant", "rhino", "hippo", "giraffe", "zebra", "bison", "moose",
+        "deer", "elk", "caribou", "antelope",
+        "waffle", "pickle", "noodle", "pretzel", "muffin", "taco", "nugget", "biscuit",
+        "donut", "bagel", "croissant", "scone", "danish", "turnover", "strudel",
+        "pizza", "burger", "hotdog", "sandwich", "wrap", "burrito", "quesadilla",
+        "nachos", "taco", "falafel", "gyro", "kebab", "samosa", "dumpling",
+        "ramen", "sushi", "tempura", "teriyaki", "miso", "udon", "soba",
+        "pasta", "ravioli", "gnocchi", "risotto",
+        "rocket", "comet", "nebula", "quasar", "meteor", "photon", "pulsar", "nova",
+        "supernova", "galaxy", "cosmos", "universe", "orbit", "asteroid", "planet",
+        "star", "moon", "sun", "eclipse", "solstice", "equinox", "aurora",
+        "constellation", "satellite", "probe", "shuttle", "capsule", "lander", "rover",
+        "beacon", "signal", "transmission", "relay", "array", "dish", "antenna",
+        "spectrum", "frequency", "wavelength", "radiation",
+        "ninja", "pirate", "wizard", "robot", "cyborg", "android", "knight", "warrior",
+        "samurai", "ronin", "monk", "sage", "oracle", "prophet", "seer",
+        "mage", "sorcerer", "warlock", "witch", "druid", "shaman", "mystic",
+        "hero", "champion", "legend", "titan", "colossus", "golem", "giant",
+        "sprite", "fairy", "pixie", "elf", "dwarf", "gnome", "goblin",
+        "dragon", "phoenix", "griffin", "sphinx",
+        "thunder", "lightning", "blizzard", "tornado", "hurricane", "cyclone", "typhoon", "monsoon",
+        "tempest", "storm", "gale", "breeze", "wind", "gust", "draft",
+        "rain", "drizzle", "shower", "downpour", "deluge", "flood", "torrent",
+        "snow", "sleet", "hail", "frost", "ice", "icicle", "glacier",
+        "fog", "mist", "haze", "cloud", "vapor", "steam", "smoke",
+        "dew", "droplet", "bubble", "sparkle",
+        "server", "laptop", "tablet", "phone", "screen", "keyboard", "mouse", "chip",
+        "processor", "memory", "drive", "disk", "cache", "buffer", "stack",
+        "queue", "thread", "process", "daemon", "kernel", "module", "plugin",
+        "widget", "gadget", "device", "sensor", "scanner", "printer", "router", "modem",
+        "guitar", "piano", "drums", "flute", "violin", "trumpet", "saxophone", "clarinet",
+        "trombone", "harp", "banjo", "ukulele", "cello", "viola", "bass",
+        "synthesizer", "organ", "accordion", "harmonica", "xylophone"
+    ],
+    "verbs": [
+        "runs", "walks", "jumps", "hops", "skips", "leaps", "bounds", "dashes",
+        "races", "sprints", "zooms", "zips", "flies", "soars", "glides",
+        "floats", "drifts", "swims", "dives", "surfs", "rides", "sails",
+        "climbs", "scales", "ascends", "descends", "slides", "slips", "rolls",
+        "spins", "twirls", "whirls", "rotates", "orbits", "circles", "loops",
+        "bounces", "springs", "vaults", "launches",
+        "builds", "creates", "makes", "crafts", "forges", "shapes", "molds", "forms",
+        "designs", "draws", "paints", "sketches", "writes", "codes", "types",
+        "clicks", "taps", "swipes", "scrolls", "drags", "drops", "picks",
+        "grabs", "holds", "carries", "lifts", "throws", "catches", "tosses",
+        "pushes", "pulls", "moves", "shifts", "slides", "turns", "flips",
+        "spins", "rotates", "twists", "bends",
+        "talks", "speaks", "says", "tells", "asks", "answers", "replies", "responds",
+        "shouts", "yells", "screams", "whispers", "murmurs", "mutters", "hums",
+        "sings", "chants", "calls", "cries", "laughs", "giggles", "chuckles",
+        "smiles", "grins", "beams", "glows", "shines", "sparkles", "glitters",
+        "blinks", "winks", "nods", "waves", "signals", "points", "gestures",
+        "shows", "reveals", "displays", "presents",
+        "thinks", "ponders", "wonders", "considers", "reflects", "meditates", "contemplates", "muses",
+        "dreams", "imagines", "envisions", "pictures", "visualizes", "sees", "views",
+        "watches", "observes", "notices", "spots", "finds", "discovers", "detects",
+        "learns", "studies", "reads", "explores", "investigates", "examines", "analyzes",
+        "solves", "figures", "calculates", "computes", "measures", "counts", "tallies",
+        "remembers", "recalls", "recollects", "recognizes",
+        "wins", "succeeds", "achieves", "accomplishes", "completes", "finishes", "conquers", "triumphs",
+        "celebrates", "cheers", "rejoices", "delights", "enjoys", "loves", "adores",
+        "helps", "aids", "assists", "supports", "guides", "leads", "directs",
+        "protects", "guards", "defends", "shields", "saves", "rescues", "recovers",
+        "heals", "fixes", "repairs", "restores", "renews", "refreshes", "revives",
+        "thrives", "grows", "blooms", "flourishes",
+        "compiles", "deploys", "merges", "commits", "pushes", "pulls", "clones", "forks",
+        "branches", "tags", "releases", "patches", "updates", "upgrades", "installs",
+        "uninstalls", "configures", "optimizes", "debugs", "tests", "validates", "verifies",
+        "authenticates", "authorizes", "encrypts", "decrypts", "compresses", "decompresses", "archives", "extracts",
+        "invents", "innovates", "improvises", "experiments", "discovers", "pioneers", "explores", "ventures",
+        "adapts", "evolves", "transforms", "revolutionizes", "reimagines", "redefines", "reinvents",
+        "generates", "synthesizes", "composes", "orchestrates", "choreographs"
+    ]
+}

package/dist/utils/state.d.ts

@@ -0,0 +1,57 @@
+export declare const EKKOS_DIR: string;
+export declare const STATE_FILE: string;
+export declare const AUTO_CLEAR_FLAG: string;
+export declare const CONFIG_FILE: string;
+export interface EkkosState {
+    sessionName: string;
+    sessionId: string;
+    turnNumber: number;
+    lastUpdated: string;
+    projectPath: string;
+}
+export interface EkkosConfig {
+    hookApiKey?: string;
+    apiKey?: string;
+    userId?: string;
+}
+/**
+ * Convert UUID to memorable 3-word name (adj-noun-verb)
+ * Deterministic: same UUID always produces same name
+ */
+export declare function uuidToWords(uuid: string): string;
+/**
+ * Ensure .ekkos directory exists
+ */
+export declare function ensureEkkosDir(): void;
+/**
+ * Get current session state
+ */
+export declare function getState(): EkkosState | null;
+/**
+ * Update session state
+ */
+export declare function updateState(updates: Partial<EkkosState>): EkkosState;
+/**
+ * Get current session name
+ */
+export declare function getCurrentSessionName(): string | null;
+/**
+ * Get ekkOS config
+ */
+export declare function getConfig(): EkkosConfig | null;
+/**
+ * Get auth token from config
+ */
+export declare function getAuthToken(): string | null;
+/**
+ * Clear auto-clear flag file
+ */
+export declare function clearAutoClearFlag(): void;
+/**
+ * Parse auto-clear flag file
+ */
+export declare function parseAutoClearFlag(): {
+    percent: number;
+    session: string;
+    timestamp: number;
+} | null;

package/dist/utils/state.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_FILE = exports.AUTO_CLEAR_FLAG = exports.STATE_FILE = exports.EKKOS_DIR = void 0;
+exports.uuidToWords = uuidToWords;
+exports.ensureEkkosDir = ensureEkkosDir;
+exports.getState = getState;
+exports.updateState = updateState;
+exports.getCurrentSessionName = getCurrentSessionName;
+exports.getConfig = getConfig;
+exports.getAuthToken = getAuthToken;
+exports.clearAutoClearFlag = clearAutoClearFlag;
+exports.parseAutoClearFlag = parseAutoClearFlag;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// State file paths
+exports.EKKOS_DIR = path.join(os.homedir(), '.ekkos');
+exports.STATE_FILE = path.join(exports.EKKOS_DIR, 'state.json');
+exports.AUTO_CLEAR_FLAG = path.join(exports.EKKOS_DIR, 'auto-clear.flag');
+exports.CONFIG_FILE = path.join(exports.EKKOS_DIR, 'config.json');
+// SINGLE SOURCE OF TRUTH: Import word lists from shared JSON
+// Must match: apps/web, apps/memory, .claude/hooks
+const session_words_json_1 = __importDefault(require("./session-words.json"));
+const ADJECTIVES = session_words_json_1.default.adjectives;
+const NOUNS = session_words_json_1.default.nouns;
+const VERBS = session_words_json_1.default.verbs;
+/**
+ * Convert UUID to memorable 3-word name (adj-noun-verb)
+ * Deterministic: same UUID always produces same name
+ */
+function uuidToWords(uuid) {
+    // Remove dashes and take first 12 hex chars
+    const hex = uuid.replace(/-/g, '').slice(0, 12);
+    if (!/^[0-9a-fA-F]+$/.test(hex)) {
+        return 'unknown-session-starts';
+    }
+    // Use different 4-char segments for each word
+    const adjSeed = parseInt(hex.slice(0, 4), 16);
+    const nounSeed = parseInt(hex.slice(4, 8), 16);
+    const verbSeed = parseInt(hex.slice(8, 12), 16);
+    const adjIdx = adjSeed % ADJECTIVES.length;
+    const nounIdx = nounSeed % NOUNS.length;
+    const verbIdx = verbSeed % VERBS.length;
+    return `${ADJECTIVES[adjIdx]}-${NOUNS[nounIdx]}-${VERBS[verbIdx]}`;
+}
+/**
+ * Ensure .ekkos directory exists
+ */
+function ensureEkkosDir() {
+    if (!fs.existsSync(exports.EKKOS_DIR)) {
+        fs.mkdirSync(exports.EKKOS_DIR, { recursive: true });
+    }
+}
+/**
+ * Get current session state
+ */
+function getState() {
+    try {
+        if (fs.existsSync(exports.STATE_FILE)) {
+            const content = fs.readFileSync(exports.STATE_FILE, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Update session state
+ */
+function updateState(updates) {
+    ensureEkkosDir();
+    const current = getState() || {
+        sessionName: '',
+        sessionId: '',
+        turnNumber: 0,
+        lastUpdated: '',
+        projectPath: process.cwd()
+    };
+    const newState = {
+        ...current,
+        ...updates,
+        lastUpdated: new Date().toISOString()
+    };
+    fs.writeFileSync(exports.STATE_FILE, JSON.stringify(newState, null, 2));
+    return newState;
+}
+/**
+ * Get current session name
+ */
+function getCurrentSessionName() {
+    const state = getState();
+    return state?.sessionName || null;
+}
+/**
+ * Get ekkOS config
+ */
+function getConfig() {
+    try {
+        if (fs.existsSync(exports.CONFIG_FILE)) {
+            const content = fs.readFileSync(exports.CONFIG_FILE, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Get auth token from config
+ */
+function getAuthToken() {
+    const config = getConfig();
+    return config?.hookApiKey || config?.apiKey || null;
+}
+/**
+ * Clear auto-clear flag file
+ */
+function clearAutoClearFlag() {
+    try {
+        if (fs.existsSync(exports.AUTO_CLEAR_FLAG)) {
+            fs.unlinkSync(exports.AUTO_CLEAR_FLAG);
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+}
+/**
+ * Parse auto-clear flag file
+ */
+function parseAutoClearFlag() {
+    try {
+        if (fs.existsSync(exports.AUTO_CLEAR_FLAG)) {
+            const content = fs.readFileSync(exports.AUTO_CLEAR_FLAG, 'utf-8').trim();
+            const [percent, session, timestamp] = content.split(':');
+            return {
+                percent: parseInt(percent, 10),
+                session: session || 'unknown',
+                timestamp: parseInt(timestamp, 10) || Date.now() / 1000
+            };
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}

package/dist/utils/templates.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Get the path to a template file or directory
+ */
+export declare function getTemplatePath(...paths: string[]): string;
+/**
+ * Check if templates exist
+ */
+export declare function templatesExist(): boolean;
+/**
+ * Read a template file
+ */
+export declare function readTemplate(relativePath: string): string;
+/**
+ * Copy a single file, creating parent directories as needed
+ */
+export declare function copyTemplateFile(templatePath: string, destPath: string, transform?: (content: string) => string): void;
+/**
+ * Recursively copy a directory of templates
+ */
+export declare function copyTemplateDir(templateDir: string, destDir: string, transform?: (content: string, filePath: string) => string): number;
+/**
+ * List template directories (for skills, agents, plugins)
+ */
+export declare function listTemplateDirs(templateDir: string): string[];

package/dist/utils/templates.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTemplatePath = getTemplatePath;
+exports.templatesExist = templatesExist;
+exports.readTemplate = readTemplate;
+exports.copyTemplateFile = copyTemplateFile;
+exports.copyTemplateDir = copyTemplateDir;
+exports.listTemplateDirs = listTemplateDirs;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const platform_1 = require("./platform");
+// Templates directory (symlinked to shared /templates/)
+const TEMPLATES_DIR = (0, path_1.join)((0, path_1.dirname)((0, path_1.dirname)(__dirname)), 'templates');
+/**
+ * Get the path to a template file or directory
+ */
+function getTemplatePath(...paths) {
+    return (0, path_1.join)(TEMPLATES_DIR, ...paths);
+}
+/**
+ * Check if templates exist
+ */
+function templatesExist() {
+    return (0, fs_1.existsSync)(TEMPLATES_DIR) && (0, fs_1.existsSync)(getTemplatePath('hooks'));
+}
+/**
+ * Read a template file
+ */
+function readTemplate(relativePath) {
+    const fullPath = getTemplatePath(relativePath);
+    if (!(0, fs_1.existsSync)(fullPath)) {
+        throw new Error(`Template not found: ${relativePath}`);
+    }
+    return (0, fs_1.readFileSync)(fullPath, 'utf-8');
+}
+/**
+ * Copy a single file, creating parent directories as needed
+ */
+function copyTemplateFile(templatePath, destPath, transform) {
+    const sourcePath = getTemplatePath(templatePath);
+    if (!(0, fs_1.existsSync)(sourcePath)) {
+        throw new Error(`Template not found: ${templatePath}`);
+    }
+    // Ensure destination directory exists
+    const destDir = (0, path_1.dirname)(destPath);
+    if (!(0, fs_1.existsSync)(destDir)) {
+        (0, fs_1.mkdirSync)(destDir, { recursive: true });
+    }
+    if (transform) {
+        // Read, transform, and write
+        let content = (0, fs_1.readFileSync)(sourcePath, 'utf-8');
+        content = transform(content);
+        (0, fs_1.writeFileSync)(destPath, content);
+    }
+    else {
+        // Direct copy
+        (0, fs_1.copyFileSync)(sourcePath, destPath);
+    }
+    // Make shell scripts executable on Unix
+    if (!platform_1.isWindows && destPath.endsWith('.sh')) {
+        (0, fs_1.chmodSync)(destPath, '755');
+    }
+}
+/**
+ * Recursively copy a directory of templates
+ */
+function copyTemplateDir(templateDir, destDir, transform) {
+    const sourcePath = getTemplatePath(templateDir);
+    if (!(0, fs_1.existsSync)(sourcePath)) {
+        throw new Error(`Template directory not found: ${templateDir}`);
+    }
+    if (!(0, fs_1.existsSync)(destDir)) {
+        (0, fs_1.mkdirSync)(destDir, { recursive: true });
+    }
+    let fileCount = 0;
+    const entries = (0, fs_1.readdirSync)(sourcePath);
+    for (const entry of entries) {
+        // Skip hidden files like .DS_Store
+        if (entry.startsWith('.'))
+            continue;
+        const sourceEntry = (0, path_1.join)(sourcePath, entry);
+        const destEntry = (0, path_1.join)(destDir, entry);
+        const stat = (0, fs_1.statSync)(sourceEntry);
+        if (stat.isDirectory()) {
+            // Recurse into subdirectory
+            fileCount += copyTemplateDir((0, path_1.join)(templateDir, entry), destEntry, transform);
+        }
+        else {
+            // Copy file
+            if (transform) {
+                let content = (0, fs_1.readFileSync)(sourceEntry, 'utf-8');
+                content = transform(content, entry);
+                (0, fs_1.writeFileSync)(destEntry, content);
+            }
+            else {
+                (0, fs_1.copyFileSync)(sourceEntry, destEntry);
+            }
+            // Make shell scripts executable
+            if (!platform_1.isWindows && entry.endsWith('.sh')) {
+                (0, fs_1.chmodSync)(destEntry, '755');
+            }
+            fileCount++;
+        }
+    }
+    return fileCount;
+}
+/**
+ * List template directories (for skills, agents, plugins)
+ */
+function listTemplateDirs(templateDir) {
+    const sourcePath = getTemplatePath(templateDir);
+    if (!(0, fs_1.existsSync)(sourcePath)) {
+        return [];
+    }
+    return (0, fs_1.readdirSync)(sourcePath)
+        .filter(entry => !entry.startsWith('.'))
+        .filter(entry => (0, fs_1.statSync)((0, path_1.join)(sourcePath, entry)).isDirectory());
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@ekkos/cli",
+  "version": "0.2.0",
+  "description": "Setup ekkOS memory for AI coding assistants (Claude Code, Cursor, Windsurf)",
+  "main": "dist/index.js",
+  "bin": {
+    "ekkos": "dist/index.js",
+    "ekkos-capture": "dist/cache/capture.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "prepack": "node scripts/build-templates.js prepack",
+    "postpack": "node scripts/build-templates.js postpack",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ekkos",
+    "ai",
+    "memory",
+    "claude-code",
+    "cursor",
+    "windsurf",
+    "mcp",
+    "anthropic"
+  ],
+  "author": "ekkOS",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "inquirer": "^9.2.23",
+    "node-pty": "1.2.0-beta.7",
+    "open": "^10.0.0",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ]
+}