@baize-ai/core 0.2.0 → 0.3.0

package/test/component-lock.test.js

@@ -0,0 +1,216 @@
+/**
+ * Component lock coverage (D20 unit A):
+ * - lock.js error copy is operation-generic (add/upgrade/uninstall)
+ * - baize add holds the component lock for install writes; --check preview
+ *   never acquires it; lock failures reject with a clear error
+ * - baize uninstall holds the component lock for removal writes
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, jest, test } from '@jest/globals';
+
+let homeDir;
+let baizeDir;
+let locksDir;
+let skillsDir;
+let componentsFile;
+
+beforeEach(() => {
+  jest.resetModules(); // config constants (BAIZE_DIR, LOCKS_DIR, ...) are read at module load
+  homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'comp-lock-'));
+  baizeDir = path.join(homeDir, 'baize');
+  locksDir = path.join(baizeDir, '.baize', 'locks');
+  skillsDir = path.join(baizeDir, '.claude', 'skills');
+  componentsFile = path.join(baizeDir, '.baize', 'components.json');
+  fs.mkdirSync(locksDir, { recursive: true });
+  fs.mkdirSync(skillsDir, { recursive: true });
+  process.env.HOME = homeDir;
+  process.env.BAIZE_DIR = baizeDir;
+});
+
+afterEach(() => {
+  delete process.env.HOME;
+  delete process.env.BAIZE_DIR;
+  fs.rmSync(homeDir, { recursive: true, force: true });
+});
+
+/**
+ * Minimal declarative component served from a local directory: resolves
+ * without network and installs without npm/hooks/services.
+ */
+function writeLocalComponent(srcRoot, name) {
+  const dir = path.join(srcRoot, name);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'SKILL.md'), `---\nname: ${name}\nversion: 1.0.0\n---\n# ${name}\n`, 'utf8');
+  return dir;
+}
+
+function writeInstalledComponent(name) {
+  const skillDir = path.join(skillsDir, name);
+  fs.mkdirSync(skillDir, { recursive: true });
+  fs.writeFileSync(path.join(skillDir, 'SKILL.md'), `---\nname: ${name}\nversion: 1.0.0\n---\n`, 'utf8');
+  fs.writeFileSync(componentsFile, JSON.stringify({
+    [name]: { version: '1.0.0', repo: null, skillDir, source: { type: 'local-dir', path: skillDir } },
+  }));
+}
+
+function readComponents() {
+  return JSON.parse(fs.readFileSync(componentsFile, 'utf8'));
+}
+
+/**
+ * Replace process.exit with a throw so control flow stops like a real exit
+ * (jest itself must not be terminated). Restore with mockRestore().
+ */
+function mockExit() {
+  return jest.spyOn(process, 'exit').mockImplementation((code) => {
+    throw new Error(`process.exit(${code})`);
+  });
+}
+
+describe('lock.js error copy', () => {
+  test('valid-lock error is operation-generic (add/upgrade/uninstall)', async () => {
+    const { acquireLock, releaseLock } = await import('../cli/lib/lock.js');
+
+    expect(acquireLock('genmsg').success).toBe(true);
+    const second = acquireLock('genmsg');
+    expect(second.success).toBe(false);
+    expect(second.error).toContain('is being operated on by PID');
+    expect(second.error).not.toContain('is being upgraded by');
+
+    expect(releaseLock('genmsg').success).toBe(true);
+  });
+});
+
+describe('baize add lock', () => {
+  test('rejects with a clear error when the component is already locked', async () => {
+    const { acquireLock, releaseLock } = await import('../cli/lib/lock.js');
+    const { addComponent } = await import('../cli/commands/add.js');
+    const srcDir = writeLocalComponent(path.join(homeDir, 'src'), 'lockedcomp');
+
+    // Pre-existing valid lock held by this (live) process
+    expect(acquireLock('lockedcomp').success).toBe(true);
+
+    const exitSpy = mockExit();
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    let output = '';
+    try {
+      await expect(addComponent([srcDir, '--yes'])).rejects.toThrow('process.exit(1)');
+      output = errorSpy.mock.calls.map((c) => String(c[0])).join('\n');
+    } finally {
+      exitSpy.mockRestore();
+      errorSpy.mockRestore();
+      logSpy.mockRestore();
+    }
+
+    expect(output).toContain('is being operated on by PID');
+    // Nothing was installed and the pre-existing lock is untouched
+    expect(fs.existsSync(path.join(skillsDir, 'lockedcomp'))).toBe(false);
+    expect(fs.existsSync(path.join(locksDir, 'lockedcomp.lock'))).toBe(true);
+
+    releaseLock('lockedcomp');
+  });
+
+  test('installs successfully after the lock is released, and releases it afterwards', async () => {
+    const { acquireLock, releaseLock } = await import('../cli/lib/lock.js');
+    const { addComponent } = await import('../cli/commands/add.js');
+    const srcDir = writeLocalComponent(path.join(homeDir, 'src'), 'goodcomp');
+
+    expect(acquireLock('goodcomp').success).toBe(true);
+    expect(releaseLock('goodcomp').success).toBe(true);
+
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    try {
+      await addComponent([srcDir, '--yes']);
+    } finally {
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+    }
+
+    // Installed and the lock was released by the finally block
+    expect(readComponents().goodcomp).toBeTruthy();
+    expect(fs.existsSync(path.join(skillsDir, 'goodcomp', 'SKILL.md'))).toBe(true);
+    expect(fs.existsSync(path.join(locksDir, 'goodcomp.lock'))).toBe(false);
+  });
+
+  test('--check preview mode never acquires the component lock', async () => {
+    const { acquireLock, releaseLock } = await import('../cli/lib/lock.js');
+    const { addComponent } = await import('../cli/commands/add.js');
+    const srcDir = writeLocalComponent(path.join(homeDir, 'src'), 'checkcomp');
+
+    // Even with a valid lock already held, --check must succeed: preview is read-only
+    expect(acquireLock('checkcomp').success).toBe(true);
+
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    const exitSpy = mockExit();
+    try {
+      const result = await addComponent([srcDir, '--check']);
+      expect(result).toBeUndefined(); // returned normally, no exit
+    } finally {
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+      exitSpy.mockRestore();
+    }
+
+    // Lock is still held by us: --check never acquired/released it
+    expect(fs.existsSync(path.join(locksDir, 'checkcomp.lock'))).toBe(true);
+    // And nothing was installed
+    expect(fs.existsSync(path.join(skillsDir, 'checkcomp'))).toBe(false);
+
+    releaseLock('checkcomp');
+  });
+});
+
+describe('baize uninstall lock', () => {
+  test('rejects with a clear error when the component is already locked', async () => {
+    const { acquireLock } = await import('../cli/lib/lock.js');
+    const { uninstallComponent } = await import('../cli/commands/component.js');
+    writeInstalledComponent('lockedun');
+
+    expect(acquireLock('lockedun').success).toBe(true);
+
+    const exitSpy = mockExit();
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    let output = '';
+    try {
+      await expect(uninstallComponent(['lockedun', '--yes'])).rejects.toThrow('process.exit(1)');
+      output = errorSpy.mock.calls.map((c) => String(c[0])).join('\n');
+    } finally {
+      exitSpy.mockRestore();
+      errorSpy.mockRestore();
+      logSpy.mockRestore();
+    }
+
+    expect(output).toContain('is being operated on by PID');
+    // Nothing was removed
+    expect(readComponents().lockedun).toBeTruthy();
+    expect(fs.existsSync(path.join(skillsDir, 'lockedun'))).toBe(true);
+  });
+
+  test('uninstalls successfully and releases the lock afterwards', async () => {
+    const { uninstallComponent } = await import('../cli/commands/component.js');
+    writeInstalledComponent('goodun');
+
+    const exitSpy = mockExit();
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    try {
+      const result = await uninstallComponent(['goodun', '--yes']);
+      expect(result).toBeUndefined();
+    } finally {
+      exitSpy.mockRestore();
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+    }
+
+    // Removed and the lock was released by the finally block
+    expect(readComponents().goodun).toBeUndefined();
+    expect(fs.existsSync(path.join(skillsDir, 'goodun'))).toBe(false);
+    expect(fs.existsSync(path.join(locksDir, 'goodun.lock'))).toBe(false);
+  });
+});

package/test/skill-catalog.test.js

@@ -0,0 +1,118 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, test } from '@jest/globals';
+import {
+  defaultSkillsDir,
+  listInstalledSkills,
+  parseSkillFrontmatter,
+} from '../skills/web-console/scripts/skill-catalog.js';
+
+let tempRoot;
+
+beforeEach(() => {
+  tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-catalog-test-'));
+});
+
+afterEach(() => {
+  if (tempRoot) fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+describe('parseSkillFrontmatter', () => {
+  test('extracts name and a plain single-line description', () => {
+    const parsed = parseSkillFrontmatter(
+      '---\nname: web-console\ndescription: Built-in web interface for Claude.\n---\n# Body\n'
+    );
+    expect(parsed).toEqual({ name: 'web-console', description: 'Built-in web interface for Claude.' });
+  });
+
+  test('folds a >- multi-line description into a single line', () => {
+    const parsed = parseSkillFrontmatter(
+      '---\nname: baize-memory\ndescription: >-\n  Core memory system. Maintains persistent memory\n  across sessions. Handles context-aware state.\n---\n'
+    );
+    expect(parsed).toEqual({
+      name: 'baize-memory',
+      description: 'Core memory system. Maintains persistent memory across sessions. Handles context-aware state.',
+    });
+  });
+
+  test('keeps newlines in a |- literal multi-line description', () => {
+    const parsed = parseSkillFrontmatter(
+      '---\nname: lit\ndescription: |-\n  Line one\n  Line two\n---\n'
+    );
+    expect(parsed).toEqual({ name: 'lit', description: 'Line one\nLine two' });
+  });
+
+  test('joins plain multi-line continuation description with spaces', () => {
+    const parsed = parseSkillFrontmatter(
+      '---\nname: multi\ndescription: First part\n  second part\n---\n'
+    );
+    expect(parsed).toEqual({ name: 'multi', description: 'First part second part' });
+  });
+
+  test('returns null when there is no frontmatter block', () => {
+    expect(parseSkillFrontmatter('# No frontmatter\ndescription: x\n')).toBeNull();
+    expect(parseSkillFrontmatter('')).toBeNull();
+  });
+
+  test('returns null when the name key is missing', () => {
+    expect(parseSkillFrontmatter('---\ndescription: only a description\n---\n')).toBeNull();
+  });
+
+  test('strips wrapping quotes and tolerates CRLF line endings', () => {
+    const parsed = parseSkillFrontmatter(
+      '---\r\nname: "quoted skill"\r\ndescription: \'single quoted\'\r\n---\r\n'
+    );
+    expect(parsed).toEqual({ name: 'quoted skill', description: 'single quoted' });
+  });
+
+  test('allows an empty description', () => {
+    const parsed = parseSkillFrontmatter('---\nname: bare\n---\n');
+    expect(parsed).toEqual({ name: 'bare', description: '' });
+  });
+});
+
+describe('listInstalledSkills', () => {
+  const writeSkill = (dir, name, description) => {
+    fs.mkdirSync(path.join(tempRoot, dir), { recursive: true });
+    fs.writeFileSync(
+      path.join(tempRoot, dir, 'SKILL.md'),
+      `---\nname: ${name}\ndescription: ${description}\n---\n`
+    );
+  };
+
+  test('lists each SKILL.md directory with its directory name as id', () => {
+    writeSkill('doccraft', 'Doc Craft', 'Craft documentation');
+    writeSkill('memory', 'Memory', '>-\n  Persistent memory\n  across sessions');
+    const skills = listInstalledSkills({ skillsDir: tempRoot });
+    expect(skills).toEqual([
+      { id: 'doccraft', name: 'Doc Craft', description: 'Craft documentation' },
+      { id: 'memory', name: 'Memory', description: 'Persistent memory across sessions' },
+    ]);
+  });
+
+  test('skips directories without SKILL.md and broken frontmatter', () => {
+    writeSkill('good', 'Good', 'fine');
+    fs.mkdirSync(path.join(tempRoot, 'no-skill-md'), { recursive: true });
+    fs.mkdirSync(path.join(tempRoot, 'broken'));
+    fs.writeFileSync(path.join(tempRoot, 'broken', 'SKILL.md'), '# no frontmatter\n');
+    fs.writeFileSync(path.join(tempRoot, 'plain-file'), 'not a directory');
+    const skills = listInstalledSkills({ skillsDir: tempRoot });
+    expect(skills).toEqual([{ id: 'good', name: 'Good', description: 'fine' }]);
+  });
+
+  test('returns [] when the skills directory does not exist', () => {
+    expect(listInstalledSkills({ skillsDir: path.join(tempRoot, 'nope') })).toEqual([]);
+  });
+
+  test('default skills dir follows BAIZE_DIR', () => {
+    const prev = process.env.BAIZE_DIR;
+    try {
+      process.env.BAIZE_DIR = tempRoot;
+      expect(defaultSkillsDir()).toBe(path.join(tempRoot, '.claude', 'skills'));
+    } finally {
+      if (prev === undefined) delete process.env.BAIZE_DIR;
+      else process.env.BAIZE_DIR = prev;
+    }
+  });
+});