opencode-leetcode-realworld 0.2.3 → 0.3.0

package/README.md

@@ -182,6 +182,43 @@ node tests/runner.mjs            # all cases
 node tests/runner.mjs --public   # visible cases only
 ```
 
+## Typed starters
+
+The starter file is generated from your test cases, so the input/output contract
+is explicit before you write any logic:
+
+- **Type-safe languages** (`typescript`, `go`, `rust`, `csharp`, `swift`) get real
+  type declarations inferred from the sample inputs/outputs — an interface /
+  struct / class per object, with nested objects and arrays typed too — plus a
+  typed function signature. Your editor autocompletes `payload.<field>`.
+- **Dynamic languages** (`javascript`, `python`, `ruby`, `php`) — and Swift when a
+  shape can't be expressed statically — get a commented input/output format with a
+  concrete example instead.
+
+Example (TypeScript), generated from input `{ "values": [1,2,3] }` -> output `[3,2,1]`:
+
+```ts
+interface Payload {
+  values: number[];
+}
+
+function solve(payload: Payload): number[] {
+  throw new Error("Not implemented: solve");
+}
+```
+
+Example (Python):
+
+```python
+# Input format:  { values: number[] }
+# Input example: {"values":[1,2,3]}
+# Output format: number[]
+# Output example: [3,2,1]
+
+def solve(payload):
+    raise NotImplementedError("Not implemented: solve")
+```
+
 ## Running from source
 
 For plugin development, clone the repo and open opencode inside it — files under
@@ -234,6 +271,7 @@ src/
   index.ts      plugin entry: tools, guard hooks, command registration
   leetcode.ts   API client + normalizer (handles endpoint shape differences)
   languages.ts  per-language adapters: starter, build, run commands
+  schema.ts     input/output schema inference + type generation
   patterns.ts   topic -> domain seeds, leak detection
   scaffold.ts   deterministic project writer (any supported language)
   guard.ts      protected-path detection

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-leetcode-realworld",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "OpenCode plugin that turns a LeetCode problem into a realistic software-engineering assignment, so you practice applying the underlying algorithm instead of solving the puzzle.",
   "type": "module",
   "license": "MIT",

package/src/languages.ts

@@ -1,9 +1,25 @@
+import {
+  buildTypes,
+  isFullyTyped,
+  isIdentifier,
+  isReserved,
+  pascal,
+  schemaSignature,
+  snake,
+  type SchemaNode,
+  type TypeDecl,
+  type TypeRef,
+} from "./schema";
 import type { FileEntry, LanguageId } from "./types";
 
 export interface LanguageContext {
   projectName: string;
   functionName: string;
   title: string;
+  input: SchemaNode;
+  output: SchemaNode;
+  inputExample: unknown;
+  outputExample: unknown;
 }
 
 export interface LanguageAdapter {
@@ -11,17 +27,32 @@ export interface LanguageAdapter {
   name: string;
   aliases: string[];
   extension: string;
-  /** Human hint shown in the generated README. */
   runtime: string;
+  /** True when the starter exposes static types for the payload/result. */
+  typed: boolean;
   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;
 }
 
+const INPUT_ROOT = "Payload";
+const OUTPUT_ROOT = "Output";
+
+function example(value: unknown): string {
+  return JSON.stringify(value);
+}
+
+/** Format comment for languages without static types (and as a fallback). */
+function formatComment(prefix: string, ctx: LanguageContext): string {
+  return [
+    `${prefix} Input format:  ${schemaSignature(ctx.input)}`,
+    `${prefix} Input example: ${example(ctx.inputExample)}`,
+    `${prefix} Output format: ${schemaSignature(ctx.output)}`,
+    `${prefix} Output example: ${example(ctx.outputExample)}`,
+  ].join("\n");
+}
+
 function packageJson(projectName: string, script: string): FileEntry {
   return {
     relative: "package.json",
@@ -40,6 +71,401 @@ function packageJson(projectName: string, script: string): FileEntry {
   };
 }
 
+/* ------------------------------------------------------------------ */
+/* TypeScript: named interfaces -> dot completion on `payload.`        */
+/* ------------------------------------------------------------------ */
+
+function tsRef(ref: TypeRef): string {
+  switch (ref.t) {
+    case "string":
+      return "string";
+    case "int":
+    case "double":
+      return "number";
+    case "bool":
+      return "boolean";
+    case "any":
+      return "unknown";
+    case "null":
+      return "null";
+    case "array": {
+      const inner = tsRef(ref.of);
+      return inner.includes(" ") ? `(${inner})[]` : `${inner}[]`;
+    }
+    case "named":
+      return ref.name;
+  }
+}
+
+function tsProp(name: string): string {
+  return isIdentifier(name) && !isReserved(name) ? name : JSON.stringify(name);
+}
+
+function tsDecl(decl: TypeDecl): string {
+  const fields = decl.fields
+    .map((field) => `  ${tsProp(field.name)}${field.optional ? "?" : ""}: ${tsRef(field.ref)};`)
+    .join("\n");
+  return `interface ${decl.name} {\n${fields}\n}`;
+}
+
+function typescriptStarter(ctx: LanguageContext): string {
+  const input = buildTypes(INPUT_ROOT, ctx.input);
+  const output = buildTypes(OUTPUT_ROOT, ctx.output);
+  const decls = [...input.decls, ...output.decls].map(tsDecl).join("\n\n");
+  const inputType = tsRef(input.root);
+  const outputType = tsRef(output.root);
+  const header = decls ? `${decls}\n\n` : "";
+  return `import { readFileSync } from "node:fs";
+
+${header}function ${ctx.functionName}(payload: ${inputType}): ${outputType} {
+  throw new Error("Not implemented: ${ctx.functionName}");
+}
+
+const input = readFileSync(0, "utf8");
+const payload = JSON.parse(input.trim() === "" ? "null" : input) as ${inputType};
+process.stdout.write(JSON.stringify(${ctx.functionName}(payload) ?? null));
+`;
+}
+
+/* ------------------------------------------------------------------ */
+/* Go: structs with json tags                                          */
+/* ------------------------------------------------------------------ */
+
+function goRef(ref: TypeRef): string {
+  switch (ref.t) {
+    case "string":
+      return "string";
+    case "int":
+      return "int";
+    case "double":
+      return "float64";
+    case "bool":
+      return "bool";
+    case "any":
+    case "null":
+      return "any";
+    case "array":
+      return "[]" + goRef(ref.of);
+    case "named":
+      return ref.name;
+  }
+}
+
+function goFieldName(name: string): string {
+  const value = pascal(name);
+  return value.length > 0 ? value : "Field";
+}
+
+function goDecl(decl: TypeDecl): string {
+  const fields = decl.fields
+    .map((field) => {
+      const tag = `json:"${field.name}${field.optional ? ",omitempty" : ""}"`;
+      return "\t" + goFieldName(field.name) + " " + goRef(field.ref) + " `" + tag + "`";
+    })
+    .join("\n");
+  return `type ${decl.name} struct {\n${fields}\n}`;
+}
+
+function goAliasOrDecls(
+  root: TypeRef,
+  decls: TypeDecl[],
+  rootName: string,
+): string {
+  const pieces = decls.map(goDecl);
+  if (root.t !== "named") pieces.unshift(`type ${rootName} = ${goRef(root)}`);
+  return pieces.join("\n\n");
+}
+
+function goStarter(ctx: LanguageContext): string {
+  const input = buildTypes(INPUT_ROOT, ctx.input);
+  const output = buildTypes(OUTPUT_ROOT, ctx.output);
+  const types = [
+    goAliasOrDecls(input.root, input.decls, INPUT_ROOT),
+    goAliasOrDecls(output.root, output.decls, OUTPUT_ROOT),
+  ].join("\n\n");
+  return `package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+)
+
+${types}
+
+func ${ctx.functionName}(payload ${INPUT_ROOT}) ${OUTPUT_ROOT} {
+	panic("Not implemented: ${ctx.functionName}")
+}
+
+func main() {
+	raw, _ := io.ReadAll(os.Stdin)
+	var payload ${INPUT_ROOT}
+	if len(raw) > 0 {
+		if err := json.Unmarshal(raw, &payload); err != nil {
+			panic(err)
+		}
+	}
+	out, err := json.Marshal(${ctx.functionName}(payload))
+	if err != nil {
+		panic(err)
+	}
+	fmt.Print(string(out))
+}
+`;
+}
+
+/* ------------------------------------------------------------------ */
+/* Rust: serde structs                                                 */
+/* ------------------------------------------------------------------ */
+
+function rustRef(ref: TypeRef): string {
+  switch (ref.t) {
+    case "string":
+      return "String";
+    case "int":
+      return "i64";
+    case "double":
+      return "f64";
+    case "bool":
+      return "bool";
+    case "any":
+    case "null":
+      return "serde_json::Value";
+    case "array":
+      return `Vec<${rustRef(ref.of)}>`;
+    case "named":
+      return ref.name;
+  }
+}
+
+function rustField(name: string): string {
+  let value = snake(name);
+  if (isReserved(value)) value = `${value}_`;
+  return value;
+}
+
+function rustDecl(decl: TypeDecl): string {
+  const fields = decl.fields
+    .map((field) => {
+      const ident = rustField(field.name);
+      const base = rustRef(field.ref);
+      const ty = field.optional ? `Option<${base}>` : base;
+      const attrs: string[] = [];
+      if (ident !== field.name) attrs.push(`    #[serde(rename = "${field.name}")]`);
+      if (field.optional) {
+        attrs.push('    #[serde(default, skip_serializing_if = "Option::is_none")]');
+      }
+      const attrText = attrs.length > 0 ? attrs.join("\n") + "\n" : "";
+      return `${attrText}    ${ident}: ${ty},`;
+    })
+    .join("\n");
+  return `#[derive(Serialize, Deserialize)]\nstruct ${decl.name} {\n${fields}\n}`;
+}
+
+function rustAliasOrDecls(root: TypeRef, decls: TypeDecl[], rootName: string): string {
+  const pieces = decls.map(rustDecl);
+  if (root.t !== "named") pieces.unshift(`type ${rootName} = ${rustRef(root)};`);
+  return pieces.join("\n\n");
+}
+
+function rustStarter(ctx: LanguageContext): string {
+  const input = buildTypes(INPUT_ROOT, ctx.input);
+  const output = buildTypes(OUTPUT_ROOT, ctx.output);
+  const types = [
+    rustAliasOrDecls(input.root, input.decls, INPUT_ROOT),
+    rustAliasOrDecls(output.root, output.decls, OUTPUT_ROOT),
+  ].join("\n\n");
+  return `use serde::{Deserialize, Serialize};
+use std::io::Read;
+
+${types}
+
+fn ${ctx.functionName}(payload: ${INPUT_ROOT}) -> ${OUTPUT_ROOT} {
+    let _ = &payload;
+    panic!("Not implemented: ${ctx.functionName}");
+}
+
+fn main() {
+    let mut raw = String::new();
+    std::io::stdin().read_to_string(&mut raw).expect("read stdin");
+    let trimmed = raw.trim();
+    let source = if trimmed.is_empty() { "null" } else { trimmed };
+    let payload: ${INPUT_ROOT} = serde_json::from_str(source).expect("parse json");
+    let result = ${ctx.functionName}(payload);
+    println!("{}", serde_json::to_string(&result).expect("serialize json"));
+}
+`;
+}
+
+/* ------------------------------------------------------------------ */
+/* C#: classes with JsonPropertyName                                   */
+/* ------------------------------------------------------------------ */
+
+function csRef(ref: TypeRef): string {
+  switch (ref.t) {
+    case "string":
+      return "string";
+    case "int":
+      return "long";
+    case "double":
+      return "double";
+    case "bool":
+      return "bool";
+    case "any":
+    case "null":
+      return "JsonNode";
+    case "array":
+      return `List<${csRef(ref.of)}>`;
+    case "named":
+      return ref.name;
+  }
+}
+
+function csFieldName(name: string): string {
+  const value = pascal(name);
+  return value.length > 0 ? value : "Field";
+}
+
+function csDecl(decl: TypeDecl): string {
+  const props = decl.fields
+    .map((field) => {
+      return `    [JsonPropertyName("${field.name}")]\n    public ${csRef(field.ref)} ${csFieldName(
+        field.name,
+      )} { get; set; }`;
+    })
+    .join("\n\n");
+  return `class ${decl.name}\n{\n${props}\n}`;
+}
+
+function csStarter(ctx: LanguageContext): string {
+  const input = buildTypes(INPUT_ROOT, ctx.input);
+  const output = buildTypes(OUTPUT_ROOT, ctx.output);
+  const decls = [...input.decls, ...output.decls].map(csDecl).join("\n\n");
+  const inputType = csRef(input.root);
+  const outputType = csRef(output.root);
+  return `using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+
+${decls}
+
+class Program
+{
+    static ${outputType} ${ctx.functionName}(${inputType} payload)
+    {
+        throw new NotImplementedException("Not implemented: ${ctx.functionName}");
+    }
+
+    static void Main()
+    {
+        var raw = Console.In.ReadToEnd().Trim();
+        var payload = JsonSerializer.Deserialize<${inputType}>(raw);
+        Console.Write(JsonSerializer.Serialize(${ctx.functionName}(payload)));
+    }
+}
+`;
+}
+
+/* ------------------------------------------------------------------ */
+/* Swift: Codable structs (only when the schema is fully typed)        */
+/* ------------------------------------------------------------------ */
+
+function swiftRef(ref: TypeRef): string {
+  switch (ref.t) {
+    case "string":
+      return "String";
+    case "int":
+      return "Int";
+    case "double":
+      return "Double";
+    case "bool":
+      return "Bool";
+    case "array":
+      return `[${swiftRef(ref.of)}]`;
+    case "named":
+      return ref.name;
+    default:
+      return "Any";
+  }
+}
+
+function swiftFieldName(name: string): string {
+  if (isIdentifier(name) && !isReserved(name)) return name;
+  let value = snake(name);
+  if (isReserved(value)) value = `${value}_`;
+  return isIdentifier(value) ? value : "field";
+}
+
+function swiftDecl(decl: TypeDecl): string {
+  const fields: string[] = [];
+  const codingKeys: string[] = [];
+  let needsKeys = false;
+  for (const field of decl.fields) {
+    const prop = swiftFieldName(field.name);
+    const base = swiftRef(field.ref);
+    const ty = field.optional ? `${base}?` : base;
+    fields.push(`    let ${prop}: ${ty}`);
+    if (prop !== field.name) {
+      needsKeys = true;
+      codingKeys.push(`        case ${prop} = "${field.name}"`);
+    } else {
+      codingKeys.push(`        case ${prop}`);
+    }
+  }
+  const keys = needsKeys ? `\n\n    enum CodingKeys: String, CodingKey {\n${codingKeys.join("\n")}\n    }` : "";
+  return `struct ${decl.name}: Codable {\n${fields.join("\n")}${keys}\n}`;
+}
+
+function swiftAliasOrDecls(root: TypeRef, decls: TypeDecl[], rootName: string): string {
+  const pieces = decls.map(swiftDecl);
+  if (root.t !== "named") pieces.unshift(`typealias ${rootName} = ${swiftRef(root)}`);
+  return pieces.join("\n\n");
+}
+
+function swiftStarter(ctx: LanguageContext): string {
+  const input = buildTypes(INPUT_ROOT, ctx.input);
+  const output = buildTypes(OUTPUT_ROOT, ctx.output);
+  const types = [
+    swiftAliasOrDecls(input.root, input.decls, INPUT_ROOT),
+    swiftAliasOrDecls(output.root, output.decls, OUTPUT_ROOT),
+  ].join("\n\n");
+  return `import Foundation
+
+${types}
+
+func ${ctx.functionName}(_ payload: ${INPUT_ROOT}) -> ${OUTPUT_ROOT} {
+    fatalError("Not implemented: ${ctx.functionName}")
+}
+
+let raw = String(data: FileHandle.standardInput.readDataToEndOfFile(), encoding: .utf8) ?? ""
+let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+let data = trimmed.isEmpty ? Data("null".utf8) : Data(raw.utf8)
+let payload = try! JSONDecoder().decode(${INPUT_ROOT}.self, from: data)
+let out = try! JSONEncoder().encode(${ctx.functionName}(payload))
+FileHandle.standardOutput.write(out)
+`;
+}
+
+function swiftFallbackStarter(ctx: LanguageContext): string {
+  return `import Foundation
+
+${formatComment("//", ctx)}
+
+func ${ctx.functionName}(_ payload: Any) -> Any {
+    fatalError("Not implemented: ${ctx.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 out = try! JSONSerialization.data(withJSONObject: ${ctx.functionName}(payload), options: [.fragmentsAllowed])
+FileHandle.standardOutput.write(out)
+`;
+}
+
 const adapters: Record<LanguageId, LanguageAdapter> = {
   typescript: {
     id: "typescript",
@@ -47,16 +473,8 @@ const adapters: Record<LanguageId, LanguageAdapter> = {
     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));
-`,
+    typed: true,
+    starter: typescriptStarter,
     files: (ctx) => [
       packageJson(ctx.projectName, "node tests/runner.mjs"),
       {
@@ -81,7 +499,7 @@ process.stdout.write(JSON.stringify(${functionName}(payload) ?? null));
       },
     ],
     build: () => null,
-    run: ({ functionName }) => `node --experimental-strip-types src/solution.ts`,
+    run: () => "node --experimental-strip-types src/solution.ts",
   },
 
   javascript: {
@@ -90,15 +508,18 @@ process.stdout.write(JSON.stringify(${functionName}(payload) ?? null));
     aliases: ["js", "node"],
     extension: "mjs",
     runtime: "Node.js 18+",
-    starter: ({ functionName }) => `function ${functionName}(payload) {
-  throw new Error("Not implemented: ${functionName}");
+    typed: false,
+    starter: (ctx) => `${formatComment("//", ctx)}
+
+function ${ctx.functionName}(payload) {
+  throw new Error("Not implemented: ${ctx.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));
+process.stdout.write(JSON.stringify(${ctx.functionName}(payload) ?? null));
 `,
     files: (ctx) => [packageJson(ctx.projectName, "node tests/runner.mjs")],
     build: () => null,
@@ -111,18 +532,21 @@ process.stdout.write(JSON.stringify(${functionName}(payload) ?? null));
     aliases: ["py", "python3"],
     extension: "py",
     runtime: "Python 3.8+",
-    starter: ({ functionName }) => `import json
+    typed: false,
+    starter: (ctx) => `${formatComment("#", ctx)}
+
+import json
 import sys
 
 
-def ${functionName}(payload):
-    raise NotImplementedError("Not implemented: ${functionName}")
+def ${ctx.functionName}(payload):
+    raise NotImplementedError("Not implemented: ${ctx.functionName}")
 
 
 def main():
     raw = sys.stdin.read().strip()
     payload = json.loads(raw) if raw else None
-    print(json.dumps(${functionName}(payload)))
+    print(json.dumps(${ctx.functionName}(payload)))
 
 
 if __name__ == "__main__":
@@ -139,15 +563,18 @@ if __name__ == "__main__":
     aliases: ["rb"],
     extension: "rb",
     runtime: "Ruby 2.6+ (json is in the standard library)",
-    starter: ({ functionName }) => `require "json"
+    typed: false,
+    starter: (ctx) => `${formatComment("#", ctx)}
+
+require "json"
 
-def ${functionName}(payload)
-  raise NotImplementedError, "Not implemented: ${functionName}"
+def ${ctx.functionName}(payload)
+  raise NotImplementedError, "Not implemented: ${ctx.functionName}"
 end
 
 raw = $stdin.read.strip
 payload = raw.empty? ? nil : JSON.parse(raw)
-puts JSON.generate(${functionName}(payload))
+puts JSON.generate(${ctx.functionName}(payload))
 `,
     files: () => [],
     build: () => null,
@@ -160,15 +587,17 @@ puts JSON.generate(${functionName}(payload))
     aliases: ["php8"],
     extension: "php",
     runtime: "PHP 7.4+",
-    starter: ({ functionName }) => `<?php
+    typed: false,
+    starter: (ctx) => `<?php
+${formatComment("//", ctx)}
 
-function ${functionName}($payload) {
-    throw new Exception("Not implemented: ${functionName}");
+function ${ctx.functionName}($payload) {
+    throw new Exception("Not implemented: ${ctx.functionName}");
 }
 
 $raw = trim(stream_get_contents(STDIN));
 $payload = $raw === "" ? null : json_decode($raw, true);
-echo json_encode(${functionName}($payload));
+echo json_encode(${ctx.functionName}($payload));
 `,
     files: () => [],
     build: () => null,
@@ -180,38 +609,10 @@ echo json_encode(${functionName}($payload));
     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" },
-    ],
+    runtime: "Go 1.18+ (`any`)",
+    typed: true,
+    starter: goStarter,
+    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",
   },
@@ -221,28 +622,9 @@ func main() {
     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"));
-}
-`,
+    runtime: "Rust 1.70+ (serde + serde_json)",
+    typed: true,
+    starter: rustStarter,
     files: (ctx) => [
       {
         relative: "Cargo.toml",
@@ -252,6 +634,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 
 [[bin]]
@@ -270,24 +653,8 @@ path = "src/solution.rs"
     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");
-    }
-}
-`,
+    typed: true,
+    starter: csStarter,
     files: (ctx) => [
       {
         relative: `${ctx.projectName}.csproj`,
@@ -296,7 +663,7 @@ class Program
     <OutputType>Exe</OutputType>
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
+    <Nullable>disable</Nullable>
     <AssemblyName>solution</AssemblyName>
   </PropertyGroup>
 </Project>
@@ -312,22 +679,9 @@ class Program
     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)
-`,
+    runtime: "Swift 5.5+",
+    typed: true,
+    starter: (ctx) => (isFullyTyped(ctx.input) && isFullyTyped(ctx.output) ? swiftStarter(ctx) : swiftFallbackStarter(ctx)),
     files: () => [],
     build: () => "mkdir -p out && swiftc -O src/solution.swift -o out/solution",
     run: () => "./out/solution",

package/src/prompt.ts

@@ -88,7 +88,12 @@ Call the tool \`leetcode_scaffold\` with a spec containing:
   "javascript", "python", "ruby", "php", "go", "rust", "csharp", "swift")
 - requirements: concrete, testable bullet points
 - edgeCases: tricky situations the solution must handle
-- starterCode: optional; otherwise a TODO stub is generated
+- Do NOT provide starterCode. Omit it so the plugin can generate a starter that
+  reflects the real types: type-safe languages get typed interfaces/structs and a
+  typed signature; dynamic languages get a documented input/output format comment.
+  The generated types are inferred from your publicTests/hiddenTests, so make the
+  first few cases representative of the full input shape (and vary fields so
+  optional ones are detected).
 - publicTests: 5-8 visible cases that illustrate the contract
 - hiddenTests: 6-12 acceptance cases, including edge cases, boundary values, an
   empty/degenerate input, and at least one larger input

package/src/scaffold.ts

@@ -1,7 +1,8 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { getLanguage, normalizeLanguage } from "./languages";
+import { getLanguage, normalizeLanguage, type LanguageContext } from "./languages";
 import { assertNoLeak } from "./patterns";
+import { schemaFromSamples } from "./schema";
 import type { FileEntry, LanguageId, ScaffoldResult, ScaffoldSpec, TestCase } from "./types";
 
 function kebab(input: string): string {
@@ -251,7 +252,17 @@ function casesFile(cases: TestCase[]): string {
 
 function buildFiles(spec: ScaffoldSpec, names: ResolvedNames, language: LanguageId): FileEntry[] {
   const adapter = getLanguage(language);
-  const ctx = { projectName: names.projectName, functionName: names.functionName, title: names.title };
+  const cases = [...(spec.publicTests ?? []), ...(spec.hiddenTests ?? [])];
+  const first = cases[0];
+  const ctx: LanguageContext = {
+    projectName: names.projectName,
+    functionName: names.functionName,
+    title: names.title,
+    input: schemaFromSamples(cases.map((test) => test.input)),
+    output: schemaFromSamples(cases.map((test) => test.expected)),
+    inputExample: first?.input ?? null,
+    outputExample: first?.expected ?? null,
+  };
 
   const files: FileEntry[] = [
     { relative: "README.md", contents: readmeFor(names, spec, language) },

package/src/schema.ts

@@ -0,0 +1,226 @@
+/**
+ * Infers a small structural schema from the sample test cases so the generated
+ * starter files can carry real types (type-safe languages) or a documented
+ * format (dynamic languages).
+ *
+ * This is intentionally schema-light: it only needs enough fidelity to describe
+ * JSON input/output shapes (objects, arrays, primitives, optionality).
+ */
+
+export type SchemaNode =
+  | { kind: "string" }
+  | { kind: "number"; integer: boolean }
+  | { kind: "boolean" }
+  | { kind: "null" }
+  | { kind: "unknown" }
+  | { kind: "array"; element: SchemaNode }
+  | { kind: "object"; fields: FieldSchema[] };
+
+export interface FieldSchema {
+  name: string;
+  schema: SchemaNode;
+  optional: boolean;
+}
+
+export function inferSchema(value: unknown): SchemaNode {
+  if (value === null || value === undefined) return { kind: "null" };
+  if (Array.isArray(value)) {
+    return { kind: "array", element: mergeMany(value.map(inferSchema)) };
+  }
+  switch (typeof value) {
+    case "string":
+      return { kind: "string" };
+    case "boolean":
+      return { kind: "boolean" };
+    case "number":
+      return { kind: "number", integer: Number.isInteger(value) };
+    case "object": {
+      const fields = Object.entries(value as Record<string, unknown>).map(([name, entry]) => ({
+        name,
+        schema: inferSchema(entry),
+        optional: false,
+      }));
+      return { kind: "object", fields };
+    }
+    default:
+      return { kind: "unknown" };
+  }
+}
+
+export function mergeSchemas(a: SchemaNode, b: SchemaNode): SchemaNode {
+  if (a.kind === "unknown") return b;
+  if (b.kind === "unknown") return a;
+  if (a.kind === "null") return b;
+  if (b.kind === "null") return a;
+
+  if (a.kind === "object" && b.kind === "object") {
+    const names = new Set([...a.fields.map((f) => f.name), ...b.fields.map((f) => f.name)]);
+    const fields: FieldSchema[] = [];
+    for (const name of names) {
+      const left = a.fields.find((f) => f.name === name);
+      const right = b.fields.find((f) => f.name === name);
+      if (left && right) {
+        fields.push({
+          name,
+          schema: mergeSchemas(left.schema, right.schema),
+          optional: left.optional && right.optional,
+        });
+      } else {
+        const only = (left ?? right)!;
+        fields.push({ name, schema: only.schema, optional: true });
+      }
+    }
+    return { kind: "object", fields };
+  }
+
+  if (a.kind === "array" && b.kind === "array") {
+    return { kind: "array", element: mergeSchemas(a.element, b.element) };
+  }
+
+  if (a.kind === "number" && b.kind === "number") {
+    return { kind: "number", integer: a.integer && b.integer };
+  }
+  if (a.kind === b.kind) return a;
+  return { kind: "unknown" };
+}
+
+function mergeMany(nodes: SchemaNode[]): SchemaNode {
+  if (nodes.length === 0) return { kind: "unknown" };
+  return nodes.reduce((acc, node) => mergeSchemas(acc, node));
+}
+
+export function schemaFromSamples(values: unknown[]): SchemaNode {
+  return mergeMany(values.map(inferSchema));
+}
+
+/** True when the schema contains only types representable as static types. */
+export function isFullyTyped(node: SchemaNode): boolean {
+  switch (node.kind) {
+    case "unknown":
+    case "null":
+      return false;
+    case "array":
+      return isFullyTyped(node.element);
+    case "object":
+      return node.fields.every((field) => isFullyTyped(field.schema));
+    default:
+      return true;
+  }
+}
+
+/** Human-readable signature, e.g. `{ amounts: number[]; target: number }`. */
+export function schemaSignature(node: SchemaNode): string {
+  switch (node.kind) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "unknown":
+      return "any";
+    case "array": {
+      const inner = schemaSignature(node.element);
+      return inner.includes(" ") ? `(${inner})[]` : `${inner}[]`;
+    }
+    case "object":
+      if (node.fields.length === 0) return "{}";
+      return `{ ${node.fields
+        .map((field) => `${field.name}${field.optional ? "?" : ""}: ${schemaSignature(field.schema)}`)
+        .join("; ")} }`;
+  }
+}
+
+export type TypeRef =
+  | { t: "string" }
+  | { t: "int" }
+  | { t: "double" }
+  | { t: "bool" }
+  | { t: "any" }
+  | { t: "null" }
+  | { t: "array"; of: TypeRef }
+  | { t: "named"; name: string };
+
+export interface TypeDecl {
+  name: string;
+  fields: { name: string; ref: TypeRef; optional: boolean }[];
+}
+
+export function buildTypes(
+  rootName: string,
+  node: SchemaNode,
+): { root: TypeRef; decls: TypeDecl[] } {
+  const decls: TypeDecl[] = [];
+  const root = refFor(rootName, node, decls);
+  return { root, decls };
+}
+
+function refFor(name: string, node: SchemaNode, decls: TypeDecl[]): TypeRef {
+  switch (node.kind) {
+    case "object": {
+      const decl: TypeDecl = { name, fields: [] };
+      decls.push(decl);
+      for (const field of node.fields) {
+        decl.fields.push({
+          name: field.name,
+          optional: field.optional,
+          ref: refFor(`${name}${pascal(field.name)}`, field.schema, decls),
+        });
+      }
+      return { t: "named", name };
+    }
+    case "array":
+      return { t: "array", of: refFor(`${name}Item`, node.element, decls) };
+    case "string":
+      return { t: "string" };
+    case "boolean":
+      return { t: "bool" };
+    case "null":
+      return { t: "null" };
+    case "unknown":
+      return { t: "any" };
+    case "number":
+      return { t: node.integer ? "int" : "double" };
+  }
+}
+
+export function pascal(input: string): string {
+  const parts = input
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .split(/[^a-zA-Z0-9]+/)
+    .filter(Boolean);
+  return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+
+export function snake(input: string): string {
+  const value = input
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/[^a-zA-Z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .toLowerCase();
+  return /^[0-9]/.test(value) ? `_${value}` : value || "field";
+}
+
+const RESERVED = new Set([
+  "abstract", "as", "async", "await", "base", "bool", "break", "byte", "case", "catch",
+  "class", "const", "continue", "crate", "default", "delegate", "do", "double", "dyn",
+  "else", "enum", "event", "explicit", "extern", "false", "final", "finally", "fixed",
+  "float", "fn", "for", "foreach", "func", "goto", "if", "impl", "implements", "import",
+  "in", "int", "interface", "internal", "is", "let", "lock", "long", "loop", "match",
+  "mod", "move", "mut", "namespace", "new", "null", "object", "operator", "out",
+  "override", "package", "params", "private", "protected", "pub", "public", "readonly",
+  "ref", "return", "self", "short", "sizeof", "static", "string", "struct", "super",
+  "switch", "this", "throw", "trait", "true", "try", "type", "typeof", "uint", "ulong",
+  "unchecked", "unsafe", "use", "ushort", "var", "virtual", "void", "volatile", "where",
+  "while", "with", "yield",
+]);
+
+export function isReserved(word: string): boolean {
+  return RESERVED.has(word.toLowerCase());
+}
+
+export function isIdentifier(word: string): boolean {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(word);
+}