atcoder-workspace 1.1.0-beta.1

package/src/cli.ts

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

package/src/config/config-store.ts

@@ -0,0 +1,72 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { findWorkspaceRoot } from '../workspace/finder';
+
+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 const DEFAULT_CONFIG: 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: ''
+};
+
+export function getConfigPath(workspaceRoot: string): string {
+  return path.join(workspaceRoot, '.atcoder-cli', 'config.json');
+}
+
+export function loadConfig(workspaceRoot: string): Config {
+  const configPath = getConfigPath(workspaceRoot);
+  if (!fs.existsSync(configPath)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const raw = fs.readFileSync(configPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return {
+      ...DEFAULT_CONFIG,
+      ...parsed,
+      languages: {
+        ...DEFAULT_CONFIG.languages,
+        ...(parsed.languages || {})
+      }
+    };
+  } catch (e) {
+    return DEFAULT_CONFIG;
+  }
+}
+
+export function saveConfig(workspaceRoot: string, config: Config): void {
+  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');
+}