kritya 0.8.2-beta

package/dist/ui/useUsageBudget.js

@@ -0,0 +1,149 @@
+import { useCallback, useRef, useState } from "react";
+import { cacheSavingsFor, costFor, crossedBudgetWarnThreshold, tokenBudgetFor, } from "../agent/budget.js";
+import { crossedContextWarnThreshold } from "../agent/contextWarning.js";
+/** Owns context/usage/cost tracking and the token-budget cap for the session. */
+export function useUsageBudget({ agent, config, modelRef, model, addItem, abortRef, }) {
+    const [usageByModel, setUsageByModel] = useState({});
+    const [ctxPct, setCtxPct] = useState(0);
+    const ctxPctRef = useRef(0);
+    const [tokenBudget, setTokenBudget] = useState(() => tokenBudgetFor(config));
+    const [budgetPct, setBudgetPct] = useState(0);
+    const budgetPctRef = useRef(0);
+    const [budgetUsed, setBudgetUsed] = useState(0);
+    const totalTokensRef = useRef(0);
+    const [budgetStopped, setBudgetStopped] = useState(false);
+    const totalUsage = Object.values(usageByModel).reduce((acc, u) => ({
+        promptTokens: acc.promptTokens + u.promptTokens,
+        completionTokens: acc.completionTokens + u.completionTokens,
+        cachedPromptTokens: (acc.cachedPromptTokens ?? 0) + (u.cachedPromptTokens ?? 0),
+        estimated: acc.estimated || Boolean(u.estimated),
+    }), { promptTokens: 0, completionTokens: 0, cachedPromptTokens: 0, estimated: false });
+    const totalCost = Object.entries(usageByModel).reduce((sum, [id, u]) => {
+        const p = config.pricing?.[id];
+        return p ? sum + costFor(u, p) : sum;
+    }, 0);
+    const costReport = useCallback(() => {
+        const lines = Object.entries(usageByModel).map(([id, u]) => {
+            const p = config.pricing?.[id];
+            const dollars = p ? ` ≈ $${costFor(u, p).toFixed(4)}` : "";
+            const cached = u.cachedPromptTokens ?? 0;
+            const hitRate = cached > 0 && u.promptTokens > 0
+                ? ` (${cached.toLocaleString()} cached, ${Math.round((cached / u.promptTokens) * 100)}% hit rate)`
+                : "";
+            // Some providers omit real token counts; those turns fall back to a
+            // text-length estimate (see agent/loop.ts). Flag it here rather than
+            // let an approximate number pass as an exact one.
+            const estNote = u.estimated ? " (some figures estimated — provider didn't report usage)" : "";
+            return `  ${id}: ${u.promptTokens.toLocaleString()} in${hitRate} / ${u.completionTokens.toLocaleString()} out${dollars}${estNote}`;
+        });
+        if (!lines.length)
+            return "No usage yet this session.";
+        const totalSavings = Object.entries(usageByModel).reduce((sum, [id, u]) => {
+            const p = config.pricing?.[id];
+            return p ? sum + cacheSavingsFor(u, p) : sum;
+        }, 0);
+        const savingsNote = totalSavings > 0 ? ` (saved $${totalSavings.toFixed(4)} via prompt caching)` : "";
+        const total = totalCost > 0 ? `\nEstimated total: $${totalCost.toFixed(4)}${savingsNote}` : "";
+        const ctxNote = `\nContext window: ${ctxPctRef.current}% used`;
+        const budgetNote = `\nToken budget: ${budgetUsed.toLocaleString()} / ${tokenBudget.toLocaleString()} ` +
+            `(${budgetPct}%)${budgetStopped ? " — STOPPED, run /budget reset or /budget <number>" : ""}`;
+        const hint = totalCost > 0
+            ? ""
+            : `\nTip: add per-model prices (USD per 1M tokens) to ~/.kritya/config.json to see $ estimates:\n  "pricing": { "${model}": { "input": 0.6, "output": 2.4, "cachedInput": 0.15 } }\n("cachedInput" is optional — the discounted rate for cache-hit prompt tokens, for cache-savings reporting.)`;
+        return `Usage this session:\n${lines.join("\n")}${total}${ctxNote}${budgetNote}${hint}`;
+    }, [usageByModel, config, totalCost, budgetUsed, tokenBudget, budgetPct, budgetStopped, model]);
+    const resetBudget = () => {
+        totalTokensRef.current = 0;
+        budgetPctRef.current = 0;
+        setBudgetUsed(0);
+        setBudgetPct(0);
+        setBudgetStopped(false);
+        addItem({ kind: "info", text: "Token budget usage reset for this session." });
+    };
+    const setBudgetLimit = (n) => {
+        setTokenBudget(n);
+        const pct = Math.min(999, Math.round((totalTokensRef.current / n) * 100));
+        budgetPctRef.current = pct;
+        setBudgetPct(pct);
+        if (pct < 100)
+            setBudgetStopped(false);
+        addItem({ kind: "info", text: `Token budget set to ${n.toLocaleString()} for this session.` });
+    };
+    /** Feed a turn's reported usage into the running totals; call from onUsage. */
+    const recordUsage = useCallback((u) => {
+        const pct = Math.round(agent.contextUsage() * 100);
+        if (crossedContextWarnThreshold(ctxPctRef.current, pct)) {
+            addItem({
+                kind: "info",
+                text: `⚠ Context usage at ${pct}% — kritya will auto-compact older history soon to stay within the model's context window.`,
+            });
+        }
+        ctxPctRef.current = pct;
+        setCtxPct(pct);
+        const id = modelRef.current;
+        setUsageByModel((prev) => ({
+            ...prev,
+            [id]: {
+                promptTokens: (prev[id]?.promptTokens ?? 0) + u.promptTokens,
+                completionTokens: (prev[id]?.completionTokens ?? 0) + u.completionTokens,
+                cachedPromptTokens: (prev[id]?.cachedPromptTokens ?? 0) + (u.cachedPromptTokens ?? 0),
+                // Once any turn's usage for this model was estimated rather
+                // than provider-reported, the running total is no longer
+                // exact — keep it flagged for the rest of the session.
+                estimated: Boolean(prev[id]?.estimated) || Boolean(u.estimated),
+            },
+        }));
+        totalTokensRef.current += u.promptTokens + u.completionTokens;
+        setBudgetUsed(totalTokensRef.current);
+        const bPct = Math.min(999, Math.round((totalTokensRef.current / tokenBudget) * 100));
+        if (crossedBudgetWarnThreshold(budgetPctRef.current, bPct)) {
+            addItem({
+                kind: "info",
+                text: `⚠ Token budget at ${bPct}% (${totalTokensRef.current.toLocaleString()} / ` +
+                    `${tokenBudget.toLocaleString()} tokens this session). kritya will stop once it ` +
+                    `hits 100% — run /budget to check or raise it.`,
+            });
+            agent.audit?.logTool({
+                tool: "budget",
+                summary: `token budget at ${bPct}% (${totalTokensRef.current}/${tokenBudget})`,
+                outcome: "ok",
+            });
+            agent.turnSpan?.addEvent("budget.warn", { "kritya.budget_pct": bPct });
+        }
+        if (bPct >= 100 && budgetPctRef.current < 100) {
+            addItem({
+                kind: "info",
+                text: `⛔ Token budget reached (${totalTokensRef.current.toLocaleString()} / ` +
+                    `${tokenBudget.toLocaleString()} tokens). Stopping further turns — run ` +
+                    `/budget reset to clear it, or /budget <number> to raise the cap.`,
+            });
+            agent.audit?.logTool({
+                tool: "budget",
+                summary: `token budget reached, stopping (${totalTokensRef.current}/${tokenBudget})`,
+                outcome: "blocked",
+            });
+            agent.turnSpan?.addEvent("budget.stopped", { "kritya.budget_pct": bPct });
+            setBudgetStopped(true);
+            abortRef.current?.abort();
+        }
+        budgetPctRef.current = bPct;
+        setBudgetPct(bPct);
+    }, [agent, addItem, modelRef, tokenBudget, abortRef]);
+    return {
+        usageByModel,
+        totalUsage,
+        totalCost,
+        costReport,
+        ctxPct,
+        ctxPctRef,
+        setCtxPct,
+        tokenBudget,
+        budgetPct,
+        budgetUsed,
+        budgetStopped,
+        resetBudget,
+        setBudgetLimit,
+        recordUsage,
+        totalTokensRef,
+    };
+}

package/dist/ui/viewport.js

@@ -0,0 +1,71 @@
+import { wrapInline } from "./inline.js";
+/** Rows below the streaming region: prompt, status line, spinner, breathing room. */
+const RESERVED_ROWS = 8;
+/** Never collapse the live view to nothing, however short the terminal. */
+const MIN_ROWS = 4;
+/**
+ * Rows held back against an estimate that comes in low. Underestimating by
+ * even one row brings back the bug this file exists to prevent, and the only
+ * cost of overestimating is showing slightly less of the live text.
+ */
+const SAFETY_ROWS = 4;
+/** Columns the renderer itself works in: the terminal, less its padding. */
+const RENDER_INSET = 2;
+/** A table row wraps its cells; assume the worst rather than guess low. */
+const TABLE_ROW_HEIGHT = 3;
+/**
+ * Terminal rows a line will occupy once rendered. Measured with the same
+ * word-wrapping the renderer uses — dividing width by columns assumes words
+ * can be split mid-word, which under-counts every wrapped paragraph.
+ */
+function rowsFor(line, columns) {
+    const width = Math.max(1, columns - RENDER_INSET);
+    const wrapped = wrapInline(line, width).length;
+    return line.includes("|") ? Math.max(wrapped, TABLE_ROW_HEIGHT) : Math.max(1, wrapped);
+}
+/**
+ * The tail of a streaming answer that fits the viewport.
+ *
+ * Ink erases its live region by rewinding a line count, which can only reach
+ * what is still on screen. Let the streaming text grow past the terminal's
+ * height and the erase silently comes up short, stranding a partial copy in
+ * the scrollback — then the finished message prints below it and the answer
+ * appears twice. Showing only what fits keeps the erase exact; the whole
+ * answer is printed once when the turn ends.
+ */
+/**
+ * The terminal's size, falling back to 80x24 when it isn't known.
+ *
+ * `columns` is 0 — not undefined — whenever Node can't get a window size from
+ * the tty (a pty opened without one, some CI runners, a few terminal
+ * emulators mid-resize). `?? 80` sails straight past that and hands the
+ * callers a 0, which after subtracting a margin clamps to the 20-column floor:
+ * Ink still draws its frames 80 wide (it uses `|| 80`), so the prose inside
+ * them wrapped into a narrow ribbon. Matching Ink's own fallback keeps the two
+ * in agreement.
+ */
+export function terminalColumns(stdout) {
+    return stdout?.columns || 80;
+}
+export function terminalRows(stdout) {
+    return stdout?.rows || 24;
+}
+export function tailForViewport(text, columns, rows) {
+    const budget = Math.max(MIN_ROWS, rows - RESERVED_ROWS - SAFETY_ROWS);
+    const lines = text.split("\n");
+    let used = 0;
+    let start = lines.length;
+    while (start > 0) {
+        const next = used + rowsFor(lines[start - 1], columns);
+        if (next > budget)
+            break;
+        used = next;
+        start--;
+    }
+    if (start === 0)
+        return text;
+    const tail = lines.slice(start);
+    // Reopen a fence the cut landed inside, so the tail doesn't render as prose.
+    const fencesDropped = lines.slice(0, start).filter((l) => l.trimStart().startsWith("```")).length;
+    return fencesDropped % 2 === 1 ? `\`\`\`\n${tail.join("\n")}` : tail.join("\n");
+}

package/dist/undo/undo.js

@@ -0,0 +1,293 @@
+import fs from "node:fs";
+import path from "node:path";
+import { writeFileAtomicSync } from "../atomicWrite.js";
+const MAX_ENTRIES = 100;
+// A watcher event this soon after our own snapshot() is treated as kritya's
+// own write settling to disk, not an external edit — write+watch-event
+// latency on a local disk is milliseconds, so this is a generous margin.
+const OWN_WRITE_GRACE_MS = 750;
+// One logical write can fire several raw filesystem events (create, write,
+// close); wait for them to go quiet before reading the file, so we don't
+// catch it mid-write.
+const WATCHER_DEBOUNCE_MS = 100;
+/**
+ * Stack of file states captured before each agent write/edit, grouped by turn.
+ * /undo reverts everything the most recent changing turn did and records the
+ * inverse so /redo can reapply it. Making a new change clears the redo stack.
+ *
+ * Also watches every file kritya has touched this session for changes made
+ * outside kritya (the user editing in their own editor between turns) and
+ * checkpoints those too, as their own undo-able step in the right
+ * chronological position — instead of only implicitly and fragilely
+ * preserving them via whatever the redo stack happens to capture.
+ */
+export class UndoStack {
+    entries = [];
+    redoStack = [];
+    turn = 0;
+    // File-watcher checkpointing. Scoped to files kritya has itself snapshotted
+    // this session — never a whole-repo recursive watch — so this can't pick up
+    // noise from build output, node_modules, or unrelated files, and can't leak
+    // anything not already touched by an undo-tracked write.
+    trackedFiles = new Map(); // absPath -> relPath
+    lastKnownContent = new Map(); // absPath -> content we believe is on disk
+    lastOwnWriteAt = new Map(); // absPath -> Date.now() of our last snapshot()
+    watchedDirs = new Map(); // parent dir -> watcher
+    debounceTimers = new Map(); // absPath -> pending settle check
+    ownWriteSyncTimers = new Map(); // absPath -> pending self-write re-read
+    /** Fires when a file-watcher checkpoint is created for an external edit. */
+    onExternalChange;
+    /** Mark the start of a new agent turn; subsequent snapshots group under it. */
+    beginTurn() {
+        this.turn++;
+    }
+    /** Capture the current state of a file before it is modified. */
+    snapshot(absPath, relPath) {
+        this.entries.push({ relPath, absPath, content: readOrNull(absPath), turn: this.turn });
+        this.evictOldestTurnsOverCap();
+        // A fresh change invalidates any redo history.
+        this.redoStack = [];
+        this.lastOwnWriteAt.set(absPath, Date.now());
+        this.watchForExternalEdits(absPath, relPath);
+        this.scheduleOwnWriteSync(absPath);
+    }
+    /**
+     * Re-read the file once the own-write grace window closes, and record that
+     * as what we believe is on disk.
+     *
+     * `lastKnownContent` used to be updated only when a watcher event arrived,
+     * which quietly assumed every write produces one. macOS coalesces FSEvents
+     * and can drop the event for a write that lands just after the watch is
+     * registered — and when the event for *our own* write goes missing, the
+     * baseline stays at whatever it was before (typically null, for a file we
+     * just created). The next genuine hand-edit is then checkpointed against
+     * that null, and undoing it deletes the user's file rather than restoring
+     * it. Reading the file ourselves removes the dependency on the event.
+     */
+    scheduleOwnWriteSync(absPath) {
+        const existing = this.ownWriteSyncTimers.get(absPath);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            this.ownWriteSyncTimers.delete(absPath);
+            // Only meaningful while the grace window is the reason we'd ignore a
+            // change; a checkpoint taken in the meantime already set the baseline.
+            this.lastKnownContent.set(absPath, readOrNull(absPath));
+        }, OWN_WRITE_GRACE_MS);
+        timer.unref();
+        this.ownWriteSyncTimers.set(absPath, timer);
+    }
+    /** Evict whole turns, never part of one — a half-evicted turn would make
+     *  /undo silently restore only some of that turn's files. If a single turn
+     *  alone exceeds the cap, keep it intact rather than truncate it. */
+    evictOldestTurnsOverCap() {
+        while (this.entries.length > MAX_ENTRIES &&
+            this.entries[0].turn !== this.entries[this.entries.length - 1].turn) {
+            const oldest = this.entries[0].turn;
+            while (this.entries.length && this.entries[0].turn === oldest)
+                this.entries.shift();
+        }
+    }
+    /** Starts watching `absPath`'s parent directory the first time we see this file. */
+    watchForExternalEdits(absPath, relPath) {
+        if (this.trackedFiles.has(absPath))
+            return;
+        this.trackedFiles.set(absPath, relPath);
+        this.lastKnownContent.set(absPath, readOrNull(absPath));
+        // Watch the parent directory, not the file itself: many editors save by
+        // writing a temp file and renaming it over the original, which would
+        // silently stop a watch on the file's own (now-replaced) inode.
+        const dir = path.dirname(absPath);
+        if (this.watchedDirs.has(dir))
+            return;
+        try {
+            const watcher = fs.watch(dir, (_eventType, filename) => {
+                if (!filename)
+                    return;
+                const target = path.join(dir, filename);
+                if (this.trackedFiles.has(target))
+                    this.scheduleWatcherCheck(target);
+            });
+            watcher.on("error", () => {
+                // Best-effort: undo still works via normal snapshotting even if the
+                // watcher errors out (e.g. the directory was removed).
+            });
+            // Don't let a background checkpoint watcher keep the process alive —
+            // closeAll() closes these explicitly on normal exit, but nothing else
+            // (tests, a crash path, an unexpected early return) should hang waiting
+            // on a handle that only exists for a nice-to-have.
+            watcher.unref();
+            this.watchedDirs.set(dir, watcher);
+        }
+        catch {
+            // Watching isn't available (platform limits, permissions, etc.) — the
+            // rest of undo/redo is unaffected, we just won't catch hand edits.
+        }
+    }
+    /**
+     * A single logical write (create + write + close) can fire several raw
+     * filesystem events, and reading the file synchronously on the first one
+     * can catch it mid-write (e.g. truncated to empty). Debounce so we only
+     * ever inspect the file once it's settled.
+     */
+    scheduleWatcherCheck(absPath) {
+        const existing = this.debounceTimers.get(absPath);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            this.debounceTimers.delete(absPath);
+            this.handleWatcherEvent(absPath);
+        }, WATCHER_DEBOUNCE_MS);
+        timer.unref();
+        this.debounceTimers.set(absPath, timer);
+    }
+    handleWatcherEvent(absPath) {
+        const relPath = this.trackedFiles.get(absPath);
+        if (!relPath)
+            return;
+        const current = readOrNull(absPath);
+        const isOwnWrite = Date.now() - (this.lastOwnWriteAt.get(absPath) ?? 0) < OWN_WRITE_GRACE_MS;
+        const known = this.lastKnownContent.get(absPath) ?? null;
+        this.lastKnownContent.set(absPath, current);
+        if (isOwnWrite || current === known)
+            return; // our own write, or no real change
+        this.turn++;
+        this.entries.push({ relPath, absPath, content: known, turn: this.turn, external: true });
+        this.evictOldestTurnsOverCap();
+        this.redoStack = [];
+        this.onExternalChange?.(relPath);
+    }
+    /** Stop all file watchers — call on process exit to avoid dangling handles. */
+    closeAll() {
+        for (const watcher of this.watchedDirs.values()) {
+            try {
+                watcher.close();
+            }
+            catch {
+                // best-effort
+            }
+        }
+        this.watchedDirs.clear();
+        for (const timer of this.debounceTimers.values())
+            clearTimeout(timer);
+        this.debounceTimers.clear();
+        for (const timer of this.ownWriteSyncTimers.values())
+            clearTimeout(timer);
+        this.ownWriteSyncTimers.clear();
+    }
+    get size() {
+        return this.entries.length;
+    }
+    /** The current turn counter — used to mark a checkpoint's position in time. */
+    currentTurn() {
+        return this.turn;
+    }
+    /**
+     * Revert every file change made after `targetTurn` — used by /rewind to roll
+     * the files back to a checkpoint. Reverts one turn at a time via undo(), so
+     * each reverted turn is still individually redoable afterwards. Returns a
+     * summary, or null if nothing newer than the checkpoint needed reverting.
+     */
+    rewindTo(targetTurn) {
+        const results = [];
+        while (this.entries.length && this.entries[this.entries.length - 1].turn > targetTurn) {
+            const result = this.undo();
+            if (result === null)
+                break;
+            results.push(result);
+        }
+        return results.length ? results.join("\n") : null;
+    }
+    /** Revert every change from the most recent changing turn. Returns a description, or null if empty. */
+    undo() {
+        const last = this.entries[this.entries.length - 1];
+        if (!last)
+            return null;
+        const turn = last.turn;
+        const group = [];
+        while (this.entries.length && this.entries[this.entries.length - 1].turn === turn) {
+            // unshift so the group reads in the order the writes happened.
+            group.unshift(this.entries.pop());
+        }
+        // One restore per file, however many times the turn wrote it. A turn that
+        // edits a file twice (an edit, then a fix-up) snapshots it twice, and only
+        // the *first* snapshot holds the state the turn started from — the rest are
+        // intermediate. Walking them all restored an intermediate state as if it
+        // were the original, and captured those same intermediates as the redo
+        // state, so a redo reinstated a half-finished file.
+        const originals = new Map();
+        for (const entry of group) {
+            if (!originals.has(entry.absPath))
+                originals.set(entry.absPath, entry);
+        }
+        // Read every current state before restoring any of it, so redo reapplies
+        // what the turn actually produced rather than what an earlier restore in
+        // this same loop left behind.
+        const redoGroup = [...originals.values()].map((entry) => ({
+            relPath: entry.relPath,
+            absPath: entry.absPath,
+            content: readOrNull(entry.absPath),
+        }));
+        const results = [];
+        for (const entry of originals.values()) {
+            // undo/redo's own restores must not be mistaken for external edits by
+            // the file watcher — mark them the same way snapshot() marks a write.
+            this.lastOwnWriteAt.set(entry.absPath, Date.now());
+            results.push(restore(entry));
+            this.lastKnownContent.set(entry.absPath, entry.content);
+        }
+        this.redoStack.push(redoGroup);
+        return summarize(results, "Reverted");
+    }
+    /** Reapply the most recently undone turn. Returns a description, or null if nothing to redo. */
+    redo() {
+        const group = this.redoStack.pop();
+        if (!group)
+            return null;
+        this.turn++;
+        // Same ordering care as undo(): capture what is on disk now, before any of
+        // this group's restores overwrite it, so the turn stays undoable.
+        const current = group.map((state) => readOrNull(state.absPath));
+        const results = [];
+        for (const [i, state] of group.entries()) {
+            this.entries.push({ ...state, content: current[i], turn: this.turn });
+            this.lastOwnWriteAt.set(state.absPath, Date.now());
+            results.push(restore(state));
+            this.lastKnownContent.set(state.absPath, state.content);
+        }
+        return summarize(results, "Reapplied");
+    }
+}
+// "latin1" maps each byte 0-255 to the same code point, so it round-trips
+// arbitrary binary content (docx/xlsx/pptx/pdf) losslessly, unlike "utf8"
+// which would corrupt byte sequences that aren't valid UTF-8.
+function readOrNull(absPath) {
+    try {
+        return fs.readFileSync(absPath, "latin1");
+    }
+    catch {
+        return null;
+    }
+}
+function restore(state) {
+    if (state.content === null) {
+        try {
+            fs.unlinkSync(state.absPath);
+        }
+        catch {
+            return `Nothing to remove: ${state.relPath}`;
+        }
+        return `Removed ${state.relPath}`;
+    }
+    fs.mkdirSync(path.dirname(state.absPath), { recursive: true });
+    // Atomic for the same reason the write tools are: a crash while restoring
+    // would leave the file half-reverted, with the original now gone from both
+    // the disk and the stack entry we just popped.
+    writeFileAtomicSync(state.absPath, state.content, { encoding: "latin1" });
+    return `Restored ${state.relPath}`;
+}
+function summarize(results, verb) {
+    return results.length === 1
+        ? results[0]
+        : `${verb} ${results.length} files:\n  ${results.join("\n  ")}`;
+}

package/dist/version.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+export const VERSION = pkg.version;

package/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "kritya",
+  "version": "0.8.2-beta",
+  "description": "Kritya — a lean, provider-agnostic terminal coding agent (NVIDIA, OpenAI, OpenRouter, Groq, Ollama, and more)",
+  "type": "module",
+  "bin": {
+    "kritya": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "!dist/test/**",
+    "!dist/electron/**"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.tsx",
+    "test": "npm run build && node scripts/run-tests.mjs",
+    "test:watch": "tsx --test --watch \"src/test/*.test.ts\"",
+    "test:coverage": "npm run build && c8 node scripts/run-tests.mjs",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "check:audit": "node scripts/check-audit.mjs",
+    "check:install-scripts": "node scripts/check-install-scripts.mjs",
+    "link": "npm run build && npm link",
+    "prepublishOnly": "npm run build",
+    "prepare": "husky",
+    "electron:dev": "npm run build && electron .",
+    "electron:build": "npm run build && electron-builder"
+  },
+  "keywords": [
+    "cli",
+    "coding-agent",
+    "terminal",
+    "ai",
+    "llm",
+    "nvidia",
+    "openai-compatible",
+    "mcp"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "docx": "^9.7.1",
+    "exceljs": "^4.4.0",
+    "fast-glob": "^3.3.2",
+    "ink": "^7.1.1",
+    "ink-text-input": "^6.0.0",
+    "jszip": "^3.10.1",
+    "mammoth": "^1.12.0",
+    "openai": "^7.4.0",
+    "pdf-lib": "^1.17.1",
+    "pdfjs-dist": "^6.1.200",
+    "pptxgenjs": "^4.0.1",
+    "react": "^19.2.8",
+    "string-width": "^8.2.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^26.2.0",
+    "@types/react": "^19.2.18",
+    "c8": "^12.0.0",
+    "electron": "^43.3.0",
+    "electron-builder": "^26.15.3",
+    "eslint": "^10.8.1",
+    "globals": "^17.11.0",
+    "husky": "^9.1.7",
+    "ink-testing-library": "^4.0.0",
+    "lint-staged": "^17.3.0",
+    "prettier": "^3.3.0",
+    "tsx": "^4.23.9",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.0.0"
+  },
+  "overrides": {
+    "brace-expansion": "^5.0.8",
+    "exceljs": {
+      "uuid": "^11.1.1",
+      "unzipper": "^0.12.3",
+      "archiver": "^7.0.1",
+      "readdir-glob": "^3.0.0",
+      "glob": "^13.0.0",
+      "fast-csv": "^5.0.7"
+    },
+    "glob": "^13.0.0"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{js,mjs,json,md}": [
+      "prettier --write"
+    ]
+  },
+  "build": {
+    "appId": "com.kritya.desktop",
+    "productName": "Kritya",
+    "directories": {
+      "output": "release"
+    },
+    "publish": null,
+    "files": [
+      "dist/**/*",
+      "electron/**/*",
+      "package.json",
+      "!src/**/*",
+      "!scripts/**/*"
+    ],
+    "win": {
+      "target": "nsis"
+    },
+    "mac": {
+      "target": "dmg"
+    },
+    "linux": {
+      "target": "AppImage"
+    }
+  }
+}