@intlayer/cli 7.1.4 → 7.1.5

package/dist/types/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/config.ts"],"sourcesContent":[],"mappings":";;;KAMK,aAAA;kBACa;AAHQ,CAAA;AAMb,cAAA,SAAuB,EAAA,CAAA,OAAa,CAAA,EAAb,aAAa,EAAA,GAAA,IAAA"}
+{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/config.ts"],"sourcesContent":[],"mappings":";;;KAMK,aAAA;kBACa;AAHQ,CAAA;AAMb,cAAA,SAAuB,EAAA,CAAA,OAAa,CAAb,EAAA,aAAa,EAAA,GAAA,IAAA"}

package/dist/types/pull.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pull.d.ts","names":[],"sources":["../../src/pull.ts"],"sourcesContent":[],"mappings":";;;KAmBK,WAAA;;EAAA,mBAAW,CAAA,EAAA,MAGE;EAcL,aA8OZ,CAAA,EA5PiB,uBAciC;;;;;;cAAtC,iBAAwB,gBAAc"}
+{"version":3,"file":"pull.d.ts","names":[],"sources":["../../src/pull.ts"],"sourcesContent":[],"mappings":";;;KAmBK,WAAA;;EAAA,mBAAW,CAAA,EAAA,MAGE;EAcL,aA8OZ,CAAA,EA5PiB,uBAcwC;;;;;;cAA7C,iBAAwB,gBAAc"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/cli",
-  "version": "7.1.4",
+  "version": "7.1.5",
   "private": false,
   "description": "Provides uniform command-line interface scripts for Intlayer, used in packages like intlayer-cli and intlayer.",
   "keywords": [
@@ -66,19 +66,19 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "7.1.4",
-    "@intlayer/chokidar": "7.1.4",
-    "@intlayer/config": "7.1.4",
-    "@intlayer/dictionaries-entry": "7.1.4",
-    "@intlayer/remote-dictionaries-entry": "7.1.4",
-    "@intlayer/types": "7.1.4",
-    "@intlayer/unmerged-dictionaries-entry": "7.1.4",
+    "@intlayer/api": "7.1.5",
+    "@intlayer/chokidar": "7.1.5",
+    "@intlayer/config": "7.1.5",
+    "@intlayer/dictionaries-entry": "7.1.5",
+    "@intlayer/remote-dictionaries-entry": "7.1.5",
+    "@intlayer/types": "7.1.5",
+    "@intlayer/unmerged-dictionaries-entry": "7.1.5",
     "commander": "14.0.1",
     "eventsource": "3.0.7",
     "fast-glob": "3.3.3"
   },
   "devDependencies": {
-    "@intlayer/core": "7.1.4",
+    "@intlayer/core": "7.1.5",
     "@types/node": "24.10.1",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",

package/dist/assets/translation-alignment/ARCHITECTURE.md

@@ -1,518 +0,0 @@
-# Architecture Diagram
-
-This document provides visual representations of the block-aware translation alignment system.
-
-## System Overview
-
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│                     Block-Aware Translation System                  │
-└─────────────────────────────────────────────────────────────────────┘
-                                    │
-                ┌───────────────────┴───────────────────┐
-                │                                       │
-         ┌──────▼──────┐                        ┌──────▼──────┐
-         │   English   │                        │   French    │
-         │  Document   │                        │  Document   │
-         │   (Base)    │                        │ (Translation)│
-         └──────┬──────┘                        └──────┬──────┘
-                │                                       │
-                │         ┌─────────────────┐          │
-                └────────►│  Segmentation   │◄─────────┘
-                          └────────┬────────┘
-                                   │
-                          ┌────────▼────────┐
-                          │  Normalization  │
-                          │  - Semantic     │
-                          │  - Anchor Text  │
-                          └────────┬────────┘
-                                   │
-                          ┌────────▼────────┐
-                          │ Fingerprinting  │
-                          │  - SHA-256      │
-                          │  - Context      │
-                          └────────┬────────┘
-                                   │
-                ┌──────────────────┴──────────────────┐
-                │                                     │
-         ┌──────▼──────┐                      ┌──────▼──────┐
-         │   English   │                      │   French    │
-         │   Blocks    │                      │   Blocks    │
-         │ (Fingerpr.) │                      │ (Fingerpr.) │
-         └──────┬──────┘                      └──────┬──────┘
-                │                                     │
-                └──────────────┬──────────────────────┘
-                               │
-                      ┌────────▼────────┐
-                      │    Alignment    │
-                      │ (Needleman-     │
-                      │  Wunsch)        │
-                      └────────┬────────┘
-                               │
-                      ┌────────▼────────┐
-                      │  Alignment      │
-                      │  Pairs          │
-                      └────────┬────────┘
-                               │
-                ┌──────────────┴──────────────┐
-                │                             │
-         ┌──────▼──────┐            ┌─────────▼────────┐
-         │    Git      │            │   Similarity     │
-         │  Changed    │            │   Options        │
-         │   Lines     │            │                  │
-         └──────┬──────┘            └─────────┬────────┘
-                │                             │
-                └──────────┬──────────────────┘
-                           │
-                  ┌────────▼────────┐
-                  │  Action         │
-                  │  Planning       │
-                  └────────┬────────┘
-                           │
-                  ┌────────▼────────┐
-                  │  Action Plan    │
-                  │  - reuse        │
-                  │  - review       │
-                  │  - insert_new   │
-                  │  - delete       │
-                  └────────┬────────┘
-                           │
-         ┌─────────────────┴─────────────────┐
-         │                                   │
-         │        ┌──────────────────┐       │
-         └───────►│   Identify       │       │
-                  │   Segments to    │       │
-                  │   Review         │       │
-                  └────────┬─────────┘       │
-                           │                 │
-                  ┌────────▼─────────┐       │
-                  │  AI Translation  │       │
-                  │  (Your Logic)    │       │
-                  └────────┬─────────┘       │
-                           │                 │
-                  ┌────────▼─────────┐       │
-                  │   Reviewed       │       │
-                  │   Segments       │       │
-                  │   (Map)          │       │
-                  └────────┬─────────┘       │
-                           │                 │
-                           └────────┬────────┘
-                                    │
-                           ┌────────▼────────┐
-                           │  Merge          │
-                           │  Reviewed       │
-                           │  Segments       │
-                           └────────┬────────┘
-                                    │
-                           ┌────────▼────────┐
-                           │  Final French   │
-                           │  Document       │
-                           └─────────────────┘
-```
-
-## Data Flow
-
-```
-Input:
-  englishText: string
-  frenchText: string (existing translation or "")
-  changedLines: number[] (optional, from Git)
-  similarityOptions: { minimumMatchForReuse: 0.9 }
-
-Output:
-  finalFrenchDocument: string (updated translation)
-```
-
-## Module Dependencies
-
-```
-types.ts
-  ↓
-segmentDocument.ts ────────┐
-  ↓                        │
-normalizeBlock.ts ─────────┤
-  ↓                        │
-fingerprintBlock.ts ───────┤
-                           ├──→ pipeline.ts ──→ reviewDocBlockAware.ts
-computeSimilarity.ts ──────┤         ↑
-  ↓                        │         │
-alignBlocks.ts ────────────┤         │
-                           │         │
-mapChangedLinesToBlocks.ts ┤         │
-  ↓                        │         │
-planActions.ts ────────────┤         │
-  ↓                        │         │
-rebuildDocument.ts ────────┘         │
-                                     │
-                              index.ts (exports)
-```
-
-## Alignment Algorithm (Needleman-Wunsch)
-
-```
-English Blocks:  [E1] [E2] [E3] [E4] [E5]
-French Blocks:   [F1] [F2] [F3] [F4]
-
-Score Matrix (5x4):
-       F1   F2   F3   F4
-E1   [ 8  ][  2 ][  1 ][  0 ]
-E2   [ 2  ][ 9  ][  3 ][  1 ]
-E3   [ 1  ][ 3  ][ 8  ][  2 ]
-E4   [ 0  ][ 1  ][ 2  ][ 7  ]
-E5   [ 0  ][ 0  ][ 1  ][ 2  ]  ← E5 is new
-
-Traceback (diagonal = match, up = delete, left = insert):
-  E1 ──→ F1  (match, score 8)
-  E2 ──→ F2  (match, score 9)
-  E3 ──→ F3  (match, score 8)
-  E4 ──→ F4  (match, score 7)
-  E5 ──→ NULL (new block, no match)
-
-Alignment Pairs:
-  [ (E1→F1, sim=0.95), (E2→F2, sim=0.98), (E3→F3, sim=0.93), (E4→F4, sim=0.91), (E5→NULL, sim=0) ]
-```
-
-## Action Planning Logic
-
-```
-For each alignment pair:
-
-  IF englishIndex = -1 AND frenchIndex != null:
-    → Action: DELETE (French block with no English match)
-
-  ELSE IF englishIndex >= 0 AND frenchIndex = null:
-    → Action: INSERT_NEW (New English block)
-
-  ELSE IF englishIndex >= 0 AND frenchIndex != null:
-    IF block changed (from Git) OR similarity < threshold:
-      → Action: REVIEW (Changed block, needs AI)
-    ELSE:
-      → Action: REUSE (Unchanged block, copy existing)
-```
-
-## Similarity Calculation (Jaccard)
-
-```
-Block 1: "[Click here](https://example.com) - see section 2.1"
-Block 2: "[Cliquez ici](https://example.com) - voir section 2.1"
-
-Anchor Text Extraction:
-  Block 1 anchor: "[](://.)-2.1"
-  Block 2 anchor: "[](://.)-2.1"
-
-Character Shingles (length=3):
-  Set A: {"[](" "](:" "]:/" "://", "//." "//.)", ".)-", ")-2", "-2.", "2.1"}
-  Set B: {"[](" "](:" "]:/" "://", "//." "//.)", ".)-", ")-2", "-2.", "2.1"}
-
-Jaccard Similarity:
-  Intersection: 10 shingles
-  Union: 10 shingles
-  Similarity = 10/10 = 1.0 (100% match!)
-
-Result: REUSE (despite different languages!)
-```
-
-## State Machine
-
-```
-┌─────────────┐
-│   Start     │
-└──────┬──────┘
-       │
-       ▼
-┌─────────────────┐
-│ Segment         │
-│ Documents       │
-└──────┬──────────┘
-       │
-       ▼
-┌─────────────────┐
-│ Normalize       │
-│ Blocks          │
-└──────┬──────────┘
-       │
-       ▼
-┌─────────────────┐
-│ Fingerprint     │
-│ Blocks          │
-└──────┬──────────┘
-       │
-       ▼
-┌─────────────────┐
-│ Align           │
-│ Blocks          │
-└──────┬──────────┘
-       │
-       ▼
-┌─────────────────┐      YES   ┌─────────────┐
-│ Changed Lines?  ├────────────►│ Map Lines   │
-└──────┬──────────┘             │ to Blocks   │
-       │ NO                     └──────┬──────┘
-       │                               │
-       └───────────────┬───────────────┘
-                       │
-                       ▼
-              ┌─────────────────┐
-              │ Plan Actions    │
-              └────────┬─────────┘
-                       │
-                       ▼
-              ┌─────────────────┐
-              │ For Each Action │
-              └────────┬─────────┘
-                       │
-       ┌───────────────┼───────────────┐
-       │               │               │
-       ▼               ▼               ▼
-┌─────────┐   ┌─────────────┐   ┌─────────┐
-│ REUSE   │   │   REVIEW    │   │  DELETE │
-│ Copy    │   │   Translate │   │  Skip   │
-│ Existing│   │   with AI   │   │         │
-└────┬────┘   └──────┬──────┘   └────┬────┘
-     │               │               │
-     └───────────────┼───────────────┘
-                     │
-                     ▼
-            ┌─────────────────┐
-            │ Merge Segments  │
-            └────────┬─────────┘
-                     │
-                     ▼
-            ┌─────────────────┐
-            │ Write Output    │
-            └────────┬─────────┘
-                     │
-                     ▼
-              ┌─────────────┐
-              │    Done     │
-              └─────────────┘
-```
-
-## Block Types Hierarchy
-
-```
-Block (abstract)
-  │
-  ├── StructuralBlock
-  │     ├── heading (# ## ###)
-  │     ├── horizontal_rule (---)
-  │     └── html (<div>...</div>)
-  │
-  ├── ContentBlock
-  │     ├── paragraph
-  │     ├── blockquote (> text)
-  │     └── list_item (- item)
-  │
-  ├── CodeBlock
-  │     └── code_block (```...```)
-  │
-  ├── TableBlock
-  │     └── table (| col |)
-  │
-  └── UnknownBlock
-        └── unknown (blank lines, etc.)
-```
-
-## Fingerprinting Strategy
-
-```
-Block Content:
-  "# Introduction\n\nWelcome to [our guide](https://example.com)!"
-
-Step 1: Normalize
-  semanticText: "introduction welcome to our guide"
-  anchorText: "#[](://.)!"
-
-Step 2: Hash
-  semanticDigest: sha256(semanticText) = "a1b2c3..."
-  anchorDigest: sha256(anchorText) = "d4e5f6..."
-
-Step 3: Composite Key
-  compositeKey: "a1b2c3...:d4e5f6..."
-
-Step 4: Context (surrounding blocks)
-  previousDigest: sha256(previousBlock.semanticText)
-  nextDigest: sha256(nextBlock.semanticText)
-  contextKey: sha256(previousDigest + ":" + nextDigest)
-
-Result: Unique fingerprint that:
-  - Identifies content semantically
-  - Preserves structure (anchors)
-  - Considers context (neighbors)
-```
-
-## Performance Characteristics
-
-```
-Time Complexity:
-  Segmentation:      O(n)        n = lines in document
-  Normalization:     O(b*m)      b = blocks, m = avg block length
-  Fingerprinting:    O(b)        b = blocks
-  Alignment:         O(b_en * b_fr)  Needleman-Wunsch
-  Planning:          O(p)        p = alignment pairs
-  Reconstruction:    O(a)        a = actions
-
-Total: O(b_en * b_fr) dominant for large documents
-
-Space Complexity:
-  Blocks storage:    O(b*m)
-  Score matrix:      O(b_en * b_fr)
-  Action plan:       O(max(b_en, b_fr))
-
-Total: O(b*m + b_en*b_fr)
-
-Optimization:
-  Blocks << Lines (typically 10x fewer)
-  So O(blocks^2) << O(lines^2)
-```
-
-## Example Trace
-
-```
-Input:
-  English: "# Title\n\nPara 1\n\nPara 2\n"
-  French:  "# Titre\n\nPara 1 (fr)\n\nPara 2 (fr)\n"
-  Changed: [3] (line 3 changed)
-
-Segmentation:
-  English Blocks: [E1: heading, E2: paragraph, E3: paragraph]
-  French Blocks:  [F1: heading, F2: paragraph, F3: paragraph]
-
-Normalization:
-  E1: semantic="title",        anchor="#"
-  E2: semantic="para 1",       anchor=""
-  E3: semantic="para 2",       anchor=""
-  F1: semantic="titre",        anchor="#"
-  F2: semantic="para 1 (fr)",  anchor="()"
-  F3: semantic="para 2 (fr)",  anchor="()"
-
-Fingerprinting:
-  E1: compositeKey="hash1:hash2"
-  E2: compositeKey="hash3:hash4"
-  E3: compositeKey="hash5:hash6"
-
-Alignment:
-  Pairs: [(E1→F1, 0.82), (E2→F2, 0.95), (E3→F3, 0.94)]
-
-Change Detection:
-  Line 3 is in block E2 (lines 3-3)
-  Changed blocks: {E2}
-
-Action Planning:
-  E1→F1: similarity=0.82 < 0.90, but not changed → REUSE
-  E2→F2: similarity=0.95, but CHANGED → REVIEW
-  E3→F3: similarity=0.94, not changed → REUSE
-
-Reconstruction:
-  Output:
-    F1 content (reused)
-    F2 content (from AI)
-    F3 content (reused)
-
-Final:
-  "# Titre\n\nPara 1 (translated by AI)\n\nPara 2 (fr)\n"
-```
-
-## Integration Points
-
-```
-┌───────────────────────────────────────────────────────┐
-│                    Your Application                   │
-└───────────────────────┬───────────────────────────────┘
-                        │
-           ┌────────────┴────────────┐
-           │                         │
-    ┌──────▼──────┐          ┌──────▼──────┐
-    │  reviewDoc  │          │   Direct    │
-    │   (main)    │          │  Pipeline   │
-    └──────┬──────┘          │    API      │
-           │                 └──────┬──────┘
-           │                        │
-    ┌──────▼──────────────────────┬─┘
-    │                             │
-    │  reviewFileBlockAware       │
-    │  (integration layer)        │
-    └──────┬──────────────────────┘
-           │
-    ┌──────▼──────────────────────┐
-    │  buildAlignmentPlan         │
-    │  (pipeline)                 │
-    └──────┬──────────────────────┘
-           │
-    ┌──────▼──────────────────────┐
-    │  Core Translation           │
-    │  Alignment Modules          │
-    └─────────────────────────────┘
-```
-
-## Testing Strategy
-
-```
-Unit Tests:
-  ├── segmentDocument.test.ts
-  │     ├── Should segment headings
-  │     ├── Should segment paragraphs
-  │     ├── Should segment code blocks
-  │     └── Should handle edge cases
-  │
-  ├── normalizeBlock.test.ts
-  │     ├── Should extract semantic text
-  │     ├── Should extract anchor text
-  │     └── Should handle special chars
-  │
-  ├── computeSimilarity.test.ts
-  │     ├── Should compute Jaccard similarity
-  │     └── Should handle edge cases
-  │
-  └── alignBlocks.test.ts
-        ├── Should align matching blocks
-        ├── Should detect insertions
-        ├── Should detect deletions
-        └── Should detect reordering
-
-Integration Tests:
-  ├── Full pipeline test
-  ├── Reordering scenario
-  ├── Insertion scenario
-  ├── Deletion scenario
-  └── Mixed changes scenario
-
-E2E Tests:
-  ├── Real markdown documents
-  ├── Multiple locales
-  └── Git integration
-```
-
-## Configuration Flow
-
-```
-User Config
-  │
-  ├── minimumMatchForReuse (default: 0.90)
-  ├── minimumMatchForNearDuplicate (default: 0.80)
-  └── AI options (provider, model, etc.)
-  │
-  └──→ pipeline.ts
-       │
-       ├──→ buildAlignmentPlan()
-       │    │
-       │    ├──→ planActions(similarityOptions)
-       │    │
-       │    └──→ Result: Plan + Segments
-       │
-       └──→ reviewFileBlockAware()
-            │
-            ├──→ chunkInference(AI options)
-            │
-            └──→ Final output
-```
-
----
-
-This architecture ensures:
-- ✅ Separation of concerns
-- ✅ Testability
-- ✅ Extensibility
-- ✅ Performance
-- ✅ Maintainability
-