@schemashift/io-ts-effect 0.10.0

package/README.md

@@ -0,0 +1,110 @@
+# @schemashift/io-ts-effect
+
+io-ts → Effect Schema transformer for SchemaShift. Migrates io-ts codecs to their Effect Schema equivalents — the official successor to io-ts after fp-ts merged into Effect.
+
+**Tier:** Pro+
+
+## Installation
+
+```bash
+npm install @schemashift/io-ts-effect
+```
+
+## Usage
+
+```typescript
+import { createIoTsToEffectHandler } from '@schemashift/io-ts-effect';
+import { TransformEngine } from '@schemashift/core';
+
+const engine = new TransformEngine();
+engine.registerHandler('io-ts', 'effect', createIoTsToEffectHandler());
+```
+
+## Why This Migration Path?
+
+- **io-ts is deprecated** — fp-ts merged into Effect-TS
+- **Effect Schema is the official successor** for FP-oriented validation
+- **Same philosophy** — both use branded types, codecs, and composable validation
+- **Better DX** — Effect Schema has simpler API with better TypeScript inference
+
+## Transformation Mappings
+
+### Imports
+
+| io-ts | Effect Schema |
+|-------|---------------|
+| `import * as t from 'io-ts'` | `import { Schema as S } from '@effect/schema'` |
+| `import { pipe } from 'fp-ts/function'` | `import { pipe } from 'effect/Function'` |
+
+### Primitives
+
+| io-ts | Effect Schema |
+|-------|---------------|
+| `t.string` | `S.String` |
+| `t.number` | `S.Number` |
+| `t.boolean` | `S.Boolean` |
+| `t.bigint` | `S.BigInt` |
+| `t.unknown` | `S.Unknown` |
+| `t.never` | `S.Never` |
+| `t.null` | `S.Null` |
+| `t.undefined` | `S.Undefined` |
+| `t.void` | `S.Void` |
+
+### Combinators
+
+| io-ts | Effect Schema |
+|-------|---------------|
+| `t.type({...})` | `S.Struct({...})` |
+| `t.partial({...})` | `S.partial(S.Struct({...}))` |
+| `t.array(X)` | `S.Array(X)` |
+| `t.record(K, V)` | `S.Record(K, V)` |
+| `t.union([A, B])` | `S.Union(A, B)` |
+| `t.tuple([A, B])` | `S.Tuple(A, B)` |
+| `t.literal(X)` | `S.Literal(X)` |
+
+### Type Helpers
+
+| io-ts | Effect Schema |
+|-------|---------------|
+| `t.TypeOf<typeof s>` | `S.Schema.Type<typeof s>` |
+| `t.OutputOf<typeof s>` | `S.Schema.Type<typeof s>` |
+| `t.InputOf<typeof s>` | `S.Schema.Encoded<typeof s>` |
+
+## Patterns Requiring Manual Review
+
+### `.decode()` / `.encode()`
+
+```typescript
+// io-ts
+const result = schema.decode(input);
+
+// Effect Schema
+const result = S.decodeUnknownSync(schema)(input);
+// or for Either result:
+const result = S.decodeUnknownEither(schema)(input);
+```
+
+### `t.brand()`
+
+```typescript
+// io-ts
+interface PositiveBrand { readonly Positive: unique symbol }
+const Positive = t.brand(t.number, (n): n is t.Branded<number, PositiveBrand> => n > 0, 'Positive');
+
+// Effect Schema
+const Positive = pipe(S.Number, S.positive(), S.brand("Positive"));
+```
+
+### Recursive Types
+
+```typescript
+// io-ts
+const Tree = t.recursion('Tree', () => t.type({ children: t.array(Tree) }));
+
+// Effect Schema
+const Tree = S.Struct({ children: S.Array(S.suspend(() => Tree)) });
+```
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,299 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FP_TS_PATTERNS: () => FP_TS_PATTERNS,
+  IMPORT_MAPPINGS: () => IMPORT_MAPPINGS,
+  IO_TS_TO_EFFECT_CODECS: () => IO_TS_TO_EFFECT_CODECS,
+  IO_TS_TO_EFFECT_COMBINATORS: () => IO_TS_TO_EFFECT_COMBINATORS,
+  MANUAL_REVIEW_PATTERNS: () => MANUAL_REVIEW_PATTERNS,
+  createIoTsToEffectHandler: () => createIoTsToEffectHandler
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/mappings.ts
+var IO_TS_TO_EFFECT_CODECS = {
+  "t.string": "S.String",
+  "t.number": "S.Number",
+  "t.boolean": "S.Boolean",
+  "t.bigint": "S.BigInt",
+  "t.unknown": "S.Unknown",
+  "t.never": "S.Never",
+  "t.null": "S.Null",
+  "t.undefined": "S.Undefined",
+  "t.void": "S.Void",
+  "t.any": "S.Unknown",
+  "t.Int": "pipe(S.Number, S.int())",
+  "t.literal": "S.Literal"
+};
+var IO_TS_TO_EFFECT_COMBINATORS = {
+  "t.type": "S.Struct",
+  "t.partial": "S.partial(S.Struct",
+  "t.array": "S.Array",
+  "t.record": "S.Record",
+  "t.union": "S.Union",
+  "t.intersection": "S.extend",
+  "t.tuple": "S.Tuple",
+  "t.readonly": "S.Struct",
+  // Effect Schema structs are readonly by default
+  "t.readonlyArray": "S.Array",
+  "t.exact": "S.Struct",
+  "t.strict": "S.Struct",
+  "t.keyof": "S.Literal"
+};
+var FP_TS_PATTERNS = [
+  "pipe",
+  "flow",
+  "Either",
+  "Option",
+  "TaskEither",
+  "fold",
+  "map",
+  "chain",
+  "getOrElse",
+  "isLeft",
+  "isRight"
+];
+var MANUAL_REVIEW_PATTERNS = [
+  "branded",
+  "withMessage",
+  "withFallback",
+  "taggedUnion",
+  "recursion",
+  "exact",
+  "clean",
+  "alias"
+];
+var IMPORT_MAPPINGS = {
+  ioTsToEffect: {
+    ioTsImport: "import * as t from 'io-ts'",
+    effectImport: "import { Schema as S } from '@effect/schema'",
+    pipeImport: "import { pipe } from 'effect/Function'"
+  }
+};
+
+// src/io-ts-to-effect-transformer.ts
+var IoTsToEffectTransformer = class {
+  errors = [];
+  warnings = [];
+  needsPipe = false;
+  transform(sourceFile) {
+    this.errors = [];
+    this.warnings = [];
+    this.needsPipe = false;
+    const filePath = sourceFile.getFilePath();
+    const originalCode = sourceFile.getFullText();
+    try {
+      let text = originalCode;
+      text = this.transformCodecs(text, filePath);
+      text = this.transformTypeHelpers(text);
+      this.checkManualReviewPatterns(text, filePath);
+      text = this.rewriteImports(text, filePath);
+      sourceFile.replaceWithText(text);
+      return {
+        success: this.errors.length === 0,
+        filePath,
+        originalCode,
+        transformedCode: sourceFile.getFullText(),
+        errors: this.errors,
+        warnings: this.warnings
+      };
+    } catch (error) {
+      this.errors.push({
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+      return {
+        success: false,
+        filePath,
+        originalCode,
+        errors: this.errors,
+        warnings: this.warnings
+      };
+    }
+  }
+  rewriteImports(text, filePath) {
+    text = text.replace(
+      /import\s*\*\s*as\s*t\s*from\s*['"]io-ts['"]/g,
+      "import { Schema as S } from '@effect/schema'"
+    );
+    text = text.replace(
+      /import\s*\{[^}]+\}\s*from\s*['"]io-ts['"]/g,
+      "import { Schema as S } from '@effect/schema'"
+    );
+    text = text.replace(
+      /import\s+type\s*\{[^}]*\bTypeOf\b[^}]*\}\s*from\s*['"]io-ts['"]/g,
+      "import type { Schema } from '@effect/schema'"
+    );
+    if (this.needsPipe && !text.includes("from 'effect/Function'")) {
+      text = text.replace(
+        /import\s*\{[^}]*Schema[^}]*\}\s*from\s*['"]@effect\/schema['"]/,
+        (match) => `${match}
+import { pipe } from 'effect/Function'`
+      );
+    }
+    if (/from\s*['"]fp-ts/.test(text)) {
+      this.warnings.push(
+        `${filePath}: fp-ts imports detected. Effect has built-in equivalents: pipe from effect/Function, Either from effect/Either, Option from effect/Option.`
+      );
+    }
+    text = text.replace(
+      /import\s*\{[^}]*\bpipe\b[^}]*\}\s*from\s*['"]fp-ts\/function['"]/g,
+      "import { pipe } from 'effect/Function'"
+    );
+    return text;
+  }
+  transformCodecs(text, filePath) {
+    for (const [ioTsCodec, effectCodec] of Object.entries(IO_TS_TO_EFFECT_CODECS)) {
+      if (text.includes(ioTsCodec)) {
+        const pattern = new RegExp(this.escapeRegex(ioTsCodec), "g");
+        text = text.replace(pattern, effectCodec);
+        if (effectCodec.includes("pipe(")) {
+          this.needsPipe = true;
+        }
+      }
+    }
+    for (const [ioTsCombinator, effectCombinator] of Object.entries(IO_TS_TO_EFFECT_COMBINATORS)) {
+      if (text.includes(ioTsCombinator)) {
+        const pattern = new RegExp(`${this.escapeRegex(ioTsCombinator)}\\(`, "g");
+        text = text.replace(pattern, `${effectCombinator}(`);
+      }
+    }
+    if (text.includes("S.partial(S.Struct(")) {
+      text = this.fixPartialClosingParens(text);
+    }
+    text = text.replace(/S\.Union\(\[([^\]]+)\]\)/g, "S.Union($1)");
+    text = text.replace(/S\.extend\(\[([^,\]]+),\s*([^\]]+)\]\)/g, (_m, a, b) => {
+      this.needsPipe = true;
+      return `pipe(${a.trim()}, S.extend(${b.trim()}))`;
+    });
+    text = text.replace(/t\.TypeOf<typeof\s+(\w+)>/g, "S.Schema.Type<typeof $1>");
+    text = text.replace(/t\.OutputOf<typeof\s+(\w+)>/g, "S.Schema.Type<typeof $1>");
+    text = text.replace(/t\.InputOf<typeof\s+(\w+)>/g, "S.Schema.Encoded<typeof $1>");
+    if (text.includes(".decode(")) {
+      this.warnings.push(
+        `${filePath}: io-ts .decode() should be converted to S.decodeUnknownSync() or S.decodeUnknownEither().`
+      );
+    }
+    if (text.includes(".encode(")) {
+      this.warnings.push(
+        `${filePath}: io-ts .encode() should be converted to S.encodeSync() or S.encodeEither().`
+      );
+    }
+    if (text.includes("t.brand(")) {
+      this.warnings.push(
+        `${filePath}: io-ts t.brand() should be converted to pipe(schema, S.brand("BrandName")).`
+      );
+    }
+    if (text.includes("isRight(") || text.includes("isLeft(")) {
+      this.warnings.push(
+        `${filePath}: fp-ts isRight/isLeft should use Effect's Either.isRight/Either.isLeft.`
+      );
+    }
+    if (/\bt\./.test(text)) {
+      this.warnings.push(
+        `${filePath}: Some io-ts patterns could not be auto-transformed to Effect Schema. Look for remaining t.* references and convert manually.`
+      );
+    }
+    return text;
+  }
+  transformTypeHelpers(text) {
+    text = text.replace(/\bt\.Type\b/g, "S.Schema");
+    text = text.replace(/\bt\.Mixed\b/g, "S.Schema<unknown>");
+    return text;
+  }
+  fixPartialClosingParens(text) {
+    let result = "";
+    let i = 0;
+    while (i < text.length) {
+      const partialIdx = text.indexOf("S.partial(S.Struct(", i);
+      if (partialIdx === -1) {
+        result += text.slice(i);
+        break;
+      }
+      result += text.slice(i, partialIdx);
+      const startParen = partialIdx + "S.partial(S.Struct(".length;
+      let depth = 1;
+      let j = startParen;
+      while (j < text.length && text[j] !== "{") j++;
+      j++;
+      depth = 1;
+      while (j < text.length && depth > 0) {
+        if (text[j] === "{") depth++;
+        if (text[j] === "}") depth--;
+        j++;
+      }
+      if (j < text.length && text[j] === ")") {
+        result += `S.partial(S.Struct(${text.slice(startParen, j + 1)})`;
+        i = j + 1;
+      } else {
+        result += text.slice(partialIdx, j);
+        i = j;
+      }
+    }
+    return result;
+  }
+  checkManualReviewPatterns(text, filePath) {
+    for (const pattern of MANUAL_REVIEW_PATTERNS) {
+      if (text.includes(`.${pattern}(`) || text.includes(`t.${pattern}`)) {
+        const guidance = this.getManualGuidance(pattern);
+        this.warnings.push(
+          `${filePath}: ${pattern} requires manual conversion to Effect Schema. ${guidance}`
+        );
+      }
+    }
+  }
+  getManualGuidance(pattern) {
+    const guidance = {
+      branded: 'Use pipe(schema, S.brand("Name")) in Effect Schema.',
+      withMessage: "Use S.message() or S.annotations({ message: ... }) in Effect Schema.",
+      withFallback: "Handle fallbacks at the application level or use S.optional with default.",
+      taggedUnion: "Effect Schema uses S.Union with S.Struct variants (discriminated automatically).",
+      recursion: "Use S.suspend(() => schema) for recursive types in Effect Schema.",
+      exact: "Effect Schema structs are exact by default (no extra keys).",
+      clean: "Not needed in Effect Schema \u2014 structs strip unknown keys by default.",
+      alias: "Not applicable in Effect Schema \u2014 use TypeScript type aliases directly."
+    };
+    return guidance[pattern] || "See Effect Schema documentation for equivalent pattern.";
+  }
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+};
+
+// src/io-ts-to-effect-handler.ts
+function createIoTsToEffectHandler() {
+  return {
+    transform(sourceFile, _options) {
+      const transformer = new IoTsToEffectTransformer();
+      return transformer.transform(sourceFile);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FP_TS_PATTERNS,
+  IMPORT_MAPPINGS,
+  IO_TS_TO_EFFECT_CODECS,
+  IO_TS_TO_EFFECT_COMBINATORS,
+  MANUAL_REVIEW_PATTERNS,
+  createIoTsToEffectHandler
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/mappings.ts","../src/io-ts-to-effect-transformer.ts","../src/io-ts-to-effect-handler.ts"],"sourcesContent":["export { createIoTsToEffectHandler } from './io-ts-to-effect-handler.js';\nexport {\n  FP_TS_PATTERNS,\n  IMPORT_MAPPINGS,\n  IO_TS_TO_EFFECT_CODECS,\n  IO_TS_TO_EFFECT_COMBINATORS,\n  MANUAL_REVIEW_PATTERNS,\n} from './mappings.js';\n","/**\n * io-ts → Effect Schema type mappings\n *\n * io-ts uses fp-ts style codecs:\n *   io-ts:         t.type({ name: t.string, age: t.number })\n *   Effect Schema: S.Struct({ name: S.String, age: S.Number })\n *\n * Key differences:\n * - Effect Schema uses PascalCase for primitives (S.String, S.Number)\n * - Effect Schema uses S.Struct instead of t.type for objects\n * - Effect Schema uses S.Union instead of t.union\n * - Effect Schema uses branded types via S.brand()\n * - Effect Schema is pipe-based using Effect's pipe() utility\n */\n\n/** io-ts codec → Effect Schema equivalent */\nexport const IO_TS_TO_EFFECT_CODECS: Record<string, string> = {\n  't.string': 'S.String',\n  't.number': 'S.Number',\n  't.boolean': 'S.Boolean',\n  't.bigint': 'S.BigInt',\n  't.unknown': 'S.Unknown',\n  't.never': 'S.Never',\n  't.null': 'S.Null',\n  't.undefined': 'S.Undefined',\n  't.void': 'S.Void',\n  't.any': 'S.Unknown',\n  't.Int': 'pipe(S.Number, S.int())',\n  't.literal': 'S.Literal',\n};\n\n/** io-ts combinators → Effect Schema combinators */\nexport const IO_TS_TO_EFFECT_COMBINATORS: Record<string, string> = {\n  't.type': 'S.Struct',\n  't.partial': 'S.partial(S.Struct',\n  't.array': 'S.Array',\n  't.record': 'S.Record',\n  't.union': 'S.Union',\n  't.intersection': 'S.extend',\n  't.tuple': 'S.Tuple',\n  't.readonly': 'S.Struct', // Effect Schema structs are readonly by default\n  't.readonlyArray': 'S.Array',\n  't.exact': 'S.Struct',\n  't.strict': 'S.Struct',\n  't.keyof': 'S.Literal',\n};\n\n/** fp-ts imports that need transformation */\nexport const FP_TS_PATTERNS = [\n  'pipe',\n  'flow',\n  'Either',\n  'Option',\n  'TaskEither',\n  'fold',\n  'map',\n  'chain',\n  'getOrElse',\n  'isLeft',\n  'isRight',\n];\n\n/** Patterns requiring manual review */\nexport const MANUAL_REVIEW_PATTERNS = [\n  'branded',\n  'withMessage',\n  'withFallback',\n  'taggedUnion',\n  'recursion',\n  'exact',\n  'clean',\n  'alias',\n];\n\n/** Import mapping */\nexport const IMPORT_MAPPINGS = {\n  ioTsToEffect: {\n    ioTsImport: \"import * as t from 'io-ts'\",\n    effectImport: \"import { Schema as S } from '@effect/schema'\",\n    pipeImport: \"import { pipe } from 'effect/Function'\",\n  },\n};\n","import type { TransformError, TransformResult } from '@schemashift/core';\nimport type { SourceFile } from 'ts-morph';\nimport {\n  IO_TS_TO_EFFECT_CODECS,\n  IO_TS_TO_EFFECT_COMBINATORS,\n  MANUAL_REVIEW_PATTERNS,\n} from './mappings.js';\n\n/**\n * io-ts → Effect Schema Transformer\n *\n * Converts io-ts codecs to Effect Schema definitions.\n * This is the successor path for io-ts users since fp-ts merged into Effect.\n *\n *   io-ts:         t.type({ name: t.string, age: t.number })\n *   Effect Schema: S.Struct({ name: S.String, age: S.Number })\n */\nexport class IoTsToEffectTransformer {\n  private errors: TransformError[] = [];\n  private warnings: string[] = [];\n  private needsPipe = false;\n\n  transform(sourceFile: SourceFile): TransformResult {\n    this.errors = [];\n    this.warnings = [];\n    this.needsPipe = false;\n\n    const filePath = sourceFile.getFilePath();\n    const originalCode = sourceFile.getFullText();\n\n    try {\n      let text = originalCode;\n\n      // Step 1: Transform codecs and combinators\n      text = this.transformCodecs(text, filePath);\n\n      // Step 2: Transform type helpers\n      text = this.transformTypeHelpers(text);\n\n      // Step 3: Check for patterns requiring manual review\n      this.checkManualReviewPatterns(text, filePath);\n\n      // Step 4: Rewrite imports (last, so we know if pipe is needed)\n      text = this.rewriteImports(text, filePath);\n\n      sourceFile.replaceWithText(text);\n\n      return {\n        success: this.errors.length === 0,\n        filePath,\n        originalCode,\n        transformedCode: sourceFile.getFullText(),\n        errors: this.errors,\n        warnings: this.warnings,\n      };\n    } catch (error) {\n      this.errors.push({\n        message: error instanceof Error ? error.message : 'Unknown error',\n      });\n      return {\n        success: false,\n        filePath,\n        originalCode,\n        errors: this.errors,\n        warnings: this.warnings,\n      };\n    }\n  }\n\n  private rewriteImports(text: string, filePath: string): string {\n    // Replace io-ts import\n    text = text.replace(\n      /import\\s*\\*\\s*as\\s*t\\s*from\\s*['\"]io-ts['\"]/g,\n      \"import { Schema as S } from '@effect/schema'\",\n    );\n\n    // Replace named io-ts imports\n    text = text.replace(\n      /import\\s*\\{[^}]+\\}\\s*from\\s*['\"]io-ts['\"]/g,\n      \"import { Schema as S } from '@effect/schema'\",\n    );\n\n    // Replace io-ts type imports\n    text = text.replace(\n      /import\\s+type\\s*\\{[^}]*\\bTypeOf\\b[^}]*\\}\\s*from\\s*['\"]io-ts['\"]/g,\n      \"import type { Schema } from '@effect/schema'\",\n    );\n\n    // Add pipe import if needed\n    if (this.needsPipe && !text.includes(\"from 'effect/Function'\")) {\n      text = text.replace(\n        /import\\s*\\{[^}]*Schema[^}]*\\}\\s*from\\s*['\"]@effect\\/schema['\"]/,\n        (match) => `${match}\\nimport { pipe } from 'effect/Function'`,\n      );\n    }\n\n    // Handle fp-ts imports — warn about them\n    if (/from\\s*['\"]fp-ts/.test(text)) {\n      this.warnings.push(\n        `${filePath}: fp-ts imports detected. Effect has built-in equivalents: ` +\n          'pipe from effect/Function, Either from effect/Either, Option from effect/Option.',\n      );\n    }\n\n    // Replace fp-ts pipe import\n    text = text.replace(\n      /import\\s*\\{[^}]*\\bpipe\\b[^}]*\\}\\s*from\\s*['\"]fp-ts\\/function['\"]/g,\n      \"import { pipe } from 'effect/Function'\",\n    );\n\n    return text;\n  }\n\n  private transformCodecs(text: string, filePath: string): string {\n    // Transform simple codecs: t.string → S.String, etc.\n    for (const [ioTsCodec, effectCodec] of Object.entries(IO_TS_TO_EFFECT_CODECS)) {\n      if (text.includes(ioTsCodec)) {\n        const pattern = new RegExp(this.escapeRegex(ioTsCodec), 'g');\n        text = text.replace(pattern, effectCodec);\n        if (effectCodec.includes('pipe(')) {\n          this.needsPipe = true;\n        }\n      }\n    }\n\n    // Transform combinators: t.type → S.Struct, etc.\n    for (const [ioTsCombinator, effectCombinator] of Object.entries(IO_TS_TO_EFFECT_COMBINATORS)) {\n      if (text.includes(ioTsCombinator)) {\n        const pattern = new RegExp(`${this.escapeRegex(ioTsCombinator)}\\\\(`, 'g');\n        text = text.replace(pattern, `${effectCombinator}(`);\n      }\n    }\n\n    // Transform t.partial({...}) → S.partial(S.Struct({...}))\n    // Already handled by combinator mapping, but need to close the extra paren\n    // t.partial({...}) becomes S.partial(S.Struct({...})) — need closing paren\n    if (text.includes('S.partial(S.Struct(')) {\n      text = this.fixPartialClosingParens(text);\n    }\n\n    // Transform t.union([A, B]) → S.Union(A, B) — Effect Schema uses spread, not array\n    text = text.replace(/S\\.Union\\(\\[([^\\]]+)\\]\\)/g, 'S.Union($1)');\n\n    // Transform t.intersection([A, B]) → pipe(A, S.extend(B))\n    text = text.replace(/S\\.extend\\(\\[([^,\\]]+),\\s*([^\\]]+)\\]\\)/g, (_m, a: string, b: string) => {\n      this.needsPipe = true;\n      return `pipe(${a.trim()}, S.extend(${b.trim()}))`;\n    });\n\n    // Transform TypeOf: t.TypeOf<typeof schema> → S.Schema.Type<typeof schema>\n    text = text.replace(/t\\.TypeOf<typeof\\s+(\\w+)>/g, 'S.Schema.Type<typeof $1>');\n\n    // Transform OutputOf: t.OutputOf<typeof schema> → S.Schema.Type<typeof schema>\n    text = text.replace(/t\\.OutputOf<typeof\\s+(\\w+)>/g, 'S.Schema.Type<typeof $1>');\n\n    // Transform InputOf: t.InputOf<typeof schema> → S.Schema.Encoded<typeof schema>\n    text = text.replace(/t\\.InputOf<typeof\\s+(\\w+)>/g, 'S.Schema.Encoded<typeof $1>');\n\n    // Transform decode/encode patterns\n    if (text.includes('.decode(')) {\n      this.warnings.push(\n        `${filePath}: io-ts .decode() should be converted to S.decodeUnknownSync() or S.decodeUnknownEither().`,\n      );\n    }\n\n    if (text.includes('.encode(')) {\n      this.warnings.push(\n        `${filePath}: io-ts .encode() should be converted to S.encodeSync() or S.encodeEither().`,\n      );\n    }\n\n    // Transform t.brand — Effect Schema uses S.brand()\n    if (text.includes('t.brand(')) {\n      this.warnings.push(\n        `${filePath}: io-ts t.brand() should be converted to pipe(schema, S.brand(\"BrandName\")).`,\n      );\n    }\n\n    // Transform isRight/isLeft patterns\n    if (text.includes('isRight(') || text.includes('isLeft(')) {\n      this.warnings.push(\n        `${filePath}: fp-ts isRight/isLeft should use Effect's Either.isRight/Either.isLeft.`,\n      );\n    }\n\n    // Warn about remaining t.* patterns\n    if (/\\bt\\./.test(text)) {\n      this.warnings.push(\n        `${filePath}: Some io-ts patterns could not be auto-transformed to Effect Schema. ` +\n          'Look for remaining t.* references and convert manually.',\n      );\n    }\n\n    return text;\n  }\n\n  private transformTypeHelpers(text: string): string {\n    // Handle any remaining type references\n    text = text.replace(/\\bt\\.Type\\b/g, 'S.Schema');\n    text = text.replace(/\\bt\\.Mixed\\b/g, 'S.Schema<unknown>');\n\n    return text;\n  }\n\n  private fixPartialClosingParens(text: string): string {\n    // Find S.partial(S.Struct({...}) and add closing paren\n    // This is a simplified approach — handles single-level objects\n    let result = '';\n    let i = 0;\n    while (i < text.length) {\n      const partialIdx = text.indexOf('S.partial(S.Struct(', i);\n      if (partialIdx === -1) {\n        result += text.slice(i);\n        break;\n      }\n\n      result += text.slice(i, partialIdx);\n      const startParen = partialIdx + 'S.partial(S.Struct('.length;\n\n      // Find matching closing brace for the object literal\n      let depth = 1; // counting from the opening { after S.Struct(\n      let j = startParen;\n      // Find the opening brace\n      while (j < text.length && text[j] !== '{') j++;\n      j++; // skip the {\n      depth = 1;\n\n      while (j < text.length && depth > 0) {\n        if (text[j] === '{') depth++;\n        if (text[j] === '}') depth--;\n        j++;\n      }\n\n      // Now j points right after the closing }\n      // We expect ) for S.Struct closing, then we need to add ) for S.partial closing\n      if (j < text.length && text[j] === ')') {\n        result += `S.partial(S.Struct(${text.slice(startParen, j + 1)})`;\n        i = j + 1;\n      } else {\n        result += text.slice(partialIdx, j);\n        i = j;\n      }\n    }\n    return result;\n  }\n\n  private checkManualReviewPatterns(text: string, filePath: string): void {\n    for (const pattern of MANUAL_REVIEW_PATTERNS) {\n      if (text.includes(`.${pattern}(`) || text.includes(`t.${pattern}`)) {\n        const guidance = this.getManualGuidance(pattern);\n        this.warnings.push(\n          `${filePath}: ${pattern} requires manual conversion to Effect Schema. ${guidance}`,\n        );\n      }\n    }\n  }\n\n  private getManualGuidance(pattern: string): string {\n    const guidance: Record<string, string> = {\n      branded: 'Use pipe(schema, S.brand(\"Name\")) in Effect Schema.',\n      withMessage: 'Use S.message() or S.annotations({ message: ... }) in Effect Schema.',\n      withFallback: 'Handle fallbacks at the application level or use S.optional with default.',\n      taggedUnion:\n        'Effect Schema uses S.Union with S.Struct variants (discriminated automatically).',\n      recursion: 'Use S.suspend(() => schema) for recursive types in Effect Schema.',\n      exact: 'Effect Schema structs are exact by default (no extra keys).',\n      clean: 'Not needed in Effect Schema — structs strip unknown keys by default.',\n      alias: 'Not applicable in Effect Schema — use TypeScript type aliases directly.',\n    };\n    return guidance[pattern] || 'See Effect Schema documentation for equivalent pattern.';\n  }\n\n  private escapeRegex(str: string): string {\n    return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n  }\n}\n","import type { TransformHandler, TransformOptions, TransformResult } from '@schemashift/core';\nimport type { SourceFile } from 'ts-morph';\nimport { IoTsToEffectTransformer } from './io-ts-to-effect-transformer.js';\n\nexport function createIoTsToEffectHandler(): TransformHandler {\n  return {\n    transform(sourceFile: SourceFile, _options: TransformOptions): TransformResult {\n      const transformer = new IoTsToEffectTransformer();\n      return transformer.transform(sourceFile);\n    },\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,36 @@
+import { TransformHandler } from '@schemashift/core';
+
+declare function createIoTsToEffectHandler(): TransformHandler;
+
+/**
+ * io-ts → Effect Schema type mappings
+ *
+ * io-ts uses fp-ts style codecs:
+ *   io-ts:         t.type({ name: t.string, age: t.number })
+ *   Effect Schema: S.Struct({ name: S.String, age: S.Number })
+ *
+ * Key differences:
+ * - Effect Schema uses PascalCase for primitives (S.String, S.Number)
+ * - Effect Schema uses S.Struct instead of t.type for objects
+ * - Effect Schema uses S.Union instead of t.union
+ * - Effect Schema uses branded types via S.brand()
+ * - Effect Schema is pipe-based using Effect's pipe() utility
+ */
+/** io-ts codec → Effect Schema equivalent */
+declare const IO_TS_TO_EFFECT_CODECS: Record<string, string>;
+/** io-ts combinators → Effect Schema combinators */
+declare const IO_TS_TO_EFFECT_COMBINATORS: Record<string, string>;
+/** fp-ts imports that need transformation */
+declare const FP_TS_PATTERNS: string[];
+/** Patterns requiring manual review */
+declare const MANUAL_REVIEW_PATTERNS: string[];
+/** Import mapping */
+declare const IMPORT_MAPPINGS: {
+    ioTsToEffect: {
+        ioTsImport: string;
+        effectImport: string;
+        pipeImport: string;
+    };
+};
+
+export { FP_TS_PATTERNS, IMPORT_MAPPINGS, IO_TS_TO_EFFECT_CODECS, IO_TS_TO_EFFECT_COMBINATORS, MANUAL_REVIEW_PATTERNS, createIoTsToEffectHandler };

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { TransformHandler } from '@schemashift/core';
+
+declare function createIoTsToEffectHandler(): TransformHandler;
+
+/**
+ * io-ts → Effect Schema type mappings
+ *
+ * io-ts uses fp-ts style codecs:
+ *   io-ts:         t.type({ name: t.string, age: t.number })
+ *   Effect Schema: S.Struct({ name: S.String, age: S.Number })
+ *
+ * Key differences:
+ * - Effect Schema uses PascalCase for primitives (S.String, S.Number)
+ * - Effect Schema uses S.Struct instead of t.type for objects
+ * - Effect Schema uses S.Union instead of t.union
+ * - Effect Schema uses branded types via S.brand()
+ * - Effect Schema is pipe-based using Effect's pipe() utility
+ */
+/** io-ts codec → Effect Schema equivalent */
+declare const IO_TS_TO_EFFECT_CODECS: Record<string, string>;
+/** io-ts combinators → Effect Schema combinators */
+declare const IO_TS_TO_EFFECT_COMBINATORS: Record<string, string>;
+/** fp-ts imports that need transformation */
+declare const FP_TS_PATTERNS: string[];
+/** Patterns requiring manual review */
+declare const MANUAL_REVIEW_PATTERNS: string[];
+/** Import mapping */
+declare const IMPORT_MAPPINGS: {
+    ioTsToEffect: {
+        ioTsImport: string;
+        effectImport: string;
+        pipeImport: string;
+    };
+};
+
+export { FP_TS_PATTERNS, IMPORT_MAPPINGS, IO_TS_TO_EFFECT_CODECS, IO_TS_TO_EFFECT_COMBINATORS, MANUAL_REVIEW_PATTERNS, createIoTsToEffectHandler };

package/dist/index.js

@@ -0,0 +1,267 @@
+// src/mappings.ts
+var IO_TS_TO_EFFECT_CODECS = {
+  "t.string": "S.String",
+  "t.number": "S.Number",
+  "t.boolean": "S.Boolean",
+  "t.bigint": "S.BigInt",
+  "t.unknown": "S.Unknown",
+  "t.never": "S.Never",
+  "t.null": "S.Null",
+  "t.undefined": "S.Undefined",
+  "t.void": "S.Void",
+  "t.any": "S.Unknown",
+  "t.Int": "pipe(S.Number, S.int())",
+  "t.literal": "S.Literal"
+};
+var IO_TS_TO_EFFECT_COMBINATORS = {
+  "t.type": "S.Struct",
+  "t.partial": "S.partial(S.Struct",
+  "t.array": "S.Array",
+  "t.record": "S.Record",
+  "t.union": "S.Union",
+  "t.intersection": "S.extend",
+  "t.tuple": "S.Tuple",
+  "t.readonly": "S.Struct",
+  // Effect Schema structs are readonly by default
+  "t.readonlyArray": "S.Array",
+  "t.exact": "S.Struct",
+  "t.strict": "S.Struct",
+  "t.keyof": "S.Literal"
+};
+var FP_TS_PATTERNS = [
+  "pipe",
+  "flow",
+  "Either",
+  "Option",
+  "TaskEither",
+  "fold",
+  "map",
+  "chain",
+  "getOrElse",
+  "isLeft",
+  "isRight"
+];
+var MANUAL_REVIEW_PATTERNS = [
+  "branded",
+  "withMessage",
+  "withFallback",
+  "taggedUnion",
+  "recursion",
+  "exact",
+  "clean",
+  "alias"
+];
+var IMPORT_MAPPINGS = {
+  ioTsToEffect: {
+    ioTsImport: "import * as t from 'io-ts'",
+    effectImport: "import { Schema as S } from '@effect/schema'",
+    pipeImport: "import { pipe } from 'effect/Function'"
+  }
+};
+
+// src/io-ts-to-effect-transformer.ts
+var IoTsToEffectTransformer = class {
+  errors = [];
+  warnings = [];
+  needsPipe = false;
+  transform(sourceFile) {
+    this.errors = [];
+    this.warnings = [];
+    this.needsPipe = false;
+    const filePath = sourceFile.getFilePath();
+    const originalCode = sourceFile.getFullText();
+    try {
+      let text = originalCode;
+      text = this.transformCodecs(text, filePath);
+      text = this.transformTypeHelpers(text);
+      this.checkManualReviewPatterns(text, filePath);
+      text = this.rewriteImports(text, filePath);
+      sourceFile.replaceWithText(text);
+      return {
+        success: this.errors.length === 0,
+        filePath,
+        originalCode,
+        transformedCode: sourceFile.getFullText(),
+        errors: this.errors,
+        warnings: this.warnings
+      };
+    } catch (error) {
+      this.errors.push({
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+      return {
+        success: false,
+        filePath,
+        originalCode,
+        errors: this.errors,
+        warnings: this.warnings
+      };
+    }
+  }
+  rewriteImports(text, filePath) {
+    text = text.replace(
+      /import\s*\*\s*as\s*t\s*from\s*['"]io-ts['"]/g,
+      "import { Schema as S } from '@effect/schema'"
+    );
+    text = text.replace(
+      /import\s*\{[^}]+\}\s*from\s*['"]io-ts['"]/g,
+      "import { Schema as S } from '@effect/schema'"
+    );
+    text = text.replace(
+      /import\s+type\s*\{[^}]*\bTypeOf\b[^}]*\}\s*from\s*['"]io-ts['"]/g,
+      "import type { Schema } from '@effect/schema'"
+    );
+    if (this.needsPipe && !text.includes("from 'effect/Function'")) {
+      text = text.replace(
+        /import\s*\{[^}]*Schema[^}]*\}\s*from\s*['"]@effect\/schema['"]/,
+        (match) => `${match}
+import { pipe } from 'effect/Function'`
+      );
+    }
+    if (/from\s*['"]fp-ts/.test(text)) {
+      this.warnings.push(
+        `${filePath}: fp-ts imports detected. Effect has built-in equivalents: pipe from effect/Function, Either from effect/Either, Option from effect/Option.`
+      );
+    }
+    text = text.replace(
+      /import\s*\{[^}]*\bpipe\b[^}]*\}\s*from\s*['"]fp-ts\/function['"]/g,
+      "import { pipe } from 'effect/Function'"
+    );
+    return text;
+  }
+  transformCodecs(text, filePath) {
+    for (const [ioTsCodec, effectCodec] of Object.entries(IO_TS_TO_EFFECT_CODECS)) {
+      if (text.includes(ioTsCodec)) {
+        const pattern = new RegExp(this.escapeRegex(ioTsCodec), "g");
+        text = text.replace(pattern, effectCodec);
+        if (effectCodec.includes("pipe(")) {
+          this.needsPipe = true;
+        }
+      }
+    }
+    for (const [ioTsCombinator, effectCombinator] of Object.entries(IO_TS_TO_EFFECT_COMBINATORS)) {
+      if (text.includes(ioTsCombinator)) {
+        const pattern = new RegExp(`${this.escapeRegex(ioTsCombinator)}\\(`, "g");
+        text = text.replace(pattern, `${effectCombinator}(`);
+      }
+    }
+    if (text.includes("S.partial(S.Struct(")) {
+      text = this.fixPartialClosingParens(text);
+    }
+    text = text.replace(/S\.Union\(\[([^\]]+)\]\)/g, "S.Union($1)");
+    text = text.replace(/S\.extend\(\[([^,\]]+),\s*([^\]]+)\]\)/g, (_m, a, b) => {
+      this.needsPipe = true;
+      return `pipe(${a.trim()}, S.extend(${b.trim()}))`;
+    });
+    text = text.replace(/t\.TypeOf<typeof\s+(\w+)>/g, "S.Schema.Type<typeof $1>");
+    text = text.replace(/t\.OutputOf<typeof\s+(\w+)>/g, "S.Schema.Type<typeof $1>");
+    text = text.replace(/t\.InputOf<typeof\s+(\w+)>/g, "S.Schema.Encoded<typeof $1>");
+    if (text.includes(".decode(")) {
+      this.warnings.push(
+        `${filePath}: io-ts .decode() should be converted to S.decodeUnknownSync() or S.decodeUnknownEither().`
+      );
+    }
+    if (text.includes(".encode(")) {
+      this.warnings.push(
+        `${filePath}: io-ts .encode() should be converted to S.encodeSync() or S.encodeEither().`
+      );
+    }
+    if (text.includes("t.brand(")) {
+      this.warnings.push(
+        `${filePath}: io-ts t.brand() should be converted to pipe(schema, S.brand("BrandName")).`
+      );
+    }
+    if (text.includes("isRight(") || text.includes("isLeft(")) {
+      this.warnings.push(
+        `${filePath}: fp-ts isRight/isLeft should use Effect's Either.isRight/Either.isLeft.`
+      );
+    }
+    if (/\bt\./.test(text)) {
+      this.warnings.push(
+        `${filePath}: Some io-ts patterns could not be auto-transformed to Effect Schema. Look for remaining t.* references and convert manually.`
+      );
+    }
+    return text;
+  }
+  transformTypeHelpers(text) {
+    text = text.replace(/\bt\.Type\b/g, "S.Schema");
+    text = text.replace(/\bt\.Mixed\b/g, "S.Schema<unknown>");
+    return text;
+  }
+  fixPartialClosingParens(text) {
+    let result = "";
+    let i = 0;
+    while (i < text.length) {
+      const partialIdx = text.indexOf("S.partial(S.Struct(", i);
+      if (partialIdx === -1) {
+        result += text.slice(i);
+        break;
+      }
+      result += text.slice(i, partialIdx);
+      const startParen = partialIdx + "S.partial(S.Struct(".length;
+      let depth = 1;
+      let j = startParen;
+      while (j < text.length && text[j] !== "{") j++;
+      j++;
+      depth = 1;
+      while (j < text.length && depth > 0) {
+        if (text[j] === "{") depth++;
+        if (text[j] === "}") depth--;
+        j++;
+      }
+      if (j < text.length && text[j] === ")") {
+        result += `S.partial(S.Struct(${text.slice(startParen, j + 1)})`;
+        i = j + 1;
+      } else {
+        result += text.slice(partialIdx, j);
+        i = j;
+      }
+    }
+    return result;
+  }
+  checkManualReviewPatterns(text, filePath) {
+    for (const pattern of MANUAL_REVIEW_PATTERNS) {
+      if (text.includes(`.${pattern}(`) || text.includes(`t.${pattern}`)) {
+        const guidance = this.getManualGuidance(pattern);
+        this.warnings.push(
+          `${filePath}: ${pattern} requires manual conversion to Effect Schema. ${guidance}`
+        );
+      }
+    }
+  }
+  getManualGuidance(pattern) {
+    const guidance = {
+      branded: 'Use pipe(schema, S.brand("Name")) in Effect Schema.',
+      withMessage: "Use S.message() or S.annotations({ message: ... }) in Effect Schema.",
+      withFallback: "Handle fallbacks at the application level or use S.optional with default.",
+      taggedUnion: "Effect Schema uses S.Union with S.Struct variants (discriminated automatically).",
+      recursion: "Use S.suspend(() => schema) for recursive types in Effect Schema.",
+      exact: "Effect Schema structs are exact by default (no extra keys).",
+      clean: "Not needed in Effect Schema \u2014 structs strip unknown keys by default.",
+      alias: "Not applicable in Effect Schema \u2014 use TypeScript type aliases directly."
+    };
+    return guidance[pattern] || "See Effect Schema documentation for equivalent pattern.";
+  }
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+};
+
+// src/io-ts-to-effect-handler.ts
+function createIoTsToEffectHandler() {
+  return {
+    transform(sourceFile, _options) {
+      const transformer = new IoTsToEffectTransformer();
+      return transformer.transform(sourceFile);
+    }
+  };
+}
+export {
+  FP_TS_PATTERNS,
+  IMPORT_MAPPINGS,
+  IO_TS_TO_EFFECT_CODECS,
+  IO_TS_TO_EFFECT_COMBINATORS,
+  MANUAL_REVIEW_PATTERNS,
+  createIoTsToEffectHandler
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mappings.ts","../src/io-ts-to-effect-transformer.ts","../src/io-ts-to-effect-handler.ts"],"sourcesContent":["/**\n * io-ts → Effect Schema type mappings\n *\n * io-ts uses fp-ts style codecs:\n *   io-ts:         t.type({ name: t.string, age: t.number })\n *   Effect Schema: S.Struct({ name: S.String, age: S.Number })\n *\n * Key differences:\n * - Effect Schema uses PascalCase for primitives (S.String, S.Number)\n * - Effect Schema uses S.Struct instead of t.type for objects\n * - Effect Schema uses S.Union instead of t.union\n * - Effect Schema uses branded types via S.brand()\n * - Effect Schema is pipe-based using Effect's pipe() utility\n */\n\n/** io-ts codec → Effect Schema equivalent */\nexport const IO_TS_TO_EFFECT_CODECS: Record<string, string> = {\n  't.string': 'S.String',\n  't.number': 'S.Number',\n  't.boolean': 'S.Boolean',\n  't.bigint': 'S.BigInt',\n  't.unknown': 'S.Unknown',\n  't.never': 'S.Never',\n  't.null': 'S.Null',\n  't.undefined': 'S.Undefined',\n  't.void': 'S.Void',\n  't.any': 'S.Unknown',\n  't.Int': 'pipe(S.Number, S.int())',\n  't.literal': 'S.Literal',\n};\n\n/** io-ts combinators → Effect Schema combinators */\nexport const IO_TS_TO_EFFECT_COMBINATORS: Record<string, string> = {\n  't.type': 'S.Struct',\n  't.partial': 'S.partial(S.Struct',\n  't.array': 'S.Array',\n  't.record': 'S.Record',\n  't.union': 'S.Union',\n  't.intersection': 'S.extend',\n  't.tuple': 'S.Tuple',\n  't.readonly': 'S.Struct', // Effect Schema structs are readonly by default\n  't.readonlyArray': 'S.Array',\n  't.exact': 'S.Struct',\n  't.strict': 'S.Struct',\n  't.keyof': 'S.Literal',\n};\n\n/** fp-ts imports that need transformation */\nexport const FP_TS_PATTERNS = [\n  'pipe',\n  'flow',\n  'Either',\n  'Option',\n  'TaskEither',\n  'fold',\n  'map',\n  'chain',\n  'getOrElse',\n  'isLeft',\n  'isRight',\n];\n\n/** Patterns requiring manual review */\nexport const MANUAL_REVIEW_PATTERNS = [\n  'branded',\n  'withMessage',\n  'withFallback',\n  'taggedUnion',\n  'recursion',\n  'exact',\n  'clean',\n  'alias',\n];\n\n/** Import mapping */\nexport const IMPORT_MAPPINGS = {\n  ioTsToEffect: {\n    ioTsImport: \"import * as t from 'io-ts'\",\n    effectImport: \"import { Schema as S } from '@effect/schema'\",\n    pipeImport: \"import { pipe } from 'effect/Function'\",\n  },\n};\n","import type { TransformError, TransformResult } from '@schemashift/core';\nimport type { SourceFile } from 'ts-morph';\nimport {\n  IO_TS_TO_EFFECT_CODECS,\n  IO_TS_TO_EFFECT_COMBINATORS,\n  MANUAL_REVIEW_PATTERNS,\n} from './mappings.js';\n\n/**\n * io-ts → Effect Schema Transformer\n *\n * Converts io-ts codecs to Effect Schema definitions.\n * This is the successor path for io-ts users since fp-ts merged into Effect.\n *\n *   io-ts:         t.type({ name: t.string, age: t.number })\n *   Effect Schema: S.Struct({ name: S.String, age: S.Number })\n */\nexport class IoTsToEffectTransformer {\n  private errors: TransformError[] = [];\n  private warnings: string[] = [];\n  private needsPipe = false;\n\n  transform(sourceFile: SourceFile): TransformResult {\n    this.errors = [];\n    this.warnings = [];\n    this.needsPipe = false;\n\n    const filePath = sourceFile.getFilePath();\n    const originalCode = sourceFile.getFullText();\n\n    try {\n      let text = originalCode;\n\n      // Step 1: Transform codecs and combinators\n      text = this.transformCodecs(text, filePath);\n\n      // Step 2: Transform type helpers\n      text = this.transformTypeHelpers(text);\n\n      // Step 3: Check for patterns requiring manual review\n      this.checkManualReviewPatterns(text, filePath);\n\n      // Step 4: Rewrite imports (last, so we know if pipe is needed)\n      text = this.rewriteImports(text, filePath);\n\n      sourceFile.replaceWithText(text);\n\n      return {\n        success: this.errors.length === 0,\n        filePath,\n        originalCode,\n        transformedCode: sourceFile.getFullText(),\n        errors: this.errors,\n        warnings: this.warnings,\n      };\n    } catch (error) {\n      this.errors.push({\n        message: error instanceof Error ? error.message : 'Unknown error',\n      });\n      return {\n        success: false,\n        filePath,\n        originalCode,\n        errors: this.errors,\n        warnings: this.warnings,\n      };\n    }\n  }\n\n  private rewriteImports(text: string, filePath: string): string {\n    // Replace io-ts import\n    text = text.replace(\n      /import\\s*\\*\\s*as\\s*t\\s*from\\s*['\"]io-ts['\"]/g,\n      \"import { Schema as S } from '@effect/schema'\",\n    );\n\n    // Replace named io-ts imports\n    text = text.replace(\n      /import\\s*\\{[^}]+\\}\\s*from\\s*['\"]io-ts['\"]/g,\n      \"import { Schema as S } from '@effect/schema'\",\n    );\n\n    // Replace io-ts type imports\n    text = text.replace(\n      /import\\s+type\\s*\\{[^}]*\\bTypeOf\\b[^}]*\\}\\s*from\\s*['\"]io-ts['\"]/g,\n      \"import type { Schema } from '@effect/schema'\",\n    );\n\n    // Add pipe import if needed\n    if (this.needsPipe && !text.includes(\"from 'effect/Function'\")) {\n      text = text.replace(\n        /import\\s*\\{[^}]*Schema[^}]*\\}\\s*from\\s*['\"]@effect\\/schema['\"]/,\n        (match) => `${match}\\nimport { pipe } from 'effect/Function'`,\n      );\n    }\n\n    // Handle fp-ts imports — warn about them\n    if (/from\\s*['\"]fp-ts/.test(text)) {\n      this.warnings.push(\n        `${filePath}: fp-ts imports detected. Effect has built-in equivalents: ` +\n          'pipe from effect/Function, Either from effect/Either, Option from effect/Option.',\n      );\n    }\n\n    // Replace fp-ts pipe import\n    text = text.replace(\n      /import\\s*\\{[^}]*\\bpipe\\b[^}]*\\}\\s*from\\s*['\"]fp-ts\\/function['\"]/g,\n      \"import { pipe } from 'effect/Function'\",\n    );\n\n    return text;\n  }\n\n  private transformCodecs(text: string, filePath: string): string {\n    // Transform simple codecs: t.string → S.String, etc.\n    for (const [ioTsCodec, effectCodec] of Object.entries(IO_TS_TO_EFFECT_CODECS)) {\n      if (text.includes(ioTsCodec)) {\n        const pattern = new RegExp(this.escapeRegex(ioTsCodec), 'g');\n        text = text.replace(pattern, effectCodec);\n        if (effectCodec.includes('pipe(')) {\n          this.needsPipe = true;\n        }\n      }\n    }\n\n    // Transform combinators: t.type → S.Struct, etc.\n    for (const [ioTsCombinator, effectCombinator] of Object.entries(IO_TS_TO_EFFECT_COMBINATORS)) {\n      if (text.includes(ioTsCombinator)) {\n        const pattern = new RegExp(`${this.escapeRegex(ioTsCombinator)}\\\\(`, 'g');\n        text = text.replace(pattern, `${effectCombinator}(`);\n      }\n    }\n\n    // Transform t.partial({...}) → S.partial(S.Struct({...}))\n    // Already handled by combinator mapping, but need to close the extra paren\n    // t.partial({...}) becomes S.partial(S.Struct({...})) — need closing paren\n    if (text.includes('S.partial(S.Struct(')) {\n      text = this.fixPartialClosingParens(text);\n    }\n\n    // Transform t.union([A, B]) → S.Union(A, B) — Effect Schema uses spread, not array\n    text = text.replace(/S\\.Union\\(\\[([^\\]]+)\\]\\)/g, 'S.Union($1)');\n\n    // Transform t.intersection([A, B]) → pipe(A, S.extend(B))\n    text = text.replace(/S\\.extend\\(\\[([^,\\]]+),\\s*([^\\]]+)\\]\\)/g, (_m, a: string, b: string) => {\n      this.needsPipe = true;\n      return `pipe(${a.trim()}, S.extend(${b.trim()}))`;\n    });\n\n    // Transform TypeOf: t.TypeOf<typeof schema> → S.Schema.Type<typeof schema>\n    text = text.replace(/t\\.TypeOf<typeof\\s+(\\w+)>/g, 'S.Schema.Type<typeof $1>');\n\n    // Transform OutputOf: t.OutputOf<typeof schema> → S.Schema.Type<typeof schema>\n    text = text.replace(/t\\.OutputOf<typeof\\s+(\\w+)>/g, 'S.Schema.Type<typeof $1>');\n\n    // Transform InputOf: t.InputOf<typeof schema> → S.Schema.Encoded<typeof schema>\n    text = text.replace(/t\\.InputOf<typeof\\s+(\\w+)>/g, 'S.Schema.Encoded<typeof $1>');\n\n    // Transform decode/encode patterns\n    if (text.includes('.decode(')) {\n      this.warnings.push(\n        `${filePath}: io-ts .decode() should be converted to S.decodeUnknownSync() or S.decodeUnknownEither().`,\n      );\n    }\n\n    if (text.includes('.encode(')) {\n      this.warnings.push(\n        `${filePath}: io-ts .encode() should be converted to S.encodeSync() or S.encodeEither().`,\n      );\n    }\n\n    // Transform t.brand — Effect Schema uses S.brand()\n    if (text.includes('t.brand(')) {\n      this.warnings.push(\n        `${filePath}: io-ts t.brand() should be converted to pipe(schema, S.brand(\"BrandName\")).`,\n      );\n    }\n\n    // Transform isRight/isLeft patterns\n    if (text.includes('isRight(') || text.includes('isLeft(')) {\n      this.warnings.push(\n        `${filePath}: fp-ts isRight/isLeft should use Effect's Either.isRight/Either.isLeft.`,\n      );\n    }\n\n    // Warn about remaining t.* patterns\n    if (/\\bt\\./.test(text)) {\n      this.warnings.push(\n        `${filePath}: Some io-ts patterns could not be auto-transformed to Effect Schema. ` +\n          'Look for remaining t.* references and convert manually.',\n      );\n    }\n\n    return text;\n  }\n\n  private transformTypeHelpers(text: string): string {\n    // Handle any remaining type references\n    text = text.replace(/\\bt\\.Type\\b/g, 'S.Schema');\n    text = text.replace(/\\bt\\.Mixed\\b/g, 'S.Schema<unknown>');\n\n    return text;\n  }\n\n  private fixPartialClosingParens(text: string): string {\n    // Find S.partial(S.Struct({...}) and add closing paren\n    // This is a simplified approach — handles single-level objects\n    let result = '';\n    let i = 0;\n    while (i < text.length) {\n      const partialIdx = text.indexOf('S.partial(S.Struct(', i);\n      if (partialIdx === -1) {\n        result += text.slice(i);\n        break;\n      }\n\n      result += text.slice(i, partialIdx);\n      const startParen = partialIdx + 'S.partial(S.Struct('.length;\n\n      // Find matching closing brace for the object literal\n      let depth = 1; // counting from the opening { after S.Struct(\n      let j = startParen;\n      // Find the opening brace\n      while (j < text.length && text[j] !== '{') j++;\n      j++; // skip the {\n      depth = 1;\n\n      while (j < text.length && depth > 0) {\n        if (text[j] === '{') depth++;\n        if (text[j] === '}') depth--;\n        j++;\n      }\n\n      // Now j points right after the closing }\n      // We expect ) for S.Struct closing, then we need to add ) for S.partial closing\n      if (j < text.length && text[j] === ')') {\n        result += `S.partial(S.Struct(${text.slice(startParen, j + 1)})`;\n        i = j + 1;\n      } else {\n        result += text.slice(partialIdx, j);\n        i = j;\n      }\n    }\n    return result;\n  }\n\n  private checkManualReviewPatterns(text: string, filePath: string): void {\n    for (const pattern of MANUAL_REVIEW_PATTERNS) {\n      if (text.includes(`.${pattern}(`) || text.includes(`t.${pattern}`)) {\n        const guidance = this.getManualGuidance(pattern);\n        this.warnings.push(\n          `${filePath}: ${pattern} requires manual conversion to Effect Schema. ${guidance}`,\n        );\n      }\n    }\n  }\n\n  private getManualGuidance(pattern: string): string {\n    const guidance: Record<string, string> = {\n      branded: 'Use pipe(schema, S.brand(\"Name\")) in Effect Schema.',\n      withMessage: 'Use S.message() or S.annotations({ message: ... }) in Effect Schema.',\n      withFallback: 'Handle fallbacks at the application level or use S.optional with default.',\n      taggedUnion:\n        'Effect Schema uses S.Union with S.Struct variants (discriminated automatically).',\n      recursion: 'Use S.suspend(() => schema) for recursive types in Effect Schema.',\n      exact: 'Effect Schema structs are exact by default (no extra keys).',\n      clean: 'Not needed in Effect Schema — structs strip unknown keys by default.',\n      alias: 'Not applicable in Effect Schema — use TypeScript type aliases directly.',\n    };\n    return guidance[pattern] || 'See Effect Schema documentation for equivalent pattern.';\n  }\n\n  private escapeRegex(str: string): string {\n    return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n  }\n}\n","import type { TransformHandler, TransformOptions, TransformResult } from '@schemashift/core';\nimport type { SourceFile } from 'ts-morph';\nimport { IoTsToEffectTransformer } from './io-ts-to-effect-transformer.js';\n\nexport function createIoTsToEffectHandler(): TransformHandler {\n  return {\n    transform(sourceFile: SourceFile, _options: TransformOptions): TransformResult {\n      const transformer = new IoTsToEffectTransformer();\n      return transformer.transform(sourceFile);\n    },\n  };\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@schemashift/io-ts-effect",
+  "version": "0.10.0",
+  "description": "io-ts → Effect Schema transformer for SchemaShift",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "schemashift",
+    "io-ts",
+    "effect",
+    "schema",
+    "migration",
+    "codemod"
+  ],
+  "author": "Joseph May",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {
+    "@schemashift/core": "0.10.0",
+    "ts-morph": "27.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}