@geminilight/mindos 0.6.71 → 0.6.73

package/tests/unit/cli-skill-auto-copy.test.ts

@@ -1,260 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-/**
- * Tests for auto-copy skill logic used by unsupported agents.
- *
- * Validates:
- *   1. copyDirSync — recursive pure-Node.js directory copy (cross-platform)
- *   2. autoInstallSkillForAgent — end-to-end skill copy for unsupported agents
- *   3. Edge cases: existing target, missing source, symlinks, nested dirs
- */
-
-let tempDir: string;
-
-beforeEach(() => {
-  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-skill-copy-test-'));
-});
-
-afterEach(() => {
-  fs.rmSync(tempDir, { recursive: true, force: true });
-});
-
-// ── copyDirSync (extracted from bin/lib/mcp-install.js for testing) ──────
-
-/** Pure-Node.js recursive directory copy — mirrors the CLI implementation. */
-function copyDirSync(src: string, dst: string) {
-  fs.mkdirSync(dst, { recursive: true });
-  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    const s = path.join(src, entry.name);
-    const d = path.join(dst, entry.name);
-    if (entry.isDirectory()) {
-      copyDirSync(s, d);
-    } else {
-      fs.copyFileSync(s, d);
-    }
-  }
-}
-
-describe('copyDirSync (cross-platform recursive copy)', () => {
-  it('copies a flat directory with files', () => {
-    const src = path.join(tempDir, 'src');
-    const dst = path.join(tempDir, 'dst');
-    fs.mkdirSync(src);
-    fs.writeFileSync(path.join(src, 'SKILL.md'), '# Test Skill\n');
-    fs.writeFileSync(path.join(src, 'config.json'), '{"key":"val"}');
-
-    copyDirSync(src, dst);
-
-    expect(fs.existsSync(path.join(dst, 'SKILL.md'))).toBe(true);
-    expect(fs.existsSync(path.join(dst, 'config.json'))).toBe(true);
-    expect(fs.readFileSync(path.join(dst, 'SKILL.md'), 'utf-8')).toBe('# Test Skill\n');
-    expect(fs.readFileSync(path.join(dst, 'config.json'), 'utf-8')).toBe('{"key":"val"}');
-  });
-
-  it('copies nested directories recursively', () => {
-    const src = path.join(tempDir, 'src');
-    fs.mkdirSync(path.join(src, 'sub', 'deep'), { recursive: true });
-    fs.writeFileSync(path.join(src, 'top.txt'), 'top');
-    fs.writeFileSync(path.join(src, 'sub', 'mid.txt'), 'mid');
-    fs.writeFileSync(path.join(src, 'sub', 'deep', 'bottom.txt'), 'bottom');
-
-    const dst = path.join(tempDir, 'dst');
-    copyDirSync(src, dst);
-
-    expect(fs.readFileSync(path.join(dst, 'top.txt'), 'utf-8')).toBe('top');
-    expect(fs.readFileSync(path.join(dst, 'sub', 'mid.txt'), 'utf-8')).toBe('mid');
-    expect(fs.readFileSync(path.join(dst, 'sub', 'deep', 'bottom.txt'), 'utf-8')).toBe('bottom');
-  });
-
-  it('creates destination directory if it does not exist', () => {
-    const src = path.join(tempDir, 'src');
-    fs.mkdirSync(src);
-    fs.writeFileSync(path.join(src, 'file.txt'), 'content');
-
-    const dst = path.join(tempDir, 'non', 'existent', 'dst');
-    copyDirSync(src, dst);
-
-    expect(fs.existsSync(path.join(dst, 'file.txt'))).toBe(true);
-  });
-
-  it('copies empty directories', () => {
-    const src = path.join(tempDir, 'src');
-    fs.mkdirSync(path.join(src, 'empty-sub'), { recursive: true });
-
-    const dst = path.join(tempDir, 'dst');
-    copyDirSync(src, dst);
-
-    expect(fs.statSync(path.join(dst, 'empty-sub')).isDirectory()).toBe(true);
-  });
-
-  it('preserves file content for binary-like files', () => {
-    const src = path.join(tempDir, 'src');
-    fs.mkdirSync(src);
-    // Write a buffer with non-UTF8 bytes
-    const buf = Buffer.from([0x00, 0x01, 0x02, 0xFF, 0xFE]);
-    fs.writeFileSync(path.join(src, 'binary.bin'), buf);
-
-    const dst = path.join(tempDir, 'dst');
-    copyDirSync(src, dst);
-
-    const copied = fs.readFileSync(path.join(dst, 'binary.bin'));
-    expect(Buffer.compare(copied, buf)).toBe(0);
-  });
-
-  it('handles files with special characters in names', () => {
-    const src = path.join(tempDir, 'src');
-    fs.mkdirSync(src);
-    // Spaces, dashes, dots are common in skill files
-    fs.writeFileSync(path.join(src, 'my-skill file.v2.md'), 'content');
-
-    const dst = path.join(tempDir, 'dst');
-    copyDirSync(src, dst);
-
-    expect(fs.readFileSync(path.join(dst, 'my-skill file.v2.md'), 'utf-8')).toBe('content');
-  });
-});
-
-// ── Realistic skill directory copy ───────────────────────────────────────
-
-describe('Skill directory copy (realistic structure)', () => {
-  it('copies a typical MindOS skill directory', () => {
-    // Create a realistic skill directory
-    const skillSrc = path.join(tempDir, 'skills', 'mindos');
-    fs.mkdirSync(skillSrc, { recursive: true });
-    fs.writeFileSync(path.join(skillSrc, 'SKILL.md'), '---\nname: mindos\n---\n# MindOS Skill');
-    fs.writeFileSync(path.join(skillSrc, 'README.md'), '# README');
-
-    // Simulate copying to a WorkBuddy-like agent dir
-    const agentDir = path.join(tempDir, '.workbuddy');
-    fs.mkdirSync(agentDir);
-    const targetSkillDir = path.join(agentDir, 'skills', 'mindos');
-
-    copyDirSync(skillSrc, targetSkillDir);
-
-    expect(fs.existsSync(path.join(targetSkillDir, 'SKILL.md'))).toBe(true);
-    expect(fs.readFileSync(path.join(targetSkillDir, 'SKILL.md'), 'utf-8')).toContain('MindOS Skill');
-    expect(fs.existsSync(path.join(targetSkillDir, 'README.md'))).toBe(true);
-  });
-
-  it('does not overwrite if target already exists (guard check)', () => {
-    const skillSrc = path.join(tempDir, 'skills', 'mindos');
-    fs.mkdirSync(skillSrc, { recursive: true });
-    fs.writeFileSync(path.join(skillSrc, 'SKILL.md'), 'new content');
-
-    const targetSkillDir = path.join(tempDir, '.agent', 'skills', 'mindos');
-    fs.mkdirSync(targetSkillDir, { recursive: true });
-    fs.writeFileSync(path.join(targetSkillDir, 'SKILL.md'), 'existing content');
-
-    // Simulate the guard from autoInstallSkillForAgent: skip if exists
-    if (!fs.existsSync(targetSkillDir)) {
-      copyDirSync(skillSrc, targetSkillDir);
-    }
-
-    // Existing content should NOT be overwritten
-    expect(fs.readFileSync(path.join(targetSkillDir, 'SKILL.md'), 'utf-8')).toBe('existing content');
-  });
-
-  it('copies to multiple agent directories independently', () => {
-    const skillSrc = path.join(tempDir, 'skills', 'mindos');
-    fs.mkdirSync(skillSrc, { recursive: true });
-    fs.writeFileSync(path.join(skillSrc, 'SKILL.md'), 'shared skill');
-
-    // Copy to 3 different unsupported agent dirs
-    for (const agent of ['workbuddy', 'qclaw', 'lingma']) {
-      const target = path.join(tempDir, `.${agent}`, 'skills', 'mindos');
-      fs.mkdirSync(path.join(tempDir, `.${agent}`), { recursive: true });
-      copyDirSync(skillSrc, target);
-      expect(fs.readFileSync(path.join(target, 'SKILL.md'), 'utf-8')).toBe('shared skill');
-    }
-  });
-
-  it('copies Chinese skill variant (mindos-zh) when available', () => {
-    // Create both English and Chinese skill variants
-    const skillSrcEn = path.join(tempDir, 'skills', 'mindos');
-    fs.mkdirSync(skillSrcEn, { recursive: true });
-    fs.writeFileSync(path.join(skillSrcEn, 'SKILL.md'), '---\nname: mindos\n---\n# MindOS (English)');
-
-    const skillSrcZh = path.join(tempDir, 'skills', 'mindos-zh');
-    fs.mkdirSync(skillSrcZh, { recursive: true });
-    fs.writeFileSync(path.join(skillSrcZh, 'SKILL.md'), '---\nname: mindos-zh\n---\n# MindOS (中文)');
-
-    // Simulate copying Chinese variant to agent
-    const agentDir = path.join(tempDir, '.copaw');
-    fs.mkdirSync(agentDir);
-    const targetSkillZh = path.join(agentDir, 'skills', 'mindos-zh');
-
-    copyDirSync(skillSrcZh, targetSkillZh);
-
-    expect(fs.existsSync(path.join(targetSkillZh, 'SKILL.md'))).toBe(true);
-    expect(fs.readFileSync(path.join(targetSkillZh, 'SKILL.md'), 'utf-8')).toContain('中文');
-  });
-
-  it('supports both English and Chinese skill variants for all unsupported agents', () => {
-    // Create both skill variants
-    const skillSrcEn = path.join(tempDir, 'skills', 'mindos');
-    fs.mkdirSync(skillSrcEn, { recursive: true });
-    fs.writeFileSync(path.join(skillSrcEn, 'SKILL.md'), 'English version');
-
-    const skillSrcZh = path.join(tempDir, 'skills', 'mindos-zh');
-    fs.mkdirSync(skillSrcZh, { recursive: true });
-    fs.writeFileSync(path.join(skillSrcZh, 'SKILL.md'), '中文版本');
-
-    // Test all unsupported agents
-    const agents = ['workbuddy', 'qclaw', 'lingma', 'copaw'];
-    for (const agent of agents) {
-      const agentDir = path.join(tempDir, `.${agent}`);
-      fs.mkdirSync(agentDir, { recursive: true });
-
-      // English variant
-      const targetEn = path.join(agentDir, 'skills', 'mindos');
-      copyDirSync(skillSrcEn, targetEn);
-      expect(fs.readFileSync(path.join(targetEn, 'SKILL.md'), 'utf-8')).toBe('English version');
-
-      // Chinese variant (reset for next agent)
-      fs.rmSync(agentDir, { recursive: true });
-      fs.mkdirSync(agentDir, { recursive: true });
-      const targetZh = path.join(agentDir, 'skills', 'mindos-zh');
-      copyDirSync(skillSrcZh, targetZh);
-      expect(fs.readFileSync(path.join(targetZh, 'SKILL.md'), 'utf-8')).toBe('中文版本');
-    }
-  });
-});
-
-// ── cpSync cross-platform equivalence ────────────────────────────────────
-
-describe('Node.js cpSync vs copyDirSync equivalence', () => {
-  it('produces identical output to cpSync recursive', () => {
-    const src = path.join(tempDir, 'src');
-    fs.mkdirSync(path.join(src, 'sub'), { recursive: true });
-    fs.writeFileSync(path.join(src, 'a.txt'), 'aaa');
-    fs.writeFileSync(path.join(src, 'sub', 'b.txt'), 'bbb');
-
-    const dst1 = path.join(tempDir, 'dst-cpsync');
-    const dst2 = path.join(tempDir, 'dst-manual');
-
-    // cpSync (used in setup.js)
-    fs.cpSync(src, dst1, { recursive: true });
-    // copyDirSync (used in mcp-install.js)
-    copyDirSync(src, dst2);
-
-    // Both should produce identical file trees
-    const walk = (dir: string): Record<string, string> => {
-      const result: Record<string, string> = {};
-      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const rel = entry.name;
-        const abs = path.join(dir, rel);
-        if (entry.isDirectory()) {
-          Object.entries(walk(abs)).forEach(([k, v]) => { result[`${rel}/${k}`] = v; });
-        } else {
-          result[rel] = fs.readFileSync(abs, 'utf-8');
-        }
-      }
-      return result;
-    };
-
-    expect(walk(dst1)).toEqual(walk(dst2));
-  });
-});

package/tests/unit/cli-smoke.test.ts

@@ -1,88 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-/**
- * CLI smoke tests — verify core commands don't crash on invocation.
- * Runs `node bin/cli.js` in a subprocess with HOME set to an empty temp dir
- * so no real config interferes.
- */
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const CLI = path.join(ROOT, 'bin', 'cli.js');
-
-let tempHome: string;
-let savedHome: string | undefined;
-
-beforeEach(() => {
-  tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-smoke-'));
-  savedHome = process.env.HOME;
-});
-
-afterEach(() => {
-  process.env.HOME = savedHome;
-  fs.rmSync(tempHome, { recursive: true, force: true });
-});
-
-function run(args: string[]): { stdout: string; stderr: string; exitCode: number } {
-  try {
-    const stdout = execFileSync(process.execPath, [CLI, ...args], {
-      encoding: 'utf-8',
-      env: { ...process.env, HOME: tempHome, NODE_ENV: 'test' },
-      timeout: 15000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    return { stdout, stderr: '', exitCode: 0 };
-  } catch (err: unknown) {
-    const e = err as { stdout?: string; stderr?: string; status?: number };
-    return {
-      stdout: e.stdout || '',
-      stderr: e.stderr || '',
-      exitCode: e.status ?? 1,
-    };
-  }
-}
-
-describe('CLI smoke tests', () => {
-  it('mindos --version exits 0 and outputs version', () => {
-    const { stdout, exitCode } = run(['--version']);
-    expect(exitCode).toBe(0);
-    expect(stdout).toMatch(/mindos\/\d+\.\d+\.\d+/);
-  });
-
-  it('mindos --help exits 0 and outputs help text', () => {
-    const { stdout, exitCode } = run(['--help']);
-    expect(exitCode).toBe(0);
-    expect(stdout).toContain('MindOS CLI');
-  });
-
-  it('mindos doctor without config exits 1 and suggests onboard', () => {
-    const { stdout, stderr, exitCode } = run(['doctor']);
-    expect(exitCode).toBe(1);
-    const output = stdout + stderr;
-    expect(output).toMatch(/onboard/i);
-  });
-
-  it('mindos config show without config exits 1', () => {
-    const { exitCode } = run(['config', 'show']);
-    expect(exitCode).toBe(1);
-  });
-
-  it('mindos config validate without config exits 1', () => {
-    const { exitCode } = run(['config', 'validate']);
-    expect(exitCode).toBe(1);
-  });
-
-  it('mindos sync without config exits 0 and shows not configured', () => {
-    const { stdout, exitCode } = run(['sync']);
-    expect(exitCode).toBe(0);
-    expect(stdout).toMatch(/not configured/i);
-  });
-
-  it('mindos nonexistent exits 1', () => {
-    const { exitCode } = run(['nonexistent']);
-    expect(exitCode).toBe(1);
-  });
-});

package/tests/unit/cli-uninstall.test.ts

@@ -1,218 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-/**
- * Tests for `mindos uninstall` command.
- *
- * Key invariants:
- * 1. Default answer is N — empty/piped stdin must abort without deleting anything
- * 2. Config is read BEFORE ~/.mindos/ is deleted (ordering bug regression)
- * 3. Knowledge base deletion requires triple protection (confirm → YES → password)
- * 4. Help text lists the uninstall command
- */
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const CLI = path.join(ROOT, 'bin', 'cli.js');
-
-let tempHome: string;
-let savedHome: string | undefined;
-
-beforeEach(() => {
-  tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-uninstall-'));
-  savedHome = process.env.HOME;
-});
-
-afterEach(() => {
-  process.env.HOME = savedHome;
-  fs.rmSync(tempHome, { recursive: true, force: true });
-});
-
-function run(
-  args: string[],
-  opts: { input?: string; home?: string } = {},
-): { stdout: string; stderr: string; exitCode: number } {
-  const home = opts.home ?? tempHome;
-  try {
-    const stdout = execFileSync(process.execPath, [CLI, ...args], {
-      encoding: 'utf-8',
-      env: { ...process.env, HOME: home, NODE_ENV: 'test' },
-      input: opts.input ?? '',
-      timeout: 15000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    return { stdout, stderr: '', exitCode: 0 };
-  } catch (err: unknown) {
-    const e = err as { stdout?: string; stderr?: string; status?: number };
-    return {
-      stdout: e.stdout || '',
-      stderr: e.stderr || '',
-      exitCode: e.status ?? 1,
-    };
-  }
-}
-
-/** Write a minimal config.json in the temp home's .mindos/ */
-function writeConfig(
-  config: Record<string, unknown>,
-  home: string = tempHome,
-): void {
-  const dir = path.join(home, '.mindos');
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify(config));
-}
-
-describe('mindos uninstall — smoke', () => {
-  it('aborts on empty enter (default N) and exits 0', () => {
-    const { stdout, exitCode } = run(['uninstall'], { input: '\n' });
-    expect(exitCode).toBe(0);
-    expect(stdout).toContain('Aborted');
-  });
-
-  it('aborts when user types n', () => {
-    const { stdout, exitCode } = run(['uninstall'], { input: 'n\n' });
-    expect(exitCode).toBe(0);
-    expect(stdout).toContain('Aborted');
-  });
-
-  it('shows operation list before asking for confirmation', () => {
-    const { stdout } = run(['uninstall'], { input: '\n' });
-    expect(stdout).toContain('Stop running MindOS processes');
-    expect(stdout).toContain('Remove background service');
-    expect(stdout).toContain('Uninstall npm package');
-  });
-});
-
-describe('mindos uninstall — help text', () => {
-  it('--all lists the uninstall command', () => {
-    const { stdout, exitCode } = run(['--all']);
-    expect(exitCode).toBe(0);
-    expect(stdout).toContain('uninstall');
-  });
-});
-
-describe('mindos uninstall — does not delete on N answers', () => {
-  it('keeps ~/.mindos/ when user says Y to proceed but N to remove config', () => {
-    const mindRoot = path.join(tempHome, 'MindOS');
-    fs.mkdirSync(mindRoot, { recursive: true });
-    fs.writeFileSync(path.join(mindRoot, 'test.md'), 'hello');
-    writeConfig({ mindRoot });
-
-    // Y to proceed, N to remove config, N to remove knowledge base
-    const { stdout } = run(['uninstall'], { input: 'y\nn\nn\n' });
-    expect(stdout).toContain('Kept');
-    expect(fs.existsSync(path.join(tempHome, '.mindos'))).toBe(true);
-    expect(fs.existsSync(mindRoot)).toBe(true);
-  });
-
-  it('keeps knowledge base when user says Y to proceed, Y to config, N to kb', () => {
-    const mindRoot = path.join(tempHome, 'MindOS');
-    fs.mkdirSync(mindRoot, { recursive: true });
-    fs.writeFileSync(path.join(mindRoot, 'test.md'), 'hello');
-    writeConfig({ mindRoot });
-
-    // Y proceed, Y remove config, N remove kb
-    const { stdout } = run(['uninstall'], { input: 'y\ny\nn\n' });
-    expect(fs.existsSync(path.join(tempHome, '.mindos'))).toBe(false);
-    expect(fs.existsSync(mindRoot)).toBe(true);
-  });
-});
-
-describe('mindos uninstall — knowledge base triple protection', () => {
-  it('keeps knowledge base when user types wrong confirmation (not YES)', () => {
-    const mindRoot = path.join(tempHome, 'MindOS');
-    fs.mkdirSync(mindRoot, { recursive: true });
-    writeConfig({ mindRoot });
-
-    // Y proceed, N config, Y kb, type "yes" (wrong — must be uppercase YES)
-    const { stdout } = run(['uninstall'], { input: 'y\nn\ny\nyes\n' });
-    expect(stdout).toContain('Knowledge base kept');
-    expect(fs.existsSync(mindRoot)).toBe(true);
-  });
-
-  it('keeps knowledge base when password is wrong', () => {
-    const mindRoot = path.join(tempHome, 'MindOS');
-    fs.mkdirSync(mindRoot, { recursive: true });
-    writeConfig({ mindRoot, webPassword: 'secret123' });
-
-    // Y proceed, N config, Y kb, YES confirm, wrong password
-    const { stdout } = run(['uninstall'], { input: 'y\nn\ny\nYES\nwrongpw\n' });
-    expect(stdout).toContain('Wrong password');
-    expect(fs.existsSync(mindRoot)).toBe(true);
-  });
-
-  it('deletes knowledge base when all protections pass (no password)', () => {
-    const mindRoot = path.join(tempHome, 'MindOS');
-    fs.mkdirSync(mindRoot, { recursive: true });
-    fs.writeFileSync(path.join(mindRoot, 'note.md'), 'data');
-    writeConfig({ mindRoot });
-
-    // Y proceed, N config, Y kb, YES confirm
-    const { stdout } = run(['uninstall'], { input: 'y\nn\ny\nYES\n' });
-    expect(stdout).toContain('Removed');
-    expect(fs.existsSync(mindRoot)).toBe(false);
-  });
-
-  it('deletes knowledge base when all protections pass (correct password)', () => {
-    const mindRoot = path.join(tempHome, 'MindOS');
-    fs.mkdirSync(mindRoot, { recursive: true });
-    writeConfig({ mindRoot, webPassword: 'mypass' });
-
-    // Y proceed, N config, Y kb, YES confirm, correct password
-    const { stdout } = run(['uninstall'], { input: 'y\nn\ny\nYES\nmypass\n' });
-    expect(fs.existsSync(mindRoot)).toBe(false);
-  });
-});
-
-describe('mindos uninstall — config read ordering (regression)', () => {
-  /**
-   * Regression: config must be read BEFORE ~/.mindos/ is deleted.
-   * Otherwise mindRoot and webPassword are lost, and the knowledge base
-   * question is silently skipped.
-   *
-   * Test: user says Y to proceed, Y to delete config, then expects the
-   * knowledge base question to still appear (config was read beforehand).
-   */
-  it('still asks about knowledge base even after deleting ~/.mindos/', () => {
-    const mindRoot = path.join(tempHome, 'MindOS');
-    fs.mkdirSync(mindRoot, { recursive: true });
-    fs.writeFileSync(path.join(mindRoot, 'note.md'), 'data');
-    writeConfig({ mindRoot });
-
-    // Y proceed, Y remove config (deletes ~/.mindos/), Y remove kb, YES confirm
-    const { stdout } = run(['uninstall'], { input: 'y\ny\ny\nYES\n' });
-    // Config dir should be gone
-    expect(fs.existsSync(path.join(tempHome, '.mindos'))).toBe(false);
-    // Knowledge base should also be gone — proves config was read before deletion
-    expect(fs.existsSync(mindRoot)).toBe(false);
-  });
-
-  it('password check works even after config dir is deleted', () => {
-    const mindRoot = path.join(tempHome, 'MindOS');
-    fs.mkdirSync(mindRoot, { recursive: true });
-    writeConfig({ mindRoot, webPassword: 'pw123' });
-
-    // Y proceed, Y remove config, Y remove kb, YES, wrong password
-    const { stdout } = run(['uninstall'], { input: 'y\ny\ny\nYES\nwrong\n' });
-    expect(fs.existsSync(path.join(tempHome, '.mindos'))).toBe(false);
-    expect(stdout).toContain('Wrong password');
-    // Knowledge base must survive — password was read from config before deletion
-    expect(fs.existsSync(mindRoot)).toBe(true);
-  });
-});
-
-describe('mindos uninstall — tilde expansion in mindRoot', () => {
-  it('expands ~ in mindRoot to HOME', () => {
-    const mindRoot = path.join(tempHome, 'MyNotes');
-    fs.mkdirSync(mindRoot, { recursive: true });
-    fs.writeFileSync(path.join(mindRoot, 'test.md'), 'data');
-    // Store with ~ prefix — the code should expand it
-    writeConfig({ mindRoot: '~/MyNotes' });
-
-    // Y proceed, N config, Y kb, YES
-    const { stdout } = run(['uninstall'], { input: 'y\nn\ny\nYES\n' });
-    expect(fs.existsSync(mindRoot)).toBe(false);
-  });
-});

package/tests/unit/cli-update-root.test.ts

@@ -1,89 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const CLI = path.join(ROOT, 'bin', 'cli.js');
-const CURRENT_VERSION = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8')).version;
-
-let tempDir: string;
-let fakeBinDir: string;
-let fakeInstallRoot: string;
-
-beforeEach(() => {
-  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-update-root-'));
-  fakeBinDir = path.join(tempDir, 'fake-bin');
-  fakeInstallRoot = path.join(tempDir, 'new-root');
-
-  fs.mkdirSync(fakeBinDir, { recursive: true });
-  fs.mkdirSync(path.join(fakeInstallRoot, 'bin'), { recursive: true });
-  fs.mkdirSync(path.join(fakeInstallRoot, 'app', '.next'), { recursive: true });
-
-  fs.writeFileSync(path.join(fakeBinDir, 'npm'), '#!/bin/sh\nexit 0\n', { mode: 0o755 });
-  fs.writeFileSync(path.join(fakeInstallRoot, 'bin', 'cli.js'), '#!/bin/sh\nexit 0\n', { mode: 0o755 });
-  fs.symlinkSync(path.join(fakeInstallRoot, 'bin', 'cli.js'), path.join(fakeBinDir, 'mindos'));
-  fs.writeFileSync(
-    path.join(fakeInstallRoot, 'package.json'),
-    JSON.stringify({ name: '@geminilight/mindos', version: '9.9.9' }),
-  );
-  fs.writeFileSync(
-    path.join(fakeInstallRoot, 'app', '.next', '.mindos-build-version'),
-    '9.9.9',
-  );
-  fs.writeFileSync(
-    path.join(fakeInstallRoot, 'app', 'package.json'),
-    JSON.stringify({ name: 'wiki-app', version: '0.1.0' }),
-  );
-});
-
-afterEach(() => {
-  fs.rmSync(tempDir, { recursive: true, force: true });
-});
-
-describe('mindos update root resolution', () => {
-  it('uses the resolved installed CLI path instead of falling back to the current repo root', () => {
-    const stdout = execFileSync(process.execPath, [CLI, 'update'], {
-      cwd: ROOT,
-      encoding: 'utf-8',
-      env: {
-        ...process.env,
-        PATH: `${fakeBinDir}:${process.env.PATH}`,
-      },
-      timeout: 30_000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    expect(stdout).toContain(`Updated: ${CURRENT_VERSION} → 9.9.9`);
-    expect(stdout).not.toContain('Already on the latest version');
-  });
-
-  it('skips the shell shim under ~/.mindos/bin/ and falls back to current ROOT', () => {
-    const fakeHome = path.join(tempDir, 'home');
-    const shimDir = path.join(fakeHome, '.mindos', 'bin');
-    fs.mkdirSync(shimDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(shimDir, 'mindos'),
-      '#!/bin/sh\nexec node "$(dirname "$0")/../cli.js" "$@"\n',
-      { mode: 0o755 },
-    );
-
-    const stdout = execFileSync(process.execPath, [CLI, 'update'], {
-      cwd: ROOT,
-      encoding: 'utf-8',
-      env: {
-        ...process.env,
-        HOME: fakeHome,
-        PATH: `${shimDir}:${fakeBinDir}:${process.env.PATH}`,
-      },
-      timeout: 30_000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    // `which mindos` finds shimDir/mindos first, but getUpdatedRoot() skips it
-    // (dirname matches $HOME/.mindos/bin). Falls back to ROOT where
-    // package.json has CURRENT_VERSION → reports "already on the latest".
-    expect(stdout).toContain('Already on the latest version');
-  });
-});