Add dataset card

README.md

@@ -0,0 +1,213 @@
+---
+license: apache-2.0
+language:
+- en
+tags:
+- code
+- software-engineering
+- synthetic
+- code-quality
+- refactoring
+- static-analysis
+task_categories:
+- text-classification
+- text-generation
+pretty_name: Code Smell Detection
+size_categories:
+- n<1K
+---
+
+# Code Smell Detection
+
+A curated synthetic dataset of **103 hand-authored code snippets** labelled with software engineering code smells across **6 languages** and **20 smell types**, including a clean negative class (~6%). Designed for training classifiers, evaluating LLM code-review capability, and teaching refactoring principles.
+
+## Dataset Summary
+
+| Attribute | Value |
+|---|---|
+| Total examples | 103 |
+| Languages | Python, JavaScript, TypeScript, Go, Java, Rust |
+| Smell types | 20 (+ clean negative class) |
+| Splits | train (72) / val (15) / test (16) |
+| License | Apache 2.0 |
+
+## Smell Types
+
+| Smell Type | Count | Description |
+|---|---|---|
+| `long_method` | 5 | Methods too long to understand at a glance |
+| `large_class` | 5 | Classes with too many responsibilities |
+| `god_object` | 5 | Objects that know/do too much |
+| `feature_envy` | 7 | Methods more interested in another class's data |
+| `data_clumps` | 6 | Groups of primitives that belong in an object |
+| `primitive_obsession` | 5 | Using primitives instead of value objects |
+| `switch_statements` | 5 | Repeated switch/if-else on a type discriminator |
+| `speculative_generality` | 6 | Unused abstraction added for hypothetical futures |
+| `comments_as_smell` | 6 | Comments that compensate for poor naming |
+| `temporary_field` | 4 | Fields only set during one method call |
+| `message_chains` | 6 | Long chains of getters/method calls |
+| `middle_man` | 5 | Classes that only delegate to another class |
+| `inappropriate_intimacy` | 4 | Classes accessing each other's private internals |
+| `refused_bequest` | 4 | Subclasses that reject inherited interface |
+| `lazy_class` | 5 | Classes that do too little to justify existence |
+| `alternative_classes` | 5 | Two classes doing the same thing with different names |
+| `dead_code` | 5 | Unreachable, deprecated, or commented-out code |
+| `parallel_inheritance` | 4 | Two class hierarchies that must change in lockstep |
+| `incomplete_library` | 5 | Re-implementing what a standard library already provides |
+| `none` | 6 | **Clean negative class** — well-written code with no smell |
+
+## Schema
+
+```python
+{
+  "id": str,                    # 16-char MD5 hex
+  "language": str,              # python | javascript | typescript | go | java | rust
+  "smell_type": str,            # see table above; "none" for clean examples
+  "severity": str,              # low | medium | high | none (none for clean examples)
+  "code_snippet": str,          # the code to evaluate
+  "smell_explanation": str,     # why this is a smell (or why it's clean)
+  "refactoring_suggestion": str,# how to fix it (or "No refactoring needed." for clean)
+  "difficulty": str             # beginner | intermediate | advanced
+}
+```
+
+## Sample Records
+
+### Example 1 — `feature_envy` (Python, beginner)
+```python
+# code_snippet:
+class Report:
+    def __init__(self, data_source):
+        self.data_source = data_source
+
+    def generate(self):
+        records = self.data_source.records
+        total = sum(r.amount for r in self.data_source.records if r.status == 'paid')
+        overdue = [r for r in self.data_source.records if r.due_date < datetime.today() and r.status != 'paid']
+        avg = total / len(self.data_source.records) if self.data_source.records else 0
+        return {'total_paid': total, 'overdue_count': len(overdue), 'average': avg}
+
+# smell_explanation:
+# Report.generate() repeatedly reaches into data_source internals (records, amounts, statuses,
+# due_dates). The method is more interested in DataSource's data than in Report's own
+# responsibilities — a classic Feature Envy.
+
+# refactoring_suggestion:
+# Move the aggregation logic to DataSource as paid_total(), overdue_records(), and
+# average_amount() methods. Report.generate() then just calls data_source.summary().
+```
+
+### Example 2 — `message_chains` (TypeScript, advanced)
+```typescript
+// code_snippet:
+function applyDiscount(context: RequestContext): number {
+  return context
+    .getSession()
+    .getCurrentUser()
+    .getSubscription()
+    .getPlan()
+    .getDiscountPolicy()
+    .calculateDiscount(context.getCart().getTotalAmount());
+}
+
+// smell_explanation:
+// A 7-deep chain crosses five domain objects to reach a discount calculation.
+// Depends on the shape of five intermediate types, impossible to unit-test without a
+// full context graph, and violates the Law of Demeter severely.
+
+// refactoring_suggestion:
+// Move calculateDiscount to a DiscountService that accepts (userId, planId, cartTotal),
+// or to User.calculateDiscount(cartTotal) if discount is user-scoped.
+```
+
+### Example 3 — `none` (Go, intermediate, clean)
+```go
+// code_snippet:
+type Money struct {
+    amount   int64  // stored in cents
+    currency string // ISO 4217
+}
+
+func NewMoney(amount int64, currency string) (Money, error) {
+    if amount < 0 { return Money{}, fmt.Errorf("amount must be non-negative") }
+    if len(currency) != 3 { return Money{}, fmt.Errorf("invalid currency code") }
+    return Money{amount: amount, currency: currency}, nil
+}
+
+func (m Money) Add(other Money) (Money, error) {
+    if m.currency != other.currency {
+        return Money{}, fmt.Errorf("currency mismatch: %s vs %s", m.currency, other.currency)
+    }
+    return Money{amount: m.amount + other.amount, currency: m.currency}, nil
+}
+
+// smell_explanation:
+// Clean value object pattern: Money is immutable, validated at construction,
+// stores currency-safe integer amounts, and arithmetic is type-safe. No smell.
+```
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("SalutefaceAAC/code-smell-detection")
+print(ds["train"][0])
+
+# Filter by language and severity
+train_df = ds["train"].to_pandas()
+high_severity = train_df[(train_df.language == "python") & (train_df.severity == "high")]
+
+# Classify: positive examples only
+positive = train_df[train_df.smell_type != "none"]
+```
+
+### LLM Evaluation Prompt
+```python
+def make_eval_prompt(snippet: str) -> str:
+    return f"""Analyze the following code snippet for software engineering code smells.
+Identify the primary smell type (or "none" if the code is clean), its severity (low/medium/high/none),
+explain why it is or isn't a smell, and suggest a refactoring if applicable.
+
+Code:
+{snippet}
+
+Respond in JSON: {{"smell_type": "...", "severity": "...", "explanation": "...", "refactoring": "..."}}"""
+```
+
+## Methodology
+
+Examples were hand-authored following these principles:
+- **Authenticity**: Each snippet resembles real-world code that would appear in a production codebase, not toy examples.
+- **Language idiomatic**: Each language's conventions (Go interfaces, Rust newtype, Java Spring, TypeScript generics) are respected.
+- **Negative class**: 6 clean examples (~6%) prevent classifiers from learning a trivial "always smelly" bias.
+- **Severity calibration**: `high` = structural problem affecting testability/extensibility; `medium` = noticeable but contained; `low` = minor style or maintenance debt.
+- **Difficulty calibration**: `beginner` = recognisable pattern, one-line fix; `intermediate` = requires understanding domain/architecture; `advanced` = multi-class refactoring or architectural pattern.
+
+## Limitations
+
+- 103 examples — suitable for evaluation, fine-tuning small classifiers, or few-shot prompting; not sufficient for training large models from scratch.
+- Python is over-represented (29/103) relative to Rust (9/103); balance will improve in v1.5.
+- Snippets are self-contained stubs; real code smells often span multiple files.
+- The taxonomy follows Fowler's *Refactoring* (2nd ed.) and Kerievsky's *Refactoring to Patterns*; some newer smells (e.g., async anti-patterns, microservice coupling) are not yet covered.
+- LLM-generated explanations: while hand-authored, these reflect the author's (agent's) interpretation of each smell, not a community consensus annotation.
+
+## Related Datasets
+
+- [SalutefaceAAC/synthetic-code-review-comments](https://huggingface.co/datasets/SalutefaceAAC/synthetic-code-review-comments)
+- [SalutefaceAAC/unit-test-edge-cases](https://huggingface.co/datasets/SalutefaceAAC/unit-test-edge-cases)
+- [SalutefaceAAC/api-error-resolution-pairs](https://huggingface.co/datasets/SalutefaceAAC/api-error-resolution-pairs)
+- [SalutefaceAAC/structured-output-generation](https://huggingface.co/datasets/SalutefaceAAC/structured-output-generation)
+
+## Citation
+
+```bibtex
+@dataset{saluteface_code_smell_2026,
+  author    = {SalutefaceAAC},
+  title     = {Code Smell Detection},
+  year      = {2026},
+  publisher = {Hugging Face},
+  url       = {https://huggingface.co/datasets/SalutefaceAAC/code-smell-detection},
+  license   = {Apache-2.0}
+}
+```