@superdoc-dev/sdk 1.0.0-alpha.3 → 1.0.0-alpha.31

package/src/__tests__/skills.test.ts

@@ -1,166 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { SuperDocCliError } from '../runtime/errors';
-import { getSkill, installSkill, listSkills } from '../skills';
-
-describe('listSkills', () => {
-  test('returns an array of skill names', () => {
-    const skills = listSkills();
-    expect(Array.isArray(skills)).toBe(true);
-    expect(skills.length).toBeGreaterThan(0);
-  });
-
-  test('includes the editing-docx skill', () => {
-    const skills = listSkills();
-    expect(skills).toContain('editing-docx');
-  });
-
-  test('returns sorted results', () => {
-    const skills = listSkills();
-    const sorted = [...skills].sort();
-    expect(skills).toEqual(sorted);
-  });
-
-  test('does not include file extensions', () => {
-    const skills = listSkills();
-    for (const name of skills) {
-      expect(name).not.toContain('.md');
-    }
-  });
-});
-
-describe('getSkill', () => {
-  test('returns content for a valid skill name', () => {
-    const content = getSkill('editing-docx');
-    expect(typeof content).toBe('string');
-    expect(content.length).toBeGreaterThan(0);
-  });
-
-  test('throws INVALID_ARGUMENT for empty name', () => {
-    expect(() => getSkill('')).toThrow(SuperDocCliError);
-    try {
-      getSkill('');
-    } catch (error) {
-      expect((error as SuperDocCliError).code).toBe('INVALID_ARGUMENT');
-    }
-  });
-
-  test('throws INVALID_ARGUMENT for whitespace-only name', () => {
-    expect(() => getSkill('   ')).toThrow(SuperDocCliError);
-    try {
-      getSkill('   ');
-    } catch (error) {
-      expect((error as SuperDocCliError).code).toBe('INVALID_ARGUMENT');
-    }
-  });
-
-  test('throws INVALID_ARGUMENT for names with path traversal characters', () => {
-    const maliciousNames = ['../etc/passwd', './local', 'foo/bar', 'a b c', 'skill.md'];
-
-    for (const name of maliciousNames) {
-      expect(() => getSkill(name)).toThrow(SuperDocCliError);
-      try {
-        getSkill(name);
-      } catch (error) {
-        expect((error as SuperDocCliError).code).toBe('INVALID_ARGUMENT');
-      }
-    }
-  });
-
-  test('throws SKILL_NOT_FOUND for nonexistent skill', () => {
-    expect(() => getSkill('nonexistent-skill-name-xyz')).toThrow(SuperDocCliError);
-    try {
-      getSkill('nonexistent-skill-name-xyz');
-    } catch (error) {
-      const sdError = error as SuperDocCliError;
-      expect(sdError.code).toBe('SKILL_NOT_FOUND');
-      expect((sdError.details as { available: string[] }).available).toContain('editing-docx');
-    }
-  });
-
-  test('accepts valid skill names with hyphens and underscores', () => {
-    // These should not throw INVALID_ARGUMENT (they may throw SKILL_NOT_FOUND)
-    const validNames = ['a', 'my-skill', 'my_skill', 'Skill1', '1skill'];
-
-    for (const name of validNames) {
-      try {
-        getSkill(name);
-      } catch (error) {
-        // SKILL_NOT_FOUND is expected; INVALID_ARGUMENT means the regex is wrong
-        expect((error as SuperDocCliError).code).not.toBe('INVALID_ARGUMENT');
-      }
-    }
-  });
-});
-
-describe('installSkill', () => {
-  test('installs bundled skill to Claude project skills directory', async () => {
-    const workdir = await mkdtemp(path.join(tmpdir(), 'superdoc-sdk-skills-project-'));
-    try {
-      const result = installSkill('editing-docx', { cwd: workdir });
-      const expectedPath = path.join(workdir, '.claude', 'skills', 'editing-docx', 'SKILL.md');
-      const content = await readFile(expectedPath, 'utf8');
-
-      expect(result.path).toBe(expectedPath);
-      expect(result.scope).toBe('project');
-      expect(result.written).toBe(true);
-      expect(result.overwritten).toBe(false);
-      expect(content).toContain('superdoc open');
-    } finally {
-      await rm(workdir, { recursive: true, force: true });
-    }
-  });
-
-  test('installs bundled skill to Claude user skills directory', async () => {
-    const homeDir = await mkdtemp(path.join(tmpdir(), 'superdoc-sdk-skills-user-'));
-    try {
-      const result = installSkill('editing-docx', { scope: 'user', homeDir });
-      const expectedPath = path.join(homeDir, '.claude', 'skills', 'editing-docx', 'SKILL.md');
-      const content = await readFile(expectedPath, 'utf8');
-
-      expect(result.path).toBe(expectedPath);
-      expect(result.scope).toBe('user');
-      expect(result.written).toBe(true);
-      expect(result.overwritten).toBe(false);
-      expect(content).toContain('superdoc open');
-    } finally {
-      await rm(homeDir, { recursive: true, force: true });
-    }
-  });
-
-  test('returns without writing when overwrite is false and target exists', async () => {
-    const workdir = await mkdtemp(path.join(tmpdir(), 'superdoc-sdk-skills-no-overwrite-'));
-    const skillFile = path.join(workdir, '.claude', 'skills', 'editing-docx', 'SKILL.md');
-    try {
-      await mkdir(path.dirname(skillFile), { recursive: true });
-      await writeFile(skillFile, 'custom-content', 'utf8');
-      const result = installSkill('editing-docx', { cwd: workdir, overwrite: false });
-      const content = await readFile(skillFile, 'utf8');
-
-      expect(result.written).toBe(false);
-      expect(result.overwritten).toBe(false);
-      expect(content).toBe('custom-content');
-    } finally {
-      await rm(workdir, { recursive: true, force: true });
-    }
-  });
-
-  test('overwrites existing target by default', async () => {
-    const workdir = await mkdtemp(path.join(tmpdir(), 'superdoc-sdk-skills-overwrite-'));
-    const skillFile = path.join(workdir, '.claude', 'skills', 'editing-docx', 'SKILL.md');
-    try {
-      await mkdir(path.dirname(skillFile), { recursive: true });
-      await writeFile(skillFile, 'old-content', 'utf8');
-      const result = installSkill('editing-docx', { cwd: workdir });
-      const content = await readFile(skillFile, 'utf8');
-
-      expect(result.written).toBe(true);
-      expect(result.overwritten).toBe(true);
-      expect(content).toContain('superdoc open');
-    } finally {
-      await rm(workdir, { recursive: true, force: true });
-    }
-  });
-});

package/src/__tests__/tools.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { dispatchSuperDocTool, resolveToolOperation } from '../tools';
-import { SuperDocCliError } from '../runtime/errors';
-
-describe('tools dispatch constraints', () => {
-  test('intent tool name resolves to doc.find operation', async () => {
-    const operationId = await resolveToolOperation('find_content');
-    expect(operationId).toBe('doc.find');
-  });
-
-  test('enforces requiresOneOf for doc.find (type | query)', async () => {
-    const client = {
-      doc: {
-        find: async () => ({ ok: true }),
-      },
-    };
-
-    try {
-      await dispatchSuperDocTool(client, 'find_content', {});
-      throw new Error('Expected dispatch to fail.');
-    } catch (error) {
-      expect(error).toBeInstanceOf(SuperDocCliError);
-      const cliError = error as SuperDocCliError;
-      expect(cliError.code).toBe('INVALID_ARGUMENT');
-      expect(cliError.message).toContain('One of the following arguments is required');
-    }
-  });
-
-  test('enforces mutuallyExclusive constraints for doc.find query + flat flags', async () => {
-    let called = false;
-    const client = {
-      doc: {
-        find: async () => {
-          called = true;
-          return { ok: true };
-        },
-      },
-    };
-
-    try {
-      await dispatchSuperDocTool(client, 'find_content', {
-        query: { select: { type: 'text', pattern: 'Wilde' } },
-        type: 'text',
-      });
-      throw new Error('Expected dispatch to fail.');
-    } catch (error) {
-      expect(error).toBeInstanceOf(SuperDocCliError);
-      const cliError = error as SuperDocCliError;
-      expect(cliError.code).toBe('INVALID_ARGUMENT');
-      expect(cliError.message).toContain('mutually exclusive');
-      expect(called).toBe(false);
-    }
-  });
-
-  test('enforces requiredWhen for doc.find text selectors', async () => {
-    const client = {
-      doc: {
-        find: async () => ({ ok: true }),
-      },
-    };
-
-    try {
-      await dispatchSuperDocTool(client, 'find_content', {
-        type: 'text',
-      });
-      throw new Error('Expected dispatch to fail.');
-    } catch (error) {
-      expect(error).toBeInstanceOf(SuperDocCliError);
-      const cliError = error as SuperDocCliError;
-      expect(cliError.code).toBe('INVALID_ARGUMENT');
-      expect(cliError.message).toContain('required by constraints');
-    }
-  });
-
-  test('dispatches when constraints are satisfied', async () => {
-    const client = {
-      doc: {
-        find: async (args: Record<string, unknown>) => ({
-          ok: true,
-          query: args,
-        }),
-      },
-    };
-
-    const result = await dispatchSuperDocTool(client, 'find_content', {
-      query: {
-        select: { type: 'text', pattern: 'Wilde' },
-      },
-    });
-
-    expect(result).toMatchObject({
-      ok: true,
-    });
-  });
-});
-