@jeeva1398/eventa 0.1.0

package/dist/index.js

@@ -0,0 +1,1243 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import chalk8 from "chalk";
+import { Command } from "commander";
+
+// src/model/registry.ts
+import { existsSync } from "fs";
+import { basename, join as join2, resolve } from "path";
+
+// src/config.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var DEFAULTS = {
+  provider: "auto",
+  model: "hf.co/jeeva1398/eventa-1.5b-gguf",
+  localModel: "eventa-1.5b",
+  ollamaHost: "http://localhost:11434",
+  temperature: 0.2,
+  contextSize: 8192
+};
+var CONFIG_KEYS = Object.keys(DEFAULTS);
+function configDir() {
+  return process.env.EVENTA_HOME ?? join(homedir(), ".eventa");
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+function readFile() {
+  try {
+    return JSON.parse(readFileSync(configPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function fromEnv(env) {
+  const out = {};
+  if (env.EVENTA_MODEL) out.model = env.EVENTA_MODEL;
+  if (env.EVENTA_LOCAL_MODEL) out.localModel = env.EVENTA_LOCAL_MODEL;
+  if (env.EVENTA_PROVIDER) out.provider = env.EVENTA_PROVIDER;
+  const host = env.EVENTA_OLLAMA_HOST ?? env.OLLAMA_HOST;
+  if (host) out.ollamaHost = host.startsWith("http") ? host : `http://${host}`;
+  return out;
+}
+function loadConfig(overrides = {}, env = process.env) {
+  const defined = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== void 0));
+  return { ...DEFAULTS, ...readFile(), ...fromEnv(env), ...defined };
+}
+function setConfigValue(key, raw) {
+  const current = readFile();
+  const value = typeof DEFAULTS[key] === "number" ? Number(raw) : raw;
+  if (typeof value === "number" && Number.isNaN(value)) throw new Error(`${key} must be a number`);
+  const next = { ...current, [key]: value };
+  mkdirSync(dirname(configPath()), { recursive: true });
+  writeFileSync(configPath(), JSON.stringify(next, null, 2) + "\n");
+  return { ...DEFAULTS, ...next };
+}
+
+// src/model/registry.ts
+var MODELS = {
+  "qwen2.5-coder-1.5b": {
+    id: "qwen2.5-coder-1.5b",
+    description: "Qwen2.5-Coder 1.5B Instruct, Q4_K_M (stock base model)",
+    url: "https://huggingface.co/Qwen/Qwen2.5-Coder-1.5B-Instruct-GGUF/resolve/main/qwen2.5-coder-1.5b-instruct-q4_k_m.gguf",
+    file: "qwen2.5-coder-1.5b-instruct-q4_k_m.gguf",
+    sha256: "cc324af070c2ecbfd324a30884d2f951a7ff756aba85cb811a6ec436933bb046",
+    size: 1117320768
+  },
+  "eventa-1.5b": {
+    id: "eventa-1.5b",
+    description: "Eventa 1.5B, fine-tuned for Node.js, Q4_K_M",
+    url: "https://huggingface.co/jeeva1398/eventa-1.5b-gguf/resolve/127365417879e6ac5e9b9742452590eda87ae353/eventa-1.5b-q4_k_m.gguf",
+    file: "eventa-1.5b-q4_k_m-4bd501d2.gguf",
+    sha256: "4bd501d2619a464e87c427bae594e59e60d1850ab9846d522bb9bd1d26265b04",
+    size: 986048192
+  }
+};
+var modelsDir = () => join2(configDir(), "models");
+function resolveModel(idOrPath) {
+  if (MODELS[idOrPath]) return MODELS[idOrPath];
+  if (/^https?:\/\/.+\.gguf$/.test(idOrPath)) {
+    const file = basename(new URL(idOrPath).pathname);
+    return { id: file.replace(/\.gguf$/, ""), description: "custom URL", url: idOrPath, file };
+  }
+  if (idOrPath.endsWith(".gguf") && existsSync(idOrPath)) {
+    return { id: basename(idOrPath, ".gguf"), description: "local file", url: "", file: resolve(idOrPath) };
+  }
+  throw new Error(`Unknown model "${idOrPath}". Known models: ${Object.keys(MODELS).join(", ")}, or pass a .gguf path or URL.`);
+}
+var modelPath = (spec) => spec.url ? join2(modelsDir(), spec.file) : spec.file;
+var isDownloaded = (spec) => existsSync(modelPath(spec));
+
+// src/model/runtime.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { createRequire } from "module";
+import { join as join3 } from "path";
+import { pathToFileURL } from "url";
+
+// src/context/exec.ts
+import { spawn } from "child_process";
+function exec(cmd, args, opts = {}) {
+  return new Promise((resolve3, reject) => {
+    const child = spawn(cmd, args, {
+      cwd: opts.cwd,
+      shell: opts.shell ?? process.platform === "win32",
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => stdout += d);
+    child.stderr.on("data", (d) => stderr += d);
+    child.on("error", reject);
+    child.on("close", (code) => resolve3({ code: code ?? 1, stdout, stderr }));
+  });
+}
+var runShell = (command, cwd) => exec(command, [], { cwd, shell: true });
+
+// src/model/runtime.ts
+var LLAMA_VERSION = "3.22.1";
+var runtimeDir = () => join3(configDir(), "runtime");
+function platformPackage(platform = process.platform, arch = process.arch) {
+  const os = platform === "win32" ? "win" : platform === "darwin" ? "mac" : platform;
+  const cpu = arch === "arm" ? "armv7l" : arch;
+  if (os === "mac" && cpu === "arm64") return "@node-llama-cpp/mac-arm64-metal";
+  const supported = ["win-x64", "win-arm64", "mac-x64", "linux-x64", "linux-arm64", "linux-armv7l", "linux-riscv64"];
+  const id = `${os}-${cpu}`;
+  if (!supported.includes(id)) throw new Error(`The built-in runtime has no prebuilt binary for ${platform}-${arch}. Use Ollama instead.`);
+  return `@node-llama-cpp/${id}`;
+}
+var entryPath = () => join3(runtimeDir(), "node_modules", "node-llama-cpp", "package.json");
+var isRuntimeInstalled = () => existsSync2(entryPath());
+async function installRuntime(log2 = () => {
+}) {
+  if (Number(process.versions.node.split(".")[0]) < 20) {
+    throw new Error("The built-in runtime needs Node.js 20 or newer. Upgrade Node, or use Ollama.");
+  }
+  const dir = runtimeDir();
+  mkdirSync2(dir, { recursive: true });
+  const manifest = join3(dir, "package.json");
+  if (!existsSync2(manifest)) writeFileSync2(manifest, JSON.stringify({ name: "eventa-runtime", private: true }, null, 2));
+  log2(`Installing the local runtime (node-llama-cpp ${LLAMA_VERSION}, about 80 MB, one time)\u2026`);
+  const r = await exec("npm", ["install", `node-llama-cpp@${LLAMA_VERSION}`, `${platformPackage()}@${LLAMA_VERSION}`, "--omit=optional", "--no-audit", "--no-fund", "--loglevel=error"], { cwd: dir });
+  if (r.code !== 0) throw new Error(`Runtime install failed:
+${r.stderr.trim()}`);
+}
+var cached;
+function loadRuntime() {
+  cached ??= (async () => {
+    const entry = createRequire(join3(runtimeDir(), "package.json")).resolve("node-llama-cpp");
+    return await import(pathToFileURL(entry).href);
+  })();
+  return cached;
+}
+
+// src/model/setup.ts
+import chalk from "chalk";
+
+// src/model/download.ts
+import { createHash } from "crypto";
+import { createReadStream, createWriteStream, existsSync as existsSync3, mkdirSync as mkdirSync3, renameSync, statSync, unlinkSync } from "fs";
+import { dirname as dirname2 } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+var mb = (n) => (n / 1024 / 1024).toFixed(0);
+function formatProgress(p, width = 24) {
+  const speed = `${(p.bytesPerSecond / 1024 / 1024).toFixed(1)} MB/s`;
+  if (!p.total) return `${mb(p.received)} MB  ${speed}`;
+  const ratio = Math.min(1, p.received / p.total);
+  const filled = Math.round(ratio * width);
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(width - filled)}] ${(ratio * 100).toFixed(0).padStart(3)}%  ${mb(p.received)}/${mb(p.total)} MB  ${speed}`;
+}
+async function sha256File(path) {
+  const hash = createHash("sha256");
+  await pipeline(createReadStream(path), hash);
+  return hash.digest("hex");
+}
+var HF_RE = /^https:\/\/huggingface\.co\/([^/]+\/[^/]+)\/resolve\/([^/]+)\/([^/]+)$/;
+async function hubChecksum(url, fetchImpl = fetch) {
+  const m = HF_RE.exec(url);
+  if (!m) return {};
+  try {
+    const res = await fetchImpl(`https://huggingface.co/api/models/${m[1]}/tree/${m[2]}`);
+    if (!res.ok) return {};
+    const files = await res.json();
+    const lfs = files.find((f) => f.path === decodeURIComponent(m[3]))?.lfs;
+    return lfs ? { sha256: lfs.oid, size: lfs.size } : {};
+  } catch {
+    return {};
+  }
+}
+async function downloadModel(model2, onProgress, fetchImpl = fetch) {
+  const target = modelPath(model2);
+  if (existsSync3(target)) return target;
+  const spec = model2.sha256 ? model2 : { ...model2, ...await hubChecksum(model2.url, fetchImpl) };
+  mkdirSync3(dirname2(target), { recursive: true });
+  const part = `${target}.part`;
+  const offset = existsSync3(part) ? statSync(part).size : 0;
+  const res = await fetchImpl(spec.url, { headers: offset ? { Range: `bytes=${offset}-` } : {} });
+  if (res.status === 404) throw new Error(`Model ${spec.id} is not published yet (${spec.url})`);
+  if (!res.ok || !res.body) throw new Error(`Download failed: HTTP ${res.status} for ${spec.url}`);
+  const resumed = res.status === 206;
+  const start = resumed ? offset : 0;
+  const length = Number(res.headers.get("content-length")) || void 0;
+  const total = spec.size ?? (length ? start + length : void 0);
+  let received = start;
+  const began = Date.now();
+  const counter = async function* (source) {
+    for await (const chunk of source) {
+      received += chunk.length;
+      const seconds = Math.max(1e-3, (Date.now() - began) / 1e3);
+      onProgress?.({ received, total, bytesPerSecond: (received - start) / seconds });
+      yield chunk;
+    }
+  };
+  await pipeline(Readable.fromWeb(res.body), counter, createWriteStream(part, { flags: resumed ? "a" : "w" }));
+  if (spec.sha256) {
+    const actual = await sha256File(part);
+    if (actual !== spec.sha256) {
+      unlinkSync(part);
+      throw new Error(`Checksum mismatch for ${spec.file} (expected ${spec.sha256}, got ${actual}). The partial file was removed; run the command again.`);
+    }
+  }
+  renameSync(part, target);
+  return target;
+}
+
+// src/model/setup.ts
+var log = (msg) => process.stderr.write(chalk.dim(msg) + "\n");
+async function prepareLocal(spec) {
+  if (!isRuntimeInstalled()) await installRuntime(log);
+  if (isDownloaded(spec)) return modelPath(spec);
+  log(`Downloading ${spec.id} (${spec.size ? `${(spec.size / 1024 ** 3).toFixed(1)} GB, ` : ""}one time)\u2026`);
+  const tty = process.stderr.isTTY;
+  let lastLog = 0;
+  const path = await downloadModel(spec, (p) => {
+    if (tty) process.stderr.write(`\r${formatProgress(p)}`);
+    else if (Date.now() - lastLog > 5e3) {
+      lastLog = Date.now();
+      log(formatProgress(p));
+    }
+  });
+  if (tty) process.stderr.write("\n");
+  log(`Saved to ${path}`);
+  return path;
+}
+
+// src/llm/provider.ts
+var ProviderError = class extends Error {
+  constructor(message, hint) {
+    super(message);
+    this.hint = hint;
+    this.name = "ProviderError";
+  }
+  hint;
+};
+
+// src/llm/local.ts
+var loaded = /* @__PURE__ */ new Map();
+async function loadModel(path) {
+  let model2 = loaded.get(path);
+  if (!model2) {
+    model2 = loadRuntime().then(async (rt) => {
+      const llama = await rt.getLlama({ gpu: process.platform === "darwin" ? "auto" : false, build: "never", logLevel: "error" });
+      return llama.loadModel({ modelPath: path });
+    });
+    model2.catch(() => loaded.delete(path));
+    loaded.set(path, model2);
+  }
+  return model2;
+}
+var LocalProvider = class {
+  constructor(model2) {
+    this.model = model2;
+  }
+  model;
+  name = "local";
+  async check() {
+    const spec = resolveModel(this.model);
+    if (!isRuntimeInstalled()) throw new ProviderError("Local runtime is not installed", "Run `eventa model pull` (or any command, it installs on first use)");
+    if (!isDownloaded(spec)) throw new ProviderError(`Local model ${spec.id} is not downloaded`, `Run \`eventa model pull ${spec.id}\``);
+  }
+  async prepare() {
+    await loadModel(await prepareLocal(resolveModel(this.model)));
+  }
+  async *generate(prompt, opts = {}) {
+    const path = await prepareLocal(resolveModel(this.model));
+    const rt = await loadRuntime();
+    const model2 = await loadModel(path);
+    const context = await model2.createContext({ contextSize: opts.numCtx });
+    const session = new rt.LlamaChatSession({ contextSequence: context.getSequence(), systemPrompt: opts.system });
+    const chunks = [];
+    let done = false;
+    let failure;
+    let wake = null;
+    const notify = () => {
+      wake?.();
+      wake = null;
+    };
+    session.prompt(prompt, {
+      temperature: opts.temperature,
+      maxTokens: opts.maxTokens ?? 1024,
+      signal: opts.signal,
+      onTextChunk: (t) => {
+        chunks.push(t);
+        notify();
+      }
+    }).catch((err) => failure = err).finally(() => {
+      done = true;
+      notify();
+    });
+    try {
+      while (true) {
+        if (chunks.length) yield chunks.shift();
+        else if (done) break;
+        else await new Promise((r) => wake = r);
+      }
+      if (failure) throw new ProviderError(`Local model error: ${failure.message}`);
+    } finally {
+      session.dispose();
+      await context.dispose();
+    }
+  }
+};
+
+// src/llm/ollama.ts
+async function* parseNdjson(body) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for await (const chunk of body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let nl;
+    while ((nl = buffer.indexOf("\n")) >= 0) {
+      const line = buffer.slice(0, nl).trim();
+      buffer = buffer.slice(nl + 1);
+      if (line) yield JSON.parse(line);
+    }
+  }
+  const rest = buffer.trim();
+  if (rest) yield JSON.parse(rest);
+}
+var OllamaProvider = class {
+  constructor(model2, host, fetchImpl = fetch) {
+    this.model = model2;
+    this.host = host;
+    this.fetchImpl = fetchImpl;
+  }
+  model;
+  host;
+  fetchImpl;
+  name = "ollama";
+  unreachable() {
+    return new ProviderError(`Cannot reach Ollama at ${this.host}`, "Start it with `ollama serve`, or install it from https://ollama.com");
+  }
+  async check() {
+    let res;
+    try {
+      res = await this.fetchImpl(`${this.host}/api/tags`, { signal: AbortSignal.timeout(2e3) });
+    } catch {
+      throw this.unreachable();
+    }
+    const { models = [] } = await res.json();
+    const wanted = this.model.includes(":") ? this.model : `${this.model}:latest`;
+    if (!models.some((m) => m.name === wanted || m.name === this.model)) {
+      throw new ProviderError(`Model "${this.model}" is not installed in Ollama`, `Run \`ollama pull ${this.model}\``);
+    }
+  }
+  async *generate(prompt, opts = {}) {
+    let res;
+    try {
+      res = await this.fetchImpl(`${this.host}/api/generate`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          model: this.model,
+          prompt,
+          system: opts.system,
+          stream: true,
+          options: { temperature: opts.temperature, num_ctx: opts.numCtx, num_predict: opts.maxTokens ?? 1024 }
+        }),
+        signal: opts.signal
+      });
+    } catch (err) {
+      if (err.name === "AbortError") return;
+      throw this.unreachable();
+    }
+    if (res.status === 404) {
+      throw new ProviderError(`Model "${this.model}" is not installed in Ollama`, `Run \`ollama pull ${this.model}\``);
+    }
+    if (!res.ok || !res.body) throw new ProviderError(`Ollama returned HTTP ${res.status}: ${await res.text()}`);
+    for await (const line of parseNdjson(res.body)) {
+      if (line.error) throw new ProviderError(`Ollama error: ${line.error}`);
+      if (line.response) yield line.response;
+      if (line.done) return;
+    }
+  }
+};
+
+// src/llm/index.ts
+var ollamaFor = (config2) => new OllamaProvider(config2.model, config2.ollamaHost.replace(/\/+$/, ""));
+async function createProvider(config2) {
+  if (config2.provider === "ollama") return ollamaFor(config2);
+  if (config2.provider === "local") return new LocalProvider(config2.localModel);
+  const ollama = ollamaFor(config2);
+  try {
+    await ollama.check();
+    return ollama;
+  } catch {
+    return new LocalProvider(config2.localModel);
+  }
+}
+
+// src/prompts/index.ts
+var SYSTEM_PROMPT = "You are Eventa, an expert Node.js engineer. Answer concisely and accurately. Prefer modern Node.js (ESM, async/await, node: built-ins). Use markdown and fenced code blocks.";
+var toPrompt = ({ instruction, input }) => input ? `${instruction}
+
+${input}` : instruction;
+
+// src/ui/render.ts
+import chalk2 from "chalk";
+import ora from "ora";
+function formatLine(line, state) {
+  if (line.trimStart().startsWith("```")) {
+    state.inCode = !state.inCode;
+    return chalk2.dim(line);
+  }
+  if (state.inCode) return chalk2.cyan(line);
+  const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+  if (heading) return chalk2.bold.underline(heading[2]);
+  return line.replace(/\*\*([^*]+)\*\*/g, (_, t) => chalk2.bold(t)).replace(/`([^`]+)`/g, (_, t) => chalk2.yellow(t)).replace(/^(\s*)[-*]\s+/, (_, s) => `${s}\u2022 `);
+}
+async function renderStream(tokens, opts = {}) {
+  const out = opts.out ?? process.stdout;
+  const pretty = !opts.raw && Boolean(out.isTTY);
+  const spinner = pretty ? ora({ text: "Thinking\u2026", stream: process.stderr }).start() : null;
+  const state = { inCode: false };
+  let full = "";
+  let pending = "";
+  try {
+    for await (const token of tokens) {
+      spinner?.stop();
+      full += token;
+      if (!pretty) {
+        out.write(token);
+        continue;
+      }
+      pending += token;
+      let nl;
+      while ((nl = pending.indexOf("\n")) >= 0) {
+        out.write(formatLine(pending.slice(0, nl), state) + "\n");
+        pending = pending.slice(nl + 1);
+      }
+    }
+    if (pretty && pending) out.write(formatLine(pending, state));
+    if (!full.endsWith("\n")) out.write("\n");
+  } finally {
+    spinner?.stop();
+  }
+  return full;
+}
+
+// src/commands/shared.ts
+async function generate(config2, parts, opts = {}) {
+  const provider = await createProvider(config2);
+  await provider.prepare?.();
+  const tokens = provider.generate(toPrompt(parts), {
+    system: opts.system ?? SYSTEM_PROMPT,
+    temperature: config2.temperature,
+    numCtx: config2.contextSize
+  });
+  if (opts.json) {
+    let text = "";
+    for await (const t of tokens) text += t;
+    return text.trim();
+  }
+  return renderStream(tokens, { raw: opts.raw });
+}
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  let data = "";
+  for await (const chunk of process.stdin) data += chunk;
+  return data;
+}
+var printJson = (value) => console.log(JSON.stringify(value, null, 2));
+
+// src/commands/ask.ts
+async function askCommand(question, config2, opts) {
+  await generate(config2, { instruction: question, input: "" }, { raw: opts.raw });
+}
+
+// src/commands/config.ts
+function assertKey(key) {
+  if (!CONFIG_KEYS.includes(key)) {
+    throw new Error(`Unknown config key "${key}". Valid keys: ${CONFIG_KEYS.join(", ")}`);
+  }
+}
+function configGet(key) {
+  const config2 = loadConfig();
+  if (!key) {
+    console.log(JSON.stringify(config2, null, 2));
+    return;
+  }
+  assertKey(key);
+  console.log(String(config2[key]));
+}
+function configSet(key, value) {
+  assertKey(key);
+  setConfigValue(key, value);
+  console.log(`${key} = ${value}`);
+}
+function configWhere() {
+  console.log(configPath());
+}
+
+// src/commands/deps.ts
+import chalk3 from "chalk";
+import ora2 from "ora";
+
+// src/context/deps.ts
+import { readdirSync, readFileSync as readFileSync2 } from "fs";
+import { builtinModules } from "module";
+import { extname, join as join4 } from "path";
+var SEVERITY_ORDER = ["critical", "high", "moderate", "low", "info"];
+var SOURCE_EXT = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".jsx", ".ts", ".mts", ".cts", ".tsx", ".vue", ".svelte"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "coverage", ".next", ".nuxt", "out", ".turbo", ".cache"]);
+var IMPORT_RE = /(?:import|export)\s[^'"]*?from\s*['"]([^'"]+)['"]|import\s*\(\s*['"]([^'"]+)['"]\s*\)|require\s*\(\s*['"]([^'"]+)['"]\s*\)|import\s+['"]([^'"]+)['"]/g;
+var BUILTINS = new Set(builtinModules);
+function readPackageJson(cwd) {
+  try {
+    return JSON.parse(readFileSync2(join4(cwd, "package.json"), "utf8"));
+  } catch {
+    throw new Error(`No readable package.json in ${cwd}`);
+  }
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function parseAudit(text) {
+  const json = parseJson(text);
+  if (!json) return { vulnerabilities: [], error: "npm audit returned no JSON" };
+  if (json.error) return { vulnerabilities: [], error: json.error.summary ?? json.error.code };
+  const vulnerabilities = Object.entries(json.vulnerabilities ?? {}).map(([name, v]) => {
+    const advisory = v.via.find((x) => typeof x === "object");
+    const fix = v.fixAvailable === true ? "npm audit fix" : v.fixAvailable ? `npm install ${v.fixAvailable.name}@${v.fixAvailable.version}${v.fixAvailable.isSemVerMajor ? " (major)" : ""}` : void 0;
+    return { name, severity: v.severity, title: advisory?.title ?? (v.via.length ? `via ${v.via.join(", ")}` : void 0), url: advisory?.url, range: v.range, fix };
+  });
+  vulnerabilities.sort((a, b) => SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity));
+  return { vulnerabilities };
+}
+function fixPlan(vulns) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const v of vulns) {
+    const command = v.fix ?? "no fix available";
+    groups.set(command, [...groups.get(command) ?? [], v.name]);
+  }
+  return [...groups].map(([command, fixes]) => ({ command, fixes }));
+}
+function parseOutdated(text) {
+  const json = parseJson(text) ?? {};
+  return Object.entries(json).map(([name, v]) => ({
+    name,
+    current: v.current,
+    wanted: v.wanted,
+    latest: v.latest,
+    major: Boolean(v.current && v.latest && v.current.split(".")[0] !== v.latest.split(".")[0])
+  }));
+}
+function packageName(specifier) {
+  if (/^(\.|\/|#|~|@\/|[a-z]+:)/i.test(specifier) || BUILTINS.has(specifier)) return void 0;
+  const parts = specifier.split("/");
+  const name = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  if (BUILTINS.has(name) || !/^(@[\w.-]+\/)?[\w.-]+$/.test(name)) return void 0;
+  return name;
+}
+function scanImports(cwd, maxFiles = 3e3) {
+  const found = /* @__PURE__ */ new Set();
+  let count = 0;
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (count >= maxFiles) return;
+      if (e.isDirectory()) {
+        if (!SKIP_DIRS.has(e.name) && !e.name.startsWith(".")) walk(join4(dir, e.name));
+      } else if (SOURCE_EXT.has(extname(e.name)) || /\.config\.[cm]?[jt]s$/.test(e.name)) {
+        count++;
+        const text = readFileSync2(join4(dir, e.name), "utf8");
+        for (const m of text.matchAll(IMPORT_RE)) {
+          const name = packageName(m[1] ?? m[2] ?? m[3] ?? m[4]);
+          if (name) found.add(name);
+        }
+      }
+    }
+  };
+  walk(cwd);
+  return found;
+}
+function binNames(cwd, dep) {
+  let text;
+  try {
+    text = readFileSync2(join4(cwd, "node_modules", dep, "package.json"), "utf8");
+  } catch {
+    return [];
+  }
+  const pkg = parseJson(text);
+  if (!pkg?.bin) return [];
+  return typeof pkg.bin === "string" ? [dep.split("/").pop()] : Object.keys(pkg.bin);
+}
+function findUnusedAndMissing(pkg, imported, cwd = process.cwd()) {
+  const scriptTokens = new Set(Object.values(pkg.scripts ?? {}).join(" ").split(/[\s&|;()'"=]+/));
+  const usedInScripts = (d) => scriptTokens.has(d) || binNames(cwd, d).some((b) => scriptTokens.has(b));
+  const declared = /* @__PURE__ */ new Set([
+    ...Object.keys(pkg.dependencies ?? {}),
+    ...Object.keys(pkg.devDependencies ?? {}),
+    ...Object.keys(pkg.peerDependencies ?? {}),
+    ...Object.keys(pkg.optionalDependencies ?? {})
+  ]);
+  const unused = Object.keys(pkg.dependencies ?? {}).filter(
+    (d) => !imported.has(d) && !d.startsWith("@types/") && !usedInScripts(d)
+  );
+  const missing = [...imported].filter((d) => !declared.has(d) && d !== pkg.name && !declared.has(`@types/${d}`)).sort();
+  return { unused, missing };
+}
+async function collectDeps(cwd) {
+  const pkg = readPackageJson(cwd);
+  const [audit, outdated] = await Promise.all([
+    exec("npm", ["audit", "--json"], { cwd }),
+    exec("npm", ["outdated", "--json"], { cwd })
+  ]);
+  const { vulnerabilities, error } = parseAudit(audit.stdout);
+  return {
+    vulnerabilities,
+    auditError: error,
+    outdated: parseOutdated(outdated.stdout),
+    ...findUnusedAndMissing(pkg, scanImports(cwd), cwd)
+  };
+}
+
+// src/prompts/deps.ts
+function depsPrompt(r, nodeVersion) {
+  const lines = [`Node ${nodeVersion}`];
+  if (r.vulnerabilities.length) {
+    lines.push("Vulnerabilities:", ...r.vulnerabilities.slice(0, 20).map((v) => `- ${v.name} [${v.severity}] ${v.title ?? ""}`));
+    lines.push("Fix commands (already computed and correct):", ...fixPlan(r.vulnerabilities).map((f) => `- ${f.command} \u2192 fixes ${f.fixes.join(", ")}`));
+  }
+  if (r.outdated.length) {
+    lines.push("Outdated:", ...r.outdated.slice(0, 25).map((o) => `- ${o.name} ${o.current ?? "not installed"} \u2192 latest ${o.latest}${o.major ? " (MAJOR)" : ""}`));
+  }
+  if (r.unused.length) lines.push(`Possibly unused dependencies: ${r.unused.join(", ")}`);
+  if (r.missing.length) lines.push(`Imported but not declared in package.json: ${r.missing.join(", ")}`);
+  return {
+    instruction: "You are given facts about a Node.js project's dependencies. Write a short, prioritized action plan:\n1. Security: repeat each fix command exactly as given and say in one line why it matters. Never change versions.\n2. Major upgrades (marked MAJOR only): for each, the main breaking-change risk you know of and what to check.\n3. Cleanup: unused packages to remove and missing packages to add.\nDo not repeat the raw lists. Do not invent versions or advisories. Skip any section with nothing to do.",
+    input: lines.join("\n")
+  };
+}
+
+// src/commands/deps.ts
+var SEVERITY_COLOR = {
+  critical: chalk3.bgRed.white,
+  high: chalk3.red,
+  moderate: chalk3.yellow,
+  low: chalk3.blue,
+  info: chalk3.dim
+};
+var isHealthy = (r) => !r.vulnerabilities.length && !r.outdated.length && !r.unused.length && !r.missing.length;
+function printReport(r) {
+  if (r.auditError) console.log(chalk3.yellow(`npm audit: ${r.auditError}`));
+  if (r.vulnerabilities.length) {
+    console.log(chalk3.bold(`Vulnerabilities (${r.vulnerabilities.length})`));
+    for (const v of r.vulnerabilities) {
+      const color = SEVERITY_COLOR[v.severity] ?? chalk3.white;
+      console.log(`  ${color(v.severity.padEnd(8))} ${v.name.padEnd(20)} ${chalk3.dim(v.title ?? "")}`);
+    }
+    console.log(chalk3.bold("\nFix"));
+    for (const f of fixPlan(r.vulnerabilities)) console.log(`  ${chalk3.green(f.command)}  ${chalk3.dim(`\u2192 ${f.fixes.join(", ")}`)}`);
+    console.log();
+  }
+  if (r.outdated.length) {
+    console.log(chalk3.bold(`Outdated (${r.outdated.length})`));
+    for (const o of r.outdated) {
+      const latest = o.major ? chalk3.red(`${o.latest} major`) : chalk3.green(o.latest);
+      console.log(`  ${o.name.padEnd(28)} ${(o.current ?? "missing").padEnd(10)} \u2192 ${latest}`);
+    }
+    console.log();
+  }
+  if (r.unused.length) console.log(`${chalk3.bold("Possibly unused:")} ${r.unused.join(", ")}
+`);
+  if (r.missing.length) console.log(`${chalk3.bold("Imported but not in package.json:")} ${r.missing.join(", ")}
+`);
+}
+async function depsCommand(config2, opts) {
+  const cwd = process.cwd();
+  readPackageJson(cwd);
+  const spinner = !opts.json && process.stderr.isTTY ? ora2({ text: "Running npm audit and npm outdated\u2026", stream: process.stderr }).start() : null;
+  const report = await collectDeps(cwd).finally(() => spinner?.stop());
+  const wantAi = opts.ai && !isHealthy(report);
+  if (opts.json) {
+    const analysis = wantAi ? await generate(config2, depsPrompt(report, process.versions.node), { json: true }) : void 0;
+    printJson({ ...report, analysis });
+    return;
+  }
+  printReport(report);
+  if (isHealthy(report)) {
+    console.log(chalk3.green("\u2714 Dependencies look healthy."));
+    return;
+  }
+  if (wantAi) {
+    console.log(chalk3.bold.underline("Advice"));
+    await generate(config2, depsPrompt(report, process.versions.node), opts);
+  }
+}
+
+// src/commands/doctor.ts
+import chalk4 from "chalk";
+var ok = (msg) => console.log(`${chalk4.green("\u2714")} ${msg}`);
+var fail = (msg, hint) => console.log(`${chalk4.red("\u2716")} ${msg}${hint ? chalk4.dim(`
+  ${hint}`) : ""}`);
+async function probe(name, check) {
+  try {
+    await check();
+    ok(name);
+    return true;
+  } catch (err) {
+    const e = err;
+    fail(`${name}: ${e.message}`, e.hint);
+    return false;
+  }
+}
+async function doctorCommand(config2) {
+  const major = Number(process.versions.node.split(".")[0]);
+  if (major >= 20) ok(`Node.js ${process.versions.node}`);
+  else fail(`Node.js ${process.versions.node}`, "Eventa needs Node.js 20 or newer");
+  const ollamaOk = await probe(`Ollama (${config2.model})`, () => new OllamaProvider(config2.model, config2.ollamaHost).check());
+  const localOk = await probe(`Built-in runtime (${config2.localModel})`, () => new LocalProvider(config2.localModel).check());
+  const active = await createProvider(config2);
+  console.log(chalk4.dim(`
+Provider setting: ${config2.provider} \u2192 using ${active.name} (${active.model})`));
+  if (!ollamaOk && !localOk) console.log(chalk4.dim("Neither is ready yet. Eventa installs the built-in runtime and model on first use, or run `eventa model pull` now."));
+  return major >= 20 && (ollamaOk || localOk);
+}
+
+// src/commands/model.ts
+import { rmSync } from "fs";
+import chalk5 from "chalk";
+function modelList() {
+  const { localModel } = loadConfig();
+  console.log(chalk5.bold("Built-in models"));
+  for (const spec of Object.values(MODELS)) {
+    const mark = spec.id === localModel ? chalk5.green("\u25CF") : " ";
+    const state = isDownloaded(spec) ? chalk5.green("downloaded") : chalk5.dim("not downloaded");
+    console.log(`${mark} ${spec.id.padEnd(22)} ${state.padEnd(24)} ${chalk5.dim(spec.description)}`);
+  }
+  console.log(chalk5.dim(`
+Runtime: ${isRuntimeInstalled() ? `installed in ${runtimeDir()}` : "not installed"}`));
+}
+async function modelPull(id) {
+  const spec = resolveModel(id ?? loadConfig().localModel);
+  const path = await prepareLocal(spec);
+  console.log(chalk5.green(`\u2714 ${spec.id} is ready (${path})`));
+}
+function modelUse(id) {
+  const spec = resolveModel(id);
+  setConfigValue("localModel", MODELS[spec.id] ? spec.id : spec.url || spec.file);
+  console.log(`localModel = ${spec.id}${isDownloaded(spec) ? "" : chalk5.dim("  (downloads on first use, or run `eventa model pull`)")}`);
+}
+function modelRemove(id) {
+  const spec = resolveModel(id);
+  if (!spec.url) throw new Error("Refusing to delete a local file you provided yourself.");
+  rmSync(modelPath(spec), { force: true });
+  rmSync(`${modelPath(spec)}.part`, { force: true });
+  console.log(`Removed ${spec.id}`);
+}
+
+// src/commands/explain.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { relative as relative2 } from "path";
+import chalk6 from "chalk";
+
+// src/context/stackParser.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { isAbsolute, relative, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var FRAME_RE = /^\s*at\s+(?:async\s+(?=[^(]*$))?(?:(.+?)\s+\()?((?:file:\/\/|node:|[A-Za-z]:[\\/]|[\\/.]).+?):(\d+)(?::(\d+))?\)?\s*$/;
+var HEADER_RE = /^((?:file:\/\/\/?)?(?:[A-Za-z]:)?[^\s:]+\.(?:[cm]?[jt]sx?)):(\d+)$/;
+var MESSAGE_RE = /^\s*(?:Uncaught\s+)?((?:[A-Z][A-Za-z]*)?Error(?:\s\[[A-Z0-9_]+\])?:\s.*)$/;
+var CODE_RE = /\b(TS\d{4,5}|P[1-3]\d{3}|ERR_[A-Z0-9_]+|E(?:CONNREFUSED|CONNRESET|ADDRINUSE|ACCES|NOENT|PERM|TIMEDOUT|NOTFOUND|EXIST|ISDIR|MFILE|PIPE))\b/;
+var TSC_RE = /^(.+?\.(?:[cm]?tsx?))(?:\((\d+),(\d+)\)|:(\d+):(\d+)) ?[:-] ?error (TS\d+): (.*)$/;
+var ANSI_RE = /\u001b\[[0-9;]*m/g;
+var PATTERN_CODES = [
+  [/Nest can't resolve dependencies/, "NEST_UNKNOWN_DEPENDENCIES"],
+  [/circular dependency/i, "NEST_CIRCULAR_DEPENDENCY"],
+  [/@prisma\/client did not initialize yet/, "PRISMA_NOT_GENERATED"]
+];
+function toPath(file) {
+  if (file.startsWith("file://")) {
+    try {
+      return fileURLToPath(file);
+    } catch {
+      return file;
+    }
+  }
+  return file;
+}
+function frame(fn, file, line, column) {
+  const path = toPath(file);
+  return {
+    fn: fn?.trim() || void 0,
+    file: path,
+    line: Number(line),
+    column: column ? Number(column) : void 0,
+    internal: path.startsWith("node:") || path.startsWith("internal/"),
+    dependency: /[\\/]node_modules[\\/]/.test(path)
+  };
+}
+function parseStack(raw) {
+  const text = raw.replace(ANSI_RE, "");
+  const result = { frames: [] };
+  const seen = /* @__PURE__ */ new Map();
+  const add = (f) => {
+    const key = `${f.file}:${f.line}`;
+    const existing = seen.get(key);
+    if (existing) {
+      existing.fn ??= f.fn;
+      existing.column ??= f.column;
+      return;
+    }
+    seen.set(key, f);
+    result.frames.push(f);
+  };
+  for (const line of text.split(/\r?\n/)) {
+    const t = TSC_RE.exec(line.trim());
+    if (t) {
+      add(frame(void 0, t[1], t[2] ?? t[4], t[3] ?? t[5]));
+      result.message ??= `error ${t[6]}: ${t[7]}`;
+      continue;
+    }
+    const m = FRAME_RE.exec(line);
+    if (m) {
+      add(frame(m[1], m[2], m[3], m[4]));
+      continue;
+    }
+    const h = HEADER_RE.exec(line.trim());
+    if (h && result.frames.length === 0) add(frame(void 0, h[1], h[2]));
+    const msg = MESSAGE_RE.exec(line);
+    if (msg && !result.message) result.message = msg[1].trim();
+  }
+  result.code = PATTERN_CODES.find(([re]) => re.test(text))?.[1] ?? CODE_RE.exec(text)?.[1];
+  return result;
+}
+function userFrames(parsed, cwd, limit = 3) {
+  return parsed.frames.filter((f) => !f.internal && !f.dependency).map((f) => ({ ...f, file: isAbsolute(f.file) ? f.file : resolve2(cwd, f.file) })).filter((f) => existsSync4(f.file)).slice(0, limit);
+}
+function readSnippet(file, marked, radius = 15, cwd = process.cwd()) {
+  const targets = (Array.isArray(marked) ? marked : [marked]).slice().sort((a, b) => a - b);
+  const lines = readFileSync3(file, "utf8").split(/\r?\n/);
+  const start = Math.max(1, targets[0] - radius);
+  const end = Math.min(lines.length, targets[targets.length - 1] + radius);
+  const body = [];
+  for (let n = start; n <= end; n++) {
+    body.push(targets.includes(n) ? `${lines[n - 1]}  // <-- line ${n}, in the stack trace` : lines[n - 1]);
+  }
+  return `// ${relative(cwd, file) || file} (lines ${start}-${end})
+${body.join("\n")}`;
+}
+function snippetsFor(frames, radius, cwd) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const f of frames) {
+    const lines = byFile.get(f.file) ?? [];
+    const last = lines[lines.length - 1];
+    if (last === void 0 || Math.abs(f.line - last) <= radius * 2) lines.push(f.line);
+    byFile.set(f.file, lines);
+  }
+  return [...byFile].map(([file, lines]) => readSnippet(file, lines, radius, cwd));
+}
+
+// src/context/tokens.ts
+var estimateTokens = (text) => Math.ceil(text.length / 3.5);
+function truncateMiddle(text, maxTokens) {
+  const maxChars = Math.floor(maxTokens * 3.5);
+  if (text.length <= maxChars) return text;
+  const half = Math.floor((maxChars - 40) / 2);
+  return `${text.slice(0, half)}
+\u2026 [${text.length - 2 * half} chars truncated] \u2026
+${text.slice(-half)}`;
+}
+
+// src/prompts/knowledge.ts
+var ERROR_CODES = {
+  ERR_REQUIRE_ESM: 'require() of an ES module. Use import / dynamic import(), switch the file to ESM ("type": "module" or .mjs), or pin an older CJS version of the package.',
+  ERR_MODULE_NOT_FOUND: "ESM import could not be resolved. ESM needs full relative paths with extensions (./util.js) and the package must be installed.",
+  MODULE_NOT_FOUND: "require() could not find the module. Check the path, spelling, and that the package is installed in dependencies.",
+  ERR_UNKNOWN_FILE_EXTENSION: "Node cannot run this extension directly (often .ts). Use tsx/ts-node, compile first, or Node >= 22.6 with --experimental-strip-types.",
+  ERR_PACKAGE_PATH_NOT_EXPORTED: 'Importing a subpath that the package "exports" field does not expose. Import the public entry point instead.',
+  ERR_HTTP_HEADERS_SENT: "Response headers were already sent, usually res.send/res.json called twice. Return after sending, and check async branches.",
+  ERR_INVALID_ARG_TYPE: "A Node API received the wrong type (often undefined). Validate the value before the call.",
+  ERR_UNHANDLED_REJECTION: "A promise rejected with no handler. Add await inside try/catch or a .catch().",
+  ERR_OSSL_EVP_UNSUPPORTED: "OpenSSL 3 rejected a legacy algorithm, common with old webpack. Upgrade the tool, or use NODE_OPTIONS=--openssl-legacy-provider as a temporary workaround.",
+  ERR_INVALID_URL: "new URL() received a relative or malformed string. Provide an absolute URL or a base argument.",
+  ERR_STREAM_PREMATURE_CLOSE: "A stream closed before finishing. Use stream.pipeline() and handle errors on both ends.",
+  ERR_SOCKET_CONNECTION_TIMEOUT: "Socket connect timed out. Check the host/port, firewall, and the timeout settings.",
+  EADDRINUSE: "The port is already taken by another process. Stop it, or use a different PORT.",
+  ECONNREFUSED: "Nothing is listening at the target host:port (DB/API down or wrong address). Start the service or fix the connection config; in Docker use the service name instead of localhost.",
+  ECONNRESET: "The peer closed the connection abruptly. Add retries/timeouts and check the server and proxy logs.",
+  ENOTFOUND: "DNS lookup failed. Check the hostname and the network.",
+  ETIMEDOUT: "The operation timed out. Check network reachability and timeouts.",
+  ENOENT: "File or directory does not exist. Resolve paths from import.meta.dirname / __dirname, not from process.cwd().",
+  EACCES: "Permission denied. Check file permissions; ports < 1024 need elevated rights.",
+  EPERM: "Operation not permitted, often a file locked by another process on Windows or missing rights.",
+  EMFILE: "Too many open files. Close handles, limit concurrency, or use graceful-fs.",
+  TS2304: "Cannot find name: the identifier is not declared or imported. Import it, or install its @types package.",
+  TS2307: "Cannot find module: the path or package does not resolve, or it has no types. Fix the path, install the package, or add @types / a declaration.",
+  TS2322: "Type is not assignable: the value does not match the declared type. Fix the value or widen the type deliberately.",
+  TS2339: "Property does not exist on type: TypeScript does not know about the property. Fix the name, narrow the type, or extend the type definition.",
+  TS2345: "Argument type mismatch: the argument does not match the parameter type. Convert or validate the value before the call.",
+  TS2532: "Object is possibly undefined: narrow with a check, optional chaining, or a default before using it.",
+  TS18048: "Value is possibly undefined: narrow with a check, optional chaining, or a default before using it.",
+  TS18046: "Value is of type 'unknown' (often `catch (err)`): narrow with `err instanceof Error` before reading properties.",
+  TS2554: "Wrong number of arguments for the function signature.",
+  TS2580: `Cannot find a Node.js global such as 'process' or 'require': install @types/node (and add "node" to compilerOptions.types if types are restricted).`,
+  TS2591: `Cannot find a Node.js global such as 'process' or 'Buffer': install @types/node (and add "node" to compilerOptions.types if types are restricted).`,
+  TS2367: "The comparison can never be true because the two types do not overlap (e.g. number vs string). Convert one side first.",
+  TS2741: "A required property is missing from the object literal.",
+  TS2366: "The function has a return type but not every code path returns a value.",
+  TS7006: "Parameter implicitly has an 'any' type (noImplicitAny): add a type annotation.",
+  TS1308: "'await' is only allowed in async functions: mark the function async.",
+  TS2835: "Relative imports need explicit file extensions under node16/nodenext module resolution: write ./file.js.",
+  TS1484: "A type is imported with a value import while verbatimModuleSyntax is on: use `import type`.",
+  P1001: "Prisma cannot reach the database server: check DATABASE_URL, that the database is running, and network/Docker host names.",
+  P2002: "Prisma unique constraint failed: a row with the same unique field already exists. Handle it (e.g. return 409) or use upsert.",
+  P2003: "Prisma foreign key constraint failed: the referenced record does not exist.",
+  P2025: "Prisma record not found for update/delete (or findUniqueOrThrow): check that the record exists or catch P2025 and return 404.",
+  PRISMA_NOT_GENERATED: "@prisma/client was not generated: run `npx prisma generate` after installing or changing schema.prisma (add it to postinstall/build).",
+  NEST_UNKNOWN_DEPENDENCIES: "Nest can't inject a constructor argument: the provider is not in the module's providers, not exported by its module, or the class lacks @Injectable(). The `?` marks the missing argument.",
+  NEST_CIRCULAR_DEPENDENCY: "Two modules or providers import each other. Break the cycle (move shared code to a third module) or use forwardRef(() => X) on both sides."
+};
+var knowledgeFor = (code) => code ? ERROR_CODES[code] : void 0;
+
+// src/prompts/explain.ts
+function explainPrompt(ctx) {
+  const sections = [`Error output:
+\`\`\`
+${ctx.errorText.trim()}
+\`\`\``];
+  const lang = ctx.snippets.some((s) => /^\/\/ \S+\.[cm]?tsx?\b/.test(s)) ? "ts" : "js";
+  if (ctx.snippets.length) sections.push(`Source around the failing lines:
+\`\`\`${lang}
+${ctx.snippets.join("\n\n")}
+\`\`\``);
+  const known = knowledgeFor(ctx.code);
+  if (known) sections.push(`Reference for ${ctx.code}: ${known}`);
+  if (ctx.project) {
+    const deps = ctx.project.dependencies.slice(0, 30).join(", ") || "none";
+    sections.push(`Project: Node ${ctx.project.nodeVersion}, ${ctx.project.moduleType} modules, dependencies: ${deps}`);
+  }
+  return {
+    instruction: "Explain this Node.js / TypeScript error. Reply with exactly three sections:\n**Cause**: the root cause in 1-3 sentences. Name the exact expression that failed and why its value is wrong.\n**Fix**: only the changed lines as a fenced code block, then one sentence on why it works.\n**Prevent**: one short tip.\nBase the answer on the code shown. Do not invent files or APIs.",
+    input: sections.join("\n\n")
+  };
+}
+
+// src/commands/explain.ts
+function projectInfo(cwd) {
+  try {
+    const pkg = readPackageJson(cwd);
+    return {
+      nodeVersion: process.versions.node,
+      moduleType: pkg.type === "module" ? "ESM" : "CommonJS",
+      dependencies: Object.keys(pkg.dependencies ?? {})
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function collectErrorText(words, opts, cwd) {
+  if (opts.run) {
+    const r = await runShell(opts.run, cwd);
+    const output = `${r.stderr}
+${r.stdout}`.trim();
+    if (r.code === 0 && !parseStack(output).message) return null;
+    return output;
+  }
+  if (opts.file) return readFileSync4(opts.file, "utf8");
+  if (words.length) return words.join(" ");
+  return readStdin();
+}
+async function explainCommand(words, config2, opts) {
+  const cwd = process.cwd();
+  const errorText = await collectErrorText(words, opts, cwd);
+  if (errorText === null) {
+    console.log(chalk6.green("\u2714 Command exited cleanly, nothing to explain."));
+    return;
+  }
+  if (!errorText.trim()) {
+    throw new Error('No error to explain. Pipe it in (node app.js 2>&1 | eventa explain), pass --file crash.log, or use --run "node app.js".');
+  }
+  const parsed = parseStack(errorText);
+  const frames = userFrames(parsed, cwd);
+  const budget = config2.contextSize - 1500;
+  const snippets = snippetsFor(frames, 12, cwd);
+  while (snippets.length > 1 && estimateTokens(snippets.join("\n")) > budget * 0.5) snippets.pop();
+  const parts = explainPrompt({
+    errorText: truncateMiddle(errorText, Math.floor(budget * 0.35)),
+    code: parsed.code,
+    snippets,
+    project: projectInfo(cwd)
+  });
+  const where = frames.map((f) => `${relative2(cwd, f.file)}:${f.line}`);
+  if (!opts.json) {
+    console.log(chalk6.bold.red(parsed.message ?? errorText.trim().split("\n")[0]));
+    if (where.length) console.log(chalk6.dim(`Looking at ${where.join(", ")}`));
+    console.log();
+  }
+  const analysis = await generate(config2, parts, opts);
+  if (opts.json) printJson({ message: parsed.message, code: parsed.code, frames: where, analysis });
+}
+
+// src/commands/review.ts
+import chalk7 from "chalk";
+
+// src/context/diff.ts
+var SKIP = [/(^|\/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb?)$/, /(^|\/)(dist|build|coverage|node_modules)\//, /\.min\.(js|css)$/, /\.(png|jpe?g|gif|ico|woff2?|gguf|map)$/];
+var isReviewable = (path) => !SKIP.some((re) => re.test(path));
+function parseDiff(diff) {
+  const files = [];
+  let current = null;
+  let newLine = 0;
+  for (const line of diff.split(/\r?\n/)) {
+    if (line.startsWith("diff --git ")) {
+      const m = / b\/(.+)$/.exec(line);
+      current = { path: m?.[1] ?? line, status: "modified", patch: "", added: [] };
+      files.push(current);
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("new file mode")) current.status = "added";
+    else if (line.startsWith("deleted file mode")) current.status = "deleted";
+    else if (line.startsWith("rename to ")) current.status = "renamed";
+    if (/^(index |--- |\+\+\+ |new file|deleted file|similarity|rename |old mode|new mode)/.test(line)) continue;
+    if (line.startsWith("Binary files")) {
+      current.patch = "";
+      current.status = "deleted";
+      continue;
+    }
+    const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
+    if (hunk) {
+      newLine = Number(hunk[1]);
+      current.patch += line + "\n";
+      continue;
+    }
+    if (line.startsWith("+")) {
+      current.added.push({ line: newLine, text: line.slice(1) });
+      current.patch += `${String(newLine).padStart(4)} ${line}
+`;
+      newLine++;
+    } else if (line.startsWith("-")) {
+      current.patch += `     ${line}
+`;
+    } else if (line.startsWith(" ")) {
+      current.patch += `${String(newLine).padStart(4)} ${line}
+`;
+      newLine++;
+    }
+  }
+  return files.filter((f) => f.status !== "deleted" && f.patch && isReviewable(f.path));
+}
+function splitPatch(patch, maxChars) {
+  if (patch.length <= maxChars) return [patch];
+  const hunks = patch.split(/(?=^@@ )/m);
+  const parts = [];
+  let buf = "";
+  for (const h of hunks) {
+    if (buf && buf.length + h.length > maxChars) {
+      parts.push(buf);
+      buf = "";
+    }
+    buf += h.length > maxChars ? h.slice(0, maxChars) + "\n\u2026 [hunk truncated]\n" : h;
+  }
+  if (buf) parts.push(buf);
+  return parts;
+}
+
+// src/context/heuristics.ts
+var RULES = [
+  { rule: "eval", severity: "high", re: /\b(eval|new Function)\s*\(/, message: "dynamic code execution (eval / new Function)" },
+  { rule: "shell-injection", severity: "high", re: /\bexec(Sync)?\s*\(\s*`[^`]*\$\{/, message: "child_process exec with an interpolated string, possible command injection" },
+  { rule: "sql-injection", severity: "high", re: /\b(query|execute|raw)\s*\(\s*`\s*(SELECT|INSERT|UPDATE|DELETE)[^`]*\$\{/i, message: "SQL built with template interpolation, use parameters" },
+  { rule: "sync-fs", severity: "medium", re: /\b(readFileSync|writeFileSync|readdirSync|existsSync|statSync)\s*\(/, message: "synchronous fs call, blocks the event loop if used in a request path" },
+  { rule: "secret", severity: "high", re: /\b(api[_-]?key|secret|password|token)\b\s*[:=]\s*['"][^'"]{8,}['"]/i, message: "possible hard-coded secret" },
+  { rule: "promise-no-await", severity: "high", re: /^\s*(?!return\b|await\b|const\b|let\b|var\b)[\w.]+\.(save|create|update\w*|delete\w*|insert\w*|send|fetch|query|find\w+|remove\w*)\s*\([^)]*\)\s*;?\s*$/, message: "async-looking call without await or return, result and errors are dropped" },
+  { rule: "empty-catch", severity: "medium", re: /catch\s*(\(\w*\))?\s*\{\s*\}/, message: "empty catch swallows errors" },
+  { rule: "then-no-catch", severity: "medium", re: /\.then\([^)]*\)\s*;\s*$/, message: ".then() without .catch(), possible unhandled rejection" },
+  { rule: "console-log", severity: "low", re: /\bconsole\.log\(/, message: "leftover console.log" },
+  { rule: "tls-off", severity: "high", re: /rejectUnauthorized\s*:\s*false|NODE_TLS_REJECT_UNAUTHORIZED/, message: "TLS certificate verification disabled" },
+  { rule: "foreach-async", severity: "high", re: /\.forEach\(\s*async\b/, message: "forEach does not await async callbacks; the caller continues before they finish" },
+  { rule: "jwt-decode", severity: "high", re: /\bjwt\.decode\(/, message: "jwt.decode does not verify the signature" },
+  { rule: "prisma-raw-unsafe", severity: "high", re: /\$(queryRawUnsafe|executeRawUnsafe)\(\s*`[^`]*\$\{/, message: 'Prisma raw "Unsafe" query with interpolation, possible SQL injection' },
+  { rule: "open-redirect", severity: "high", re: /\bredirect\(\s*req\.(query|body|params)\b/, message: "redirect target comes from user input (open redirect)" },
+  { rule: "assign-in-if", severity: "high", re: /\bif\s*\(\s*[\w.$[\]'"]+\s*=(?![=>])/, message: "assignment inside an if condition, probably meant === " },
+  { rule: "insecure-random", severity: "medium", re: /Math\.random\(\)\.toString\(\d+\)/, message: "Math.random() is not cryptographically secure; do not use it for tokens or IDs" },
+  { rule: "parseint-unchecked", severity: "medium", re: /\bparseInt\(\s*[^,()]+\)/, message: "parseInt without radix; NaN and out-of-range values are not handled" },
+  { rule: "sort-default", severity: "low", re: /\.sort\(\)/, message: "sort() without a comparator compares as strings (wrong for numbers)" },
+  { rule: "weak-hash", severity: "medium", re: /createHash\(\s*['"](md5|sha1)['"]/, message: "md5/sha1 are weak; never use fast hashes for passwords" }
+];
+var LOOP_START_RE = /^\s*(for|while)\s*\(|\.forEach\(|\.map\(\s*async/;
+var QUERY_RE = /\bawait\s+[\w.$]+\.(find\w*|query|count|aggregate|get\w*|load\w*)\(/;
+var braceDelta = (text) => (text.match(/\{/g)?.length ?? 0) - (text.match(/\}/g)?.length ?? 0);
+function scanAddedLines(added) {
+  const hints = [];
+  const push = (line, r) => hints.push({ line, rule: r.rule, severity: r.severity, message: r.message });
+  let loopDepth = 0;
+  let depth = 0;
+  for (const { line, text } of added) {
+    for (const r of RULES) if (r.re.test(text)) push(line, r);
+    if (loopDepth && QUERY_RE.test(text)) push(line, { rule: "query-in-loop", severity: "medium", message: "database query inside a loop (N+1); batch it or load relations in one query" });
+    if (!loopDepth && LOOP_START_RE.test(text)) loopDepth = depth + 1;
+    depth += braceDelta(text);
+    if (loopDepth && depth < loopDepth) loopDepth = 0;
+  }
+  return hints;
+}
+
+// src/prompts/review.ts
+function reviewPrompt(path, patch, hints) {
+  const sections = [`File: ${path}
+Diff (left column is the new line number, + added, - removed):
+\`\`\`diff
+${patch.trimEnd()}
+\`\`\``];
+  if (hints.length) sections.push(`Static checks flagged:
+${hints.map((h) => `- [${h.severity}] line ${h.line}: ${h.message}`).join("\n")}`);
+  return {
+    instruction: 'Review this Node.js code change. Report only real problems in the added lines: bugs, missing await, unhandled promise rejections, error handling, security (injection, path traversal, secrets, unsafe TLS), and event-loop blocking work in request paths. Confirm or dismiss each static check.\nFormat each issue as: `- [high|medium|low] line N: problem \u2192 fix`. Add a short code block only when the fix is not obvious.\nSeverity: injection, secrets, disabled TLS and lost errors from a missing await are high; swallowed errors and blocking I/O are medium; style is low.\nWrite "No issues found." only when you list no issues at all.',
+    input: sections.join("\n\n")
+  };
+}
+
+// src/commands/review.ts
+var SEVERITY = { high: chalk7.red, medium: chalk7.yellow, low: chalk7.dim };
+var git = (args, cwd) => exec("git", args, { cwd, shell: false });
+async function getDiff(cwd, base) {
+  if ((await git(["rev-parse", "--is-inside-work-tree"], cwd)).code !== 0) throw new Error("Not inside a git repository.");
+  const flags = ["diff", "--no-color", "--no-ext-diff", "-U3"];
+  if (base) {
+    const r = await git([...flags, `${base}...HEAD`], cwd);
+    if (r.code !== 0) throw new Error(r.stderr.trim() || `git diff ${base}...HEAD failed`);
+    return { diff: r.stdout, label: `changes since ${base}` };
+  }
+  const staged = await git([...flags, "--staged"], cwd);
+  if (staged.stdout.trim()) return { diff: staged.stdout, label: "staged changes" };
+  return { diff: (await git(flags, cwd)).stdout, label: "unstaged changes" };
+}
+async function reviewCommand(config2, opts) {
+  const cwd = process.cwd();
+  const { diff, label } = await getDiff(cwd, opts.base);
+  const files = parseDiff(diff).slice(0, Number(opts.maxFiles) || 20);
+  if (!files.length) {
+    if (opts.json) printJson([]);
+    else console.log(chalk7.yellow("Nothing to review: no changed source files found."));
+    return;
+  }
+  if (!opts.json) console.log(chalk7.dim(`Reviewing ${label} in ${files.length} file(s)
+`));
+  const maxChars = Math.min(12e3, Math.floor((config2.contextSize - 2e3) * 3.5));
+  const results = [];
+  for (const file of files) {
+    const hints = scanAddedLines(file.added);
+    const parts = splitPatch(file.patch, maxChars);
+    for (const [i, part] of parts.entries()) {
+      const partHints = hints.filter((h) => part.includes(`${String(h.line).padStart(4)} +`));
+      if (!opts.json) {
+        const suffix = parts.length > 1 ? chalk7.dim(` (part ${i + 1}/${parts.length})`) : "";
+        console.log(chalk7.bold.cyan(`\u25B8 ${file.path}`) + suffix);
+        if (partHints.length) {
+          console.log(chalk7.bold("Static checks"));
+          for (const h of partHints) console.log(`  ${SEVERITY[h.severity](`[${h.severity}]`)} line ${h.line}: ${h.message}`);
+          console.log(chalk7.bold("AI review"));
+        }
+      }
+      const analysis = await generate(config2, reviewPrompt(file.path, part, partHints), opts);
+      results.push({ file: file.path, hints: partHints, analysis });
+      if (!opts.json && /^no issues found\.?$/i.test(analysis.trim()) && partHints.some((h) => h.severity !== "low")) {
+        console.log(chalk7.yellow("The AI did not confirm the static checks above. Verify them yourself."));
+      }
+      if (!opts.json) console.log();
+    }
+  }
+  if (opts.json) printJson(results);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("eventa").description("Offline AI assistant for Node.js developers").version("0.1.0").option("-m, --model <name>", "model to use (overrides config)").option("--host <url>", "Ollama host URL").option("-p, --provider <name>", "auto | ollama | local").option("--raw", "print plain output without terminal formatting");
+var configFrom = (cmd) => {
+  const g = cmd.optsWithGlobals();
+  if (g.provider && !["auto", "ollama", "local"].includes(g.provider)) throw new Error("--provider must be auto, ollama or local");
+  return { config: loadConfig({ model: g.model, localModel: g.model, ollamaHost: g.host, provider: g.provider }), raw: g.raw };
+};
+program.command("ask").description("ask a Node.js question").argument("<question...>", "your question").action(async (words, _opts, cmd) => {
+  const { config: config2, raw } = configFrom(cmd);
+  await askCommand(words.join(" "), config2, { raw });
+});
+program.command("explain").description("explain a Node.js error or stack trace and suggest a fix").argument("[error...]", "error text (or pipe it via stdin)").option("-f, --file <path>", "read the error from a log file").option("-r, --run <command>", "run a command and explain its failure").option("--json", "print JSON output").addHelpText("after", '\nExamples:\n  node app.js 2>&1 | eventa explain\n  eventa explain --run "npm test"\n  eventa explain --file crash.log').action(async (words, opts, cmd) => {
+  const { config: config2, raw } = configFrom(cmd);
+  await explainCommand(words, config2, { ...opts, raw });
+});
+program.command("review").description("review your staged git diff (falls back to unstaged changes)").option("-b, --base <ref>", "review all changes since a branch or commit, e.g. main").option("--max-files <n>", "maximum files to review", "20").option("--json", "print JSON output").action(async (opts, cmd) => {
+  const { config: config2, raw } = configFrom(cmd);
+  await reviewCommand(config2, { ...opts, raw });
+});
+program.command("deps").description("audit dependencies: vulnerabilities, outdated, unused and missing packages").option("--no-ai", "only print the report, skip AI advice").option("--json", "print JSON output").action(async (opts, cmd) => {
+  const { config: config2, raw } = configFrom(cmd);
+  await depsCommand(config2, { ...opts, raw });
+});
+program.command("doctor").description("check that Node.js, Ollama and the model are ready").action(async (_opts, cmd) => {
+  const healthy = await doctorCommand(configFrom(cmd).config);
+  if (!healthy) process.exitCode = 1;
+});
+var model = program.command("model").description("manage the built-in local model");
+model.command("list").description("show built-in models and what is downloaded").action(modelList);
+model.command("pull").argument("[id]", "model id, .gguf URL or path (default: configured localModel)").description("install the runtime and download a model").action(modelPull);
+model.command("use").argument("<id>").description("set the default local model").action(modelUse);
+model.command("rm").argument("<id>").description("delete a downloaded model").action(modelRemove);
+var config = program.command("config").description("view or change settings");
+config.command("get").argument("[key]").description("print a setting or all settings").action(configGet);
+config.command("set").argument("<key>").argument("<value>").description("change a setting").action(configSet);
+config.command("path").description("print the config file location").action(configWhere);
+program.parseAsync().catch((err) => {
+  if (err instanceof ProviderError) {
+    console.error(chalk8.red(`\u2716 ${err.message}`));
+    if (err.hint) console.error(chalk8.dim(`  ${err.hint}`));
+  } else {
+    console.error(chalk8.red(`\u2716 ${err.message}`));
+  }
+  process.exitCode = 1;
+});