atcoder-workspace 1.1.0-beta.1 → 1.1.0-beta.3

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

@@ -13,9 +13,338 @@ export interface TaskDetails {
   timeLimitMs: number;
   memoryLimitBytes: number;
   samples: SampleCase[];
+  problemStatementMd?: string;
 }
 
-export function parseProblemPage(html: string): TaskDetails {
+function escapeMarkdown(text: string): string {
+  return text
+    .replace(/\\/g, '\\\\')
+    .replace(/\*/g, '\\*')
+    .replace(/_/g, '\\_')
+    .replace(/`/g, '\\`')
+    .replace(/\[/g, '\\[')
+    .replace(/\]/g, '\\]');
+}
+
+function convertLineToMath(line: string): string {
+  const trimmed = line.trim();
+  if (trimmed === ':' || trimmed === '\\vdots') {
+    return '\\vdots';
+  }
+  if (trimmed === '...' || trimmed === '\\dots' || trimmed === '\\cdots') {
+    return '\\dots';
+  }
+
+  let result = '';
+  let i = 0;
+  let textBuffer = '';
+  
+  const flushBuffer = () => {
+    if (textBuffer) {
+      result += `\\text{${textBuffer}}`;
+      textBuffer = '';
+    }
+  };
+
+  while (i < line.length) {
+    const remaining = line.slice(i);
+
+    // 0. Match existing \text{...} optionally followed by a subscript
+    const textSubMatch = remaining.match(/^\\text\{([^{}]+)\}(?:_([a-zA-Z0-9]+|\{[^{}]+\}))?/);
+    if (textSubMatch) {
+      flushBuffer();
+      const baseText = textSubMatch[1];
+      const subText = textSubMatch[2];
+      if (subText) {
+        const formattedSub = (subText.startsWith('{') && subText.endsWith('}')) 
+          ? subText 
+          : (subText.length > 1 ? `{${subText}}` : subText);
+        result += `\\text{${baseText}}_${formattedSub}`;
+      } else {
+        result += `\\text{${baseText}}`;
+      }
+      i += textSubMatch[0].length;
+      continue;
+    }
+
+    // 1. Match LaTeX commands like \dots, \vdots, \cdots
+    const cmdMatch = remaining.match(/^(\\[a-zA-Z]+)/);
+    if (cmdMatch) {
+      flushBuffer();
+      result += cmdMatch[1];
+      i += cmdMatch[1].length;
+      continue;
+    }
+
+    // 2. Match subscript pattern: e.g. A_i, query_1
+    const subMatch = remaining.match(/^([a-zA-Z]+)_([a-zA-Z0-9]+)/);
+    if (subMatch) {
+      flushBuffer();
+      const base = subMatch[1];
+      const sub = subMatch[2];
+      const formattedSub = sub.length > 1 ? `\\text{${sub}}` : sub;
+      result += `\\text{${base}}_${formattedSub}`;
+      i += subMatch[0].length;
+      continue;
+    }
+
+    // 3. Match raw ellipsis "..."
+    if (remaining.startsWith('...')) {
+      flushBuffer();
+      result += '\\dots';
+      i += 3;
+      continue;
+    }
+
+    // 4. Match colon ":"
+    if (remaining.startsWith(':')) {
+      flushBuffer();
+      result += '\\vdots';
+      i += 1;
+      continue;
+    }
+
+    // 5. Normal character (including spaces)
+    textBuffer += line[i];
+    i += 1;
+  }
+  
+  flushBuffer();
+  return result;
+}
+
+function renderPreAsMathArray(node: any, $: cheerio.CheerioAPI): string {
+  const rawText = $(node).text();
+  const lines = rawText.split('\n');
+  
+  let startIdx = 0;
+  while (startIdx < lines.length && lines[startIdx].trim() === '') {
+    startIdx++;
+  }
+  let endIdx = lines.length - 1;
+  while (endIdx >= startIdx && lines[endIdx].trim() === '') {
+    endIdx--;
+  }
+  
+  const activeLines = lines.slice(startIdx, endIdx + 1);
+  if (activeLines.length === 0) {
+    return '';
+  }
+  
+  const convertedLines = activeLines.map(line => convertLineToMath(line));
+  
+  let result = '\n\n$$\n\\begin{array}{l}\n';
+  result += convertedLines.join(' \\\\\n');
+  result += '\n\\end{array}\n$$\n\n';
+  
+  return result;
+}
+
+function processTextNode(text: string): string {
+  const parts: string[] = [];
+  let i = 0;
+  while (i < text.length) {
+    if (text.startsWith('\\[', i)) {
+      const start = i;
+      const end = text.indexOf('\\]', i + 2);
+      if (end !== -1) {
+        const mathContent = text.slice(start + 2, end);
+        parts.push(`$$\n${mathContent.trim()}\n$$`);
+        i = end + 2;
+      } else {
+        parts.push(escapeMarkdown(text.slice(i, i + 2)));
+        i += 2;
+      }
+    } else if (text.startsWith('\\(', i)) {
+      const start = i;
+      const end = text.indexOf('\\)', i + 2);
+      if (end !== -1) {
+        const mathContent = text.slice(start + 2, end);
+        parts.push(`$${mathContent.trim()}$`);
+        i = end + 2;
+      } else {
+        parts.push(escapeMarkdown(text.slice(i, i + 2)));
+        i += 2;
+      }
+    } else if (text.startsWith('$$', i)) {
+      const start = i;
+      const end = text.indexOf('$$', i + 2);
+      if (end !== -1) {
+        const mathContent = text.slice(start + 2, end);
+        parts.push(`$$\n${mathContent.trim()}\n$$`);
+        i = end + 2;
+      } else {
+        parts.push(escapeMarkdown(text.slice(i, i + 2)));
+        i += 2;
+      }
+    } else if (text.startsWith('$', i)) {
+      const start = i;
+      const end = text.indexOf('$', i + 1);
+      if (end !== -1) {
+        const mathContent = text.slice(start + 1, end);
+        parts.push(`$${mathContent.trim()}$`);
+        i = end + 1;
+      } else {
+        parts.push('$');
+        i += 1;
+      }
+    } else {
+      let nextIndex = -1;
+      let selectedDelim = '';
+      
+      const delims = ['\\[', '\\(', '$$', '$'];
+      for (const delim of delims) {
+        const idx = text.indexOf(delim, i);
+        if (idx !== -1 && (nextIndex === -1 || idx < nextIndex)) {
+          nextIndex = idx;
+          selectedDelim = delim;
+        }
+      }
+      
+      if (nextIndex === -1) {
+        parts.push(escapeMarkdown(text.slice(i)));
+        break;
+      } else {
+        parts.push(escapeMarkdown(text.slice(i, nextIndex)));
+        i = nextIndex;
+      }
+    }
+  }
+  return parts.join('');
+}
+
+function nodeToMarkdown(node: any, $: cheerio.CheerioAPI, isInsideMath = false): string {
+  if (node.type === 'text') {
+    return isInsideMath ? ((node as any).data || '') : processTextNode((node as any).data || '');
+  }
+
+  if (node.type === 'tag') {
+    const tagName = (node as any).name;
+    const className = $(node).attr('class') || '';
+    const classes = className.split(/\s+/);
+    const isMathContainer = tagName === 'var' || classes.includes('math');
+    const isBlockMath = tagName === 'div' && classes.includes('math');
+
+    if (isMathContainer) {
+      let mathBody = '';
+      if ((node as any).children) {
+        for (const child of (node as any).children) {
+          mathBody += nodeToMarkdown(child, $, true);
+        }
+      }
+      const delim = isBlockMath ? '$$' : '$';
+      if (isBlockMath) {
+        return `\n\n$$\n${mathBody.trim()}\n$$\n\n`;
+      }
+      return `${delim}${mathBody.trim()}${delim}`;
+    }
+
+    if (tagName === 'table') {
+      const $table = $(node).clone();
+      $table.find('a').each((_, el) => {
+        const href = $(el).attr('href');
+        if (href && href.startsWith('/') && !href.startsWith('//')) {
+          $(el).attr('href', 'https://atcoder.jp' + href);
+        }
+      });
+      $table.find('img').each((_, el) => {
+        const src = $(el).attr('src');
+        if (src && src.startsWith('/') && !src.startsWith('//')) {
+          $(el).attr('src', 'https://atcoder.jp' + src);
+        }
+      });
+      return '\n\n' + $.html($table) + '\n\n';
+    }
+
+    let childrenMarkdown = '';
+    if ((node as any).children) {
+      for (const child of (node as any).children) {
+        childrenMarkdown += nodeToMarkdown(child, $, isInsideMath);
+      }
+    }
+
+    switch (tagName) {
+      case 'h1':
+      case 'h2':
+      case 'h3':
+      case 'h4':
+      case 'h5':
+      case 'h6': {
+        const level = parseInt(tagName.substring(1), 10);
+        return `\n\n${'#'.repeat(level)} ${childrenMarkdown.trim()}\n\n`;
+      }
+      case 'p':
+        return `\n\n${childrenMarkdown.trim()}\n\n`;
+      case 'br':
+        return '\n';
+      case 'strong':
+      case 'b':
+        return `**${childrenMarkdown.trim()}**`;
+      case 'em':
+      case 'i':
+        return `*${childrenMarkdown.trim()}*`;
+      case 'code': {
+        const parentTagName = (node.parent as any)?.name;
+        if (parentTagName === 'pre') {
+          return childrenMarkdown;
+        }
+        return `\`${childrenMarkdown}\``;
+      }
+      case 'pre': {
+        const text = $(node).text();
+        const hasVar = $(node).find('var').length > 0;
+        const hasMathSymbols = text.includes('\\dots') || text.includes('\\vdots') || text.includes('\\cdots') || text.includes('\\le');
+        if (hasVar || hasMathSymbols) {
+          return renderPreAsMathArray(node, $);
+        }
+        return `\n\n\`\`\`\n${text.trim()}\n\`\`\`\n\n`;
+      }
+      case 'a': {
+        let href = $(node).attr('href') || '';
+        if (href.startsWith('/') && !href.startsWith('//')) {
+          href = 'https://atcoder.jp' + href;
+        }
+        return `[${childrenMarkdown.trim()}](${href})`;
+      }
+      case 'img': {
+        let src = $(node).attr('src') || '';
+        if (src.startsWith('/') && !src.startsWith('//')) {
+          src = 'https://atcoder.jp' + src;
+        }
+        const alt = $(node).attr('alt') || '';
+        return `![${alt}](${src})`;
+      }
+      case 'ul':
+      case 'ol':
+        return `\n\n${childrenMarkdown}\n\n`;
+      case 'li': {
+        let indentLevel = 0;
+        let parent = node.parent;
+        while (parent) {
+          const parentName = (parent as any).name;
+          if (parentName === 'ul' || parentName === 'ol') {
+            indentLevel++;
+          }
+          parent = parent.parent;
+        }
+        const indent = '  '.repeat(Math.max(0, indentLevel - 1));
+        const parentTagName = (node.parent as any)?.name;
+        const prefix = parentTagName === 'ol' ? '1. ' : '- ';
+        return `\n${indent}${prefix}${childrenMarkdown.trim()}`;
+      }
+      case 'div':
+      case 'span':
+      case 'section':
+        return childrenMarkdown;
+      default:
+        return childrenMarkdown;
+    }
+  }
+
+  return '';
+}
+
+export function parseProblemPage(html: string, preferredLang?: 'en' | 'ja'): TaskDetails {
   const $ = cheerio.load(html);
 
   let title = $('span.h2').first().text().trim();
@@ -53,10 +382,33 @@ export function parseProblemPage(html: string): TaskDetails {
   }
 
   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');
+  if (preferredLang === 'ja') {
+    if ($container.find('.lang-ja').length > 0) {
+      $container = $container.find('.lang-ja');
+    } else if ($container.find('.lang-en').length > 0) {
+      $container = $container.find('.lang-en');
+    }
+  } else {
+    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');
+    }
+  }
+
+  // Convert task statement HTML to Markdown if task statement exists
+  let problemStatementMd = '';
+  if ($container.length > 0) {
+    let mdBody = '';
+    $container.contents().each((_, node) => {
+      mdBody += nodeToMarkdown(node, $);
+    });
+    mdBody = mdBody.replace(/\n{3,}/g, '\n\n').trim();
+
+    problemStatementMd = `# ${title}\n\n`;
+    problemStatementMd += `- Time Limit: ${timeLimitMs / 1000} sec\n`;
+    problemStatementMd += `- Memory Limit: ${Math.round(memoryLimitBytes / (1024 * 1024))} MB\n\n`;
+    problemStatementMd += mdBody + '\n';
   }
 
   const sampleMap: Record<number, { input?: string; output?: string }> = {};
@@ -121,6 +473,7 @@ export function parseProblemPage(html: string): TaskDetails {
     title,
     timeLimitMs,
     memoryLimitBytes,
-    samples
+    samples,
+    problemStatementMd
   };
 }

package/src/cli.ts

@@ -8,7 +8,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 
 import { findWorkspaceRoot } from './workspace/finder';
-import { initWorkspace } from './workspace/initializer';
+import { initWorkspace, LANGUAGE_PRESETS, addLanguage } from './workspace/initializer';
 import { loginWithCookie, whoami } from './session/auth';
 import { clearSession } from './session/store';
 import { fetchContestTasks, setupTask } from './atcoder/new';
@@ -36,8 +36,8 @@ const program = new Command();
 
 program
   .name('atc')
-  .description('AtCoder All-in-One CLI (Local-first)')
-  .version('1.1.0-betas');
+  .description('AtCoder Workspace')
+  .version('1.1.0-beta.3');
 
 function handleAction(fn: (...args: any[]) => Promise<void>) {
   return async (...args: any[]) => {
@@ -243,42 +243,101 @@ program
       }
 
       p.outro(pc.green(t('newScaffoldingComplete', lang, selectedTasks.length)));
+
+      if (config.extractProblemStatement) {
+        p.note(
+          t('newStatementWarningBody', lang),
+          pc.yellow(t('newStatementWarningTitle', lang))
+        );
+      }
     })
   );
 
-function resolveArgs(workspaceRoot: string, taskArg: string | undefined, fileArg: string | undefined) {
+function resolveArgs(
+  workspaceRoot: string,
+  arg1: string | undefined,
+  arg2: string | undefined,
+  arg3: string | undefined
+) {
+  const cwd = process.cwd();
+  const config = loadConfig(workspaceRoot);
+  const contestDir = config.contestDir || '';
+
   let resolvedTaskDir = '';
   let resolvedFile: string | undefined;
 
-  let isFile = false;
-  let filePath = '';
-
-  if (taskArg) {
-    const pathsToCheck = [
-      path.resolve(taskArg),
-      path.resolve(workspaceRoot, taskArg)
+  // Helper function to check if relative path parts exist in cwd, workspaceRoot or contestDir
+  function checkPath(relativeParts: string[]): { isFile: boolean; isDir: boolean; path: string } | null {
+    const pathsToTry = [
+      path.resolve(cwd, ...relativeParts),
+      path.resolve(workspaceRoot, ...relativeParts),
+      path.resolve(workspaceRoot, contestDir, ...relativeParts)
     ];
-    
-    const config = loadConfig(workspaceRoot);
-    if (config.contestDir) {
-      pathsToCheck.push(path.resolve(workspaceRoot, config.contestDir, taskArg));
+
+    for (const p of pathsToTry) {
+      if (fs.existsSync(p)) {
+        const stat = fs.statSync(p);
+        return {
+          isFile: stat.isFile(),
+          isDir: stat.isDirectory(),
+          path: p
+        };
+      }
+    }
+    return null;
+  }
+
+  // 1. Three arguments provided: (arg1, arg2, arg3)
+  if (arg1 && arg2 && arg3) {
+    // e.g., abc300 a main.cpp -> check if arg1/arg2 is a directory
+    const checkDir = checkPath([arg1, arg2]);
+    if (checkDir && checkDir.isDir) {
+      resolvedTaskDir = checkDir.path;
+      resolvedFile = arg3;
     }
+  }
+
+  // 2. Two arguments provided: (arg1, arg2)
+  if (!resolvedTaskDir && arg1 && arg2) {
+    // Pattern A: arg1/arg2 is a directory (e.g., abc300 a)
+    const checkDir = checkPath([arg1, arg2]);
+    if (checkDir && checkDir.isDir) {
+      resolvedTaskDir = checkDir.path;
+      resolvedFile = undefined;
+    } else {
+      // Pattern B: arg1 is a directory, arg2 is a file (e.g., a main.cpp)
+      const checkArg1 = checkPath([arg1]);
+      if (checkArg1 && checkArg1.isDir) {
+        resolvedTaskDir = checkArg1.path;
+        resolvedFile = arg2;
+      }
+    }
+  }
 
-    for (const p of pathsToCheck) {
-      if (fs.existsSync(p) && fs.statSync(p).isFile()) {
-        isFile = true;
-        filePath = p;
-        break;
+  // 3. One argument provided: (arg1)
+  if (!resolvedTaskDir && arg1) {
+    const checkArg1 = checkPath([arg1]);
+    if (checkArg1) {
+      if (checkArg1.isFile) {
+        // Pattern A: directly specified a file (e.g., main.cpp)
+        resolvedTaskDir = path.dirname(checkArg1.path);
+        resolvedFile = path.basename(checkArg1.path);
+      } else if (checkArg1.isDir) {
+        // Pattern B: directly specified a directory (e.g., a or abc300/a)
+        resolvedTaskDir = checkArg1.path;
+        resolvedFile = undefined;
       }
+    } else {
+      // Fallback to resolveTaskDirectory (legacy behavior)
+      resolvedTaskDir = resolveTaskDirectory(workspaceRoot, arg1);
+      resolvedFile = undefined;
     }
   }
 
-  if (isFile) {
-    resolvedFile = path.basename(filePath);
-    resolvedTaskDir = path.dirname(filePath);
-  } else {
-    resolvedTaskDir = resolveTaskDirectory(workspaceRoot, taskArg);
-    resolvedFile = fileArg;
+  // 4. No arguments provided
+  if (!resolvedTaskDir) {
+    resolvedTaskDir = resolveTaskDirectory(workspaceRoot, undefined);
+    resolvedFile = undefined;
   }
 
   const taskLabel = path.basename(resolvedTaskDir);
@@ -288,12 +347,12 @@ function resolveArgs(workspaceRoot: string, taskArg: string | undefined, fileArg
 }
 
 program
-  .command('test [task] [file]')
+  .command('test [arg1] [arg2] [arg3]')
   .description(t('descTest', lang))
   .action(
-    handleAction(async (taskArg: string | undefined, fileArg: string | undefined) => {
+    handleAction(async (arg1: string | undefined, arg2: string | undefined, arg3: string | undefined) => {
       const workspaceRoot = findWorkspaceRoot();
-      const { resolvedTaskDir, resolvedFile, taskLabel, contestId } = resolveArgs(workspaceRoot, taskArg, fileArg);
+      const { resolvedTaskDir, resolvedFile, taskLabel, contestId } = resolveArgs(workspaceRoot, arg1, arg2, arg3);
 
       p.intro(pc.cyan(t('testIntro', lang, contestId, taskLabel)));
 
@@ -378,12 +437,12 @@ program
   );
 
 program
-  .command('submit [task] [file]')
+  .command('submit [arg1] [arg2] [arg3]')
   .description(t('descSubmit', lang))
   .action(
-    handleAction(async (taskArg: string | undefined, fileArg: string | undefined) => {
+    handleAction(async (arg1: string | undefined, arg2: string | undefined, arg3: string | undefined) => {
       const workspaceRoot = findWorkspaceRoot();
-      const { resolvedTaskDir, resolvedFile, taskLabel, contestId } = resolveArgs(workspaceRoot, taskArg, fileArg);
+      const { resolvedTaskDir, resolvedFile, taskLabel, contestId } = resolveArgs(workspaceRoot, arg1, arg2, arg3);
 
       p.intro(pc.cyan(t('submitPreparing', lang, contestId, taskLabel)));
 
@@ -532,12 +591,26 @@ program
         process.exit(1);
       }
 
-      if (!targetLanguage) {
-        console.log(t('langCommandUsage', lang));
-        process.exit(0);
+      let selectedLang = targetLanguage;
+
+      if (!selectedLang) {
+        const choice = await p.select({
+          message: t('langSelectMessage', lang),
+          options: [
+            { value: 'en', label: 'English (en)' },
+            { value: 'ja', label: '日本語 (ja)' }
+          ]
+        });
+
+        if (p.isCancel(choice)) {
+          p.cancel(t('langCancelled', lang));
+          process.exit(0);
+        }
+
+        selectedLang = choice as string;
       }
 
-      const cleanLang = targetLanguage.trim().toLowerCase();
+      const cleanLang = selectedLang.trim().toLowerCase();
       if (cleanLang !== 'en' && cleanLang !== 'ja') {
         p.log.error(pc.red(t('langInvalid', lang)));
         process.exit(1);
@@ -551,4 +624,102 @@ program
     })
   );
 
+program
+  .command('add-lang [langName]')
+  .description(t('descAddLang', lang))
+  .action(
+    handleAction(async (langName: string | undefined) => {
+      const root = findWorkspaceRoot();
+      const config = loadConfig(root);
+
+      let targetLang = langName;
+      if (!targetLang) {
+        targetLang = await p.text({
+          message: t('addLangEnterName', lang),
+          validate: (val) => (!val.trim() ? t('addLangNameNotEmpty', lang) : undefined)
+        }) as string;
+
+        if (p.isCancel(targetLang)) {
+          p.cancel(t('addLangCancelled', lang));
+          process.exit(0);
+        }
+      }
+
+      targetLang = targetLang.trim().toLowerCase();
+
+      // Check if already exists
+      if (config.languages[targetLang]) {
+        throw new AtcError(t('addLangAlreadyExists', lang, targetLang));
+      }
+
+      const preset = LANGUAGE_PRESETS[targetLang];
+      let extension = '';
+      let build = '';
+      let run = '';
+      let template = '';
+
+      if (preset) {
+        extension = preset.config.extension;
+        build = preset.config.build;
+        run = preset.config.run;
+        template = preset.template;
+      } else {
+        // If not preset, prompt for parameters
+        const extInput = await p.text({
+          message: t('addLangEnterExtension', lang, targetLang),
+          placeholder: targetLang,
+          validate: (val) => (!val.trim() ? t('addLangExtNotEmpty', lang) : undefined)
+        }) as string;
+
+        if (p.isCancel(extInput)) {
+          p.cancel(t('addLangCancelled', lang));
+          process.exit(0);
+        }
+
+        const buildInput = await p.text({
+          message: t('addLangEnterBuildCmd', lang),
+          placeholder: 'e.g. g++ -O2 main.cpp (leave empty if not needed)'
+        }) as string;
+
+        if (p.isCancel(buildInput)) {
+          p.cancel(t('addLangCancelled', lang));
+          process.exit(0);
+        }
+
+        const runInput = await p.text({
+          message: t('addLangEnterRunCmd', lang),
+          placeholder: `e.g. python3 main.py or ./a.out`,
+          validate: (val) => (!val.trim() ? t('addLangRunCmdNotEmpty', lang) : undefined)
+        }) as string;
+
+        if (p.isCancel(runInput)) {
+          p.cancel(t('addLangCancelled', lang));
+          process.exit(0);
+        }
+
+        extension = extInput.trim();
+        build = buildInput.trim();
+        run = runInput.trim();
+        template = `// Solve the problem here\n`;
+      }
+
+      const s = p.spinner();
+      s.start(t('addLangSpinner', lang));
+
+      try {
+        addLanguage(root, targetLang, {
+          extension,
+          build,
+          run,
+          template
+        });
+      } catch (e: any) {
+        s.stop('Failed');
+        throw e;
+      }
+
+      s.stop(t('addLangSuccess', lang, targetLang));
+    })
+  );
+
 program.parse(process.argv);