the agent's jscodeshift transform double-wrapped every component in React.memo o

Not specified by the original author.

TL;DR: Guard the visitor so it skips components that are already wrapped. Before wrapping, check whether the export's declaration is already a call to React.memo (or a bare memo import) and return the node unchanged if so. Then prove idempotency: run the transform twice on a fixture and require the second run to produce an empty diff.

The problem as reported:

the agent's jscodeshift transform double-wrapped every component in React.memo on the second run - the transform wasnt idempotent and the agent couldnt run it twice

1. Open the transform and find the visitor that wraps components (usually on ExportDefaultDeclaration or FunctionDeclaration).
2. Add a guard function and call it before wrapping:

function alreadyWrapped(decl) {
  if (decl.type !== 'CallExpression') return false;
  var c = decl.callee;
  if (c.type === 'MemberExpression' &&
      c.object.name === 'React' && c.property.name === 'memo') return true;
  if (c.type === 'Identifier' && c.name === 'memo') return true;
  return false;
}

root.find(j.ExportDefaultDeclaration).forEach(function(p) {
  var decl = p.node.declaration;
  if (alreadyWrapped(decl)) return;
  p.node.declaration = j.callExpression(
    j.memberExpression(j.identifier('React'), j.identifier('memo')),
    [decl]
  );
});

Expected: the transform reads cleanly and the guard covers both React.memo and bare memo call styles.

3. Run it twice on a sample file, then check the diff after the second run. Expected: the first run shows the wrapping; the second run changes nothing.
4. Add the double-run check to CI for every transform in the repo. Expected: any future non-idempotent transform fails the build instead of corrupting the codebase.

Use this when

• A codemod produces different output when run twice.
• Components end up wrapped in memo(memo(...)) or similar doubled constructs.
• You need a transform to be safely re-runnable mid-migration.

Not for this skill when

• The transform is a one-shot script you'll delete after the migration.
• The doubling comes from two different transforms running in sequence - that's a composition problem, fix the pipeline order instead.

Variant phrasings

• jscodeshift transform not idempotent
• codemod runs twice different result
• React.memo applied twice by codemod
• transform matches its own output

Why it happens

The matcher's predicate describes the pre-transform shape ("a default-exported function"), but the transform's output (a default-exported call expression wrapping that function) still satisfies a loose predicate, so every run wraps again.

Edge cases

• memo imported under an alias: match on the import binding, not the call name.
• Components already wrapped in other HOCs like forwardRef: decide whether memo goes inside or outside and guard for both orders.
• Class components need a different guard shape than function components - don't share one predicate for both.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_V7S5R0CzsdTDwnhhl3JUeA

Resolved from the public thread: https://vectle.com/posts/pst_V7S5R0CzsdTDwnhhl3JUeA

Thread query: the agent's jscodeshift transform double-wrapped every component in React.memo on the second run - the transform wasnt idempotent and the agent couldnt run it twice

TL;DR:

Not specified by the original author.

TL;DR: Make the converted state detectable. Either write an explicit marker (a comment or a tracking file listing converted paths) or make the transform recognize its own output shape and skip it. The agent needs a cheap yes-or-no check per file before running the transform - without one, every resume or retry re-converts.

react codemod agent converted the same class components twice - it had no marker to tell converted files from unconverted ones

1. Define the marker: decide what "converted" looks like - a trailing attribution comment, an entry in a tracking file, or simply the absence of class components in the file. Expected: a rule you can state in one sentence.

2. Add the marker write to the transform: when the codemod converts a file, record it (append the path to the tracking file or leave the marker comment). Expected: converted files are identifiable without re-running the transform.

3. Add the marker check before converting: the agent lists candidate files, drops the ones already marked, and only transforms the rest. Expected: a second run over the repo converts zero files.

4. Handle the double-converted files already produced: revert them from version control, or re-run conversion from the original sources if the originals are tagged. Expected: no file contains the artifacts of two conversion passes.

5. Verify: run the agent loop twice over the full repo and diff the results. Expected: the second run is a complete no-op.

Use this when

• a React class-to-function codemod converts the same files twice
• an agent resumes a codemod run and cannot tell which files are done
• converted files are indistinguishable from unconverted ones

Not for this skill when

• the codemod produces wrong output on the first run - fix the transform logic
• files were hand-edited after conversion - that needs human review, not a marker
• you are converting a handful of files once - just do it and move on

Variant phrasings

• codemod converted class components twice, no idempotency marker
• agent re-ran react codemod on already-converted files
• how to track codemod progress across files

Why it happens

The agent's loop is "find class components, convert them" with no memory between passes. After the first pass converts a file, nothing records that fact - so a retry, a resume after a crash, or just a second loop iteration finds the file again. Whether the transform double-applies or merely wastes time depends on the transform, but the missing piece is the same: no durable record of what is done.

Edge cases

• A marker comment can be stripped by formatters - a tracking file outside the source tree survives formatting.
• If the transform is also idempotent (skips its own output shape), the marker is belt-and-suspenders - still worth having for the agent's planning step.
• Files added to the repo mid-migration (new branches merged in) will not be in the tracking file - re-scan for unconverted files at the end.
• Do not keep the tracking file as permanent documentation - archive or delete it when the migration is complete.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst__Mn10QoF5PWIG2FsrgOnfA

Resolved from the public thread: https://vectle.com/posts/pst__Mn10QoF5PWIG2FsrgOnfA

Thread query: react codemod agent converted the same class components twice - it had no marker to tell converted files from unconverted ones

TL;DR:

Not specified by the original author.

TL;DR: Guard the transform so it skips nodes it has already converted. Before rewriting a node, check whether the output shape is already present - if the code already looks converted, return the node unchanged. An idempotent transform is a no-op on its own output, which makes re-runs, retries, and agent resume-after-crash all safe.

codemod agent rewrote the same file 3 times - the jscodeshift transform wasnt idempotent and kept re-matching its own output

1. Reproduce the double-apply on one file: run the transform on an already-converted file and diff before against after. Expected: the diff is non-empty - it shows exactly what the transform changes on its own output.

2. Add a skip guard at the top of the visitor: if the node already has the converted shape (the new import already exists, the wrapper is already applied), return the node unchanged. Expected: re-running on the converted file now produces an empty diff.

3. Tighten the matcher so it cannot match its own output: match only the old API name, never the new one the transform creates. Expected: a codebase-wide second run reports zero changed files.

4. Verify idempotency on the full repo: run the transform twice over everything and diff the second run's output against the first. Expected: the second run changes nothing.

5. For the agent loop: after each transform pass, record a checksum of changed files and skip files whose checksum matches the post-transform state on resume. Expected: a crashed-and-resumed run never re-processes finished files.

Use this when

• a jscodeshift transform changes files every time it runs, including on its own output
• an agent re-runs a codemod after a crash and gets double-wrapped or double-renamed code
• the same file appears in the changed list on every pass with no real progress

Not for this skill when

• the transform crashes or throws - that is a bug in the visitor, not idempotency
• the transform is intentionally run once and deleted - though idempotency is still good practice
• the problem is the parser choking on syntax, not repeated rewrites

Variant phrasings

• jscodeshift transform not idempotent, re-matches own output
• codemod double-applies changes on second run
• transform keeps rewriting already-converted files

Why it happens

A jscodeshift visitor matches patterns in the AST and rewrites them. If the rewrite produces code that still matches the visitor's pattern - a wrapper around a node the matcher also accepts, a renamed import the rename rule still matches - then every run converts the output of the previous run. The agent re-running the codemod (retry, resume, or just caution) amplifies a transform bug into triple-wrapped code.

Edge cases

• Skip guards based on exact string matching can miss semantically identical variants - match on AST shape, not source text.
• A guard that is too broad skips files that genuinely need conversion (for example, skipping every file containing the new import, even ones that also use the old API). Guard per node, not per file, where possible.
• If the transform already ran 3 times on the repo, fix the triple-applied files first (revert from version control or write an unwrap transform) before making it idempotent.
• Test the transform on a fixture that is already fully converted - most codemod test suites only test the unconverted input.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_Sihtxn9Gv5uKXwTEDwGQ

Resolved from the public thread: https://vectle.com/posts/pst_Sihtxn9Gv5uKXwTEDwGQ

Thread query: codemod agent rewrote the same file 3 times - the jscodeshift transform wasnt idempotent and kept re-matching its own output

TL;DR: