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

package/dist/workspace/initializer.js

@@ -33,11 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LANGUAGE_PRESETS = exports.DEFAULT_PYTHON_TEMPLATE = exports.DEFAULT_CPP_TEMPLATE = void 0;
 exports.initWorkspace = initWorkspace;
+exports.addLanguage = addLanguage;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const config_store_1 = require("../config/config-store");
-const DEFAULT_CPP_TEMPLATE = `#include <bits/stdc++.h>
+const errors_1 = require("../utils/errors");
+exports.DEFAULT_CPP_TEMPLATE = `#include <bits/stdc++.h>
 
 using namespace std;
 
@@ -46,7 +49,7 @@ int main() {
     return 0;
 }
 `;
-const DEFAULT_PYTHON_TEMPLATE = `import sys
+exports.DEFAULT_PYTHON_TEMPLATE = `import sys
 
 def main():
     # Solve the problem here
@@ -55,6 +58,28 @@ def main():
 if __name__ == '__main__':
     main()
 `;
+exports.LANGUAGE_PRESETS = {
+    cpp: {
+        config: {
+            extension: 'cpp',
+            templateDir: 'templates/cpp',
+            build: 'g++ -O2 -std=gnu++20 -o a.out main.cpp',
+            run: './a.out'
+        },
+        template: exports.DEFAULT_CPP_TEMPLATE,
+        filename: 'main.cpp'
+    },
+    python: {
+        config: {
+            extension: 'py',
+            templateDir: 'templates/python',
+            build: '',
+            run: 'python3 main.py'
+        },
+        template: exports.DEFAULT_PYTHON_TEMPLATE,
+        filename: 'main.py'
+    }
+};
 function initWorkspace(targetDir = process.cwd(), defaultLanguage = 'cpp') {
     const atCoderCliDir = path.join(targetDir, '.atcoder-cli');
     let alreadyInitialized = false;
@@ -67,43 +92,103 @@ function initWorkspace(targetDir = process.cwd(), defaultLanguage = 'cpp') {
     // Create default config if it doesn't exist
     const configPath = path.join(atCoderCliDir, 'config.json');
     if (!fs.existsSync(configPath)) {
-        (0, config_store_1.saveConfig)(targetDir, {
-            ...config_store_1.DEFAULT_CONFIG,
-            defaultLanguage
-        });
+        const preset = exports.LANGUAGE_PRESETS[defaultLanguage] || {
+            config: {
+                extension: defaultLanguage,
+                templateDir: `templates/${defaultLanguage}`,
+                build: '',
+                run: ''
+            },
+            template: '',
+            filename: `main.${defaultLanguage}`
+        };
+        const initialConfig = {
+            defaultLanguage,
+            languages: {
+                [defaultLanguage]: preset.config
+            },
+            testDirName: 'tests',
+            contestDir: '',
+            lang: 'en',
+            extractProblemStatement: false,
+            problemLang: 'ja'
+        };
+        (0, config_store_1.saveConfig)(targetDir, initialConfig);
     }
     // Create default templates
     const templatesDir = path.join(atCoderCliDir, 'templates');
-    const cppTemplateDir = path.join(templatesDir, 'cpp');
-    const pythonTemplateDir = path.join(templatesDir, 'python');
-    if (!fs.existsSync(cppTemplateDir)) {
-        fs.mkdirSync(cppTemplateDir, { recursive: true });
-    }
-    const cppFile = path.join(cppTemplateDir, 'main.cpp');
-    if (!fs.existsSync(cppFile)) {
-        fs.writeFileSync(cppFile, DEFAULT_CPP_TEMPLATE, 'utf8');
-    }
-    if (!fs.existsSync(pythonTemplateDir)) {
-        fs.mkdirSync(pythonTemplateDir, { recursive: true });
+    const preset = exports.LANGUAGE_PRESETS[defaultLanguage] || {
+        config: {
+            extension: defaultLanguage,
+            templateDir: `templates/${defaultLanguage}`,
+            build: '',
+            run: ''
+        },
+        template: '',
+        filename: `main.${defaultLanguage}`
+    };
+    const langTemplateDir = path.join(templatesDir, defaultLanguage);
+    if (!fs.existsSync(langTemplateDir)) {
+        fs.mkdirSync(langTemplateDir, { recursive: true });
     }
-    const pythonFile = path.join(pythonTemplateDir, 'main.py');
-    if (!fs.existsSync(pythonFile)) {
-        fs.writeFileSync(pythonFile, DEFAULT_PYTHON_TEMPLATE, 'utf8');
+    const templateFile = path.join(langTemplateDir, preset.filename);
+    if (!fs.existsSync(templateFile)) {
+        fs.writeFileSync(templateFile, preset.template, 'utf8');
     }
     // Update or create .gitignore
     const gitignorePath = path.join(targetDir, '.gitignore');
-    const ignoreRule = '\n# AtCoder CLI Session\n.atcoder-cli/session.json\n';
+    const ignoreSession = '.atcoder-cli/session.json';
+    const ignoreProblem = 'problem.md';
     let gitignoreUpdated = false;
     if (fs.existsSync(gitignorePath)) {
-        const content = fs.readFileSync(gitignorePath, 'utf8');
-        if (!content.includes('.atcoder-cli/session.json')) {
-            fs.writeFileSync(gitignorePath, content + ignoreRule, 'utf8');
+        let content = fs.readFileSync(gitignorePath, 'utf8');
+        let updated = false;
+        if (!content.includes(ignoreSession)) {
+            content += (content.endsWith('\n') ? '' : '\n') + '\n# AtCoder CLI Session\n' + ignoreSession + '\n';
+            updated = true;
+        }
+        if (!content.includes(ignoreProblem)) {
+            content += (content.endsWith('\n') ? '' : '\n') + '\n# AtCoder problem statements\n' + ignoreProblem + '\n';
+            updated = true;
+        }
+        if (updated) {
+            fs.writeFileSync(gitignorePath, content, 'utf8');
             gitignoreUpdated = true;
         }
     }
     else {
-        fs.writeFileSync(gitignorePath, ignoreRule.trim() + '\n', 'utf8');
+        const defaultIgnore = `# AtCoder CLI Session\n${ignoreSession}\n\n# AtCoder problem statements\n${ignoreProblem}\n`;
+        fs.writeFileSync(gitignorePath, defaultIgnore, 'utf8');
         gitignoreUpdated = true;
     }
     return { alreadyInitialized, gitignoreUpdated };
 }
+function addLanguage(workspaceRoot, langName, options) {
+    const config = (0, config_store_1.loadConfig)(workspaceRoot);
+    const cleanLang = langName.trim().toLowerCase();
+    if (config.languages[cleanLang]) {
+        throw new errors_1.AtcError(`Language "${cleanLang}" is already configured.`);
+    }
+    const preset = exports.LANGUAGE_PRESETS[cleanLang];
+    const extension = options.extension || (preset ? preset.config.extension : cleanLang);
+    const build = options.build !== undefined ? options.build : (preset ? preset.config.build : '');
+    const run = options.run || (preset ? preset.config.run : '');
+    const template = options.template !== undefined ? options.template : (preset ? preset.template : '// Solve the problem here\n');
+    const templatesDir = path.join(workspaceRoot, '.atcoder-cli', 'templates');
+    const langTemplateDir = path.join(templatesDir, cleanLang);
+    if (!fs.existsSync(langTemplateDir)) {
+        fs.mkdirSync(langTemplateDir, { recursive: true });
+    }
+    const filename = preset ? preset.filename : `main.${extension}`;
+    const templateFile = path.join(langTemplateDir, filename);
+    if (!fs.existsSync(templateFile)) {
+        fs.writeFileSync(templateFile, template, 'utf8');
+    }
+    config.languages[cleanLang] = {
+        extension,
+        templateDir: `templates/${cleanLang}`,
+        build,
+        run
+    };
+    (0, config_store_1.saveConfig)(workspaceRoot, config);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "atcoder-workspace",
-  "version": "1.1.0-beta.1",
-  "description": "AtCoder All-in-One CLI (Local-first)",
+  "version": "1.1.0-beta.3",
+  "description": "AtCoder Workspace CLI (Local-first)",
   "main": "dist/cli.js",
   "bin": {
     "atc": "./dist/cli.js"
@@ -12,7 +12,7 @@
     "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"
+    "test-env:setup": "npm run build && npm pack && npm --prefix test install atcoder-workspace-1.1.0-beta.3.tgz"
   },
   "keywords": [
     "atcoder",

package/src/atcoder/new.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { setupTask } from './new';
+import { loadConfig, saveConfig, DEFAULT_CONFIG } from '../config/config-store';
+
+vi.mock('./client', () => {
+  return {
+    createAtCoderClient: vi.fn().mockReturnValue({
+      get: vi.fn().mockResolvedValue({
+        data: `
+          <span class="h2">A - Test Problem</span>
+          <div id="task-statement">
+            <span class="lang-en">
+              <p>English problem text.</p>
+              <h3>Sample Input 1</h3>
+              <pre>1 2</pre>
+              <h3>Sample Output 1</h3>
+              <pre>3</pre>
+            </span>
+            <span class="lang-ja">
+              <p>日本語の問題文。</p>
+              <h3>入力例 1</h3>
+              <pre>1 2</pre>
+              <h3>出力例 1</h3>
+              <pre>3</pre>
+            </span>
+          </div>
+        `
+      })
+    })
+  };
+});
+
+describe('setupTask problem extraction', () => {
+  const tempDir = path.join(__dirname, '../../test-temp-new');
+
+  beforeEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    // Create .atcoder-cli/templates/cpp/main.cpp to avoid errors
+    const templatesDir = path.join(tempDir, '.atcoder-cli', 'templates', 'cpp');
+    fs.mkdirSync(templatesDir, { recursive: true });
+    fs.writeFileSync(path.join(templatesDir, 'main.cpp'), '// template', 'utf8');
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should NOT extract problem statement by default (extractProblemStatement = false)', async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      extractProblemStatement: false
+    };
+    saveConfig(tempDir, config);
+
+    const task = {
+      id: 'abc300_a',
+      label: 'a',
+      title: 'A - Test Problem'
+    };
+
+    const res = await setupTask(tempDir, 'abc300', task);
+    expect(res.sampleCount).toBe(1);
+    expect(fs.existsSync(path.join(res.taskDir, 'problem.md'))).toBe(false);
+  });
+
+  it('should extract problem statement if extractProblemStatement = true', async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      extractProblemStatement: true,
+      problemLang: 'en' as const
+    };
+    saveConfig(tempDir, config);
+
+    const task = {
+      id: 'abc300_a',
+      label: 'a',
+      title: 'A - Test Problem'
+    };
+
+    const res = await setupTask(tempDir, 'abc300', task);
+    expect(res.sampleCount).toBe(1);
+
+    const problemMdPath = path.join(res.taskDir, 'problem.md');
+    expect(fs.existsSync(problemMdPath)).toBe(true);
+
+    const content = fs.readFileSync(problemMdPath, 'utf8');
+    expect(content).toContain('# A - Test Problem');
+    expect(content).toContain('English problem text.');
+    expect(content).toContain('### Sample Input 1');
+  });
+
+  it('should respect problemLang configuration specifically', async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      extractProblemStatement: true,
+      lang: 'en' as const,
+      problemLang: 'ja' as const
+    };
+    saveConfig(tempDir, config);
+
+    const task = {
+      id: 'abc300_a',
+      label: 'a',
+      title: 'A - Test Problem'
+    };
+
+    const res = await setupTask(tempDir, 'abc300', task);
+    const content = fs.readFileSync(path.join(res.taskDir, 'problem.md'), 'utf8');
+    expect(content).toContain('日本語の問題文。');
+    expect(content).not.toContain('English problem text.');
+  });
+
+  it('should fallback to lang configuration if problemLang is not specified', async () => {
+    const config = {
+      ...DEFAULT_CONFIG,
+      extractProblemStatement: true,
+      lang: 'ja' as const
+    };
+    saveConfig(tempDir, config);
+
+    const task = {
+      id: 'abc300_a',
+      label: 'a',
+      title: 'A - Test Problem'
+    };
+
+    const res = await setupTask(tempDir, 'abc300', task);
+    const content = fs.readFileSync(path.join(res.taskDir, 'problem.md'), 'utf8');
+    expect(content).toContain('日本語の問題文。');
+    expect(content).not.toContain('English problem text.');
+  });
+});

package/src/atcoder/new.ts

@@ -75,7 +75,8 @@ export async function setupTask(
     throw new AtcError(`Failed to fetch problem page for "${task.id}": ${err.message}`);
   }
 
-  const problemDetails = parseProblemPage(problemHtml);
+  const preferredProblemLang = config.problemLang || config.lang;
+  const problemDetails = parseProblemPage(problemHtml, preferredProblemLang);
 
   // Write sample cases to tests/ directory
   const testDirName = config.testDirName || 'tests';
@@ -98,6 +99,11 @@ export async function setupTask(
     fs.writeFileSync(path.join(testDir, `sample-${sample.index}.out`), sample.output, 'utf8');
   }
 
+  // Write problem statement if enabled in config
+  if (config.extractProblemStatement && problemDetails.problemStatementMd) {
+    fs.writeFileSync(path.join(taskDir, 'problem.md'), problemDetails.problemStatementMd, 'utf8');
+  }
+
   return {
     contestId,
     taskLabel: task.label,

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

@@ -64,5 +64,130 @@ describe('problem-page parser', () => {
       input: '10 20\n30\n',
       output: '60\n'
     });
+    expect(details.problemStatementMd).toContain('# A - ABC Problem');
+    expect(details.problemStatementMd).toContain('### Sample Input 1');
+  });
+
+  it('should parse Japanese problem statement with preferredLang ja', () => {
+    const details = parseProblemPage(MOCK_PROBLEM_HTML, 'ja');
+    expect(details.problemStatementMd).toContain('### 入力例 1');
+    expect(details.problemStatementMd).not.toContain('### Sample Input 1');
+  });
+
+  it('should preserve LaTeX formatting without escaping math expressions', () => {
+    const htmlWithLatex = `
+      <div id="task-statement">
+        <span class="lang-en">
+          <p>Given $N$ integers $A_1, A_2, \\dots, A_N$.</p>
+          <p>Find $$ \\sum_{i=1}^N A_i $$.</p>
+          <p>Constraints: $1 \\le N \\le 100$ and $A_i \\le 1000$ with some _underscores_ outside and grid cell # symbols.</p>
+        </span>
+      </div>
+    `;
+    const details = parseProblemPage(htmlWithLatex);
+    expect(details.problemStatementMd).toContain('Given $N$ integers $A_1, A_2, \\dots, A_N$.');
+    expect(details.problemStatementMd).toContain('Find $$\n\\sum_{i=1}^N A_i\n$$.');
+    expect(details.problemStatementMd).toContain('Constraints: $1 \\le N \\le 100$ and $A_i \\le 1000$');
+    expect(details.problemStatementMd).toContain('\\_underscores\\_');
+    expect(details.problemStatementMd).toContain('grid cell # symbols');
+  });
+
+  it('should translate \\( and \\[] delimiters to $ and $$, and keep content unescaped', () => {
+    const htmlWithLatex = `
+      <div id="task-statement">
+        <span class="lang-en">
+          <p>Given \\(T_i\\) for all \\(i\\).</p>
+          <p>Find \\[ \\sum_{i=1}^N T_i \\].</p>
+          <p>Constraints: \\(1 \\le N,Q \\le 1000\\).</p>
+        </span>
+      </div>
+    `;
+    const details = parseProblemPage(htmlWithLatex);
+    expect(details.problemStatementMd).toContain('Given $T_i$ for all $i$.');
+    expect(details.problemStatementMd).toContain('$$\n\\sum_{i=1}^N T_i\n$$');
+    expect(details.problemStatementMd).toContain('Constraints: $1 \\le N,Q \\le 1000$.');
+  });
+
+  it('should convert <var> and span.math tags to $ math blocks and keep content unescaped', () => {
+    const htmlWithVar = `
+      <div id="task-statement">
+        <span class="lang-en">
+          <p>Let <var>N</var> be the number of elements.</p>
+          <p>Constraints: <ul><li><var>1 \\le N \\le 300</var></li><li><span class="math">A_i \\le 1000</span></li></ul></p>
+        </span>
+      </div>
+    `;
+    const details = parseProblemPage(htmlWithVar);
+    expect(details.problemStatementMd).toContain('Let $N$ be the number of elements.');
+    expect(details.problemStatementMd).toContain('- $1 \\le N \\le 300$');
+    expect(details.problemStatementMd).toContain('- $A_i \\le 1000$');
+  });
+
+  it('should format <pre> blocks containing math or var tags as LaTeX array block', () => {
+    const htmlWithPre = `
+      <div id="task-statement">
+        <span class="lang-en">
+          <h3>Input</h3>
+          <pre>
+N M
+A_1 A_2 ... A_N
+:
+query_Q
+          </pre>
+        </span>
+      </div>
+    `;
+    // Add <var> tag to trigger math conversion
+    const htmlWithPreVar = htmlWithPre.replace('N M', '<var>N</var> <var>M</var>');
+    const details = parseProblemPage(htmlWithPreVar);
+    expect(details.problemStatementMd).toContain('\\begin{array}{l}');
+    expect(details.problemStatementMd).toContain('\\text{N M}');
+    expect(details.problemStatementMd).toContain('\\text{A}_1');
+    expect(details.problemStatementMd).toContain('\\dots');
+    expect(details.problemStatementMd).toContain('\\vdots');
+    expect(details.problemStatementMd).toContain('\\text{query}_Q');
+    expect(details.problemStatementMd).toContain('\\end{array}');
+  });
+
+  it('should keep standard pre blocks (sample cases) as markdown code blocks', () => {
+    const htmlWithStandardPre = `
+      <div id="task-statement">
+        <span class="lang-en">
+          <h3>Sample Input 1</h3>
+          <pre>3 125 175
+200 300 400</pre>
+        </span>
+      </div>
+    `;
+    const details = parseProblemPage(htmlWithStandardPre);
+    expect(details.problemStatementMd).toContain('\`\`\`\n3 125 175\n200 300 400\n\`\`\`');
+  });
+
+  it('should format pre blocks that already contain LaTeX \\text{} commands correctly', () => {
+    const htmlWithPreLaTeX = `
+      <div id="task-statement">
+        <span class="lang-en">
+          <h3>Input</h3>
+          <pre>
+Q
+\\text{query}_1
+\\text{query}_2
+:
+\\text{query}_Q
+          </pre>
+        </span>
+      </div>
+    `;
+    // Add <var> tag to trigger math conversion
+    const htmlWithPreVar = htmlWithPreLaTeX.replace('Q', '<var>Q</var>');
+    const details = parseProblemPage(htmlWithPreVar);
+    expect(details.problemStatementMd).toContain('\\begin{array}{l}');
+    expect(details.problemStatementMd).toContain('\\text{Q}');
+    expect(details.problemStatementMd).toContain('\\text{query}_1');
+    expect(details.problemStatementMd).toContain('\\text{query}_2');
+    expect(details.problemStatementMd).toContain('\\vdots');
+    expect(details.problemStatementMd).toContain('\\text{query}_Q');
+    expect(details.problemStatementMd).toContain('\\end{array}');
+    expect(details.problemStatementMd).not.toContain('\\text\\text');
   });
 });