notoken-core 1.6.0 → 2.0.0

package/dist/utils/smartArchive.js

@@ -0,0 +1,172 @@
+/**
+ * Smart archive creation.
+ *
+ * Auto-excludes heavy/non-essential directories (node_modules, .git, etc.)
+ * unless the user explicitly requests them. Checks disk space before archiving.
+ */
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync, statSync } from "node:fs";
+import { resolve, basename } from "node:path";
+import { detectLocalPlatform } from "./platform.js";
+import { askForConfirmation } from "../policy/confirm.js";
+const execAsync = promisify(exec);
+const c = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", cyan: "\x1b[36m",
+};
+/** Directories that are safe to exclude by default (regenerable/cached). */
+const DEFAULT_EXCLUDES = [
+    "node_modules",
+    ".git",
+    ".next",
+    ".nuxt",
+    "dist",
+    "build",
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".env.local",
+    ".cache",
+    ".turbo",
+    "vendor", // PHP composer
+    "target", // Rust cargo
+    ".gradle",
+    ".idea",
+    ".vscode",
+    "*.pyc",
+    "*.o",
+    "*.class",
+    ".DS_Store",
+    "Thumbs.db",
+];
+/** Estimate the size of a directory (excluding default excludes). */
+async function estimateSize(source, excludes) {
+    const plat = detectLocalPlatform();
+    try {
+        // Total size
+        const { stdout: totalOut } = await execAsync(`du -sb "${source}" 2>/dev/null | cut -f1`, { timeout: 30_000 });
+        const totalBytes = parseInt(totalOut.trim()) || 0;
+        // Size of excluded dirs
+        let excludedBytes = 0;
+        for (const ex of excludes) {
+            if (ex.startsWith("*"))
+                continue; // skip glob patterns
+            const exPath = resolve(source, ex);
+            if (existsSync(exPath)) {
+                try {
+                    const { stdout } = await execAsync(`du -sb "${exPath}" 2>/dev/null | cut -f1`, { timeout: 10_000 });
+                    excludedBytes += parseInt(stdout.trim()) || 0;
+                }
+                catch { }
+            }
+        }
+        return {
+            totalGB: totalBytes / 1073741824,
+            excludedGB: excludedBytes / 1073741824,
+        };
+    }
+    catch {
+        return { totalGB: 0, excludedGB: 0 };
+    }
+}
+/** Check available disk space at a path. */
+async function getAvailableSpaceGB(path) {
+    try {
+        const { stdout } = await execAsync(`df -B1 "${path}" 2>/dev/null | tail -1 | awk '{print $4}'`, { timeout: 5000 });
+        return parseInt(stdout.trim()) / 1073741824;
+    }
+    catch {
+        return -1; // unknown
+    }
+}
+/**
+ * Smart archive: checks space, shows what will be excluded, asks before creating.
+ */
+export async function smartArchive(options) {
+    const source = resolve(options.source);
+    const lines = [];
+    if (!existsSync(source)) {
+        return `${c.red}✗ Source not found: ${source}${c.reset}`;
+    }
+    // Determine destination
+    const destName = options.destination || `${basename(source)}.tar.gz`;
+    const dest = resolve(destName.endsWith(".tar.gz") || destName.endsWith(".tgz") ? destName : destName + ".tar.gz");
+    // Determine exclusions
+    const excludes = options.includeAll ? [] : DEFAULT_EXCLUDES;
+    const foundExcludes = [];
+    // Check which excludable dirs actually exist in source
+    if (!options.includeAll) {
+        for (const ex of DEFAULT_EXCLUDES) {
+            if (ex.startsWith("*"))
+                continue;
+            const exPath = resolve(source, ex);
+            if (existsSync(exPath)) {
+                try {
+                    const stat = statSync(exPath);
+                    if (stat.isDirectory()) {
+                        const { stdout } = await execAsync(`du -sb "${exPath}" 2>/dev/null | cut -f1`, { timeout: 10_000 });
+                        const sizeGB = parseInt(stdout.trim()) / 1073741824;
+                        foundExcludes.push({ name: ex, sizeGB });
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    // Estimate sizes
+    const sizes = await estimateSize(source, options.includeAll ? [] : DEFAULT_EXCLUDES.filter(e => !e.startsWith("*")));
+    const archiveEstimateGB = (sizes.totalGB - sizes.excludedGB) * 0.3; // rough compression ratio
+    const availableGB = await getAvailableSpaceGB(resolve(dest, ".."));
+    lines.push(`\n${c.bold}${c.cyan}── Smart Archive ──${c.reset}\n`);
+    lines.push(`  Source:      ${c.bold}${source}${c.reset}`);
+    lines.push(`  Destination: ${c.bold}${dest}${c.reset}`);
+    lines.push(`  Source size: ${c.bold}${sizes.totalGB.toFixed(2)} GB${c.reset}`);
+    if (foundExcludes.length > 0) {
+        const totalExcluded = foundExcludes.reduce((s, e) => s + e.sizeGB, 0);
+        lines.push(`\n  ${c.bold}Auto-excluding (${totalExcluded.toFixed(2)} GB saved):${c.reset}`);
+        for (const ex of foundExcludes.sort((a, b) => b.sizeGB - a.sizeGB)) {
+            const sizeStr = ex.sizeGB >= 1 ? `${ex.sizeGB.toFixed(2)} GB` : `${(ex.sizeGB * 1024).toFixed(0)} MB`;
+            lines.push(`    ${c.yellow}${sizeStr.padStart(10)}${c.reset}  ${ex.name}/`);
+        }
+        lines.push(`\n  ${c.dim}To include everything: add "include all" or "with node_modules"${c.reset}`);
+    }
+    lines.push(`\n  Estimated archive: ${c.bold}~${archiveEstimateGB.toFixed(2)} GB${c.reset} ${c.dim}(compressed)${c.reset}`);
+    // Space check
+    if (availableGB >= 0) {
+        lines.push(`  Available space:  ${c.bold}${availableGB.toFixed(2)} GB${c.reset}`);
+        if (archiveEstimateGB > availableGB * 0.9) {
+            lines.push(`\n  ${c.red}${c.bold}⚠ NOT ENOUGH SPACE!${c.reset} Archive (~${archiveEstimateGB.toFixed(2)} GB) may exceed available space (${availableGB.toFixed(2)} GB).`);
+            lines.push(`  ${c.yellow}Free up space first: notoken "free up space"${c.reset}`);
+            return lines.join("\n");
+        }
+        else if (archiveEstimateGB > availableGB * 0.5) {
+            lines.push(`  ${c.yellow}⚠ This will use ${Math.round((archiveEstimateGB / availableGB) * 100)}% of remaining space.${c.reset}`);
+        }
+        else {
+            lines.push(`  ${c.green}✓ Plenty of space.${c.reset}`);
+        }
+    }
+    console.log(lines.join("\n"));
+    // Confirm
+    const ok = await askForConfirmation(`\nCreate archive?`);
+    if (!ok) {
+        return `${c.dim}Cancelled.${c.reset}`;
+    }
+    // Build tar command
+    const excludeFlags = excludes.map((e) => `--exclude='${e}'`).join(" ");
+    const tarCmd = `tar -czf "${dest}" ${excludeFlags} -C "${resolve(source, "..")}" "${basename(source)}"`;
+    console.log(`\n${c.dim}→ ${tarCmd}${c.reset}`);
+    try {
+        await execAsync(tarCmd, { timeout: 600_000 }); // 10 min timeout for large archives
+        // Show result
+        const stat = statSync(dest);
+        const resultGB = stat.size / 1073741824;
+        const sizeStr = resultGB >= 1 ? `${resultGB.toFixed(2)} GB` : `${(resultGB * 1024).toFixed(0)} MB`;
+        return `\n${c.green}${c.bold}✓ Archive created: ${dest}${c.reset}\n  Size: ${c.bold}${sizeStr}${c.reset}`;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return `\n${c.red}✗ Archive failed: ${msg.split("\n")[0]}${c.reset}`;
+    }
+}

package/dist/utils/smartRetry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Smart Retry — analyzes command failures and suggests fixes.
+ *
+ * When a command fails, this module inspects the error message,
+ * identifies common patterns, and suggests an actionable fix
+ * that can be registered as a pending action.
+ */
+export interface FailureAnalysis {
+    /** Whether this failure has an automated fix */
+    canFix: boolean;
+    /** Short human-friendly suggestion shown to the user */
+    suggestion: string;
+    /** The command/intent text to execute as the fix */
+    fixCommand: string;
+    /** Why this fix should help */
+    explanation: string;
+}
+/**
+ * Analyze a command failure and suggest a fix.
+ *
+ * @param intent  - The intent name or raw text that failed
+ * @param error   - The error (string or Error)
+ * @param fields  - Parsed intent fields (service name, tool, path, etc.)
+ * @returns A FailureAnalysis if a known pattern matches, or null
+ */
+export declare function analyzeFailure(intent: string, error: string | Error, fields?: Record<string, unknown>): FailureAnalysis | null;

package/dist/utils/smartRetry.js

@@ -0,0 +1,114 @@
+/**
+ * Smart Retry — analyzes command failures and suggests fixes.
+ *
+ * When a command fails, this module inspects the error message,
+ * identifies common patterns, and suggests an actionable fix
+ * that can be registered as a pending action.
+ */
+const patterns = [
+    {
+        pattern: /command not found[:\s]*(\S+)|(\S+):\s*not found|'(\S+)' is not recognized/i,
+        build: (m) => {
+            const tool = (m[1] || m[2] || m[3]).replace(/['"]/g, "");
+            return {
+                canFix: true,
+                suggestion: `${tool} is not installed. Install it?`,
+                fixCommand: `install ${tool}`,
+                explanation: `The command "${tool}" was not found on this system. Installing it should fix the issue.`,
+            };
+        },
+    },
+    {
+        pattern: /connection refused|ECONNREFUSED/i,
+        build: (_m, _intent, fields) => {
+            const service = fields.service || fields.tool || "the service";
+            return {
+                canFix: true,
+                suggestion: `Can't connect — ${service} may not be running. Start it?`,
+                fixCommand: `start ${service}`,
+                explanation: `Connection was refused, which usually means the target service is not running.`,
+            };
+        },
+    },
+    {
+        pattern: /permission denied|EACCES|access denied/i,
+        build: (_m, intent) => ({
+            canFix: true,
+            suggestion: "Permission denied. Retry with elevated privileges?",
+            fixCommand: `sudo ${intent}`,
+            explanation: "The command failed due to insufficient permissions. Running with sudo may resolve it.",
+        }),
+    },
+    {
+        pattern: /no such file or directory[:\s]*(.+)|ENOENT[:\s]*(.+)/i,
+        build: (m) => {
+            const raw = (m[1] || m[2] || "").trim().replace(/['"]/g, "");
+            const filename = raw.split("/").pop() || raw;
+            return {
+                canFix: true,
+                suggestion: `File not found: ${filename}. Search for it?`,
+                fixCommand: `find ${filename}`,
+                explanation: `The path "${raw}" does not exist. A search may locate the correct path.`,
+            };
+        },
+    },
+    {
+        pattern: /address already in use|port.*already in use|EADDRINUSE/i,
+        build: () => ({
+            canFix: true,
+            suggestion: "Port already in use. Check what's using it?",
+            fixCommand: "check ports",
+            explanation: "Another process is occupying the required port.",
+        }),
+    },
+    {
+        pattern: /no space left|disk full|ENOSPC/i,
+        build: () => ({
+            canFix: true,
+            suggestion: "Disk is full. Free up space?",
+            fixCommand: "free up space",
+            explanation: "The disk has no remaining space. Clearing caches or temp files may help.",
+        }),
+    },
+    {
+        pattern: /timed?\s*out|ETIMEDOUT|ESOCKETTIMEDOUT/i,
+        build: (_m, intent) => ({
+            canFix: true,
+            suggestion: "Command timed out. Try again?",
+            fixCommand: intent,
+            explanation: "The operation exceeded its time limit. A retry may succeed if the issue was transient.",
+        }),
+    },
+    {
+        pattern: /ECONNREFUSED/i,
+        build: (_m, _intent, fields) => {
+            const service = fields.service || fields.tool || "the service";
+            return {
+                canFix: true,
+                suggestion: `Can't connect to ${service}. Check if it's running?`,
+                fixCommand: `check status ${service}`,
+                explanation: "The connection was actively refused — the target service may be down.",
+            };
+        },
+    },
+];
+/**
+ * Analyze a command failure and suggest a fix.
+ *
+ * @param intent  - The intent name or raw text that failed
+ * @param error   - The error (string or Error)
+ * @param fields  - Parsed intent fields (service name, tool, path, etc.)
+ * @returns A FailureAnalysis if a known pattern matches, or null
+ */
+export function analyzeFailure(intent, error, fields = {}) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message)
+        return null;
+    for (const { pattern, build } of patterns) {
+        const match = message.match(pattern);
+        if (match) {
+            return build(match, intent, fields);
+        }
+    }
+    return null;
+}

package/dist/utils/updater.d.ts

@@ -30,3 +30,4 @@ export declare function runUpdate(): string;
  * Format update banner for terminal.
  */
 export declare function formatUpdateBanner(info: UpdateInfo): string;
+export declare function isNewer(latest: string, current: string): boolean;

package/dist/utils/updater.js

@@ -113,7 +113,7 @@ function getInstalledVersion() {
         return "0.0.0";
     }
 }
-function isNewer(latest, current) {
+export function isNewer(latest, current) {
     const l = latest.split(".").map(Number);
     const c = current.split(".").map(Number);
     for (let i = 0; i < 3; i++) {

package/dist/utils/version.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Version check and self-upgrade utilities.
+ *
+ * Checks npm registry for latest published version and compares
+ * with the locally installed version.
+ */
+/** Get the current local version from package.json. */
+export declare function getLocalVersion(): string;
+/** Fetch the latest version from npm registry (non-blocking, best-effort). */
+export declare function getLatestVersion(): Promise<string | null>;
+/** Compare two semver strings. Returns 1 if a > b, -1 if a < b, 0 if equal. */
+export declare function compareSemver(a: string, b: string): number;
+/** Check if an update is available. Returns formatted message or null. */
+export declare function checkForUpdate(): Promise<string | null>;
+/** Run the upgrade. Records current version before upgrading for rollback. */
+export declare function runUpgrade(): Promise<void>;
+/** Roll back to the previous version. */
+export declare function runRollback(targetVersion?: string): Promise<void>;
+/** Show version history. */
+export declare function showVersionHistory(): void;

package/dist/utils/version.js

@@ -0,0 +1,212 @@
+/**
+ * Version check and self-upgrade utilities.
+ *
+ * Checks npm registry for latest published version and compares
+ * with the locally installed version.
+ */
+import { execSync } from "node:child_process";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+const c = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", cyan: "\x1b[36m",
+};
+/** Get the current local version from package.json. */
+export function getLocalVersion() {
+    try {
+        // Try relative to this file first (works in dist/)
+        const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), "../../package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+/** Fetch the latest version from npm registry (non-blocking, best-effort). */
+export async function getLatestVersion() {
+    try {
+        const result = execSync("npm view notoken version 2>/dev/null", {
+            encoding: "utf-8",
+            timeout: 10_000,
+        }).trim();
+        return result || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Compare two semver strings. Returns 1 if a > b, -1 if a < b, 0 if equal. */
+export function compareSemver(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((pa[i] ?? 0) > (pb[i] ?? 0))
+            return 1;
+        if ((pa[i] ?? 0) < (pb[i] ?? 0))
+            return -1;
+    }
+    return 0;
+}
+/** Check if an update is available. Returns formatted message or null. */
+export async function checkForUpdate() {
+    const local = getLocalVersion();
+    if (local === "unknown")
+        return null;
+    const latest = await getLatestVersion();
+    if (!latest)
+        return null;
+    if (compareSemver(latest, local) > 0) {
+        return `${c.yellow}Update available: ${c.bold}v${local}${c.reset}${c.yellow} → ${c.bold}${c.green}v${latest}${c.reset}${c.yellow}  Run: ${c.cyan}notoken upgrade${c.reset}`;
+    }
+    return null;
+}
+// ─── Version history ─────────────────────────────────────────────────────────
+const VERSION_HISTORY_PATH = resolve(homedir(), ".notoken", "version-history.json");
+function loadVersionHistory() {
+    try {
+        if (existsSync(VERSION_HISTORY_PATH)) {
+            return JSON.parse(readFileSync(VERSION_HISTORY_PATH, "utf-8"));
+        }
+    }
+    catch { }
+    return [];
+}
+function saveVersionHistory(history) {
+    const dir = dirname(VERSION_HISTORY_PATH);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(VERSION_HISTORY_PATH, JSON.stringify(history, null, 2) + "\n");
+}
+function recordVersion(version, action) {
+    const history = loadVersionHistory();
+    history.push({ version, date: new Date().toISOString(), action });
+    // Keep last 20 entries
+    if (history.length > 20)
+        history.splice(0, history.length - 20);
+    saveVersionHistory(history);
+}
+/** Get the previous version from history. */
+function getPreviousVersion() {
+    const history = loadVersionHistory();
+    // Find the second-to-last unique version
+    const versions = [...new Set(history.map((h) => h.version))];
+    return versions.length >= 2 ? versions[versions.length - 2] : null;
+}
+// ─── Upgrade ─────────────────────────────────────────────────────────────────
+/** Run the upgrade. Records current version before upgrading for rollback. */
+export async function runUpgrade() {
+    const local = getLocalVersion();
+    const latest = await getLatestVersion();
+    console.log(`${c.bold}notoken upgrade${c.reset}\n`);
+    console.log(`  Current version: ${c.bold}v${local}${c.reset}`);
+    if (!latest) {
+        console.log(`  ${c.yellow}Could not check npm registry.${c.reset}`);
+        console.log(`  ${c.dim}Try manually: npm install -g notoken@latest${c.reset}`);
+        return;
+    }
+    console.log(`  Latest version:  ${c.bold}v${latest}${c.reset}`);
+    if (compareSemver(latest, local) <= 0) {
+        console.log(`\n  ${c.green}✓ Already up to date.${c.reset}`);
+        return;
+    }
+    // Record current version before upgrading
+    recordVersion(local, "upgrade");
+    console.log(`\n  ${c.cyan}Upgrading v${local} → v${latest}...${c.reset}`);
+    console.log(`  ${c.dim}Previous version saved — run "notoken rollback" to revert.${c.reset}\n`);
+    try {
+        execSync("npm install -g notoken@latest", {
+            stdio: "inherit",
+            timeout: 120_000,
+        });
+        recordVersion(latest, "upgrade");
+        console.log(`\n  ${c.green}✓ Upgraded to v${latest}${c.reset}`);
+        console.log(`  ${c.dim}If something breaks: notoken rollback${c.reset}`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`\n  ${c.red}✗ Upgrade failed: ${msg.split("\n")[0]}${c.reset}`);
+        console.error(`  ${c.dim}Try manually: npm install -g notoken@latest${c.reset}`);
+    }
+}
+// ─── Rollback ────────────────────────────────────────────────────────────────
+/** Roll back to the previous version. */
+export async function runRollback(targetVersion) {
+    const local = getLocalVersion();
+    console.log(`${c.bold}notoken rollback${c.reset}\n`);
+    console.log(`  Current version: ${c.bold}v${local}${c.reset}`);
+    // Determine target version
+    let target = targetVersion;
+    if (!target) {
+        target = getPreviousVersion() ?? undefined;
+    }
+    if (!target) {
+        // No history — list available versions for the user to pick
+        console.log(`  ${c.yellow}No previous version in history.${c.reset}\n`);
+        console.log(`  ${c.bold}Available versions:${c.reset}`);
+        await listVersions();
+        console.log(`\n  ${c.dim}To rollback to a specific version:${c.reset}`);
+        console.log(`  ${c.cyan}notoken rollback 1.0.1${c.reset}`);
+        return;
+    }
+    if (target === local) {
+        console.log(`  ${c.green}✓ Already on v${target}.${c.reset}`);
+        return;
+    }
+    console.log(`  Rolling back to: ${c.bold}v${target}${c.reset}\n`);
+    try {
+        execSync(`npm install -g notoken@${target}`, {
+            stdio: "inherit",
+            timeout: 120_000,
+        });
+        recordVersion(target, "rollback");
+        console.log(`\n  ${c.green}✓ Rolled back to v${target}${c.reset}`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`\n  ${c.red}✗ Rollback failed: ${msg.split("\n")[0]}${c.reset}`);
+        console.error(`  ${c.dim}Try manually: npm install -g notoken@${target}${c.reset}`);
+    }
+}
+/** List recent published versions from npm. */
+async function listVersions() {
+    try {
+        const result = execSync("npm view notoken versions --json 2>/dev/null", {
+            encoding: "utf-8",
+            timeout: 10_000,
+        }).trim();
+        const versions = JSON.parse(result);
+        const recent = versions.slice(-10).reverse();
+        const local = getLocalVersion();
+        for (const v of recent) {
+            const marker = v === local ? ` ${c.green}← current${c.reset}` : "";
+            console.log(`    ${c.cyan}v${v}${c.reset}${marker}`);
+        }
+    }
+    catch {
+        console.log(`  ${c.yellow}Could not fetch versions from npm.${c.reset}`);
+    }
+}
+/** Show version history. */
+export function showVersionHistory() {
+    const history = loadVersionHistory();
+    console.log(`${c.bold}notoken version history${c.reset}\n`);
+    console.log(`  Current: ${c.bold}v${getLocalVersion()}${c.reset}\n`);
+    if (history.length === 0) {
+        console.log(`  ${c.dim}No upgrade/rollback history yet.${c.reset}`);
+        return;
+    }
+    for (const entry of history.slice(-10).reverse()) {
+        const icon = entry.action === "upgrade" ? `${c.green}↑${c.reset}` :
+            entry.action === "rollback" ? `${c.yellow}↓${c.reset}` :
+                `${c.cyan}•${c.reset}`;
+        const date = new Date(entry.date).toLocaleDateString();
+        console.log(`  ${icon} v${entry.version}  ${c.dim}${date}  ${entry.action}${c.reset}`);
+    }
+    const prev = getPreviousVersion();
+    if (prev) {
+        console.log(`\n  ${c.dim}To rollback: ${c.cyan}notoken rollback${c.reset} ${c.dim}(→ v${prev})${c.reset}`);
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "notoken-core",
-  "version": "1.6.0",
-  "description": "Shared engine for notoken — NLP parsing, execution, detection, analysis",
+  "version": "2.0.0",
+  "description": "Shared engine for notoken \u2014 NLP parsing, execution, detection, analysis",
   "type": "module",
   "license": "MIT",
   "author": "Dino Bartolome",
@@ -25,18 +25,21 @@
     "test": "vitest run"
   },
   "dependencies": {
+    "@types/ssh2": "^1.15.5",
     "compromise": "^14.15.0",
     "dotenv": "^17.3.1",
     "simple-git": "^3.33.0",
+    "ssh2": "^1.17.0",
     "yaml": "^2.8.3",
     "zod": "^3.22.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
+    "playwright": "^1.59.1",
     "typescript": "^5.3.0",
     "vitest": "^1.6.1"
   },
   "engines": {
     "node": ">=18"
   }
-}
+}