atcoder-workspace 1.1.0-beta.1

package/dist/session/auth.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginWithCookie = loginWithCookie;
+exports.whoami = whoami;
+const cheerio = __importStar(require("cheerio"));
+const store_1 = require("./store");
+const client_1 = require("../atcoder/client");
+const errors_1 = require("../utils/errors");
+/**
+ * Saves a manually entered REVEL_SESSION cookie and verifies the session.
+ */
+async function loginWithCookie(workspaceRoot, revelSession) {
+    let cleanSession = revelSession.trim();
+    if (!cleanSession) {
+        throw new errors_1.AuthError('REVEL_SESSION cookie value cannot be empty.');
+    }
+    if (cleanSession.startsWith('REVEL_SESSION=')) {
+        cleanSession = cleanSession.substring('REVEL_SESSION='.length);
+    }
+    cleanSession = cleanSession.split(';')[0].trim();
+    if (!cleanSession) {
+        throw new errors_1.AuthError('Could not extract a valid REVEL_SESSION value.');
+    }
+    const savedCookies = [
+        {
+            name: 'REVEL_SESSION',
+            value: cleanSession,
+            domain: '.atcoder.jp',
+            path: '/',
+            expires: Math.floor(Date.now() / 1000) + 86400 * 30,
+            httpOnly: true,
+            secure: true,
+            sameSite: 'Lax'
+        }
+    ];
+    (0, store_1.saveSession)(workspaceRoot, savedCookies);
+    try {
+        const username = await whoami(workspaceRoot);
+        return username;
+    }
+    catch (err) {
+        try {
+            const { clearSession } = require('./store');
+            clearSession(workspaceRoot);
+        }
+        catch (e) { }
+        throw new errors_1.AuthError(`The provided REVEL_SESSION cookie is invalid or expired: ${err.message}`);
+    }
+}
+/**
+ * Checks the login status by requesting the AtCoder settings page with saved session cookies.
+ */
+async function whoami(workspaceRoot) {
+    const session = (0, store_1.loadSession)(workspaceRoot);
+    if (!session || !session.some(c => c.name === 'REVEL_SESSION')) {
+        throw new errors_1.AuthError('No active session. Please log in using "atc login".');
+    }
+    const client = (0, client_1.createAtCoderClient)(workspaceRoot);
+    try {
+        const res = await client.get('/settings');
+        const $ = cheerio.load(res.data);
+        const userLink = $('header a[href^="/users/"], .navbar-right a[href^="/users/"]').first();
+        const href = userLink.attr('href');
+        if (href) {
+            const match = href.match(/\/users\/([a-zA-Z0-9_]+)/);
+            if (match && match[1]) {
+                return match[1];
+            }
+        }
+        const usernameSpan = $('header a.username, header .dropdown-toggle').first();
+        if (usernameSpan.length) {
+            const name = usernameSpan.text().replace(/\s+/g, ' ').trim();
+            if (name && name !== 'Sign In' && name !== 'ログイン' && name !== 'Sign Up' && name !== '新規登録') {
+                return name;
+            }
+        }
+        throw new errors_1.AuthError('Session is invalid or expired.');
+    }
+    catch (err) {
+        if (err instanceof errors_1.AuthError)
+            throw err;
+        throw new errors_1.AuthError(`Failed to verify session: ${err.message}`);
+    }
+}

package/dist/session/store.d.ts

@@ -0,0 +1,15 @@
+export interface SavedCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    expires: number;
+    httpOnly: boolean;
+    secure: boolean;
+    sameSite: 'Strict' | 'Lax' | 'None';
+}
+export declare function getSessionPath(workspaceRoot: string): string;
+export declare function saveSession(workspaceRoot: string, cookies: SavedCookie[]): void;
+export declare function loadSession(workspaceRoot: string): SavedCookie[] | null;
+export declare function clearSession(workspaceRoot: string): void;
+export declare function getCookieHeaderString(cookies: SavedCookie[]): string;

package/dist/session/store.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionPath = getSessionPath;
+exports.saveSession = saveSession;
+exports.loadSession = loadSession;
+exports.clearSession = clearSession;
+exports.getCookieHeaderString = getCookieHeaderString;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function getSessionPath(workspaceRoot) {
+    return path.join(workspaceRoot, '.atcoder-cli', 'session.json');
+}
+function saveSession(workspaceRoot, cookies) {
+    const sessionPath = getSessionPath(workspaceRoot);
+    const dir = path.dirname(sessionPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(sessionPath, JSON.stringify(cookies, null, 2), 'utf8');
+}
+function loadSession(workspaceRoot) {
+    const sessionPath = getSessionPath(workspaceRoot);
+    if (!fs.existsSync(sessionPath)) {
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(sessionPath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        return null;
+    }
+}
+function clearSession(workspaceRoot) {
+    const sessionPath = getSessionPath(workspaceRoot);
+    if (fs.existsSync(sessionPath)) {
+        fs.unlinkSync(sessionPath);
+    }
+}
+function getCookieHeaderString(cookies) {
+    return cookies.map(c => `${c.name}=${c.value}`).join('; ');
+}

package/dist/test-runner/diff.d.ts

@@ -0,0 +1,7 @@
+export interface CompareResult {
+    isMatch: boolean;
+    actualNormalized: string;
+    expectedNormalized: string;
+    firstDiffLine?: number;
+}
+export declare function compareOutput(actual: string, expected: string): CompareResult;

package/dist/test-runner/diff.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareOutput = compareOutput;
+function compareOutput(actual, expected) {
+    const actualLines = normalizeAndSplit(actual);
+    const expectedLines = normalizeAndSplit(expected);
+    let isMatch = true;
+    let firstDiffLine;
+    const maxLines = Math.max(actualLines.length, expectedLines.length);
+    for (let i = 0; i < maxLines; i++) {
+        if (actualLines[i] !== expectedLines[i]) {
+            isMatch = false;
+            firstDiffLine = i + 1;
+            break;
+        }
+    }
+    return {
+        isMatch,
+        actualNormalized: actualLines.join('\n'),
+        expectedNormalized: expectedLines.join('\n'),
+        firstDiffLine
+    };
+}
+function normalizeAndSplit(str) {
+    const lines = str.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+    const trimmed = lines.map(line => line.trimEnd());
+    // Remove trailing empty lines
+    while (trimmed.length > 0 && trimmed[trimmed.length - 1] === '') {
+        trimmed.pop();
+    }
+    return trimmed;
+}

package/dist/test-runner/runner.d.ts

@@ -0,0 +1,46 @@
+import { Config, LanguageConfig } from '../config/config-store';
+export interface TestCaseResult {
+    index: number;
+    status: 'AC' | 'WA' | 'TLE' | 'RE';
+    durationMs: number;
+    actualOutput: string;
+    expectedOutput: string;
+    errorOutput?: string;
+    firstDiffLine?: number;
+}
+export interface RunAllTestsResult {
+    success: boolean;
+    compileError?: string;
+    results: TestCaseResult[];
+}
+/**
+ * Resolves the absolute path to a task directory.
+ */
+export declare function resolveTaskDirectory(workspaceRoot: string, taskArg?: string): string;
+/**
+ * Detects the code file to execute in the task directory.
+ */
+export declare function detectCodeFile(workspaceRoot: string, taskDir: string, config: Config, fileArg?: string): {
+    codeFile: string;
+    langKey: string;
+    langConfig: LanguageConfig;
+};
+/**
+ * Resolves the build and run commands by substituting template filenames with the actual filename.
+ */
+export declare function resolveCommands(workspaceRoot: string, langConfig: LanguageConfig, actualFile: string, extension: string): {
+    build: string;
+    run: string;
+};
+/**
+ * Runs the build command if present.
+ */
+export declare function runBuild(buildCommand: string, taskDir: string): Promise<{
+    code: number;
+    stderr: string;
+}>;
+/**
+ * Runs a single test case.
+ */
+export declare function runTestCase(runCommand: string, taskDir: string, inputPath: string, outputPath: string, timeLimitMs: number, index: number): Promise<TestCaseResult>;
+export declare function runAllTests(workspaceRoot: string, taskDir: string, fileArg?: string, timeLimitMs?: number): Promise<RunAllTestsResult>;

package/dist/test-runner/runner.js

@@ -0,0 +1,274 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTaskDirectory = resolveTaskDirectory;
+exports.detectCodeFile = detectCodeFile;
+exports.resolveCommands = resolveCommands;
+exports.runBuild = runBuild;
+exports.runTestCase = runTestCase;
+exports.runAllTests = runAllTests;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const config_store_1 = require("../config/config-store");
+const diff_1 = require("./diff");
+const errors_1 = require("../utils/errors");
+/**
+ * Resolves the absolute path to a task directory.
+ */
+function resolveTaskDirectory(workspaceRoot, taskArg) {
+    const cwd = process.cwd();
+    if (taskArg) {
+        const pathFromCwd = path.resolve(cwd, taskArg);
+        if (fs.existsSync(pathFromCwd) && fs.statSync(pathFromCwd).isDirectory()) {
+            return pathFromCwd;
+        }
+        const pathFromRoot = path.resolve(workspaceRoot, taskArg);
+        if (fs.existsSync(pathFromRoot) && fs.statSync(pathFromRoot).isDirectory()) {
+            return pathFromRoot;
+        }
+        const config = (0, config_store_1.loadConfig)(workspaceRoot);
+        if (config.contestDir) {
+            const pathFromConfigDir = path.resolve(workspaceRoot, config.contestDir, taskArg);
+            if (fs.existsSync(pathFromConfigDir) && fs.statSync(pathFromConfigDir).isDirectory()) {
+                return pathFromConfigDir;
+            }
+        }
+        const labelPath = path.join(cwd, taskArg);
+        if (fs.existsSync(labelPath) && fs.statSync(labelPath).isDirectory()) {
+            return labelPath;
+        }
+        throw new errors_1.AtcError(`Task directory "${taskArg}" not found.`);
+    }
+    if (path.resolve(cwd) === path.resolve(workspaceRoot)) {
+        throw new errors_1.AtcError('You are in the workspace root. Please specify a task directory (e.g., "atc test abc300/a").');
+    }
+    return cwd;
+}
+/**
+ * Detects the code file to execute in the task directory.
+ */
+function detectCodeFile(workspaceRoot, taskDir, config, fileArg) {
+    if (fileArg) {
+        const fullPath = path.resolve(taskDir, fileArg);
+        if (!fs.existsSync(fullPath)) {
+            throw new errors_1.AtcError(`Specified source file "${fileArg}" not found in "${taskDir}"`);
+        }
+        const ext = path.extname(fileArg).slice(1);
+        for (const [key, langConfig] of Object.entries(config.languages)) {
+            if (langConfig.extension === ext) {
+                return { codeFile: fileArg, langKey: key, langConfig };
+            }
+        }
+        throw new errors_1.AtcError(`No language configuration found for file extension ".${ext}"`);
+    }
+    const files = fs.readdirSync(taskDir);
+    const defLang = config.languages[config.defaultLanguage];
+    if (defLang) {
+        const matchedFile = files.find(f => f.endsWith(`.${defLang.extension}`) && fs.statSync(path.join(taskDir, f)).isFile());
+        if (matchedFile) {
+            return { codeFile: matchedFile, langKey: config.defaultLanguage, langConfig: defLang };
+        }
+    }
+    for (const [key, langConfig] of Object.entries(config.languages)) {
+        if (key === config.defaultLanguage)
+            continue;
+        const matchedFile = files.find(f => f.endsWith(`.${langConfig.extension}`) && fs.statSync(path.join(taskDir, f)).isFile());
+        if (matchedFile) {
+            return { codeFile: matchedFile, langKey: key, langConfig };
+        }
+    }
+    throw new errors_1.AtcError(`No source files found in "${taskDir}" matching configured languages.`);
+}
+/**
+ * Resolves the build and run commands by substituting template filenames with the actual filename.
+ */
+function resolveCommands(workspaceRoot, langConfig, actualFile, extension) {
+    const templateDir = langConfig.templateDir;
+    let templateFileName = `main.${extension}`;
+    const fullTemplatePath = path.join(workspaceRoot, '.atcoder-cli', templateDir);
+    if (fs.existsSync(fullTemplatePath) && fs.statSync(fullTemplatePath).isDirectory()) {
+        const files = fs.readdirSync(fullTemplatePath);
+        const matched = files.find(f => f.endsWith(`.${extension}`));
+        if (matched) {
+            templateFileName = matched;
+        }
+    }
+    const escapedTemplateName = templateFileName.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+    const regex = new RegExp(escapedTemplateName, 'g');
+    const resolvedBuild = langConfig.build.replace(regex, actualFile);
+    const resolvedRun = langConfig.run.replace(regex, actualFile);
+    return {
+        build: resolvedBuild,
+        run: resolvedRun
+    };
+}
+/**
+ * Runs the build command if present.
+ */
+function runBuild(buildCommand, taskDir) {
+    return new Promise((resolve) => {
+        (0, child_process_1.exec)(buildCommand, { cwd: taskDir }, (err, stdout, stderr) => {
+            resolve({
+                code: err ? (err.code ?? 1) : 0,
+                stderr: stderr || stdout
+            });
+        });
+    });
+}
+/**
+ * Runs a single test case.
+ */
+function runTestCase(runCommand, taskDir, inputPath, outputPath, timeLimitMs, index) {
+    return new Promise((resolve) => {
+        const input = fs.readFileSync(inputPath, 'utf8');
+        const expected = fs.readFileSync(outputPath, 'utf8');
+        const startTime = process.hrtime.bigint();
+        const child = (0, child_process_1.spawn)(runCommand, {
+            cwd: taskDir,
+            shell: true
+        });
+        let stdout = '';
+        let stderr = '';
+        let killedByTimeout = false;
+        const timer = setTimeout(() => {
+            killedByTimeout = true;
+            child.kill('SIGKILL');
+        }, timeLimitMs);
+        child.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            const endTime = process.hrtime.bigint();
+            const durationMs = Number(endTime - startTime) / 1e6;
+            resolve({
+                index,
+                status: 'RE',
+                durationMs,
+                actualOutput: stdout,
+                expectedOutput: expected,
+                errorOutput: err.message
+            });
+        });
+        child.on('exit', (code, signal) => {
+            clearTimeout(timer);
+            const endTime = process.hrtime.bigint();
+            const durationMs = Number(endTime - startTime) / 1e6;
+            if (killedByTimeout || signal === 'SIGKILL') {
+                resolve({
+                    index,
+                    status: 'TLE',
+                    durationMs,
+                    actualOutput: stdout,
+                    expectedOutput: expected,
+                    errorOutput: 'Time Limit Exceeded'
+                });
+                return;
+            }
+            if (code !== 0) {
+                resolve({
+                    index,
+                    status: 'RE',
+                    durationMs,
+                    actualOutput: stdout,
+                    expectedOutput: expected,
+                    errorOutput: stderr || `Exit code ${code}`
+                });
+                return;
+            }
+            const comp = (0, diff_1.compareOutput)(stdout, expected);
+            resolve({
+                index,
+                status: comp.isMatch ? 'AC' : 'WA',
+                durationMs,
+                actualOutput: stdout,
+                expectedOutput: expected,
+                firstDiffLine: comp.firstDiffLine
+            });
+        });
+        child.stdin.write(input);
+        child.stdin.end();
+    });
+}
+async function runAllTests(workspaceRoot, taskDir, fileArg, timeLimitMs = 2000) {
+    const config = (0, config_store_1.loadConfig)(workspaceRoot);
+    const { codeFile, langConfig } = detectCodeFile(workspaceRoot, taskDir, config, fileArg);
+    const { build, run } = resolveCommands(workspaceRoot, langConfig, codeFile, langConfig.extension);
+    if (build.trim() !== '') {
+        const buildRes = await runBuild(build, taskDir);
+        if (buildRes.code !== 0) {
+            return {
+                success: false,
+                compileError: buildRes.stderr,
+                results: []
+            };
+        }
+    }
+    const testDirName = config.testDirName || 'tests';
+    const testDir = path.join(taskDir, testDirName);
+    if (!fs.existsSync(testDir) || !fs.statSync(testDir).isDirectory()) {
+        throw new errors_1.AtcError(`Test directory "${testDir}" not found.`);
+    }
+    const files = fs.readdirSync(testDir);
+    const inFiles = files.filter(f => f.startsWith('sample-') && f.endsWith('.in'));
+    const results = [];
+    inFiles.sort((a, b) => {
+        const aIdx = parseInt(a.match(/sample-(\d+)\.in/)[1], 10);
+        const bIdx = parseInt(b.match(/sample-(\d+)\.in/)[1], 10);
+        return aIdx - bIdx;
+    });
+    for (const inFile of inFiles) {
+        const match = inFile.match(/sample-(\d+)\.in/);
+        if (!match)
+            continue;
+        const index = parseInt(match[1], 10);
+        const inputPath = path.join(testDir, inFile);
+        const outputPath = path.join(testDir, `sample-${index}.out`);
+        if (!fs.existsSync(outputPath)) {
+            continue;
+        }
+        const testRes = await runTestCase(run, taskDir, inputPath, outputPath, timeLimitMs, index);
+        results.push(testRes);
+    }
+    const success = results.length > 0 && results.every(r => r.status === 'AC');
+    return {
+        success,
+        results
+    };
+}

package/dist/utils/errors.d.ts

@@ -0,0 +1,15 @@
+export declare class AtcError extends Error {
+    constructor(message: string);
+}
+export declare class WorkspaceNotFoundError extends AtcError {
+    constructor();
+}
+export declare class AuthError extends AtcError {
+    constructor(message: string);
+}
+export declare class ParseError extends AtcError {
+    constructor(message: string);
+}
+export declare class TestError extends AtcError {
+    constructor(message: string);
+}

package/dist/utils/errors.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestError = exports.ParseError = exports.AuthError = exports.WorkspaceNotFoundError = exports.AtcError = void 0;
+class AtcError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.AtcError = AtcError;
+class WorkspaceNotFoundError extends AtcError {
+    constructor() {
+        super('.atcoder-cli/ directory was not found. Please run "atc init" in your workspace root first.');
+    }
+}
+exports.WorkspaceNotFoundError = WorkspaceNotFoundError;
+class AuthError extends AtcError {
+    constructor(message) {
+        super(`Authentication failed: ${message}`);
+    }
+}
+exports.AuthError = AuthError;
+class ParseError extends AtcError {
+    constructor(message) {
+        super(`Parsing failed: ${message}`);
+    }
+}
+exports.ParseError = ParseError;
+class TestError extends AtcError {
+    constructor(message) {
+        super(`Test execution failed: ${message}`);
+    }
+}
+exports.TestError = TestError;

package/dist/utils/format.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Formats multi-line output with line numbers, a left border,
+ * a mismatch pointer, and smart truncation for large outputs.
+ */
+export declare function formatOutputLines(output: string, firstDiffLine?: number): string[];
+/**
+ * Formats error output with red text, a left border, and clean indents.
+ */
+export declare function formatErrorOutputLines(errorOutput: string): string[];