opencode-leetcode-realworld 0.0.0-stage → 0.2.0

package/src/languages.ts

@@ -0,0 +1,358 @@
+import type { FileEntry, LanguageId } from "./types";
+
+export interface LanguageContext {
+  projectName: string;
+  functionName: string;
+  title: string;
+}
+
+export interface LanguageAdapter {
+  id: LanguageId;
+  name: string;
+  aliases: string[];
+  extension: string;
+  /** Human hint shown in the generated README. */
+  runtime: string;
+  starter(ctx: LanguageContext): string;
+  /** Extra project files (build manifests etc). */
+  files(ctx: LanguageContext): FileEntry[];
+  /** Command run once before the cases, or null when not needed. */
+  build(ctx: LanguageContext): string | null;
+  /** Command that runs the solution once, reading one JSON value on stdin. */
+  run(ctx: LanguageContext): string;
+}
+
+function packageJson(projectName: string, script: string): FileEntry {
+  return {
+    relative: "package.json",
+    contents:
+      JSON.stringify(
+        {
+          name: projectName,
+          version: "0.1.0",
+          private: true,
+          type: "module",
+          scripts: { test: script, check: script },
+        },
+        null,
+        2,
+      ) + "\n",
+  };
+}
+
+const adapters: Record<LanguageId, LanguageAdapter> = {
+  typescript: {
+    id: "typescript",
+    name: "TypeScript",
+    aliases: ["ts"],
+    extension: "ts",
+    runtime: "Node.js 22.6+ (uses `--experimental-strip-types`)",
+    starter: ({ functionName }) => `import { readFileSync } from "node:fs";
+
+function ${functionName}(payload: unknown): unknown {
+  throw new Error("Not implemented: ${functionName}");
+}
+
+const input = readFileSync(0, "utf8");
+const payload = JSON.parse(input.trim() === "" ? "null" : input);
+process.stdout.write(JSON.stringify(${functionName}(payload) ?? null));
+`,
+    files: (ctx) => [
+      packageJson(ctx.projectName, "node tests/runner.mjs"),
+      {
+        relative: "tsconfig.json",
+        contents:
+          JSON.stringify(
+            {
+              compilerOptions: {
+                target: "ES2022",
+                module: "ESNext",
+                moduleResolution: "bundler",
+                strict: true,
+                skipLibCheck: true,
+                types: ["node"],
+                noEmit: true,
+              },
+              include: ["src"],
+            },
+            null,
+            2,
+          ) + "\n",
+      },
+    ],
+    build: () => null,
+    run: ({ functionName }) => `node --experimental-strip-types src/solution.ts`,
+  },
+
+  javascript: {
+    id: "javascript",
+    name: "JavaScript",
+    aliases: ["js", "node"],
+    extension: "mjs",
+    runtime: "Node.js 18+",
+    starter: ({ functionName }) => `function ${functionName}(payload) {
+  throw new Error("Not implemented: ${functionName}");
+}
+
+const chunks = [];
+for await (const chunk of process.stdin) chunks.push(chunk);
+const input = Buffer.concat(chunks).toString("utf8");
+const payload = JSON.parse(input.trim() === "" ? "null" : input);
+process.stdout.write(JSON.stringify(${functionName}(payload) ?? null));
+`,
+    files: (ctx) => [packageJson(ctx.projectName, "node tests/runner.mjs")],
+    build: () => null,
+    run: () => "node src/solution.mjs",
+  },
+
+  python: {
+    id: "python",
+    name: "Python",
+    aliases: ["py", "python3"],
+    extension: "py",
+    runtime: "Python 3.8+",
+    starter: ({ functionName }) => `import json
+import sys
+
+
+def ${functionName}(payload):
+    raise NotImplementedError("Not implemented: ${functionName}")
+
+
+def main():
+    raw = sys.stdin.read().strip()
+    payload = json.loads(raw) if raw else None
+    print(json.dumps(${functionName}(payload)))
+
+
+if __name__ == "__main__":
+    main()
+`,
+    files: () => [],
+    build: () => null,
+    run: () => "python3 src/solution.py",
+  },
+
+  ruby: {
+    id: "ruby",
+    name: "Ruby",
+    aliases: ["rb"],
+    extension: "rb",
+    runtime: "Ruby 2.6+ (json is in the standard library)",
+    starter: ({ functionName }) => `require "json"
+
+def ${functionName}(payload)
+  raise NotImplementedError, "Not implemented: ${functionName}"
+end
+
+raw = $stdin.read.strip
+payload = raw.empty? ? nil : JSON.parse(raw)
+puts JSON.generate(${functionName}(payload))
+`,
+    files: () => [],
+    build: () => null,
+    run: () => "ruby src/solution.rb",
+  },
+
+  php: {
+    id: "php",
+    name: "PHP",
+    aliases: ["php8"],
+    extension: "php",
+    runtime: "PHP 7.4+",
+    starter: ({ functionName }) => `<?php
+
+function ${functionName}($payload) {
+    throw new Exception("Not implemented: ${functionName}");
+}
+
+$raw = trim(stream_get_contents(STDIN));
+$payload = $raw === "" ? null : json_decode($raw, true);
+echo json_encode(${functionName}($payload));
+`,
+    files: () => [],
+    build: () => null,
+    run: () => "php src/solution.php",
+  },
+
+  go: {
+    id: "go",
+    name: "Go",
+    aliases: ["golang"],
+    extension: "go",
+    runtime: "Go 1.18+ (uses `any`)",
+    starter: ({ functionName }) => `package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+)
+
+func ${functionName}(payload any) any {
+	panic("Not implemented: ${functionName}")
+}
+
+func main() {
+	raw, _ := io.ReadAll(os.Stdin)
+	var payload any
+	if len(raw) > 0 {
+		if err := json.Unmarshal(raw, &payload); err != nil {
+			panic(err)
+		}
+	}
+	out, err := json.Marshal(${functionName}(payload))
+	if err != nil {
+		panic(err)
+	}
+	fmt.Print(string(out))
+}
+`,
+    files: () => [
+      { relative: "go.mod", contents: "module practice\n\ngo 1.21\n" },
+    ],
+    build: () => "mkdir -p out && go build -o out/solution src/solution.go",
+    run: () => "./out/solution",
+  },
+
+  rust: {
+    id: "rust",
+    name: "Rust",
+    aliases: ["rs", "cargo"],
+    extension: "rs",
+    runtime: "Rust 1.70+ (uses serde_json)",
+    starter: ({ functionName }) => `use serde_json::Value;
+use std::io::Read;
+
+fn ${functionName}(payload: Value) -> Value {
+    let _ = payload;
+    panic!("Not implemented: ${functionName}");
+}
+
+fn main() {
+    let mut raw = String::new();
+    std::io::stdin().read_to_string(&mut raw).expect("read stdin");
+    let trimmed = raw.trim();
+    let payload: Value = if trimmed.is_empty() {
+        Value::Null
+    } else {
+        serde_json::from_str(trimmed).expect("parse json")
+    };
+    let result = ${functionName}(payload);
+    println!("{}", serde_json::to_string(&result).expect("serialize json"));
+}
+`,
+    files: (ctx) => [
+      {
+        relative: "Cargo.toml",
+        contents: `[package]
+name = "${ctx.projectName}"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde_json = "1"
+
+[[bin]]
+name = "solution"
+path = "src/solution.rs"
+`,
+      },
+    ],
+    build: () => "cargo build --quiet",
+    run: () => "./target/debug/solution",
+  },
+
+  csharp: {
+    id: "csharp",
+    name: "C#",
+    aliases: ["cs", "dotnet"],
+    extension: "cs",
+    runtime: ".NET 8 SDK",
+    starter: ({ functionName }) => `using System;
+using System.Text.Json.Nodes;
+
+class Program
+{
+    static JsonNode? ${functionName}(JsonNode? payload)
+    {
+        throw new NotImplementedException("Not implemented: ${functionName}");
+    }
+
+    static void Main()
+    {
+        var raw = Console.In.ReadToEnd().Trim();
+        var payload = raw.Length == 0 ? null : JsonNode.Parse(raw);
+        Console.Write(${functionName}(payload)?.ToJsonString() ?? "null");
+    }
+}
+`,
+    files: (ctx) => [
+      {
+        relative: `${ctx.projectName}.csproj`,
+        contents: `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AssemblyName>solution</AssemblyName>
+  </PropertyGroup>
+</Project>
+`,
+      },
+    ],
+    build: () => "dotnet build -c Release -o out --nologo -v quiet",
+    run: () => "dotnet out/solution.dll",
+  },
+
+  swift: {
+    id: "swift",
+    name: "Swift",
+    aliases: [],
+    extension: "swift",
+    runtime: "Swift 5.5+ (Foundation JSONSerialization)",
+    starter: ({ functionName }) => `import Foundation
+
+func ${functionName}(_ payload: Any) -> Any {
+    fatalError("Not implemented: ${functionName}")
+}
+
+let raw = String(data: FileHandle.standardInput.readDataToEndOfFile(), encoding: .utf8) ?? ""
+let data = raw.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+    ? Data("null".utf8)
+    : Data(raw.utf8)
+let payload = try! JSONSerialization.jsonObject(with: data, options: [.fragmentsAllowed])
+let result = ${functionName}(payload)
+let out = try! JSONSerialization.data(withJSONObject: result, options: [.fragmentsAllowed])
+FileHandle.standardOutput.write(out)
+`,
+    files: () => [],
+    build: () => "mkdir -p out && swiftc -O src/solution.swift -o out/solution",
+    run: () => "./out/solution",
+  },
+};
+
+export function getLanguage(id: LanguageId): LanguageAdapter {
+  return adapters[id];
+}
+
+export function languageIds(): LanguageId[] {
+  return Object.keys(adapters) as LanguageId[];
+}
+
+export function languageNames(): string {
+  return languageIds()
+    .map((id) => adapters[id].name)
+    .join(", ");
+}
+
+export function normalizeLanguage(input: string | undefined): LanguageId | undefined {
+  if (!input) return undefined;
+  const key = input.trim().toLowerCase();
+  for (const adapter of Object.values(adapters)) {
+    if (adapter.id === key || adapter.aliases.includes(key)) return adapter.id;
+  }
+  return undefined;
+}

package/src/leetcode.ts

@@ -0,0 +1,257 @@
+import type { CodeSnippet, NormalizedProblem } from "./types";
+
+const DEFAULT_BASE_URL = "https://leetcode-api-pied.vercel.app";
+
+export function apiBaseUrl(): string {
+  return (process.env.LEETCODE_API_BASE ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+}
+
+export interface FetchOptions {
+  /** How to choose the problem. Defaults to `random`. */
+  mode?: "random" | "specific" | "daily" | "filter";
+  /** Required when `mode` is `specific`. Accepts an id ("1") or a slug ("two-sum"). */
+  idOrSlug?: string;
+  difficulty?: "Easy" | "Medium" | "Hard";
+  tags?: string[];
+  signal?: AbortSignal;
+}
+
+async function getJson<T>(path: string, signal?: AbortSignal): Promise<T> {
+  const url = `${apiBaseUrl()}${path}`;
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      signal,
+      headers: { accept: "application/json", "user-agent": "opencode-leetcode-realworld" },
+    });
+  } catch (error) {
+    throw new Error(`Failed to reach LeetCode API at ${url}: ${(error as Error).message}`);
+  }
+  if (!res.ok) {
+    throw new Error(`LeetCode API responded ${res.status} ${res.statusText} for ${url}`);
+  }
+  return (await res.json()) as T;
+}
+
+function htmlToText(html: string): string {
+  if (!html) return "";
+  return html
+    .replace(/<sup>\s*([^<]*)\s*<\/sup>/gi, "^$1")
+    .replace(/<br\s*\/?>/gi, "\n")
+    .replace(/<\/(p|div|pre|li|ul|ol|h[1-6])>/gi, "\n")
+    .replace(/<[^>]+>/g, "")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&amp;/g, "&")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function normalizeSnippets(raw: unknown): CodeSnippet[] {
+  if (!Array.isArray(raw)) return [];
+  return raw
+    .map((entry) => {
+      const record = entry as Record<string, unknown>;
+      return {
+        lang: String(record.lang ?? record.langSlug ?? ""),
+        langSlug: String(record.langSlug ?? record.langsSlug ?? record.lang ?? ""),
+        code: String(record.code ?? ""),
+      };
+    })
+    .filter((snippet) => snippet.code.length > 0);
+}
+
+function normalizeTopics(raw: unknown): string[] {
+  if (!Array.isArray(raw)) return [];
+  return raw
+    .map((entry) => {
+      if (typeof entry === "string") return entry;
+      const record = entry as Record<string, unknown>;
+      return String(record.name ?? record.slug ?? "");
+    })
+    .filter((name) => name.length > 0);
+}
+
+function extractAcRate(raw: Record<string, unknown>): number | undefined {
+  if (typeof raw.acRate === "number") return raw.acRate;
+  if (typeof raw.stats === "string") {
+    try {
+      const parsed = JSON.parse(raw.stats) as { acRate?: string | number };
+      if (parsed.acRate !== undefined) return Number.parseFloat(String(parsed.acRate));
+    } catch {
+      /* ignore malformed stats */
+    }
+  }
+  return undefined;
+}
+
+export function normalizeProblem(
+  raw: Record<string, unknown>,
+  fallbackSlug?: string,
+): NormalizedProblem {
+  const nested = (raw.question ?? {}) as Record<string, unknown>;
+  const contentHtml = String(raw.content ?? nested.content ?? "");
+  const slug = String(
+    raw.titleSlug ?? raw.title_slug ?? raw.slug ?? nested.titleSlug ?? fallbackSlug ?? "",
+  );
+  const acRate = extractAcRate(raw);
+  return {
+    id: String(raw.questionId ?? nested.questionId ?? raw.id ?? ""),
+    frontendId: String(
+      raw.questionFrontendId ?? nested.questionFrontendId ?? raw.frontend_id ?? "",
+    ),
+    slug,
+    title: String(raw.title ?? nested.title ?? ""),
+    difficulty: String(raw.difficulty ?? nested.difficulty ?? "Unknown"),
+    url: String(raw.url ?? (slug ? `https://leetcode.com/problems/${slug}/` : "")),
+    topics: normalizeTopics(raw.topicTags ?? nested.topicTags),
+    contentHtml,
+    contentText: htmlToText(contentHtml),
+    hints: Array.isArray(raw.hints)
+      ? raw.hints.map((hint) => htmlToText(String(hint)))
+      : [],
+    snippets: normalizeSnippets(raw.codeSnippets ?? nested.codeSnippets),
+    acRate,
+    paidOnly: Boolean(raw.isPaidOnly ?? raw.paid_only ?? nested.isPaidOnly ?? false),
+    date: typeof raw.date === "string" ? raw.date : undefined,
+  };
+}
+
+function preferredSlug(idOrSlug: string | undefined): string | undefined {
+  if (!idOrSlug) return undefined;
+  return /^\d+$/.test(idOrSlug.trim()) ? undefined : idOrSlug.trim();
+}
+
+/**
+ * A problem is usable for practice generation only if it is free and actually
+ * carries a statement. The API returns `content: null` (with `isPaidOnly: true`)
+ * for premium problems.
+ */
+export function isUsableProblem(problem: NormalizedProblem): boolean {
+  return !problem.paidOnly && problem.contentText.trim().length > 40;
+}
+
+async function pickUsable(
+  make: () => Promise<NormalizedProblem>,
+  attempts = 6,
+): Promise<NormalizedProblem> {
+  let last: NormalizedProblem | undefined;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    const candidate = await make();
+    last = candidate;
+    if (isUsableProblem(candidate)) return candidate;
+  }
+  if (!last) throw new Error("LeetCode API returned no problems.");
+  return last;
+}
+
+export async function getProblem(idOrSlug: string, signal?: AbortSignal): Promise<NormalizedProblem> {
+  const raw = await getJson<Record<string, unknown>>(
+    `/problem/${encodeURIComponent(idOrSlug)}`,
+    signal,
+  );
+  return normalizeProblem(raw, preferredSlug(idOrSlug));
+}
+
+interface RandomProblem {
+  title_slug?: string;
+  titleSlug?: string;
+}
+
+export async function getRandom(
+  opts: { difficulty?: string; tags?: string[]; signal?: AbortSignal } = {},
+): Promise<NormalizedProblem> {
+  const params = new URLSearchParams();
+  if (opts.difficulty) params.set("difficulty", opts.difficulty);
+  if (opts.tags?.length) params.set("tags", opts.tags.join(","));
+  const query = params.toString();
+  const raw = await getJson<RandomProblem>(`/random${query ? `?${query}` : ""}`, opts.signal);
+  const slug = raw.title_slug ?? raw.titleSlug;
+  if (!slug) throw new Error("LeetCode API /random did not return a problem slug.");
+  return getProblem(slug, opts.signal);
+}
+
+export async function getDaily(signal?: AbortSignal): Promise<NormalizedProblem> {
+  const raw = await getJson<Record<string, unknown>>("/daily", signal);
+  return normalizeProblem(raw);
+}
+
+interface FilterResponse {
+  problems?: Array<Record<string, unknown>>;
+}
+
+export async function getFiltered(
+  opts: { difficulty?: string; tags?: string[]; limit?: number; signal?: AbortSignal } = {},
+): Promise<NormalizedProblem> {
+  const params = new URLSearchParams();
+  if (opts.difficulty) params.set("difficulty", opts.difficulty);
+  if (opts.tags?.length) params.set("tags", opts.tags.join(","));
+  params.set("limit", String(opts.limit ?? 20));
+  const raw = await getJson<FilterResponse>(`/problems/filter?${params.toString()}`, opts.signal);
+  const candidates = raw.problems ?? [];
+  if (candidates.length === 0) throw new Error("LeetCode API returned no problems for the given filter.");
+  const choice = candidates[Math.floor(Math.random() * candidates.length)] as Record<string, unknown>;
+  const slug = String(choice.title_slug ?? choice.titleSlug ?? "");
+  if (!slug) throw new Error("Filtered problem is missing a slug.");
+  return getProblem(slug, opts.signal);
+}
+
+export async function fetchProblem(options: FetchOptions = {}): Promise<NormalizedProblem> {
+  const mode = options.mode ?? "random";
+  switch (mode) {
+    case "specific": {
+      if (!options.idOrSlug) throw new Error("`idOrSlug` is required when mode is `specific`.");
+      return getProblem(options.idOrSlug, options.signal);
+    }
+    case "daily": {
+      const daily = await getDaily(options.signal);
+      if (isUsableProblem(daily)) return daily;
+      return pickUsable(() =>
+        getRandom({ difficulty: options.difficulty, tags: options.tags, signal: options.signal }),
+      );
+    }
+    case "filter":
+      return pickUsable(() =>
+        getFiltered({
+          difficulty: options.difficulty,
+          tags: options.tags,
+          signal: options.signal,
+        }),
+      );
+    case "random":
+    default:
+      return pickUsable(() =>
+        getRandom({ difficulty: options.difficulty, tags: options.tags, signal: options.signal }),
+      );
+  }
+}
+
+export interface TagInfo {
+  name: string;
+  slug: string;
+  problem_count: number;
+}
+
+export async function getTags(signal?: AbortSignal): Promise<TagInfo[]> {
+  return getJson<TagInfo[]>("/tags", signal);
+}
+
+/** Render a compact, agent-friendly view of the problem. Never write this to disk. */
+export function renderProblemForAgent(problem: NormalizedProblem): string {
+  const lines: string[] = [];
+  lines.push(`# ${problem.title} (${problem.difficulty})`);
+  if (problem.topics.length) lines.push(`Topics: ${problem.topics.join(", ")}`);
+  if (problem.acRate !== undefined) lines.push(`Acceptance: ${problem.acRate}%`);
+  lines.push("");
+  lines.push(problem.contentText || "(no statement returned)");
+  if (problem.hints.length) {
+    lines.push("");
+    lines.push("## Hints (do not reveal verbatim)");
+    for (const hint of problem.hints) lines.push(`- ${hint}`);
+  }
+  return lines.join("\n");
+}