claudeup 4.19.0 → 4.22.0

package/src/__tests__/doctor-bins.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+import {
+	checkBinaries,
+	missingBinaries,
+} from "../services/doctor-bins.js";
+import type { ResolvedBin } from "../types/index.js";
+
+const bins: ResolvedBin[] = [
+	{ name: "tmux", via: "brew", formula: "tmux", sources: ["plugin:terminal@magus"] },
+	{ name: "claudish", via: "bun", package: "claudish", version: "1.2.0", sources: ["profile:x.cliTools"] },
+];
+
+describe("checkBinaries", () => {
+	test("reports presence and an install command per bin", async () => {
+		const present = new Set(["claudish"]);
+		const results = await checkBinaries(bins, async (n) => present.has(n));
+
+		const tmux = results.find((r) => r.name === "tmux")!;
+		expect(tmux.present).toBe(false);
+		expect(tmux.installCommand).toBe("brew install tmux");
+		expect(tmux.sources).toEqual(["plugin:terminal@magus"]);
+
+		const claudish = results.find((r) => r.name === "claudish")!;
+		expect(claudish.present).toBe(true);
+		expect(claudish.installCommand).toBe("bun install -g claudish@1.2.0");
+	});
+});
+
+describe("missingBinaries", () => {
+	test("returns only the absent ones", async () => {
+		const results = await checkBinaries(bins, async (n) => n === "claudish");
+		const missing = missingBinaries(results);
+		expect(missing.map((m) => m.name)).toEqual(["tmux"]);
+	});
+});

package/src/__tests__/doctor.test.ts

@@ -0,0 +1,450 @@
+/**
+ * Unit tests for doctor service
+ *
+ * Tests cover:
+ * - checkProject: project accessible, gitignore entries, claudemd sections, malformed markers
+ * - runDoctor: empty registry, registered projects, summary counts
+ * - fixDoctorIssues: add gitignore entries, inject claudemd sections, repair markers
+ *
+ * Strategy: checkProject and fixDoctorIssues are tested against real temp directories
+ * with real plugin.json files. runDoctor is tested by mocking the registry.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdtemp, rm, writeFile, readFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { checkProject, fixDoctorIssues } from '../services/doctor.js';
+import type { DoctorResult } from '../services/doctor.js';
+
+// ============================================================
+// HELPERS
+// ============================================================
+
+/**
+ * Create a minimal plugin directory with plugin.json and optional template.
+ */
+async function createPluginDir(
+  baseDir: string,
+  pluginName: string,
+  conventions?: {
+    gitignore?: { project?: string[] };
+    claudemd?: { section: string; template: string; version: string };
+  },
+  templateContent?: string,
+): Promise<string> {
+  const pluginDir = join(baseDir, pluginName);
+  await mkdir(pluginDir, { recursive: true });
+
+  const manifest: Record<string, unknown> = {
+    name: pluginName,
+    version: '1.0.0',
+    description: `Test plugin ${pluginName}`,
+  };
+
+  if (conventions) {
+    manifest.conventions = conventions;
+  }
+
+  await writeFile(join(pluginDir, 'plugin.json'), JSON.stringify(manifest, null, 2));
+
+  if (templateContent && conventions?.claudemd?.template) {
+    const templateDir = join(pluginDir, 'templates');
+    await mkdir(templateDir, { recursive: true });
+    await writeFile(join(templateDir, 'claude-md-conventions.md'), templateContent);
+  }
+
+  return pluginDir;
+}
+
+describe('doctor', () => {
+  let testDir: string;
+  let projectDir: string;
+  let pluginsDir: string;
+
+  beforeEach(async () => {
+    testDir = await mkdtemp(join(tmpdir(), 'doctor-test-'));
+    projectDir = join(testDir, 'project');
+    pluginsDir = join(testDir, 'plugins');
+    await mkdir(projectDir, { recursive: true });
+    await mkdir(pluginsDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  // ============================================================
+  // checkProject
+  // ============================================================
+
+  describe('checkProject', () => {
+    it('should report fail when project path does not exist', async () => {
+      const result = await checkProject('/nonexistent/path/that/does/not/exist', ['some-plugin@magus']);
+
+      expect(result.projectPath).toBe('/nonexistent/path/that/does/not/exist');
+      expect(result.checks).toHaveLength(1);
+      expect(result.checks[0].name).toBe('project-accessible');
+      expect(result.checks[0].status).toBe('fail');
+      expect(result.checks[0].fixable).toBe(false);
+    });
+
+    it('should return empty checks when plugins have no conventions', async () => {
+      // checkProject with pluginIds that cannot be resolved will produce no convention checks
+      // (since resolvePluginPath returns null for unknown IDs)
+      const result = await checkProject(projectDir, ['nonexistent-plugin@nonexistent-marketplace']);
+
+      // No convention checks should be generated since the plugin could not be resolved
+      const conventionChecks = result.checks.filter(
+        (c) => c.name !== 'project-accessible',
+      );
+      expect(conventionChecks).toHaveLength(0);
+    });
+  });
+
+  // ============================================================
+  // checkProject with real conventions (using checkProject directly with
+  // pre-setup gitignore/CLAUDE.md, bypassing plugin resolution)
+  // ============================================================
+
+  describe('checkProject gitignore checks', () => {
+    it('should pass when gitignore has all required entries', async () => {
+      // Since checkProject resolves plugins via marketplace, we test the
+      // underlying behavior by checking project files directly.
+      // For unit testing, we verify checkProject handles the missing-plugin case gracefully.
+      const gitignorePath = join(projectDir, '.gitignore');
+      await writeFile(gitignorePath, 'node_modules/\n.mnemex/\n');
+
+      // With no resolvable plugins, no gitignore checks are generated
+      const result = await checkProject(projectDir, []);
+      expect(result.checks).toHaveLength(0);
+    });
+  });
+
+  describe('checkProject CLAUDE.md checks', () => {
+    it('should detect malformed CLAUDE.md markers', async () => {
+      const claudeMdPath = join(projectDir, 'CLAUDE.md');
+      // Write CLAUDE.md with unclosed marker
+      await writeFile(
+        claudeMdPath,
+        '# Project\n\n<!-- BEGIN magus:test-plugin v1.0.0 -->\nSome content\n',
+      );
+
+      // checkProject won't find the marker issue unless it resolves plugins.
+      // But the parse is done on the file itself. Let's verify via parseClaudeMdSections directly.
+      const { parseClaudeMdSections } = await import('../services/conventions-manager.js');
+      const parseResult = await parseClaudeMdSections(claudeMdPath);
+      expect(parseResult.errors).toHaveLength(1);
+      expect(parseResult.errors[0].type).toBe('missing_end');
+    });
+  });
+
+  // ============================================================
+  // runDoctor with no registered projects
+  // ============================================================
+
+  describe('runDoctor', () => {
+    it('should return empty results when no projects are registered', async () => {
+      // Mock the registry to return empty
+      const doctorModule = await import('../services/doctor.js');
+
+      // We can't easily mock the internal collectProjects, but we can
+      // test via the exported runDoctor if the registry is empty.
+      // In practice, runDoctor reads the real registry, so we test the
+      // output shape is correct.
+      const { runDoctor } = doctorModule;
+      const result = await runDoctor();
+
+      // The result shape should be valid even if we have real projects
+      expect(result).toHaveProperty('projects');
+      expect(result).toHaveProperty('summary');
+      expect(result.summary).toHaveProperty('totalProjects');
+      expect(result.summary).toHaveProperty('totalChecks');
+      expect(result.summary).toHaveProperty('passed');
+      expect(result.summary).toHaveProperty('warnings');
+      expect(result.summary).toHaveProperty('failures');
+      expect(result.summary).toHaveProperty('fixable');
+      expect(typeof result.summary.totalProjects).toBe('number');
+    });
+
+    it('should compute summary counts correctly', async () => {
+      // Build a DoctorResult manually and verify summary computation
+      // This tests the summary logic without needing real plugin resolution
+      const { runDoctor } = await import('../services/doctor.js');
+      const result = await runDoctor();
+
+      // Verify summary math
+      const { summary, projects } = result;
+      let expectedChecks = 0;
+      let expectedPassed = 0;
+      let expectedWarnings = 0;
+      let expectedFailures = 0;
+      let expectedFixable = 0;
+
+      for (const project of projects) {
+        for (const check of project.checks) {
+          expectedChecks++;
+          if (check.status === 'pass') expectedPassed++;
+          else if (check.status === 'warn') expectedWarnings++;
+          else if (check.status === 'fail') expectedFailures++;
+          if (check.fixable) expectedFixable++;
+        }
+      }
+
+      expect(summary.totalChecks).toBe(expectedChecks);
+      expect(summary.passed).toBe(expectedPassed);
+      expect(summary.warnings).toBe(expectedWarnings);
+      expect(summary.failures).toBe(expectedFailures);
+      expect(summary.fixable).toBe(expectedFixable);
+      expect(summary.totalProjects).toBe(projects.length);
+    });
+  });
+
+  // ============================================================
+  // fixDoctorIssues
+  // ============================================================
+
+  describe('fixDoctorIssues', () => {
+    it('should add missing gitignore entries', async () => {
+      const gitignorePath = join(projectDir, '.gitignore');
+      await writeFile(gitignorePath, 'node_modules/\n');
+
+      const doctorResult: DoctorResult = {
+        projects: [
+          {
+            projectPath: projectDir,
+            plugins: ['test-plugin@magus'],
+            checks: [
+              {
+                name: 'gitignore-entries',
+                status: 'fail',
+                message: '.gitignore missing: .mnemex/',
+                fixable: true,
+                _fixData: {
+                  type: 'add-gitignore-entries',
+                  gitignorePath,
+                  entries: ['.mnemex/'],
+                },
+              },
+            ],
+          },
+        ],
+        summary: {
+          totalProjects: 1,
+          totalChecks: 1,
+          passed: 0,
+          warnings: 0,
+          failures: 1,
+          fixable: 1,
+        },
+      };
+
+      const fixResult = await fixDoctorIssues(doctorResult);
+
+      expect(fixResult.fixed).toBe(1);
+      expect(fixResult.failed).toBe(0);
+
+      const content = await readFile(gitignorePath, 'utf-8');
+      expect(content).toContain('.mnemex/');
+      expect(content).toContain('node_modules/');
+    });
+
+    it('should inject missing CLAUDE.md sections', async () => {
+      const claudeMdPath = join(projectDir, 'CLAUDE.md');
+      await writeFile(claudeMdPath, '# My Project\n\nSome existing content.\n');
+
+      // Create a plugin dir with template
+      const pluginDir = await createPluginDir(
+        pluginsDir,
+        'test-plugin',
+        {
+          claudemd: {
+            section: 'test-plugin',
+            template: './templates/claude-md-conventions.md',
+            version: '1.0.0',
+          },
+        },
+        '## Test Plugin\n\nDo not commit .test-data/ to git.',
+      );
+
+      const doctorResult: DoctorResult = {
+        projects: [
+          {
+            projectPath: projectDir,
+            plugins: ['test-plugin@magus'],
+            checks: [
+              {
+                name: 'claudemd-section-test-plugin',
+                status: 'warn',
+                message: 'CLAUDE.md missing test-plugin conventions',
+                fixable: true,
+                _fixData: {
+                  type: 'inject-section',
+                  claudeMdPath,
+                  pluginName: 'test-plugin',
+                  pluginPath: pluginDir,
+                  conventions: {
+                    claudemd: {
+                      section: 'test-plugin',
+                      template: './templates/claude-md-conventions.md',
+                      version: '1.0.0',
+                    },
+                  },
+                },
+              },
+            ],
+          },
+        ],
+        summary: {
+          totalProjects: 1,
+          totalChecks: 1,
+          passed: 0,
+          warnings: 1,
+          failures: 0,
+          fixable: 1,
+        },
+      };
+
+      const fixResult = await fixDoctorIssues(doctorResult);
+
+      expect(fixResult.fixed).toBe(1);
+      expect(fixResult.failed).toBe(0);
+
+      const content = await readFile(claudeMdPath, 'utf-8');
+      expect(content).toContain('<!-- BEGIN magus:test-plugin v1.0.0 -->');
+      expect(content).toContain('Do not commit .test-data/ to git.');
+      expect(content).toContain('<!-- END magus:test-plugin -->');
+      expect(content).toContain('# My Project');
+    });
+
+    it('should create gitignore when project has none', async () => {
+      const gitignorePath = join(projectDir, '.gitignore');
+      expect(existsSync(gitignorePath)).toBe(false);
+
+      const doctorResult: DoctorResult = {
+        projects: [
+          {
+            projectPath: projectDir,
+            plugins: ['test-plugin@magus'],
+            checks: [
+              {
+                name: 'gitignore-exists',
+                status: 'warn',
+                message: '.gitignore does not exist',
+                fixable: true,
+                _fixData: {
+                  type: 'create-gitignore',
+                  projectPath: projectDir,
+                  entries: ['.mnemex/', '.claudemem/'],
+                },
+              },
+            ],
+          },
+        ],
+        summary: {
+          totalProjects: 1,
+          totalChecks: 1,
+          passed: 0,
+          warnings: 1,
+          failures: 0,
+          fixable: 1,
+        },
+      };
+
+      const fixResult = await fixDoctorIssues(doctorResult);
+
+      expect(fixResult.fixed).toBe(1);
+      expect(existsSync(gitignorePath)).toBe(true);
+      const content = await readFile(gitignorePath, 'utf-8');
+      expect(content).toContain('.mnemex/');
+      expect(content).toContain('.claudemem/');
+    });
+
+    it('should skip unfixable issues', async () => {
+      const doctorResult: DoctorResult = {
+        projects: [
+          {
+            projectPath: '/nonexistent/path',
+            plugins: ['some-plugin@magus'],
+            checks: [
+              {
+                name: 'project-accessible',
+                status: 'fail',
+                message: 'Project path does not exist',
+                fixable: false,
+              },
+            ],
+          },
+        ],
+        summary: {
+          totalProjects: 1,
+          totalChecks: 1,
+          passed: 0,
+          warnings: 0,
+          failures: 1,
+          fixable: 0,
+        },
+      };
+
+      const fixResult = await fixDoctorIssues(doctorResult);
+
+      expect(fixResult.fixed).toBe(0);
+      expect(fixResult.failed).toBe(0);
+    });
+
+    it('should report fix count correctly with mixed results', async () => {
+      const gitignorePath = join(projectDir, '.gitignore');
+      await writeFile(gitignorePath, 'node_modules/\n');
+
+      const doctorResult: DoctorResult = {
+        projects: [
+          {
+            projectPath: projectDir,
+            plugins: ['test-plugin@magus'],
+            checks: [
+              {
+                name: 'gitignore-entries',
+                status: 'fail',
+                message: '.gitignore missing: .mnemex/',
+                fixable: true,
+                _fixData: {
+                  type: 'add-gitignore-entries',
+                  gitignorePath,
+                  entries: ['.mnemex/'],
+                },
+              },
+              {
+                name: 'project-accessible',
+                status: 'fail',
+                message: 'Project path does not exist',
+                fixable: false,
+              },
+              {
+                name: 'claudemd-section-test-plugin',
+                status: 'warn',
+                message: 'CLAUDE.md missing test-plugin conventions',
+                fixable: true,
+                // Missing _fixData -- should count as failed
+              },
+            ],
+          },
+        ],
+        summary: {
+          totalProjects: 1,
+          totalChecks: 3,
+          passed: 0,
+          warnings: 1,
+          failures: 2,
+          fixable: 2,
+        },
+      };
+
+      const fixResult = await fixDoctorIssues(doctorResult);
+
+      // 1 fixed (gitignore), 1 failed (missing _fixData), 1 skipped (not fixable)
+      expect(fixResult.fixed).toBe(1);
+      expect(fixResult.failed).toBe(1);
+    });
+  });
+});

package/src/__tests__/dual-write-prevention.test.ts

@@ -15,6 +15,11 @@ import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as url from "node:url";
+// Real modules captured before the mock.module() overrides below, so the mocks
+// can spread the full export surface instead of stripping it.
+import * as actualClaudeSettings from "../services/claude-settings.js";
+import * as actualClaudeCli from "../services/claude-cli.js";
+import * as actualPluginManager from "../services/plugin-manager.js";
 
 // ---------------------------------------------------------------------------
 // PART 1: PluginsScreen source-level policy tests
@@ -93,11 +98,14 @@ let mockUpdatePlugin: ReturnType<typeof mock>;
 let mockIsClaudeAvailable: ReturnType<typeof mock>;
 let mockGetAvailablePlugins: ReturnType<typeof mock>;
 
-// We must register mock.module before importing the module under test.
-// Bun hoists mock.module() calls, so the mocks are active when the
-// module is first loaded.
-
+// Spread the REAL modules and override only the functions under test, so this
+// file's mock.module doesn't strip other exports the module graph needs (which
+// breaks both this file in isolation and — because bun's mock.module is global
+// and not restored across files — every later test file). The `import * as`
+// bindings are evaluated before these mock.module() calls run, so they capture
+// the real modules.
 mock.module("../services/claude-settings.js", () => ({
+  ...actualClaudeSettings,
   recoverMarketplaceSettings: mock(() =>
     Promise.resolve({ enabledAutoUpdate: [], removed: [], reregistered: [] }),
   ),
@@ -120,6 +128,7 @@ mock.module("../services/claude-settings.js", () => ({
 }));
 
 mock.module("../services/claude-cli.js", () => ({
+  ...actualClaudeCli,
   updatePlugin: (...args: unknown[]) => mockUpdatePlugin(...args),
   isClaudeAvailable: (...args: unknown[]) => mockIsClaudeAvailable(...args),
   addMarketplace: mock(() => Promise.resolve()),
@@ -127,6 +136,7 @@ mock.module("../services/claude-cli.js", () => ({
 }));
 
 mock.module("../services/plugin-manager.js", () => ({
+  ...actualPluginManager,
   getAvailablePlugins: (...args: unknown[]) =>
     mockGetAvailablePlugins(...args),
   clearMarketplaceCache: mock(() => undefined),