atcoder-workspace 1.1.0-beta.1

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "atcoder-workspace",
+  "version": "1.1.0-beta.1",
+  "description": "AtCoder All-in-One CLI (Local-first)",
+  "main": "dist/cli.js",
+  "bin": {
+    "atc": "./dist/cli.js"
+  },
+  "type": "commonjs",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "dev": "tsx src/cli.ts",
+    "test-env:setup": "npm run build && npm pack && npm --prefix test install atcoder-workspace-1.1.0-beta.1.tgz"
+  },
+  "keywords": [
+    "atcoder",
+    "cli",
+    "competitive-programming"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "axios": "^1.6.8",
+    "cheerio": "^1.0.0-rc.12",
+    "commander": "^12.0.0",
+    "ora": "^5.4.1",
+    "picocolors": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.24",
+    "tsx": "^4.7.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.3.1"
+  }
+}

package/src/atcoder/client.ts

@@ -0,0 +1,21 @@
+import axios, { AxiosInstance } from 'axios';
+import { loadSession, getCookieHeaderString } from '../session/store';
+
+export function createAtCoderClient(workspaceRoot: string): AxiosInstance {
+  const cookies = loadSession(workspaceRoot);
+  const headers: Record<string, string> = {
+    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+  };
+
+  if (cookies) {
+    headers['Cookie'] = getCookieHeaderString(cookies);
+  }
+
+  const client = axios.create({
+    baseURL: 'https://atcoder.jp',
+    headers,
+    timeout: 15000,
+  });
+
+  return client;
+}

package/src/atcoder/new.ts

@@ -0,0 +1,107 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createAtCoderClient } from './client';
+import { parseContestTasks, TaskInfo } from './parser/contest-tasks';
+import { parseProblemPage, SampleCase } from './parser/problem-page';
+import { loadConfig } from '../config/config-store';
+import { AtcError } from '../utils/errors';
+
+export interface SetupResult {
+  contestId: string;
+  taskLabel: string;
+  taskDir: string;
+  sampleCount: number;
+}
+
+/**
+ * Fetches the list of tasks for a given contest.
+ */
+export async function fetchContestTasks(workspaceRoot: string, contestId: string): Promise<TaskInfo[]> {
+  const client = createAtCoderClient(workspaceRoot);
+  try {
+    const res = await client.get(`/contests/${contestId}/tasks`);
+    return parseContestTasks(res.data);
+  } catch (err: any) {
+    throw new AtcError(`Failed to fetch tasks for contest "${contestId}": ${err.message}`);
+  }
+}
+
+/**
+ * Sets up a single task by downloading sample cases and copying language templates.
+ */
+export async function setupTask(
+  workspaceRoot: string,
+  contestId: string,
+  task: TaskInfo,
+  languageKey?: string
+): Promise<SetupResult> {
+  const config = loadConfig(workspaceRoot);
+  const langKey = languageKey || config.defaultLanguage;
+  const langConfig = config.languages[langKey];
+
+  if (!langConfig) {
+    throw new AtcError(`Language configuration for "${langKey}" not found in config.json`);
+  }
+
+  // Create contest and task directories
+  const contestParentDir = config.contestDir ? path.join(workspaceRoot, config.contestDir) : workspaceRoot;
+  const contestDir = path.join(contestParentDir, contestId);
+  const taskDir = path.join(contestDir, task.label);
+  
+  if (!fs.existsSync(taskDir)) {
+    fs.mkdirSync(taskDir, { recursive: true });
+  }
+
+  // Copy template files
+  const templateSrcDir = path.join(workspaceRoot, '.atcoder-cli', langConfig.templateDir);
+  if (fs.existsSync(templateSrcDir) && fs.statSync(templateSrcDir).isDirectory()) {
+    const files = fs.readdirSync(templateSrcDir);
+    for (const file of files) {
+      const srcPath = path.join(templateSrcDir, file);
+      const destPath = path.join(taskDir, file);
+      if (fs.statSync(srcPath).isFile() && !fs.existsSync(destPath)) {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  // Fetch problem page
+  const client = createAtCoderClient(workspaceRoot);
+  let problemHtml = '';
+  try {
+    const res = await client.get(`/contests/${contestId}/tasks/${task.id}`);
+    problemHtml = res.data;
+  } catch (err: any) {
+    throw new AtcError(`Failed to fetch problem page for "${task.id}": ${err.message}`);
+  }
+
+  const problemDetails = parseProblemPage(problemHtml);
+
+  // Write sample cases to tests/ directory
+  const testDirName = config.testDirName || 'tests';
+  const testDir = path.join(taskDir, testDirName);
+  
+  if (fs.existsSync(testDir)) {
+    // Clear existing sample files to avoid mixing old/new samples
+    const files = fs.readdirSync(testDir);
+    for (const file of files) {
+      if (file.startsWith('sample-')) {
+        fs.unlinkSync(path.join(testDir, file));
+      }
+    }
+  } else {
+    fs.mkdirSync(testDir, { recursive: true });
+  }
+
+  for (const sample of problemDetails.samples) {
+    fs.writeFileSync(path.join(testDir, `sample-${sample.index}.in`), sample.input, 'utf8');
+    fs.writeFileSync(path.join(testDir, `sample-${sample.index}.out`), sample.output, 'utf8');
+  }
+
+  return {
+    contestId,
+    taskLabel: task.label,
+    taskDir,
+    sampleCount: problemDetails.samples.length
+  };
+}

package/src/atcoder/parser/contest-tasks.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import { parseContestTasks } from './contest-tasks';
+
+const MOCK_CONTEST_TASKS_HTML = `
+<table>
+  <thead>
+    <tr><th>Task</th><th>Task Name</th></tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td><a href="/contests/abc300/tasks/abc300_a">A</a></td>
+      <td><a href="/contests/abc300/tasks/abc300_a">Bitwise XOR</a></td>
+    </tr>
+    <tr>
+      <td><a href="/contests/abc300/tasks/abc300_b">B</a></td>
+      <td><a href="/contests/abc300/tasks/abc300_b">Grid Rotations</a></td>
+    </tr>
+  </tbody>
+</table>
+`;
+
+describe('contest-tasks parser', () => {
+  it('should parse task list correctly', () => {
+    const tasks = parseContestTasks(MOCK_CONTEST_TASKS_HTML);
+    expect(tasks).toHaveLength(2);
+    expect(tasks[0]).toEqual({
+      id: 'abc300_a',
+      label: 'a',
+      url: '/contests/abc300/tasks/abc300_a'
+    });
+    expect(tasks[1]).toEqual({
+      id: 'abc300_b',
+      label: 'b',
+      url: '/contests/abc300/tasks/abc300_b'
+    });
+  });
+});

package/src/atcoder/parser/contest-tasks.ts

@@ -0,0 +1,61 @@
+import * as cheerio from 'cheerio';
+
+export interface TaskInfo {
+  id: string;
+  label: string;
+  url: string;
+}
+
+export function parseContestTasks(html: string): TaskInfo[] {
+  const $ = cheerio.load(html);
+  const tasks: TaskInfo[] = [];
+  const seenIds = new Set<string>();
+
+  $('a').each((_, elem) => {
+    const href = $(elem).attr('href');
+    if (href) {
+      const match = href.match(/\/contests\/([^/]+)\/tasks\/([^/?#]+)$/);
+      if (match) {
+        const id = match[2];
+        const label = $(elem).text().trim().toLowerCase();
+        
+        if (label.length > 0 && label.length <= 4 && !seenIds.has(id)) {
+          seenIds.add(id);
+          tasks.push({
+            id,
+            label,
+            url: href
+          });
+        }
+      }
+    }
+  });
+
+  if (tasks.length === 0) {
+    $('a').each((_, elem) => {
+      const href = $(elem).attr('href');
+      if (href) {
+        const match = href.match(/\/contests\/([^/]+)\/tasks\/([^/?#]+)$/);
+        if (match) {
+          const id = match[2];
+          const label = $(elem).text().trim().toLowerCase();
+          if (label && !seenIds.has(id)) {
+            seenIds.add(id);
+            let cleanLabel = label;
+            if (cleanLabel.length > 4) {
+              const parts = id.split('_');
+              cleanLabel = parts[parts.length - 1] || 'task';
+            }
+            tasks.push({
+              id,
+              label: cleanLabel.toLowerCase(),
+              url: href
+            });
+          }
+        }
+      }
+    });
+  }
+
+  return tasks.sort((a, b) => a.label.localeCompare(b.label));
+}

package/src/atcoder/parser/limits.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest';
+import { parseTimeLimit, parseMemoryLimit } from './limits';
+
+describe('limits parser', () => {
+  describe('parseTimeLimit', () => {
+    it('should parse standard english formats', () => {
+      expect(parseTimeLimit('Time Limit: 2 sec')).toBe(2000);
+      expect(parseTimeLimit('Time Limit: 2.5 sec')).toBe(2500);
+      expect(parseTimeLimit('Time Limit: 1000 ms')).toBe(1000);
+    });
+
+    it('should parse standard japanese formats', () => {
+      expect(parseTimeLimit('実行時間制限: 2 秒')).toBe(2000);
+      expect(parseTimeLimit('実行時間制限: 2.5 秒')).toBe(2500);
+      expect(parseTimeLimit('実行時間制限: 1000 ミリ秒')).toBe(1000);
+    });
+
+    it('should parse simple formats without labels', () => {
+      expect(parseTimeLimit('2 sec')).toBe(2000);
+      expect(parseTimeLimit('1500 ms')).toBe(1500);
+    });
+
+    it('should throw ParseError on invalid formats', () => {
+      expect(() => parseTimeLimit('no limit here')).toThrow();
+    });
+  });
+
+  describe('parseMemoryLimit', () => {
+    it('should parse standard english formats', () => {
+      expect(parseMemoryLimit('Memory Limit: 1024 MB')).toBe(1024 * 1024 * 1024);
+      expect(parseMemoryLimit('Memory Limit: 1024 MiB')).toBe(1024 * 1024 * 1024);
+      expect(parseMemoryLimit('Memory Limit: 256 KB')).toBe(256 * 1024);
+      expect(parseMemoryLimit('Memory Limit: 512 KiB')).toBe(512 * 1024);
+      expect(parseMemoryLimit('Memory Limit: 1 GB')).toBe(1024 * 1024 * 1024);
+      expect(parseMemoryLimit('Memory Limit: 1 GiB')).toBe(1024 * 1024 * 1024);
+    });
+
+    it('should parse standard japanese formats', () => {
+      expect(parseMemoryLimit('メモリ制限: 1024 MB')).toBe(1024 * 1024 * 1024);
+      expect(parseMemoryLimit('メモリ制限: 1024 MiB')).toBe(1024 * 1024 * 1024);
+    });
+
+    it('should parse simple formats without labels', () => {
+      expect(parseMemoryLimit('1024 MB')).toBe(1024 * 1024 * 1024);
+      expect(parseMemoryLimit('512 MiB')).toBe(512 * 1024 * 1024);
+    });
+
+    it('should throw ParseError on invalid formats', () => {
+      expect(() => parseMemoryLimit('no memory here')).toThrow();
+    });
+  });
+});

package/src/atcoder/parser/limits.ts

@@ -0,0 +1,75 @@
+import { ParseError } from '../../utils/errors';
+
+/**
+ * Parses a time limit string and returns the limit in milliseconds.
+ * E.g., "2 sec", "2.5 sec", "2000 ms", "2 秒", "2.5 秒"
+ */
+export function parseTimeLimit(text: string): number {
+  // Support both English and Japanese formats
+  const timeRegex = /(?:Time Limit|実行時間制限)\s*:\s*([\d.]+)\s*(sec|ms|秒|ミリ秒)/i;
+  const match = text.match(timeRegex);
+  
+  if (!match) {
+    // If not found with label, try parsing raw units in the context of limits
+    const simpleRegex = /(\d+(?:\.\d+)?)\s*(sec|ms|秒|ミリ秒)/i;
+    const simpleMatch = text.match(simpleRegex);
+    if (!simpleMatch) {
+      throw new ParseError(`Could not parse time limit from text: "${text}"`);
+    }
+    return convertTimeToMs(parseFloat(simpleMatch[1]), simpleMatch[2]);
+  }
+
+  const value = parseFloat(match[1]);
+  const unit = match[2];
+  return convertTimeToMs(value, unit);
+}
+
+function convertTimeToMs(value: number, unit: string): number {
+  const normUnit = unit.toLowerCase();
+  if (normUnit === 'sec' || normUnit === '秒') {
+    return Math.round(value * 1000);
+  }
+  if (normUnit === 'ms' || normUnit === 'ミリ秒') {
+    return Math.round(value);
+  }
+  throw new ParseError(`Unknown time unit: "${unit}"`);
+}
+
+/**
+ * Parses a memory limit string and returns the limit in bytes.
+ * E.g., "1024 MB", "1024 MiB", "256 KB", "256 KiB", "1 GB", "1 GiB"
+ */
+export function parseMemoryLimit(text: string): number {
+  const memoryRegex = /(?:Memory Limit|メモリ制限)\s*:\s*(\d+)\s*(KB|MB|GB|KiB|MiB|GiB)/i;
+  const match = text.match(memoryRegex);
+
+  if (!match) {
+    const simpleRegex = /(\d+)\s*(KB|MB|GB|KiB|MiB|GiB)/i;
+    const simpleMatch = text.match(simpleRegex);
+    if (!simpleMatch) {
+      throw new ParseError(`Could not parse memory limit from text: "${text}"`);
+    }
+    return convertMemoryToBytes(parseInt(simpleMatch[1], 10), simpleMatch[2]);
+  }
+
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  return convertMemoryToBytes(value, unit);
+}
+
+function convertMemoryToBytes(value: number, unit: string): number {
+  const normUnit = unit.toLowerCase();
+  switch (normUnit) {
+    case 'kb':
+    case 'kib':
+      return value * 1024;
+    case 'mb':
+    case 'mib':
+      return value * 1024 * 1024;
+    case 'gb':
+    case 'gib':
+      return value * 1024 * 1024 * 1024;
+    default:
+      throw new ParseError(`Unknown memory unit: "${unit}"`);
+  }
+}

package/src/atcoder/parser/problem-page.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect } from 'vitest';
+import { parseProblemPage } from './problem-page';
+
+const MOCK_PROBLEM_HTML = `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>A - ABC Problem</title>
+</head>
+<body>
+  <span class="h2">A - ABC Problem</span>
+  <div id="task-statement">
+    <p>Time Limit: 2 sec / Memory Limit: 1024 MB</p>
+    <span class="lang-en">
+      <div class="part">
+        <h3>Sample Input 1</h3>
+        <pre>1 2
+3</pre>
+      </div>
+      <div class="part">
+        <h3>Sample Output 1</h3>
+        <pre>6</pre>
+      </div>
+      <div class="part">
+        <h3>Sample Input 2</h3>
+        <pre>10 20
+30</pre>
+      </div>
+      <div class="part">
+        <h3>Sample Output 2</h3>
+        <pre>60</pre>
+      </div>
+    </span>
+    <span class="lang-ja">
+      <div class="part">
+        <h3>入力例 1</h3>
+        <pre>1 2
+3</pre>
+      </div>
+      <div class="part">
+        <h3>出力例 1</h3>
+        <pre>6</pre>
+      </div>
+    </span>
+  </div>
+</body>
+</html>
+`;
+
+describe('problem-page parser', () => {
+  it('should parse details correctly', () => {
+    const details = parseProblemPage(MOCK_PROBLEM_HTML);
+    expect(details.title).toBe('A - ABC Problem');
+    expect(details.timeLimitMs).toBe(2000);
+    expect(details.memoryLimitBytes).toBe(1024 * 1024 * 1024);
+    expect(details.samples).toHaveLength(2);
+    expect(details.samples[0]).toEqual({
+      index: 1,
+      input: '1 2\n3\n',
+      output: '6\n'
+    });
+    expect(details.samples[1]).toEqual({
+      index: 2,
+      input: '10 20\n30\n',
+      output: '60\n'
+    });
+  });
+});

package/src/atcoder/parser/problem-page.ts

@@ -0,0 +1,126 @@
+import * as cheerio from 'cheerio';
+import { parseTimeLimit, parseMemoryLimit } from './limits';
+import { ParseError } from '../../utils/errors';
+
+export interface SampleCase {
+  index: number;
+  input: string;
+  output: string;
+}
+
+export interface TaskDetails {
+  title: string;
+  timeLimitMs: number;
+  memoryLimitBytes: number;
+  samples: SampleCase[];
+}
+
+export function parseProblemPage(html: string): TaskDetails {
+  const $ = cheerio.load(html);
+
+  let title = $('span.h2').first().text().trim();
+  if (!title) {
+    title = $('h2').first().text().trim();
+  }
+  if (!title) {
+    title = $('title').text().trim() || 'Task';
+  }
+
+  title = title.replace(/\s+/g, ' ');
+
+  const taskStatementText = $('#task-statement').text() || $('body').text();
+  let timeLimitMs = 2000;
+  let memoryLimitBytes = 1024 * 1024 * 1024;
+
+  try {
+    timeLimitMs = parseTimeLimit(taskStatementText);
+  } catch (e) {
+    try {
+      timeLimitMs = parseTimeLimit($('body').text());
+    } catch (err) {
+      console.warn('Could not parse time limit. Using default 2000ms.');
+    }
+  }
+
+  try {
+    memoryLimitBytes = parseMemoryLimit(taskStatementText);
+  } catch (e) {
+    try {
+      memoryLimitBytes = parseMemoryLimit($('body').text());
+    } catch (err) {
+      console.warn('Could not parse memory limit. Using default 1024MB.');
+    }
+  }
+
+  let $container = $('#task-statement');
+  if ($container.find('.lang-en').length > 0) {
+    $container = $container.find('.lang-en');
+  } else if ($container.find('.lang-ja').length > 0) {
+    $container = $container.find('.lang-ja');
+  }
+
+  const sampleMap: Record<number, { input?: string; output?: string }> = {};
+
+  const inputRegex = /(?:Sample\s+Input|入力例)\s*(?:#|No\.?)?\s*(\d+)/i;
+  const outputRegex = /(?:Sample\s+Output|出力例)\s*(?:#|No\.?)?\s*(\d+)/i;
+
+  $container.find('h3, h4').each((_, elem) => {
+    const headerText = $(elem).text().trim();
+    
+    const inputMatch = headerText.match(inputRegex);
+    const outputMatch = headerText.match(outputRegex);
+
+    if (inputMatch || outputMatch) {
+      const isInput = !!inputMatch;
+      const index = parseInt(isInput ? inputMatch![1] : outputMatch![1], 10);
+
+      let $pre = $(elem).next('pre');
+      if ($pre.length === 0) {
+        $pre = $(elem).parent().find('pre');
+      }
+      if ($pre.length === 0 || $pre.parent().is(elem)) {
+        $pre = $(elem).nextAll('pre').first();
+      }
+      if ($pre.length === 0) {
+        $pre = $(elem).nextAll().find('pre').first();
+      }
+
+      if ($pre.length > 0) {
+        let content = $pre.text();
+        content = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        if (content && !content.endsWith('\n')) {
+          content += '\n';
+        }
+
+        if (!sampleMap[index]) {
+          sampleMap[index] = {};
+        }
+
+        if (isInput) {
+          sampleMap[index].input = content;
+        } else {
+          sampleMap[index].output = content;
+        }
+      }
+    }
+  });
+
+  const samples: SampleCase[] = Object.keys(sampleMap)
+    .map(key => {
+      const idx = parseInt(key, 10);
+      return {
+        index: idx,
+        input: sampleMap[idx].input ?? '',
+        output: sampleMap[idx].output ?? ''
+      };
+    })
+    .filter(s => s.input !== '' || s.output !== '')
+    .sort((a, b) => a.index - b.index);
+
+  return {
+    title,
+    timeLimitMs,
+    memoryLimitBytes,
+    samples
+  };
+}

package/src/atcoder/parser/submission-status.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { parseSubmissionStatus } from './submission-status';
+
+const MOCK_SUBMISSION_WJ = `
+<table>
+  <tr><th>Status</th><td id="judge-status">12/15 WJ</td></tr>
+  <tr><th>Score</th><td>0</td></tr>
+</table>
+`;
+
+const MOCK_SUBMISSION_AC = `
+<table>
+  <tr><th>Status</th><td id="judge-status"><span class="label label-success">AC</span></td></tr>
+  <tr><th>Execution Time</th><td>15 ms</td></tr>
+  <tr><th>Memory</th><td>2048 KB</td></tr>
+  <tr><th>Score</th><td>100</td></tr>
+</table>
+`;
+
+describe('submission-status parser', () => {
+  it('should parse WJ state correctly', () => {
+    const res = parseSubmissionStatus(MOCK_SUBMISSION_WJ);
+    expect(res.status).toBe('12/15 WJ');
+    expect(res.isCompleted).toBe(false);
+    expect(res.score).toBe('0');
+  });
+
+  it('should parse AC state correctly', () => {
+    const res = parseSubmissionStatus(MOCK_SUBMISSION_AC);
+    expect(res.status).toBe('AC');
+    expect(res.isCompleted).toBe(true);
+    expect(res.time).toBe('15 ms');
+    expect(res.memory).toBe('2048 KB');
+    expect(res.score).toBe('100');
+  });
+});

package/src/atcoder/parser/submission-status.ts

@@ -0,0 +1,54 @@
+import * as cheerio from 'cheerio';
+
+export interface SubmissionStatus {
+  status: string;
+  time?: string;
+  memory?: string;
+  score?: string;
+  isCompleted: boolean;
+}
+
+export function parseSubmissionStatus(html: string): SubmissionStatus {
+  const $ = cheerio.load(html);
+  
+  let status = '';
+  let time: string | undefined;
+  let memory: string | undefined;
+  let score: string | undefined;
+
+  const statusElem = $('#judge-status');
+  if (statusElem.length > 0) {
+    status = statusElem.text().trim();
+  } else {
+    $('table tr').each((_, tr) => {
+      const thText = $(tr).find('th').text().trim();
+      if (thText === 'Status' || thText === '状態' || thText === '結果') {
+        status = $(tr).find('td').text().trim();
+      }
+    });
+  }
+
+  $('table tr').each((_, tr) => {
+    const thText = $(tr).find('th').text().trim();
+    const tdText = $(tr).find('td').text().trim();
+
+    if (thText === 'Execution Time' || thText === '実行時間') {
+      time = tdText;
+    } else if (thText === 'Memory' || thText === 'メモリ') {
+      memory = tdText;
+    } else if (thText === 'Score' || thText === '得点') {
+      score = tdText;
+    }
+  });
+
+  status = status.replace(/\s+/g, ' ');
+  const isCompleted = status !== '' && !status.includes('WJ') && !status.includes('Judging');
+
+  return {
+    status: status || 'WJ',
+    time,
+    memory,
+    score,
+    isCompleted
+  };
+}