@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/lib/echo-insight-prompt.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+import { buildEchoInsightUserPrompt } from '@/lib/echo-insight-prompt';
+
+describe('buildEchoInsightUserPrompt', () => {
+  it('includes section title and snapshot lines', () => {
+    const s = buildEchoInsightUserPrompt({
+      locale: 'en',
+      segment: 'self',
+      segmentTitle: 'Insight',
+      factsHeading: 'Snapshot',
+      emptyTitle: 'Nothing yet',
+      emptyBody: 'Clues will appear.',
+      dailyLineLabel: 'Today',
+      dailyLine: '',
+      growthIntentLabel: 'Intent',
+      growthIntent: '',
+    });
+    expect(s).toContain('Insight');
+    expect(s).toContain('Snapshot');
+    expect(s).toContain('Nothing yet');
+    expect(s).toContain('Clues will appear.');
+    expect(s).toMatch(/English/);
+  });
+
+  it('appends daily line when segment is imprint and line non-empty', () => {
+    const s = buildEchoInsightUserPrompt({
+      locale: 'zh',
+      segment: 'imprint',
+      segmentTitle: '印迹',
+      factsHeading: '所见',
+      emptyTitle: '空',
+      emptyBody: '说明',
+      dailyLineLabel: '今日一行',
+      dailyLine: '  hello  ',
+      growthIntentLabel: '意图',
+      growthIntent: '',
+    });
+    expect(s).toContain('今日一行: hello');
+    expect(s).toMatch(/Chinese/);
+  });
+
+  it('appends growth intent when segment is growth', () => {
+    const s = buildEchoInsightUserPrompt({
+      locale: 'en',
+      segment: 'growth',
+      segmentTitle: 'Growth',
+      factsHeading: 'Snapshot',
+      emptyTitle: 'Intent lives here',
+      emptyBody: 'Write your direction.',
+      dailyLineLabel: 'Today',
+      dailyLine: '',
+      growthIntentLabel: 'Intent',
+      growthIntent: '  ship v1  ',
+    });
+    expect(s).toContain('Intent: ship v1');
+  });
+});

package/_standalone/__tests__/lib/echo-pages-visual-i18n.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { en } from '@/lib/i18n';
+import { zh } from '@/lib/i18n';
+
+/** Visual polish strings; en/zh must stay in sync. */
+const VISUAL_KEYS = [
+  'segmentNavAria',
+  'generateInsightNoAi',
+  'insightGenerating',
+  'insightErrorPrefix',
+  'insightRetry',
+  'imprintChatLabel',
+  'growthChatLabel',
+  'selfChatLabel',
+] as const;
+
+describe('echoPages visual polish i18n', () => {
+  it('en defines all visual keys', () => {
+    const p = en.echoPages;
+    for (const k of VISUAL_KEYS) {
+      expect((p as Record<string, unknown>)[k], k).toBeTruthy();
+    }
+  });
+
+  it('zh mirrors all visual keys', () => {
+    const p = zh.echoPages;
+    for (const k of VISUAL_KEYS) {
+      expect((p as Record<string, unknown>)[k], k).toBeTruthy();
+    }
+  });
+});

package/_standalone/__tests__/lib/echo-segments.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest';
+import {
+  defaultEchoSegment,
+  ECHO_SEGMENT_HREF,
+  ECHO_SEGMENT_IDS,
+  ECHO_SEGMENT_ORDER,
+  isEchoSegment,
+} from '@/lib/echo-segments';
+
+describe('echo-segments', () => {
+  it('lists three segments in product order', () => {
+    expect(ECHO_SEGMENT_IDS).toEqual(['imprint', 'growth', 'self']);
+    expect(ECHO_SEGMENT_ORDER).toBe(ECHO_SEGMENT_IDS);
+  });
+
+  it('accepts valid segment slugs', () => {
+    for (const id of ECHO_SEGMENT_IDS) {
+      expect(isEchoSegment(id)).toBe(true);
+    }
+  });
+
+  it('rejects old segment slugs', () => {
+    expect(isEchoSegment('about-you')).toBe(false);
+    expect(isEchoSegment('continued')).toBe(false);
+    expect(isEchoSegment('daily')).toBe(false);
+    expect(isEchoSegment('past-you')).toBe(false);
+  });
+
+  it('rejects empty and malformed slugs', () => {
+    expect(isEchoSegment('')).toBe(false);
+    expect(isEchoSegment(' ')).toBe(false);
+    expect(isEchoSegment('IMPRINT')).toBe(false);
+  });
+
+  it('defaultEchoSegment returns imprint', () => {
+    expect(defaultEchoSegment()).toBe('imprint');
+  });
+
+  it('index redirect path is /echo/imprint', () => {
+    expect(`/echo/${defaultEchoSegment()}`).toBe('/echo/imprint');
+  });
+
+  it('ECHO_SEGMENT_HREF covers every segment with /echo/ prefix', () => {
+    for (const id of ECHO_SEGMENT_IDS) {
+      expect(ECHO_SEGMENT_HREF[id]).toBe(`/echo/${id}`);
+    }
+  });
+});

package/_standalone/__tests__/lib/explore-use-cases.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest';
+import { useCases, categories, scenarios, type UseCaseCategory, type UseCaseScenario } from '@/components/explore/use-cases.generated';
+
+describe('explore/use-cases', () => {
+  it('defines 9 use cases (C1-C9)', () => {
+    expect(useCases).toHaveLength(9);
+  });
+
+  it('each use case has id, icon, valid category, and valid scenario', () => {
+    for (const uc of useCases) {
+      expect(uc.id).toMatch(/^c[1-9]$/);
+      expect(uc.icon).toBeTruthy();
+      expect(categories).toContain(uc.category);
+      expect(scenarios).toContain(uc.scenario);
+    }
+  });
+
+  it('has unique IDs', () => {
+    const ids = useCases.map(u => u.id);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  it('defines exactly 6 categories', () => {
+    expect(categories).toHaveLength(6);
+    expect(categories).toEqual([
+      'knowledge-management',
+      'memory-sync',
+      'auto-execute',
+      'experience-evolution',
+      'human-insights',
+      'audit-control',
+    ]);
+  });
+
+  it('defines exactly 4 scenarios', () => {
+    expect(scenarios).toHaveLength(4);
+    expect(scenarios).toEqual([
+      'first-day',
+      'daily',
+      'project',
+      'advanced',
+    ]);
+  });
+
+  it('every category has at least one use case', () => {
+    for (const cat of categories) {
+      const count = useCases.filter(u => u.category === cat).length;
+      expect(count).toBeGreaterThan(0);
+    }
+  });
+
+  it('every scenario has at least one use case', () => {
+    for (const sc of scenarios) {
+      const count = useCases.filter(u => u.scenario === sc).length;
+      expect(count).toBeGreaterThan(0);
+    }
+  });
+
+  it('C1 is memory-sync + first-day', () => {
+    const c1 = useCases.find(u => u.id === 'c1');
+    expect(c1?.category).toBe('memory-sync');
+    expect(c1?.scenario).toBe('first-day');
+  });
+
+  it('C9 is audit-control + advanced', () => {
+    const c9 = useCases.find(u => u.id === 'c9');
+    expect(c9?.category).toBe('audit-control');
+    expect(c9?.scenario).toBe('advanced');
+  });
+});

package/_standalone/__tests__/lib/i18n-new-keys.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect } from 'vitest';
+import { en } from '@/lib/i18n';
+import { zh } from '@/lib/i18n';
+
+describe('i18n explore keys', () => {
+  const e = en.explore;
+
+  it('has title and subtitle', () => {
+    expect(e.title).toBeTruthy();
+    expect(e.subtitle).toBeTruthy();
+  });
+
+  it('has tryIt button text', () => {
+    expect(e.tryIt).toBeTruthy();
+  });
+
+  it('has all 6 category labels', () => {
+    expect(e.categories['knowledge-management']).toBeTruthy();
+    expect(e.categories['memory-sync']).toBeTruthy();
+    expect(e.categories['auto-execute']).toBeTruthy();
+    expect(e.categories['experience-evolution']).toBeTruthy();
+    expect(e.categories['human-insights']).toBeTruthy();
+    expect(e.categories['audit-control']).toBeTruthy();
+  });
+
+  it('has all 4 scenario labels', () => {
+    expect(e.scenarios['first-day']).toBeTruthy();
+    expect(e.scenarios['daily']).toBeTruthy();
+    expect(e.scenarios['project']).toBeTruthy();
+    expect(e.scenarios['advanced']).toBeTruthy();
+  });
+
+  it('has c1-c9 each with title, desc, prompt', () => {
+    for (let i = 1; i <= 9; i++) {
+      const key = `c${i}` as keyof typeof e;
+      const data = e[key] as { title: string; desc: string; prompt: string };
+      expect(data.title, `c${i}.title`).toBeTruthy();
+      expect(data.desc, `c${i}.desc`).toBeTruthy();
+      expect(data.prompt, `c${i}.prompt`).toBeTruthy();
+    }
+  });
+});
+
+describe('i18n walkthrough keys', () => {
+  const w = en.walkthrough;
+
+  it('has step counter function', () => {
+    expect(w.step(1, 5)).toBe('1 of 5');
+    expect(w.step(3, 5)).toBe('3 of 5');
+  });
+
+  it('has navigation labels', () => {
+    expect(w.next).toBeTruthy();
+    expect(w.back).toBeTruthy();
+    expect(w.skip).toBeTruthy();
+    expect(w.done).toBeTruthy();
+  });
+
+  it('has exploreCta', () => {
+    expect(w.exploreCta).toBeTruthy();
+  });
+
+  it('defines exactly 3 steps', () => {
+    expect(w.steps).toHaveLength(3);
+  });
+
+  it('each step has title and body', () => {
+    for (const step of w.steps) {
+      expect(step.title).toBeTruthy();
+      expect(step.body).toBeTruthy();
+    }
+  });
+});
+
+describe('i18n onboarding keys', () => {
+  const o = en.onboarding;
+
+  it('has error-related keys', () => {
+    expect(o.initError).toBeTruthy();
+    expect(o.dismiss).toBeTruthy();
+  });
+});
+
+describe('i18n agents panel hub', () => {
+  const hubKeys = [
+    'navOverview',
+    'navMcp',
+    'navSkills',
+    'rosterLabel',
+    'notFoundDetail',
+    'skillsEmptyHint',
+    'backToList',
+    'closeAgentDetail',
+    'agentDetailPanelAria',
+    'agentDetailTransport',
+    'agentDetailSnippet',
+  ] as const;
+
+  it('en has all hub keys', () => {
+    const a = en.panels.agents;
+    for (const k of hubKeys) {
+      expect((a as Record<string, unknown>)[k], k).toBeTruthy();
+    }
+  });
+
+  it('zh mirrors all hub keys', () => {
+    const a = zh.panels.agents;
+    for (const k of hubKeys) {
+      expect((a as Record<string, unknown>)[k], k).toBeTruthy();
+    }
+  });
+});
+
+describe('i18n echo panel', () => {
+  const echoKeys = [
+    'title',
+    'imprintTitle',
+    'growthTitle',
+    'selfTitle',
+  ] as const;
+
+  it('en has all echo keys', () => {
+    const e = en.panels.echo;
+    for (const k of echoKeys) {
+      expect((e as Record<string, unknown>)[k], k).toBeTruthy();
+    }
+  });
+
+  it('zh mirrors all echo keys', () => {
+    const e = zh.panels.echo;
+    for (const k of echoKeys) {
+      expect((e as Record<string, unknown>)[k], k).toBeTruthy();
+    }
+  });
+});
+
+describe('i18n ask panel composer', () => {
+  const keys = ['panelComposerResize', 'panelComposerFooter', 'panelComposerResetHint', 'panelComposerKeyboard'] as const;
+
+  it('en has panel composer UX strings', () => {
+    const a = en.ask;
+    for (const k of keys) {
+      expect((a as Record<string, unknown>)[k], k).toBeTruthy();
+    }
+  });
+
+  it('zh mirrors panel composer UX strings', () => {
+    const a = zh.ask;
+    for (const k of keys) {
+      expect((a as Record<string, unknown>)[k], k).toBeTruthy();
+    }
+  });
+});

package/_standalone/__tests__/lib/mcp-snippets.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect } from 'vitest';
+import {
+  generateStdioSnippet,
+  generateHttpSnippet,
+  generateSnippet,
+  type ConfigSnippet,
+} from '@/lib/mcp-snippets';
+import type { AgentInfo, McpStatus } from '@/components/settings/types';
+
+/* ── Fixtures ── */
+
+const jsonAgent: AgentInfo = {
+  key: 'claude-code',
+  name: 'Claude Code',
+  present: true,
+  installed: true,
+  hasProjectScope: false,
+  hasGlobalScope: true,
+  preferredTransport: 'stdio' as const,
+  format: 'json' as const,
+  configKey: 'mcpServers',
+  globalPath: '~/.claude.json',
+  projectPath: null,
+};
+
+const nestedJsonAgent: AgentInfo = {
+  ...jsonAgent,
+  key: 'cursor',
+  name: 'Cursor',
+  globalNestedKey: 'mcpServers',
+  configKey: 'mcpServers',
+  globalPath: '~/.cursor/mcp.json',
+  projectPath: '.cursor/mcp.json',
+  hasProjectScope: true,
+};
+
+const tomlAgent: AgentInfo = {
+  ...jsonAgent,
+  key: 'zed',
+  name: 'Zed',
+  format: 'toml' as const,
+  configKey: 'context_servers',
+  globalPath: '~/.config/zed/settings.toml',
+};
+
+const mcpStatus: McpStatus = {
+  running: true,
+  transport: 'http',
+  endpoint: 'http://192.168.1.100:8781/mcp',
+  port: 8781,
+  toolCount: 20,
+  authConfigured: true,
+  authToken: 'token_abc123',
+  maskedToken: 'token_a••••3',
+};
+
+/* ── Tests ── */
+
+describe('mcp-snippets', () => {
+  describe('generateStdioSnippet', () => {
+    it('generates JSON snippet for standard agent', () => {
+      const result = generateStdioSnippet(jsonAgent);
+      expect(result.path).toBe('~/.claude.json');
+      const parsed = JSON.parse(result.snippet);
+      expect(parsed.mcpServers.mindos).toEqual({
+        type: 'stdio',
+        command: 'mindos',
+        args: ['mcp'],
+      });
+      // snippet and displaySnippet should be identical for stdio
+      expect(result.snippet).toBe(result.displaySnippet);
+    });
+
+    it('generates JSON snippet for nested-key agent with projectPath', () => {
+      const result = generateStdioSnippet(nestedJsonAgent);
+      expect(result.path).toBe('.cursor/mcp.json');
+      const parsed = JSON.parse(result.snippet);
+      expect(parsed.mcpServers.mindos.command).toBe('mindos');
+    });
+
+    it('generates TOML snippet for TOML-format agent', () => {
+      const result = generateStdioSnippet(tomlAgent);
+      expect(result.path).toBe('~/.config/zed/settings.toml');
+      expect(result.snippet).toContain('[context_servers.mindos]');
+      expect(result.snippet).toContain('command = "mindos"');
+      expect(result.snippet).toContain('MCP_TRANSPORT = "stdio"');
+    });
+  });
+
+  describe('generateHttpSnippet', () => {
+    it('generates HTTP snippet with auth token', () => {
+      const result = generateHttpSnippet(
+        jsonAgent,
+        'http://192.168.1.100:8781/mcp',
+        'token_abc123',
+        'token_a••••3',
+      );
+      // Copy version has full token
+      const parsed = JSON.parse(result.snippet);
+      expect(parsed.mcpServers.mindos.url).toBe('http://192.168.1.100:8781/mcp');
+      expect(parsed.mcpServers.mindos.headers.Authorization).toBe('Bearer token_abc123');
+
+      // Display version has masked token
+      const display = JSON.parse(result.displaySnippet);
+      expect(display.mcpServers.mindos.headers.Authorization).toBe('Bearer token_a••••3');
+    });
+
+    it('generates HTTP snippet without auth when token is undefined', () => {
+      const result = generateHttpSnippet(jsonAgent, 'http://localhost:8781/mcp');
+      const parsed = JSON.parse(result.snippet);
+      expect(parsed.mcpServers.mindos.url).toBe('http://localhost:8781/mcp');
+      expect(parsed.mcpServers.mindos.headers).toBeUndefined();
+    });
+
+    it('generates TOML HTTP snippet with auth header', () => {
+      const result = generateHttpSnippet(
+        tomlAgent,
+        'http://192.168.1.100:8781/mcp',
+        'token_abc123',
+        'token_a••••3',
+      );
+      expect(result.snippet).toContain('[context_servers.mindos]');
+      expect(result.snippet).toContain('type = "http"');
+      expect(result.snippet).toContain('url = "http://192.168.1.100:8781/mcp"');
+      expect(result.snippet).toContain('[context_servers.mindos.headers]');
+      expect(result.snippet).toContain('Authorization = "Bearer token_abc123"');
+    });
+  });
+
+  describe('generateSnippet', () => {
+    it('delegates to stdio when transport is stdio', () => {
+      const result = generateSnippet(jsonAgent, mcpStatus, 'stdio');
+      const parsed = JSON.parse(result.snippet);
+      expect(parsed.mcpServers.mindos.type).toBe('stdio');
+      expect(parsed.mcpServers.mindos.command).toBe('mindos');
+    });
+
+    it('delegates to http when transport is http', () => {
+      const result = generateSnippet(jsonAgent, mcpStatus, 'http');
+      const parsed = JSON.parse(result.snippet);
+      expect(parsed.mcpServers.mindos.url).toBe('http://192.168.1.100:8781/mcp');
+    });
+
+    it('uses fallback endpoint when status is null', () => {
+      const result = generateSnippet(jsonAgent, null, 'http');
+      const parsed = JSON.parse(result.snippet);
+      expect(parsed.mcpServers.mindos.url).toBe('http://127.0.0.1:8781/mcp');
+    });
+
+    it('passes authToken from status to http snippet', () => {
+      const result = generateSnippet(jsonAgent, mcpStatus, 'http');
+      const parsed = JSON.parse(result.snippet);
+      expect(parsed.mcpServers.mindos.headers.Authorization).toBe('Bearer token_abc123');
+    });
+
+    it('omits auth header when status has no authToken', () => {
+      const noAuthStatus: McpStatus = { ...mcpStatus, authToken: undefined, maskedToken: undefined };
+      const result = generateSnippet(jsonAgent, noAuthStatus, 'http');
+      const parsed = JSON.parse(result.snippet);
+      expect(parsed.mcpServers.mindos.headers).toBeUndefined();
+    });
+  });
+});

package/_standalone/__tests__/lib/mindos-copy-alignment.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { MINDOS_AGENT } from '@/lib/ask-agent';
+import { aiChatEn, aiChatZh } from '@/lib/i18n/modules/ai-chat';
+import { navigationEn, navigationZh } from '@/lib/i18n/modules/navigation';
+import { featuresEn, featuresZh } from '@/lib/i18n/modules/features';
+import { panelsEn, panelsZh } from '@/lib/i18n/modules/panels';
+import { onboardingEn, onboardingZh } from '@/lib/i18n/modules/onboarding';
+
+describe('MindOS copy alignment', () => {
+  it('uses MindOS as the default local assistant name', () => {
+    expect(MINDOS_AGENT).toEqual({ id: 'mindos', name: 'MindOS' });
+    expect(aiChatEn.ask.title).toBe('MindOS');
+    expect(aiChatZh.ask.title).toBe('MindOS');
+    expect(navigationEn.sidebar.askTitle).toBe('MindOS');
+    expect(navigationZh.sidebar.askTitle).toBe('MindOS');
+    expect(panelsEn.panels.agents.acpDefaultAgent).toBe('MindOS');
+    expect(panelsZh.panels.agents.acpDefaultAgent).toBe('MindOS');
+  });
+
+  it('keeps shortcut and onboarding copy aligned around MindOS', () => {
+    expect(featuresEn.shortcuts[1]?.description).toBe('MindOS');
+    expect(featuresZh.shortcuts[1]?.description).toBe('MindOS');
+    expect(featuresEn.shortcuts[2]?.description).not.toBe('MindOS');
+    expect(onboardingEn.setup.welcomeLinkAskAI).toBe('MindOS');
+    expect(onboardingZh.setup.welcomeLinkAskAI).toBe('MindOS');
+    expect(onboardingEn.walkthrough.steps[1]?.body).toContain('MindOS');
+    expect(onboardingZh.walkthrough.steps[1]?.body).toContain('MindOS');
+  });
+
+  it('removes second-brain wording from key user-facing copy surfaces', () => {
+    expect(featuresEn.help.whatIs.body.toLowerCase()).not.toContain('same brain');
+    expect(featuresZh.help.whatIs.body).not.toContain('同一个大脑');
+    expect(panelsEn.panels.im.emptyDesc.toLowerCase()).not.toContain('mindos agent');
+    expect(panelsZh.panels.im.emptyDesc).not.toContain('MindOS Agent');
+  });
+});

package/_standalone/__tests__/lib/pi-extensions.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { getExtensionsList } from '@/lib/pi-integration/extensions';
+
+let tempHome: string;
+let origHome: string;
+
+beforeEach(() => {
+  tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-ext-test-'));
+  origHome = process.env.HOME ?? '';
+  process.env.HOME = tempHome;
+});
+
+afterEach(() => {
+  process.env.HOME = origHome;
+  fs.rmSync(tempHome, { recursive: true, force: true });
+});
+
+describe('extensions discovery', () => {
+  it('discovers extensions from ~/.mindos/extensions/', async () => {
+    const extDir = path.join(tempHome, '.mindos', 'extensions');
+    fs.mkdirSync(extDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(extDir, 'hello.ts'),
+      `export default function hello(pi) { pi.on("context", () => ({ appendSystemPrompt: "hello" })); }`,
+    );
+
+    const extensions = await getExtensionsList('/tmp/nonexistent-project', '/tmp/nonexistent-mind');
+    const ext = extensions.find((e) => e.name === 'hello');
+    expect(ext).toBeDefined();
+    expect(ext!.enabled).toBe(true);
+    expect(ext!.path).toContain('hello');
+  });
+
+  it('returns empty array when no extensions exist', async () => {
+    const extensions = await getExtensionsList('/tmp/nonexistent-project', '/tmp/nonexistent-mind');
+    expect(extensions).toEqual([]);
+  });
+});