opencode-leetcode-realworld 0.2.3 → 0.4.0

package/README.md

@@ -76,6 +76,7 @@ Options can be given in any order; the command figures out which is which.
 | `tags` | One or more topic tags, comma-separated (e.g. `graph` or `dynamic-programming,sliding-window`) | any | Nudges which underlying algorithm and real-world domain you get. |
 | `<id-or-slug>` | A problem number or slug (e.g. `1`, `two-sum`) | random | Derive the assignment from one specific source problem. |
 | `language` | A supported language or alias (see below) | **asks you** | Language of the generated project and tests. |
+| `scope` | `single` \| `mini` \| `full` | **asks you** | How big the assignment is (see Two modes). |
 
 If you leave the language (or difficulty) out, opencode **asks you** with a
 multiple-choice question before generating anything.
@@ -150,17 +151,34 @@ they tend to produce:
 ```
 /practice
    │
-   ├─ (agent)             if language/difficulty are missing, ask you via the `question` tool
+   ├─ (agent)             ask you for language/difficulty, then how you want to start
    │
    ├─ leetcode_fetch      fetch a problem from the LeetCode API (private reasoning input)
    │
    ├─ (agent)             derive the principle -> invent a real-world scenario
    │
-   ├─ leetcode_scaffold   write README / PROJECT / starter / tests, reject any leak
+   ├─ leetcode_scaffold   write the exercises(s): one function, or a multi-file app
    │
    └─ guard hooks         block reading hidden tests + provenance, keep the exercise honest
 ```
 
+## Two modes
+
+`/practice` asks **how you want to start**, and the answer changes what gets built:
+
+| Scope | What you get |
+| --- | --- |
+| **Quick exercise** | One entry point with a JSON-in / JSON-out contract (any language). |
+| **Mini project** | A small multi-file app (~3-6 files) with the algorithm behind a single `TODO` (TypeScript, Python, Rust). |
+| **Fuller project** | A multi-file app with more realistic layers (~6-15 files) and the same single `TODO`. |
+
+In project mode you get a real little codebase — CLI entry, domain types, service
+layer, wiring — where **everything works except one `TODO`**. You implement that
+piece (the algorithm) and `node tests/runner.mjs` verifies the app end-to-end.
+
+Project mode is available for **TypeScript, Python, Rust**; the other languages use
+the quick exercise.
+
 The generated project looks like this:
 
 ```
@@ -182,6 +200,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 +289,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.4.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/index.ts

@@ -71,9 +71,15 @@ export const LeetCodeRealWorld: Plugin = async ({ client, directory }) => {
 
   const scaffoldTool = tool({
     description:
-      "Create a real-world practice project from a spec (scenario, requirements, starter, tests). " +
+      "Create a real-world practice project from a spec. " +
+      "Use mode \"single\" for one JSON-in/out function (any language) or mode \"project\" " +
+      "(typescript, python, rust) for a multi-file app where one TODO must be implemented. " +
       "Rejects any spec that leaks the original problem, its title, slug, or a coding-practice site name.",
     args: {
+      mode: tool.schema
+        .enum(["single", "project"])
+        .default("single")
+        .describe("single = one function; project = multi-file app (ts/python/rust)"),
       title: tool.schema.string().describe("Real-world project title (no coding-practice words)"),
       scenario: tool.schema.string().describe("Business context, written like a real ticket"),
       pattern: tool.schema.string().describe("Underlying algorithmic principle (internal only)"),
@@ -102,6 +108,22 @@ export const LeetCodeRealWorld: Plugin = async ({ client, directory }) => {
       outDir: tool.schema.string().optional().describe("Target directory, relative to the session directory"),
       sourceSlug: tool.schema.string().optional().describe("Provenance only; never surfaced"),
       sourceTitle: tool.schema.string().optional().describe("Provenance only; never surfaced"),
+      task: tool.schema
+        .string()
+        .optional()
+        .describe("Project mode: markdown brief telling the learner what to implement and where"),
+      files: tool.schema
+        .array(tool.schema.object({ path: tool.schema.string(), content: tool.schema.string() }))
+        .optional()
+        .describe("Project mode: the full file tree, leaving one TODO to implement"),
+      runCommand: tool.schema
+        .string()
+        .optional()
+        .describe("Project mode: command that runs one case (JSON on stdin, JSON on stdout)"),
+      buildCommand: tool.schema
+        .string()
+        .optional()
+        .describe("Project mode: optional one-time build command (compiled languages)"),
     },
     async execute(rawArgs, context) {
       const spec = rawArgs as ScaffoldSpec;
@@ -131,6 +153,7 @@ export const LeetCodeRealWorld: Plugin = async ({ client, directory }) => {
         `Created a real-world practice project at ${relative}`,
         "",
         `Title: ${result.title}`,
+        `Mode: ${result.mode}${result.mode === "project" ? " (implement the marked TODO)" : ""}`,
         `Language: ${result.languageName} (${result.runtime})`,
         `Files (${result.files.length}):`,
         ...result.files.map((file) => `  - ${file}`),