nou-cli 0.0.0-stage → 0.2.0

package/dist/src/commands/index.js

@@ -0,0 +1,125 @@
+import path from "path";
+import fs from "fs/promises";
+import { readdirSync } from "fs";
+import { exec } from "child_process";
+export const IGNORED = new Set(["node_modules", ".git", "dist", "build", ".next", "__pycache__", ".venv"]);
+function resolveInProject(filePath) {
+    const fullPath = path.resolve(process.cwd(), filePath);
+    const rel = path.relative(process.cwd(), fullPath);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new Error(`${filePath} is outside the project folder`);
+    }
+    return fullPath;
+}
+export function toRelative(filePath) {
+    return path.relative(process.cwd(), path.resolve(process.cwd(), filePath)).replace(/\\/g, "/");
+}
+export async function readFile(filepath) {
+    try {
+        const fullPath = path.resolve(process.cwd(), filepath);
+        const content = await fs.readFile(fullPath, "utf-8");
+        return content;
+    }
+    catch {
+        return "Error: File not found or could not be read.";
+    }
+}
+;
+export function runCommand(command) {
+    // Async so the UI keeps rendering while the command runs.
+    return new Promise((resolve) => {
+        exec(command, { cwd: process.cwd(), timeout: 120_000, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (error) {
+                const reason = error.killed ? "timed out after 2 minutes" : `Exit Code ${error.code ?? "?"}`;
+                resolve(`Error (${reason}): ${stderr || error.message}${stdout ? `
+${stdout}` : ""}`);
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}
+export function fileTree(dir = ".", maxDepth = 3) {
+    const lines = [];
+    const walk = (current, depth, prefix) => {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(current, { withFileTypes: true })
+                .filter((e) => !IGNORED.has(e.name))
+                .sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name));
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            lines.push(`${prefix}${entry.name}${entry.isDirectory() ? "/" : ""}`);
+            if (entry.isDirectory())
+                walk(path.join(current, entry.name), depth + 1, prefix + "  ");
+        }
+    };
+    walk(path.resolve(process.cwd(), dir), 1, "");
+    return lines.join("\n") || "(empty)";
+}
+/**
+ * Undoes common model mistakes in write_file content without touching real code:
+ * - a whole file sent as one line with literal "\n" escapes (no real newlines at all) is unescaped;
+ *   files that already have real newlines are left alone, so "\n" inside strings and regexes survives
+ * - a whole file wrapped in a markdown code fence is unwrapped
+ * Indentation and blank lines are kept; a final newline is added if missing.
+ */
+export function cleanContent(content) {
+    let text = content;
+    if (!text.includes("\n") && text.includes("\\n")) {
+        text = text.replace(/\\r\\n|\\n/g, "\n").replace(/\\t/g, "\t");
+    }
+    const fenced = text.match(/^\s*```[\w+-]*\r?\n([\s\S]*?)\r?\n```\s*$/);
+    if (fenced)
+        text = fenced[1];
+    return text.endsWith("\n") || text === "" ? text : `${text}\n`;
+}
+async function readOrEmpty(fullPath) {
+    try {
+        return await fs.readFile(fullPath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Works out what write_file would do, without touching the disk. */
+export async function proposeWrite(filePath, content) {
+    const fullPath = resolveInProject(filePath);
+    const before = await readOrEmpty(fullPath);
+    return { path: toRelative(filePath), before: before ?? "", after: cleanContent(content), isNew: before === null };
+}
+/** Works out what edit_file would do, without touching the disk. */
+export async function proposeEdit(filePath, oldString, newString) {
+    const fullPath = resolveInProject(filePath);
+    const before = await readOrEmpty(fullPath);
+    if (before === null)
+        throw new Error(`${filePath} does not exist. Use write_file to create it.`);
+    // Models often send LF while Windows files use CRLF, so match on normalized text.
+    const eol = before.includes("\r\n") ? "\r\n" : "\n";
+    const normalized = before.replace(/\r\n/g, "\n");
+    const target = oldString.replace(/\r\n/g, "\n");
+    const count = target ? normalized.split(target).length - 1 : 0;
+    if (count === 0)
+        throw new Error("old_string was not found in the file. Read the file and copy the text exactly.");
+    if (count > 1)
+        throw new Error(`old_string appears ${count} times. Include more surrounding lines so it is unique.`);
+    const after = normalized.replace(target, () => newString.replace(/\r\n/g, "\n")).replace(/\n/g, eol);
+    return { path: toRelative(filePath), before, after, isNew: false };
+}
+export async function applyChange(change) {
+    try {
+        const fullPath = resolveInProject(change.path);
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, change.after, "utf-8");
+        return `Successfully ${change.isNew ? "created" : "updated"} ${change.path}`;
+    }
+    catch (error) {
+        return `Failed to write file: ${error.message}`;
+    }
+}

package/dist/src/config/index.js

@@ -0,0 +1,39 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+export const NOU_HOME = path.join(os.homedir(), ".nou");
+const CONFIG_PATH = path.join(NOU_HOME, "config.json");
+export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+export const AUTO_SAVE = ["delay", "focus", "off"];
+export const DEFAULT_SETTINGS = {
+    model: "",
+    effort: "high",
+    followMode: true,
+    autoApproveEdits: false,
+    autoApproveCommands: false,
+    gitContext: true,
+    autoSave: "delay",
+    plugins: {},
+    trustedPlugins: {},
+};
+export function loadSettings() {
+    try {
+        const saved = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+        return { ...DEFAULT_SETTINGS, ...saved, plugins: { ...saved.plugins }, trustedPlugins: { ...saved.trustedPlugins } };
+    }
+    catch {
+        return { ...DEFAULT_SETTINGS, plugins: {}, trustedPlugins: {} };
+    }
+}
+export function saveSettings(patch) {
+    const next = { ...loadSettings(), ...patch };
+    try {
+        if (!existsSync(NOU_HOME))
+            mkdirSync(NOU_HOME, { recursive: true });
+        writeFileSync(CONFIG_PATH, JSON.stringify(next, null, 2));
+    }
+    catch {
+        // settings are best effort; the session still uses them
+    }
+    return next;
+}

package/dist/src/context/index.js

@@ -0,0 +1,53 @@
+import { highlight } from "cli-highlight";
+import fs from "fs/promises";
+import path from "path";
+import { fileTree, readFile } from "../commands/index.js";
+import { complete } from "../providers/index.js";
+import * as p from "@clack/prompts";
+export const sugarfy = (str) => {
+    return highlight(str, { language: "typescript", ignoreIllegals: true });
+};
+export async function generateContext(contextPath, choice) {
+    const s = p.spinner();
+    s.start("Analyzing project structure to create NOU.md...");
+    const dirStructure = fileTree(".", 2);
+    const packageJson = await readFile("package.json");
+    let content;
+    try {
+        content = await complete(choice, `I am starting a new project. Based on these files: \n${dirStructure}\n\nAnd this package.json: \n${packageJson}\n\nPlease generate a NOU.md file that summarizes: 
+      1. What this project is.
+      2. Commands to build, test, and run it.
+      3. Tech stack used.
+      Output ONLY the markdown content.`);
+    }
+    catch (error) {
+        s.stop(`Skipped NOU.md: ${error.message}`);
+        return;
+    }
+    await fs.writeFile(contextPath, content);
+    s.stop("NOU.md generated! Nou is now context-aware.");
+}
+;
+export async function ensureProjectContext(choice) {
+    const contextPath = path.join(process.cwd(), "NOU.md");
+    try {
+        await fs.access(contextPath);
+        const nonEmpty = (await fs.readFile(contextPath, "utf-8")).trim().length > 0;
+        if (!nonEmpty) {
+            await generateContext(contextPath, choice);
+        }
+    }
+    catch {
+        await generateContext(contextPath, choice);
+    }
+}
+export async function loadPermanentContext() {
+    const contextPath = path.join(process.cwd(), "NOU.md");
+    try {
+        const content = await fs.readFile(contextPath, "utf-8");
+        return `\n\nPROJECT SPECIFIC RULES (from NOU.md):\n${content}`;
+    }
+    catch (err) {
+        return "";
+    }
+}

package/dist/src/diagnostics/index.js

@@ -0,0 +1,235 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { diffLines } from "diff";
+const ORDER = { error: 0, warning: 1, info: 2 };
+export const sortDiagnostics = (list) => [...list].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || ORDER[a.severity] - ORDER[b.severity]);
+export function formatDiagnostic(d, withFile = false) {
+    return `${withFile ? `${d.file}:` : "line "}${d.line}:${d.col} ${d.severity}: ${d.message}${d.code ? ` (${d.source} ${d.code})` : ` (${d.source})`}`;
+}
+/** Problems in `after` that weren't in `before`, matched by checker + code + message (line numbers shift). */
+export function newProblems(before, after) {
+    const key = (d) => `${d.source}|${d.code ?? ""}|${d.message}`;
+    const seen = new Map();
+    for (const d of before)
+        seen.set(key(d), (seen.get(key(d)) ?? 0) + 1);
+    return after.filter((d) => {
+        const left = seen.get(key(d)) ?? 0;
+        if (left > 0) {
+            seen.set(key(d), left - 1);
+            return false;
+        }
+        return true;
+    });
+}
+/** tsc and the TypeScript language server can report the same error; keep one. */
+function dedupe(list) {
+    const seen = new Set();
+    return list.filter((d) => {
+        const key = `${d.file}|${d.line}|${d.col}|${d.message}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+/** Line numbers in `after` that an edit added or changed, plus the line where text was removed. */
+export function touchedLines(before, after) {
+    const touched = new Set();
+    let line = 1;
+    for (const part of diffLines(before.replace(/\r\n/g, "\n"), after.replace(/\r\n/g, "\n"))) {
+        const count = part.count ?? part.value.split("\n").length - 1;
+        if (part.added)
+            for (let i = 0; i < count; i++)
+                touched.add(line + i);
+        if (part.removed)
+            touched.add(line);
+        else
+            line += count;
+    }
+    return touched;
+}
+function readText(file) {
+    try {
+        return readFileSync(path.resolve(process.cwd(), file), "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Runs checkers, caches their results per file, and tells the UI when anything changes. */
+export class DiagnosticsManager {
+    providers = [];
+    availability = new Map();
+    /** file -> provider id -> problems */
+    results = new Map();
+    projectTimer = null;
+    /** Project checks run one at a time; a queued run is shared by everyone who asks while it waits. */
+    projectChain = Promise.resolve();
+    projectQueued = null;
+    /** Whether a full project check has finished, i.e. we know which problems already existed. */
+    projectBaseline = false;
+    running = new Set();
+    listeners = new Set();
+    setProviders(providers) {
+        const ids = new Set(providers.map((p) => p.id));
+        // Drop results from checkers that were switched off.
+        for (const byProvider of this.results.values()) {
+            for (const id of [...byProvider.keys()])
+                if (!ids.has(id))
+                    byProvider.delete(id);
+        }
+        this.providers = providers;
+        this.emit();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    emit() {
+        for (const l of this.listeners)
+            l();
+    }
+    /** Names of checkers currently running, for the status bar. */
+    get busy() {
+        return [...this.running];
+    }
+    async isAvailable(p) {
+        if (!this.availability.has(p.id)) {
+            try {
+                this.availability.set(p.id, await p.available());
+            }
+            catch {
+                this.availability.set(p.id, false);
+            }
+        }
+        return this.availability.get(p.id);
+    }
+    async activeProviders() {
+        const out = [];
+        for (const p of this.providers)
+            if (await this.isAvailable(p))
+                out.push(p);
+        return out;
+    }
+    async runProvider(p, file, text) {
+        this.running.add(p.name);
+        this.emit();
+        try {
+            return await p.check(file, text);
+        }
+        catch {
+            return [];
+        }
+        finally {
+            this.running.delete(p.name);
+            this.emit();
+        }
+    }
+    store(file, providerId, list) {
+        const byProvider = this.results.get(file) ?? new Map();
+        byProvider.set(providerId, list);
+        this.results.set(file, byProvider);
+    }
+    /** Checks one file (unsaved `text` if given, otherwise what's on disk) with the per-file checkers. */
+    async checkFile(file, text) {
+        const content = text ?? readText(file);
+        if (content === null)
+            return [];
+        const providers = (await this.activeProviders()).filter((p) => !p.projectWide && p.matches(file));
+        await Promise.all(providers.map(async (p) => this.store(file, p.id, await this.runProvider(p, file, content))));
+        this.emit();
+        return this.get(file);
+    }
+    /**
+     * Runs project-wide checkers (like tsc) and replaces their results everywhere. Runs never overlap (they'd
+     * overwrite each other); asking while one is queued reuses it, since it will see the latest files anyway.
+     */
+    checkProject() {
+        if (this.projectQueued)
+            return this.projectQueued;
+        const run = this.projectChain.then(() => {
+            this.projectQueued = null;
+            return this.runProject();
+        });
+        this.projectQueued = run;
+        this.projectChain = run.catch(() => { });
+        return run;
+    }
+    async runProject() {
+        const providers = (await this.activeProviders()).filter((p) => p.projectWide);
+        await Promise.all(providers.map(async (p) => {
+            const list = await this.runProvider(p, ".", "");
+            for (const byProvider of this.results.values())
+                byProvider.delete(p.id);
+            const byFile = new Map();
+            for (const d of list)
+                byFile.set(d.file, [...(byFile.get(d.file) ?? []), d]);
+            for (const [file, items] of byFile)
+                this.store(file, p.id, items);
+        }));
+        this.projectBaseline = true;
+        this.emit();
+    }
+    /** Debounced checkProject, for after saves. */
+    scheduleProject(delay = 1500) {
+        if (this.projectTimer)
+            clearTimeout(this.projectTimer);
+        this.projectTimer = setTimeout(() => void this.checkProject(), delay);
+    }
+    /** Checks text without storing it, e.g. a proposed edit. Only checkers that accept unsaved text. */
+    async checkText(file, text) {
+        const providers = (await this.activeProviders()).filter((p) => p.checksText && !p.projectWide && p.matches(file));
+        return (await Promise.all(providers.map((p) => this.runProvider(p, file, text)))).flat();
+    }
+    get(file) {
+        return dedupe(sortDiagnostics([...(this.results.get(file)?.values() ?? [])].flat()));
+    }
+    all() {
+        return dedupe(sortDiagnostics([...this.results.values()].flatMap((m) => [...m.values()].flat())));
+    }
+    counts(file) {
+        const list = file ? this.get(file) : this.all();
+        return {
+            errors: list.filter((d) => d.severity === "error").length,
+            warnings: list.filter((d) => d.severity === "warning").length,
+        };
+    }
+    /** Per-file counts, for markers in the file tree. */
+    fileCounts() {
+        const out = new Map();
+        for (const d of this.all()) {
+            const c = out.get(d.file) ?? { errors: 0, warnings: 0 };
+            if (d.severity === "error")
+                c.errors++;
+            else if (d.severity === "warning")
+                c.warnings++;
+            out.set(d.file, c);
+        }
+        return out;
+    }
+    /**
+     * After Nou's edit: the problems it introduced in that file, compared with the file before.
+     * Checks both versions with per-file checkers, and re-runs project-wide ones.
+     */
+    async introducedBy(file, before, after) {
+        const projectIds = (await this.activeProviders()).filter((p) => p.projectWide && p.matches(file)).map((p) => p.id);
+        const hadBaseline = this.projectBaseline;
+        const projectBefore = this.getFrom(file, projectIds);
+        // One after the other: language servers hold a single copy of each document.
+        const beforeList = await this.checkText(file, before);
+        const afterList = await this.checkFile(file, after);
+        if (projectIds.length)
+            await this.checkProject();
+        let projectNew = newProblems(projectBefore, this.getFrom(file, projectIds));
+        if (!hadBaseline) {
+            // No check finished before this edit, so old and new problems look the same.
+            // Only blame the edit for problems on lines it actually touched.
+            const touched = touchedLines(before, after);
+            projectNew = projectNew.filter((d) => touched.has(d.line));
+        }
+        return [...newProblems(beforeList, afterList), ...projectNew];
+    }
+    getFrom(file, providerIds) {
+        return providerIds.flatMap((id) => this.results.get(file)?.get(id) ?? []);
+    }
+}

package/dist/src/diagnostics/process.js

@@ -0,0 +1,64 @@
+import { spawn, spawnSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+/** Runs a program without a shell (safe with any file name), optionally piping text to stdin. */
+export function run(command, args, options = {}) {
+    return new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        let child;
+        try {
+            child = spawn(command, args, { cwd: process.cwd(), windowsHide: true });
+        }
+        catch (error) {
+            resolve({ code: -1, stdout: "", stderr: error.message });
+            return;
+        }
+        const timer = setTimeout(() => child.kill(), options.timeout ?? 60_000);
+        child.stdout.on("data", (d) => (stdout += d));
+        child.stderr.on("data", (d) => (stderr += d));
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            resolve({ code: -1, stdout, stderr: error.message });
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr });
+        });
+        if (options.input !== undefined)
+            child.stdin.end(options.input);
+        else
+            child.stdin.end();
+    });
+}
+/** Whether a program is on PATH (e.g. `ruff`). */
+export function onPath(command) {
+    try {
+        return spawnSync(command, ["--version"], { windowsHide: true, timeout: 5000 }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Finds a CLI installed in the user's project (not Nou's own copy), e.g. their ESLint,
+ * returning the JS entry point so it can be run with `node` on every OS.
+ */
+export function projectBin(pkg, bin = pkg) {
+    try {
+        const require = createRequire(path.join(process.cwd(), "package.json"));
+        const manifestPath = require.resolve(`${pkg}/package.json`);
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        const rel = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[bin];
+        if (!rel)
+            return null;
+        const full = path.join(path.dirname(manifestPath), rel);
+        // Only use it if it's really the project's install, not something hoisted from Nou itself.
+        const inside = path.relative(process.cwd(), full);
+        return existsSync(full) && !inside.startsWith("..") && !path.isAbsolute(inside) ? full : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/diagnostics/providers.js

@@ -0,0 +1,103 @@
+import { existsSync } from "fs";
+import path from "path";
+import { onPath, projectBin, run } from "./process.js";
+const rel = (file) => path.relative(process.cwd(), path.resolve(process.cwd(), file)).replace(/\\/g, "/");
+/** ESLint, using the project's own install and config, so results match `npm run lint`. */
+export const eslintProvider = {
+    id: "eslint",
+    name: "ESLint",
+    checksText: true,
+    matches: (file) => /\.(m|c)?(j|t)sx?$/.test(file),
+    available: () => projectBin("eslint") !== null,
+    async check(file, text) {
+        const bin = projectBin("eslint");
+        if (!bin)
+            return [];
+        const result = await run(process.execPath, [bin, "--stdin", "--stdin-filename", file, "--format", "json"], { input: text, timeout: 60_000 });
+        let reports;
+        try {
+            reports = JSON.parse(result.stdout);
+        }
+        catch {
+            return [];
+        }
+        return reports.flatMap((report) => (report.messages ?? [])
+            // "File ignored by config" isn't a real problem.
+            .filter((m) => !(m.ruleId === null && /ignored/i.test(m.message)))
+            .map((m) => ({
+            file: rel(file),
+            line: m.line ?? 1,
+            col: m.column ?? 1,
+            ...(m.endLine ? { endLine: m.endLine } : {}),
+            ...(m.endColumn ? { endCol: m.endColumn } : {}),
+            severity: m.severity === 2 ? "error" : "warning",
+            message: m.message,
+            source: "eslint",
+            ...(m.ruleId ? { code: m.ruleId } : {}),
+        })));
+    },
+};
+/** The TypeScript compiler over the whole project (type errors need the full picture). */
+export const typescriptProvider = {
+    id: "typescript",
+    name: "TypeScript",
+    checksText: false,
+    projectWide: true,
+    matches: (file) => /\.(m|c)?tsx?$/.test(file),
+    available: () => existsSync(path.join(process.cwd(), "tsconfig.json")) && projectBin("typescript", "tsc") !== null,
+    async check() {
+        const bin = projectBin("typescript", "tsc");
+        if (!bin)
+            return [];
+        const result = await run(process.execPath, [bin, "--noEmit", "-p", ".", "--pretty", "false"], { timeout: 180_000 });
+        const diagnostics = [];
+        for (const line of result.stdout.split(/\r?\n/)) {
+            const m = line.match(/^(.+?)\((\d+),(\d+)\): (error|warning) (TS\d+): (.*)$/);
+            if (m) {
+                diagnostics.push({
+                    file: rel(m[1]),
+                    line: Number(m[2]),
+                    col: Number(m[3]),
+                    severity: m[4] === "error" ? "error" : "warning",
+                    message: m[6],
+                    source: "tsc",
+                    code: m[5],
+                });
+            }
+            else if (line.startsWith("  ") && diagnostics.length) {
+                diagnostics[diagnostics.length - 1].message += ` ${line.trim()}`;
+            }
+        }
+        return diagnostics;
+    },
+};
+let ruffInstalled;
+/** Ruff for Python, if it's installed. */
+export const ruffProvider = {
+    id: "ruff",
+    name: "Ruff (Python)",
+    checksText: true,
+    matches: (file) => /\.pyi?$/.test(file),
+    available: () => (ruffInstalled ??= onPath("ruff")),
+    async check(file, text) {
+        const result = await run("ruff", ["check", "--output-format", "json", "--stdin-filename", file, "-"], { input: text, timeout: 30_000 });
+        let items;
+        try {
+            items = JSON.parse(result.stdout);
+        }
+        catch {
+            return [];
+        }
+        return items.map((item) => ({
+            file: rel(file),
+            line: item.location?.row ?? 1,
+            col: item.location?.column ?? 1,
+            ...(item.end_location ? { endLine: item.end_location.row, endCol: item.end_location.column } : {}),
+            // Syntax errors (no code / E9) and pyflakes (F) are real bugs; style rules are warnings.
+            severity: !item.code || /^(E9|F)/.test(item.code) ? "error" : "warning",
+            message: item.message,
+            source: "ruff",
+            ...(item.code ? { code: item.code } : {}),
+        }));
+    },
+};

package/dist/src/diagnostics/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/env.js

@@ -0,0 +1,12 @@
+import { existsSync } from "fs";
+// This module must be imported before anything else (index.ts imports it first).
+// npm only warns about an unsupported Node version, so check here, before Ink loads and fails confusingly.
+const [major, minor] = process.versions.node.split(".").map(Number);
+if (major < 22 || (major === 22 && minor < 12)) {
+    console.error(`Nou needs Node.js 22.12 or newer (you have ${process.versions.node}). Get it from https://nodejs.org`);
+    process.exit(1);
+}
+// Load the project's .env (API keys, base URLs). Providers read their settings when they load,
+// so loading .env later would be too late for them.
+if (existsSync(".env"))
+    process.loadEnvFile(".env");