vigthoria-cli 1.8.19 → 1.9.2

package/dist/utils/config.js

@@ -155,28 +155,27 @@ class Config {
             expiresAt: data.expiresAt || null,
         });
     }
-    // Model selection - Vigthoria Models (internal: qwen3-coder, deepseek via OpenRouter)
+    // Model selection - Vigthoria Models (internal routing IDs only)
     getAvailableModels() {
         const sub = this.store.get('subscription');
         const plan = (sub.plan || '').toLowerCase();
         // ═══════════════════════════════════════════════════════════════
-        // VIGTHORIA LOCAL - Self-hosted models (fast, no API costs)
+        // VIGTHORIA LOCAL - Self-hosted operational models
         // ═══════════════════════════════════════════════════════════════
         const models = [
-            { id: 'agent', name: 'Vigthoria Agent GPU', description: 'Blackwell autonomous agent workflow', tier: 'local', backendModel: 'vigthoria-v3-code-30b' },
-            { id: 'code', name: 'Vigthoria v3 Code 30B', description: 'Native 30B coding model on Blackwell', tier: 'local', backendModel: 'vigthoria-v3-code-30b' },
-            { id: 'code-30b', name: 'Vigthoria v3 Code 30B', description: 'Same flagship model as code', tier: 'local', backendModel: 'vigthoria-v3-code-30b' },
-            { id: 'code-8b', name: 'Vigthoria v2 Code 8B', description: 'Native 8B coding specialist', tier: 'local', backendModel: 'vigthoria-v2-code-8b' },
-            { id: 'balanced', name: 'Vigthoria Balanced 4B', description: 'Balanced general-purpose local model', tier: 'local', backendModel: 'vigthoria-balanced-4b' },
-            { id: 'fast', name: 'Vigthoria Fast 1.7B', description: 'Low-latency local responses', tier: 'local', backendModel: 'vigthoria-fast-1.7b' },
-            { id: 'creative', name: 'Vigthoria Creative 9B V4', description: 'Creative and lyric generation model', tier: 'local', backendModel: 'vigthoria-creative-9b-v4' },
+            { id: 'agent', name: 'Vigthoria Agent GPU', description: 'Blackwell autonomous agent workflow', tier: 'local', backendModel: 'vigthoria-v3-code-35b' },
+            { id: 'code', name: 'Vigthoria v3 Code 35B', description: 'Native 35B coding model on Blackwell', tier: 'local', backendModel: 'vigthoria-v3-code-35b' },
+            { id: 'code-35b', name: 'Vigthoria v3 Code 35B', description: 'Same flagship model as code', tier: 'local', backendModel: 'vigthoria-v3-code-35b' },
+            { id: 'code-9b', name: 'Vigthoria C1 Code 9B', description: 'Efficient coding specialist for quick tasks', tier: 'local', backendModel: 'vigthoria_c1_m' },
+            { id: 'balanced', name: 'Vigthoria Master 7.6B', description: 'Balanced general-purpose local model', tier: 'local', backendModel: 'vigthoria_master' },
+            { id: 'balanced-4b', name: 'Vigthoria v3 Balanced 4B', description: 'Efficient 4B general-purpose model (Qwen3.5-4B based)', tier: 'local', backendModel: 'vigthoria-balanced-4b' },
         ];
         // ═══════════════════════════════════════════════════════════════
         // VIGTHORIA CLOUD - Premium cloud models (Pro subscription)
         // For complex multi-file tasks, large refactoring, architecture
         // ═══════════════════════════════════════════════════════════════
         if (this.hasCloudAccess()) {
-            models.push({ id: 'cloud', name: 'Vigthoria Cloud Pro', description: 'DeepSeek-class cloud model for complex tasks', tier: 'cloud', backendModel: 'vigthoria-cloud-pro' }, { id: 'cloud-reason', name: 'Vigthoria Cloud K2', description: 'Reasoning-focused cloud model', tier: 'cloud', backendModel: 'vigthoria-cloud-k2' }, { id: 'ultra', name: 'Vigthoria Cloud Ultra', description: 'Maximum capability cloud routing', tier: 'cloud', backendModel: 'vigthoria-cloud-ultra' });
+            models.push({ id: 'cloud', name: 'Vigthoria Cloud Pro', description: 'High-capability cloud model for complex tasks', tier: 'cloud', backendModel: 'vigthoria-cloud-pro' }, { id: 'cloud-reason', name: 'Vigthoria Cloud K2', description: 'Reasoning-focused cloud model', tier: 'cloud', backendModel: 'vigthoria-cloud-k2' }, { id: 'ultra', name: 'Vigthoria Cloud Ultra', description: 'Maximum capability cloud routing', tier: 'cloud', backendModel: 'vigthoria-cloud-ultra' });
         }
         return models;
     }

package/dist/utils/context-ranker.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Vigthoria CLI — Semantic Context Ranker
+ *
+ * Lightweight local-first file relevance scoring. Extracts keywords from the
+ * user prompt and scores workspace files by occurrence in filename + content.
+ * Used to prioritise which files are sent to V3 as workspace context.
+ *
+ * No external dependencies — uses only Node.js built-ins.
+ */
+export interface RankedFile {
+    path: string;
+    score: number;
+    snippet: string;
+}
+export interface RankedContext {
+    topFiles: RankedFile[];
+    totalFilesScanned: number;
+    keywords: string[];
+}
+/**
+ * Score and rank workspace files by relevance to the given prompt.
+ * Returns the top N files with path, score, and content snippet.
+ */
+export declare function buildSemanticContext(workspacePath: string, prompt: string, topN?: number): RankedContext;

package/dist/utils/context-ranker.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Vigthoria CLI — Semantic Context Ranker
+ *
+ * Lightweight local-first file relevance scoring. Extracts keywords from the
+ * user prompt and scores workspace files by occurrence in filename + content.
+ * Used to prioritise which files are sent to V3 as workspace context.
+ *
+ * No external dependencies — uses only Node.js built-ins.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSemanticContext = buildSemanticContext;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const IGNORED_DIRS = new Set([
+    '.git', 'node_modules', 'dist', '.next', '__pycache__',
+    '.vigthoria', 'coverage', '.cache', '.turbo', 'build', 'out',
+]);
+const TEXT_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.go', '.rs', '.java', '.c', '.cpp', '.h', '.cs', '.php', '.rb',
+    '.json', '.yaml', '.yml', '.toml', '.env', '.sh', '.bash',
+    '.html', '.css', '.scss', '.sass', '.less',
+    '.md', '.txt', '.xml', '.svg',
+]);
+/** Extract scoring keywords from the user prompt. */
+function extractKeywords(prompt) {
+    // General words (min length 4)
+    const words = prompt
+        .replace(/[^\w\s./\\-]/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length >= 4)
+        .map((w) => w.toLowerCase());
+    // CamelCase splits
+    const camel = (prompt.match(/[a-z][A-Z][a-zA-Z]+|[A-Z]{2,}[a-z]+[a-zA-Z]*/g) || [])
+        .map((w) => w.toLowerCase());
+    // Acronyms: uppercase sequences 2-4 chars (SSE, API, HTTP, etc.)
+    const acronyms = (prompt.match(/\b[A-Z]{2,4}\b/g) || [])
+        .map((w) => w.toLowerCase());
+    return [...new Set([...words, ...camel, ...acronyms])].filter((kw) => kw.length >= 2);
+}
+function scoreFile(filePath, keywords) {
+    if (keywords.length === 0)
+        return 0;
+    const filename = node_path_1.default.basename(filePath).toLowerCase();
+    const parentDir = node_path_1.default.basename(node_path_1.default.dirname(filePath)).toLowerCase();
+    let score = 0;
+    for (const kw of keywords) {
+        // Filename match (high weight)
+        if (filename.includes(kw))
+            score += 15;
+        // Parent directory name match (medium weight)
+        if (parentDir.includes(kw))
+            score += 6;
+    }
+    try {
+        const content = node_fs_1.default.readFileSync(filePath, 'utf-8').slice(0, 300000);
+        const lower = content.toLowerCase();
+        for (const kw of keywords) {
+            const escaped = kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            // Word boundaries for short keywords prevent false-positives (e.g. 'sse' inside 'assert')
+            const pattern = kw.length <= 4 ? '\\b' + escaped + '\\b' : escaped;
+            const hits = (lower.match(new RegExp(pattern, 'g')) || []).length;
+            score += hits;
+        }
+    }
+    catch { /* binary or unreadable */ }
+    return score;
+}
+function walkWorkspace(dir, maxFiles = 800) {
+    const results = [];
+    const stack = [dir];
+    const workspaceRoot = node_path_1.default.resolve(dir);
+    while (stack.length > 0 && results.length < maxFiles) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            // Hard cap enforced inside inner loop (fixes > 800 overshoot)
+            if (results.length >= maxFiles)
+                break;
+            if (IGNORED_DIRS.has(entry.name))
+                continue;
+            const fullPath = node_path_1.default.join(current, entry.name);
+            // Security: skip symlinks that escape workspace root (fixes 8.2)
+            if (entry.isSymbolicLink()) {
+                try {
+                    const real = node_fs_1.default.realpathSync(fullPath);
+                    if (!real.startsWith(workspaceRoot + node_path_1.default.sep) && real !== workspaceRoot)
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+            }
+            else if (entry.isFile() && TEXT_EXTENSIONS.has(node_path_1.default.extname(entry.name).toLowerCase())) {
+                results.push(fullPath);
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Score and rank workspace files by relevance to the given prompt.
+ * Returns the top N files with path, score, and content snippet.
+ */
+function buildSemanticContext(workspacePath, prompt, topN = 12) {
+    if (!workspacePath || !node_fs_1.default.existsSync(workspacePath)) {
+        return { topFiles: [], totalFilesScanned: 0, keywords: [] };
+    }
+    const keywords = extractKeywords(prompt);
+    if (keywords.length === 0) {
+        return { topFiles: [], totalFilesScanned: 0, keywords: [] };
+    }
+    const files = walkWorkspace(workspacePath);
+    const scored = files
+        .map((f) => ({ filePath: f, score: scoreFile(f, keywords) }))
+        .filter((f) => f.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, topN);
+    const topFiles = scored.map(({ filePath, score }) => {
+        let snippet = '';
+        try {
+            snippet = node_fs_1.default.readFileSync(filePath, 'utf-8').slice(0, 600);
+        }
+        catch { /* ignore */ }
+        return {
+            path: node_path_1.default.relative(workspacePath, filePath).replace(/\\/g, '/'),
+            score,
+            snippet,
+        };
+    });
+    return { topFiles, totalFilesScanned: files.length, keywords };
+}

package/dist/utils/post-write-validator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Vigthoria CLI — Post-Write Validator / Self-Healing Layer
+ *
+ * After the V3 agent writes files to the workspace, this module:
+ *   1. Detects available validators (tsc, npm test, py_compile).
+ *   2. Runs them in the project directory.
+ *   3. Returns structured pass/fail results for each tool.
+ *
+ * Used by runSelfHealingCycle in api.ts to send targeted correction prompts.
+ */
+export interface ValidationResult {
+    ran: boolean;
+    tool: string;
+    passed: boolean;
+    output: string;
+}
+/**
+ * Run post-write validation in the project directory.
+ * Each check is time-bounded to avoid blocking the CLI.
+ */
+export declare function runPostWriteValidation(workspacePath: string): Promise<ValidationResult[]>;
+/**
+ * Build a clear error summary string from failed validation results.
+ */
+export declare function formatValidationErrors(results: ValidationResult[]): string;

package/dist/utils/post-write-validator.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Vigthoria CLI — Post-Write Validator / Self-Healing Layer
+ *
+ * After the V3 agent writes files to the workspace, this module:
+ *   1. Detects available validators (tsc, npm test, py_compile).
+ *   2. Runs them in the project directory.
+ *   3. Returns structured pass/fail results for each tool.
+ *
+ * Used by runSelfHealingCycle in api.ts to send targeted correction prompts.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPostWriteValidation = runPostWriteValidation;
+exports.formatValidationErrors = formatValidationErrors;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function commandExists(cmd, args = ['--version']) {
+    try {
+        (0, node_child_process_1.execFileSync)(cmd, args, { stdio: 'pipe', timeout: 4000, windowsHide: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasTsConfig(dir) {
+    return node_fs_1.default.existsSync(node_path_1.default.join(dir, 'tsconfig.json'));
+}
+/**
+ * Resolve the best available tsc binary for the project.
+ * Prefers local node_modules/.bin/tsc over npx to avoid network fetches.
+ */
+function resolveTscBin(workspacePath) {
+    const localTsc = node_path_1.default.join(workspacePath, 'node_modules', '.bin', 'tsc');
+    if (node_fs_1.default.existsSync(localTsc))
+        return { cmd: localTsc, args: ["--noEmit", "--skipLibCheck"] };
+    try {
+        (0, node_child_process_1.execFileSync)("npx", ["--version"], { stdio: "pipe", timeout: 4000, windowsHide: true });
+        return { cmd: "npx", args: ["tsc", "--noEmit", "--skipLibCheck"] };
+    }
+    catch { /* npx not available */ }
+    try {
+        (0, node_child_process_1.execFileSync)("tsc", ["--version"], { stdio: "pipe", timeout: 4000, windowsHide: true });
+        return { cmd: "tsc", args: ["--noEmit", "--skipLibCheck"] };
+    }
+    catch { /* tsc not available */ }
+    return null;
+}
+function hasRealTestScript(dir) {
+    try {
+        const pkgPath = node_path_1.default.join(dir, 'package.json');
+        if (!node_fs_1.default.existsSync(pkgPath))
+            return false;
+        const pkg = JSON.parse(node_fs_1.default.readFileSync(pkgPath, 'utf-8'));
+        const script = pkg.scripts?.test ?? '';
+        return typeof script === 'string' && script.length > 0
+            && !script.startsWith('echo "Error: no test specified"');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Run post-write validation in the project directory.
+ * Each check is time-bounded to avoid blocking the CLI.
+ */
+async function runPostWriteValidation(workspacePath) {
+    if (!workspacePath || !node_fs_1.default.existsSync(workspacePath))
+        return [];
+    const results = [];
+    const opts = { cwd: workspacePath, stdio: 'pipe', windowsHide: true };
+    // 1. TypeScript type check
+    const tscBin = hasTsConfig(workspacePath) ? resolveTscBin(workspacePath) : null;
+    if (tscBin) {
+        try {
+            (0, node_child_process_1.execFileSync)(tscBin.cmd, tscBin.args, { ...opts, timeout: 45_000 });
+            results.push({ ran: true, tool: 'tsc', passed: true, output: '' });
+        }
+        catch (err) {
+            const out = [err.stderr?.toString(), err.stdout?.toString()].filter(Boolean).join('\n').slice(0, 4000);
+            results.push({ ran: true, tool: 'tsc', passed: false, output: out });
+        }
+    }
+    // 2. npm test
+    if (hasRealTestScript(workspacePath) && commandExists('npm')) {
+        try {
+            (0, node_child_process_1.execFileSync)('npm', ['test', '--', '--passWithNoTests'], { ...opts, timeout: 90_000 });
+            results.push({ ran: true, tool: 'npm test', passed: true, output: '' });
+        }
+        catch (err) {
+            const out = [err.stderr?.toString(), err.stdout?.toString()].filter(Boolean).join('\n').slice(0, 4000);
+            results.push({ ran: true, tool: 'npm test', passed: false, output: out });
+        }
+    }
+    // 3. Python syntax check
+    const hasPy = node_fs_1.default.existsSync(node_path_1.default.join(workspacePath, 'requirements.txt'))
+        || node_fs_1.default.existsSync(node_path_1.default.join(workspacePath, 'setup.py'))
+        || node_fs_1.default.existsSync(node_path_1.default.join(workspacePath, 'pyproject.toml'));
+    if (hasPy && commandExists('python3', ['-c', 'import ast'])) {
+        const pyFiles = [];
+        try {
+            const entries = node_fs_1.default.readdirSync(workspacePath, { withFileTypes: true });
+            for (const e of entries) {
+                if (e.isFile() && e.name.endsWith('.py'))
+                    pyFiles.push(e.name);
+            }
+        }
+        catch { /* ignore */ }
+        let pyPassed = true;
+        let pyOut = '';
+        for (const pyFile of pyFiles.slice(0, 20)) {
+            try {
+                (0, node_child_process_1.execFileSync)('python3', ['-m', 'py_compile', pyFile], { ...opts, timeout: 10_000 });
+            }
+            catch (err) {
+                pyPassed = false;
+                pyOut += `${pyFile}: ${err.stderr?.toString()?.trim() || 'syntax error'}\n`;
+            }
+        }
+        if (pyFiles.length > 0) {
+            results.push({ ran: true, tool: 'py_compile', passed: pyPassed, output: pyOut.slice(0, 2000) });
+        }
+    }
+    return results;
+}
+/**
+ * Build a clear error summary string from failed validation results.
+ */
+function formatValidationErrors(results) {
+    return results
+        .filter((r) => r.ran && !r.passed)
+        .map((r) => `[${r.tool}]\n${r.output.trim()}`)
+        .join('\n\n─────────────────────────\n\n');
+}

package/dist/utils/session.d.ts

@@ -3,6 +3,25 @@
  * Similar to Vigthoria's session persistence
  */
 import { ChatMessage } from './api.js';
+export type AuthState = {
+    token: string | null;
+    expiresAt: number | null;
+    isValid: boolean;
+};
+export type CliError = {
+    code: string;
+    message: string;
+    details?: any;
+    isCritical: boolean;
+};
+/**
+ * Validate persisted authentication state without assuming any field is present.
+ */
+export declare function validateSession(session: AuthState): boolean;
+/**
+ * Load persisted authentication state and normalize nullable token fields safely.
+ */
+export declare function loadSession(): Promise<AuthState>;
 export interface Session {
     id: string;
     name: string;

package/dist/utils/session.js

@@ -38,9 +38,96 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionManager = void 0;
+exports.validateSession = validateSession;
+exports.loadSession = loadSession;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+function createSessionLoadError(message, details) {
+    return {
+        code: 'SESSION_LOAD_FAILED',
+        message,
+        details,
+        isCritical: true,
+    };
+}
+function normalizeAuthState(raw) {
+    if (!raw || typeof raw !== 'object') {
+        const session = { token: null, expiresAt: null, isValid: false };
+        session.isValid = validateSession(session);
+        return session;
+    }
+    const source = raw.auth && typeof raw.auth === 'object' ? raw.auth : raw;
+    const rawToken = source.token ?? source.accessToken ?? source.jwt ?? null;
+    const rawExpiresAt = source.expiresAt ?? null;
+    const token = typeof rawToken === 'string' && rawToken.trim().length > 0 ? rawToken.trim() : null;
+    const expiresAt = typeof rawExpiresAt === 'number' && Number.isFinite(rawExpiresAt) ? rawExpiresAt : null;
+    const session = { token, expiresAt, isValid: false };
+    session.isValid = validateSession(session);
+    return session;
+}
+/**
+ * Validate persisted authentication state without assuming any field is present.
+ */
+function validateSession(session) {
+    if (!session || typeof session !== 'object') {
+        console.warn('Invalid session: session state is missing.');
+        return false;
+    }
+    if (typeof session.token !== 'string' || session.token.trim().length === 0) {
+        console.warn('Invalid session: authentication token is missing.');
+        return false;
+    }
+    if (typeof session.expiresAt !== 'number' || !Number.isFinite(session.expiresAt)) {
+        console.warn('Invalid session: expiration timestamp is missing.');
+        return false;
+    }
+    if (session.expiresAt <= Date.now()) {
+        console.warn('Invalid session: authentication token has expired.');
+        return false;
+    }
+    return true;
+}
+/**
+ * Load persisted authentication state and normalize nullable token fields safely.
+ */
+async function loadSession() {
+    const configDir = path.join(os.homedir(), '.vigthoria');
+    const candidateFiles = [
+        path.join(configDir, 'auth.json'),
+        path.join(configDir, 'session.json'),
+        path.join(configDir, 'config.json'),
+    ];
+    try {
+        const sessionFile = candidateFiles.find((filePath) => fs.existsSync(filePath));
+        if (!sessionFile) {
+            const session = { token: null, expiresAt: null, isValid: false };
+            validateSession(session);
+            throw createSessionLoadError('Failed to load persisted authentication session: no session file found.');
+        }
+        const content = fs.readFileSync(sessionFile, 'utf-8');
+        const parsed = JSON.parse(content);
+        const session = normalizeAuthState(parsed);
+        if (session.token === null || session.expiresAt === null || !session.isValid) {
+            throw createSessionLoadError('Failed to load persisted authentication session: token is missing or expired.', {
+                sessionFile,
+                hasToken: session.token !== null,
+                expiresAt: session.expiresAt,
+            });
+        }
+        return session;
+    }
+    catch (error) {
+        if (error?.code === 'SESSION_LOAD_FAILED') {
+            console.error(error.message, error.details ?? '');
+            throw error;
+        }
+        console.error('Failed to load persisted authentication session.', error?.message ?? error);
+        throw createSessionLoadError('Failed to load persisted authentication session.', {
+            message: error?.message ?? String(error),
+        });
+    }
+}
 class SessionManager {
     sessionsDir;
     compactThreshold = 40;
@@ -56,15 +143,12 @@ class SessionManager {
             }
         }
         catch (error) {
-            // On permission errors, try alternative location
             if (error.code === 'EACCES' || error.code === 'EPERM') {
-                // Fallback to temp directory
                 this.sessionsDir = path.join(os.tmpdir(), 'vigthoria-sessions');
                 if (!fs.existsSync(this.sessionsDir)) {
                     fs.mkdirSync(this.sessionsDir, { recursive: true });
                 }
             }
-            // Silently continue if directory creation fails
         }
     }
     /**
@@ -117,7 +201,8 @@ class SessionManager {
             const content = fs.readFileSync(filePath, 'utf-8');
             return JSON.parse(content);
         }
-        catch {
+        catch (error) {
+            console.warn(`Failed to load session ${id}:`, error);
             return null;
         }
     }
@@ -141,11 +226,11 @@ class SessionManager {
             try {
                 const content = fs.readFileSync(path.join(this.sessionsDir, f), 'utf-8');
                 const session = JSON.parse(content);
-                // Return without messages for efficiency
                 const { messages, ...metadata } = session;
                 return { ...metadata, messages: [] };
             }
-            catch {
+            catch (error) {
+                console.warn(`Failed to read session metadata from ${f}:`, error);
                 return null;
             }
         }).filter(Boolean);

package/dist/utils/task-display.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Vigthoria CLI — Multi-Step Terminal Task Display
+ *
+ * Renders a live, updating task progress list in the terminal using ANSI
+ * escape codes and chalk — no external UI framework required.
+ *
+ * Only activates when stderr is a real TTY; JSON mode and piped output stay clean.
+ */
+export type TaskStatus = 'pending' | 'running' | 'done' | 'error' | 'skipped';
+export interface Task {
+    label: string;
+    status: TaskStatus;
+    detail?: string;
+}
+export declare class TaskDisplay {
+    private tasks;
+    private linesRendered;
+    private readonly enabled;
+    constructor(labels: string[], enabled?: boolean);
+    private clearLines;
+    private renderLines;
+    render(): void;
+    start(index: number, detail?: string): void;
+    complete(index: number, detail?: string): void;
+    fail(index: number, detail?: string): void;
+    skip(index: number, detail?: string): void;
+    setDetail(index: number, detail: string): void;
+    clear(): void;
+    finalize(): void;
+    get isEnabled(): boolean;
+}