codewhale.history 2.8.13 → 2.9.1

package/README.md

@@ -78,11 +78,13 @@ Git already has your back.
 
 ### `//teach-me`
 An interactive code-teaching quiz that randomly selects real snippets from your
-current project. Two modes across five difficulty levels:
+current project. Three modes across five difficulty levels:
 
 - **Passive** (default): Explain what the code does and how it works.
 - **Interactive**: Lines are removed from the file — you restore the missing
   logic, then say `done` for the model to verify your work.
+- **SOLID**: Working code is rewritten with deliberate anti-patterns (breaks
+  SOLID, DRY, cohesion). You restore good design, then say `done`.
 
 **Triggers:** `teach me` · `quiz me` · `test my knowledge` · `code quiz` ·
 `drill me`
@@ -93,7 +95,8 @@ current project. Two modes across five difficulty levels:
 |----------|---------|-------------|
 | Language | `teach me python` | Restrict to Python, TypeScript, Rust, Go, Java… |
 | Level | `teach me level 3` or `teach me l3` | Set difficulty 1–5 (default: 3) |
-| Mode | `teach me interactive` | Reconstruction mode — you restore missing lines |
+| Mode | `teach me interactive` | Reconstruction — restore missing lines |
+| Mode | `teach me solid` | Anti-pattern detection — fix degraded design |
 | Scope | `teach me services/` | Narrow to a specific file or folder |
 | Concept | `teach me decorators` | Target: decorators, async, generators, context managers, comprehensions, error handling, type hints, threading |
 
@@ -109,11 +112,25 @@ current project. Two modes across five difficulty levels:
 
 **Mid-round commands:** `hint` (get a nudge) · `skip` (see the answer) ·
 `next` (draw a new snippet) · `level N` · `easier` · `harder` ·
-`interactive` · `passive` · `done` (verify restoration) · `stop`
+`interactive` · `passive` · `solid` · `done` (verify work) · `stop`
 
 **At the end** you get a session summary: rounds completed, mode, files covered,
 what you're strong on, what to review, and a suggested next level.
 
+### SOLID Mode
+
+| Trigger | What happens |
+|---------|-------------|
+| `teach me solid` | SOLID mode at level 3, passive feedback |
+| `teach me SOLID level 4` | Level 4, passive |
+| `teach me solid interactive` | SOLID mode, you edit the file (not just describe) |
+
+**How it works:** The model picks code, rewrites it with deliberate anti-patterns
+(STUPID, WET, god objects, tight coupling), presents the degraded code, and you
+restore good design. The model assesses across anti-patterns fixed, design
+quality, functional correctness, and intentionality. Files are always restored
+with `git checkout` after each round.
+
 ## Requirements
 - Node.js (for the `codewhale-history` command)
 - [CodeWhale](https://codewhale.net/en/docs)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codewhale.history",
-  "version": "2.8.13",
+  "version": "2.9.1",
   "description": "CodeWhale utility commands: session history, tool listing, file snapshot, interactive code quiz — global install",
   "bin": {
     "codewhale-history": "./_list_sessions.js",

package/skills/teach-me/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: teach-me
-description: Interactive code-teaching quiz. Selects random snippets from the current project and quizzes the user on application logic and language semantics. Triggered by 'teach me', 'quiz me', 'test my knowledge', 'code quiz', or 'drill me'. Supports difficulty levels 1–5 and two modes: passive (explain) and interactive (reconstruct).
+description: Interactive code-teaching quiz. Selects random snippets from the current project and quizzes the user on application logic and language semantics. Triggered by 'teach me', 'quiz me', 'test my knowledge', 'code quiz', or 'drill me'. Supports difficulty levels 1–5 and three modes: passive (explain), interactive (reconstruct), and solid (anti-pattern detection).
 ---
 
 # Teach Me — Interactive Code Quiz
@@ -13,6 +13,9 @@ current project. Two modes:
   accomplishes) and **language mechanics** (syntax and semantics).
 - **Interactive**: removes lines from the file; the user restores them and
   says `done`; the model diffs against the original and gives feedback.
+- **SOLID**: rewrites working code to be deliberately anti-pattern-ridden
+  (STUPID principles, WET code, poor cohesion). The user restores good
+  design and says `done`; the model evaluates against the original.
 
 ## Session Trigger
 
@@ -37,15 +40,19 @@ Optionally followed by modifiers:
 
 Modifiers combine freely: `teach me decorators level 4`,
 `teach me async services/`, `teach me generators l2`,
-`teach me level 2 interactive`, `teach me interactive decorators`
+`teach me level 2 interactive`, `teach me interactive decorators`,
+`teach me solid level 3`, `teach me SOLID`
 
-Two modes are available, orthogonal to difficulty:
+Three modes are available, orthogonal to difficulty:
 
 - **`passive`** (default) — You explain what the code does and how it works.
 - **`interactive`** — Lines are removed from the file; you restore the missing
   logic. When done, say `done` or `check my work` and the model verifies.
+- **`solid`** / **`SOLID`** — Working code is rewritten with deliberate
+  anti-patterns (breaks SOLID, DRY, cohesion, abstraction). You restore good
+  design principles. When done, say `done` or `check my work`.
 
-Switch modes mid-session with `interactive` or `passive`.
+Switch modes mid-session with `passive`, `interactive`, or `solid`.
 
 If no level is specified, default to **level 3** and adjust based on
 performance across rounds.
@@ -204,6 +211,109 @@ Type `hint` for a clue, `skip` to see the answer, or `stop` to end.
 ---
 ```
 
+### 2c. SOLID Mode — Anti-Pattern Reconstruction
+
+When mode is `solid` (or `SOLID`), the model rewrites working code to be
+deliberately anti-pattern-ridden — breaking SOLID principles, DRY, cohesion,
+and abstraction — while keeping the code functional. The user must restore
+good design.
+
+#### Scope by Level
+
+| Level | Scope | Anti-patterns introduced |
+|-------|-------|--------------------------|
+| 1 | Single method, 5–15 lines | 2 (e.g., bad naming + duplication) |
+| 2 | Single method, 8–20 lines | 3–4 (add tight coupling, god method creep) |
+| 3 | Method + immediate collaborators, 12–30 lines each | 4–5 across methods (tight coupling, WET, poor cohesion) |
+| 4 | Small class, 18–45 lines of method bodies | 5–6 systemic anti-patterns |
+| 5 | Full class or multiple related classes, 25–55+ lines | Architectural: Singleton abuse, dependency inversion violation, shotgun surgery |
+
+#### Anti-Pattern Catalog
+
+The model chooses from this catalog when deconstructing code. Select
+anti-patterns appropriate to the language and scope:
+
+**STUPID principles (broken SOLID):**
+- **S**ingleton abuse — unnecessary global/static state
+- **T**ight coupling — hardcoded dependencies, `new` inside methods, no DI
+- **U**ntestable — no seams, side effects mixed with logic, `new Date()` inline
+- **P**remature optimization — complex code for imaginary performance needs
+- **I**ndescriptive naming — single-letter vars (`x`, `tmp`, `data`), misleading names
+- **D**uplication — copy-pasted logic blocks, WET (Write Everything Twice)
+
+**Broken design principles:**
+- Single Responsibility violation — one function/method does 3+ unrelated things
+- Open/Closed violation — `if isinstance()` chains or giant `switch` for extensibility
+- Interface Segregation violation — fat interfaces with unused methods
+- Dependency Inversion violation — high-level modules depending on low-level details
+- Leaky abstraction — exposing implementation details through the API
+- God object — one class/method that knows and does everything
+- Shotgun surgery — one change requires touching many files/methods
+
+#### SOLID Mode Per-Round Flow
+
+0. **Snapshot git state.** Run `git status --porcelain <file>` before touching it.
+1. **Select** a snippet using the standard rules (section 2). For levels 3–5,
+   read enough context (callers, callees, class definition) to rewrite coherently.
+2. **Save** the original code in memory (full selected scope).
+3. **Deconstruct** the code. Rewrite the file with `write_file` (full file) or
+   `edit_file` (targeted) to introduce anti-patterns. The code MUST still
+   compile/run and produce the same behavior as the original.
+4. **Present** the deconstructed code. State the scope, the number of
+   anti-patterns introduced, but do NOT name or annotate them — the user must
+   find them.
+5. **Instruct:** "Open `<file>`, find and fix the [N] anti-patterns. The code
+   should still work. Say `done` or `check my work` when ready."
+6. **Wait.** Do not evaluate until the user signals completion.
+7. **Re-read** the file. Compare against the saved original.
+8. **Feedback** (see SOLID Evaluation below). Restore with `git checkout -- <file>`.
+9. **Restore.** After feedback, `git checkout -- <file>` for a byte-perfect reset.
+   If pre-existing uncommitted changes (step 0), warn the user and offer manual
+   restore.
+
+#### Thinking Suppression (SOLID Mode)
+
+Same as interactive mode: use **Skip** thinking during steps 1–5 (selection
+through presentation). Resume normal depth at step 6. Never include the
+original code or the specific anti-patterns chosen in your reasoning.
+
+#### SOLID Mode Presentation Format
+
+```
+---
+## Round N — Level X · solid | `path/to/file.py` (lines A–B)
+
+```python
+ 42  class ReportGenerator:
+ 43      def process(self, data):
+ 44          x = data.strip()
+ 45          # Parse + validate + format all in one method
+ 46          if ',' in x:
+ 47              parts = x.split(',')
+ 48              if len(parts) != 3: return None
+ 49              result = f"{parts[0].upper()}: {parts[1]} - {parts[2]}"
+ 50          elif '|' in x:
+ 51              parts = x.split('|')
+ 52              if len(parts) != 3: return None
+ 53              result = f"{parts[0].upper()}: {parts[1]} - {parts[2]}"
+ 54          else:
+ 55              return None
+ 56          # Save + notify all in one place
+ 57          db = DatabaseConnection()  # hardcoded dependency
+ 58          db.save(result)
+ 59          EmailSender().send("admin@corp.com", "Report", result)
+ 60          return result
+```
+
+⚠️ **SOLID Mode.** This code still works, but contains ~5 anti-patterns
+(violating SOLID, DRY, and cohesion principles). Open
+`path/to/file.py` and restore good design. When you're done, say
+**`done`** or **`check my work`**.
+
+Type `hint` for a clue, `skip` to see the answer, or `stop` to end.
+---
+```
+
 ### 3. Presentation — Show the Snippet
 
 For each round, present the snippet with its filename:
@@ -311,6 +421,56 @@ Here's what was removed:
 After strike 3, restore the original lines in the file and proceed to the
 next round automatically (no "another round?" prompt).
 
+#### D. SOLID Mode Evaluation
+
+When mode is `solid`, evaluation compares the user's restored design against
+the saved original and the anti-patterns that were introduced. Score across
+these dimensions:
+
+| Dimension | What to check |
+|-----------|--------------|
+| **Anti-patterns fixed** | How many of the N introduced anti-patterns did the user address? |
+| **Design quality** | Does the restored code follow SOLID, DRY, and cohesion principles at least as well as the original? |
+| **Functional correctness** | Does the code still work? Same inputs → same outputs? |
+| **Intentionality** | Did the user identify WHY each anti-pattern was wrong, or just guess? |
+
+Feedback structure:
+
+```
+**Anti-patterns addressed:** [N/M] — [list which ones and how]
+
+**What you improved:**
+- [specific anti-pattern they fixed well]
+
+**What you missed:**
+- [anti-patterns still present or not fully addressed]
+
+**Comparison to original:**
+[How their solution compares to the original — is it equivalent, better, or
+does it introduce new issues?]
+```
+
+**Strikes in SOLID mode:**
+
+**Strike 1** — Category nudge (name the principle, not the fix):
+```
+Good effort. Think about [principle — e.g., "Single Responsibility"] —
+does this method do too many different things?
+```
+
+**Strike 2** — Near-explicit hint (name the anti-pattern):
+```
+You're close. Look at the duplication between lines 46-49 and 50-53. That's
+WET code — both branches do the same parsing. Also, `DatabaseConnection()`
+on line 57 creates tight coupling.
+```
+
+**Strike 3** — Reveal the original code and move to the next round:
+```
+Here's the original design. Compare it with yours to see what was improved.
+```
+Then restore with `git checkout -- <file>` and proceed automatically.
+
 #### Weighted Evaluation for Targeted Concepts
 
 When a concept is targeted (e.g., `teach me decorators`), bias the
@@ -391,13 +551,14 @@ nailed everything at-level, say so and highlight the nuance they caught.
 | `harder` | Increase level by 1 (maximum 5). |
 | `interactive` | Switch to interactive (reconstruction) mode for subsequent rounds. |
 | `passive` | Switch to passive (explanation) mode for subsequent rounds. |
-| `done` / `check my work` | (Interactive mode only) Signal that missing lines have been restored. Triggers verification. |
+| `solid` / `SOLID` | Switch to SOLID (anti-pattern reconstruction) mode for subsequent rounds. |
+| `done` / `check my work` | (Interactive/SOLID mode) Signal that work is complete. Triggers verification. |
 | `stop` / `end` | End session. Deliver summary. |
 
 ### 5. Loop — Keep Going
 
 After a successful evaluation or a `next` skip, ask:
-"Another round? (yes / no / level N / interactive / passive / stop)"
+"Another round? (yes / no / level N / interactive / passive / solid / stop)"
 
 After a strike-3 reveal, do **not** ask — proceed directly to the next
 round with:
@@ -456,15 +617,18 @@ criteria for the Mechanics axis:
 - **Interactive mode file edits.** The model MAY remove lines from files to set
   up reconstruction exercises. The model MUST NOT add or modify lines — only
   the user restores code.
-- **Restore after each round.** After feedback in interactive mode, restore
-  each touched file with `git checkout -- <file>` for a byte-perfect reset
-  that leaves no git diff. If the file had pre-existing uncommitted changes
-  (noted in step 0), restore the original lines manually via `edit_file`
-  instead and warn the user.
+- **SOLID mode file rewrites.** The model MAY rewrite files to introduce
+  anti-patterns. The deconstructed code MUST still compile/run with the same
+  behavior. The model MUST NOT delete code or break functionality — only
+  degrade the design.
+- **Restore after each round.** After feedback in interactive or SOLID mode,
+  restore each touched file with `git checkout -- <file>` for a byte-perfect
+  reset. If the file had pre-existing uncommitted changes (noted in step 0),
+  restore the original lines manually via `edit_file` instead and warn the user.
 - **Restore on session end.** When the session ends, check whether any files
-  still contain `# ... N lines removed ...` placeholders. If so, restore
-  them with `git checkout -- <file>` (or `edit_file` if pre-existing
-  changes were present).
+  still contain `# ... N lines removed ...` placeholders or deconstructed
+  code from interactive/SOLID mode. If so, restore them with
+  `git checkout -- <file>` (or `edit_file` if pre-existing changes).
 
 ## Verification
 
@@ -479,3 +643,10 @@ After each round, confirm:
 - (Interactive mode) The file was re-read before evaluating the user's restoration
 - (Interactive mode) Feedback accurately describes any differences from the original
 - (Interactive mode) Gapped files were restored or the user was offered restoration on session end
+- (SOLID mode) The original code was saved before deconstruction
+- (SOLID mode) The deconstructed code is functional (same behavior, just degraded design)
+- (SOLID mode) Anti-patterns were introduced deliberately — no accidental breakage
+- (SOLID mode) The number of anti-patterns was stated in the presentation
+- (SOLID mode) Individual anti-patterns were NOT annotated or revealed before evaluation
+- (SOLID mode) The file was re-read before evaluating the user's restoration
+- (SOLID mode) Deconstructed files were restored with `git checkout` on round end