notoken-core 1.0.0

package/dist/utils/verbose.d.ts

@@ -0,0 +1,27 @@
+import type { ParsedCommand } from "../types/intent.js";
+/**
+ * Generate a verbose, human-friendly restatement of the parsed command.
+ *
+ * Example output:
+ *
+ *   I understand you want to:
+ *     Action:      restart nginx
+ *     Environment: prod
+ *     Risk:        high — confirmation required
+ *     Command:     sudo systemctl restart nginx && ...
+ */
+export declare function formatVerbose(parsed: ParsedCommand): string;
+/**
+ * Format a background task notification.
+ */
+export declare function formatTaskNotification(id: number, name: string, status: "completed" | "failed", duration?: number): string;
+/**
+ * Format the background jobs list.
+ */
+export declare function formatJobsList(tasks: Array<{
+    id: number;
+    rawText: string;
+    status: string;
+    startedAt: Date;
+    completedAt?: Date;
+}>): string;

package/dist/utils/verbose.js

@@ -0,0 +1,131 @@
+import { getIntentDef } from "./config.js";
+const c = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    cyan: "\x1b[36m",
+    magenta: "\x1b[35m",
+    white: "\x1b[37m",
+};
+const RISK_COLOR = {
+    low: c.green,
+    medium: c.yellow,
+    high: c.red,
+};
+/**
+ * Generate a verbose, human-friendly restatement of the parsed command.
+ *
+ * Example output:
+ *
+ *   I understand you want to:
+ *     Action:      restart nginx
+ *     Environment: prod
+ *     Risk:        high — confirmation required
+ *     Command:     sudo systemctl restart nginx && ...
+ */
+export function formatVerbose(parsed) {
+    const { intent } = parsed;
+    const def = getIntentDef(intent.intent);
+    const lines = [];
+    lines.push(`${c.bold}I understand you want to:${c.reset}`);
+    lines.push("");
+    // Action description
+    if (def) {
+        lines.push(`  ${c.cyan}Action:${c.reset}      ${def.description}`);
+    }
+    lines.push(`  ${c.cyan}Intent:${c.reset}      ${c.bold}${intent.intent}${c.reset}`);
+    lines.push(`  ${c.cyan}Confidence:${c.reset}  ${formatConfidence(intent.confidence)}`);
+    // Fields
+    // Fields — show explicit values, skip internal/empty ones
+    const fields = Object.entries(intent.fields).filter(([k, v]) => v !== undefined && v !== "" && k !== "logPath");
+    if (fields.length > 0) {
+        lines.push("");
+        for (const [key, value] of fields) {
+            const label = key.charAt(0).toUpperCase() + key.slice(1);
+            lines.push(`  ${c.cyan}${label}:${c.reset}${" ".repeat(Math.max(1, 12 - label.length))}${c.bold}${value}${c.reset}`);
+        }
+    }
+    // Risk + confirmation
+    if (def) {
+        const riskColor = RISK_COLOR[def.riskLevel] ?? c.white;
+        const confirm = def.requiresConfirmation ? " — confirmation required" : "";
+        lines.push("");
+        lines.push(`  ${c.cyan}Risk:${c.reset}        ${riskColor}${def.riskLevel}${confirm}${c.reset}`);
+    }
+    // Show the resolved command template
+    if (def) {
+        const command = previewCommand(def, intent.fields);
+        if (command.length < 120) {
+            lines.push(`  ${c.cyan}Command:${c.reset}     ${c.dim}${command}${c.reset}`);
+        }
+        else {
+            lines.push(`  ${c.cyan}Command:${c.reset}     ${c.dim}${command.slice(0, 117)}...${c.reset}`);
+        }
+    }
+    // Warnings
+    if (parsed.needsClarification) {
+        lines.push("");
+        lines.push(`  ${c.yellow}⚠ Clarification needed${c.reset}`);
+        if (parsed.missingFields.length > 0) {
+            lines.push(`    Missing: ${parsed.missingFields.join(", ")}`);
+        }
+        for (const a of parsed.ambiguousFields) {
+            lines.push(`    ${a.field}: did you mean ${a.candidates.join(" or ")}?`);
+        }
+    }
+    return lines.join("\n");
+}
+function formatConfidence(conf) {
+    const pct = (conf * 100).toFixed(0);
+    if (conf >= 0.8)
+        return `${c.green}${pct}%${c.reset}`;
+    if (conf >= 0.6)
+        return `${c.yellow}${pct}%${c.reset}`;
+    return `${c.red}${pct}%${c.reset}`;
+}
+function previewCommand(def, fields) {
+    let cmd = def.command;
+    for (const [key, value] of Object.entries(fields)) {
+        if (value !== undefined && value !== null) {
+            cmd = cmd.replaceAll(`{{${key}}}`, String(value));
+        }
+    }
+    for (const [name, fieldDef] of Object.entries(def.fields)) {
+        if (fieldDef.default !== undefined) {
+            cmd = cmd.replaceAll(`{{${name}}}`, String(fieldDef.default));
+        }
+    }
+    cmd = cmd.replace(/\{\{[a-zA-Z_]+\}\}/g, "").trim();
+    return cmd;
+}
+/**
+ * Format a background task notification.
+ */
+export function formatTaskNotification(id, name, status, duration) {
+    const icon = status === "completed" ? `${c.green}✓${c.reset}` : `${c.red}✗${c.reset}`;
+    const dur = duration ? ` (${(duration / 1000).toFixed(1)}s)` : "";
+    return `\n${icon} ${c.dim}[bg #${id}]${c.reset} ${name} ${status}${dur}`;
+}
+/**
+ * Format the background jobs list.
+ */
+export function formatJobsList(tasks) {
+    if (tasks.length === 0)
+        return `${c.dim}No background tasks.${c.reset}`;
+    const lines = [];
+    lines.push(`${c.bold}Background tasks:${c.reset}`);
+    for (const t of tasks) {
+        const statusColor = t.status === "running" ? c.cyan :
+            t.status === "completed" ? c.green :
+                t.status === "failed" ? c.red :
+                    c.yellow;
+        const duration = t.completedAt
+            ? `${((t.completedAt.getTime() - t.startedAt.getTime()) / 1000).toFixed(1)}s`
+            : `${((Date.now() - t.startedAt.getTime()) / 1000).toFixed(0)}s...`;
+        lines.push(`  ${c.dim}#${t.id}${c.reset} ${statusColor}${t.status.padEnd(10)}${c.reset} ${t.rawText} ${c.dim}(${duration})${c.reset}`);
+    }
+    return lines.join("\n");
+}

package/dist/utils/wslPaths.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Windows/WSL path support.
+ *
+ * Handles:
+ * - Detecting WSL environment
+ * - Converting between Windows (C:\Users\...) and Linux (/mnt/c/Users/...) paths
+ * - Resolving ~ and %USERPROFILE% across platforms
+ * - Path normalization for cross-platform commands
+ */
+declare const isWSL: any;
+declare const isWindows: boolean;
+/**
+ * Convert a Windows path to WSL Linux path.
+ * C:\Users\dino\docs → /mnt/c/Users/dino/docs
+ */
+export declare function winToLinux(winPath: string): string;
+/**
+ * Convert a WSL Linux path to Windows path.
+ * /mnt/c/Users/dino/docs → C:\Users\dino\docs
+ */
+export declare function linuxToWin(linuxPath: string): string;
+/**
+ * Normalize a path for the current platform.
+ * Accepts either Windows or Linux format, returns appropriate format.
+ */
+export declare function normalizePath(inputPath: string): string;
+/**
+ * Get common user directories in the correct format.
+ */
+export declare function getUserDirs(): Record<string, string>;
+export { isWSL, isWindows };

package/dist/utils/wslPaths.js

@@ -0,0 +1,145 @@
+/**
+ * Windows/WSL path support.
+ *
+ * Handles:
+ * - Detecting WSL environment
+ * - Converting between Windows (C:\Users\...) and Linux (/mnt/c/Users/...) paths
+ * - Resolving ~ and %USERPROFILE% across platforms
+ * - Path normalization for cross-platform commands
+ */
+import { execSync } from "node:child_process";
+import { platform as osPlatform } from "node:os";
+import { resolve } from "node:path";
+const isWSL = osPlatform() === "linux" && (process.env.WSL_DISTRO_NAME !== undefined ||
+    process.env.WSLENV !== undefined ||
+    (() => { try {
+        return require("os").release().toLowerCase().includes("microsoft");
+    }
+    catch {
+        return false;
+    } })());
+const isWindows = osPlatform() === "win32";
+/**
+ * Convert a Windows path to WSL Linux path.
+ * C:\Users\dino\docs → /mnt/c/Users/dino/docs
+ */
+export function winToLinux(winPath) {
+    if (!winPath)
+        return winPath;
+    // Already a Linux path
+    if (winPath.startsWith("/"))
+        return winPath;
+    // Try wslpath if available (most reliable)
+    if (isWSL) {
+        try {
+            return execSync(`wslpath -u ${JSON.stringify(winPath)}`, { encoding: "utf-8", timeout: 3000 }).trim();
+        }
+        catch { }
+    }
+    // Manual conversion: C:\Users\... → /mnt/c/Users/...
+    const match = winPath.match(/^([A-Za-z]):[\\\/](.*)/);
+    if (match) {
+        const drive = match[1].toLowerCase();
+        const rest = match[2].replace(/\\/g, "/");
+        return `/mnt/${drive}/${rest}`;
+    }
+    // UNC path: \\server\share → /mnt/server/share (approximation)
+    if (winPath.startsWith("\\\\")) {
+        return winPath.replace(/\\/g, "/").replace(/^\/\//, "/mnt/");
+    }
+    return winPath;
+}
+/**
+ * Convert a WSL Linux path to Windows path.
+ * /mnt/c/Users/dino/docs → C:\Users\dino\docs
+ */
+export function linuxToWin(linuxPath) {
+    if (!linuxPath)
+        return linuxPath;
+    // Already a Windows path
+    if (/^[A-Za-z]:/.test(linuxPath))
+        return linuxPath;
+    // Try wslpath if available
+    if (isWSL) {
+        try {
+            return execSync(`wslpath -w ${JSON.stringify(linuxPath)}`, { encoding: "utf-8", timeout: 3000 }).trim();
+        }
+        catch { }
+    }
+    // Manual: /mnt/c/Users/... → C:\Users\...
+    const match = linuxPath.match(/^\/mnt\/([a-z])\/(.*)/);
+    if (match) {
+        const drive = match[1].toUpperCase();
+        const rest = match[2].replace(/\//g, "\\");
+        return `${drive}:\\${rest}`;
+    }
+    return linuxPath;
+}
+/**
+ * Normalize a path for the current platform.
+ * Accepts either Windows or Linux format, returns appropriate format.
+ */
+export function normalizePath(inputPath) {
+    if (!inputPath)
+        return inputPath;
+    // Expand ~ to home directory
+    if (inputPath.startsWith("~")) {
+        const home = process.env.HOME || process.env.USERPROFILE || "";
+        inputPath = resolve(home, inputPath.slice(2));
+    }
+    // Expand %USERPROFILE% (Windows env var)
+    if (inputPath.includes("%USERPROFILE%")) {
+        const profile = process.env.USERPROFILE || process.env.HOME || "";
+        inputPath = inputPath.replace(/%USERPROFILE%/gi, profile);
+    }
+    // On WSL: convert Windows paths to Linux paths
+    if (isWSL && /^[A-Za-z]:/.test(inputPath)) {
+        return winToLinux(inputPath);
+    }
+    // On Windows: convert Linux-style /mnt/c paths
+    if (isWindows && inputPath.startsWith("/mnt/")) {
+        return linuxToWin(inputPath);
+    }
+    return inputPath;
+}
+/**
+ * Get common user directories in the correct format.
+ */
+export function getUserDirs() {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    if (isWindows) {
+        const profile = process.env.USERPROFILE || "";
+        return {
+            home: profile,
+            documents: resolve(profile, "Documents"),
+            downloads: resolve(profile, "Downloads"),
+            desktop: resolve(profile, "Desktop"),
+        };
+    }
+    if (isWSL) {
+        // In WSL, get both Linux home and Windows home
+        const winHome = tryExec("wslpath -u \"$(cmd.exe /c 'echo %USERPROFILE%' 2>/dev/null | tr -d '\\r')\"");
+        return {
+            home,
+            documents: winHome ? `${winHome}/Documents` : resolve(home, "Documents"),
+            downloads: winHome ? `${winHome}/Downloads` : resolve(home, "Downloads"),
+            desktop: winHome ? `${winHome}/Desktop` : resolve(home, "Desktop"),
+            winHome: winHome || "",
+        };
+    }
+    return {
+        home,
+        documents: resolve(home, "Documents"),
+        downloads: resolve(home, "Downloads"),
+        desktop: resolve(home, "Desktop"),
+    };
+}
+export { isWSL, isWindows };
+function tryExec(cmd) {
+    try {
+        return execSync(cmd, { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "notoken-core",
+  "version": "1.0.0",
+  "description": "Shared engine for notoken — NLP parsing, execution, detection, analysis",
+  "type": "module",
+  "license": "MIT",
+  "author": "Dino Bartolome",
+  "homepage": "https://notoken.sh",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/offset25/notoken-cli",
+    "directory": "packages/core"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": ["dist/", "config/"],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "compromise": "^14.15.0",
+    "dotenv": "^17.3.1",
+    "simple-git": "^3.33.0",
+    "yaml": "^2.8.3",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.6.1"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}