@hasna/terminal 0.1.5 → 0.2.1

package/dist/providers/anthropic.js

@@ -0,0 +1,39 @@
+import Anthropic from "@anthropic-ai/sdk";
+export class AnthropicProvider {
+    name = "anthropic";
+    client;
+    constructor() {
+        this.client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+    }
+    isAvailable() {
+        return !!process.env.ANTHROPIC_API_KEY;
+    }
+    async complete(prompt, options) {
+        const message = await this.client.messages.create({
+            model: options.model ?? "claude-haiku-4-5-20251001",
+            max_tokens: options.maxTokens ?? 256,
+            system: options.system,
+            messages: [{ role: "user", content: prompt }],
+        });
+        const block = message.content[0];
+        if (block.type !== "text")
+            throw new Error("Unexpected response type");
+        return block.text.trim();
+    }
+    async stream(prompt, options, callbacks) {
+        let result = "";
+        const stream = await this.client.messages.stream({
+            model: options.model ?? "claude-haiku-4-5-20251001",
+            max_tokens: options.maxTokens ?? 256,
+            system: options.system,
+            messages: [{ role: "user", content: prompt }],
+        });
+        for await (const chunk of stream) {
+            if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+                result += chunk.delta.text;
+                callbacks.onToken(result.trim());
+            }
+        }
+        return result.trim();
+    }
+}

package/dist/providers/base.js

@@ -0,0 +1,4 @@
+// Provider interface for LLM backends (Anthropic, Cerebras, etc.)
+export const DEFAULT_PROVIDER_CONFIG = {
+    provider: "auto",
+};

package/dist/providers/cerebras.js

@@ -0,0 +1,95 @@
+// Cerebras provider — uses OpenAI-compatible API
+// Default for open-source users. Fast inference on Llama models.
+const CEREBRAS_BASE_URL = "https://api.cerebras.ai/v1";
+const DEFAULT_MODEL = "llama3.1-8b";
+export class CerebrasProvider {
+    name = "cerebras";
+    apiKey;
+    constructor() {
+        this.apiKey = process.env.CEREBRAS_API_KEY ?? "";
+    }
+    isAvailable() {
+        return !!process.env.CEREBRAS_API_KEY;
+    }
+    async complete(prompt, options) {
+        const model = options.model ?? DEFAULT_MODEL;
+        const res = await fetch(`${CEREBRAS_BASE_URL}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: options.maxTokens ?? 256,
+                messages: [
+                    { role: "system", content: options.system },
+                    { role: "user", content: prompt },
+                ],
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Cerebras API error ${res.status}: ${text}`);
+        }
+        const json = (await res.json());
+        return (json.choices?.[0]?.message?.content ?? "").trim();
+    }
+    async stream(prompt, options, callbacks) {
+        const model = options.model ?? DEFAULT_MODEL;
+        const res = await fetch(`${CEREBRAS_BASE_URL}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: options.maxTokens ?? 256,
+                stream: true,
+                messages: [
+                    { role: "system", content: options.system },
+                    { role: "user", content: prompt },
+                ],
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Cerebras API error ${res.status}: ${text}`);
+        }
+        let result = "";
+        const reader = res.body?.getReader();
+        if (!reader)
+            throw new Error("No response body");
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed.startsWith("data: "))
+                    continue;
+                const data = trimmed.slice(6);
+                if (data === "[DONE]")
+                    break;
+                try {
+                    const parsed = JSON.parse(data);
+                    const delta = parsed.choices?.[0]?.delta?.content;
+                    if (delta) {
+                        result += delta;
+                        callbacks.onToken(result.trim());
+                    }
+                }
+                catch {
+                    // skip malformed chunks
+                }
+            }
+        }
+        return result.trim();
+    }
+}

package/dist/providers/index.js

@@ -0,0 +1,49 @@
+// Provider auto-detection and management
+import { DEFAULT_PROVIDER_CONFIG } from "./base.js";
+import { AnthropicProvider } from "./anthropic.js";
+import { CerebrasProvider } from "./cerebras.js";
+export { DEFAULT_PROVIDER_CONFIG } from "./base.js";
+let _provider = null;
+/** Get the active LLM provider. Auto-detects based on available API keys. */
+export function getProvider(config) {
+    if (_provider)
+        return _provider;
+    const cfg = config ?? DEFAULT_PROVIDER_CONFIG;
+    _provider = resolveProvider(cfg);
+    return _provider;
+}
+/** Reset the cached provider (useful when config changes). */
+export function resetProvider() {
+    _provider = null;
+}
+function resolveProvider(config) {
+    if (config.provider === "cerebras") {
+        const p = new CerebrasProvider();
+        if (!p.isAvailable())
+            throw new Error("CEREBRAS_API_KEY not set. Run: export CEREBRAS_API_KEY=your-key");
+        return p;
+    }
+    if (config.provider === "anthropic") {
+        const p = new AnthropicProvider();
+        if (!p.isAvailable())
+            throw new Error("ANTHROPIC_API_KEY not set. Run: export ANTHROPIC_API_KEY=your-key");
+        return p;
+    }
+    // auto: prefer Cerebras (open-source friendly), fall back to Anthropic
+    const cerebras = new CerebrasProvider();
+    if (cerebras.isAvailable())
+        return cerebras;
+    const anthropic = new AnthropicProvider();
+    if (anthropic.isAvailable())
+        return anthropic;
+    throw new Error("No API key found. Set one of:\n" +
+        "  export CEREBRAS_API_KEY=your-key  (free, open-source)\n" +
+        "  export ANTHROPIC_API_KEY=your-key (Claude)");
+}
+/** List available providers (for onboarding UI). */
+export function availableProviders() {
+    return [
+        { name: "cerebras", available: new CerebrasProvider().isAvailable() },
+        { name: "anthropic", available: new AnthropicProvider().isAvailable() },
+    ];
+}

package/dist/providers/providers.test.js

@@ -0,0 +1,14 @@
+import { describe, it, expect } from "bun:test";
+import { availableProviders, resetProvider } from "./index.js";
+describe("providers", () => {
+    it("lists available providers", () => {
+        const providers = availableProviders();
+        expect(providers.length).toBe(2);
+        expect(providers[0].name).toBe("cerebras");
+        expect(providers[1].name).toBe("anthropic");
+    });
+    it("resetProvider clears cache", () => {
+        // Should not throw
+        resetProvider();
+    });
+});

package/dist/recipes/model.js

@@ -0,0 +1,20 @@
+// Recipes data model — reusable command templates with collections and projects
+/** Generate a short random ID */
+export function genId() {
+    return Math.random().toString(36).slice(2, 10);
+}
+/** Substitute variables in a command template */
+export function substituteVariables(command, vars) {
+    let result = command;
+    for (const [name, value] of Object.entries(vars)) {
+        result = result.replace(new RegExp(`\\{${name}\\}`, "g"), value);
+    }
+    return result;
+}
+/** Extract variable placeholders from a command */
+export function extractVariables(command) {
+    const matches = command.match(/\{(\w+)\}/g);
+    if (!matches)
+        return [];
+    return [...new Set(matches.map(m => m.slice(1, -1)))];
+}

package/dist/recipes/recipes.test.js

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "bun:test";
+import { genId, substituteVariables, extractVariables } from "./model.js";
+describe("genId", () => {
+    it("generates unique ids", () => {
+        const a = genId();
+        const b = genId();
+        expect(a).not.toBe(b);
+        expect(a.length).toBe(8);
+    });
+});
+describe("substituteVariables", () => {
+    it("replaces {var} placeholders", () => {
+        expect(substituteVariables("kill -9 {pid}", { pid: "1234" })).toBe("kill -9 1234");
+    });
+    it("replaces multiple variables", () => {
+        expect(substituteVariables("curl {host}:{port}", { host: "localhost", port: "3000" }))
+            .toBe("curl localhost:3000");
+    });
+    it("replaces all occurrences of same variable", () => {
+        expect(substituteVariables("{x} and {x}", { x: "y" })).toBe("y and y");
+    });
+    it("leaves unmatched vars alone", () => {
+        expect(substituteVariables("{a} {b}", { a: "1" })).toBe("1 {b}");
+    });
+});
+describe("extractVariables", () => {
+    it("extracts variable names from command", () => {
+        expect(extractVariables("lsof -i :{port} -t | xargs kill")).toEqual(["port"]);
+    });
+    it("deduplicates", () => {
+        expect(extractVariables("{x} {x} {y}")).toEqual(["x", "y"]);
+    });
+    it("returns empty for no variables", () => {
+        expect(extractVariables("ls -la")).toEqual([]);
+    });
+});

package/dist/recipes/storage.js

@@ -0,0 +1,118 @@
+// Recipes storage — global (~/.terminal/recipes.json) + per-project (.terminal/recipes.json)
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { genId, extractVariables } from "./model.js";
+const GLOBAL_DIR = join(homedir(), ".terminal");
+const GLOBAL_FILE = join(GLOBAL_DIR, "recipes.json");
+function projectFile(projectPath) {
+    return join(projectPath, ".terminal", "recipes.json");
+}
+function loadStore(filePath) {
+    if (!existsSync(filePath))
+        return { recipes: [], collections: [] };
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return { recipes: [], collections: [] };
+    }
+}
+function saveStore(filePath, store) {
+    const dir = filePath.replace(/\/[^/]+$/, "");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(filePath, JSON.stringify(store, null, 2));
+}
+// ── CRUD operations ──────────────────────────────────────────────────────────
+/** Get all recipes (merged: global + project-scoped) */
+export function listRecipes(projectPath) {
+    const global = loadStore(GLOBAL_FILE).recipes;
+    if (!projectPath)
+        return global;
+    const project = loadStore(projectFile(projectPath)).recipes;
+    return [...project, ...global]; // project recipes first (higher priority)
+}
+/** Get recipes filtered by collection */
+export function listByCollection(collection, projectPath) {
+    return listRecipes(projectPath).filter(r => r.collection === collection);
+}
+/** Get a recipe by name */
+export function getRecipe(name, projectPath) {
+    return listRecipes(projectPath).find(r => r.name === name) ?? null;
+}
+/** Create a recipe */
+export function createRecipe(opts) {
+    const filePath = opts.project ? projectFile(opts.project) : GLOBAL_FILE;
+    const store = loadStore(filePath);
+    // Auto-detect variables from command if not explicitly provided
+    const detectedVars = extractVariables(opts.command);
+    const variables = opts.variables ?? detectedVars.map(name => ({ name, required: true }));
+    const recipe = {
+        id: genId(),
+        name: opts.name,
+        description: opts.description,
+        command: opts.command,
+        tags: opts.tags ?? [],
+        collection: opts.collection,
+        project: opts.project,
+        variables,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+    };
+    store.recipes.push(recipe);
+    saveStore(filePath, store);
+    return recipe;
+}
+/** Delete a recipe by name — tries project first, then global */
+export function deleteRecipe(name, projectPath) {
+    // Try project-scoped first
+    if (projectPath) {
+        const pFile = projectFile(projectPath);
+        const pStore = loadStore(pFile);
+        const before = pStore.recipes.length;
+        pStore.recipes = pStore.recipes.filter(r => r.name !== name);
+        if (pStore.recipes.length < before) {
+            saveStore(pFile, pStore);
+            return true;
+        }
+    }
+    // Fall back to global
+    const store = loadStore(GLOBAL_FILE);
+    const before = store.recipes.length;
+    store.recipes = store.recipes.filter(r => r.name !== name);
+    if (store.recipes.length < before) {
+        saveStore(GLOBAL_FILE, store);
+        return true;
+    }
+    return false;
+}
+// ── Collections ──────────────────────────────────────────────────────────────
+export function listCollections(projectPath) {
+    const global = loadStore(GLOBAL_FILE).collections;
+    if (!projectPath)
+        return global;
+    const project = loadStore(projectFile(projectPath)).collections;
+    return [...project, ...global];
+}
+export function createCollection(opts) {
+    const filePath = opts.project ? projectFile(opts.project) : GLOBAL_FILE;
+    const store = loadStore(filePath);
+    const collection = {
+        id: genId(),
+        name: opts.name,
+        description: opts.description,
+        project: opts.project,
+        createdAt: Date.now(),
+    };
+    store.collections.push(collection);
+    saveStore(filePath, store);
+    return collection;
+}
+/** Initialize project-scoped recipes file */
+export function initProject(projectPath) {
+    const file = projectFile(projectPath);
+    if (!existsSync(file)) {
+        saveStore(file, { recipes: [], collections: [] });
+    }
+}

package/dist/search/content-search.js

@@ -0,0 +1,61 @@
+// Smart content search — structured grep/ripgrep with grouping and dedup
+import { spawn } from "child_process";
+import { DEFAULT_EXCLUDE_DIRS, relevanceScore } from "./filters.js";
+function exec(command, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let out = "";
+        proc.stdout?.on("data", (d) => { out += d.toString(); });
+        proc.on("close", () => resolve(out));
+    });
+}
+export async function searchContent(pattern, cwd, options = {}) {
+    const { fileType, maxResults = 30, contextLines = 0 } = options;
+    // Prefer ripgrep, fall back to grep
+    const excludeArgs = DEFAULT_EXCLUDE_DIRS.map(d => `--glob '!${d}'`).join(" ");
+    const typeArg = fileType ? `--type ${fileType}` : "";
+    const contextArg = contextLines > 0 ? `-C ${contextLines}` : "";
+    // Try rg first, fall back to grep
+    const rgCmd = `rg --line-number --no-heading ${contextArg} ${typeArg} ${excludeArgs} '${pattern.replace(/'/g, "'\\''")}' 2>/dev/null | head -500`;
+    const grepCmd = `grep -rn ${contextArg} '${pattern.replace(/'/g, "'\\''")}' . --include='*.ts' --include='*.js' --include='*.py' --include='*.go' --include='*.rs' --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=dist 2>/dev/null | head -500`;
+    let raw = await exec(rgCmd, cwd);
+    if (!raw.trim()) {
+        raw = await exec(grepCmd, cwd);
+    }
+    const lines = raw.split("\n").filter(l => l.trim());
+    const fileMap = new Map();
+    let filteredCount = 0;
+    for (const line of lines) {
+        // Format: path:line:content
+        const match = line.match(/^([^:]+):(\d+):(.*)$/);
+        if (!match)
+            continue;
+        const [, path, lineNum, content] = match;
+        if (DEFAULT_EXCLUDE_DIRS.some(d => path.includes(`/${d}/`))) {
+            filteredCount++;
+            continue;
+        }
+        if (!fileMap.has(path))
+            fileMap.set(path, []);
+        fileMap.get(path).push({
+            line: parseInt(lineNum),
+            content: content.trim(),
+        });
+    }
+    // Sort files by relevance
+    const files = [...fileMap.entries()]
+        .map(([path, matches]) => ({
+        path,
+        matches: matches.slice(0, 5), // max 5 matches per file
+        relevance: relevanceScore(path),
+    }))
+        .sort((a, b) => b.relevance - a.relevance)
+        .slice(0, maxResults);
+    const totalMatches = [...fileMap.values()].reduce((sum, m) => sum + m.length, 0);
+    const filtered = filteredCount > 0 ? [{ count: filteredCount, reason: "excluded directories" }] : [];
+    const rawTokens = Math.ceil(raw.length / 4);
+    const result = { query: pattern, totalMatches, files, filtered };
+    const resultTokens = Math.ceil(JSON.stringify(result).length / 4);
+    result.tokensSaved = Math.max(0, rawTokens - resultTokens);
+    return result;
+}

package/dist/search/file-search.js

@@ -0,0 +1,61 @@
+// Smart file search — structured, filtered, token-efficient results
+import { spawn } from "child_process";
+import { DEFAULT_EXCLUDE_DIRS, isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";
+function exec(command, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let out = "";
+        proc.stdout?.on("data", (d) => { out += d.toString(); });
+        proc.stderr?.on("data", (d) => { out += d.toString(); });
+        proc.on("close", () => resolve(out));
+    });
+}
+export async function searchFiles(pattern, cwd, options = {}) {
+    const { includeNodeModules = false, maxResults = 50 } = options;
+    // Build find command
+    const excludes = includeNodeModules
+        ? DEFAULT_EXCLUDE_DIRS.filter(d => d !== "node_modules")
+        : DEFAULT_EXCLUDE_DIRS;
+    const excludeArgs = excludes.map(d => `-not -path '*/${d}/*'`).join(" ");
+    const command = `find . -name '${pattern}' -type f ${excludeArgs} 2>/dev/null | head -${maxResults * 3}`;
+    const raw = await exec(command, cwd);
+    const allPaths = raw.split("\n").filter(l => l.trim());
+    // Categorize
+    const source = [];
+    const config = [];
+    const other = [];
+    const filteredCounts = {};
+    for (const path of allPaths) {
+        if (isExcludedDir(path)) {
+            const dir = DEFAULT_EXCLUDE_DIRS.find(d => path.includes(`/${d}/`)) ?? "other";
+            filteredCounts[dir] = (filteredCounts[dir] ?? 0) + 1;
+            continue;
+        }
+        if (isSourceFile(path)) {
+            source.push(path);
+        }
+        else if (path.match(/\.(json|yaml|yml|toml|ini|env)/)) {
+            config.push(path);
+        }
+        else {
+            other.push(path);
+        }
+    }
+    // Sort by relevance
+    source.sort((a, b) => relevanceScore(b) - relevanceScore(a));
+    // Limit results
+    const filtered = Object.entries(filteredCounts).map(([reason, count]) => ({ reason, count }));
+    // Estimate token savings
+    const rawTokens = Math.ceil(raw.length / 4);
+    const result = {
+        query: pattern,
+        total: allPaths.length,
+        source: source.slice(0, maxResults),
+        config: config.slice(0, 10),
+        other: other.slice(0, 10),
+        filtered,
+    };
+    const resultTokens = Math.ceil(JSON.stringify(result).length / 4);
+    result.tokensSaved = Math.max(0, rawTokens - resultTokens);
+    return result;
+}

package/dist/search/filters.js

@@ -0,0 +1,34 @@
+// Smart filters for search results — auto-hide noise, prioritize source files
+export const DEFAULT_EXCLUDE_DIRS = [
+    "node_modules", ".git", "dist", "build", ".next", "__pycache__",
+    "coverage", ".turbo", ".cache", ".output", "vendor", "target",
+];
+export const SOURCE_EXTENSIONS = new Set([
+    ".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java", ".rb",
+    ".sh", ".c", ".cpp", ".h", ".css", ".scss", ".html", ".vue", ".svelte",
+    ".md", ".json", ".yaml", ".yml", ".toml", ".sql", ".graphql",
+]);
+export const CONFIG_EXTENSIONS = new Set([
+    ".json", ".yaml", ".yml", ".toml", ".ini", ".env", ".config.js",
+    ".config.ts", ".config.mjs",
+]);
+export function isSourceFile(path) {
+    const ext = path.match(/\.\w+$/)?.[0] ?? "";
+    return SOURCE_EXTENSIONS.has(ext);
+}
+export function isExcludedDir(path) {
+    return DEFAULT_EXCLUDE_DIRS.some(d => path.includes(`/${d}/`) || path.includes(`/${d}`));
+}
+/** Relevance score: higher = more relevant */
+export function relevanceScore(path) {
+    if (isExcludedDir(path))
+        return 0;
+    const ext = path.match(/\.\w+$/)?.[0] ?? "";
+    if (SOURCE_EXTENSIONS.has(ext))
+        return 10;
+    if (CONFIG_EXTENSIONS.has(ext))
+        return 5;
+    if (path.includes("/test") || path.includes(".test.") || path.includes(".spec."))
+        return 7;
+    return 3;
+}

package/dist/search/index.js

@@ -0,0 +1,4 @@
+// Smart search — unified entry point for file + content search
+export { searchFiles } from "./file-search.js";
+export { searchContent } from "./content-search.js";
+export { DEFAULT_EXCLUDE_DIRS, SOURCE_EXTENSIONS, isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";

package/dist/search/search.test.js

@@ -0,0 +1,22 @@
+import { describe, it, expect } from "bun:test";
+import { isSourceFile, isExcludedDir, relevanceScore } from "./filters.js";
+describe("filters", () => {
+    it("identifies source files", () => {
+        expect(isSourceFile("src/app.ts")).toBe(true);
+        expect(isSourceFile("index.tsx")).toBe(true);
+        expect(isSourceFile("main.py")).toBe(true);
+        expect(isSourceFile("image.png")).toBe(false);
+        expect(isSourceFile("binary")).toBe(false);
+    });
+    it("identifies excluded directories", () => {
+        expect(isExcludedDir("./node_modules/foo/bar.js")).toBe(true);
+        expect(isExcludedDir("./dist/index.js")).toBe(true);
+        expect(isExcludedDir("./.git/config")).toBe(true);
+        expect(isExcludedDir("./src/lib/utils.ts")).toBe(false);
+    });
+    it("scores source files highest", () => {
+        expect(relevanceScore("src/app.ts")).toBe(10);
+        expect(relevanceScore("./node_modules/foo.js")).toBe(0);
+        expect(relevanceScore("binary")).toBe(3);
+    });
+});

package/dist/snapshots.js

@@ -0,0 +1,51 @@
+// Session snapshots — capture terminal state for agent context handoff
+import { loadHistory } from "./history.js";
+import { bgStatus } from "./supervisor.js";
+import { getEconomyStats, formatTokens } from "./economy.js";
+import { listRecipes } from "./recipes/storage.js";
+/** Capture a compact snapshot of the current terminal state */
+export function captureSnapshot() {
+    // Filtered env — only relevant vars, no secrets
+    const safeEnvKeys = [
+        "PATH", "HOME", "USER", "SHELL", "NODE_ENV", "PWD", "LANG",
+        "TERM", "EDITOR", "VISUAL",
+    ];
+    const env = {};
+    for (const key of safeEnvKeys) {
+        if (process.env[key])
+            env[key] = process.env[key];
+    }
+    // Running processes
+    const processes = bgStatus().map(p => ({
+        pid: p.pid,
+        command: p.command,
+        port: p.port,
+        uptime: Date.now() - p.startedAt,
+    }));
+    // Recent commands (last 10, compressed)
+    const history = loadHistory().slice(-10);
+    const recentCommands = history.map(h => ({
+        cmd: h.cmd,
+        exitCode: h.error,
+        summary: h.nl !== h.cmd ? h.nl : undefined,
+    }));
+    // Project recipes
+    const recipes = listRecipes(process.cwd()).slice(0, 10).map(r => ({
+        name: r.name,
+        command: r.command,
+    }));
+    // Economy
+    const econ = getEconomyStats();
+    return {
+        cwd: process.cwd(),
+        env,
+        runningProcesses: processes,
+        recentCommands,
+        recipes,
+        economy: {
+            tokensSaved: formatTokens(econ.totalTokensSaved),
+            tokensUsed: formatTokens(econ.totalTokensUsed),
+        },
+        timestamp: Date.now(),
+    };
+}