@intlayer/chokidar 9.0.0-canary.0 → 9.0.0-canary.2

package/dist/cjs/docReview/rebuildDocument.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebuildDocument.cjs","names":[],"sources":["../../../src/docReview/rebuildDocument.ts"],"sourcesContent":["import type { AlignmentPlan, FingerprintedBlock } from './types';\n\n/**\n * A block that needs to be translated or re-translated by an external consumer\n * (an AI client, a human, or an agent).\n */\nexport type SegmentToReview = {\n  /** The base block to translate. */\n  baseBlock: FingerprintedBlock;\n  /** Existing target translation, or `null` when the block is new. */\n  targetBlockText: string | null;\n  /** Index of the originating action within {@link AlignmentPlan.actions}. */\n  actionIndex: number;\n};\n\nexport type RebuildInput = {\n  baseBlocks: FingerprintedBlock[];\n  targetBlocks: FingerprintedBlock[];\n  plan: AlignmentPlan;\n};\n\nexport type RebuildResult = {\n  segmentsToReview: SegmentToReview[];\n};\n\n/**\n * Analyze the alignment plan and return only the segments that need\n * review/translation. Does not generate output text - that is done by\n * {@link mergeReviewedSegments} once the translations are available.\n *\n * @param input - The base/target blocks and the alignment plan.\n * @returns The list of segments that require translation.\n */\nexport const identifySegmentsToReview = ({\n  baseBlocks,\n  targetBlocks,\n  plan,\n}: RebuildInput): RebuildResult => {\n  const segmentsToReview: SegmentToReview[] = [];\n\n  plan.actions.forEach((action, actionIndex) => {\n    if (action.kind === 'review') {\n      const baseBlock = baseBlocks[action.baseIndex];\n      const targetBlockText =\n        action.targetIndex !== null\n          ? targetBlocks[action.targetIndex].content\n          : null;\n\n      segmentsToReview.push({ baseBlock, targetBlockText, actionIndex });\n    } else if (action.kind === 'insert_new') {\n      const baseBlock = baseBlocks[action.baseIndex];\n\n      segmentsToReview.push({\n        baseBlock,\n        targetBlockText: null,\n        actionIndex,\n      });\n    }\n  });\n\n  return { segmentsToReview };\n};\n\n/**\n * Merge reviewed translations back into the final document following the\n * alignment plan, reusing untouched target blocks as-is.\n *\n * @param plan - The alignment plan.\n * @param targetBlocks - Blocks of the existing target document.\n * @param reviewedSegments - Map of action index to its reviewed translation.\n * @returns The rebuilt target document.\n */\nexport const mergeReviewedSegments = (\n  plan: AlignmentPlan,\n  targetBlocks: FingerprintedBlock[],\n  reviewedSegments: Map<number, string>\n): string => {\n  const outputParts: string[] = [];\n\n  plan.actions.forEach((action, actionIndex) => {\n    if (action.kind === 'reuse') {\n      outputParts.push(targetBlocks[action.targetIndex].content);\n    } else if (action.kind === 'review' || action.kind === 'insert_new') {\n      const reviewedContent = reviewedSegments.get(actionIndex);\n\n      if (reviewedContent !== undefined) {\n        outputParts.push(reviewedContent);\n      } else {\n        // Fallback: if review failed, use existing or blank\n        if (action.kind === 'review' && action.targetIndex !== null) {\n          outputParts.push(targetBlocks[action.targetIndex].content);\n        } else {\n          outputParts.push('\\n');\n        }\n      }\n    } else if (action.kind === 'delete') {\n      const reviewedContent = reviewedSegments.get(actionIndex);\n      if (reviewedContent !== undefined) {\n        // Caller explicitly resolved this block: empty string = actually delete,\n        // non-empty string = replacement content.\n        if (reviewedContent) outputParts.push(reviewedContent);\n      } else {\n        // Default: keep verbatim. A target block with no base counterpart may\n        // just be a section the aligner could not follow (reordering, split\n        // prose) — keeping it prevents accidental data loss in log/read-only mode.\n        outputParts.push(targetBlocks[action.targetIndex].content);\n      }\n    }\n  });\n\n  return outputParts.join('');\n};\n"],"mappings":";;;;;;;;;;;AAiCA,MAAa,4BAA4B,EACvC,YACA,cACA,WACiC;CACjC,MAAM,mBAAsC,EAAE;AAE9C,MAAK,QAAQ,SAAS,QAAQ,gBAAgB;AAC5C,MAAI,OAAO,SAAS,UAAU;GAC5B,MAAM,YAAY,WAAW,OAAO;GACpC,MAAM,kBACJ,OAAO,gBAAgB,OACnB,aAAa,OAAO,aAAa,UACjC;AAEN,oBAAiB,KAAK;IAAE;IAAW;IAAiB;IAAa,CAAC;aACzD,OAAO,SAAS,cAAc;GACvC,MAAM,YAAY,WAAW,OAAO;AAEpC,oBAAiB,KAAK;IACpB;IACA,iBAAiB;IACjB;IACD,CAAC;;GAEJ;AAEF,QAAO,EAAE,kBAAkB;;;;;;;;;;;AAY7B,MAAa,yBACX,MACA,cACA,qBACW;CACX,MAAM,cAAwB,EAAE;AAEhC,MAAK,QAAQ,SAAS,QAAQ,gBAAgB;AAC5C,MAAI,OAAO,SAAS,QAClB,aAAY,KAAK,aAAa,OAAO,aAAa,QAAQ;WACjD,OAAO,SAAS,YAAY,OAAO,SAAS,cAAc;GACnE,MAAM,kBAAkB,iBAAiB,IAAI,YAAY;AAEzD,OAAI,oBAAoB,OACtB,aAAY,KAAK,gBAAgB;YAG7B,OAAO,SAAS,YAAY,OAAO,gBAAgB,KACrD,aAAY,KAAK,aAAa,OAAO,aAAa,QAAQ;OAE1D,aAAY,KAAK,KAAK;aAGjB,OAAO,SAAS,UAAU;GACnC,MAAM,kBAAkB,iBAAiB,IAAI,YAAY;AACzD,OAAI,oBAAoB,QAGtB;QAAI,gBAAiB,aAAY,KAAK,gBAAgB;SAKtD,aAAY,KAAK,aAAa,OAAO,aAAa,QAAQ;;GAG9D;AAEF,QAAO,YAAY,KAAK,GAAG"}

package/dist/cjs/docReview/reviewReport.cjs

@@ -0,0 +1,200 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_docReview_pipeline = require('./pipeline.cjs');
+let _intlayer_config_logger = require("@intlayer/config/logger");
+let _intlayer_config_colors = require("@intlayer/config/colors");
+_intlayer_config_colors = require_runtime.__toESM(_intlayer_config_colors);
+
+//#region src/docReview/reviewReport.ts
+/**
+* Compare a base markdown document with its translation and report only the
+* blocks that need attention, with their line ranges and content.
+*
+* Reusable across the CLI (`doc review --log`), the backend (comparing two
+* translation contents stored in database), and agents that generate the
+* missing translations.
+*
+* @param input - The base/target texts and optional changed lines.
+* @returns The divergent blocks and a per-action summary.
+*/
+const buildReviewReport = ({ baseText, targetText, changedLines }) => {
+	const { baseBlocks, targetBlocks, plan } = require_docReview_pipeline.buildAlignmentPlan({
+		baseText,
+		targetText,
+		changedLines
+	});
+	const summary = {
+		reuse: 0,
+		review: 0,
+		insertNew: 0,
+		delete: 0
+	};
+	const blocks = [];
+	for (const [actionIndex, action] of plan.actions.entries()) {
+		if (action.kind === "reuse") {
+			summary.reuse += 1;
+			continue;
+		}
+		if (action.kind === "review") {
+			summary.review += 1;
+			const baseBlock = baseBlocks[action.baseIndex];
+			if (!baseBlock) continue;
+			const targetBlock = action.targetIndex !== null ? targetBlocks[action.targetIndex] : null;
+			blocks.push({
+				action: "review",
+				baseLineRange: {
+					start: baseBlock.lineStart,
+					end: baseBlock.lineEnd
+				},
+				targetLineRange: targetBlock ? {
+					start: targetBlock.lineStart,
+					end: targetBlock.lineEnd
+				} : void 0,
+				baseContent: baseBlock.content,
+				targetContent: targetBlock?.content
+			});
+			continue;
+		}
+		if (action.kind === "insert_new") {
+			summary.insertNew += 1;
+			const baseBlock = baseBlocks[action.baseIndex];
+			if (!baseBlock) continue;
+			let insertAfterLine;
+			for (let prevIndex = actionIndex - 1; prevIndex >= 0; prevIndex--) {
+				const prevAction = plan.actions[prevIndex];
+				if (!prevAction) continue;
+				let targetIdx = null;
+				if (prevAction.kind === "reuse") targetIdx = prevAction.targetIndex;
+				else if (prevAction.kind === "review" && prevAction.targetIndex !== null) targetIdx = prevAction.targetIndex;
+				else if (prevAction.kind === "delete") targetIdx = prevAction.targetIndex;
+				if (targetIdx !== null) {
+					const prevTargetBlock = targetBlocks[targetIdx];
+					if (prevTargetBlock) {
+						insertAfterLine = prevTargetBlock.lineEnd + 1;
+						break;
+					}
+				}
+			}
+			blocks.push({
+				action: "insert_new",
+				baseLineRange: {
+					start: baseBlock.lineStart,
+					end: baseBlock.lineEnd
+				},
+				targetLineRange: insertAfterLine !== void 0 ? {
+					start: insertAfterLine,
+					end: insertAfterLine
+				} : void 0,
+				baseContent: baseBlock.content
+			});
+			continue;
+		}
+		if (action.kind === "delete") {
+			summary.delete += 1;
+			const targetBlock = targetBlocks[action.targetIndex];
+			if (!targetBlock) continue;
+			blocks.push({
+				action: "delete",
+				targetLineRange: {
+					start: targetBlock.lineStart,
+					end: targetBlock.lineEnd
+				},
+				targetContent: targetBlock.content
+			});
+		}
+	}
+	return {
+		blocks,
+		summary
+	};
+};
+/** Render a line range as a blue colored string, or an orange dash when absent. */
+const colorizeLineRange = (range) => {
+	if (!range) return (0, _intlayer_config_logger.colorize)("—", _intlayer_config_colors.ORANGE);
+	return (0, _intlayer_config_logger.colorize)(range.start === range.end ? `L${range.start}` : `L${range.start}-${range.end}`, _intlayer_config_colors.BLUE);
+};
+/**
+* Colorize a count with green when zero (nothing to do) and a caller-supplied
+* non-zero color (orange for warnings, red for destructive actions).
+*/
+const colorizeCount = (count, nonZeroColor) => (0, _intlayer_config_logger.colorizeNumber)(count, {
+	zero: _intlayer_config_colors.GREEN,
+	one: nonZeroColor,
+	two: nonZeroColor,
+	few: nonZeroColor,
+	many: nonZeroColor,
+	other: nonZeroColor
+});
+/**
+* Render a {@link ReviewReport} as a human and agent readable log.
+*
+* Each divergent block is printed with its action, the base/target line ranges,
+* the base content to translate, and the existing translation to update.
+*
+* @param report - The report to format.
+* @param options - Optional labels for the base and target locales.
+* @returns A multi-line string describing every block that needs attention.
+*/
+const formatReviewReport = (report, options) => {
+	const baseLabel = options?.baseLabel ?? "base";
+	const targetLabel = options?.targetLabel ?? "target";
+	const { summary, blocks } = report;
+	const header = [
+		(0, _intlayer_config_logger.colorize)("Review report: ", _intlayer_config_colors.ORANGE),
+		colorizeCount(blocks.length, _intlayer_config_colors.ORANGE),
+		(0, _intlayer_config_logger.colorize)(" block(s) need attention (review=", _intlayer_config_colors.ORANGE),
+		colorizeCount(summary.review, _intlayer_config_colors.ORANGE),
+		(0, _intlayer_config_logger.colorize)(", new=", _intlayer_config_colors.ORANGE),
+		colorizeCount(summary.insertNew, _intlayer_config_colors.ORANGE),
+		(0, _intlayer_config_logger.colorize)(", delete=", _intlayer_config_colors.ORANGE),
+		colorizeCount(summary.delete, _intlayer_config_colors.RED),
+		(0, _intlayer_config_logger.colorize)(", reuse=", _intlayer_config_colors.ORANGE),
+		(0, _intlayer_config_logger.colorizeNumber)(summary.reuse),
+		(0, _intlayer_config_logger.colorize)(").", _intlayer_config_colors.ORANGE)
+	].join("");
+	if (blocks.length === 0) return `${header}\n${(0, _intlayer_config_logger.colorize)("No changes needed.", _intlayer_config_colors.GREEN)}`;
+	const sections = blocks.map((block, index) => {
+		const lines = [];
+		const blockHeader = [
+			(0, _intlayer_config_logger.colorize)("--- Block ", _intlayer_config_colors.ORANGE),
+			(0, _intlayer_config_logger.colorizeNumber)(index + 1),
+			(0, _intlayer_config_logger.colorize)("/", _intlayer_config_colors.ORANGE),
+			(0, _intlayer_config_logger.colorizeNumber)(blocks.length),
+			(0, _intlayer_config_logger.colorize)(` [${block.action}] `, _intlayer_config_colors.ORANGE),
+			baseLabel,
+			(0, _intlayer_config_logger.colorize)(" ", _intlayer_config_colors.ORANGE),
+			colorizeLineRange(block.baseLineRange),
+			(0, _intlayer_config_logger.colorize)(" → ", _intlayer_config_colors.ORANGE),
+			targetLabel,
+			(0, _intlayer_config_logger.colorize)(" ", _intlayer_config_colors.ORANGE),
+			colorizeLineRange(block.targetLineRange),
+			(0, _intlayer_config_logger.colorize)(" ---", _intlayer_config_colors.ORANGE)
+		].join("");
+		lines.push(blockHeader);
+		if (block.baseContent !== void 0) {
+			lines.push((0, _intlayer_config_logger.colorize)(`[${baseLabel}]`, _intlayer_config_colors.BEIGE));
+			lines.push((0, _intlayer_config_logger.colorize)(block.baseContent.trimEnd(), _intlayer_config_colors.GREY));
+		}
+		if (block.targetContent !== void 0) {
+			lines.push((0, _intlayer_config_logger.colorize)(`[${targetLabel}]`, _intlayer_config_colors.BEIGE));
+			lines.push((0, _intlayer_config_logger.colorize)(block.targetContent.trimEnd(), _intlayer_config_colors.GREY));
+		} else if (block.action === "insert_new") {
+			lines.push((0, _intlayer_config_logger.colorize)(`[${targetLabel}]`, _intlayer_config_colors.BEIGE));
+			lines.push((0, _intlayer_config_logger.colorize)("(missing — to be translated)", _intlayer_config_colors.ORANGE));
+		}
+		return lines.join("\n");
+	});
+	const editingNote = (0, _intlayer_config_logger.colorize)("Tip: start editing from the last block — working bottom-up keeps earlier line numbers accurate.", _intlayer_config_colors.GREY);
+	return [
+		header,
+		"",
+		...sections,
+		"",
+		editingNote
+	].join("\n");
+};
+
+//#endregion
+exports.buildReviewReport = buildReviewReport;
+exports.formatReviewReport = formatReviewReport;
+//# sourceMappingURL=reviewReport.cjs.map

package/dist/cjs/docReview/reviewReport.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reviewReport.cjs","names":["buildAlignmentPlan","ANSIColors"],"sources":["../../../src/docReview/reviewReport.ts"],"sourcesContent":["import * as ANSIColors from '@intlayer/config/colors';\nimport { colorize, colorizeNumber } from '@intlayer/config/logger';\nimport { buildAlignmentPlan } from './pipeline';\n\n/**\n * The kind of change detected for a block when reviewing a translation against\n * its base document.\n *\n * - `review`: the base block changed and its translation must be updated.\n * - `insert_new`: the base block has no translation yet and must be added.\n * - `delete`: the target block no longer exists in the base and should be removed.\n */\nexport type ReviewBlockAction = 'review' | 'insert_new' | 'delete';\n\n/** A 1-based, inclusive line range within a document. */\nexport type LineRange = {\n  start: number;\n  end: number;\n};\n\n/**\n * A single block that diverges between the base document and its translation.\n *\n * This is the unit an external translator (AI client, human, or agent) needs to\n * act on: it carries the base content to translate, the existing translation to\n * update, and where each lives so the change can be located in the file.\n */\nexport type ReviewReportBlock = {\n  /** What should happen to this block. */\n  action: ReviewBlockAction;\n  /** Line range of the block in the base document (omitted for pure deletions). */\n  baseLineRange?: LineRange;\n  /** Line range of the block in the target document (omitted for new insertions). */\n  targetLineRange?: LineRange;\n  /** Raw markdown of the base block (omitted for pure deletions). */\n  baseContent?: string;\n  /** Existing translation of the block (omitted for new insertions). */\n  targetContent?: string;\n};\n\nexport type ReviewReportSummary = {\n  /** Number of blocks reused as-is (unchanged translation). */\n  reuse: number;\n  /** Number of blocks whose translation must be updated. */\n  review: number;\n  /** Number of blocks missing a translation. */\n  insertNew: number;\n  /** Number of stale target blocks to delete. */\n  delete: number;\n};\n\nexport type ReviewReport = {\n  /** Only the blocks that diverge (review, insert_new, delete). */\n  blocks: ReviewReportBlock[];\n  /** Counts per action over the whole document, including reused blocks. */\n  summary: ReviewReportSummary;\n};\n\nexport type BuildReviewReportInput = {\n  /** The base (source) document, used as the translation reference. */\n  baseText: string;\n  /** The existing target (translated) document, possibly empty. */\n  targetText: string;\n  /**\n   * 1-based line numbers that changed in the base document. When omitted, only\n   * inserted and deleted blocks are reported (no aligned block is flagged for\n   * review since there is no way to know which ones changed).\n   */\n  changedLines?: number[];\n};\n\n/**\n * Compare a base markdown document with its translation and report only the\n * blocks that need attention, with their line ranges and content.\n *\n * Reusable across the CLI (`doc review --log`), the backend (comparing two\n * translation contents stored in database), and agents that generate the\n * missing translations.\n *\n * @param input - The base/target texts and optional changed lines.\n * @returns The divergent blocks and a per-action summary.\n */\nexport const buildReviewReport = ({\n  baseText,\n  targetText,\n  changedLines,\n}: BuildReviewReportInput): ReviewReport => {\n  const { baseBlocks, targetBlocks, plan } = buildAlignmentPlan({\n    baseText,\n    targetText,\n    changedLines,\n  });\n\n  const summary: ReviewReportSummary = {\n    reuse: 0,\n    review: 0,\n    insertNew: 0,\n    delete: 0,\n  };\n\n  const blocks: ReviewReportBlock[] = [];\n\n  for (const [actionIndex, action] of plan.actions.entries()) {\n    if (action.kind === 'reuse') {\n      summary.reuse += 1;\n      continue;\n    }\n\n    if (action.kind === 'review') {\n      summary.review += 1;\n      const baseBlock = baseBlocks[action.baseIndex];\n\n      if (!baseBlock) continue;\n\n      const targetBlock =\n        action.targetIndex !== null ? targetBlocks[action.targetIndex] : null;\n\n      blocks.push({\n        action: 'review',\n        baseLineRange: { start: baseBlock.lineStart, end: baseBlock.lineEnd },\n        targetLineRange: targetBlock\n          ? { start: targetBlock.lineStart, end: targetBlock.lineEnd }\n          : undefined,\n        baseContent: baseBlock.content,\n        targetContent: targetBlock?.content,\n      });\n      continue;\n    }\n\n    if (action.kind === 'insert_new') {\n      summary.insertNew += 1;\n      const baseBlock = baseBlocks[action.baseIndex];\n\n      if (!baseBlock) continue;\n\n      // Find the target line after which the new block should be inserted:\n      // scan backwards for the last action that produced a target block.\n      let insertAfterLine: number | undefined;\n      for (let prevIndex = actionIndex - 1; prevIndex >= 0; prevIndex--) {\n        const prevAction = plan.actions[prevIndex];\n        if (!prevAction) continue;\n\n        let targetIdx: number | null = null;\n        if (prevAction.kind === 'reuse') targetIdx = prevAction.targetIndex;\n        else if (\n          prevAction.kind === 'review' &&\n          prevAction.targetIndex !== null\n        )\n          targetIdx = prevAction.targetIndex;\n        else if (prevAction.kind === 'delete')\n          targetIdx = prevAction.targetIndex;\n\n        if (targetIdx !== null) {\n          const prevTargetBlock = targetBlocks[targetIdx];\n          if (prevTargetBlock) {\n            insertAfterLine = prevTargetBlock.lineEnd + 1;\n            break;\n          }\n        }\n      }\n\n      blocks.push({\n        action: 'insert_new',\n        baseLineRange: { start: baseBlock.lineStart, end: baseBlock.lineEnd },\n        targetLineRange:\n          insertAfterLine !== undefined\n            ? { start: insertAfterLine, end: insertAfterLine }\n            : undefined,\n        baseContent: baseBlock.content,\n      });\n      continue;\n    }\n\n    if (action.kind === 'delete') {\n      summary.delete += 1;\n      const targetBlock = targetBlocks[action.targetIndex];\n\n      if (!targetBlock) continue;\n\n      blocks.push({\n        action: 'delete',\n        targetLineRange: {\n          start: targetBlock.lineStart,\n          end: targetBlock.lineEnd,\n        },\n        targetContent: targetBlock.content,\n      });\n    }\n  }\n\n  return { blocks, summary };\n};\n\n/** Render a line range as a blue colored string, or an orange dash when absent. */\nconst colorizeLineRange = (range?: LineRange): string => {\n  if (!range) return colorize('—', ANSIColors.ORANGE);\n  const rangeStr =\n    range.start === range.end\n      ? `L${range.start}`\n      : `L${range.start}-${range.end}`;\n  return colorize(rangeStr, ANSIColors.BLUE);\n};\n\n/**\n * Colorize a count with green when zero (nothing to do) and a caller-supplied\n * non-zero color (orange for warnings, red for destructive actions).\n */\nconst colorizeCount = (\n  count: number,\n  nonZeroColor: (typeof ANSIColors)[keyof typeof ANSIColors]\n): string =>\n  colorizeNumber(count, {\n    zero: ANSIColors.GREEN,\n    one: nonZeroColor,\n    two: nonZeroColor,\n    few: nonZeroColor,\n    many: nonZeroColor,\n    other: nonZeroColor,\n  });\n\n/**\n * Render a {@link ReviewReport} as a human and agent readable log.\n *\n * Each divergent block is printed with its action, the base/target line ranges,\n * the base content to translate, and the existing translation to update.\n *\n * @param report - The report to format.\n * @param options - Optional labels for the base and target locales.\n * @returns A multi-line string describing every block that needs attention.\n */\nexport const formatReviewReport = (\n  report: ReviewReport,\n  options?: { baseLabel?: string; targetLabel?: string }\n): string => {\n  const baseLabel = options?.baseLabel ?? 'base';\n  const targetLabel = options?.targetLabel ?? 'target';\n\n  const { summary, blocks } = report;\n\n  // Build the summary header piece-by-piece so each count uses its own color.\n  const header = [\n    colorize('Review report: ', ANSIColors.ORANGE),\n    colorizeCount(blocks.length, ANSIColors.ORANGE),\n    colorize(' block(s) need attention (review=', ANSIColors.ORANGE),\n    colorizeCount(summary.review, ANSIColors.ORANGE),\n    colorize(', new=', ANSIColors.ORANGE),\n    colorizeCount(summary.insertNew, ANSIColors.ORANGE),\n    colorize(', delete=', ANSIColors.ORANGE),\n    colorizeCount(summary.delete, ANSIColors.RED),\n    colorize(', reuse=', ANSIColors.ORANGE),\n    colorizeNumber(summary.reuse),\n    colorize(').', ANSIColors.ORANGE),\n  ].join('');\n\n  if (blocks.length === 0) {\n    return `${header}\\n${colorize('No changes needed.', ANSIColors.GREEN)}`;\n  }\n\n  const sections = blocks.map((block, index) => {\n    const lines: string[] = [];\n\n    // Block header: each token colored individually.\n    const blockHeader = [\n      colorize('--- Block ', ANSIColors.ORANGE),\n      colorizeNumber(index + 1),\n      colorize('/', ANSIColors.ORANGE),\n      colorizeNumber(blocks.length),\n      colorize(` [${block.action}] `, ANSIColors.ORANGE),\n      baseLabel,\n      colorize(' ', ANSIColors.ORANGE),\n      colorizeLineRange(block.baseLineRange),\n      colorize(' → ', ANSIColors.ORANGE),\n      targetLabel,\n      colorize(' ', ANSIColors.ORANGE),\n      colorizeLineRange(block.targetLineRange),\n      colorize(' ---', ANSIColors.ORANGE),\n    ].join('');\n\n    lines.push(blockHeader);\n\n    if (block.baseContent !== undefined) {\n      lines.push(colorize(`[${baseLabel}]`, ANSIColors.BEIGE));\n      lines.push(colorize(block.baseContent.trimEnd(), ANSIColors.GREY));\n    }\n\n    if (block.targetContent !== undefined) {\n      lines.push(colorize(`[${targetLabel}]`, ANSIColors.BEIGE));\n      lines.push(colorize(block.targetContent.trimEnd(), ANSIColors.GREY));\n    } else if (block.action === 'insert_new') {\n      lines.push(colorize(`[${targetLabel}]`, ANSIColors.BEIGE));\n      lines.push(colorize('(missing — to be translated)', ANSIColors.ORANGE));\n    }\n\n    return lines.join('\\n');\n  });\n\n  const editingNote = colorize(\n    'Tip: start editing from the last block — working bottom-up keeps earlier line numbers accurate.',\n    ANSIColors.GREY\n  );\n\n  return [header, '', ...sections, '', editingNote].join('\\n');\n};\n"],"mappings":"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"}

package/dist/cjs/docReview/segmentDocument.cjs

@@ -0,0 +1,134 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/docReview/segmentDocument.ts
+const isBlankLine = (line) => line.trim().length === 0;
+const isFencedCodeDelimiter = (line) => /^\s*```/.test(line);
+const isHeading = (line) => /^\s*#{1,6}\s+/.test(line);
+const isFrontmatterDelimiter = (line) => /^\s*---\s*$/.test(line);
+/**
+* Split a markdown document into fine-grained blocks.
+*
+* Boundaries are drawn at headings, blank lines (paragraph breaks) and fenced
+* code blocks, while frontmatter and the inside of code fences are kept intact.
+* Each blank-line run is appended to the block that precedes it, so the blocks
+* form an exact partition of the document: concatenating every `content` (in
+* order) yields the original text unchanged. This is what lets the block-aware
+* review re-translate only the paragraphs/snippets that actually changed instead
+* of the whole heading section.
+*
+* @param text - The full markdown document.
+* @returns The ordered list of blocks with their 1-based line ranges.
+*/
+const segmentDocument = (text) => {
+	const lines = text.split("\n");
+	const lineCount = lines.length;
+	const units = [];
+	let index = 0;
+	while (index < lineCount) {
+		const currentLine = lines[index];
+		if (isBlankLine(currentLine)) {
+			index += 1;
+			continue;
+		}
+		if (units.length === 0 && isFrontmatterDelimiter(currentLine)) {
+			const startIndex = index;
+			index += 1;
+			while (index < lineCount && !isFrontmatterDelimiter(lines[index])) index += 1;
+			if (index < lineCount) index += 1;
+			units.push({
+				type: "unknown",
+				startIndex,
+				endIndex: index - 1
+			});
+			continue;
+		}
+		if (isFencedCodeDelimiter(currentLine)) {
+			const startIndex = index;
+			index += 1;
+			while (index < lineCount && !isFencedCodeDelimiter(lines[index])) index += 1;
+			if (index < lineCount) index += 1;
+			units.push({
+				type: "code_block",
+				startIndex,
+				endIndex: index - 1
+			});
+			continue;
+		}
+		if (isHeading(currentLine)) {
+			units.push({
+				type: "heading",
+				startIndex: index,
+				endIndex: index
+			});
+			index += 1;
+			continue;
+		}
+		const startIndex = index;
+		while (index < lineCount && !isBlankLine(lines[index]) && !isHeading(lines[index]) && !isFencedCodeDelimiter(lines[index])) index += 1;
+		units.push({
+			type: "paragraph",
+			startIndex,
+			endIndex: index - 1
+		});
+	}
+	if (units.length === 0) return [];
+	return units.map((unit, unitIndex) => {
+		const blockStartIndex = unitIndex === 0 ? 0 : unit.startIndex;
+		const blockEndIndex = unitIndex === units.length - 1 ? lineCount - 1 : units[unitIndex + 1].startIndex - 1;
+		const blockLines = lines.slice(blockStartIndex, blockEndIndex + 1);
+		const content = blockEndIndex < lineCount - 1 ? `${blockLines.join("\n")}\n` : blockLines.join("\n");
+		return {
+			type: unit.type,
+			content,
+			lineStart: blockStartIndex + 1,
+			lineEnd: blockEndIndex + 1
+		};
+	});
+};
+/**
+* Split a markdown document into coarse, heading-anchored sections.
+*
+* Built by grouping the fine blocks of {@link segmentDocument}: frontmatter and
+* each heading open a new section, and the following non-heading blocks are
+* folded into it. Because it only concatenates adjacent fine blocks, the result
+* is still an exact partition of the document (sections concatenate back to the
+* source unchanged).
+*
+* Sections are the robust alignment unit between a base document and its
+* translation — both share the same heading structure, so they align almost
+* perfectly and a translation that splits its prose into a different number of
+* paragraphs never causes a section to be dropped. Fine-grained review happens
+* within a section once it is known to have changed.
+*
+* @param text - The full markdown document.
+* @returns The ordered list of sections with their 1-based line ranges.
+*/
+const segmentSections = (text) => {
+	const fineBlocks = segmentDocument(text);
+	const sections = [];
+	let currentBlocks = [];
+	const flushSection = () => {
+		if (currentBlocks.length === 0) return;
+		const [firstBlock] = currentBlocks;
+		const lastBlock = currentBlocks[currentBlocks.length - 1];
+		sections.push({
+			type: firstBlock.type,
+			content: currentBlocks.map((block) => block.content).join(""),
+			lineStart: firstBlock.lineStart,
+			lineEnd: lastBlock.lineEnd
+		});
+		currentBlocks = [];
+	};
+	for (const block of fineBlocks) {
+		if (block.type === "heading" || block.type === "unknown" && sections.length === 0) flushSection();
+		currentBlocks.push(block);
+		if (block.type === "unknown" && sections.length === 0) flushSection();
+	}
+	flushSection();
+	return sections;
+};
+
+//#endregion
+exports.segmentDocument = segmentDocument;
+exports.segmentSections = segmentSections;
+//# sourceMappingURL=segmentDocument.cjs.map

package/dist/cjs/docReview/segmentDocument.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmentDocument.cjs","names":[],"sources":["../../../src/docReview/segmentDocument.ts"],"sourcesContent":["import type { Block, BlockType } from './types';\n\nconst isBlankLine = (line: string): boolean => line.trim().length === 0;\nconst isFencedCodeDelimiter = (line: string): boolean => /^\\s*```/.test(line);\nconst isHeading = (line: string): boolean => /^\\s*#{1,6}\\s+/.test(line);\nconst isFrontmatterDelimiter = (line: string): boolean =>\n  /^\\s*---\\s*$/.test(line);\n\n/**\n * A content unit (heading, paragraph, code block or frontmatter) spanning a\n * 0-based, inclusive line range. Blank-line runs are not units of their own;\n * they are folded into the preceding unit as trailing separators (see\n * {@link segmentDocument}) so that the concatenation of every block's content\n * reproduces the document byte-for-byte.\n */\ntype ContentUnit = {\n  type: BlockType;\n  startIndex: number;\n  endIndex: number;\n};\n\n/**\n * Split a markdown document into fine-grained blocks.\n *\n * Boundaries are drawn at headings, blank lines (paragraph breaks) and fenced\n * code blocks, while frontmatter and the inside of code fences are kept intact.\n * Each blank-line run is appended to the block that precedes it, so the blocks\n * form an exact partition of the document: concatenating every `content` (in\n * order) yields the original text unchanged. This is what lets the block-aware\n * review re-translate only the paragraphs/snippets that actually changed instead\n * of the whole heading section.\n *\n * @param text - The full markdown document.\n * @returns The ordered list of blocks with their 1-based line ranges.\n */\nexport const segmentDocument = (text: string): Block[] => {\n  const lines = text.split('\\n');\n  const lineCount = lines.length;\n\n  // 1. Tokenize into content units, skipping blank-line runs (folded in below).\n  const units: ContentUnit[] = [];\n  let index = 0;\n\n  while (index < lineCount) {\n    const currentLine = lines[index];\n\n    if (isBlankLine(currentLine)) {\n      index += 1;\n      continue;\n    }\n\n    // Frontmatter: only when it opens the document.\n    if (units.length === 0 && isFrontmatterDelimiter(currentLine)) {\n      const startIndex = index;\n      index += 1;\n      while (index < lineCount && !isFrontmatterDelimiter(lines[index])) {\n        index += 1;\n      }\n      // Include the closing delimiter when present.\n      if (index < lineCount) index += 1;\n      units.push({ type: 'unknown', startIndex, endIndex: index - 1 });\n      continue;\n    }\n\n    // Fenced code block: consumed whole so inner blank lines and `#` lines are\n    // never treated as boundaries.\n    if (isFencedCodeDelimiter(currentLine)) {\n      const startIndex = index;\n      index += 1;\n      while (index < lineCount && !isFencedCodeDelimiter(lines[index])) {\n        index += 1;\n      }\n      // Include the closing fence when present.\n      if (index < lineCount) index += 1;\n      units.push({ type: 'code_block', startIndex, endIndex: index - 1 });\n      continue;\n    }\n\n    // Heading: a single self-contained line.\n    if (isHeading(currentLine)) {\n      units.push({ type: 'heading', startIndex: index, endIndex: index });\n      index += 1;\n      continue;\n    }\n\n    // Paragraph: a run of consecutive lines until a blank line, a heading or a\n    // code fence. Tables and tight lists stay together (no blank line between\n    // their rows/items).\n    const startIndex = index;\n    while (\n      index < lineCount &&\n      !isBlankLine(lines[index]) &&\n      !isHeading(lines[index]) &&\n      !isFencedCodeDelimiter(lines[index])\n    ) {\n      index += 1;\n    }\n    units.push({ type: 'paragraph', startIndex, endIndex: index - 1 });\n  }\n\n  if (units.length === 0) return [];\n\n  // 2. Turn each unit into a block whose line range extends to just before the\n  //    next unit, so the trailing blank-line run is owned by it. The first block\n  //    also absorbs any leading blank lines, and the last block runs to EOF.\n  return units.map((unit, unitIndex): Block => {\n    const blockStartIndex = unitIndex === 0 ? 0 : unit.startIndex;\n    const blockEndIndex =\n      unitIndex === units.length - 1\n        ? lineCount - 1\n        : units[unitIndex + 1].startIndex - 1;\n\n    const blockLines = lines.slice(blockStartIndex, blockEndIndex + 1);\n    // Re-append the boundary newline dropped by `split` for every block but the\n    // one ending at EOF, so concatenating all blocks rebuilds the document.\n    const content =\n      blockEndIndex < lineCount - 1\n        ? `${blockLines.join('\\n')}\\n`\n        : blockLines.join('\\n');\n\n    return {\n      type: unit.type,\n      content,\n      lineStart: blockStartIndex + 1,\n      lineEnd: blockEndIndex + 1,\n    };\n  });\n};\n\n/**\n * Split a markdown document into coarse, heading-anchored sections.\n *\n * Built by grouping the fine blocks of {@link segmentDocument}: frontmatter and\n * each heading open a new section, and the following non-heading blocks are\n * folded into it. Because it only concatenates adjacent fine blocks, the result\n * is still an exact partition of the document (sections concatenate back to the\n * source unchanged).\n *\n * Sections are the robust alignment unit between a base document and its\n * translation — both share the same heading structure, so they align almost\n * perfectly and a translation that splits its prose into a different number of\n * paragraphs never causes a section to be dropped. Fine-grained review happens\n * within a section once it is known to have changed.\n *\n * @param text - The full markdown document.\n * @returns The ordered list of sections with their 1-based line ranges.\n */\nexport const segmentSections = (text: string): Block[] => {\n  const fineBlocks = segmentDocument(text);\n  const sections: Block[] = [];\n  let currentBlocks: Block[] = [];\n\n  const flushSection = (): void => {\n    if (currentBlocks.length === 0) return;\n\n    const [firstBlock] = currentBlocks;\n    const lastBlock = currentBlocks[currentBlocks.length - 1];\n\n    sections.push({\n      type: firstBlock.type,\n      content: currentBlocks.map((block) => block.content).join(''),\n      lineStart: firstBlock.lineStart,\n      lineEnd: lastBlock.lineEnd,\n    });\n    currentBlocks = [];\n  };\n\n  for (const block of fineBlocks) {\n    // Frontmatter (a leading `unknown` block) and every heading open a section.\n    const opensSection =\n      block.type === 'heading' ||\n      (block.type === 'unknown' && sections.length === 0);\n\n    if (opensSection) flushSection();\n    currentBlocks.push(block);\n    if (block.type === 'unknown' && sections.length === 0) flushSection();\n  }\n\n  flushSection();\n\n  return sections;\n};\n"],"mappings":";;;AAEA,MAAM,eAAe,SAA0B,KAAK,MAAM,CAAC,WAAW;AACtE,MAAM,yBAAyB,SAA0B,UAAU,KAAK,KAAK;AAC7E,MAAM,aAAa,SAA0B,gBAAgB,KAAK,KAAK;AACvE,MAAM,0BAA0B,SAC9B,cAAc,KAAK,KAAK;;;;;;;;;;;;;;;AA6B1B,MAAa,mBAAmB,SAA0B;CACxD,MAAM,QAAQ,KAAK,MAAM,KAAK;CAC9B,MAAM,YAAY,MAAM;CAGxB,MAAM,QAAuB,EAAE;CAC/B,IAAI,QAAQ;AAEZ,QAAO,QAAQ,WAAW;EACxB,MAAM,cAAc,MAAM;AAE1B,MAAI,YAAY,YAAY,EAAE;AAC5B,YAAS;AACT;;AAIF,MAAI,MAAM,WAAW,KAAK,uBAAuB,YAAY,EAAE;GAC7D,MAAM,aAAa;AACnB,YAAS;AACT,UAAO,QAAQ,aAAa,CAAC,uBAAuB,MAAM,OAAO,CAC/D,UAAS;AAGX,OAAI,QAAQ,UAAW,UAAS;AAChC,SAAM,KAAK;IAAE,MAAM;IAAW;IAAY,UAAU,QAAQ;IAAG,CAAC;AAChE;;AAKF,MAAI,sBAAsB,YAAY,EAAE;GACtC,MAAM,aAAa;AACnB,YAAS;AACT,UAAO,QAAQ,aAAa,CAAC,sBAAsB,MAAM,OAAO,CAC9D,UAAS;AAGX,OAAI,QAAQ,UAAW,UAAS;AAChC,SAAM,KAAK;IAAE,MAAM;IAAc;IAAY,UAAU,QAAQ;IAAG,CAAC;AACnE;;AAIF,MAAI,UAAU,YAAY,EAAE;AAC1B,SAAM,KAAK;IAAE,MAAM;IAAW,YAAY;IAAO,UAAU;IAAO,CAAC;AACnE,YAAS;AACT;;EAMF,MAAM,aAAa;AACnB,SACE,QAAQ,aACR,CAAC,YAAY,MAAM,OAAO,IAC1B,CAAC,UAAU,MAAM,OAAO,IACxB,CAAC,sBAAsB,MAAM,OAAO,CAEpC,UAAS;AAEX,QAAM,KAAK;GAAE,MAAM;GAAa;GAAY,UAAU,QAAQ;GAAG,CAAC;;AAGpE,KAAI,MAAM,WAAW,EAAG,QAAO,EAAE;AAKjC,QAAO,MAAM,KAAK,MAAM,cAAqB;EAC3C,MAAM,kBAAkB,cAAc,IAAI,IAAI,KAAK;EACnD,MAAM,gBACJ,cAAc,MAAM,SAAS,IACzB,YAAY,IACZ,MAAM,YAAY,GAAG,aAAa;EAExC,MAAM,aAAa,MAAM,MAAM,iBAAiB,gBAAgB,EAAE;EAGlE,MAAM,UACJ,gBAAgB,YAAY,IACxB,GAAG,WAAW,KAAK,KAAK,CAAC,MACzB,WAAW,KAAK,KAAK;AAE3B,SAAO;GACL,MAAM,KAAK;GACX;GACA,WAAW,kBAAkB;GAC7B,SAAS,gBAAgB;GAC1B;GACD;;;;;;;;;;;;;;;;;;;;AAqBJ,MAAa,mBAAmB,SAA0B;CACxD,MAAM,aAAa,gBAAgB,KAAK;CACxC,MAAM,WAAoB,EAAE;CAC5B,IAAI,gBAAyB,EAAE;CAE/B,MAAM,qBAA2B;AAC/B,MAAI,cAAc,WAAW,EAAG;EAEhC,MAAM,CAAC,cAAc;EACrB,MAAM,YAAY,cAAc,cAAc,SAAS;AAEvD,WAAS,KAAK;GACZ,MAAM,WAAW;GACjB,SAAS,cAAc,KAAK,UAAU,MAAM,QAAQ,CAAC,KAAK,GAAG;GAC7D,WAAW,WAAW;GACtB,SAAS,UAAU;GACpB,CAAC;AACF,kBAAgB,EAAE;;AAGpB,MAAK,MAAM,SAAS,YAAY;AAM9B,MAHE,MAAM,SAAS,aACd,MAAM,SAAS,aAAa,SAAS,WAAW,EAEjC,eAAc;AAChC,gBAAc,KAAK,MAAM;AACzB,MAAI,MAAM,SAAS,aAAa,SAAS,WAAW,EAAG,eAAc;;AAGvE,eAAc;AAEd,QAAO"}

package/dist/cjs/init/index.cjs

@@ -3,6 +3,7 @@ const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_initConfig_index = require('../initConfig/index.cjs');
 const require_init_utils_configManipulation = require('./utils/configManipulation.cjs');
 const require_init_utils_fileSystem = require('./utils/fileSystem.cjs');
+const require_init_utils_githubActions = require('./utils/githubActions.cjs');
 const require_init_utils_jsonParser = require('./utils/jsonParser.cjs');
 const require_init_utils_packageManager = require('./utils/packageManager.cjs');
 const require_init_utils_tsConfig = require('./utils/tsConfig.cjs');
@@ -123,7 +124,7 @@ const initIntlayer = async (rootDir, options) => {
 		...packageJson.devDependencies ?? {}
 	};
 	const packageManager = require_init_utils_packageManager.detectPackageManager(rootDir);
-	const { packagesToInstall, compatSyncConfig, compatVitePluginConfig } = require_init_utils_packageManager.detectMissingIntlayerPackages(allDeps);
+	const { packagesToInstall, devPackagesToInstall, compatSyncConfig, compatVitePluginConfig } = require_init_utils_packageManager.detectMissingIntlayerPackages(allDeps);
 	if (packagesToInstall.length > 0) {
 		(0, _intlayer_config_logger.logger)((0, _intlayer_config_logger.colorize)("Installing missing Intlayer dependencies...", _intlayer_config_colors.CYAN));
 		try {
@@ -133,6 +134,15 @@ const initIntlayer = async (rootDir, options) => {
 			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Failed to install packages. Please install manually: ${packagesToInstall.join(" ")}`, { level: "warn" });
 		}
 	}
+	if (devPackagesToInstall.length > 0) {
+		(0, _intlayer_config_logger.logger)((0, _intlayer_config_logger.colorize)("Installing missing Intlayer dev dependencies...", _intlayer_config_colors.CYAN));
+		try {
+			require_init_utils_packageManager.installPackages(rootDir, devPackagesToInstall, packageManager, true);
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Installed: ${devPackagesToInstall.map((pkg) => (0, _intlayer_config_logger.colorize)(pkg, _intlayer_config_colors.MAGENTA)).join(", ")}`);
+		} catch {
+			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Failed to install dev packages. Please install manually: ${devPackagesToInstall.join(" ")}`, { level: "warn" });
+		}
+	}
 	const gitignorePath = ".gitignore";
 	if (!options?.noGitignore && await require_init_utils_fileSystem.exists(rootDir, gitignorePath)) {
 		const gitignoreContent = await require_init_utils_fileSystem.readFileFromRoot(rootDir, gitignorePath);
@@ -141,6 +151,22 @@ const initIntlayer = async (rootDir, options) => {
 			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Added ${(0, _intlayer_config_logger.colorizePath)(".intlayer")} to ${(0, _intlayer_config_logger.colorizePath)(gitignorePath)}`);
 		} else (0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(gitignorePath)} already includes .intlayer`);
 	}
+	if (!options?.noGithubActions) {
+		const workflows = require_init_utils_githubActions.getGithubWorkflows(packageManager);
+		for (const workflow of workflows) {
+			if (await require_init_utils_fileSystem.exists(rootDir, workflow.filePath)) {
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} ${(0, _intlayer_config_logger.colorizePath)(workflow.filePath)} already exists`);
+				continue;
+			}
+			try {
+				await require_init_utils_fileSystem.ensureDirectory(rootDir, (0, node_path.join)(".github", "workflows"));
+				await require_init_utils_fileSystem.writeFileToRoot(rootDir, workflow.filePath, workflow.content);
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Added GitHub Actions workflow ${(0, _intlayer_config_logger.colorizePath)(workflow.filePath)}`);
+			} catch {
+				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Could not create ${(0, _intlayer_config_logger.colorizePath)(workflow.filePath)}. You may need to add it manually.`, { level: "warn" });
+			}
+		}
+	}
 	const vscodeDir = ".vscode";
 	const extensionsJsonPath = (0, node_path.join)(vscodeDir, "extensions.json");
 	const extensionId = "intlayer.intlayer-vs-code-extension";
@@ -198,9 +224,10 @@ const initIntlayer = async (rootDir, options) => {
 			(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.x} Could not parse or update ${(0, _intlayer_config_logger.colorizePath)(fileName)}. You may need to add ${(0, _intlayer_config_logger.colorizePath)(".intlayer/types/**/*.ts")} manually.`, { level: "warn" });
 		}
 	}
-	await require_initConfig_index.initConfig(hasTsConfig ? "intlayer.config.ts" : "intlayer.config.mjs", rootDir);
+	const format = hasTsConfig ? "intlayer.config.ts" : "intlayer.config.mjs";
+	const detectedPattern = await require_init_utils_fileSystem.detectJsonLocalePattern(rootDir);
+	await require_initConfig_index.initConfig(format, rootDir, detectedPattern?.locales);
 	if (compatSyncConfig) {
-		const detectedPattern = await require_init_utils_fileSystem.detectJsonLocalePattern(rootDir);
 		const resolvedSyncConfig = detectedPattern ? {
 			...compatSyncConfig,
 			sourceTemplate: detectedPattern.template
@@ -299,7 +326,7 @@ const initIntlayer = async (rootDir, options) => {
 	const isVersionGreaterOrEqual = (versionString, major) => {
 		if (!versionString || typeof versionString !== "string") return false;
 		const match = versionString.match(/^[^\d]*(\d+)/);
-		if (!match) return false;
+		if (!match?.[1]) return false;
 		return parseInt(match[1], 10) >= major;
 	};
 	const backendIntlayerPackages = [
@@ -310,7 +337,7 @@ const initIntlayer = async (rootDir, options) => {
 	];
 	const devScript = packageJson.scripts?.dev;
 	let newDevScript;
-	if ((isNextJsProject && isVersionGreaterOrEqual(allDeps.next, 16) || backendIntlayerPackages.some((pkg) => allDeps[pkg])) && !devScript.includes("intlayer watch")) newDevScript = `intlayer watch --with '${devScript}'`;
+	if ((isNextJsProject && allDeps.next && isVersionGreaterOrEqual(allDeps.next, 16) || backendIntlayerPackages.some((pkg) => allDeps[pkg])) && !devScript.includes("intlayer watch")) newDevScript = `intlayer watch --with '${devScript}'`;
 	if (newDevScript) {
 		packageJson.scripts.dev = newDevScript;
 		await require_init_utils_fileSystem.writeFileToRoot(rootDir, packageJsonPath, JSON.stringify(packageJson, null, 2));
@@ -337,19 +364,21 @@ const initIntlayer = async (rootDir, options) => {
 		const aliases = (0, _intlayer_config_utils.getAlias)({ configuration: (0, _intlayer_config_node.getConfiguration)({ baseDir: rootDir }) });
 		if (hasTsConfig && tsConfigFiles.length > 0) {
 			const tsConfigPath = tsConfigFiles.find((file) => file === "tsconfig.json") || tsConfigFiles[0];
-			const config = require_init_utils_jsonParser.parseJSONWithComments(await require_init_utils_fileSystem.readFileFromRoot(rootDir, tsConfigPath));
-			config.compilerOptions ??= {};
-			config.compilerOptions.paths ??= {};
-			let updated = false;
-			Object.entries(aliases).forEach(([alias, path]) => {
-				if (!config.compilerOptions.paths[alias]) {
-					config.compilerOptions.paths[alias] = [path];
-					updated = true;
+			if (tsConfigPath) {
+				const config = require_init_utils_jsonParser.parseJSONWithComments(await require_init_utils_fileSystem.readFileFromRoot(rootDir, tsConfigPath));
+				config.compilerOptions ??= {};
+				config.compilerOptions.paths ??= {};
+				let updated = false;
+				Object.entries(aliases).forEach(([alias, path]) => {
+					if (!config.compilerOptions.paths[alias]) {
+						config.compilerOptions.paths[alias] = [path];
+						updated = true;
+					}
+				});
+				if (updated) {
+					await require_init_utils_fileSystem.writeFileToRoot(rootDir, tsConfigPath, JSON.stringify(config, null, 2));
+					(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(tsConfigPath)} to include Intlayer aliases`);
 				}
-			});
-			if (updated) {
-				await require_init_utils_fileSystem.writeFileToRoot(rootDir, tsConfigPath, JSON.stringify(config, null, 2));
-				(0, _intlayer_config_logger.logger)(`${_intlayer_config_logger.v} Updated ${(0, _intlayer_config_logger.colorizePath)(tsConfigPath)} to include Intlayer aliases`);
 			}
 		} else {
 			const jsConfigPath = "jsconfig.json";