atcoder-workspace 1.1.0-beta.1

package/dist/cli.js

@@ -0,0 +1,508 @@
+#!/usr/bin/env node
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const p = __importStar(require("@clack/prompts"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const finder_1 = require("./workspace/finder");
+const initializer_1 = require("./workspace/initializer");
+const auth_1 = require("./session/auth");
+const store_1 = require("./session/store");
+const new_1 = require("./atcoder/new");
+const config_store_1 = require("./config/config-store");
+const runner_1 = require("./test-runner/runner");
+const submit_1 = require("./atcoder/submit");
+const client_1 = require("./atcoder/client");
+const submission_status_1 = require("./atcoder/parser/submission-status");
+const problem_page_1 = require("./atcoder/parser/problem-page");
+const errors_1 = require("./utils/errors");
+const format_1 = require("./utils/format");
+const i18n_1 = require("./utils/i18n");
+const open_1 = require("./utils/open");
+const workspaceRoot = (() => {
+    try {
+        return (0, finder_1.findWorkspaceRoot)();
+    }
+    catch {
+        return undefined;
+    }
+})();
+const lang = (0, i18n_1.getLanguage)(workspaceRoot);
+const program = new commander_1.Command();
+program
+    .name('atc')
+    .description('AtCoder All-in-One CLI (Local-first)')
+    .version('1.1.0-betas');
+function handleAction(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        catch (err) {
+            let errMsg = err.message || 'An unexpected error occurred.';
+            if (err instanceof errors_1.WorkspaceNotFoundError) {
+                errMsg = (0, i18n_1.t)('workspaceNotFound', lang);
+            }
+            p.log.error(picocolors_1.default.red(errMsg));
+            process.exit(1);
+        }
+    };
+}
+program
+    .command('init')
+    .description((0, i18n_1.t)('descInit', lang))
+    .action(handleAction(async () => {
+    p.intro(picocolors_1.default.cyan((0, i18n_1.t)('initIntro', lang)));
+    const defaultLanguage = await p.select({
+        message: (0, i18n_1.t)('initSelectLang', lang),
+        options: [
+            { value: 'cpp', label: 'C++ (cpp)' },
+            { value: 'python', label: 'Python (python)' }
+        ]
+    });
+    if (p.isCancel(defaultLanguage)) {
+        p.cancel((0, i18n_1.t)('initCancelled', lang));
+        process.exit(0);
+    }
+    const targetDir = process.cwd();
+    const s = p.spinner();
+    s.start((0, i18n_1.t)('initSpinner', lang));
+    const { alreadyInitialized, gitignoreUpdated } = (0, initializer_1.initWorkspace)(targetDir, defaultLanguage);
+    s.stop((0, i18n_1.t)('initFilesSet', lang));
+    if (alreadyInitialized) {
+        p.log.warn((0, i18n_1.t)('initAlreadyInitialized', lang));
+    }
+    else {
+        p.log.success((0, i18n_1.t)('initCreatedConfig', lang, defaultLanguage));
+    }
+    if (gitignoreUpdated) {
+        p.log.success((0, i18n_1.t)('initGitignoreUpdated', lang));
+    }
+    p.outro(picocolors_1.default.green((0, i18n_1.t)('initOutro', lang)));
+}));
+program
+    .command('login')
+    .description((0, i18n_1.t)('descLogin', lang))
+    .action(handleAction(async () => {
+    p.intro(picocolors_1.default.cyan((0, i18n_1.t)('loginIntro', lang)));
+    const workspaceRoot = (0, finder_1.findWorkspaceRoot)();
+    p.note((0, i18n_1.t)('loginNote', lang));
+    const username = await promptManualCookie(workspaceRoot);
+    p.outro(picocolors_1.default.green((0, i18n_1.t)('loginWelcome', lang, username)));
+}));
+async function promptManualCookie(workspaceRoot) {
+    while (true) {
+        const sessionVal = await p.text({
+            message: (0, i18n_1.t)('loginEnterCookie', lang),
+            placeholder: (0, i18n_1.t)('loginPlaceholder', lang),
+            validate: (val) => (!val.trim() ? (0, i18n_1.t)('loginCookieNotEmpty', lang) : undefined)
+        });
+        if (p.isCancel(sessionVal)) {
+            p.cancel((0, i18n_1.t)('loginCancelled', lang));
+            process.exit(0);
+        }
+        const s = p.spinner();
+        s.start((0, i18n_1.t)('loginVerifying', lang));
+        try {
+            const username = await (0, auth_1.loginWithCookie)(workspaceRoot, sessionVal);
+            s.stop((0, i18n_1.t)('loginVerifySuccess', lang));
+            return username;
+        }
+        catch (err) {
+            s.stop((0, i18n_1.t)('loginVerifyFailed', lang));
+            p.log.error(picocolors_1.default.red(err.message));
+            const retry = await p.confirm({
+                message: (0, i18n_1.t)('loginRetryConfirm', lang),
+                initialValue: true
+            });
+            if (p.isCancel(retry) || !retry) {
+                p.cancel((0, i18n_1.t)('loginAborted', lang));
+                process.exit(1);
+            }
+        }
+    }
+}
+program
+    .command('logout')
+    .description((0, i18n_1.t)('descLogout', lang))
+    .action(handleAction(async () => {
+    const workspaceRoot = (0, finder_1.findWorkspaceRoot)();
+    (0, store_1.clearSession)(workspaceRoot);
+    p.log.success((0, i18n_1.t)('logoutSuccess', lang));
+}));
+program
+    .command('whoami')
+    .description((0, i18n_1.t)('descWhoami', lang))
+    .action(handleAction(async () => {
+    const workspaceRoot = (0, finder_1.findWorkspaceRoot)();
+    const s = p.spinner();
+    s.start('Verifying session...');
+    const username = await (0, auth_1.whoami)(workspaceRoot);
+    s.stop(`Logged in as: ${picocolors_1.default.bold(picocolors_1.default.cyan(username))}`);
+}));
+program
+    .command('new <contest> [task]')
+    .description((0, i18n_1.t)('descNew', lang))
+    .option('-a, --all', 'Download all tasks for the contest')
+    .action(handleAction(async (contestId, taskLabel, options) => {
+    const workspaceRoot = (0, finder_1.findWorkspaceRoot)();
+    const config = (0, config_store_1.loadConfig)(workspaceRoot);
+    const contestParentDir = config.contestDir ? path.join(workspaceRoot, config.contestDir) : workspaceRoot;
+    const contestDir = path.join(contestParentDir, contestId);
+    if (fs.existsSync(contestDir)) {
+        throw new errors_1.AtcError((0, i18n_1.t)('newContestDirExists', lang, contestId));
+    }
+    p.intro(picocolors_1.default.cyan((0, i18n_1.t)('newIntro', lang, contestId)));
+    const s = p.spinner();
+    s.start((0, i18n_1.t)('newFetchingTasks', lang, contestId));
+    const tasks = await (0, new_1.fetchContestTasks)(workspaceRoot, contestId);
+    s.stop((0, i18n_1.t)('newFoundTasks', lang, tasks.length));
+    if (tasks.length === 0) {
+        throw new errors_1.AtcError((0, i18n_1.t)('newNoTasksFound', lang, contestId));
+    }
+    let selectedTasks = tasks;
+    if (options.all) {
+        selectedTasks = tasks;
+    }
+    else if (taskLabel) {
+        const matched = tasks.find(t => t.label.toLowerCase() === taskLabel.toLowerCase());
+        if (!matched) {
+            throw new errors_1.AtcError((0, i18n_1.t)('newLabelNotFound', lang, taskLabel, contestId, tasks.map(t => t.label).join(', ')));
+        }
+        selectedTasks = [matched];
+    }
+    else {
+        const taskOptions = tasks.map(t => ({
+            value: t.id,
+            label: `${t.label.toUpperCase()} - ${t.id}`
+        }));
+        const selection = await p.multiselect({
+            message: (0, i18n_1.t)('newMultiselectMessage', lang),
+            options: taskOptions,
+            initialValues: tasks.map(t => t.id),
+            required: true
+        });
+        if (p.isCancel(selection)) {
+            p.cancel((0, i18n_1.t)('newCancelled', lang));
+            process.exit(0);
+        }
+        selectedTasks = tasks.filter(t => selection.includes(t.id));
+    }
+    const setupSpinner = p.spinner();
+    for (let i = 0; i < selectedTasks.length; i++) {
+        const tObj = selectedTasks[i];
+        if (i > 0) {
+            await new Promise(resolve => setTimeout(resolve, 300));
+        }
+        setupSpinner.start((0, i18n_1.t)('newSettingUpTask', lang, tObj.label.toUpperCase(), tObj.id));
+        const res = await (0, new_1.setupTask)(workspaceRoot, contestId, tObj);
+        setupSpinner.stop((0, i18n_1.t)('newSetupSuccess', lang, tObj.label.toUpperCase(), res.sampleCount));
+    }
+    p.outro(picocolors_1.default.green((0, i18n_1.t)('newScaffoldingComplete', lang, selectedTasks.length)));
+}));
+function resolveArgs(workspaceRoot, taskArg, fileArg) {
+    let resolvedTaskDir = '';
+    let resolvedFile;
+    let isFile = false;
+    let filePath = '';
+    if (taskArg) {
+        const pathsToCheck = [
+            path.resolve(taskArg),
+            path.resolve(workspaceRoot, taskArg)
+        ];
+        const config = (0, config_store_1.loadConfig)(workspaceRoot);
+        if (config.contestDir) {
+            pathsToCheck.push(path.resolve(workspaceRoot, config.contestDir, taskArg));
+        }
+        for (const p of pathsToCheck) {
+            if (fs.existsSync(p) && fs.statSync(p).isFile()) {
+                isFile = true;
+                filePath = p;
+                break;
+            }
+        }
+    }
+    if (isFile) {
+        resolvedFile = path.basename(filePath);
+        resolvedTaskDir = path.dirname(filePath);
+    }
+    else {
+        resolvedTaskDir = (0, runner_1.resolveTaskDirectory)(workspaceRoot, taskArg);
+        resolvedFile = fileArg;
+    }
+    const taskLabel = path.basename(resolvedTaskDir);
+    const contestId = path.basename(path.dirname(resolvedTaskDir));
+    return { resolvedTaskDir, resolvedFile, taskLabel, contestId };
+}
+program
+    .command('test [task] [file]')
+    .description((0, i18n_1.t)('descTest', lang))
+    .action(handleAction(async (taskArg, fileArg) => {
+    const workspaceRoot = (0, finder_1.findWorkspaceRoot)();
+    const { resolvedTaskDir, resolvedFile, taskLabel, contestId } = resolveArgs(workspaceRoot, taskArg, fileArg);
+    p.intro(picocolors_1.default.cyan((0, i18n_1.t)('testIntro', lang, contestId, taskLabel)));
+    const s = p.spinner();
+    s.start((0, i18n_1.t)('testRetrievingLimits', lang));
+    let timeLimitMs = 2000;
+    try {
+        const client = (0, client_1.createAtCoderClient)(workspaceRoot);
+        const tasks = await (0, new_1.fetchContestTasks)(workspaceRoot, contestId);
+        const taskInfo = tasks.find(t => t.label.toLowerCase() === taskLabel.toLowerCase());
+        if (taskInfo) {
+            const res = await client.get(`/contests/${contestId}/tasks/${taskInfo.id}`);
+            const details = (0, problem_page_1.parseProblemPage)(res.data);
+            timeLimitMs = details.timeLimitMs;
+            s.stop((0, i18n_1.t)('testLoadedLimits', lang, timeLimitMs));
+        }
+        else {
+            s.stop((0, i18n_1.t)('testDefaultLimits', lang));
+        }
+    }
+    catch (err) {
+        s.stop((0, i18n_1.t)('testDefaultLimitsError', lang));
+    }
+    const testSpinner = p.spinner();
+    testSpinner.start((0, i18n_1.t)('testCompilingRunning', lang));
+    const testRes = await (0, runner_1.runAllTests)(workspaceRoot, resolvedTaskDir, resolvedFile, timeLimitMs);
+    testSpinner.stop((0, i18n_1.t)('testFinished', lang));
+    if (testRes.compileError) {
+        p.log.error(picocolors_1.default.red((0, i18n_1.t)('testCompilationFailed', lang)));
+        console.log(testRes.compileError);
+        process.exit(1);
+    }
+    if (testRes.results.length === 0) {
+        p.log.warn((0, i18n_1.t)('testNoSamples', lang));
+        process.exit(0);
+    }
+    let allPassed = true;
+    for (const res of testRes.results) {
+        const label = `sample-${res.index}`;
+        const duration = `${res.durationMs.toFixed(0)} ms`;
+        if (res.status === 'AC') {
+            p.log.success(`${picocolors_1.default.green(picocolors_1.default.bold('[AC]'))} ${label}: Passed (${duration})`);
+        }
+        else if (res.status === 'WA') {
+            allPassed = false;
+            p.log.error(`${picocolors_1.default.red(picocolors_1.default.bold('[WA]'))} ${label}: Failed (${duration})`);
+            console.log(`   ${picocolors_1.default.gray('┌────────────────────────────────────────────────────────')}`);
+            console.log(`   ${picocolors_1.default.gray('│')} ${picocolors_1.default.bold('Expected Output:')}`);
+            (0, format_1.formatOutputLines)(res.expectedOutput, res.firstDiffLine).forEach(l => console.log(l));
+            console.log(`   ${picocolors_1.default.gray('├────────────────────────────────────────────────────────')}`);
+            console.log(`   ${picocolors_1.default.gray('│')} ${picocolors_1.default.bold('Actual Output:')}`);
+            (0, format_1.formatOutputLines)(res.actualOutput, res.firstDiffLine).forEach(l => console.log(l));
+            if (res.firstDiffLine) {
+                console.log(`   ${picocolors_1.default.gray('├────────────────────────────────────────────────────────')}`);
+                console.log(`   ${picocolors_1.default.gray('│')} ${picocolors_1.default.yellow(`First mismatch on line ${res.firstDiffLine}`)}`);
+            }
+            console.log(`   ${picocolors_1.default.gray('└────────────────────────────────────────────────────────')}`);
+        }
+        else if (res.status === 'TLE') {
+            allPassed = false;
+            p.log.error(`${picocolors_1.default.red(picocolors_1.default.bold('[TLE]'))} ${label}: Time Limit Exceeded (${duration} vs Limit ${timeLimitMs} ms)`);
+        }
+        else if (res.status === 'RE') {
+            allPassed = false;
+            p.log.error(`${picocolors_1.default.red(picocolors_1.default.bold('[RE]'))} ${label}: Runtime Error (${duration})`);
+            if (res.errorOutput) {
+                console.log(`   ${picocolors_1.default.gray('┌────────────────────────────────────────────────────────')}`);
+                console.log(`   ${picocolors_1.default.gray('│')} ${picocolors_1.default.bold('Error Output:')}`);
+                (0, format_1.formatErrorOutputLines)(res.errorOutput).forEach(l => console.log(l));
+                console.log(`   ${picocolors_1.default.gray('└────────────────────────────────────────────────────────')}`);
+            }
+        }
+    }
+    p.outro(allPassed ? picocolors_1.default.green((0, i18n_1.t)('testOutroPassed', lang)) : picocolors_1.default.red((0, i18n_1.t)('testOutroFailed', lang)));
+    if (!allPassed) {
+        process.exit(1);
+    }
+}));
+program
+    .command('submit [task] [file]')
+    .description((0, i18n_1.t)('descSubmit', lang))
+    .action(handleAction(async (taskArg, fileArg) => {
+    const workspaceRoot = (0, finder_1.findWorkspaceRoot)();
+    const { resolvedTaskDir, resolvedFile, taskLabel, contestId } = resolveArgs(workspaceRoot, taskArg, fileArg);
+    p.intro(picocolors_1.default.cyan((0, i18n_1.t)('submitPreparing', lang, contestId, taskLabel)));
+    const s = p.spinner();
+    s.start((0, i18n_1.t)('submitRetrievingLimits', lang));
+    let timeLimitMs = 2000;
+    let taskId = '';
+    const client = (0, client_1.createAtCoderClient)(workspaceRoot);
+    const tasks = await (0, new_1.fetchContestTasks)(workspaceRoot, contestId);
+    const taskInfo = tasks.find(t => t.label.toLowerCase() === taskLabel.toLowerCase());
+    if (!taskInfo) {
+        throw new errors_1.AtcError(`Task label "${taskLabel}" not found in contest "${contestId}".`);
+    }
+    taskId = taskInfo.id;
+    try {
+        const res = await client.get(`/contests/${contestId}/tasks/${taskId}`);
+        const details = (0, problem_page_1.parseProblemPage)(res.data);
+        timeLimitMs = details.timeLimitMs;
+        s.stop((0, i18n_1.t)('testLoadedLimits', lang, timeLimitMs));
+    }
+    catch (err) {
+        s.stop((0, i18n_1.t)('testDefaultLimitsError', lang));
+    }
+    p.log.step((0, i18n_1.t)('submitRunningTests', lang));
+    const testRes = await (0, runner_1.runAllTests)(workspaceRoot, resolvedTaskDir, resolvedFile, timeLimitMs);
+    if (testRes.compileError) {
+        p.log.error(picocolors_1.default.red((0, i18n_1.t)('testCompilationFailed', lang)));
+        console.log(testRes.compileError);
+        process.exit(1);
+    }
+    const allPassed = testRes.results.length > 0 && testRes.results.every(r => r.status === 'AC');
+    if (testRes.results.length === 0) {
+        p.log.warn((0, i18n_1.t)('submitNoSamples', lang));
+    }
+    else if (!allPassed) {
+        p.log.warn(picocolors_1.default.yellow((0, i18n_1.t)('submitTestsFailed', lang)));
+        const confirmSubmit = await p.confirm({
+            message: (0, i18n_1.t)('submitConfirmMessage', lang),
+            initialValue: false
+        });
+        if (p.isCancel(confirmSubmit) || !confirmSubmit) {
+            p.cancel((0, i18n_1.t)('submitAborted', lang));
+            process.exit(0);
+        }
+    }
+    else {
+        p.log.success(picocolors_1.default.green((0, i18n_1.t)('submitTestsPassed', lang)));
+    }
+    const subSpinner = p.spinner();
+    subSpinner.start((0, i18n_1.t)('submitSubmitting', lang));
+    let subDetails;
+    try {
+        subDetails = await (0, submit_1.submitTask)(workspaceRoot, contestId, taskId, taskLabel, resolvedFile);
+        subSpinner.stop((0, i18n_1.t)('submitSuccess', lang, subDetails.submissionId));
+        (0, open_1.openUrl)(`https://atcoder.jp${subDetails.url}`);
+    }
+    catch (err) {
+        subSpinner.stop(picocolors_1.default.yellow((0, i18n_1.t)('submitManualSubmission', lang)));
+        let codeContent = '';
+        try {
+            const config = (0, config_store_1.loadConfig)(workspaceRoot);
+            const { codeFile } = (0, runner_1.detectCodeFile)(workspaceRoot, resolvedTaskDir, config, resolvedFile);
+            codeContent = fs.readFileSync(path.join(resolvedTaskDir, codeFile), 'utf8');
+        }
+        catch {
+            // Ignore
+        }
+        const submitPageUrl = `https://atcoder.jp/contests/${contestId}/submit?taskScreenName=${taskId}`;
+        (0, open_1.openUrl)(submitPageUrl);
+        if (codeContent) {
+            await (0, open_1.copyToClipboard)(codeContent);
+            p.outro(picocolors_1.default.cyan((0, i18n_1.t)('submitFallbackMessageWithClipboard', lang)));
+        }
+        else {
+            p.outro(picocolors_1.default.cyan((0, i18n_1.t)('submitFallbackMessage', lang)));
+        }
+        process.exit(0);
+    }
+    const pollSpinner = p.spinner();
+    pollSpinner.start((0, i18n_1.t)('submitWaitingJudge', lang));
+    const pollInterval = 2000;
+    const timeout = 300000; // 5 minutes
+    const startTime = Date.now();
+    let completed = false;
+    while (Date.now() - startTime < timeout) {
+        try {
+            const detailRes = await client.get(subDetails.url);
+            const status = (0, submission_status_1.parseSubmissionStatus)(detailRes.data);
+            pollSpinner.message(`Judge Status: ${picocolors_1.default.yellow(picocolors_1.default.bold(status.status))}`);
+            if (status.isCompleted) {
+                completed = true;
+                pollSpinner.stop((0, i18n_1.t)('submitJudgeFinished', lang, status.status));
+                const stats = [];
+                if (status.score)
+                    stats.push(`Score: ${status.score}`);
+                if (status.time)
+                    stats.push(`Time: ${status.time}`);
+                if (status.memory)
+                    stats.push(`Memory: ${status.memory}`);
+                const statsStr = stats.length > 0 ? ` (${stats.join(', ')})` : '';
+                if (status.status === 'AC') {
+                    p.log.success(`${picocolors_1.default.green(picocolors_1.default.bold('[AC]'))} ${(0, i18n_1.t)('submitAccepted', lang)}${statsStr}`);
+                }
+                else {
+                    p.log.error(`${picocolors_1.default.red(picocolors_1.default.bold(`[${status.status}]`))} ${(0, i18n_1.t)('submitFailed', lang)}${statsStr}`);
+                }
+                break;
+            }
+        }
+        catch (e) {
+            // Ignore intermediate polling network errors
+            pollSpinner.message(`Polling status... (network retry: ${e.message})`);
+        }
+        await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+    if (!completed) {
+        pollSpinner.stop((0, i18n_1.t)('submitTimeout', lang));
+        p.log.warn((0, i18n_1.t)('submitTimeoutWarn', lang, subDetails.url));
+    }
+    p.outro(picocolors_1.default.green('Done.'));
+}));
+program
+    .command('lang [language]')
+    .description((0, i18n_1.t)('descLang', lang))
+    .action(handleAction(async (targetLanguage) => {
+    let workspaceRoot;
+    try {
+        workspaceRoot = (0, finder_1.findWorkspaceRoot)();
+    }
+    catch {
+        p.log.error(picocolors_1.default.red((0, i18n_1.t)('langWorkspaceRequired', lang)));
+        process.exit(1);
+    }
+    if (!targetLanguage) {
+        console.log((0, i18n_1.t)('langCommandUsage', lang));
+        process.exit(0);
+    }
+    const cleanLang = targetLanguage.trim().toLowerCase();
+    if (cleanLang !== 'en' && cleanLang !== 'ja') {
+        p.log.error(picocolors_1.default.red((0, i18n_1.t)('langInvalid', lang)));
+        process.exit(1);
+    }
+    const config = (0, config_store_1.loadConfig)(workspaceRoot);
+    config.lang = cleanLang;
+    (0, config_store_1.saveConfig)(workspaceRoot, config);
+    p.log.success((0, i18n_1.t)('langSuccess', cleanLang, cleanLang));
+}));
+program.parse(process.argv);

package/dist/config/config-store.d.ts

@@ -0,0 +1,17 @@
+export interface LanguageConfig {
+    extension: string;
+    templateDir: string;
+    build: string;
+    run: string;
+}
+export interface Config {
+    defaultLanguage: string;
+    languages: Record<string, LanguageConfig>;
+    testDirName: string;
+    contestDir?: string;
+    lang?: 'en' | 'ja';
+}
+export declare const DEFAULT_CONFIG: Config;
+export declare function getConfigPath(workspaceRoot: string): string;
+export declare function loadConfig(workspaceRoot: string): Config;
+export declare function saveConfig(workspaceRoot: string, config: Config): void;

package/dist/config/config-store.js

@@ -0,0 +1,92 @@
+"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.DEFAULT_CONFIG = void 0;
+exports.getConfigPath = getConfigPath;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.DEFAULT_CONFIG = {
+    defaultLanguage: 'cpp',
+    languages: {
+        cpp: {
+            extension: 'cpp',
+            templateDir: 'templates/cpp',
+            build: 'g++ -O2 -std=gnu++20 -o a.out main.cpp',
+            run: './a.out'
+        },
+        python: {
+            extension: 'py',
+            templateDir: 'templates/python',
+            build: '',
+            run: 'python3 main.py'
+        }
+    },
+    testDirName: 'tests',
+    contestDir: ''
+};
+function getConfigPath(workspaceRoot) {
+    return path.join(workspaceRoot, '.atcoder-cli', 'config.json');
+}
+function loadConfig(workspaceRoot) {
+    const configPath = getConfigPath(workspaceRoot);
+    if (!fs.existsSync(configPath)) {
+        return exports.DEFAULT_CONFIG;
+    }
+    try {
+        const raw = fs.readFileSync(configPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return {
+            ...exports.DEFAULT_CONFIG,
+            ...parsed,
+            languages: {
+                ...exports.DEFAULT_CONFIG.languages,
+                ...(parsed.languages || {})
+            }
+        };
+    }
+    catch (e) {
+        return exports.DEFAULT_CONFIG;
+    }
+}
+function saveConfig(workspaceRoot, config) {
+    const configPath = getConfigPath(workspaceRoot);
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+}

package/dist/session/auth.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Saves a manually entered REVEL_SESSION cookie and verifies the session.
+ */
+export declare function loginWithCookie(workspaceRoot: string, revelSession: string): Promise<string>;
+/**
+ * Checks the login status by requesting the AtCoder settings page with saved session cookies.
+ */
+export declare function whoami(workspaceRoot: string): Promise<string>;