Merge pull request #34 from TrueNine/dev

refactor: bidirectional config sync via ensureConfigLink (5 modified)

Author: TrueNine

cli/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@truenine/memory-sync-cli",
   "type": "module",
-  "version": "2026.10221.10118",
+  "version": "2026.10221.10208",
   "description": "TrueNine Memory Synchronization CLI",
   "author": "TrueNine",
   "license": "AGPL-3.0-only",

cli/public/tnmsc.example.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.10221.10118",
+  "version": "2026.10221.10208",
   "workspaceDir": "~/project",
   "shadowSourceProject": {
     "name": "tnmsc-shadow",

cli/src/ConfigLoader.test.ts

@@ -2,10 +2,15 @@ import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
 import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
-import {ConfigLoader, DEFAULT_CONFIG_FILE_NAME, DEFAULT_GLOBAL_CONFIG_DIR, loadUserConfig} from './ConfigLoader'
+import {ConfigLoader, DEFAULT_CONFIG_FILE_NAME, DEFAULT_GLOBAL_CONFIG_DIR, ensureConfigLink, loadUserConfig} from './ConfigLoader'
 
 vi.mock('node:fs') // Mock fs module
 vi.mock('node:os')
+vi.mock('@truenine/desk-paths', () => ({
+  isSymlink: vi.fn(),
+  readSymlinkTarget: vi.fn(),
+  deletePathSync: vi.fn()
+}))
 
 describe('configLoader', () => {
   const mockHomedir = '/home/testuser'
@@ -328,3 +333,135 @@ describe('configLoader', () => {
     })
   })
 })
+
+describe('ensureConfigLink', () => {
+  let deskPaths: typeof import('@truenine/desk-paths')
+
+  const LOCAL = '/shadow/.tnmsc.json'
+  const GLOBAL = '/home/testuser/.aindex/.tnmsc.json'
+
+  const logger = {
+    trace: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    fatal: vi.fn()
+  }
+
+  beforeEach(async () => {
+    deskPaths = await import('@truenine/desk-paths')
+    vi.mocked(os.homedir).mockReturnValue('/home/testuser')
+    vi.mocked(fs.existsSync).mockReturnValue(false)
+    vi.mocked(fs.symlinkSync).mockImplementation(() => void 0)
+    vi.mocked(fs.copyFileSync).mockImplementation(() => void 0)
+    vi.mocked(deskPaths.isSymlink).mockReturnValue(false)
+    vi.mocked(deskPaths.readSymlinkTarget).mockReturnValue(null)
+    vi.mocked(deskPaths.deletePathSync).mockImplementation(() => void 0)
+  })
+
+  afterEach(() => vi.clearAllMocks())
+
+  it('no-op when global config does not exist', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false)
+
+    ensureConfigLink(LOCAL, GLOBAL, logger)
+
+    expect(fs.symlinkSync).not.toHaveBeenCalled()
+    expect(fs.copyFileSync).not.toHaveBeenCalled()
+  })
+
+  it('creates symlink when local file does not exist', () => {
+    vi.mocked(fs.existsSync).mockImplementation(p => p === GLOBAL)
+    vi.mocked(deskPaths.isSymlink).mockReturnValue(false)
+
+    ensureConfigLink(LOCAL, GLOBAL, logger)
+
+    expect(fs.symlinkSync).toHaveBeenCalledWith(GLOBAL, LOCAL, 'file')
+  })
+
+  it('no-op when local is a correct symlink pointing to global', () => {
+    vi.mocked(fs.existsSync).mockImplementation(p => p === GLOBAL || p === LOCAL)
+    vi.mocked(deskPaths.isSymlink).mockReturnValue(true)
+    vi.mocked(deskPaths.readSymlinkTarget).mockReturnValue(GLOBAL)
+
+    ensureConfigLink(LOCAL, GLOBAL, logger)
+
+    expect(fs.symlinkSync).not.toHaveBeenCalled()
+    expect(deskPaths.deletePathSync).not.toHaveBeenCalled()
+  })
+
+  it('deletes stale symlink and recreates when target differs', () => {
+    vi.mocked(fs.existsSync).mockImplementation(p => p === GLOBAL || p === LOCAL)
+    vi.mocked(deskPaths.isSymlink).mockReturnValue(true)
+    vi.mocked(deskPaths.readSymlinkTarget).mockReturnValue('/other/path/.tnmsc.json')
+
+    ensureConfigLink(LOCAL, GLOBAL, logger)
+
+    expect(deskPaths.deletePathSync).toHaveBeenCalledWith(LOCAL)
+    expect(fs.symlinkSync).toHaveBeenCalledWith(GLOBAL, LOCAL, 'file')
+  })
+
+  it('syncs regular file back to global when local is newer, then recreates symlink', () => {
+    vi.mocked(fs.existsSync).mockImplementation(p => p === GLOBAL || p === LOCAL)
+    vi.mocked(deskPaths.isSymlink).mockReturnValue(false)
+    vi.mocked(fs.statSync).mockImplementation(p => {
+      if (p === LOCAL) return {mtimeMs: 2000} as fs.Stats
+      return {mtimeMs: 1000} as fs.Stats
+    })
+
+    ensureConfigLink(LOCAL, GLOBAL, logger)
+
+    expect(fs.copyFileSync).toHaveBeenCalledWith(LOCAL, GLOBAL)
+    expect(deskPaths.deletePathSync).toHaveBeenCalledWith(LOCAL)
+    expect(fs.symlinkSync).toHaveBeenCalledWith(GLOBAL, LOCAL, 'file')
+  })
+
+  it('deletes regular file without sync-back when local is older than global', () => {
+    vi.mocked(fs.existsSync).mockImplementation(p => p === GLOBAL || p === LOCAL)
+    vi.mocked(deskPaths.isSymlink).mockReturnValue(false)
+    vi.mocked(fs.statSync).mockImplementation(p => {
+      if (p === LOCAL) return {mtimeMs: 500} as fs.Stats
+      return {mtimeMs: 1000} as fs.Stats
+    })
+
+    ensureConfigLink(LOCAL, GLOBAL, logger)
+
+    expect(fs.copyFileSync).not.toHaveBeenCalledWith(LOCAL, GLOBAL)
+    expect(deskPaths.deletePathSync).toHaveBeenCalledWith(LOCAL)
+    expect(fs.symlinkSync).toHaveBeenCalledWith(GLOBAL, LOCAL, 'file')
+  })
+
+  it('falls back to copy when symlink fails', () => {
+    vi.mocked(fs.existsSync).mockImplementation(p => p === GLOBAL)
+    vi.mocked(deskPaths.isSymlink).mockReturnValue(false)
+    vi.mocked(fs.symlinkSync).mockImplementation(() => {
+      throw new Error('EPERM: operation not permitted')
+    })
+
+    ensureConfigLink(LOCAL, GLOBAL, logger)
+
+    expect(fs.copyFileSync).toHaveBeenCalledWith(GLOBAL, LOCAL)
+    expect(logger.warn).toHaveBeenCalledWith(
+      'symlink unavailable, copied config (auto-sync disabled)',
+      expect.objectContaining({dest: LOCAL})
+    )
+  })
+
+  it('logs warn and does not throw when both symlink and copy fail', () => {
+    vi.mocked(fs.existsSync).mockImplementation(p => p === GLOBAL)
+    vi.mocked(deskPaths.isSymlink).mockReturnValue(false)
+    vi.mocked(fs.symlinkSync).mockImplementation(() => {
+      throw new Error('EPERM')
+    })
+    vi.mocked(fs.copyFileSync).mockImplementation(() => {
+      throw new Error('ENOENT')
+    })
+
+    expect(() => ensureConfigLink(LOCAL, GLOBAL, logger)).not.toThrow()
+    expect(logger.warn).toHaveBeenCalledWith(
+      'failed to link or copy config',
+      expect.objectContaining({path: LOCAL, error: 'ENOENT'})
+    )
+  })
+})

cli/src/ConfigLoader.ts

@@ -4,6 +4,7 @@ import * as fs from 'node:fs'
 import * as os from 'node:os'
 import * as path from 'node:path'
 import process from 'node:process'
+import {deletePathSync, isSymlink, readSymlinkTarget} from '@truenine/desk-paths'
 import {DEFAULT_USER_CONFIG} from '@/constants'
 import {createLogger} from '@/log'
 import {ZUserConfigFile} from '@/types/ConfigTypes.schema'
@@ -226,42 +227,74 @@ export function loadUserConfig(cwd?: string): MergedConfigResult {
 }
 
 /**
- * Ensure the shadow source project directory has a .tnmsc.json symlink
- * pointing to the global config. Creates a symlink where possible, falls
- * back to a file copy when symlinks are unavailable (e.g. Windows without
- * Developer Mode). Skips if the file already exists.
+ * Ensure a local config file is linked (symlink preferred) to the global config.
+ * On every run:
+ * - If local is a correct symlink → no-op
+ * - If local is a stale symlink → delete and recreate
+ * - If local is a regular file newer than global → sync back to global, then recreate link
+ * - If local is a regular file older than global → delete and recreate link
+ * Falls back to a file copy with a warning when symlink creation fails.
  */
-export function ensureShadowProjectConfigLink(shadowProjectDir: string, logger: ILogger): void {
-  const resolved = shadowProjectDir.startsWith('~')
-    ? path.join(os.homedir(), shadowProjectDir.slice(1))
-    : shadowProjectDir
-
-  if (!fs.existsSync(resolved)) return
-
-  const globalConfigPath = getGlobalConfigPath()
+export function ensureConfigLink(
+  localConfigPath: string,
+  globalConfigPath: string,
+  logger: ILogger
+): void {
   if (!fs.existsSync(globalConfigPath)) return
 
-  const configPath = path.join(resolved, DEFAULT_CONFIG_FILE_NAME)
-  if (fs.existsSync(configPath)) return
+  if (fs.existsSync(localConfigPath) || isSymlink(localConfigPath)) {
+    if (isSymlink(localConfigPath)) {
+      const target = readSymlinkTarget(localConfigPath)
+      if (target !== null && path.resolve(target) === path.resolve(globalConfigPath)) return // correct symlink, no-op
+      deletePathSync(localConfigPath) // stale symlink — delete and fall through
+    } else {
+      const localStat = fs.statSync(localConfigPath) // regular file — compare mtime for sync-back
+      const globalStat = fs.statSync(globalConfigPath)
+      if (localStat.mtimeMs > globalStat.mtimeMs) {
+        fs.copyFileSync(localConfigPath, globalConfigPath) // local is newer: sync back to global
+        logger.debug('synced local config back to global', {src: localConfigPath, dest: globalConfigPath})
+      }
+      deletePathSync(localConfigPath)
+    }
+  }
 
   try {
-    fs.symlinkSync(globalConfigPath, configPath, 'file')
-    logger.debug('linked config to shadow project', {link: configPath, target: globalConfigPath})
+    fs.symlinkSync(globalConfigPath, localConfigPath, 'file')
+    logger.debug('linked config', {link: localConfigPath, target: globalConfigPath})
   }
   catch {
     try {
-      fs.copyFileSync(globalConfigPath, configPath)
-      logger.debug('copied config to shadow project (symlink unavailable)', {dest: configPath})
+      fs.copyFileSync(globalConfigPath, localConfigPath)
+      logger.warn('symlink unavailable, copied config (auto-sync disabled)', {dest: localConfigPath})
     }
     catch (copyErr) {
-      logger.warn('failed to link or copy config to shadow project', {
-        path: configPath,
+      logger.warn('failed to link or copy config', {
+        path: localConfigPath,
         error: copyErr instanceof Error ? copyErr.message : String(copyErr)
       })
     }
   }
 }
 
+/**
+ * Ensure the shadow source project directory has a .tnmsc.json symlink
+ * pointing to the global config. Creates a symlink where possible, falls
+ * back to a file copy when symlinks are unavailable (e.g. Windows without
+ * Developer Mode). On every run, syncs edits made inside the shadow back
+ * to the global config before relinking.
+ */
+export function ensureShadowProjectConfigLink(shadowProjectDir: string, logger: ILogger): void {
+  const resolved = shadowProjectDir.startsWith('~')
+    ? path.join(os.homedir(), shadowProjectDir.slice(1))
+    : shadowProjectDir
+
+  if (!fs.existsSync(resolved)) return
+
+  const globalConfigPath = getGlobalConfigPath()
+  const configPath = path.join(resolved, DEFAULT_CONFIG_FILE_NAME)
+  ensureConfigLink(configPath, globalConfigPath, logger)
+}
+
 /**
  * Validate global config file strictly.
  * - If config doesn't exist: create default config, log warn, continue