Convert Code Snippets

Use when (1) user provides a code snippet and asks to convert it from one programming language to another (e.g., Python to JavaScript, Java to Kotlin). (2) user asks to transform code between representations (e.g., JSON schema to TypeScript types, Markdown table to CSV). (3) user provides code in one style/convention and wants it converted to another (e.g., CommonJS to ESM, callback to async/await).

Core Position

This skill converts code snippets and data structures between programming languages, formats, and conventions. It handles syntactic transformation (language-to-language), representational transformation (JSON to TypeScript types), and stylistic transformation (older patterns to newer ones). It does NOT just copy-paste — it applies semantic equivalence, meaning the output code must be functionally equivalent to the input.

Key responsibilities:

• Detect the source and target languages from file extensions or explicit annotation
• Apply language-specific syntax rules (indentation, semicolons, keyword differences, standard library equivalents)
• Handle language idioms — not just syntax replacement, but idiomatic transformation
• Preserve comments and docstrings where possible, or mark them as needing manual review
• Validate that the output is syntactically correct in the target language

Modes

/convert-code-snippets --language

Language-to-language conversion. Converts code from source language to target language. Requires --from and --to flags:

text

--from python --to javascript
--from java --to kotlin
--from go --to rust
--from typescript --to python

Supported languages: Python, JavaScript, TypeScript, Java, Kotlin, Go, Rust, C++, C#, Swift, Ruby, PHP.

/convert-code-snippets --schema

Schema to code conversion. Converts a data schema (JSON Schema, OpenAPI, SQL schema) into typed code:

• JSON Schema → TypeScript interfaces, Python dataclasses, Java classes, Go structs
• OpenAPI spec → client code (TypeScript, Python), server stubs
• SQL CREATE TABLE → ORM models (SQLAlchemy, TypeORM, Prisma)

/convert-code-snippets --style

Code style transformation. Converts code between conventions:

• callback-to-async — converts callback-based code to async/await
• class-to-function — converts class-based OOP to functional style
• commonjs-to-esm — converts require() to import/export
• python2-to-python3 — converts Python 2 print statements, unicode handling
• jsx-to-tsx — converts JavaScript JSX to TypeScript TSX

/convert-code-snippets --format

Data format conversion. Converts between structured data formats:

• json-to-yaml, yaml-to-json, toml-to-json
• csv-to-json, json-to-csv, tsv-to-csv
• xml-to-json, json-to-xml

Execution Steps

1. Detect source and target language/format

From file extension:

text

.py  → Python     .js  → JavaScript   .java → Java
.ts  → TypeScript .kt  → Kotlin       .go   → Go
.rs  → Rust       .cpp → C++          .cs   → C#
.swift → Swift   .rb  → Ruby         .php  → PHP
.tsx → TypeScript .jsx → JavaScript   .json → JSON
.yaml → YAML      .yml → YAML        .toml → TOML
.csv → CSV        .xml → XML          .sql  → SQL

From content (if extension ambiguous):

• Python: def , import , print( → Python
• JavaScript: function , const , let , => → JavaScript
• Java: public class , System.out. → Java
• TypeScript: : string, : number, interface → TypeScript

If source or target is ambiguous, ask the user: "Cannot determine target language — please specify --from python --to javascript explicitly."

2. Parse and analyze source code

Read the source code as UTF-8 text. Use a parser if available for the source language:

• Python: ast module to parse into AST
• JavaScript/TypeScript: esprima or babel parser
• Java: use a simple regex-based approach if full parser unavailable

For languages without parser support, use structural pattern matching:

• Identify functions/methods: pattern def name( or function name(
• Identify classes: pattern class Name or class Name extends
• Identify imports: pattern import or from or require(
• Identify type annotations: pattern : Type or -> Type

Extract: function signatures, class definitions, imports, type annotations, comments.

3. Map language constructs

Build a transformation map for the specific language pair. Common mappings:

Python → JavaScript:

text

def fn(x, y)          →  function fn(x, y) {
print(x)              →  console.log(x)
None                  →  null
True / False          →  true / false
x if cond else y      →  cond ? x : y
with open(f) as f:    →  (async () => { const fs = require('fs'); ... })()
def __init__(self):   →  constructor() {
self.x                →  this.x
f"string {x}"         →  `string ${x}`
[x for x in lst]      →  lst.map(x => x)

Python → TypeScript: (above + type annotations)

text

int, float, str       →  number, number, string
List[int]             →  number[]
Dict[str, int]        →  Record<string, number>
Optional[int]         →  number | null
def fn() -> int       →  function fn(): number

Java → Kotlin:

text

System.out.println()  →  println()
public class          →  class (public is default)
String                →  String (kotlin.String)
final                 →  val
void method()         →  fun method(): Unit
if (x == null)        →  if (x == null)

Callback → Async/Await:

text

// Before (callback style)
apiCall(arg, function(err, result) {
  if (err) return handleError(err);
  process(result);
});

// After (async/await)
try {
  const result = await apiCall(arg);
  process(result);
} catch (err) {
  handleError(err);
}

CommonJS → ESM:

text

const fs = require('fs');                  →  import fs from 'fs';
const {a, b} = require('./module');        →  import {a, b} from './module.js';
module.exports = {fn};                     →  export const fn = ...;
module.exports.fn = fn;                    →  export function fn() {...}

4. Apply formatting rules

Indentation:

• Detect current indentation (tabs, 2-space, 4-space) from first indented line
• Preserve or convert based on --indent flag (default: 2 spaces for most languages)

Semicolons:

• JavaScript/TypeScript: add ; at end of statement (unless already present or line ends with {/})
• Python: remove ; if present

Quotes:

• Prefer single quotes in Python, backticks in JavaScript template literals
• Convert double-quoted strings with no special chars to single quotes in Python

Imports/exports:

• Group imports: stdlib, third-party, local (separated by blank lines)
• Sort alphabetically within groups
• Remove unused imports

5. Validate output

For parsed languages, attempt to parse the output:

• Python: ast.parse(output) — if it fails, report the error with line number
• JavaScript: run eslint --no-eslintrc --parser-options {ecmaVersion: 2020} filename.js if available

If no parser available, do structural validation:

• Balanced braces {...}, brackets [...], parentheses (...)
• No unclosed strings (detect by scanning for string delimiters)
• Keywords in correct case (function not Function, const not CONST)

If validation fails, report: "Converted code is invalid [target language]: error at line {N}: {detail}. Reverting to source format."

6. Report transformation summary

Return:

json

{
  "source_language": "python",
  "target_language": "javascript",
  "lines_converted": 142,
  "functions_mapped": 8,
  "classes_mapped": 3,
  "imports_mapped": 12,
  "comments_preserved": 7,
  "warnings": [
    {"line": 42, "issue": "Python dict comprehension has no direct JS equivalent — converted to .map() but verify correctness"},
    {"line": 87, "issue": "Decorator @property cannot be represented in ES5 — needs manual conversion"}
  ],
  "approximate_functional_equivalence": "85%"
}

Mandatory Rules

Do not

• Do not perform literal search-replace without understanding semantics (e.g., Python is vs JavaScript ===)
• Do not convert language-specific standard library calls without substituting the equivalent (e.g., System.out.println() must become console.log(), not just stay as-is)
• Do not drop type annotations in --schema mode — TypeScript/Java/Kotlin output must have types
• Do not silently skip functions or classes — every top-level definition must appear in output (even if as stub requiring manual completion)
• Do not convert code that uses a library/framework not available in the target ecosystem without warning
• Do not preserve inline comments that reference source-language-specific constructs (e.g., # self in Python → // self in JavaScript — remove or update)

Do

• Report approximate_functional_equivalence percentage and list specific areas needing manual review
• Map standard library functions (e.g., Python len() → JS .length, Python str() → JS String())
• Preserve comments when they document behavior, not implementation details
• In --style mode, add a comment // Auto-converted from [source style] — verify correctness at the top
• Detect and flag language-specific features that cannot be directly converted (decorators, metaclasses, generators, async generators)
• Use the target language's idiomatic patterns, not just syntactic translation

Quality Bar

Criterion	Minimum	Ideal
Syntax validity	Output parses without error in target language	Output passes linter with no warnings
Semantic equivalence	Approximate functional equivalence >= 70%	>= 90% with manual review only for complex features
Standard library mapping	All detected stdlib calls mapped to target equivalent	Verified by running converted code against test cases
Type preservation	Type annotations preserved where possible	Full type inference in target language
Comment preservation	Comments that document behavior preserved	Comments translated, not just copied
Edge case handling	Handles null, empty input gracefully	All edge cases have explicit handling with test cases

A good output is syntactically valid in the target language, semantically equivalent to the source (with known gaps documented), and formatted according to the target language's conventions.

Good vs. Bad Examples

Scenario	Bad	Good
Python is to JS	Replaces is with === literally	Maps is to === for primitives but warns about object identity difference
len(list) in Python	Writes len(list) in JS (not valid)	Converts to list.length
def fn(a, b=None)	Converts to function fn(a, b=null) (loses default intent)	Adds if (b === undefined) b = null or uses default parameter b = null
Python f-string	Converts f"{x}" to "${x}" (wrong in non-template context)	Detects f-string, converts to template literal `${x}`
Java for loop	Converts for (int i=0; i<n; i++) to for i in range(n): (Pythonic but not equivalent)	Preserves index-based loop or maps to for i in range(n) with note
Missing import	Silently drops import os	Maps to const os = require('os') (Node) or reports "os module has no direct JS equivalent"
Callback to async	Converts only one level of callbacks	Recursively converts nested callbacks to async/await, flattening the chain
Unknown construct	Skips the function entirely	Includes function signature as comment: // function unknownFeature() — needs manual implementation