miii-cli 0.3.4 → 0.3.5

package/dist/tui/hooks/useRefactor.js

@@ -0,0 +1,131 @@
+import { useCallback, useRef } from 'react';
+import { generateId } from '../../types.js';
+import { chat } from '../../llm/stream.js';
+import { MicroQueue } from '../../tasks/queue.js';
+import { fileEditContext } from '../../tasks/compactor.js';
+import { StreamParser } from '../../parser/stream-parser.js';
+import * as printer from '../printer.js';
+export function useRefactor(deps) {
+    const depsRef = useRef(deps);
+    depsRef.current = deps;
+    const runRefactor = useCallback(async (goal) => {
+        const { config, currentModelRef, systemPromptRef, abortRef, macroQueueRef, executorRef, setStatus, setTaskLabel, setCurrentTool, pushHistory, } = depsRef.current;
+        printer.systemMsg(`refactor: ${goal}`);
+        setTaskLabel(`planning: ${goal}`);
+        setStatus('thinking');
+        const planCtx = [
+            { role: 'system', content: systemPromptRef.current },
+            {
+                role: 'user',
+                content: `Refactor goal: ${goal}\n\nList every file that needs to change. For each file output:\nFILE: <path>\nCHANGE: <one sentence describing the edit>\n\nUse list_files and read_file to discover relevant files first. Only list files that genuinely need changes.`,
+            },
+        ];
+        abortRef.current = new AbortController();
+        let planText = '';
+        await chat({
+            provider: config.provider,
+            model: currentModelRef.current,
+            baseUrl: config.baseUrl,
+            messages: planCtx,
+            signal: abortRef.current.signal,
+            async onDone(text) { planText = text; },
+            onError(err) { printer.errorMsg(err.message); },
+        });
+        if (!planText) {
+            setStatus('idle');
+            setTaskLabel(undefined);
+            return;
+        }
+        printer.assistantMsg(planText);
+        const filePlan = [];
+        const lines = planText.split('\n');
+        let lastPath = '';
+        for (const line of lines) {
+            const fm = line.match(/^FILE:\s*(.+)/);
+            const cm = line.match(/^CHANGE:\s*(.+)/);
+            if (fm)
+                lastPath = fm[1].trim();
+            if (cm && lastPath) {
+                filePlan.push({ path: lastPath, change: cm[1].trim() });
+                lastPath = '';
+            }
+        }
+        if (!filePlan.length) {
+            printer.systemMsg('no files identified in plan — done');
+            setStatus('idle');
+            setTaskLabel(undefined);
+            return;
+        }
+        printer.systemMsg(`plan: ${filePlan.length} file(s) to change`);
+        const micro = new MicroQueue();
+        for (const fp of filePlan) {
+            const t = { id: `read:${fp.path}`, priority: 1, tool: 'read_file', args: { path: fp.path }, deps: [], status: 'pending' };
+            micro.push(t);
+        }
+        const macro = {
+            id: generateId(),
+            goal,
+            priority: 0,
+            microtasks: micro.toArray(),
+            status: 'running',
+        };
+        macroQueueRef.current.enqueue(macro);
+        setTaskLabel(`reading ${filePlan.length} file(s)…`);
+        const readResults = await executorRef.current.drain(micro, ({ task, error }) => {
+            if (error)
+                printer.errorMsg(`read failed: ${task.args.path} — ${error}`);
+            else
+                printer.systemMsg(`read: ${task.args.path}`);
+        });
+        setTaskLabel(`applying changes…`);
+        const writeMicro = new MicroQueue();
+        for (const fp of filePlan) {
+            const readId = `read:${fp.path}`;
+            const fileContent = readResults.get(readId) ?? '';
+            if (!fileContent) {
+                printer.systemMsg(`skip (unreadable): ${fp.path}`);
+                continue;
+            }
+            setCurrentTool(`edit ${fp.path}`);
+            setTaskLabel(`editing: ${fp.path}`);
+            const editCtx = fileEditContext(systemPromptRef.current, goal, fp.path, fileContent, fp.change);
+            let editText = '';
+            await chat({
+                provider: config.provider,
+                model: currentModelRef.current,
+                baseUrl: config.baseUrl,
+                messages: editCtx,
+                signal: abortRef.current?.signal,
+                async onDone(text) { editText = text; },
+                onError(err) { printer.errorMsg(`edit LLM error: ${err.message}`); },
+            });
+            if (!editText)
+                continue;
+            printer.assistantMsg(editText);
+            const parser = new StreamParser();
+            for (const item of [...parser.feed(editText), ...parser.flush()]) {
+                if (item.type === 'tool_call') {
+                    writeMicro.push({ id: generateId(), priority: 2, tool: item.toolName, args: item.toolArgs, deps: [], status: 'pending' });
+                }
+            }
+        }
+        if (writeMicro.size > 0) {
+            setTaskLabel(`writing ${writeMicro.size} change(s)…`);
+            await executorRef.current.drain(writeMicro, ({ task, result, error }) => {
+                if (error)
+                    printer.errorMsg(`${task.tool} failed: ${error}`);
+                else
+                    printer.toolMsg(task.tool, result ?? '');
+            });
+        }
+        macro.status = 'done';
+        macroQueueRef.current.dequeue();
+        setCurrentTool(undefined);
+        setTaskLabel(undefined);
+        setStatus('idle');
+        printer.systemMsg(`refactor done — ${filePlan.length} file(s) processed`);
+        pushHistory({ role: 'user', content: `[refactor] ${goal}` });
+        pushHistory({ role: 'assistant', content: planText });
+    }, []);
+    return { runRefactor };
+}

package/dist/tui/hooks/useSubmit.js

@@ -0,0 +1,382 @@
+import { useCallback, useRef } from 'react';
+import { readFile } from '../../files/ops.js';
+import { getSystemPrompt } from '../../tools/index.js';
+import { loadSession, saveSession, listSessions, deleteSession, deleteAllSessions } from '../../sessions.js';
+import { runDeepThink } from '../deepThink.js';
+import { buildGitContext, looksCodeRelated } from '../git-context.js';
+import { getTavilyKey, saveTavilyKey } from '../../tavily/client.js';
+import { buildIndex } from '../../index/indexer.js';
+import { indexStats, clearIndex } from '../../index/store.js';
+import { embed } from '../../index/embedder.js';
+import { loadIndex } from '../../index/store.js';
+import { topK } from '../../index/search.js';
+import * as printer from '../printer.js';
+function buildAtContext(text) {
+    const refs = [...text.matchAll(/@([\w./\-]+)/g)];
+    if (!refs.length)
+        return '';
+    const parts = [];
+    for (const m of refs) {
+        try {
+            const content = readFile(m[1]);
+            if (content)
+                parts.push(`<file path="${m[1]}">\n${content}\n</file>`);
+        }
+        catch { }
+    }
+    return parts.length ? parts.join('\n\n') + '\n\n' : '';
+}
+export function useSubmit(deps) {
+    const depsRef = useRef(deps);
+    depsRef.current = deps;
+    const handleSubmit = useCallback(async (text) => {
+        const { config, skills, cwd, version, currentModelRef, setCurrentModel, historyRef, sessionNameRef, saveTimerRef, systemPromptRef, abortRef, planningMode, setPlanningMode, runLoop, buildContext, pushHistory, setSessionName, renameFromMessage, openPicker, setStatus, setTaskLabel, setCurrentTool, runRefactor, handleGit, lastGitStatusRef, } = depsRef.current;
+        const cmd = text.trim();
+        if (cmd === '?') {
+            printer.systemMsg('shortcuts:\n' +
+                '  enter          send message\n' +
+                '  ctrl+j         insert newline\n' +
+                '  ↑ / ↓          history navigate\n' +
+                '  ctrl+a / ctrl+e  line start / end\n' +
+                '  ctrl+w         delete word back\n' +
+                '  ctrl+k         kill to line end\n' +
+                '  ctrl+u         clear line\n' +
+                '  ctrl+← / →     jump word\n' +
+                '  @filename      inject file into context\n' +
+                '  /cmd           open command palette\n' +
+                '  esc            abort / clear input\n' +
+                '  ctrl+c         abort / exit');
+            return;
+        }
+        if (cmd === '/version') {
+            printer.systemMsg(`miii v${version ?? 'unknown'}`);
+            return;
+        }
+        if (cmd === '/tavily-key' || cmd.startsWith('/tavily-key ')) {
+            const key = cmd.slice(11).trim();
+            if (!key) {
+                const existing = getTavilyKey();
+                printer.systemMsg(existing ? 'Tavily key set (use /tavily-key <key> to update)' : 'No Tavily key set. Usage: /tavily-key tvly-...');
+                return;
+            }
+            if (!key.startsWith('tvly-')) {
+                printer.systemMsg('Key should start with tvly-. Get yours at https://tavily.com');
+                return;
+            }
+            saveTavilyKey(key);
+            printer.systemMsg('Tavily API key saved to ~/.config/miii/tavily.key (mode 600)');
+            return;
+        }
+        if (cmd === '/skills' || cmd.startsWith('/skills ')) {
+            const sub = cmd.slice(7).trim();
+            if (!sub || sub === 'list') {
+                const pkgs = skills.listNpmSkills();
+                printer.systemMsg(pkgs.length ? `installed npm skills:\n${pkgs.map(p => `  ${p}`).join('\n')}` : 'no npm skills installed — try /skills install <name>');
+                return;
+            }
+            if (sub.startsWith('install ')) {
+                const pkg = sub.slice(8).trim();
+                if (!pkg) {
+                    printer.systemMsg('usage: /skills install <name>  (e.g. /skills install git-summary)');
+                    return;
+                }
+                printer.systemMsg(`installing miii-skill-${pkg}…`);
+                try {
+                    printer.systemMsg(await skills.installSkill(pkg));
+                }
+                catch (e) {
+                    printer.errorMsg(String(e));
+                }
+                return;
+            }
+            if (sub.startsWith('uninstall ')) {
+                const pkg = sub.slice(10).trim();
+                if (!pkg) {
+                    printer.systemMsg('usage: /skills uninstall <name>');
+                    return;
+                }
+                try {
+                    printer.systemMsg(await skills.uninstallSkill(pkg));
+                }
+                catch (e) {
+                    printer.errorMsg(String(e));
+                }
+                return;
+            }
+            printer.systemMsg('usage: /skills install <name> | /skills uninstall <name> | /skills list');
+            return;
+        }
+        if (cmd === '/model' || cmd.startsWith('/model ')) {
+            const name = cmd.slice(6).trim();
+            if (!name) {
+                printer.systemMsg(`current model: ${currentModelRef.current}`);
+                return;
+            }
+            setCurrentModel(name);
+            currentModelRef.current = name;
+            printer.systemMsg(`model → ${name}`);
+            return;
+        }
+        if (cmd === '/models') {
+            await openPicker();
+            return;
+        }
+        if (cmd === '/new') {
+            if (saveTimerRef.current) {
+                clearTimeout(saveTimerRef.current);
+                saveTimerRef.current = null;
+            }
+            saveSession(sessionNameRef.current, historyRef.current);
+            const newName = new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-');
+            historyRef.current = [];
+            setSessionName(newName);
+            setPlanningMode(false);
+            systemPromptRef.current = getSystemPrompt(`\n- CWD: ${cwd}`);
+            printer.systemMsg(`new session → ${newName}`);
+            return;
+        }
+        if (cmd === '/clear') {
+            historyRef.current = [];
+            saveSession(sessionNameRef.current, []);
+            setPlanningMode(false);
+            systemPromptRef.current = getSystemPrompt(`\n- CWD: ${cwd}`);
+            printer.systemMsg('chat cleared');
+            return;
+        }
+        if (cmd === '/exit') {
+            process.exit(0);
+        }
+        if (cmd === '/git' || cmd.startsWith('/git ')) {
+            await handleGit(cmd.slice(4).trim());
+            return;
+        }
+        if (cmd.startsWith('/refactor ') || cmd === '/refactor') {
+            const goal = cmd.slice(9).trim();
+            if (!goal) {
+                printer.systemMsg('usage: /refactor <goal>');
+                return;
+            }
+            await runRefactor(goal);
+            return;
+        }
+        if (cmd.startsWith('/think ') || cmd === '/think') {
+            const query = cmd.slice(6).trim();
+            if (!query) {
+                printer.systemMsg('usage: /think <query>');
+                return;
+            }
+            printer.userMsg(`/think ${query}`);
+            setStatus('thinking');
+            setTaskLabel(`gathering: ${query}`);
+            abortRef.current = new AbortController();
+            try {
+                const result = await runDeepThink(query, config, currentModelRef.current, abortRef.current.signal, (toolName) => setCurrentTool(`gather:${toolName}`));
+                setCurrentTool(undefined);
+                printer.systemMsg(`gathered: ${result.toolCalls} tool call(s), ${result.webCalls} web call(s)`);
+                if (result.findings) {
+                    pushHistory({ role: 'user', content: `/think ${query}` });
+                    pushHistory({ role: 'assistant', content: result.findings });
+                    pushHistory({ role: 'user', content: `Based on your research above, give a complete answer to: ${query}` });
+                    await runLoop(buildContext(), 0, query);
+                }
+                else {
+                    printer.systemMsg('nothing gathered — try rephrasing');
+                    setStatus('idle');
+                }
+            }
+            catch (e) {
+                printer.errorMsg(`deep think failed: ${e}`);
+                setStatus('idle');
+            }
+            finally {
+                setCurrentTool(undefined);
+                setTaskLabel(undefined);
+            }
+            return;
+        }
+        if (cmd === '/plan' || cmd.startsWith('/plan ')) {
+            const topic = cmd.slice(5).trim();
+            setPlanningMode(true);
+            systemPromptRef.current = getSystemPrompt(`\n- CWD: ${cwd}\n- MODE: Planning assistant. Help the user plan step by step. Ask clarifying questions. Suggest concrete next steps. Use plain text only — no markdown, no headers, no bold, no bullets with asterisks, no backtick blocks. Use numbered lists and plain indentation for structure.`);
+            const msg = topic ? `I want to plan: ${topic}` : 'I want to start planning. Help me think through my goals step by step.';
+            printer.userMsg(msg);
+            pushHistory({ role: 'user', content: msg });
+            await runLoop(buildContext());
+            return;
+        }
+        if (cmd === '/plan:done') {
+            setPlanningMode(false);
+            systemPromptRef.current = getSystemPrompt(`\n- CWD: ${cwd}`);
+            printer.systemMsg('planning mode off');
+            return;
+        }
+        if (cmd.startsWith('/plan:')) {
+            const subCmd = cmd.slice(6);
+            const subPrompts = {
+                next: 'What are the next concrete steps I should take?',
+                breakdown: 'Can you break this down into specific subtasks?',
+                review: 'Please review and critique our plan so far. What are we missing?',
+            };
+            const msg = subPrompts[subCmd];
+            if (msg) {
+                printer.userMsg(msg);
+                pushHistory({ role: 'user', content: msg });
+                await runLoop(buildContext());
+                return;
+            }
+        }
+        if (cmd === '/sessions') {
+            const sessions = listSessions();
+            if (!sessions.length) {
+                printer.systemMsg('no saved sessions');
+                return;
+            }
+            printer.systemMsg(sessions.map(s => `${s.name === sessionNameRef.current ? '▶ ' : '  '}${s.name}  (${s.messageCount} msgs)`).join('\n'));
+            return;
+        }
+        if (cmd.startsWith('/session')) {
+            const arg = cmd.slice(8).trim();
+            if (!arg) {
+                printer.systemMsg(`current: ${sessionNameRef.current}`);
+                return;
+            }
+            if (arg.startsWith('delete ')) {
+                const target = arg.slice(7).trim();
+                if (!target) {
+                    printer.systemMsg('usage: /session delete <name|all>');
+                    return;
+                }
+                if (target === 'all') {
+                    const count = deleteAllSessions(sessionNameRef.current);
+                    printer.systemMsg(`deleted ${count} session(s) — kept active: ${sessionNameRef.current}`);
+                    return;
+                }
+                if (target === sessionNameRef.current) {
+                    printer.systemMsg('cannot delete active session — switch first');
+                    return;
+                }
+                try {
+                    deleteSession(target);
+                    printer.systemMsg(`deleted: ${target}`);
+                }
+                catch (e) {
+                    printer.errorMsg(`delete failed: ${String(e)}`);
+                }
+                return;
+            }
+            if (saveTimerRef.current) {
+                clearTimeout(saveTimerRef.current);
+                saveTimerRef.current = null;
+            }
+            saveSession(sessionNameRef.current, historyRef.current);
+            historyRef.current = loadSession(arg);
+            setSessionName(arg);
+            printer.systemMsg(`session → ${arg}  (${historyRef.current.length} messages)`);
+            return;
+        }
+        if (cmd === '/index' || cmd.startsWith('/index ')) {
+            const sub = cmd.slice(6).trim();
+            if (!sub || sub === 'status') {
+                const stats = indexStats(cwd);
+                if (!stats) {
+                    printer.systemMsg('no index — run /index build');
+                    return;
+                }
+                const age = Math.round((Date.now() - stats.mtime) / 60000);
+                printer.systemMsg(`index: ${stats.count} chunks, ${stats.sizeKb} KB, built ${age < 2 ? 'just now' : `${age}m ago`}`);
+                return;
+            }
+            if (sub === 'build') {
+                const embedModel = config.embedModel ?? 'nomic-embed-text';
+                printer.systemMsg(`building index with ${embedModel}…`);
+                setStatus('thinking');
+                setTaskLabel('indexing codebase…');
+                try {
+                    const result = await buildIndex(config, cwd, ({ file, done, total }) => {
+                        setTaskLabel(`indexing ${done + 1}/${total}: ${file}`);
+                    });
+                    printer.systemMsg(`index built: ${result.indexed} chunks across ${result.files} files${result.skipped ? `, ${result.skipped} embed errors` : ''}`);
+                }
+                catch (e) {
+                    printer.errorMsg(`index build failed: ${e}`);
+                }
+                finally {
+                    setStatus('idle');
+                    setTaskLabel(undefined);
+                }
+                return;
+            }
+            if (sub === 'clear') {
+                clearIndex(cwd);
+                printer.systemMsg('index cleared');
+                return;
+            }
+            if (sub.startsWith('search ')) {
+                const query = sub.slice(7).trim();
+                if (!query) {
+                    printer.systemMsg('usage: /index search <query>');
+                    return;
+                }
+                const chunks = loadIndex(cwd);
+                if (!chunks.length) {
+                    printer.systemMsg('no index — run /index build');
+                    return;
+                }
+                const embedModel = config.embedModel ?? 'nomic-embed-text';
+                try {
+                    const queryVec = await embed(config.baseUrl, embedModel, query);
+                    const results = topK(chunks, queryVec, 5);
+                    printer.systemMsg(results.map((r, i) => `[${i + 1}] ${r.file} lines ${r.start + 1}–${r.end + 1} (score ${r.score.toFixed(3)})`).join('\n'));
+                }
+                catch (e) {
+                    printer.errorMsg(`search failed: ${e}`);
+                }
+                return;
+            }
+            printer.systemMsg('usage: /index build | /index status | /index search <query> | /index clear');
+            return;
+        }
+        if (text.startsWith('/')) {
+            const [slashCmd, ...rest] = text.slice(1).split(' ');
+            const skill = skills.get(slashCmd);
+            if (skill) {
+                if (skill.name === 'list') {
+                    printer.systemMsg(skills.list().map(s => `/${s.ns === 'default' ? '' : s.ns + ':'}${s.name}  — ${s.description}`).join('\n'));
+                    return;
+                }
+                if (skill.execute) {
+                    const ctx = {
+                        messages: historyRef.current.map(m => ({ role: m.role, content: m.content })),
+                        appendMessage: (_role, content) => printer.systemMsg(content),
+                        setSystemPrompt: (p) => { systemPromptRef.current = p; },
+                        getSystemPrompt: () => systemPromptRef.current,
+                    };
+                    const result = await skill.execute(rest.join(' '), ctx);
+                    if (result)
+                        printer.systemMsg(result);
+                    return;
+                }
+                if (skill.prompt) {
+                    printer.userMsg(skill.prompt);
+                    pushHistory({ role: 'user', content: skill.prompt });
+                    await runLoop(buildContext());
+                    return;
+                }
+            }
+            printer.systemMsg(`unknown command: /${slashCmd}  —  try /list`);
+            return;
+        }
+        renameFromMessage(text);
+        const contextPrefix = buildAtContext(text);
+        const shouldInjectGit = config.gitContext !== false && looksCodeRelated(text);
+        const { prefix: gitPrefix, label: gitLabel } = shouldInjectGit
+            ? await buildGitContext(cwd, lastGitStatusRef)
+            : { prefix: '', label: '' };
+        if (gitLabel)
+            printer.systemMsg(gitLabel);
+        printer.userMsg(text);
+        pushHistory({ role: 'user', content: gitPrefix + contextPrefix + text });
+        await runLoop(buildContext());
+    }, []);
+    return { handleSubmit };
+}

package/dist/tui/printer.js

@@ -132,10 +132,12 @@ export function welcome(provider, model, cwd, version, updateAvailable, linked)
     const pr = [...rightLines, ...Array(Math.max(0, maxLen - rightLines.length)).fill('')];
     const contentRows = pl.map((l, i) => row(l, pr[i]));
     const upgradeCmd = linked ? 'cd <miii-dir> && npm run build' : 'npm install -g miii-cli';
-    const separator = gray('│') + bold(yellow(' ⬆ update available: v' + updateAvailable + ' — run: ' + upgradeCmd)).padEnd(innerW - 1) + gray('│');
-    const updateRow = updateAvailable
-        ? [gray('├' + '─'.repeat(innerW) + '┤'), separator, gray('├' + '─'.repeat(innerW) + '┤')]
-        : [];
+    const updateRow = updateAvailable ? (() => {
+        const updateText = bold(yellow(` ⬆  update available: v${updateAvailable}  —  run: ${upgradeCmd}`));
+        const pad = Math.max(0, innerW - vis(updateText).length);
+        const separator = gray('│') + updateText + ' '.repeat(pad) + gray('│');
+        return [gray('├' + '─'.repeat(innerW) + '┤'), separator, gray('├' + '─'.repeat(innerW) + '┤')];
+    })() : [];
     const lines = [
         top,
         ...contentRows,
@@ -162,10 +164,37 @@ export function assistantMsg(text) {
 }
 const EDIT_TOOLS = new Set(['edit_file', 'patch_file', 'create_file', 'write_file']);
 const DELETE_TOOLS = new Set(['delete_file', 'remove_file']);
+function toolLabel(name, args) {
+    const a = args;
+    const short = (s, n = 55) => s.length > n ? s.slice(0, n) + '…' : s;
+    switch (name) {
+        case 'read_file': return `Reading ${a.path ?? ''}`;
+        case 'list_files': return `Listing ${a.path || '.'}`;
+        case 'create_file': return `Creating ${a.path ?? ''}`;
+        case 'edit_file': return `Writing ${a.path ?? ''}`;
+        case 'patch_file': return `Editing ${a.path ?? ''}`;
+        case 'delete_file': return `Deleting ${a.path ?? ''}`;
+        case 'move_file': return `Moving ${a.from} → ${a.to}`;
+        case 'create_folder': return `Creating folder ${a.path ?? ''}`;
+        case 'run_command': return `Running ${short(a.command ?? '')}`;
+        case 'git_status': return 'Checking git status';
+        case 'git_diff': return 'Reading diff';
+        case 'git_log': return 'Reading commits';
+        case 'git_commit': return `Committing: ${short(a.message ?? '')}`;
+        case 'run_tests': return a.path ? `Running tests › ${a.path}` : 'Running tests';
+        case 'web_search': return `Searching: ${short(a.query ?? '')}`;
+        case 'web_extract': return `Extracting page`;
+        case 'deep_think': return `Researching: ${short(a.query ?? '')}`;
+        case 'search_codebase': return `Searching codebase: ${short(a.query ?? '')}`;
+        default: {
+            const s = toolArgSummary(args);
+            return s ? `${name} ${s}` : name;
+        }
+    }
+}
 export function toolCallStart(name, args) {
-    const summary = toolArgSummary(args);
     const dot = DELETE_TOOLS.has(name) ? red('●') : EDIT_TOOLS.has(name) ? green('●') : blue('●');
-    write(`  ${dot} ${cyan(name)}${summary ? gray('(' + summary + ')') : ''}\n`);
+    write(`  ${dot} ${toolLabel(name, args)}\n`);
 }
 export function toolMsg(name, result) {
     const preview = result.length > 250 ? result.slice(0, 250) + '…' : result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miii-cli",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "type": "module",
   "description": "The high-performance local AI coding agent for your terminal. Automate complex workflows with local LLMs.",
   "license": "MIT",