Convert Spreadsheet Rows

Core Position#

This skill transforms input data from one format into a target format, preserving structure and fidelity. It is NOT a simple copy-paste — it handles formatting, schema mapping, and edge cases.

Key responsibilities:

• Parse the input format (JSON/CSV/code/etc.) and validate structure before transforming
• Apply formatting rules specific to the target format (indentation, escaping, etc.)
• Handle edge cases: missing fields, unusual characters, nested structures
• Provide a clear mapping summary so the user understands how input maps to output

Modes#

/convert-spreadsheet-rows --pretty#

Formatted output. Applies proper indentation, spacing, and style conventions.

/convert-spreadsheet-rows --strict#

Strict mode. Fails on any deviation from expected structure rather than guessing.

Execution Steps#

1. Parse input — Read and parse the input; detect format (JSON/CSV/XML/code/etc.)

   • If parsing fails, report: "Failed to parse input as [format] — error at line [N]: [detail]"

2. Validate structure — Check required fields/columns are present

   • If missing required field X, stop and report: "Missing required field: [X]"

3. Transform — Convert input to target format, applying format-specific rules

   • Preserve all data — do not silently drop fields
   • Apply proper escaping for special characters (quotes, newlines, etc.)

4. Validate output — Run the target format parser on the result to confirm it's valid

   • If output is invalid, revert to previous version and report what went wrong

5. Deliver — Return the converted output with a brief mapping summary

Mandatory Rules#

Do not#

• Do not silently drop fields or data — if a field cannot be mapped, report it
• Do not guess at missing data — if a field is absent, leave it null/empty and flag it
• Do not apply formatting that destroys the semantic meaning of the data
• Do not produce output that fails the target format validator
• Do not convert binary data as if it were text — detect and handle binary separately

Do#

• Report the complete field mapping: [source] -> [target] for every field
• Validate input and output formats before and after transformation
• Preserve character encoding (UTF-8) throughout the conversion process
• Handle large inputs in chunks if needed to avoid memory exhaustion
• Log conversion statistics: fields mapped, fields dropped, warnings issued

Quality Bar#

CriterionMinimumIdealData fidelityZero data loss — all fields mappedFull semantic equivalence, not just structuralFormat validityOutput passes target parserOutput passes strict schema validationEdge case handlingHandles missing/null/empty gracefullyDocuments every edge case decisionEscaping correctnessProper escaping for target formatRound-trip: convert back to source equals originalPerformanceCompletes within 2x manual timeStreaming output for large inputs

A good output passes the target format parser without errors and preserves all semantic content.

Good vs. Bad Examples#

ScenarioBadGoodMissing fieldOmits field from output silentlyReports "Field [X] absent — output null, flagged as warning"Special charactersOnly escapes visible charsEscapes all special chars per target format specLarge inputLoads entire file into memoryStreams in chunks, reports progress at 25/50/75%Output validationSkips validationRuns target parser on output, confirms valid before returningFormat errorReturns raw output with error text appendedReturns nothing, reports "Output invalid: [parser error] at [location]"