@mseep/claudian 2.0.25

package/tests/unit/i18n/i18n.test.ts

@@ -0,0 +1,244 @@
+import {
+  getAvailableLocales,
+  getLocale,
+  getLocaleDisplayName,
+  setLocale,
+  t,
+} from '@/i18n/i18n';
+import type { Locale, TranslationKey } from '@/i18n/types';
+
+describe('i18n', () => {
+  // Reset locale to default before each test
+  beforeEach(() => {
+    setLocale('en');
+  });
+
+  describe('t (translate)', () => {
+    it('returns translated string for valid key', () => {
+      const result = t('common.save' as TranslationKey);
+      expect(result).toBe('Save');
+    });
+
+    it('returns string with parameter interpolation', () => {
+      // Use a key that has placeholders
+      const result = t('chat.rewind.notice' as TranslationKey, { count: 2 });
+      expect(result).toBe('Rewound: 2 file(s) reverted');
+    });
+
+    it('returns key for missing translation in English', () => {
+      const result = t('nonexistent.key.here' as TranslationKey);
+
+      expect(result).toBe('nonexistent.key.here');
+    });
+
+    it('falls back to English for missing translation in other locale', () => {
+      setLocale('de');
+
+      // Use a key that exists in English but might not in German
+      const result = t('common.save' as TranslationKey);
+
+      // Should return the English translation or the German one
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('handles nested keys correctly', () => {
+      const result = t('settings.userName.name' as TranslationKey);
+      expect(result).toBe('What should Claudian call you?');
+    });
+
+    it('handles deeply nested keys', () => {
+      const result = t('settings.userName.desc' as TranslationKey);
+      expect(result).toBe('Your name for personalized greetings (leave empty for generic greetings)');
+    });
+
+    it('returns key when value is not a string', () => {
+      // Try to access a non-leaf key (object instead of string)
+      const result = t('settings' as TranslationKey);
+
+      expect(result).toBe('settings');
+    });
+
+    it('replaces placeholders with params', () => {
+      // Use a key with {param} placeholders
+      const result = t('chat.fork.failed' as TranslationKey, { error: 'Network timeout' });
+      expect(result).toBe('Fork failed: Network timeout');
+    });
+
+    it('keeps placeholder if param not provided', () => {
+      // Use a key with placeholders but don't provide the param
+      const result = t('chat.rewind.notice' as TranslationKey, {});
+      expect(result).toBe('Rewound: {count} file(s) reverted');
+    });
+  });
+
+  describe('setLocale', () => {
+    it('sets valid locale and returns true', () => {
+      const result = setLocale('ja');
+
+      expect(result).toBe(true);
+      expect(getLocale()).toBe('ja');
+    });
+
+    it('sets Chinese Simplified locale', () => {
+      const result = setLocale('zh-CN');
+
+      expect(result).toBe(true);
+      expect(getLocale()).toBe('zh-CN');
+    });
+
+    it('sets Chinese Traditional locale', () => {
+      const result = setLocale('zh-TW');
+
+      expect(result).toBe(true);
+      expect(getLocale()).toBe('zh-TW');
+    });
+
+    it('returns false for invalid locale and keeps current', () => {
+      setLocale('de');
+
+      const result = setLocale('invalid' as Locale);
+
+      expect(result).toBe(false);
+      expect(getLocale()).toBe('de'); // Should remain unchanged
+    });
+  });
+
+  describe('getLocale', () => {
+    it('returns default locale initially', () => {
+      expect(getLocale()).toBe('en');
+    });
+
+    it('returns current locale after change', () => {
+      setLocale('fr');
+      expect(getLocale()).toBe('fr');
+    });
+  });
+
+  describe('getAvailableLocales', () => {
+    it('returns all supported locales', () => {
+      const locales = getAvailableLocales();
+
+      expect(locales).toContain('en');
+      expect(locales).toContain('zh-CN');
+      expect(locales).toContain('zh-TW');
+      expect(locales).toContain('ja');
+      expect(locales).toContain('ko');
+      expect(locales).toContain('de');
+      expect(locales).toContain('fr');
+      expect(locales).toContain('es');
+      expect(locales).toContain('ru');
+      expect(locales).toContain('pt');
+    });
+
+    it('returns exactly 10 locales', () => {
+      const locales = getAvailableLocales();
+      expect(locales).toHaveLength(10);
+    });
+  });
+
+  describe('getLocaleDisplayName', () => {
+    it('returns English for en', () => {
+      expect(getLocaleDisplayName('en')).toBe('English');
+    });
+
+    it('returns Simplified Chinese name for zh-CN', () => {
+      expect(getLocaleDisplayName('zh-CN')).toBe('简体中文');
+    });
+
+    it('returns Traditional Chinese name for zh-TW', () => {
+      expect(getLocaleDisplayName('zh-TW')).toBe('繁體中文');
+    });
+
+    it('returns Japanese name for ja', () => {
+      expect(getLocaleDisplayName('ja')).toBe('日本語');
+    });
+
+    it('returns Korean name for ko', () => {
+      expect(getLocaleDisplayName('ko')).toBe('한국어');
+    });
+
+    it('returns German name for de', () => {
+      expect(getLocaleDisplayName('de')).toBe('Deutsch');
+    });
+
+    it('returns French name for fr', () => {
+      expect(getLocaleDisplayName('fr')).toBe('Français');
+    });
+
+    it('returns Spanish name for es', () => {
+      expect(getLocaleDisplayName('es')).toBe('Español');
+    });
+
+    it('returns Russian name for ru', () => {
+      expect(getLocaleDisplayName('ru')).toBe('Русский');
+    });
+
+    it('returns Portuguese name for pt', () => {
+      expect(getLocaleDisplayName('pt')).toBe('Português');
+    });
+
+    it('returns locale code for unknown locale', () => {
+      expect(getLocaleDisplayName('xx' as Locale)).toBe('xx');
+    });
+  });
+
+  describe('translation in different locales', () => {
+    it('translates correctly in German', () => {
+      setLocale('de');
+      const result = t('common.save' as TranslationKey);
+      // German should have a translation or fall back to English
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('translates correctly in Japanese', () => {
+      setLocale('ja');
+      const result = t('common.save' as TranslationKey);
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('translates correctly in Korean', () => {
+      setLocale('ko');
+      const result = t('common.save' as TranslationKey);
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('translates correctly in Simplified Chinese', () => {
+      setLocale('zh-CN');
+      const result = t('common.save' as TranslationKey);
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('translates correctly in French', () => {
+      setLocale('fr');
+      const result = t('common.save' as TranslationKey);
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('translates correctly in Spanish', () => {
+      setLocale('es');
+      const result = t('common.save' as TranslationKey);
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('translates correctly in Russian', () => {
+      setLocale('ru');
+      const result = t('common.save' as TranslationKey);
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('translates correctly in Portuguese', () => {
+      setLocale('pt');
+      const result = t('common.save' as TranslationKey);
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+  });
+});

package/tests/unit/i18n/locales.test.ts

@@ -0,0 +1,134 @@
+import * as de from '@/i18n/locales/de.json';
+import * as en from '@/i18n/locales/en.json';
+import * as es from '@/i18n/locales/es.json';
+import * as fr from '@/i18n/locales/fr.json';
+import * as ja from '@/i18n/locales/ja.json';
+import * as ko from '@/i18n/locales/ko.json';
+import * as pt from '@/i18n/locales/pt.json';
+import * as ru from '@/i18n/locales/ru.json';
+import * as zhCN from '@/i18n/locales/zh-CN.json';
+import * as zhTW from '@/i18n/locales/zh-TW.json';
+
+interface TranslationTree {
+  [key: string]: string | TranslationTree;
+}
+
+const locales = {
+  de,
+  es,
+  fr,
+  ja,
+  ko,
+  pt,
+  ru,
+  'zh-CN': zhCN,
+  'zh-TW': zhTW,
+} as const;
+
+const localizedKeys = [
+  'chat.rewind.confirmMessageConversationOnly',
+  'chat.rewind.menuConversationOnly',
+  'chat.rewind.menuCodeAndConversation',
+  'chat.rewind.noticeConversationOnly',
+  'chat.rewind.noticeConversationOnlySaveFailed',
+  'chat.fork.errorMessageNotFound',
+  'chat.fork.errorNoSession',
+  'chat.fork.errorNoActiveTab',
+  'chat.bangBash.placeholder',
+  'chat.bangBash.commandPanel',
+  'chat.bangBash.copyAriaLabel',
+  'chat.bangBash.clearAriaLabel',
+  'chat.bangBash.statusLabel',
+  'chat.bangBash.collapseOutput',
+  'chat.bangBash.expandOutput',
+  'chat.bangBash.running',
+  'chat.bangBash.copyFailed',
+  'settings.subagents.name',
+  'settings.subagents.desc',
+  'settings.subagents.noAgents',
+  'settings.subagents.deleteConfirm',
+  'settings.subagents.saveFailed',
+  'settings.subagents.deleteFailed',
+  'settings.subagents.renameCleanupFailed',
+  'settings.subagents.created',
+  'settings.subagents.updated',
+  'settings.subagents.deleted',
+  'settings.subagents.duplicateName',
+  'settings.subagents.descriptionRequired',
+  'settings.subagents.promptRequired',
+  'settings.subagents.modal.titleEdit',
+  'settings.subagents.modal.titleAdd',
+  'settings.subagents.modal.nameDesc',
+  'settings.subagents.modal.descriptionDesc',
+  'settings.subagents.modal.descriptionPlaceholder',
+  'settings.subagents.modal.advancedOptions',
+  'settings.subagents.modal.modelDesc',
+  'settings.subagents.modal.toolsDesc',
+  'settings.subagents.modal.disallowedTools',
+  'settings.subagents.modal.disallowedToolsDesc',
+  'settings.subagents.modal.skills',
+  'settings.subagents.modal.skillsDesc',
+  'settings.subagents.modal.prompt',
+  'settings.subagents.modal.promptDesc',
+  'settings.subagents.modal.promptPlaceholder',
+  'settings.enableBangBash.name',
+  'settings.enableBangBash.desc',
+  'settings.enableBangBash.validation.noNode',
+  'settings.requireCommandOrControlEnterToSend.name',
+  'settings.requireCommandOrControlEnterToSend.desc',
+] as const;
+
+const staleBangBashDesc =
+  'Type ! on empty input to enter bash mode. Runs commands directly via Node.js child_process.';
+
+function flattenTranslations(
+  translations: TranslationTree,
+  prefix = '',
+  out: Record<string, string> = {}
+): Record<string, string> {
+  for (const [key, value] of Object.entries(translations)) {
+    const nextKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === 'object') {
+      flattenTranslations(value as TranslationTree, nextKey, out);
+      continue;
+    }
+
+    out[nextKey] = String(value);
+  }
+
+  return out;
+}
+
+describe('locale files', () => {
+  const english = flattenTranslations(en as unknown as TranslationTree);
+
+  it('keeps every locale structurally aligned with English', () => {
+    const englishKeys = Object.keys(english).sort();
+
+    for (const [locale, translations] of Object.entries(locales)) {
+      const localeKeys = Object.keys(flattenTranslations(translations as unknown as TranslationTree)).sort();
+      expect(localeKeys).toEqual(englishKeys);
+      expect(locale).toBeTruthy();
+    }
+  });
+
+  it('localizes the recent bang bash and subagent additions', () => {
+    for (const translations of Object.values(locales)) {
+      const locale = flattenTranslations(translations as unknown as TranslationTree);
+
+      for (const key of localizedKeys) {
+        expect(locale[key]).toBeDefined();
+        expect(locale[key]).not.toBe(english[key]);
+      }
+
+      expect(locale['settings.enableBangBash.desc']).not.toBe(staleBangBashDesc);
+    }
+  });
+
+  it('uses commands-and-skills copy for hidden Claude entries', () => {
+    expect(english['settings.hiddenSlashCommands.name']).toBe('Hidden Commands and Skills');
+    expect(english['settings.hiddenSlashCommands.desc']).toBe(
+      'Hide specific commands and skills from the dropdown. Useful for hiding Claude Code entries that are not relevant to Claudian. Enter names without the leading slash, one per line.',
+    );
+  });
+});

package/tests/unit/providers/acp/AcpClientConnection.test.ts

@@ -0,0 +1,248 @@
+import { createInterface } from 'node:readline';
+import { PassThrough } from 'node:stream';
+
+import type {
+  AcpSessionNotification,
+  JsonRpcRequestOptions,
+} from '../../../../src/providers/acp';
+import {
+  AcpClientConnection,
+  AcpJsonRpcTransport,
+  JsonRpcErrorResponse,
+} from '../../../../src/providers/acp';
+
+interface ConnectionHarness {
+  close: () => void;
+  connection: AcpClientConnection;
+  nextOutbound: () => Promise<Record<string, unknown>>;
+  sendInbound: (message: Record<string, unknown>) => void;
+  transport: AcpJsonRpcTransport;
+}
+
+function createConnectionHarness(
+  connectionFactory: (transport: AcpJsonRpcTransport) => AcpClientConnection,
+): ConnectionHarness {
+  const input = new PassThrough();
+  const output = new PassThrough();
+  const reader = createInterface({ input: output });
+  const queued: Record<string, unknown>[] = [];
+  const waiters: Array<(message: Record<string, unknown>) => void> = [];
+  const transport = new AcpJsonRpcTransport({ input, output });
+
+  reader.on('line', (line) => {
+    const message = JSON.parse(line) as Record<string, unknown>;
+    const waiter = waiters.shift();
+    if (waiter) {
+      waiter(message);
+      return;
+    }
+    queued.push(message);
+  });
+
+  return {
+    close: () => {
+      reader.close();
+      input.end();
+      output.end();
+    },
+    connection: connectionFactory(transport),
+    nextOutbound: () => {
+      if (queued.length > 0) {
+        return Promise.resolve(queued.shift()!);
+      }
+      return new Promise(resolve => waiters.push(resolve));
+    },
+    sendInbound: (message) => {
+      input.write(`${JSON.stringify(message)}\n`);
+    },
+    transport,
+  };
+}
+
+describe('AcpClientConnection', () => {
+  it('advertises derived client capabilities and dispatches session notifications', async () => {
+    const notifications: AcpSessionNotification[] = [];
+    const harness = createConnectionHarness((transport) => new AcpClientConnection({
+      clientInfo: { name: 'claudian', version: '0.0.0-test' },
+      delegate: {
+        fileSystem: {
+          readTextFile: async () => ({ content: 'hello' }),
+        },
+        onSessionNotification: async (notification) => {
+          notifications.push(notification);
+        },
+      },
+      transport,
+    }));
+
+    try {
+      const initializePromise = harness.connection.initialize();
+      const outbound = await harness.nextOutbound();
+
+      expect(outbound.method).toBe('initialize');
+      expect(outbound.params).toMatchObject({
+        clientCapabilities: {
+          fs: {
+            readTextFile: true,
+          },
+        },
+        clientInfo: { name: 'claudian', version: '0.0.0-test' },
+        protocolVersion: 1,
+      });
+
+      harness.sendInbound({
+        id: outbound.id,
+        jsonrpc: '2.0',
+        result: {
+          agentCapabilities: { loadSession: true },
+          agentInfo: { name: 'gemini', version: '1.0.0' },
+          protocolVersion: 1,
+        },
+      });
+
+      await initializePromise;
+
+      harness.sendInbound({
+        jsonrpc: '2.0',
+        method: 'session/update',
+        params: {
+          sessionId: 'session-1',
+          update: {
+            sessionUpdate: 'session_info_update',
+            title: 'Renamed Session',
+          },
+        },
+      });
+
+      await new Promise(resolve => setImmediate(resolve));
+      expect(notifications).toEqual([{
+        sessionId: 'session-1',
+        update: {
+          sessionUpdate: 'session_info_update',
+          title: 'Renamed Session',
+        },
+      }]);
+    } finally {
+      harness.connection.dispose();
+      harness.transport.dispose();
+      harness.close();
+    }
+  });
+
+  it('falls back to legacy method names and caches the resolved method', async () => {
+    const harness = createConnectionHarness((transport) => new AcpClientConnection({ transport }));
+
+    try {
+      const firstPromise = harness.connection.setMode({
+        modeId: 'plan',
+        sessionId: 'session-1',
+      });
+
+      const firstAttempt = await harness.nextOutbound();
+      expect(firstAttempt.method).toBe('session/set_mode');
+      harness.sendInbound({
+        error: {
+          code: -32601,
+          message: 'Method not found',
+        },
+        id: firstAttempt.id,
+        jsonrpc: '2.0',
+      });
+
+      const secondAttempt = await harness.nextOutbound();
+      expect(secondAttempt.method).toBe('setSessionMode');
+      harness.sendInbound({
+        id: secondAttempt.id,
+        jsonrpc: '2.0',
+        result: {},
+      });
+
+      await expect(firstPromise).resolves.toEqual({});
+
+      const cachedPromise = harness.connection.setMode({
+        modeId: 'plan',
+        sessionId: 'session-1',
+      });
+
+      const cachedAttempt = await harness.nextOutbound();
+      expect(cachedAttempt.method).toBe('setSessionMode');
+      harness.sendInbound({
+        id: cachedAttempt.id,
+        jsonrpc: '2.0',
+        result: {},
+      });
+
+      await expect(cachedPromise).resolves.toEqual({});
+    } finally {
+      harness.connection.dispose();
+      harness.transport.dispose();
+      harness.close();
+    }
+  });
+
+  it('disables request timeout for prompt turns across method fallback', async () => {
+    const promptRequest = {
+      prompt: [{ text: 'hi', type: 'text' as const }],
+      sessionId: 'session-1',
+    };
+    const requests: Array<{
+      method: string;
+      options?: JsonRpcRequestOptions;
+      params?: unknown;
+    }> = [];
+    const transport = {
+      notify: () => undefined,
+      onNotification: () => () => undefined,
+      onRequest: () => () => undefined,
+      request: async (method: string, params?: unknown, options?: JsonRpcRequestOptions) => {
+        requests.push({ method, options, params });
+        if (method === 'session/prompt') {
+          throw new JsonRpcErrorResponse(method, -32601, 'Method not found');
+        }
+        return { stopReason: 'end_turn' };
+      },
+      signal: new AbortController().signal,
+    } as unknown as AcpJsonRpcTransport;
+    const connection = new AcpClientConnection({ transport });
+
+    await expect(connection.prompt(promptRequest)).resolves.toEqual({
+      stopReason: 'end_turn',
+    });
+
+    expect(requests).toEqual([
+      {
+        method: 'session/prompt',
+        options: { timeoutMs: 0 },
+        params: promptRequest,
+      },
+      {
+        method: 'prompt',
+        options: { timeoutMs: 0 },
+        params: promptRequest,
+      },
+    ]);
+  });
+
+  it('sends cancel notifications to all known aliases when no working method is cached', async () => {
+    const harness = createConnectionHarness((transport) => new AcpClientConnection({ transport }));
+
+    try {
+      harness.connection.cancel({ sessionId: 'session-1' });
+
+      await expect(harness.nextOutbound()).resolves.toMatchObject({
+        jsonrpc: '2.0',
+        method: 'session/cancel',
+        params: { sessionId: 'session-1' },
+      });
+      await expect(harness.nextOutbound()).resolves.toMatchObject({
+        jsonrpc: '2.0',
+        method: 'cancel',
+        params: { sessionId: 'session-1' },
+      });
+    } finally {
+      harness.connection.dispose();
+      harness.transport.dispose();
+      harness.close();
+    }
+  });
+});