agent-facets 0.2.2 → 0.3.3

package/src/__tests__/cli.test.ts

@@ -1,195 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { resolve } from 'node:path'
-
-const CLI_PATH = resolve(import.meta.dir, '../../dist/facet')
-const COMMAND_NAMES = ['add', 'build', 'create', 'edit', 'info', 'install', 'list', 'publish', 'remove', 'upgrade']
-const STUB_COMMAND_NAMES = ['add', 'info', 'install', 'list', 'publish', 'remove', 'upgrade']
-
-type ExecResult = {
-  stdout: string
-  stderr: string
-  exitCode: number
-}
-
-async function runCli(...args: string[]): Promise<ExecResult> {
-  const proc = Bun.spawn([CLI_PATH, ...args], {
-    stdout: 'pipe',
-    stderr: 'pipe',
-  })
-  const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()])
-  const exitCode = await proc.exited
-  return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode }
-}
-
-// --- Help ---
-
-describe('CLI — help', () => {
-  test('--help prints command list to stdout and exits 0', async () => {
-    const result = await runCli('--help')
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain('Usage: facet <command>')
-    for (const cmd of COMMAND_NAMES) {
-      expect(result.stdout).toContain(cmd)
-    }
-    expect(result.stderr).toBe('')
-  })
-
-  test('help command produces same output as --help', async () => {
-    const helpFlag = await runCli('--help')
-    const helpCommand = await runCli('help')
-    expect(helpCommand.exitCode).toBe(0)
-    expect(helpCommand.stdout).toBe(helpFlag.stdout)
-    expect(helpCommand.stderr).toBe('')
-  })
-})
-
-// --- Version ---
-
-describe('CLI — version', () => {
-  test('--version prints version matching package.json and exits 0', async () => {
-    const pkg = await Bun.file(resolve(import.meta.dir, '../../package.json')).json()
-    const result = await runCli('--version')
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toBe(pkg.version)
-    expect(result.stderr).toBe('')
-  })
-})
-
-// --- Bare invocation ---
-
-describe('CLI — bare invocation', () => {
-  test('no arguments prints help and exits 0', async () => {
-    const helpResult = await runCli('--help')
-    const bareResult = await runCli()
-    expect(bareResult.exitCode).toBe(0)
-    expect(bareResult.stdout).toBe(helpResult.stdout)
-    expect(bareResult.stderr).toBe('')
-  })
-})
-
-// --- Stub commands ---
-
-describe('CLI — stub commands', () => {
-  test.each(STUB_COMMAND_NAMES)('"%s" prints not yet implemented with command name and exits 0', async (cmd) => {
-    const result = await runCli(cmd)
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain(cmd)
-    expect(result.stdout).toContain('not yet implemented')
-    expect(result.stderr).toBe('')
-  })
-})
-
-// --- Edit command dispatch ---
-
-describe('CLI — edit command', () => {
-  test('edit with no manifest prints error and exits 1', async () => {
-    const result = await runCli('edit', import.meta.dir)
-    expect(result.exitCode).toBe(1)
-    expect(result.stderr).toContain('facet.json')
-  })
-})
-
-// --- Unknown commands ---
-
-describe('CLI — unknown commands', () => {
-  test('unknown command prints error to stderr and exits 1', async () => {
-    const result = await runCli('xyzzy')
-    expect(result.exitCode).toBe(1)
-    expect(result.stderr).toContain('Unknown command "xyzzy"')
-    expect(result.stdout).toBe('')
-  })
-
-  test('unknown command with close match includes "did you mean?" suggestion', async () => {
-    const result = await runCli('bild')
-    expect(result.exitCode).toBe(1)
-    expect(result.stderr).toContain('Unknown command "bild"')
-    expect(result.stderr).toContain('Did you mean "build"')
-    expect(result.stdout).toBe('')
-  })
-
-  test('unknown command with no close match does not include suggestion', async () => {
-    const result = await runCli('xyzzy')
-    expect(result.exitCode).toBe(1)
-    expect(result.stderr).toContain('Unknown command "xyzzy"')
-    expect(result.stderr).not.toContain('Did you mean')
-    expect(result.stdout).toBe('')
-  })
-})
-
-// --- Per-command help ---
-
-describe('CLI — per-command help', () => {
-  test('<command> --help prints command-specific help and exits 0', async () => {
-    const result = await runCli('build', '--help')
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain('facet build')
-    expect(result.stdout).toContain('Build a facet from the current directory')
-    expect(result.stderr).toBe('')
-  })
-})
-
-// --- Unexpected error ---
-
-describe('CLI — unexpected error', () => {
-  test('unexpected error is thrown by run', async () => {
-    const { run } = await import('../run.ts')
-
-    const crashRegistry = {
-      crash: {
-        name: 'crash',
-        description: 'Throws an error',
-        run: async (_args: string[], _flags: Record<string, unknown>) => {
-          throw new Error('boom')
-        },
-      },
-    }
-
-    await expect(run(['crash'], crashRegistry)).rejects.toThrow('boom')
-  })
-})
-
-// --- Per-command flags ---
-
-describe('CLI — per-command flags', () => {
-  test('create --help shows --force flag and usage', async () => {
-    const result = await runCli('create', '--help')
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain('[directory]')
-    expect(result.stdout).toContain('--force')
-    expect(result.stdout).toContain('Overwrite existing facet.json')
-  })
-
-  test('build --help shows directory usage', async () => {
-    const result = await runCli('build', '--help')
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain('[directory]')
-  })
-
-  test('edit --help shows directory usage', async () => {
-    const result = await runCli('edit', '--help')
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain('[directory]')
-  })
-})
-
-// --- Directory validation ---
-
-describe('CLI — directory validation', () => {
-  test('build with non-existent directory errors', async () => {
-    const result = await runCli('build', `/tmp/does-not-exist-${Date.now()}`)
-    expect(result.exitCode).toBe(1)
-    expect(result.stderr).toContain('does not exist')
-  })
-
-  test('edit with non-existent directory errors', async () => {
-    const result = await runCli('edit', `/tmp/does-not-exist-${Date.now()}`)
-    expect(result.exitCode).toBe(1)
-    expect(result.stderr).toContain('does not exist')
-  })
-
-  test('build with file instead of directory errors', async () => {
-    const result = await runCli('build', import.meta.path)
-    expect(result.exitCode).toBe(1)
-    expect(result.stderr).toContain('Expected a directory')
-  })
-})

package/src/__tests__/create-build.test.ts

@@ -1,227 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join, resolve } from 'node:path'
-import { writeScaffold } from '../commands/create/index.ts'
-import { DEFAULT_VERSION } from '../commands/create-scaffold.ts'
-
-let testDir: string
-
-beforeAll(async () => {
-  testDir = await mkdtemp(join(tmpdir(), 'cli-create-build-test-'))
-})
-
-afterAll(async () => {
-  await rm(testDir, { recursive: true, force: true })
-})
-
-async function createFixtureDir(name: string): Promise<string> {
-  const dir = join(testDir, name)
-  await Bun.write(join(dir, '.keep'), '')
-  return dir
-}
-
-const CLI_PATH = resolve(import.meta.dir, '../../dist/facet')
-
-async function runCli(...args: string[]) {
-  const proc = Bun.spawn([CLI_PATH, ...args], {
-    stdout: 'pipe',
-    stderr: 'pipe',
-    env: { ...process.env, NO_COLOR: '1' },
-  })
-  const stdout = await new Response(proc.stdout).text()
-  const stderr = await new Response(proc.stderr).text()
-  const exitCode = await proc.exited
-
-  // Don't let build errors flood test output — capture but don't dump
-  if (exitCode !== 0 && stderr.trim()) {
-    const lines = stderr.trim().split('\n')
-    const summary =
-      lines.length > 3 ? [...lines.slice(0, 3), `... (${lines.length - 3} more lines)`].join('\n') : stderr.trim()
-    return { stdout: stdout.trim(), stderr: summary, exitCode }
-  }
-
-  return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode }
-}
-
-// --- Scaffold generation (unit) ---
-
-describe('writeScaffold', () => {
-  test('scaffolds with named assets across all types', async () => {
-    const dir = await createFixtureDir('scaffold-all')
-    const files = await writeScaffold(
-      {
-        name: 'my-facet',
-        version: DEFAULT_VERSION,
-        description: 'A test facet',
-        skills: ['code-review', 'testing-guide'],
-        agents: ['reviewer'],
-        commands: ['deploy'],
-      },
-      dir,
-    )
-
-    expect(files).toContain('facet.json')
-    expect(files).toContain('skills/code-review/SKILL.md')
-    expect(files).toContain('skills/testing-guide/SKILL.md')
-    expect(files).toContain('agents/reviewer.md')
-    expect(files).toContain('commands/deploy.md')
-
-    // Verify manifest content (JSON)
-    const manifestText = await Bun.file(join(dir, 'facet.json')).text()
-    const manifest = JSON.parse(manifestText)
-    expect(manifest.name).toBe('my-facet')
-    expect(manifest.version).toBe(DEFAULT_VERSION)
-    expect(manifest.description).toBe('A test facet')
-    expect(manifest.skills).toBeDefined()
-    expect(manifest.skills['code-review']).toBeDefined()
-    expect(manifest.skills['testing-guide']).toBeDefined()
-    expect(manifest.agents).toBeDefined()
-    expect(manifest.agents.reviewer).toBeDefined()
-    expect(manifest.commands).toBeDefined()
-    expect(manifest.commands.deploy).toBeDefined()
-
-    // Verify starter files exist and have named template content
-    const skill = await Bun.file(join(dir, 'skills/code-review/SKILL.md')).text()
-    expect(skill).toContain('# Code Review')
-
-    const skill2 = await Bun.file(join(dir, 'skills/testing-guide/SKILL.md')).text()
-    expect(skill2).toContain('# Testing Guide')
-
-    const agent = await Bun.file(join(dir, 'agents/reviewer.md')).text()
-    expect(agent).toContain('# Reviewer')
-
-    const command = await Bun.file(join(dir, 'commands/deploy.md')).text()
-    expect(command).toContain('# Deploy')
-  })
-
-  test('scaffolds with only one skill', async () => {
-    const dir = await createFixtureDir('scaffold-skills-only')
-    const files = await writeScaffold(
-      {
-        name: 'minimal',
-        version: DEFAULT_VERSION,
-        description: '',
-        skills: ['minimal'],
-        agents: [],
-        commands: [],
-      },
-      dir,
-    )
-
-    expect(files).toContain('facet.json')
-    expect(files).toContain('skills/minimal/SKILL.md')
-    expect(files).not.toContain('agents/')
-    expect(files).not.toContain('commands/')
-
-    const manifestText = await Bun.file(join(dir, 'facet.json')).text()
-    const manifest = JSON.parse(manifestText)
-    expect(manifest.skills).toBeDefined()
-    expect(manifest.agents).toBeUndefined()
-    expect(manifest.commands).toBeUndefined()
-  })
-
-  test('version defaults to DEFAULT_VERSION (0.0.0)', async () => {
-    const dir = await createFixtureDir('scaffold-default-version')
-    await writeScaffold(
-      {
-        name: 'default-ver',
-        version: DEFAULT_VERSION,
-        description: 'Testing default version',
-        skills: ['example'],
-        agents: [],
-        commands: [],
-      },
-      dir,
-    )
-
-    const manifestText = await Bun.file(join(dir, 'facet.json')).text()
-    const manifest = JSON.parse(manifestText)
-    expect(manifest.version).toBe('0.0.0')
-  })
-
-  test('scaffolded project passes build', async () => {
-    const dir = await createFixtureDir('scaffold-buildable')
-    await writeScaffold(
-      {
-        name: 'buildable',
-        version: DEFAULT_VERSION,
-        description: 'A buildable facet',
-        skills: ['helper'],
-        agents: ['assistant'],
-        commands: [],
-      },
-      dir,
-    )
-
-    // Run facet build against the scaffolded project
-    const result = await runCli('build', dir)
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain('Built buildable')
-
-    // Verify dist/ output exists — archive + build manifest
-    const distArchive = await Bun.file(join(dir, `dist/buildable-${DEFAULT_VERSION}.facet`)).exists()
-    expect(distArchive).toBe(true)
-
-    const distManifest = await Bun.file(join(dir, 'dist/build-manifest.json')).exists()
-    expect(distManifest).toBe(true)
-
-    // No loose files
-    const looseManifest = await Bun.file(join(dir, 'dist/facet.json')).exists()
-    expect(looseManifest).toBe(false)
-  })
-})
-
-// --- Build command (e2e) ---
-
-describe('facet build', () => {
-  test('build succeeds on valid project', async () => {
-    const dir = await createFixtureDir('build-valid')
-    await Bun.write(join(dir, 'skills/review/SKILL.md'), '# Review skill content')
-    await Bun.write(
-      join(dir, 'facet.json'),
-      JSON.stringify({
-        name: 'test-facet',
-        version: '1.0.0',
-        skills: {
-          review: {
-            description: 'Code review skill',
-          },
-        },
-      }),
-    )
-
-    const result = await runCli('build', dir)
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain('Built test-facet')
-    expect(result.stdout).toContain('sha256:')
-  })
-
-  test('build fails on missing manifest', async () => {
-    const dir = await createFixtureDir('build-no-manifest')
-
-    const result = await runCli('build', dir)
-    expect(result.exitCode).toBe(1)
-    expect(result.stderr).toContain('facet.json')
-  })
-
-  test('build fails on missing asset file', async () => {
-    const dir = await createFixtureDir('build-missing-file')
-    await Bun.write(
-      join(dir, 'facet.json'),
-      JSON.stringify({
-        name: 'test-facet',
-        version: '1.0.0',
-        skills: {
-          review: {
-            description: 'Code review skill',
-          },
-        },
-      }),
-    )
-
-    const result = await runCli('build', dir)
-    expect(result.exitCode).toBe(1)
-    expect(result.stdout).toContain('Build failed')
-  })
-})

package/src/__tests__/edit-integration.test.ts

@@ -1,171 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { mkdir } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { runBuildPipeline } from '@agent-facets/core'
-import dedent from 'dedent'
-import { applyOperations, buildEditContext } from '../commands/edit/index.ts'
-import type { EditOperation } from '../tui/views/edit/edit-types.ts'
-
-async function createFixtureDir(name: string): Promise<string> {
-  const dir = join(tmpdir(), `facets-edit-integ-${name}-${Date.now()}`)
-  await mkdir(dir, { recursive: true })
-  return dir
-}
-
-async function writeManifest(dir: string, manifest: Record<string, unknown>): Promise<void> {
-  await Bun.write(join(dir, 'facet.json'), JSON.stringify(manifest, null, 2))
-}
-
-describe('edit integration', () => {
-  test('buildEditContext detects new files on disk not in manifest', async () => {
-    const dir = await createFixtureDir('detect-additions')
-    await writeManifest(dir, {
-      name: 'test',
-      version: '1.0.0',
-      skills: { existing: { description: 'Existing skill' } },
-    })
-    await mkdir(join(dir, 'skills/existing'), { recursive: true })
-    await Bun.write(join(dir, 'skills/existing/SKILL.md'), '# Existing')
-    // Add a file not in manifest
-    await mkdir(join(dir, 'skills/new-one'), { recursive: true })
-    await Bun.write(join(dir, 'skills/new-one/SKILL.md'), '# New')
-
-    const result = await buildEditContext(dir)
-    expect(result.ok).toBe(true)
-    if (!result.ok) return
-
-    const additions = result.context.reconciliationItems.filter((i) => i.kind === 'addition')
-    expect(additions).toHaveLength(1)
-    expect(additions[0]?.name).toBe('new-one')
-  })
-
-  test('buildEditContext detects missing files in manifest', async () => {
-    const dir = await createFixtureDir('detect-missing')
-    await writeManifest(dir, {
-      name: 'test',
-      version: '1.0.0',
-      skills: {
-        present: { description: 'Present' },
-        gone: { description: 'Gone' },
-      },
-    })
-    await mkdir(join(dir, 'skills/present'), { recursive: true })
-    await Bun.write(join(dir, 'skills/present/SKILL.md'), '# Present')
-    // 'gone' has no file on disk
-
-    const result = await buildEditContext(dir)
-    expect(result.ok).toBe(true)
-    if (!result.ok) return
-
-    const missing = result.context.reconciliationItems.filter((i) => i.kind === 'missing')
-    expect(missing).toHaveLength(1)
-    expect(missing[0]?.name).toBe('gone')
-  })
-
-  test('buildEditContext detects front matter in matched files', async () => {
-    const dir = await createFixtureDir('detect-frontmatter')
-    await writeManifest(dir, {
-      name: 'test',
-      version: '1.0.0',
-      skills: { review: { description: 'Review' } },
-    })
-    await mkdir(join(dir, 'skills/review'), { recursive: true })
-    await Bun.write(
-      join(dir, 'skills/review/SKILL.md'),
-      dedent`
-        ---
-        name: Review
-        ---
-        # Review skill
-      `,
-    )
-
-    const result = await buildEditContext(dir)
-    expect(result.ok).toBe(true)
-    if (!result.ok) return
-
-    const fm = result.context.reconciliationItems.filter((i) => i.kind === 'front-matter')
-    expect(fm).toHaveLength(1)
-    expect(fm[0]?.name).toBe('review')
-  })
-
-  test('applyOperations scaffolds new skill files', async () => {
-    const dir = await createFixtureDir('scaffold-skill')
-    const manifest = {
-      name: 'test',
-      version: '1.0.0',
-      skills: { helper: { description: 'A helper skill' } },
-    }
-    const operations: EditOperation[] = [{ op: 'write-manifest' }, { op: 'scaffold', type: 'skills', name: 'helper' }]
-
-    await applyOperations(manifest, operations, dir)
-
-    const manifestExists = await Bun.file(join(dir, 'facet.json')).exists()
-    expect(manifestExists).toBe(true)
-
-    const skillExists = await Bun.file(join(dir, 'skills/helper/SKILL.md')).exists()
-    expect(skillExists).toBe(true)
-  })
-
-  test('applyOperations strips front matter from files', async () => {
-    const dir = await createFixtureDir('strip-fm')
-    await mkdir(join(dir, 'skills/review'), { recursive: true })
-    await Bun.write(
-      join(dir, 'skills/review/SKILL.md'),
-      dedent`
-        ---
-        name: Review
-        description: A review skill
-        ---
-        # Review
-        Review all code.
-      `,
-    )
-
-    const manifest = {
-      name: 'test',
-      version: '1.0.0',
-      skills: { review: { description: 'A review skill' } },
-    }
-    const operations: EditOperation[] = [
-      { op: 'write-manifest' },
-      { op: 'strip-front-matter', type: 'skills', name: 'review', path: 'skills/review/SKILL.md' },
-    ]
-
-    await applyOperations(manifest, operations, dir)
-
-    const content = await Bun.file(join(dir, 'skills/review/SKILL.md')).text()
-    expect(content).not.toContain('---')
-    expect(content).toContain('# Review')
-  })
-
-  test('applyOperations deletes removed asset files', async () => {
-    const dir = await createFixtureDir('delete-asset')
-    await mkdir(join(dir, 'skills/old'), { recursive: true })
-    await Bun.write(join(dir, 'skills/old/SKILL.md'), '# Old skill')
-
-    const manifest = { name: 'test', version: '1.0.0', skills: { remaining: { description: 'Remaining' } } }
-    const operations: EditOperation[] = [{ op: 'write-manifest' }, { op: 'delete-file', type: 'skills', name: 'old' }]
-
-    await applyOperations(manifest, operations, dir)
-
-    const deleted = await Bun.file(join(dir, 'skills/old/SKILL.md')).exists()
-    expect(deleted).toBe(false)
-  })
-
-  test('scaffold then build succeeds end-to-end', async () => {
-    const dir = await createFixtureDir('scaffold-then-build')
-    const manifest = {
-      name: 'test-facet',
-      version: '1.0.0',
-      skills: { example: { description: 'An example skill' } },
-    }
-    const operations: EditOperation[] = [{ op: 'write-manifest' }, { op: 'scaffold', type: 'skills', name: 'example' }]
-
-    await applyOperations(manifest, operations, dir)
-
-    const buildResult = await runBuildPipeline(dir)
-    expect(buildResult.ok).toBe(true)
-  })
-})

package/src/__tests__/resolve-dir.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { mkdir } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { resolveTargetDir } from '../commands/resolve-dir.ts'
-
-async function createFixtureDir(name: string): Promise<string> {
-  const dir = join(tmpdir(), `facets-resolve-test-${name}-${Date.now()}`)
-  await mkdir(dir, { recursive: true })
-
-  return dir
-}
-
-describe('resolveTargetDir', () => {
-  test('no arg defaults to cwd', async () => {
-    const result = await resolveTargetDir(undefined, { mustExist: true })
-    expect(result.ok).toBe(true)
-    if (!result.ok) return
-
-    expect(result.dir).toBe(process.cwd())
-    expect(result.display).toBe('.')
-  })
-
-  test('facet.json path uses parent directory', async () => {
-    const dir = await createFixtureDir('facet-json')
-    await Bun.write(join(dir, 'facet.json'), '{}')
-
-    const result = await resolveTargetDir(join(dir, 'facet.json'), { mustExist: true })
-    expect(result.ok).toBe(true)
-    if (!result.ok) return
-
-    expect(result.dir).toBe(dir)
-  })
-
-  test('non-directory file returns error', async () => {
-    const dir = await createFixtureDir('non-dir')
-    const filePath = join(dir, 'not-a-dir.txt')
-    await Bun.write(filePath, 'hello')
-
-    const result = await resolveTargetDir(filePath, { mustExist: true })
-    expect(result.ok).toBe(false)
-    if (result.ok) return
-
-    expect(result.message).toContain('Expected a directory')
-  })
-
-  test('non-existent dir with mustExist true returns error', async () => {
-    const result = await resolveTargetDir(`/tmp/does-not-exist-${Date.now()}`, { mustExist: true })
-    expect(result.ok).toBe(false)
-    if (result.ok) return
-
-    expect(result.message).toContain('does not exist')
-  })
-
-  test('non-existent dir with mustExist false auto-creates it', async () => {
-    const dir = join(tmpdir(), `facets-resolve-autocreate-${Date.now()}`)
-
-    const result = await resolveTargetDir(dir, { mustExist: false })
-    expect(result.ok).toBe(true)
-    if (!result.ok) return
-
-    const { stat } = await import('node:fs/promises')
-    const dirStat = await stat(result.dir)
-    expect(dirStat.isDirectory()).toBe(true)
-  })
-
-  test('valid existing directory passes', async () => {
-    const dir = await createFixtureDir('valid-dir')
-
-    const result = await resolveTargetDir(dir, { mustExist: true })
-    expect(result.ok).toBe(true)
-    if (!result.ok) return
-
-    expect(result.dir).toBe(dir)
-    expect(result.display).toBe(dir)
-  })
-
-  test('facetMustExist true without facet.json returns error', async () => {
-    const dir = await createFixtureDir('no-manifest')
-
-    const result = await resolveTargetDir(dir, { mustExist: true, facetMustExist: true })
-    expect(result.ok).toBe(false)
-    if (result.ok) return
-
-    expect(result.message).toContain('facet.json')
-  })
-
-  test('facetMustExist true with facet.json passes', async () => {
-    const dir = await createFixtureDir('has-manifest')
-    await Bun.write(join(dir, 'facet.json'), '{}')
-
-    const result = await resolveTargetDir(dir, { mustExist: true, facetMustExist: true })
-    expect(result.ok).toBe(true)
-  })
-})