@tianmucreations/jeeves 0.2.0 → 0.3.0

package/dist/app.js

@@ -6,27 +6,35 @@ import { Transcript } from './components/Transcript.js';
 import { Input } from './components/Input.js';
 import { Footer } from './components/Footer.js';
 import { session, useSession } from './state/session.js';
-import { initKeys, hasCredentials, refreshCredit } from './providers/index.js';
-import { getHiddenMetrics, getFavorites, getRecents, getRecentProjects, getDefaultModel, getDefaultProvider, getVerbosePreference } from './platform/config.js';
+import { initKeys, hasCredentials, refreshCredit, serviceKey } from './providers/index.js';
+import { isDirectService } from './providers/direct-services.js';
+import { loadDirectModels } from './providers/catalogue.js';
+import { getDailyLimit, getFavorites, getRecents, getRecentProjects, getDefaultModel, getDefaultProvider, getVerbosePreference } from './platform/config.js';
 import { loadModels } from './models/registry.js';
 import { ModelPicker } from './components/ModelPicker.js';
 import { KeysManager } from './components/KeysManager.js';
 import { HelpView } from './components/HelpView.js';
 import { ProjectPicker } from './components/ProjectPicker.js';
-// The whole frame is exactly the height of the terminal window, so nothing ever
-// scrolls away: the header is pinned at the top, the footer and input at the bottom,
-// and only the fixed-height transcript area in the middle re-clips its content.
+import { AddressPrompt } from './components/AddressPrompt.js';
+// The main window: a rounded box border around the top section only, with the
+// info bar on its own row below the box. Top to bottom: plain top border, header
+// row inside the box (Jeeves left, dot right), transcript (flexGrow), internal
+// separator, input row, plain bottom border closing the box, then the info bar
+// outside the box at the very bottom (model left, metrics right). Budget:
+// border 1 + header 1 + transcript rows-6 + separator 1 + input 1 + border 1 +
+// info bar 1 = exactly the terminal's rows.
 export function App() {
     const s = useSession();
     const { stdout } = useStdout();
     const rows = Math.max(stdout.rows ?? 24, 8);
     const columns = Math.max(stdout.columns ?? 80, 40);
-    const transcriptHeight = Math.max(1, rows - 7);
-    const innerWidth = columns - 4;
-    const separator = '─'.repeat(innerWidth);
+    const inner = columns - 2;
+    const midHeight = Math.max(1, rows - 6);
+    const side = '│\n'.repeat(midHeight - 1) + '│';
+    const separator = '─'.repeat(inner);
     useEffect(() => {
-        session.setHiddenMetrics(getHiddenMetrics());
         session.setFavorites(getFavorites());
+        session.setDailyLimit(getDailyLimit());
         session.setRecents(getRecents());
         session.setRecentProjects(getRecentProjects());
         if (getVerbosePreference())
@@ -41,6 +49,10 @@ export function App() {
         // Keys resolve from the Mac keychain first; the first-run wizard now starts
         // after the project is chosen (the project list always shows first).
         void initKeys().then(() => {
+            // A direct connection's models (memory sizes, prices) load in the background.
+            const directKey = isDirectService(session.providerId) ? serviceKey(session.providerId) : null;
+            if (directKey)
+                void loadDirectModels(session.providerId, directKey).catch(() => { });
             if (hasCredentials()) {
                 void refreshCredit();
             }
@@ -61,8 +73,11 @@ export function App() {
     if (s.helpOpen) {
         return _jsx(HelpView, { rows: rows });
     }
+    if (s.addressOpen || s.launchStage === 'address') {
+        return _jsx(AddressPrompt, { rows: rows });
+    }
     if (s.launchStage === 'project') {
         return _jsx(ProjectPicker, { rows: rows, columns: columns });
     }
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", paddingX: 1, height: rows, children: [_jsx(Header, {}), _jsx(Transcript, { height: transcriptHeight, width: innerWidth }), _jsx(Text, { dimColor: true, children: separator }), _jsx(Input, { scrollPage: transcriptHeight }), _jsx(Text, { dimColor: true, children: separator }), _jsx(Footer, {})] }));
+    return (_jsxs(Box, { flexDirection: "column", height: rows, width: columns, children: [_jsxs(Text, { dimColor: true, children: ["\u256D", separator, "\u256E"] }), _jsxs(Box, { height: 1, children: [_jsx(Text, { dimColor: true, children: "\u2502" }), _jsx(Box, { width: inner, paddingLeft: 1, paddingRight: 1, flexDirection: "column", children: _jsx(Header, {}) }), _jsx(Text, { dimColor: true, children: "\u2502" })] }), _jsxs(Box, { height: midHeight, children: [_jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { dimColor: true, children: side }) }), _jsx(Box, { width: inner, paddingLeft: 1, paddingRight: 1, children: _jsx(Transcript, { width: inner - 2 }) }), _jsx(Box, { width: 1, flexShrink: 0, children: _jsx(Text, { dimColor: true, children: side }) })] }), _jsxs(Text, { dimColor: true, children: ["\u251C", separator, "\u2524"] }), _jsxs(Box, { height: 1, children: [_jsx(Text, { dimColor: true, children: "\u2502 " }), _jsx(Box, { width: inner - 2, children: _jsx(Input, { scrollPage: midHeight, width: inner - 2 }) }), _jsx(Text, { dimColor: true, children: " \u2502" })] }), _jsxs(Text, { dimColor: true, children: ["\u2570", separator, "\u256F"] }), _jsx(Box, { height: 1, flexDirection: "column", children: _jsx(Footer, {}) })] }));
 }

package/dist/checkpoints/index.js

@@ -0,0 +1,103 @@
+import path from 'node:path';
+import { session } from '../state/session.js';
+import { settingsFolder } from '../platform/config.js';
+import { CheckpointStore } from './store.js';
+// Ties backups to the conversation: one checkpoint per message, taken just before
+// the first thing Jeeves changes in answer to it (after permission, before the change),
+// so /undo puts the folder back to how it was before that message.
+let turnLabel = '';
+let takenThisTurn = false;
+const warnedIncomplete = new Set();
+export function checkpointStoreRoot() {
+    return process.env.JEEVES_CHECKPOINTS_DIR || path.join(settingsFolder(), 'checkpoints');
+}
+function store() {
+    return new CheckpointStore(checkpointStoreRoot(), process.cwd());
+}
+export function startTurnCheckpoints(label) {
+    turnLabel = label;
+    takenThisTurn = false;
+}
+// Called before any change. Never throws: a backup failure is reported plainly and
+// the person decides - but the change is not silently made without a backup.
+export async function ensureCheckpoint() {
+    if (takenThisTurn)
+        return { ok: true };
+    session.setBusyNote('backing up…');
+    try {
+        const checkpoint = await store().create(turnLabel || 'a change');
+        takenThisTurn = true;
+        const folder = process.cwd();
+        if (checkpoint.skipped.length > 0 && !warnedIncomplete.has(folder)) {
+            warnedIncomplete.add(folder);
+            const shown = checkpoint.skipped.slice(0, 3).join('; ');
+            const more = checkpoint.skipped.length > 3 ? `, and ${checkpoint.skipped.length - 3} more` : '';
+            session.addNotice(`Backup note: ${shown}${more}. /undo can't bring those back.`);
+        }
+        return { ok: true };
+    }
+    catch (error) {
+        return { ok: false, problem: error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        session.setBusyNote(null);
+    }
+}
+export async function undoLastChange() {
+    const s = store();
+    const checkpoint = await s.latestUndoable();
+    if (!checkpoint)
+        return { message: "There's nothing to undo in this project folder yet.", historyNote: null };
+    session.setBusyNote('undoing…');
+    try {
+        const result = await s.restore(checkpoint);
+        const parts = [];
+        if (result.restored.length > 0)
+            parts.push(`put back ${plural(result.restored.length, 'file')} (${listNames(result.restored)})`);
+        if (result.removed.length > 0)
+            parts.push(`removed ${plural(result.removed.length, 'file')} added since (${listNames(result.removed)})`);
+        const what = parts.length > 0 ? parts.join(', and ') : 'nothing needed changing';
+        const label = checkpoint.label.length > 60 ? checkpoint.label.slice(0, 59) + '…' : checkpoint.label;
+        let message = `Undone: the folder is back to how it was before "${label}" - ${what}.`;
+        if (result.failed.length > 0)
+            message += ` ${plural(result.failed.length, 'file')} could not be put back: ${listNames(result.failed)}.`;
+        if (checkpoint.skipped.length > 0)
+            message += ' Some things were never backed up, so they were left as they are.';
+        return {
+            message,
+            historyNote: `[The person used /undo. The project folder was put back to how it was before their message "${checkpoint.label}". Any changes made after that are gone - check files again before relying on earlier results.]`,
+        };
+    }
+    finally {
+        session.setBusyNote(null);
+    }
+}
+function plural(count, word) {
+    return `${count} ${word}${count === 1 ? '' : 's'}`;
+}
+function listNames(files) {
+    const shown = files.slice(0, 3).join(', ');
+    return files.length > 3 ? `${shown} and ${files.length - 3} more` : shown;
+}
+// Is this location outside the project folder (so /undo cannot reverse a change to it)?
+export function isOutsideProject(target, folder = process.cwd()) {
+    const relative = path.relative(path.resolve(folder), path.resolve(folder, target));
+    return relative.startsWith('..') || path.isAbsolute(relative);
+}
+// Could this command change things outside the project folder? A careful, simple
+// check: absolute paths elsewhere, the home folder, parent folders, administrator
+// rights, and installing programs for the whole computer.
+export function commandMayReachOutside(command, folder = process.cwd()) {
+    if (/(^|[\s;|&])sudo\b|\bbrew\s|\s(-g|--global)\b|\bapt(-get)?\s|\bchoco\s|\bwinget\s/.test(command))
+        return true;
+    if (/(^|[\s'"=])~(\/|\s|$)|(^|[\s'"=/])\.\.(\/|\\|\s|$)|\$HOME|%USERPROFILE%/.test(command))
+        return true;
+    for (const match of command.matchAll(/(?:^|[\s'"=])((?:\/|[A-Za-z]:\\)[^\s'"]*)/g)) {
+        const candidate = match[1];
+        if (/^\/dev\/null$/.test(candidate))
+            continue;
+        if (isOutsideProject(candidate, folder))
+            return true;
+    }
+    return false;
+}

package/dist/checkpoints/store.js

@@ -0,0 +1,239 @@
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+// Automatic backups ("checkpoints") of the project folder, so /undo can put things
+// back. Researched first: Claude Code keeps copies of files its own edit tools
+// change, but cannot undo what a shell command did; Cline and Gemini CLI snapshot
+// the whole folder into a hidden git repository, which covers commands but needs git
+// installed - not a given on a non-coder's machine. This takes the whole-folder
+// approach without git: every file is stored once by its content fingerprint
+// (SHA-256), and a checkpoint is a list of which fingerprint each file had. Files
+// that have not changed since the last checkpoint are recognised by size and
+// modified time and are not read again.
+// Folders that are rebuilt automatically or are the person's own version history.
+// Restoring a .git folder from a copy could damage that history, so it is left alone.
+export const SKIPPED_FOLDERS = new Set(['.git', 'node_modules', '.venv', 'venv', '__pycache__', '.DS_Store']);
+// Limits that keep a checkpoint fast. Past them the checkpoint is marked incomplete
+// and the person is told plainly that some things could not be backed up.
+export const MAX_FILE_BYTES = 50 * 1024 * 1024;
+export const MAX_FILES = 20_000;
+export const MAX_TOTAL_BYTES = 1024 * 1024 * 1024;
+export const KEEP_CHECKPOINTS = 50;
+export function projectKey(folder) {
+    return createHash('sha256').update(path.resolve(folder)).digest('hex').slice(0, 16);
+}
+export class CheckpointStore {
+    folder;
+    dir;
+    constructor(storeRoot, folder) {
+        this.folder = folder;
+        this.dir = path.join(storeRoot, projectKey(folder));
+    }
+    blobPath(hash) {
+        return path.join(this.dir, 'blobs', hash.slice(0, 2), hash);
+    }
+    checkpointsDir() {
+        return path.join(this.dir, 'checkpoints');
+    }
+    async list() {
+        let names;
+        try {
+            names = await fs.readdir(this.checkpointsDir());
+        }
+        catch {
+            return [];
+        }
+        const checkpoints = [];
+        for (const name of names.filter((n) => n.endsWith('.json')).sort()) {
+            try {
+                checkpoints.push(JSON.parse(await fs.readFile(path.join(this.checkpointsDir(), name), 'utf8')));
+            }
+            catch {
+                // A damaged checkpoint record is ignored rather than breaking undo entirely.
+            }
+        }
+        return checkpoints.sort((a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id));
+    }
+    // Walks the folder and records every file, storing any content not stored before.
+    async create(label, now = Date.now(), kind = 'turn') {
+        const previous = (await this.list()).at(-1);
+        const files = {};
+        const folders = [];
+        const skipped = [];
+        let count = 0;
+        let total = 0;
+        let overLimit = false;
+        const walk = async (relative) => {
+            let entries;
+            try {
+                entries = await fs.readdir(path.join(this.folder, relative), { withFileTypes: true });
+            }
+            catch {
+                skipped.push(`the folder "${relative || '.'}" could not be read`);
+                return;
+            }
+            for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+                const rel = relative ? path.join(relative, entry.name) : entry.name;
+                if (SKIPPED_FOLDERS.has(entry.name))
+                    continue;
+                if (entry.isSymbolicLink()) {
+                    skipped.push(`"${rel}" is a shortcut (link), which is not backed up`);
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    folders.push(rel);
+                    await walk(rel);
+                    continue;
+                }
+                if (!entry.isFile())
+                    continue;
+                const full = path.join(this.folder, rel);
+                let stat;
+                try {
+                    stat = await fs.stat(full);
+                }
+                catch {
+                    skipped.push(`"${rel}" could not be read`);
+                    continue;
+                }
+                if (stat.size > MAX_FILE_BYTES) {
+                    skipped.push(`"${rel}" is too large to back up`);
+                    continue;
+                }
+                if (count >= MAX_FILES || total + stat.size > MAX_TOTAL_BYTES) {
+                    overLimit = true;
+                    continue;
+                }
+                const known = previous?.files[rel];
+                if (known && known.size === stat.size && known.mtimeMs === stat.mtimeMs && (await this.hasBlob(known.hash))) {
+                    files[rel] = { ...known, mode: stat.mode };
+                }
+                else {
+                    try {
+                        const content = await fs.readFile(full);
+                        const hash = createHash('sha256').update(content).digest('hex');
+                        await this.storeBlob(hash, content);
+                        files[rel] = { hash, size: stat.size, mtimeMs: stat.mtimeMs, mode: stat.mode };
+                    }
+                    catch {
+                        skipped.push(`"${rel}" could not be read`);
+                        continue;
+                    }
+                }
+                count += 1;
+                total += stat.size;
+            }
+        };
+        await walk('');
+        if (overLimit)
+            skipped.push('the folder is too big to back up completely');
+        const checkpoint = {
+            id: `${now}-${Math.random().toString(36).slice(2, 8)}`,
+            kind,
+            createdAt: now,
+            label: label.slice(0, 200),
+            folder: path.resolve(this.folder),
+            files,
+            folders,
+            skipped,
+        };
+        await fs.mkdir(this.checkpointsDir(), { recursive: true });
+        await fs.writeFile(path.join(this.checkpointsDir(), `${checkpoint.id}.json`), JSON.stringify(checkpoint));
+        await this.prune();
+        return checkpoint;
+    }
+    async hasBlob(hash) {
+        try {
+            await fs.access(this.blobPath(hash));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async storeBlob(hash, content) {
+        const target = this.blobPath(hash);
+        if (await this.hasBlob(hash))
+            return;
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        // Written beside the target, then renamed, so a crash never leaves half a copy.
+        const temporary = `${target}.${process.pid}.tmp`;
+        await fs.writeFile(temporary, content);
+        await fs.rename(temporary, target);
+    }
+    // Puts the folder back exactly as it was at the checkpoint: changed and deleted
+    // files come back, and files created since are removed. A checkpoint of the
+    // current state is taken first, so nothing is ever lost by undoing.
+    async restore(checkpoint, now = Date.now()) {
+        const current = await this.create(`before undoing "${checkpoint.label}"`, now, 'before-undo');
+        const restored = [];
+        const removed = [];
+        const failed = [];
+        for (const [rel, record] of Object.entries(checkpoint.files)) {
+            if (current.files[rel]?.hash === record.hash)
+                continue;
+            const full = path.join(this.folder, rel);
+            try {
+                const content = await fs.readFile(this.blobPath(record.hash));
+                await fs.mkdir(path.dirname(full), { recursive: true });
+                await fs.writeFile(full, content);
+                await fs.chmod(full, record.mode & 0o777);
+                restored.push(rel);
+            }
+            catch {
+                failed.push(rel);
+            }
+        }
+        // Files created since are removed - but only when both copies are complete. If
+        // anything was skipped, a file missing from the checkpoint might simply not have
+        // been backed up, so nothing is deleted blind.
+        const incomplete = checkpoint.skipped.length > 0 || current.skipped.length > 0;
+        for (const rel of Object.keys(current.files)) {
+            if (rel in checkpoint.files || incomplete)
+                continue;
+            try {
+                await fs.rm(path.join(this.folder, rel));
+                removed.push(rel);
+            }
+            catch {
+                failed.push(rel);
+            }
+        }
+        // Folders created since the checkpoint are removed if they are now empty.
+        for (const rel of [...current.folders].sort((a, b) => b.length - a.length)) {
+            if (checkpoint.folders.includes(rel) || incomplete)
+                continue;
+            try {
+                await fs.rmdir(path.join(this.folder, rel));
+            }
+            catch {
+                // Not empty (or already gone) - left as it is.
+            }
+        }
+        // The undone checkpoint is used up, so the next /undo goes one step further back.
+        await fs.rm(path.join(this.checkpointsDir(), `${checkpoint.id}.json`), { force: true });
+        return { checkpoint, restored: restored.sort(), removed: removed.sort(), failed: failed.sort() };
+    }
+    // The most recent checkpoint that /undo would go back to.
+    async latestUndoable() {
+        return (await this.list()).filter((checkpoint) => checkpoint.kind !== 'before-undo').at(-1);
+    }
+    // Keeps the most recent checkpoints and deletes stored content nothing refers to.
+    async prune() {
+        const all = await this.list();
+        const excess = all.slice(0, Math.max(0, all.length - KEEP_CHECKPOINTS));
+        if (excess.length === 0)
+            return;
+        for (const checkpoint of excess) {
+            await fs.rm(path.join(this.checkpointsDir(), `${checkpoint.id}.json`), { force: true });
+        }
+        const referenced = new Set(all.slice(excess.length).flatMap((checkpoint) => Object.values(checkpoint.files).map((f) => f.hash)));
+        const blobsRoot = path.join(this.dir, 'blobs');
+        for (const prefix of await fs.readdir(blobsRoot).catch(() => [])) {
+            for (const hash of await fs.readdir(path.join(blobsRoot, prefix)).catch(() => [])) {
+                if (!referenced.has(hash))
+                    await fs.rm(path.join(blobsRoot, prefix, hash), { force: true });
+            }
+        }
+    }
+}

package/dist/commands/address.js

@@ -0,0 +1,5 @@
+import { session } from '../state/session.js';
+// Reopens the first-launch question so the saved form of address can change.
+export function openAddressPrompt() {
+    session.openAddress();
+}

package/dist/commands/clear.js

@@ -1,9 +1,11 @@
 import { session } from '../state/session.js';
 import { resetStickySession } from '../providers/openrouter.js';
+import { resetResearchGate } from '../agent/research-gate.js';
 // Starts fresh: wipes the screen and the conversation the model remembers.
 export function clearConversation() {
     session.clearTranscript();
     session.setHistory([]);
     session.setLastReasoning('');
     resetStickySession();
+    resetResearchGate();
 }

package/dist/commands/help.js

@@ -1,8 +1,10 @@
 export const COMMANDS = [
     { command: '/help', description: 'show this list' },
     { command: '/model', description: 'pick a different AI model' },
-    { command: '/keys', description: 'add or remove API keys' },
-    { command: '/verbose', description: "show the model's thinking on screen" },
+    { command: '/keys', description: 'add or remove keys' },
+    { command: '/address', description: 'change how Jeeves addresses you' },
+    { command: '/verbose', description: "show the model's thinking and technical details" },
+    { command: '/undo', description: 'put the project folder back to how it was before the last change' },
     { command: '/clear', description: 'start a fresh conversation and clear the screen' },
     { command: '/exit', description: 'quit' },
 ];
@@ -10,8 +12,9 @@ export const KEY_BINDINGS = [
     { command: 'up down', description: 'move in lists' },
     { command: 'Enter', description: 'select' },
     { command: 'Esc', description: 'go back' },
-    { command: 'Tab', description: 'zoom a footer bar' },
     { command: 'Ctrl+R', description: "show the model's last thinking" },
     { command: 'y / n', description: 'allow or deny a permission request' },
-    { command: 'arrows', description: 'scroll the conversation up and down; Page Up / Page Down jump a whole screen' },
+    { command: 'arrows', description: 'scroll the conversation up and down; Page Up / Page Down jump a whole screen; End returns to the newest' },
+    { command: 'wheel', description: 'the trackpad or mouse wheel scrolls the conversation too' },
+    { command: 'copying', description: 'hold Fn and drag to select text (Option in iTerm2, Shift elsewhere)' },
 ];

package/dist/commands/keys.js

@@ -10,6 +10,6 @@ export function describeKeySource(source) {
     if (source === 'keychain')
         return 'key stored in your Mac keychain';
     if (source === 'env')
-        return 'key in the .env development file';
+        return 'key in a local file - add it with /keys to store it safely';
     return 'no key';
 }

package/dist/commands/verbose.js

@@ -4,5 +4,5 @@ import { setVerbosePreference } from '../platform/config.js';
 export function toggleVerbose() {
     session.setVerbose(!session.verbose);
     setVerbosePreference(session.verbose);
-    return session.verbose ? 'Verbose reasoning: on' : 'Verbose reasoning: off';
+    return session.verbose ? "Showing the model's thinking and technical details: on" : "Showing the model's thinking and technical details: off";
 }

package/dist/components/AddressPrompt.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { session } from '../state/session.js';
+import { getAddress, setAddress } from '../platform/config.js';
+import { isMouseSequence } from '../ink/mouse.js';
+// The first-launch question, in Jeeves' own voice, asked once before the project
+// picker whenever no address is saved; /address reopens the same screen later.
+export function AddressPrompt({ rows }) {
+    const [value, setValue] = useState('');
+    const firstRun = session.launchStage === 'address';
+    useInput((input, key) => {
+        if (isMouseSequence(input))
+            return;
+        if (key.return) {
+            const address = value.trim() || getAddress() || 'Sir';
+            setAddress(address.slice(0, 30));
+            session.addressDone();
+            session.addNotice(`Very good - I shall address you as ${address.slice(0, 30)}.`);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setValue((v) => v.slice(0, -1));
+            return;
+        }
+        if (!input || key.ctrl || key.meta)
+            return;
+        setValue((v) => (v.length >= 30 ? v : v + input));
+    });
+    return (_jsxs(Box, { flexDirection: "column", height: rows, children: [_jsx(Text, { dimColor: true, children: "Good evening. Before we begin \u2014 how shall I address you? Sir, Madam, or something else?" }), _jsx(Box, { flexGrow: 1, justifyContent: "center", flexDirection: "column", minHeight: 1, children: _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Address: " }), _jsx(Text, { children: value }), _jsx(Text, { inverse: true, children: " " })] }) }), firstRun ? _jsx(Text, { dimColor: true, children: "type your title \u00B7 Enter save" }) : _jsx(Text, { dimColor: true, children: "type a new title \u00B7 Enter save \u00B7 unchanged keeps the current one" })] }));
+}