cpscribe 0.1.0__tar.gz

cpscribe-0.1.0/.githooks/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -e
+ruff check src/ tests/
+ruff format --check src/ tests/

cpscribe-0.1.0/.github/CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# Contributing
+
+Open an issue before starting non-trivial work so we can discuss the approach.
+
+## Setup
+
+```sh
+git clone https://github.com/shravanngoswamii/cpscribe
+cd cpscribe
+pip install -e ".[dev]"
+git config core.hooksPath .githooks
+```
+
+## Workflow
+
+- One commit per logical change, concise message in casual tone
+- Run `ruff check src/ tests/` and `ruff format src/ tests/` before committing
+- Add or update tests for any changed behavior
+- Update `CHANGELOG.md` under `[Unreleased]`

cpscribe-0.1.0/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,23 @@
+name: Bug report
+description: Something is broken
+labels: [bug]
+body:
+  - type: input
+    id: version
+    attributes:
+      label: cpscribe version
+      placeholder: "0.1.0"
+    validations:
+      required: true
+  - type: textarea
+    id: description
+    attributes:
+      label: What happened?
+    validations:
+      required: true
+  - type: textarea
+    id: repro
+    attributes:
+      label: Steps to reproduce
+    validations:
+      required: true

cpscribe-0.1.0/.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,16 @@
+name: Feature request
+description: Suggest an improvement
+labels: [enhancement]
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: What problem does this solve?
+    validations:
+      required: true
+  - type: textarea
+    id: proposal
+    attributes:
+      label: Proposed solution
+    validations:
+      required: true

cpscribe-0.1.0/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,13 @@
+## What
+
+<!-- What does this PR change? -->
+
+## Why
+
+<!-- Why is this change needed? Link to an issue if applicable. -->
+
+## Checklist
+
+- [ ] Tests pass (`pytest -q`)
+- [ ] Lint passes (`ruff check src/ tests/`)
+- [ ] `CHANGELOG.md` updated

cpscribe-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,20 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[dev]" -q
+      - run: ruff check src/ tests/
+      - run: ruff format --check src/ tests/
+      - run: pytest -q

cpscribe-0.1.0/.github/workflows/release-trigger.yml

@@ -0,0 +1,75 @@
+name: Release trigger
+
+on:
+  issue_comment:
+    types:
+      - created
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  issues: write
+
+jobs:
+  trigger:
+    if: github.event_name == 'workflow_dispatch' || github.event.comment.body == '/release'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check write permission
+        if: github.event_name == 'issue_comment'
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const { data } = await github.rest.repos.getCollaboratorPermissionLevel({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              username: context.payload.comment.user.login,
+            });
+            if (!['admin', 'write'].includes(data.permission)) {
+              core.setFailed(`@${context.payload.comment.user.login} does not have write access`);
+            }
+
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.RELEASE_PAT }}
+
+      - name: Read version and verify tag is new
+        id: version
+        shell: bash
+        run: |
+          version="$(grep -m1 '^version = ' pyproject.toml | sed 's/version = "\(.*\)"/\1/')"
+          tag="v${version}"
+          if git rev-parse "$tag" >/dev/null 2>&1; then
+            echo "Tag $tag already exists -- bump the version in pyproject.toml first" >&2
+            exit 1
+          fi
+          echo "tag=${tag}" >> "$GITHUB_OUTPUT"
+
+      - name: Create and push tag
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          tag="${{ steps.version.outputs.tag }}"
+          msg="Release ${tag}"
+          if [[ "${{ github.event_name }}" == "issue_comment" ]]; then
+            msg="${msg}"$'\n'"issue=${{ github.event.issue.number }}"$'\n'"comment=${{ github.event.comment.id }}"
+          else
+            msg="${msg}"$'\n'"issue=1"
+          fi
+          git tag -a "${tag}" HEAD -m "${msg}"
+          git push origin "${tag}"
+
+      - name: React with rocket
+        if: success() && github.event_name == 'issue_comment'
+        uses: actions/github-script@v8
+        with:
+          script: |
+            await github.rest.reactions.createForIssueComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              comment_id: context.payload.comment.id,
+              content: 'rocket',
+            });

cpscribe-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,153 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+permissions:
+  contents: write
+  issues: write
+
+jobs:
+  validate:
+    name: Validate tag
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Read version
+        id: version
+        shell: bash
+        run: |
+          version="${GITHUB_REF_NAME#v}"
+          if [[ ! "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "Release tag must look like v1.2.3; got ${GITHUB_REF_NAME}" >&2
+            exit 1
+          fi
+          pkg_version="$(grep -m1 '^version = ' pyproject.toml | sed 's/version = "\(.*\)"/\1/')"
+          if [[ "$version" != "$pkg_version" ]]; then
+            echo "Tag v$version does not match pyproject.toml version $pkg_version" >&2
+            exit 1
+          fi
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+
+  quality:
+    name: Quality gate
+    needs: validate
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[dev]" -q
+      - run: ruff check src/ tests/
+      - run: ruff format --check src/ tests/
+      - run: pytest -q
+
+  publish:
+    name: Publish
+    needs:
+      - validate
+      - quality
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build wheel and sdist
+        run: |
+          pip install hatchling -q
+          python -m hatchling build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - name: Publish GitHub release
+        uses: softprops/action-gh-release@v3
+        with:
+          name: v${{ needs.validate.outputs.version }}
+          generate_release_notes: true
+          files: dist/*
+
+  notify:
+    name: Notify release comment
+    if: always() && needs.validate.result == 'success'
+    needs:
+      - validate
+      - publish
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Read trigger context from tag annotation
+        id: ctx
+        run: |
+          annotation=$(git tag -l "${{ github.ref_name }}" --format='%(contents)')
+          issue=$(printf '%s' "$annotation" | grep '^issue=' | cut -d= -f2)
+          comment=$(printf '%s' "$annotation" | grep '^comment=' | cut -d= -f2)
+          echo "issue=${issue}" >> "$GITHUB_OUTPUT"
+          echo "comment=${comment}" >> "$GITHUB_OUTPUT"
+
+      - name: Post release status to issue
+        if: steps.ctx.outputs.issue != ''
+        uses: actions/github-script@v8
+        env:
+          COMMENT_ID: ${{ steps.ctx.outputs.comment }}
+          ISSUE_NUM: ${{ steps.ctx.outputs.issue }}
+          PUBLISH_RESULT: ${{ needs.publish.result }}
+        with:
+          script: |
+            const tag     = context.ref.replace('refs/tags/', '');
+            const version = tag.replace(/^v/, '');
+            const repo    = `${context.repo.owner}/${context.repo.repo}`;
+
+            const status = r => ({ success: 'success', failure: 'FAILED', cancelled: 'cancelled', skipped: 'skipped' }[r] ?? r);
+            const publishResult = process.env.PUBLISH_RESULT;
+            const allGood = publishResult === 'success';
+
+            const headline = allGood
+              ? `**cpscribe ${tag} released**`
+              : `**cpscribe ${tag} -- some steps failed** -- [view run](https://github.com/${repo}/actions/runs/${context.runId})`;
+
+            const body = [
+              headline,
+              '',
+              '| Destination | Status |',
+              '| :-- | :-- |',
+              `| [GitHub Release](https://github.com/${repo}/releases/tag/${tag}) | ${status(publishResult)} |`,
+              `| [PyPI](https://pypi.org/project/cpscribe/${version}) | ${status(publishResult)} |`,
+            ].join('\n');
+
+            const commentId = process.env.COMMENT_ID ? parseInt(process.env.COMMENT_ID, 10) : null;
+            if (commentId) {
+              await github.rest.issues.updateComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                comment_id: commentId,
+                body: '/release\n\n---\n' + body,
+              });
+            } else {
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: parseInt(process.env.ISSUE_NUM, 10),
+                body,
+              });
+            }

cpscribe-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+*.egg-info/
+.ruff_cache/
+.pytest_cache/

cpscribe-0.1.0/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-06-25
+
+### Added
+
+- `cpscribe post` command: scrapes Codeforces problem page, generates a structured blog post
+- `cpscribe init` command: interactive config setup
+- Config file at `~/.config/cpscribe/config` with `CPSCRIBE_BLOG_ROOT` / `CPSCRIBE_AUTHOR` env overrides
+- URL extraction from `.cpp` file comments

cpscribe-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shravan Goswami
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cpscribe-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: cpscribe
+Version: 0.1.0
+Summary: Generate blog posts for competitive programming solutions
+Project-URL: Repository, https://github.com/shravanngoswamii/cpscribe
+Project-URL: Issues, https://github.com/shravanngoswamii/cpscribe/issues
+Author-email: Shravan Goswami <contact@shravangoswami.com>
+License: MIT
+License-File: LICENSE
+Keywords: blog,cli,codeforces,competitive-programming
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: cloudscraper>=1.2.71
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cpscribe
+
+Generate structured blog posts for Codeforces solutions.
+
+## Install
+
+```sh
+pipx install cpscribe
+```
+
+## Setup
+
+```sh
+cpscribe init
+```
+
+This creates `~/.config/cpscribe/config` with your blog root and author name.
+You can also set `CPSCRIBE_BLOG_ROOT` and `CPSCRIBE_AUTHOR` as environment variables.
+
+## Usage
+
+```sh
+# from a URL
+cpscribe post https://codeforces.com/contest/1903/problem/B
+
+# from a .cpp file with a URL in a comment
+cpscribe post B.cpp
+
+# with an explicit solution file
+cpscribe post https://codeforces.com/contest/1903/problem/B B.cpp
+```
+
+The generated post includes the full problem statement, sample I/O, and structured
+sections for your approach, complexity, solution, and takeaways.
+
+## Update
+
+```sh
+pipx upgrade cpscribe
+```
+
+## License
+
+MIT

cpscribe-0.1.0/README.md

@@ -0,0 +1,44 @@
+# cpscribe
+
+Generate structured blog posts for Codeforces solutions.
+
+## Install
+
+```sh
+pipx install cpscribe
+```
+
+## Setup
+
+```sh
+cpscribe init
+```
+
+This creates `~/.config/cpscribe/config` with your blog root and author name.
+You can also set `CPSCRIBE_BLOG_ROOT` and `CPSCRIBE_AUTHOR` as environment variables.
+
+## Usage
+
+```sh
+# from a URL
+cpscribe post https://codeforces.com/contest/1903/problem/B
+
+# from a .cpp file with a URL in a comment
+cpscribe post B.cpp
+
+# with an explicit solution file
+cpscribe post https://codeforces.com/contest/1903/problem/B B.cpp
+```
+
+The generated post includes the full problem statement, sample I/O, and structured
+sections for your approach, complexity, solution, and takeaways.
+
+## Update
+
+```sh
+pipx upgrade cpscribe
+```
+
+## License
+
+MIT

cpscribe-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cpscribe"
+version = "0.1.0"
+description = "Generate blog posts for competitive programming solutions"
+authors = [{ name = "Shravan Goswami", email = "contact@shravangoswami.com" }]
+license = { text = "MIT" }
+readme = "README.md"
+requires-python = ">=3.10"
+keywords = ["competitive-programming", "codeforces", "blog", "cli"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Utilities",
+]
+dependencies = [
+    "cloudscraper>=1.2.71",
+    "beautifulsoup4>=4.12.0",
+]
+
+[project.urls]
+Repository = "https://github.com/shravanngoswamii/cpscribe"
+Issues     = "https://github.com/shravanngoswamii/cpscribe/issues"
+
+[project.scripts]
+cpscribe = "cpscribe.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "ruff>=0.4.0"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cpscribe"]
+
+[tool.ruff]
+line-length = 100
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

cpscribe-0.1.0/src/cpscribe/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

cpscribe-0.1.0/src/cpscribe/__main__.py

@@ -0,0 +1,3 @@
+from cpscribe.cli import main
+
+main()

cpscribe-0.1.0/src/cpscribe/cli.py

@@ -0,0 +1,73 @@
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+from cpscribe import __version__, generator, scraper
+from cpscribe import config as cfg
+
+
+def cmd_init(_args) -> None:
+    cfg.init_interactive()
+
+
+def cmd_post(args) -> None:
+    conf = cfg.load()
+    if not conf["blog_root"]:
+        sys.exit("blog_root not configured -- run `cpscribe init` first")
+
+    if args.input.endswith(".cpp"):
+        cpp_file = Path(args.input)
+        if not cpp_file.exists():
+            sys.exit(f"file not found: {cpp_file}")
+        url = scraper.extract_url_from_cpp(cpp_file.read_text())
+        if not url:
+            sys.exit(f"no Codeforces URL found in {cpp_file}")
+    else:
+        url = args.input
+        cpp_file = Path(args.solution) if args.solution else None
+
+    contest_id, index = scraper.parse_url(url)
+
+    if cpp_file is None:
+        cpp_file = Path(f"{index}.cpp")
+    cpp_code = cpp_file.read_text().strip() if cpp_file.exists() else "// paste your solution here"
+
+    print(f"fetching CF{contest_id}{index}...")
+    problem = scraper.scrape(contest_id, index)
+    print(f"  {index}. {problem['name']}  {problem['rating']}  {problem['contest']}")
+    print(f"  {len(problem['samples'])} sample(s)  {problem['time_lim']}  {problem['mem_lim']}")
+
+    out_dir = Path(conf["blog_root"]) / contest_id
+    out_file = out_dir / f"{index}.md"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    if out_file.exists() and not args.force:
+        sys.exit(f"already exists: {out_file}  (--force to overwrite)")
+
+    out_file.write_text(generator.build(contest_id, index, problem, cpp_code, conf["author"]))
+    print(f"created: {out_file}")
+
+    editor = args.editor or conf["editor"]
+    if editor:
+        subprocess.Popen([editor, str(out_file)])
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="cpscribe",
+        description="Generate blog posts for competitive programming solutions",
+    )
+    parser.add_argument("-v", "--version", action="version", version=f"cpscribe {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    sub.add_parser("init", help="Configure cpscribe interactively")
+
+    post = sub.add_parser("post", help="Generate a blog post for a Codeforces problem")
+    post.add_argument("input", metavar="URL|file.cpp")
+    post.add_argument("solution", nargs="?", metavar="solution.cpp")
+    post.add_argument("--force", action="store_true", help="overwrite existing post")
+    post.add_argument("--editor", metavar="CMD")
+
+    args = parser.parse_args()
+    {"init": cmd_init, "post": cmd_post}[args.command](args)

cpscribe-0.1.0/src/cpscribe/config.py

@@ -0,0 +1,49 @@
+import os
+from configparser import ConfigParser
+from pathlib import Path
+
+CONFIG_DIR = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "cpscribe"
+CONFIG_FILE = CONFIG_DIR / "config"
+
+DEFAULTS: dict[str, str] = {
+    "blog_root": "",
+    "author": "Shravan Goswami",
+    "editor": "subl",
+}
+
+
+def load() -> dict[str, str]:
+    cfg = dict(DEFAULTS)
+    if CONFIG_FILE.exists():
+        parser = ConfigParser()
+        parser.read(CONFIG_FILE)
+        if "cpscribe" in parser:
+            cfg.update(parser["cpscribe"])
+    if v := os.environ.get("CPSCRIBE_BLOG_ROOT"):
+        cfg["blog_root"] = v
+    if v := os.environ.get("CPSCRIBE_AUTHOR"):
+        cfg["author"] = v
+    return cfg
+
+
+def save(cfg: dict[str, str]) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    parser = ConfigParser()
+    parser["cpscribe"] = cfg
+    with open(CONFIG_FILE, "w") as f:
+        parser.write(f)
+
+
+def init_interactive() -> None:
+    cfg = load()
+    print("cpscribe config\n")
+    blog_root = input(f"Blog root [{cfg['blog_root'] or 'required'}]: ").strip()
+    author = input(f"Author [{cfg['author']}]: ").strip()
+    editor = input(f"Editor [{cfg['editor']}]: ").strip()
+    cfg["blog_root"] = blog_root or cfg["blog_root"]
+    cfg["author"] = author or cfg["author"]
+    cfg["editor"] = editor or cfg["editor"]
+    if not cfg["blog_root"]:
+        raise SystemExit("blog_root is required")
+    save(cfg)
+    print(f"\nconfig saved to {CONFIG_FILE}")

cpscribe-0.1.0/src/cpscribe/generator.py

@@ -0,0 +1,94 @@
+import re
+from datetime import datetime, timezone
+
+
+def _slug(name: str) -> str:
+    return re.sub(r"[^A-Za-z0-9]+", "-", name).strip("-")
+
+
+def _fmt_examples(samples: list[tuple[str, str]]) -> str:
+    if not samples:
+        return "<!-- paste sample inputs/outputs here -->"
+    parts = []
+    for i, (inp, out) in enumerate(samples, 1):
+        label = f"**Example {i}**" if len(samples) > 1 else "**Example**"
+        parts.append(f"{label}\n\nInput:\n```\n{inp}\n```\nOutput:\n```\n{out}\n```")
+    return "\n\n".join(parts)
+
+
+def build(
+    contest_id: str,
+    index: str,
+    problem: dict,
+    cpp_code: str,
+    author: str,
+) -> str:
+    name = problem["name"]
+    rating = problem["rating"]
+    contest = problem["contest"]
+    note_block = f"\n\n### Note\n\n{problem['note']}" if problem.get("note") else ""
+    pub_dt = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    cf_url = f"https://codeforces.com/problemset/problem/{contest_id}/{index}"
+
+    return f"""\
+---
+author: {author}
+pubDatetime: {pub_dt}
+title: "{index}. {name} (CF{contest_id} {rating} RATED)"
+slug: cp/codeforces/{contest_id}/{index}
+tags: [CPP, Codeforces, CF{rating}]
+description: "{index}. {name}, {rating} RATED - {contest}"
+aliases:
+  - /writing/{contest_id}-{index}-{_slug(name)}
+---
+
+Problem Link: [{index}. {name}, {rating} RATED - {contest}]({cf_url})
+
+| Time Limit | Memory Limit |
+| --- | --- |
+| {problem["time_lim"]} | {problem["mem_lim"]} |
+
+## Problem Statement
+
+{problem["body"]}
+
+### Input
+
+{problem["input_spec"]}
+
+### Output
+
+{problem["output_spec"]}{note_block}
+
+## Examples
+
+{_fmt_examples(problem["samples"])}
+
+## My Understanding
+
+<!-- How do you model or restate this problem in your own words? -->
+
+## Key Observations
+
+- <!-- Observation 1 -->
+- <!-- Observation 2 -->
+
+## Approach
+
+<!-- Walk through your full solution strategy -->
+
+## Complexity
+
+- **Time:** $O()$
+- **Space:** $O()$
+
+## Solution
+
+```cpp
+{cpp_code}
+```
+
+## What I Learned
+
+<!-- Key takeaway, trick, or pattern from this problem -->
+"""

cpscribe-0.1.0/src/cpscribe/scraper.py

@@ -0,0 +1,118 @@
+import re
+import sys
+
+import cloudscraper
+from bs4 import BeautifulSoup, NavigableString
+
+CF_URL_RE = re.compile(
+    r"https://codeforces\.com/(?:contest|problemset/problem)/\d+/(?:problem/)?[A-Za-z]\d*"
+)
+
+
+def parse_url(url: str) -> tuple[str, str]:
+    m = re.search(r"/(?:contest|problemset/problem)/(\d+)/(?:problem/)?([A-Za-z]\d*)", url)
+    if not m:
+        sys.exit(f"could not parse URL: {url}")
+    return m.group(1), m.group(2).upper()
+
+
+def extract_url_from_cpp(text: str) -> str | None:
+    m = CF_URL_RE.search(text)
+    return m.group(0) if m else None
+
+
+def _fix_math(text: str) -> str:
+    return re.sub(r"\$\$\$(.+?)\$\$\$", r"$\1$", text, flags=re.DOTALL)
+
+
+def _node_to_md(node) -> str:
+    if isinstance(node, NavigableString):
+        return _fix_math(str(node))
+    tag = node.name
+    inner = "".join(_node_to_md(c) for c in node.children)
+    match tag:
+        case "p":
+            return inner.strip() + "\n\n"
+        case "strong" | "b":
+            return f"**{inner}**"
+        case "em" | "i":
+            return f"*{inner}*"
+        case "ul" | "ol":
+            return inner
+        case "li":
+            return f"- {inner.strip()}\n"
+        case "br":
+            return "\n"
+        case "div" if "section-title" in node.get("class", []):
+            return ""
+        case _:
+            return inner
+
+
+def _section_md(div) -> str:
+    if not div:
+        return ""
+    return "".join(_node_to_md(c) for c in div.children).strip()
+
+
+def _sample_pre(div) -> str:
+    pre = div.find("pre")
+    if not pre:
+        return ""
+    lines = pre.find_all("div", class_="test-example-line")
+    if lines:
+        return "\n".join(d.get_text() for d in lines).strip()
+    for br in pre.find_all("br"):
+        br.replace_with("\n")
+    return pre.get_text().strip()
+
+
+def scrape(contest_id: str, index: str) -> dict:
+    url = f"https://codeforces.com/problemset/problem/{contest_id}/{index}"
+    resp = cloudscraper.create_scraper().get(url, timeout=15)
+    if resp.status_code != 200:
+        sys.exit(f"problem page returned {resp.status_code}")
+
+    soup = BeautifulSoup(resp.content, "html.parser")
+    ps = soup.find("div", class_="problem-statement")
+
+    header = ps.find("div", class_="header")
+    title_div = header.find("div", class_="title") if header else None
+    name = re.sub(r"^[A-Z]\d*\.\s*", "", title_div.text.strip()) if title_div else "Unknown"
+
+    rating_tag = soup.find("span", class_="tag-box", title="Difficulty")
+    rating = rating_tag.text.strip().replace("*", "") if rating_tag else "Unrated"
+
+    rtable = soup.find("table", class_="rtable")
+    link = rtable.find("a") if rtable else None
+    contest = link.text.strip() if link else f"Codeforces Contest {contest_id}"
+
+    time_tag = soup.find("div", class_="time-limit")
+    mem_tag = soup.find("div", class_="memory-limit")
+    time_lim = time_tag.text.replace("time limit per test", "").strip() if time_tag else "2 seconds"
+    mem_lim = (
+        mem_tag.text.replace("memory limit per test", "").strip() if mem_tag else "256 megabytes"
+    )
+
+    body_div = next((c for c in ps.children if hasattr(c, "get") and not c.get("class")), None)
+
+    samples = []
+    for block in soup.find_all("div", class_="sample-test"):
+        for inp_div, out_div in zip(
+            block.find_all("div", class_="input"),
+            block.find_all("div", class_="output"),
+        ):
+            samples.append((_sample_pre(inp_div), _sample_pre(out_div)))
+
+    return {
+        "name": name,
+        "rating": rating,
+        "contest": contest,
+        "time_lim": time_lim,
+        "mem_lim": mem_lim,
+        "body": _section_md(body_div),
+        "input_spec": _section_md(ps.find("div", class_="input-specification")),
+        "output_spec": _section_md(ps.find("div", class_="output-specification")),
+        "note": _section_md(ps.find("div", class_="note")),
+        "samples": samples,
+    }

cpscribe-0.1.0/tests/conftest.py

@@ -0,0 +1,17 @@
+import pytest
+
+
+@pytest.fixture
+def problem() -> dict:
+    return {
+        "name": "Consecutive Sum Riddle",
+        "rating": "800",
+        "contest": "Codeforces Round 747 (Div. 2)",
+        "time_lim": "2 seconds",
+        "mem_lim": "256 megabytes",
+        "body": "Find $l$ and $r$ such that $l + \\ldots + r = n$.\n\n",
+        "input_spec": "A single integer $n$ ($1 \\le n \\le 10^{12}$).\n\n",
+        "output_spec": "Print two integers $l$ and $r$.\n\n",
+        "note": "",
+        "samples": [("3\n4\n5", "1 2\n1 3\n2 3")],
+    }

cpscribe-0.1.0/tests/test_generator.py

@@ -0,0 +1,37 @@
+from cpscribe import generator
+
+
+def test_frontmatter(problem):
+    md = generator.build("1594", "A", problem, "// code", "Test Author")
+    assert "pubDatetime:" in md
+    assert 'title: "A. Consecutive Sum Riddle (CF1594 800 RATED)"' in md
+    assert "slug: cp/codeforces/1594/A" in md
+    assert "tags: [CPP, Codeforces, CF800]" in md
+
+
+def test_single_alias(problem):
+    md = generator.build("1594", "A", problem, "", "Test Author")
+    assert md.count("  - /") == 1
+    assert "/writing/1594-A-Consecutive-Sum-Riddle" in md
+
+
+def test_sections_present(problem):
+    md = generator.build("1594", "A", problem, "", "Test Author")
+    for section in ("## Problem Statement", "## Examples", "## Approach", "## Solution"):
+        assert section in md
+    assert "## What I Learned" in md
+
+
+def test_solution_code_injected(problem):
+    code = "#include <bits/stdc++.h>\nint main(){}"
+    assert code in generator.build("1594", "A", problem, code, "Test Author")
+
+
+def test_note_omitted_when_empty(problem):
+    problem["note"] = ""
+    assert "### Note" not in generator.build("1594", "A", problem, "", "Test Author")
+
+
+def test_note_included_when_present(problem):
+    problem["note"] = "Constraints are tight."
+    assert "### Note" in generator.build("1594", "A", problem, "", "Test Author")

cpscribe-0.1.0/tests/test_scraper.py

@@ -0,0 +1,25 @@
+from cpscribe.scraper import extract_url_from_cpp, parse_url
+
+
+def test_parse_contest_url():
+    cid, idx = parse_url("https://codeforces.com/contest/1594/problem/A")
+    assert (cid, idx) == ("1594", "A")
+
+
+def test_parse_problemset_url():
+    cid, idx = parse_url("https://codeforces.com/problemset/problem/1903/B")
+    assert (cid, idx) == ("1903", "B")
+
+
+def test_extract_url_from_line_comment():
+    code = "// https://codeforces.com/contest/1594/problem/A\nint main(){}"
+    assert extract_url_from_cpp(code) == "https://codeforces.com/contest/1594/problem/A"
+
+
+def test_extract_url_from_block_comment():
+    code = "/* https://codeforces.com/problemset/problem/1903/B */\nint main(){}"
+    assert extract_url_from_cpp(code) == "https://codeforces.com/problemset/problem/1903/B"
+
+
+def test_extract_url_missing():
+    assert extract_url_from_cpp("#include <bits/stdc++.h>\nint main(){}") is None